fast-agent-mcp 0.2.5__tar.gz → 0.2.7__tar.gz

{fast_agent_mcp-0.2.5 → fast_agent_mcp-0.2.7}/.gitignore

@@ -190,3 +190,4 @@ tests/integration/workflow/orchestrator/fastagent.jsonl
 fastagent.jsonl
 tests/integration/resources/fastagent.jsonl
 fastagent.jsonl
+tests/e2e/workflow/weather_location.txt

{fast_agent_mcp-0.2.5 → fast_agent_mcp-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.2.5
+Version: 0.2.7
 Summary: Define, Prompt and Test MCP enabled Agents and Workflows
 Author-email: Shaun Smith <fastagent@llmindset.co.uk>, Sarmad Qadri <sarmad@lastmileai.dev>
 License:                                  Apache License
@@ -260,8 +260,7 @@ The simple declarative syntax lets you concentrate on composing your Prompts and
 
 `fast-agent` is multi-modal, supporting Images and PDFs for both Anthropic and OpenAI endpoints via Prompts, Resources and MCP Tool Call results. The inclusion of passthrough and playback LLMs enable rapid development and test of Python glue-code for your applications.
 
-> [!TIP]
-> `fast-agent` is now MCP Native! Coming Soon - Full Documentation Site and Further MCP Examples.
+> [!TIP] > `fast-agent` is now MCP Native! Coming Soon - Full Documentation Site and Further MCP Examples.
 
 ### Agent Application Development
 
@@ -525,7 +524,7 @@ agent["greeter"].send("Good Evening!")          # Dictionary access is supported
   servers=["filesystem"],                # list of MCP Servers for the agent
   model="o3-mini.high",                  # specify a model for the agent
   use_history=True,                      # agent maintains chat history
-  request_params={"temperature": 0.7},   # additional parameters for the LLM (or RequestParams())
+  request_params=RequestParams(temperature= 0.7)), # additional parameters for the LLM (or RequestParams())
   human_input=True,                      # agent can request human input
 )
 ```

{fast_agent_mcp-0.2.5 → fast_agent_mcp-0.2.7}/README.md

@@ -18,8 +18,7 @@ The simple declarative syntax lets you concentrate on composing your Prompts and
 
 `fast-agent` is multi-modal, supporting Images and PDFs for both Anthropic and OpenAI endpoints via Prompts, Resources and MCP Tool Call results. The inclusion of passthrough and playback LLMs enable rapid development and test of Python glue-code for your applications.
 
-> [!TIP]
-> `fast-agent` is now MCP Native! Coming Soon - Full Documentation Site and Further MCP Examples.
+> [!TIP] > `fast-agent` is now MCP Native! Coming Soon - Full Documentation Site and Further MCP Examples.
 
 ### Agent Application Development
 
@@ -283,7 +282,7 @@ agent["greeter"].send("Good Evening!")          # Dictionary access is supported
   servers=["filesystem"],                # list of MCP Servers for the agent
   model="o3-mini.high",                  # specify a model for the agent
   use_history=True,                      # agent maintains chat history
-  request_params={"temperature": 0.7},   # additional parameters for the LLM (or RequestParams())
+  request_params=RequestParams(temperature= 0.7)), # additional parameters for the LLM (or RequestParams())
   human_input=True,                      # agent can request human input
 )
 ```

