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

mcp_agent/core/proxies.py

@@ -28,30 +28,62 @@ class BaseAgentProxy:
         self._name = name
 
     async def __call__(self, message: Optional[str] = None) -> str:
-        """Allow: agent.researcher('message')"""
+        """Allow: agent.researcher('message') or just agent.researcher()"""
+        if message is None:
+            # When called with no arguments, use prompt() to open the interactive interface
+            return await self.prompt()
         return await self.send(message)
 
     async def send(self, message: Optional[str] = None) -> str:
         """Allow: agent.researcher.send('message')"""
         if message is None:
+            # For consistency with agent(), use prompt() to open the interactive interface
             return await self.prompt()
         return await self.generate_str(message)
 
     async def prompt(self, default_prompt: str = "") -> str:
         """Allow: agent.researcher.prompt()"""
-        return await self._app.prompt(self._name, default_prompt)
+        from mcp_agent.core.agent_app import AgentApp
+        
+        # First check if _app is directly an AgentApp
+        if isinstance(self._app, AgentApp):
+            return await self._app.prompt(self._name, default_prompt)
+            
+        # If not, check if it's an MCPApp with an _agent_app attribute
+        if hasattr(self._app, "_agent_app"):
+            agent_app = self._app._agent_app
+            if agent_app:
+                return await agent_app.prompt(self._name, default_prompt)
+        
+        # If we can't find an AgentApp, return an error message
+        return "ERROR: Cannot prompt() - AgentApp not found"
 
     async def generate_str(self, message: str) -> str:
         """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 +97,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"""
@@ -141,7 +200,7 @@ class ChainProxy(BaseAgentProxy):
 
         if self._cumulative:
             # Cumulative mode: each agent gets all previous responses
-            cumulative_response = f"<{first_agent}>\n{first_response}\n</{first_agent}>"
+            cumulative_response = f'<fastagent:response agent="{first_agent}">\n{first_response}\n</fastagent:response>'
 
             # Process subsequent agents with cumulative results
             for agent_name in self._sequence[1:]:
@@ -149,9 +208,7 @@ class ChainProxy(BaseAgentProxy):
                 # 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<{agent_name}>\n{agent_response}\n</{agent_name}>"
-                )
+                cumulative_response += f'\n\n<fastagent:response agent="{agent_name}">\n{agent_response}\n</fastagent:response>'
 
             return cumulative_response
         else:
@@ -163,4 +220,4 @@ class ChainProxy(BaseAgentProxy):
                 proxy = self._agent_proxies[agent_name]
                 current_message = await proxy.generate_str(current_message)
 
-            return current_message
+            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]")