fast-agent-mcp 0.2.36__py3-none-any.whl → 0.2.37__py3-none-any.whl

mcp_agent/human_input/elicitation_forms.py

@@ -0,0 +1,59 @@
+"""Shared styling configuration for MCP elicitation forms."""
+
+from prompt_toolkit.styles import Style
+
+# Define consistent elicitation style - inspired by usage display and interactive prompt
+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 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
+        # 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
+        # Form elements with consistent green/yellow theme
+        # Checkboxes - green when checked, yellow when focused
+        "checkbox": "fg:ansidefault",  # Default color unchecked checkbox (dimmer)
+        "checkbox-checked": "fg:ansibrightgreen bold",  # Green when checked (matches buttons)
+        "checkbox-selected": "bg:ansidefault fg:ansibrightyellow bold",  # Yellow when focused
+        # Radio list styling - consistent with checkbox colors
+        "radio-list": "bg:ansidefault",  # True black background for radio list
+        "radio": "fg:ansidefault",  # Default color for unselected items (dimmer)
+        "radio-selected": "bg:ansidefault fg:ansibrightyellow bold",  # Yellow when focused
+        "radio-checked": "fg:ansibrightgreen bold",  # Green when selected (matches buttons)
+        # Text input areas - use ansidefault for non-focused (dimmer effect)
+        "input-field": "fg:ansidefault bold",  # Default color (inactive) - should be dimmer than white
+        "input-field.focused": "fg:ansibrightyellow bold",  # Bright yellow (active)
+        "input-field.error": "fg:ansired bold",  # Red text (validation error)
+        # 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
+        "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.border": "fg:ansibrightred",
+        "validation-error": "fg:ansibrightred bold",  # For status line errors
+        # Separator styling
+        "separator": "fg:ansibrightblue bold",
+        # Completion menu - exactly matching enhanced_prompt.py
+        "completion-menu.completion": "bg:ansiblack fg:ansigreen",
+        "completion-menu.completion.current": "bg:ansiblack fg:ansigreen bold",
+        "completion-menu.meta.completion": "bg:ansiblack fg:ansiblue",
+        "completion-menu.meta.completion.current": "bg:ansibrightblack fg:ansiblue",
+        # Toolbar - matching enhanced_prompt.py exactly
+        "bottom-toolbar": "fg:ansiblack bg:ansigray",
+        "bottom-toolbar.text": "fg:ansiblack bg:ansigray",
+    }
+)

mcp_agent/human_input/elicitation_handler.py

@@ -0,0 +1,88 @@
+from typing import Any, Dict, Optional
+
+from mcp_agent.human_input.elicitation_form import (
+    show_simple_elicitation_form,
+)
+from mcp_agent.human_input.elicitation_forms import (
+    ELICITATION_STYLE,
+)
+from mcp_agent.human_input.elicitation_state import elicitation_state
+from mcp_agent.human_input.types import (
+    HumanInputRequest,
+    HumanInputResponse,
+)
+from mcp_agent.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"
+
+    # 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},
+    )

mcp_agent/human_input/elicitation_state.py

@@ -0,0 +1,34 @@
+"""Simple state management for elicitation Cancel All functionality."""
+
+from typing import Set
+
+
+class ElicitationState:
+    """Manages global state for elicitation requests, including disabled servers."""
+    
+    def __init__(self):
+        self.disabled_servers: Set[str] = set()
+    
+    def disable_server(self, server_name: str) -> None:
+        """Disable elicitation requests for a specific server."""
+        self.disabled_servers.add(server_name)
+    
+    def is_disabled(self, server_name: str) -> bool:
+        """Check if elicitation is disabled for a server."""
+        return server_name in self.disabled_servers
+    
+    def enable_server(self, server_name: str) -> None:
+        """Re-enable elicitation requests for a specific server."""
+        self.disabled_servers.discard(server_name)
+    
+    def clear_all(self) -> None:
+        """Clear all disabled servers."""
+        self.disabled_servers.clear()
+    
+    def get_disabled_servers(self) -> Set[str]:
+        """Get a copy of all disabled servers."""
+        return self.disabled_servers.copy()
+
+
+# Global instance for session-scoped Cancel All functionality
+elicitation_state = ElicitationState()

