fast-agent-mcp 0.3.6__py3-none-any.whl → 0.3.7__py3-none-any.whl

fast_agent/agents/mcp_agent.py

@@ -16,8 +16,6 @@ from typing import (
     Mapping,
     Optional,
     Sequence,
-    Tuple,
-    Type,
     TypeVar,
     Union,
 )
@@ -195,8 +193,9 @@ class McpAgent(ABC, ToolAgent):
                 server_instructions = ""
 
             # Replace the template variable
-            self.instruction = self.instruction.replace("{{serverInstructions}}", server_instructions)
-
+            self.instruction = self.instruction.replace(
+                "{{serverInstructions}}", server_instructions
+            )
 
         # Update default request params to match
         if self._default_request_params:
@@ -204,7 +203,9 @@ class McpAgent(ABC, ToolAgent):
 
         self.logger.debug(f"Applied instruction templates for agent {self._name}")
 
-    def _format_server_instructions(self, instructions_data: Dict[str, tuple[str | None, List[str]]]) -> str:
+    def _format_server_instructions(
+        self, instructions_data: Dict[str, tuple[str | None, List[str]]]
+    ) -> str:
         """
         Format server instructions with XML tags and tool lists.
 
@@ -228,7 +229,7 @@ class McpAgent(ABC, ToolAgent):
             tools_list = ", ".join(prefixed_tools) if prefixed_tools else "No tools available"
 
             formatted_parts.append(
-                f"<mcp-server name=\"{server_name}\">\n"
+                f'<mcp-server name="{server_name}">\n'
                 f"<tools>{tools_list}</tools>\n"
                 f"<instructions>\n{instructions}\n</instructions>\n"
                 f"</mcp-server>"
@@ -249,31 +250,31 @@ class McpAgent(ABC, ToolAgent):
     ) -> str:
         return await self.send(message)
 
-    async def send(
-        self,
-        message: Union[
-            str,
-            PromptMessage,
-            PromptMessageExtended,
-            Sequence[Union[str, PromptMessage, PromptMessageExtended]],
-        ],
-        request_params: RequestParams | None = None,
-    ) -> str:
-        """
-        Send a message to the agent and get a response.
-
-        Args:
-            message: Message content in various formats:
-                - String: Converted to a user PromptMessageExtended
-                - PromptMessage: Converted to PromptMessageExtended
-                - PromptMessageExtended: Used directly
-                - request_params: Optional request parameters
-
-        Returns:
-            The agent's response as a string
-        """
-        response = await self.generate(message, request_params)
-        return response.last_text() or ""
+    # async def send(
+    #     self,
+    #     message: Union[
+    #         str,
+    #         PromptMessage,
+    #         PromptMessageExtended,
+    #         Sequence[Union[str, PromptMessage, PromptMessageExtended]],
+    #     ],
+    #     request_params: RequestParams | None = None,
+    # ) -> str:
+    #     """
+    #     Send a message to the agent and get a response.
+
+    #     Args:
+    #         message: Message content in various formats:
+    #             - String: Converted to a user PromptMessageExtended
+    #             - PromptMessage: Converted to PromptMessageExtended
+    #             - PromptMessageExtended: Used directly
+    #             - request_params: Optional request parameters
+
+    #     Returns:
+    #         The agent's response as a string
+    #     """
+    #     response = await self.generate(message, request_params)
+    #     return response.last_text() or ""
 
     def _matches_pattern(self, name: str, pattern: str, server_name: str) -> bool:
         """
@@ -597,6 +598,7 @@ class McpAgent(ABC, ToolAgent):
             return PromptMessageExtended(role="user", tool_results={})
 
         tool_results: dict[str, CallToolResult] = {}
+        self._tool_loop_error = None
 
         # Cache available tool names (original, not namespaced) for display
         available_tools = [
@@ -613,6 +615,27 @@ class McpAgent(ABC, ToolAgent):
             namespaced_tool = self._aggregator._namespaced_tool_map.get(tool_name)
             display_tool_name = namespaced_tool.tool.name if namespaced_tool else tool_name
 
+            tool_available = False
+            if tool_name == HUMAN_INPUT_TOOL_NAME:
+                tool_available = True
+            elif namespaced_tool:
+                tool_available = True
+            else:
+                tool_available = any(
+                    candidate.tool.name == tool_name
+                    for candidate in self._aggregator._namespaced_tool_map.values()
+                )
+
+            if not tool_available:
+                error_message = f"Tool '{display_tool_name}' is not available"
+                self.logger.error(error_message)
+                self._mark_tool_loop_error(
+                    correlation_id=correlation_id,
+                    error_message=error_message,
+                    tool_results=tool_results,
+                )
+                break
+
             # Find the index of the current tool in available_tools for highlighting
             highlight_index = None
             try:
@@ -650,7 +673,7 @@ class McpAgent(ABC, ToolAgent):
                 # Show error result too
                 self.display.show_tool_result(name=self._name, result=error_result)
 
-        return PromptMessageExtended(role="user", tool_results=tool_results)
+        return self._finalize_tool_results(tool_results)
 
     async def apply_prompt_template(self, prompt_result: GetPromptResult, prompt_name: str) -> str:
         """
