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

mcp_agent/workflows/llm/augmented_llm_playback.py

@@ -1,9 +1,13 @@
-from typing import List, Optional, Union
+from typing import TYPE_CHECKING, List, Optional, Union
+
 from mcp import GetPromptResult
-from mcp.types import PromptMessage
+
 from mcp_agent.workflows.llm.augmented_llm import MessageParamT, RequestParams
 from mcp_agent.workflows.llm.augmented_llm_passthrough import PassthroughLLM
 
+if TYPE_CHECKING:
+    from mcp.types import PromptMessage
+
 
 # TODO -- support tool calling
 class PlaybackLLM(PassthroughLLM):
@@ -19,7 +23,7 @@ class PlaybackLLM(PassthroughLLM):
     been played back, it returns a message indicating that messages are exhausted.
     """
 
-    def __init__(self, name: str = "Playback", **kwargs):
+    def __init__(self, name: str = "Playback", **kwargs) -> None:
         super().__init__(name=name, **kwargs)
         self._messages: List[PromptMessage] = []
         self._current_index = 0
@@ -70,9 +74,7 @@ class PlaybackLLM(PassthroughLLM):
         # If we get here, we've run out of assistant messages
         return f"MESSAGES EXHAUSTED (list size {len(self._messages)})"
 
-    async def apply_prompt_template(
-        self, prompt_result: GetPromptResult, prompt_name: str
-    ) -> str:
+    async def apply_prompt_template(self, prompt_result: GetPromptResult, prompt_name: str) -> str:
         """
         Apply a prompt template by adding its messages to the playback queue.
 

mcp_agent/workflows/llm/memory.py

@@ -0,0 +1,103 @@
+from typing import Generic, List, Protocol, TypeVar
+
+# Define our own type variable for implementation use
+MessageParamT = TypeVar("MessageParamT")
+
+
+class Memory(Protocol, Generic[MessageParamT]):
+    """
+    Simple memory management for storing past interactions in-memory.
+    """
+
+    # TODO: saqadri - add checkpointing and other advanced memory capabilities
+
+    def __init__(self) -> None: ...
+
+    def extend(self, messages: List[MessageParamT], is_prompt: bool = False) -> None: ...
+
+    def set(self, messages: List[MessageParamT], is_prompt: bool = False) -> None: ...
+
+    def append(self, message: MessageParamT, is_prompt: bool = False) -> None: ...
+
+    def get(self, include_history: bool = True) -> List[MessageParamT]: ...
+
+    def clear(self, clear_prompts: bool = False) -> None: ...
+
+
+class SimpleMemory(Memory, Generic[MessageParamT]):
+    """
+    Simple memory management for storing past interactions in-memory.
+
+    Maintains both prompt messages (which are always included) and
+    generated conversation history (which is included based on use_history setting).
+    """
+
+    def __init__(self) -> None:
+        self.history: List[MessageParamT] = []
+        self.prompt_messages: List[MessageParamT] = []  # Always included
+
+    def extend(self, messages: List[MessageParamT], is_prompt: bool = False) -> None:
+        """
+        Add multiple messages to history.
+
+        Args:
+            messages: Messages to add
+            is_prompt: If True, add to prompt_messages instead of regular history
+        """
+        if is_prompt:
+            self.prompt_messages.extend(messages)
+        else:
+            self.history.extend(messages)
+
+    def set(self, messages: List[MessageParamT], is_prompt: bool = False) -> None:
+        """
+        Replace messages in history.
+
+        Args:
+            messages: Messages to set
+            is_prompt: If True, replace prompt_messages instead of regular history
+        """
+        if is_prompt:
+            self.prompt_messages = messages.copy()
+        else:
+            self.history = messages.copy()
+
+    def append(self, message: MessageParamT, is_prompt: bool = False) -> None:
+        """
+        Add a single message to history.
+
+        Args:
+            message: Message to add
+            is_prompt: If True, add to prompt_messages instead of regular history
+        """
+        if is_prompt:
+            self.prompt_messages.append(message)
+        else:
+            self.history.append(message)
+
+    def get(self, include_history: bool = True) -> List[MessageParamT]:
+        """
+        Get all messages in memory.
+
+        Args:
+            include_history: If True, include regular history messages
+                             If False, only return prompt messages
+
+        Returns:
+            Combined list of prompt messages and optionally history messages
+        """
+        if include_history:
+            return self.prompt_messages + self.history
+        else:
+            return self.prompt_messages.copy()
+
+    def clear(self, clear_prompts: bool = False) -> None:
+        """
+        Clear history and optionally prompt messages.
+
+        Args:
+            clear_prompts: If True, also clear prompt messages
+        """
+        self.history = []
+        if clear_prompts:
+            self.prompt_messages = []

