fast-agent-mcp 0.2.27__py3-none-any.whl → 0.2.28__py3-none-any.whl

mcp_agent/llm/providers/google_converter.py

@@ -0,0 +1,361 @@
+import base64
+from typing import Any, Dict, List, Tuple
+
+# Import necessary types from google.genai
+from google.genai import types
+from mcp.types import (
+    BlobResourceContents,
+    CallToolRequest,
+    CallToolRequestParams,
+    CallToolResult,
+    EmbeddedResource,
+    ImageContent,
+    TextContent,
+)
+
+from mcp_agent.core.request_params import RequestParams
+from mcp_agent.mcp.helpers.content_helpers import (
+    get_image_data,
+    get_text,
+    is_image_content,
+    is_resource_content,
+    is_text_content,
+)
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+from mcp_agent.tools.tool_definition import ToolDefinition
+
+
+class GoogleConverter:
+    """
+    Converts between fast-agent and google.genai data structures.
+    """
+
+    def _clean_schema_for_google(self, schema: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Recursively removes unsupported JSON schema keywords for google.genai.types.Schema.
+        Specifically removes 'additionalProperties', '$schema', 'exclusiveMaximum', and 'exclusiveMinimum'.
+        """
+        cleaned_schema = {}
+        unsupported_keys = {
+            "additionalProperties",
+            "$schema",
+            "exclusiveMaximum",
+            "exclusiveMinimum",
+        }
+        supported_string_formats = {"enum", "date-time"}
+
+        for key, value in schema.items():
+            if key in unsupported_keys:
+                continue  # Skip this key
+
+            if (
+                key == "format"
+                and schema.get("type") == "string"
+                and value not in supported_string_formats
+            ):
+                continue  # Remove unsupported string formats
+
+            if isinstance(value, dict):
+                cleaned_schema[key] = self._clean_schema_for_google(value)
+            elif isinstance(value, list):
+                cleaned_schema[key] = [
+                    self._clean_schema_for_google(item) if isinstance(item, dict) else item
+                    for item in value
+                ]
+            else:
+                cleaned_schema[key] = value
+        return cleaned_schema
+
+    def convert_to_google_content(
+        self, messages: List[PromptMessageMultipart]
+    ) -> List[types.Content]:
+        """
+        Converts a list of fast-agent PromptMessageMultipart to google.genai types.Content.
+        Handles different roles and content types (text, images, etc.).
+        """
+        google_contents: List[types.Content] = []
+        for message in messages:
+            parts: List[types.Part] = []
+            for part_content in message.content:  # renamed part to part_content to avoid conflict
+                if is_text_content(part_content):
+                    parts.append(types.Part.from_text(text=get_text(part_content) or ""))
+                elif is_image_content(part_content):
+                    assert isinstance(part_content, ImageContent)
+                    image_bytes = base64.b64decode(get_image_data(part_content) or "")
+                    parts.append(
+                        types.Part.from_bytes(mime_type=part_content.mimeType, data=image_bytes)
+                    )
+                elif is_resource_content(part_content):
+                    assert isinstance(part_content, EmbeddedResource)
+                    if (
+                        "application/pdf" == part_content.resource.mimeType
+                        and hasattr(part_content.resource, "blob")
+                        and isinstance(part_content.resource, BlobResourceContents)
+                    ):
+                        pdf_bytes = base64.b64decode(part_content.resource.blob)
+                        parts.append(
+                            types.Part.from_bytes(
+                                mime_type=part_content.resource.mimeType or "application/pdf",
+                                data=pdf_bytes,
+                            )
+                        )
+                    else:
+                        # Check if the resource itself has text content
+                        resource_text = None
+                        if hasattr(part_content.resource, "text"):  # Direct text attribute
+                            resource_text = part_content.resource.text
+                        # Example: if EmbeddedResource wraps a TextContent-like object in its 'resource' field
+                        elif (
+                            hasattr(part_content.resource, "type")
+                            and part_content.resource.type == "text"
+                            and hasattr(part_content.resource, "text")
+                        ):
+                            resource_text = get_text(part_content.resource)
+
+                        if resource_text is not None:
+                            parts.append(types.Part.from_text(text=resource_text))
+                        else:
+                            # Fallback for other binary types or types without direct text
+                            uri_str = (
+                                part_content.resource.uri
+                                if hasattr(part_content.resource, "uri")
+                                else "unknown_uri"
+                            )
+                            mime_str = (
+                                part_content.resource.mimeType
+                                if hasattr(part_content.resource, "mimeType")
+                                else "unknown_mime"
+                            )
+                            parts.append(
+                                types.Part.from_text(
+                                    text=f"[Resource: {uri_str}, MIME: {mime_str}]"
+                                )
+                            )
+
+            if parts:
+                google_role = (
+                    "user"
+                    if message.role == "user"
+                    else ("model" if message.role == "assistant" else "tool")
+                )
+                google_contents.append(types.Content(role=google_role, parts=parts))
+        return google_contents
+
+    def convert_to_google_tools(self, tools: List[ToolDefinition]) -> List[types.Tool]:
+        """
+        Converts a list of fast-agent ToolDefinition to google.genai types.Tool.
+        """
+        google_tools: List[types.Tool] = []
+        for tool in tools:
+            cleaned_input_schema = self._clean_schema_for_google(tool.inputSchema)
+            function_declaration = types.FunctionDeclaration(
+                name=tool.name,
+                description=tool.description if tool.description else "",
+                parameters=types.Schema(**cleaned_input_schema),
+            )
+            google_tools.append(types.Tool(function_declarations=[function_declaration]))
+        return google_tools
+
+    def convert_from_google_content(
+        self, content: types.Content
+    ) -> List[TextContent | ImageContent | EmbeddedResource | CallToolRequestParams]:
+        """
+        Converts google.genai types.Content from a model response to a list of
+        fast-agent content types or tool call requests.
+        """
+        fast_agent_parts: List[
+            TextContent | ImageContent | EmbeddedResource | CallToolRequestParams
+        ] = []
+        for part in content.parts:
+            if part.text:
+                fast_agent_parts.append(TextContent(type="text", text=part.text))
+            elif part.function_call:
+                fast_agent_parts.append(
+                    CallToolRequestParams(
+                        name=part.function_call.name,
+                        arguments=part.function_call.args,
+                    )
+                )
+        return fast_agent_parts
+
+    def convert_from_google_function_call(
+        self, function_call: types.FunctionCall
+    ) -> CallToolRequest:
+        """
+        Converts a single google.genai types.FunctionCall to a fast-agent CallToolRequest.
+        """
+        return CallToolRequest(
+            method="tools/call",
+            params=CallToolRequestParams(
+                name=function_call.name,
+                arguments=function_call.args,
+            ),
+        )
+
+    def convert_function_results_to_google(
+        self, tool_results: List[Tuple[str, CallToolResult]]
+    ) -> List[types.Content]:
+        """
+        Converts a list of fast-agent tool results to google.genai types.Content
+        with role 'tool'. Handles multimodal content in tool results.
+        """
+        google_tool_response_contents: List[types.Content] = []
+        for tool_name, tool_result in tool_results:
+            current_content_parts: List[types.Part] = []
+            textual_outputs: List[str] = []
+            media_parts: List[types.Part] = []
+
+            for item in tool_result.content:
+                if is_text_content(item):
+                    textual_outputs.append(get_text(item) or "")  # Ensure no None is added
+                elif is_image_content(item):
+                    assert isinstance(item, ImageContent)
+                    try:
+                        image_bytes = base64.b64decode(get_image_data(item) or "")
+                        media_parts.append(
+                            types.Part.from_bytes(data=image_bytes, mime_type=item.mimeType)
+                        )
+                    except Exception as e:
+                        textual_outputs.append(f"[Error processing image from tool result: {e}]")
+                elif is_resource_content(item):
+                    assert isinstance(item, EmbeddedResource)
+                    if (
+                        "application/pdf" == item.resource.mimeType
+                        and hasattr(item.resource, "blob")
+                        and isinstance(item.resource, BlobResourceContents)
+                    ):
+                        try:
+                            pdf_bytes = base64.b64decode(item.resource.blob)
+                            media_parts.append(
+                                types.Part.from_bytes(
+                                    data=pdf_bytes,
+                                    mime_type=item.resource.mimeType or "application/pdf",
+                                )
+                            )
+                        except Exception as e:
+                            textual_outputs.append(f"[Error processing PDF from tool result: {e}]")
+                    else:
+                        # Check if the resource itself has text content
+                        resource_text = None
+                        if hasattr(item.resource, "text"):  # Direct text attribute
+                            resource_text = item.resource.text
+                        # Example: if EmbeddedResource wraps a TextContent-like object in its 'resource' field
+                        elif (
+                            hasattr(item.resource, "type")
+                            and item.resource.type == "text"
+                            and hasattr(item.resource, "text")
+                        ):
+                            resource_text = get_text(item.resource)
+
+                        if resource_text is not None:
+                            textual_outputs.append(resource_text)
+                        else:
+                            uri_str = (
+                                item.resource.uri
+                                if hasattr(item.resource, "uri")
+                                else "unknown_uri"
+                            )
+                            mime_str = (
+                                item.resource.mimeType
+                                if hasattr(item.resource, "mimeType")
+                                else "unknown_mime"
+                            )
+                            textual_outputs.append(
+                                f"[Unhandled Resource in Tool: {uri_str}, MIME: {mime_str}]"
+                            )
+                # Add handling for other content types if needed, for now they are skipped or become unhandled resource text
+
+            function_response_payload: Dict[str, Any] = {"tool_name": tool_name}
+            if textual_outputs:
+                function_response_payload["text_content"] = "\n".join(textual_outputs)
+
+            # Only add media_parts if there are some, otherwise Gemini might error on empty parts for function response
+            if media_parts:
+                # Create the main FunctionResponse part
+                fn_response_part = types.Part.from_function_response(
+                    name=tool_name, response=function_response_payload
+                )
+                current_content_parts.append(fn_response_part)
+                current_content_parts.extend(
+                    media_parts
+                )  # Add media parts after the main response part
+            else:  # If no media parts, the textual output (if any) is the sole content of the function response
+                fn_response_part = types.Part.from_function_response(
+                    name=tool_name, response=function_response_payload
+                )
+                current_content_parts.append(fn_response_part)
+
+            google_tool_response_contents.append(
+                types.Content(role="tool", parts=current_content_parts)
+            )
+        return google_tool_response_contents
+
+    def convert_request_params_to_google_config(
+        self, request_params: RequestParams
+    ) -> types.GenerateContentConfig:
+        """
+        Converts fast-agent RequestParams to google.genai types.GenerateContentConfig.
+        """
+        config_args: Dict[str, Any] = {}
+        if request_params.temperature is not None:
+            config_args["temperature"] = request_params.temperature
+        if request_params.maxTokens is not None:
+            config_args["max_output_tokens"] = request_params.maxTokens
+        if hasattr(request_params, "topK") and request_params.topK is not None:
+            config_args["top_k"] = request_params.topK
+        if hasattr(request_params, "topP") and request_params.topP is not None:
+            config_args["top_p"] = request_params.topP
+        if hasattr(request_params, "stopSequences") and request_params.stopSequences is not None:
+            config_args["stop_sequences"] = request_params.stopSequences
+        if (
+            hasattr(request_params, "presencePenalty")
+            and request_params.presencePenalty is not None
+        ):
+            config_args["presence_penalty"] = request_params.presencePenalty
+        if (
+            hasattr(request_params, "frequencyPenalty")
+            and request_params.frequencyPenalty is not None
+        ):
+            config_args["frequency_penalty"] = request_params.frequencyPenalty
+        if request_params.systemPrompt is not None:
+            config_args["system_instruction"] = request_params.systemPrompt
+        return types.GenerateContentConfig(**config_args)
+
+    def convert_from_google_content_list(
+        self, contents: List[types.Content]
+    ) -> List[PromptMessageMultipart]:
+        """
+        Converts a list of google.genai types.Content to a list of fast-agent PromptMessageMultipart.
+        """
+        return [self._convert_from_google_content(content) for content in contents]
+
+    def _convert_from_google_content(self, content: types.Content) -> PromptMessageMultipart:
+        """
+        Converts a single google.genai types.Content to a fast-agent PromptMessageMultipart.
+        """
+        if content.role == "model" and any(part.function_call for part in content.parts):
+            return PromptMessageMultipart(role="assistant", content=[])
+
+        fast_agent_parts: List[
+            TextContent | ImageContent | EmbeddedResource | CallToolRequestParams
+        ] = []
+        for part in content.parts:
+            if part.text:
+                fast_agent_parts.append(TextContent(type="text", text=part.text))
+            elif part.function_response:
+                response_text = str(part.function_response.response)
+                fast_agent_parts.append(TextContent(type="text", text=response_text))
+            elif part.file_data:
+                fast_agent_parts.append(
+                    EmbeddedResource(
+                        type="resource",
+                        resource=TextContent(
+                            uri=part.file_data.file_uri,
+                            mimeType=part.file_data.mime_type,
+                            text=f"[Resource: {part.file_data.file_uri}, MIME: {part.file_data.mime_type}]",
+                        ),
+                    )
+                )
+
+        fast_agent_role = "user" if content.role == "user" else "assistant"
+        return PromptMessageMultipart(role=fast_agent_role, content=fast_agent_parts)

mcp_agent/mcp/helpers/server_config_helpers.py

@@ -0,0 +1,23 @@
+"""Helper functions for type-safe server config access."""
+
+from typing import TYPE_CHECKING, Optional
+
+from mcp import ClientSession
+
+if TYPE_CHECKING:
+    from mcp_agent.config import MCPServerSettings
+
+
+def get_server_config(ctx: ClientSession) -> Optional["MCPServerSettings"]:
+    """Extract server config from context if available.
+    
+    Type guard helper that safely accesses server_config with proper type checking.
+    """
+    # 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
+    return None

mcp_agent/mcp/mcp_agent_client_session.py

@@ -4,7 +4,7 @@ It adds logging and supports sampling requests.
 """
 
 from datetime import timedelta
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from mcp import ClientSession, ServerNotification
 from mcp.shared.session import (
@@ -20,6 +20,7 @@ from pydantic import FileUrl
 
 from mcp_agent.context_dependent import ContextDependent
 from mcp_agent.logging.logger import get_logger
+from mcp_agent.mcp.helpers.server_config_helpers import get_server_config
 from mcp_agent.mcp.sampling import sample
 
 if TYPE_CHECKING:
@@ -31,24 +32,20 @@ logger = get_logger(__name__)
 async def list_roots(ctx: ClientSession) -> ListRootsResult:
     """List roots callback that will be called by the MCP library."""
 
-    roots = []
-    if (
-        hasattr(ctx, "session")
-        and hasattr(ctx.session, "server_config")
-        and ctx.session.server_config
-        and hasattr(ctx.session.server_config, "roots")
-        and ctx.session.server_config.roots
-    ):
-        roots = [
-            Root(
-                uri=FileUrl(
-                    root.server_uri_alias or root.uri,
-                ),
-                name=root.name,
-            )
-            for root in ctx.session.server_config.roots
-        ]
-    return ListRootsResult(roots=roots or [])
+    if server_config := get_server_config(ctx):
+        if server_config.roots:
+            roots = [
+                Root(
+                    uri=FileUrl(
+                        root.server_uri_alias or root.uri,
+                    ),
+                    name=root.name,
+                )
+                for root in server_config.roots
+            ]
+            return ListRootsResult(roots=roots)
+
+    return ListRootsResult(roots=[])
 
 
 class MCPAgentClientSession(ClientSession, ContextDependent):
@@ -72,14 +69,43 @@ class MCPAgentClientSession(ClientSession, ContextDependent):
         self.session_server_name = kwargs.pop("server_name", None)
         # Extract the notification callbacks if provided
         self._tool_list_changed_callback = kwargs.pop("tool_list_changed_callback", None)
+        # Extract server_config if provided
+        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)
+
+        # 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
+        
+        # Register sampling callback if either:
+        # 1. Sampling is explicitly configured, OR
+        # 2. Application-level auto_sampling is enabled
+        sampling_cb = None
+        if self.server_config and hasattr(self.server_config, "sampling") and self.server_config.sampling:
+            # Explicit sampling configuration
+            sampling_cb = sample
+        elif self._should_enable_auto_sampling():
+            # Auto-sampling enabled at application level
+            sampling_cb = sample
+
         super().__init__(
             *args,
             **kwargs,
-            list_roots_callback=list_roots,
-            sampling_callback=sample,
+            list_roots_callback=list_roots_cb,
+            sampling_callback=sampling_cb,
             client_info=fast_agent,
         )
-        self.server_config: Optional[MCPServerSettings] = None
+
+    def _should_enable_auto_sampling(self) -> bool:
+        """Check if auto_sampling is enabled at the application level."""
+        try:
+            from mcp_agent.context import get_current_context
+            context = get_current_context()
+            if context and context.config:
+                return getattr(context.config, 'auto_sampling', True)
+        except Exception:
+            pass
+        return True  # Default to True if can't access config
 
     async def send_request(
         self,
@@ -91,10 +117,11 @@ class MCPAgentClientSession(ClientSession, ContextDependent):
         logger.debug("send_request: request=", data=request.model_dump())
         try:
             result = await super().send_request(
-                request,
-                result_type,
+                request=request,
+                result_type=result_type,
                 request_read_timeout_seconds=request_read_timeout_seconds,
                 progress_callback=progress_callback,
+                metadata=None,
             )
             logger.debug("send_request: response=", data=result.model_dump())
             return result

mcp_agent/mcp/mcp_aggregator.py

@@ -215,13 +215,20 @@ class MCPAggregator(ContextDependent):
                 )
 
                 # Create a wrapper to capture the parameters for the client session
-                def session_factory(read_stream, write_stream, read_timeout):
+                def session_factory(read_stream, write_stream, read_timeout, **kwargs):
+                    # Get agent's model if this aggregator is part of an agent
+                    agent_model = None
+                    if hasattr(self, 'config') and self.config and hasattr(self.config, 'model'):
+                        agent_model = self.config.model
+                    
                     return MCPAgentClientSession(
                         read_stream,
                         write_stream,
                         read_timeout,
                         server_name=server_name,
+                        agent_model=agent_model,
                         tool_list_changed_callback=self._handle_tool_list_changed,
+                        **kwargs  # Pass through any additional kwargs like server_config
                     )
 
                 await self._persistent_connection_manager.get_server(
@@ -269,13 +276,20 @@ class MCPAggregator(ContextDependent):
                 prompts = await fetch_prompts(server_connection.session, server_name)
             else:
                 # Create a factory function for the client session
-                def create_session(read_stream, write_stream, read_timeout):
+                def create_session(read_stream, write_stream, read_timeout, **kwargs):
+                    # Get agent's model if this aggregator is part of an agent
+                    agent_model = None
+                    if hasattr(self, 'config') and self.config and hasattr(self.config, 'model'):
+                        agent_model = self.config.model
+                    
                     return MCPAgentClientSession(
                         read_stream,
                         write_stream,
                         read_timeout,
                         server_name=server_name,
+                        agent_model=agent_model,
                         tool_list_changed_callback=self._handle_tool_list_changed,
+                        **kwargs  # Pass through any additional kwargs like server_config
                     )
 
                 async with gen_client(
@@ -797,12 +811,13 @@ class MCPAggregator(ContextDependent):
             messages=[],
         )
 
-    async def list_prompts(self, server_name: str | None = None) -> Mapping[str, List[Prompt]]:
+    async def list_prompts(self, server_name: str | None = None, agent_name: str | None = None) -> Mapping[str, List[Prompt]]:
         """
         List available prompts from one or all servers.
 
         :param server_name: Optional server name to list prompts from. If not provided,
                            lists prompts from all servers.
+        :param agent_name: Optional agent name (ignored at this level, used by multi-agent apps)
         :return: Dictionary mapping server names to lists of Prompt objects
         """
         if not self.initialized:

mcp_agent/mcp/mcp_connection_manager.py

@@ -165,11 +165,12 @@ class ServerConnection:
             else None
         )
 
-        session = self._client_session_factory(read_stream, send_stream, read_timeout)
-
-        # Make the server config available to the session for initialization
-        if hasattr(session, "server_config"):
-            session.server_config = self.server_config
+        session = self._client_session_factory(
+            read_stream, 
+            send_stream, 
+            read_timeout,
+            server_config=self.server_config
+        )
 
         self.session = session
 

mcp_agent/mcp/sampling.py

@@ -10,6 +10,7 @@ from mcp.types import CreateMessageRequestParams, CreateMessageResult, TextConte
 from mcp_agent.core.agent_types import AgentConfig
 from mcp_agent.llm.sampling_converter import SamplingConverter
 from mcp_agent.logging.logger import get_logger
+from mcp_agent.mcp.helpers.server_config_helpers import get_server_config
 from mcp_agent.mcp.interfaces import AugmentedLLMProtocol
 
 if TYPE_CHECKING:
@@ -78,18 +79,47 @@ async def sample(mcp_ctx: ClientSession, params: CreateMessageRequestParams) ->
     """
     model = None
     try:
-        # Extract model from server config
-        if (
-            hasattr(mcp_ctx, "session")
-            and hasattr(mcp_ctx.session, "server_config")
-            and mcp_ctx.session.server_config
-            and hasattr(mcp_ctx.session.server_config, "sampling")
-            and mcp_ctx.session.server_config.sampling.model
-        ):
-            model = mcp_ctx.session.server_config.sampling.model
+        # Extract model from server config using type-safe helper
+        server_config = get_server_config(mcp_ctx)
+        
+        # First priority: explicitly configured sampling model
+        if server_config and hasattr(server_config, "sampling") and server_config.sampling:
+            model = server_config.sampling.model
+        
+        # Second priority: auto_sampling fallback (if enabled at application level)
+        if model is None:
+            # Check if auto_sampling is enabled
+            auto_sampling_enabled = False
+            try:
+                from mcp_agent.context import get_current_context
+                app_context = get_current_context()
+                if app_context and app_context.config:
+                    auto_sampling_enabled = getattr(app_context.config, 'auto_sampling', True)
+            except Exception as e:
+                logger.debug(f"Could not get application config: {e}")
+                auto_sampling_enabled = True  # Default to enabled
+            
+            if auto_sampling_enabled:
+                # Import here to avoid circular import
+                from mcp_agent.mcp.mcp_agent_client_session import MCPAgentClientSession
+                
+                # Try agent's model first (from the session)
+                if (hasattr(mcp_ctx, 'session') and 
+                    isinstance(mcp_ctx.session, MCPAgentClientSession) and
+                    mcp_ctx.session.agent_model):
+                    model = mcp_ctx.session.agent_model
+                    logger.debug(f"Using agent's model for sampling: {model}")
+                else:
+                    # Fall back to system default model
+                    try:
+                        if app_context and app_context.config and app_context.config.default_model:
+                            model = app_context.config.default_model
+                            logger.debug(f"Using system default model for sampling: {model}")
+                    except Exception as e:
+                        logger.debug(f"Could not get system default model: {e}")
 
         if model is None:
-            raise ValueError("No model configured")
+            raise ValueError("No model configured for sampling (server config, agent model, or system default)")
 
         # Create an LLM instance
         llm = create_sampling_llm(params, model)