fast-agent-mcp 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

mcp_agent/workflows/llm/augmented_llm_passthrough.py

@@ -0,0 +1,61 @@
+from typing import Any, List, Optional, Type, Union
+
+from pydantic_core import from_json
+from mcp_agent.workflows.llm.augmented_llm import (
+    AugmentedLLM,
+    MessageParamT,
+    MessageT,
+    ModelT,
+    RequestParams,
+)
+
+
+class PassthroughLLM(AugmentedLLM):
+    """
+    A specialized LLM implementation that simply passes through input messages without modification.
+
+    This is useful for cases where you need an object with the AugmentedLLM interface
+    but want to preserve the original message without any processing, such as in a
+    parallel workflow where no fan-in aggregation is needed.
+    """
+
+    def __init__(self, name: str = "Passthrough", context=None, **kwargs):
+        super().__init__(name=name, context=context, **kwargs)
+
+    async def generate(
+        self,
+        message: Union[str, MessageParamT, List[MessageParamT]],
+        request_params: Optional[RequestParams] = None,
+    ) -> Union[List[MessageT], Any]:
+        """Simply return the input message as is."""
+        # Return in the format expected by the caller
+        return [message] if isinstance(message, list) else message
+
+    async def generate_str(
+        self,
+        message: Union[str, MessageParamT, List[MessageParamT]],
+        request_params: Optional[RequestParams] = None,
+    ) -> str:
+        """Return the input message as a string."""
+        self.show_user_message(message, model="fastagent-passthrough", chat_turn=0)
+        await self.show_assistant_message(message, title="ASSISTANT/PASSTHROUGH")
+
+        return str(message)
+
+    async def generate_structured(
+        self,
+        message: Union[str, MessageParamT, List[MessageParamT]],
+        response_model: Type[ModelT],
+        request_params: Optional[RequestParams] = None,
+    ) -> ModelT:
+        """
+        Return the input message as the requested model type.
+        This is a best-effort implementation - it may fail if the
+        message cannot be converted to the requested model.
+        """
+        if isinstance(message, response_model):
+            return message
+        elif isinstance(message, dict):
+            return response_model(**message)
+        elif isinstance(message, str):
+            return response_model.model_validate(from_json(message, allow_partial=True))

mcp_agent/workflows/llm/model_factory.py

@@ -7,7 +7,7 @@ from mcp_agent.core.exceptions import ModelConfigError
 from mcp_agent.workflows.llm.augmented_llm_anthropic import AnthropicAugmentedLLM
 from mcp_agent.workflows.llm.augmented_llm_openai import OpenAIAugmentedLLM
 from mcp_agent.workflows.llm.augmented_llm import RequestParams
-from mcp_agent.workflows.llm.enhanced_passthrough import EnhancedPassthroughLLM
+from mcp_agent.workflows.llm.augmented_llm_passthrough import PassthroughLLM
 
 # Type alias for LLM classes
 LLMClass = Union[Type[AnthropicAugmentedLLM], Type[OpenAIAugmentedLLM]]
@@ -18,7 +18,7 @@ class Provider(Enum):
 
     ANTHROPIC = auto()
     OPENAI = auto()
-    SIMULATOR = auto()
+    FAST_AGENT = auto()
 
 
 class ReasoningEffort(Enum):
@@ -45,6 +45,7 @@ class ModelFactory:
     PROVIDER_MAP = {
         "anthropic": Provider.ANTHROPIC,
         "openai": Provider.OPENAI,
+        "fast-agent": Provider.FAST_AGENT,
     }
 
     # Mapping of effort strings to enum values
@@ -59,6 +60,7 @@ class ModelFactory:
     # TODO -- bring model parameter configuration here
     # Mapping of model names to their default providers
     DEFAULT_PROVIDERS = {
+        "passthrough": Provider.FAST_AGENT,
         "gpt-4o": Provider.OPENAI,
         "gpt-4o-mini": Provider.OPENAI,
         "o1-mini": Provider.OPENAI,
@@ -93,7 +95,7 @@ class ModelFactory:
     PROVIDER_CLASSES: Dict[Provider, LLMClass] = {
         Provider.ANTHROPIC: AnthropicAugmentedLLM,
         Provider.OPENAI: OpenAIAugmentedLLM,
-        Provider.SIMULATOR: EnhancedPassthroughLLM,
+        Provider.FAST_AGENT: PassthroughLLM,
     }
 
     @classmethod

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