@@ -668,36 +691,36 @@ class McpAgent(ABC, ToolAgent):
         with self._tracer.start_as_current_span(f"Agent: '{self._name}' apply_prompt_template"):
             return await self._llm.apply_prompt_template(prompt_result, prompt_name)
 
-    async def structured(
-        self,
-        messages: Union[
-            str,
-            PromptMessage,
-            PromptMessageExtended,
-            List[Union[str, PromptMessage, PromptMessageExtended]],
-        ],
-        model: Type[ModelT],
-        request_params: RequestParams | None = None,
-    ) -> Tuple[ModelT | None, PromptMessageExtended]:
-        """
-        Apply the prompt and return the result as a Pydantic model.
-        Normalizes input messages and delegates to the attached LLM.
-
-        Args:
-            messages: Message(s) in various formats:
-                - String: Converted to a user PromptMessageExtended
-                - PromptMessage: Converted to PromptMessageExtended
-                - PromptMessageExtended: Used directly
-                - List of any combination of the above
-            model: The Pydantic model class to parse the result into
-            request_params: Optional parameters to configure the LLM request
-
-        Returns:
-            An instance of the specified model, or None if coercion fails
-        """
-
-        with self._tracer.start_as_current_span(f"Agent: '{self._name}' structured"):
-            return await super().structured(messages, model, request_params)
+    # async def structured(
+    #     self,
+    #     messages: Union[
+    #         str,
+    #         PromptMessage,
+    #         PromptMessageExtended,
+    #         Sequence[Union[str, PromptMessage, PromptMessageExtended]],
+    #     ],
+    #     model: Type[ModelT],
+    #     request_params: RequestParams | None = None,
+    # ) -> Tuple[ModelT | None, PromptMessageExtended]:
+    #     """
+    #     Apply the prompt and return the result as a Pydantic model.
+    #     Normalizes input messages and delegates to the attached LLM.
+
+    #     Args:
+    #         messages: Message(s) in various formats:
+    #             - String: Converted to a user PromptMessageExtended
+    #             - PromptMessage: Converted to PromptMessageExtended
+    #             - PromptMessageExtended: Used directly
+    #             - List of any combination of the above
+    #         model: The Pydantic model class to parse the result into
+    #         request_params: Optional parameters to configure the LLM request
+
+    #     Returns:
+    #         An instance of the specified model, or None if coercion fails
+    #     """
+
+    #     with self._tracer.start_as_current_span(f"Agent: '{self._name}' structured"):
+    #         return await super().structured(messages, model, request_params)
 
     async def apply_prompt_messages(
         self, prompts: List[PromptMessageExtended], request_params: RequestParams | None = None

fast_agent/agents/tool_agent.py

@@ -5,7 +5,7 @@ from mcp.types import CallToolResult, ListToolsResult, Tool
 
 from fast_agent.agents.agent_types import AgentConfig
 from fast_agent.agents.llm_agent import LlmAgent
-from fast_agent.constants import HUMAN_INPUT_TOOL_NAME
+from fast_agent.constants import FAST_AGENT_ERROR_CHANNEL, HUMAN_INPUT_TOOL_NAME
 from fast_agent.context import Context
 from fast_agent.core.logging.logger import get_logger
 from fast_agent.mcp.helpers.content_helpers import text_content
@@ -42,6 +42,7 @@ class ToolAgent(LlmAgent):
 
         self._execution_tools: dict[str, FastMCPTool] = {}
         self._tool_schemas: list[Tool] = []
+        self._tool_loop_error: str | None = None
 
         # Build a working list of tools and auto-inject human-input tool if missing
         working_tools: list[FastMCPTool | Callable] = list(tools) if tools else []
@@ -97,10 +98,19 @@ class ToolAgent(LlmAgent):
             )
 
             if LlmStopReason.TOOL_USE == result.stop_reason:
+                self._tool_loop_error = None
                 if self.config.use_history:
-                    messages = [await self.run_tools(result)]
+                    tool_message = await self.run_tools(result)
+                    if self._tool_loop_error:
+                        result.stop_reason = LlmStopReason.ERROR
+                        break
+                    messages = [tool_message]
                 else:
-                    messages.extend([result, await self.run_tools(result)])
+                    tool_message = await self.run_tools(result)
+                    if self._tool_loop_error:
+                        result.stop_reason = LlmStopReason.ERROR
+                        break
+                    messages.extend([result, tool_message])
             else:
                 break
 
@@ -123,12 +133,23 @@ class ToolAgent(LlmAgent):
             return PromptMessageExtended(role="user", tool_results={})
 
         tool_results: dict[str, CallToolResult] = {}
+        self._tool_loop_error = None
         # TODO -- use gather() for parallel results, update display
         available_tools = [t.name for t in (await self.list_tools()).tools]
         for correlation_id, tool_request in request.tool_calls.items():
             tool_name = tool_request.params.name
             tool_args = tool_request.params.arguments or {}
 
+            if tool_name not in self._execution_tools:
+                error_message = f"Tool '{tool_name}' is not available"
+                logger.error(error_message)
+                self._mark_tool_loop_error(
+                    correlation_id=correlation_id,
+                    error_message=error_message,
+                    tool_results=tool_results,
+                )
+                break
+
             # Find the index of the current tool in available_tools for highlighting
             highlight_index = None
             try:
@@ -151,7 +172,32 @@ class ToolAgent(LlmAgent):
             tool_results[correlation_id] = result
             self.display.show_tool_result(name=self.name, result=result)
 
-        return PromptMessageExtended(role="user", tool_results=tool_results)
+        return self._finalize_tool_results(tool_results)
+
+    def _mark_tool_loop_error(
+        self,
+        *,
+        correlation_id: str,
+        error_message: str,
+        tool_results: dict[str, CallToolResult],
+    ) -> None:
+        error_result = CallToolResult(
+            content=[text_content(error_message)],
+            isError=True,
+        )
+        tool_results[correlation_id] = error_result
+        self.display.show_tool_result(name=self.name, result=error_result)
+        self._tool_loop_error = error_message
+
+    def _finalize_tool_results(
+        self, tool_results: dict[str, CallToolResult]
+    ) -> PromptMessageExtended:
+        channels = None
+        if self._tool_loop_error:
+            channels = {
+                FAST_AGENT_ERROR_CHANNEL: [text_content(self._tool_loop_error)],
+            }
+        return PromptMessageExtended(role="user", tool_results=tool_results, channels=channels)
 
     async def list_tools(self) -> ListToolsResult:
         """Return available tools for this agent. Overridable by subclasses."""

fast_agent/cli/commands/go.py

