fast-agent-mcp 0.2.3__py3-none-any.whl → 0.2.5__py3-none-any.whl

mcp_agent/agents/workflow/evaluator_optimizer.py

@@ -8,7 +8,7 @@ or a maximum number of refinements is attempted.
 """
 
 from enum import Enum
-from typing import Any, List, Optional, Type
+from typing import Any, List, Optional, Tuple, Type
 
 from pydantic import BaseModel, Field
 
@@ -139,7 +139,7 @@ class EvaluatorOptimizerAgent(BaseAgent):
 
             # Create evaluation message and get structured evaluation result
             eval_message = Prompt.user(eval_prompt)
-            evaluation_result = await self.evaluator_agent.structured(
+            evaluation_result, _ = await self.evaluator_agent.structured(
                 [eval_message], EvaluationResult, request_params
             )
 
@@ -202,7 +202,7 @@ class EvaluatorOptimizerAgent(BaseAgent):
         prompt: List[PromptMessageMultipart],
         model: Type[ModelT],
         request_params: Optional[RequestParams] = None,
-    ) -> Optional[ModelT]:
+    ) -> Tuple[ModelT | None, PromptMessageMultipart]:
         """
         Generate an optimized response and parse it into a structured format.
 

mcp_agent/agents/workflow/orchestrator_agent.py

@@ -5,7 +5,7 @@ This workflow provides an implementation that manages complex tasks by
 dynamically planning, delegating to specialized agents, and synthesizing results.
 """
 
-from typing import Any, Dict, List, Literal, Optional, Type
+from typing import Any, Dict, List, Literal, Optional, Tuple, Type
 
 from mcp.types import TextContent
 
@@ -29,6 +29,7 @@ from mcp_agent.agents.workflow.orchestrator_prompts import (
 )
 from mcp_agent.core.agent_types import AgentConfig
 from mcp_agent.core.exceptions import AgentConfigError
+from mcp_agent.core.prompt import Prompt
 from mcp_agent.core.request_params import RequestParams
 from mcp_agent.logging.logger import get_logger
 from mcp_agent.mcp.interfaces import ModelT
@@ -117,7 +118,7 @@ class OrchestratorAgent(BaseAgent):
         prompt: List[PromptMessageMultipart],
         model: Type[ModelT],
         request_params: Optional[RequestParams] = None,
-    ) -> Optional[ModelT]:
+    ) -> Tuple[ModelT | None, PromptMessageMultipart]:
         """
         Execute an orchestration plan and parse the result into a structured format.
 
@@ -138,12 +139,11 @@ class OrchestratorAgent(BaseAgent):
             prompt_message = PromptMessageMultipart(
                 role="user", content=[TextContent(type="text", text=result_text)]
             )
-
-            # Use the LLM's structured parsing capability
+            assert self._llm
             return await self._llm.structured([prompt_message], model, request_params)
         except Exception as e:
             self.logger.warning(f"Failed to parse orchestration result: {str(e)}")
-            return None
+            return None, Prompt.assistant(f"Failed to parse orchestration result: {str(e)}")
 
     async def initialize(self) -> None:
         """Initialize the orchestrator agent and worker agents."""
@@ -429,7 +429,8 @@ class OrchestratorAgent(BaseAgent):
             plan_msg = PromptMessageMultipart(
                 role="user", content=[TextContent(type="text", text=prompt)]
             )
-            return await self._llm.structured([plan_msg], Plan, request_params)
+            plan, _ = await self._llm.structured([plan_msg], Plan, request_params)
+            return plan
         except Exception as e:
             self.logger.error(f"Failed to parse plan: {str(e)}")
             return None
@@ -483,7 +484,8 @@ class OrchestratorAgent(BaseAgent):
             plan_msg = PromptMessageMultipart(
                 role="user", content=[TextContent(type="text", text=prompt)]
             )
-            return await self._llm.structured([plan_msg], NextStep, request_params)
+            next_step, _ = await self._llm.structured([plan_msg], NextStep, request_params)
+            return next_step
         except Exception as e:
             self.logger.error(f"Failed to parse next step: {str(e)}")
             return None

mcp_agent/agents/workflow/parallel_agent.py

@@ -1,5 +1,5 @@
 import asyncio
