fast-agent-mcp 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

mcp_agent/core/proxies.py

@@ -45,13 +45,28 @@ class BaseAgentProxy:
         """Generate response for a message - must be implemented by subclasses"""
         raise NotImplementedError("Subclasses must implement generate_str")
 
-
-class AgentProxy(BaseAgentProxy):
-    """Legacy proxy for individual agent operations"""
-
-    async def generate_str(self, message: str, **kwargs) -> str:
-        """Forward only the message to app.send, ignoring kwargs for legacy compatibility"""
-        return await self._app.send(self._name, message)
+    async def load_prompt(self, prompt_name: str = None, arguments: dict[str, str] = None) -> str:
+        """
+        Use a Prompt from an MCP Server - implemented by subclasses.
+        Always returns an Assistant message.
+        
+        Args:
+            prompt_name: Name of the prompt to load
+            arguments: Optional dictionary of string arguments for prompt templating
+        """
+        raise NotImplementedError("Subclasses must implement mcp-prompt")
+        
+    async def apply_prompt(self, prompt_name: str = None, arguments: dict[str, str] = None) -> str:
+        """
+        Apply a Prompt from an MCP Server - implemented by subclasses.
+        This is the preferred method for applying prompts.
+        Always returns an Assistant message.
+        
+        Args:
+            prompt_name: Name of the prompt to apply
+            arguments: Optional dictionary of string arguments for prompt templating
+        """
+        raise NotImplementedError("Subclasses must implement apply_prompt")
 
 
 class LLMAgentProxy(BaseAgentProxy):
@@ -65,6 +80,33 @@ class LLMAgentProxy(BaseAgentProxy):
         """Forward message and all kwargs to the agent's LLM"""
         return await self._agent._llm.generate_str(message, **kwargs)
 
+    async def load_prompt(self, prompt_name: str = None, arguments: dict[str, str] = None) -> str:
+        """
+        Load and apply a prompt from an MCP server.
+        
+        Args:
+            prompt_name: Name of the prompt to load
+            arguments: Optional dictionary of string arguments for prompt templating
+            
+        Returns:
+            The assistant's response
+        """
+        return await self._agent.load_prompt(prompt_name, arguments)
+        
+    async def apply_prompt(self, prompt_name: str = None, arguments: dict[str, str] = None) -> str:
+        """
+        Apply a prompt from an MCP server.
+        This is the preferred method for applying prompts.
+        
+        Args:
+            prompt_name: Name of the prompt to apply
+            arguments: Optional dictionary of string arguments for prompt templating
+            
+        Returns:
+            The assistant's response
+        """
+        return await self._agent.apply_prompt(prompt_name, arguments)
+
 
 class WorkflowProxy(BaseAgentProxy):
     """Proxy for workflow types that implement generate_str() directly"""
@@ -119,52 +161,46 @@ class ChainProxy(BaseAgentProxy):
         self._continue_with_final = True  # Default behavior
         self._cumulative = False  # Default to sequential chaining
 
-    async def generate_str(self, message: str) -> str:
-        """Chain message through a sequence of agents with optional cumulative behavior"""
-        if not self._cumulative:
-            # Original sequential behavior
-            current_message = message
-            for agent_name in self._sequence:
-                proxy = self._agent_proxies[agent_name]
-                current_message = await proxy.generate_str(current_message)
-            return current_message
-        else:
-            # Cumulative behavior
-            original_message = message
-            agent_responses = {}
-
-            for agent_name in self._sequence:
-                proxy = self._agent_proxies[agent_name]
+    async def generate_str(self, message: str, **kwargs) -> str:
+        """Chain message through a sequence of agents.
 
-                if not agent_responses:  # First agent
-                    response = await proxy.generate_str(original_message)
-                else:
-                    # Construct context with previous responses
-                    context_message = "The following request was sent to the agents:\n"
-                    context_message += f"<fastagent:request>\n{original_message}\n</fastagent:request>\n\n"
+        For the first agent in the chain, pass all kwargs to maintain transparency.
 
-                    context_message += "Previous agent responses:\n"
+        Two modes of operation:
+        1. Sequential (default): Each agent receives only the output of the previous agent
+        2. Cumulative: Each agent receives all previous agent responses concatenated
+        """
+        if not self._sequence:
+            return message
 
-                    for prev_name in self._sequence:
-                        if prev_name in agent_responses:
-                            prev_response = agent_responses[prev_name]
-                            context_message += f'<fastagent:response agent="{prev_name}">\n{prev_response}\n</fastagent:response>\n\n'
+        # Process the first agent (same for both modes)
+        first_agent = self._sequence[0]
+        first_proxy = self._agent_proxies[first_agent]
+        first_response = await first_proxy.generate_str(message, **kwargs)
 
-                    context_message += f"Your task is to build upon this work to address: {original_message}"
+        if len(self._sequence) == 1:
+            return first_response
 
