fast-agent-mcp 0.2.58__py3-none-any.whl → 0.3.1__py3-none-any.whl

fast_agent/agents/tool_agent.py

@@ -0,0 +1,168 @@
+from typing import Any, Callable, Dict, List
+
+from mcp.server.fastmcp.tools.base import Tool as FastMCPTool
+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.context import Context
+from fast_agent.core.logging.logger import get_logger
+from fast_agent.mcp.helpers.content_helpers import text_content
+from fast_agent.tools.elicitation import get_elicitation_fastmcp_tool
+from fast_agent.types import PromptMessageExtended, RequestParams
+from fast_agent.types.llm_stop_reason import LlmStopReason
+
+logger = get_logger(__name__)
+
+DEFAULT_MAX_TOOL_CALLS = 20
+
+
+# should we have MAX_TOOL_CALLS instead to constrain by number of tools rather than turns...?
+DEFAULT_MAX_ITERATIONS = 20
+"""Maximum number of User/Assistant turns to take"""
+
+
+class ToolAgent(LlmAgent):
+    """
+    A Tool Calling agent that uses FastMCP Tools for execution.
+
+    Pass either:
+    - FastMCP Tool objects (created via Tool.from_function)
+    - Regular Python functions (will be wrapped as FastMCP Tools)
+    """
+
+    def __init__(
+        self,
+        config: AgentConfig,
+        tools: list[FastMCPTool | Callable] = [],
+        context: Context | None = None,
+    ) -> None:
+        super().__init__(config=config, context=context)
+
+        self._execution_tools: dict[str, FastMCPTool] = {}
+        self._tool_schemas: list[Tool] = []
+
+        # Build a working list of tools and auto-inject human-input tool if missing
+        working_tools: list[FastMCPTool | Callable] = list(tools) if tools else []
+        # Only auto-inject if enabled via AgentConfig
+        if self.config.human_input:
+            existing_names = {
+                t.name if isinstance(t, FastMCPTool) else getattr(t, "__name__", "")
+                for t in working_tools
+            }
+            if HUMAN_INPUT_TOOL_NAME not in existing_names:
+                try:
+                    working_tools.append(get_elicitation_fastmcp_tool())
+                except Exception as e:
+                    logger.warning(f"Failed to initialize human-input tool: {e}")
+
+        for tool in working_tools:
+            if isinstance(tool, FastMCPTool):
+                fast_tool = tool
+            elif callable(tool):
+                fast_tool = FastMCPTool.from_function(tool)
+            else:
+                logger.warning(f"Skipping unknown tool type: {type(tool)}")
+                continue
+
+            self._execution_tools[fast_tool.name] = fast_tool
+            # Create MCP Tool schema for the LLM interface
+            self._tool_schemas.append(
+                Tool(
+                    name=fast_tool.name,
+                    description=fast_tool.description,
+                    inputSchema=fast_tool.parameters,
+                )
+            )
+
+    async def generate_impl(
+        self,
+        messages: List[PromptMessageExtended],
+        request_params: RequestParams | None = None,
+        tools: List[Tool] | None = None,
+    ) -> PromptMessageExtended:
+        """
+        Generate a response using the LLM, and handle tool calls if necessary.
+        Messages are already normalized to List[PromptMessageExtended].
+        """
+        if tools is None:
+            tools = (await self.list_tools()).tools
+
+        iterations = 0
+
+        while True:
+            result = await super().generate_impl(
+                messages, request_params=request_params, tools=tools
+            )
+
+            if LlmStopReason.TOOL_USE == result.stop_reason:
+                messages = [await self.run_tools(result)]
+            else:
+                break
+
+            iterations += 1
+            if iterations > DEFAULT_MAX_ITERATIONS:
+                logger.warning("Max iterations reached, stopping tool loop")
+                break
+        return result
+
+    # we take care of tool results, so skip displaying them
+    def show_user_message(self, message: PromptMessageExtended) -> None:
+        if message.tool_results:
+            return
+        super().show_user_message(message)
+
+    async def run_tools(self, request: PromptMessageExtended) -> PromptMessageExtended:
+        """Runs the tools in the request, and returns a new User message with the results"""
+        if not request.tool_calls:
+            logger.warning("No tool calls found in request", data=request)
+            return PromptMessageExtended(role="user", tool_results={})
+
+        tool_results: dict[str, CallToolResult] = {}
+        # 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 {}
+            self.display.show_tool_call(
+                name=self.name,
+                tool_args=tool_args,
+                bottom_items=available_tools,
+                tool_name=tool_name,
+                max_item_length=12,
+            )
+
+            # Delegate to call_tool for execution (overridable by subclasses)
+            result = await self.call_tool(tool_name, tool_args)
+            tool_results[correlation_id] = result
+            self.display.show_tool_result(name=self.name, result=result)
+
+        return PromptMessageExtended(role="user", tool_results=tool_results)
+
+    async def list_tools(self) -> ListToolsResult:
+        """Return available tools for this agent. Overridable by subclasses."""
+        return ListToolsResult(tools=list(self._tool_schemas))
+
+    async def call_tool(self, name: str, arguments: Dict[str, Any] | None = None) -> CallToolResult:
+        """Execute a tool by name using local FastMCP tools. Overridable by subclasses."""
+        fast_tool = self._execution_tools.get(name)
+        if not fast_tool:
+            logger.warning(f"Unknown tool: {name}")
+            return CallToolResult(
+                content=[text_content(f"Unknown tool: {name}")],
+                isError=True,
+            )
+
+        try:
+            result = await fast_tool.run(arguments or {}, convert_result=False)
+            return CallToolResult(
+                content=[text_content(str(result))],
+                isError=False,
+            )
+        except Exception as e:
+            logger.error(f"Tool {name} failed: {e}")
+            return CallToolResult(
+                content=[text_content(f"Error: {str(e)}")],
+                isError=True,
+            )

