fast-agent-mcp 0.3.15__py3-none-any.whl → 0.3.16__py3-none-any.whl

fast_agent/ui/console_display.py

@@ -1,4 +1,6 @@
+import asyncio
 import math
+import time
 from contextlib import contextmanager
 from enum import Enum
 from json import JSONDecodeError
@@ -12,6 +14,7 @@ from rich.text import Text
 
 from fast_agent.config import Settings
 from fast_agent.constants import REASONING
+from fast_agent.core.logging.logger import get_logger
 from fast_agent.ui import console
 from fast_agent.ui.markdown_truncator import MarkdownTruncator
 from fast_agent.ui.mcp_ui_utils import UILink
@@ -27,6 +30,8 @@ if TYPE_CHECKING:
     from fast_agent.mcp.prompt_message_extended import PromptMessageExtended
     from fast_agent.mcp.skybridge import SkybridgeServerConfig
 
+logger = get_logger(__name__)
+
 CODE_STYLE = "native"
 
 MARKDOWN_STREAM_TARGET_RATIO = 0.7
@@ -884,10 +889,11 @@ class ConsoleDisplay:
         self,
         tool_name: str,
         tool_args: Dict[str, Any] | None,
-        bottom_items: List[str] | None = None,
+        bottom_items: list[str] | None = None,
         highlight_index: int | None = None,
         max_item_length: int | None = None,
         name: str | None = None,
+        metadata: Dict[str, Any] | None = None,
     ) -> None:
         """Display a tool call in the new visual style.
 
@@ -898,23 +904,77 @@ class ConsoleDisplay:
             highlight_index: Index of item to highlight in the bottom separator (0-based), or None
             max_item_length: Optional max length for bottom items (with ellipsis)
             name: Optional agent name
+            metadata: Optional dictionary of metadata about the tool call
         """
         if not self.config or not self.config.logger.show_tools:
             return
 
-        # Build right info
+        tool_args = tool_args or {}
+        metadata = metadata or {}
+        # Build right info and specialised content for known variants
         right_info = f"[dim]tool request - {tool_name}[/dim]"
+        content: Any = tool_args
+        pre_content: Text | None = None
+        truncate_content = True
+
+        if metadata.get("variant") == "shell":
+            bottom_items = list()
+            max_item_length = 50
+            command = metadata.get("command") or tool_args.get("command")
+
+            command_text = Text()
+            if command and isinstance(command, str):
+                # Only prepend $ to the first line, not continuation lines
+                command_text.append("$ ", style="magenta")
+                command_text.append(command, style="white")
+            else:
+                command_text.append("$ ", style="magenta")
+                command_text.append("(no shell command provided)", style="dim")
+
+            content = command_text
+
+            # Include shell name and path in the header, with timeout
+            shell_name = metadata.get("shell_name") or "shell"
+            shell_path = metadata.get("shell_path")
+            if shell_path:
+                bottom_items.append(str(shell_path))
+            # Build header right info with shell and timeout
+            right_parts = []
+            if shell_path and shell_path != shell_name:
+                right_parts.append(f"{shell_name} ({shell_path})")
+            elif shell_name:
+                right_parts.append(shell_name)
+
+            right_info = f"[dim]{' | '.join(right_parts)}[/dim]" if right_parts else ""
+            truncate_content = False
+
+            # Build compact metadata summary - just working directory now
+            metadata_text = Text()
+            working_dir_display = metadata.get("working_dir_display") or metadata.get("working_dir")
+            if working_dir_display:
+                bottom_items.append(f"cwd: {working_dir_display}")
+
+            timeout_seconds = metadata.get("timeout_seconds")
+            warning_interval = metadata.get("warning_interval_seconds")
+
+            if timeout_seconds and warning_interval:
+                bottom_items.append(
+                    f"timeout: {timeout_seconds}s, warning every {warning_interval}s"
+                )
+
+            pre_content = metadata_text
 
         # Display using unified method
         self.display_message(
-            content=tool_args,
+            content=content,
             message_type=MessageType.TOOL_CALL,
             name=name,
+            pre_content=pre_content,
             right_info=right_info,
             bottom_metadata=bottom_items,
             highlight_index=highlight_index,
             max_item_length=max_item_length,
-            truncate_content=True,
+            truncate_content=truncate_content,
         )
 
     async def show_tool_update(self, updated_server: str, agent_name: str | None = None) -> None:
@@ -1604,6 +1664,16 @@ class _StreamingMessageHandle:
             if self._use_plain_text
             else MARKDOWN_STREAM_REFRESH_PER_SECOND
         )
+        self._min_render_interval = 1.0 / refresh_rate if refresh_rate else None
+        self._last_render_time = 0.0
+        try:
+            self._loop: asyncio.AbstractEventLoop | None = asyncio.get_running_loop()
+        except RuntimeError:
+            self._loop = None
+        self._async_mode = self._loop is not None
+        self._queue: asyncio.Queue[object] | None = asyncio.Queue() if self._async_mode else None
+        self._stop_sentinel: object = object()
+        self._worker_task: asyncio.Task[None] | None = None
         self._live: Live | None = Live(
             initial_renderable,
             console=console.console,
@@ -1626,120 +1696,19 @@ class _StreamingMessageHandle:
         )
         self._max_render_height = 0
 
+        if self._async_mode and self._loop and self._queue is not None:
+            self._worker_task = self._loop.create_task(self._render_worker())
+
     def update(self, chunk: str) -> None:
         if not self._active or not chunk:
             return
 
-        self._ensure_started()
-
-        if self._use_plain_text:
-            chunk = self._wrap_plain_chunk(chunk)
-            if self._pending_table_row:
-                self._buffer.append(self._pending_table_row)
-                self._pending_table_row = ""
-        else:
-            # Detect if we're streaming table content
-            # Tables have rows starting with '|' and we want to batch updates until we get a complete row
-            text_so_far = "".join(self._buffer)
-
-            # Check if we're currently in a table (last non-empty line starts with |)
-            lines = text_so_far.strip().split("\n")
-            last_line = lines[-1] if lines else ""
-            currently_in_table = last_line.strip().startswith("|")
-
-            # If we're in a table and the chunk doesn't contain a newline, accumulate it
-            if currently_in_table and "\n" not in chunk:
-                self._pending_table_row += chunk
-                # Don't update display yet - wait for complete row
-                return
-
-            # If we have a pending table row, flush it now
-            if self._pending_table_row:
-                self._buffer.append(self._pending_table_row)
-                self._pending_table_row = ""
-
-        self._buffer.append(chunk)
-
-        text = "".join(self._buffer)
-
-        if self._use_plain_text:
-            trimmed = self._trim_to_displayable(text)
-            if trimmed != text:
-                text = trimmed
-                self._buffer = [trimmed]
-
-        # Guard against single logical paragraphs that would expand far wider than expected.
-        trailing_paragraph = self._extract_trailing_paragraph(text)
-        if trailing_paragraph and "\n" not in trailing_paragraph:
-            width = max(1, console.console.size.width)
-            target_ratio = (
-                PLAIN_STREAM_TARGET_RATIO if self._use_plain_text else MARKDOWN_STREAM_TARGET_RATIO
-            )
-            target_rows = max(
-                1,
-                int(console.console.size.height * target_ratio) - 1,
-            )
-            estimated_rows = math.ceil(len(trailing_paragraph.expandtabs()) / width)
-            if estimated_rows > target_rows:
-                trimmed_text = self._trim_to_displayable(text)
-                if trimmed_text != text:
-                    text = trimmed_text
-                    self._buffer = [trimmed_text]
-
-        # Trim buffer periodically to avoid unbounded growth
-        # Keep only what can fit in ~1.5x terminal height
-        if len(self._buffer) > 10:
-            text = self._trim_to_displayable(text)
-            self._buffer = [text]
-
-        if self._live:
-            # Build the header bar
-            header = self._build_header()
-
-            # Build the content renderable
-            max_allowed_height = max(1, console.console.size.height - 2)
-            self._max_render_height = min(self._max_render_height, max_allowed_height)
-
-            if self._use_plain_text:
-                # Plain text rendering - no markdown processing
-                content_height = self._estimate_plain_render_height(text)
-                budget_height = min(content_height + PLAIN_STREAM_HEIGHT_FUDGE, max_allowed_height)
-
-                if budget_height > self._max_render_height:
-                    self._max_render_height = budget_height
-
-                padding_lines = max(0, self._max_render_height - content_height)
-                display_text = text + ("\n" * padding_lines if padding_lines else "")
-                content = Text(display_text)
-            else:
-                # Markdown rendering with XML escaping
-                prepared = _prepare_markdown_content(text, self._display._escape_xml)
-                prepared_for_display = self._close_incomplete_code_blocks(prepared)
-
-                content_height = self._truncator.measure_rendered_height(
-                    prepared_for_display, console.console, CODE_STYLE
-                )
-                budget_height = min(
-                    content_height + MARKDOWN_STREAM_HEIGHT_FUDGE, max_allowed_height
-                )
-
-                if budget_height > self._max_render_height:
-                    self._max_render_height = budget_height
-
-                padding_lines = max(0, self._max_render_height - content_height)
-                if padding_lines:
-                    prepared_for_display = prepared_for_display + ("\n" * padding_lines)
-
-                content = Markdown(prepared_for_display, code_theme=CODE_STYLE)
-
-            # Combine header and content using Group
-            from rich.console import Group
+        if self._async_mode and self._queue is not None:
+            self._enqueue_chunk(chunk)
+            return
 
