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

fast_agent/llm/provider/anthropic/anthropic_utils.py

@@ -0,0 +1,84 @@
+"""
+Utility functions for Anthropic integration with MCP.
+
+Provides conversion between Anthropic message formats and PromptMessageExtended,
+leveraging existing code for resource handling and delimited formats.
+"""
+
+from anthropic.types import (
+    MessageParam,
+)
+from mcp.types import (
+    EmbeddedResource,
+    ImageContent,
+    TextContent,
+    TextResourceContents,
+)
+
+from fast_agent.types import PromptMessageExtended
+
+
+# TODO -- only used for saving, but this will be driven directly from PromptMessages
+def anthropic_message_param_to_prompt_message_multipart(
+    message_param: MessageParam,
+) -> PromptMessageExtended:
+    """
+    Convert an Anthropic MessageParam to a PromptMessageExtended.
+
+    Args:
+        message_param: The Anthropic MessageParam to convert
+
+    Returns:
+        A PromptMessageExtended representation
+    """
+    role = message_param["role"]
+    content = message_param["content"]
+
+    # Handle string content (user messages can be simple strings)
+    if isinstance(content, str):
+        return PromptMessageExtended(role=role, content=[TextContent(type="text", text=content)])
+
+    # Convert content blocks to MCP content types
+    mcp_contents = []
+
+    for block in content:
+        if isinstance(block, dict):
+            if block.get("type") == "text":
+                text = block.get("text", "")
+
+                # Check if this is a resource marker
+                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()
+                        if mime_match != "text/plain":  # Only process non-plain text resources
+                            if "Resource:" in header and "Binary Resource:" not in header:
+                                uri = header.split("Resource:", 1)[1].split(",")[0].strip()
+                                mcp_contents.append(
+                                    EmbeddedResource(
+                                        type="resource",
+                                        resource=TextResourceContents(
+                                            uri=uri,
+                                            mimeType=mime_match,
+                                            text=content_text,
+                                        ),
+                                    )
+                                )
+                                continue
+
+                # Regular text content
+                mcp_contents.append(TextContent(type="text", text=text))
+
+            elif block.get("type") == "image":
+                # Image content
+                source = block.get("source", {})
+                if isinstance(source, dict) and source.get("type") == "base64":
+                    media_type = source.get("media_type", "image/png")
+                    data = source.get("data", "")
+                    mcp_contents.append(ImageContent(type="image", data=data, mimeType=media_type))
+
+    return PromptMessageExtended(role=role, content=mcp_contents)

fast_agent/llm/provider/anthropic/cache_planner.py

@@ -0,0 +1,56 @@
+
+from fast_agent.mcp.prompt_message_extended import PromptMessageExtended
+
+
+class AnthropicCachePlanner:
+    """Calculate where to apply Anthropic cache_control blocks."""
+
+    def __init__(
+        self,
+        walk_distance: int = 6,
+        max_conversation_blocks: int = 2,
+        max_total_blocks: int = 4,
+    ) -> None:
+        self.walk_distance = walk_distance
+        self.max_conversation_blocks = max_conversation_blocks
+        self.max_total_blocks = max_total_blocks
+
+    def _template_prefix_count(self, messages: list[PromptMessageExtended]) -> int:
+        return sum(msg.is_template for msg in messages)
+
+    def plan_indices(
+        self,
+        messages: list[PromptMessageExtended],
+        cache_mode: str,
+        system_cache_blocks: int = 0,
+    ) -> list[int]:
+        """Return message indices that should receive cache_control."""
+
+        if cache_mode == "off" or not messages:
+            return []
+
+        budget = max(0, self.max_total_blocks - system_cache_blocks)
+        if budget == 0:
+            return []
+
+        template_prefix = self._template_prefix_count(messages)
+        template_indices: list[int] = []
+
+        if cache_mode in ("prompt", "auto") and template_prefix:
+            template_indices = list(range(min(template_prefix, budget)))
+            budget -= len(template_indices)
+
+        conversation_indices: list[int] = []
+        if cache_mode == "auto" and budget > 0:
+            conv_count = max(0, len(messages) - template_prefix)
+            if conv_count >= self.walk_distance:
+                positions = [
+                    template_prefix + i
+                    for i in range(self.walk_distance - 1, conv_count, self.walk_distance)
+                ]
+
+                # Respect Anthropic limits and remaining budget
+                positions = positions[-self.max_conversation_blocks :]
+                conversation_indices = positions[:budget]
+
+        return template_indices + conversation_indices