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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.3.10
+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.10 → fast_agent_mcp-0.3.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fast-agent-mcp"
-version = "0.3.10"
+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.10 → 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.10 → 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.10 → fast_agent_mcp-0.3.11}/src/fast_agent/mcp/mcp_aggregator.py

@@ -1362,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:

{fast_agent_mcp-0.3.10 → 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.10 → 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.10 → 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":

{fast_agent_mcp-0.3.10 → fast_agent_mcp-0.3.11}/src/fast_agent/ui/mcp_display.py

@@ -19,12 +19,12 @@ class Colours:
     """Color constants for MCP status display elements."""
 
     # Timeline activity colors (Option A: Mixed Intensity)
-    ERROR = "bright_red"        # Keep error bright
-    DISABLED = "bright_blue"    # Keep disabled bright
-    RESPONSE = "blue"           # Normal blue instead of bright
-    REQUEST = "yellow"          # Normal yellow instead of bright
-    NOTIFICATION = "cyan"       # Normal cyan instead of bright
-    PING = "dim green"          # Keep ping dim
+    ERROR = "bright_red"  # Keep error bright
+    DISABLED = "bright_blue"  # Keep disabled bright
+    RESPONSE = "blue"  # Normal blue instead of bright
+    REQUEST = "yellow"  # Normal yellow instead of bright
+    NOTIFICATION = "cyan"  # Normal cyan instead of bright
+    PING = "dim green"  # Keep ping dim
     IDLE = "white dim"
     NONE = "dim"
 
@@ -195,7 +195,7 @@ def _format_capability_shorthand(
         entries.append(("Ro", False, False))
 
     mode = (status.elicitation_mode or "").lower()
-    if mode == "auto_cancel":
+    if mode == "auto-cancel":
         entries.append(("El", "red", False))
     elif mode and mode != "none":
         entries.append(("El", True, False))
@@ -405,7 +405,21 @@ def _render_channel_summary(status: ServerStatus, indent: str, total_width: int)
         else:
             display_arrow = arrow
         line.append(display_arrow, style=arrow_style)
-        line.append(f" {label:<13}", style=Colours.TEXT_DEFAULT)
+
+        # Determine label style based on activity and special cases
+        if not channel:
+            # No channel = dim
+            label_style = Colours.TEXT_DIM
+        elif channel.last_status_code == 405 and "GET" in label:
+            # Special case: GET (SSE) with 405 = dim (hollow arrow already handled above)
+            label_style = Colours.TEXT_DIM
+        elif channel.request_count == 0 and channel.response_count == 0:
+            # No activity = dim
+            label_style = Colours.TEXT_DIM
+        else:
+            # Has activity = normal
+            label_style = Colours.TEXT_DEFAULT
+        line.append(f" {label:<13}", style=label_style)
 
         # Always show timeline (dim black dots if no data)
         line.append("10m ", style="dim")
@@ -415,6 +429,9 @@ def _render_channel_summary(status: ServerStatus, indent: str, total_width: int)
                 color = timeline_color_map.get(bucket_state, "dim")
                 if bucket_state in {"idle", "none"}:
                     symbol = "·"
+                elif is_stdio:
+                    # For STDIO, all activity shows as filled circles since types are combined
+                    symbol = "●"
                 elif bucket_state == "request":
                     symbol = "◆"  # Diamond for requests - rare and important
                 else:
@@ -442,9 +459,9 @@ def _render_channel_summary(status: ServerStatus, indent: str, total_width: int)
                 # Show "-" for shut/disabled channels (405, off, disabled states)
                 channel_state = (channel.state or "open").lower()
                 is_shut = (
-                    channel.last_status_code == 405 or
-                    channel_state in {"off", "disabled"} or
-                    (channel_state == "error" and channel.last_status_code == 405)
+                    channel.last_status_code == 405
+                    or channel_state in {"off", "disabled"}
+                    or (channel_state == "error" and channel.last_status_code == 405)
                 )
 
                 if is_shut:

fast_agent_mcp-0.3.11/src/fast_agent/ui/notification_tracker.py

@@ -0,0 +1,167 @@
+"""
+Enhanced notification tracker for prompt_toolkit toolbar display.
+Tracks both active events (sampling/elicitation) and completed notifications.
+"""
+
+from datetime import datetime
+from typing import Dict, List, Optional
+
+# Active events currently in progress
+active_events: Dict[str, Dict[str, str]] = {}
+
+# Completed notifications history
+notifications: List[Dict[str, str]] = []
+
+
+def add_tool_update(server_name: str) -> None:
+    """Add a tool update notification.
+
+    Args:
+        server_name: Name of the server that had tools updated
+    """
+    notifications.append({
+        'type': 'tool_update',
+        'server': server_name
+    })
+
+
+def start_sampling(server_name: str) -> None:
+    """Start tracking a sampling operation.
+
+    Args:
+        server_name: Name of the server making the sampling request
+    """
+    active_events['sampling'] = {
+        'server': server_name,
+        'start_time': datetime.now().isoformat()
+    }
+
+    # Force prompt_toolkit to redraw if active
+    try:
+        from prompt_toolkit.application.current import get_app
+        get_app().invalidate()
+    except Exception:
+        pass
+
+
+def end_sampling(server_name: str) -> None:
+    """End tracking a sampling operation and add to completed notifications.
+
+    Args:
+        server_name: Name of the server that made the sampling request
+    """
+    if 'sampling' in active_events:
+        del active_events['sampling']
+
+    notifications.append({
+        'type': 'sampling',
+        'server': server_name
+    })
+
+    # Force prompt_toolkit to redraw if active
+    try:
+        from prompt_toolkit.application.current import get_app
+        get_app().invalidate()
+    except Exception:
+        pass
+
+
+def start_elicitation(server_name: str) -> None:
+    """Start tracking an elicitation operation.
+
+    Args:
+        server_name: Name of the server making the elicitation request
+    """
+    active_events['elicitation'] = {
+        'server': server_name,
+        'start_time': datetime.now().isoformat()
+    }
+
+    # Force prompt_toolkit to redraw if active
+    try:
+        from prompt_toolkit.application.current import get_app
+        get_app().invalidate()
+    except Exception:
+        pass
+
+
+def end_elicitation(server_name: str) -> None:
+    """End tracking an elicitation operation and add to completed notifications.
+
+    Args:
+        server_name: Name of the server that made the elicitation request
+    """
+    if 'elicitation' in active_events:
+        del active_events['elicitation']
+
+    notifications.append({
+        'type': 'elicitation',
+        'server': server_name
+    })
+
+    # Force prompt_toolkit to redraw if active
+    try:
+        from prompt_toolkit.application.current import get_app
+        get_app().invalidate()
+    except Exception:
+        pass
+
+
+def get_active_status() -> Optional[Dict[str, str]]:
+    """Get currently active operation, if any.
+
+    Returns:
+        Dict with 'type' and 'server' keys, or None if nothing active
+    """
+    if 'sampling' in active_events:
+        return {'type': 'sampling', 'server': active_events['sampling']['server']}
+    if 'elicitation' in active_events:
+        return {'type': 'elicitation', 'server': active_events['elicitation']['server']}
+    return None
+
+
+def clear() -> None:
+    """Clear all notifications and active events."""
+    notifications.clear()
+    active_events.clear()
+
+
+def get_count() -> int:
+    """Get the current completed notification count."""
+    return len(notifications)
+
+
+def get_latest() -> Dict[str, str] | None:
+    """Get the most recent completed notification."""
+    return notifications[-1] if notifications else None
+
+
+def get_summary() -> str:
+    """Get a summary of completed notifications by type.
+
+    Returns:
+        String like "3 tools, 1 sampling, 2 elicitations" or "1 tool update"
+    """
+    if not notifications:
+        return ""
+
+    counts = {}
+    for notification in notifications:
+        event_type = notification['type']
+        if event_type == 'tool_update':
+            counts['tools'] = counts.get('tools', 0) + 1
+        else:
+            # For sampling/elicitation, use the type directly
+            counts[event_type] = counts.get(event_type, 0) + 1
+
+    # Build summary string
+    parts = []
+    for event_type, count in sorted(counts.items()):
+        if event_type == 'tools':
+            parts.append(f"{count} tool{'s' if count != 1 else ''}")
+        elif event_type == 'sampling':
+            parts.append(f"{count} sample{'s' if count != 1 else ''}")
+        else:
+            parts.append(f"{count} {event_type}{'s' if count != 1 else ''}")
+
+    return ", ".join(parts)