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

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

@@ -11,6 +11,7 @@ from typing import (
 )
 
 from mcp_agent.agents.agent import Agent
+from mcp_agent.event_progress import ProgressAction
 from mcp_agent.workflows.llm.augmented_llm import (
     AugmentedLLM,
     MessageParamT,
@@ -80,6 +81,12 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
             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
@@ -104,13 +111,24 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
         else:
             kwargs["request_params"] = orchestrator_params
 
+        # Pass verb to AugmentedLLM
+        kwargs["verb"] = self.verb
+
         super().__init__(context=context, **kwargs)
 
         self.planner = planner
+
+        if hasattr(self.planner, "verb"):
+            self.planner.verb = self.verb
+
         self.plan_type = plan_type
         self.server_registry = self.context.server_registry
         self.agents = {agent.name: agent for agent in available_agents}
 
+        # Initialize logger
+        self.logger = logger
+        self.name = name
+
     async def generate(
         self,
         message: str | MessageParamT | List[MessageParamT],
@@ -130,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,
@@ -163,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:
@@ -193,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}),
@@ -236,10 +269,22 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
 
         # Execute tasks
         futures = []
+        error_tasks = []
+
         for task in step.tasks:
             agent = self.agents.get(task.agent)
             if not agent:
-                raise ValueError(f"No agent found matching {task.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())}"
+                )
+                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,
@@ -250,13 +295,27 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
             # All agents should now be LLM-capable
             futures.append(agent._llm.generate_str(message=task_description))
 
-        # Wait for all tasks
-        results = await self.executor.execute(*futures)
+        # 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
 
-        # Process results
-        for task, result in zip(step.tasks, results):
+        # Add error task results
+        for task, error_message in error_tasks:
             step_result.add_task_result(
-                TaskWithResult(**task.model_dump(), result=str(result))
+                TaskWithResult(**task.model_dump(), result=error_message)
             )
 
         step_result.result = format_step_result(step_result)
@@ -285,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,
@@ -316,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,

mcp_agent/resources/examples/workflows/fastagent.config.yaml

@@ -1,9 +0,0 @@
-default_model: sonnet
-mcp:
-    servers:
-        fetch:
-            command: "uvx"
-            args: ["mcp-server-fetch"]
-        filesystem:
-            command: "npx"
-            args: ["@modelcontextprotocol/server-filesystem","."]