-                    response = await proxy.generate_str(context_message)
+        if self._cumulative:
+            # Cumulative mode: each agent gets all previous responses
+            cumulative_response = f'<fastagent:response agent="{first_agent}">\n{first_response}\n</fastagent:response>'
 
-                agent_responses[agent_name] = response
+            # Process subsequent agents with cumulative results
+            for agent_name in self._sequence[1:]:
+                proxy = self._agent_proxies[agent_name]
+                # Pass all previous responses to next agent
+                agent_response = await proxy.generate_str(cumulative_response)
+                # Add this agent's response to the cumulative result
+                cumulative_response += f'\n\n<fastagent:response agent="{agent_name}">\n{agent_response}\n</fastagent:response>'
 
-            # Format final output with ALL responses in XML format
-            final_output = "The following request was sent to the agents:\n"
-            final_output += (
-                f"<fastagent:request>\n{original_message}\n</fastagent:request>\n\n"
-            )
+            return cumulative_response
+        else:
+            # Sequential chaining (original behavior)
+            current_message = first_response
 
-            for agent_name in self._sequence:
-                response = agent_responses[agent_name]
-                final_output += f'<fastagent:response agent="{agent_name}">\n{response}\n</fastagent:response>\n\n'
+            # For subsequent agents, just pass the message from previous agent
+            for agent_name in self._sequence[1:]:
+                proxy = self._agent_proxies[agent_name]
+                current_message = await proxy.generate_str(current_message)
 
-            # Return the XML-structured combination of all responses
-            return final_output.strip()
+            return current_message

mcp_agent/core/validation.py

