comate-cli 0.8.3__tar.gz → 0.8.4__tar.gz

{comate_cli-0.8.3 → comate_cli-0.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comate-cli
-Version: 0.8.3
+Version: 0.8.4
 Summary: Comate terminal CLI built on comate-agent-sdk
 Project-URL: Homepage, https://github.com/AndyLee1024/agent-sdk
 Project-URL: Repository, https://github.com/AndyLee1024/agent-sdk

{comate_cli-0.8.3 → comate_cli-0.8.4}/comate_cli/terminal_agent/event_renderer.py

@@ -35,8 +35,10 @@ from comate_agent_sdk.agent.events import (
     ThinkingDeltaEvent,
     TaskUpdatedEvent,
     ToolCallEvent,
+    ToolCallArgsProgressEvent,
     ToolCallStartEvent,
     ToolResultEvent,
+    StreamDisplayResetEvent,
     UsageDeltaEvent,
     UserQuestionEvent,
 )
@@ -81,6 +83,9 @@ _DEFAULT_TOOL_PANEL_MAX_LINES = 4
 _DEFAULT_TASK_PANEL_MAX_LINES = 6
 _RECENT_TEAM_EVENT_CACHE_SIZE = 128
 _SYSTEM_MESSAGE_DEDUPE_WINDOW_SECONDS = 0.5
+TOOL_ARGS_PROGRESS_VISIBLE_TOKENS = 1000
+TOOL_ARGS_PROGRESS_VISIBLE_AFTER_SECONDS = 1.5
+TOOL_ARGS_PROGRESS_VISIBLE_MIN_TOKENS_AFTER_DELAY = 256
 
 
 def _truncate(content: str, max_len: int = 120) -> str:
@@ -129,6 +134,13 @@ def _format_tokens(token_count: int) -> str:
     return f"{compact}k tok"
 
 
+def _format_tool_args_tokens(token_count: int) -> str:
+    tokens = max(int(token_count), 0)
+    if tokens < 1_000:
+        return f"{tokens} tokens"
+    return f"{tokens / 1_000:.1f}k tokens"
+
+
 def _split_fragments_by_newline(
     fragments: list[tuple[str, str]],
 ) -> list[list[tuple[str, str]]]:
@@ -245,6 +257,16 @@ class _RunningTool:
     subagent_model_name: str = ""
 
 
+@dataclass
+class _ToolArgsProgressState:
+    tool_call_id: str
+    tool_name: str
+    started_at_monotonic: float
+    last_updated_at_monotonic: float
+    estimated_tokens: int = 0
+    visible: bool = False
+
+
 @dataclass(frozen=True)
 class ActiveLLMRetrySnapshot:
     retry_id: str
@@ -309,6 +331,7 @@ class EventRenderer:
         self._fallback_tool_result_sequence = 0
         self._assistant_buffer = ""
         self._pending_tool_starts: set[str] = set()
+        self._tool_args_progress: dict[str, _ToolArgsProgressState] = {}
         self._loading_state: LoadingState = LoadingState.idle()
         self._current_tasks: list[dict[str, Any]] = []
         self._current_task_title: str | None = None
@@ -668,6 +691,55 @@ class EventRenderer:
         self._text_delta_started = False
         self._active_text_message_id = None
 
+    def _clear_tool_args_progress(self, tool_call_id: str | None = None) -> None:
+        if tool_call_id is None:
+            self._tool_args_progress.clear()
+            return
+        normalized_id = str(tool_call_id or "").strip()
+        if normalized_id:
+            self._tool_args_progress.pop(normalized_id, None)
+
+    def _start_tool_args_progress(self, tool_call_id: str, tool_name: str) -> None:
+        normalized_id = str(tool_call_id or "").strip()
+        if not normalized_id:
+            return
+        now = time.monotonic()
+        state = self._tool_args_progress.get(normalized_id)
+        if state is None:
+            self._tool_args_progress[normalized_id] = _ToolArgsProgressState(
+                tool_call_id=normalized_id,
+                tool_name=str(tool_name or "").strip(),
+                started_at_monotonic=now,
+                last_updated_at_monotonic=now,
+            )
+            return
+        if tool_name:
+            state.tool_name = str(tool_name).strip()
+
+    def _handle_tool_args_progress(self, event: ToolCallArgsProgressEvent) -> None:
+        normalized_id = str(event.tool_call_id or "").strip()
+        if not normalized_id:
+            return
+        state = self._tool_args_progress.get(normalized_id)
+        if state is None:
+            return
+        now = time.monotonic()
+        state.last_updated_at_monotonic = now
+        if event.tool:
+            state.tool_name = str(event.tool).strip()
+        state.estimated_tokens = max(int(event.estimated_tokens), 0)
+        if state.visible:
+            return
+        elapsed = now - state.started_at_monotonic
+        state.visible = (
+            state.estimated_tokens >= TOOL_ARGS_PROGRESS_VISIBLE_TOKENS
+            or (
+                elapsed >= TOOL_ARGS_PROGRESS_VISIBLE_AFTER_SECONDS
+                and state.estimated_tokens
+                >= TOOL_ARGS_PROGRESS_VISIBLE_MIN_TOKENS_AFTER_DELAY
+            )
+        )
+
     def _should_drop_duplicate_system_message(
         self,
         *,
@@ -699,6 +771,7 @@ class EventRenderer:
         self._active_llm_retry = None
         self._flush_assistant_segment()
         self._pending_tool_starts.clear()
+        self._clear_tool_args_progress()
         self._turn_received_text_delta = False
         self._turn_received_thinking_delta = False
         self._text_delta_started = False
@@ -760,6 +833,7 @@ class EventRenderer:
         self._flush_assistant_segment()
         self.flush_pending_logs()
         self._pending_tool_starts.clear()
+        self._clear_tool_args_progress()
         self._rebuild_loading_line()
 
     def tick_progress(self) -> None:
@@ -782,6 +856,7 @@ class EventRenderer:
         self._flush_assistant_segment()
         self._commit_active_tool_fold()
         self._pending_tool_starts.clear()
+        self._clear_tool_args_progress()
         # spec §6.4：用户中断 → 5 个新字段全部丢弃不入队
         self._drop_all_pending()
         self._rebuild_loading_line()
@@ -802,6 +877,7 @@ class EventRenderer:
         self._active_tool_fold.clear()
         self._assistant_buffer = ""
         self._pending_tool_starts.clear()
+        self._clear_tool_args_progress()
         self._turn_received_text_delta = False
         self._turn_received_thinking_delta = False
         self._text_delta_started = False
@@ -869,6 +945,15 @@ class EventRenderer:
         拼接到 spinner phrase。无容器时返回 ""。"""
         return self._loading_aux_text
 
+    def tool_args_progress_text(self) -> str:
+        visible_states = [
+            state for state in self._tool_args_progress.values() if state.visible
+        ]
+        if not visible_states:
+            return ""
+        total_tokens = sum(state.estimated_tokens for state in visible_states)
+        return f"↓ {_format_tool_args_tokens(total_tokens)}"
+
     def active_llm_retry_snapshot(self) -> ActiveLLMRetrySnapshot | None:
         return self._active_llm_retry
 
@@ -1467,7 +1552,14 @@ class EventRenderer:
     def handle_event(self, event: Any) -> tuple[bool, list[dict[str, Any]] | None]:
         if not isinstance(
             event,
-            (TextEvent, TextDeltaEvent, ThinkingDeltaEvent, ToolCallStartEvent),
+            (
+                TextEvent,
+                TextDeltaEvent,
+                ThinkingDeltaEvent,
+                ToolCallStartEvent,
+                ToolCallArgsProgressEvent,
+                StreamDisplayResetEvent,
+            ),
         ):
             self._flush_assistant_segment()
 
@@ -1498,6 +1590,12 @@ class EventRenderer:
                 normalized_id = str(tool_call_id or "").strip()
                 if normalized_id and normalized_id not in self._pending_tool_starts:
                     self._pending_tool_starts.add(normalized_id)
+                    self._start_tool_args_progress(normalized_id, tool_name)
+            case ToolCallArgsProgressEvent():
+                self._handle_tool_args_progress(event)
+            case StreamDisplayResetEvent(reason="stream_fallback"):
+                self._pending_tool_starts.clear()
+                self._clear_tool_args_progress()
             case ThinkingEvent(content=thinking):
                 if self._turn_received_thinking_delta:
                     pass
@@ -1566,6 +1664,7 @@ class EventRenderer:
                         severity="warning",
                     )
             case ToolCallEvent(tool=tool_name, args=arguments, tool_call_id=tool_call_id):
+                self._clear_tool_args_progress(tool_call_id)
                 args_dict = arguments if isinstance(arguments, dict) else {"_raw": str(arguments)}
                 # Store args for ToolResult phase lookup.
                 self._tool_call_args[tool_call_id] = args_dict
@@ -1584,6 +1683,7 @@ class EventRenderer:
                     return (False, None)
                 self._append_tool_call(tool_name, args_dict, tool_call_id)
             case ToolResultEvent(tool=tool_name, result=result, tool_call_id=tool_call_id, is_error=is_error, metadata=metadata, output=output):
+                self._clear_tool_args_progress(tool_call_id)
                 stored_args = self._tool_call_args.pop(tool_call_id, {})
                 if self._active_tool_fold.has_call(tool_call_id):
                     display_name = resolve_display_tool_name(tool_name, stored_args)
@@ -1764,11 +1864,13 @@ class EventRenderer:
                 # Cancellation/error paths may emit StepCompleteEvent without ToolResultEvent.
                 # Ensure tool panel state is cleaned up by step id.
                 self._running_tools.pop(step_id, None)
+                self._clear_tool_args_progress(step_id)
             case StopEvent(reason=reason):
                 self._active_llm_retry = None
                 self._flush_assistant_segment()
                 self._commit_active_tool_fold()
                 self._pending_tool_starts.clear()
+                self._clear_tool_args_progress()
                 # Safety net: if any running tool rows remain, stop event means this turn is ending.
                 self._running_tools.clear()
                 self._hidden_thinking_badge_text = ""

{comate_cli-0.8.3 → comate_cli-0.8.4}/comate_cli/terminal_agent/tui_parts/render_panels.py

@@ -823,35 +823,55 @@ class RenderPanelsMixin:
             return ""
         return str(badge_fn() or "").strip()
 
+    def _tool_args_progress_text(self) -> str:
+        progress_fn = getattr(self._renderer, "tool_args_progress_text", None)
+        if not callable(progress_fn):
+            return ""
+        return str(progress_fn() or "").strip()
+
     @staticmethod
     def _fragments_width(frags: list[tuple[str, str]]) -> int:
         return sum(get_cwidth(char) for _, text in frags for char in text)
 
-    def _running_status_suffix_fragments(self) -> list[tuple[str, str]]:
+    def _running_status_suffix_fragments(
+        self,
+        *,
+        max_width: int | None = None,
+    ) -> list[tuple[str, str]]:
         """Build the dim parenthetical status suffix for active work."""
         status_style = "fg:#6B7280"
         badge_style = "fg:#FBBF24 bold"
 
         run_start: float | None = getattr(self, "_run_start_time", None)
+        args_progress = self._tool_args_progress_text()
         badge = self._hidden_thinking_badge_text()
-        if run_start is None and not badge:
+        if run_start is None and not args_progress and not badge:
             return []
 
         parts: list[tuple[str, str]] = [(status_style, "  (")]
-        has_elapsed = run_start is not None
-        if has_elapsed:
+        has_parts = False
+        if run_start is not None:
             elapsed = time.monotonic() - run_start
-            parts.append(
-                (
-                    status_style,
-                    f"{self._format_run_elapsed(elapsed)} {BULLET} ctrl+c to interrupt",
-                )
-            )
+            parts.append((status_style, self._format_run_elapsed(elapsed)))
+            has_parts = True
+        if args_progress:
+            if has_parts:
+                parts.append((status_style, f" {BULLET} "))
+            parts.append((status_style, args_progress))
+            has_parts = True
+        if run_start is not None:
+            if has_parts:
+                parts.append((status_style, f" {BULLET} "))
+            parts.append((status_style, "ctrl+c to interrupt"))
+            has_parts = True
         if badge:
-            if has_elapsed:
+            if has_parts:
                 parts.append((status_style, f" {BULLET} "))
             parts.append((badge_style, badge))
         parts.append((status_style, ")"))
+        if max_width is not None and self._fragments_width(parts) > max_width:
+            clipped = fit_single_line("".join(text for _, text in parts), max_width)
+            return [(status_style, clipped)]
         return parts
 
     def _visible_loading_tip(self) -> str:
@@ -897,7 +917,9 @@ class RenderPanelsMixin:
     ) -> list[tuple[str, str]]:
         """用低噪音 spinner + 流光走字渲染 loading 文案."""
         width = self._terminal_width()
-        status_suffix = self._running_status_suffix_fragments()
+        status_suffix = self._running_status_suffix_fragments(
+            max_width=max(width - 10, 8)
+        )
 
         # glyph(1) + space(1) = 2，再减去运行状态后缀宽度
         phrase_budget = width - 2 - self._fragments_width(status_suffix)
@@ -921,7 +943,10 @@ class RenderPanelsMixin:
         frags: list[tuple[str, str]],
     ) -> list[tuple[str, str]]:
         """Append the running status suffix before any Rich trailing newline."""
-        status_suffix = self._running_status_suffix_fragments()
+        width = self._terminal_width()
+        status_suffix = self._running_status_suffix_fragments(
+            max_width=max(width - 8, 8)
+        )
         if not status_suffix:
             return frags
         # Rich __rich_console__ 末尾会输出一个 "\n" segment，需要先剥掉再追加，
@@ -930,7 +955,17 @@ class RenderPanelsMixin:
         trimmed = list(frags)
         while trimmed and trimmed[-1][1] == "\n":
             tail.insert(0, trimmed.pop())
-        return trimmed + status_suffix + tail
+        base_width = self._fragments_width(trimmed)
+        suffix_width = self._fragments_width(status_suffix)
+        if base_width + suffix_width <= width:
+            return trimmed + status_suffix + tail
+
+        base_budget = max(width - suffix_width, 8)
+        clipped_base = fit_single_line(
+            "".join(text for _, text in trimmed),
+            base_budget,
+        )
+        return [("class:loading", clipped_base)] + status_suffix + tail
 
     def _loading_height(self) -> int:
         if self._should_hide_loading_panel():

{comate_cli-0.8.3 → comate_cli-0.8.4}/docs/cli-rpc-stdio-guide.md

@@ -217,8 +217,10 @@ stdio bridge 明确不承担历史重放职责。需要历史请走 `comate resu
 | `TextEvent` | 文本块最终落地（入历史） | `content`, `structured_output`, `force_display` |
 | `ThinkingDeltaEvent` / `ThinkingEvent` | 思维链增量 / 落地 | `content`/`delta` |
 | `ToolCallStartEvent` | 工具调用开始（transient） | `tool_call_id`, `tool` |
+| `ToolCallArgsProgressEvent` | 工具参数仍在流式生成中的 UI-only 进度（transient） | `tool_call_id`, `tool`, `estimated_tokens` |
 | `ToolCallEvent` | 工具调用入参确定 | `tool`, `args`, `tool_call_id`, `input` |
 | `ToolResultEvent` | 工具返回 | `tool`, `result`, `is_error`, `output` |
+| `StreamDisplayResetEvent` | 内部 transient display reset；stream fallback 前要求客户端清理 partial display state；facade 不公开 | `reason` |
 | `StepStartEvent` / `StepCompleteEvent` | 单步边界 | — |
 | `StopEvent` | 流终止信号 | `reason` |
 | `UsageDeltaEvent` | token 用量 | — |
@@ -228,7 +230,10 @@ stdio bridge 明确不承担历史重放职责。需要历史请走 `comate resu
 **消费建议**：
 - 只关心最终答案：忽略所有 `*DeltaEvent`，只收集 `TextEvent`，以 `StopEvent` 为终止。
 - 想做打字机效果：按 `message_id` 累加 `TextDeltaEvent`，`TextEvent` 到达后用 `force_display` 决定是否覆盖。
-- 工具调用可视化：用 `ToolCallStartEvent` → `ToolCallEvent` → `ToolResultEvent` 的三段式。
+- 工具调用可视化：用 `ToolCallStartEvent` → 可选多个 `ToolCallArgsProgressEvent` → `ToolCallEvent` → `ToolResultEvent`。
+- stream fallback：收到 `StreamDisplayResetEvent(reason="stream_fallback")` 时清理任何 pending tool args progress / pending tool start 展示；不要把它显示为 assistant 内容。
+
+`ToolCallArgsProgressEvent` 与 `StreamDisplayResetEvent` 都不是 assistant message content，也不应作为 transcript 内容持久化。`ToolCallArgsProgressEvent.estimated_tokens` 只用于 UI estimate，不进入 provider usage、context token budget 或 compaction 阈值。`ToolCallArgsProgressEvent` 在 facade 中属于 `include_partial_messages=True` 时才公开的 partial event；`StreamDisplayResetEvent` 是 CLI/RPC internal transient display control，facade adapter 会忽略。
 
 事件被序列化时，dataclass 字段直接展开到 `params`，并补一个 `event_type` 字段。无法被 JSON 序列化的对象会 fallback 为 `str(value)`。
 

{comate_cli-0.8.3 → comate_cli-0.8.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "comate-cli"
-version = "0.8.3"
+version = "0.8.4"
 description = "Comate terminal CLI built on comate-agent-sdk"
 readme = "README.md"
 requires-python = ">=3.11,<3.14"

{comate_cli-0.8.3 → comate_cli-0.8.4}/tests/recap/test_idle_recap_controller.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
 import asyncio
+import gc
 import unittest
 
 from comate_agent_sdk.agent.recap import RecapResult
+from comate_agent_sdk.llm.exceptions import ModelRateLimitError
 from comate_cli.terminal_agent.recap.controller import IdleRecapController, IdleRecapOptions
 
 
@@ -298,6 +300,59 @@ class TestIdleRecapController(unittest.IsolatedAsyncioTestCase):
 
         self.assertEqual(appended, [])
 
+    async def test_cancelled_generation_provider_error_is_observed(self) -> None:
+        appended: list[str] = []
+        started = asyncio.Event()
+        provider_error_raised = asyncio.Event()
+        loop = asyncio.get_running_loop()
+        previous_handler = loop.get_exception_handler()
+        unretrieved_contexts: list[dict[str, object]] = []
+
+        async def generate(parent_runtime):
+            del parent_runtime
+            started.set()
+            try:
+                await asyncio.sleep(60)
+            except asyncio.CancelledError:
+                provider_error_raised.set()
+                raise ModelRateLimitError("rate limited", model="fake:model")
+
+        def _collect_unretrieved(loop, context):  # type: ignore[no-untyped-def]
+            del loop
+            if context.get("message") == "Task exception was never retrieved":
+                unretrieved_contexts.append(dict(context))
+                return
+            if previous_handler is not None:
+                previous_handler(asyncio.get_running_loop(), context)
+
+        controller = IdleRecapController(
+            options=IdleRecapOptions(enabled=True, delay_seconds=0),
+            generate=generate,
+            append=appended.append,
+            is_idle=lambda: True,
+            get_input_text=lambda: "",
+        )
+
+        loop.set_exception_handler(_collect_unretrieved)
+        try:
+            controller.arm_after_stop(
+                stop_seq=1,
+                parent_runtime=object(),
+                stop_reason="completed",
+            )
+            await started.wait()
+            controller.cancel_for_busy()
+            await controller.wait_for_current()
+            await asyncio.wait_for(provider_error_raised.wait(), timeout=3.0)
+            await asyncio.sleep(0)
+            gc.collect()
+            await asyncio.sleep(0)
+        finally:
+            loop.set_exception_handler(previous_handler)
+
+        self.assertEqual(appended, [])
+        self.assertEqual(unretrieved_contexts, [])
+
     async def test_generate_exception_does_not_poison_next_stop(self) -> None:
         appended: list[str] = []
         call_count = 0

{comate_cli-0.8.3 → comate_cli-0.8.4}/tests/test_completion_status_panel.py

@@ -7,6 +7,7 @@ from unittest.mock import patch
 
 from prompt_toolkit.completion import Completion
 from prompt_toolkit.document import Document
+from prompt_toolkit.utils import get_cwidth
 from rich.text import Text
 
 from comate_cli.terminal_agent.event_renderer import ActiveLLMRetrySnapshot
@@ -68,6 +69,7 @@ class _FakeRenderer:
         self.running_tools = False
         self.auto_compacting = False
         self.hidden_thinking_badge = ""
+        self.tool_args_progress = ""
         self.todo_lines: list[str] = []
         self.tool_entries: list[tuple[int, str]] = [(0, "Agent(task) · 1s · +1 tool uses")]
         self.retry_snapshot: ActiveLLMRetrySnapshot | None = None
@@ -93,6 +95,9 @@ class _FakeRenderer:
     def hidden_thinking_badge_text(self) -> str:
         return self.hidden_thinking_badge
 
+    def tool_args_progress_text(self) -> str:
+        return self.tool_args_progress
+
     def active_llm_retry_snapshot(self) -> ActiveLLMRetrySnapshot | None:
         return self.retry_snapshot
 
@@ -436,6 +441,63 @@ class TestCompletionStatusPanel(unittest.TestCase):
             )
         )
 
+    def test_loading_text_appends_tool_args_progress_before_interrupt_hint(self) -> None:
+        tui = _FakeTUI(None, width=120)
+        tui._busy = True
+        tui._run_start_time = 780.0
+        tui._renderer.tool_args_progress = "↓ 1.2k tokens"
+        tui._renderer.hidden_thinking_badge = "ultra thinking"
+
+        with patch(
+            "comate_cli.terminal_agent.tui_parts.render_panels.time.monotonic",
+            return_value=1000.0,
+        ):
+            fragments = tui._loading_text()
+        text = _join_fragments(fragments)
+
+        self.assertIn(
+            "Thinking  (3m 40s • ↓ 1.2k tokens • ctrl+c to interrupt • ultra thinking)",
+            text,
+        )
+
+    def test_loading_text_keeps_status_suffix_on_one_line_when_width_is_tight(self) -> None:
+        tui = _FakeTUI(None, width=40)
+        tui._busy = True
+        tui._run_start_time = 780.0
+        tui._renderer.tool_args_progress = "↓ 12.5k tokens"
+
+        with patch(
+            "comate_cli.terminal_agent.tui_parts.render_panels.time.monotonic",
+            return_value=1000.0,
+        ):
+            fragments = tui._loading_text()
+        text = _join_fragments(fragments)
+
+        self.assertNotIn("\n", text)
+        self.assertLessEqual(get_cwidth(text), 40)
+        self.assertIn("↓ 12.5k tokens", text)
+
+    def test_animator_loading_text_keeps_status_suffix_inside_tight_width(self) -> None:
+        tui = _FakeTUI(None, width=40)
+        tui._busy = True
+        tui._run_start_time = 780.0
+        tui._renderer.tool_args_progress = "↓ 12.5k tokens"
+        tui._animator = SimpleNamespace(
+            is_active=True,
+            renderable=lambda: Text("Generating a very long phrase"),
+        )
+
+        with patch(
+            "comate_cli.terminal_agent.tui_parts.render_panels.time.monotonic",
+            return_value=1000.0,
+        ):
+            fragments = tui._loading_text()
+        text = _join_fragments(fragments)
+
+        self.assertNotIn("\n", text)
+        self.assertLessEqual(get_cwidth(text), 40)
+        self.assertIn("↓ 12.5k tokens", text)
+
     def test_loading_text_appends_hidden_thinking_badge_to_active_animator(self) -> None:
         tui = _FakeTUI(None, width=80)
         tui._busy = True