fast-agent-mcp 0.4.7__py3-none-any.whl

fast_agent/mcp/prompt_message_extended.py

@@ -0,0 +1,155 @@
+from typing import Mapping, Sequence
+
+from mcp.types import (
+    CallToolRequest,
+    CallToolResult,
+    ContentBlock,
+    GetPromptResult,
+    PromptMessage,
+    Role,
+    TextContent,
+)
+from pydantic import BaseModel
+
+from fast_agent.mcp.helpers.content_helpers import get_text
+
+# Import directly to avoid circular dependency with types/__init__.py
+from fast_agent.types.llm_stop_reason import LlmStopReason
+
+
+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] = []
+    tool_calls: dict[str, CallToolRequest] | None = None
+    tool_results: dict[str, CallToolResult] | None = None
+    channels: Mapping[str, Sequence[ContentBlock]] | None = None
+    stop_reason: LlmStopReason | None = None
+    is_template: bool = False
+
+    @classmethod
+    def to_extended(cls, messages: list[PromptMessage]) -> list["PromptMessageExtended"]:
+        """Convert a sequence of PromptMessages into PromptMessageExtended objects."""
+        if not messages:
+            return []
+
+        result = []
+        current_group = None
+        current_role = None
+
+        for msg in messages:
+            if msg.role != current_role:
+                # Role changed, start new message
+                if current_group is not None:
+                    result.append(current_group)
+                current_role = msg.role
+                current_group = cls(role=msg.role, content=[msg.content])
+            else:
+                # Same role, add to current message
+                if current_group is not None:
+                    current_group.content.append(msg.content)
+
+        # Add the last group
+        if current_group is not None:
+            result.append(current_group)
+
+        return result
+
+    def from_multipart(self) -> list[PromptMessage]:
+        """Convert this PromptMessageExtended to a sequence of standard PromptMessages."""
+        return [
+            PromptMessage(role=self.role, content=content_part) for content_part in self.content
+        ]
+
+    def first_text(self) -> str:
+        """
+        Get the first available text content from a message. Note this could be tool content etc.
+
+        Args:
+            message: A PromptMessage or PromptMessageExtended
+
+        Returns:
+            First text content or None if no text content exists
+        """
+        for content in self.content:
+            text = get_text(content)
+            if text is not None:
+                return text
+
+        return "<no text>"
+
+    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 PromptMessageExtended
+
+        Returns:
+            First text content or None if no text content exists
+        """
+        for content in reversed(self.content):
+            text = get_text(content)
+            if text is not None:
+                return text
+
+        return None
+
+    def all_text(self) -> str:
+        """
+        Get all the text available.
+
+        Args:
+            message: A PromptMessage or PromptMessageExtended
+
+        Returns:
+            First text content or None if no text content exists
+        """
+        result = []
+        for content in self.content:
+            text = get_text(content)
+            if text is not None:
+                result.append(text)
+
+        return "\n".join(result)
+
+    def add_text(self, to_add: str) -> TextContent:
+        text = TextContent(type="text", text=to_add)
+        self.content.append(text)
+        return text
+
+    @classmethod
+    def parse_get_prompt_result(cls, result: GetPromptResult) -> list["PromptMessageExtended"]:
+        """
+        Parse a GetPromptResult into PromptMessageExtended objects.
+
+        Args:
+            result: GetPromptResult from MCP server
+
+        Returns:
+            List of PromptMessageExtended objects
+        """
+        return cls.to_extended(result.messages)
+
+    @classmethod
+    def from_get_prompt_result(
+        cls, result: GetPromptResult | None
+    ) -> list["PromptMessageExtended"]:
+        """
+        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 PromptMessageExtended objects or empty list if result is None/empty
+        """
+        if not result or not result.messages:
+            return []
+        return cls.to_extended(result.messages)

fast_agent/mcp/prompt_render.py

@@ -0,0 +1,84 @@
+"""
+Utilities for rendering PromptMessageExtended objects for display.
+"""
+
+from typing import cast
+
+from mcp.types import BlobResourceContents, EmbeddedResource, ImageContent, TextResourceContents
+
+from fast_agent.mcp.helpers.content_helpers import (
+    get_resource_uri,
+    get_text,
+    is_image_content,
+    is_resource_content,
+    is_text_content,
+)
+from fast_agent.types import PromptMessageExtended
+
+
+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 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 = cast("ImageContent", content)
+            image_data = image.data
+            data_size = len(image_data) if image_data else 0
+            mime_type = image.mimeType
+            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)
+            embedded = cast("EmbeddedResource", content)
+            resource = embedded.resource
+
+            if isinstance(resource, TextResourceContents):
+                # Handle text resources
+                text = resource.text
+                text_length = len(text)
+                mime_type = resource.mimeType or "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}"
+                )
+                rendered_parts.append(resource_info)
+
+            elif isinstance(resource, BlobResourceContents):
+                # Handle blob resources (binary data)
+                blob = resource.blob
+                blob_length = len(blob) if blob else 0
+                mime_type = resource.mimeType or "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)