mcp_agent/workflows/llm/model_factory.py

@@ -1,16 +1,16 @@
 from dataclasses import dataclass
 from enum import Enum, auto
-from typing import Optional, Type, Dict, Union, Callable
+from typing import Callable, Dict, Optional, Type, Union
 
 from mcp_agent.agents.agent import Agent
 from mcp_agent.core.exceptions import ModelConfigError
 from mcp_agent.core.request_params import RequestParams
+from mcp_agent.mcp.interfaces import AugmentedLLMProtocol
 from mcp_agent.workflows.llm.augmented_llm_anthropic import AnthropicAugmentedLLM
 from mcp_agent.workflows.llm.augmented_llm_openai import OpenAIAugmentedLLM
 from mcp_agent.workflows.llm.augmented_llm_passthrough import PassthroughLLM
 from mcp_agent.workflows.llm.augmented_llm_playback import PlaybackLLM
 
-
 # Type alias for LLM classes
 LLMClass = Union[
     Type[AnthropicAugmentedLLM],
@@ -145,14 +145,10 @@ class ModelFactory:
             if provider is None:
                 raise ModelConfigError(f"Unknown model: {model_name}")
 
-        return ModelConfig(
-            provider=provider, model_name=model_name, reasoning_effort=reasoning_effort
-        )
+        return ModelConfig(provider=provider, model_name=model_name, reasoning_effort=reasoning_effort)
 
     @classmethod
-    def create_factory(
-        cls, model_string: str, request_params: Optional[RequestParams] = None
-    ) -> Callable[..., LLMClass]:
+    def create_factory(cls, model_string: str, request_params: Optional[RequestParams] = None) -> Callable[..., AugmentedLLMProtocol]:
         """
         Creates a factory function that follows the attach_llm protocol.
 
@@ -173,23 +169,15 @@ class ModelFactory:
         # Create a factory function matching the attach_llm protocol
         def factory(agent: Agent, **kwargs) -> LLMClass:
             # Create merged params with parsed model name
-            factory_params = (
-                request_params.model_copy() if request_params else RequestParams()
-            )
-            factory_params.model = (
-                config.model_name
-            )  # Use the parsed model name, not the alias
+            factory_params = request_params.model_copy() if request_params else RequestParams()
+            factory_params.model = config.model_name  # Use the parsed model name, not the alias
 
             # Merge with any provided default_request_params
             if "default_request_params" in kwargs and kwargs["default_request_params"]:
                 params_dict = factory_params.model_dump()
-                params_dict.update(
-                    kwargs["default_request_params"].model_dump(exclude_unset=True)
-                )
+                params_dict.update(kwargs["default_request_params"].model_dump(exclude_unset=True))
                 factory_params = RequestParams(**params_dict)
-                factory_params.model = (
-                    config.model_name
-                )  # Ensure parsed model name isn't overwritten
+                factory_params.model = config.model_name  # Ensure parsed model name isn't overwritten
 
             # Forward all keyword arguments to LLM constructor
             llm_args = {

mcp_agent/workflows/llm/openai_utils.py

@@ -5,7 +5,7 @@ This file provides backward compatibility with the existing API while
 delegating to the proper implementations in the providers/ directory.
 """
 
-from typing import Dict, Any, Union
+from typing import Any, Dict, Union
 
 from openai.types.chat import (
     ChatCompletionMessage,

mcp_agent/workflows/llm/prompt_utils.py

@@ -97,9 +97,7 @@ def format_server_info(
 
     # Combine all components
     server_content = "\n".join(components)
-    return format_fastagent_tag(
-        "server", f"\n{server_content}\n", {"name": server_name}
-    )
+    return format_fastagent_tag("server", f"\n{server_content}\n", {"name": server_name})
 
 
 def format_agent_info(

mcp_agent/workflows/llm/providers/multipart_converter_anthropic.py

@@ -1,38 +1,40 @@
-from typing import List, Union, Sequence, Optional
+from typing import TYPE_CHECKING, List, Optional, Sequence, Union
 
+from anthropic.types import (
+    Base64ImageSourceParam,
+    Base64PDFSourceParam,
+    ContentBlockParam,
+    DocumentBlockParam,
+    ImageBlockParam,
+    MessageParam,
+    PlainTextSourceParam,
+    TextBlockParam,
+    ToolResultBlockParam,
+    URLImageSourceParam,
+    URLPDFSourceParam,
+)
 from mcp.types import (
-    TextContent,
-    ImageContent,
-    EmbeddedResource,
-    CallToolResult,
-    TextResourceContents,
     BlobResourceContents,
+    CallToolResult,
+    EmbeddedResource,
+    ImageContent,
     PromptMessage,
+    TextContent,
+    TextResourceContents,
 )
-from pydantic import AnyUrl
-from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+
+from mcp_agent.logging.logger import get_logger
 from mcp_agent.mcp.mime_utils import (
     guess_mime_type,
-    is_text_mime_type,
     is_image_mime_type,
+    is_text_mime_type,
 )
-
-from anthropic.types import (
-    MessageParam,
-    TextBlockParam,
-    ImageBlockParam,
-    DocumentBlockParam,
-    Base64ImageSourceParam,
-    URLImageSourceParam,
-    Base64PDFSourceParam,
-    URLPDFSourceParam,
-    PlainTextSourceParam,
-    ToolResultBlockParam,
-    ContentBlockParam,
-)
-from mcp_agent.logging.logger import get_logger
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 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
@@ -72,9 +74,7 @@ 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,9 +83,7 @@ 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
@@ -127,15 +125,11 @@ class AnthropicConverter:
 
         for content_item in content_items:
             if isinstance(content_item, TextContent):
-                anthropic_blocks.append(
-                    TextBlockParam(type="text", text=content_item.text)
-                )
+                anthropic_blocks.append(TextBlockParam(type="text", text=content_item.text))
 
             elif isinstance(content_item, 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(content_item.mimeType):
                     anthropic_blocks.append(
                         TextBlockParam(
                             type="text",
@@ -155,9 +149,7 @@ class AnthropicConverter:
                     )
 
             elif isinstance(content_item, EmbeddedResource):
-                block = AnthropicConverter._convert_embedded_resource(
-                    content_item, document_mode
-                )
+                block = AnthropicConverter._convert_embedded_resource(content_item, document_mode)
                 anthropic_blocks.append(block)
 
         return anthropic_blocks
@@ -193,24 +185,16 @@ 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))
-                )
+                return ImageBlockParam(type="image", source=URLImageSourceParam(type="url", url=str(uri)))
             elif hasattr(resource_content, "blob"):
                 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=resource_content.blob),
                 )
-            return AnthropicConverter._create_fallback_text(
-                "Image missing data", resource
-            )
+            return AnthropicConverter._create_fallback_text("Image missing data", resource)
 
         elif mime_type == "application/pdf":
             if is_url:
@@ -229,9 +213,7 @@ class AnthropicConverter:
                         data=resource_content.blob,
                     ),
                 )
