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

mcp_agent/agents/workflow/router_agent.py

@@ -5,9 +5,8 @@ This provides a simplified implementation that routes messages to agents
 by determining the best agent for a request and dispatching to it.
 """
 
-from typing import TYPE_CHECKING, List, Optional, Tuple, Type
+from typing import TYPE_CHECKING, Callable, List, Optional, Tuple, Type
 
-from mcp.types import TextContent
 from pydantic import BaseModel
 
 from mcp_agent.agents.agent import Agent
@@ -17,10 +16,12 @@ from mcp_agent.core.exceptions import AgentConfigError
 from mcp_agent.core.prompt import Prompt
 from mcp_agent.core.request_params import RequestParams
 from mcp_agent.logging.logger import get_logger
-from mcp_agent.mcp.interfaces import ModelT
+from mcp_agent.mcp.interfaces import AugmentedLLMProtocol, ModelT
 from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 
 if TYPE_CHECKING:
+    from a2a_types.types import AgentCard
+
     from mcp_agent.context import Context
 
 logger = get_logger(__name__)
@@ -36,47 +37,17 @@ Follow these guidelines:
 - Provide your confidence level (high, medium, low) and brief reasoning for your selection
 """
 
-# Default routing instruction with placeholders for context and request
+# Default routing instruction with placeholders for context (AgentCard JSON)
 DEFAULT_ROUTING_INSTRUCTION = """
-You are a highly accurate request router that directs incoming requests to the most appropriate agent.
-
-<fastagent:data>
+Select from the following agents to handle the request:
 <fastagent:agents>
+[
 {context}
+]
 </fastagent:agents>
 
-<fastagent:request>
-{request}
-</fastagent:request>
-</fastagent:data>
-
-Your task is to analyze the request and determine the most appropriate agent from the options above.
-
-<fastagent:instruction>
-Respond with JSON following the schema below:
-{{
-    "type": "object",
-    "required": ["agent", "confidence", "reasoning"],
-    "properties": {{
-        "agent": {{
-            "type": "string",
-            "description": "The exact name of the selected agent"
-        }},
-        "confidence": {{
-            "type": "string",
-            "enum": ["high", "medium", "low"],
-            "description": "Your confidence level in this selection"
-        }},
-        "reasoning": {{
-            "type": "string",
-            "description": "Brief explanation for your selection"
-        }}
-    }}
-}}
-
-Supply only the JSON with no preamble. Use "reasoning" field to describe actions. NEVER EMIT CODE FENCES. 
-
-</fastagent:instruction>
+You must respond with the 'name' of one of the agents listed above.
+
 """
 
 
@@ -85,18 +56,7 @@ class RoutingResponse(BaseModel):
 
     agent: str
     confidence: str
-    reasoning: Optional[str] = None
-
-
-class RouterResult(BaseModel):
-    """Router result with agent reference and confidence rating."""
-
-    result: BaseAgent
-    confidence: str
-    reasoning: Optional[str] = None
-
-    # Allow Agent objects to be stored without serialization
-    model_config = {"arbitrary_types_allowed": True}
+    reasoning: str | None = None
 
 
 class RouterAgent(BaseAgent):
@@ -142,9 +102,7 @@ class RouterAgent(BaseAgent):
         # Set up base router request parameters
         base_params = {"systemPrompt": ROUTING_SYSTEM_INSTRUCTION, "use_history": False}
 
-        # Merge with provided defaults if any
         if default_request_params:
-            # Start with defaults and override with router-specific settings
             merged_params = default_request_params.model_copy(update=base_params)
         else:
             merged_params = RequestParams(**base_params)
@@ -174,32 +132,16 @@ class RouterAgent(BaseAgent):
             except Exception as e:
                 logger.warning(f"Error shutting down agent: {str(e)}")
 
-    async def _get_routing_result(
+    async def attach_llm(
         self,
-        messages: List[PromptMessageMultipart],
-    ) -> Optional[RouterResult]:
-        """
-        Common method to extract request and get routing result.
-
-        Args:
-            messages: The messages to extract request from
-
-        Returns:
-            RouterResult containing the selected agent, or None if no suitable agent found
-        """
-        if not self.initialized:
-            await self.initialize()
-
-        # Extract the request text from the last message
-        request = messages[-1].all_text() if messages else ""
-
-        # Determine which agent to route to
-        routing_result = await self._route_request(request)
-
-        if not routing_result:
-            logger.warning("Could not determine appropriate agent for this request")
-
-        return routing_result
+        llm_factory: type[AugmentedLLMProtocol] | Callable[..., AugmentedLLMProtocol],
+        model: str | None = None,
+        request_params: RequestParams | None = None,
+        **additional_kwargs,
+    ) -> AugmentedLLMProtocol:
+        return await super().attach_llm(
+            llm_factory, model, request_params, verb="Routing", **additional_kwargs
+        )
 
     async def generate(
         self,
@@ -216,32 +158,21 @@ class RouterAgent(BaseAgent):
         Returns:
             The response from the selected agent
         """
-        routing_result = await self._get_routing_result(multipart_messages)
-
-        if not routing_result:
-            return PromptMessageMultipart(
-                role="assistant",
-                content=[
-                    TextContent(
-                        type="text", text="Could not determine appropriate agent for this request."
-                    )
-                ],
-            )
 
-        # Get the selected agent
-        selected_agent = routing_result.result
+        route, warn = await self._route_request(multipart_messages[-1])
 
-        # Log the routing decision
-        logger.info(
-            f"Routing request to agent: {selected_agent.name} (confidence: {routing_result.confidence})"
-        )
+        if not route:
+            return Prompt.assistant(warn or "No routing result or warning received")
+
+        # Get the selected agent
+        agent: Agent = self.agent_map[route.agent]
 
         # Dispatch the request to the selected agent
-        return await selected_agent.generate(multipart_messages, request_params)
+        return await agent.generate(multipart_messages, request_params)
 
     async def structured(
         self,
-        prompt: List[PromptMessageMultipart],
+        multipart_messages: List[PromptMessageMultipart],
         model: Type[ModelT],
         request_params: Optional[RequestParams] = None,
     ) -> Tuple[ModelT | None, PromptMessageMultipart]:
@@ -256,23 +187,22 @@ class RouterAgent(BaseAgent):
         Returns:
             The parsed response from the selected agent, or None if parsing fails
         """
-        routing_result = await self._get_routing_result(prompt)
+        route, warn = await self._route_request(multipart_messages[-1])
 
-        if not routing_result:
-            return None, Prompt.assistant("No routing result")
+        if not route:
+            return None, Prompt.assistant(
+                warn or "No routing result or warning received (structured)"
+            )
 
         # Get the selected agent
-        selected_agent = routing_result.result
-
-        # Log the routing decision
-        logger.info(
-            f"Routing structured request to agent: {selected_agent.name} (confidence: {routing_result.confidence})"
-        )
+        agent: Agent = self.agent_map[route.agent]
 
         # Dispatch the request to the selected agent
-        return await selected_agent.structured(prompt, model, request_params)
+        return await agent.structured(multipart_messages, model, request_params)
 
-    async def _route_request(self, request: str) -> Optional[RouterResult]:
+    async def _route_request(
+        self, message: PromptMessageMultipart
+    ) -> Tuple[RoutingResponse | None, str | None]:
         """
         Determine which agent to route the request to.
 
@@ -283,49 +213,53 @@ class RouterAgent(BaseAgent):
             RouterResult containing the selected agent, or None if no suitable agent was found
         """
         if not self.agents:
-            logger.warning("No agents available for routing")
-            return None
+            logger.error("No agents available for routing")
+            raise AgentConfigError("No agents available for routing - fatal error")
 
         # If only one agent is available, use it directly
         if len(self.agents) == 1:
-            return RouterResult(
-                result=self.agents[0], confidence="high", reasoning="Only one agent available"
-            )
+            return RoutingResponse(
+                agent=self.agents[0].name, confidence="high", reasoning="Only one agent available"
+            ), None
 
         # Generate agent descriptions for the context
         agent_descriptions = []
-        for i, agent in enumerate(self.agents, 1):
-            description = agent.instruction if isinstance(agent.instruction, str) else ""
-            agent_descriptions.append(f"{i}. Name: {agent.name} - {description}")
+        for agent in self.agents:
+            agent_card: AgentCard = await agent.agent_card()
+            agent_descriptions.append(
+                agent_card.model_dump_json(
+                    include={"name", "description", "skills"}, exclude_none=True
+                )
+            )
 
-        context = "\n\n".join(agent_descriptions)
+        context = ",\n".join(agent_descriptions)
 
         # Format the routing prompt
         routing_instruction = self.routing_instruction or DEFAULT_ROUTING_INSTRUCTION
-        prompt_text = routing_instruction.format(context=context, request=request)
-
-        # Create multipart message for the router
-        prompt = PromptMessageMultipart(
-            role="user", content=[TextContent(type="text", text=prompt_text)]
-        )
+        routing_instruction = routing_instruction.format(context=context)
 
-        # Get structured response from LLM
         assert self._llm
+        mutated = message.model_copy(deep=True)
+        mutated.add_text(routing_instruction)
         response, _ = await self._llm.structured(
-            [prompt], RoutingResponse, self._default_request_params
+            [mutated],
+            RoutingResponse,
+            self._default_request_params,
         )
 
+        warn: str | None = None
         if not response:
-            logger.warning("No routing response received from LLM")
-            return None
+            warn = "No routing response received from LLM"
+        elif response.agent not in self.agent_map:
+            warn = f"A response was received, but the agent {response.agent} was not known to the Router"
 
-        # Look up the agent by name
-        selected_agent = self.agent_map.get(response.agent)
-
-        if not selected_agent:
-            logger.warning(f"Agent '{response.agent}' not found in available agents")
-            return None
+        if warn:
+            logger.warning(warn)
+            return None, warn
+        else:
+            assert response
+            logger.info(
+                f"Routing structured request to agent: {response.agent or 'error'} (confidence: {response.confidence or ''})"
+            )
 
-        return RouterResult(
-            result=selected_agent, confidence=response.confidence, reasoning=response.reasoning
-        )
+            return response, None

mcp_agent/app.py

@@ -1,7 +1,6 @@
 import asyncio
 from contextlib import asynccontextmanager
-from datetime import timedelta
-from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Type, TypeVar
+from typing import TYPE_CHECKING, Dict, Optional, Type, TypeVar
 
 from mcp_agent.config import Settings
 from mcp_agent.context import Context, cleanup_context, initialize_context
@@ -174,125 +173,3 @@ class MCPApp:
             yield self
         finally:
             await self.cleanup()
-
-    def workflow(self, cls: Type, *args, workflow_id: str | None = None, **kwargs) -> Type:
-        """
-        Decorator for a workflow class. By default it's a no-op,
-        but different executors can use this to customize behavior
-        for workflow registration.
-
-        Example:
-            If Temporal is available & we use a TemporalExecutor,
-            this decorator will wrap with temporal_workflow.defn.
-        """
-        decorator_registry = self.context.decorator_registry
-        execution_engine = self.engine
-        workflow_defn_decorator = decorator_registry.get_workflow_defn_decorator(execution_engine)
-
-        if workflow_defn_decorator:
-            return workflow_defn_decorator(cls, *args, **kwargs)
-
-        cls._app = self
-        self._workflows[workflow_id or cls.__name__] = cls
-
-        # Default no-op
-        return cls
-
-    def workflow_run(self, fn: Callable[..., R]) -> Callable[..., R]:
-        """
-        Decorator for a workflow's main 'run' method.
-        Different executors can use this to customize behavior for workflow execution.
-
-        Example:
-            If Temporal is in use, this gets converted to @workflow.run.
-        """
-
-        decorator_registry = self.context.decorator_registry
-        execution_engine = self.engine
-        workflow_run_decorator = decorator_registry.get_workflow_run_decorator(execution_engine)
-
-        if workflow_run_decorator:
-            return workflow_run_decorator(fn)
-
-        # Default no-op
-        def wrapper(*args, **kwargs):
-            # no-op wrapper
-            return fn(*args, **kwargs)
-
-        return wrapper
-
-    def workflow_task(
-        self,
-        name: str | None = None,
-        schedule_to_close_timeout: timedelta | None = None,
-        retry_policy: Dict[str, Any] | None = None,
-        **kwargs: Any,
-    ) -> Callable[[Callable[..., R]], Callable[..., R]]:
-        """
-        Decorator to mark a function as a workflow task,
-        automatically registering it in the global activity registry.
-
-        Args:
-            name: Optional custom name for the activity
-            schedule_to_close_timeout: Maximum time the task can take to complete
-            retry_policy: Retry policy configuration
-            **kwargs: Additional metadata passed to the activity registration
-
-        Returns:
-            Decorated function that preserves async and typing information
-
-        Raises:
-            TypeError: If the decorated function is not async
-            ValueError: If the retry policy or timeout is invalid
-        """
-
-        def decorator(func: Callable[..., R]) -> Callable[..., R]:
-            if not asyncio.iscoroutinefunction(func):
-                raise TypeError(f"Function {func.__name__} must be async.")
-
-            actual_name = name or f"{func.__module__}.{func.__qualname__}"
-            timeout = schedule_to_close_timeout or timedelta(minutes=10)
-            metadata = {
-                "activity_name": actual_name,
-                "schedule_to_close_timeout": timeout,
-                "retry_policy": retry_policy or {},
-                **kwargs,
-            }
-            activity_registry = self.context.task_registry
-            activity_registry.register(actual_name, func, metadata)
-
-            setattr(func, "is_workflow_task", True)
-            setattr(func, "execution_metadata", metadata)
-
-            # TODO: saqadri - determine if we need this
-            # Preserve metadata through partial application
-            # @functools.wraps(func)
-            # async def wrapper(*args: Any, **kwargs: Any) -> R:
-            #     result = await func(*args, **kwargs)
-            #     return cast(R, result)  # Ensure type checking works
-
-            # # Add metadata that survives partial application
-            # wrapper.is_workflow_task = True  # type: ignore
-            # wrapper.execution_metadata = metadata  # type: ignore
-
-            # # Make metadata accessible through partial
-            # def __getattr__(name: str) -> Any:
-            #     if name == "is_workflow_task":
-            #         return True
-            #     if name == "execution_metadata":
-            #         return metadata
-            #     raise AttributeError(f"'{func.__name__}' has no attribute '{name}'")
-
-            # wrapper.__getattr__ = __getattr__  # type: ignore
-
-            # return wrapper
-
-            return func
-
-        return decorator
-
-    def is_workflow_task(self, func: Callable[..., Any]) -> bool:
-        """
-        Check if a function is marked as a workflow task.
-        This gets set for functions that are decorated with @workflow_task."""
-        return bool(getattr(func, "is_workflow_task", False))

mcp_agent/cli/commands/setup.py

@@ -15,7 +15,7 @@ FASTAGENT_CONFIG_TEMPLATE = """
 # Takes format:
 #   <provider>.<model_string>.<reasoning_effort?> (e.g. anthropic.claude-3-5-sonnet-20241022 or openai.o3-mini.low)
 # Accepts aliases for Anthropic Models: haiku, haiku3, sonnet, sonnet35, opus, opus3
-# and OpenAI Models: gpt-4o-mini, gpt-4o, o1, o1-mini, o3-mini
+# and OpenAI Models: gpt-4.1, gpt-4.1-mini, o1, o1-mini, o3-mini
 #
 # If not specified, defaults to "haiku". 
 # Can be overriden with a command line switch --model=<model>, or within the Agent constructor.

mcp_agent/config.py

@@ -139,40 +139,42 @@ class DeepSeekSettings(BaseModel):
     model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
 
 
-class GenericSettings(BaseModel):
+class GoogleSettings(BaseModel):
     """
     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 OpenRouterSettings(BaseModel):
+class GenericSettings(BaseModel):
     """
-    Settings for using OpenRouter models via its OpenAI-compatible API.
+    Settings for using OpenAI models in the fast-agent application.
     """
 
     api_key: str | None = None
 
-    base_url: str | None = None  # Optional override, defaults handled in provider
+    base_url: str | None = None
 
     model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
 
 
-class TemporalSettings(BaseModel):
+class OpenRouterSettings(BaseModel):
     """
-    Temporal settings for the fast-agent application.
+    Settings for using OpenRouter models via its OpenAI-compatible API.
     """
 
-    host: str
-    namespace: str = "default"
-    task_queue: str
     api_key: str | None = None
 
+    base_url: str | None = None  # Optional override, defaults handled in provider
+
+    model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
+
 
 class OpenTelemetrySettings(BaseModel):
     """
@@ -254,16 +256,14 @@ class Settings(BaseSettings):
     mcp: MCPSettings | None = MCPSettings()
     """MCP config, such as MCP servers"""
 
-    execution_engine: Literal["asyncio", "temporal"] = "asyncio"
+    execution_engine: Literal["asyncio"] = "asyncio"
     """Execution engine for the fast-agent application"""
 
     default_model: str | None = "haiku"
     """
     Default model for agents. Format is provider.model_name.<reasoning_effort>, for example openai.o3-mini.low
-    Aliases are provided for common models e.g. sonnet, haiku, gpt-4o, o3-mini etc.
+    Aliases are provided for common models e.g. sonnet, haiku, gpt-4.1, o3-mini etc.
     """
-    temporal: TemporalSettings | None = None
-    """Settings for Temporal workflow orchestration"""
 
     anthropic: AnthropicSettings | None = None
     """Settings for using Anthropic models in the fast-agent application"""
@@ -277,6 +277,9 @@ class Settings(BaseSettings):
     deepseek: DeepSeekSettings | None = None
     """Settings for using DeepSeek models in the fast-agent application"""
 
+    google: GoogleSettings | None = None
+    """Settings for using DeepSeek models in the fast-agent application"""
+
     openrouter: OpenRouterSettings | None = None
     """Settings for using OpenRouter models in the fast-agent application"""
 

mcp_agent/context.py

@@ -17,10 +17,6 @@ from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapProp
 from pydantic import BaseModel, ConfigDict
 
 from mcp_agent.config import Settings, get_settings
-from mcp_agent.executor.decorator_registry import (
-    DecoratorRegistry,
-    register_asyncio_decorators,
-)
 from mcp_agent.executor.executor import AsyncioExecutor, Executor
 from mcp_agent.executor.task_registry import ActivityRegistry
 from mcp_agent.logging.events import EventFilter
@@ -54,7 +50,6 @@ class Context(BaseModel):
     # Registries
     server_registry: Optional[ServerRegistry] = None
     task_registry: Optional[ActivityRegistry] = None
-    decorator_registry: Optional[DecoratorRegistry] = None
 
     tracer: Optional[trace.Tracer] = None
 
@@ -142,18 +137,7 @@ async def configure_executor(config: "Settings"):
     """
     Configure the executor based on the application config.
     """
-    if config.execution_engine == "asyncio":
-        return AsyncioExecutor()
-    elif config.execution_engine == "temporal":
-        # Configure Temporal executor
-        from mcp_agent.executor.temporal import TemporalExecutor
-
-        executor = TemporalExecutor(config=config.temporal)
-        return executor
-    else:
-        # Default to asyncio executor
-        executor = AsyncioExecutor()
-        return executor
+    return AsyncioExecutor()
 
 
 async def initialize_context(
@@ -180,11 +164,9 @@ async def initialize_context(
     context.executor = await configure_executor(config)
     context.task_registry = ActivityRegistry()
 
-    context.decorator_registry = DecoratorRegistry()
-    register_asyncio_decorators(context.decorator_registry)
-
     # Store the tracer in context if needed
-    context.tracer = trace.get_tracer(config.otel.service_name)
+    if config.otel:
+        context.tracer = trace.get_tracer(config.otel.service_name)
 
     if store_globally:
         global _global_context
@@ -234,7 +216,7 @@ def get_current_context() -> Context:
 def get_current_config():
     """
     Get the current application config.
-    
+
     Returns the context config if available, otherwise falls back to global settings.
     """
     return get_current_context().config or get_settings()

mcp_agent/core/agent_types.py

@@ -34,8 +34,8 @@ class AgentConfig(BaseModel):
     human_input: bool = False
     agent_type: AgentType = AgentType.BASIC
 
-    @model_validator(mode='after')
-    def ensure_default_request_params(self) -> 'AgentConfig':
+    @model_validator(mode="after")
+    def ensure_default_request_params(self) -> "AgentConfig":
         """Ensure default_request_params exists with proper history setting"""
         if self.default_request_params is None:
             self.default_request_params = RequestParams(

mcp_agent/core/direct_decorators.py

@@ -224,7 +224,7 @@ def orchestrator(
     use_history: bool = False,
     human_input: bool = False,
     plan_type: Literal["full", "iterative"] = "full",
-    max_iterations: int = 30,
+    plan_iterations: int = 5,
 ) -> Callable[[AgentCallable[P, R]], DecoratedOrchestratorProtocol[P, R]]:
     """
     Decorator to create and register an orchestrator agent with type-safe signature.
@@ -260,7 +260,7 @@ def orchestrator(
             human_input=human_input,
             child_agents=agents,
             plan_type=plan_type,
-            max_iterations=max_iterations,
+            plan_iterations=plan_iterations,
         ),
     )
 

mcp_agent/core/direct_factory.py

@@ -138,7 +138,7 @@ async def create_agents_by_type(
             # Get common configuration
             config = agent_data["config"]
 
-                # Type-specific initialization based on the Enum type
+            # Type-specific initialization based on the Enum type
             # Note: Above we compared string values from config, here we compare Enum objects directly
             if agent_type == AgentType.BASIC:
                 # Create a basic agent
@@ -175,6 +175,7 @@ async def create_agents_by_type(
                     config=config,
                     context=app_instance.context,
                     agents=child_agents,
+                    plan_iterations=agent_data.get("plan_iterations", 5),
                     plan_type=agent_data.get("plan_type", "full"),
                 )
 

mcp_agent/core/fastagent.py

@@ -381,7 +381,7 @@ class FastAgent:
             handle_error(
                 e,
                 "Model Configuration Error",
-                "Common models: gpt-4o, o3-mini, sonnet, haiku. for o3, set reasoning effort with o3-mini.high",
+                "Common models: gpt-4.1, o3-mini, sonnet, haiku. for o3, set reasoning effort with o3-mini.high",
             )
         elif isinstance(e, CircularDependencyError):
             handle_error(

mcp_agent/core/request_params.py

@@ -2,7 +2,7 @@
 Request parameters definitions for LLM interactions.
 """
 
-from typing import List
+from typing import Any, List
 
 from mcp import SamplingMessage
 from mcp.types import CreateMessageRequestParams
@@ -44,3 +44,7 @@ class RequestParams(CreateMessageRequestParams):
     Whether to allow multiple tool calls per iteration.
     Also known as multi-step tool use.
     """
+    response_format: Any | None = None
+    """
+    Override response format for structured calls. Prefer sending pydantic model - only use in exceptional circumstances
+    """