fast-agent-mcp 0.0.16__py3-none-any.whl → 0.1.1__py3-none-any.whl

mcp_agent/workflows/orchestrator/orchestrator.py

@@ -32,6 +32,7 @@ from mcp_agent.workflows.orchestrator.orchestrator_models import (
 from mcp_agent.workflows.orchestrator.orchestrator_prompts import (
     FULL_PLAN_PROMPT_TEMPLATE,
     ITERATIVE_PLAN_PROMPT_TEMPLATE,
+    SYNTHESIZE_INCOMPLETE_PLAN_TEMPLATE,  # Add the missing import
     SYNTHESIZE_PLAN_PROMPT_TEMPLATE,
     TASK_PROMPT_TEMPLATE,
 )
@@ -90,7 +91,7 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
         # Initialize with orchestrator-specific defaults
         orchestrator_params = RequestParams(
             use_history=False,  # Orchestrator doesn't support history
-            max_iterations=30,  # Higher default for complex tasks
+            max_iterations=10,  # Higher default for complex tasks
             maxTokens=8192,  # Higher default for planning
             parallel_tool_calls=True,
         )
@@ -126,9 +127,29 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
         self.agents = {agent.name: agent for agent in available_agents}
 
         # Initialize logger
-        self.logger = logger
         self.name = name
 
+        # Store agents by name - COMPLETE REWRITE OF AGENT STORAGE
+        self.agents = {}
+        for agent in available_agents:
+            # Fix: Remove all special handling of agent names and store them exactly as they are
+            agent_name = agent.name
+
+            # Verify if the name is actually "None" (string) or None (NoneType)
+            if agent_name == "None":
+                # Try to get a better name from config if available
+                if hasattr(agent, "config") and agent.config and agent.config.name:
+                    agent_name = agent.config.name
+            elif agent_name is None:
+                # Try to get a better name from config if available
+                if hasattr(agent, "config") and agent.config and agent.config.name:
+                    agent_name = agent.config.name
+                else:
+                    agent_name = f"unnamed_agent_{len(self.agents)}"
+
+            self.logger.info(f"Adding agent '{agent_name}' to orchestrator")
+            self.agents[agent_name] = agent
+
     async def generate(
         self,
         message: str | MessageParamT | List[MessageParamT],
@@ -165,19 +186,21 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
         """Request a structured LLM generation and return the result as a Pydantic model."""
         import json
         from pydantic import ValidationError
-        
+
         params = self.get_request_params(request_params)
         result_str = await self.generate_str(message=message, request_params=params)
-        
+
         try:
             # Directly parse JSON and create model instance
             parsed_data = json.loads(result_str)
             return response_model(**parsed_data)
         except (json.JSONDecodeError, ValidationError) as e:
             # Log the error and fall back to the original method if direct parsing fails
-            self.logger.error(f"Direct JSON parsing failed: {str(e)}. Falling back to standard method.")
+            self.logger.error(
+                f"Direct JSON parsing failed: {str(e)}. Falling back to standard method."
+            )
             self.logger.debug(f"Failed JSON content: {result_str}")
-            
+
             # Use AugmentedLLM's structured output handling as fallback
             return await super().generate_structured(
                 message=result_str,
@@ -190,8 +213,12 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
     ) -> PlanResult:
         """Execute task with result chaining between steps"""
         iterations = 0
+        total_steps_executed = 0
 
         params = self.get_request_params(request_params)
+        max_steps = getattr(
+            params, "max_steps", params.max_iterations * 5
+        )  # Default to 5× max_iterations
 
         # Single progress event for orchestration start
         model = await self.select_model(params) or "unknown-model"
@@ -208,6 +235,9 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
         )
 
         plan_result = PlanResult(objective=objective, step_results=[])
+        plan_result.max_iterations_reached = (
+            False  # Add a flag to track if we hit the limit
+        )
 
         while iterations < params.max_iterations:
             if self.plan_type == "iterative":
@@ -256,6 +286,14 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
             # Execute each step, collecting results
             # Note that in iterative mode this will only be a single step
             for step in plan.steps:
+                # Check if we've hit the step limit
+                if total_steps_executed >= max_steps:
+                    self.logger.warning(
+                        f"Reached maximum step limit ({max_steps}) without completing objective."
+                    )
+                    plan_result.max_steps_reached = True
+                    break
+
                 step_result = await self._execute_step(
                     step=step,
                     previous_result=plan_result,
@@ -263,16 +301,40 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
                 )
 
                 plan_result.add_step_result(step_result)
+                total_steps_executed += 1
+
+            # Check for step limit after executing steps
+            if total_steps_executed >= max_steps:
+                plan_result.max_iterations_reached = True
+                break
 
             logger.debug(
                 f"Iteration {iterations}: Intermediate plan result:", data=plan_result
             )
             iterations += 1
 
-        raise RuntimeError(
-            f"Task failed to complete in {params.max_iterations} iterations"
+        # If we get here, we've hit the iteration limit without completing
+        self.logger.warning(
+            f"Failed to complete in {params.max_iterations} iterations."
+        )
+
+        # Mark that we hit the iteration limit
+        plan_result.max_iterations_reached = True
+
+        # Synthesize what we have so far, but use a different prompt that explains the incomplete status
+        synthesis_prompt = SYNTHESIZE_INCOMPLETE_PLAN_TEMPLATE.format(
+            plan_result=format_plan_result(plan_result),
+            max_iterations=params.max_iterations,
+        )
+
+        # Generate a final synthesis that acknowledges the incomplete status
+        plan_result.result = await self.planner.generate_str(
+            message=synthesis_prompt,
+            request_params=params.model_copy(update={"max_iterations": 1}),
         )
 
+        return plan_result
+
     async def _execute_step(
         self,
         step: Step,
@@ -312,8 +374,14 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
                 context=context,
             )
 
-            # All agents should now be LLM-capable
-            futures.append(agent._llm.generate_str(message=task_description))
+            # Handle both Agent objects and AugmentedLLM objects
+            from mcp_agent.workflows.llm.augmented_llm import AugmentedLLM
+
+            if isinstance(agent, AugmentedLLM):
+                futures.append(agent.generate_str(message=task_description))
+            else:
+                # Traditional Agent objects with _llm property
+                futures.append(agent._llm.generate_str(message=task_description))
 
         # Wait for all tasks (only if we have valid futures)
         results = await self.executor.execute(*futures) if futures else []
@@ -332,7 +400,7 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
                 task_result = TaskWithResult(
                     description=task_model["description"],
                     agent=task_model["agent"],  # Track which agent produced this result
-                    result=str(result)
+                    result=str(result),
                 )
                 step_result.add_task_result(task_result)
                 task_index += 1
@@ -344,7 +412,7 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
                 TaskWithResult(
                     description=task_model["description"],
                     agent=task_model["agent"],
-                    result=f"ERROR: {error_message}"
+                    result=f"ERROR: {error_message}",
                 )
             )
 
@@ -361,25 +429,49 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
         """Generate full plan considering previous results"""
         import json
         from pydantic import ValidationError
-        from mcp_agent.workflows.orchestrator.orchestrator_models import Plan, Step, AgentTask
+        from mcp_agent.workflows.orchestrator.orchestrator_models import (
+            Plan,
+            Step,
+            AgentTask,
+        )
 
         params = self.get_request_params(request_params)
         params = params.model_copy(update={"use_history": False})
 
         # Format agents without numeric prefixes for cleaner XML
-        agents = "\n".join(
-            [self._format_agent_info(agent) for agent in self.agents]
-        )
+        agent_formats = []
+        for agent_name in self.agents.keys():
+            formatted = self._format_agent_info(agent_name)
+            agent_formats.append(formatted)
+
+        agents = "\n".join(agent_formats)
 
         # Create clear plan status indicator for the template
         plan_status = "Plan Status: Not Started"
         if hasattr(plan_result, "is_complete"):
-            plan_status = "Plan Status: Complete" if plan_result.is_complete else "Plan Status: In Progress"
-        
+            plan_status = (
+                "Plan Status: Complete"
+                if plan_result.is_complete
+                else "Plan Status: In Progress"
+            )
+
+        # Fix the iteration counting display
+        max_iterations = params.max_iterations
+        # Get the actual iteration number we're on (0-based → 1-based for display)
+        current_iteration = len(plan_result.step_results) // (
+            1 if self.plan_type == "iterative" else len(plan_result.step_results) or 1
+        )
+        current_iteration = min(current_iteration, max_iterations - 1)  # Cap at max-1
+        iterations_remaining = max(
+            0, max_iterations - current_iteration - 1
+        )  # Ensure non-negative
+        iterations_info = f"Planning Budget: Iteration {current_iteration + 1} of {max_iterations} (with {iterations_remaining} remaining)"
+
         prompt = FULL_PLAN_PROMPT_TEMPLATE.format(
             objective=objective,
             plan_result=format_plan_result(plan_result),
             plan_status=plan_status,
+            iterations_info=iterations_info,
             agents=agents,
         )
 
@@ -388,50 +480,44 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
             message=prompt,
             request_params=params,
         )
-        
+
         try:
             # Parse JSON directly
             data = json.loads(result_str)
-            
+
             # Create models manually to ensure agent names are preserved exactly as returned
             steps = []
-            for step_data in data.get('steps', []):
+            for step_data in data.get("steps", []):
                 tasks = []
-                for task_data in step_data.get('tasks', []):
+                for task_data in step_data.get("tasks", []):
                     # Create AgentTask directly from dict, preserving exact agent string
                     task = AgentTask(
-                        description=task_data.get('description', ''),
-                        agent=task_data.get('agent', '')  # Preserve exact agent name
+                        description=task_data.get("description", ""),
+                        agent=task_data.get("agent", ""),  # Preserve exact agent name
                     )
                     tasks.append(task)
-                
+
                 # Create Step with the exact task objects we created
-                step = Step(
-                    description=step_data.get('description', ''),
-                    tasks=tasks
-                )
+                step = Step(description=step_data.get("description", ""), tasks=tasks)
                 steps.append(step)
-            
+
             # Create final Plan
-            plan = Plan(
-                steps=steps,
-                is_complete=data.get('is_complete', False)
-            )
-            
+            plan = Plan(steps=steps, is_complete=data.get("is_complete", False))
+
             return plan
