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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comate-cli
-Version: 0.8.3
+Version: 0.8.5
 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
@@ -18,6 +18,7 @@ Requires-Dist: charset-normalizer==3.4.7
 Requires-Dist: comate-agent-sdk<0.9.20,>=0.8.0a1
 Requires-Dist: concurrent-log-handler>=0.9.25
 Requires-Dist: curl-cffi==0.13.0
+Requires-Dist: httpx<0.29.0,>=0.28.1
 Requires-Dist: packaging>=21.0
 Requires-Dist: pillow==12.2.0
 Requires-Dist: prompt-toolkit>=3.0

{comate_cli-0.8.3 → comate_cli-0.8.5}/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.5}/comate_cli/terminal_agent/tui.py

@@ -1491,10 +1491,20 @@ class TerminalAgentTUI(
         self._interrupt_requested_at = None
         self._allow_latest_recall_on_interrupt = False
         self._set_busy(False)
-        await self._status_bar.refresh()
+        await self._refresh_status_bar_safely(reason="error-cleanup")
         self._renderer.clear_auto_compacting()
         self._refresh_layers()
 
+    async def _refresh_status_bar_safely(self, *, reason: str) -> None:
+        try:
+            await self._status_bar.refresh()
+        except Exception:
+            logger.warning(
+                "TUI status bar refresh failed during %s; continuing event pump",
+                reason,
+                exc_info=True,
+            )
+
     async def _submit_user_message(
         self,
         text: str,
@@ -1646,7 +1656,7 @@ class TerminalAgentTUI(
                         f"✻ Running scheduled task ({self._format_scheduled_fire_time()})"
                     )
                 if isinstance(event, GoalUpdatedEvent):
-                    await self._status_bar.refresh()
+                    await self._refresh_status_bar_safely(reason="goal-update")
                     self._refresh_layers()
                     self._invalidate()
                     continue
@@ -1730,7 +1740,7 @@ class TerminalAgentTUI(
                         self._append_run_elapsed_to_history(stop_reason=stop_reason)
                     self._run_start_time = None
                     self._set_busy(False)
-                    await self._status_bar.refresh()
+                    await self._refresh_status_bar_safely(reason="stop-event")
 
                     if waiting_for_input:
                         self._waiting_for_input = True

{comate_cli-0.8.3 → comate_cli-0.8.5}/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.5}/comate_cli/terminal_agent/update_check.py

@@ -110,47 +110,12 @@ async def check_update(
     profiler: Any | None = None,
 ) -> UpdateInfo | None:
     """异步检查 comate-cli 是否有新版本，返回结构化版本信息或 None。"""
-    if profiler is not None:
-        profiler.mark("thread.await.start")
-    try:
-        return await asyncio.to_thread(
-            check_update_blocking,
-            package=package,
-            release_notes_url=release_notes_url,
-            log=log,
-            profiler=profiler,
-        )
-    except asyncio.CancelledError:
-        if profiler is not None:
-            profiler.mark("thread.await.cancelled")
-        raise
-    except Exception:
-        if profiler is not None:
-            profiler.mark("thread.await.failed")
-        active_logger = log or logger
-        active_logger.debug("update check worker failed", exc_info=True)
-        return None
-    finally:
-        if profiler is not None:
-            profiler.mark("thread.await.done")
-
-
-def check_update_blocking(
-    *,
-    package: str = PACKAGE_NAME,
-    release_notes_url: str = RELEASE_NOTES_URL,
-    log: logging.Logger | None = None,
-    profiler: Any | None = None,
-) -> UpdateInfo | None:
-    """同步执行版本检查；由 async wrapper 放入 worker thread，避免阻塞 TUI event loop。"""
     active_logger = log or logger
+    source_label = "unknown"
     try:
         if profiler is not None:
-            profiler.mark("thread.run.start")
-
+            profiler.mark("current_version.start")
         try:
-            if profiler is not None:
-                profiler.mark("current_version.start")
             current = importlib.metadata.version(package)
         except importlib.metadata.PackageNotFoundError:
             return None
@@ -170,74 +135,87 @@ def check_update_blocking(
             profiler.mark("locale.done")
 
         try:
-            if profiler is not None:
-                profiler.mark("httpx_import.start")
-            import httpx
-            if profiler is not None:
-                profiler.mark("httpx_import.done")
-
-            trust_env = _update_check_trust_env()
-            if profiler is not None:
-                profiler.mark(
-                    "http_client.trust_env.enabled"
-                    if trust_env
-                    else "http_client.trust_env.disabled"
-                )
-                profiler.mark("http_client.construct.start")
-            client_kwargs: dict[str, Any] = {"timeout": 3.0, "trust_env": trust_env}
-            if not trust_env:
-                # 默认路径用 certifi context 绕开 Windows 证书库枚举（见 _get_update_check_ssl_context）。
-                # trust_env 逃生通道（企业代理/自签根证书）保持 httpx 默认 verify=True 行为不变。
-                ssl_context = _get_update_check_ssl_context()
-                if ssl_context is not None:
-                    client_kwargs["verify"] = ssl_context
-            client = httpx.Client(**client_kwargs)
-            if profiler is not None:
-                profiler.mark("http_client.construct.done")
-
-            if profiler is not None:
-                profiler.mark("http_client.enter.start")
-            with client:
-                if profiler is not None:
-                    profiler.mark("http_client.enter.done")
-                    profiler.mark("http_get.start")
-                resp = client.get(url)
-                resp.raise_for_status()
-                latest = resp.json()["info"]["version"]
-                if profiler is not None:
-                    profiler.mark("http_get.done")
+            latest = await _fetch_latest_version_async(
+                url,
+                trust_env=_update_check_trust_env(),
+                profiler=profiler,
+            )
+        except asyncio.CancelledError:
+            raise
         except Exception:
             if profiler is not None:
                 profiler.mark("http_client.failed")
-            active_logger.debug(f"update check failed (source={source_label})", exc_info=True)
-            return None
+            raise
+    except asyncio.CancelledError:
+        raise
+    except Exception:
+        active_logger.debug(f"update check failed (source={source_label})", exc_info=True)
+        return None
 
-        try:
-            if profiler is not None:
-                profiler.mark("version_compare.start")
-            from packaging.version import Version
-
-            if Version(latest) > Version(current):
-                return UpdateInfo(
-                    package=package,
-                    current_version=current,
-                    latest_version=latest,
-                    release_notes_url=release_notes_url,
-                )
-        except Exception:
-            active_logger.debug(
-                "update comparison failed (current=%s, latest=%s)",
-                current,
-                latest,
-                exc_info=True,
+    try:
+        if profiler is not None:
+            profiler.mark("version_compare.start")
+        from packaging.version import Version
+
+        if Version(latest) > Version(current):
+            return UpdateInfo(
+                package=package,
+                current_version=current,
+                latest_version=latest,
+                release_notes_url=release_notes_url,
             )
-        finally:
-            if profiler is not None:
-                profiler.mark("version_compare.done")
-        return None
+    except Exception:
+        active_logger.debug(
+            "update comparison failed (current=%s, latest=%s)",
+            current,
+            latest,
+            exc_info=True,
+        )
     finally:
         if profiler is not None:
-            profiler.mark("thread.run.done")
+            profiler.mark("version_compare.done")
+    return None
+
+
+async def _fetch_latest_version_async(
+    url: str,
+    *,
+    trust_env: bool,
+    profiler: Any | None,
+) -> str:
+    if profiler is not None:
+        profiler.mark("httpx_import.start")
+    import httpx
+    if profiler is not None:
+        profiler.mark("httpx_import.done")
+        profiler.mark(
+            "http_client.trust_env.enabled"
+            if trust_env
+            else "http_client.trust_env.disabled"
+        )
+        profiler.mark("http_client.construct.start")
+
+    client_kwargs: dict[str, Any] = {"timeout": 3.0, "trust_env": trust_env}
+    if not trust_env:
+        ssl_context = _get_update_check_ssl_context()
+        if ssl_context is not None:
+            client_kwargs["verify"] = ssl_context
+
+    client = httpx.AsyncClient(**client_kwargs)
+    if profiler is not None:
+        profiler.mark("http_client.construct.done")
+        profiler.mark("http_client.enter.start")
+
+    async with client:
+        if profiler is not None:
+            profiler.mark("http_client.enter.done")
+            profiler.mark("http_get.start")
+        resp = await client.get(url)
+        resp.raise_for_status()
+        latest = resp.json()["info"]["version"]
+        if profiler is not None:
+            profiler.mark("http_get.done")
+        return str(latest)
 
 
 def format_update_hint(info: UpdateInfo) -> str:

{comate_cli-0.8.3 → comate_cli-0.8.5}/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.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "comate-cli"
-version = "0.8.3"
+version = "0.8.5"
 description = "Comate terminal CLI built on comate-agent-sdk"
 readme = "README.md"
 requires-python = ">=3.11,<3.14"
@@ -31,6 +31,7 @@ dependencies = [
     "curl-cffi==0.13.0",
     "requests==2.32.5",
     "concurrent-log-handler>=0.9.25",
+    "httpx>=0.28.1,<0.29.0",
 ]
 
 [project.urls]