kiwi-code 0.0.26__tar.gz → 0.0.27__tar.gz

{kiwi_code-0.0.26 → kiwi_code-0.0.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kiwi-code
-Version: 0.0.26
+Version: 0.0.27
 Summary: A textual-based terminal user interface application
 Project-URL: Homepage, https://meetkiwi.ai
 Project-URL: Repository, https://github.com/jetoslabs/kiwi-code
@@ -25,6 +25,7 @@ Requires-Dist: textual-dev>=1.8.0
 Requires-Dist: textual>=8.1.1
 Requires-Dist: typer>=0.24.1
 Requires-Dist: websockets>=14.1
+Requires-Dist: wonderwords>=2.2.0
 Description-Content-Type: text/markdown
 
 # Kiwi Code

{kiwi_code-0.0.26 → kiwi_code-0.0.27}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kiwi-code"
-version = "0.0.26"
+version = "0.0.27"
 description = "A textual-based terminal user interface application"
 readme = {file = "README.md", content-type = "text/markdown"}
 requires-python = ">=3.11,<4.0"
@@ -15,7 +15,9 @@ dependencies = [
     "httpx>=0.25.0",
     "psutil>=5.9.0",
     "setproctitle>=1.3.0",
+    "wonderwords>=2.2.0",
 ]
+
 authors = [
     { name = "Anurag Jha", email = "anurag@meetkiwi.co" }
 ]

{kiwi_code-0.0.26 → kiwi_code-0.0.27}/src/kiwi_tui/main.py

@@ -281,6 +281,8 @@ class AutobotsTUI(App):
         # Chat UX: full-width highlight color for user-message rows.
         # Keep it subtle and theme-aware.
         variables["user-msg-bg"] = "#333333" if self._is_dark_theme() else "#e8e8e8"
+        # Chat UX: subtle highlight for the *active streaming* assistant message.
+        variables["assistant-stream-bg"] = "#222222" if self._is_dark_theme() else "#f2f2f2"
         # Scrollbars: cyan thumb, dark track.
         variables["scrollbar"] = cyan
         variables["scrollbar-hover"] = cyan

kiwi_code-0.0.27/src/kiwi_tui/random_words.py

@@ -0,0 +1,80 @@
+from functools import lru_cache
+
+
+@lru_cache(maxsize=1)
+def _ww() -> object | None:
+    try:
+        from wonderwords import RandomWord  # type: ignore
+
+        return RandomWord()
+    except Exception:
+        return None
+
+
+def _to_present_participle(verb: str) -> str:
+    v = (verb or "").strip()
+    if not v:
+        return ""
+    w = v.lower()
+
+    # Common irregulars / spelling rules that a simple suffix approach misses.
+    irregular = {
+        "be": "being",
+        "see": "seeing",
+        "flee": "fleeing",
+        "knee": "kneeing",
+        "die": "dying",
+        "tie": "tying",
+        "lie": "lying",
+    }
+    if w in irregular:
+        return irregular[w].capitalize()
+
+    # ie -> ying (die -> dying).
+    if w.endswith("ie") and len(w) > 2:
+        return (w[:-2] + "ying").capitalize()
+
+    # Drop trailing e (make -> making), but keep ee/ye/oe (see -> seeing).
+    if w.endswith("e") and not w.endswith(("ee", "ye", "oe")) and len(w) > 1:
+        return (w[:-1] + "ing").capitalize()
+
+    # Verbs ending in 'ic' often add 'k' (panic -> panicking).
+    if w.endswith("ic") and len(w) > 2:
+        return (w + "king").capitalize()
+
+    vowels = set("aeiou")
+    # Double final consonant for short CVC words with a/i/o/u vowel (run -> running).
+    if (
+        3 <= len(w) <= 4
+        and w[-1] not in vowels
+        and w[-1] not in "wxy"
+        and w[-2] in vowels
+        and w[-2] != "e"
+        and w[-3] not in vowels
+    ):
+        return (w + w[-1] + "ing").capitalize()
+
+    return (w + "ing").capitalize()
+
+
+def random_verb(*, default: str = "Thinking") -> str:
+    """Return a random present-participle verb for display (e.g. "Searching")."""
+    rw = _ww()
+    if rw is None:
+        return default
+
+    try:
+        # wonderwords supports parts_of_speech filtering.
+        word = rw.word(include_parts_of_speech=["verbs"])  # type: ignore[attr-defined]
+        word = str(word or "").strip()
+        if not word:
+            return default
+        ing = _to_present_participle(word)
+        return ing if ing else default
+    except Exception:
+        return default
+
+
+# Backward-compat alias (older code used adjectives).
+def random_adjective(*, default: str = "Curious") -> str:  # pragma: no cover
+    return default

{kiwi_code-0.0.26 → kiwi_code-0.0.27}/src/kiwi_tui/screens/dashboard.py

@@ -25,6 +25,8 @@ import time
 import re
 import html
 from pathlib import Path
+from kiwi_tui.random_words import random_verb
+
 
 
 class UserMessageRow(Horizontal):
@@ -41,16 +43,42 @@ class UserMessageRow(Horizontal):
 
 
 class AssistantMessageRow(Horizontal):
-    """A single assistant message rendered with a left dot + markdown body."""
+    """A single assistant message rendered with a left dot + markdown body.
+
+    While streaming, shows a footer line under the message:
+      [Kiwi] <verb>  <spinner>
 
-    def __init__(self, markdown_text: str, *, classes: str = "") -> None:
+    Requirement: the footer is visible only while streaming and disappears when
+    the final output is available.
+    """
+
+    def __init__(
+        self,
+        markdown_text: str,
+        *,
+        verb: str | None = None,
+        streaming: bool = False,
+        classes: str = "",
+    ) -> None:
         super().__init__(classes=classes)
         self._markdown_text = markdown_text
+        self._verb = (verb or random_verb()).strip() or "Thinking"
+        self._streaming = bool(streaming)
+        if self._streaming:
+            self.add_class("streaming")
 
     def compose(self) -> ComposeResult:
         # Solid dot marker on the left side of the model response.
         yield Static("●", classes="assistant-dot", markup=False)
-        yield Markdown(self._markdown_text, classes="assistant-body")
+
+        with Vertical(classes="assistant-content"):
+            # Message body comes first (user request: streaming message above).
+            yield Markdown(self._markdown_text, classes="assistant-body")
+
+            # Footer comes after the body, and is only visible while streaming.
+            with Horizontal(classes="assistant-footer"):
+                yield Static(f"[Kiwi] {self._verb}", classes="assistant-name", markup=False)
+                yield Static("⣾", classes="assistant-spinner", markup=False)
 
     def update_markdown(self, markdown_text: str) -> None:
         """Update the markdown content in-place."""
@@ -61,13 +89,42 @@ class AssistantMessageRow(Horizontal):
             # Defensive: if the widget tree isn't ready or the child was removed.
             pass
 
+    def set_streaming(self, streaming: bool) -> None:
+        """Toggle streaming visual state (footer visibility + blink target)."""
+        self._streaming = bool(streaming)
+        if self._streaming:
+            self.add_class("streaming")
+        else:
+            self.remove_class("streaming")
+            # Ensure spinner is cleared when not streaming.
+            self.set_spinner_frame("")
+
+    def set_blink_dim(self, dim: bool) -> None:
+        """Dim/undim the dot to create a blink effect."""
+        try:
+            dot = self.query_one(".assistant-dot", Static)
+            if dim:
+                dot.add_class("blink-dim")
+            else:
+                dot.remove_class("blink-dim")
+        except Exception:
+            pass
+
+    def set_spinner_frame(self, frame: str) -> None:
+        """Update the spinner glyph (shown only while streaming)."""
+        try:
+            sp = self.query_one(".assistant-spinner", Static)
+            sp.update(frame or "")
+        except Exception:
+            pass
+
 # Footer hint for inserting a newline differs by OS:
 # - macOS terminals often don't forward modified Enter combos to terminal apps reliably, so we advertise Ctrl+N.
 # - Windows terminals tend to support Shift+Enter for multi-line input.
 NEWLINE_HINT_BINDING = (
-    Binding("ctrl+n", "hint_newline", "↩ newline (Mac)", show=True, priority=True)
+    Binding("ctrl+n", "hint_newline", "newline (Mac)", show=True, priority=True)
     if sys.platform == "darwin"
-    else Binding("shift+enter", "hint_newline", "↩ newline (Win)", show=True, priority=True)
+    else Binding("shift+enter", "hint_newline", "newline (Win)", show=True, priority=True)
 )
 
 class DashboardScreen(Screen):
@@ -96,6 +153,15 @@ class DashboardScreen(Screen):
         self._metadata: dict = {}  # Persistent metadata for all subsequent runs
         self._is_streaming: bool = False  # Track streaming state for send/stop toggle
 
+        # UI helpers for streaming UX: blinking dot + spinner on the active assistant row.
+        self._streaming_widget_ref: AssistantMessageRow | None = None
+        self._blink_timer = None
+        self._blink_dim: bool = False
+        self._spinner_timer = None
+        self._spinner_i: int = 0
+
+
+
         self._cmd_running: bool = False  # True while a /command is executing
 
 
@@ -219,14 +285,58 @@ class DashboardScreen(Screen):
         padding: 0 1;
     }
 
+    /* Grayish background to indicate "in progress" assistant output. */
+    .assistant-message.streaming {
+        background: $assistant-stream-bg;
+    }
+
     .assistant-dot {
-        width: 2;
+        /* Slightly larger + bolder to improve visibility (requested). */
+        width: 4;
         padding: 0 1 0 0;
         color: $brand-cyan;
         text-style: bold;
         content-align: center top;
     }
 
+    /* Blink effect (we toggle this class in code while streaming). */
+    .assistant-dot.blink-dim {
+        opacity: 0.15;
+    }
+
+    .assistant-content {
+        width: 1fr;
+        /* Critical: keep each assistant row sized to its content (no 1fr stretching). */
+        height: auto;
+    }
+
+    .assistant-footer {
+        width: 1fr;
+        height: auto;
+        background: transparent;
+        padding: 0;
+        /* Hidden unless the row is actively streaming. */
+        display: none;
+    }
+
+    .assistant-message.streaming .assistant-footer {
+        display: block;
+    }
+
+    .assistant-name {
+        width: auto;
+        color: $brand-cyan;
+        text-style: bold;
+        padding: 0 1 0 0;
+    }
+
+    .assistant-spinner {
+        width: auto;
+        height: 1;
+        color: $brand-cyan;
+        text-style: bold;
+    }
+
     .assistant-body {
         width: 1fr;
     }