-            
+
         except (json.JSONDecodeError, ValidationError, KeyError) as e:
             # Log detailed error and fall back to the original method as last resort
             self.logger.error(f"Error parsing plan JSON: {str(e)}")
             self.logger.debug(f"Failed JSON content: {result_str}")
-            
+
             # Use the normal structured parsing as fallback
             plan = await self.planner.generate_structured(
                 message=result_str,
                 response_model=Plan,
                 request_params=params,
             )
-            
+
             return plan
 
     async def _get_next_step(
@@ -443,25 +529,40 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
         """Generate just the next needed step"""
         import json
         from pydantic import ValidationError
-        from mcp_agent.workflows.orchestrator.orchestrator_models import NextStep, AgentTask
-        
+        from mcp_agent.workflows.orchestrator.orchestrator_models import (
+            NextStep,
+            AgentTask,
+        )
+
         params = self.get_request_params(request_params)
         params = params.model_copy(update={"use_history": False})
 
         # Format agents without numeric prefixes for cleaner XML
+        # FIX: Iterate over agent names instead of agent objects
         agents = "\n".join(
-            [self._format_agent_info(agent) for agent in self.agents]
+            [self._format_agent_info(agent_name) for agent_name in self.agents.keys()]
         )
 
         # Create clear plan status indicator for the template
         plan_status = "Plan Status: Not Started"
         if hasattr(plan_result, "is_complete"):
-            plan_status = "Plan Status: Complete" if plan_result.is_complete else "Plan Status: In Progress"
-            
+            plan_status = (
+                "Plan Status: Complete"
+                if plan_result.is_complete
+                else "Plan Status: In Progress"
+            )
+
+        # Add max_iterations info for the LLM
+        max_iterations = params.max_iterations
+        current_iteration = len(plan_result.step_results)
+        iterations_remaining = max_iterations - current_iteration
+        iterations_info = f"Planning Budget: {iterations_remaining} of {max_iterations} iterations remaining"
+
         prompt = ITERATIVE_PLAN_PROMPT_TEMPLATE.format(
             objective=objective,
             plan_result=format_plan_result(plan_result),
             plan_status=plan_status,
+            iterations_info=iterations_info,
             agents=agents,
         )
 
@@ -470,55 +571,55 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
             message=prompt,
             request_params=params,
         )