mcp_agent/llm/providers/augmented_llm_google_native.py

@@ -242,8 +242,10 @@ class GoogleNativeAugmentedLLM(AugmentedLLM[types.Content, types.Content]):
                 self.history.get(include_completion_history=True)
             )
         else:
-            # If not using history, start with an empty list
-            conversation_history = []
+            # If not using history, convert the last message to google.genai format
+            conversation_history = self._converter.convert_to_google_content(
+                self.history.get(include_completion_history=True)[-1:]
+            )
 
         self.logger.debug(f"Google completion requested with messages: {conversation_history}")
         self._log_chat_progress(

mcp_agent/llm/providers/augmented_llm_openai.py

@@ -123,7 +123,7 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
         # For non-OpenAI providers (like Ollama), ChatCompletionStreamState might not work correctly
         # Fall back to manual accumulation if needed
         # TODO -- consider this and whether to subclass instead
-        if self.provider in [Provider.GENERIC, Provider.OPENROUTER]:
+        if self.provider in [Provider.GENERIC, Provider.OPENROUTER, Provider.GOOGLE_OAI]:
             return await self._process_stream_manual(stream, model)
 
         # Use ChatCompletionStreamState helper for accumulation (OpenAI only)

mcp_agent/mcp/elicitation_factory.py

@@ -0,0 +1,84 @@
+"""
+Factory for resolving elicitation handlers with proper precedence.
+"""
+
+from typing import Any, Optional
+
+from mcp.client.session import ElicitationFnT
+
+from mcp_agent.core.agent_types import AgentConfig
+from mcp_agent.logging.logger import get_logger
+from mcp_agent.mcp.elicitation_handlers import (
+    auto_cancel_elicitation_handler,
+    forms_elicitation_handler,
+)
+
+logger = get_logger(__name__)
+
+
+def resolve_elicitation_handler(
+    agent_config: AgentConfig, app_config: Any, server_config: Any = None
+) -> Optional[ElicitationFnT]:
+    """Resolve elicitation handler with proper precedence.
+
+    Precedence order:
+    1. Agent decorator supplied (highest precedence)
+    2. Server-specific config file setting
+    3. Global config file setting
+    4. Default forms handler (lowest precedence)
+
+    Args:
+        agent_config: Agent configuration from decorator
+        app_config: Application configuration from YAML
+        server_config: Server-specific configuration (optional)
+
+    Returns:
+        ElicitationFnT handler or None (no elicitation capability)
+    """
+
+    # 1. Decorator takes highest precedence
+    if agent_config.elicitation_handler:
+        logger.debug(f"Using decorator-provided elicitation handler for agent {agent_config.name}")
+        return agent_config.elicitation_handler
+
+    # 2. Check server-specific config first
+    if server_config:
+        elicitation_config = getattr(server_config, "elicitation", {})
+        if isinstance(elicitation_config, dict):
+            mode = elicitation_config.get("mode")
+        else:
+            mode = getattr(elicitation_config, "mode", None)
+
+        if mode:
+            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":
+                logger.debug(
+                    f"Using auto-cancel elicitation handler (server config) for agent {agent_config.name}"
+                )
+                return auto_cancel_elicitation_handler
+            else:  # "forms" or other
+                logger.debug(
+                    f"Using forms elicitation handler (server config) for agent {agent_config.name}"
+                )
+                return forms_elicitation_handler
+
+    # 3. Check global config file
+    elicitation_config = getattr(app_config, "elicitation", {})
+    if isinstance(elicitation_config, dict):
+        mode = elicitation_config.get("mode", "forms")
+    else:
+        mode = getattr(elicitation_config, "mode", "forms")
+
+    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":
+        logger.debug(
+            f"Using auto-cancel elicitation handler (global config) for agent {agent_config.name}"
+        )
+        return auto_cancel_elicitation_handler
+    else:  # "forms" or default
+        logger.debug(f"Using default forms elicitation handler for agent {agent_config.name}")
+        return forms_elicitation_handler

mcp_agent/mcp/elicitation_handlers.py

@@ -0,0 +1,155 @@
+"""
+Predefined elicitation handlers for different use cases.
+"""
+
+import json
+from typing import TYPE_CHECKING, Any
+
+from mcp.shared.context import RequestContext
+from mcp.types import ElicitRequestParams, ElicitResult, ErrorData
+
+from mcp_agent.human_input.elicitation_handler import elicitation_input_callback
+from mcp_agent.human_input.types import HumanInputRequest
+from mcp_agent.logging.logger import get_logger
+from mcp_agent.mcp.helpers.server_config_helpers import get_server_config
+
+if TYPE_CHECKING:
+    from mcp import ClientSession
+
+logger = get_logger(__name__)
+
+
+async def auto_cancel_elicitation_handler(
+    context: RequestContext["ClientSession", Any],
+    params: ElicitRequestParams,
+) -> ElicitResult | ErrorData:
+    """Handler that automatically cancels all elicitation requests.
+    
+    Useful for production deployments where you want to advertise elicitation
+    capability but automatically decline all requests.
+    """
+    logger.info(f"Auto-cancelling elicitation request: {params.message}")
+    return ElicitResult(action="cancel")
+
+
+async def forms_elicitation_handler(
+    context: RequestContext["ClientSession", Any], params: ElicitRequestParams
+) -> ElicitResult:
+    """
+    Interactive forms-based elicitation handler using enhanced input handler.
+    """
+    logger.info(f"Eliciting response for params: {params}")
+
+    # Get server config for additional context
+    server_config = get_server_config(context)
+    server_name = server_config.name if server_config else "Unknown Server"
+    server_info = (
+        {"command": server_config.command} if server_config and server_config.command else None
+    )
+
+    # Get agent name - try multiple sources in order of preference
+    agent_name: str | None = None
+
+    # 1. Check if we have an MCPAgentClientSession in the context
+    from mcp_agent.mcp.mcp_agent_client_session import MCPAgentClientSession
+    if hasattr(context, "session") and isinstance(context.session, MCPAgentClientSession):
+        agent_name = context.session.agent_name
+
+    # 2. If no agent name yet, use a sensible default
+    if not agent_name:
+        agent_name = "Unknown Agent"
+
+    # Create human input request
+    request = HumanInputRequest(
+        prompt=params.message,
+        description=f"Schema: {params.requestedSchema}" if params.requestedSchema else None,
+        request_id=f"elicit_{id(params)}",
+        metadata={
+            "agent_name": agent_name,
+            "server_name": server_name,
+            "elicitation": True,
+            "requested_schema": params.requestedSchema,
+        },
+    )
+
+    try:
+        # Call the enhanced elicitation handler
+        response = await elicitation_input_callback(
+            request=request,
+            agent_name=agent_name,
+            server_name=server_name,
+            server_info=server_info,
+        )
+
+        # Check for special action responses
+        response_data = response.response.strip()
+
+        # Handle special responses
+        if response_data == "__DECLINED__":
+            return ElicitResult(action="decline")
+        elif response_data == "__CANCELLED__":
+            return ElicitResult(action="cancel")
+        elif response_data == "__DISABLE_SERVER__":
+            # Log that user wants to disable elicitation for this server
+            logger.warning(f"User requested to disable elicitation for server: {server_name}")
+            # For now, just cancel - in a full implementation, this would update server config
+            return ElicitResult(action="cancel")
+
+        # Parse response based on schema if provided
+        if params.requestedSchema:
+            # Check if the response is already JSON (from our form)
+            try:
+                # Try to parse as JSON first (from schema-driven form)
+                content = json.loads(response_data)
+                # Validate that all required fields are present
+                required_fields = params.requestedSchema.get("required", [])
+                for field in required_fields:
+                    if field not in content:
+                        logger.warning(f"Missing required field '{field}' in elicitation response")
+                        return ElicitResult(action="decline")
+            except json.JSONDecodeError:
+                # Not JSON, try to handle as simple text response
+                # This is a fallback for simple schemas or text-based responses
+                properties = params.requestedSchema.get("properties", {})
+                if len(properties) == 1:
+                    # Single field schema - try to parse based on type
+                    field_name = list(properties.keys())[0]
+                    field_def = properties[field_name]
+                    field_type = field_def.get("type")
+
+                    if field_type == "boolean":
+                        # Parse boolean values
+                        if response_data.lower() in ["yes", "y", "true", "1"]:
+                            content = {field_name: True}
+                        elif response_data.lower() in ["no", "n", "false", "0"]:
+                            content = {field_name: False}
+                        else:
+                            return ElicitResult(action="decline")
+                    elif field_type == "string":
+                        content = {field_name: response_data}
+                    elif field_type in ["number", "integer"]:
+                        try:
+                            value = (
+                                int(response_data)
+                                if field_type == "integer"
+                                else float(response_data)
+                            )
+                            content = {field_name: value}
+                        except ValueError:
+                            return ElicitResult(action="decline")
+                    else:
+                        # Unknown type, just pass as string
+                        content = {field_name: response_data}
+                else:
+                    # Multiple fields but text response - can't parse reliably
+                    logger.warning("Text response provided for multi-field schema")
+                    return ElicitResult(action="decline")
+        else:
+            # No schema, just return the raw response
+            content = {"response": response_data}
+
+        # Return the response wrapped in ElicitResult with accept action
+        return ElicitResult(action="accept", content=content)
+    except (KeyboardInterrupt, EOFError, TimeoutError):
+        # User cancelled or timeout
+        return ElicitResult(action="cancel")

mcp_agent/mcp/helpers/content_helpers.py

@@ -11,6 +11,7 @@ from mcp.types import (
     BlobResourceContents,
     EmbeddedResource,
     ImageContent,
+    ReadResourceResult,
     TextContent,
     TextResourceContents,
 )
@@ -114,3 +115,29 @@ def is_resource_content(content: Union[TextContent, ImageContent, EmbeddedResour
         True if the content is EmbeddedResource, False otherwise
     """
     return isinstance(content, EmbeddedResource)
+
+
+def get_resource_text(result: ReadResourceResult, index: int = 0) -> Optional[str]:
+    """
+    Extract text content from a ReadResourceResult at the specified index.
+
+    Args:
+        result: A ReadResourceResult from an MCP resource read operation
+        index: Index of the content item to extract text from (default: 0)
+
+    Returns:
+        The text content as a string or None if not available or not text content
+
+    Raises:
+        IndexError: If the index is out of bounds for the contents list
+    """
+    if index >= len(result.contents):
+        raise IndexError(
+            f"Index {index} out of bounds for contents list of length {len(result.contents)}"
+        )
+
+    content = result.contents[index]
+    if isinstance(content, TextResourceContents):
+        return content.text
+
+    return None

mcp_agent/mcp/helpers/server_config_helpers.py

@@ -1,14 +1,12 @@
 """Helper functions for type-safe server config access."""
 
-from typing import TYPE_CHECKING, Optional
-
-from mcp import ClientSession
+from typing import TYPE_CHECKING, Any, Optional
 
 if TYPE_CHECKING:
     from mcp_agent.config import MCPServerSettings
 
 
-def get_server_config(ctx: ClientSession) -> Optional["MCPServerSettings"]:
+def get_server_config(ctx: Any) -> Optional["MCPServerSettings"]:
     """Extract server config from context if available.
     
     Type guard helper that safely accesses server_config with proper type checking.
@@ -16,8 +14,12 @@ def get_server_config(ctx: ClientSession) -> Optional["MCPServerSettings"]:
     # Import here to avoid circular import
     from mcp_agent.mcp.mcp_agent_client_session import MCPAgentClientSession
     
-    if (hasattr(ctx, "session") and 
-        isinstance(ctx.session, MCPAgentClientSession) and
-        ctx.session.server_config):
-        return ctx.session.server_config
+    # Check if ctx has a session attribute (RequestContext case)
+    if hasattr(ctx, "session"):
+        if isinstance(ctx.session, MCPAgentClientSession) and hasattr(ctx.session, 'server_config'):
+            return ctx.session.server_config
+    # Also check if ctx itself is MCPAgentClientSession (direct call case)
+    elif isinstance(ctx, MCPAgentClientSession) and hasattr(ctx, 'server_config'):
+        return ctx.server_config
+    
     return None

mcp_agent/mcp/mcp_agent_client_session.py

@@ -13,7 +13,12 @@ from mcp.shared.session import (
     ReceiveResultT,
     SendRequestT,
 )
-from mcp.types import Implementation, ListRootsResult, Root, ToolListChangedNotification
+from mcp.types import (
+    Implementation,
+    ListRootsResult,
+    Root,
+    ToolListChangedNotification,
+)
 from pydantic import FileUrl
 
 from mcp_agent.context_dependent import ContextDependent
@@ -71,6 +76,10 @@ class MCPAgentClientSession(ClientSession, ContextDependent):
         self.server_config: MCPServerSettings | None = kwargs.pop("server_config", None)
         # Extract agent_model if provided (for auto_sampling fallback)
         self.agent_model: str | None = kwargs.pop("agent_model", None)
+        # Extract agent_name if provided
+        self.agent_name: str | None = kwargs.pop("agent_name", None)
+        # Extract custom elicitation handler if provided
+        custom_elicitation_handler = kwargs.pop("elicitation_handler", None)
 
         # Only register callbacks if the server_config has the relevant settings
         list_roots_cb = list_roots if (self.server_config and self.server_config.roots) else None
@@ -90,12 +99,46 @@ class MCPAgentClientSession(ClientSession, ContextDependent):
             # Auto-sampling enabled at application level
             sampling_cb = sample
 
+        # Use custom elicitation handler if provided, otherwise resolve using factory
+        if custom_elicitation_handler is not None:
+            elicitation_handler = custom_elicitation_handler
+        else:
+            # Try to resolve using factory
+            elicitation_handler = None
+            try:
+                from mcp_agent.context import get_current_context
+                from mcp_agent.core.agent_types import AgentConfig
+                from mcp_agent.mcp.elicitation_factory import resolve_elicitation_handler
+
+                context = get_current_context()
+                if context and context.config:
+                    # Create a minimal agent config for the factory
+                    agent_config = AgentConfig(
+                        name=self.agent_name or "unknown",
+                        model=self.agent_model or "unknown",
+                        elicitation_handler=None,  # No decorator-level handler since we're in the else block
+                    )
+                    elicitation_handler = resolve_elicitation_handler(
+                        agent_config, context.config, self.server_config
+                    )
+            except Exception:
+                # If factory resolution fails, we'll use default fallback
+                pass
+
+            # Fallback to forms handler only if factory resolution wasn't attempted
+            # If factory was attempted and returned None, respect that (means no elicitation capability)
+            if elicitation_handler is None and not self.server_config:
+                from mcp_agent.mcp.elicitation_handlers import forms_elicitation_handler
+
+                elicitation_handler = forms_elicitation_handler
+
         super().__init__(
             *args,
             **kwargs,
             list_roots_callback=list_roots_cb,
             sampling_callback=sampling_cb,
             client_info=fast_agent,
+            elicitation_callback=elicitation_handler,
         )
 
     def _should_enable_auto_sampling(self) -> bool: