fast-agent-mcp 0.3.9__tar.gz → 0.3.11__tar.gz

{fast_agent_mcp-0.3.9 → fast_agent_mcp-0.3.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.3.9
+Version: 0.3.11
 Summary: Define, Prompt and Test MCP enabled Agents and Workflows
 Author-email: Shaun Smith <fastagent@llmindset.co.uk>
 License:                                  Apache License

{fast_agent_mcp-0.3.9 → fast_agent_mcp-0.3.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fast-agent-mcp"
-version = "0.3.9"
+version = "0.3.11"
 description = "Define, Prompt and Test MCP enabled Agents and Workflows"
 readme = "README.md"
 license = { file = "LICENSE" }

{fast_agent_mcp-0.3.9 → fast_agent_mcp-0.3.11}/src/fast_agent/config.py

@@ -43,8 +43,8 @@ class MCPSamplingSettings(BaseModel):
 
 
 class MCPElicitationSettings(BaseModel):
-    mode: Literal["forms", "auto_cancel", "none"] = "none"
-    """Elicitation mode: 'forms' (default UI), 'auto_cancel', 'none' (no capability)"""
+    mode: Literal["forms", "auto-cancel", "none"] = "none"
+    """Elicitation mode: 'forms' (default UI), 'auto-cancel', 'none' (no capability)"""
 
     model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
 

fast_agent_mcp-0.3.11/src/fast_agent/human_input/elicitation_handler.py

@@ -0,0 +1,123 @@
+from typing import Any, Dict, Optional
+
+from fast_agent.human_input.elicitation_state import elicitation_state
+from fast_agent.human_input.types import (
+    HumanInputRequest,
+    HumanInputResponse,
+)
+from fast_agent.tools.elicitation import set_elicitation_input_callback
+from fast_agent.ui.elicitation_form import (
+    show_simple_elicitation_form,
+)
+from fast_agent.ui.elicitation_style import (
+    ELICITATION_STYLE,
+)
+from fast_agent.ui.progress_display import progress_display
+
+
+async def elicitation_input_callback(
+    request: HumanInputRequest,
+    agent_name: str | None = None,
+    server_name: str | None = None,
+    server_info: dict[str, Any] | None = None,
+) -> HumanInputResponse:
+    """Request input from a human user for MCP server elicitation requests."""
+
+    # Extract effective names
+    effective_agent_name = agent_name or (
+        request.metadata.get("agent_name", "Unknown Agent") if request.metadata else "Unknown Agent"
+    )
+    effective_server_name = server_name or "Unknown Server"
+
+    # Start tracking elicitation operation
+    try:
+        from fast_agent.ui import notification_tracker
+        notification_tracker.start_elicitation(effective_server_name)
+    except Exception:
+        # Don't let notification tracking break elicitation
+        pass
+
+    try:
+        # Check if elicitation is disabled for this server
+        if elicitation_state.is_disabled(effective_server_name):
+            return HumanInputResponse(
+                request_id=request.request_id,
+                response="__CANCELLED__",
+                metadata={"auto_cancelled": True, "reason": "Server elicitation disabled by user"},
+            )
+
+        # Get the elicitation schema from metadata
+        schema: Optional[Dict[str, Any]] = None
+        if request.metadata and "requested_schema" in request.metadata:
+            schema = request.metadata["requested_schema"]
+
+        # Use the context manager to pause the progress display while getting input
+        with progress_display.paused():
+            try:
+                if schema:
+                    form_action, form_data = await show_simple_elicitation_form(
+                        schema=schema,
+                        message=request.prompt,
+                        agent_name=effective_agent_name,
+                        server_name=effective_server_name,
+                    )
+
+                    if form_action == "accept" and form_data is not None:
+                        # Convert form data to JSON string
+                        import json
+
+                        response = json.dumps(form_data)
+                    elif form_action == "decline":
+                        response = "__DECLINED__"
+                    elif form_action == "disable":
+                        response = "__DISABLE_SERVER__"
+                    else:  # cancel
+                        response = "__CANCELLED__"
+                else:
+                    # No schema, fall back to text input using prompt_toolkit only
+                    from prompt_toolkit.shortcuts import input_dialog
+
+                    response = await input_dialog(
+                        title="Input Requested",
+                        text=f"Agent: {effective_agent_name}\nServer: {effective_server_name}\n\n{request.prompt}",
+                        style=ELICITATION_STYLE,
+                    ).run_async()
+
+                    if response is None:
+                        response = "__CANCELLED__"
+
+            except KeyboardInterrupt:
+                response = "__CANCELLED__"
+            except EOFError:
+                response = "__CANCELLED__"
+
+        return HumanInputResponse(
+            request_id=request.request_id,
+            response=response.strip() if isinstance(response, str) else response,
+            metadata={"has_schema": schema is not None},
+        )
+    finally:
+        # End tracking elicitation operation
+        try:
+            from fast_agent.ui import notification_tracker
+            notification_tracker.end_elicitation(effective_server_name)
+        except Exception:
+            # Don't let notification tracking break elicitation
+            pass
+
+
+# Register adapter with fast_agent tools so they can invoke this UI handler without importing types
+async def _elicitation_adapter(
+    request_payload: dict,
+    agent_name: str | None = None,
+    server_name: str | None = None,
+    server_info: dict[str, Any] | None = None,
+) -> str:
+    req = HumanInputRequest(**request_payload)
+    resp = await elicitation_input_callback(
+        request=req, agent_name=agent_name, server_name=server_name, server_info=server_info
+    )
+    return resp.response if isinstance(resp.response, str) else str(resp.response)
+
+
+set_elicitation_input_callback(_elicitation_adapter)

{fast_agent_mcp-0.3.9 → fast_agent_mcp-0.3.11}/src/fast_agent/mcp/elicitation_factory.py

@@ -53,7 +53,7 @@ def resolve_elicitation_handler(
             if mode == "none":
                 logger.debug(f"Elicitation disabled by server config for agent {agent_config.name}")
                 return None  # Don't advertise elicitation capability
-            elif mode == "auto_cancel":
+            elif mode == "auto-cancel":
                 logger.debug(
                     f"Using auto-cancel elicitation handler (server config) for agent {agent_config.name}"
                 )
@@ -74,7 +74,7 @@ def resolve_elicitation_handler(
     if mode == "none":
         logger.debug(f"Elicitation disabled by global config for agent {agent_config.name}")
         return None  # Don't advertise elicitation capability
-    elif mode == "auto_cancel":
+    elif mode == "auto-cancel":
         logger.debug(
             f"Using auto-cancel elicitation handler (global config) for agent {agent_config.name}"
         )

{fast_agent_mcp-0.3.9 → fast_agent_mcp-0.3.11}/src/fast_agent/mcp/mcp_aggregator.py

@@ -334,6 +334,9 @@ class MCPAggregator(ContextDependent):
                     server_name, client_session_factory=self._create_session_factory(server_name)
                 )
 
+                # Record the initialize call that happened during connection setup
+                await self._record_server_call(server_name, "initialize", True)
+
             logger.info(
                 f"MCP Servers initialized for agent '{self.agent_name}'",
                 data={
@@ -342,27 +345,39 @@ class MCPAggregator(ContextDependent):
                 },
             )
 
-        async def fetch_tools(client: ClientSession, server_name: str) -> List[Tool]:
+        async def fetch_tools(server_name: str) -> List[Tool]:
             # Only fetch tools if the server supports them
             if not await self.server_supports_feature(server_name, "tools"):
                 logger.debug(f"Server '{server_name}' does not support tools")
                 return []
 
             try:
-                result: ListToolsResult = await client.list_tools()
+                result: ListToolsResult = await self._execute_on_server(
+                    server_name=server_name,
+                    operation_type="tools/list",
+                    operation_name="",
+                    method_name="list_tools",
+                    method_args={},
+                )
                 return result.tools or []
             except Exception as e:
                 logger.error(f"Error loading tools from server '{server_name}'", data=e)
                 return []
 
-        async def fetch_prompts(client: ClientSession, server_name: str) -> List[Prompt]:
+        async def fetch_prompts(server_name: str) -> List[Prompt]:
             # Only fetch prompts if the server supports them
             if not await self.server_supports_feature(server_name, "prompts"):
                 logger.debug(f"Server '{server_name}' does not support prompts")
                 return []
 
             try:
-                result = await client.list_prompts()
+                result = await self._execute_on_server(
+                    server_name=server_name,
+                    operation_type="prompts/list",
+                    operation_name="",
+                    method_name="list_prompts",
+                    method_args={},
+                )
                 return getattr(result, "prompts", [])
             except Exception as e:
                 logger.debug(f"Error loading prompts from server '{server_name}': {e}")
@@ -372,20 +387,9 @@ class MCPAggregator(ContextDependent):
             tools: List[Tool] = []
             prompts: List[Prompt] = []
 
-            if self.connection_persistence:
-                server_connection = await self._persistent_connection_manager.get_server(
-                    server_name, client_session_factory=self._create_session_factory(server_name)
-                )
-                tools = await fetch_tools(server_connection.session, server_name)
-                prompts = await fetch_prompts(server_connection.session, server_name)
-            else:
-                async with gen_client(
-                    server_name,
-                    server_registry=self.context.server_registry,
-                    client_session_factory=self._create_session_factory(server_name),
-                ) as client:
-                    tools = await fetch_tools(client, server_name)
-                    prompts = await fetch_prompts(client, server_name)
+            # Use _execute_on_server for consistent tracking regardless of connection mode
+            tools = await fetch_tools(server_name)
+            prompts = await fetch_prompts(server_name)
 
             return server_name, tools, prompts
 
@@ -978,7 +982,7 @@ class MCPAggregator(ContextDependent):
 
             return await self._execute_on_server(
                 server_name=server_name,
-                operation_type="tool",
+                operation_type="tools/call",
                 operation_name=local_tool_name,
                 method_name="call_tool",
                 method_args={
@@ -1071,7 +1075,7 @@ class MCPAggregator(ContextDependent):
 
             result = await self._execute_on_server(
                 server_name=server_name,
-                operation_type="prompt",
+                operation_type="prompts/get",
                 operation_name=local_prompt_name or "default",
                 method_name="get_prompt",
                 method_args=method_args,
@@ -1119,7 +1123,7 @@ class MCPAggregator(ContextDependent):
 
                     result = await self._execute_on_server(
                         server_name=s_name,
-                        operation_type="prompt",
+                        operation_type="prompts/get",
                         operation_name=local_prompt_name,
                         method_name="get_prompt",
                         method_args=method_args,
@@ -1167,7 +1171,7 @@ class MCPAggregator(ContextDependent):
 
                     result = await self._execute_on_server(
                         server_name=s_name,
-                        operation_type="prompt",
+                        operation_type="prompts/get",
                         operation_name=local_prompt_name,
                         method_name="get_prompt",
                         method_args=method_args,
@@ -1190,7 +1194,7 @@ class MCPAggregator(ContextDependent):
                         try:
                             prompt_list_result = await self._execute_on_server(
                                 server_name=s_name,
-                                operation_type="prompts-list",
+                                operation_type="prompts/list",
                                 operation_name="",
                                 method_name="list_prompts",
                                 error_factory=lambda _: None,
@@ -1264,7 +1268,7 @@ class MCPAggregator(ContextDependent):
             # Fetch from server
             result = await self._execute_on_server(
                 server_name=server_name,
-                operation_type="prompts-list",
+                operation_type="prompts/list",
                 operation_name="",
                 method_name="list_prompts",
                 error_factory=lambda _: None,
@@ -1303,7 +1307,7 @@ class MCPAggregator(ContextDependent):
             try:
                 result = await self._execute_on_server(
                     server_name=s_name,
-                    operation_type="prompts-list",
+                    operation_type="prompts/list",
                     operation_name="",
                     method_name="list_prompts",
                     error_factory=lambda _: None,
@@ -1358,22 +1362,15 @@ class MCPAggregator(ContextDependent):
 
         async with self._refresh_lock:
             try:
-                # Fetch new tools from the server
-                if self.connection_persistence:
-                    server_connection = await self._persistent_connection_manager.get_server(
-                        server_name,
-                        client_session_factory=self._create_session_factory(server_name),
-                    )
-                    tools_result = await server_connection.session.list_tools()
-                    new_tools = tools_result.tools or []
-                else:
-                    async with gen_client(
-                        server_name,
-                        server_registry=self.context.server_registry,
-                        client_session_factory=self._create_session_factory(server_name),
-                    ) as client:
-                        tools_result = await client.list_tools()
-                        new_tools = tools_result.tools or []
+                # Fetch new tools from the server using _execute_on_server to properly record stats
+                tools_result = await self._execute_on_server(
+                    server_name=server_name,
+                    operation_type="tools/list",
+                    operation_name="",
+                    method_name="list_tools",
+                    method_args={},
+                )
+                new_tools = tools_result.tools or []
 
                 # Update tool maps
                 async with self._tool_map_lock:
@@ -1489,7 +1486,7 @@ class MCPAggregator(ContextDependent):
         # Use the _execute_on_server method to call read_resource on the server
         result = await self._execute_on_server(
             server_name=server_name,
-            operation_type="resource",
+            operation_type="resources/read",
             operation_name=resource_uri,
             method_name="read_resource",
             method_args={"uri": uri},
@@ -1540,7 +1537,7 @@ class MCPAggregator(ContextDependent):
                 # Use the _execute_on_server method to call list_resources on the server
                 result = await self._execute_on_server(
                     server_name=s_name,
-                    operation_type="resources-list",
+                    operation_type="resources/list",
                     operation_name="",
                     method_name="list_resources",
                     method_args={},  # Empty dictionary instead of None
@@ -1593,7 +1590,7 @@ class MCPAggregator(ContextDependent):
                 # Use the _execute_on_server method to call list_tools on the server
                 result = await self._execute_on_server(
                     server_name=s_name,
-                    operation_type="tools-list",
+                    operation_type="tools/list",
                     operation_name="",
                     method_name="list_tools",
                     method_args={},

{fast_agent_mcp-0.3.9 → fast_agent_mcp-0.3.11}/src/fast_agent/mcp/sampling.py

@@ -77,6 +77,19 @@ async def sample(mcp_ctx: ClientSession, params: CreateMessageRequestParams) ->
     Returns:
         A CreateMessageResult containing the LLM's response
     """
+    # Get server name for notification tracking
+    server_name = "unknown"
+    if hasattr(mcp_ctx, "session") and hasattr(mcp_ctx.session, "session_server_name"):
+        server_name = mcp_ctx.session.session_server_name or "unknown"
+
+    # Start tracking sampling operation
+    try:
+        from fast_agent.ui import notification_tracker
+        notification_tracker.start_sampling(server_name)
+    except Exception:
+        # Don't let notification tracking break sampling
+        pass
+
     model: str | None = None
     api_key: str | None = None
     try:
@@ -157,6 +170,14 @@ async def sample(mcp_ctx: ClientSession, params: CreateMessageRequestParams) ->
         return SamplingConverter.error_result(
             error_message=f"Error in sampling: {str(e)}", model=model
         )
+    finally:
+        # End tracking sampling operation
+        try:
+            from fast_agent.ui import notification_tracker
+            notification_tracker.end_sampling(server_name)
+        except Exception:
+            # Don't let notification tracking break sampling
+            pass
 
 
 def sampling_agent_config(

{fast_agent_mcp-0.3.9 → fast_agent_mcp-0.3.11}/src/fast_agent/mcp/transport_tracking.py

@@ -243,7 +243,9 @@ class TransportChannelMetrics:
             self._get_last_error = event.detail
             self._get_last_event = "error"
             self._get_last_event_at = now
-            self._record_history("get", "error", now)
+            # Record 405 as "disabled" in timeline, not "error"
+            timeline_state = "disabled" if event.status_code == 405 else "error"
+            self._record_history("get", timeline_state, now)
 
     def _handle_resumption_event(self, event: ChannelEvent, now: datetime) -> None:
         if event.event_type == "message" and event.message is not None:

{fast_agent_mcp-0.3.9 → fast_agent_mcp-0.3.11}/src/fast_agent/ui/console_display.py

@@ -623,33 +623,38 @@ class ConsoleDisplay:
         if not self.config or not self.config.logger.show_tools:
             return
 
-        # Combined separator and status line
-        if agent_name:
-            left = (
-                f"[magenta]▎[/magenta][dim magenta]▶[/dim magenta] [magenta]{agent_name}[/magenta]"
-            )
-        else:
-            left = "[magenta]▎[/magenta][dim magenta]▶[/dim magenta]"
+        # Check if prompt_toolkit is active
+        try:
+            from prompt_toolkit.application.current import get_app
 
-        right = f"[dim]{updated_server}[/dim]"
-        self._create_combined_separator_status(left, right)
+            app = get_app()
+            # We're in interactive mode - add to notification tracker
+            from fast_agent.ui import notification_tracker
 
-        # Display update message
-        message = f"Updating tools for server {updated_server}"
-        console.console.print(message, style="dim", markup=self._markup)
+            notification_tracker.add_tool_update(updated_server)
+            app.invalidate()  # Force toolbar redraw
 
-        # Bottom separator
-        console.console.print()
-        console.console.print("─" * console.console.size.width, style="dim")
-        console.console.print()
+        except:  # noqa: E722
+            # 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]"
+                )
+            else:
+                left = "[magenta]▎[/magenta][dim magenta]▶[/dim magenta]"
 
-        # Force prompt_toolkit redraw if active
-        try:
-            from prompt_toolkit.application.current import get_app
+            right = f"[dim]{updated_server}[/dim]"
+            self._create_combined_separator_status(left, right)
 
-            get_app().invalidate()  # Forces prompt_toolkit to redraw
-        except:  # noqa: E722
-            pass  # No active prompt_toolkit session
+            # Display update message
+            message = f"Updating tools for server {updated_server}"
+            console.console.print(message, style="dim", markup=self._markup)
+
+            # Bottom separator
+            console.console.print()
+            console.console.print("─" * console.console.size.width, style="dim")
+            console.console.print()
 
     def _create_combined_separator_status(self, left_content: str, right_info: str = "") -> None:
         """

{fast_agent_mcp-0.3.9 → fast_agent_mcp-0.3.11}/src/fast_agent/ui/elicitation_style.py

@@ -7,16 +7,16 @@ ELICITATION_STYLE = Style.from_dict(
     {
         # Dialog structure - use ansidefault for true black, remove problematic shadow
         "dialog": "bg:ansidefault",  # True black dialog using ansidefault
-        "dialog.body": "bg:ansidefault fg:ansiwhite",  # True black dialog body
+        "dialog.body": "bg:ansidefault fg:ansidefault",  # True black dialog body with default text color
         "dialog shadow": "bg:ansidefault",  # Set shadow background to match application
         "dialog.border": "bg:ansidefault",  # True black border background
         # Set application background to true black
         "application": "bg:ansidefault",  # True black application background
         # Title styling with better contrast
-        "title": "fg:ansibrightmagenta bold",  # Bright magenta text
+        "title": "fg:ansidefault bold",  # Default color title for terminal compatibility
         # Buttons - only define focused state to preserve focus highlighting
         "button.focused": "bg:ansibrightgreen fg:ansiblack bold",  # Bright green with black text for contrast
-        "button.arrow": "fg:ansiwhite bold",  # White arrows for visibility
+        "button.arrow": "fg:ansidefault bold",  # Default color arrows for terminal compatibility
         # Form elements with consistent green/yellow theme
         # Checkboxes - green when checked, yellow when focused
         "checkbox": "fg:ansidefault",  # Default color unchecked checkbox (dimmer)
@@ -34,15 +34,15 @@ ELICITATION_STYLE = Style.from_dict(
         # Frame styling with ANSI colors - make borders visible
         "frame.border": "fg:ansibrightblack",  # Bright black borders for subtlety
         "frame.label": "fg:ansigray",  # Gray frame labels (less prominent)
-        # Labels and text - use white for good visibility
-        "label": "fg:ansiwhite",  # White labels for good readability
+        # Labels and text - use default color for terminal compatibility
+        "label": "fg:ansidefault",  # Default color labels for terminal compatibility
         "message": "fg:ansibrightcyan",  # Bright cyan messages (no bold)
         # Agent and server names - make them match
         "agent-name": "fg:ansibrightblue bold",
         "server-name": "fg:ansibrightblue bold",  # Same color as agent
         # Validation errors - better contrast
-        "validation-toolbar": "bg:ansibrightred fg:ansiwhite bold",
-        "validation-toolbar.text": "bg:ansibrightred fg:ansiwhite",
+        "validation-toolbar": "bg:ansibrightred fg:ansidefault bold",
+        "validation-toolbar.text": "bg:ansibrightred fg:ansidefault",
         "validation.border": "fg:ansibrightred",
         "validation-error": "fg:ansibrightred bold",  # For status line errors
         # Separator styling

{fast_agent_mcp-0.3.9 → fast_agent_mcp-0.3.11}/src/fast_agent/ui/enhanced_prompt.py

@@ -717,17 +717,33 @@ async def get_enhanced_input(
         # Version/app label in green (dynamic version)
         version_segment = f"fast-agent {app_version}"
 
+        # Add notifications - prioritize active events over completed ones
+        from fast_agent.ui import notification_tracker
+
+        notification_segment = ""
+
+        # Check for active events first (highest priority)
+        active_status = notification_tracker.get_active_status()
+        if active_status:
+            event_type = active_status['type'].upper()
+            server = active_status['server']
+            notification_segment = f" | <style fg='ansired' bg='ansiblack'>◀ {event_type} ({server})</style>"
+        elif notification_tracker.get_count() > 0:
+            # Show completed events summary when no active events
+            summary = notification_tracker.get_summary()
+            notification_segment = f" | ◀ {notification_tracker.get_count()} updates ({summary})"
+
         if middle:
             return HTML(
                 f" <style fg='{toolbar_color}' bg='ansiblack'> {agent_name} </style> "
                 f" {middle} | <style fg='{mode_style}' bg='ansiblack'> {mode_text} </style> | "
-                f"{version_segment}"
+                f"{version_segment}{notification_segment}"
             )
         else:
             return HTML(
                 f" <style fg='{toolbar_color}' bg='ansiblack'> {agent_name} </style> "
                 f"Mode: <style fg='{mode_style}' bg='ansiblack'> {mode_text} </style> | "
-                f"{version_segment}"
+                f"{version_segment}{notification_segment}"
             )
 
     # A more terminal-agnostic style that should work across themes
@@ -766,7 +782,7 @@ async def get_enhanced_input(
     session.app.key_bindings = bindings
 
     # Create formatted prompt text
-    prompt_text = f"<ansibrightblue>{agent_name}</ansibrightblue> > "
+    prompt_text = f"<ansibrightblue>{agent_name}</ansibrightblue> ❯ "
 
     # Add default value display if requested
     if show_default and default and default != "STOP":