-        
+
         try:
             # Parse JSON directly
             data = json.loads(result_str)
-            
+
             # Create task objects manually to preserve exact agent names
             tasks = []
-            for task_data in data.get('tasks', []):
+            for task_data in data.get("tasks", []):
                 # Preserve the exact agent name as specified in the JSON
                 task = AgentTask(
-                    description=task_data.get('description', ''),
-                    agent=task_data.get('agent', '')
+                    description=task_data.get("description", ""),
+                    agent=task_data.get("agent", ""),
                 )
                 tasks.append(task)
-            
+
             # Create step with manually constructed tasks
             next_step = NextStep(
-                description=data.get('description', ''),
+                description=data.get("description", ""),
                 tasks=tasks,
-                is_complete=data.get('is_complete', False)
+                is_complete=data.get("is_complete", False),
             )
-            
+
             return next_step
-            
+
         except (json.JSONDecodeError, ValidationError, KeyError) as e:
             # Log detailed error and fall back to the original method
             self.logger.error(f"Error parsing next step JSON: {str(e)}")
             self.logger.debug(f"Failed JSON content: {result_str}")
-            
+
             # Use the normal structured parsing as fallback
             next_step = await self.planner.generate_structured(
                 message=result_str,
                 response_model=NextStep,
                 request_params=params,
             )
-            
+
             return next_step
 
     def _format_server_info(self, server_name: str) -> str:
         """Format server information for display to planners using XML tags"""
         from mcp_agent.workflows.llm.prompt_utils import format_server_info
-        
+
         server_config = self.server_registry.get_server_config(server_name)
-        
+
         # Get description or empty string if not available
         description = ""
         if server_config and server_config.description:
             description = server_config.description
-        
+
         return format_server_info(server_name, description)
 
     def _validate_agent_names(self, plan: Plan) -> None:
@@ -527,12 +628,12 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
         This helps catch invalid agent references early.
         """
         invalid_agents = []
-        
+
         for step in plan.steps:
             for task in step.tasks:
                 if task.agent not in self.agents:
                     invalid_agents.append(task.agent)
-        
+
         if invalid_agents:
             available_agents = ", ".join(self.agents.keys())
             invalid_list = ", ".join(invalid_agents)
@@ -540,20 +641,17 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
             self.logger.error(error_msg)
             # We don't raise an exception here as the execution will handle invalid agents
             # by logging errors for individual tasks
-    
+
     def _format_agent_info(self, agent_name: str) -> str:
         """Format Agent information for display to planners using XML tags"""
         from mcp_agent.workflows.llm.prompt_utils import format_agent_info
-        
+
         agent = self.agents.get(agent_name)
         if not agent:
+            self.logger.error(f"Agent '{agent_name}' not found in orchestrator agents")
             return ""
-
-        # Get agent instruction as string
         instruction = agent.instruction
-        if callable(instruction):
-            instruction = instruction({})
-        
+
         # Get servers information
         server_info = []
         for server_name in agent.server_names:
@@ -561,7 +659,9 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
             description = ""
             if server_config and server_config.description:
                 description = server_config.description
-            
+
             server_info.append({"name": server_name, "description": description})
-            
-        return format_agent_info(agent.name, instruction, server_info if server_info else None)
+
+        return format_agent_info(
+            agent.name, instruction, server_info if server_info else None
+        )

mcp_agent/workflows/orchestrator/orchestrator_models.py

@@ -102,6 +102,9 @@ class PlanResult(BaseModel):
     is_complete: bool = False
     """Whether the overall plan objective is complete"""
 
+    max_iterations_reached: bool = False
+    """Whether the plan execution reached the maximum number of iterations without completing"""
+
     result: str | None = None
     """Result of executing the plan"""
 

mcp_agent/workflows/orchestrator/orchestrator_prompts.py

@@ -1,3 +1,8 @@
+"""
+Prompt templates used by the Orchestrator workflow.
+"""
+
+# Templates for formatting results
 TASK_RESULT_TEMPLATE = """Task: {task_description}
 Result: {task_result}"""
 
@@ -30,6 +35,7 @@ You can analyze results from the previous steps already executed to decide if th
 
 <fastagent:status>
 {plan_status}
+{iterations_info}
 </fastagent:status>
 </fastagent:data>
 
@@ -38,6 +44,10 @@ If the previous results achieve the objective, return is_complete=True.
 Otherwise, generate remaining steps needed.
 
 <fastagent:instruction>
+You are operating in "full plan" mode, where you generate a complete plan with ALL remaining steps needed.
+After receiving your plan, the system will execute ALL steps in your plan before asking for your input again.
+If the plan needs multiple iterations, you'll be called again with updated results.
+
 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.
@@ -68,6 +78,8 @@ Return your response in the following JSON structure:
         "is_complete": false
     }}
 
+Set "is_complete" to true ONLY if you are confident the objective has been fully achieved based on work completed so far.
+
 You must respond with valid JSON only, with no triple backticks. No markdown formatting.
 No extra text. Do not wrap in ```json code fences.
 </fastagent:instruction>
@@ -92,6 +104,7 @@ to decide what to do next.
 
 <fastagent:status>
 {plan_status}
+{iterations_info}
 </fastagent:status>
 </fastagent:data>
 
@@ -100,6 +113,9 @@ If the previous results achieve the objective, return is_complete=True.
 Otherwise, generate the next Step.
 
 <fastagent:instruction>
+You are operating in "iterative plan" mode, where you generate ONLY ONE STEP at a time.
+After each step is executed, you'll be called again to determine the next step based on updated results.
+
 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  
@@ -120,6 +136,8 @@ Return your response in the following JSON structure:
         "is_complete": false
     }}
 
+Set "is_complete" to true ONLY if you are confident the objective has been fully achieved based on work completed so far.
+
 You must respond with valid JSON only, with no triple backticks. No markdown formatting.
 No extra text. Do not wrap in ```json code fences.
 </fastagent:instruction>
@@ -184,5 +202,35 @@ Create a comprehensive final response that addresses the original objective.
 Integrate all the information gathered across all plan steps.
 Provide a clear, complete answer that achieves the objective.
 Focus on delivering value through your synthesis, not just summarizing.
+
+If the plan was marked as incomplete but the maximum number of iterations was reached,
+make sure to state clearly what was accomplished and what remains to be done.
+</fastagent:instruction>
+"""
+
+# New template for incomplete plans due to iteration limits
+SYNTHESIZE_INCOMPLETE_PLAN_TEMPLATE = """You need to synthesize the results of all completed plan steps into a final response.
+
+<fastagent:data>
+<fastagent:plan-results>
+{plan_result}
+</fastagent:plan-results>
+</fastagent:data>
+
+<fastagent:status>
+The maximum number of iterations ({max_iterations}) was reached before the objective could be completed.
+</fastagent:status>
+
+<fastagent:instruction>
+Create a comprehensive response that summarizes what was accomplished so far.
+The objective was NOT fully completed due to reaching the maximum number of iterations.
+
+In your response:
+1. Clearly state that the objective was not fully completed
+2. Summarize what WAS accomplished across all the executed steps
+3. Identify what remains to be done to complete the objective
+4. Organize the information to provide maximum value despite being incomplete
+
+Focus on being transparent about the incomplete status while providing as much value as possible.
 </fastagent:instruction>
 """