fast-agent-mcp 0.3.9__py3-none-any.whl → 0.3.11__py3-none-any.whl

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/human_input/elicitation_handler.py

@@ -29,64 +29,81 @@ async def elicitation_input_callback(
     )
     effective_server_name = server_name or "Unknown Server"
 
-    # Check if elicitation is disabled for this server
-    if elicitation_state.is_disabled(effective_server_name):
+    # 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="__CANCELLED__",
-            metadata={"auto_cancelled": True, "reason": "Server elicitation disabled by user"},
+            response=response.strip() if isinstance(response, str) else response,
+            metadata={"has_schema": schema is not None},
         )
-
-    # 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():
+    finally:
+        # End tracking elicitation operation
         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},
-    )
+            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

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/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/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/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/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/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/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/ui/mcp_display.py

@@ -14,6 +14,67 @@ if TYPE_CHECKING:
     from fast_agent.mcp.transport_tracking import ChannelSnapshot
 
 
+# Centralized color configuration
+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
+    IDLE = "white dim"
+    NONE = "dim"
+
+    # Channel arrow states
+    ARROW_ERROR = "bright_red"
+    ARROW_DISABLED = "bright_yellow"  # For explicitly disabled/off
+    ARROW_METHOD_NOT_ALLOWED = "cyan"  # For 405 method not allowed (notification color)
+    ARROW_OFF = "black dim"
+    ARROW_IDLE = "bright_cyan"  # Connected but no activity
+    ARROW_ACTIVE = "bright_green"  # Connected with activity
+
+    # Capability token states
+    TOKEN_ERROR = "bright_red"
+    TOKEN_WARNING = "bright_cyan"
+    TOKEN_DISABLED = "dim"
+    TOKEN_HIGHLIGHTED = "bright_yellow"
+    TOKEN_ENABLED = "bright_green"
+
+    # Text elements
+    TEXT_DIM = "dim"
+    TEXT_DEFAULT = "default"  # Use terminal's default text color
+    TEXT_BRIGHT = "bright_white"
+    TEXT_ERROR = "bright_red"
+    TEXT_WARNING = "bright_yellow"
+    TEXT_SUCCESS = "bright_green"
+    TEXT_INFO = "bright_blue"
+    TEXT_CYAN = "cyan"
+
+
+# Color mappings for different contexts
+TIMELINE_COLORS = {
+    "error": Colours.ERROR,
+    "disabled": Colours.DISABLED,
+    "response": Colours.RESPONSE,
+    "request": Colours.REQUEST,
+    "notification": Colours.NOTIFICATION,
+    "ping": Colours.PING,
+    "none": Colours.IDLE,
+}
+
+TIMELINE_COLORS_STDIO = {
+    "error": Colours.ERROR,
+    "request": Colours.TOKEN_ENABLED,  # All activity shows as bright green
+    "response": Colours.TOKEN_ENABLED,
+    "notification": Colours.TOKEN_ENABLED,
+    "ping": Colours.PING,
+    "none": Colours.IDLE,
+}
+
+
 def _format_compact_duration(seconds: float | None) -> str | None:
     if seconds is None:
         return None
@@ -58,7 +119,7 @@ def _format_session_id(session_id: str | None) -> Text:
 
 
 def _build_aligned_field(
-    label: str, value: Text | str, *, label_width: int = 9, value_style: str = "white"
+    label: str, value: Text | str, *, label_width: int = 9, value_style: str = Colours.TEXT_DEFAULT
 ) -> Text:
     field = Text()
     field.append(f"{label:<{label_width}}: ", style="dim")
