fast-agent-mcp 0.2.3__py3-none-any.whl → 0.2.5__py3-none-any.whl

mcp_agent/llm/augmented_llm.py

@@ -5,6 +5,7 @@ from typing import (
     Generic,
     List,
     Optional,
+    Tuple,
     Type,
     TypeVar,
     cast,
@@ -38,7 +39,6 @@ from mcp_agent.mcp.interfaces import (
 from mcp_agent.mcp.mcp_aggregator import MCPAggregator
 from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 from mcp_agent.mcp.prompt_render import render_multipart_message
-from mcp_agent.mcp.prompt_serialization import multipart_messages_to_delimited_format
 from mcp_agent.ui.console_display import ConsoleDisplay
 
 # Define type variables locally
@@ -76,12 +76,24 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
             ProviderFormatConverter[MessageParamT, MessageT]
         ] = BasicFormatConverter,
         context: Optional["Context"] = None,
+        model: Optional[str] = None,
         **kwargs: dict[str, Any],
     ) -> None:
         """
         Initialize the LLM with a list of server names and an instruction.
         If a name is provided, it will be used to identify the LLM.
         If an agent is provided, all other properties are optional
+
+        Args:
+            agent: Optional Agent that owns this LLM
+            server_names: List of MCP server names to connect to
+            instruction: System prompt for the LLM
+            name: Optional name identifier for the LLM
+            request_params: RequestParams to configure LLM behavior
+            type_converter: Provider-specific format converter class
+            context: Application context
+            model: Optional model name override
+            **kwargs: Additional provider-specific parameters
         """
         # Extract request_params before super() call
         self._init_request_params = request_params
@@ -95,7 +107,7 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
         # memory contains provider specific API types.
         self.history: Memory[MessageParamT] = SimpleMemory[MessageParamT]()
 
-        self.message_history: List[PromptMessageMultipart] = []
+        self._message_history: List[PromptMessageMultipart] = []
 
         # Initialize the display component
         self.display = ConsoleDisplay(config=self.context.config)
@@ -103,6 +115,10 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
         # Initialize default parameters
         self.default_request_params = self._initialize_default_params(kwargs)
 
+        # Apply model override if provided
+        if model:
+            self.default_request_params.model = model
+
         # Merge with provided params if any
         if self._init_request_params:
             self.default_request_params = self._merge_request_params(
@@ -127,17 +143,17 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
         prompt: List[PromptMessageMultipart],
         model: Type[ModelT],
         request_params: RequestParams | None = None,
-    ) -> ModelT | None:
+    ) -> Tuple[ModelT | None, PromptMessageMultipart]:
         """Apply the prompt and return the result as a Pydantic model, or None if coercion fails"""
         try:
             result: PromptMessageMultipart = await self.generate(prompt, request_params)
             json_data = from_json(result.first_text(), allow_partial=True)
             validated_model = model.model_validate(json_data)
-            return cast("ModelT", validated_model)
+            return cast("ModelT", validated_model), Prompt.assistant(json_data)
         except Exception as e:
             logger = get_logger(__name__)
             logger.error(f"Failed to parse structured response: {str(e)}")
-            return None
+            return None, Prompt.assistant(f"Failed to parse structured response: {str(e)}")
 
     async def generate(
         self,
@@ -158,7 +174,7 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
             )
             return Prompt.assistant(f"History saved to {filename}")
 
-        self.message_history.extend(multipart_messages)
+        self._message_history.extend(multipart_messages)
 
         if multipart_messages[-1].role == "user":
             self.show_user_message(
@@ -171,12 +187,12 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
             multipart_messages, request_params
         )
 
-        self.message_history.append(assistant_response)
+        self._message_history.append(assistant_response)
         return assistant_response
 
     def chat_turn(self) -> int:
         """Return the current chat turn number"""
