fast-agent-mcp 0.0.8__py3-none-any.whl → 0.0.11__py3-none-any.whl

mcp_agent/workflows/llm/augmented_llm.py

@@ -238,6 +238,7 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol[MessageParamT, Message
 
         self.model_selector = self.context.model_selector
         self.type_converter = type_converter
+        self.verb = kwargs.get("verb")
 
     @abstractmethod
     async def generate(
@@ -627,8 +628,15 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol[MessageParamT, Message
         self, chat_turn: Optional[int] = None, model: Optional[str] = None
     ):
         """Log a chat progress event"""
+        # Determine action type based on verb
+        if hasattr(self, "verb") and self.verb:
+            # Use verb directly regardless of type
+            act = self.verb
+        else:
+            act = ProgressAction.CHATTING
+
         data = {
-            "progress_action": ProgressAction.CHATTING,
+            "progress_action": act,
             "model": model,
             "agent_name": self.name,
             "chat_turn": chat_turn if chat_turn is not None else None,

mcp_agent/workflows/llm/augmented_llm_anthropic.py

@@ -52,11 +52,12 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
     """
 
     def __init__(self, *args, **kwargs):
-        super().__init__(*args, type_converter=AnthropicMCPTypeConverter, **kwargs)
-
         self.provider = "Anthropic"
-        # Initialize logger with name if available
-        self.logger = get_logger(f"{__name__}.{self.name}" if self.name else __name__)
+        # Initialize logger - keep it simple without name reference
+        self.logger = get_logger(__name__)
+
+        # Now call super().__init__
+        super().__init__(*args, type_converter=AnthropicMCPTypeConverter, **kwargs)
 
     def _initialize_default_params(self, kwargs: dict) -> RequestParams:
         """Initialize Anthropic-specific default parameters"""
@@ -79,25 +80,8 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
         Process a query using an LLM and available tools.
         Override this method to use a different LLM.
         """
-        config = self.context.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.",
-            )
+        api_key = self._api_key(self.context.config)
         try:
             anthropic = Anthropic(api_key=api_key)
             messages: List[MessageParam] = []
@@ -264,6 +248,27 @@ 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_str(
         self,
         message,
@@ -313,7 +318,7 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
 
         # Next we pass the text through instructor to extract structured data
         client = instructor.from_anthropic(
-            Anthropic(api_key=self.context.config.anthropic.api_key),
+            Anthropic(api_key=self._api_key(self.context.config)),
         )
 
         params = self.get_request_params(request_params)

mcp_agent/workflows/llm/model_factory.py

@@ -62,18 +62,23 @@ class ModelFactory:
         "o1-preview": Provider.OPENAI,
         "o3-mini": Provider.OPENAI,
         "claude-3-haiku-20240307": Provider.ANTHROPIC,
+        "claude-3-5-haiku-20241022": Provider.ANTHROPIC,
+        "claude-3-5-haiku-latest": Provider.ANTHROPIC,
         "claude-3-5-sonnet-20240620": Provider.ANTHROPIC,
         "claude-3-5-sonnet-20241022": Provider.ANTHROPIC,
         "claude-3-5-sonnet-latest": Provider.ANTHROPIC,
+        "claude-3-7-sonnet-20250219": Provider.ANTHROPIC,
+        "claude-3-7-sonnet-latest": Provider.ANTHROPIC,
         "claude-3-opus-20240229": Provider.ANTHROPIC,
         "claude-3-opus-latest": Provider.ANTHROPIC,
     }
 
     MODEL_ALIASES = {
-        "sonnet": "claude-3-5-sonnet-latest",
+        "sonnet": "claude-3-7-sonnet-latest",
         "sonnet35": "claude-3-5-sonnet-latest",
+        "sonnet37": "claude-3-7-sonnet-latest",
         "claude": "claude-3-5-sonnet-latest",
-        "haiku": "claude-3-haiku-20240307",
+        "haiku": "claude-3-5-haiku-latest",
         "haiku3": "claude-3-haiku-20240307",
         "opus": "claude-3-opus-latest",
         "opus3": "claude-3-opus-latest",
@@ -161,15 +166,24 @@ class ModelFactory:
                     config.model_name
                 )  # Ensure parsed model name isn't overwritten
 
-            llm = llm_class(
-                agent=agent,
-                model=config.model_name,
-                reasoning_effort=config.reasoning_effort.value
-                if config.reasoning_effort
-                else None,
-                request_params=factory_params,
-                name=kwargs.get("name"),
-            )
+            # Forward all keyword arguments to LLM constructor
+            llm_args = {
+                "agent": agent,
+                "model": config.model_name,
+                "request_params": factory_params,
+                "name": kwargs.get("name"),
+            }
+            
+            # Add reasoning effort if available
+            if config.reasoning_effort:
+                llm_args["reasoning_effort"] = config.reasoning_effort.value
+                
+            # Forward all other kwargs (including verb)
+            for key, value in kwargs.items():
+                if key not in ["agent", "default_request_params", "name"]:
+                    llm_args[key] = value
+                    
+            llm = llm_class(**llm_args)
             return llm
 
         return factory

mcp_agent/workflows/orchestrator/orchestrator.py

@@ -2,9 +2,7 @@
 Orchestrator implementation for MCP Agent applications.
 """
 
-import contextlib
 from typing import (
-    Callable,
     List,
     Literal,
     Optional,
@@ -12,7 +10,8 @@ from typing import (
     TYPE_CHECKING,
 )
 
-from mcp_agent.agents.agent import Agent, AgentConfig
+from mcp_agent.agents.agent import Agent
+from mcp_agent.event_progress import ProgressAction
 from mcp_agent.workflows.llm.augmented_llm import (
     AugmentedLLM,
     MessageParamT,
@@ -20,7 +19,6 @@ from mcp_agent.workflows.llm.augmented_llm import (
     ModelT,
     RequestParams,
 )
-from mcp_agent.workflows.llm.model_factory import ModelFactory
 from mcp_agent.workflows.orchestrator.orchestrator_models import (
     format_plan_result,
     format_step_result,
@@ -47,9 +45,9 @@ logger = get_logger(__name__)
 
 class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
     """
-    In the orchestrator-workers workflow, a central LLM dynamically breaks down tasks,
-    delegates them to worker LLMs, and synthesizes their results. It does this
-    in a loop until the task is complete.
+    In the orchestrator-workers workflow, a central planner LLM dynamically breaks down tasks and
+    delegates them to pre-configured worker LLMs. The planner synthesizes their results in a loop
+    until the task is complete.
 
     When to use this workflow:
         - This workflow is well-suited for complex tasks where you can't predict the
@@ -60,65 +58,76 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
         - Coding products that make complex changes to multiple files each time.
         - Search tasks that involve gathering and analyzing information from multiple sources
         for possible relevant information.
+
+    Note:
+        All agents must be pre-configured with LLMs before being passed to the orchestrator.
+        This ensures consistent model behavior and configuration across all components.
     """
 
     def __init__(
         self,
-        llm_factory: Callable[[Agent], AugmentedLLM[MessageParamT, MessageT]],
-        planner: AugmentedLLM | None = None,
-        available_agents: List[Agent | AugmentedLLM] | None = None,
+        name: str,
+        planner: AugmentedLLM,  # Pre-configured planner
+        available_agents: List[Agent | AugmentedLLM],
         plan_type: Literal["full", "iterative"] = "full",
         context: Optional["Context"] = None,
         **kwargs,
     ):
         """
         Args:
-            llm_factory: Factory function to create an LLM for a given agent
-            planner: LLM to use for planning steps (if not provided, a default planner will be used)
-            plan_type: "full" planning generates the full plan first, then executes. "iterative" plans the next step, and loops until success.
-            available_agents: List of agents available to tasks executed by this orchestrator
+            name: Name of the orchestrator workflow
+            planner: Pre-configured planner LLM to use for planning steps
+            available_agents: List of pre-configured agents available to this orchestrator
+            plan_type: "full" planning generates the full plan first, then executes. "iterative" plans next step and loops.
             context: Application context
         """
+        # Initialize logger early so we can log
+        self.logger = logger
+
+        # Set a fixed verb - always use PLANNING for all orchestrator activities
+        self.verb = ProgressAction.PLANNING
+
         # Initialize with orchestrator-specific defaults
         orchestrator_params = RequestParams(
             use_history=False,  # Orchestrator doesn't support history
             max_iterations=30,  # Higher default for complex tasks
-            maxTokens=8192,  # Higher default for planning TODO this will break some models - make configurable.
+            maxTokens=8192,  # Higher default for planning
             parallel_tool_calls=True,
         )
 
-        # If kwargs contains request_params, merge with our defaults but force use_history False
+        # If kwargs contains request_params, merge our defaults while preserving the model config
         if "request_params" in kwargs:
             base_params = kwargs["request_params"]
-            merged = base_params.model_copy()
-            merged.use_history = False  # Force this setting
+            # Create merged params starting with our defaults
+            merged = orchestrator_params.model_copy()
+            # Update with base params to get model config
+            if isinstance(base_params, dict):
+                merged = merged.model_copy(update=base_params)
+            else:
+                merged = merged.model_copy(update=base_params.model_dump())
+            # Force specific settings
+            merged.use_history = False
             kwargs["request_params"] = merged
         else:
             kwargs["request_params"] = orchestrator_params
 
+        # Pass verb to AugmentedLLM
+        kwargs["verb"] = self.verb
+
         super().__init__(context=context, **kwargs)
 
-        self.llm_factory = llm_factory
-
-        # Create default planner with AgentConfig
-        request_params = self.get_request_params(kwargs.get("request_params"))
-        planner_config = AgentConfig(
-            name="LLM Orchestrator",
-            instruction="""
-            You are an expert planner. Given an objective task and a list of MCP servers (which are collections of tools)
-            or Agents (which are collections of servers), your job is to break down the objective into a series of steps,
-            which can be performed by LLMs with access to the servers or agents.
-            """,
-            servers=[],  # Planner doesn't need direct server access
-            default_request_params=request_params,
-            model=request_params.model if request_params else None,
-        )
+        self.planner = planner
 
-        self.planner = planner or llm_factory(agent=Agent(config=planner_config))
+        if hasattr(self.planner, "verb"):
+            self.planner.verb = self.verb
 
-        self.plan_type: Literal["full", "iterative"] = plan_type
+        self.plan_type = plan_type
         self.server_registry = self.context.server_registry
-        self.agents = {agent.name: agent for agent in available_agents or []}
+        self.agents = {agent.name: agent for agent in available_agents}
+
+        # Initialize logger
+        self.logger = logger
+        self.name = name
 
     async def generate(
         self,
@@ -139,7 +148,7 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
     ) -> str:
         """Request an LLM generation and return the string representation of the result"""
         params = self.get_request_params(request_params)
-
+        # TODO -- properly incorporate this in to message display etc.
         result = await self.generate(
             message=message,
             request_params=params,
@@ -155,25 +164,15 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
     ) -> ModelT:
         """Request a structured LLM generation and return the result as a Pydantic model."""
         params = self.get_request_params(request_params)
-
         result_str = await self.generate_str(message=message, request_params=params)
 
-        structured_config = AgentConfig(
-            name="Structured Output",
-            instruction="Produce a structured output given a message",
-            servers=[],  # No server access needed for structured output
-        )
-
-        llm = self.llm_factory(agent=Agent(config=structured_config))
-
-        structured_result = await llm.generate_structured(
+        # Use AugmentedLLM's structured output handling
+        return await super().generate_structured(
             message=result_str,
             response_model=response_model,
             request_params=params,
         )
 
-        return structured_result
-
     async def execute(
         self, objective: str, request_params: RequestParams | None = None
     ) -> PlanResult:
@@ -182,6 +181,20 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
 
         params = self.get_request_params(request_params)
 
+        # Single progress event for orchestration start
+        model = await self.select_model(params) or "unknown-model"
+
+        # Log the progress with minimal required fields
+        self.logger.info(
+            "Planning task execution",
+            data={
+                "progress_action": self.verb,
+                "model": model,
+                "agent_name": self.name,
+                "target": self.name,
+            },
+        )
+
         plan_result = PlanResult(objective=objective, step_results=[])
 
         while iterations < params.max_iterations:
@@ -212,6 +225,7 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
                         plan_result=format_plan_result(plan_result)
                     )
 
+                    # Use planner directly - planner already has PLANNING verb
                     plan_result.result = await self.planner.generate_str(
                         message=synthesis_prompt,
                         request_params=params.model_copy(update={"max_iterations": 1}),
@@ -233,8 +247,6 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
 
                 plan_result.add_step_result(step_result)
 
-                plan_result.add_step_result(step_result)
-
             logger.debug(
                 f"Iteration {iterations}: Intermediate plan result:", data=plan_result
             )
@@ -251,70 +263,62 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
         request_params: RequestParams | None = None,
     ) -> StepResult:
         """Execute a step's subtasks in parallel and synthesize results"""
-        params = self.get_request_params(request_params)
 
         step_result = StepResult(step=step, task_results=[])
         context = format_plan_result(previous_result)
 
-        # Prepare tasks and LLMs
-        task_llms = []
-        async with contextlib.AsyncExitStack() as stack:
-            for task in step.tasks:
-                agent = self.agents.get(task.agent)
-                if not agent:
-                    raise ValueError(f"No agent found matching {task.agent}")
+        # Execute tasks
+        futures = []
+        error_tasks = []
 
-                if isinstance(agent, AugmentedLLM):
-                    llm = agent
-                else:
-                    # Use existing LLM if agent has one
-                    if hasattr(agent, "_llm") and agent._llm:
-                        llm = agent._llm
-                    else:
-                        # Only create new context if needed
-                        ctx_agent = await stack.enter_async_context(agent)
-                        # Create factory with agent's own configuration
-                        agent_factory = ModelFactory.create_factory(
-                            model_string=agent.config.model,
-                            request_params=agent.config.default_request_params,
-                        )
-                        llm = await ctx_agent.attach_llm(agent_factory)
-
-                task_llms.append((task, llm))
-
-            # Execute all tasks within the same context
-            futures = []
-            for task, llm in task_llms:
-                task_description = TASK_PROMPT_TEMPLATE.format(
-                    objective=previous_result.objective,
-                    task=task.description,
-                    context=context,
+        for task in step.tasks:
+            agent = self.agents.get(task.agent)
+            if not agent:
+                # Instead of failing the entire step, track this as an error task
+                self.logger.error(
+                    f"No agent found matching '{task.agent}'. Available agents: {list(self.agents.keys())}"
                 )
-                # Get the agent's config for task execution
-                agent = self.agents.get(task.agent)
-                task_params = (
-                    agent.config.default_request_params
-                    if hasattr(agent, "config")
-                    else params
-                )
-                futures.append(
-                    llm.generate_str(
-                        message=task_description, request_params=task_params
+                error_tasks.append(
+                    (
+                        task,
+                        f"Error: Agent '{task.agent}' not found. Available agents: {', '.join(self.agents.keys())}",
                     )
                 )
+                continue
+
+            task_description = TASK_PROMPT_TEMPLATE.format(
+                objective=previous_result.objective,
+                task=task.description,
+                context=context,
+            )
 
-            # Wait for all tasks, including any tool calls they make
-            results = await self.executor.execute(*futures)
+            # All agents should now be LLM-capable
+            futures.append(agent._llm.generate_str(message=task_description))
 
-            # Process results while contexts are still active
-            for (task, _), result in zip(task_llms, results):
+        # Wait for all tasks (only if we have valid futures)
+        results = await self.executor.execute(*futures) if futures else []
+
+        # Process successful results
+        task_index = 0
+        for task in step.tasks:
+            # Skip tasks that had agent errors (they're in error_tasks)
+            if any(et[0] == task for et in error_tasks):
+                continue
+
+            if task_index < len(results):
+                result = results[task_index]
                 step_result.add_task_result(
                     TaskWithResult(**task.model_dump(), result=str(result))
                 )
+                task_index += 1
 
-            # Format final result while contexts are still active
-            step_result.result = format_step_result(step_result)
+        # Add error task results
+        for task, error_message in error_tasks:
+            step_result.add_task_result(
+                TaskWithResult(**task.model_dump(), result=error_message)
+            )
 
+        step_result.result = format_step_result(step_result)
         return step_result
 
     async def _get_full_plan(
@@ -340,6 +344,7 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
             agents=agents,
         )
 
+        # Use planner directly - no verb manipulation needed
         plan = await self.planner.generate_structured(
             message=prompt,
             response_model=Plan,
@@ -371,6 +376,7 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
             agents=agents,
         )
 
+        # Use planner directly - no verb manipulation needed
         next_step = await self.planner.generate_structured(
             message=prompt,
             response_model=NextStep,

mcp_agent/workflows/orchestrator/orchestrator_prompts.py

@@ -30,12 +30,15 @@ and Agents (which are collections of servers):
 Agents:
 {agents}
 
+IMPORTANT: You can ONLY use the agents listed above. Do not invent or reference agents that are not in the list.
+The plan will fail if you reference agents that are not available.
+
 Generate a plan with all remaining steps needed.
 Steps are sequential, but each Step can have parallel subtasks.
 For each Step, specify a description of the step and independent subtasks that can run in parallel.
 For each subtask specify:
     1. Clear description of the task that an LLM can execute  
-    2. Name of 1 Agent OR List of MCP server names to use for the task
+    2. Name of 1 Agent from the available agents list above
     
 Return your response in the following JSON structure:
     {{
@@ -45,11 +48,11 @@ Return your response in the following JSON structure:
                 "tasks": [
                     {{
                         "description": "Description of task 1",
-                        "agent": "agent_name"  # For AgentTask
+                        "agent": "agent_name"  # For AgentTask - MUST be one of the available agents
                     }},
                     {{
                         "description": "Description of task 2", 
-                        "agent": "agent_name2"
+                        "agent": "agent_name2"  # MUST be one of the available agents
                     }}
                 ]
             }}
@@ -79,19 +82,21 @@ and Agents (which are collections of servers):
 Agents:
 {agents}
 
+IMPORTANT: You can ONLY use the agents listed above. Do not invent or reference agents that are not in the list.
+The plan will fail if you reference agents that are not available.
+
 Generate the next step, by specifying a description of the step and independent subtasks that can run in parallel:
 For each subtask specify:
     1. Clear description of the task that an LLM can execute  
-    2. Name of 1 Agent OR List of MCP server names to use for the task
+    2. Name of 1 Agent from the available agents list above
 
 Return your response in the following JSON structure:
     {{
-    
         "description": "Description of step 1",
         "tasks": [
             {{
                 "description": "Description of task 1",
-                "agent": "agent_name"  # For AgentTask
+                "agent": "agent_name"  # For AgentTask - MUST be one of the available agents
             }}
         ],
         "is_complete": false

mcp_agent/workflows/router/router_llm.py

@@ -6,6 +6,7 @@ from mcp_agent.agents.agent import Agent
 from mcp_agent.workflows.llm.augmented_llm import AugmentedLLM, RequestParams
 from mcp_agent.workflows.router.router_base import ResultT, Router, RouterResult
 from mcp_agent.logging.logger import get_logger
+from mcp_agent.event_progress import ProgressAction
 
 if TYPE_CHECKING:
     from mcp_agent.context import Context
@@ -100,6 +101,9 @@ class LLMRouter(Router):
         default_request_params: Optional[RequestParams] = None,
         **kwargs,
     ):
+        # Extract verb from kwargs to avoid passing it up the inheritance chain
+        self._llm_verb = kwargs.pop("verb", None)
+
         super().__init__(
             server_names=server_names,
             agents=agents,
@@ -161,10 +165,18 @@ class LLMRouter(Router):
                 router_params = RequestParams(**params_dict)
             # Set up router-specific request params with routing instruction
             router_params.use_history = False
+            # Use the stored verb if available, otherwise default to ROUTING
+            verb_param = (
+                self._llm_verb
+                if hasattr(self, "_llm_verb") and self._llm_verb
+                else ProgressAction.ROUTING
+            )
+
             self.llm = self.llm_factory(
                 agent=None,  # Router doesn't need an agent context
-                name="LLM Router",
+                name=self.name,  # Use the name provided during initialization
                 default_request_params=router_params,
+                verb=verb_param,  # Use stored verb parameter or default to ROUTING
             )
             self.initialized = True
 
@@ -243,7 +255,6 @@ class LLMRouter(Router):
             context=context, request=request, top_k=top_k
         )
 
-        # Get routes from LLM
         response = await self.llm.generate_structured(
             message=prompt,
             response_model=StructuredResponse,