fast-agent-mcp 0.2.13__py3-none-any.whl → 0.2.16__py3-none-any.whl

mcp_agent/llm/providers/augmented_llm_anthropic.py

@@ -1,9 +1,9 @@
-import os
 from typing import TYPE_CHECKING, List
 
 from mcp.types import EmbeddedResource, ImageContent, TextContent
 
 from mcp_agent.core.prompt import Prompt
+from mcp_agent.llm.provider_types import Provider
 from mcp_agent.llm.providers.multipart_converter_anthropic import (
     AnthropicConverter,
 )
@@ -51,12 +51,12 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
     """
 
     def __init__(self, *args, **kwargs) -> None:
-        self.provider = "Anthropic"
         # Initialize logger - keep it simple without name reference
         self.logger = get_logger(__name__)
 
-        # Now call super().__init__
-        super().__init__(*args, type_converter=AnthropicSamplingConverter, **kwargs)
+        super().__init__(
+            *args, provider=Provider.ANTHROPIC, type_converter=AnthropicSamplingConverter, **kwargs
+        )
 
     def _initialize_default_params(self, kwargs: dict) -> RequestParams:
         """Initialize Anthropic-specific default parameters"""
@@ -83,7 +83,7 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
         Override this method to use a different LLM.
         """
 
-        api_key = self._api_key(self.context.config)
+        api_key = self._api_key()
         base_url = self._base_url()
         if base_url and base_url.endswith("/v1"):
             base_url = base_url.rstrip("/v1")
@@ -277,27 +277,6 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
 
         return responses
 
-    def _api_key(self, config):
-        api_key = None
-
-        if hasattr(config, "anthropic") and config.anthropic:
-            api_key = config.anthropic.api_key
-            if api_key == "<your-api-key-here>":
-                api_key = None
-
-        if api_key is None:
-            api_key = os.getenv("ANTHROPIC_API_KEY")
-
-        if not api_key:
-            raise ProviderKeyError(
-                "Anthropic API key not configured",
-                "The Anthropic API key is required but not set.\n"
-                "Add it to your configuration file under anthropic.api_key "
-                "or set the ANTHROPIC_API_KEY environment variable.",
-            )
-
-        return api_key
-
     async def generate_messages(
         self,
         message_param,

mcp_agent/llm/providers/augmented_llm_deepseek.py

@@ -1,7 +1,6 @@
-import os
 
-from mcp_agent.core.exceptions import ProviderKeyError
 from mcp_agent.core.request_params import RequestParams
+from mcp_agent.llm.provider_types import Provider
 from mcp_agent.llm.providers.augmented_llm_openai import OpenAIAugmentedLLM
 
 DEEPSEEK_BASE_URL = "https://api.deepseek.com"
@@ -11,7 +10,9 @@ DEFAULT_DEEPSEEK_MODEL = "deepseekchat"  # current Deepseek only has two type mo
 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
+        super().__init__(
+            *args, provider=Provider.DEEPSEEK, **kwargs
+        )  # Properly pass args and kwargs to parent
 
     def _initialize_default_params(self, kwargs: dict) -> RequestParams:
         """Initialize Deepseek-specific default parameters"""
@@ -25,28 +26,8 @@ class DeepSeekAugmentedLLM(OpenAIAugmentedLLM):
             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:
+        base_url = None
         if self.context.config and self.context.config.deepseek:
             base_url = self.context.config.deepseek.base_url
 

mcp_agent/llm/providers/augmented_llm_generic.py

@@ -1,6 +1,7 @@
 import os
 
 from mcp_agent.core.request_params import RequestParams
+from mcp_agent.llm.provider_types import Provider
 from mcp_agent.llm.providers.augmented_llm_openai import OpenAIAugmentedLLM
 
 DEFAULT_OLLAMA_BASE_URL = "http://localhost:11434/v1"
@@ -10,8 +11,9 @@ DEFAULT_OLLAMA_API_KEY = "ollama"
 
 class GenericAugmentedLLM(OpenAIAugmentedLLM):
     def __init__(self, *args, **kwargs) -> None:
-        kwargs["provider_name"] = "GenericOpenAI"
-        super().__init__(*args, **kwargs)  # Properly pass args and kwargs to parent
+        super().__init__(
+            *args, provider=Provider.GENERIC, **kwargs
+        )  # Properly pass args and kwargs to parent
 
     def _initialize_default_params(self, kwargs: dict) -> RequestParams:
         """Initialize Generic  parameters"""
@@ -25,20 +27,6 @@ class GenericAugmentedLLM(OpenAIAugmentedLLM):
             use_history=True,
         )
 
-    def _api_key(self) -> str:
-        config = self.context.config
-        api_key = None
-
-        if config and config.generic:
-            api_key = config.generic.api_key
-            if api_key == "<your-api-key-here>":
-                api_key = None
-
-        if api_key is None:
-            api_key = os.getenv("GENERIC_API_KEY")
-
-        return api_key or "ollama"
-
     def _base_url(self) -> str:
         base_url = os.getenv("GENERIC_BASE_URL", DEFAULT_OLLAMA_BASE_URL)
         if self.context.config and self.context.config.generic:

mcp_agent/llm/providers/augmented_llm_openai.py

@@ -1,4 +1,3 @@
-import os
 from typing import List, Tuple, Type
 
 from mcp.types import (
@@ -29,6 +28,7 @@ from mcp_agent.llm.augmented_llm import (
     ModelT,
     RequestParams,
 )
+from mcp_agent.llm.provider_types import Provider
 from mcp_agent.llm.providers.multipart_converter_openai import OpenAIConverter
 from mcp_agent.llm.providers.sampling_converter_openai import (
     OpenAISamplingConverter,
@@ -49,14 +49,13 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
     This implementation uses OpenAI's ChatCompletion as the LLM.
     """
 
-    def __init__(self, provider_name: str = "OpenAI", *args, **kwargs) -> None:
+    def __init__(self, provider: Provider = Provider.OPENAI, *args, **kwargs) -> None:
         # Set type_converter before calling super().__init__
         if "type_converter" not in kwargs:
             kwargs["type_converter"] = OpenAISamplingConverter
 
-        super().__init__(*args, **kwargs)
+        super().__init__(*args, provider=provider, **kwargs)
 
-        self.provider = provider_name
         # Initialize logger with name if available
         self.logger = get_logger(f"{__name__}.{self.name}" if self.name else __name__)
 
@@ -90,27 +89,6 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
             use_history=True,
         )
 
-    def _api_key(self) -> str:
-        config = self.context.config
-        api_key = None
-
-        if hasattr(config, "openai") and config.openai:
-            api_key = config.openai.api_key
-            if api_key == "<your-api-key-here>":
-                api_key = None
-
-        if api_key is None:
-            api_key = os.getenv("OPENAI_API_KEY")
-
-        if not api_key:
-            raise ProviderKeyError(
-                "OpenAI API key not configured",
-                "The OpenAI API key is required but not set.\n"
-                "Add it to your configuration file under openai.api_key\n"
-                "Or set the OPENAI_API_KEY environment variable",
-            )
-        return api_key
-
     def _base_url(self) -> str:
         return self.context.config.openai.base_url if self.context.config.openai else None
 
@@ -371,7 +349,7 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
             The parsed response as a Pydantic model, or None if parsing fails
         """
 
-        if not "OpenAI" == self.provider:
+        if not Provider.OPENAI == self.provider:
             return await super().structured(prompt, model, request_params)
 
         logger = get_logger(__name__)

mcp_agent/llm/providers/augmented_llm_openrouter.py

@@ -1,19 +1,19 @@
 import os
 
-from mcp_agent.core.exceptions import ProviderKeyError
 from mcp_agent.core.request_params import RequestParams
+from mcp_agent.llm.provider_types import Provider
 from mcp_agent.llm.providers.augmented_llm_openai import OpenAIAugmentedLLM
 
 DEFAULT_OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1"
 # No single default model for OpenRouter, users must specify full path
-DEFAULT_OPENROUTER_MODEL = None 
+DEFAULT_OPENROUTER_MODEL = None
 
 
 class OpenRouterAugmentedLLM(OpenAIAugmentedLLM):
     """Augmented LLM provider for OpenRouter, using an OpenAI-compatible API."""
+
     def __init__(self, *args, **kwargs) -> None:
-        kwargs["provider_name"] = "OpenRouter"  # Set provider name
-        super().__init__(*args, **kwargs)
+        super().__init__(*args, provider=Provider.OPENROUTER, **kwargs)
 
     def _initialize_default_params(self, kwargs: dict) -> RequestParams:
         """Initialize OpenRouter-specific default parameters."""
@@ -21,58 +21,30 @@ class OpenRouterAugmentedLLM(OpenAIAugmentedLLM):
         # The model should be passed in the 'model' kwarg during factory creation.
         chosen_model = kwargs.get("model", DEFAULT_OPENROUTER_MODEL)
         if not chosen_model:
-             # Unlike Deepseek, OpenRouter *requires* a model path in the identifier.
-             # The factory should extract this before calling the constructor.
-             # We rely on the model being passed correctly via kwargs.
-             # If it's still None here, it indicates an issue upstream (factory or user input).
-             # However, the base class _get_model handles the error if model is None.
-             pass
-
+            # Unlike Deepseek, OpenRouter *requires* a model path in the identifier.
+            # The factory should extract this before calling the constructor.
+            # We rely on the model being passed correctly via kwargs.
+            # If it's still None here, it indicates an issue upstream (factory or user input).
+            # However, the base class _get_model handles the error if model is None.
+            pass
 
         return RequestParams(
-            model=chosen_model, # Will be validated by base class
+            model=chosen_model,  # Will be validated by base class
             systemPrompt=self.instruction,
-            parallel_tool_calls=True, # Default based on OpenAI provider
-            max_iterations=10,      # Default based on OpenAI provider
-            use_history=True,       # Default based on OpenAI provider
+            parallel_tool_calls=True,  # Default based on OpenAI provider
+            max_iterations=10,  # Default based on OpenAI provider
+            use_history=True,  # Default based on OpenAI provider
         )
 
-    def _api_key(self) -> str:
-        """Retrieve the OpenRouter API key from config or environment variables."""
-        config = self.context.config
-        api_key = None
-
-        # Check config file first
-        if config and hasattr(config, 'openrouter') and config.openrouter:
-            api_key = getattr(config.openrouter, 'api_key', None)
-            if api_key == "<your-openrouter-api-key-here>" or not api_key:
-                api_key = None
-
-        # Fallback to environment variable
-        if api_key is None:
-            api_key = os.getenv("OPENROUTER_API_KEY")
-
-        if not api_key:
-            raise ProviderKeyError(
-                "OpenRouter API key not configured",
-                "The OpenRouter API key is required but not set.\n"
-                "Add it to your configuration file under openrouter.api_key\n"
-                "Or set the OPENROUTER_API_KEY environment variable.",
-            )
-        return api_key
-
     def _base_url(self) -> str:
         """Retrieve the OpenRouter base URL from config or use the default."""
         base_url = os.getenv("OPENROUTER_BASE_URL", DEFAULT_OPENROUTER_BASE_URL)  # Default
         config = self.context.config
-        
+
         # Check config file for override
-        if config and hasattr(config, 'openrouter') and config.openrouter:
-            config_base_url = getattr(config.openrouter, 'base_url', None)
+        if config and hasattr(config, "openrouter") and config.openrouter:
+            config_base_url = getattr(config.openrouter, "base_url", None)
             if config_base_url:
                 base_url = config_base_url
 
         return base_url
-
-    # Other methods like _get_model, _send_request etc., are inherited from OpenAIAugmentedLLM
-    # We may override them later if OpenRouter deviates significantly or offers unique features. 

mcp_agent/mcp/interfaces.py

@@ -26,6 +26,7 @@ from mcp import ClientSession
 from mcp.types import GetPromptResult, Prompt, PromptMessage, ReadResourceResult
 from pydantic import BaseModel
 
+from mcp_agent.core.agent_types import AgentType
 from mcp_agent.core.request_params import RequestParams
 from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 
@@ -137,7 +138,7 @@ class AgentProtocol(AugmentedLLMProtocol, Protocol):
     name: str
 
     @property
-    def agent_type(self) -> str:
+    def agent_type(self) -> AgentType:
         """Return the type of this agent"""
         ...
 

mcp_agent/mcp_server/agent_server.py

@@ -143,13 +143,38 @@ class AgentMCPServer:
             self.mcp_server.settings.host = host
             self.mcp_server.settings.port = port
 
-        try:
-            self.mcp_server.run(transport=transport)
-        except KeyboardInterrupt:
-            print("\nServer stopped by user (CTRL+C)")
-        finally:
-            # Run an async cleanup in a new event loop
-            asyncio.run(self.shutdown())
+            # For synchronous run, we can use the simpler approach
+            try:
+                # Add any server attributes that might help with shutdown
+                if not hasattr(self.mcp_server, "_server_should_exit"):
+                    self.mcp_server._server_should_exit = False
+
+                # Run the server
+                self.mcp_server.run(transport=transport)
+            except KeyboardInterrupt:
+                print("\nServer stopped by user (CTRL+C)")
+            except SystemExit as e:
+                # Handle normal exit
+                print(f"\nServer exiting with code {e.code}")
+                # Re-raise to allow normal exit process
+                raise
+            except Exception as e:
+                print(f"\nServer error: {e}")
+            finally:
+                # Run an async cleanup in a new event loop
+                try:
+                    asyncio.run(self.shutdown())
+                except (SystemExit, KeyboardInterrupt):
+                    # These are expected during shutdown
+                    pass
+        else:  # stdio
+            try:
+                self.mcp_server.run(transport=transport)
+            except KeyboardInterrupt:
+                print("\nServer stopped by user (CTRL+C)")
+            finally:
+                # Minimal cleanup for stdio
+                asyncio.run(self._cleanup_stdio())
 
     async def run_async(
         self, transport: str = "sse", host: str = "0.0.0.0", port: int = 8000
@@ -169,20 +194,26 @@ class AgentMCPServer:
             try:
                 # Wait for the server task to complete
                 await self._server_task
-            except asyncio.CancelledError:
-                logger.info("Server task cancelled.")
-                print("\nServer task cancelled.")
+            except (asyncio.CancelledError, KeyboardInterrupt):
+                # Both cancellation and KeyboardInterrupt are expected during shutdown
+                logger.info("Server stopped via cancellation or interrupt")
+                print("\nServer stopped")
+            except SystemExit as e:
+                # Handle normal exit cleanly
+                logger.info(f"Server exiting with code {e.code}")
+                print(f"\nServer exiting with code {e.code}")
+                # If this is exit code 0, let it propagate for normal exit
+                if e.code == 0:
+                    raise
             except Exception as e:
                 logger.error(f"Server error: {e}", exc_info=True)
                 print(f"\nServer error: {e}")
             finally:
-                # Ensure cleanup happens
-                await self.shutdown()
-                logger.info("Server shutdown complete.")
+                # Only do minimal cleanup - don't try to be too clever
+                await self._cleanup_stdio()
                 print("\nServer shutdown complete.")
         else:  # stdio
             # For STDIO, use simpler approach that respects STDIO lifecycle
-            # STDIO will naturally terminate when streams close
             try:
                 # Run directly without extra monitoring or signal handlers
                 # This preserves the natural lifecycle of STDIO connections
@@ -190,9 +221,14 @@ class AgentMCPServer:
             except (asyncio.CancelledError, KeyboardInterrupt):
                 logger.info("Server stopped (CTRL+C)")
                 print("\nServer stopped (CTRL+C)")
-
+            except SystemExit as e:
+                # Handle normal exit cleanly
+                logger.info(f"Server exiting with code {e.code}")
+                print(f"\nServer exiting with code {e.code}")
+                # If this is exit code 0, let it propagate for normal exit
+                if e.code == 0:
+                    raise
             # Only perform minimal cleanup needed for STDIO
-            # Don't use our full shutdown procedure which could keep process alive
             await self._cleanup_stdio()
 
     async def _run_server_with_shutdown(self, transport: str):
@@ -246,7 +282,6 @@ class AgentMCPServer:
             force_shutdown_task = asyncio.create_task(self._force_shutdown_event.wait())
             timeout_task = asyncio.create_task(asyncio.sleep(self._shutdown_timeout))
 
-            # Wait for either force shutdown or timeout
             done, pending = await asyncio.wait(
                 [force_shutdown_task, timeout_task], return_when=asyncio.FIRST_COMPLETED
             )
@@ -255,21 +290,16 @@ class AgentMCPServer:
             for task in pending:
                 task.cancel()
 
-            # Determine the shutdown reason
+            # Determine shutdown reason
             if force_shutdown_task in done:
-                logger.info("Force shutdown requested")
-                print("\nForced shutdown initiated...")
+                logger.info("Force shutdown requested by user")
+                print("\nForce shutdown initiated...")
             else:
                 logger.info(f"Graceful shutdown timed out after {self._shutdown_timeout} seconds")
                 print(f"\nGraceful shutdown timed out after {self._shutdown_timeout} seconds")
 
-            # Force close any remaining SSE connections
-            await self._close_sse_connections()
+                os._exit(0)
 
-            # Cancel the server task if running
-            if self._server_task and not self._server_task.done():
-                logger.info("Cancelling server task")
-                self._server_task.cancel()
         except asyncio.CancelledError:
             # Monitor was cancelled - clean exit
             pass
@@ -302,11 +332,36 @@ class AgentMCPServer:
                 for session_id, writer in writers:
                     try:
                         logger.debug(f"Closing SSE connection: {session_id}")
+                        # Instead of aclose, try to close more gracefully
+                        # Send a special event to notify client, then close
+                        try:
+                            if hasattr(writer, "send") and not getattr(writer, "_closed", False):
+                                try:
+                                    # Try to send a close event if possible
+                                    await writer.send(Exception("Server shutting down"))
+                                except (AttributeError, asyncio.CancelledError):
+                                    pass
+                        except Exception:
+                            pass
+
+                        # Now close the stream
                         await writer.aclose()
                         sse._read_stream_writers.pop(session_id, None)
                     except Exception as e:
                         logger.error(f"Error closing SSE connection {session_id}: {e}")
 
+        # If we have a ASGI lifespan hook, try to signal closure
+        if (
+            hasattr(self.mcp_server, "_lifespan_state")
+            and self.mcp_server._lifespan_state == "started"
+        ):
+            logger.debug("Attempting to signal ASGI lifespan shutdown")
+            try:
+                if hasattr(self.mcp_server, "_on_shutdown"):
+                    await self.mcp_server._on_shutdown()
+            except Exception as e:
+                logger.error(f"Error during ASGI lifespan shutdown: {e}")
+
     async def with_bridged_context(self, agent_context, mcp_context, func, *args, **kwargs):
         """
         Execute a function with bridged context between MCP and agent
@@ -374,18 +429,45 @@ class AgentMCPServer:
         # Signal shutdown
         self._graceful_shutdown_event.set()
 
-        # Close SSE connections
-        await self._close_sse_connections()
+        try:
+            # Close SSE connections
+            await self._close_sse_connections()
 
-        # Close any resources in the exit stack
-        await self._exit_stack.aclose()
+            # Close any resources in the exit stack
+            await self._exit_stack.aclose()
 
-        # Shutdown any agent resources
-        for agent_name, agent in self.agent_app._agents.items():
-            try:
-                if hasattr(agent, "shutdown"):
-                    await agent.shutdown()
-            except Exception as e:
-                logger.error(f"Error shutting down agent {agent_name}: {e}")
+            # Shutdown any agent resources
+            for agent_name, agent in self.agent_app._agents.items():
+                try:
+                    if hasattr(agent, "shutdown"):
+                        await agent.shutdown()
+                except Exception as e:
+                    logger.error(f"Error shutting down agent {agent_name}: {e}")
+        except Exception as e:
+            # Log any errors but don't let them prevent shutdown
+            logger.error(f"Error during shutdown: {e}", exc_info=True)
+        finally:
+            logger.info("Full shutdown complete")
+
+    async def _cleanup_minimal(self):
+        """Perform minimal cleanup before simulating a KeyboardInterrupt."""
+        logger.info("Performing minimal cleanup before interrupt")
+
+        # Only close SSE connection writers directly
+        if (
+            hasattr(self.mcp_server, "_sse_transport")
+            and self.mcp_server._sse_transport is not None
+        ):
+            sse = self.mcp_server._sse_transport
+
+            # Close all read stream writers
+            if hasattr(sse, "_read_stream_writers"):
+                for session_id, writer in list(sse._read_stream_writers.items()):
+                    try:
+                        await writer.aclose()
+                    except Exception:
+                        # Ignore errors during cleanup
+                        pass
 
-        logger.info("Full shutdown complete")
+        # Clear active connections set to prevent further operations
+        self._active_connections.clear()

mcp_agent/cli/commands/config.py

@@ -1,11 +0,0 @@
-from typing import NoReturn
-
-import typer
-
-app = typer.Typer()
-
-
-@app.command()
-def show() -> NoReturn:
-    """Show the configuration."""
-    raise NotImplementedError("The show configuration command has not been implemented yet")