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

mcp_agent/{workflows/llm → llm}/augmented_llm_passthrough.py

@@ -1,19 +1,19 @@
 import json  # Import at the module level
-from typing import Any, List, Optional, Type, Union
+from typing import Any, List, Optional, Union
 
-from mcp import GetPromptResult
 from mcp.types import PromptMessage
-from pydantic_core import from_json
 
-from mcp_agent.logging.logger import get_logger
-from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
-from mcp_agent.workflows.llm.augmented_llm import (
+from mcp_agent.core.prompt import Prompt
+from mcp_agent.llm.augmented_llm import (
     AugmentedLLM,
     MessageParamT,
-    MessageT,
-    ModelT,
     RequestParams,
 )
+from mcp_agent.logging.logger import get_logger
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+
+CALL_TOOL_INDICATOR = "***CALL_TOOL"
+FIXED_RESPONSE_INDICATOR = "***FIXED_RESPONSE"
 
 
 class PassthroughLLM(AugmentedLLM):
@@ -25,21 +25,12 @@ class PassthroughLLM(AugmentedLLM):
     parallel workflow where no fan-in aggregation is needed.
     """
 
-    def __init__(self, name: str = "Passthrough", context=None, **kwargs) -> None:
-        super().__init__(name=name, context=context, **kwargs)
+    def __init__(self, name: str = "Passthrough", **kwargs: dict[str, Any]) -> None:
+        super().__init__(name=name, **kwargs)
         self.provider = "fast-agent"
-        # Initialize logger - keep it simple without name reference
         self.logger = get_logger(__name__)
         self._messages = [PromptMessage]
-
-    async def generate(
-        self,
-        message: Union[str, MessageParamT, List[MessageParamT]],
-        request_params: Optional[RequestParams] = None,
-    ) -> Union[List[MessageT], Any]:
-        """Simply return the input message as is."""
-        # Return in the format expected by the caller
-        return [message] if isinstance(message, list) else message
+        self._fixed_response: str | None = None
 
     async def generate_str(
         self,
@@ -143,92 +134,29 @@ class PassthroughLLM(AugmentedLLM):
 
         return "\n".join(result_text)
 
-    async def generate_structured(
-        self,
-        message: Union[str, MessageParamT, List[MessageParamT]],
-        response_model: Type[ModelT],
-        request_params: Optional[RequestParams] = None,
-    ) -> ModelT:
-        """
-        Return the input message as the requested model type.
-        This is a best-effort implementation - it may fail if the
-        message cannot be converted to the requested model.
-        """
-        if isinstance(message, response_model):
-            return message
-        elif isinstance(message, dict):
-            return response_model(**message)
-        elif isinstance(message, str):
-            return response_model.model_validate(from_json(message, allow_partial=True))
-
-    async def generate_prompt(self, prompt: "PromptMessageMultipart", request_params: RequestParams | None) -> str:
-        # Check if this prompt contains a tool call command
-        if prompt.content and prompt.content[0].text and prompt.content[0].text.startswith("***CALL_TOOL "):
-            return await self._call_tool_and_return_result(prompt.content[0].text)
-
-        # Process all parts of the PromptMessageMultipart
-        parts_text = []
-        for part in prompt.content:
-            parts_text.append(str(part))
-
-        # If no parts found, return empty string
-        if not parts_text:
-            return ""
-
-        # Join all parts and process with generate_str
-        return await self.generate_str("\n".join(parts_text), request_params)
-
-    async def apply_prompt(
+    async def _apply_prompt_provider_specific(
         self,
         multipart_messages: List["PromptMessageMultipart"],
-        request_params: Optional[RequestParams] = None,
-    ) -> str:
-        """
-        Apply a list of PromptMessageMultipart messages directly to the LLM.
-        In PassthroughLLM, this returns a concatenated string of all message content.
-
-        Args:
-            multipart_messages: List of PromptMessageMultipart objects
-            request_params: Optional parameters to configure the LLM request
-
-        Returns:
-            String representation of all message content concatenated together
-        """
-        # Generate and concatenate result from all messages
-        result = ""
-        for prompt in multipart_messages:
-            result += await self.generate_prompt(prompt, request_params) + "\n"
-
-        return result
-
-    async def apply_prompt_template(self, prompt_result: GetPromptResult, prompt_name: str) -> str:
-        """
-        Apply a prompt template by adding it to the conversation history.
-        For PassthroughLLM, this returns all content concatenated together.
-
-        Args:
-            prompt_result: The GetPromptResult containing prompt messages
-            prompt_name: The name of the prompt being applied
-
-        Returns:
-            String representation of all message content concatenated together
-        """
-        prompt_messages: List[PromptMessage] = prompt_result.messages
-
-        # Extract arguments if they were stored in the result
-        arguments = getattr(prompt_result, "arguments", None)
-
-        # Display information about the loaded prompt
-        await self.show_prompt_loaded(
-            prompt_name=prompt_name,
-            description=prompt_result.description,
-            message_count=len(prompt_messages),
-            arguments=arguments,
-        )
-        self._messages = prompt_messages
-
-        # Convert prompt messages to multipart format
-        multipart_messages = PromptMessageMultipart.to_multipart(prompt_messages)
-
-        # Use apply_prompt to handle the multipart messages
-        return await self.apply_prompt(multipart_messages)
+        request_params: RequestParams | None = None,
+    ) -> PromptMessageMultipart:
+        last_message = multipart_messages[-1]
+
+        # 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()))
+
+        if last_message.first_text().startswith(FIXED_RESPONSE_INDICATOR):
+            self._fixed_response = (
+                last_message.first_text().split(FIXED_RESPONSE_INDICATOR, 1)[1].strip()
+            )
+
+        if self._fixed_response:
+            await self.show_assistant_message(self._fixed_response)
+            return Prompt.assistant(self._fixed_response)
+        else:
+            concatenated: str = "\n".join(message.all_text() for message in multipart_messages)
+            await self.show_assistant_message(concatenated)
+            return Prompt.assistant(concatenated)
+
+    def is_tool_call(self, message: PromptMessageMultipart) -> bool:
+        return message.first_text().startswith(CALL_TOOL_INDICATOR)

mcp_agent/llm/augmented_llm_playback.py

@@ -0,0 +1,83 @@
+from typing import Any, List
+
+from mcp_agent.core.prompt import Prompt
+from mcp_agent.llm.augmented_llm import RequestParams
+from mcp_agent.llm.augmented_llm_passthrough import PassthroughLLM
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+from mcp_agent.mcp.prompts.prompt_helpers import MessageContent
+
+
+class PlaybackLLM(PassthroughLLM):
+    """
+    A specialized LLM implementation that plays back assistant messages when loaded with prompts.
+
+    Unlike the PassthroughLLM which simply passes through messages without modification,
+    PlaybackLLM is designed to simulate a conversation by playing back prompt messages
+    in sequence when loaded with prompts through apply_prompt_template.
+
+    After apply_prompts has been called, each call to generate_str returns the next
+    "ASSISTANT" message in the loaded messages. If no messages are set or all messages have
+    been played back, it returns a message indicating that messages are exhausted.
+    """
+
+    def __init__(self, name: str = "Playback", **kwargs: dict[str, Any]) -> None:
+        super().__init__(name=name, **kwargs)
+        self._messages: List[PromptMessageMultipart] = []
+        self._current_index = -1
+        self._overage = -1
+
+    def _get_next_assistant_message(self) -> PromptMessageMultipart:
+        """
+        Get the next assistant message from the loaded messages.
+        Increments the current message index and skips user messages.
+        """
+        # Find next assistant message
+        while self._current_index < len(self._messages):
+            message = self._messages[self._current_index]
+            self._current_index += 1
+            if "assistant" != message.role:
+                continue
+
+            return message
+
+        self._overage += 1
+        return Prompt.assistant(
+            f"MESSAGES EXHAUSTED (list size {len(self._messages)}) ({self._overage} overage)"
+        )
+
+    async def generate(
+        self,
+        multipart_messages: List[PromptMessageMultipart],
+        request_params: RequestParams | None = None,
+    ) -> PromptMessageMultipart:
+        """
+        Handle playback of messages in two modes:
+        1. First call: store messages for playback and return "HISTORY LOADED"
+        2. Subsequent calls: return the next assistant message
+        """
+        # If this is the first call (initialization) or we're loading a prompt template
+        # with multiple messages (comes from apply_prompt)
+        if -1 == self._current_index:
+            if len(multipart_messages) > 1:
+                self._messages = multipart_messages
+            else:
+                self._messages.extend(multipart_messages)
+
+            # Reset the index to the beginning for proper playback
+            self._current_index = 0
+
+            await self.show_assistant_message(
+                message_text=f"HISTORY LOADED ({len(self._messages)} messages)",
+                title="ASSISTANT/PLAYBACK",
+            )
+
+            # In PlaybackLLM, we always return "HISTORY LOADED" on initialization,
+            # regardless of the prompt content. The next call will return messages.
+            return Prompt.assistant("HISTORY LOADED")
+
+        response = self._get_next_assistant_message()
+        await self.show_assistant_message(
+            message_text=MessageContent.get_first_text(response), title="ASSISTANT/PLAYBACK"
+        )
+
+        return response

mcp_agent/{workflows/llm → llm}/model_factory.py

@@ -5,11 +5,15 @@ 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.llm.augmented_llm_passthrough import PassthroughLLM
+from mcp_agent.llm.augmented_llm_playback import PlaybackLLM
+from mcp_agent.llm.providers.augmented_llm_anthropic import AnthropicAugmentedLLM
+from mcp_agent.llm.providers.augmented_llm_deepseek import DeepSeekAugmentedLLM
+from mcp_agent.llm.providers.augmented_llm_openai import OpenAIAugmentedLLM
 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
+
+# from mcp_agent.workflows.llm.augmented_llm_deepseek import DeekSeekAugmentedLLM
+
 
 # Type alias for LLM classes
 LLMClass = Union[
@@ -17,6 +21,7 @@ LLMClass = Union[
     Type[OpenAIAugmentedLLM],
     Type[PassthroughLLM],
     Type[PlaybackLLM],
+    Type[DeepSeekAugmentedLLM],
 ]
 
 
@@ -26,6 +31,7 @@ class Provider(Enum):
     ANTHROPIC = auto()
     OPENAI = auto()
     FAST_AGENT = auto()
+    DEEPSEEK = auto()
 
 
 class ReasoningEffort(Enum):
@@ -53,6 +59,7 @@ class ModelFactory:
         "anthropic": Provider.ANTHROPIC,
         "openai": Provider.OPENAI,
         "fast-agent": Provider.FAST_AGENT,
+        "deepseek": Provider.DEEPSEEK,
     }
 
     # Mapping of effort strings to enum values
@@ -85,6 +92,8 @@ class ModelFactory:
         "claude-3-7-sonnet-latest": Provider.ANTHROPIC,
         "claude-3-opus-20240229": Provider.ANTHROPIC,
         "claude-3-opus-latest": Provider.ANTHROPIC,
+        "deepseek-chat": Provider.DEEPSEEK,
+        #        "deepseek-reasoner": Provider.DEEPSEEK, reinstate on release
     }
 
     MODEL_ALIASES = {
@@ -97,6 +106,8 @@ class ModelFactory:
         "haiku35": "claude-3-5-haiku-latest",
         "opus": "claude-3-opus-latest",
         "opus3": "claude-3-opus-latest",
+        "deepseekv3": "deepseek-chat",
+        "deepseek": "deepseek-chat",
     }
 
     # Mapping of providers to their LLM classes
@@ -104,6 +115,7 @@ class ModelFactory:
         Provider.ANTHROPIC: AnthropicAugmentedLLM,
         Provider.OPENAI: OpenAIAugmentedLLM,
         Provider.FAST_AGENT: PassthroughLLM,
+        Provider.DEEPSEEK: DeepSeekAugmentedLLM,
     }
 
     # Mapping of special model names to their specific LLM classes
@@ -145,10 +157,14 @@ 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[..., AugmentedLLMProtocol]:
+    def create_factory(
+        cls, model_string: str, request_params: Optional[RequestParams] = None
+    ) -> Callable[..., AugmentedLLMProtocol]:
         """
         Creates a factory function that follows the attach_llm protocol.
 
@@ -177,7 +193,9 @@ class ModelFactory:
                 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
+                factory_params.model = (
+                    config.model_name
+                )  # Ensure parsed model name isn't overwritten
 
             # Forward all keyword arguments to LLM constructor
             llm_args = {
@@ -196,7 +214,7 @@ class ModelFactory:
                 if key not in ["agent", "default_request_params", "name"]:
                     llm_args[key] = value
 
-            llm = llm_class(**llm_args)
+            llm: AugmentedLLMProtocol = llm_class(**llm_args)
             return llm
 
         return factory

mcp_agent/llm/providers/__init__.py

@@ -0,0 +1,8 @@
+from mcp_agent.llm.providers.sampling_converter_anthropic import (
+    AnthropicSamplingConverter,
+)
+from mcp_agent.llm.providers.sampling_converter_openai import (
+    OpenAISamplingConverter,
+)
+
+__all__ = ["AnthropicSamplingConverter", "OpenAISamplingConverter"]

mcp_agent/{workflows/llm → llm/providers}/anthropic_utils.py

@@ -47,7 +47,11 @@ def anthropic_message_param_to_prompt_message_multipart(
                 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:
+                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()

mcp_agent/{workflows/llm → llm/providers}/augmented_llm_anthropic.py

@@ -1,18 +1,18 @@
 import os
 from typing import TYPE_CHECKING, List, Type
 
-from mcp_agent.workflows.llm.providers.multipart_converter_anthropic import (
+from mcp_agent.core.prompt import Prompt
+from mcp_agent.llm.providers.multipart_converter_anthropic import (
     AnthropicConverter,
 )
-from mcp_agent.workflows.llm.providers.sampling_converter_anthropic import (
+from mcp_agent.llm.providers.sampling_converter_anthropic import (
     AnthropicSamplingConverter,
 )
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 
 if TYPE_CHECKING:
     from mcp import ListToolsResult
 
-    from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
-
 
 from anthropic import Anthropic, AuthenticationError
 from anthropic.types import (
@@ -32,12 +32,12 @@ from pydantic_core import from_json
 from rich.text import Text
 
 from mcp_agent.core.exceptions import ProviderKeyError
-from mcp_agent.logging.logger import get_logger
-from mcp_agent.workflows.llm.augmented_llm import (
+from mcp_agent.llm.augmented_llm import (
     AugmentedLLM,
     ModelT,
     RequestParams,
 )
+from mcp_agent.logging.logger import get_logger
 
 DEFAULT_ANTHROPIC_MODEL = "claude-3-7-sonnet-latest"
 
@@ -69,9 +69,12 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
             use_history=True,
         )
 
-    async def generate(
+    def _base_url(self) -> str:
+        return self.context.config.anthropic.base_url if self.context.config.anthropic else None
+
+    async def generate_internal(
         self,
-        message,
+        message_param,
         request_params: RequestParams | None = None,
     ):
         """
@@ -80,8 +83,12 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
         """
 
         api_key = self._api_key(self.context.config)
+        base_url = self._base_url()
+        if base_url and base_url.endswith("/v1"):
+            base_url = base_url.rstrip("/v1")
+
         try:
-            anthropic = Anthropic(api_key=api_key)
+            anthropic = Anthropic(api_key=api_key, base_url=base_url)
             messages: List[MessageParam] = []
             params = self.get_request_params(request_params)
         except AuthenticationError as e:
@@ -94,12 +101,7 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
         # if use_history is True
         messages.extend(self.history.get(include_history=params.use_history))
 
-        if isinstance(message, str):
-            messages.append({"role": "user", "content": message})
-        elif isinstance(message, list):
-            messages.extend(message)
-        else:
-            messages.append(message)
+        messages.append(message_param)
 
         tool_list: ListToolsResult = await self.aggregator.list_tools()
         available_tools: List[ToolParam] = [
@@ -112,13 +114,11 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
         ]
 
         responses: List[Message] = []
-        model = await self.select_model(params)
-        chat_turn = (len(messages) + 1) // 2
-        self.show_user_message(str(message), model, chat_turn)
+
+        model = self.default_request_params.model
 
         for i in range(params.max_iterations):
-            chat_turn = (len(messages) + 1) // 2
-            self._log_chat_progress(chat_turn, model=model)
+            self._log_chat_progress(self.chat_turn(), model=model)
             arguments = {
                 "model": model,
                 "messages": messages,
@@ -191,7 +191,9 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
                 break
             elif response.stop_reason == "stop_sequence":
                 # We have reached a stop sequence
-                self.logger.debug(f"Iteration {i}: Stopping because finish_reason is 'stop_sequence'")
+                self.logger.debug(
+                    f"Iteration {i}: Stopping because finish_reason is 'stop_sequence'"
+                )
                 break
             elif response.stop_reason == "max_tokens":
                 # We have reached the max tokens limit
@@ -246,7 +248,9 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
                             params=CallToolRequestParams(name=tool_name, arguments=tool_args),
                         )
                         # TODO -- support MCP isError etc.
-                        result = await self.call_tool(request=tool_call_request, tool_call_id=tool_use_id)
+                        result = await self.call_tool(
+                            request=tool_call_request, tool_call_id=tool_use_id
+                        )
                         self.show_tool_result(result)
 
                         # Add each result to our collection
@@ -293,7 +297,7 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
 
     async def generate_str(
         self,
-        message,
+        message_param,
         request_params: RequestParams | None = None,
     ) -> str:
         """
@@ -301,16 +305,10 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
         The default implementation uses Claude as the LLM.
         Override this method to use a different LLM.
 
-        Special commands:
-        - "***SAVE_HISTORY <filename.md>" - Saves the conversation history to the specified file
-          in MCP prompt format with user/assistant delimiters.
         """
-        # Check if this is a special command to save history
-        if isinstance(message, str) and message.startswith("***SAVE_HISTORY "):
-            return await self._save_history_to_file(message)
 
-        responses: List[Message] = await self.generate(
-            message=message,
+        responses: List[Message] = await self.generate_internal(
+            message_param=message_param,
             request_params=request_params,
         )
 
@@ -333,96 +331,32 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
         # Join all collected text
         return "\n".join(final_text)
 
-    async def generate_prompt(self, prompt: "PromptMessageMultipart", request_params: RequestParams | None) -> str:
-        return await self.generate_str(AnthropicConverter.convert_to_anthropic(prompt), request_params)
-
-    async def _apply_prompt_template_provider_specific(
+    async def _apply_prompt_provider_specific(
         self,
         multipart_messages: List["PromptMessageMultipart"],
         request_params: RequestParams | None = None,
-    ) -> str:
-        """
-        Anthropic-specific implementation of apply_prompt_template that handles
-        multimodal content natively.
-
-        Args:
-            multipart_messages: List of PromptMessageMultipart objects parsed from the prompt template
-
-        Returns:
-            String representation of the assistant's response if generated,
-            or the last assistant message in the prompt
-        """
+    ) -> PromptMessageMultipart:
         # Check the last message role
         last_message = multipart_messages[-1]
 
         # Add all previous messages to history (or all messages if last is from assistant)
-        messages_to_add = multipart_messages[:-1] if last_message.role == "user" else multipart_messages
+        messages_to_add = (
+            multipart_messages[:-1] if last_message.role == "user" else multipart_messages
+        )
         converted = []
         for msg in messages_to_add:
             converted.append(AnthropicConverter.convert_to_anthropic(msg))
+
         self.history.extend(converted, is_prompt=True)
 
         if last_message.role == "user":
-            # For user messages: Generate response to the last one
             self.logger.debug("Last message in prompt is from user, generating assistant response")
             message_param = AnthropicConverter.convert_to_anthropic(last_message)
-            return await self.generate_str(message_param, request_params)
+            return Prompt.assistant(await self.generate_str(message_param, request_params))
         else:
             # For assistant messages: Return the last message content as text
             self.logger.debug("Last message in prompt is from assistant, returning it directly")
-            return str(last_message)
-
-    async def _save_history_to_file(self, command: str) -> str:
-        """
-        Save the conversation history to a file in MCP prompt format.
-
-        Args:
-            command: The command string, expected format: "***SAVE_HISTORY <filename.md>"
-
-        Returns:
-            Success or error message
-        """
-        try:
-            # Extract the filename from the command
-            parts = command.split(" ", 1)
-            if len(parts) != 2 or not parts[1].strip():
-                return "Error: Invalid format. Expected '***SAVE_HISTORY <filename.md>'"
-
-            filename = parts[1].strip()
-
-            # Get all messages from history
-            messages = self.history.get(include_history=True)
-
-            # Import required utilities
-            from mcp_agent.mcp.prompt_serialization import (
-                multipart_messages_to_delimited_format,
-            )
-            from mcp_agent.workflows.llm.anthropic_utils import (
-                anthropic_message_param_to_prompt_message_multipart,
-            )
-
-            # Convert message params to PromptMessageMultipart objects
-            multipart_messages = []
-            for msg in messages:
-                multipart_messages.append(anthropic_message_param_to_prompt_message_multipart(msg))
-
-            # Convert to delimited format
-            delimited_content = multipart_messages_to_delimited_format(
-                multipart_messages,
-                user_delimiter="---USER",
-                assistant_delimiter="---ASSISTANT",
-            )
-
-            # Write to file
-            with open(filename, "w", encoding="utf-8") as f:
-                f.write("\n\n".join(delimited_content))
-
-            self.logger.info(f"Saved conversation history to {filename}")
-            return f"Done. Saved conversation history to {filename}"
-
-        except Exception as e:
-            self.logger.error(f"Error saving history: {str(e)}")
-            return f"Error saving history: {str(e)}"
+            return last_message
 
     async def generate_structured(
         self,
@@ -461,41 +395,3 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
                 )
 
         return MessageParam(role="assistant", content=content, **kwargs)
-
-    def message_param_str(self, message: MessageParam) -> str:
-        """Convert an input message to a string representation."""
-
-        if message.get("content"):
-            content = message["content"]
-            if isinstance(content, str):
-                return content
-            else:
-                final_text: List[str] = []
-                for block in content:
-                    if block.text:
-                        final_text.append(str(block.text))
-                    else:
-                        final_text.append(str(block))
-
-                return "\n".join(final_text)
-
-        return str(message)
-
-    def message_str(self, message: Message) -> str:
-        """Convert an output message to a string representation."""
-        content = message.content
-
-        if content:
-            if isinstance(content, list):
-                final_text: List[str] = []
-                for block in content:
-                    if block.text:
-                        final_text.append(str(block.text))
-                    else:
-                        final_text.append(str(block))
-
-                return "\n".join(final_text)
-            else:
-                return str(content)
-
-        return str(message)