@@ -134,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))
@@ -153,14 +214,14 @@ def _format_capability_shorthand(
 
     def token_style(supported, highlighted) -> str:
         if supported == "red":
-            return "bright_red"
+            return Colours.TOKEN_ERROR
         if supported == "blue":
-            return "bright_cyan"
+            return Colours.TOKEN_WARNING
         if not supported:
-            return "dim"
+            return Colours.TOKEN_DISABLED
         if highlighted:
-            return "bright_yellow"
-        return "bright_green"
+            return Colours.TOKEN_HIGHLIGHTED
+        return Colours.TOKEN_ENABLED
 
     tokens = [
         (label, token_style(supported, highlighted)) for label, supported, highlighted in entries
@@ -198,19 +259,16 @@ def _format_label(label: str, width: int = 10) -> str:
 
 def _build_inline_timeline(buckets: Iterable[str]) -> str:
     """Build a compact timeline string for inline display."""
-    color_map = {
-        "error": "bright_red",
-        "disabled": "bright_blue",
-        "response": "bright_blue",
-        "request": "bright_yellow",
-        "notification": "bright_cyan",
-        "ping": "bright_green",
-        "none": "dim",
-    }
     timeline = "  [dim]10m[/dim] "
     for state in buckets:
-        color = color_map.get(state, "dim")
-        timeline += f"[bold {color}]●[/bold {color}]"
+        color = TIMELINE_COLORS.get(state, Colours.NONE)
+        if state in {"idle", "none"}:
+            symbol = "·"
+        elif state == "request":
+            symbol = "◆"  # Diamond for requests - rare and important
+        else:
+            symbol = "●"  # Circle for other activity
+        timeline += f"[bold {color}]{symbol}[/bold {color}]"
     timeline += " [dim]now[/dim]"
     return timeline
 
@@ -298,45 +356,25 @@ def _render_channel_summary(status: ServerStatus, indent: str, total_width: int)
     # Collect any errors to show at bottom
     errors = []
 
-    # Build timeline color map
-    if is_stdio:
-        # Simplified color map for stdio: bright green for activity, dim for idle
-        timeline_color_map = {
-            "error": "bright_red",  # Keep error as red
-            "request": "bright_green",  # All activity shows as bright green
-            "response": "bright_green",  # (not used in stdio but just in case)
-            "notification": "bright_green",  # (not used in stdio but just in case)
-            "ping": "bright_green",  # (not used in stdio but just in case)
-            "none": "white dim",
-        }
-    else:
-        # Full color map for HTTP channels
-        timeline_color_map = {
-            "error": "bright_red",
-            "disabled": "bright_blue",
-            "response": "bright_blue",
-            "request": "bright_yellow",
-            "notification": "bright_cyan",
-            "ping": "bright_green",
-            "none": "white dim",
-        }
+    # Get appropriate timeline color map
+    timeline_color_map = TIMELINE_COLORS_STDIO if is_stdio else TIMELINE_COLORS
 
     for label, arrow, channel in entries:
         line = Text(indent)
         line.append("│ ", style="dim")
 
         # Determine arrow color based on state
-        arrow_style = "black dim"  # default no channel
+        arrow_style = Colours.ARROW_OFF  # default no channel
         if channel:
             state = (channel.state or "open").lower()
 
-            # Check for 405 status code (method not allowed = disabled endpoint)
+            # Check for 405 status code (method not allowed = not an error, just unsupported)
             if channel.last_status_code == 405:
-                arrow_style = "bright_yellow"
-                # Don't add 405 to errors list - it's just disabled, not an error
+                arrow_style = Colours.ARROW_METHOD_NOT_ALLOWED
+                # Don't add 405 to errors list - it's not an error, just method not supported
             # Error state (non-405 errors)
             elif state == "error":
-                arrow_style = "bright_red"
+                arrow_style = Colours.ARROW_ERROR
                 if channel.last_error and channel.last_status_code != 405:
                     error_msg = channel.last_error
                     if channel.last_status_code:
@@ -347,20 +385,41 @@ def _render_channel_summary(status: ServerStatus, indent: str, total_width: int)
                         errors.append((label.split()[0], error_msg))
             # Explicitly disabled or off
             elif state in {"off", "disabled"}:
-                arrow_style = "black dim"
+                arrow_style = Colours.ARROW_OFF
             # No activity (idle)
             elif channel.request_count == 0 and channel.response_count == 0:
-                arrow_style = "bright_cyan"
+                arrow_style = Colours.ARROW_IDLE
             # Active/connected with activity
             elif state in {"open", "connected"}:
-                arrow_style = "bright_green"
+                arrow_style = Colours.ARROW_ACTIVE
             # Fallback for other states
             else:
-                arrow_style = "bright_cyan"
+                arrow_style = Colours.ARROW_IDLE
 
         # Arrow and label with better spacing
-        line.append(arrow, style=arrow_style)
-        line.append(f" {label:<13}", style="bright_white")
+        # Use hollow arrow for 405 Method Not Allowed
+        if channel and channel.last_status_code == 405:
+            # Convert solid arrows to hollow for 405
+            hollow_arrows = {"◀": "◁", "▶": "▷", "⇄": "⇄"}  # bidirectional stays same
+            display_arrow = hollow_arrows.get(arrow, arrow)
+        else:
+            display_arrow = arrow
+        line.append(display_arrow, style=arrow_style)
+
+        # 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")
@@ -368,11 +427,20 @@ def _render_channel_summary(status: ServerStatus, indent: str, total_width: int)
             # Show actual activity
             for bucket_state in channel.activity_buckets:
                 color = timeline_color_map.get(bucket_state, "dim")
-                line.append("●", style=f"bold {color}")
+                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:
+                    symbol = "●"  # Circle for other activity
+                line.append(symbol, style=f"bold {color}")
         else:
-            # Show dim black dots for no activity
+            # Show dim dots for no activity
             for _ in range(20):
-                line.append("●", style="black dim")
+                line.append("·", style="black dim")
         line.append(" now", style="dim")
 
         # Metrics - different layouts for stdio vs HTTP
@@ -380,26 +448,41 @@ def _render_channel_summary(status: ServerStatus, indent: str, total_width: int)
             # Simplified activity column for stdio
             if channel and channel.message_count > 0:
                 activity = str(channel.message_count).rjust(8)
-                activity_style = "bright_white"
+                activity_style = Colours.TEXT_DEFAULT
             else:
                 activity = "-".rjust(8)
-                activity_style = "dim"
+                activity_style = Colours.TEXT_DIM
             line.append(f"  {activity}", style=activity_style)
         else:
             # Original HTTP columns
             if channel:
-                req = str(channel.request_count).rjust(5)
-                resp = str(channel.response_count).rjust(5)
-                notif = str(channel.notification_count).rjust(5)
-                ping = str(channel.ping_count if channel.ping_count else "-").rjust(5)
+                # 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)
+                )
+
+                if is_shut:
+                    req = "-".rjust(5)
+                    resp = "-".rjust(5)
+                    notif = "-".rjust(5)
+                    ping = "-".rjust(5)
+                    metrics_style = Colours.TEXT_DIM
+                else:
+                    req = str(channel.request_count).rjust(5)
+                    resp = str(channel.response_count).rjust(5)
+                    notif = str(channel.notification_count).rjust(5)
+                    ping = str(channel.ping_count if channel.ping_count else "-").rjust(5)
+                    metrics_style = Colours.TEXT_DEFAULT
             else:
                 req = "-".rjust(5)
                 resp = "-".rjust(5)
                 notif = "-".rjust(5)
                 ping = "-".rjust(5)
-            line.append(
-                f"  {req} {resp} {notif} {ping}", style="bright_white" if channel else "dim"
-            )
+                metrics_style = Colours.TEXT_DIM
+            line.append(f"  {req} {resp} {notif} {ping}", style=metrics_style)
 
         console.console.print(line)
 
@@ -416,13 +499,13 @@ def _render_channel_summary(status: ServerStatus, indent: str, total_width: int)
 
         for channel_type, error_msg in errors:
             error_line = Text(indent)
-            error_line.append("│ ", style="dim")
-            error_line.append("⚠ ", style="bright_yellow")
-            error_line.append(f"{channel_type}: ", style="bright_white")
+            error_line.append("│ ", style=Colours.TEXT_DIM)
+            error_line.append("⚠ ", style=Colours.TEXT_WARNING)
+            error_line.append(f"{channel_type}: ", style=Colours.TEXT_DEFAULT)
             # Truncate long error messages
             if len(error_msg) > 60:
                 error_msg = error_msg[:57] + "..."
-            error_line.append(error_msg, style="bright_red")
+            error_line.append(error_msg, style=Colours.TEXT_ERROR)
             console.console.print(error_line)
 
     # Legend if any timelines shown
@@ -444,24 +527,30 @@ def _render_channel_summary(status: ServerStatus, indent: str, total_width: int)
         if is_stdio:
             # Simplified legend for stdio: just activity vs idle
             legend_map = [
-                ("activity", "bright_green"),
-                ("idle", "white dim"),
+                ("activity", f"bold {Colours.TOKEN_ENABLED}"),
+                ("idle", Colours.IDLE),
             ]
         else:
             # Full legend for HTTP channels
             legend_map = [
-                ("error", "bright_red"),
-                ("response", "bright_blue"),
-                ("request", "bright_yellow"),
-                ("notification", "bright_cyan"),
-                ("ping", "bright_green"),
-                ("idle", "white dim"),
+                ("error", f"bold {Colours.ERROR}"),
+                ("response", f"bold {Colours.RESPONSE}"),
+                ("request", f"bold {Colours.REQUEST}"),
+                ("notification", f"bold {Colours.NOTIFICATION}"),
+                ("ping", Colours.PING),
+                ("idle", Colours.IDLE),
             ]
 
         for i, (name, color) in enumerate(legend_map):
             if i > 0:
                 footer.append(" ", style="dim")
-            footer.append("●", style=f"bold {color}")
+            if name == "idle":
+                symbol = "·"
+            elif name == "request":
+                symbol = "◆"  # Diamond for requests
+            else:
+                symbol = "●"
+            footer.append(symbol, style=f"{color}")
             footer.append(f" {name}", style="dim")
 
     console.console.print(footer)
@@ -526,10 +615,10 @@ async def render_mcp_status(agent, indent: str = "") -> None:
             version_display = version_display[:9] + "..."
 
         header_label = Text(indent)
-        header_label.append("▎", style="cyan")
-        header_label.append("●", style="dim cyan")
-        header_label.append(f" [{index:2}] ", style="cyan")
-        header_label.append(server, style="bright_blue bold")
+        header_label.append("▎", style=Colours.TEXT_CYAN)
+        header_label.append("●", style=f"dim {Colours.TEXT_CYAN}")
+        header_label.append(f" [{index:2}] ", style=Colours.TEXT_CYAN)
+        header_label.append(server, style=f"{Colours.TEXT_INFO} bold")
         render_header(header_label)
 
         # First line: name and version
@@ -571,22 +660,22 @@ async def render_mcp_status(agent, indent: str = "") -> None:
 
         duration = _format_compact_duration(status.staleness_seconds)
         if duration:
-            last_text = Text("last activity: ", style="dim")
-            last_text.append(duration, style="bright_white")
-            last_text.append(" ago", style="dim")
+            last_text = Text("last activity: ", style=Colours.TEXT_DIM)
+            last_text.append(duration, style=Colours.TEXT_DEFAULT)
+            last_text.append(" ago", style=Colours.TEXT_DIM)
             state_segments.append(last_text)
 
         if status.error_message and status.is_connected is False:
-            state_segments.append(Text(status.error_message, style="bright_red"))
+            state_segments.append(Text(status.error_message, style=Colours.TEXT_ERROR))
 
         instr_available = bool(status.instructions_available)
         if instr_available and status.instructions_enabled is False:
-            state_segments.append(Text("instructions disabled", style="bright_red"))
+            state_segments.append(Text("instructions disabled", style=Colours.TEXT_ERROR))
         elif instr_available and not template_expected:
-            state_segments.append(Text("template missing", style="bright_yellow"))
+            state_segments.append(Text("template missing", style=Colours.TEXT_WARNING))
 
         if status.spoofing_enabled:
-            state_segments.append(Text("client spoof", style="bright_yellow"))
+            state_segments.append(Text("client spoof", style=Colours.TEXT_WARNING))
 
         # Main status line (without transport and connected)
         if state_segments:
@@ -601,8 +690,8 @@ async def render_mcp_status(agent, indent: str = "") -> None:
         calls = _summarise_call_counts(status.call_counts)
         if calls:
             calls_line = Text(indent + "  ")
-            calls_line.append("mcp calls: ", style="dim")
-            calls_line.append(calls, style="bright_white")
+            calls_line.append("mcp calls: ", style=Colours.TEXT_DIM)
+            calls_line.append(calls, style=Colours.TEXT_DEFAULT)
             console.console.print(calls_line)
         _render_channel_summary(status, indent, total_width)
 

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)

