fast-agent-mcp 0.4.7__py3-none-any.whl

fast_agent/ui/tool_display.py

@@ -0,0 +1,422 @@
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Any, Mapping
+
+from rich.syntax import Syntax
+from rich.text import Text
+
+from fast_agent.ui import console
+from fast_agent.ui.message_primitives import MESSAGE_CONFIGS, MessageType
+
+if TYPE_CHECKING:
+    from mcp.types import CallToolResult
+
+    from fast_agent.mcp.skybridge import SkybridgeServerConfig
+    from fast_agent.ui.console_display import ConsoleDisplay
+
+
+class ToolDisplay:
+    """Encapsulates rendering logic for tool calls and results."""
+
+    def __init__(self, display: "ConsoleDisplay") -> None:
+        self._display = display
+
+    @property
+    def _markup(self) -> bool:
+        return self._display._markup
+
+    def show_tool_result(
+        self,
+        result: CallToolResult,
+        *,
+        name: str | None = None,
+        tool_name: str | None = None,
+        skybridge_config: "SkybridgeServerConfig | None" = None,
+        timing_ms: float | None = None,
+        type_label: str = "tool result",
+    ) -> None:
+        """Display a tool result in the console."""
+        config = self._display.config
+        if config and not config.logger.show_tools:
+            return
+
+        from fast_agent.mcp.helpers.content_helpers import get_text, is_text_content
+
+        content = result.content
+        structured_content = getattr(result, "structuredContent", None)
+        has_structured = structured_content is not None
+
+        is_skybridge_tool = False
+        skybridge_resource_uri: str | None = None
+        if has_structured and tool_name and skybridge_config:
+            for tool_cfg in skybridge_config.tools:
+                if tool_cfg.tool_name == tool_name and tool_cfg.is_valid:
+                    is_skybridge_tool = True
+                    skybridge_resource_uri = tool_cfg.resource_uri
+                    break
+
+        if result.isError:
+            status = "ERROR"
+        else:
+            if not content:
+                status = "No Content"
+            elif len(content) == 1 and is_text_content(content[0]):
+                text_content = get_text(content[0])
+                char_count = len(text_content) if text_content else 0
+                status = f"Text Only {char_count} chars"
+            else:
+                text_count = sum(1 for item in content if is_text_content(item))
+                if text_count == len(content):
+                    status = f"{len(content)} Text Blocks" if len(content) > 1 else "1 Text Block"
+                else:
+                    status = (
+                        f"{len(content)} Content Blocks" if len(content) > 1 else "1 Content Block"
+                    )
+
+        channel = getattr(result, "transport_channel", None)
+        bottom_metadata_items: list[str] = []
+        if channel:
+            if channel == "post-json":
+                transport_info = "HTTP (JSON-RPC)"
+            elif channel == "post-sse":
+                transport_info = "HTTP (SSE)"
+            elif channel == "get":
+                transport_info = "Legacy SSE"
+            elif channel == "resumption":
+                transport_info = "Resumption"
+            elif channel == "stdio":
+                transport_info = "STDIO"
+            else:
+                transport_info = channel.upper()
+
+            bottom_metadata_items.append(transport_info)
+
+        # Use timing from FAST_AGENT_TOOL_TIMING (passed as parameter)
+        if timing_ms is not None:
+            # Convert ms to seconds for display
+            timing_seconds = timing_ms / 1000.0
+            bottom_metadata_items.append(self._display._format_elapsed(timing_seconds))
+
+        if has_structured:
+            bottom_metadata_items.append("Structured ■")
+
+        bottom_metadata = bottom_metadata_items or None
+        right_info = f"[dim]{type_label} - {status}[/dim]"
+
+        if has_structured:
+            config_map = MESSAGE_CONFIGS[MessageType.TOOL_RESULT]
+            block_color = "red" if result.isError else config_map["block_color"]
+            arrow = config_map["arrow"]
+            arrow_style = config_map["arrow_style"]
+            left = f"[{block_color}]▎[/{block_color}][{arrow_style}]{arrow}[/{arrow_style}]"
+            if name:
+                name_color = block_color if not result.isError else "red"
+                left += f" [{name_color}]{name}[/{name_color}]"
+
+            self._display._create_combined_separator_status(left, right_info)
+
+            self._display._display_content(
+                content,
+                True,
+                result.isError,
+                MessageType.TOOL_RESULT,
+                check_markdown_markers=False,
+            )
+
+            console.console.print()
+            total_width = console.console.size.width
+
+            if is_skybridge_tool:
+                resource_label = (
+                    f"skybridge resource: {skybridge_resource_uri}"
+                    if skybridge_resource_uri
+                    else "skybridge resource"
+                )
+                prefix = Text("─| ")
+                prefix.stylize("dim")
+                resource_text = Text(resource_label, style="magenta")
+                suffix = Text(" |")
+                suffix.stylize("dim")
+
+                separator_line = Text()
+                separator_line.append_text(prefix)
+                separator_line.append_text(resource_text)
+                separator_line.append_text(suffix)
+                remaining = total_width - separator_line.cell_len
+                if remaining > 0:
+                    separator_line.append("─" * remaining, style="dim")
+                console.console.print(separator_line, markup=self._markup)
+                console.console.print()
+
+                json_str = json.dumps(structured_content, indent=2)
+                syntax_obj = Syntax(
+                    json_str,
+                    "json",
+                    theme=self._display.code_style,
+                    background_color="default",
+                )
+                console.console.print(syntax_obj, markup=self._markup)
+            else:
+                prefix = Text("─| ")
+                prefix.stylize("dim")
+                suffix = Text(" |")
+                suffix.stylize("dim")
+                available = max(0, total_width - prefix.cell_len - suffix.cell_len)
+
+                metadata_text = self._display._format_bottom_metadata(
+                    bottom_metadata_items,
+                    None,
+                    config_map["highlight_color"],
+                    max_width=available,
+                )
+
+                line = Text()
+                line.append_text(prefix)
+                line.append_text(metadata_text)
+                line.append_text(suffix)
+                remaining = total_width - line.cell_len
+                if remaining > 0:
+                    line.append("─" * remaining, style="dim")
+                console.console.print(line, markup=self._markup)
+                console.console.print()
+        else:
+            self._display.display_message(
+                content=content,
+                message_type=MessageType.TOOL_RESULT,
+                name=name,
+                right_info=right_info,
+                bottom_metadata=bottom_metadata,
+                is_error=result.isError,
+                truncate_content=True,
+            )
+
+    def show_tool_call(
+        self,
+        tool_name: str,
+        tool_args: dict[str, Any] | 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,
+        type_label: str = "tool call",
+    ) -> None:
+        """Display a tool call header and body."""
+        config = self._display.config
+        if config and not config.logger.show_tools:
+            return
+
+        tool_args = tool_args or {}
+        metadata = metadata or {}
+
+        right_info = f"[dim]{type_label} - {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):
+                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
+
+            shell_name = metadata.get("shell_name") or "shell"
+            shell_path = metadata.get("shell_path")
+            if shell_path:
+                bottom_items.append(str(shell_path))
+
+            right_parts: list[str] = []
+            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
+
+            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"
+                )
+
+        self._display.display_message(
+            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=truncate_content,
+        )
+
+    async def show_tool_update(self, updated_server: str, *, agent_name: str | None = None) -> None:
+        """Show a background tool update notification."""
+        config = self._display.config
+        if config and not config.logger.show_tools:
+            return
+
+        try:
+            from prompt_toolkit.application.current import get_app
+
+            app = get_app()
+            from fast_agent.ui import notification_tracker
+
+            notification_tracker.add_tool_update(updated_server)
+            app.invalidate()
+        except Exception:  # noqa: BLE001
+            if agent_name:
+                left = f"[magenta]▎[/magenta][dim magenta]▶[/dim magenta] [magenta]{agent_name}[/magenta]"
+            else:
+                left = "[magenta]▎[/magenta][dim magenta]▶[/dim magenta]"
+
+            right = f"[dim]{updated_server}[/dim]"
+            self._display._create_combined_separator_status(left, right)
+
+            message = f"Updating tools for server {updated_server}"
+            console.console.print(message, style="dim", markup=self._markup)
+
+            console.console.print()
+            console.console.print("─" * console.console.size.width, style="dim")
+            console.console.print()
+
+    @staticmethod
+    def summarize_skybridge_configs(
+        configs: Mapping[str, "SkybridgeServerConfig"] | None,
+    ) -> tuple[list[dict[str, Any]], list[str]]:
+        """Convert Skybridge configs into display-ready structures."""
+        server_rows: list[dict[str, Any]] = []
+        warnings: list[str] = []
+        warning_seen: set[str] = set()
+
+        if not configs:
+            return server_rows, warnings
+
+        def add_warning(message: str) -> None:
+            formatted = message.strip()
+            if not formatted:
+                return
+            if formatted not in warning_seen:
+                warnings.append(formatted)
+                warning_seen.add(formatted)
+
+        for server_name in sorted(configs.keys()):
+            config = configs.get(server_name)
+            if not config:
+                continue
+            resources = list(config.ui_resources or [])
+            has_skybridge_signal = bool(
+                config.enabled or resources or config.tools or config.warnings
+            )
+            if not has_skybridge_signal:
+                continue
+
+            valid_resource_count = sum(1 for resource in resources if resource.is_skybridge)
+
+            server_rows.append(
+                {
+                    "server_name": server_name,
+                    "config": config,
+                    "resources": resources,
+                    "valid_resource_count": valid_resource_count,
+                    "total_resource_count": len(resources),
+                    "active_tools": [
+                        {
+                            "name": tool.display_name,
+                            "template": str(tool.template_uri) if tool.template_uri else None,
+                        }
+                        for tool in config.tools
+                        if tool.is_valid
+                    ],
+                    "enabled": config.enabled,
+                }
+            )
+
+            for warning in config.warnings:
+                message = warning.strip()
+                if not message:
+                    continue
+                if not message.startswith(server_name):
+                    message = f"{server_name} {message}"
+                add_warning(message)
+
+        return server_rows, warnings
+
+    def show_skybridge_summary(
+        self,
+        agent_name: str,
+        configs: Mapping[str, "SkybridgeServerConfig"] | None,
+    ) -> None:
+        """Display aggregated Skybridge status."""
+        server_rows, warnings = self.summarize_skybridge_configs(configs)
+
+        if not server_rows and not warnings:
+            return
+
+        heading = "[dim]OpenAI Apps SDK ([/dim][cyan]skybridge[/cyan][dim]) detected:[/dim]"
+        console.console.print()
+        console.console.print(heading, markup=self._markup)
+
+        if not server_rows:
+            console.console.print("[dim]  ● none detected[/dim]", markup=self._markup)
+        else:
+            for row in server_rows:
+                server_name = row["server_name"]
+                resource_count = row["valid_resource_count"]
+                tool_infos = row["active_tools"]
+                enabled = row["enabled"]
+
+                tool_count = len(tool_infos)
+                tool_word = "tool" if tool_count == 1 else "tools"
+                resource_word = (
+                    "skybridge resource" if resource_count == 1 else "skybridge resources"
+                )
+                tool_segment = f"[cyan]{tool_count}[/cyan][dim] {tool_word}[/dim]"
+                resource_segment = f"[cyan]{resource_count}[/cyan][dim] {resource_word}[/dim]"
+                name_style = "cyan" if enabled else "yellow"
+                status_suffix = "" if enabled else "[dim] (issues detected)[/dim]"
+
+                console.console.print(
+                    f"[dim]  ● [/dim][{name_style}]{server_name}[/{name_style}]{status_suffix}"
+                    f"[dim] — [/dim]{tool_segment}[dim], [/dim]{resource_segment}",
+                    markup=self._markup,
+                )
+
+                if tool_infos:
+                    for tool in tool_infos:
+                        template_info = (
+                            f" [dim]({tool['template']})[/dim]" if tool["template"] else ""
+                        )
+                        console.console.print(
+                            f"[dim]     · [/dim]{tool['name']}{template_info}", markup=self._markup
+                        )
+                else:
+                    console.console.print("[dim]     · no active tools[/dim]", markup=self._markup)
+
+        if warnings:
+            console.console.print()
+            console.console.print(
+                "[yellow]Warnings[/yellow]",
+                markup=self._markup,
+            )
+            for warning in warnings:
+                console.console.print(f"[yellow]- {warning}[/yellow]", markup=self._markup)