-            return TextBlockParam(
-                type="text", text=f"[PDF resource missing data: {title}]"
-            )
+            return TextBlockParam(type="text", text=f"[PDF resource missing data: {title}]")
 
         elif is_text_mime_type(mime_type):
             if not hasattr(resource_content, "text"):
@@ -260,18 +242,14 @@ class AnthropicConverter:
             return TextBlockParam(type="text", text=resource_content.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(
@@ -314,9 +292,7 @@ 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.
 
@@ -334,9 +310,7 @@ 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.
 
@@ -353,22 +327,16 @@ 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
-                blocks = AnthropicConverter._convert_content_items(
-                    [item], document_mode=False
-                )
+                blocks = AnthropicConverter._convert_content_items([item], document_mode=False)
                 anthropic_content.extend(blocks)
 
         # If we ended up with no valid content blocks, create a placeholder
         if not anthropic_content:
-            anthropic_content = [
-                TextBlockParam(type="text", text="[No content in tool result]")
-            ]
+            anthropic_content = [TextBlockParam(type="text", text="[No content in tool result]")]
 
         # Create the tool result block
         return ToolResultBlockParam(
@@ -401,24 +369,18 @@ class AnthropicConverter:
             # Process each content item in the result
             for item in result.content:
                 if isinstance(item, (TextContent, ImageContent)):
-                    blocks = AnthropicConverter._convert_content_items(
-                        [item], document_mode=False
-                    )
+                    blocks = AnthropicConverter._convert_content_items([item], document_mode=False)
                     tool_result_blocks.extend(blocks)
                 elif isinstance(item, EmbeddedResource):
                     resource_content = item.resource
 
                     # 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
@@ -437,11 +399,7 @@ class AnthropicConverter:
                     ToolResultBlockParam(
                         type="tool_result",
                         tool_use_id=tool_use_id,
-                        content=[
-                            TextBlockParam(
-                                type="text", text="[No content in tool result]"
-                            )
-                        ],
+                        content=[TextBlockParam(type="text", text="[No content in tool result]")],
                         is_error=result.isError,
                     )
                 )

mcp_agent/workflows/llm/providers/multipart_converter_openai.py

@@ -1,23 +1,22 @@
-from typing import List, Union, Optional, Tuple, Dict, Any
+from typing import Any, Dict, List, Optional, Tuple, Union
 
 from mcp.types import (
-    TextContent,
-    ImageContent,
-    EmbeddedResource,
     CallToolResult,
+    EmbeddedResource,
+    ImageContent,
     PromptMessage,
+    TextContent,
 )
-from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+
+from mcp_agent.logging.logger import get_logger
 from mcp_agent.mcp.mime_utils import (
     guess_mime_type,
-    is_text_mime_type,
     is_image_mime_type,
+    is_text_mime_type,
 )
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 from mcp_agent.mcp.resource_utils import extract_title_from_uri
 
-
-from mcp_agent.logging.logger import get_logger
-
 _logger = get_logger("multipart_converter_openai")
 
 # Define type aliases for content blocks
@@ -39,16 +38,10 @@ 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.
 
@@ -104,9 +97,7 @@ class OpenAIConverter:
 
                 # Handle input_audio if implemented
                 elif hasattr(item, "type") and getattr(item, "type") == "input_audio":
-                    _logger.warning(
-                        "Input audio content not supported in standard OpenAI types"
-                    )
+                    _logger.warning("Input audio content not supported in standard OpenAI types")
                     fallback_text = "[Audio content not directly supported]"
                     content_blocks.append({"type": "text", "text": fallback_text})
 
@@ -127,11 +118,7 @@ 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
@@ -180,9 +167,7 @@ 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.
 
@@ -265,9 +250,7 @@ class OpenAIConverter:
             elif hasattr(resource_content, "blob"):
                 return {
                     "type": "image_url",
-                    "image_url": {
-                        "url": f"data:{mime_type};base64,{resource_content.blob}"
-                    },
+                    "image_url": {"url": f"data:{mime_type};base64,{resource_content.blob}"},
                 }
             else:
                 return {"type": "text", "text": f"[Image missing data: {title}]"}
@@ -291,20 +274,12 @@ 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>"
-            )
+            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}
 
         # 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>"
-            )
+            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}
 
         # Default fallback for text resources
@@ -349,11 +324,7 @@ class OpenAIConverter:
             if block.get("type") == "text":
                 text_parts.append(block.get("text", ""))
 
-        return (
-            " ".join(text_parts)
-            if text_parts
-            else "[Complex content converted to text]"
-        )
+        return " ".join(text_parts) if text_parts else "[Complex content converted to text]"
 
     @staticmethod
     def convert_tool_result_to_openai(
@@ -399,14 +370,10 @@ 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]"
@@ -423,9 +390,7 @@ class OpenAIConverter:
             return tool_message
 
         # Process non-text content as a separate user message
-        non_text_multipart = PromptMessageMultipart(
-            role="user", content=non_text_content
-        )
+        non_text_multipart = PromptMessageMultipart(role="user", content=non_text_content)
 
         # Convert to OpenAI format
         user_message = OpenAIConverter.convert_to_openai(non_text_multipart)