fast-agent-mcp 0.3.13__py3-none-any.whl → 0.3.14__py3-none-any.whl

fast_agent/ui/console_display.py

@@ -1,6 +1,6 @@
 from enum import Enum
 from json import JSONDecodeError
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Mapping, Optional, Set, Tuple, Union
 
 from mcp.types import CallToolResult
 from rich.panel import Panel
@@ -18,6 +18,7 @@ from fast_agent.ui.mermaid_utils import (
 
 if TYPE_CHECKING:
     from fast_agent.mcp.prompt_message_extended import PromptMessageExtended
+    from fast_agent.mcp.skybridge import SkybridgeServerConfig
 
 CODE_STYLE = "native"
 
@@ -538,8 +539,21 @@ class ConsoleDisplay:
 
         return formatted
 
-    def show_tool_result(self, result: CallToolResult, name: str | None = None) -> None:
-        """Display a tool result in the new visual style."""
+    def show_tool_result(
+        self,
+        result: CallToolResult,
+        name: str | None = None,
+        tool_name: str | None = None,
+        skybridge_config: "SkybridgeServerConfig | None" = None,
+    ) -> None:
+        """Display a tool result in the new visual style.
+
+        Args:
+            result: The tool result to display
+            name: Optional agent name
+            tool_name: Optional tool name for skybridge detection
+            skybridge_config: Optional skybridge configuration for the server
+        """
         if not self.config or not self.config.logger.show_tools:
             return
 
@@ -548,6 +562,20 @@ class ConsoleDisplay:
 
         # Analyze content to determine display format and status
         content = result.content
+        structured_content = getattr(result, "structuredContent", None)
+        has_structured = structured_content is not None
+
+        # Determine if this is a skybridge tool
+        is_skybridge_tool = False
+        skybridge_resource_uri = None
+        if has_structured and tool_name and skybridge_config:
+            # Check if this tool is a valid skybridge tool
+            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:
@@ -575,9 +603,9 @@ class ConsoleDisplay:
             if channel == "post-json":
                 transport_info = "HTTP (JSON-RPC)"
             elif channel == "post-sse":
-                transport_info = "HTTP (SSE)"
+                transport_info = "Legacy SSE"
             elif channel == "get":
-                transport_info = "HTTP (SSE)"
+                transport_info = "Legacy SSE"
             elif channel == "resumption":
                 transport_info = "Resumption"
             elif channel == "stdio":
@@ -591,21 +619,138 @@ class ConsoleDisplay:
         if isinstance(elapsed, (int, float)):
             bottom_metadata_items.append(self._format_elapsed(float(elapsed)))
 
+        # Add structured content indicator if present
+        if has_structured:
+            bottom_metadata_items.append("Structured ■")
+
         bottom_metadata = bottom_metadata_items or None
 
         # Build right info (without channel info)
         right_info = f"[dim]tool result - {status}[/dim]"
 
-        # Display using unified method
-        self.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,
-        )
+        if has_structured:
+            # Handle structured content display manually to insert it before bottom separator
+            # Display main content without bottom separator
+            config = MESSAGE_CONFIGS[MessageType.TOOL_RESULT]
+            block_color = "red" if result.isError else config["block_color"]
+            arrow = config["arrow"]
+            arrow_style = config["arrow_style"]
+            left = f"[{block_color}]▎[/{block_color}][{arrow_style}]{arrow}[/{arrow_style}]"
+            if name:
+                left += f" [{block_color if not result.isError else 'red'}]{name}[/{block_color if not result.isError else 'red'}]"
+
+            # Top separator
+            self._create_combined_separator_status(left, right_info)
+
+            # Main content
+            self._display_content(
+                content, True, result.isError, MessageType.TOOL_RESULT, check_markdown_markers=False
+            )
+
+            # Structured content separator and display
+            console.console.print()
+            total_width = console.console.size.width
+
+            if is_skybridge_tool:
+                # Skybridge: magenta separator with resource URI
+                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()
+
+                # Display with bright syntax highlighting
+                import json
+
+                from rich.syntax import Syntax
+
+                json_str = json.dumps(structured_content, indent=2)
+                syntax_obj = Syntax(json_str, "json", theme=CODE_STYLE, background_color="default")
+                console.console.print(syntax_obj, markup=self._markup)
+            else:
+                # Regular tool: dim separator
+                prefix = Text("─| ")
+                prefix.stylize("dim")
+                label_text = Text("Structured Content", style="dim")
+                suffix = Text(" |")
+                suffix.stylize("dim")
+
+                separator_line = Text()
+                separator_line.append_text(prefix)
+                separator_line.append_text(label_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()
+
+                # Display truncated content in dim
+                from rich.pretty import Pretty
+
+                if self.config and self.config.logger.truncate_tools:
+                    pretty_obj = Pretty(structured_content, max_length=10, max_string=50)
+                else:
+                    pretty_obj = Pretty(structured_content)
+                console.console.print(pretty_obj, style="dim", markup=self._markup)
+
+            # Bottom separator with metadata
+            console.console.print()
+            if bottom_metadata:
+                display_items = (
+                    self._shorten_items(bottom_metadata, 12) if True else bottom_metadata
+                )
+                prefix = Text("─| ")
+                prefix.stylize("dim")
+                suffix = Text(" |")
+                suffix.stylize("dim")
+                available = max(0, total_width - prefix.cell_len - suffix.cell_len)
+
+                metadata_text = self._format_bottom_metadata(
+                    display_items,
+                    None,
+                    config["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)
+            else:
+                console.console.print("─" * total_width, style="dim")
+            console.console.print()
+
+        else:
+            # No structured content - use standard display
+            self.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,
@@ -669,9 +814,7 @@ class ConsoleDisplay:
             # No active prompt_toolkit session - display with rich as before
             # Combined separator and status line
             if agent_name:
-                left = (
-                    f"[magenta]▎[/magenta][dim magenta]▶[/dim magenta] [magenta]{agent_name}[/magenta]"
-                )
+                left = f"[magenta]▎[/magenta][dim magenta]▶[/dim magenta] [magenta]{agent_name}[/magenta]"
             else:
                 left = "[magenta]▎[/magenta][dim magenta]▶[/dim magenta]"
 
@@ -727,6 +870,140 @@ class ConsoleDisplay:
         console.console.print(combined, markup=self._markup)
         console.console.print()
 
+    @staticmethod
+    def summarize_skybridge_configs(
+        configs: Mapping[str, "SkybridgeServerConfig"] | None,
+    ) -> Tuple[List[Dict[str, Any]], List[str]]:
+        """Convert raw Skybridge configs into display-friendly summary data."""
+        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 Skybridge availability and warnings."""
+        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"]
+                total_resource_count = row["total_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,
+                )
+
+                for tool_info in tool_infos:
+                    template_text = (
+                        f"[dim] ({tool_info['template']})[/dim]" if tool_info["template"] else ""
+                    )
+                    console.console.print(
+                        f"[dim]    ▶ [/dim][white]{tool_info['name']}[/white]{template_text}",
+                        markup=self._markup,
+                    )
+
+                if tool_count == 0 and resource_count > 0:
+                    console.console.print(
+                        "[dim]     ▶ tools not linked[/dim]",
+                        markup=self._markup,
+                    )
+                if not enabled and total_resource_count > resource_count:
+                    invalid_count = total_resource_count - resource_count
+                    invalid_word = "resource" if invalid_count == 1 else "resources"
+                    console.console.print(
+                        (
+                            "[dim]     ▶ "
+                            f"[/dim][cyan]{invalid_count}[/cyan][dim] {invalid_word} detected with non-skybridge MIME type[/dim]"
+                        ),
+                        markup=self._markup,
+                    )
+
+        for warning_entry in warnings:
+            console.console.print(
+                f"[dim red]  ▶ [/dim red][red]warning[/red] [dim]{warning_entry}[/dim]",
+                markup=self._markup,
+            )
+
     async def show_assistant_message(
         self,
         message_text: Union[str, Text, "PromptMessageExtended"],

fast_agent/ui/enhanced_prompt.py

@@ -9,7 +9,7 @@ import shlex
 import subprocess
 import tempfile
 from importlib.metadata import version
-from typing import TYPE_CHECKING, List, Optional
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
 from prompt_toolkit import PromptSession
 from prompt_toolkit.completion import Completer, Completion, WordCompleter
@@ -24,6 +24,7 @@ from fast_agent.agents.agent_types import AgentType
 from fast_agent.constants import FAST_AGENT_ERROR_CHANNEL, FAST_AGENT_REMOVED_METADATA_CHANNEL
 from fast_agent.core.exceptions import PromptExitError
 from fast_agent.llm.model_info import get_model_info
+from fast_agent.mcp.types import McpAgentProtocol
 from fast_agent.ui.mcp_display import render_mcp_status
 
 if TYPE_CHECKING:
@@ -103,10 +104,9 @@ async def _display_agent_info_helper(agent_name: str, agent_provider: "AgentApp
 
         # Get counts TODO -- add this to the type library or adjust the way aggregator/reporting works
         server_count = 0
-        if hasattr(agent, "_aggregator") and hasattr(agent._aggregator, "server_names"):
-            server_count = (
-                len(agent._aggregator.server_names) if agent._aggregator.server_names else 0
-            )
+        if isinstance(agent, McpAgentProtocol):
+            server_names = agent.aggregator.server_names
+            server_count = len(server_names) if server_names else 0
 
         tools_result = await agent.list_tools()
         tool_count = (
@@ -182,6 +182,17 @@ async def _display_agent_info_helper(agent_name: str, agent_provider: "AgentApp
                 rich_print(f"[dim]Agent [/dim][blue]{agent_name}[/blue][dim]:[/dim] {content}")
         #               await _render_mcp_status(agent)
 
+        # Display Skybridge status (if aggregator discovered any)
+        try:
+            aggregator = agent.aggregator if isinstance(agent, McpAgentProtocol) else None
+            display = getattr(agent, "display", None)
+            if aggregator and display and hasattr(display, "show_skybridge_summary"):
+                skybridge_configs = await aggregator.get_skybridge_configs()
+                display.show_skybridge_summary(agent_name, skybridge_configs)
+        except Exception:
+            # Ignore Skybridge rendering issues to avoid interfering with startup
+            pass
+
         # Mark as shown
         _agent_info_shown.add(agent_name)
 
@@ -648,60 +659,96 @@ async def get_enhanced_input(
         model_display = None
         tdv_segment = None
         turn_count = 0
-        try:
-            if agent_provider:
+        agent = None
+        if agent_provider:
+            try:
                 agent = agent_provider._agent(agent_name)
+            except Exception as exc:
+                print(f"[toolbar debug] unable to resolve agent '{agent_name}': {exc}")
 
-                # Get turn count from message history
-                for message in agent.message_history:
-                    if message.role == "user":
-                        turn_count += 1
-
-                # Get model name from LLM
-                if agent.llm and agent.llm.model_name:
-                    model_name = agent.llm.model_name
-                    # Truncate model name to max 25 characters with ellipsis
-                    max_len = 25
-                    if len(model_name) > max_len:
-                        # Keep total length at max_len including ellipsis
-                        model_display = model_name[: max_len - 1] + "…"
-                    else:
-                        model_display = model_name
-
-                # Build TDV capability segment based on model database
-                info = get_model_info(agent)
-                # Default to text-only if info resolution fails for any reason
-                t, d, v = (True, False, False)
-                if info:
-                    t, d, v = info.tdv_flags
-
-                # Check for alert flags in user messages
-                alert_flags: set[str] = set()
-                error_seen = False
-                for message in agent.message_history:
-                    if message.channels:
-                        if message.channels.get(FAST_AGENT_ERROR_CHANNEL):
-                            error_seen = True
-                    if message.role == "user" and message.channels:
-                        meta_blocks = message.channels.get(FAST_AGENT_REMOVED_METADATA_CHANNEL, [])
-                        alert_flags.update(_extract_alert_flags_from_meta(meta_blocks))
-
-                if error_seen and not alert_flags:
-                    alert_flags.add("T")
-
-                def _style_flag(letter: str, supported: bool) -> str:
-                    # Enabled uses the same color as NORMAL mode (ansigreen), disabled is dim
-                    if letter in alert_flags:
-                        return f"<style fg='ansired' bg='ansiblack'>{letter}</style>"
-
-                    enabled_color = "ansigreen"
-                    if supported:
-                        return f"<style fg='{enabled_color}' bg='ansiblack'>{letter}</style>"
-                    return f"<style fg='ansiblack' bg='ansiwhite'>{letter}</style>"
-
-                tdv_segment = f"{_style_flag('T', t)}{_style_flag('D', d)}{_style_flag('V', v)}"
-        except Exception:
-            # If anything goes wrong determining the model, omit it gracefully
+        if agent:
+            for message in agent.message_history:
+                if message.role == "user":
+                    turn_count += 1
+
+            # Resolve LLM reference safely (avoid assertion when unattached)
+            llm = None
+            try:
+                llm = agent.llm
+            except AssertionError:
+                llm = getattr(agent, "_llm", None)
+            except Exception as exc:
+                print(f"[toolbar debug] agent.llm access failed for '{agent_name}': {exc}")
+
+            model_name = None
+            if llm:
+                model_name = getattr(llm, "model_name", None)
+                if not model_name:
+                    model_name = getattr(getattr(llm, "default_request_params", None), "model", None)
+
+            if not model_name:
+                model_name = getattr(agent.config, "model", None)
+            if not model_name and getattr(agent.config, "default_request_params", None):
+                model_name = getattr(agent.config.default_request_params, "model", None)
+            if not model_name:
+                context = getattr(agent, "context", None) or getattr(agent_provider, "context", None)
+                config_obj = getattr(context, "config", None) if context else None
+                model_name = getattr(config_obj, "default_model", None)
+
+            if model_name:
+                max_len = 25
+                model_display = model_name[: max_len - 1] + "…" if len(model_name) > max_len else model_name
+            else:
+                print(f"[toolbar debug] no model resolved for agent '{agent_name}'")
+                model_display = "unknown"
+
+            # Build TDV capability segment based on model database
+            info = None
+            if llm:
+                try:
+                    info = get_model_info(llm)
+                except TypeError:
+                    info = None
+            if not info and model_name:
+                try:
+                    info = get_model_info(model_name)
+                except TypeError:
+                    info = None
+                except Exception as exc:
+                    print(f"[toolbar debug] get_model_info failed for '{agent_name}': {exc}")
+                    info = None
+
+            # Default to text-only if info resolution fails for any reason
+            t, d, v = (True, False, False)
+            if info:
+                t, d, v = info.tdv_flags
+
+            # Check for alert flags in user messages
+            alert_flags: set[str] = set()
+            error_seen = False
+            for message in agent.message_history:
+                if message.channels:
+                    if message.channels.get(FAST_AGENT_ERROR_CHANNEL):
+                        error_seen = True
+                if message.role == "user" and message.channels:
+                    meta_blocks = message.channels.get(FAST_AGENT_REMOVED_METADATA_CHANNEL, [])
+                    alert_flags.update(_extract_alert_flags_from_meta(meta_blocks))
+
+            if error_seen and not alert_flags:
+                alert_flags.add("T")
+
+            def _style_flag(letter: str, supported: bool) -> str:
+                # Enabled uses the same color as NORMAL mode (ansigreen), disabled is dim
+                if letter in alert_flags:
+                    return f"<style fg='ansired' bg='ansiblack'>{letter}</style>"
+
+                enabled_color = "ansigreen"
+                if supported:
+                    return f"<style fg='{enabled_color}' bg='ansiblack'>{letter}</style>"
+                return f"<style fg='ansiblack' bg='ansiwhite'>{letter}</style>"
+
+            tdv_segment = f"{_style_flag('T', t)}{_style_flag('D', d)}{_style_flag('V', v)}"
+        else:
             model_display = None
             tdv_segment = None
 
@@ -1022,7 +1069,9 @@ async def get_argument_input(
             prompt_session.app.exit()
 
 
-async def handle_special_commands(command, agent_app=None):
+async def handle_special_commands(
+    command: Any, agent_app: "AgentApp | None" = None
+) -> bool | Dict[str, Any]:
     """
     Handle special input commands.