{mcp_agent → fast_agent}/agents/workflow/chain_agent.py

@@ -7,18 +7,20 @@ other agents, chaining their outputs together.
 
 from typing import Any, List, Optional, Tuple, Type
 
+from mcp import Tool
 from mcp.types import TextContent
 
-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
-from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+from fast_agent.agents.agent_types import AgentConfig, AgentType
+from fast_agent.agents.llm_agent import LlmAgent
+from fast_agent.core.logging.logger import get_logger
+from fast_agent.core.prompt import Prompt
+from fast_agent.interfaces import ModelT
+from fast_agent.types import PromptMessageExtended, RequestParams
 
+logger = get_logger(__name__)
 
-class ChainAgent(BaseAgent):
+
+class ChainAgent(LlmAgent):
     """
     A chain agent that processes requests through a series of specialized agents in sequence.
     Passes the output of each agent to the next agent in the chain.
@@ -33,7 +35,7 @@ class ChainAgent(BaseAgent):
     def __init__(
         self,
         config: AgentConfig,
-        agents: List[Agent],
+        agents: List[LlmAgent],
         cumulative: bool = False,
         context: Optional[Any] = None,
         **kwargs,
@@ -52,50 +54,61 @@ class ChainAgent(BaseAgent):
         self.agents = agents
         self.cumulative = cumulative
 
-    async def generate(
+    async def generate_impl(
         self,
-        multipart_messages: List[PromptMessageMultipart],
+        messages: List[PromptMessageExtended],
         request_params: Optional[RequestParams] = None,
-    ) -> PromptMessageMultipart:
+        tools: List[Tool] | None = None,
+    ) -> PromptMessageExtended:
         """
         Chain the request through multiple agents in sequence.
 
         Args:
-            multipart_messages: Initial messages to send to the first agent
+            normalized_messages: Already normalized list of PromptMessageExtended
             request_params: Optional request parameters
 
         Returns:
             The response from the final agent in the chain
         """
-
-        # # Get the original user message (last message in the list)
-        user_message = multipart_messages[-1] if multipart_messages else None
+        # Get the original user message (last message in the list)
+        user_message = messages[-1]
 
         if not self.cumulative:
-            response: PromptMessageMultipart = await self.agents[0].generate(multipart_messages)
+            response: PromptMessageExtended = await self.agents[0].generate(
+                messages, request_params
+            )
             # Process the rest of the agents in the chain
             for agent in self.agents[1:]:
                 next_message = Prompt.user(*response.content)
-                response = await agent.generate([next_message])
+                response = await agent.generate([next_message], request_params)
 
             return response
 
         # Track all responses in the chain
-        all_responses: List[PromptMessageMultipart] = []
+        all_responses: List[PromptMessageExtended] = []
 
         # Initialize list for storing formatted results
         final_results: List[str] = []
 
         # Add the original request with XML tag
-        request_text = f"<fastagent:request>{user_message.all_text()}</fastagent:request>"
+        request_text = (
+            f"<fastagent:request>{user_message.all_text() or '<no response>'}</fastagent:request>"
+        )
         final_results.append(request_text)
 
         # Process through each agent in sequence
         for i, agent in enumerate(self.agents):
             # In cumulative mode, include the original message and all previous responses
-            chain_messages = multipart_messages.copy()
-            chain_messages.extend(all_responses)
-            current_response = await agent.generate(chain_messages, request_params)
+            chain_messages = messages.copy()
+
+            # Convert previous assistant responses to user messages for the next agent
+            for prev_response in all_responses:
+                chain_messages.append(Prompt.user(prev_response.all_text()))
+
+            current_response = await agent.generate(
+                chain_messages,
+                request_params,
+            )
 
             # Store the response
             all_responses.append(current_response)
@@ -106,22 +119,19 @@ class ChainAgent(BaseAgent):
             )
             final_results.append(attributed_response)
 
-            if i < len(self.agents) - 1:
-                [Prompt.user(current_response.all_text())]
-
         # For cumulative mode, return the properly formatted output with XML tags
         response_text = "\n\n".join(final_results)
-        return PromptMessageMultipart(
+        return PromptMessageExtended(
             role="assistant",
             content=[TextContent(type="text", text=response_text)],
         )
 
-    async def structured(
+    async def structured_impl(
         self,
-        prompt: List[PromptMessageMultipart],
+        messages: List[PromptMessageExtended],
         model: Type[ModelT],
         request_params: Optional[RequestParams] = None,
-    ) -> Tuple[ModelT | None, PromptMessageMultipart]:
+    ) -> Tuple[ModelT | None, PromptMessageExtended]:
         """
         Chain the request through multiple agents and parse the final response.
 
@@ -134,12 +144,12 @@ class ChainAgent(BaseAgent):
             The parsed response from the final agent, or None if parsing fails
         """
         # Generate response through the chain
-        response = await self.generate(prompt, request_params)
+        response = await self.generate(messages, request_params)
         last_agent = self.agents[-1]
         try:
             return await last_agent.structured([response], model, request_params)
         except Exception as e:
-            self.logger.warning(f"Failed to parse response from chain: {str(e)}")
+            logger.warning(f"Failed to parse response from chain: {str(e)}")
             return None, Prompt.assistant("Failed to parse response from chain: {str(e)}")
 
     async def initialize(self) -> None:
@@ -164,4 +174,4 @@ class ChainAgent(BaseAgent):
             try:
                 await agent.shutdown()
             except Exception as e:
-                self.logger.warning(f"Error shutting down agent in chain: {str(e)}")
+                logger.warning(f"Error shutting down agent in chain: {str(e)}")

{mcp_agent → fast_agent}/agents/workflow/evaluator_optimizer.py

@@ -10,17 +10,16 @@ or a maximum number of refinements is attempted.
 from enum import Enum
 from typing import Any, List, Optional, Tuple, Type
 
+from mcp import Tool
 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
-from mcp_agent.logging.logger import get_logger
-from mcp_agent.mcp.interfaces import ModelT
-from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+from fast_agent.agents.agent_types import AgentConfig, AgentType
+from fast_agent.agents.llm_agent import LlmAgent
+from fast_agent.core.exceptions import AgentConfigError
+from fast_agent.core.logging.logger import get_logger
+from fast_agent.core.prompt import Prompt
+from fast_agent.interfaces import AgentProtocol, ModelT
+from fast_agent.types import PromptMessageExtended, RequestParams
 
 logger = get_logger(__name__)
 
@@ -54,7 +53,7 @@ class EvaluationResult(BaseModel):
     )
 
 
-class EvaluatorOptimizerAgent(BaseAgent):
+class EvaluatorOptimizerAgent(LlmAgent):
     """
     An agent that implements the evaluator-optimizer workflow pattern.
 
