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

mcp_agent/config.py

@@ -100,31 +100,36 @@ class MCPSettings(BaseModel):
 
 class AnthropicSettings(BaseModel):
     """
-    Settings for using Anthropic models in the MCP Agent application.
+    Settings for using Anthropic models in the fast-agent application.
     """
 
     api_key: str | None = None
 
+    base_url: str | None = None
+
     model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
 
 
-class CohereSettings(BaseModel):
+class OpenAISettings(BaseModel):
     """
-    Settings for using Cohere models in the MCP Agent application.
+    Settings for using OpenAI models in the fast-agent application.
     """
 
     api_key: str | None = None
+    reasoning_effort: Literal["low", "medium", "high"] = "medium"
+
+    base_url: str | None = None
 
     model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
 
 
-class OpenAISettings(BaseModel):
+class DeepSeekSettings(BaseModel):
     """
-    Settings for using OpenAI models in the MCP Agent application.
+    Settings for using OpenAI models in the fast-agent application.
     """
 
     api_key: str | None = None
-    reasoning_effort: Literal["low", "medium", "high"] = "medium"
+    # reasoning_effort: Literal["low", "medium", "high"] = "medium"
 
     base_url: str | None = None
 
@@ -133,7 +138,7 @@ class OpenAISettings(BaseModel):
 
 class TemporalSettings(BaseModel):
     """
-    Temporal settings for the MCP Agent application.
+    Temporal settings for the fast-agent application.
     """
 
     host: str
@@ -142,27 +147,14 @@ class TemporalSettings(BaseModel):
     api_key: str | None = None
 
 
-class UsageTelemetrySettings(BaseModel):
-    """
-    Settings for usage telemetry in the MCP Agent application.
-    Anonymized usage metrics are sent to a telemetry server to help improve the product.
-    """
-
-    enabled: bool = True
-    """Enable usage telemetry in the MCP Agent application."""
-
-    enable_detailed_telemetry: bool = False
-    """If enabled, detailed telemetry data, including prompts and agents, will be sent to the telemetry server."""
-
-
 class OpenTelemetrySettings(BaseModel):
     """
-    OTEL settings for the MCP Agent application.
+    OTEL settings for the fast-agent application.
     """
 
     enabled: bool = True
 
-    service_name: str = "mcp-agent"
+    service_name: str = "fast-agent"
     service_instance_id: str | None = None
     service_version: str | None = None
 
@@ -178,7 +170,7 @@ class OpenTelemetrySettings(BaseModel):
 
 class LoggerSettings(BaseModel):
     """
-    Logger settings for the MCP Agent application.
+    Logger settings for the fast-agent application.
     """
 
     type: Literal["none", "console", "file", "http"] = "file"
@@ -221,7 +213,7 @@ class LoggerSettings(BaseModel):
 
 class Settings(BaseSettings):
     """
-    Settings class for the MCP Agent application.
+    Settings class for the fast-agent application.
     """
 
     model_config = SettingsConfigDict(
@@ -236,7 +228,7 @@ class Settings(BaseSettings):
     """MCP config, such as MCP servers"""
 
     execution_engine: Literal["asyncio", "temporal"] = "asyncio"
-    """Execution engine for the MCP Agent application"""
+    """Execution engine for the fast-agent application"""
 
     default_model: str | None = "haiku"
     """
@@ -247,22 +239,19 @@ class Settings(BaseSettings):
     """Settings for Temporal workflow orchestration"""
 
     anthropic: AnthropicSettings | None = None
-    """Settings for using Anthropic models in the MCP Agent application"""
+    """Settings for using Anthropic models in the fast-agent application"""
 
-    cohere: CohereSettings | None = None
-    """Settings for using Cohere models in the MCP Agent application"""
+    otel: OpenTelemetrySettings | None = OpenTelemetrySettings()
+    """OpenTelemetry logging settings for the fast-agent application"""
 
     openai: OpenAISettings | None = None
-    """Settings for using OpenAI models in the MCP Agent application"""
+    """Settings for using OpenAI models in the fast-agent application"""
 
-    otel: OpenTelemetrySettings | None = OpenTelemetrySettings()
-    """OpenTelemetry logging settings for the MCP Agent application"""
+    deepseek: DeepSeekSettings | None = None
+    """Settings for using DeepSeek models in the fast-agent application"""
 
     logger: LoggerSettings | None = LoggerSettings()
-    """Logger settings for the MCP Agent application"""
-
-    usage_telemetry: UsageTelemetrySettings | None = UsageTelemetrySettings()
-    """Usage tracking settings for the MCP Agent application"""
+    """Logger settings for the fast-agent application"""
 
     @classmethod
     def find_config(cls) -> Path | None:

mcp_agent/context.py

@@ -156,7 +156,9 @@ async def configure_executor(config: "Settings"):
         return executor
 
 
-async def initialize_context(config: Optional[Union["Settings", str]] = None, store_globally: bool = False):
+async def initialize_context(
+    config: Optional[Union["Settings", str]] = None, store_globally: bool = False
+):
     """
     Initialize the global application context.
     """

mcp_agent/context_dependent.py

@@ -31,7 +31,9 @@ class ContextDependent:
 
             return get_current_context()
         except Exception as e:
-            raise RuntimeError(f"No context available for {self.__class__.__name__}. Either initialize MCPApp first or pass context explicitly.") from e
+            raise RuntimeError(
+                f"No context available for {self.__class__.__name__}. Either initialize MCPApp first or pass context explicitly."
+            ) from e
 
     @contextmanager
     def use_context(self, context: "Context"):

mcp_agent/core/agent_types.py

@@ -2,9 +2,10 @@
 Type definitions for agents and agent configurations.
 """
 
+import dataclasses
 from dataclasses import dataclass
 from enum import Enum
-from typing import Callable, Dict, List, Optional, Union
+from typing import List
 
 # Forward imports to avoid circular dependencies
 from mcp_agent.core.request_params import RequestParams
@@ -26,18 +27,20 @@ class AgentConfig:
     """Configuration for an Agent instance"""
 
     name: str
-    instruction: Union[str, Callable[[Dict], str]]
-    servers: List[str]
-    model: Optional[str] = None
+    instruction: str = "You are a helpful agent."
+    servers: List[str] = dataclasses.field(default_factory=list)
+    model: str | None = None
     use_history: bool = True
-    default_request_params: Optional[RequestParams] = None
+    default_request_params: RequestParams | None = None
     human_input: bool = False
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         """Ensure default_request_params exists with proper history setting"""
 
         if self.default_request_params is None:
-            self.default_request_params = RequestParams(use_history=self.use_history)
+            self.default_request_params = RequestParams(
+                use_history=self.use_history, systemPrompt=self.instruction
+            )
         else:
             # Override the request params history setting if explicitly configured
             self.default_request_params.use_history = self.use_history

mcp_agent/core/direct_agent_app.py

@@ -0,0 +1,179 @@
+"""
+Direct AgentApp implementation for interacting with agents without proxies.
+"""
+
+from typing import Dict, Optional, Union
+
+from mcp_agent.agents.agent import Agent
+from mcp_agent.core.interactive_prompt import InteractivePrompt
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+
+
+class DirectAgentApp:
+    """
+    Container for active agents that provides a simple API for interacting with them.
+    This implementation works directly with Agent instances without proxies.
+
+    The DirectAgentApp provides both attribute-style access (app.agent_name)
+    and dictionary-style access (app["agent_name"]) to agents.
+
+    It also implements the AgentProtocol interface, automatically forwarding
+    calls to the default agent (the first agent in the container).
+    """
+
+    def __init__(self, agents: Dict[str, Agent]) -> None:
+        """
+        Initialize the DirectAgentApp.
+
+        Args:
+            agents: Dictionary of agent instances keyed by name
+        """
+        self._agents = agents
+
+    def __getitem__(self, key: str) -> Agent:
+        """Allow access to agents using dictionary syntax."""
+        if key not in self._agents:
+            raise KeyError(f"Agent '{key}' not found")
+        return self._agents[key]
+
+    def __getattr__(self, name: str) -> Agent:
+        """Allow access to agents using attribute syntax."""
+        if name in self._agents:
+            return self._agents[name]
+        raise AttributeError(f"Agent '{name}' not found")
+
+    async def __call__(
+        self,
+        message: Union[str, PromptMessageMultipart] | None = None,
+        agent_name: str | None = None,
+        default_prompt: str = "",
+    ) -> str:
+        """
+        Make the object callable to send messages or start interactive prompt.
+        This mirrors the FastAgent implementation that allowed agent("message").
+
+        Args:
+            message: The message to send
+            agent_name: Optional name of the agent to send to (defaults to first agent)
+            default: Default message to use in interactive prompt mode
+
+        Returns:
+            The agent's response as a string or the result of the interactive session
+        """
+        if message:
+            return await self._agent(agent_name).send(message)
+
+        return await self._agent(agent_name).prompt(default_prompt=default_prompt)
+
+    async def send(self, message: str, agent_name: Optional[str] = None) -> str:
+        """
+        Send a message to the specified agent (or to all agents).
+
+        Args:
+            message: The message to send
+            agent_name: Optional name of the agent to send to
+
+        Returns:
+            The agent's response as a string
+        """
+        return await self._agent(agent_name).send(message)
+
+    def _agent(self, agent_name: str | None) -> Agent:
+        if agent_name:
+            if agent_name not in self._agents:
+                raise ValueError(f"Agent '{agent_name}' not found")
+            return self._agents[agent_name]
+
+        return next(iter(self._agents.values()))
+
+    async def apply_prompt(
+        self,
+        prompt_name: str,
+        arguments: Dict[str, str] | None = None,
+        agent_name: str | None = None,
+    ) -> str:
+        """
+        Apply a prompt template to an agent (default agent if not specified).
+
+        Args:
+            prompt_name: Name of the prompt template to apply
+            agent_name: Name of the agent to send to
+            arguments: Optional arguments for the prompt template
+
+        Returns:
+            The agent's response as a string
+        """
+        return await self._agent(agent_name).apply_prompt(prompt_name, arguments)
+
+    async def list_prompts(self, agent_name: str | None = None):
+        """
+        List available prompts for an agent.
+
+        Args:
+            agent_name: Name of the agent to list prompts for
+
+        Returns:
+            Dictionary mapping server names to lists of available prompts
+        """
+        return await self._agent(agent_name).list_prompts()
+
+    async def with_resource(self, user_prompt: str, server_name: str, resource_name: str) -> str:
+        return await self._agent(None).with_resource(
+            prompt_content=user_prompt, server_name=server_name, resource_name=resource_name
+        )
+
+    async def prompt(self, agent_name: Optional[str] = None, default_prompt: str = "") -> str:
+        """
+        Interactive prompt for sending messages with advanced features.
+
+        Args:
+            agent_name: Optional target agent name (uses default if not specified)
+            default: Default message to use when user presses enter
+
+        Returns:
+            The result of the interactive session
+        """
+
+        # Get the default agent name if none specified
+        if agent_name:
+            # Validate that this agent exists
+            if agent_name not in self._agents:
+                raise ValueError(f"Agent '{agent_name}' not found")
+            target_name = agent_name
+        else:
+            # Use the first agent's name as default
+            target_name = next(iter(self._agents.keys()))
+
+        # Don't delegate to the agent's own prompt method - use our implementation
+        # The agent's prompt method doesn't fully support switching between agents
+
+        # Create agent_types dictionary mapping agent names to their types
+        agent_types = {}
+        for name, agent in self._agents.items():
+            # Determine agent type if possible
+            agent_type = "Agent"  # Default type
+
+            # Try to get the type from the agent directly
+            if hasattr(agent, "agent_type"):
+                agent_type = agent.agent_type
+            elif hasattr(agent, "config") and hasattr(agent.config, "agent_type"):
+                agent_type = agent.config.agent_type
+
+            agent_types[name] = agent_type
+
+        # Create the interactive prompt
+        prompt = InteractivePrompt(agent_types=agent_types)
+
+        # Define the wrapper for send function
+        async def send_wrapper(message, agent_name):
+            return await self.send(message, agent_name)
+
+        # Start the prompt loop with the agent name (not the agent object)
+        return await prompt.prompt_loop(
+            send_func=send_wrapper,
+            default_agent=target_name,  # Pass the agent name, not the agent object
+            available_agents=list(self._agents.keys()),
+            apply_prompt_func=self.apply_prompt,
+            list_prompts_func=self.list_prompts,
+            default=default_prompt,
+        )