fast-agent-mcp 0.1.13__py3-none-any.whl → 0.2.0__py3-none-any.whl

mcp_agent/{workflows/llm → llm}/providers/multipart_converter_anthropic.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, List, Optional, Sequence, Union
+from typing import List, Sequence, Union
 
 from anthropic.types import (
     Base64ImageSourceParam,
@@ -30,11 +30,16 @@ from mcp_agent.mcp.mime_utils import (
     is_text_mime_type,
 )
 from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+from mcp_agent.mcp.prompts.prompt_helpers import (
+    get_image_data,
+    get_resource_uri,
+    get_text,
+    is_image_content,
+    is_resource_content,
+    is_text_content,
+)
 from mcp_agent.mcp.resource_utils import extract_title_from_uri
 
-if TYPE_CHECKING:
-    from pydantic import AnyUrl
-
 _logger = get_logger("multipart_converter_anthropic")
 
 # List of image MIME types supported by Anthropic API
@@ -74,7 +79,9 @@ class AnthropicConverter:
             return MessageParam(role=role, content=[])
 
         # Convert content blocks
-        anthropic_blocks = AnthropicConverter._convert_content_items(multipart_msg.content, document_mode=True)
+        anthropic_blocks = AnthropicConverter._convert_content_items(
+            multipart_msg.content, document_mode=True
+        )
 
         # Filter blocks based on role (assistant can only have text blocks)
         if role == "assistant":
@@ -83,7 +90,9 @@ class AnthropicConverter:
                 if block.get("type") == "text":
                     text_blocks.append(block)
                 else:
-                    _logger.warning(f"Removing non-text block from assistant message: {block.get('type')}")
+                    _logger.warning(
+                        f"Removing non-text block from assistant message: {block.get('type')}"
+                    )
             anthropic_blocks = text_blocks
 
         # Create the Anthropic message
@@ -124,31 +133,38 @@ class AnthropicConverter:
         anthropic_blocks: List[ContentBlockParam] = []
 
         for content_item in content_items:
-            if isinstance(content_item, TextContent):
-                anthropic_blocks.append(TextBlockParam(type="text", text=content_item.text))
-
-            elif isinstance(content_item, ImageContent):
+            if is_text_content(content_item):
+                # Handle text content
+                text = get_text(content_item)
+                anthropic_blocks.append(TextBlockParam(type="text", text=text))
+
+            elif is_image_content(content_item):
+                # Handle image content
+                image_content = content_item  # type: ImageContent
                 # Check if image MIME type is supported
-                if not AnthropicConverter._is_supported_image_type(content_item.mimeType):
+                if not AnthropicConverter._is_supported_image_type(image_content.mimeType):
+                    data_size = len(image_content.data) if image_content.data else 0
                     anthropic_blocks.append(
                         TextBlockParam(
                             type="text",
-                            text=f"Image with unsupported format '{content_item.mimeType}' ({len(content_item.data)} bytes)",
+                            text=f"Image with unsupported format '{image_content.mimeType}' ({data_size} bytes)",
                         )
                     )
                 else:
+                    image_data = get_image_data(image_content)
                     anthropic_blocks.append(
                         ImageBlockParam(
                             type="image",
                             source=Base64ImageSourceParam(
                                 type="base64",
-                                media_type=content_item.mimeType,
-                                data=content_item.data,
+                                media_type=image_content.mimeType,
+                                data=image_data,
                             ),
                         )
                     )
 
-            elif isinstance(content_item, EmbeddedResource):
+            elif is_resource_content(content_item):
+                # Handle embedded resource
                 block = AnthropicConverter._convert_embedded_resource(content_item, document_mode)
                 anthropic_blocks.append(block)
 
@@ -170,7 +186,8 @@ class AnthropicConverter:
             An appropriate ContentBlockParam for the resource
         """
         resource_content = resource.resource
-        uri: Optional[AnyUrl] = getattr(resource_content, "uri", None)
+        uri_str = get_resource_uri(resource)
+        uri = getattr(resource_content, "uri", None)
         is_url: bool = uri and uri.scheme in ("http", "https")
 
         # Determine MIME type
@@ -185,23 +202,33 @@ class AnthropicConverter:
 
         elif is_image_mime_type(mime_type):
             if not AnthropicConverter._is_supported_image_type(mime_type):
-                return AnthropicConverter._create_fallback_text(f"Image with unsupported format '{mime_type}'", resource)
+                return AnthropicConverter._create_fallback_text(
+                    f"Image with unsupported format '{mime_type}'", resource
+                )
 
-            if is_url:
-                return ImageBlockParam(type="image", source=URLImageSourceParam(type="url", url=str(uri)))
-            elif hasattr(resource_content, "blob"):
+            if is_url and uri_str:
+                return ImageBlockParam(
+                    type="image", source=URLImageSourceParam(type="url", url=uri_str)
+                )
+            
+            # Try to get image data
+            image_data = get_image_data(resource)
+            if image_data:
                 return ImageBlockParam(
                     type="image",
-                    source=Base64ImageSourceParam(type="base64", media_type=mime_type, data=resource_content.blob),
+                    source=Base64ImageSourceParam(
+                        type="base64", media_type=mime_type, data=image_data
+                    ),
                 )
+            
             return AnthropicConverter._create_fallback_text("Image missing data", resource)
 
         elif mime_type == "application/pdf":
-            if is_url:
+            if is_url and uri_str:
                 return DocumentBlockParam(
                     type="document",
                     title=title,
-                    source=URLPDFSourceParam(type="url", url=str(uri)),
+                    source=URLPDFSourceParam(type="url", url=uri_str),
                 )
             elif hasattr(resource_content, "blob"):
                 return DocumentBlockParam(
@@ -216,7 +243,8 @@ class AnthropicConverter:
             return TextBlockParam(type="text", text=f"[PDF resource missing data: {title}]")
 
         elif is_text_mime_type(mime_type):
-            if not hasattr(resource_content, "text"):
+            text = get_text(resource)
+            if not text:
                 return TextBlockParam(
                     type="text",
                     text=f"[Text content could not be extracted from {title}]",
@@ -230,26 +258,31 @@ class AnthropicConverter:
                     source=PlainTextSourceParam(
                         type="text",
                         media_type="text/plain",
-                        data=resource_content.text,
+                        data=text,
                     ),
                 )
 
             # Return as simple text block when not in document mode
-            return TextBlockParam(type="text", text=resource_content.text)
+            return TextBlockParam(type="text", text=text)
 
         # Default fallback - convert to text if possible
-        if hasattr(resource_content, "text"):
-            return TextBlockParam(type="text", text=resource_content.text)
+        text = get_text(resource)
+        if text:
+            return TextBlockParam(type="text", text=text)
 
         # This is for binary resources - match the format expected by the test
-        if isinstance(resource.resource, BlobResourceContents) and hasattr(resource.resource, "blob"):
+        if isinstance(resource.resource, BlobResourceContents) and hasattr(
+            resource.resource, "blob"
+        ):
             blob_length = len(resource.resource.blob)
             return TextBlockParam(
                 type="text",
                 text=f"Embedded Resource {uri._url} with unsupported format {mime_type} ({blob_length} characters)",
             )
 
-        return AnthropicConverter._create_fallback_text(f"Unsupported resource ({mime_type})", resource)
+        return AnthropicConverter._create_fallback_text(
+            f"Unsupported resource ({mime_type})", resource
+        )
 
     @staticmethod
     def _determine_mime_type(
@@ -292,7 +325,9 @@ class AnthropicConverter:
         return TextBlockParam(type="text", text="[SVG content could not be extracted]")
 
     @staticmethod
-    def _create_fallback_text(message: str, resource: Union[TextContent, ImageContent, EmbeddedResource]) -> TextBlockParam:
+    def _create_fallback_text(
+        message: str, resource: Union[TextContent, ImageContent, EmbeddedResource]
+    ) -> TextBlockParam:
         """
         Create a fallback text block for unsupported resource types.
 
@@ -310,7 +345,9 @@ class AnthropicConverter:
         return TextBlockParam(type="text", text=f"[{message}]")
 
     @staticmethod
-    def convert_tool_result_to_anthropic(tool_result: CallToolResult, tool_use_id: str) -> ToolResultBlockParam:
+    def convert_tool_result_to_anthropic(
+        tool_result: CallToolResult, tool_use_id: str
+    ) -> ToolResultBlockParam:
         """
         Convert an MCP CallToolResult to an Anthropic ToolResultBlockParam.
 
@@ -327,7 +364,9 @@ class AnthropicConverter:
         for item in tool_result.content:
             if isinstance(item, EmbeddedResource):
                 # For embedded resources, always use text mode in tool results
-                resource_block = AnthropicConverter._convert_embedded_resource(item, document_mode=False)
+                resource_block = AnthropicConverter._convert_embedded_resource(
+                    item, document_mode=False
+                )
                 anthropic_content.append(resource_block)
             elif isinstance(item, (TextContent, ImageContent)):
                 # For text and image, use standard conversion
@@ -376,11 +415,15 @@ class AnthropicConverter:
 
                     # Text resources go in tool results, others go as separate blocks
                     if isinstance(resource_content, TextResourceContents):
-                        block = AnthropicConverter._convert_embedded_resource(item, document_mode=False)
+                        block = AnthropicConverter._convert_embedded_resource(
+                            item, document_mode=False
+                        )
                         tool_result_blocks.append(block)
                     else:
                         # For binary resources like PDFs, add as separate block
-                        block = AnthropicConverter._convert_embedded_resource(item, document_mode=True)
+                        block = AnthropicConverter._convert_embedded_resource(
+                            item, document_mode=True
+                        )
                         separate_blocks.append(block)
 
             # Create the tool result block if we have content

mcp_agent/{workflows/llm → llm}/providers/multipart_converter_openai.py

@@ -15,6 +15,15 @@ from mcp_agent.mcp.mime_utils import (
     is_text_mime_type,
 )
 from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+from mcp_agent.mcp.prompts.prompt_helpers import (
+    MessageContent,
+    get_image_data,
+    get_resource_uri,
+    get_text,
+    is_image_content,
+    is_resource_content,
+    is_text_content,
+)
 from mcp_agent.mcp.resource_utils import extract_title_from_uri
 
 _logger = get_logger("multipart_converter_openai")
@@ -38,10 +47,14 @@ class OpenAIConverter:
         Returns:
             True if the MIME type is generally supported, False otherwise
         """
-        return mime_type is not None and is_image_mime_type(mime_type) and mime_type != "image/svg+xml"
+        return (
+            mime_type is not None and is_image_mime_type(mime_type) and mime_type != "image/svg+xml"
+        )
 
     @staticmethod
-    def convert_to_openai(multipart_msg: PromptMessageMultipart, concatenate_text_blocks: bool = False) -> OpenAIMessage:
+    def convert_to_openai(
+        multipart_msg: PromptMessageMultipart, concatenate_text_blocks: bool = False
+    ) -> OpenAIMessage:
         """
         Convert a PromptMessageMultipart message to OpenAI API format.
 
@@ -58,25 +71,10 @@ class OpenAIConverter:
         if not multipart_msg.content:
             return {"role": role, "content": ""}
 
-        # Assistant messages in OpenAI only support string content, not array of content blocks
-        if role == "assistant":
-            # Extract text from all text content blocks
-            content_text = ""
-            for item in multipart_msg.content:
-                if isinstance(item, TextContent):
-                    content_text += item.text
-                # Other types are ignored for assistant messages in OpenAI
-
-            return {"role": role, "content": content_text}
-
-        # System messages also only support string content
-        if role == "system":
-            # Extract text from all text content blocks
-            content_text = ""
-            for item in multipart_msg.content:
-                if isinstance(item, TextContent):
-                    content_text += item.text
-
+        # Assistant and system messages in OpenAI only support string content, not array of content blocks
+        if role == "assistant" or role == "system":
+            # Use MessageContent helper to get all text
+            content_text = MessageContent.join_text(multipart_msg, separator="")
             return {"role": role, "content": content_text}
 
         # For user messages, convert each content block
@@ -84,13 +82,14 @@ class OpenAIConverter:
 
         for item in multipart_msg.content:
             try:
-                if isinstance(item, TextContent):
-                    content_blocks.append({"type": "text", "text": item.text})
+                if is_text_content(item):
+                    text = get_text(item)
+                    content_blocks.append({"type": "text", "text": text})
 
-                elif isinstance(item, ImageContent):
+                elif is_image_content(item):
                     content_blocks.append(OpenAIConverter._convert_image_content(item))
 
-                elif isinstance(item, EmbeddedResource):
+                elif is_resource_content(item):
                     block = OpenAIConverter._convert_embedded_resource(item)
                     if block:
                         content_blocks.append(block)
@@ -118,7 +117,11 @@ class OpenAIConverter:
             return {"role": role, "content": ""}
 
         # If we only have one text content and it's empty, return an empty string for content
-        if len(content_blocks) == 1 and content_blocks[0]["type"] == "text" and not content_blocks[0]["text"]:
+        if (
+            len(content_blocks) == 1
+            and content_blocks[0]["type"] == "text"
+            and not content_blocks[0]["text"]
+        ):
             return {"role": role, "content": ""}
 
         # If concatenate_text_blocks is True, combine adjacent text blocks
@@ -167,7 +170,9 @@ class OpenAIConverter:
         return combined_blocks
 
     @staticmethod
-    def convert_prompt_message_to_openai(message: PromptMessage, concatenate_text_blocks: bool = False) -> OpenAIMessage:
+    def convert_prompt_message_to_openai(
+        message: PromptMessage, concatenate_text_blocks: bool = False
+    ) -> OpenAIMessage:
         """
         Convert a standard PromptMessage to OpenAI API format.
 
@@ -187,8 +192,11 @@ class OpenAIConverter:
     @staticmethod
     def _convert_image_content(content: ImageContent) -> ContentBlock:
         """Convert ImageContent to OpenAI image_url content block."""
+        # Get image data using helper
+        image_data = get_image_data(content)
+        
         # OpenAI requires image URLs or data URIs for images
-        image_url = {"url": f"data:{content.mimeType};base64,{content.data}"}
+        image_url = {"url": f"data:{content.mimeType};base64,{image_data}"}
 
         # Check if the image has annotations for detail level
         if hasattr(content, "annotations") and content.annotations:
@@ -236,6 +244,7 @@ class OpenAIConverter:
             An appropriate OpenAI content block or None if conversion failed
         """
         resource_content = resource.resource
+        uri_str = get_resource_uri(resource)
         uri = getattr(resource_content, "uri", None)
         is_url = uri and str(uri).startswith(("http://", "https://"))
         title = extract_title_from_uri(uri) if uri else "resource"
@@ -245,23 +254,26 @@ class OpenAIConverter:
 
         # Handle images
         if OpenAIConverter._is_supported_image_type(mime_type):
-            if is_url:
-                return {"type": "image_url", "image_url": {"url": str(uri)}}
-            elif hasattr(resource_content, "blob"):
+            if is_url and uri_str:
+                return {"type": "image_url", "image_url": {"url": uri_str}}
+            
+            # Try to get image data 
+            image_data = get_image_data(resource)
+            if image_data:
                 return {
                     "type": "image_url",
-                    "image_url": {"url": f"data:{mime_type};base64,{resource_content.blob}"},
+                    "image_url": {"url": f"data:{mime_type};base64,{image_data}"},
                 }
             else:
                 return {"type": "text", "text": f"[Image missing data: {title}]"}
 
         # Handle PDFs
         elif mime_type == "application/pdf":
-            if is_url:
+            if is_url and uri_str:
                 # OpenAI doesn't directly support PDF URLs, explain this limitation
                 return {
                     "type": "text",
-                    "text": f"[PDF URL: {uri}]\nOpenAI requires PDF files to be uploaded or provided as base64 data.",
+                    "text": f"[PDF URL: {uri_str}]\nOpenAI requires PDF files to be uploaded or provided as base64 data.",
                 }
             elif hasattr(resource_content, "blob"):
                 return {
@@ -273,18 +285,31 @@ class OpenAIConverter:
                 }
 
         # Handle SVG (convert to text)
-        elif mime_type == "image/svg+xml" and hasattr(resource_content, "text"):
-            file_text = f'<fastagent:file title="{title}" mimetype="{mime_type}">\n' f"{resource_content.text}\n" f"</fastagent:file>"
-            return {"type": "text", "text": file_text}
+        elif mime_type == "image/svg+xml":
+            text = get_text(resource)
+            if text:
+                file_text = (
+                    f'<fastagent:file title="{title}" mimetype="{mime_type}">\n'
+                    f"{text}\n"
+                    f"</fastagent:file>"
+                )
+                return {"type": "text", "text": file_text}
 
         # Handle text files
-        elif is_text_mime_type(mime_type) and hasattr(resource_content, "text"):
-            file_text = f'<fastagent:file title="{title}" mimetype="{mime_type}">\n' f"{resource_content.text}\n" f"</fastagent:file>"
-            return {"type": "text", "text": file_text}
+        elif is_text_mime_type(mime_type):
+            text = get_text(resource)
+            if text:
+                file_text = (
+                    f'<fastagent:file title="{title}" mimetype="{mime_type}">\n'
+                    f"{text}\n"
+                    f"</fastagent:file>"
+                )
+                return {"type": "text", "text": file_text}
 
         # Default fallback for text resources
-        elif hasattr(resource_content, "text"):
-            return {"type": "text", "text": resource_content.text}
+        text = get_text(resource)
+        if text:
+            return {"type": "text", "text": text}
 
         # Default fallback for binary resources
         elif hasattr(resource_content, "blob"):
@@ -370,10 +395,14 @@ class OpenAIConverter:
         if text_content:
             # Convert text content to OpenAI format
             temp_multipart = PromptMessageMultipart(role="user", content=text_content)
-            converted = OpenAIConverter.convert_to_openai(temp_multipart, concatenate_text_blocks=concatenate_text_blocks)
+            converted = OpenAIConverter.convert_to_openai(
+                temp_multipart, concatenate_text_blocks=concatenate_text_blocks
+            )
 
             # Extract text from content blocks
-            tool_message_content = OpenAIConverter._extract_text_from_content_blocks(converted.get("content", ""))
+            tool_message_content = OpenAIConverter._extract_text_from_content_blocks(
+                converted.get("content", "")
+            )
 
         if not tool_message_content:
             tool_message_content = "[Tool returned non-text content]"

mcp_agent/{workflows/llm → llm}/providers/openai_multipart.py

@@ -70,7 +70,11 @@ def _openai_message_to_multipart(
                 text = part.get("text") if isinstance(part, dict) else getattr(part, "text", "")
 
                 # Check if this is a resource marker
-                if text and (text.startswith("[Resource:") or text.startswith("[Binary Resource:")) and "\n" in text:
+                if (
+                    text
+                    and (text.startswith("[Resource:") or text.startswith("[Binary Resource:"))
+                    and "\n" in text
+                ):
                     header, content_text = text.split("\n", 1)
                     if "MIME:" in header:
                         mime_match = header.split("MIME:", 1)[1].split("]")[0].strip()
@@ -96,14 +100,24 @@ def _openai_message_to_multipart(
 
             # Handle image content
             elif part_type == "image_url":
-                image_url = part.get("image_url", {}) if isinstance(part, dict) else getattr(part, "image_url", None)
+                image_url = (
+                    part.get("image_url", {})
+                    if isinstance(part, dict)
+                    else getattr(part, "image_url", None)
+                )
                 if image_url:
-                    url = image_url.get("url") if isinstance(image_url, dict) else getattr(image_url, "url", "")
+                    url = (
+                        image_url.get("url")
+                        if isinstance(image_url, dict)
+                        else getattr(image_url, "url", "")
+                    )
                     if url and url.startswith("data:image/"):
                         # Handle base64 data URLs
                         mime_type = url.split(";")[0].replace("data:", "")
                         data = url.split(",")[1]
-                        mcp_contents.append(ImageContent(type="image", data=data, mimeType=mime_type))
+                        mcp_contents.append(
+                            ImageContent(type="image", data=data, mimeType=mime_type)
+                        )
 
             # Handle explicit resource types
             elif part_type == "resource" and isinstance(part, dict) and "resource" in part:

mcp_agent/{workflows/llm → llm/providers}/openai_utils.py

@@ -12,11 +12,11 @@ from openai.types.chat import (
     ChatCompletionMessageParam,
 )
 
-from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
-from mcp_agent.workflows.llm.providers.multipart_converter_openai import OpenAIConverter
-from mcp_agent.workflows.llm.providers.openai_multipart import (
+from mcp_agent.llm.providers.multipart_converter_openai import OpenAIConverter
+from mcp_agent.llm.providers.openai_multipart import (
     openai_to_multipart,
 )
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 
 
 def openai_message_to_prompt_message_multipart(

mcp_agent/{workflows/llm → llm}/providers/sampling_converter_anthropic.py

@@ -7,11 +7,11 @@ from mcp.types import (
     PromptMessage,
 )
 
-from mcp_agent.logging.logger import get_logger
-from mcp_agent.workflows.llm.providers.multipart_converter_anthropic import (
+from mcp_agent.llm.providers.multipart_converter_anthropic import (
     AnthropicConverter,
 )
-from mcp_agent.workflows.llm.sampling_format_converter import ProviderFormatConverter
+from mcp_agent.llm.sampling_format_converter import ProviderFormatConverter
+from mcp_agent.logging.logger import get_logger
 
 _logger = get_logger(__name__)
 

mcp_agent/{workflows/llm → llm}/providers/sampling_converter_openai.py

@@ -7,10 +7,10 @@ from openai.types.chat import (
     ChatCompletionMessage,
 )
 
-from mcp_agent.logging.logger import get_logger
-from mcp_agent.workflows.llm.sampling_format_converter import (
+from mcp_agent.llm.sampling_format_converter import (
     ProviderFormatConverter,
 )
+from mcp_agent.logging.logger import get_logger
 
 _logger = get_logger(__name__)
 
@@ -19,7 +19,7 @@ class OpenAISamplingConverter(ProviderFormatConverter[Dict[str, Any], ChatComple
     @classmethod
     def from_prompt_message(cls, message: PromptMessage) -> Dict[str, Any]:
         """Convert an MCP PromptMessage to an OpenAI message dict."""
-        from mcp_agent.workflows.llm.providers.multipart_converter_openai import (
+        from mcp_agent.llm.providers.multipart_converter_openai import (
             OpenAIConverter,
         )
 

mcp_agent/{workflows/llm → llm}/sampling_converter.py

@@ -9,7 +9,6 @@ from mcp.types import (
     CreateMessageRequestParams,
     CreateMessageResult,
     SamplingMessage,
-    StopReason,
     TextContent,
 )
 
@@ -62,26 +61,6 @@ class SamplingConverter:
             # Add any other parameters needed
         )
 
-    @staticmethod
-    def create_message_result(response: str, model: str, stop_reason: StopReason = "endTurn") -> CreateMessageResult:
-        """
-        Create a CreateMessageResult from an LLM response.
-
-        Args:
-            response: Text response from the LLM
-            model: Model identifier
-            stop_reason: Reason generation stopped
-
-        Returns:
-            CreateMessageResult suitable for returning to MCP
-        """
-        return CreateMessageResult(
-            role="assistant",
-            content=TextContent(type="text", text=response),
-            model=model,
-            stopReason=stop_reason,
-        )
-
     @staticmethod
     def error_result(error_message: str, model: Optional[str] = None) -> CreateMessageResult:
         """

mcp_agent/{workflows/llm → llm}/sampling_format_converter.py

@@ -1,7 +1,9 @@
-from typing import Generic, Protocol, TypeVar
+from typing import Generic, List, Protocol, TypeVar
 
 from mcp.types import PromptMessage
 
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+
 # Define covariant type variables
 MessageParamT_co = TypeVar("MessageParamT_co", covariant=True)
 MessageT_co = TypeVar("MessageT_co", covariant=True)
@@ -15,8 +17,21 @@ class ProviderFormatConverter(Protocol, Generic[MessageParamT_co, MessageT_co]):
         """Convert an MCP PromptMessage to a provider-specific message parameter."""
         ...
 
+    @classmethod
+    def from_mutlipart_prompts(
+        cls, messages: List[PromptMessageMultipart]
+    ) -> List[MessageParamT_co]:
+        """Convert a list of PromptMessageMultiparts to a list of provider-specific implementations"""
+        ...
+
 
 class BasicFormatConverter(ProviderFormatConverter[PromptMessage, PromptMessage]):
     @classmethod
     def from_prompt_message(cls, message: PromptMessage) -> PromptMessage:
         return message
+
+    @classmethod
+    def from_multipart_prompts(
+        cls, messages: List[PromptMessageMultipart]
+    ) -> List[PromptMessageMultipart]:
+        return messages

mcp_agent/logging/logger.py

@@ -192,7 +192,7 @@ class LoggingConfig:
         batch_size: int = 100,
         flush_interval: float = 2.0,
         **kwargs: Any,
-    ):
+    ) -> None:
         """
         Configure the logging system.
 
@@ -230,7 +230,7 @@ class LoggingConfig:
         cls._initialized = True
 
     @classmethod
-    async def shutdown(cls):
+    async def shutdown(cls) -> None:
         """Shutdown the logging system gracefully."""
         if not cls._initialized:
             return