chore: some minor fix for mini-swe-agent

Signed-off-by: Chojan Shang <chojan.shang@vesoft.com>

Author: Chojan Shang

docs/mini-swe-agent.md

@@ -1,18 +1,18 @@
 # Mini SWE Agent bridge
 
-This example wraps mini-swe-agent behind ACP so Zed can run it as an external agent over stdio. It also includes a local Textual UI client connected via a duet launcher.
+> Just a show of the bridge in action. Not a best-effort or absolutely-correct implementation of the agent.
+
+This example wraps mini-swe-agent behind ACP so Zed can run it as an external agent over stdio. It also includes a local Textual UI client connected via a duet launcher
 
 ## Behavior
 
-- Prompts: text blocks are concatenated into a single task string; referenced resources (`resource_link` / `resource`) are surfaced as hints in the task.
-- Streaming: incremental text is sent via `session/update` with `agent_message_chunk`.
+- Prompts: text blocks are concatenated into a single task string. (Resource embedding is not used in this example.)
+- Streaming: only LM output is streamed via `session/update` → `agent_message_chunk`.
 - Tool calls: when the agent executes a shell command, the bridge sends:
   - `tool_call` with `kind=execute`, pending status, and a bash code block containing the command
   - `tool_call_update` upon completion, including output and a `rawOutput` object with `output` and `returncode`
 - Final result: on task submission (mini-swe-agent prints `COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT` as the first line), a final `agent_message_chunk` with the submission content is sent.
 
-Non-terminating events (e.g. user rejection or timeouts) are surfaced both as a `tool_call_update` with `status=cancelled|failed` and as a text chunk so the session can continue.
-
 ## Configuration
 
 Environment variables control the model:
@@ -27,7 +27,7 @@ If `mini-swe-agent` is not installed in the venv, the bridge attempts to import
 
 ## How to run
 
-- In Zed (editor integration): configure an agent server to launch `examples/mini_swe_agent/agent.py` and set the environment variables there.
+- In Zed (editor integration): configure an agent server to launch `examples/mini_swe_agent/agent.py` and set the environment variables there. Use Zed’s “Open ACP Logs” to inspect `tool_call`/`tool_call_update` and message chunks.
 - In terminal (local TUI): run the duet launcher to start both the agent and the Textual client with the same environment and dedicated pipes:
 
 ```bash
@@ -36,6 +36,12 @@ python examples/mini_swe_agent/duet.py
 
 The launcher loads `.env` from the repo root (using python-dotenv) so both processes share the same configuration.
 
+### TUI usage
+
+- Hotkeys: `y` → YOLO, `c` → Confirm, `u` → Human, `Enter` → Continue.
+- In Human mode, you’ll be prompted for a bash command; it will be executed and streamed back as a tool call.
+- Each executed command appears in the “TOOL CALLS” section with live status and output.
+
 ## Files
 
 - Agent entry: [`examples/mini_swe_agent/agent.py`](https://github.com/psiace/agent-client-protocol-python/blob/main/examples/mini_swe_agent/agent.py)

examples/mini_swe_agent/README.md

@@ -1,5 +1,7 @@
 # Mini SWE Agent (Python) — ACP Bridge
 
+> Just a show of the bridge in action. Not a best-effort or absolutely-correct implementation of the agent.
+
 A minimal Agent Client Protocol (ACP) bridge that wraps mini-swe-agent so it can be run by Zed as an external agent over stdio, and also provides a local Textual UI client.
 
 ## Configure in Zed (recommended for editor integration)

examples/mini_swe_agent/agent.py

@@ -20,6 +20,8 @@
     PromptRequest,
     PromptResponse,
     SessionNotification,
+    SetSessionModeRequest,
+    SetSessionModeResponse,
     stdio_streams,
     PROTOCOL_VERSION,
 )
@@ -138,15 +140,51 @@ def _send_cost_hint(self) -> None:
                 except RuntimeError:
                     self._schedule(self._send(hint))
 
+            async def on_tool_start(self, title: str, command: str, tool_call_id: str) -> None:
+                """Send a tool_call start notification for a bash command."""
+                update = SessionUpdate4(
+                    sessionUpdate="tool_call",
+                    toolCallId=tool_call_id,
+                    title=title,
+                    kind="execute",
+                    status="pending",
+                    content=[
+                        ToolCallContent1(
+                            type="content", content=ContentBlock1(type="text", text=f"```bash\n{command}\n```")
+                        )
+                    ],
+                    rawInput={"command": command},
+                )
+                await self._send(update)
+
+            async def on_tool_complete(
+                self,
+                tool_call_id: str,
+                output: str,
+                returncode: int,
+                *,
+                status: str = "completed",
+            ) -> None:
+                """Send a tool_call_update with the final output and return code."""
+                update = SessionUpdate5(
+                    sessionUpdate="tool_call_update",
+                    toolCallId=tool_call_id,
+                    status=status,
+                    content=[
+                        ToolCallContent1(
+                            type="content", content=ContentBlock1(type="text", text=f"```ansi\n{output}\n```")
+                        )
+                    ],
+                    rawOutput={"output": output, "returncode": returncode},
+                )
+                await self._send(update)
+
             def add_message(self, role: str, content: str, **kwargs):
                 super().add_message(role, content, **kwargs)
-                # Only the client should send user_message_chunk. The agent reports its own text via agent_message_chunk.
-                if not getattr(self, "_emit_updates", True):
+                # Only stream LM output as agent_message_chunk; tool output is handled via tool_call_update.
+                if not getattr(self, "_emit_updates", True) or role != "assistant":
                     return
-                # Avoid duplicating tool outputs as a separate "Observation" agent message; rely on tool_call_update
                 text = str(content)
-                if role == "user" and text.strip().startswith("Observation:"):
-                    return
                 block = ContentBlock1(type="text", text=text)
                 update = SessionUpdate2(sessionUpdate="agent_message_chunk", content=block)
                 try:
@@ -324,6 +362,15 @@ async def loadSession(self, params) -> None:  # type: ignore[override]
     async def authenticate(self, _params: AuthenticateRequest) -> None:
         return None
 
+    async def setSessionMode(self, params: SetSessionModeRequest) -> SetSessionModeResponse | None:  # type: ignore[override]
+        sess = self._sessions.get(params.sessionId)
+        if not sess:
+            return SetSessionModeResponse()
+        mode = params.modeId.lower()
+        if mode in ("confirm", "yolo", "human"):
+            sess["config"].mode = mode  # type: ignore[attr-defined]
+        return SetSessionModeResponse()
+
     def _extract_mode_from_blocks(self, blocks) -> Literal["confirm", "yolo", "human"] | None:
         for b in blocks:
             if getattr(b, "type", None) == "text":