-            header_with_spacing = header.copy()
-            header_with_spacing.append("\n", style="default")
-
-            combined = Group(header_with_spacing, content)
-            self._live.update(combined)
+        if self._handle_chunk(chunk):
+            self._render_current_buffer()
 
     def _build_header(self) -> Text:
         """Build the header bar as a Text renderable.
@@ -1776,11 +1745,7 @@ class _StreamingMessageHandle:
 
         return combined
 
-    def _ensure_started(self) -> None:
-        """Start live rendering and pause progress display if needed."""
-        if self._live_started:
-            return
-
+    def _pause_progress_display(self) -> None:
         if self._progress_display and not self._progress_paused:
             try:
                 self._progress_display.pause()
@@ -1788,6 +1753,25 @@ class _StreamingMessageHandle:
             except Exception:
                 self._progress_paused = False
 
+    def _resume_progress_display(self) -> None:
+        if self._progress_display and self._progress_paused:
+            try:
+                self._progress_display.resume()
+            except Exception:
+                pass
+            finally:
+                self._progress_paused = False
+
+    def _ensure_started(self) -> None:
+        """Start live rendering and pause progress display if needed."""
+        if not self._live:
+            return
+
+        if self._live_started:
+            return
+
+        self._pause_progress_display()
+
         if self._live and not self._live_started:
             self._live.__enter__()
             self._live_started = True
@@ -1859,6 +1843,16 @@ class _StreamingMessageHandle:
             prefer_recent=True,  # Streaming mode
         )
 
+    def _switch_to_plain_text(self) -> None:
+        """Switch from markdown to plain text rendering for tool arguments."""
+        if not self._use_plain_text:
+            self._use_plain_text = True
+            # Initialize plain truncator if needed
+            if not self._plain_truncator:
+                self._plain_truncator = PlainTextTruncator(
+                    target_height_ratio=PLAIN_STREAM_TARGET_RATIO
+                )
+
     def finalize(self, _message: "PromptMessageExtended | str") -> None:
         if not self._active or self._finalized:
             return
@@ -1867,18 +1861,41 @@ class _StreamingMessageHandle:
         self.close()
 
     def close(self) -> None:
-        if self._live and self._live_started:
-            self._live.__exit__(None, None, None)
-            self._live = None
-            self._live_started = False
-        if self._progress_display and self._progress_paused:
-            try:
-                self._progress_display.resume()
-            except Exception:
-                pass
-            finally:
-                self._progress_paused = False
+        if not self._active:
+            return
+
         self._active = False
+        if self._async_mode:
+            if self._queue and self._loop:
+                try:
+                    current_loop = asyncio.get_running_loop()
+                except RuntimeError:
+                    current_loop = None
+
+                # Send stop sentinel to queue
+                try:
+                    if current_loop is self._loop:
+                        self._queue.put_nowait(self._stop_sentinel)
+                    else:
+                        # Use call_soon_threadsafe from different thread/loop
+                        self._loop.call_soon_threadsafe(self._queue.put_nowait, self._stop_sentinel)
+                except RuntimeError as e:
+                    # Expected during event loop shutdown - log at debug level
+                    logger.debug(
+                        "RuntimeError while closing streaming display (expected during shutdown)",
+                        data={"error": str(e)},
+                    )
+                except Exception as e:
+                    # Unexpected exception - log at warning level
+                    logger.warning(
+                        "Unexpected error while closing streaming display",
+                        exc_info=True,
+                        data={"error": str(e)},
+                    )
+            if self._worker_task:
+                self._worker_task.cancel()
+                self._worker_task = None
+        self._shutdown_live_resources()
         self._max_render_height = 0
 
     def _extract_trailing_paragraph(self, text: str) -> str:
@@ -1958,3 +1975,253 @@ class _StreamingMessageHandle:
             expanded_len = len(line.expandtabs())
             total += max(1, math.ceil(expanded_len / width)) if expanded_len else 1
         return total
+
+    def _enqueue_chunk(self, chunk: str) -> None:
+        if not self._queue or not self._loop:
+            return
+
+        try:
+            current_loop = asyncio.get_running_loop()
+        except RuntimeError:
+            current_loop = None
+
+        if current_loop is self._loop:
+            try:
+                self._queue.put_nowait(chunk)
+            except asyncio.QueueFull:
+                # Shouldn't happen with default unlimited queue, but fail safe
+                pass
+        else:
+            try:
+                self._loop.call_soon_threadsafe(self._queue.put_nowait, chunk)
+            except RuntimeError as e:
+                # Expected during event loop shutdown - log at debug level
+                logger.debug(
+                    "RuntimeError while enqueuing chunk (expected during shutdown)",
+                    data={"error": str(e), "chunk_length": len(chunk)},
+                )
+            except Exception as e:
+                # Unexpected exception - log at warning level
+                logger.warning(
+                    "Unexpected error while enqueuing chunk",
+                    exc_info=True,
+                    data={"error": str(e), "chunk_length": len(chunk)},
+                )
+
+    def _handle_chunk(self, chunk: str) -> bool:
+        """
+        Process an incoming chunk and determine whether rendering is needed.
+
+        Returns:
+            True if the display should be updated, False otherwise.
+        """
+        if not chunk:
+            return False
+
+        if self._use_plain_text:
+            chunk = self._wrap_plain_chunk(chunk)
+            if self._pending_table_row:
+                self._buffer.append(self._pending_table_row)
+                self._pending_table_row = ""
+        else:
+            text_so_far = "".join(self._buffer)
+            lines = text_so_far.strip().split("\n")
+            last_line = lines[-1] if lines else ""
+            currently_in_table = last_line.strip().startswith("|")
+
+            if currently_in_table and "\n" not in chunk:
+                self._pending_table_row += chunk
+                return False
+
+            if self._pending_table_row:
+                self._buffer.append(self._pending_table_row)
+                self._pending_table_row = ""
+
+        self._buffer.append(chunk)
+        return True
+
+    def _render_current_buffer(self) -> None:
+        if not self._buffer:
+            return
+
+        self._ensure_started()
+
+        if not self._live:
+            return
+
+        text = "".join(self._buffer)
+
+        if self._use_plain_text:
+            trimmed = self._trim_to_displayable(text)
+            if trimmed != text:
+                text = trimmed
+                self._buffer = [trimmed]
+        trailing_paragraph = self._extract_trailing_paragraph(text)
+        if trailing_paragraph and "\n" not in trailing_paragraph:
+            width = max(1, console.console.size.width)
+            target_ratio = (
+                PLAIN_STREAM_TARGET_RATIO if self._use_plain_text else MARKDOWN_STREAM_TARGET_RATIO
+            )
+            target_rows = max(1, int(console.console.size.height * target_ratio) - 1)
+            estimated_rows = math.ceil(len(trailing_paragraph.expandtabs()) / width)
+            if estimated_rows > target_rows:
+                trimmed_text = self._trim_to_displayable(text)
+                if trimmed_text != text:
+                    text = trimmed_text
+                    self._buffer = [trimmed_text]
+
+        if len(self._buffer) > 10:
+            text = self._trim_to_displayable(text)
+            self._buffer = [text]
+
+        # Build the header bar
+        header = self._build_header()
+
+        # Build the content renderable
+        max_allowed_height = max(1, console.console.size.height - 2)
+        self._max_render_height = min(self._max_render_height, max_allowed_height)
+
+        if self._use_plain_text:
+            content_height = self._estimate_plain_render_height(text)
+            budget_height = min(content_height + PLAIN_STREAM_HEIGHT_FUDGE, max_allowed_height)
+
+            if budget_height > self._max_render_height:
+                self._max_render_height = budget_height
+
+            padding_lines = max(0, self._max_render_height - content_height)
+            display_text = text + ("\n" * padding_lines if padding_lines else "")
+            content = Text(display_text)
+        else:
+            prepared = _prepare_markdown_content(text, self._display._escape_xml)
+            prepared_for_display = self._close_incomplete_code_blocks(prepared)
+
+            content_height = self._truncator.measure_rendered_height(
+                prepared_for_display, console.console, CODE_STYLE
+            )
+            budget_height = min(content_height + MARKDOWN_STREAM_HEIGHT_FUDGE, max_allowed_height)
+
+            if budget_height > self._max_render_height:
+                self._max_render_height = budget_height
+
+            padding_lines = max(0, self._max_render_height - content_height)
+            if padding_lines:
+                prepared_for_display = prepared_for_display + ("\n" * padding_lines)
+
+            content = Markdown(prepared_for_display, code_theme=CODE_STYLE)
+
+        from rich.console import Group
+
+        header_with_spacing = header.copy()
+        header_with_spacing.append("\n", style="default")
+
+        combined = Group(header_with_spacing, content)
+        try:
+            self._live.update(combined)
+            self._last_render_time = time.monotonic()
+        except Exception:
+            # Avoid crashing streaming on renderer errors
+            pass
+
+    async def _render_worker(self) -> None:
+        assert self._queue is not None
+        try:
+            while True:
+                try:
+                    item = await self._queue.get()
+                except asyncio.CancelledError:
+                    break
+
+                if item is self._stop_sentinel:
+                    break
+
+                stop_requested = False
+                chunks = [item]
+                while True:
+                    try:
+                        next_item = self._queue.get_nowait()
+                    except asyncio.QueueEmpty:
+                        break
+                    if next_item is self._stop_sentinel:
+                        stop_requested = True
+                        break
+                    chunks.append(next_item)
+
+                should_render = False
+                for chunk in chunks:
+                    if isinstance(chunk, str):
+                        should_render = self._handle_chunk(chunk) or should_render
+
+                if should_render:
+                    self._render_current_buffer()
+                    if self._min_render_interval:
+                        try:
+                            await asyncio.sleep(self._min_render_interval)
+                        except asyncio.CancelledError:
+                            break
+
+                if stop_requested:
+                    break
+        except asyncio.CancelledError:
+            pass
+        finally:
+            self._shutdown_live_resources()
+
+    def _shutdown_live_resources(self) -> None:
+        if self._live and self._live_started:
+            try:
+                self._live.__exit__(None, None, None)
+            except Exception:
+                pass
+            self._live = None
+            self._live_started = False
+
+        self._resume_progress_display()
+        self._active = False
+
+    def handle_tool_event(self, event_type: str, info: Dict[str, Any] | None = None) -> None:
+        """Handle tool streaming events with comprehensive error handling.
+
+        This is called from listener callbacks during async streaming, so we need
+        to be defensive about any errors to prevent crashes in the event loop.
+        """
+        try:
+            if not self._active:
+                return
+
+            # Check if this provider streams tool arguments
+            streams_arguments = info.get("streams_arguments", False) if info else False
+
+            if event_type == "start":
+                if streams_arguments:
+                    # OpenAI: Switch to plain text and show tool call header
+                    self._switch_to_plain_text()
+                    tool_name = info.get("tool_name", "unknown") if info else "unknown"
+                    self.update(f"\n→ Calling {tool_name}\n")
+                else:
+                    # Anthropic: Close streaming display immediately
+                    self.close()
+                return
+            elif event_type == "delta":
+                if streams_arguments and info and "chunk" in info:
+                    # Stream the tool argument chunks as plain text
+                    self.update(info["chunk"])
+            elif event_type == "text":
+                self._pause_progress_display()
+            elif event_type == "stop":
+                if streams_arguments:
+                    # Close the streaming display
+                    self.update("\n")
+                    self.close()
+                else:
+                    self._resume_progress_display()
+        except Exception as e:
+            # Log but don't crash - streaming display is "nice to have"
+            logger.warning(
+                "Error handling tool event",
+                exc_info=True,
+                data={
+                    "event_type": event_type,
+                    "streams_arguments": info.get("streams_arguments") if info else None,
+                    "error": str(e),
+                },
+            )