-from typing import Any, List, Optional
+from typing import Any, List, Optional, Tuple
 
 from mcp.types import TextContent
 
@@ -113,7 +113,7 @@ class ParallelAgent(BaseAgent):
         prompt: List[PromptMessageMultipart],
         model: type[ModelT],
         request_params: Optional[RequestParams] = None,
-    ) -> Optional[ModelT]:
+    ) -> Tuple[ModelT | None, PromptMessageMultipart]:
         """
         Apply the prompt and return the result as a Pydantic model.
 

mcp_agent/agents/workflow/router_agent.py

@@ -5,7 +5,7 @@ This provides a simplified implementation that routes messages to agents
 by determining the best agent for a request and dispatching to it.
 """
 
-from typing import TYPE_CHECKING, List, Optional, Type
+from typing import TYPE_CHECKING, List, Optional, Tuple, Type
 
 from mcp.types import TextContent
 from pydantic import BaseModel
@@ -14,6 +14,7 @@ from mcp_agent.agents.agent import Agent
 from mcp_agent.agents.base_agent import BaseAgent
 from mcp_agent.core.agent_types import AgentConfig
 from mcp_agent.core.exceptions import AgentConfigError
+from mcp_agent.core.prompt import Prompt
 from mcp_agent.core.request_params import RequestParams
 from mcp_agent.logging.logger import get_logger
 from mcp_agent.mcp.interfaces import ModelT
@@ -73,7 +74,7 @@ class RoutingResponse(BaseModel):
 class RouterResult(BaseModel):
     """Router result with agent reference and confidence rating."""
 
-    result: Agent
+    result: BaseAgent
     confidence: str
     reasoning: Optional[str] = None
 
@@ -221,7 +222,7 @@ class RouterAgent(BaseAgent):
         prompt: List[PromptMessageMultipart],
         model: Type[ModelT],
         request_params: Optional[RequestParams] = None,
-    ) -> Optional[ModelT]:
+    ) -> Tuple[ModelT | None, PromptMessageMultipart]:
         """
         Route the request to the most appropriate agent and parse its response.
 
@@ -236,7 +237,7 @@ class RouterAgent(BaseAgent):
         routing_result = await self._get_routing_result(prompt)
 
         if not routing_result:
-            return None
+            return None, Prompt.assistant("No routing result")
 
         # Get the selected agent
         selected_agent = routing_result.result
@@ -287,7 +288,8 @@ class RouterAgent(BaseAgent):
         )
 
         # Get structured response from LLM
-        response = await self._llm.structured(
+        assert self._llm
+        response, _ = await self._llm.structured(
             [prompt], RoutingResponse, self._default_request_params
         )
 

mcp_agent/cli/main.py

@@ -62,6 +62,7 @@ def main(
     verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose mode"),
     quiet: bool = typer.Option(False, "--quiet", "-q", help="Disable output"),
     color: bool = typer.Option(True, "--color/--no-color", help="Enable/disable color output"),
+    version: bool = typer.Option(False, "--version", help="Show version and exit"),
 ) -> None:
     """FastAgent CLI - Build effective agents using Model Context Protocol (MCP).
 