fast_agent/ui/usage_display.py

@@ -0,0 +1,204 @@
+"""
+Utility module for displaying usage statistics in a consistent format.
+Consolidates the usage display logic that was duplicated between fastagent.py and interactive_prompt.py.
+"""
+
+from typing import Any
+
+from rich.console import Console
+
+
+def display_usage_report(
+    agents: dict[str, Any], show_if_progress_disabled: bool = False, subdued_colors: bool = False
+) -> None:
+    """
+    Display a formatted table of token usage for all agents.
+
+    Args:
+        agents: Dictionary of agent name -> agent object
+        show_if_progress_disabled: If True, show even when progress display is disabled
+        subdued_colors: If True, use dim styling for a more subdued appearance
+    """
+    # Check if progress display is enabled (only relevant for fastagent context)
+    if not show_if_progress_disabled:
+        try:
+            from fast_agent import config
+
+            settings = config.get_settings()
+            if not settings.logger.progress_display:
+                return
+        except (ImportError, AttributeError):
+            # If we can't check settings, assume we should display
+            pass
+
+    # Collect usage data from all agents
+    usage_data = []
+    total_input = 0
+    total_output = 0
+    total_tokens = 0
+    total_tool_calls = 0
+
+    for agent_name, agent in agents.items():
+        if agent.usage_accumulator:
+            summary = agent.usage_accumulator.get_summary()
+            if summary["turn_count"] > 0:
+                input_tokens = summary["cumulative_input_tokens"]
+                output_tokens = summary["cumulative_output_tokens"]
+                billing_tokens = summary["cumulative_billing_tokens"]
+                turns = summary["turn_count"]
+                tool_calls = summary["cumulative_tool_calls"]
+
+                # Get context percentage for this agent
+                context_percentage = agent.usage_accumulator.context_usage_percentage
+
+                # Get model name via typed property when available
+                model = "unknown"
+                if agent.llm:
+                    model = agent.llm.model_name or "unknown"
+
+                # Standardize model name truncation - use consistent 25 char width with 22+... truncation
+                if len(model) > 25:
+                    model = model[:22] + "..."
+
+                usage_data.append(
+                    {
+                        "name": agent_name,
+                        "model": model,
+                        "input": input_tokens,
+                        "output": output_tokens,
+                        "total": billing_tokens,
+                        "turns": turns,
+                        "tool_calls": tool_calls,
+                        "context": context_percentage,
+                    }
+                )
+
+                total_input += input_tokens
+                total_output += output_tokens
+                total_tokens += billing_tokens
+                total_tool_calls += tool_calls
+
+    if not usage_data:
+        return
+
+    # Calculate dynamic agent column width (max 15)
+    max_agent_width = min(15, max(len(data["name"]) for data in usage_data) if usage_data else 8)
+    agent_width = max(max_agent_width, 5)  # Minimum of 5 for "Agent" header
+
+    # Display the table with new visual style
+    console = Console()
+
+    # Top separator
+    console.print()
+    console.print("─" * console.size.width, style="dim")
+    console.print()
+
+    # Header with block character
+    console.print("[dim]▎[/dim] [bold dim]Usage Summary[/bold dim]")
+    console.print()
+
+    # Table header with proper spacing
+    console.print(
+        f"[dim]{'Agent':<{agent_width}} {'Input':>9} {'Output':>9} {'Total':>9} {'Turns':>6} {'Tools':>6} {'Context%':>9}  {'Model':<25}[/dim]"
+    )
+
+    # Print agent rows - use styling based on subdued_colors flag
+    for data in usage_data:
+        input_str = f"{data['input']:,}"
+        output_str = f"{data['output']:,}"
+        total_str = f"{data['total']:,}"
+        turns_str = str(data["turns"])
+        tools_str = str(data["tool_calls"])
+        context_str = f"{data['context']:.1f}%" if data["context"] is not None else "-"
+
+        # Truncate agent name if needed
+        agent_name = data["name"]
+        if len(agent_name) > agent_width:
+            agent_name = agent_name[: agent_width - 3] + "..."
+
+        if subdued_colors:
+            # Original fastagent.py style with dim wrapper
+            console.print(
+                f"[dim]{agent_name:<{agent_width}} "
+                f"{input_str:>9} "
+                f"{output_str:>9} "
+                f"[bold]{total_str:>9}[/bold] "
+                f"{turns_str:>6} "
+                f"{tools_str:>6} "
+                f"{context_str:>9}  "
+                f"{data['model']:<25}[/dim]"
+            )
+        else:
+            # Original interactive_prompt.py style
+            console.print(
+                f"{agent_name:<{agent_width}} "
+                f"{input_str:>9} "
+                f"{output_str:>9} "
+                f"[bold]{total_str:>9}[/bold] "
+                f"{turns_str:>6} "
+                f"{tools_str:>6} "
+                f"{context_str:>9}  "
+                f"[dim]{data['model']:<25}[/dim]"
+            )
+
+    # Add total row if multiple agents
+    if len(usage_data) > 1:
+        console.print()
+        total_input_str = f"{total_input:,}"
+        total_output_str = f"{total_output:,}"
+        total_tokens_str = f"{total_tokens:,}"
+        total_tools_str = str(total_tool_calls)
+
+        if subdued_colors:
+            # Original fastagent.py style with dim wrapper on bold
+            console.print(
+                f"[bold dim]{'TOTAL':<{agent_width}} "
+                f"{total_input_str:>9} "
+                f"{total_output_str:>9} "
+                f"[bold]{total_tokens_str:>9}[/bold] "
+                f"{'':<6} "
+                f"{total_tools_str:>6} "
+                f"{'':<9}  "
+                f"{'':<25}[/bold dim]"
+            )
+        else:
+            # Original interactive_prompt.py style
+            console.print(
+                f"[bold]{'TOTAL':<{agent_width}}[/bold] "
+                f"[bold]{total_input_str:>9}[/bold] "
+                f"[bold]{total_output_str:>9}[/bold] "
+                f"[bold]{total_tokens_str:>9}[/bold] "
+                f"{'':<6} "
+                f"[bold]{total_tools_str:>6}[/bold] "
+                f"{'':<9}  "
+                f"{'':<25}"
+            )
+
+    console.print()
+
+
+def collect_agents_from_provider(
+    prompt_provider: Any, agent_name: str | None = None
+) -> dict[str, Any]:
+    """
+    Collect agents from a prompt provider for usage display.
+
+    Args:
+        prompt_provider: Provider that has access to agents
+        agent_name: Name of the current agent (for context)
+
+    Returns:
+        Dictionary of agent name -> agent object
+    """
+    agents_to_show = {}
+
+    if hasattr(prompt_provider, "_agents"):
+        # Multi-agent app - show all agents
+        agents_to_show = prompt_provider._agents
+    elif hasattr(prompt_provider, "agent"):
+        # Single agent
+        agent = prompt_provider.agent
+        if hasattr(agent, "name"):
+            agents_to_show = {agent.name: agent}
+
+    return agents_to_show

fast_agent/utils/__init__.py

@@ -0,0 +1,5 @@
+"""Utility helpers for fast-agent."""
+
+from .time import format_duration
+
+__all__ = ["format_duration"]