-        return 1 + sum(1 for message in self.message_history if message.role == "assistant")
+        return 1 + sum(1 for message in self._message_history if message.role == "assistant")
 
     def _merge_request_params(
         self, default_params: RequestParams, provided_params: RequestParams
@@ -418,16 +434,15 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
 
     async def _save_history(self, filename: str) -> None:
         """
-        Save the Message History to a file in a simple delimeted format.
+        Save the Message History to a file in a format determined by the file extension.
+
+        Uses JSON format for .json files (MCP SDK compatible format) and
+        delimited text format for other extensions.
         """
-        # Convert to delimited format
-        delimited_content = multipart_messages_to_delimited_format(
-            self.message_history,
-        )
+        from mcp_agent.mcp.prompt_serialization import save_messages_to_file
 
-        # Write to file
-        with open(filename, "w", encoding="utf-8") as f:
-            f.write("\n\n".join(delimited_content))
+        # Save messages using the unified save function that auto-detects format
+        save_messages_to_file(self._message_history, filename)
 
     @abstractmethod
     async def _apply_prompt_provider_specific(
@@ -448,3 +463,16 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
             String representation of the assistant's response if generated,
             or the last assistant message in the prompt
         """
+
+    @property
+    def message_history(self) -> List[PromptMessageMultipart]:
+        """
+        Return the agent's message history as PromptMessageMultipart objects.
+
+        This history can be used to transfer state between agents or for
+        analysis and debugging purposes.
+
+        Returns:
+            List of PromptMessageMultipart objects representing the conversation history
+        """
+        return self._message_history

mcp_agent/llm/augmented_llm_passthrough.py

@@ -143,7 +143,9 @@ class PassthroughLLM(AugmentedLLM):
 
         # TODO -- improve when we support Audio/Multimodal gen
         if self.is_tool_call(last_message):
-            return Prompt.assistant(await self.generate_str(last_message.first_text()))
+            result = Prompt.assistant(await self.generate_str(last_message.first_text()))
+            await self.show_assistant_message(result.first_text())
+            return result
 
         if last_message.first_text().startswith(FIXED_RESPONSE_INDICATOR):
             self._fixed_response = (

mcp_agent/llm/model_factory.py

@@ -103,7 +103,7 @@ class ModelFactory:
         "sonnet": "claude-3-7-sonnet-latest",
         "sonnet35": "claude-3-5-sonnet-latest",
         "sonnet37": "claude-3-7-sonnet-latest",
-        "claude": "claude-3-5-sonnet-latest",
+        "claude": "claude-3-7-sonnet-latest",
         "haiku": "claude-3-5-haiku-latest",
         "haiku3": "claude-3-haiku-20240307",
         "haiku35": "claude-3-5-haiku-latest",
@@ -186,37 +186,25 @@ class ModelFactory:
         else:
             llm_class = cls.PROVIDER_CLASSES[config.provider]
 
-        # 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
-
-            # 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))
-                factory_params = RequestParams(**params_dict)
-                factory_params.model = (
-                    config.model_name
-                )  # Ensure parsed model name isn't overwritten
-
-            # Forward all keyword arguments to LLM constructor
-            llm_args = {
-                "agent": agent,
-                "model": config.model_name,
-                "request_params": factory_params,
-                "name": kwargs.get("name"),
-            }
+        # Create a factory function matching the updated attach_llm protocol
+        def factory(
+            agent: Agent, request_params: Optional[RequestParams] = None, **kwargs
+        ) -> AugmentedLLMProtocol:
+            # Create base params with parsed model name
+            base_params = RequestParams()
+            base_params.model = config.model_name  # Use the parsed model name, not the alias
 
             # Add reasoning effort if available
             if config.reasoning_effort:
-                llm_args["reasoning_effort"] = config.reasoning_effort.value
+                kwargs["reasoning_effort"] = config.reasoning_effort.value
 
-            # Forward all other kwargs (including verb)
-            for key, value in kwargs.items():
-                if key not in ["agent", "default_request_params", "name"]:
-                    llm_args[key] = value
+            # Forward all arguments to LLM constructor
+            llm_args = {
+                "agent": agent,
+                "model": config.model_name,
+                "request_params": request_params,
+                **kwargs,
+            }
 
             llm: AugmentedLLMProtocol = llm_class(**llm_args)
             return llm

mcp_agent/llm/providers/augmented_llm_openai.py

@@ -1,5 +1,5 @@
 import os
-from typing import List, Type
+from typing import List, Tuple, Type
 
 from mcp.types import (
     CallToolRequest,
@@ -377,7 +377,7 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
         prompt: List[PromptMessageMultipart],
         model: Type[ModelT],
         request_params: RequestParams | None = None,
-    ) -> ModelT | None:
+    ) -> Tuple[ModelT | None, PromptMessageMultipart]:
         """
         Apply the prompt and return the result as a Pydantic model.
 
@@ -432,7 +432,7 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
 
                 parsed_result = response[0].choices[0].message
                 logger.debug("Successfully used OpenAI beta parse feature for structured output")
-                return parsed_result.parsed
+                return parsed_result.parsed, Prompt.assistant(parsed_result.content)
 
             except (ImportError, AttributeError, NotImplementedError) as e:
                 # Beta feature not available, log and continue to fallback

mcp_agent/llm/providers/multipart_converter_anthropic.py

@@ -24,13 +24,7 @@ from mcp.types import (
 )
 
 from mcp_agent.logging.logger import get_logger
-from mcp_agent.mcp.mime_utils import (
-    guess_mime_type,
-    is_image_mime_type,
-    is_text_mime_type,
-)
-from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
-from mcp_agent.mcp.prompts.prompt_helpers import (
+from mcp_agent.mcp.helpers.content_helpers import (
     get_image_data,
     get_resource_uri,
     get_text,
@@ -38,6 +32,12 @@ from mcp_agent.mcp.prompts.prompt_helpers import (
     is_resource_content,
     is_text_content,
 )
+from mcp_agent.mcp.mime_utils import (
+    guess_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
 
 _logger = get_logger("multipart_converter_anthropic")
@@ -450,4 +450,4 @@ class AnthropicConverter:
             # Add separate blocks directly to the message
             content_blocks.extend(separate_blocks)
 
-        return MessageParam(role="user", content=content_blocks)
+        return MessageParam(role="user", content=content_blocks)

mcp_agent/llm/providers/multipart_converter_openai.py

@@ -9,14 +9,7 @@ from mcp.types import (
 )
 
 from mcp_agent.logging.logger import get_logger
-from mcp_agent.mcp.mime_utils import (
-    guess_mime_type,
-    is_image_mime_type,
-    is_text_mime_type,
-)
-from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
-from mcp_agent.mcp.prompts.prompt_helpers import (
-    MessageContent,
+from mcp_agent.mcp.helpers.content_helpers import (
     get_image_data,
     get_resource_uri,
     get_text,
@@ -24,6 +17,13 @@ from mcp_agent.mcp.prompts.prompt_helpers import (
     is_resource_content,
     is_text_content,
 )
+from mcp_agent.mcp.mime_utils import (
+    guess_mime_type,
+    is_image_mime_type,
+    is_text_mime_type,
+)
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+from mcp_agent.mcp.prompts.prompt_helpers import MessageContent
 from mcp_agent.mcp.resource_utils import extract_title_from_uri
 
 _logger = get_logger("multipart_converter_openai")
@@ -462,4 +462,4 @@ class OpenAIConverter:
                 # Single message case (text-only)
                 messages.append(converted)
 
-        return messages
+        return messages

mcp_agent/mcp/helpers/__init__.py

@@ -0,0 +1,3 @@
+"""
+Helper modules for working with MCP content.
+"""

mcp_agent/mcp/helpers/content_helpers.py

@@ -0,0 +1,116 @@
+"""
+Helper functions for working with content objects.
+
+These utilities simplify extracting content from content structures
+without repetitive type checking.
+"""
+
+from typing import Optional, Union
+
+from mcp.types import (
+    BlobResourceContents,
+    EmbeddedResource,
+    ImageContent,
+    TextContent,
+    TextResourceContents,
+)
+
+
+def get_text(content: Union[TextContent, ImageContent, EmbeddedResource]) -> Optional[str]:
+    """
+    Extract text content from a content object if available.
+
+    Args:
+        content: A content object (TextContent, ImageContent, or EmbeddedResource)
+
+    Returns:
+        The text content as a string or None if not a text content
+    """
+    if isinstance(content, TextContent):
+        return content.text
+
+    if isinstance(content, TextResourceContents):
+        return content.text
+
+    if isinstance(content, EmbeddedResource):
+        if isinstance(content.resource, TextResourceContents):
+            return content.resource.text
+
+    return None
+
+
+def get_image_data(content: Union[TextContent, ImageContent, EmbeddedResource]) -> Optional[str]:
+    """
+    Extract image data from a content object if available.
+
+    Args:
+        content: A content object (TextContent, ImageContent, or EmbeddedResource)
+
+    Returns:
+        The image data as a base64 string or None if not an image content
+    """
+    if isinstance(content, ImageContent):
+        return content.data
+
+    if isinstance(content, EmbeddedResource):
+        if isinstance(content.resource, BlobResourceContents):
+            # This assumes the blob might be an image, which isn't always true
+            # Consider checking the mimeType if needed
+            return content.resource.blob
+
+    return None
+
+
+def get_resource_uri(content: Union[TextContent, ImageContent, EmbeddedResource]) -> Optional[str]:
+    """
+    Extract resource URI from an EmbeddedResource if available.
+
+    Args:
+        content: A content object (TextContent, ImageContent, or EmbeddedResource)
+
+    Returns:
+        The resource URI as a string or None if not an embedded resource
+    """
+    if isinstance(content, EmbeddedResource):
+        return str(content.resource.uri)
+
+    return None
+
+
+def is_text_content(content: Union[TextContent, ImageContent, EmbeddedResource]) -> bool:
+    """
+    Check if the content is text content.
+
+    Args:
+        content: A content object (TextContent, ImageContent, or EmbeddedResource)
+
+    Returns:
+        True if the content is TextContent, False otherwise
+    """
+    return isinstance(content, TextContent) or isinstance(content, TextResourceContents)
+
+
+def is_image_content(content: Union[TextContent, ImageContent, EmbeddedResource]) -> bool:
+    """
+    Check if the content is image content.
+
+    Args:
+        content: A content object (TextContent, ImageContent, or EmbeddedResource)
+
+    Returns:
+        True if the content is ImageContent, False otherwise
+    """
+    return isinstance(content, ImageContent)
+
+
+def is_resource_content(content: Union[TextContent, ImageContent, EmbeddedResource]) -> bool:
+    """
+    Check if the content is an embedded resource.
+
+    Args:
+        content: A content object (TextContent, ImageContent, or EmbeddedResource)
+
+    Returns:
+        True if the content is EmbeddedResource, False otherwise
+    """
+    return isinstance(content, EmbeddedResource)

mcp_agent/mcp/interfaces.py

@@ -10,6 +10,7 @@ from typing import (
     Callable,
     Dict,
     List,
+    Mapping,
     Optional,
     Protocol,
     Tuple,
@@ -21,10 +22,10 @@ from typing import (
 
 from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
 from deprecated import deprecated
-from mcp import ClientSession, GetPromptResult, ReadResourceResult
+from mcp import ClientSession
+from mcp.types import GetPromptResult, Prompt, PromptMessage, ReadResourceResult
 from pydantic import BaseModel
 
-from mcp_agent.core.prompt import Prompt
 from mcp_agent.core.request_params import RequestParams
 from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 
@@ -119,44 +120,66 @@ class AugmentedLLMProtocol(Protocol):
         """
         ...
 
+    @property
+    def message_history(self) -> List[PromptMessageMultipart]:
+        """
+        Return the LLM's message history as PromptMessageMultipart objects.
+
+        Returns:
+            List of PromptMessageMultipart objects representing the conversation history
+        """
+        ...
+
 
 class AgentProtocol(AugmentedLLMProtocol, Protocol):
     """Protocol defining the standard agent interface"""
 
     name: str
 
-    async def __call__(self, message: Union[str, PromptMessageMultipart] | None = None) -> str:
+    async def __call__(self, message: Union[str, PromptMessage, PromptMessageMultipart]) -> str:
         """Make the agent callable for sending messages directly."""
         ...
 
-    async def send(self, message: Union[str, PromptMessageMultipart]) -> str:
+    async def send(self, message: Union[str, PromptMessage, PromptMessageMultipart]) -> str:
         """Send a message to the agent and get a response"""
         ...
 
-    async def prompt(self, default_prompt: str = "") -> str:
-        """Start an interactive prompt session with the agent"""
-        ...
-
     async def apply_prompt(self, prompt_name: str, arguments: Dict[str, str] | None = None) -> str:
         """Apply an MCP prompt template by name"""
         ...
 
-    async def get_prompt(self, prompt_name: str) -> GetPromptResult: ...
+    async def get_prompt(
+        self,
+        prompt_name: str,
+        arguments: Dict[str, str] | None = None,
+        server_name: str | None = None,
+    ) -> GetPromptResult: ...
 
-    async def list_prompts(self, server_name: str | None) -> Dict[str, List[Prompt]]: ...
+    async def list_prompts(self, server_name: str | None = None) -> Mapping[str, List[Prompt]]: ...
 
-    async def get_resource(self, server_name: str, resource_uri: str) -> ReadResourceResult: ...
+    async def list_resources(self, server_name: str | None = None) -> Mapping[str, List[str]]: ...
+
+    async def get_resource(
+        self, resource_uri: str, server_name: str | None = None
+    ) -> ReadResourceResult:
+        """Get a resource from a specific server or search all servers"""
+        ...
 
     @deprecated
-    async def generate_str(self, message: str, request_params: RequestParams | None) -> str:
-        """Generate a response. Deprecated: please use send instead"""
+    async def generate_str(self, message: str, request_params: RequestParams | None = None) -> str:
+        """Generate a response. Deprecated: Use send(), generate() or structured()  instead"""
+        ...
+
+    @deprecated
+    async def prompt(self, default_prompt: str = "") -> str:
+        """Start an interactive prompt session with the agent. Deprecated. Use agent_app.interactive() instead."""
         ...
 
     async def with_resource(
         self,
-        prompt_content: Union[str, PromptMessageMultipart],
-        server_name: str,
-        resource_name: str,
+        prompt_content: Union[str, PromptMessage, PromptMessageMultipart],
+        resource_uri: str,
+        server_name: str | None = None,
     ) -> str:
         """Send a message with an attached MCP resource"""
         ...