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

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

@@ -5,11 +5,12 @@ Iterative Planner Agent - works towards an objective using sub-agents
 import asyncio
 from typing import Any, Dict, 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.agents.workflow.orchestrator_models import (
+from fast_agent.agents.agent_types import AgentConfig, AgentType
+from fast_agent.agents.llm_agent import LlmAgent
+from fast_agent.agents.workflow.orchestrator_models import (
     Plan,
     PlanningStep,
     PlanResult,
@@ -18,13 +19,11 @@ from mcp_agent.agents.workflow.orchestrator_models import (
     format_plan_result,
     format_step_result_text,
 )
-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
-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.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__)
 
@@ -146,11 +145,11 @@ make sure to state clearly what was accomplished and what remains to be done.
 
 
 Complete the plan by providing an appropriate answer for the original objective. Provide a Mermaid diagram
-(in code fences) showing the plan steps and their relationships, if applicable.
+(in code fences) showing the plan steps and their relationships, if applicable. Do not use parentheses in labels.
 """
 
 
-class IterativePlanner(BaseAgent):
+class IterativePlanner(LlmAgent):
     """
     An agent that implements the orchestrator workflow pattern.
 
@@ -167,7 +166,7 @@ class IterativePlanner(BaseAgent):
     def __init__(
         self,
         config: AgentConfig,
-        agents: List[Agent],
+        agents: List[AgentProtocol],
         plan_iterations: int = -1,
         context: Optional[Any] = None,
         **kwargs,
@@ -186,11 +185,13 @@ class IterativePlanner(BaseAgent):
             raise AgentConfigError("At least one worker agent must be provided")
 
         # Store agents by name for easier lookup
-        self.agents: Dict[str, Agent] = {}
+        self.agents: Dict[str, AgentProtocol] = {}
         for agent in agents:
             agent_name = agent.name
             self.agents[agent_name] = agent
 
+        # Extract plan_type from kwargs before passing to parent
+        kwargs.pop("plan_type", "full")
         super().__init__(config, context=context, **kwargs)
 
         self.plan_iterations = plan_iterations
@@ -200,7 +201,7 @@ class IterativePlanner(BaseAgent):
         # Initialize all worker agents first if not already initialized
         for agent_name, agent in self.agents.items():
             if not getattr(agent, "initialized", False):
-                self.logger.debug(f"Initializing agent: {agent_name}")
+                logger.debug(f"Initializing agent: {agent_name}")
                 await agent.initialize()
 
         # Format agent information using agent cards with XML formatting
@@ -218,7 +219,6 @@ class IterativePlanner(BaseAgent):
 
         # Update the config instruction with the formatted system prompt
         self.instruction = system_prompt
-
         # Initialize the base agent with the updated system prompt
         await super().initialize()
 
@@ -233,44 +233,44 @@ class IterativePlanner(BaseAgent):
             try:
                 await agent.shutdown()
             except Exception as e:
-                self.logger.warning(f"Error shutting down agent {agent_name}: {str(e)}")
+                logger.warning(f"Error shutting down agent {agent_name}: {str(e)}")
 
-    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:
         """
         Execute an orchestrated plan to process the input.
 
         Args:
-            multipart_messages: Messages to process
+            normalized_messages: Already normalized list of PromptMessageExtended
             request_params: Optional request parameters
 
         Returns:
             The final synthesized response from the orchestration
         """
         # Extract user request
-        objective = multipart_messages[-1].all_text() if multipart_messages else ""
+        objective = messages[-1].all_text() if messages else ""
         plan_result = await self._execute_plan(objective, request_params)
-
         # Return the result
-        return PromptMessageMultipart(
+        return PromptMessageExtended(
             role="assistant",
             content=[TextContent(type="text", text=plan_result.result or "No result available")],
         )
 
-    async def structured(
+    async def structured_impl(
         self,
-        multipart_messages: List[PromptMessageMultipart],
+        messages: List[PromptMessageExtended],
         model: Type[ModelT],
         request_params: Optional[RequestParams] = None,
-    ) -> Tuple[ModelT | None, PromptMessageMultipart]:
+    ) -> Tuple[ModelT | None, PromptMessageExtended]:
         """
         Execute an orchestration plan and parse the result 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
 
@@ -278,18 +278,18 @@ class IterativePlanner(BaseAgent):
             The parsed final response, or None if parsing fails
         """
         # Generate orchestration result
-        response = await self.generate(multipart_messages, request_params)
+        response = await self.generate_impl(messages, request_params)
 
         # Try to parse the response into the specified model
         try:
-            result_text = response.last_text()
-            prompt_message = PromptMessageMultipart(
+            result_text = response.last_text() or "<no text>"
+            prompt_message = PromptMessageExtended(
                 role="user", content=[TextContent(type="text", text=result_text)]
             )
             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)}")
+            logger.warning(f"Failed to parse orchestration result: {str(e)}")
             return None, Prompt.assistant(f"Failed to parse orchestration result: {str(e)}")
 
     async def _execute_plan(
@@ -317,7 +317,7 @@ class IterativePlanner(BaseAgent):
 
             if None is next_step:
                 terminate_plan = "Failed to generate plan, terminating early"
-                self.logger.error("Failed to generate next step, terminating plan early")
+                logger.error("Failed to generate next step, terminating plan early")
                 break
 
             assert next_step  # lets keep the indenting manageable!
@@ -330,7 +330,7 @@ class IterativePlanner(BaseAgent):
             plan = Plan(steps=[next_step], is_complete=next_step.is_complete)
             invalid_agents = self._validate_agent_names(plan)
             if invalid_agents:
-                self.logger.error(f"Plan contains invalid agent names: {', '.join(invalid_agents)}")
+                logger.error(f"Plan contains invalid agent names: {', '.join(invalid_agents)}")
                 terminate_plan = (
                     f"Invalid agent names found ({', '.join(invalid_agents)}), terminating plan"
                 )
@@ -354,7 +354,9 @@ class IterativePlanner(BaseAgent):
         )
 
         # Generate final synthesis
-        plan_result.result = await self._planner_generate_str(result_prompt, request_params)
+        final_message = await self._planner_generate_str(result_prompt, request_params)
+        plan_result.result = final_message.last_text() or "No final message generated"
+        await self.show_assistant_message(final_message)
         return plan_result
 
     async def _execute_step(self, step: Step, previous_result: PlanResult) -> Any:
@@ -369,7 +371,7 @@ class IterativePlanner(BaseAgent):
         Returns:
             Result of executing the step
         """
-        from mcp_agent.agents.workflow.orchestrator_models import StepResult
+        from fast_agent.agents.workflow.orchestrator_models import StepResult
 
         # Initialize step result
         step_result = StepResult(step=step, task_results=[])
@@ -397,7 +399,7 @@ class IterativePlanner(BaseAgent):
                     )
                     result = await agent.generate(
                         [
-                            PromptMessageMultipart(
+                            PromptMessageExtended(
                                 role="user",
                                 content=[TextContent(type="text", text=task_description)],
                             )
@@ -409,11 +411,11 @@ class IterativePlanner(BaseAgent):
                         TaskWithResult(
                             description=task_model["description"],
                             agent=task_model["agent"],
-                            result=result.last_text(),
+                            result=result.last_text() or "<missing response>",
                         )
                     )
                 except Exception as e:
-                    self.logger.error(f"Error executing task: {str(e)}")
+                    logger.error(f"Error executing task: {str(e)}")
                     task_model = task.model_dump()
                     results.append(
                         TaskWithResult(
@@ -484,16 +486,24 @@ class IterativePlanner(BaseAgent):
             iterations_info=iterations_info,
         )
 
+        request_params = self._merge_request_params(
+            request_params, RequestParams(systemPrompt=self.instruction)
+        )
+
         # Get structured response from LLM
         try:
-            plan_msg = PromptMessageMultipart(
+            plan_msg = PromptMessageExtended(
                 role="user", content=[TextContent(type="text", text=prompt)]
             )
             assert self._llm
-            next_step, _ = await self._llm.structured([plan_msg], PlanningStep, request_params)
+            self.show_user_message(plan_msg)
+            next_step, raw_response = await self._llm.structured(
+                [plan_msg], PlanningStep, request_params
+            )
+            await self.show_assistant_message(raw_response)
             return next_step
         except Exception as e:
-            self.logger.error(f"Failed to parse next step: {str(e)}")
+            logger.error(f"Failed to parse next step: {str(e)}")
             return None
 
     def _validate_agent_names(self, plan: Plan) -> List[str]:
@@ -552,7 +562,7 @@ class IterativePlanner(BaseAgent):
 
     async def _planner_generate_str(
         self, message: str, request_params: RequestParams | None
-    ) -> str:
+    ) -> PromptMessageExtended:
         """
         Generate string response from the orchestrator's own LLM.
 
@@ -564,9 +574,8 @@ class IterativePlanner(BaseAgent):
             String response from the LLM
         """
         # Create prompt message
-        prompt = PromptMessageMultipart(
+        prompt = PromptMessageExtended(
             role="user", content=[TextContent(type="text", text=message)]
         )
         assert self._llm, "LLM must be initialized before generating text"
-        response = await self._llm.generate([prompt], request_params)
-        return response.last_text()
+        return await self._llm.generate([prompt], request_params)

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

@@ -2,7 +2,7 @@ from typing import List
 
 from pydantic import BaseModel, ConfigDict, Field
 
-from mcp_agent.agents.workflow.orchestrator_prompts import (
+from fast_agent.agents.workflow.orchestrator_prompts import (
     PLAN_RESULT_TEMPLATE,
     STEP_RESULT_TEMPLATE,
     TASK_RESULT_TEMPLATE,
@@ -152,7 +152,7 @@ def format_plan_result_text(plan_result: PlanResult) -> str:
 
 def format_task_result_xml(task_result: TaskWithResult) -> str:
     """Format a task result with XML tags for better semantic understanding"""
-    from mcp_agent.llm.prompt_utils import format_fastagent_tag
+    from fast_agent.llm.prompt_utils import format_fastagent_tag
 
     return format_fastagent_tag(
         "task-result",
@@ -168,7 +168,7 @@ def format_task_result_xml(task_result: TaskWithResult) -> str:
 
 def format_step_result_xml(step_result: StepResult) -> str:
     """Format a step result with XML tags for better semantic understanding"""
-    from mcp_agent.llm.prompt_utils import format_fastagent_tag
+    from fast_agent.llm.prompt_utils import format_fastagent_tag
 
     # Format each task result with XML
     task_results = []
@@ -190,7 +190,7 @@ def format_step_result_xml(step_result: StepResult) -> str:
 
 def format_plan_result(plan_result: PlanResult) -> str:
     """Format the full plan execution state with XML for better semantic understanding"""
-    from mcp_agent.llm.prompt_utils import format_fastagent_tag
+    from fast_agent.llm.prompt_utils import format_fastagent_tag
 
     # Format objective
     objective_tag = format_fastagent_tag("objective", plan_result.objective)

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

@@ -1,18 +1,20 @@
 import asyncio
 from typing import Any, List, Optional, Tuple
 
+from mcp import Tool
 from mcp.types import TextContent
 from opentelemetry import trace
 
-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
+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.interfaces import AgentProtocol, ModelT
+from fast_agent.types import PromptMessageExtended, RequestParams
 
+logger = get_logger(__name__)
 
-class ParallelAgent(BaseAgent):
+
+class ParallelAgent(LlmAgent):
     """
     LLMs can sometimes work simultaneously on a task (fan-out)
     and have their outputs aggregated programmatically (fan-in).
@@ -28,8 +30,8 @@ class ParallelAgent(BaseAgent):
     def __init__(
         self,
         config: AgentConfig,
-        fan_in_agent: Agent,
-        fan_out_agents: List[Agent],
+        fan_in_agent: AgentProtocol,
+        fan_out_agents: List[AgentProtocol],
         include_request: bool = True,
         **kwargs,
     ) -> None:
@@ -48,16 +50,17 @@ class ParallelAgent(BaseAgent):
         self.fan_out_agents = fan_out_agents
         self.include_request = include_request
 
-    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:
         """
         Execute fan-out agents in parallel and aggregate their results with the fan-in agent.
 
         Args:
-            multipart_messages: List of messages to send to the fan-out agents
+            normalized_messages: Already normalized list of PromptMessageExtended
             request_params: Optional parameters to configure the request
 
         Returns:
@@ -65,19 +68,14 @@ class ParallelAgent(BaseAgent):
         """
 
         tracer = trace.get_tracer(__name__)
-        with tracer.start_as_current_span(f"Parallel: '{self.name}' generate"):
+        with tracer.start_as_current_span(f"Parallel: '{self._name}' generate"):
             # Execute all fan-out agents in parallel
-            responses: List[PromptMessageMultipart] = await asyncio.gather(
-                *[
-                    agent.generate(multipart_messages, request_params)
-                    for agent in self.fan_out_agents
-                ]
+            responses: List[PromptMessageExtended] = await asyncio.gather(
+                *[agent.generate(messages, request_params) for agent in self.fan_out_agents]
             )
 
             # Extract the received message from the input
-            received_message: Optional[str] = (
-                multipart_messages[-1].all_text() if multipart_messages else None
-            )
+            received_message: Optional[str] = messages[-1].all_text() if messages else None
 
             # Convert responses to strings for aggregation
             string_responses = []
@@ -88,7 +86,7 @@ class ParallelAgent(BaseAgent):
             aggregated_prompt = self._format_responses(string_responses, received_message)
 
             # Create a new multipart message with the formatted responses
-            formatted_prompt = PromptMessageMultipart(
+            formatted_prompt = PromptMessageExtended(
                 role="user", content=[TextContent(type="text", text=aggregated_prompt)]
             )
 
@@ -121,19 +119,19 @@ class ParallelAgent(BaseAgent):
             )
         return "\n\n".join(formatted)
 
-    async def structured(
+    async def structured_impl(
         self,
-        multipart_messages: List[PromptMessageMultipart],
+        messages: List[PromptMessageExtended],
         model: type[ModelT],
         request_params: Optional[RequestParams] = None,
-    ) -> Tuple[ModelT | None, PromptMessageMultipart]:
+    ) -> Tuple[ModelT | None, PromptMessageExtended]:
         """
         Apply the prompt and return the result as a Pydantic model.
 
         This implementation delegates to the fan-in agent's structured method.
 
         Args:
-            prompt: List of PromptMessageMultipart objects
+            messages: List of PromptMessageExtended objects
             model: The Pydantic model class to parse the result into
             request_params: Optional parameters to configure the LLM request
 
@@ -142,19 +140,14 @@ class ParallelAgent(BaseAgent):
         """
 
         tracer = trace.get_tracer(__name__)
-        with tracer.start_as_current_span(f"Parallel: '{self.name}' generate"):
+        with tracer.start_as_current_span(f"Parallel: '{self._name}' generate"):
             # Generate parallel responses first
-            responses: List[PromptMessageMultipart] = await asyncio.gather(
-                *[
-                    agent.generate(multipart_messages, request_params)
-                    for agent in self.fan_out_agents
-                ]
+            responses: List[PromptMessageExtended] = await asyncio.gather(
+                *[agent.generate(messages, request_params) for agent in self.fan_out_agents]
             )
 
             # Extract the received message
-            received_message: Optional[str] = (
-                multipart_messages[-1].all_text() if multipart_messages else None
-            )
+            received_message: Optional[str] = messages[-1].all_text() if messages else None
 
             # Convert responses to strings
             string_responses = [response.all_text() for response in responses]
@@ -163,7 +156,7 @@ class ParallelAgent(BaseAgent):
             aggregated_prompt = self._format_responses(string_responses, received_message)
 
             # Create a multipart message
-            formatted_prompt = PromptMessageMultipart(
+            formatted_prompt = PromptMessageExtended(
                 role="user", content=[TextContent(type="text", text=aggregated_prompt)]
             )
 
@@ -177,11 +170,11 @@ class ParallelAgent(BaseAgent):
         await super().initialize()
 
         # Initialize fan-in and fan-out agents if not already initialized
-        if not getattr(self.fan_in_agent, "initialized", False):
+        if not self.fan_in_agent.initialized:
             await self.fan_in_agent.initialize()
 
         for agent in self.fan_out_agents:
-            if not getattr(agent, "initialized", False):
+            if not agent.initialized:
                 await agent.initialize()
 
     async def shutdown(self) -> None:
@@ -194,10 +187,10 @@ class ParallelAgent(BaseAgent):
         try:
             await self.fan_in_agent.shutdown()
         except Exception as e:
-            self.logger.warning(f"Error shutting down fan-in agent: {str(e)}")
+            logger.warning(f"Error shutting down fan-in agent: {str(e)}")
 
         for agent in self.fan_out_agents:
             try:
                 await agent.shutdown()
             except Exception as e:
-                self.logger.warning(f"Error shutting down fan-out agent {agent.name}: {str(e)}")
+                logger.warning(f"Error shutting down fan-out agent {agent.name}: {str(e)}")