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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comate-cli
-Version: 0.8.5
+Version: 0.8.6
 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.5 → comate_cli-0.8.6}/comate_cli/terminal_agent/error_display.py

@@ -1,7 +1,8 @@
 """Unified error formatter for terminal agent."""
 from __future__ import annotations
 
-import re
+import ast
+import json
 
 
 def format_error(exc: Exception) -> tuple[str, str, str]:
@@ -42,27 +43,14 @@ def format_error(exc: Exception) -> tuple[str, str, str]:
 
     if exc_type == "ModelProviderError":
         code = getattr(exc, "status_code", None)
-
-        # Context size exceeded (400 with specific body pattern)
-        if code == 400:
-            ctx = _parse_context_size_error(exc_msg)
-            if ctx:
-                return (
-                    f"Request ({ctx[0]} tokens) exceeds context limit ({ctx[1]})",
-                    "Context limit exceeded",
-                    "error",
-                )
-            return f"API error: {exc_msg}", "API error", "error"
-
-        if code == 401:
-            return "Invalid or expired API key", "Auth failed", "error"
-        if code == 403:
-            return "Access denied to this model", "Access denied", "error"
-        if code == 404:
-            return "Model not found or invalid API path", "Model not found", "error"
-        if code and code >= 500:
-            return f"Server error ({code})", "Server error", "warning"
-        return f"API error: {exc_msg}", "API error", "error"
+        detail = _provider_error_detail(exc_msg)
+        status = f" (HTTP {code})" if code is not None else ""
+        message = f"Provider error{status}"
+        if detail:
+            message = f"{message}: {detail}"
+        transient = f"Provider error {code}" if code is not None else "Provider error"
+        severity = "warning" if code is not None and code >= 500 else "error"
+        return message, transient, severity
 
     # Session errors
     if exc_type == "ChatSessionClosedError":
@@ -79,23 +67,34 @@ def format_error(exc: Exception) -> tuple[str, str, str]:
     return f"Error: {exc_msg}", "Error occurred", "error"
 
 
-def _parse_context_size_error(msg: str) -> tuple[str, str] | None:
-    """Extract (prompt_tokens, ctx_limit) from context size error body.
-
-    Matches patterns like 'n_prompt_tokens': 35099, 'n_ctx': 32768
-    or 'request (35099 tokens) exceeds the available context size (32768 tokens)'.
-    """
-    m = re.search(r"n_prompt_tokens['\"]?:\s*(\d+)", msg)
-    n = re.search(r"n_ctx['\"]?:\s*(\d+)", msg)
-    if m and n:
-        return m.group(1), n.group(1)
-
-    m2 = re.search(r"request\s*\((\d+)\s*tokens?\)", msg, re.IGNORECASE)
-    n2 = re.search(r"context\s*size\s*\((\d+)\s*tokens?\)", msg, re.IGNORECASE)
-    if m2 and n2:
-        return m2.group(1), n2.group(1)
-
-    if "exceed_context_size_error" in msg:
-        return None  # Type matches but can't parse numbers — fall through to generic 400
-
+def _provider_error_detail(msg: str) -> str:
+    """Return provider-supplied detail, unwrapped from common SDK envelopes."""
+    text = str(msg or "").strip()
+    if not text:
+        return ""
+
+    candidates = [text]
+    if " - " in text:
+        candidates.append(text.split(" - ", 1)[1].strip())
+
+    for candidate in candidates:
+        detail = _error_message_from_mapping_text(candidate)
+        if detail:
+            return detail
+    return text
+
+
+def _error_message_from_mapping_text(text: str) -> str | None:
+    for parser in (json.loads, ast.literal_eval):
+        try:
+            value = parser(text)
+        except (ValueError, SyntaxError, TypeError):
+            continue
+        if not isinstance(value, dict):
+            continue
+        error = value.get("error")
+        if isinstance(error, dict):
+            message = error.get("message")
+            if isinstance(message, str) and message.strip():
+                return message.strip()
     return None