{fast_agent_mcp-0.3.9.dist-info → fast_agent_mcp-0.3.11.dist-info}/METADATA

@@ -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.dist-info → fast_agent_mcp-0.3.11.dist-info}/RECORD

@@ -1,5 +1,5 @@
 fast_agent/__init__.py,sha256=ns6CPmjOL5y7cyV4XgFTfMGcfLnuBJwVTbcjJ5Co3x4,4152
-fast_agent/config.py,sha256=5glgvbPcPZFGG6UG_P8hByryPrteqrYg4pUCep4x6s8,22509
+fast_agent/config.py,sha256=tKnAhGAADpuwU7DggScG0VESs7el4R1Y1T3MUPzD5_U,22509
 fast_agent/constants.py,sha256=IoXL5m4L0iLlcRrKerMaK3ZPcS6KCJgK8b_bj1BAR60,345
 fast_agent/context.py,sha256=nBelOqehSH91z3aG2nYhwETP-biRzz-iuA2fqmKdHP8,7700
 fast_agent/context_dependent.py,sha256=KU1eydVBoIt4bYOZroqxDgE1AUexDaZi7hurE26QsF4,1584
@@ -54,7 +54,7 @@ fast_agent/core/logging/logger.py,sha256=L-hLfUGFCIABoNYDiUkNHWvFxL6j-6zn5Pc5E7a
 fast_agent/core/logging/transport.py,sha256=i_WYXk5mqyfetT72bCYrbdrMWcuL1HJCyeQKfQg7U2w,16994
 fast_agent/history/history_exporter.py,sha256=oqkw7qC5rrW73u20tkIqt8yBWPoVzCTC61x2Q2rOKGs,1404
 fast_agent/human_input/__init__.py,sha256=4Jr_0JLJwdQ3iEUNd6Api9InldtnRMDv_WeZq_WEHpA,935
