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

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

@@ -1,15 +1,17 @@
 import os
-from typing import List, Type, TYPE_CHECKING
+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_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+    from mcp import ListToolsResult
 
 
 from anthropic import Anthropic, AuthenticationError
@@ -20,21 +22,21 @@ from anthropic.types import (
     TextBlockParam,
     ToolParam,
     ToolUseBlockParam,
+    Usage,
 )
 from mcp.types import (
-    CallToolRequestParams,
     CallToolRequest,
+    CallToolRequestParams,
 )
 from pydantic_core import from_json
+from rich.text import Text
 
-from mcp_agent.workflows.llm.augmented_llm import (
+from mcp_agent.core.exceptions import ProviderKeyError
+from mcp_agent.llm.augmented_llm import (
     AugmentedLLM,
     ModelT,
     RequestParams,
 )
-from mcp_agent.core.exceptions import ProviderKeyError
-from rich.text import Text
-
 from mcp_agent.logging.logger import get_logger
 
 DEFAULT_ANTHROPIC_MODEL = "claude-3-7-sonnet-latest"
@@ -48,7 +50,7 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
     selecting appropriate tools, and determining what information to retain.
     """
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args, **kwargs) -> None:
         self.provider = "Anthropic"
         # Initialize logger - keep it simple without name reference
         self.logger = get_logger(__name__)
@@ -67,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,
     ):
         """
@@ -78,46 +83,42 @@ 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:
             raise ProviderKeyError(
                 "Invalid Anthropic API key",
-                "The configured Anthropic API key was rejected.\n"
-                "Please check that your API key is valid and not expired.",
+                "The configured Anthropic API key was rejected.\nPlease check that your API key is valid and not expired.",
             ) from e
 
         # Always include prompt messages, but only include conversation history
         # 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)
 
-        response = await self.aggregator.list_tools()
+        tool_list: ListToolsResult = await self.aggregator.list_tools()
         available_tools: List[ToolParam] = [
-            {
-                "name": tool.name,
-                "description": tool.description,
-                "input_schema": tool.inputSchema,
-            }
-            for tool in response.tools
+            ToolParam(
+                name=tool.name,
+                description=tool.description or "",
+                input_schema=tool.inputSchema,
+            )
+            for tool in tool_list.tools
         ]
 
         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,
@@ -134,17 +135,14 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
 
             self.logger.debug(f"{arguments}")
 
-            executor_result = await self.executor.execute(
-                anthropic.messages.create, **arguments
-            )
+            executor_result = await self.executor.execute(anthropic.messages.create, **arguments)
 
             response = executor_result[0]
 
             if isinstance(response, AuthenticationError):
                 raise ProviderKeyError(
                     "Invalid Anthropic API key",
-                    "The configured Anthropic API key was rejected.\n"
-                    "Please check that your API key is valid and not expired.",
+                    "The configured Anthropic API key was rejected.\nPlease check that your API key is valid and not expired.",
                 ) from response
             elif isinstance(response, BaseException):
                 error_details = str(response)
@@ -154,13 +152,9 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
                 if hasattr(response, "status_code") and hasattr(response, "response"):
                     try:
                         error_json = response.response.json()
-                        error_details = (
-                            f"Error code: {response.status_code} - {error_json}"
-                        )
+                        error_details = f"Error code: {response.status_code} - {error_json}"
                     except:  # noqa: E722
-                        error_details = (
-                            f"Error code: {response.status_code} - {str(response)}"
-                        )
+                        error_details = f"Error code: {response.status_code} - {str(response)}"
 
                 # Convert other errors to text response
                 error_message = f"Error during generation: {error_details}"
@@ -171,7 +165,7 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
                     type="message",
                     content=[TextBlock(type="text", text=error_message)],
                     stop_reason="end_turn",  # Must be one of the allowed values
-                    usage={"input_tokens": 0, "output_tokens": 0},  # Required field
+                    usage=Usage(input_tokens=0, output_tokens=0),  # Required field
                 )
 
             self.logger.debug(
@@ -193,9 +187,7 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
 
                 await self.show_assistant_message(message_text)
 
-                self.logger.debug(
-                    f"Iteration {i}: Stopping because finish_reason is 'end_turn'"
-                )
+                self.logger.debug(f"Iteration {i}: Stopping because finish_reason is 'end_turn'")
                 break
             elif response.stop_reason == "stop_sequence":
                 # We have reached a stop sequence
@@ -206,9 +198,7 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
             elif response.stop_reason == "max_tokens":
                 # We have reached the max tokens limit
 
-                self.logger.debug(
-                    f"Iteration {i}: Stopping because finish_reason is 'max_tokens'"
-                )
+                self.logger.debug(f"Iteration {i}: Stopping because finish_reason is 'max_tokens'")
                 if params.maxTokens is not None:
                     message_text = Text(
                         f"the assistant has reached the maximum token limit ({params.maxTokens})",
@@ -255,9 +245,7 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
                         self.show_tool_call(available_tools, tool_name, tool_args)
                         tool_call_request = CallToolRequest(
                             method="tools/call",
-                            params=CallToolRequestParams(
-                                name=tool_name, arguments=tool_args
-                            ),
+                            params=CallToolRequestParams(name=tool_name, arguments=tool_args),
                         )
                         # TODO -- support MCP isError etc.
                         result = await self.call_tool(
@@ -268,9 +256,7 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
                         # Add each result to our collection
                         tool_results.append((tool_use_id, result))
 
-                    messages.append(
-                        AnthropicConverter.create_tool_results_message(tool_results)
-                    )
+                    messages.append(AnthropicConverter.create_tool_results_message(tool_results))
 
         # Only save the new conversation messages to history if use_history is true
         # Keep the prompt messages separate
@@ -311,7 +297,7 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
 
     async def generate_str(
         self,
-        message,
+        message_param,
         request_params: RequestParams | None = None,
     ) -> str:
         """
@@ -319,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,
         )
 
@@ -351,114 +331,36 @@ 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
+            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"
-            )
+            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.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)}"
+            self.logger.debug("Last message in prompt is from assistant, returning it directly")
+            return last_message
 
     async def generate_structured(
         self,
-        message,
+        message: str,
         response_model: Type[ModelT],
         request_params: RequestParams | None = None,
     ) -> ModelT:
@@ -475,9 +377,7 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
         return response_model.model_validate(from_json(response, allow_partial=True))
 
     @classmethod
-    def convert_message_to_message_param(
-        cls, message: Message, **kwargs
-    ) -> MessageParam:
+    def convert_message_to_message_param(cls, message: Message, **kwargs) -> MessageParam:
         """Convert a response object to an input parameter object to allow LLM calls to be chained."""
         content = []
 
@@ -495,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)

mcp_agent/llm/providers/augmented_llm_deepseek.py

@@ -0,0 +1,53 @@
+import os
+
+from mcp_agent.core.exceptions import ProviderKeyError
+from mcp_agent.core.request_params import RequestParams
+from mcp_agent.llm.providers.augmented_llm_openai import OpenAIAugmentedLLM
+
+DEEPSEEK_BASE_URL = "https://api.deepseek.com"
+DEFAULT_DEEPSEEK_MODEL = "deepseekchat"  # current Deepseek only has two type models
+
+
+class DeepSeekAugmentedLLM(OpenAIAugmentedLLM):
+    def __init__(self, *args, **kwargs) -> None:
+        kwargs["provider_name"] = "Deepseek"  # Set provider name in kwargs
+        super().__init__(*args, **kwargs)  # Properly pass args and kwargs to parent
+
+    def _initialize_default_params(self, kwargs: dict) -> RequestParams:
+        """Initialize Deepseek-specific default parameters"""
+        chosen_model = kwargs.get("model", DEFAULT_DEEPSEEK_MODEL)
+
+        return RequestParams(
+            model=chosen_model,
+            systemPrompt=self.instruction,
+            parallel_tool_calls=True,
+            max_iterations=10,
+            use_history=True,
+        )
+
+    def _api_key(self) -> str:
+        config = self.context.config
+        api_key = None
+
+        if config and config.deepseek:
+            api_key = config.deepseek.api_key
+            if api_key == "<your-api-key-here>":
+                api_key = None
+
+        if api_key is None:
+            api_key = os.getenv("DEEPSEEK_API_KEY")
+
+        if not api_key:
+            raise ProviderKeyError(
+                "DEEPSEEK API key not configured",
+                "The DEEKSEEK API key is required but not set.\n"
+                "Add it to your configuration file under deepseek.api_key\n"
+                "Or set the DEEPSEEK_API_KEY environment variable",
+            )
+        return api_key
+
+    def _base_url(self) -> str:
+        if self.context.config and self.context.config.deepseek:
+            base_url = self.context.config.deepseek.base_url
+
+        return base_url if base_url else DEEPSEEK_BASE_URL