{fast_agent_mcp-0.2.5 → fast_agent_mcp-0.2.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fast-agent-mcp"
-version = "0.2.5"
+version = "0.2.7"
 description = "Define, Prompt and Test MCP enabled Agents and Workflows"
 readme = "README.md"
 license = { file = "LICENSE" }

{fast_agent_mcp-0.2.5 → fast_agent_mcp-0.2.7}/src/mcp_agent/agents/agent.py

@@ -66,7 +66,7 @@ class Agent(BaseAgent):
         agent_name_str = str(self.name)
 
         # Create agent_types dictionary with just this agent
-        agent_types = {agent_name_str: getattr(self.config, "agent_type", "Agent")}
+        agent_types = {agent_name_str: self.agent_type}
 
         # Create the interactive prompt
         prompt = InteractivePrompt(agent_types=agent_types)

{fast_agent_mcp-0.2.5 → fast_agent_mcp-0.2.7}/src/mcp_agent/agents/base_agent.py

@@ -215,7 +215,7 @@ class BaseAgent(MCPAggregator, AgentProtocol):
 
         # Use the LLM to generate a response
         response = await self.generate([prompt], None)
-        return response.first_text()
+        return response.all_text()
 
     def _normalize_message_input(
         self, message: Union[str, PromptMessage, PromptMessageMultipart]
@@ -622,6 +622,18 @@ class BaseAgent(MCPAggregator, AgentProtocol):
         response = await self.generate(prompts, request_params)
         return response.first_text()
 
+    @property
+    def agent_type(self) -> str:
+        """
+        Return the type of this agent.
+
+        This is used for display purposes in the interactive prompt and other UI elements.
+
+        Returns:
+            String representing the agent type
+        """
+        return self.config.agent_type
+
     @property
     def message_history(self) -> List[PromptMessageMultipart]:
         """

{fast_agent_mcp-0.2.5 → fast_agent_mcp-0.2.7}/src/mcp_agent/agents/workflow/chain_agent.py

@@ -9,8 +9,9 @@ from typing import Any, List, Optional, Tuple, Type
 
 from mcp.types import TextContent
 
-from mcp_agent.agents.agent import Agent, AgentConfig
+from mcp_agent.agents.agent import Agent
 from mcp_agent.agents.base_agent import BaseAgent
+from mcp_agent.core.agent_types import AgentConfig, AgentType
 from mcp_agent.core.prompt import Prompt
 from mcp_agent.core.request_params import RequestParams
 from mcp_agent.mcp.interfaces import ModelT
@@ -23,6 +24,12 @@ class ChainAgent(BaseAgent):
     Passes the output of each agent to the next agent in the chain.
     """
 
+    # TODO -- consider adding "repeat" mode
+    @property
+    def agent_type(self) -> str:
+        """Return the type of this agent."""
+        return AgentType.CHAIN.value
+
     def __init__(
         self,
         config: AgentConfig,
@@ -64,20 +71,11 @@ class ChainAgent(BaseAgent):
         # # Get the original user message (last message in the list)
         user_message = multipart_messages[-1] if multipart_messages else None
 
-        # # If no user message, return an error
-        # if not user_message:
-        #     return PromptMessageMultipart(
-        #         role="assistant",
-        #         content=[TextContent(type="text", text="No input message provided.")],
-        #     )
-
-        # Initialize messages with the input
-
         if not self.cumulative:
             response: PromptMessageMultipart = await self.agents[0].generate(multipart_messages)
             # Process the rest of the agents in the chain
             for agent in self.agents[1:]:
-                next_message = Prompt.user(response.content[0].text)
+                next_message = Prompt.user(*response.content)
                 response = await agent.generate([next_message])
 
             return response

{fast_agent_mcp-0.2.5 → fast_agent_mcp-0.2.7}/src/mcp_agent/agents/workflow/evaluator_optimizer.py

@@ -14,6 +14,7 @@ from pydantic import BaseModel, Field
 
 from mcp_agent.agents.agent import Agent
 from mcp_agent.agents.base_agent import BaseAgent
+from mcp_agent.core.agent_types import AgentType
 from mcp_agent.core.exceptions import AgentConfigError
 from mcp_agent.core.prompt import Prompt
 from mcp_agent.core.request_params import RequestParams
@@ -63,6 +64,11 @@ class EvaluatorOptimizerAgent(BaseAgent):
     for refinement, continuing until a quality threshold is reached or a maximum
     number of refinement cycles is completed.
     """
+    
+    @property
+    def agent_type(self) -> str:
+        """Return the type of this agent."""
+        return AgentType.EVALUATOR_OPTIMIZER.value
 
     def __init__(
         self,

{fast_agent_mcp-0.2.5 → fast_agent_mcp-0.2.7}/src/mcp_agent/agents/workflow/orchestrator_agent.py

@@ -27,7 +27,7 @@ from mcp_agent.agents.workflow.orchestrator_prompts import (
     SYNTHESIZE_PLAN_PROMPT_TEMPLATE,
     TASK_PROMPT_TEMPLATE,
 )
-from mcp_agent.core.agent_types import AgentConfig
+from mcp_agent.core.agent_types import AgentConfig, AgentType
 from mcp_agent.core.exceptions import AgentConfigError
 from mcp_agent.core.prompt import Prompt
 from mcp_agent.core.request_params import RequestParams
@@ -46,6 +46,11 @@ class OrchestratorAgent(BaseAgent):
     to specialized worker agents, synthesizing their results into a cohesive output.
     Supports both full planning and iterative planning modes.
     """
+    
+    @property
+    def agent_type(self) -> str:
+        """Return the type of this agent."""
+        return AgentType.ORCHESTRATOR.value
 
     def __init__(
         self,

{fast_agent_mcp-0.2.5 → fast_agent_mcp-0.2.7}/src/mcp_agent/agents/workflow/parallel_agent.py

@@ -3,8 +3,9 @@ from typing import Any, List, Optional, Tuple
 
 from mcp.types import TextContent
 
-from mcp_agent.agents.agent import Agent, AgentConfig
+from mcp_agent.agents.agent import Agent
 from mcp_agent.agents.base_agent import BaseAgent
+from mcp_agent.core.agent_types import AgentConfig, AgentType
 from mcp_agent.core.request_params import RequestParams
 from mcp_agent.mcp.interfaces import ModelT
 from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
@@ -17,6 +18,11 @@ class ParallelAgent(BaseAgent):
     This workflow performs both the fan-out and fan-in operations using LLMs.
     From the user's perspective, an input is specified and the output is returned.
     """
+    
+    @property
+    def agent_type(self) -> str:
+        """Return the type of this agent."""
+        return AgentType.PARALLEL.value
 
     def __init__(
         self,

{fast_agent_mcp-0.2.5 → fast_agent_mcp-0.2.7}/src/mcp_agent/agents/workflow/router_agent.py

@@ -12,7 +12,7 @@ from pydantic import BaseModel
 
 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.agent_types import AgentConfig, AgentType
 from mcp_agent.core.exceptions import AgentConfigError
 from mcp_agent.core.prompt import Prompt
 from mcp_agent.core.request_params import RequestParams
@@ -53,12 +53,29 @@ You are a highly accurate request router that directs incoming requests to the m
 Your task is to analyze the request and determine the most appropriate agent from the options above.
 
 <fastagent:instruction>
-Respond in JSON format. NEVER include Code Fences:
+Respond with JSON following the schema below:
 {{
-    "agent": "<agent name>",
-    "confidence": "<high, medium or low>",
-    "reasoning": "<brief explanation>"
+    "type": "object",
+    "required": ["agent", "confidence", "reasoning"],
+    "properties": {{
+        "agent": {{
+            "type": "string",
+            "description": "The exact name of the selected agent"
+        }},
+        "confidence": {{
+            "type": "string",
+            "enum": ["high", "medium", "low"],
+            "description": "Your confidence level in this selection"
+        }},
+        "reasoning": {{
+            "type": "string",
+            "description": "Brief explanation for your selection"
+        }}
+    }}
 }}
+
+Supply only the JSON with no preamble. Use "reasoning" field to describe actions. NEVER EMIT CODE FENCES. 
+
 </fastagent:instruction>
 """
 
@@ -88,6 +105,11 @@ class RouterAgent(BaseAgent):
     then dispatches the request to that agent and returns the response.
     """
 
+    @property
+    def agent_type(self) -> str:
+        """Return the type of this agent."""
+        return AgentType.ROUTER.value
+
     def __init__(
         self,
         config: AgentConfig,

{fast_agent_mcp-0.2.5 → fast_agent_mcp-0.2.7}/src/mcp_agent/cli/commands/setup.py

@@ -73,7 +73,7 @@ mcp:
 
 GITIGNORE_TEMPLATE = """
 # FastAgent secrets file
-fastagent-secrets.yaml
+fastagent.secrets.yaml
 
 # Python
 __pycache__/
@@ -215,7 +215,7 @@ def init(
         if "fastagent.secrets.yaml" in created:
             console.print("\n[yellow]Important:[/yellow] Remember to:")
             console.print(
-                "1. Add your API keys to fastagent-secrets.yaml or set OPENAI_API_KEY and ANTHROPIC_API_KEY environment variables"
+                "1. Add your API keys to fastagent.secrets.yaml or set OPENAI_API_KEY and ANTHROPIC_API_KEY environment variables"
             )
             console.print(
                 "2. Keep fastagent.secrets.yaml secure and never commit it to version control"

{fast_agent_mcp-0.2.5 → fast_agent_mcp-0.2.7}/src/mcp_agent/config.py

@@ -75,6 +75,9 @@ class MCPServerSettings(BaseModel):
     url: str | None = None
     """The URL for the server (e.g. for SSE transport)."""
 
+    headers: Dict[str, str] | None = None
+    """Headers dictionary for SSE connections"""
+
     auth: MCPServerAuthSettings | None = None
     """The authentication configuration for the server."""
 
@@ -84,9 +87,6 @@ class MCPServerSettings(BaseModel):
     env: Dict[str, str] | None = None
     """Environment variables to pass to the server process."""
 
-    env: Dict[str, str] | None = None
-    """Environment variables to pass to the server process."""
-
     sampling: MCPSamplingSettings | None = None
     """Sampling settings for this Client/Server pair"""
 

{fast_agent_mcp-0.2.5 → fast_agent_mcp-0.2.7}/src/mcp_agent/core/agent_app.py

@@ -69,7 +69,7 @@ class AgentApp:
         if message:
             return await self._agent(agent_name).send(message)
 
-        return await self.interactive(agent_name=agent_name, default_prompt=default_prompt)
+        return await self.interactive(agent=agent_name, default_prompt=default_prompt)
 
     async def send(
         self,
@@ -220,9 +220,9 @@ class AgentApp:
         """
         Deprecated - use interactive() instead.
         """
-        return await self.interactive(agent_name=agent_name, default_prompt=default_prompt)
+        return await self.interactive(agent=agent_name, default_prompt=default_prompt)
 
-    async def interactive(self, agent_name: str | None = None, default_prompt: str = "") -> str:
+    async def interactive(self, agent: str | None = None, default_prompt: str = "") -> str:
         """
         Interactive prompt for sending messages with advanced features.
 
@@ -235,11 +235,11 @@ class AgentApp:
         """
 
         # Get the default agent name if none specified
-        if agent_name:
+        if agent:
             # Validate that this agent exists
-            if agent_name not in self._agents:
-                raise ValueError(f"Agent '{agent_name}' not found")
-            target_name = agent_name
+            if agent not in self._agents:
+                raise ValueError(f"Agent '{agent}' not found")
+            target_name = agent
         else:
             # Use the first agent's name as default
             target_name = next(iter(self._agents.keys()))
@@ -248,18 +248,7 @@ class AgentApp:
         # The agent's prompt method doesn't fully support switching between agents
 
         # Create agent_types dictionary mapping agent names to their types
-        agent_types = {}
-        for name, agent in self._agents.items():
-            # Determine agent type if possible
-            agent_type = "Agent"  # Default type
-
-            # Try to get the type from the agent directly
-            if hasattr(agent, "agent_type"):
-                agent_type = agent.agent_type
-            elif hasattr(agent, "config") and hasattr(agent.config, "agent_type"):
-                agent_type = agent.config.agent_type
-
-            agent_types[name] = agent_type
+        agent_types = {name: agent.agent_type for name, agent in self._agents.items()}
 
         # Create the interactive prompt
         prompt = InteractivePrompt(agent_types=agent_types)

{fast_agent_mcp-0.2.5 → fast_agent_mcp-0.2.7}/src/mcp_agent/core/agent_types.py

@@ -33,6 +33,7 @@ class AgentConfig:
     use_history: bool = True
     default_request_params: RequestParams | None = None
     human_input: bool = False
+    agent_type: str = AgentType.BASIC.value
 
     def __post_init__(self) -> None:
         """Ensure default_request_params exists with proper history setting"""

{fast_agent_mcp-0.2.5 → fast_agent_mcp-0.2.7}/src/mcp_agent/core/direct_decorators.py

@@ -269,6 +269,7 @@ def router(
     *,
     agents: List[str],
     instruction: Optional[str] = None,
+    servers: List[str] = [],
     model: Optional[str] = None,
     use_history: bool = False,
     request_params: RequestParams | None = None,
@@ -301,7 +302,7 @@ def router(
             AgentType.ROUTER,
             name=name,
             instruction=instruction or default_instruction,
-            servers=[],  # Routers don't connect to servers directly
+            servers=servers,
             model=model,
             use_history=use_history,
             request_params=request_params,

{fast_agent_mcp-0.2.5 → fast_agent_mcp-0.2.7}/src/mcp_agent/core/direct_factory.py

@@ -236,7 +236,7 @@ async def create_agents_by_type(
                     config=config,
                     context=app_instance.context,
                     agents=router_agents,
-                    routing_instruction=agent_data.get("routing_instruction"),
+                    routing_instruction=agent_data.get("instruction"),
                 )
                 await router.initialize()
 

{fast_agent_mcp-0.2.5 → fast_agent_mcp-0.2.7}/src/mcp_agent/core/fastagent.py

@@ -235,6 +235,8 @@ class FastAgent:
                     progress_display.stop()
 
                 # Pre-flight validation
+                if 0 == len(self.agents):
+                    raise AgentConfigError("No agents defined. Please define at least one agent.")
                 validate_server_references(self.context, self.agents)
                 validate_workflow_references(self.agents)
 

{fast_agent_mcp-0.2.5 → fast_agent_mcp-0.2.7}/src/mcp_agent/core/interactive_prompt.py

@@ -77,7 +77,7 @@ class InteractivePrompt:
         if agent not in available_agents:
             raise ValueError(f"No agent named '{agent}'")
 
-        # Create agent_types dictionary if not provided
+        # Ensure we track available agents in a set for fast lookup
         available_agents_set = set(available_agents)
 
         result = ""

{fast_agent_mcp-0.2.5 → fast_agent_mcp-0.2.7}/src/mcp_agent/llm/augmented_llm.py

@@ -32,6 +32,7 @@ from mcp_agent.llm.sampling_format_converter import (
     ProviderFormatConverter,
 )
 from mcp_agent.logging.logger import get_logger
+from mcp_agent.mcp.helpers.content_helpers import get_text
 from mcp_agent.mcp.interfaces import (
     AugmentedLLMProtocol,
     ModelT,
@@ -147,8 +148,11 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
         """Apply the prompt and return the result as a Pydantic model, or None if coercion fails"""
         try:
             result: PromptMessageMultipart = await self.generate(prompt, request_params)
-            json_data = from_json(result.first_text(), allow_partial=True)
+            final_generation = get_text(result.content[-1]) or ""
+            await self.show_assistant_message(final_generation)
+            json_data = from_json(final_generation, allow_partial=True)
             validated_model = model.model_validate(json_data)
+
             return cast("ModelT", validated_model), Prompt.assistant(json_data)
         except Exception as e:
             logger = get_logger(__name__)

{fast_agent_mcp-0.2.5 → fast_agent_mcp-0.2.7}/src/mcp_agent/llm/providers/augmented_llm_anthropic.py

@@ -1,5 +1,7 @@
 import os
-from typing import TYPE_CHECKING, List, Type
+from typing import TYPE_CHECKING, List
+
+from mcp.types import EmbeddedResource, ImageContent, TextContent
 
 from mcp_agent.core.prompt import Prompt
 from mcp_agent.llm.providers.multipart_converter_anthropic import (
@@ -28,13 +30,11 @@ from mcp.types import (
     CallToolRequest,
     CallToolRequestParams,
 )
-from pydantic_core import from_json
 from rich.text import Text
 
 from mcp_agent.core.exceptions import ProviderKeyError
 from mcp_agent.llm.augmented_llm import (
     AugmentedLLM,
-    ModelT,
     RequestParams,
 )
 from mcp_agent.logging.logger import get_logger
@@ -69,14 +69,15 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
             use_history=True,
         )
 
-    def _base_url(self) -> str:
+    def _base_url(self) -> str | None:
+        assert self.context.config
         return self.context.config.anthropic.base_url if self.context.config.anthropic else None
 
     async def generate_internal(
         self,
         message_param,
         request_params: RequestParams | None = None,
-    ):
+    ) -> list[TextContent | ImageContent | EmbeddedResource]:
         """
         Process a query using an LLM and available tools.
         Override this method to use a different LLM.
@@ -113,7 +114,7 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
             for tool in tool_list.tools
         ]
 
-        responses: List[Message] = []
+        responses: List[TextContent | ImageContent | EmbeddedResource] = []
 
         model = self.default_request_params.model
 
@@ -175,7 +176,8 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
 
             response_as_message = self.convert_message_to_message_param(response)
             messages.append(response_as_message)
-            responses.append(response)
+            if response.content[0].type == "text":
+                responses.append(TextContent(type="text", text=response.content[0].text))
 
             if response.stop_reason == "end_turn":
                 message_text = ""
@@ -255,6 +257,7 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
 
                         # Add each result to our collection
                         tool_results.append((tool_use_id, result))
+                        responses.extend(result.content)
 
                     messages.append(AnthropicConverter.create_tool_results_message(tool_results))
 
@@ -295,41 +298,22 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
 
         return api_key
 
-    async def generate_str(
+    async def generate_messages(
         self,
         message_param,
         request_params: RequestParams | None = None,
-    ) -> str:
+    ) -> PromptMessageMultipart:
         """
         Process a query using an LLM and available tools.
         The default implementation uses Claude as the LLM.
         Override this method to use a different LLM.
 
         """
-
-        responses: List[Message] = await self.generate_internal(
+        res = await self.generate_internal(
             message_param=message_param,
             request_params=request_params,
         )
-
-        final_text: List[str] = []
-
-        # Process all responses and collect all text content
-        for response in responses:
-            # Extract text content from each message
-            message_text = ""
-            for content in response.content:
-                if content.type == "text":
-                    # Extract text from text blocks
-                    message_text += content.text
-
-            # Only append non-empty text
-            if message_text:
-                final_text.append(message_text)
-
-        # TODO -- make tool detail inclusion behaviour configurable
-        # Join all collected text
-        return "\n".join(final_text)
+        return Prompt.assistant(*res)
 
     async def _apply_prompt_provider_specific(
         self,
@@ -352,30 +336,12 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
         if last_message.role == "user":
             self.logger.debug("Last message in prompt is from user, generating assistant response")
             message_param = AnthropicConverter.convert_to_anthropic(last_message)
-            return Prompt.assistant(await self.generate_str(message_param, request_params))
+            return await self.generate_messages(message_param, request_params)
         else:
             # For assistant messages: Return the last message content as text
             self.logger.debug("Last message in prompt is from assistant, returning it directly")
             return last_message
 
-    async def generate_structured(
-        self,
-        message: str,
-        response_model: Type[ModelT],
-        request_params: RequestParams | None = None,
-    ) -> ModelT:
-        # TODO -- simiar to the OAI version, we should create a tool call for the expected schema
-        response = await self.generate_str(
-            message=message,
-            request_params=request_params,
-        )
-        # Don't try to parse if we got no response
-        if not response:
-            self.logger.error("No response from generate_str")
-            return None
-
-        return response_model.model_validate(from_json(response, allow_partial=True))
-
     @classmethod
     def convert_message_to_message_param(cls, message: Message, **kwargs) -> MessageParam:
         """Convert a response object to an input parameter object to allow LLM calls to be chained."""