-fast_agent/human_input/elicitation_handler.py,sha256=U6278SJLIu1tosyL6qvo5OVwMSVE03gpGlWoF8YDlvQ,3985
+fast_agent/human_input/elicitation_handler.py,sha256=diR8jWRCAuoqTDQHJ3C097EORcLFxpLjdz6EubVOnI8,4776
 fast_agent/human_input/elicitation_state.py,sha256=L_vSTpw1-TSDumRYa89Me-twWRbUL2w7GNVhVJmn3KE,1152
 fast_agent/human_input/form_fields.py,sha256=aE7HdR-wOPO_6HllNaJXtn3BzpPsC4TctUApbveRk8g,7644
 fast_agent/human_input/simple_form.py,sha256=_flUll9z93VPjKqLS7gvz4L1_YJ3-KNx8_ZpUaaxhoQ,3508
@@ -97,14 +97,14 @@ fast_agent/llm/provider/openai/openai_multipart.py,sha256=uuoRMYWiznYksBODbknBuq
 fast_agent/llm/provider/openai/openai_utils.py,sha256=RI9UgF7SGkZ02bAep7glvLy3erbismmZp7wXDsRoJPQ,2034
 fast_agent/mcp/__init__.py,sha256=Q-86MBawKmB602VMut8U3uqUQDOrTAMx2HmHKnWT32Q,1371
 fast_agent/mcp/common.py,sha256=MpSC0fLO21RcDz4VApah4C8_LisVGz7OXkR17Xw-9mY,431
-fast_agent/mcp/elicitation_factory.py,sha256=p9tSTcs1KSCXkFcFv1cG7vJBpS1PedOJ5bcBJp0qKw4,3172
+fast_agent/mcp/elicitation_factory.py,sha256=d4unxJyR0S-qH05yBZ_oQ08XLBToFtUzzFFYvv0wLrY,3172
 fast_agent/mcp/elicitation_handlers.py,sha256=LWNKn850Ht9V1SGTfAZDptlsgzrycNhOPNsCcqzsuUY,6884
 fast_agent/mcp/gen_client.py,sha256=Q0hhCVzC659GsvTLJIbhUBgGwsAJRL8b3ejTFokyjn4,3038
 fast_agent/mcp/hf_auth.py,sha256=ndDvR7E9LCc5dBiMsStFXtvvX9lYrL-edCq_qJw4lDw,4476
 fast_agent/mcp/interfaces.py,sha256=xCWONGXe4uQSmmBlMZRD3mflPegTJnz2caVNihEl3ok,2411
 fast_agent/mcp/logger_textio.py,sha256=4YLVXlXghdGm1s_qp1VoAWEX_eWufBfD2iD7l08yoak,3170
 fast_agent/mcp/mcp_agent_client_session.py,sha256=5_9cW3CSzYspRzb8lOJTFx9E8Qk7ieCBASBbUtNrmiY,15578
-fast_agent/mcp/mcp_aggregator.py,sha256=0ekpAHdBb87TCpkwWsTNUcvTsg-MVp-sU8Tpc1bKFi8,67656
+fast_agent/mcp/mcp_aggregator.py,sha256=HzNyKuUelAlp5JBkjMAaOB2JvdMgpm0ItEPGjidI9l0,67198
 fast_agent/mcp/mcp_connection_manager.py,sha256=nbjcyWGK3LQhuFUABV1Mxf_v3rWFSMXNsDHV1h3qDUI,23803
 fast_agent/mcp/mcp_content.py,sha256=F9bgJ57EO9sgWg1m-eTNM6xd9js79mHKf4e9O8K8jrI,8829
 fast_agent/mcp/mime_utils.py,sha256=D6YXNdZJ351BjacSW5o0sVF_hrWuRHD6UyWS4TDlLZI,2915
@@ -114,10 +114,10 @@ fast_agent/mcp/prompt_message_extended.py,sha256=BsiV2SsiZkDlvqzvjeSowq8Ojvowr9X
 fast_agent/mcp/prompt_render.py,sha256=AqDaQqM6kqciV9X79S5rsRr3VjcQ_2JOiLaHqpRzsS4,2888
 fast_agent/mcp/prompt_serialization.py,sha256=QMbY0aa_UlJ7bbxl_muOm2TYeYbBVTEeEMHFmEy99ss,20182
 fast_agent/mcp/resource_utils.py,sha256=cu-l9aOy-NFs8tPihYRNjsB2QSuime8KGOGpUvihp84,6589
-fast_agent/mcp/sampling.py,sha256=3EhEguls5GpVMr_SYrVQcYSRXlryGmqidn-zbFaeDMk,6711
+fast_agent/mcp/sampling.py,sha256=6S9bpGCFGC5azIGE-zxODvKgBbBn1x6amL5mc4sMg_4,7491
 fast_agent/mcp/stdio_tracking_simple.py,sha256=T6kCIb6YjwqKtXHz_6HvlLLYiSCbuggt2xCXSihVnIg,1918
 fast_agent/mcp/streamable_http_tracking.py,sha256=bcNNReokho6WMjWEH13F33bUSkjJ2F5l3qnegkDqdMA,11465
-fast_agent/mcp/transport_tracking.py,sha256=FyY3Ynzq4JGUJ5RDHPNFxBxF1oAZBiUwnL_-C9eqSYA,23936
+fast_agent/mcp/transport_tracking.py,sha256=tsc2Ntf47KbKXs8DzRkqvG0U-FbpwU2VxemNfRbJBpo,24088
 fast_agent/mcp/ui_agent.py,sha256=OBGEuFpOPPK7EthPRwzxmtzu1SDIeZy-vHwdRsyDNQk,1424
 fast_agent/mcp/ui_mixin.py,sha256=iOlSNJVPwiMUun0clCiWyot59Qgy8R7ZvUgH2afRnQA,7662
 fast_agent/mcp/helpers/__init__.py,sha256=o6-HuX6bEVFnfT_wgclFOVb1NxtOsJEOnHX8L2IqDdw,857
@@ -191,19 +191,20 @@ fast_agent/types/__init__.py,sha256=y-53m-C4drf4Rx8Bbnk_GAhko9LdNYCyRUWya8e0mos,
 fast_agent/types/llm_stop_reason.py,sha256=bWe97OfhALUe8uQeAQOnTdPlYzJiabIfo8u38kPgj3Q,2293
 fast_agent/ui/__init__.py,sha256=MXxTQjFdF7mI_3JHxBPd-aoZYLlxV_-51-Trqgv5-3w,1104
 fast_agent/ui/console.py,sha256=Gjf2QLFumwG1Lav__c07X_kZxxEUSkzV-1_-YbAwcwo,813
-fast_agent/ui/console_display.py,sha256=8KBhiv1RRvi-WcvddaFgxkgoCDRdq81uJR_QFnLM-M0,41744
+fast_agent/ui/console_display.py,sha256=oZg-SMd_F0_1azsxWF5ug7cee_-ou2xOgGeW_y_6xrI,42034
 fast_agent/ui/elicitation_form.py,sha256=t3UhBG44YmxTLu1RjCnHwW36eQQaroE45CiBGJB2czg,29410
-fast_agent/ui/elicitation_style.py,sha256=rtZiJH4CwTdkDLSzDDvThlZyIyuRX0oVNzscKiHvry8,3835
-fast_agent/ui/enhanced_prompt.py,sha256=aFQfKijKzE1y_erDaufdYl74u3wXOXWJLc0LwxfRlyI,42647
+fast_agent/ui/elicitation_style.py,sha256=-WqXgVjVs65oNwhCDw3E0A9cCyw95IOe6LYCJgjT6ok,3939
+fast_agent/ui/enhanced_prompt.py,sha256=nGtYqvabfwYqCNczqWEf36AjY4laetG8CI__ePKtwKs,43496
 fast_agent/ui/interactive_prompt.py,sha256=Y-tYaU_5jqjDLRRgP3rzoMAXmJxYHVIVPsd8gWkcQso,44823
-fast_agent/ui/mcp_display.py,sha256=3Qtx8GZKwWs_PWRVPL1cGc1tLDEsFCPdVu9bnSxkTfQ,23296
+fast_agent/ui/mcp_display.py,sha256=54NVlWL6KsvhLP2tZm3edC3RH7fiLOJeKOYQCJ55uks,27142
 fast_agent/ui/mcp_ui_utils.py,sha256=hV7z-yHX86BgdH6CMmN5qyOUjyiegQXLJOa5n5A1vQs,8476
 fast_agent/ui/mermaid_utils.py,sha256=MpcRyVCPMTwU1XeIxnyFg0fQLjcyXZduWRF8NhEqvXE,5332
+fast_agent/ui/notification_tracker.py,sha256=XU2_C_1PwKEReyL2L6sFfFOq-3CczMlBiIIspxUjx0E,4625
 fast_agent/ui/progress_display.py,sha256=hajDob65PttiJ2mPS6FsCtnmTcnyvDWGn-UqQboXqkQ,361
 fast_agent/ui/rich_progress.py,sha256=fMiTigtkll4gL4Ik5WYHx-t0a92jfUovj0b580rT6J0,7735
 fast_agent/ui/usage_display.py,sha256=ltJpn_sDzo8PDNSXWx-QdEUbQWUnhmajCItNt5mA5rM,7285
-fast_agent_mcp-0.3.9.dist-info/METADATA,sha256=whumvjkxJyoYdKo5-96rBeYR4wRwaZdxGOm6XlYBEGA,31696
-fast_agent_mcp-0.3.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fast_agent_mcp-0.3.9.dist-info/entry_points.txt,sha256=i6Ujja9J-hRxttOKqTYdbYP_tyaS4gLHg53vupoCSsg,199
-fast_agent_mcp-0.3.9.dist-info/licenses/LICENSE,sha256=Gx1L3axA4PnuK4FxsbX87jQ1opoOkSFfHHSytW6wLUU,10935
-fast_agent_mcp-0.3.9.dist-info/RECORD,,
+fast_agent_mcp-0.3.11.dist-info/METADATA,sha256=hXINwYTIB7UUzPSbYOlPN0Mcq-YUKy1nWlfs0Gx5hcQ,31697
+fast_agent_mcp-0.3.11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fast_agent_mcp-0.3.11.dist-info/entry_points.txt,sha256=i6Ujja9J-hRxttOKqTYdbYP_tyaS4gLHg53vupoCSsg,199
+fast_agent_mcp-0.3.11.dist-info/licenses/LICENSE,sha256=Gx1L3axA4PnuK4FxsbX87jQ1opoOkSFfHHSytW6wLUU,10935
+fast_agent_mcp-0.3.11.dist-info/RECORD,,