@@ -70,6 +71,16 @@ def main(
     application.verbosity = 1 if verbose else 0 if not quiet else -1
     application.console = application.console if color else None
 
+    # Handle version flag
+    if version:
+        from importlib.metadata import version as get_version
+        try:
+            app_version = get_version("fast-agent-mcp")
+        except:  # noqa: E722
+            app_version = "unknown"
+        console.print(f"fast-agent-mcp v{app_version}")
+        raise typer.Exit()
+
     # Show welcome message if no command was invoked
     if ctx.invoked_subcommand is None:
         show_welcome()

mcp_agent/config.py

@@ -40,7 +40,7 @@ class MCPRootSettings(BaseModel):
     @classmethod
     def validate_uri(cls, v: str) -> str:
         """Validate that the URI starts with file:// (required by specification 2024-11-05)"""
-        if not v.startswith("file://"):
+        if v and not v.startswith("file://"):
             raise ValueError("Root URI must start with file://")
         return v
 
@@ -276,9 +276,9 @@ class Settings(BaseSettings):
         # Check current directory and parent directories
         while current_dir != current_dir.parent:
             for filename in [
+                "fastagent.config.yaml",
                 "mcp-agent.config.yaml",
                 "mcp_agent.config.yaml",
-                "fastagent.config.yaml",
             ]:
                 config_path = current_dir / filename
                 if config_path.exists():
@@ -306,15 +306,33 @@ def get_settings(config_path: str | None = None) -> Settings:
         return merged
 
     global _settings
-    if _settings:
+
+    # If we have a specific config path, always reload settings
+    # This ensures each test gets its own config
+    if config_path:
+        # Reset for the new path
+        _settings = None
+    elif _settings:
+        # Use cached settings only for no specific path
         return _settings
 
-    config_file = Path(config_path) if config_path else Settings.find_config()
+    # Handle config path - convert string to Path if needed
+    if config_path:
+        config_file = Path(config_path)
+        # If it's a relative path and doesn't exist, try finding it
+        if not config_file.is_absolute() and not config_file.exists():
+            # Try resolving against current directory first
+            resolved_path = Path.cwd() / config_file.name
+            if resolved_path.exists():
+                config_file = resolved_path
+    else:
+        config_file = Settings.find_config()
+
     merged_settings = {}
 
     if config_file:
         if not config_file.exists():
-            pass
+            print(f"Warning: Specified config file does not exist: {config_file}")
         else:
             import yaml  # pylint: disable=C0415
 
@@ -326,11 +344,14 @@ def get_settings(config_path: str | None = None) -> Settings:
             # but stop after finding the first one
             current_dir = config_file.parent
             found_secrets = False
+            # Start with the absolute path of the config file's directory
+            current_dir = config_file.parent.resolve()
+
             while current_dir != current_dir.parent and not found_secrets:
                 for secrets_filename in [
+                    "fastagent.secrets.yaml",
                     "mcp-agent.secrets.yaml",
                     "mcp_agent.secrets.yaml",
-                    "fastagent.secrets.yaml",
                 ]:
                     secrets_file = current_dir / secrets_filename
                     if secrets_file.exists():
@@ -340,7 +361,8 @@ def get_settings(config_path: str | None = None) -> Settings:
                             found_secrets = True
                             break
                 if not found_secrets:
-                    current_dir = current_dir.parent
+                    # Get the absolute path of the parent directory
+                    current_dir = current_dir.parent.resolve()
 
             _settings = Settings(**merged_settings)
             return _settings

mcp_agent/context.py

@@ -234,5 +234,7 @@ def get_current_context() -> Context:
 def get_current_config():
     """
     Get the current application config.
+    
+    Returns the context config if available, otherwise falls back to global settings.
     """
     return get_current_context().config or get_settings()

mcp_agent/core/{direct_agent_app.py → agent_app.py}

@@ -2,14 +2,17 @@
 Direct AgentApp implementation for interacting with agents without proxies.
 """
 
-from typing import Dict, Optional, Union
+from typing import Dict, List, Optional, Union
+
+from deprecated import deprecated
+from mcp.types import PromptMessage
 
 from mcp_agent.agents.agent import Agent
 from mcp_agent.core.interactive_prompt import InteractivePrompt
 from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 
 
-class DirectAgentApp:
+class AgentApp:
     """
     Container for active agents that provides a simple API for interacting with them.
     This implementation works directly with Agent instances without proxies.
@@ -44,7 +47,7 @@ class DirectAgentApp:
 
     async def __call__(
         self,
-        message: Union[str, PromptMessageMultipart] | None = None,
+        message: Union[str, PromptMessage, PromptMessageMultipart] | None = None,
         agent_name: str | None = None,
         default_prompt: str = "",
     ) -> str:
@@ -53,9 +56,12 @@ class DirectAgentApp:
         This mirrors the FastAgent implementation that allowed agent("message").
 
         Args:
-            message: The message to send
+            message: Message content in various formats:
+                - String: Converted to a user PromptMessageMultipart
+                - PromptMessage: Converted to PromptMessageMultipart
+                - PromptMessageMultipart: Used directly
             agent_name: Optional name of the agent to send to (defaults to first agent)
-            default: Default message to use in interactive prompt mode
+            default_prompt: Default message to use in interactive prompt mode
 
         Returns:
             The agent's response as a string or the result of the interactive session
@@ -63,14 +69,21 @@ class DirectAgentApp:
         if message:
             return await self._agent(agent_name).send(message)
 
-        return await self._agent(agent_name).prompt(default_prompt=default_prompt)
+        return await self.interactive(agent_name=agent_name, default_prompt=default_prompt)
 
-    async def send(self, message: str, agent_name: Optional[str] = None) -> str:
+    async def send(
+        self,
+        message: Union[str, PromptMessage, PromptMessageMultipart],
+        agent_name: Optional[str] = None,
+    ) -> str:
         """
         Send a message to the specified agent (or to all agents).
 
         Args:
-            message: The message to send
+            message: Message content in various formats:
+                - String: Converted to a user PromptMessageMultipart
+                - PromptMessage: Converted to PromptMessageMultipart
+                - PromptMessageMultipart: Used directly
             agent_name: Optional name of the agent to send to
 
         Returns:
@@ -97,32 +110,119 @@ class DirectAgentApp:
 
         Args:
             prompt_name: Name of the prompt template to apply
-            agent_name: Name of the agent to send to
             arguments: Optional arguments for the prompt template
+            agent_name: Name of the agent to send to
 
         Returns:
             The agent's response as a string
         """
         return await self._agent(agent_name).apply_prompt(prompt_name, arguments)
 
-    async def list_prompts(self, agent_name: str | None = None):
+    async def list_prompts(self, server_name: str | None = None, agent_name: str | None = None):
         """
         List available prompts for an agent.
 
         Args:
+            server_name: Optional name of the server to list prompts from
             agent_name: Name of the agent to list prompts for
 
         Returns:
             Dictionary mapping server names to lists of available prompts
         """
-        return await self._agent(agent_name).list_prompts()
+        return await self._agent(agent_name).list_prompts(server_name=server_name)
+
+    async def get_prompt(
+        self,
+        prompt_name: str,
+        arguments: Dict[str, str] | None = None,
+        server_name: str | None = None,
+        agent_name: str | None = None,
+    ):
+        """
+        Get a prompt from a server.
+
+        Args:
+            prompt_name: Name of the prompt, optionally namespaced
+            arguments: Optional dictionary of arguments to pass to the prompt template
+            server_name: Optional name of the server to get the prompt from
+            agent_name: Name of the agent to use
 
-    async def with_resource(self, user_prompt: str, server_name: str, resource_name: str) -> str:
-        return await self._agent(None).with_resource(
-            prompt_content=user_prompt, server_name=server_name, resource_name=resource_name
+        Returns:
+            GetPromptResult containing the prompt information
+        """
+        return await self._agent(agent_name).get_prompt(
+            prompt_name=prompt_name, arguments=arguments, server_name=server_name
         )
 
-    async def prompt(self, agent_name: Optional[str] = None, default_prompt: str = "") -> str:
+    async def with_resource(
+        self,
+        prompt_content: Union[str, PromptMessage, PromptMessageMultipart],
+        resource_uri: str,
+        server_name: str | None = None,
+        agent_name: str | None = None,
+    ) -> str:
+        """
+        Send a message with an attached MCP resource.
+
+        Args:
+            prompt_content: Content in various formats (String, PromptMessage, or PromptMessageMultipart)
+            resource_uri: URI of the resource to retrieve
+            server_name: Optional name of the MCP server to retrieve the resource from
+            agent_name: Name of the agent to use
+
+        Returns:
+            The agent's response as a string
+        """
+        return await self._agent(agent_name).with_resource(
+            prompt_content=prompt_content, resource_uri=resource_uri, server_name=server_name
+        )
+
+    async def list_resources(
+        self,
+        server_name: str | None = None,
+        agent_name: str | None = None,
+    ) -> Dict[str, List[str]]:
+        """
+        List available resources from one or all servers.
+
+        Args:
+            server_name: Optional server name to list resources from
+            agent_name: Name of the agent to use
+
+        Returns:
+            Dictionary mapping server names to lists of resource URIs
+        """
+        return await self._agent(agent_name).list_resources(server_name=server_name)
+
+    async def get_resource(
+        self,
+        resource_uri: str,
+        server_name: str | None = None,
+        agent_name: str | None = None,
+    ):
+        """
+        Get a resource from an MCP server.
+
+        Args:
+            resource_uri: URI of the resource to retrieve
+            server_name: Optional name of the MCP server to retrieve the resource from
+            agent_name: Name of the agent to use
+
+        Returns:
+            ReadResourceResult object containing the resource content
+        """
+        return await self._agent(agent_name).get_resource(
+            resource_uri=resource_uri, server_name=server_name
+        )
+
+    @deprecated
+    async def prompt(self, agent_name: str | None = None, default_prompt: str = "") -> str:
+        """
+        Deprecated - use interactive() instead.
+        """
+        return await self.interactive(agent_name=agent_name, default_prompt=default_prompt)
+
+    async def interactive(self, agent_name: str | None = None, default_prompt: str = "") -> str:
         """
         Interactive prompt for sending messages with advanced features.
 

mcp_agent/core/direct_factory.py

@@ -147,11 +147,8 @@ async def create_agents_by_type(
                 await agent.initialize()
 
                 # Attach LLM to the agent
-                llm_factory = model_factory_func(
-                    model=config.model,
-                    request_params=config.default_request_params,
-                )
-                await agent.attach_llm(llm_factory)
+                llm_factory = model_factory_func(model=config.model)
+                await agent.attach_llm(llm_factory, request_params=config.default_request_params)
                 result_agents[name] = agent
 
             elif agent_type == AgentType.ORCHESTRATOR:
@@ -183,11 +180,10 @@ async def create_agents_by_type(
                 await orchestrator.initialize()
 
                 # Attach LLM to the orchestrator
-                llm_factory = model_factory_func(
-                    model=config.model,
-                    request_params=config.default_request_params,
+                llm_factory = model_factory_func(model=config.model)
+                await orchestrator.attach_llm(
+                    llm_factory, request_params=config.default_request_params
                 )
-                await orchestrator.attach_llm(llm_factory)
 
                 result_agents[name] = orchestrator
 
@@ -201,9 +197,7 @@ async def create_agents_by_type(
                     # Create default fan-in agent with auto-generated name
                     fan_in_name = f"{name}_fan_in"
                     fan_in_agent = await _create_default_fan_in_agent(
-                        fan_in_name,
-                        app_instance.context, 
-                        model_factory_func
+                        fan_in_name, app_instance.context, model_factory_func
                     )
                     # Add to result_agents so it's registered properly
                     result_agents[fan_in_name] = fan_in_agent
@@ -247,11 +241,8 @@ async def create_agents_by_type(
                 await router.initialize()
 
                 # Attach LLM to the router
-                llm_factory = model_factory_func(
-                    model=config.model,
-                    request_params=config.default_request_params,
-                )
-                await router.attach_llm(llm_factory)
+                llm_factory = model_factory_func(model=config.model)
+                await router.attach_llm(llm_factory, request_params=config.default_request_params)
                 result_agents[name] = router
 
             elif agent_type == AgentType.CHAIN:
@@ -459,7 +450,7 @@ async def _create_default_fan_in_agent(
     default_config = AgentConfig(
         name=fan_in_name,
         model="passthrough",
-        instruction="You are a passthrough agent that combines outputs from parallel agents."
+        instruction="You are a passthrough agent that combines outputs from parallel agents.",
     )
 
     # Create and initialize the default agent

mcp_agent/core/enhanced_prompt.py

@@ -291,7 +291,7 @@ async def get_enhanced_input(
                 return f"SELECT_PROMPT:{cmd_parts[1].strip()}"
             elif cmd == "exit":
                 return "EXIT"
-            elif cmd == "stop":
+            elif cmd.lower() == "stop":
                 return "STOP"
 
         # Agent switching
@@ -420,7 +420,7 @@ async def get_argument_input(
             prompt_session.app.exit()
 
 
-async def handle_special_commands(command, agent_app=None):
+async def handle_special_commands(command: str, agent_app=None):
     """Handle special input commands."""
     # Quick guard for empty or None commands
     if not command:
@@ -450,7 +450,7 @@ async def handle_special_commands(command, agent_app=None):
         print("\033c", end="")
         return True
 
-    elif command == "EXIT":
+    elif command.upper() == "EXIT":
         raise PromptExitError("User requested to exit fast-agent session")
 
     elif command == "LIST_AGENTS":