@@ -40,7 +40,7 @@ async def _run_agent(
     """Async implementation to run an interactive agent."""
     from pathlib import Path
 
-    from fast_agent.mcp.prompts.prompt_load import load_prompt_multipart
+    from fast_agent.mcp.prompts.prompt_load import load_prompt
 
     # Create the FastAgent instance
 
@@ -110,7 +110,7 @@ async def _run_agent(
                     display = ConsoleDisplay(config=None)
                     display.show_parallel_results(agent.parallel)
                 elif prompt_file:
-                    prompt = load_prompt_multipart(Path(prompt_file))
+                    prompt = load_prompt(Path(prompt_file))
                     await agent.parallel.generate(prompt)
                     display = ConsoleDisplay(config=None)
                     display.show_parallel_results(agent.parallel)
@@ -135,7 +135,7 @@ async def _run_agent(
                     # Print the response and exit
                     print(response)
                 elif prompt_file:
-                    prompt = load_prompt_multipart(Path(prompt_file))
+                    prompt = load_prompt(Path(prompt_file))
                     response = await agent.agent.generate(prompt)
                     print(f"\nLoaded {len(prompt)} messages from prompt file '{prompt_file}'")
                     await agent.interactive()

fast_agent/constants.py

@@ -6,3 +6,5 @@ Global constants for fast_agent with minimal dependencies to avoid circular impo
 HUMAN_INPUT_TOOL_NAME = "__human_input"
 MCP_UI = "mcp-ui"
 REASONING = "reasoning"
+FAST_AGENT_ERROR_CHANNEL = "fast-agent-error"
+FAST_AGENT_REMOVED_METADATA_CHANNEL = "fast-agent-removed-meta"

fast_agent/core/agent_app.py

@@ -34,6 +34,8 @@ class AgentApp:
         Args:
             agents: Dictionary of agent instances keyed by name
         """
+        if len(agents) == 0:
+            raise ValueError("No agents provided!")
         self._agents = agents
 
     def __getitem__(self, key: str) -> AgentProtocol:

fast_agent/core/direct_factory.py

@@ -3,7 +3,8 @@ Direct factory functions for creating agent and workflow instances without proxi
 Implements type-safe factories with improved error handling.
 """
 
-from typing import Any, Dict, Optional, Protocol, TypeVar
+from functools import partial
+from typing import Any, Dict, List, Optional, Protocol, TypeVar
 
 from fast_agent.agents import McpAgent
 from fast_agent.agents.agent_types import AgentConfig, AgentType
@@ -379,6 +380,35 @@ async def create_agents_by_type(
     return result_agents
 
 
+async def active_agents_in_dependency_group(
+    app_instance: Core,
+    agents_dict: AgentConfigDict,
+    model_factory_func: ModelFactoryFunctionProtocol,
+    group: List[str],
+    active_agents: AgentDict,
+):
+    """
+    For each of the possible agent types, create agents and update the active agents dictionary.
+
+    Notice: This function modifies the active_agents dictionary in-place which is a feature (no copies).
+    """
+    type_of_agents = list(map(lambda c: (c, c.value), AgentType))
+    for agent_type, agent_type_value in type_of_agents:
+        agents_dict_local = {
+            name: agents_dict[name]
+            for name in group
+            if agents_dict[name]["type"] == agent_type_value
+        }
+        agents = await create_agents_by_type(
+            app_instance,
+            agents_dict_local,
+            agent_type,
+            model_factory_func,
+            active_agents,
+        )
+        active_agents.update(agents)
+
+
 async def create_agents_in_dependency_order(
     app_instance: Core,
     agents_dict: AgentConfigDict,
@@ -403,127 +433,16 @@ async def create_agents_in_dependency_order(
     # Create a dictionary to store all active agents/workflows
     active_agents: AgentDict = {}
 
+    active_agents_in_dependency_group_partial = partial(
+        active_agents_in_dependency_group,
+        app_instance,
+        agents_dict,
+        model_factory_func,
+    )
+
     # Create agent proxies for each group in dependency order
     for group in dependencies:
-        # Create basic agents first
-        # Note: We compare string values from config with the Enum's string value
-        if AgentType.BASIC.value in [agents_dict[name]["type"] for name in group]:
-            basic_agents = await create_agents_by_type(
-                app_instance,
-                {
-                    name: agents_dict[name]
-                    for name in group
-                    if agents_dict[name]["type"] == AgentType.BASIC.value
-                },
-                AgentType.BASIC,
-                model_factory_func,
-                active_agents,
-            )
-            active_agents.update(basic_agents)
-
-        # Create custom agents first
-        if AgentType.CUSTOM.value in [agents_dict[name]["type"] for name in group]:
-            basic_agents = await create_agents_by_type(
-                app_instance,
-                {
-                    name: agents_dict[name]
-                    for name in group
-                    if agents_dict[name]["type"] == AgentType.CUSTOM.value
-                },
-                AgentType.CUSTOM,
-                model_factory_func,
-                active_agents,
-            )
-            active_agents.update(basic_agents)
-
-        # Create parallel agents
-        if AgentType.PARALLEL.value in [agents_dict[name]["type"] for name in group]:
-            parallel_agents = await create_agents_by_type(
-                app_instance,
-                {
-                    name: agents_dict[name]
-                    for name in group
-                    if agents_dict[name]["type"] == AgentType.PARALLEL.value
-                },
-                AgentType.PARALLEL,
-                model_factory_func,
-                active_agents,
-            )
-            active_agents.update(parallel_agents)
-
-        # Create router agents
-        if AgentType.ROUTER.value in [agents_dict[name]["type"] for name in group]:
-            router_agents = await create_agents_by_type(
-                app_instance,
-                {
-                    name: agents_dict[name]
-                    for name in group
-                    if agents_dict[name]["type"] == AgentType.ROUTER.value
-                },
-                AgentType.ROUTER,
-                model_factory_func,
-                active_agents,
-            )
-            active_agents.update(router_agents)
-
-        # Create chain agents
-        if AgentType.CHAIN.value in [agents_dict[name]["type"] for name in group]:
-            chain_agents = await create_agents_by_type(
-                app_instance,
-                {
-                    name: agents_dict[name]
-                    for name in group
-                    if agents_dict[name]["type"] == AgentType.CHAIN.value
-                },
-                AgentType.CHAIN,
-                model_factory_func,
-                active_agents,
-            )
-            active_agents.update(chain_agents)
-
-        # Create evaluator-optimizer agents
-        if AgentType.EVALUATOR_OPTIMIZER.value in [agents_dict[name]["type"] for name in group]:
-            evaluator_agents = await create_agents_by_type(
-                app_instance,
-                {
-                    name: agents_dict[name]
-                    for name in group
-                    if agents_dict[name]["type"] == AgentType.EVALUATOR_OPTIMIZER.value
-                },
-                AgentType.EVALUATOR_OPTIMIZER,
-                model_factory_func,
-                active_agents,
-            )
-            active_agents.update(evaluator_agents)
-
-        if AgentType.ORCHESTRATOR.value in [agents_dict[name]["type"] for name in group]:
-            orchestrator_agents = await create_agents_by_type(
-                app_instance,
-                {
-                    name: agents_dict[name]
-                    for name in group
-                    if agents_dict[name]["type"] == AgentType.ORCHESTRATOR.value
-                },
-                AgentType.ORCHESTRATOR,
-                model_factory_func,
-                active_agents,
-            )
-            active_agents.update(orchestrator_agents)
-
-        # Create orchestrator2 agents last since they might depend on other agents
-        if AgentType.ITERATIVE_PLANNER.value in [agents_dict[name]["type"] for name in group]:
-            orchestrator2_agents = await create_agents_by_type(
-                app_instance,
-                {
-                    name: agents_dict[name]
-                    for name in group
-                    if agents_dict[name]["type"] == AgentType.ITERATIVE_PLANNER.value
-                },
-                AgentType.ITERATIVE_PLANNER,
-                model_factory_func,
-                active_agents,
-            )
-            active_agents.update(orchestrator2_agents)
+        await active_agents_in_dependency_group_partial(group, active_agents)
 
     return active_agents
 

fast_agent/core/fastagent.py

@@ -75,7 +75,7 @@ from fast_agent.core.validation import (
     validate_server_references,
     validate_workflow_references,
 )
-from fast_agent.mcp.prompts.prompt_load import load_prompt_multipart
+from fast_agent.mcp.prompts.prompt_load import load_prompt
 from fast_agent.ui.usage_display import display_usage_report
 
 if TYPE_CHECKING:
@@ -543,7 +543,7 @@ class FastAgent:
 
                     if hasattr(self.args, "prompt_file") and self.args.prompt_file:
                         agent_name = self.args.agent
-                        prompt: List[PromptMessageExtended] = load_prompt_multipart(
+                        prompt: List[PromptMessageExtended] = load_prompt(
                             Path(self.args.prompt_file)
                         )
                         if agent_name not in active_agents:

fast_agent/history/history_exporter.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Optional
 
-from fast_agent.mcp.prompt_serialization import save_messages_to_file
+from fast_agent.mcp.prompt_serialization import save_messages
 
 if TYPE_CHECKING:
     from fast_agent.interfaces import AgentProtocol
@@ -35,10 +35,10 @@ class HistoryExporter:
             The path that was written to.
         """
         # Determine a default filename when not provided
-        target = filename or f"{getattr(agent, 'name', 'assistant')}_prompts.txt"
+        target = filename or f"{getattr(agent, 'name', 'assistant')}.json"
 
         messages = agent.message_history
-        save_messages_to_file(messages, target)
+        save_messages(messages, target)
 
         # Return and optionally print a small confirmation
         return target

fast_agent/llm/fastagent_llm.py

@@ -198,7 +198,7 @@ class FastAgentLLM(ContextDependent, FastAgentLLMProtocol, Generic[MessageParamT
         if messages[-1].first_text().startswith("***SAVE_HISTORY"):
             parts: list[str] = messages[-1].first_text().split(" ", 1)
             filename: str = (
-                parts[1].strip() if len(parts) > 1 else f"{self.name or 'assistant'}_prompts.txt"
+                parts[1].strip() if len(parts) > 1 else f"{self.name or 'assistant'}.json"
             )
             await self._save_history(filename)
             return Prompt.assistant(f"History saved to {filename}")
@@ -589,10 +589,10 @@ class FastAgentLLM(ContextDependent, FastAgentLLMProtocol, Generic[MessageParamT
         Uses JSON format for .json files (MCP SDK compatible format) and
         delimited text format for other extensions.
         """
-        from fast_agent.mcp.prompt_serialization import save_messages_to_file
+        from fast_agent.mcp.prompt_serialization import save_messages
 
         # Save messages using the unified save function that auto-detects format
-        save_messages_to_file(self._message_history, filename)
+        save_messages(self._message_history, filename)
 
     @property
     def message_history(self) -> List[PromptMessageExtended]: