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

fast_agent/ui/elicitation_form.py

@@ -1,5 +1,6 @@
 """Simplified, robust elicitation form dialog."""
 
+import re
 from datetime import date, datetime
 from typing import Any, Dict, Optional
 
@@ -63,9 +64,15 @@ class SimpleNumberValidator(Validator):
 class SimpleStringValidator(Validator):
     """Simple string validator with real-time feedback."""
 
-    def __init__(self, min_length: Optional[int] = None, max_length: Optional[int] = None):
+    def __init__(
+        self,
+        min_length: Optional[int] = None,
+        max_length: Optional[int] = None,
+        pattern: Optional[str] = None
+    ):
         self.min_length = min_length
         self.max_length = max_length
+        self.pattern = re.compile(pattern, re.DOTALL) if pattern else None
 
     def validate(self, document):
         text = document.text
@@ -83,6 +90,12 @@ class SimpleStringValidator(Validator):
                 cursor_position=self.max_length,
             )
 
+        if self.pattern is not None and self.pattern.fullmatch(text) is None:
+            # TODO: Wrap or truncate line if too long
+            raise ValidationError(
+                message=f"Must match pattern '{self.pattern.pattern}'", cursor_position=len(text)
+            )
+
 
 class FormatValidator(Validator):
     """Format-specific validator using Pydantic validators."""
@@ -429,6 +442,8 @@ class ElicitationForm:
             constraints["minLength"] = field_def["minLength"]
         if field_def.get("maxLength") is not None:
             constraints["maxLength"] = field_def["maxLength"]
+        if field_def.get("pattern") is not None:
+            constraints["pattern"] = field_def["pattern"]
 
         # Check anyOf constraints (for Optional fields)
         if "anyOf" in field_def:
@@ -438,6 +453,8 @@ class ElicitationForm:
                         constraints["minLength"] = variant["minLength"]
                     if variant.get("maxLength") is not None:
                         constraints["maxLength"] = variant["maxLength"]
+                    if variant.get("pattern") is not None:
+                        constraints["pattern"] = variant["pattern"]
                     break
 
         return constraints
@@ -468,6 +485,10 @@ class ElicitationForm:
             if constraints.get("maxLength"):
                 hints.append(f"max {constraints['maxLength']} chars")
 
+            if constraints.get("pattern"):
+                # TODO: Wrap or truncate line if too long
+                format_hint = f"Pattern: {constraints['pattern']}"
+
             # Handle format hints separately (these go on next line)
             format_type = field_def.get("format")
             if format_type:
@@ -545,6 +566,7 @@ class ElicitationForm:
                     validator = SimpleStringValidator(
                         min_length=constraints.get("minLength"),
                         max_length=constraints.get("maxLength"),
+                        pattern=constraints.get("pattern"),
                     )
             else:
                 constraints = {}

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,102 @@ 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
 
@@ -829,6 +882,46 @@ async def get_enhanced_input(
                 # Display info for all available agents with tree structure for workflows
                 await _display_all_agents_with_hierarchy(available_agents, agent_provider)
 
+            # Show streaming status message
+            if agent_provider:
+                # Get logger settings from the agent's context (not agent_provider)
+                logger_settings = None
+                try:
+                    agent = agent_provider._agent(agent_name)
+                    agent_context = agent._context or agent.context
+                    logger_settings = agent_context.config.logger
+                except Exception:
+                    # If we can't get the agent or its context, logger_settings stays None
+                    pass
+
+                # Only show streaming messages if chat display is enabled AND we have logger_settings
+                if logger_settings:
+                    show_chat = getattr(logger_settings, "show_chat", True)
+
+                    if show_chat:
+                        # Check for parallel agents
+                        has_parallel = any(
+                            agent.agent_type == AgentType.PARALLEL
+                            for agent in agent_provider._agents.values()
+                        )
+
+                        # Note: streaming may have been disabled by fastagent.py if parallel agents exist
+                        # So we check has_parallel first to show the appropriate message
+                        if has_parallel:
+                            # Streaming is disabled due to parallel agents
+                            rich_print(
+                                "[dim]Markdown Streaming disabled (Parallel Agents configured)[/dim]"
+                            )
+                        else:
+                            # Check if streaming is enabled
+                            streaming_enabled = getattr(logger_settings, "streaming_display", True)
+                            streaming_mode = getattr(logger_settings, "streaming", "markdown")
+                            if streaming_enabled and streaming_mode != "none":
+                                # Streaming is enabled - notify users since it's experimental
+                                rich_print(
+                                    f"[dim]Experimental: Streaming Enabled - {streaming_mode} mode[/dim]"
+                                )
+
         rich_print()
         help_message_shown = True
 
@@ -1022,7 +1115,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.
 

fast_agent/ui/interactive_prompt.py

@@ -14,7 +14,7 @@ Usage:
     )
 """
 
-from typing import TYPE_CHECKING, Awaitable, Callable, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Any, Awaitable, Callable, Dict, List, Optional, Union, cast
 
 if TYPE_CHECKING:
     from fast_agent.core.agent_app import AgentApp
@@ -25,6 +25,7 @@ from rich import print as rich_print
 from fast_agent.agents.agent_types import AgentType
 from fast_agent.history.history_exporter import HistoryExporter
 from fast_agent.mcp.mcp_aggregator import SEP
+from fast_agent.mcp.types import McpAgentProtocol
 from fast_agent.types import PromptMessageExtended
 from fast_agent.ui.enhanced_prompt import (
     _display_agent_info_helper,
@@ -114,8 +115,9 @@ class InteractivePrompt:
 
                 # Check if we should switch agents
                 if isinstance(command_result, dict):
-                    if "switch_agent" in command_result:
-                        new_agent = command_result["switch_agent"]
+                    command_dict: Dict[str, Any] = command_result
+                    if "switch_agent" in command_dict:
+                        new_agent = command_dict["switch_agent"]
                         if new_agent in available_agents_set:
                             agent = new_agent
                             # Display new agent info immediately when switching
@@ -126,14 +128,14 @@ class InteractivePrompt:
                             rich_print(f"[red]Agent '{new_agent}' not found[/red]")
                             continue
                     # Keep the existing list_prompts handler for backward compatibility
-                    elif "list_prompts" in command_result:
+                    elif "list_prompts" in command_dict:
                         # Use the prompt_provider directly
                         await self._list_prompts(prompt_provider, agent)
                         continue
-                    elif "select_prompt" in command_result:
+                    elif "select_prompt" in command_dict:
                         # Handle prompt selection, using both list_prompts and apply_prompt
-                        prompt_name = command_result.get("prompt_name")
-                        prompt_index = command_result.get("prompt_index")
+                        prompt_name = command_dict.get("prompt_name")
+                        prompt_index = command_dict.get("prompt_index")
 
                         # If a specific index was provided (from /prompt <number>)
                         if prompt_index is not None:
@@ -163,16 +165,20 @@ class InteractivePrompt:
                             # Use the name-based selection
                             await self._select_prompt(prompt_provider, agent, prompt_name)
                         continue
-                    elif "list_tools" in command_result:
+                    elif "list_tools" in command_dict:
                         # Handle tools list display
                         await self._list_tools(prompt_provider, agent)
                         continue
-                    elif "show_usage" in command_result:
+                    elif "show_usage" in command_dict:
                         # Handle usage display
                         await self._show_usage(prompt_provider, agent)
                         continue
-                    elif "show_history" in command_result:
-                        target_agent = command_result.get("show_history", {}).get("agent") or agent
+                    elif "show_history" in command_dict:
+                        history_info = command_dict.get("show_history")
+                        history_agent = (
+                            history_info.get("agent") if isinstance(history_info, dict) else None
+                        )
+                        target_agent = history_agent or agent
                         try:
                             agent_obj = prompt_provider._agent(target_agent)
                         except Exception:
@@ -183,8 +189,12 @@ class InteractivePrompt:
                         usage = getattr(agent_obj, "usage_accumulator", None)
                         display_history_overview(target_agent, history, usage)
                         continue
-                    elif "clear_history" in command_result:
-                        target_agent = command_result.get("clear_history", {}).get("agent") or agent
+                    elif "clear_history" in command_dict:
+                        clear_info = command_dict.get("clear_history")
+                        clear_agent = (
+                            clear_info.get("agent") if isinstance(clear_info, dict) else None
+                        )
+                        target_agent = clear_agent or agent
                         try:
                             agent_obj = prompt_provider._agent(target_agent)
                         except Exception:
@@ -194,7 +204,9 @@ class InteractivePrompt:
                         if hasattr(agent_obj, "clear"):
                             try:
                                 agent_obj.clear()
-                                rich_print(f"[green]History cleared for agent '{target_agent}'.[/green]")
+                                rich_print(
+                                    f"[green]History cleared for agent '{target_agent}'.[/green]"
+                                )
                             except Exception as exc:
                                 rich_print(
                                     f"[red]Failed to clear history for '{target_agent}': {exc}[/red]"
@@ -204,21 +216,21 @@ class InteractivePrompt:
                                 f"[yellow]Agent '{target_agent}' does not support clearing history.[/yellow]"
                             )
                         continue
-                    elif "show_system" in command_result:
+                    elif "show_system" in command_dict:
                         # Handle system prompt display
                         await self._show_system(prompt_provider, agent)
                         continue
-                    elif "show_markdown" in command_result:
+                    elif "show_markdown" in command_dict:
                         # Handle markdown display
                         await self._show_markdown(prompt_provider, agent)
                         continue
-                    elif "show_mcp_status" in command_result:
+                    elif "show_mcp_status" in command_dict:
                         rich_print()
                         await show_mcp_status(agent, prompt_provider)
                         continue
-                    elif "save_history" in command_result:
+                    elif "save_history" in command_dict:
                         # Save history for the current agent
-                        filename = command_result.get("filename")
+                        filename = command_dict.get("filename")
                         try:
                             agent_obj = prompt_provider._agent(agent)
 
@@ -353,15 +365,16 @@ class InteractivePrompt:
                                 )
                             else:
                                 # Handle Prompt objects from mcp.types
+                                prompt_obj = cast("Prompt", prompt)
                                 all_prompts.append(
                                     {
                                         "server": server_name,
-                                        "name": prompt.name,
-                                        "namespaced_name": f"{server_name}{SEP}{prompt.name}",
-                                        "title": prompt.title or None,
-                                        "description": prompt.description or "No description",
-                                        "arg_count": len(prompt.arguments or []),
-                                        "arguments": prompt.arguments or [],
+                                        "name": prompt_obj.name,
+                                        "namespaced_name": f"{server_name}{SEP}{prompt_obj.name}",
+                                        "title": prompt_obj.title or None,
+                                        "description": prompt_obj.description or "No description",
+                                        "arg_count": len(prompt_obj.arguments or []),
+                                        "arguments": prompt_obj.arguments or [],
                                     }
                                 )
 
@@ -856,6 +869,10 @@ class InteractivePrompt:
                 if tool.title and tool.title.strip():
                     tool_line.append(f" {tool.title}", style="default")
 
+                meta = getattr(tool, "meta", {}) or {}
+                if meta.get("openai/skybridgeEnabled"):
+                    tool_line.append(" (skybridge)", style="cyan")
+
                 rich_print(tool_line)
 
                 # Description lines - show 2-3 rows if needed
@@ -909,6 +926,11 @@ class InteractivePrompt:
                                 args_text = args_text[:77] + "..."
                             rich_print(f"     [dim magenta]args: {args_text}[/dim magenta]")
 
+                if meta.get("openai/skybridgeEnabled"):
+                    template = meta.get("openai/skybridgeTemplate")
+                    if template:
+                        rich_print(f"     [dim magenta]template:[/dim magenta] {template}")
+
                 rich_print()  # Space between tools
 
         except Exception as e:
@@ -962,22 +984,23 @@ class InteractivePrompt:
 
             # Get server count for display
             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
 
             # Use the display utility to show the system prompt
-            if hasattr(agent, "display") and agent.display:
-                agent.display.show_system_message(
+            agent_display = getattr(agent, "display", None)
+            if agent_display:
+                agent_display.show_system_message(
                     system_prompt=system_prompt, agent_name=agent_name, server_count=server_count
                 )
             else:
                 # Fallback to basic display
                 from fast_agent.ui.console_display import ConsoleDisplay
 
+                agent_context = getattr(agent, "context", None)
                 display = ConsoleDisplay(
-                    config=agent.context.config if hasattr(agent, "context") else None
+                    config=agent_context.config if hasattr(agent_context, "config") else None
                 )
                 display.show_system_message(
                     system_prompt=system_prompt, agent_name=agent_name, server_count=server_count
@@ -1005,11 +1028,11 @@ class InteractivePrompt:
             agent = prompt_provider._agent(agent_name)
 
             # Check if agent has message history
-            if not hasattr(agent, "_llm") or not agent._llm:
+            if not agent.llm:
                 rich_print("[yellow]No message history available[/yellow]")
                 return
 
-            message_history = agent._llm.message_history
+            message_history = agent.llm.message_history
             if not message_history:
                 rich_print("[yellow]No messages in history[/yellow]")
                 return