@@ -0,0 +1,221 @@
+"""
+Validation utilities for FastAgent configuration and dependencies.
+"""
+
+from typing import Dict, List, Any
+from mcp_agent.core.agent_types import AgentType
+from mcp_agent.workflows.llm.augmented_llm import AugmentedLLM
+from mcp_agent.core.exceptions import ServerConfigError, AgentConfigError, CircularDependencyError
+
+
+def validate_server_references(context, agents: Dict[str, Dict[str, Any]]) -> None:
+    """
+    Validate that all server references in agent configurations exist in config.
+    Raises ServerConfigError if any referenced servers are not defined.
+    
+    Args:
+        context: Application context
+        agents: Dictionary of agent configurations
+    """
+    if not context.config.mcp or not context.config.mcp.servers:
+        available_servers = set()
+    else:
+        available_servers = set(context.config.mcp.servers.keys())
+
+    # Check each agent's server references
+    for name, agent_data in agents.items():
+        config = agent_data["config"]
+        if config.servers:
+            missing = [s for s in config.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)}",
+                )
+
+
+def validate_workflow_references(agents: Dict[str, Dict[str, Any]]) -> None:
+    """
+    Validate that all workflow references point to valid agents/workflows.
+    Also validates that referenced agents have required configuration.
+    Raises AgentConfigError if any validation fails.
+    
+    Args:
+        agents: Dictionary of agent configurations
+    """
+    available_components = set(agents.keys())
+
+    for name, agent_data in agents.items():
+        agent_type = agent_data["type"]
+
+        if agent_type == AgentType.PARALLEL.value:
+            # Check fan_in exists
+            fan_in = agent_data["fan_in"]
+            if fan_in not in available_components:
+                raise AgentConfigError(
+                    f"Parallel workflow '{name}' references non-existent fan_in component: {fan_in}"
+                )
+
+            # Check fan_out agents exist
+            fan_out = agent_data["fan_out"]
+            missing = [a for a in fan_out if a not in available_components]
+            if missing:
+                raise AgentConfigError(
+                    f"Parallel workflow '{name}' references non-existent fan_out components: {', '.join(missing)}"
+                )
+
+        elif agent_type == AgentType.ORCHESTRATOR.value:
+            # Check all child agents exist and are properly configured
+            child_agents = agent_data["child_agents"]
+            missing = [a for a in child_agents if a not in available_components]
+            if missing:
+                raise AgentConfigError(
+                    f"Orchestrator '{name}' references non-existent agents: {', '.join(missing)}"
+                )
+
+            # Validate child agents have required LLM configuration
+            for agent_name in child_agents:
+                child_data = agents[agent_name]
+                if child_data["type"] == AgentType.BASIC.value:
+                    # For basic agents, we'll validate LLM config during creation
+                    continue
+                # Check if it's a workflow type or has LLM capability
+                # Workflows like EvaluatorOptimizer and Parallel are valid for orchestrator
+                func = child_data["func"]
+                workflow_types = [
+                    AgentType.EVALUATOR_OPTIMIZER.value,
+                    AgentType.PARALLEL.value,
+                    AgentType.ROUTER.value,
+                    AgentType.CHAIN.value,
+                ]
+
+                if not (
+                    isinstance(func, AugmentedLLM)
+                    or child_data["type"] in workflow_types
+                    or (hasattr(func, "_llm") and func._llm is not None)
+                ):
+                    raise AgentConfigError(
+                        f"Agent '{agent_name}' used by orchestrator '{name}' lacks LLM capability",
+                        "All agents used by orchestrators must be LLM-capable (either an AugmentedLLM or have an _llm property)",
+                    )
+
+        elif agent_type == AgentType.ROUTER.value:
+            # Check all referenced agents exist
+            router_agents = agent_data["agents"]
+            missing = [a for a in router_agents if a not in available_components]
+            if missing:
+                raise AgentConfigError(
+                    f"Router '{name}' references non-existent agents: {', '.join(missing)}"
+                )
+
+        elif agent_type == AgentType.EVALUATOR_OPTIMIZER.value:
+            # Check both evaluator and optimizer exist
+            evaluator = agent_data["evaluator"]
+            generator = agent_data["generator"]
+            missing = []
+            if evaluator not in available_components:
+                missing.append(f"evaluator: {evaluator}")
+            if generator not in available_components:
+                missing.append(f"generator: {generator}")
+            if missing:
+                raise AgentConfigError(
+                    f"Evaluator-Optimizer '{name}' references non-existent components: {', '.join(missing)}"
+                )
+
+        elif agent_type == AgentType.CHAIN.value:
+            # Check that all agents in the sequence exist
+            sequence = agent_data.get("sequence", agent_data.get("agents", []))
+            missing = [a for a in sequence if a not in available_components]
+            if missing:
+                raise AgentConfigError(
+                    f"Chain '{name}' references non-existent agents: {', '.join(missing)}"
+                )
+
+
+def get_dependencies(
+    name: str, 
+    agents: Dict[str, Dict[str, Any]],
+    visited: set, 
+    path: set, 
+    agent_type: AgentType = None
+) -> List[str]:
+    """
+    Get dependencies for an agent in topological order.
+    Works for both Parallel and Chain workflows.
+
+    Args:
+        name: Name of the agent
+        agents: Dictionary of agent configurations
+        visited: Set of already visited agents
+        path: Current path for cycle detection
+        agent_type: Optional type filter (e.g., only check Parallel or Chain)
+
+    Returns:
+        List of agent names in dependency order
+
+    Raises:
+        CircularDependencyError: If circular dependency detected
+    """
+    if name in path:
+        path_str = " -> ".join(path)
+        raise CircularDependencyError(f"Path: {path_str} -> {name}")
+
+    if name in visited:
+        return []
+
+    if name not in agents:
+        return []
+
+    config = agents[name]
+
+    # Skip if not the requested type (when filtering)
+    if agent_type and config["type"] != agent_type.value:
+        return []
+
+    path.add(name)
+    deps = []
+
+    # Handle dependencies based on agent type
+    if config["type"] == AgentType.PARALLEL.value:
+        # Get dependencies from fan-out agents
+        for fan_out in config["fan_out"]:
+            deps.extend(get_dependencies(fan_out, agents, visited, path, agent_type))
+    elif config["type"] == AgentType.CHAIN.value:
+        # Get dependencies from sequence agents
+        sequence = config.get("sequence", config.get("agents", []))
+        for agent_name in sequence:
+            deps.extend(
+                get_dependencies(agent_name, agents, visited, path, agent_type)
+            )
+
+    # Add this agent after its dependencies
+    deps.append(name)
+    visited.add(name)
+    path.remove(name)
+
+    return deps
+
+
+def get_parallel_dependencies(
+    name: str, 
+    agents: Dict[str, Dict[str, Any]],
+    visited: set, 
+    path: set
+) -> List[str]:
+    """
+    Get dependencies for a parallel agent in topological order.
+    Legacy function that calls the more general get_dependencies.
+
+    Args:
+        name: Name of the parallel agent
+        agents: Dictionary of agent configurations
+        visited: Set of already visited agents
+        path: Current path for cycle detection
+
+    Returns:
+        List of agent names in dependency order
+
+    Raises:
+        CircularDependencyError: If circular dependency detected
+    """
+    return get_dependencies(name, agents, visited, path, AgentType.PARALLEL)

mcp_agent/human_input/handler.py

@@ -65,8 +65,11 @@ async def console_input_callback(request: HumanInputRequest) -> HumanInputRespon
                     toolbar_color="ansimagenta",
                 )
 
-            #            if response and (response.startswith("/") or response.startswith("@")):
-            await handle_special_commands(response)
+            # Handle special commands but ignore dictionary results as they require app context
+            command_result = await handle_special_commands(response)
+            if isinstance(command_result, dict) and "list_prompts" in command_result:
+                from rich import print as rich_print
+                rich_print("[yellow]Prompt listing not available in human input context[/yellow]")
 
         except KeyboardInterrupt:
             console.print("\n[yellow]Input interrupted[/yellow]")