@@ -235,6 +345,7 @@ class DashboardScreen(Screen):
         margin: 0;
         padding: 0;
         width: 1fr;
+        background: transparent;
     }
 
     .error-message {
@@ -1571,7 +1682,9 @@ class DashboardScreen(Screen):
         css_class = f"message {msg_type}-message"
         if msg_type == "assistant":
             prepared = self._prepare_markdown(text)
-            messages.mount(AssistantMessageRow(prepared, classes=css_class))
+            messages.mount(
+                AssistantMessageRow(prepared, classes=css_class)
+            )
         elif msg_type == "user":
             # Render a styled "YOU" label without enabling markup (keeps input safe).
             messages.mount(UserMessageRow(str(text), classes=css_class))
@@ -1625,12 +1738,125 @@ class DashboardScreen(Screen):
             pass
         self._apply_blocking_state()
 
+    def _get_active_streaming_row(self) -> AssistantMessageRow | None:
+        """Best-effort: find the assistant row currently marked as streaming.
+
+        This makes the spinner resilient even if we temporarily lose the stored
+        widget reference (e.g., stream reconnects / DOM changes).
+        """
+        try:
+            messages = self.query_one("#messages", VerticalScroll)
+            # Query returns widgets in document order; we want the most recent one.
+            candidates = list(messages.query(".assistant-message"))
+            for w in reversed(candidates):
+                if isinstance(w, AssistantMessageRow) and w.has_class("streaming"):
+                    return w
+        except Exception:
+            return None
+        return None
+
+    def _blink_streaming_dot_tick(self) -> None:
+        """Timer tick: blink the dot for the active streaming assistant row."""
+        w = getattr(self, "_streaming_widget_ref", None)
+        if not isinstance(w, AssistantMessageRow) or not w.has_class("streaming"):
+            w = self._get_active_streaming_row()
+            if w:
+                self._streaming_widget_ref = w
+        if not w:
+            return
+        try:
+            self._blink_dim = not bool(getattr(self, "_blink_dim", False))
+            w.set_blink_dim(self._blink_dim)
+        except Exception:
+            pass
+
+        # Watchdog: if spinner timer stopped for any reason, restart it while streaming.
+        try:
+            if self._is_streaming and getattr(self, "_spinner_timer", None) is None:
+                self._spinner_i = int(getattr(self, "_spinner_i", 0) or 0)
+                self._spinner_timer = self.set_interval(0.12, self._spinner_tick)
+        except Exception:
+            pass
+
+    _SPINNER_FRAMES: tuple[str, ...] = ("⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷")
+
+    def _spinner_tick(self) -> None:
+        """Timer tick: animate the spinner for the active streaming assistant row."""
+        w = getattr(self, "_streaming_widget_ref", None)
+        if not isinstance(w, AssistantMessageRow) or not w.has_class("streaming"):
+            w = self._get_active_streaming_row()
+            if w:
+                self._streaming_widget_ref = w
+        if not w:
+            return
+        try:
+            frames = getattr(self, "_SPINNER_FRAMES", ("⠋",))
+            i = int(getattr(self, "_spinner_i", 0) or 0)
+            i = (i + 1) % max(1, len(frames))
+            self._spinner_i = i
+            w.set_spinner_frame(frames[i])
+        except Exception:
+            pass
+
     def _set_streaming(self, streaming: bool) -> None:
         """Set busy/streaming mode (chat send)."""
         self._is_streaming = streaming
-        self._apply_blocking_state()
 
+        try:
+            if streaming:
+                # Blink timer (slower).
+                if getattr(self, "_blink_timer", None) is None:
+                    self._blink_timer = self.set_interval(0.5, self._blink_streaming_dot_tick)
+
+                # Spinner timer (faster).
+                if getattr(self, "_spinner_timer", None) is None:
+                    self._spinner_i = 0
+                    self._spinner_timer = self.set_interval(0.12, self._spinner_tick)
+
+                w = getattr(self, "_streaming_widget_ref", None)
+                if w:
+                    w.set_streaming(True)
+                    # Set an initial frame immediately (avoid a blank spinner until first tick).
+                    try:
+                        w.set_spinner_frame(self._SPINNER_FRAMES[0])
+                    except Exception:
+                        pass
+
+                try:
+                    self._spinner_tick()
+                    self._blink_streaming_dot_tick()
+                except Exception:
+                    pass
+            else:
+                # Stop blink timer.
+                t = getattr(self, "_blink_timer", None)
+                if t is not None:
+                    try:
+                        t.stop()
+                    except Exception:
+                        pass
+                self._blink_timer = None
+                self._blink_dim = False
+
+                # Stop spinner timer.
+                st = getattr(self, "_spinner_timer", None)
+                if st is not None:
+                    try:
+                        st.stop()
+                    except Exception:
+                        pass
+                self._spinner_timer = None
+                self._spinner_i = 0
+
+                w = getattr(self, "_streaming_widget_ref", None)
+                if w:
+                    w.set_streaming(False)
+                    w.set_blink_dim(False)
+                    w.set_spinner_frame("")
+        except Exception:
+            pass
 
+        self._apply_blocking_state()
 
     def _on_attach_result(self, result: dict) -> None:
         """Callback from AttachContentScreen."""
@@ -1702,10 +1928,33 @@ class DashboardScreen(Screen):
         self.run_action_with_polling(message)
 
     def run_action_with_polling(self, user_input: str) -> None:
-        """Run action and stream results via SSE."""
+        """Run action and stream results via SSE.
+
+        UX requirement: as soon as the user hits Enter, show an "in progress"
+        assistant row (dot + [Kiwi] header + spinner) and animate it until we
+        have a terminal result (success/error), regardless of whether SSE is
+        currently emitting tokens.
+        """
+        # Mount the streaming placeholder immediately (before any network calls).
+        try:
+            messages = self.query_one("#messages", VerticalScroll)
+            placeholder = AssistantMessageRow(
+                "",
+                verb=random_verb(),
+                streaming=True,
+                classes="message assistant-message",
+            )
+            messages.mount(placeholder)
+            messages.scroll_end(animate=False)
+            self._streaming_widget_ref = placeholder
+        except Exception:
+            # Non-fatal; we'll still run the action and stream/poll results.
+            self._streaming_widget_ref = None
+
         # Mark as busy immediately (prevents double-submit before the HTTP request returns)
         self._set_streaming(True)
-        # Kick off as a worker so the UI renders the user message first
+
+        # Kick off as a worker so the UI renders the user message + placeholder first
         self.run_worker(self._run_action_worker(user_input), exclusive=True, group="stream")
 
     async def _run_action_worker(self, user_input: str) -> None:
@@ -1734,11 +1983,32 @@ class DashboardScreen(Screen):
             # If the user hit Stop before the request returned, restore UI state.
             self._set_streaming(False)
             raise
+        except Exception as e:
+            # Unexpected error starting the action request.
+            self.add_message(f"Error starting action: {e}", "error")
+            try:
+                w = getattr(self, "_streaming_widget_ref", None)
+                if w:
+                    w.remove()
+            except Exception:
+                pass
+            self._streaming_widget_ref = None
+            self._set_streaming(False)
+            return
 
         if not success:
             self.add_message(f"Error starting action: {message}", "error")
+            # Remove the placeholder row (no run was started).
+            try:
+                w = getattr(self, "_streaming_widget_ref", None)
+                if w:
+                    w.remove()
+            except Exception:
+                pass
+            self._streaming_widget_ref = None
             self._set_streaming(False)
             return
+
         # Check if this is continuing an existing conversation
         if self.current_run_id and run_id == self.current_run_id:
             logger.info(f"Continuing conversation with run_id: {run_id}")
@@ -1752,7 +2022,6 @@ class DashboardScreen(Screen):
                 pass
             logger.info(f"Started new conversation with run_id: {run_id}")
 
-
         self._update_run_status_bar()
 
         # Cache run name (best-effort) so the quit-time runtime cleanup prompt can show it.
@@ -1816,8 +2085,9 @@ class DashboardScreen(Screen):
         client = self.app.autobots_client
         got_final_result = False
 
-        # Track status widget for streaming transitional messages
-        status_widget_container = [None]
+        # Track status widget for streaming transitional messages.
+        # If we already mounted a placeholder row on submit, reuse it.
+        status_widget_container = [getattr(self, "_streaming_widget_ref", None)]
 
         logger.info(f"Starting stream_results for {run_id}")
 
@@ -1825,17 +2095,42 @@ class DashboardScreen(Screen):
             """Remove the streaming status widget if it exists."""
             if status_widget_container[0]:
                 try:
-                    status_widget_container[0].remove()
+                    removed = status_widget_container[0]
+                    removed.remove()
                     status_widget_container[0] = None
+                    # Also clear streaming UI reference if this was the active row.
+                    try:
+                        if getattr(self, "_streaming_widget_ref", None) is removed:
+                            self._streaming_widget_ref = None
+                    except Exception:
+                        pass
                 except Exception as e:
                     logger.warning(f"Failed to remove status widget: {e}")
 
-        def _try_fetch_final_result() -> bool:
-            """Attempt to fetch and display the final result. Returns True on success/error."""
+        fetch_lock = asyncio.Lock()
+
+        async def _try_fetch_final_result_async() -> bool:
+            """Attempt to fetch and display the final result. Returns True on success/error.
+
+            Important: fetching uses a background thread so the Textual event loop
+            stays responsive and UI timers (spinner/dot) continue animating even
+            when SSE is quiet or the backend is slow.
+            """
             nonlocal got_final_result
             if got_final_result:
                 return True
-            success, final_result, message = client.get_action_result(run_id)
+
+            try:
+                async with fetch_lock:
+                    if got_final_result:
+                        return True
+                    success, final_result, _message = await asyncio.to_thread(
+                        client.get_action_result, run_id
+                    )
+            except Exception as e:
+                logger.warning(f"Poll error: {e}")
+                return False
+
             if not success or not final_result:
                 return False
 
@@ -1845,10 +2140,23 @@ class DashboardScreen(Screen):
             # Handle error/failed states
             if status in ("error", "failed"):
                 logger.info(f"Run failed with status: {status}")
-                _remove_status_widget()
                 error_msg = final_result.get("message", "") or final_result.get("error", "") or "Action failed"
-                self.add_message(f"Error: {error_msg}", "error")
+
+                w = status_widget_container[0]
+                if isinstance(w, AssistantMessageRow):
+                    prepared = self._prepare_markdown(f"Error: {error_msg}")
+                    w.update_markdown(prepared)
+                    w.set_streaming(False)
+                    w.set_blink_dim(False)
+                    w.set_spinner_frame("")
+                    status_widget_container[0] = None
+                    self._streaming_widget_ref = None
+                else:
+                    self.add_message(f"Error: {error_msg}", "error")
+
                 got_final_result = True
+                # Stop spinner/blink immediately when we have a terminal state.
+                self._set_streaming(False)
                 return True
 
             # Only treat as complete if status indicates completion
@@ -1862,9 +2170,14 @@ class DashboardScreen(Screen):
                 last = results_list[-1]
                 if isinstance(last, dict) and last.get("output"):
                     logger.info("Final result fetched successfully")
-                    _remove_status_widget()
-                    self.display_final_result(final_result)
+                    w = status_widget_container[0] if isinstance(status_widget_container[0], AssistantMessageRow) else None
+                    self.display_final_result(final_result, widget_ref=w)
+                    # Keep the rendered message, but prevent cleanup from removing it.
+                    status_widget_container[0] = None
+                    self._streaming_widget_ref = None
                     got_final_result = True
+                    # Stop spinner/blink immediately when we have a terminal state.
+                    self._set_streaming(False)
                     return True
             return False
 
@@ -1889,7 +2202,7 @@ class DashboardScreen(Screen):
                 # Detect completion from text signals (server sends these as plain text)
                 if any(kw in text_lower for kw in ["finishing", "completed", "finished"]):
                     logger.info(f"Completion signal from SSE text: {text}")
-                    _try_fetch_final_result()
+                    asyncio.create_task(_try_fetch_final_result_async())
                 return
 
             # JSON status messages
@@ -1897,7 +2210,7 @@ class DashboardScreen(Screen):
             if status:
                 logger.info(f"SSE JSON status: {status}")
             if status in ["completed", "success", "finished", "error", "failed"]:
-                _try_fetch_final_result()
+                asyncio.create_task(_try_fetch_final_result_async())
 
         # ---- Concurrent polling task ----
         async def _poll_until_done() -> None:
@@ -1907,7 +2220,7 @@ class DashboardScreen(Screen):
                 if got_final_result:
                     return
                 try:
-                    if _try_fetch_final_result():
+                    if await _try_fetch_final_result_async():
                         return
                 except Exception as e:
                     logger.warning(f"Poll error: {e}")
@@ -1979,13 +2292,14 @@ class DashboardScreen(Screen):
                 except (asyncio.CancelledError, Exception):
                     pass
 
-        # Always clean up status widget when SSE stream ends
-        _remove_status_widget()
+        # Clean up status widget if it still exists (we keep it when it becomes the final output).
+        if status_widget_container[0]:
+            _remove_status_widget()
 
         # Final fallback — if neither SSE nor polling found the result
         if not got_final_result:
             logger.info(f"Final fallback poll for {run_id}")
-            _try_fetch_final_result()
+            await _try_fetch_final_result_async()
 
         if not got_final_result:
             self.add_message("Could not get result. Use /new to start over.", "error")
@@ -2009,22 +2323,56 @@ class DashboardScreen(Screen):
 
         markdown_text = self._prepare_markdown(text_content)
         if widget_ref is None:
-            widget_ref = AssistantMessageRow(markdown_text, classes="message assistant-message")
+            widget_ref = AssistantMessageRow(
+                markdown_text,
+                verb=random_verb(),
+                streaming=True,
+                classes="message assistant-message",
+            )
             messages.mount(widget_ref)
+            self._streaming_widget_ref = widget_ref
+            try:
+                frames = getattr(self, "_SPINNER_FRAMES", ("⠋",))
+                i = int(getattr(self, "_spinner_i", 0) or 0) % max(1, len(frames))
+                widget_ref.set_spinner_frame(frames[i])
+            except Exception:
+                pass
         else:
             try:
                 if isinstance(widget_ref, AssistantMessageRow):
+                    # Keep the streaming state "on" while we update markdown.
+                    self._streaming_widget_ref = widget_ref
+                    widget_ref.set_streaming(True)
+                    try:
+                        frames = getattr(self, "_SPINNER_FRAMES", ("⠋",))
+                        i = int(getattr(self, "_spinner_i", 0) or 0) % max(1, len(frames))
+                        widget_ref.set_spinner_frame(frames[i])
+                    except Exception:
+                        pass
                     widget_ref.update_markdown(markdown_text)
                 else:
                     # Backward-compat: if an older ref is a Markdown widget.
                     widget_ref.update(markdown_text)
             except Exception as e:
                 logger.warning(f"Failed to update widget: {e}")
-                widget_ref = AssistantMessageRow(markdown_text, classes="message assistant-message")
+                widget_ref = AssistantMessageRow(
+                    markdown_text,
+                    verb=random_verb(),
+                    streaming=True,
+                    classes="message assistant-message",
+                )
                 messages.mount(widget_ref)
+                self._streaming_widget_ref = widget_ref
+                try:
+                    frames = getattr(self, "_SPINNER_FRAMES", ("⠋",))
+                    i = int(getattr(self, "_spinner_i", 0) or 0) % max(1, len(frames))
+                    widget_ref.set_spinner_frame(frames[i])
+                except Exception:
+                    pass
 
         messages.scroll_end(animate=False)
         return widget_ref
+
     def extract_text_from_output(self, output: any) -> str:
         """Extract text content from output blocks structure and clean it for display."""
         if not isinstance(output, dict):
@@ -2112,61 +2460,76 @@ class DashboardScreen(Screen):
 
         messages.scroll_end(animate=False)
         self._update_run_status_bar()
-    def display_final_result(self, result: dict) -> None:
+    def display_final_result(self, result: dict, *, widget_ref: AssistantMessageRow | None = None) -> None:
         """Display the final result from results array, showing only the latest output.
 
-        Args:
-            result: The result dictionary from get_action_result containing result.result.results[]
+        If `widget_ref` is provided (streaming placeholder row), we update that row
+        in-place and hide the streaming footer so the transition feels seamless.
         """
-        logger.info(f"Displaying final result from results array")
+        logger.info("Displaying final result from results array")
+
+        def _finalize_streaming_row() -> None:
+            try:
+                if widget_ref:
+                    widget_ref.set_streaming(False)
+                    widget_ref.set_blink_dim(False)
+                    widget_ref.set_spinner_frame("")
+            except Exception:
+                pass
 
         # Extract results array from result.result.results
         if "result" not in result or not isinstance(result["result"], dict):
-            logger.warning(f"No result.result field found")
+            logger.warning("No result.result field found")
+            _finalize_streaming_row()
             self.add_message("Action completed (no output)", "info")
             return
 
         action_doc = result["result"]
-        logger.info(f"ActionDoc keys: {action_doc.keys()}")
-
         if "results" not in action_doc or not isinstance(action_doc["results"], list):
-            logger.warning(f"No results array found in ActionDoc")
+            logger.warning("No results array found in ActionDoc")
+            _finalize_streaming_row()
             self.add_message("Action completed (no output)", "info")
             return
 
         results_list = action_doc["results"]
-
-        logger.info(f"Found {len(results_list)} items in results array")
-
-        if len(results_list) == 0:
-            logger.warning(f"Results array is empty")
+        if not results_list:
+            logger.warning("Results array is empty")
+            _finalize_streaming_row()
             self.add_message("Action completed (no output)", "info")
             return
 
         # Only display the LAST result item's output.
-        # The results array contains full conversation history; the user's input
-        # was already shown when they typed it, so we only need the latest response.
         last_result = results_list[-1]
         if not isinstance(last_result, dict):
-            logger.warning(f"Last result is not a dict")
+            logger.warning("Last result is not a dict")
+            _finalize_streaming_row()
             self.add_message("Action completed (no output)", "info")
             return
 
-        logger.info(f"Processing last result, keys: {last_result.keys()}")
+        output_data = last_result.get("output")
+        if not output_data:
+            logger.warning("Last result has no output field")
+            _finalize_streaming_row()
+            self.add_message("Action completed (no output)", "info")
+            return
 
-        # Extract and display only the output (skip input — already shown)
-        if "output" in last_result and last_result["output"]:
-            output_data = last_result["output"]
-            output_text = self.extract_text_from_output(output_data)
-            if output_text:
-                logger.info(f"Last result output: {len(output_text)} chars, {len(output_text.splitlines())} lines")
-                self.add_message(output_text, "assistant")
-            else:
-                logger.warning(f"Last result output extraction returned empty")
-                self.add_message("Action completed (no output)", "info")
-        else:
-            logger.warning(f"Last result has no output field")
+        output_text = self.extract_text_from_output(output_data) if isinstance(output_data, dict) else str(output_data)
+        output_text = (output_text or "").strip()
+        if not output_text:
+            logger.warning("Last result output extraction returned empty")
+            _finalize_streaming_row()
             self.add_message("Action completed (no output)", "info")
+            return
+
+        # Update existing streaming row in-place (preferred).
+        if widget_ref and isinstance(widget_ref, AssistantMessageRow):
+            prepared = self._prepare_markdown(output_text)
+            widget_ref.update_markdown(prepared)
+            _finalize_streaming_row()
+            return
+
+        # Fallback: mount a new assistant message.
+        self.add_message(output_text, "assistant")
 
     def format_and_display_output(self, output: any) -> None:
         """Format and display output, extracting text and files from blocks."""

{kiwi_code-0.0.26 → kiwi_code-0.0.27}/uv.lock

@@ -397,7 +397,7 @@ wheels = [
 
 [[package]]
 name = "kiwi-code"
-version = "0.0.26"
+version = "0.0.27"
 source = { editable = "." }
 dependencies = [
     { name = "autobots-client" },
@@ -410,6 +410,7 @@ dependencies = [
     { name = "textual-dev" },
     { name = "typer" },
     { name = "websockets" },
+    { name = "wonderwords" },
 ]
 
 [package.dev-dependencies]
@@ -430,6 +431,7 @@ requires-dist = [
     { name = "textual-dev", specifier = ">=1.8.0" },
     { name = "typer", specifier = ">=0.24.1" },
     { name = "websockets", specifier = ">=14.1" },
+    { name = "wonderwords", specifier = ">=2.2.0" },
 ]
 
 [package.metadata.requires-dev]
@@ -1326,6 +1328,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e1/07/c6fe3ad3e685340704d314d765b7912993bcb8dc198f0e7a89382d37974b/win32_setctime-1.2.0-py3-none-any.whl", hash = "sha256:95d644c4e708aba81dc3704a116d8cbc974d70b3bdb8be1d150e36be6e9d1390", size = 4083, upload-time = "2024-12-07T15:28:26.465Z" },
 ]
 
+[[package]]
+name = "wonderwords"
+version = "3.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ff/23/e144fc3dfabb845dc1d94c45315d97b308cf75a664e3db3a89aeb1cb505d/wonderwords-3.0.1.tar.gz", hash = "sha256:5ee43ab6f13823a857a7c3d58c7b4db6a1350bd3aa5f914ed379ad49042a1c36", size = 73339, upload-time = "2025-10-30T17:30:44.231Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a4/75/855c2062d28b8e9247939f8262fb2f4ff3b12a49e4bab9fd1ba16cc5df82/wonderwords-3.0.1-py3-none-any.whl", hash = "sha256:4dd66deb6a76ca9e0b0422d1d3e111f9b910d7c16922d42de733ee8def98f8d0", size = 51658, upload-time = "2025-10-30T17:30:42.785Z" },
+]
+
 [[package]]
 name = "yarl"
 version = "1.23.0"