virtuai-cli 0.8.7__tar.gz → 0.8.9__tar.gz

{virtuai_cli-0.8.7 → virtuai_cli-0.8.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: virtuai-cli
-Version: 0.8.7
+Version: 0.8.9
 Summary: Run VirtuAI deep agents on your local machine
 Author-email: uCloudStore <lmoreno@ucloudstore.com>
 License: Proprietary
@@ -20,6 +20,8 @@ Requires-Dist: keyring>=25.0
 Requires-Dist: typer>=0.12
 Requires-Dist: rich>=13.0
 Requires-Dist: textual>=0.86
+Provides-Extra: local
+Requires-Dist: langchain-ollama>=0.2; extra == "local"
 
 # VirtuAI CLI
 
@@ -37,6 +39,12 @@ Or with [pipx](https://pipx.pypa.io/) (recommended for CLI tools — handles PAT
 pipx install virtuai-cli
 ```
 
+For **local model inference** (running agents against [Ollama](https://ollama.com) on your machine — see below), install the `local` extra:
+
+```bash
+pip install 'virtuai-cli[local]'      # or: pipx install 'virtuai-cli[local]'
+```
+
 Requires Python 3.11+.
 
 ## Quick start
@@ -71,6 +79,28 @@ virtuai ask --json "find any bugs" > events.jsonl
 
 `ask` is non-interactive: it prints the response to stdout, then exits.
 
+## Local model inference (Ollama)
+
+Agents can run inference on **your own machine** via [Ollama](https://ollama.com) instead of a cloud provider — useful for cost, data locality, or running open models. Only the model turns are proxied to your machine over the CLI's WebSocket; the agent loop, tools, knowledge bases, and chat history stay on the server.
+
+To use it:
+
+1. Install the CLI with the local extra (pulls `langchain-ollama`):
+   ```bash
+   pip install 'virtuai-cli[local]'
+   ```
+2. Install [Ollama](https://ollama.com), start it, and pull a **tool-capable** model:
+   ```bash
+   ollama serve
+   ollama pull qwen3:8b          # instruct/agentic models work best for tool calling
+   ```
+3. In the VirtuAI portal, set the agent's **Provider** to **Local (Ollama)**, enter the model tag you pulled, and pick a **cloud fallback** model.
+4. Connect the CLI (`virtuai chat`, `virtuai ask`, or `virtuai run`) — model turns are now answered by your local Ollama.
+
+The CLI talks to Ollama at `http://localhost:11434` by default; override with the `OLLAMA_BASE_URL` environment variable.
+
+If the CLI isn't connected, Ollama isn't running, or the model isn't pulled, the agent **falls back to its configured cloud model** and shows a notice. For reliable tool use, prefer instruct/agentic models (e.g. `qwen3:*`, `qwen2.5:*`); some code-tuned or non-instruct models emit tool calls as plain text and won't drive the agent's tools.
+
 ## Commands
 
 | Command | Description |

{virtuai_cli-0.8.7 → virtuai_cli-0.8.9}/README.md

@@ -14,6 +14,12 @@ Or with [pipx](https://pipx.pypa.io/) (recommended for CLI tools — handles PAT
 pipx install virtuai-cli
 ```
 
+For **local model inference** (running agents against [Ollama](https://ollama.com) on your machine — see below), install the `local` extra:
+
+```bash
+pip install 'virtuai-cli[local]'      # or: pipx install 'virtuai-cli[local]'
+```
+
 Requires Python 3.11+.
 
 ## Quick start
@@ -48,6 +54,28 @@ virtuai ask --json "find any bugs" > events.jsonl
 
 `ask` is non-interactive: it prints the response to stdout, then exits.
 
+## Local model inference (Ollama)
+
+Agents can run inference on **your own machine** via [Ollama](https://ollama.com) instead of a cloud provider — useful for cost, data locality, or running open models. Only the model turns are proxied to your machine over the CLI's WebSocket; the agent loop, tools, knowledge bases, and chat history stay on the server.
+
+To use it:
+
+1. Install the CLI with the local extra (pulls `langchain-ollama`):
+   ```bash
+   pip install 'virtuai-cli[local]'
+   ```
+2. Install [Ollama](https://ollama.com), start it, and pull a **tool-capable** model:
+   ```bash
+   ollama serve
+   ollama pull qwen3:8b          # instruct/agentic models work best for tool calling
+   ```
+3. In the VirtuAI portal, set the agent's **Provider** to **Local (Ollama)**, enter the model tag you pulled, and pick a **cloud fallback** model.
+4. Connect the CLI (`virtuai chat`, `virtuai ask`, or `virtuai run`) — model turns are now answered by your local Ollama.
+
+The CLI talks to Ollama at `http://localhost:11434` by default; override with the `OLLAMA_BASE_URL` environment variable.
+
+If the CLI isn't connected, Ollama isn't running, or the model isn't pulled, the agent **falls back to its configured cloud model** and shows a notice. For reliable tool use, prefer instruct/agentic models (e.g. `qwen3:*`, `qwen2.5:*`); some code-tuned or non-instruct models emit tool calls as plain text and won't drive the agent's tools.
+
 ## Commands
 
 | Command | Description |

{virtuai_cli-0.8.7 → virtuai_cli-0.8.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "virtuai-cli"
-version = "0.8.7"
+version = "0.8.9"
 description = "Run VirtuAI deep agents on your local machine"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -30,6 +30,14 @@ dependencies = [
     "textual>=0.86",
 ]
 
+# Optional: local model inference. Pulls langchain-ollama (+ langchain-core) so
+# the CLI can answer the server's model_generate frames from a locally-running
+# Ollama. Install with: pip install 'virtuai-cli[local]'
+[project.optional-dependencies]
+local = [
+    "langchain-ollama>=0.2",
+]
+
 [project.urls]
 Homepage = "https://imvituai.com"
 

{virtuai_cli-0.8.7 → virtuai_cli-0.8.9}/src/virtuai_cli/chat/ask.py

@@ -101,6 +101,8 @@ async def _run_ask(
     final_session = session_id
     final_text_parts: list[str] = []
     exit_code = 0
+    total_input_tokens = 0
+    total_output_tokens = 0
 
     try:
         async for event in stream_chat(
@@ -134,17 +136,26 @@ async def _run_ask(
                     err.print(f"[dim]✓ {first[0][:80] if first else ''}[/dim]")
                 else:
                     err.print("[dim]✓ done[/dim]")
+            elif etype == "notice" and mode == "stream":
+                msg = event.get("message", "")
+                color = {"warn": "yellow", "error": "red"}.get(event.get("level"), "dim")
+                err.print(f"[{color}]⚠ {msg}[/{color}]")
             elif etype == "error":
                 msg = event.get("error") or event.get("message") or "unknown"
                 err.print(f"[red]error: {msg}[/red]")
                 exit_code = 1
                 break
             elif etype in ("done", "complete"):
+                if etype == "complete":
+                    total_input_tokens += event.get("input_tokens") or 0
+                    total_output_tokens += event.get("output_tokens") or 0
                 break
 
         if mode == "stream":
             sys.stdout.write("\n")
             sys.stdout.flush()
+            if total_input_tokens or total_output_tokens:
+                err.print(f"[dim]↑{total_input_tokens} ↓{total_output_tokens} tokens[/dim]")
         elif mode == "quiet":
             sys.stdout.write("".join(final_text_parts))
             if final_text_parts and not final_text_parts[-1].endswith("\n"):
@@ -176,9 +187,9 @@ def run_ask_command(
 ) -> None:
     """Entry point invoked by `virtuai ask` in main.py."""
     server_url = (server or cfg.get_server_url()).rstrip("/")
-    token = cfg.load_token(cfg._KEYRING_CLI_TOKEN_KEY)
+    token = cfg.load_token(cfg._KEYRING_USER_TOKEN_KEY)
     if not token:
-        err.print("[red]Not paired.[/red] Run [bold]virtuai pair <code>[/bold] first.")
+        err.print("[red]Not logged in.[/red] Run [bold]virtuai login[/bold] first.")
         raise typer.Exit(1)
 
     # Compose message from arg + stdin (if piped)

{virtuai_cli-0.8.7 → virtuai_cli-0.8.9}/src/virtuai_cli/chat/command.py

@@ -69,9 +69,9 @@ def run_chat(
 ) -> None:
     """Launch the chat TUI. Called by the `chat` command in main.py."""
     server_url = (server or cfg.get_server_url()).rstrip("/")
-    token = cfg.load_token(cfg._KEYRING_CLI_TOKEN_KEY)
+    token = cfg.load_token(cfg._KEYRING_USER_TOKEN_KEY)
     if not token:
-        console.print("[red]Not paired.[/red] Run [bold]virtuai pair <code>[/bold] first.")
+        console.print("[red]Not logged in.[/red] Run [bold]virtuai login[/bold] first.")
         raise typer.Exit(1)
 
     base = workdir or Path.cwd()
@@ -95,4 +95,6 @@ def run_chat(
         default_model_id=picked.get("default_model_id") or None,
         allowed_models=picked.get("allowed_models") or [],
     )
+    saved_theme = cfg.get("theme", "textual-dark")
+    app.theme = saved_theme
     app.run()

{virtuai_cli-0.8.7 → virtuai_cli-0.8.9}/src/virtuai_cli/chat/tui.py

@@ -23,7 +23,14 @@ from virtuai_cli.chat.sse import (
     stream_chat,
     stream_chat_multimodal,
 )
-from virtuai_cli.chat.widgets import AssistantTurn, ChatInput, TextSegment, UserBubble
+from virtuai_cli.chat.widgets import (
+    ApprovalPrompt,
+    AssistantTurn,
+    ChatInput,
+    ExpandableCard,
+    TextSegment,
+    UserBubble,
+)
 
 
 # Slash command catalog — single source of truth used by /help, the
@@ -41,6 +48,8 @@ SLASH_COMMANDS: list[tuple[str, str]] = [
     ("/load", "load a past conversation: /load <session_id>"),
     ("/models", "list models available for this agent"),
     ("/model", "switch the model: /model <id>"),
+    ("/connect", "connect a Google Workspace account: /connect <service>"),
+    ("/accounts", "list your connected Google accounts"),
     ("/exit", "close the TUI"),
     ("/quit", "close the TUI"),
 ]
@@ -91,6 +100,7 @@ class ChatApp(App):
         Binding("ctrl+y", "copy_last", "Copy last", show=True, priority=True),
         Binding("f2", "toggle_select_mode", "Select", show=True, priority=True),
         Binding("tab", "complete_slash", "Complete", show=False, priority=True),
+        Binding("ctrl+e", "toggle_steps", "Expand steps", show=True, priority=True),
     ]
 
     status_line = reactive("")
@@ -134,6 +144,11 @@ class ChatApp(App):
         # Buffer for execute_output chunks that arrive before the matching
         # tool_start SSE event has mounted the tool card.
         self._streaming_output: dict[str, list[str]] = {}
+        # Cumulative token usage for this session, from `complete` SSE events.
+        self._session_input_tokens: int = 0
+        self._session_output_tokens: int = 0
+        # Live command-approval prompt, keyed by request_id.
+        self._approval_prompts: dict[str, ApprovalPrompt] = {}
 
     # ── Layout ────────────────────────────────────────────────────────────
     def compose(self) -> ComposeResult:
@@ -177,12 +192,19 @@ class ChatApp(App):
         else:
             work_part = ""
 
+        total = self._session_input_tokens + self._session_output_tokens
+        tok_part = f" · [dim]{total:,} tokens[/dim]" if total else ""
+
         msg_part = f" · {self._status_message}" if self._status_message else ""
         return (
             f"{self.workspace_name} · {self.agent_name}{model} · "
-            f"{conn_part}{work_part}{msg_part}"
+            f"{conn_part}{work_part}{tok_part}{msg_part}"
         )
 
+    def watch_theme(self, theme: str) -> None:
+        from virtuai_cli import config as _cfg
+        _cfg.set_key("theme", theme)
+
     # ── Mount: start the WS runner in the background ──────────────────────
     async def on_mount(self) -> None:
         self.title = "VirtuAI"
@@ -299,6 +321,26 @@ class ChatApp(App):
         first_line = value.split("\n", 1)[0]
         self._refresh_slash_hints(first_line if "\n" not in value else "")
 
+    def action_toggle_steps(self) -> None:
+        """Ctrl+E — expand or collapse every step card in the conversation.
+
+        Individual cards can also be toggled by clicking them. The new state is
+        the opposite of whether *any* card is currently expanded, so one press
+        always produces a consistent view.
+        """
+        try:
+            cards = list(self.query(ExpandableCard))
+        except Exception:
+            return
+        if not cards:
+            self._set_status("no steps to expand")
+            return
+        expand = not any(c.expanded for c in cards)
+        for card in cards:
+            card.expanded = expand
+            card._redraw()
+        self._set_status(f"steps {'expanded' if expand else 'collapsed'}")
+
     def action_complete_slash(self) -> None:
         """Tab — complete the current slash command from the hint list."""
         try:
@@ -361,6 +403,66 @@ class ChatApp(App):
         await scroll.mount(widget)
         scroll.scroll_end(animate=False)
 
+    # ── Command approvals ─────────────────────────────────────────────────
+    def _set_input_enabled(self, enabled: bool) -> None:
+        """Disable the composer while an approval prompt owns the keyboard."""
+        try:
+            inp = self.query_one(ChatInput)
+        except Exception:
+            return
+        inp.disabled = not enabled
+        if enabled:
+            inp.focus()
+
+    @on(ApprovalPrompt.Decision)
+    async def _on_approval_decision(self, message: ApprovalPrompt.Decision) -> None:
+        """Send the user's choice to the server and unblock the waiting command."""
+        prompt = self._approval_prompts.pop(message.request_id, None)
+        scope = message.scope if message.approved else "once"
+        payload = {
+            "approved": message.approved,
+            "scope": scope,
+            "duration_minutes": message.duration_minutes,
+        }
+        try:
+            import httpx
+            resp = await asyncio.to_thread(
+                lambda: httpx.post(
+                    f"{self.server_url}/api/web-chat/approvals/{message.request_id}/decision",
+                    params={"agent_id": self.agent_id},
+                    headers={"Authorization": f"Bearer {self.token}"},
+                    json=payload,
+                    timeout=15,
+                )
+            )
+            resp.raise_for_status()
+        except Exception as exc:
+            from rich.markup import escape
+            await self._append(Static(
+                f"[red]Failed to send approval decision: {escape(str(exc))}[/red]"
+            ))
+            if prompt is not None:
+                prompt.mark_stale("could not be sent")
+            if not self._approval_prompts:
+                self._set_input_enabled(True)
+            return
+
+        if prompt is not None:
+            if message.approved:
+                # Nothing left to say — the tool card below shows the command
+                # running, so the prompt just gets out of the way.
+                try:
+                    await prompt.remove()
+                except Exception:
+                    pass
+            else:
+                # Keep a one-line trace so the agent's "I couldn't run that"
+                # reply has visible context.
+                prompt.mark_stale("denied")
+        # Hand the keyboard back so the user can keep typing.
+        if not self._approval_prompts:
+            self._set_input_enabled(True)
+
     # ── Slash commands ────────────────────────────────────────────────────
     async def _handle_slash(self, cmd: str) -> None:
         parts = cmd.split(None, 1)
@@ -388,6 +490,10 @@ class ChatApp(App):
             await self._show_attachments()
         elif head == "/detach":
             await self._detach_file(arg)
+        elif head == "/connect":
+            await self._connect_google(arg)
+        elif head == "/accounts":
+            await self._show_accounts()
         elif head == "/help":
             await self._append(Static(
                 "[b]Commands[/b]\n"
@@ -402,6 +508,8 @@ class ChatApp(App):
                 "  /load <id>         load a past conversation by session_id\n"
                 "  /models            list models available for this agent\n"
                 "  /model <id>        switch the model for the next message\n"
+                "  /connect <service> connect a Google account (e.g. /connect google_gmail)\n"
+                "  /accounts          list connected Google accounts\n"
                 "  /exit, /quit       close the TUI\n"
                 "\n"
                 "[b]Keys[/b]\n"
@@ -412,6 +520,11 @@ class ChatApp(App):
                 "  Ctrl+Y             copy last assistant response\n"
                 "  F2                 toggle select mode (mouse selection on/off)\n"
                 "  Tab                autocomplete slash command\n"
+                "  Ctrl+E             expand/collapse all step cards\n"
+                "\n"
+                "[b]Step cards[/b]\n"
+                "  Click any step card to expand it and see the full command\n"
+                "  and output. Click again to collapse. [b]Ctrl+E[/b] toggles all.\n"
                 "\n"
                 "[b]Selecting text with the mouse[/b]\n"
                 "  Press [b]F2[/b] (or run [b]/select[/b]) to release the TUI's mouse\n"
@@ -422,6 +535,112 @@ class ChatApp(App):
         else:
             await self._append(Static(f"[red]Unknown command: {head}[/red]  (try /help)"))
 
+    async def _connect_google(self, service: str) -> None:
+        """Open browser to connect a Google Workspace account via OAuth2."""
+        known = {
+            "google_gmail": "Gmail",
+            "google_drive": "Google Drive",
+            "google_calendar": "Google Calendar",
+            "google_chat": "Google Chat",
+            "google_people": "Google Contacts",
+        }
+        if not service:
+            lines = ["[b]Available Google services:[/b]"]
+            for k, v in known.items():
+                lines.append(f"  /connect [cyan]{k}[/cyan]  → {v}")
+            await self._append(Static("\n".join(lines)))
+            return
+
+        label = known.get(service, service)
+        await self._append(Static(f"[dim]Connecting to {label}…[/dim]"))
+
+        try:
+            import httpx
+            resp = httpx.get(
+                f"{self.server_url}/api/web-chat/oauth/google/authorize",
+                params={"predefined_type": service, "agent_id": self.agent_id},
+                headers={"Authorization": f"Bearer {self.token}"},
+                timeout=10,
+            )
+            resp.raise_for_status()
+            auth_url = resp.json().get("auth_url", "")
+        except Exception as e:
+            from rich.markup import escape
+            await self._append(Static(f"[red]Failed to get authorization URL: {escape(str(e))}[/red]"))
+            return
+
+        await self._append(Static(
+            f"[b]Connect {label}[/b]\n"
+            f"Open this URL in your browser:"
+        ))
+        # OAuth URLs contain characters Rich parses as markup — render raw.
+        await self._append(Static(auth_url, markup=False))
+        await self._append(Static(
+            "[dim]After authorizing, your account will be connected automatically.[/dim]"
+        ))
+
+        import webbrowser
+        try:
+            webbrowser.open(auth_url)
+            await self._append(Static("[dim]Browser opened (if available).[/dim]"))
+        except Exception:
+            pass
+
+        # Poll for token for up to 90 seconds
+        await self._append(Static("[dim]Waiting for authorization (up to 90 s)…[/dim]"))
+        for _ in range(30):
+            await asyncio.sleep(3)
+            try:
+                check = httpx.get(
+                    f"{self.server_url}/api/web-chat/oauth/tokens",
+                    params={"agent_id": self.agent_id},
+                    headers={"Authorization": f"Bearer {self.token}"},
+                    timeout=5,
+                )
+                tokens = check.json() if check.is_success else []
+                match = next((t for t in tokens if t.get("service") == service), None)
+                if match and match.get("status") == "connected":
+                    email = match.get("connected_email", "your account")
+                    await self._append(Static(f"[green]✓ Connected as {email}[/green]"))
+                    return
+            except Exception:
+                pass
+
+        await self._append(Static("[yellow]Timed out waiting for authorization. Try again or check the browser.[/yellow]"))
+
+    async def _show_accounts(self) -> None:
+        """List connected Google accounts for this user."""
+        try:
+            import httpx
+            resp = httpx.get(
+                f"{self.server_url}/api/web-chat/oauth/tokens",
+                params={"agent_id": self.agent_id},
+                headers={"Authorization": f"Bearer {self.token}"},
+                timeout=10,
+            )
+            resp.raise_for_status()
+            tokens = resp.json()
+        except Exception as e:
+            from rich.markup import escape
+            await self._append(Static(f"[red]Failed to load accounts: {escape(str(e))}[/red]"))
+            return
+
+        if not tokens:
+            await self._append(Static(
+                "[yellow]No Google accounts connected.[/yellow]  "
+                "Use [cyan]/connect google_gmail[/cyan] (or other services) to connect."
+            ))
+            return
+
+        lines = ["[b]Connected Google accounts:[/b]"]
+        for t in tokens:
+            name = t.get("display_name") or t.get("service", "")
+            email = t.get("connected_email", "")
+            status = "✓" if t.get("status") == "connected" else "⚠ expired"
+            color = "green" if t.get("status") == "connected" else "yellow"
+            lines.append(f"  [{color}]{status}[/{color}]  {name}  [dim]{email}[/dim]")
+        await self._append(Static("\n".join(lines)))
+
     async def _show_models(self) -> None:
         if not self.allowed_models:
             await self._append(Static(
@@ -833,48 +1052,139 @@ class ChatApp(App):
             # story. Empty == "", "{}", or anything that strips to nothing.
             input_val = event.get("input", "")
             input_str = input_val if isinstance(input_val, str) else json.dumps(input_val, default=str)
-            tool_id = event.get("id", "")
-            if input_str.strip() in ("", "{}", "[]"):
-                turn._tools[tool_id] = None  # type: ignore[assignment]
+            raw_tool_id = event.get("id", "")
+            subagent_id = event.get("subagent_id")
+            if subagent_id:
+                # Nested step — belongs to a sub-agent. Prefix and indent it.
+                agent_name = turn._subagent_names.get(subagent_id, "sub-agent")
+                tool_id = f"{subagent_id}:{raw_tool_id}"
+                if input_str.strip() in ("", "{}", "[]"):
+                    turn._tools[tool_id] = None  # type: ignore[assignment]
+                else:
+                    await turn.start_tool(
+                        tool_id,
+                        f"[{agent_name}] {event.get('name', 'tool')}",
+                        input_val,
+                        display=event.get("display", ""),
+                        file_content=event.get("file_content"),
+                        file_content_before=event.get("file_content_before"),
+                        read_offset=event.get("read_offset"),
+                        read_limit=event.get("read_limit"),
+                        indent=True,
+                    )
             else:
-                await turn.start_tool(
-                    tool_id,
-                    event.get("name", "tool"),
-                    input_val,
-                    display=event.get("display", ""),
-                    file_content=event.get("file_content"),
-                    file_content_before=event.get("file_content_before"),
-                    read_offset=event.get("read_offset"),
-                    read_limit=event.get("read_limit"),
-                )
-                # Flush any execute_output chunks that raced ahead of this
-                # tool_start event (can happen when a subprocess starts
-                # printing immediately, e.g. a fast SSH connection).
-                card = turn._tools.get(tool_id)
-                if card is not None:
-                    for buffered_chunk in self._streaming_output.pop(tool_id, []):
-                        if hasattr(card, "append_output"):
-                            card.append_output(buffered_chunk)
+                tool_id = raw_tool_id
+                if input_str.strip() in ("", "{}", "[]"):
+                    turn._tools[tool_id] = None  # type: ignore[assignment]
+                else:
+                    await turn.start_tool(
+                        tool_id,
+                        event.get("name", "tool"),
+                        input_val,
+                        display=event.get("display", ""),
+                        file_content=event.get("file_content"),
+                        file_content_before=event.get("file_content_before"),
+                        read_offset=event.get("read_offset"),
+                        read_limit=event.get("read_limit"),
+                    )
+                    # Flush any execute_output chunks that raced ahead of this
+                    # tool_start event (can happen when a subprocess starts
+                    # printing immediately, e.g. a fast SSH connection).
+                    card = turn._tools.get(tool_id)
+                    if card is not None:
+                        for buffered_chunk in self._streaming_output.pop(tool_id, []):
+                            if hasattr(card, "append_output"):
+                                card.append_output(buffered_chunk)
         elif etype == "tool_end":
             # If we skipped the matching tool_start (empty input), don't try
             # to finalize a card that doesn't exist.
-            if turn._tools.get(event.get("id", "")) is not None:
-                turn.finish_tool(event.get("id", ""), event.get("output_preview"), errored=False)
+            raw_tool_id = event.get("id", "")
+            subagent_id = event.get("subagent_id")
+            tool_id = f"{subagent_id}:{raw_tool_id}" if subagent_id else raw_tool_id
+            if turn._tools.get(tool_id) is not None:
+                turn.finish_tool(tool_id, event.get("output_preview"), errored=False)
+        elif etype == "approval_request":
+            request_id = event.get("request_id", "")
+            if request_id and request_id not in self._approval_prompts:
+                prompt = ApprovalPrompt(
+                    request_id,
+                    event.get("command", ""),
+                    int(event.get("timeout_secs", 300)),
+                )
+                self._approval_prompts[request_id] = prompt
+                await self._append(prompt)
+                # A focused TextArea swallows printable keys before any
+                # binding runs, so the choice keys only reach the prompt if
+                # the input isn't focused. The input is unusable anyway while
+                # the turn is blocked on this decision.
+                self._set_input_enabled(False)
+                prompt.focus()
+        elif etype == "approval_resolved":
+            request_id = event.get("request_id", "")
+            prompt = self._approval_prompts.pop(request_id, None)
+            if prompt is not None and not prompt._answered:
+                prompt.mark_stale("expired")
+            if not self._approval_prompts:
+                self._set_input_enabled(True)
         elif etype == "todos":
             await turn.set_todos(event.get("items", []))
         elif etype == "truncated":
-            # Dedupe: when max_tokens hits repeatedly on multiple model passes
-            # in a single turn (e.g. while a big tool-call arg gets retried),
-            # we don't want a wall of `[response truncated]` markers.
+            # Dedupe: only show once per turn — multiple model calls in one turn
+            # (e.g. tool retries) can each emit this, but one notice is enough.
             if not turn._truncated_shown:
                 await turn.append_token(
-                    "\n\n*[response truncated — try raising the agent's max_tokens]*"
+                    "\n\n*[output cut off — max output tokens reached. Ask the agent to continue.]*"
                 )
                 turn._truncated_shown = True
+        elif etype == "notice":
+            msg = event.get("message") or ""
+            if msg:
+                await turn.append_token(f"\n\n*⚠ {msg}*\n\n")
         elif etype == "error":
             msg = event.get("error") or event.get("message") or "unknown error"
             await turn.append_token(f"\n\n*[error: {msg}]*")
         elif etype in ("done", "complete"):
+            if etype == "complete":
+                inp = event.get("input_tokens") or 0
+                out = event.get("output_tokens") or 0
+                if inp or out:
+                    self._session_input_tokens += inp
+                    self._session_output_tokens += out
+                    await turn.set_usage(inp, out)
+                    self._refresh_status_bar()
             return
-        # Other event types (subagent_*, skill_loaded, memory_updated, etc.)
-        # are silently ignored in v1.
+        elif etype == "subagent_start":
+            delegation_id = event.get("id", "")
+            raw_name = event.get("name", "")
+            agent_name = raw_name.replace("delegate_to_", "")
+            # Record the delegation_id → name mapping so nested tool_start
+            # events with subagent_id can label and indent their cards.
+            turn._subagent_names[delegation_id] = agent_name
+            task = event.get("input", "")
+            tool_id = f"subagent:{delegation_id}"
+            await turn.start_tool(tool_id, f"🤖 {agent_name}", task)
+        elif etype == "subagent_end":
+            tool_id = f"subagent:{event.get('id', '')}"
+            turn.finish_tool(tool_id, event.get("output_preview"), errored=False)
+        elif etype == "subagent_step":
+            subagent_name = event.get("subagent_name", "sub-agent")
+            step = event.get("step") or {}
+            stype = step.get("type", "")
+            # Prefix tool IDs so sub-agent tool cards don't collide with parent ones.
+            tool_id = f"{subagent_name}:{step.get('id', '')}"
+            if stype == "tool_start":
+                input_val = step.get("input", "")
+                input_str = input_val if isinstance(input_val, str) else json.dumps(input_val, default=str)
+                if input_str.strip() not in ("", "{}", "[]"):
+                    await turn.start_tool(
+                        tool_id,
+                        f"[{subagent_name}] {step.get('name', 'tool')}",
+                        input_val,
+                        display=step.get("display", ""),
+                    )
+            elif stype == "tool_end":
+                if turn._tools.get(tool_id) is not None:
+                    turn.finish_tool(tool_id, step.get("output_preview"), errored=False)
+            elif stype == "todos":
+                await turn.set_todos(step.get("items", []))
+        # Other event types (skill_loaded, memory_updated, etc.) are silently ignored.