fast-agent-mcp 0.2.58__py3-none-any.whl → 0.3.1__py3-none-any.whl

{mcp_agent/core → fast_agent/mcp}/mcp_content.py

@@ -12,6 +12,7 @@ from typing import Any, List, Literal, Optional, Union
 from mcp.types import (
     Annotations,
     BlobResourceContents,
+    ContentBlock,
     EmbeddedResource,
     ImageContent,
     ReadResourceResult,
@@ -21,15 +22,12 @@ from mcp.types import (
 )
 from pydantic import AnyUrl
 
-from mcp_agent.mcp.mime_utils import (
+from fast_agent.mcp.mime_utils import (
     guess_mime_type,
     is_binary_content,
     is_image_mime_type,
 )
 
-# Type for all MCP content types
-MCPContentType = Union[TextContent, ImageContent, EmbeddedResource, ResourceContents]
-
 
 def MCPText(
     text: str,
@@ -152,8 +150,8 @@ def MCPFile(
 
 
 def MCPPrompt(
-    *content_items: Union[dict, str, Path, bytes, MCPContentType, 'EmbeddedResource', 'ReadResourceResult'], 
-    role: Literal["user", "assistant"] = "user"
+    *content_items: Union[dict, str, Path, bytes, ContentBlock, ReadResourceResult],
+    role: Literal["user", "assistant"] = "user",
 ) -> List[dict]:
     """
     Create one or more prompt messages with various content types.
@@ -209,19 +207,25 @@ def MCPPrompt(
         elif isinstance(item, EmbeddedResource):
             # Already an EmbeddedResource, wrap in a message
             result.append({"role": role, "content": item})
-        elif hasattr(item, 'type') and item.type == 'resource' and hasattr(item, 'resource'):
+        elif hasattr(item, "type") and item.type == "resource" and hasattr(item, "resource"):
             # Looks like an EmbeddedResource but may not be the exact class
-            result.append({"role": role, "content": EmbeddedResource(type="resource", resource=item.resource)})
+            result.append(
+                {"role": role, "content": EmbeddedResource(type="resource", resource=item.resource)}
+            )
         elif isinstance(item, ResourceContents):
             # It's a ResourceContents, wrap it in an EmbeddedResource
-            result.append({"role": role, "content": EmbeddedResource(type="resource", resource=item)})
+            result.append(
+                {"role": role, "content": EmbeddedResource(type="resource", resource=item)}
+            )
         elif isinstance(item, ReadResourceResult):
             # It's a ReadResourceResult, convert each resource content
             for resource_content in item.contents:
-                result.append({
-                    "role": role, 
-                    "content": EmbeddedResource(type="resource", resource=resource_content)
-                })
+                result.append(
+                    {
+                        "role": role,
+                        "content": EmbeddedResource(type="resource", resource=resource_content),
+                    }
+                )
         else:
             # Try to convert to string
             result.append(MCPText(str(item), role=role))
@@ -229,12 +233,16 @@ def MCPPrompt(
     return result
 
 
-def User(*content_items: Union[dict, str, Path, bytes, MCPContentType, 'EmbeddedResource', 'ReadResourceResult']) -> List[dict]:
+def User(
+    *content_items: Union[dict, str, Path, bytes, ContentBlock, ReadResourceResult],
+) -> List[dict]:
     """Create user message(s) with various content types."""
     return MCPPrompt(*content_items, role="user")
 
 
-def Assistant(*content_items: Union[dict, str, Path, bytes, MCPContentType, 'EmbeddedResource', 'ReadResourceResult']) -> List[dict]:
+def Assistant(
+    *content_items: Union[dict, str, Path, bytes, ContentBlock, ReadResourceResult],
+) -> List[dict]:
     """Create assistant message(s) with various content types."""
     return MCPPrompt(*content_items, role="assistant")
 

{mcp_agent → fast_agent}/mcp/mime_utils.py

@@ -67,3 +67,42 @@ def is_binary_content(mime_type: str) -> bool:
 def is_image_mime_type(mime_type: str) -> bool:
     """Check if a MIME type represents an image."""
     return mime_type.startswith("image/") and mime_type != "image/svg+xml"
+
+
+# Common alias mapping and normalization helpers
+_MIME_ALIASES = {
+    # Friendly or non-standard labels
+    "document/pdf": "application/pdf",
+    "image/jpg": "image/jpeg",
+    # Some providers sometimes return these variants
+    "application/x-pdf": "application/pdf",
+}
+
+
+def normalize_mime_type(mime: str | None) -> str | None:
+    """
+    Normalize a MIME-like string to a canonical MIME type.
+
+    - Lowercases and trims
+    - Resolves common aliases (e.g. image/jpg -> image/jpeg, document/pdf -> application/pdf)
+    - If input looks like a bare extension (e.g. "pdf", "png"), map via mimetypes
+    - Returns None for falsy inputs
+    """
+    if not mime:
+        return None
+
+    m = mime.strip().lower()
+
+    # If it's an alias we know about
+    if m in _MIME_ALIASES:
+        return _MIME_ALIASES[m]
+
+    # If it already looks like a full MIME type
+    if "/" in m:
+        # image/jpg -> image/jpeg etc.
+        return _MIME_ALIASES.get(m, m)
+
+    # Treat as a bare file extension (e.g. "pdf", "png")
+    if not m.startswith("."):
+        m = "." + m
+    return mimetypes.types_map.get(m, None)

fast_agent/mcp/prompt.py

@@ -0,0 +1,159 @@
+"""
+Prompt class for easily creating and working with MCP prompt content.
+
+This implementation lives in the fast_agent namespace as part of the
+migration away from fast_agent. A compatibility shim remains at
+fast_agent.core.prompt importing this Prompt.
+"""
+
+from pathlib import Path
+from typing import Dict, List, Literal, Union
+
+from mcp import CallToolRequest
+from mcp.types import ContentBlock, PromptMessage
+
+from fast_agent.mcp.mcp_content import Assistant, MCPPrompt, User
+from fast_agent.types import LlmStopReason, PromptMessageExtended
+
+
+class Prompt:
+    """
+    A helper class for working with MCP prompt content.
+
+    This class provides static methods to create:
+    - PromptMessage instances
+    - PromptMessageExtended instances
+    - Lists of messages for conversations
+
+    All methods intelligently handle various content types:
+    - Strings become TextContent
+    - Image file paths become ImageContent
+    - Other file paths become EmbeddedResource
+    - TextContent objects are used directly
+    - ImageContent objects are used directly
+    - EmbeddedResource objects are used directly
+    - Pre-formatted messages pass through unchanged
+    """
+
+    @classmethod
+    def user(
+        cls,
+        *content_items: Union[
+            str, Path, bytes, dict, ContentBlock, PromptMessage, PromptMessageExtended
+        ],
+    ) -> PromptMessageExtended:
+        """
+        Create a user PromptMessageExtended with various content items.
+        """
+        # Handle PromptMessage and PromptMessageExtended directly
+        if len(content_items) == 1:
+            item = content_items[0]
+            if isinstance(item, PromptMessage):
+                return PromptMessageExtended(role="user", content=[item.content])
+            elif isinstance(item, PromptMessageExtended):
+                # Keep the content but change role to user
+                return PromptMessageExtended(role="user", content=item.content)
+
+        # Use the content factory for other types
+        messages = User(*content_items)
+        return PromptMessageExtended(role="user", content=[msg["content"] for msg in messages])
+
+    @classmethod
+    def assistant(
+        cls,
+        *content_items: Union[
+            str, Path, bytes, dict, ContentBlock, PromptMessage, PromptMessageExtended
+        ],
+        stop_reason: LlmStopReason | None = None,
+        tool_calls: Dict[str, CallToolRequest] | None = None,
+    ) -> PromptMessageExtended:
+        """
+        Create an assistant PromptMessageExtended with various content items.
+        """
+        # Handle PromptMessage and PromptMessageExtended directly
+        if len(content_items) == 1:
+            item = content_items[0]
+            if isinstance(item, PromptMessage):
+                return PromptMessageExtended(
+                    role="assistant",
+                    content=[item.content],
+                    stop_reason=stop_reason,
+                    tool_calls=tool_calls,
+                )
+            elif isinstance(item, PromptMessageExtended):
+                # Keep the content but change role to assistant
+                return PromptMessageExtended(
+                    role="assistant",
+                    content=item.content,
+                    stop_reason=stop_reason,
+                    tool_calls=tool_calls,
+                )
+
+        # Use the content factory for other types
+        messages = Assistant(*content_items)
+        return PromptMessageExtended(
+            role="assistant",
+            content=[msg["content"] for msg in messages],
+            stop_reason=stop_reason,
+            tool_calls=tool_calls,
+        )
+
+    @classmethod
+    def message(
+        cls,
+        *content_items: Union[
+            str, Path, bytes, dict, ContentBlock, PromptMessage, PromptMessageExtended
+        ],
+        role: Literal["user", "assistant"] = "user",
+    ) -> PromptMessageExtended:
+        """
+        Create a PromptMessageExtended with the specified role and content items.
+        """
+        # Handle PromptMessage and PromptMessageExtended directly
+        if len(content_items) == 1:
+            item = content_items[0]
+            if isinstance(item, PromptMessage):
+                return PromptMessageExtended(role=role, content=[item.content])
+            elif isinstance(item, PromptMessageExtended):
+                # Keep the content but change role as specified
+                return PromptMessageExtended(role=role, content=item.content)
+
+        # Use the content factory for other types
+        messages = MCPPrompt(*content_items, role=role)
+        return PromptMessageExtended(
+            role=messages[0]["role"] if messages else role,
+            content=[msg["content"] for msg in messages],
+        )
+
+    @classmethod
+    def conversation(cls, *messages) -> List[PromptMessage]:
+        """
+        Create a list of PromptMessages from various inputs.
+        """
+        result = []
+
+        for item in messages:
+            if isinstance(item, PromptMessageExtended):
+                # Convert PromptMessageExtended to a list of PromptMessages
+                result.extend(item.from_multipart())
+            elif isinstance(item, dict) and "role" in item and "content" in item:
+                # Convert a single message dict to PromptMessage
+                result.append(PromptMessage(**item))
+            elif isinstance(item, list):
+                # Process each item in the list
+                for msg in item:
+                    if isinstance(msg, dict) and "role" in msg and "content" in msg:
+                        result.append(PromptMessage(**msg))
+            # Ignore other types
+
+        return result
+
+    @classmethod
+    def from_multipart(cls, multipart: List[PromptMessageExtended]) -> List[PromptMessage]:
+        """
+        Convert a list of PromptMessageExtended objects to PromptMessages.
+        """
+        result = []
+        for mp in multipart:
+            result.extend(mp.from_multipart())
+        return result

mcp_agent/mcp/prompt_message_multipart.py → fast_agent/mcp/prompt_message_extended.py

@@ -1,6 +1,8 @@
-from typing import List, Optional
+from typing import Dict, List, Optional
 
 from mcp.types import (
+    CallToolRequest,
+    CallToolResult,
     ContentBlock,
     GetPromptResult,
     PromptMessage,
@@ -9,21 +11,26 @@ from mcp.types import (
 )
 from pydantic import BaseModel
 
-from mcp_agent.mcp.helpers.content_helpers import get_text
+from fast_agent.mcp.helpers.content_helpers import get_text
+from fast_agent.types.llm_stop_reason import LlmStopReason
 
 
-class PromptMessageMultipart(BaseModel):
+class PromptMessageExtended(BaseModel):
     """
     Extension of PromptMessage that handles multiple content parts.
     Internally converts to/from a sequence of standard PromptMessages.
     """
 
     role: Role
-    content: List[ContentBlock]
+    content: List[ContentBlock] = []
+    tool_calls: Dict[str, CallToolRequest] | None = None
+    tool_results: Dict[str, CallToolResult] | None = None
+    channels: Dict[str, List[ContentBlock]] | None = None
+    stop_reason: LlmStopReason | None = None
 
     @classmethod
-    def to_multipart(cls, messages: List[PromptMessage]) -> List["PromptMessageMultipart"]:
-        """Convert a sequence of PromptMessages into PromptMessageMultipart objects."""
+    def to_extended(cls, messages: List[PromptMessage]) -> List["PromptMessageExtended"]:
+        """Convert a sequence of PromptMessages into PromptMessageExtended objects."""
         if not messages:
             return []
 
@@ -50,7 +57,7 @@ class PromptMessageMultipart(BaseModel):
         return result
 
     def from_multipart(self) -> List[PromptMessage]:
-        """Convert this PromptMessageMultipart to a sequence of standard PromptMessages."""
+        """Convert this PromptMessageExtended to a sequence of standard PromptMessages."""
         return [
             PromptMessage(role=self.role, content=content_part) for content_part in self.content
         ]
@@ -60,7 +67,7 @@ class PromptMessageMultipart(BaseModel):
         Get the first available text content from a message. Note this could be tool content etc.
 
         Args:
-            message: A PromptMessage or PromptMessageMultipart
+            message: A PromptMessage or PromptMessageExtended
 
         Returns:
             First text content or None if no text content exists
@@ -72,13 +79,13 @@ class PromptMessageMultipart(BaseModel):
 
         return "<no text>"
 
-    def last_text(self) -> str:
+    def last_text(self) -> str | None:
         """
         Get the last available text content from a message. This will usually be the final
         generation from the Assistant.
 
         Args:
-            message: A PromptMessage or PromptMessageMultipart
+            message: A PromptMessage or PromptMessageExtended
 
         Returns:
             First text content or None if no text content exists
@@ -88,14 +95,14 @@ class PromptMessageMultipart(BaseModel):
             if text is not None:
                 return text
 
-        return "<no text>"
+        return None
 
     def all_text(self) -> str:
         """
         Get all the text available.
 
         Args:
-            message: A PromptMessage or PromptMessageMultipart
+            message: A PromptMessage or PromptMessageExtended
 
         Returns:
             First text content or None if no text content exists
@@ -114,32 +121,32 @@ class PromptMessageMultipart(BaseModel):
         return text
 
     @classmethod
-    def parse_get_prompt_result(cls, result: GetPromptResult) -> List["PromptMessageMultipart"]:
+    def parse_get_prompt_result(cls, result: GetPromptResult) -> List["PromptMessageExtended"]:
         """
-        Parse a GetPromptResult into PromptMessageMultipart objects.
+        Parse a GetPromptResult into PromptMessageExtended objects.
 
         Args:
             result: GetPromptResult from MCP server
 
         Returns:
-            List of PromptMessageMultipart objects
+            List of PromptMessageExtended objects
         """
-        return cls.to_multipart(result.messages)
+        return cls.to_extended(result.messages)
 
     @classmethod
     def from_get_prompt_result(
         cls, result: Optional[GetPromptResult]
-    ) -> List["PromptMessageMultipart"]:
+    ) -> List["PromptMessageExtended"]:
         """
-        Convert a GetPromptResult to PromptMessageMultipart objects with error handling.
+        Convert a GetPromptResult to PromptMessageExtended objects with error handling.
         This method safely handles None values and empty results.
 
         Args:
             result: GetPromptResult from MCP server or None
 
         Returns:
-            List of PromptMessageMultipart objects or empty list if result is None/empty
+            List of PromptMessageExtended objects or empty list if result is None/empty
         """
         if not result or not result.messages:
             return []
-        return cls.to_multipart(result.messages)
+        return cls.to_extended(result.messages)

{mcp_agent → fast_agent}/mcp/prompt_render.py

@@ -1,43 +1,43 @@
 """
-Utilities for rendering PromptMessageMultipart objects for display.
+Utilities for rendering PromptMessageExtended objects for display.
 """
 
 from typing import List
 
 from mcp.types import BlobResourceContents, TextResourceContents
 
-from mcp_agent.mcp.helpers.content_helpers import (
+from fast_agent.mcp.helpers.content_helpers import (
     get_resource_uri,
     get_text,
     is_image_content,
     is_resource_content,
     is_text_content,
 )
-from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+from fast_agent.types import PromptMessageExtended
 
 
-def render_multipart_message(message: PromptMessageMultipart) -> str:
+def render_multipart_message(message: PromptMessageExtended) -> str:
     """
     Render a multipart message for display purposes.
-    
+
     This function formats the message content for user-friendly display,
     handling different content types appropriately.
-    
+
     Args:
-        message: A PromptMessageMultipart object to render
-        
+        message: A PromptMessageExtended object to render
+
     Returns:
         A string representation of the message's content
     """
     rendered_parts: List[str] = []
-    
+
     for content in message.content:
         if is_text_content(content):
             # Handle text content
             text = get_text(content)
             if text:
                 rendered_parts.append(text)
-            
+
         elif is_image_content(content):
             # Format details about the image
             image_data = getattr(content, "data", "")
@@ -45,36 +45,38 @@ def render_multipart_message(message: PromptMessageMultipart) -> str:
             mime_type = getattr(content, "mimeType", "unknown")
             image_info = f"[IMAGE: {mime_type}, {data_size} bytes]"
             rendered_parts.append(image_info)
-            
+
         elif is_resource_content(content):
             # Handle embedded resources
             uri = get_resource_uri(content)
             resource = getattr(content, "resource", None)
-            
+
             if resource and isinstance(resource, TextResourceContents):
                 # Handle text resources
                 text = resource.text
                 text_length = len(text)
                 mime_type = getattr(resource, "mimeType", "text/plain")
-                
+
                 # Preview with truncation for long content
                 preview = text[:300] + ("..." if text_length > 300 else "")
-                resource_info = f"[EMBEDDED TEXT RESOURCE: {mime_type}, {uri}, {text_length} chars]\n{preview}"
+                resource_info = (
+                    f"[EMBEDDED TEXT RESOURCE: {mime_type}, {uri}, {text_length} chars]\n{preview}"
+                )
                 rendered_parts.append(resource_info)
-                
+
             elif resource and isinstance(resource, BlobResourceContents):
                 # Handle blob resources (binary data)
                 blob = getattr(resource, "blob", "")
                 blob_length = len(blob) if blob else 0
                 mime_type = getattr(resource, "mimeType", "application/octet-stream")
-                
+
                 resource_info = f"[EMBEDDED BLOB RESOURCE: {mime_type}, {uri}, {blob_length} bytes]"
                 rendered_parts.append(resource_info)
-                
+
         else:
             # Fallback for other content types
             text = get_text(content)
             if text is not None:
                 rendered_parts.append(text)
-    
-    return "\n".join(rendered_parts)
+
+    return "\n".join(rendered_parts)