virtuai-cli 0.7.3__tar.gz → 0.7.6__tar.gz

{virtuai_cli-0.7.3 → virtuai_cli-0.7.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: virtuai-cli
-Version: 0.7.3
+Version: 0.7.6
 Summary: Run VirtuAI deep agents on your local machine
 Author-email: uCloudStore <lmoreno@ucloudstore.com>
 License: Proprietary

{virtuai_cli-0.7.3 → virtuai_cli-0.7.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "virtuai-cli"
-version = "0.7.3"
+version = "0.7.6"
 description = "Run VirtuAI deep agents on your local machine"
 readme = "README.md"
 requires-python = ">=3.11"

{virtuai_cli-0.7.3 → virtuai_cli-0.7.6}/src/virtuai_cli/__init__.py

@@ -1,2 +1,2 @@
 """VirtuAI local CLI."""
-__version__ = "0.7.3"
+__version__ = "0.7.6"

{virtuai_cli-0.7.3 → virtuai_cli-0.7.6}/src/virtuai_cli/chat/tui.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import json
 from pathlib import Path
 from typing import Optional
 
@@ -109,6 +110,12 @@ class ChatApp(App):
         self._runner_task: Optional[asyncio.Task] = None
         self._current_turn: Optional[AssistantTurn] = None
         self._select_mode: bool = False
+        # Persistent state shown in the status bar — refreshed by a periodic
+        # tick so the user always sees current connection + working status.
+        self._connection_state: str = "connecting"   # connecting | live | reconnecting | offline
+        self._streaming: bool = False
+        self._status_message: str = ""
+        self._spinner_idx: int = 0
 
     # ── Layout ────────────────────────────────────────────────────────────
     def compose(self) -> ComposeResult:
@@ -125,39 +132,102 @@ class ChatApp(App):
         yield ChatInput(id="input")
         yield Footer()
 
+    _SPINNER = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
+
     def _initial_status(self) -> str:
+        # Composed once for the first paint; the tick timer takes over after mount.
+        return self._compose_status()
+
+    def _compose_status(self) -> str:
         model = f" · {self.current_model_id}" if self.current_model_id else ""
-        return f"{self.workspace_name} · {self.agent_name}{model} · connecting…"
+
+        conn = self._connection_state
+        if conn == "live":
+            conn_part = "[green]● live[/green]"
+        elif conn == "offline":
+            conn_part = "[red]○ offline[/red]"
+        elif conn == "reconnecting":
+            spin = self._SPINNER[self._spinner_idx % len(self._SPINNER)]
+            conn_part = f"[yellow]{spin} reconnecting[/yellow]"
+        else:  # connecting
+            spin = self._SPINNER[self._spinner_idx % len(self._SPINNER)]
+            conn_part = f"[yellow]{spin} connecting[/yellow]"
+
+        if self._streaming:
+            spin = self._SPINNER[self._spinner_idx % len(self._SPINNER)]
+            work_part = f" · [cyan]{spin} working[/cyan]"
+        else:
+            work_part = ""
+
+        msg_part = f" · {self._status_message}" if self._status_message else ""
+        return (
+            f"{self.workspace_name} · {self.agent_name}{model} · "
+            f"{conn_part}{work_part}{msg_part}"
+        )
 
     # ── Mount: start the WS runner in the background ──────────────────────
     async def on_mount(self) -> None:
         self.title = "VirtuAI"
         self.sub_title = f"{self.agent_name} · {self.workspace_name}"
         self.query_one(ChatInput).focus()
+        # 100 ms tick to animate the spinner whenever connection or stream
+        # state needs a moving indicator.
+        self.set_interval(0.1, self._tick_status)
         self._runner_task = asyncio.create_task(self._run_ws())
 
+    def _tick_status(self) -> None:
+        # Only repaint when something is actually animating — otherwise we'd
+        # force a Textual reflow 10x/sec across the whole scrollback, which
+        # makes long conversations laggy.
+        moving = self._streaming or self._connection_state in ("connecting", "reconnecting")
+        if moving:
+            self._spinner_idx = (self._spinner_idx + 1) % len(self._SPINNER)
+            self._refresh_status_bar()
+
+    def _refresh_status_bar(self) -> None:
+        try:
+            self.query_one("#status", Static).update(self._compose_status())
+        except Exception:
+            pass
+
     async def _run_ws(self) -> None:
         def on_status(level: str, msg: str) -> None:
-            # Runner runs on the same event loop, so call directly.
-            self._set_status(msg)
+            low = msg.lower()
+            if low.startswith("connected"):
+                self._connection_state = "live"
+                self._status_message = ""
+            elif low.startswith("connecting"):
+                self._connection_state = "connecting"
+                self._status_message = ""
+            elif low.startswith("disconnected") or "retrying" in low:
+                self._connection_state = "reconnecting"
+                # Keep the runner's "Retrying in Ns…" message as context.
+                self._status_message = msg
+            elif level == "error":
+                self._connection_state = "offline"
+                self._status_message = msg
+            elif level == "exec":
+                # ephemeral one-line preview of what the agent is running
+                self._status_message = f"exec: {msg}"
+            else:
+                self._status_message = msg
+            self._refresh_status_bar()
 
         try:
             await ws_runner.run_forever(self.server_url, self.token, self.workdir, on_status=on_status)
         except asyncio.CancelledError:
+            self._connection_state = "offline"
+            self._refresh_status_bar()
             raise
         except Exception as exc:
-            self._set_status(f"runner error: {exc}")
+            self._connection_state = "offline"
+            self._status_message = f"runner error: {exc}"
+            self._refresh_status_bar()
 
     def _set_status(self, text: str) -> None:
-        # The status widget may have been torn down during app shutdown —
-        # swallow the lookup error so we don't surface a NoMatches on exit.
-        model = f" · {self.current_model_id}" if self.current_model_id else ""
-        try:
-            self.query_one("#status", Static).update(
-                f"{self.workspace_name} · {self.agent_name}{model} · {text}"
-            )
-        except Exception:
-            pass
+        """Set an ephemeral status message — connection/streaming glyphs stay."""
+        self._status_message = text
+        self._refresh_status_bar()
 
     # ── Slash hints / autocomplete ────────────────────────────────────────
     def _matching_commands(self, prefix: str) -> list[tuple[str, str]]:
@@ -535,6 +605,8 @@ class ChatApp(App):
 
     # ── SSE stream → widget mutations ─────────────────────────────────────
     async def _stream_response(self, message: str, turn: AssistantTurn) -> None:
+        self._streaming = True
+        self._refresh_status_bar()
         try:
             async for event in stream_chat(
                 self.server_url,
@@ -556,6 +628,8 @@ class ChatApp(App):
             except Exception:
                 pass
         finally:
+            self._streaming = False
+            self._refresh_status_bar()
             try:
                 await turn.mark_final()
             except Exception:
@@ -585,22 +659,42 @@ class ChatApp(App):
             if content:
                 await turn.append_token(content)
         elif etype == "tool_start":
-            await turn.start_tool(
-                event.get("id", ""),
-                event.get("name", "tool"),
-                event.get("input", ""),
-                display=event.get("display", ""),
-                file_content=event.get("file_content"),
-                file_content_before=event.get("file_content_before"),
-                read_offset=event.get("read_offset"),
-                read_limit=event.get("read_limit"),
-            )
+            # Skip tool-call cards whose input is empty — those are the visual
+            # debris of a tool call that was truncated mid-JSON when the model
+            # hit max_tokens. The card has no useful info and clutters the
+            # screen; the accompanying `truncated` event already tells the
+            # story. Empty == "", "{}", or anything that strips to nothing.
+            input_val = event.get("input", "")
+            input_str = input_val if isinstance(input_val, str) else json.dumps(input_val, default=str)
+            if input_str.strip() in ("", "{}", "[]"):
+                turn._tools[event.get("id", "")] = None  # type: ignore[assignment]
+            else:
+                await turn.start_tool(
+                    event.get("id", ""),
+                    event.get("name", "tool"),
+                    input_val,
+                    display=event.get("display", ""),
+                    file_content=event.get("file_content"),
+                    file_content_before=event.get("file_content_before"),
+                    read_offset=event.get("read_offset"),
+                    read_limit=event.get("read_limit"),
+                )
         elif etype == "tool_end":
-            turn.finish_tool(event.get("id", ""), event.get("output_preview"), errored=False)
+            # If we skipped the matching tool_start (empty input), don't try
+            # to finalize a card that doesn't exist.
+            if turn._tools.get(event.get("id", "")) is not None:
+                turn.finish_tool(event.get("id", ""), event.get("output_preview"), errored=False)
         elif etype == "todos":
             await turn.set_todos(event.get("items", []))
         elif etype == "truncated":
-            await turn.append_token("\n\n*[response truncated]*")
+            # Dedupe: when max_tokens hits repeatedly on multiple model passes
+            # in a single turn (e.g. while a big tool-call arg gets retried),
+            # we don't want a wall of `[response truncated]` markers.
+            if not turn._truncated_shown:
+                await turn.append_token(
+                    "\n\n*[response truncated — try raising the agent's max_tokens]*"
+                )
+                turn._truncated_shown = True
         elif etype == "error":
             msg = event.get("error") or event.get("message") or "unknown error"
             await turn.append_token(f"\n\n*[error: {msg}]*")

{virtuai_cli-0.7.3 → virtuai_cli-0.7.6}/src/virtuai_cli/chat/widgets.py

@@ -200,19 +200,52 @@ class UserBubble(Static):
 
 
 class TextSegment(Static):
-    """A streaming markdown segment of assistant text."""
+    """A streaming markdown segment of assistant text.
+
+    Renders are throttled to ~20 Hz: the markdown AST is rebuilt from the
+    full buffer on every paint (Rich/mistletoe parse from scratch), so
+    rendering once per token on a long response is O(n²) and dominates CPU.
+    With throttling, bursts of tokens coalesce into a single render and any
+    final pending render is flushed via mark_final()/flush().
+    """
 
     DEFAULT_CSS = """
     TextSegment { margin: 0 0 0 2; }
     """
 
+    _RENDER_INTERVAL = 0.05  # seconds (= 20 fps)
+
     def __init__(self) -> None:
         super().__init__("")
         self._buf = ""
+        self._last_render_t: float = 0.0
+        self._render_pending: bool = False
 
     def append(self, chunk: str) -> None:
         self._buf += chunk
-        self.update(Markdown(normalize_artifacts(self._buf)))
+        if self._render_pending:
+            # A flush is already scheduled and will pick up the new content.
+            return
+        now = time.monotonic()
+        elapsed = now - self._last_render_t
+        if elapsed >= self._RENDER_INTERVAL:
+            self._flush()
+        else:
+            self._render_pending = True
+            self.set_timer(self._RENDER_INTERVAL - elapsed, self._flush)
+
+    def flush(self) -> None:
+        """Force a render now — used to finalize the segment at end-of-stream."""
+        self._flush()
+
+    def _flush(self) -> None:
+        self._render_pending = False
+        self._last_render_t = time.monotonic()
+        try:
+            self.update(Markdown(normalize_artifacts(self._buf)))
+        except Exception:
+            # Widget might be unmounted by the time a scheduled flush fires.
+            pass
 
     @property
     def content(self) -> str:
@@ -504,11 +537,14 @@ class AssistantTurn(Vertical):
 
     def __init__(self, *, show_thinking: bool = True) -> None:
         super().__init__()
-        self._tools: dict[str, ToolCallCard] = {}
+        # Value is either the card widget OR None when the matching tool_start
+        # was suppressed (empty/truncated args) — see tui.py _handle_event.
+        self._tools: dict[str, Optional[Any]] = {}
         self._todo: Optional[TodoList] = None
         self._last_text: Optional[TextSegment] = None
         self._thinking: Optional[ThinkingIndicator] = None
         self._show_thinking = show_thinking
+        self._truncated_shown: bool = False
         self._final = False
 
     async def on_mount(self) -> None:
@@ -582,4 +618,11 @@ class AssistantTurn(Vertical):
 
     async def mark_final(self) -> None:
         await self._stop_thinking()
+        # Force any throttled TextSegment to do its final render so the user
+        # doesn't see the last sub-50ms of tokens missing after stream-end.
+        for seg in self.query(TextSegment):
+            try:
+                seg.flush()
+            except Exception:
+                pass
         self._final = True

{virtuai_cli-0.7.3 → virtuai_cli-0.7.6}/src/virtuai_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: virtuai-cli
-Version: 0.7.3
+Version: 0.7.6
 Summary: Run VirtuAI deep agents on your local machine
 Author-email: uCloudStore <lmoreno@ucloudstore.com>
 License: Proprietary