@@ -70,9 +69,9 @@ class EvaluatorOptimizerAgent(BaseAgent):
 
     def __init__(
         self,
-        config: Agent,
-        generator_agent: Agent,
-        evaluator_agent: Agent,
+        config: AgentConfig,
+        generator_agent: AgentProtocol,
+        evaluator_agent: AgentProtocol,
         min_rating: QualityRating = QualityRating.GOOD,
         max_refinements: int = 3,
         context: Optional[Any] = None,
@@ -83,8 +82,8 @@ class EvaluatorOptimizerAgent(BaseAgent):
 
         Args:
             config: Agent configuration or name
-            generator_agent: Agent that generates the initial and refined responses
-            evaluator_agent: Agent that evaluates responses and provides feedback
+            generator_agent: LlmAgent that generates the initial and refined responses
+            evaluator_agent: LlmAgent that evaluates responses and provides feedback
             min_rating: Minimum acceptable quality rating to stop refinement
             max_refinements: Maximum number of refinement cycles to attempt
             context: Optional context object
@@ -104,16 +103,17 @@ class EvaluatorOptimizerAgent(BaseAgent):
         self.max_refinements = max_refinements
         self.refinement_history = []
 
-    async def generate(
+    async def generate_impl(
         self,
-        multipart_messages: List[PromptMessageMultipart],
-        request_params: Optional[RequestParams] = None,
-    ) -> PromptMessageMultipart:
+        messages: List[PromptMessageExtended],
+        request_params: RequestParams | None = None,
+        tools: List[Tool] | None = None,
+    ) -> PromptMessageExtended:
         """
         Generate a response through evaluation-guided refinement.
 
         Args:
-            multipart_messages: Messages to process
+            normalized_messages: Already normalized list of PromptMessageExtended
             request_params: Optional request parameters
 
         Returns:
@@ -126,10 +126,10 @@ class EvaluatorOptimizerAgent(BaseAgent):
         self.refinement_history = []
 
         # Extract the user request
-        request = multipart_messages[-1].all_text() if multipart_messages else ""
+        request = messages[-1].all_text() if messages else ""
 
         # Initial generation
-        response = await self.generator_agent.generate(multipart_messages, request_params)
+        response = await self.generator_agent.generate(messages, request_params)
         best_response = response
 
         # Refinement loop
@@ -138,7 +138,7 @@ class EvaluatorOptimizerAgent(BaseAgent):
 
             # Evaluate current response
             eval_prompt = self._build_eval_prompt(
-                request=request, response=response.last_text(), iteration=refinement_count
+                request=request, response=response.last_text() or "", iteration=refinement_count
             )
 
             # Create evaluation message and get structured evaluation result
@@ -190,8 +190,6 @@ class EvaluatorOptimizerAgent(BaseAgent):
 
             # Generate refined response
             refinement_prompt = self._build_refinement_prompt(
-                request=request,
-                response=response.last_text(),  ## only if there is no history?
                 feedback=evaluation_result,
                 iteration=refinement_count,
             )
@@ -204,17 +202,17 @@ class EvaluatorOptimizerAgent(BaseAgent):
 
         return best_response
 
-    async def structured(
+    async def structured_impl(
         self,
-        prompt: List[PromptMessageMultipart],
+        messages: List[PromptMessageExtended],
         model: Type[ModelT],
-        request_params: Optional[RequestParams] = None,
-    ) -> Tuple[ModelT | None, PromptMessageMultipart]:
+        request_params: RequestParams | None = None,
+    ) -> Tuple[ModelT | None, PromptMessageExtended]:
         """
         Generate an optimized response and parse it into a structured format.
 
         Args:
-            prompt: List of messages to process
+            messages: List of messages to process
             model: Pydantic model to parse the response into
             request_params: Optional request parameters
 
@@ -222,7 +220,7 @@ class EvaluatorOptimizerAgent(BaseAgent):
             The parsed response, or None if parsing fails
         """
         # Generate optimized response
-        response = await self.generate(prompt, request_params)
+        response = await self.generate_impl(messages, request_params)
 
         # Delegate structured parsing to the generator agent
         structured_prompt = Prompt.user(response.all_text())
@@ -233,10 +231,10 @@ class EvaluatorOptimizerAgent(BaseAgent):
         await super().initialize()
 
         # Initialize generator and evaluator agents if not already initialized
-        if not getattr(self.generator_agent, "initialized", False):
+        if not self.generator_agent.initialized:
             await self.generator_agent.initialize()
 
-        if not getattr(self.evaluator_agent, "initialized", False):
+        if not self.evaluator_agent.initialized:
             await self.evaluator_agent.initialize()
 
         self.initialized = True
@@ -290,8 +288,6 @@ Evaluate the response for iteration {iteration + 1} and provide feedback on its
 
     def _build_refinement_prompt(
         self,
-        request: str,
-        response: str,
         feedback: EvaluationResult,
         iteration: int,
     ) -> str: