fast-agent-mcp 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

mcp_agent/workflows/llm/augmented_llm_anthropic.py

@@ -1,48 +1,42 @@
-import json
 import os
-from typing import Iterable, List, Type
+from typing import List, Type, TYPE_CHECKING
+
+from mcp_agent.workflows.llm.providers.multipart_converter_anthropic import (
+    AnthropicConverter,
+)
+from mcp_agent.workflows.llm.providers.sampling_converter_anthropic import (
+    AnthropicSamplingConverter,
+)
+
+if TYPE_CHECKING:
+    from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 
-from pydantic import BaseModel
 
-import instructor
 from anthropic import Anthropic, AuthenticationError
 from anthropic.types import (
-    ContentBlock,
-    DocumentBlockParam,
     Message,
     MessageParam,
-    ImageBlockParam,
     TextBlock,
     TextBlockParam,
     ToolParam,
-    ToolResultBlockParam,
     ToolUseBlockParam,
 )
 from mcp.types import (
     CallToolRequestParams,
     CallToolRequest,
-    EmbeddedResource,
-    ImageContent,
-    StopReason,
-    TextContent,
-    TextResourceContents,
 )
+from pydantic_core import from_json
 
-from mcp_agent.workflows.router.router_llm import StructuredResponse
 from mcp_agent.workflows.llm.augmented_llm import (
     AugmentedLLM,
     ModelT,
-    MCPMessageParam,
-    MCPMessageResult,
-    ProviderToMCPConverter,
     RequestParams,
 )
 from mcp_agent.core.exceptions import ProviderKeyError
-from mcp_agent.logging.logger import get_logger
-from mcp.types import PromptMessage
 from rich.text import Text
 
-_logger = get_logger(__name__)
+from mcp_agent.logging.logger import get_logger
+
 DEFAULT_ANTHROPIC_MODEL = "claude-3-7-sonnet-latest"
 
 
@@ -60,7 +54,7 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
         self.logger = get_logger(__name__)
 
         # Now call super().__init__
-        super().__init__(*args, type_converter=AnthropicMCPTypeConverter, **kwargs)
+        super().__init__(*args, type_converter=AnthropicSamplingConverter, **kwargs)
 
     def _initialize_default_params(self, kwargs: dict) -> RequestParams:
         """Initialize Anthropic-specific default parameters"""
@@ -96,7 +90,7 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
                 "Please check that your API key is valid and not expired.",
             ) from e
 
-        # Always include prompt messages, but only include conversation history 
+        # Always include prompt messages, but only include conversation history
         # if use_history is True
         messages.extend(self.history.get(include_history=params.use_history))
 
@@ -273,21 +267,10 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
                         self.show_tool_result(result)
 
                         # Add each result to our collection
-                        tool_results.append(
-                            ToolResultBlockParam(
-                                type="tool_result",
-                                tool_use_id=tool_use_id,
-                                content=result.content,
-                                is_error=result.isError,
-                            )
-                        )
+                        tool_results.append((tool_use_id, result))
 
-                    # Add all tool results in a single message
                     messages.append(
-                        MessageParam(
-                            role="user",
-                            content=tool_results,
-                        )
+                        AnthropicConverter.create_tool_results_message(tool_results)
                     )
 
         # Only save the new conversation messages to history if use_history is true
@@ -295,10 +278,10 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
         if params.use_history:
             # Get current prompt messages
             prompt_messages = self.history.get(include_history=False)
-            
+
             # Calculate new conversation messages (excluding prompts)
-            new_messages = messages[len(prompt_messages):]
-            
+            new_messages = messages[len(prompt_messages) :]
+
             # Update conversation history
             self.history.set(new_messages)
 
@@ -336,7 +319,15 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
         Process a query using an LLM and available tools.
         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,
             request_params=request_params,
@@ -361,16 +352,116 @@ 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(
+        self, multipart_messages: List["PromptMessageMultipart"]
+    ) -> 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
+        """
+        # 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
+        )
+        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)
+        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.workflows.llm.anthropic_utils import (
+                anthropic_message_param_to_prompt_message_multipart,
+            )
+            from mcp_agent.mcp.prompt_serialization import (
+                multipart_messages_to_delimited_format,
+            )
+
+            # 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)}"
+
     async def generate_structured(
         self,
         message,
         response_model: Type[ModelT],
         request_params: RequestParams | None = None,
     ) -> ModelT:
-        # First we invoke the LLM to generate a string response
-        # We need to do this in a two-step process because Instructor doesn't
-        # know how to invoke MCP tools via call_tool, so we'll handle all the
-        # processing first and then pass the final response through Instructor
+        # TODO -- simiar to the OAI version, we should create a tool call for the expected schema
         response = await self.generate_str(
             message=message,
             request_params=request_params,
@@ -378,27 +469,9 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
         # Don't try to parse if we got no response
         if not response:
             self.logger.error("No response from generate_str")
-            return StructuredResponse(categories=[])
-
-        # Next we pass the text through instructor to extract structured data
-        client = instructor.from_anthropic(
-            Anthropic(api_key=self._api_key(self.context.config)),
-        )
+            return None
 
-        params = self.get_request_params(request_params)
-        model = await self.select_model(params)
-
-        # Extract structured data from natural language
-        structured_response = client.chat.completions.create(
-            model=model,
-            response_model=response_model,
-            messages=[{"role": "user", "content": response}],
-            max_tokens=params.maxTokens,
-        )
-        await self.show_assistant_message(
-            str(structured_response), title="ASSISTANT/STRUCTURED"
-        )
-        return structured_response
+        return response_model.model_validate(from_json(response, allow_partial=True))
 
     @classmethod
     def convert_message_to_message_param(
@@ -459,222 +532,3 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
                 return str(content)
 
         return str(message)
-
-
-class AnthropicMCPTypeConverter(ProviderToMCPConverter[MessageParam, Message]):
-    """
-    Convert between Anthropic and MCP types.
-    """
-
-    @classmethod
-    def from_mcp_message_result(cls, result: MCPMessageResult) -> Message:
-        # MCPMessageResult -> Message
-        if result.role != "assistant":
-            raise ValueError(
-                f"Expected role to be 'assistant' but got '{result.role}' instead."
-            )
-
-        return Message(
-            role="assistant",
-            type="message",
-            content=[mcp_content_to_anthropic_content(result.content)],
-            model=result.model,
-            stop_reason=mcp_stop_reason_to_anthropic_stop_reason(result.stopReason),
-            id=result.id or None,
-            usage=result.usage or None,
-            # TODO: should we push extras?
-        )
-
-    @classmethod
-    def to_mcp_message_result(cls, result: Message) -> MCPMessageResult:
-        # Message -> MCPMessageResult
-
-        contents = anthropic_content_to_mcp_content(result.content)
-        if len(contents) > 1:
-            raise NotImplementedError(
-                "Multiple content elements in a single message are not supported in MCP yet"
-            )
-        mcp_content = contents[0]
-
-        return MCPMessageResult(
-            role=result.role,
-            content=mcp_content,
-            model=result.model,
-            stopReason=anthropic_stop_reason_to_mcp_stop_reason(result.stop_reason),
-            # extras for Message fields
-            **result.model_dump(exclude={"role", "content", "model", "stop_reason"}),
-        )
-
-    @classmethod
-    def from_mcp_message_param(cls, param: MCPMessageParam) -> MessageParam:
-        # MCPMessageParam -> MessageParam
-        extras = param.model_dump(exclude={"role", "content"})
-        return MessageParam(
-            role=param.role,
-            content=[mcp_content_to_anthropic_content(param.content)],
-            **extras,
-        )
-
-    @classmethod
-    def to_mcp_message_param(cls, param: MessageParam) -> MCPMessageParam:
-        # Implement the conversion from ChatCompletionMessage to MCP message param
-
-        contents = anthropic_content_to_mcp_content(param.content)
-
-        # TODO: saqadri - the mcp_content can have multiple elements
-        # while sampling message content has a single content element
-        # Right now we error out if there are > 1 elements in mcp_content
-        # We need to handle this case properly going forward
-        if len(contents) > 1:
-            raise NotImplementedError(
-                "Multiple content elements in a single message are not supported"
-            )
-        mcp_content = contents[0]
-
-        return MCPMessageParam(
-            role=param.role,
-            content=mcp_content,
-            **typed_dict_extras(param, ["role", "content"]),
-        )
-
-    @classmethod
-    def from_mcp_prompt_message(cls, message: PromptMessage) -> MessageParam:
-        """Convert an MCP PromptMessage to an Anthropic MessageParam."""
-
-        # Extract content text
-        content_text = (
-            message.content.text
-            if hasattr(message.content, "text")
-            else str(message.content)
-        )
-
-        # Extract extras for flexibility
-        extras = message.model_dump(exclude={"role", "content"})
-
-        # Handle based on role
-        if message.role == "user":
-            return {"role": "user", "content": content_text, **extras}
-        elif message.role == "assistant":
-            return {
-                "role": "assistant",
-                "content": [{"type": "text", "text": content_text}],
-                **extras,
-            }
-        else:
-            # Fall back to user for any unrecognized role, including "system"
-            _logger.warning(
-                f"Unsupported role '{message.role}' in PromptMessage. Falling back to 'user' role."
-            )
-            return {
-                "role": "user",
-                "content": f"[{message.role.upper()}] {content_text}",
-                **extras,
-            }
-
-
-def mcp_content_to_anthropic_content(
-    content: TextContent | ImageContent | EmbeddedResource,
-) -> ContentBlock:
-    if isinstance(content, TextContent):
-        return TextBlock(type=content.type, text=content.text)
-    elif isinstance(content, ImageContent):
-        # Best effort to convert an image to text (since there's no ImageBlock)
-        return TextBlock(type="text", text=f"{content.mimeType}:{content.data}")
-    elif isinstance(content, EmbeddedResource):
-        if isinstance(content.resource, TextResourceContents):
-            return TextBlock(type="text", text=content.resource.text)
-        else:  # BlobResourceContents
-            return TextBlock(
-                type="text", text=f"{content.resource.mimeType}:{content.resource.blob}"
-            )
-    else:
-        # Last effort to convert the content to a string
-        return TextBlock(type="text", text=str(content))
-
-
-def anthropic_content_to_mcp_content(
-    content: str
-    | Iterable[
-        TextBlockParam
-        | ImageBlockParam
-        | ToolUseBlockParam
-        | ToolResultBlockParam
-        | DocumentBlockParam
-        | ContentBlock
-    ],
-) -> List[TextContent | ImageContent | EmbeddedResource]:
-    mcp_content = []
-
-    if isinstance(content, str):
-        mcp_content.append(TextContent(type="text", text=content))
-    else:
-        for block in content:
-            if block.type == "text":
-                mcp_content.append(TextContent(type="text", text=block.text))
-            elif block.type == "image":
-                raise NotImplementedError("Image content conversion not implemented")
-            elif block.type == "tool_use":
-                # Best effort to convert a tool use to text (since there's no ToolUseContent)
-                mcp_content.append(
-                    TextContent(
-                        type="text",
-                        text=to_string(block),
-                    )
-                )
-            elif block.type == "tool_result":
-                # Best effort to convert a tool result to text (since there's no ToolResultContent)
-                mcp_content.append(
-                    TextContent(
-                        type="text",
-                        text=to_string(block),
-                    )
-                )
-            elif block.type == "document":
-                raise NotImplementedError("Document content conversion not implemented")
-            else:
-                # Last effort to convert the content to a string
-                mcp_content.append(TextContent(type="text", text=str(block)))
-
-    return mcp_content
-
-
-def mcp_stop_reason_to_anthropic_stop_reason(stop_reason: StopReason):
-    if not stop_reason:
-        return None
-    elif stop_reason == "endTurn":
-        return "end_turn"
-    elif stop_reason == "maxTokens":
-        return "max_tokens"
-    elif stop_reason == "stopSequence":
-        return "stop_sequence"
-    elif stop_reason == "toolUse":
-        return "tool_use"
-    else:
-        return stop_reason
-
-
-def anthropic_stop_reason_to_mcp_stop_reason(stop_reason: str) -> StopReason:
-    if not stop_reason:
-        return None
-    elif stop_reason == "end_turn":
-        return "endTurn"
-    elif stop_reason == "max_tokens":
-        return "maxTokens"
-    elif stop_reason == "stop_sequence":
-        return "stopSequence"
-    elif stop_reason == "tool_use":
-        return "toolUse"
-    else:
-        return stop_reason
-
-
-def to_string(obj: BaseModel | dict) -> str:
-    if isinstance(obj, BaseModel):
-        return obj.model_dump_json()
-    else:
-        return json.dumps(obj)
-
-
-def typed_dict_extras(d: dict, exclude: List[str]):
-    extras = {k: v for k, v in d.items() if k not in exclude}
-    return extras