deep-agent-cli 0.1.0__py3-none-any.whl

agent/cli/session_controller.py

@@ -0,0 +1,221 @@
+"""CLI session workflow: /new, /resume, and waiting out a session held elsewhere.
+
+The controller owns the resume picker, the busy-session wait, and applying a
+restored snapshot to the visible state. It drives the runner but never touches
+the prompt_toolkit layout.
+"""
+from __future__ import annotations
+
+import asyncio
+from typing import TYPE_CHECKING, Any
+
+from agent.cli.interactions import InteractionController
+
+if TYPE_CHECKING:
+    from agent.cli.app import CliApplication
+
+
+# Shown while the runner waits for a session held by another window.
+WAIT_STATUS = "Waiting for session {} · Esc cancels"
+
+
+class SessionController:
+    def __init__(self, app: CliApplication) -> None:
+        self._app = app
+        self.open_picker_on_start = False
+        self.startup_session_id: str | None = None
+        self._wait_target: str | None = None
+        self._wait_cancelled = False
+        self._wait_task: asyncio.Task[None] | None = None
+
+    @property
+    def waiting(self) -> bool:
+        return self._wait_target is not None
+
+    @property
+    def wait_target(self) -> str | None:
+        return self._wait_target
+
+    @property
+    def wait_task(self) -> asyncio.Task[None] | None:
+        return self._wait_task
+
+    def wait_status(self) -> str:
+        assert self._wait_target is not None
+        return WAIT_STATUS.format(self._wait_target[:8])
+
+    def schedule_start(self, loop: asyncio.AbstractEventLoop) -> None:
+        if self.startup_session_id is not None:
+            loop.create_task(self._switch_with_wait(self.startup_session_id))
+        elif self.open_picker_on_start:
+            loop.create_task(self.resume())
+
+    async def start(self) -> None:
+        if self.startup_session_id is not None:
+            await self._switch_with_wait(self.startup_session_id)
+        elif self.open_picker_on_start:
+            await self.resume()
+
+    def new_session(self) -> None:
+        app = self._app
+        if app.state.running:
+            app.set_status("Cancel the active run before starting a new session")
+            return
+        if self.waiting:
+            app.set_status(self.wait_status())
+            return
+        app._restore_queued_to_editor(app.buffer)
+        try:
+            info = app.runner.new_session()
+        except RuntimeError as exc:
+            app.state.add_system(str(exc), error=True)
+            return
+        app.state.clear()
+        app.state.attachments.clear()
+        app.interaction = None
+        app._reviewing = False
+        app._transcript_anchor = None
+        app._renderer.clear()
+        app.state.add_system(f"Started session {info.id}")
+        app.set_status("Ready")
+
+    async def resume(self, arg: str = "") -> None:
+        app = self._app
+        if app.state.running:
+            app.set_status("Cancel the active run before switching sessions")
+            return
+        if app.runner.session_store is None:
+            app.state.add_system(
+                "/resume is unavailable: persistent session storage is not configured", error=True,
+            )
+            return
+        if self.waiting:
+            return
+        if arg.strip():
+            app._restore_queued_to_editor(app.buffer)
+            await self._switch_with_wait(arg.strip())
+            return
+        sessions = self._sessions_with_content(limit=50)
+        if not sessions:
+            app.state.add_system("No sessions with conversation content.", error=True)
+            return
+        options = [
+            {
+                "value": item.id,
+                "label": f"{item.id[:8]} · {item.last_run_status.value} · {item.title[:40]}",
+                "right_label": item.updated_at.astimezone().strftime("%Y-%m-%d %H:%M:%S"),
+            }
+            for item in sessions
+        ]
+        app.interaction = InteractionController(
+            kind="resume",
+            title="Resume session",
+            question="Select a session to restore",
+            fields=[{
+                "id": "session",
+                "type": "single_select",
+                "label": "Session",
+                "required": True,
+                "options": options,
+            }],
+        )
+        app.set_status("Select a session · Enter confirm · Esc cancel")
+        app.application.invalidate()
+
+    def begin_switch(self, session_id: str) -> None:
+        """Picker Enter: switch immediately, or enter the visible wait."""
+        app = self._app
+        try:
+            app._restore_queued_to_editor(app.buffer)
+            result = app.runner.begin_session_switch(session_id)
+        except (KeyError, RuntimeError) as exc:
+            app.state.add_system(str(exc), error=True)
+            return
+        if result.busy:
+            self._enter_wait(result.target_id)
+            return
+        assert result.snapshot is not None
+        self.apply_snapshot(result.snapshot)
+
+    def apply_snapshot(self, snapshot: Any) -> None:
+        app = self._app
+        app.state.load_transcript(snapshot.transcript)
+        app.state.todos = list(snapshot.todos)
+        app.interaction = None
+        app._reviewing = False
+        app.state.add_system(
+            f"Resumed session {snapshot.info.id} (last run: {snapshot.info.last_run_status.value})"
+        )
+        for notice in snapshot.notices:
+            app.state.add_system(notice)
+        if not app._reopen_pending_interaction(notify_missing=False):
+            app.set_status("Ready")
+        app._transcript_anchor = None
+        app._renderer.clear()
+        app.state.usage = dict(app.runner.latest_usage())
+        app.application.invalidate()
+
+    def cancel_wait(self) -> None:
+        self._wait_cancelled = True
+        self._app.set_status("Cancelling wait…")
+
+    def notify_exit(self) -> None:
+        self._wait_cancelled = True
+
+    async def _switch_with_wait(self, session_id: str) -> None:
+        app = self._app
+        try:
+            result = await app._run_blocking(app.runner.begin_session_switch, session_id)
+        except (KeyError, RuntimeError) as exc:
+            app.state.add_system(str(exc), error=True)
+            return
+        if result.busy:
+            self._enter_wait(result.target_id)
+            return
+        assert result.snapshot is not None
+        self.apply_snapshot(result.snapshot)
+
+    def _enter_wait(self, target_id: str) -> None:
+        """Detach into a visible wait for a session busy in another window."""
+        app = self._app
+        self._wait_target = target_id
+        self._wait_cancelled = False
+        app.interaction = None
+        app.state.add_system(
+            f"Session {target_id[:8]} is open in another window; waiting for it to be released."
+        )
+        app.set_status(self.wait_status())
+        self._wait_task = asyncio.create_task(self._wait_for_session(target_id))
+        app.application.invalidate()
+
+    async def _wait_for_session(self, target_id: str) -> None:
+        app = self._app
+        try:
+            snapshot = await app._run_blocking(
+                app.runner.complete_session_switch, target_id,
+                cancelled=lambda: self._wait_cancelled,
+            )
+        except (KeyError, RuntimeError) as exc:
+            self._wait_target = None
+            app.state.add_system(str(exc), error=True)
+            app.set_status("Session switch failed")
+            return
+        self._wait_target = None
+        if snapshot is None:
+            # Cancelled: the runner stays detached, so the picker (or /new) must
+            # choose the next session explicitly.
+            app.set_status("Waiting cancelled · pick a session")
+            await self.resume()
+            return
+        self.apply_snapshot(snapshot)
+
+    def _sessions_with_content(self, *, limit: int = 50) -> list[Any]:
+        app = self._app
+        if app.runner.session_store is None:
+            return []
+        sessions = []
+        for info in app.runner.list_sessions(limit=limit):
+            if not app.runner.thread_has_content(info.id):
+                continue
+            sessions.append(info)
+        return sessions

agent/cli/state.py

@@ -0,0 +1,326 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any, Callable
+from uuid import uuid4
+
+from agent.attachments import ImageAttachmentRef
+from agent.runner import RunEvent, RunResult, TurnTiming
+from agent.session import TranscriptBlock
+
+
+@dataclass
+class MessageBlock:
+    kind: str
+    content: str = ""
+    thinking: str = ""
+    id: str = field(default_factory=lambda: str(uuid4()))
+    is_error: bool = False
+    pending: bool = False
+    attachments: tuple[ImageAttachmentRef, ...] = ()
+    # Bumped on every mutation so the transcript renderer can tell a frozen
+    # block from the one still being streamed into.
+    revision: int = 0
+
+
+@dataclass
+class ToolBlock:
+    tool_call_id: str
+    name: str
+    arguments: dict[str, Any]
+    output: str = ""
+    # Raw ToolMessage.artifact: the structured tool result, preserved for
+    # preview builders. Not persisted as a derived preview.
+    artifact: Any = None
+    status: str = "running"
+    is_error: bool = False
+    revision: int = 0
+    exit_code: int | None = None
+
+
+@dataclass(frozen=True)
+class TurnSummaryBlock:
+    elapsed_seconds: float
+    finished_at: datetime
+
+
+Block = MessageBlock | ToolBlock | TurnSummaryBlock
+
+
+def touch(block: MessageBlock | ToolBlock) -> MessageBlock | ToolBlock:
+    """Mark a block as changed so its cached rendering is rebuilt."""
+    block.revision += 1
+    return block
+
+
+@dataclass
+class CliState:
+    blocks: list[Block] = field(default_factory=list)
+    todos: list[dict[str, str]] = field(default_factory=list)
+    running: bool = False
+    status: str = "Ready"
+    thinking_collapsed: bool = False
+    tools_expanded: bool = False
+    # Held by reference, not index: app-side filtering of `blocks` would
+    # otherwise silently redirect stream deltas into an unrelated block.
+    active_block: MessageBlock | None = None
+    pending_user_ids: dict[str, str] = field(default_factory=dict)
+    attachments: list[ImageAttachmentRef] = field(default_factory=list)
+    usage: dict[str, int] = field(default_factory=dict)
+
+    def add_user(
+        self,
+        text: str,
+        *,
+        pending: bool = False,
+        message_id: str = "",
+        attachments: tuple[ImageAttachmentRef, ...] = (),
+    ) -> None:
+        block = MessageBlock(
+            kind="user", content=text, pending=pending,
+            id=message_id or str(uuid4()), attachments=attachments,
+        )
+        self.blocks.append(block)
+        self.active_block = None
+        if pending and message_id:
+            self.pending_user_ids[message_id] = block.id
+
+    def add_system(self, text: str, *, error: bool = False) -> None:
+        self.blocks.append(MessageBlock(kind="error" if error else "system", content=text, is_error=error))
+
+    def clear(self) -> None:
+        self.blocks.clear()
+        self.todos.clear()
+        self.active_block = None
+        self.pending_user_ids.clear()
+        self.usage.clear()
+
+    def load_transcript(self, blocks: list[TranscriptBlock]) -> None:
+        self.clear()
+        for item in blocks:
+            if item.kind == "user":
+                self.blocks.append(MessageBlock(
+                    kind="user", content=item.content, attachments=item.attachments,
+                ))
+            elif item.kind == "assistant":
+                self.blocks.append(MessageBlock(
+                    kind="assistant", content=item.content, thinking=item.thinking,
+                ))
+            elif item.kind == "tool":
+                self.blocks.append(ToolBlock(
+                    tool_call_id=item.tool_call_id,
+                    name=item.name or "tool",
+                    arguments=item.arguments or {},
+                    output=item.content,
+                    artifact=item.artifact,
+                    status=item.status or ("error" if item.is_error else "completed"),
+                    is_error=item.is_error,
+                    exit_code=item.exit_code,
+                ))
+
+    def apply(self, event: RunEvent) -> None:
+        if event.type == "run_started":
+            self.running = True
+            self.status = "Working…  Esc to cancel"
+            self.active_block = None
+        elif event.type == "assistant_started":
+            self.active_block = None
+        elif event.type == "todos_updated" and isinstance(event.result, list):
+            self.todos = [dict(item) for item in event.result if isinstance(item, dict)]
+        elif event.type == "usage" and isinstance(event.result, dict):
+            usage = {
+                key: int(value)
+                for key, value in event.result.items()
+                if key in {"input_tokens", "output_tokens", "total_tokens"}
+                and isinstance(value, int)
+            }
+            if usage:
+                self.usage = usage
+        elif event.type in {"thinking_delta", "assistant_delta"}:
+            block = touch(self._assistant_block())
+            if event.type == "thinking_delta":
+                block.thinking = event.content
+            else:
+                block.content = event.content
+        elif event.type == "tool_started":
+            tool = self._tool_by_id(event.tool_call_id)
+            if tool is None:
+                self.blocks.append(ToolBlock(
+                    tool_call_id=event.tool_call_id,
+                    name=event.name,
+                    arguments=event.arguments,
+                ))
+            elif tool.status not in {"completed", "error"}:
+                touch(tool)
+                tool.name = event.name or tool.name
+                tool.arguments = event.arguments or tool.arguments
+                tool.status = "running"
+            self.active_block = None
+        elif event.type == "tool_output_delta":
+            tool = self._tool(event.tool_call_id) or self._running_tool()
+            if tool is None:
+                tool = ToolBlock(event.tool_call_id, event.name or "tool", {})
+                self.blocks.append(tool)
+            touch(tool)
+            if event.stream == "tail_snapshot" and tool.name == "execute":
+                tool.output = event.content
+                artifact = tool.artifact if isinstance(tool.artifact, dict) else {}
+                tool.artifact = {**artifact, "truncated": True}
+            else:
+                tool.output += event.content
+        elif event.type == "assistant_completed":
+            self.active_block = None
+        elif event.type == "tool_completed":
+            tool = self._tool(event.tool_call_id)
+            if tool is None:
+                tool = ToolBlock(event.tool_call_id, event.name, {})
+                self.blocks.append(tool)
+            touch(tool)
+            artifact = event.artifact if isinstance(event.artifact, dict) else None
+            had_tail_snapshot = (
+                event.name == "execute" and isinstance(tool.artifact, dict)
+                and tool.artifact.get("truncated") is True
+            )
+            if artifact is not None:
+                tool.artifact = artifact
+            if event.name == "execute" and artifact is not None:
+                if artifact.get("truncated") and not had_tail_snapshot and event.content:
+                    # Legacy/no-stream fallback: the final result has the tail.
+                    tool.output = event.content
+                elif not tool.output:
+                    tool.output = event.content
+            elif event.content and (not tool.output or event.content.startswith(tool.output)):
+                tool.output = event.content
+            tool.is_error = event.is_error
+            tool.status = "error" if event.is_error else "completed"
+            if event.name == "execute" and artifact is not None:
+                code = artifact.get("exit_code")
+                tool.exit_code = code if isinstance(code, int) and not isinstance(code, bool) else None
+        elif event.type == "steering_queued":
+            mode = ""
+            message_id = ""
+            if isinstance(event.result, dict):
+                mode = str(event.result.get("mode") or "")
+                message_id = str(event.result.get("id") or "")
+            if mode == "steer" and event.content:
+                self.add_user(event.content, pending=True, message_id=message_id)
+                self.status = "Steering queued"
+            elif mode == "followUp":
+                self.status = f"Follow-up queued ({event.content[:40]})"
+        elif event.type == "steering_applied":
+            message_id = ""
+            if isinstance(event.result, dict):
+                message_id = str(event.result.get("id") or "")
+            block_id = self.pending_user_ids.pop(message_id, None)
+            if block_id:
+                for block in self.blocks:
+                    if isinstance(block, MessageBlock) and block.id == block_id:
+                        touch(block).pending = False
+                        break
+        elif event.type == "run_cancelling":
+            self.status = "Cancelling…"
+        elif event.type == "interaction_requested":
+            self.running = False
+            self.status = "Waiting for input"
+            self.active_block = None
+            settle = _interaction_settlement(event.result)
+            for block in self.blocks:
+                if isinstance(block, ToolBlock) and block.status == "running":
+                    touch(block).status = settle(block)
+        elif event.type == "run_completed":
+            self.running = False
+            self.status = "Ready"
+            for block in self.blocks:
+                if isinstance(block, ToolBlock) and block.status in {"running", "waiting"}:
+                    touch(block).status = "interrupted"
+            if event.content and not self._has_assistant_text(event.content):
+                self.blocks.append(MessageBlock(kind="assistant", content=event.content))
+            self.active_block = None
+        elif event.type == "turn_completed" and isinstance(event.result, TurnTiming):
+            if event.content and not self._has_assistant_text(event.content):
+                self.blocks.append(MessageBlock(kind="assistant", content=event.content))
+            self.blocks.append(TurnSummaryBlock(
+                elapsed_seconds=event.result.elapsed_seconds,
+                finished_at=event.result.finished_at,
+            ))
+            self.active_block = None
+        elif event.type == "run_cancelled":
+            self.running = False
+            self.status = "Cancelled"
+            for block in self.blocks:
+                if isinstance(block, ToolBlock) and block.status == "running":
+                    touch(block)
+                    block.status = "error"
+                    block.is_error = True
+                    block.exit_code = 1
+                    if block.name == "execute":
+                        artifact = block.artifact if isinstance(block.artifact, dict) else {}
+                        block.artifact = {**artifact, "termination_reason": "cancelled"}
+            self.add_system("Operation cancelled.", error=True)
+        elif event.type == "run_failed":
+            self.running = False
+            self.status = "Failed"
+            for block in self.blocks:
+                if isinstance(block, ToolBlock) and block.status in {"running", "waiting"}:
+                    touch(block).status = "error"
+                    block.is_error = True
+                    block.exit_code = 1
+            self.add_system(event.content or "Unknown error", error=True)
+
+    def _assistant_block(self) -> MessageBlock:
+        block = self.active_block
+        if block is not None and any(item is block for item in self.blocks):
+            return block
+        block = MessageBlock(kind="assistant")
+        self.blocks.append(block)
+        self.active_block = block
+        return block
+
+    def _tool(self, tool_call_id: str) -> ToolBlock | None:
+        if not tool_call_id:
+            return self._running_tool()
+        for block in reversed(self.blocks):
+            if isinstance(block, ToolBlock) and block.tool_call_id == tool_call_id:
+                return block
+        return None
+
+    def _tool_by_id(self, tool_call_id: str) -> ToolBlock | None:
+        """Exact identity lookup; never falls back to an unrelated running tool."""
+        if not tool_call_id:
+            return None
+        for block in reversed(self.blocks):
+            if isinstance(block, ToolBlock) and block.tool_call_id == tool_call_id:
+                return block
+        return None
+
+    def _running_tool(self) -> ToolBlock | None:
+        for block in reversed(self.blocks):
+            if isinstance(block, ToolBlock) and block.status == "running":
+                return block
+        return None
+
+    def _has_assistant_text(self, text: str) -> bool:
+        return any(
+            isinstance(block, MessageBlock) and block.kind == "assistant" and block.content == text
+            for block in self.blocks
+        )
+
+
+def _interaction_settlement(result: Any) -> Callable[[ToolBlock], str]:
+    """Classify running tools at an interrupt as waiting or interrupted.
+
+    Only the calls the interrupt actually blocks keep the ``waiting`` label;
+    every other unfinished call merely lost its completion confirmation.
+    """
+    status = str(getattr(result, "status", "") or "")
+    if status == "waiting_confirmation":
+        pending = {
+            str(call.get("toolCallId") or "")
+            for call in getattr(result, "pending_tool_calls", None) or []
+            if isinstance(call, dict)
+        }
+        return lambda block: "waiting" if block.tool_call_id in pending else "interrupted"
+    if status == "waiting_human":
+        return lambda block: "waiting" if block.name == "request_human_input" else "interrupted"
+    return lambda _block: "interrupted"

agent/config.example.yaml

@@ -0,0 +1,76 @@
+# DeepAgent template configuration.
+# First CLI launch copies this template to ~/.deep-agent/config.yaml and exits.
+#
+# Override path with DEEP_AGENT_CONFIG=/path/outside/workspace/config.yaml
+
+agent:
+  # Long-term user instructions appended after the built-in identity.
+  # instructions: |
+  #   优先使用中文回答。
+  instructions: null
+
+ui:
+  # IANA time zone for the time shown after each completed answer.
+  timezone: Asia/Shanghai
+
+llm:
+  # Required for grouped models: source/model. Change this to select the startup model.
+  default: local/qwen-plus
+  models:
+    local:
+      # A literal key or a complete environment reference such as ${MODEL_API_KEY}.
+      api_key: sk-local
+      base_url: http://localhost:8000/v1
+      provider: qwen-responses
+      stream_usage: false
+      models:
+        qwen-plus:
+          model: qwen3.5-plus
+          input: [text, image]
+          context_window: 1m
+        qwen3.6-flash:
+          input: [text, image]
+          context_window: 1m
+    # --- Aliyun Bailian Qwen Token Plan (compatible-mode endpoint) ---
+    # Uncomment this group and set default: token-plan/auto to start with Token Plan.
+    # token-plan:
+    #   api_key: ${TOKEN_PLAN_API_KEY}
+    #   base_url: https://token-plan.cn-beijing.maas.aliyuncs.com/compatible-mode/v1
+    #   provider: openai-compatible
+    #   stream_usage: true
+    #   context_window: 1m
+    #   models:
+    #     auto:
+    #       input: [text]
+    #     qwen3.8-max:
+    #       input: [text, image]
+    #     qwen3.8-flash:
+    #       input: [text, image]
+
+web_search:
+  # Optional. TAVILY_API_KEY overrides this value; omit both to hide web_search.
+  # This field also accepts a literal key in your private ~/.deep-agent/config.yaml.
+  tavily_api_key: null
+
+sandbox:
+  # Host directory mapped to /workspace. "." = the directory you start the TUI from (cwd).
+  workspace: .
+  bwrap_path: bwrap
+  # Allow dangerous host execution when bubblewrap is unavailable.
+  allow_unsandboxed: false
+  # No time limit by default. Set a positive number to cap each command.
+  timeout_seconds: null
+  max_output_bytes: 100000
+  # Host env var names explicitly exposed to Agent commands.
+  env_allowlist: []
+  # Fixed env vars injected into the sandbox (not read from the host).
+  env_set: {}
+  # Extra mounts: [{source: /host/path, destination: /sandbox/path}, ...]
+  extra_read_only_mounts: []
+  extra_read_write_mounts: []
+
+paths:
+  # SQLite session DB. null → ~/.deep-agent/sessions/<workspace-hash>.sqlite3
+  state_path: null
+  # Keybindings directory. null → ~/.deep-agent
+  config_dir: null