fast-agent-mcp 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

mcp_agent/workflows/orchestrator/orchestrator.py

@@ -6,8 +6,8 @@ from typing import (
     List,
     Literal,
     Optional,
-    Type,
     TYPE_CHECKING,
+    Type,
 )
 
 from mcp_agent.agents.agent import Agent
@@ -132,21 +132,7 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
         # 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
 
@@ -169,7 +155,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,
@@ -183,30 +169,7 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
         response_model: Type[ModelT],
         request_params: RequestParams | None = None,
     ) -> ModelT:
-        """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.debug(f"Failed JSON content: {result_str}")
-
-            # Use AugmentedLLM's structured output handling as fallback
-            return await super().generate_structured(
-                message=result_str,
-                response_model=response_model,
-                request_params=params,
-            )
+        return None
 
     async def execute(
         self, objective: str, request_params: RequestParams | None = None
@@ -299,9 +262,11 @@ 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
+            # Check if we need to break from the main loop due to hitting max_steps
+            if (
+                hasattr(plan_result, "max_steps_reached")
+                and plan_result.max_steps_reached
+            ):
                 break
 
             logger.debug(
@@ -317,21 +282,38 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
 
             iterations += 1
 
-        # If we get here, we've hit the iteration limit without completing
-        self.logger.warning(
-            f"Failed to complete in {params.max_iterations} iterations."
-        )
+        # If we reach here, either:
+        # 1. We hit iteration limit without completing
+        # 2. We hit max_steps limit without completing
+        # 3. We detected diminishing returns (plan with 0-1 steps after multiple iterations)
 
-        # Mark that we hit the iteration limit
-        plan_result.max_iterations_reached = True
+        # Check if we hit iteration limits without completing
+        if iterations >= params.max_iterations and not plan_result.is_complete:
+            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,
-        )
+            # Use the incomplete template when we've hit iteration limits
+            synthesis_prompt = SYNTHESIZE_INCOMPLETE_PLAN_TEMPLATE.format(
+                plan_result=format_plan_result(plan_result),
+                max_iterations=params.max_iterations,
+            )
+        else:
+            # Either plan is complete or we had diminishing returns (which we mark as complete)
+            if not plan_result.is_complete:
+                self.logger.info(
+                    "Plan terminated due to diminishing returns, marking as complete"
+                )
+                plan_result.is_complete = True
+
+            # Use standard template for complete plans
+            synthesis_prompt = SYNTHESIZE_PLAN_PROMPT_TEMPLATE.format(
+                plan_result=format_plan_result(plan_result)
+            )
 
-        # Generate a final synthesis that acknowledges the incomplete status
+        # Generate the final synthesis with the appropriate template
         plan_result.result = await self.planner.generate_str(
             message=synthesis_prompt,
             request_params=params.model_copy(update={"max_iterations": 1}),
@@ -359,8 +341,6 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
             # Make sure we're using a valid agent name
             agent = self.agents.get(task.agent)
             if not agent:
-                # Log a more prominent error - this is a serious problem that shouldn't happen
-                # with the improved prompt
                 self.logger.error(
                     f"AGENT VALIDATION ERROR: No agent found matching '{task.agent}'. Available agents: {list(self.agents.keys())}"
                 )
@@ -431,18 +411,10 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
         request_params: RequestParams | None = None,
     ) -> Plan:
         """Generate full plan considering previous results"""
-        import json
-        from pydantic import ValidationError
-        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
         agent_formats = []
         for agent_name in self.agents.keys():
             formatted = self._format_agent_info(agent_name)
@@ -452,7 +424,7 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
 
         # Create clear plan status indicator for the template
         plan_status = "Plan Status: Not Started"
-        if hasattr(plan_result, "is_complete"):
+        if plan_result.is_complete:
             plan_status = (
                 "Plan Status: Complete"
                 if plan_result.is_complete
@@ -478,49 +450,30 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
         )
 
         # Get raw JSON response from LLM
-        result_str = await self.planner.generate_str(
+        return await self.planner.generate_structured(
             message=prompt,
             request_params=params,
+            response_model=Plan,
         )
-
-        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", []):
-                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
-                    )
-                    tasks.append(task)
-
-                # Create Step with the exact task objects we created
-                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))
-
-            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
+        # return data
+
+        # steps = []
+        # for step_data in data.steps:
+        #     tasks = []
+        #     for task_data in step_data.tasks:
+        #         task = AgentTask(
+        #             description=task_data.description,
+        #             agent=task_data.agent,
+        #         )
+        #         tasks.append(task)
+
+        #     # Create Step with the exact task objects we created
+        #     step = Step(description=step_data.description, tasks=tasks)
+        #     steps.append(step)
+
+        # # Create final Plan
+        # plan = Plan(steps=steps, is_complete=data.is_complete)
+        # return plan
 
     async def _get_next_step(
         self,
@@ -529,12 +482,6 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
         request_params: RequestParams | None = None,
     ) -> NextStep:
         """Generate just the next needed step"""
-        import json
-        from pydantic import ValidationError
-        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})
@@ -547,7 +494,7 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
 
         # Create clear plan status indicator for the template
         plan_status = "Plan Status: Not Started"
-        if hasattr(plan_result, "is_complete"):
+        if plan_result:
             plan_status = (
                 "Plan Status: Complete"
                 if plan_result.is_complete
@@ -569,48 +516,10 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
         )
 
         # Get raw JSON response from LLM
-        result_str = await self.planner.generate_str(
-            message=prompt,
-            request_params=params,
+        return await self.planner.generate_structured(
+            message=prompt, request_params=params, response_model=NextStep
         )
 
-        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", []):
-                # Preserve the exact agent name as specified in the JSON
-                task = AgentTask(
-                    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", ""),
-                tasks=tasks,
-                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

mcp_agent/workflows/router/router_llm.py

@@ -13,7 +13,8 @@ if TYPE_CHECKING:
 
 logger = get_logger(__name__)
 
-
+# TODO -- reinstate function/server routing
+# TODO -- Generate the Example Schema from the Pydantic Model
 DEFAULT_ROUTING_INSTRUCTION = """
 You are a highly accurate request router that directs incoming requests to the most appropriate category.
 A category is a specialized destination, such as a Function, an MCP Server (a collection of tools/functions), or an Agent (a collection of servers).
@@ -34,7 +35,7 @@ Your task is to analyze the request and determine the most appropriate categorie
 - Whether the request might benefit from multiple categories (up to {top_k})
 
 <fastagent:instruction>
-Respond in JSON format:
+Respond in JSON format. NEVER include Code Fences:
 {{
     "categories": [
         {{
@@ -65,37 +66,31 @@ Follow these guidelines:
 """
 
 
-class LLMRouterResult(RouterResult[ResultT]):
-    """A class that represents the result of an LLMRouter.route request"""
+class ConfidenceRating(BaseModel):
+    """Base class for models with confidence ratings and reasoning"""
 
-    confidence: Literal["high", "medium", "low"]
     """The confidence level of the routing decision."""
+    confidence: Literal["high", "medium", "low"]
+    """A brief explanation of the routing decision."""
+    reasoning: str | None = None  # Make nullable to support both use cases
 
-    reasoning: str | None = None
-    """
-    A brief explanation of the routing decision.
-    This is optional and may only be provided if the router is an LLM
-    """
-
-
-class StructuredResponseCategory(BaseModel):
-    """A class that represents a single category returned by an LLM router"""
 
-    category: str
+# Used for LLM output parsing
+class StructuredResponseCategory(ConfidenceRating):
     """The name of the category (i.e. MCP server, Agent or function) to route the input to."""
 
-    confidence: Literal["high", "medium", "low"]
-    """The confidence level of the routing decision."""
-
-    reasoning: str | None = None
-    """A brief explanation of the routing decision."""
+    category: str  # Category name for lookup
 
 
 class StructuredResponse(BaseModel):
-    """A class that represents the structured response of an LLM router"""
-
     categories: List[StructuredResponseCategory]
-    """A list of categories to route the input to."""
+
+
+# Used for final router output
+class LLMRouterResult(RouterResult[ResultT], ConfidenceRating):
+    # Inherits 'result' from RouterResult
+    # Inherits 'confidence' and 'reasoning' from ConfidenceRating
+    pass
 
 
 class LLMRouter(Router):
@@ -282,7 +277,6 @@ class LLMRouter(Router):
         for r in response.categories:
             router_category = self.categories.get(r.category)
             if not router_category:
-                # Skip invalid categories
                 # TODO: log or raise an error
                 continue
 

mcp_agent/core/server_validation.py

@@ -1,44 +0,0 @@
-"""FastAgent validation methods."""
-
-from mcp_agent.core.exceptions import ServerConfigError
-
-
-def _validate_server_references(self) -> None:
-    """
-    Validate that all server references in agent configurations exist in config.
-    Raises ServerConfigError if any referenced servers are not defined.
-    """
-    # First check if any agents need servers
-    agents_needing_servers = {
-        name: agent_data["config"].servers
-        for name, agent_data in self.agents.items()
-        if agent_data["config"].servers
-    }
-
-    if not agents_needing_servers:
-        return  # No validation needed
-
-    # If we need servers, verify MCP config exists
-    if not hasattr(self.context.config, "mcp"):
-        raise ServerConfigError(
-            "MCP configuration missing",
-            "Agents require server access but no MCP configuration found.\n"
-            "Add an 'mcp' section to your configuration file.",
-        )
-
-    if not self.context.config.mcp.servers:
-        raise ServerConfigError(
-            "No MCP servers configured",
-            "Agents require server access but no servers are defined.\n"
-            "Add server definitions under mcp.servers in your configuration file.",
-        )
-
-    # Now check each agent's servers exist
-    available_servers = set(self.context.config.mcp.servers.keys())
-    for name, servers in agents_needing_servers.items():
-        missing = [s for s in servers if s not in available_servers]
-        if missing:
-            raise ServerConfigError(
-                f"Missing server configuration for agent '{name}'",
-                f"The following servers are referenced but not defined in config: {', '.join(missing)}",
-            )

mcp_agent/core/simulator_registry.py

@@ -1,22 +0,0 @@
-from typing import Optional, Any
-
-
-class SimulatorRegistry:
-    """Registry to access simulator instances for testing assertions"""
-
-    _instances = {}
-
-    @classmethod
-    def register(cls, name: str, simulator: "Any"):
-        """Register a simulator instance"""
-        cls._instances[name] = simulator
-
-    @classmethod
-    def get(cls, name: str) -> Optional["Any"]:
-        """Get a simulator by name"""
-        return cls._instances.get(name)
-
-    @classmethod
-    def clear(cls):
-        """Clear registry (useful between tests)"""
-        cls._instances.clear()

mcp_agent/workflows/llm/enhanced_passthrough.py

@@ -1,70 +0,0 @@
-# src/mcp_agent/workflows/llm/enhanced_passthrough.py
-
-
-import datetime
-from typing import List, Optional, Union
-from mcp_agent.core.simulator_registry import SimulatorRegistry
-from mcp_agent.workflows.llm.augmented_llm import (
-    AugmentedLLM,
-    MessageParamT,
-    RequestParams,
-)
-
-
-class EnhancedPassthroughLLM(AugmentedLLM):
-    """Enhanced passthrough LLM for testing parameter handling and workflows"""
-
-    def __init__(self, name: str = "Simulator", context=None, **kwargs):
-        super().__init__(name=name, context=context, **kwargs)
-        self.simulation_mode = kwargs.get("simulation_mode", "passthrough")
-        self.request_log = []
-        self.last_request_params = None
-
-        # Register this instance with the registry
-        SimulatorRegistry.register(self.name, self)
-
-    async def generate_str(
-        self,
-        message: Union[str, MessageParamT, List[MessageParamT]],
-        request_params: Optional[RequestParams] = None,
-    ) -> str:
-        """Capture parameters and log the request"""
-        # Store for assertion testing
-        self.last_request_params = request_params
-
-        # Log the request
-        self.request_log.append(
-            {
-                "timestamp": datetime.now().isoformat(),
-                "message": str(message),
-                "request_params": request_params.model_dump()
-                if request_params
-                else None,
-            }
-        )
-
-        # Display for debugging
-        self.show_user_message(str(message), model="simulator", chat_turn=0)
-
-        # Simulate response
-        result = f"[SIMULATOR] Response to: {message}"
-        await self.show_assistant_message(result, title="SIMULATOR")
-
-        return result
-
-    # Other generate methods with similar parameter capture
-
-    def get_parameter_usage_report(self):
-        """Generate report of parameter usage"""
-        param_usage = {}
-
-        for req in self.request_log:
-            params = req.get("request_params", {})
-            if params:
-                for key, value in params.items():
-                    if key not in param_usage:
-                        param_usage[key] = {"count": 0, "values": set()}
-                    param_usage[key]["count"] += 1
-                    param_usage[key]["values"].add(str(value))
-
-        return {"total_requests": len(self.request_log), "parameter_usage": param_usage}