{comate_cli-0.8.5 → comate_cli-0.8.6}/comate_cli/terminal_agent/event_renderer.py

@@ -120,10 +120,10 @@ def _format_duration(seconds: float) -> str:
     minutes = int(elapsed // 60)
     remaining_seconds = int(elapsed % 60)
     if minutes < 60:
-        return f"{minutes}m{remaining_seconds:02d}s"
+        return f"{minutes}m {remaining_seconds:02d}s"
     hours = minutes // 60
     remaining_minutes = minutes % 60
-    return f"{hours}h{remaining_minutes:02d}m"
+    return f"{hours}h {remaining_minutes:02d}m"
 
 
 def _format_tokens(token_count: int) -> str:

{comate_cli-0.8.5 → comate_cli-0.8.6}/comate_cli/terminal_agent/status_bar.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import logging
+import os
 import subprocess
 import time
 from pathlib import Path
@@ -22,11 +24,17 @@ class GitDiffStats(NamedTuple):
     removed: int
 
 
+class _GitCommandResult(NamedTuple):
+    returncode: int
+    stdout: str
+
+
 class StatusBar:
     _DEFAULT_TERMINAL_WIDTH: int = 100
     _MIN_TERMINAL_WIDTH: int = 40
     _GIT_DIFF_CACHE_SECONDS: float = 5.0
     _GIT_CMD_TIMEOUT_SECONDS: float = 0.2
+    _GIT_FAILURE_BACKOFF_SECONDS: float = 30.0
     _SEPARATOR: str = " \u00b7 "  # " · "
 
     # 分组颜色
@@ -46,6 +54,7 @@ class StatusBar:
         self._context_left_pct: float = 100.0
         self._git_diff_stats: GitDiffStats | None = None
         self._git_diff_cache_time: float = 0.0
+        self._git_failure_backoff_until: float = 0.0
         self._transient_message: str | None = None
         self._transient_severity: str = "info"
         self._transient_until: float | None = None
@@ -129,43 +138,76 @@ class StatusBar:
         normalized = str(mode).strip().lower()
         self._mode = normalized or "act"
 
-    @staticmethod
-    def _resolve_git_branch() -> str:
+    def _git_backoff_active(self) -> bool:
+        return time.monotonic() < self._git_failure_backoff_until
+
+    def _record_git_failure_backoff(self, *, reason: str, args: tuple[str, ...]) -> None:
+        self._git_failure_backoff_until = (
+            time.monotonic() + self._GIT_FAILURE_BACKOFF_SECONDS
+        )
+        logger.debug(
+            "status bar git refresh disabled temporarily: reason=%s args=%s",
+            reason,
+            " ".join(args),
+        )
+
+    async def _run_git_command(self, *args: str) -> _GitCommandResult | None:
+        if self._git_backoff_active():
+            return None
+
+        env = os.environ.copy()
+        env.setdefault("GIT_TERMINAL_PROMPT", "0")
+        env.setdefault("GIT_OPTIONAL_LOCKS", "0")
+        env.setdefault("GCM_INTERACTIVE", "Never")
+        proc: asyncio.subprocess.Process | None = None
         try:
-            completed = subprocess.run(
-                ["git", "branch", "--show-current"],
-                check=False,
-                capture_output=True,
-                text=True,
-                encoding="utf-8",
-                timeout=StatusBar._GIT_CMD_TIMEOUT_SECONDS,
+            proc = await asyncio.create_subprocess_exec(
+                "git",
+                *args,
+                stdin=subprocess.DEVNULL,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=subprocess.DEVNULL,
+                env=env,
             )
-        except subprocess.TimeoutExpired:
-            return "N/A"
+            stdout, _stderr = await asyncio.wait_for(
+                proc.communicate(),
+                timeout=self._GIT_CMD_TIMEOUT_SECONDS,
+            )
+        except asyncio.TimeoutError:
+            self._record_git_failure_backoff(reason="timeout", args=args)
+            if proc is not None and proc.returncode is None:
+                with contextlib.suppress(ProcessLookupError):
+                    proc.kill()
+                with contextlib.suppress(Exception):
+                    await asyncio.wait_for(proc.wait(), timeout=0.2)
+            return None
         except Exception:
-            return "N/A"
+            self._record_git_failure_backoff(reason="error", args=args)
+            if proc is not None and proc.returncode is None:
+                with contextlib.suppress(ProcessLookupError):
+                    proc.kill()
+                with contextlib.suppress(Exception):
+                    await asyncio.wait_for(proc.wait(), timeout=0.2)
+            return None
+
+        return _GitCommandResult(
+            returncode=int(proc.returncode or 0),
+            stdout=stdout.decode("utf-8", errors="replace"),
+        )
 
+    async def _resolve_git_branch(self) -> str:
+        completed = await self._run_git_command("branch", "--show-current")
+        if completed is None:
+            return "N/A"
         if completed.returncode != 0:
             return "N/A"
         branch = completed.stdout.strip()
         return branch or "N/A"
 
-    @staticmethod
-    def _resolve_git_diff_stats() -> GitDiffStats | None:
-        try:
-            completed = subprocess.run(
-                ["git", "diff", "--shortstat", "--no-color"],
-                check=False,
-                capture_output=True,
-                text=True,
-                encoding="utf-8",
-                timeout=StatusBar._GIT_CMD_TIMEOUT_SECONDS,
-            )
-        except subprocess.TimeoutExpired:
-            return None
-        except Exception:
+    async def _resolve_git_diff_stats(self) -> GitDiffStats | None:
+        completed = await self._run_git_command("diff", "--shortstat", "--no-color")
+        if completed is None:
             return None
-
         if completed.returncode != 0:
             return None
 
@@ -185,16 +227,6 @@ class StatusBar:
 
         return GitDiffStats(added=added, removed=removed)
 
-    def _ensure_git_diff_stats(self) -> None:
-        now = time.monotonic()
-        if (
-            self._git_diff_stats is not None
-            and now - self._git_diff_cache_time < self._GIT_DIFF_CACHE_SECONDS
-        ):
-            return
-        self._git_diff_stats = self._resolve_git_diff_stats()
-        self._git_diff_cache_time = now
-
     def _resolve_llm_level(self) -> str:
         agent = getattr(self._session, "_agent", None)
         level = getattr(agent, "level", None)
@@ -294,23 +326,37 @@ class StatusBar:
         except Exception:
             pass
 
-        branch_task = asyncio.to_thread(self._resolve_git_branch)
+        cfg = self._config
+        branch_task = (
+            asyncio.create_task(self._resolve_git_branch())
+            if cfg.show_git_branch
+            else None
+        )
         now = time.monotonic()
         diff_is_stale = (
-            self._git_diff_stats is None
-            or now - self._git_diff_cache_time >= self._GIT_DIFF_CACHE_SECONDS
+            cfg.show_git_diff
+            and (
+                self._git_diff_stats is None
+                or now - self._git_diff_cache_time >= self._GIT_DIFF_CACHE_SECONDS
+            )
         )
-        if diff_is_stale:
-            diff_task = asyncio.to_thread(self._resolve_git_diff_stats)
+        diff_task = (
+            asyncio.create_task(self._resolve_git_diff_stats())
+            if diff_is_stale
+            else None
+        )
+        if branch_task is not None and diff_task is not None:
             branch, diff_stats = await asyncio.gather(branch_task, diff_task)
+            self._git_branch = branch
             self._git_diff_stats = diff_stats
             self._git_diff_cache_time = time.monotonic()
-        else:
-            branch = await branch_task
-        self._git_branch = branch
+        elif branch_task is not None:
+            self._git_branch = await branch_task
+        elif diff_task is not None:
+            self._git_diff_stats = await diff_task
+            self._git_diff_cache_time = time.monotonic()
 
         # Refresh token usage cache if any token-related items are enabled.
-        cfg = self._config
         wants_token_counts = cfg.show_token_usage or cfg.show_token_input or cfg.show_token_output
         wants_cost = cfg.show_session_cost
         if wants_cost:

{comate_cli-0.8.5 → comate_cli-0.8.6}/comate_cli/terminal_agent/tool_view.py

@@ -333,10 +333,10 @@ def _format_duration(seconds: float) -> str:
     minutes = int(elapsed // 60)
     remaining_seconds = int(elapsed % 60)
     if minutes < 60:
-        return f"{minutes}m{remaining_seconds:02d}s"
+        return f"{minutes}m {remaining_seconds:02d}s"
     hours = minutes // 60
     remaining_minutes = minutes % 60
-    return f"{hours}h{remaining_minutes:02d}m"
+    return f"{hours}h {remaining_minutes:02d}m"
 
 
 def _sweep_gradient_text(content: str, frame: int) -> Text:

{comate_cli-0.8.5 → comate_cli-0.8.6}/comate_cli/terminal_agent/tui.py

@@ -186,6 +186,7 @@ class TerminalAgentTUI(
     RenderPanelsMixin,
 ):
     _NON_BLOCKING_UI_MODES = frozenset({UIMode.NORMAL})
+    _STATUS_REFRESH_TIMEOUT_SECONDS = 0.3
 
     def __init__(
         self,
@@ -206,6 +207,7 @@ class TerminalAgentTUI(
             set_tool_result_registry(self._tool_result_registry)
         self._task_poll_next_at = time.monotonic() + _TASK_POLL_INTERVAL_S
         self._task_poll_last_list_id: str | None = None
+        self._status_refresh_timeout_s = self._STATUS_REFRESH_TIMEOUT_SECONDS
 
         self._bind_team_message_callback(self._session)
 
@@ -1497,7 +1499,19 @@ class TerminalAgentTUI(
 
     async def _refresh_status_bar_safely(self, *, reason: str) -> None:
         try:
-            await self._status_bar.refresh()
+            timeout_s = max(
+                0.01,
+                float(getattr(self, "_status_refresh_timeout_s", 0.3)),
+            )
+            await asyncio.wait_for(
+                self._status_bar.refresh(),
+                timeout=timeout_s,
+            )
+        except asyncio.TimeoutError:
+            logger.debug(
+                "TUI status bar refresh timed out during %s; continuing event pump",
+                reason,
+            )
         except Exception:
             logger.warning(
                 "TUI status bar refresh failed during %s; continuing event pump",

{comate_cli-0.8.5 → comate_cli-0.8.6}/pyproject.toml

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

{comate_cli-0.8.5 → comate_cli-0.8.6}/tests/test_format_error.py

@@ -26,38 +26,86 @@ class TestFormatError(unittest.TestCase):
     def test_provider_401(self):
         from comate_cli.terminal_agent.error_display import format_error
 
-        exc = self._make_exc("ModelProviderError", status_code=401)
+        exc = self._make_exc(
+            "ModelProviderError",
+            "provider says the API key is expired",
+            status_code=401,
+        )
         msg, transient, severity = format_error(exc)
         assert severity == "error"
-        assert "API key" in msg
-        assert transient == "Auth failed"
+        assert msg == "Provider error (HTTP 401): provider says the API key is expired"
+        assert transient == "Provider error 401"
 
     def test_provider_403(self):
         from comate_cli.terminal_agent.error_display import format_error
 
-        exc = self._make_exc("ModelProviderError", status_code=403)
+        exc = self._make_exc(
+            "ModelProviderError",
+            "预扣费额度失败, 用户剩余额度: ¥0.000015, 需要预扣费额度: ¥0.000555",
+            status_code=403,
+        )
         msg, transient, severity = format_error(exc)
         assert severity == "error"
-        assert "Access denied" in msg
-        assert transient == "Access denied"
+        assert "预扣费额度失败" in msg
+        assert "Access denied" not in msg
+        assert transient == "Provider error 403"
 
     def test_provider_404(self):
         from comate_cli.terminal_agent.error_display import format_error
 
-        exc = self._make_exc("ModelProviderError", status_code=404)
+        exc = self._make_exc(
+            "ModelProviderError",
+            "provider says the model route does not exist",
+            status_code=404,
+        )
         msg, transient, severity = format_error(exc)
         assert severity == "error"
-        assert "not found" in msg.lower()
-        assert transient == "Model not found"
+        assert "provider says the model route does not exist" in msg
+        assert transient == "Provider error 404"
 
     def test_provider_5xx(self):
         from comate_cli.terminal_agent.error_display import format_error
 
-        exc = self._make_exc("ModelProviderError", status_code=502)
+        exc = self._make_exc(
+            "ModelProviderError",
+            "No available channel for model MiniMax-M2.7 under group svip",
+            status_code=503,
+        )
         msg, transient, severity = format_error(exc)
         assert severity == "warning"
-        assert "502" in msg
-        assert transient == "Server error"
+        assert "No available channel for model MiniMax-M2.7" in msg
+        assert "Server error" not in msg
+        assert transient == "Provider error 503"
+
+    def test_provider_openai_wrapped_error_message(self):
+        from comate_cli.terminal_agent.error_display import format_error
+
+        body = (
+            "Error code: 403 - {'error': {'message': '预扣费额度失败, "
+            "用户剩余额度: ¥0.000015', 'type': 'new_api_error', "
+            "'code': 'insufficient_user_quota'}}"
+        )
+        exc = self._make_exc("ModelProviderError", body, status_code=403)
+        msg, transient, severity = format_error(exc)
+        assert severity == "error"
+        assert msg == "Provider error (HTTP 403): 预扣费额度失败, 用户剩余额度: ¥0.000015"
+        assert transient == "Provider error 403"
+
+    def test_provider_json_error_message(self):
+        from comate_cli.terminal_agent.error_display import format_error
+
+        body = (
+            '{"error":{"type":"new_api_error","message":"预扣费额度失败, '
+            '用户剩余额度: ¥0.000015, 需要预扣费额度: ¥0.001664"},"type":"error"}'
+        )
+        exc = self._make_exc("ModelProviderError", body, status_code=403)
+        msg, transient, severity = format_error(exc)
+        assert severity == "error"
+        assert msg == (
+            "Provider error (HTTP 403): 预扣费额度失败, "
+            "用户剩余额度: ¥0.000015, 需要预扣费额度: ¥0.001664"
+        )
+        assert transient == "Provider error 403"
 
     def test_provider_stream_protocol_error(self):
         from comate_agent_sdk.llm.exceptions import ProviderStreamProtocolError
@@ -122,9 +170,11 @@ class TestFormatError(unittest.TestCase):
         exc = self._make_exc("ModelProviderError", body, status_code=400)
         msg, transient, severity = format_error(exc)
         assert severity == "error"
-        assert "35099" in msg
-        assert "32768" in msg
-        assert transient == "Context limit exceeded"
+        assert msg == (
+            "Provider error (HTTP 400): request (35099 tokens) exceeds the "
+            "available context size (32768 tokens)"
+        )
+        assert transient == "Provider error 400"
 
     def test_context_size_type_without_parseable_numbers(self):
         from comate_cli.terminal_agent.error_display import format_error
@@ -136,7 +186,8 @@ class TestFormatError(unittest.TestCase):
         )
         msg, transient, severity = format_error(exc)
         assert severity == "error"
-        assert transient == "API error"  # Falls through to generic 400
+        assert "exceed_context_size_error without parseable numbers" in msg
+        assert transient == "Provider error 400"
 
     def test_provider_400_generic(self):
         from comate_cli.terminal_agent.error_display import format_error
@@ -144,8 +195,8 @@ class TestFormatError(unittest.TestCase):
         exc = self._make_exc("ModelProviderError", "bad request", status_code=400)
         msg, transient, severity = format_error(exc)
         assert severity == "error"
-        assert "API error" in msg
-        assert transient == "API error"
+        assert msg == "Provider error (HTTP 400): bad request"
+        assert transient == "Provider error 400"
 
     def test_session_closed(self):
         from comate_cli.terminal_agent.error_display import format_error