fast-agent-mcp 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

mcp_agent/workflows/llm/sampling_converter.py

@@ -0,0 +1,117 @@
+"""
+Simplified converter between MCP sampling types and PromptMessageMultipart.
+This replaces the more complex provider-specific converters with direct conversions.
+"""
+
+from typing import List, Optional
+
+from mcp.types import (
+    CreateMessageRequestParams,
+    CreateMessageResult,
+    SamplingMessage,
+    StopReason,
+    TextContent,
+)
+
+from mcp_agent.mcp.interfaces import RequestParams
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+
+
+class SamplingConverter:
+    """
+    Simplified converter between MCP sampling types and internal LLM types.
+
+    This handles converting between:
+    - SamplingMessage and PromptMessageMultipart
+    - CreateMessageRequestParams and RequestParams
+    - LLM responses and CreateMessageResult
+    """
+
+    @staticmethod
+    def sampling_message_to_prompt_message(
+        message: SamplingMessage,
+    ) -> PromptMessageMultipart:
+        """
+        Convert a SamplingMessage to a PromptMessageMultipart.
+
+        Args:
+            message: MCP SamplingMessage to convert
+
+        Returns:
+            PromptMessageMultipart suitable for use with LLMs
+        """
+        return PromptMessageMultipart(role=message.role, content=[message.content])
+
+    @staticmethod
+    def extract_request_params(params: CreateMessageRequestParams) -> RequestParams:
+        """
+        Extract parameters from CreateMessageRequestParams into RequestParams.
+
+        Args:
+            params: MCP request parameters
+
+        Returns:
+            RequestParams suitable for use with LLM.generate_prompt
+        """
+        return RequestParams(
+            maxTokens=params.maxTokens,
+            systemPrompt=params.systemPrompt,
+            temperature=params.temperature,
+            stopSequences=params.stopSequences,
+            modelPreferences=params.modelPreferences,
+            # Add any other parameters needed
+        )
+
+    @staticmethod
+    def create_message_result(response: str, model: str, stop_reason: StopReason = "endTurn") -> CreateMessageResult:
+        """
+        Create a CreateMessageResult from an LLM response.
+
+        Args:
+            response: Text response from the LLM
+            model: Model identifier
+            stop_reason: Reason generation stopped
+
+        Returns:
+            CreateMessageResult suitable for returning to MCP
+        """
+        return CreateMessageResult(
+            role="assistant",
+            content=TextContent(type="text", text=response),
+            model=model,
+            stopReason=stop_reason,
+        )
+
+    @staticmethod
+    def error_result(error_message: str, model: Optional[str] = None) -> CreateMessageResult:
+        """
+        Create an error result.
+
+        Args:
+            error_message: Error message text
+            model: Optional model identifier
+
+        Returns:
+            CreateMessageResult with error information
+        """
+        return CreateMessageResult(
+            role="assistant",
+            content=TextContent(type="text", text=error_message),
+            model=model or "unknown",
+            stopReason="error",
+        )
+
+    @staticmethod
+    def convert_messages(
+        messages: List[SamplingMessage],
+    ) -> List[PromptMessageMultipart]:
+        """
+        Convert multiple SamplingMessages to PromptMessageMultipart objects.
+
+        Args:
+            messages: List of SamplingMessages to convert
+
+        Returns:
+            List of PromptMessageMultipart objects, each with a single content item
+        """
+        return [SamplingConverter.sampling_message_to_prompt_message(msg) for msg in messages]

mcp_agent/workflows/llm/sampling_format_converter.py

@@ -1,39 +1,22 @@
-from typing import Generic, List, Protocol, TypeVar
+from typing import Generic, Protocol, TypeVar
 
-from mcp import CreateMessageResult, SamplingMessage
+from mcp.types import PromptMessage
 
-# Define type variables here instead of importing from augmented_llm
-MessageParamT = TypeVar("MessageParamT")
-"""A type representing an input message to an LLM."""
+# Define covariant type variables
+MessageParamT_co = TypeVar("MessageParamT_co", covariant=True)
+MessageT_co = TypeVar("MessageT_co", covariant=True)
 
-MessageT = TypeVar("MessageT")
-"""A type representing an output message from an LLM."""
 
-
-class SamplingFormatConverter(Protocol, Generic[MessageParamT, MessageT]):
+class ProviderFormatConverter(Protocol, Generic[MessageParamT_co, MessageT_co]):
     """Conversions between LLM provider and MCP types"""
 
     @classmethod
-    def to_sampling_result(cls, result: MessageT) -> CreateMessageResult:
-        """Convert an LLM response to an MCP message result type."""
-
-    @classmethod
-    def from_sampling_result(cls, result: CreateMessageResult) -> MessageT:
-        """Convert an MCP message result to an LLM response type."""
-
-    @classmethod
-    def to_sampling_message(cls, param: MessageParamT) -> SamplingMessage:
-        """Convert an LLM input to an MCP message (SamplingMessage) type."""
-
-    @classmethod
-    def from_sampling_message(cls, param: SamplingMessage) -> MessageParamT:
-        """Convert an MCP message (SamplingMessage) to an LLM input type."""
-
-    @classmethod
-    def from_prompt_message(cls, message) -> MessageParamT:
+    def from_prompt_message(cls, message: PromptMessage) -> MessageParamT_co:
         """Convert an MCP PromptMessage to a provider-specific message parameter."""
+        ...
 
 
-def typed_dict_extras(d: dict, exclude: List[str]):
-    extras = {k: v for k, v in d.items() if k not in exclude}
-    return extras
+class BasicFormatConverter(ProviderFormatConverter[PromptMessage, PromptMessage]):
+    @classmethod
+    def from_prompt_message(cls, message: PromptMessage) -> PromptMessage:
+        return message

mcp_agent/workflows/orchestrator/orchestrator.py

@@ -3,15 +3,16 @@ Orchestrator implementation for MCP Agent applications.
 """
 
 from typing import (
+    TYPE_CHECKING,
     List,
     Literal,
     Optional,
-    TYPE_CHECKING,
     Type,
 )
 
 from mcp_agent.agents.agent import Agent
 from mcp_agent.event_progress import ProgressAction
+from mcp_agent.logging.logger import get_logger
 from mcp_agent.workflows.llm.augmented_llm import (
     AugmentedLLM,
     MessageParamT,
@@ -20,14 +21,14 @@ from mcp_agent.workflows.llm.augmented_llm import (
     RequestParams,
 )
 from mcp_agent.workflows.orchestrator.orchestrator_models import (
-    format_plan_result,
-    format_step_result_text,
     NextStep,
     Plan,
     PlanResult,
     Step,
     StepResult,
     TaskWithResult,
+    format_plan_result,
+    format_step_result_text,
 )
 from mcp_agent.workflows.orchestrator.orchestrator_prompts import (
     FULL_PLAN_PROMPT_TEMPLATE,
@@ -36,7 +37,6 @@ from mcp_agent.workflows.orchestrator.orchestrator_prompts import (
     SYNTHESIZE_PLAN_PROMPT_TEMPLATE,
     TASK_PROMPT_TEMPLATE,
 )
-from mcp_agent.logging.logger import get_logger
 
 if TYPE_CHECKING:
     from mcp_agent.context import Context
@@ -73,7 +73,7 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
         plan_type: Literal["full", "iterative"] = "full",
         context: Optional["Context"] = None,
         **kwargs,
-    ):
+    ) -> None:
         """
         Args:
             name: Name of the orchestrator workflow
@@ -171,17 +171,13 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
     ) -> ModelT:
         return None
 
-    async def execute(
-        self, objective: str, request_params: RequestParams | None = None
-    ) -> PlanResult:
+    async def execute(self, objective: str, request_params: RequestParams | None = None) -> PlanResult:
         """Execute task with result chaining between steps"""
         iterations = 0
         total_steps_executed = 0
 
         params = self.get_request_params(request_params)
-        max_steps = getattr(
-            params, "max_steps", params.max_iterations * 5
-        )  # Default to 5× max_iterations
+        max_steps = getattr(params, "max_steps", params.max_iterations * 5)  # Default to 5× max_iterations
 
         # Single progress event for orchestration start
         model = await self.select_model(params) or "unknown-model"
@@ -198,24 +194,18 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
         )
 
         plan_result = PlanResult(objective=objective, step_results=[])
-        plan_result.max_iterations_reached = (
-            False  # Add a flag to track if we hit the limit
-        )
+        plan_result.max_iterations_reached = False  # Add a flag to track if we hit the limit
 
         while iterations < params.max_iterations:
             if self.plan_type == "iterative":
                 # Get next plan/step
-                next_step = await self._get_next_step(
-                    objective=objective, plan_result=plan_result, request_params=params
-                )
+                next_step = await self._get_next_step(objective=objective, plan_result=plan_result, request_params=params)
                 logger.debug(f"Iteration {iterations}: Iterative plan:", data=next_step)
                 plan = Plan(steps=[next_step], is_complete=next_step.is_complete)
                 # Validate agent names in the plan early
                 self._validate_agent_names(plan)
             elif self.plan_type == "full":
-                plan = await self._get_full_plan(
-                    objective=objective, plan_result=plan_result, request_params=params
-                )
+                plan = await self._get_full_plan(objective=objective, plan_result=plan_result, request_params=params)
                 logger.debug(f"Iteration {iterations}: Full Plan:", data=plan)
                 # Validate agent names in the plan early
                 self._validate_agent_names(plan)
@@ -230,9 +220,7 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
 
                 # Synthesize final result into a single message
                 # Use the structured XML format for better context
-                synthesis_prompt = SYNTHESIZE_PLAN_PROMPT_TEMPLATE.format(
-                    plan_result=format_plan_result(plan_result)
-                )
+                synthesis_prompt = SYNTHESIZE_PLAN_PROMPT_TEMPLATE.format(plan_result=format_plan_result(plan_result))
 
                 # Use planner directly - planner already has PLANNING verb
                 plan_result.result = await self.planner.generate_str(
@@ -247,9 +235,7 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
             for step in plan.steps:
                 # Check if we've hit the step limit
                 if total_steps_executed >= max_steps:
-                    self.logger.warning(
-                        f"Reached maximum step limit ({max_steps}) without completing objective."
-                    )
+                    self.logger.warning(f"Reached maximum step limit ({max_steps}) without completing objective.")
                     plan_result.max_steps_reached = True
                     break
 
@@ -263,15 +249,10 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
                 total_steps_executed += 1
 
             # Check if we need to break from the main loop due to hitting max_steps
-            if (
-                hasattr(plan_result, "max_steps_reached")
-                and plan_result.max_steps_reached
-            ):
+            if hasattr(plan_result, "max_steps_reached") and plan_result.max_steps_reached:
                 break
 
-            logger.debug(
-                f"Iteration {iterations}: Intermediate plan result:", data=plan_result
-            )
+            logger.debug(f"Iteration {iterations}: Intermediate plan result:", data=plan_result)
 
             # Check for diminishing returns
             if iterations > 2 and len(plan.steps) <= 1:
@@ -289,9 +270,7 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
 
         # Check if we hit iteration limits without completing
         if iterations >= params.max_iterations and not plan_result.is_complete:
-            self.logger.warning(
-                f"Failed to complete in {params.max_iterations} iterations."
-            )
+            self.logger.warning(f"Failed to complete in {params.max_iterations} iterations.")
             # Mark that we hit the iteration limit
             plan_result.max_iterations_reached = True
 
@@ -303,15 +282,11 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
         else:
             # Either plan is complete or we had diminishing returns (which we mark as complete)
             if not plan_result.is_complete:
-                self.logger.info(
-                    "Plan terminated due to diminishing returns, marking as complete"
-                )
+                self.logger.info("Plan terminated due to diminishing returns, marking as complete")
                 plan_result.is_complete = True
 
             # Use standard template for complete plans
-            synthesis_prompt = SYNTHESIZE_PLAN_PROMPT_TEMPLATE.format(
-                plan_result=format_plan_result(plan_result)
-            )
+            synthesis_prompt = SYNTHESIZE_PLAN_PROMPT_TEMPLATE.format(plan_result=format_plan_result(plan_result))
 
         # Generate the final synthesis with the appropriate template
         plan_result.result = await self.planner.generate_str(
@@ -341,9 +316,7 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
             # Make sure we're using a valid agent name
             agent = self.agents.get(task.agent)
             if not agent:
-                self.logger.error(
-                    f"AGENT VALIDATION ERROR: No agent found matching '{task.agent}'. Available agents: {list(self.agents.keys())}"
-                )
+                self.logger.error(f"AGENT VALIDATION ERROR: No agent found matching '{task.agent}'. Available agents: {list(self.agents.keys())}")
                 error_tasks.append(
                     (
                         task,
@@ -425,20 +398,14 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
         # Create clear plan status indicator for the template
         plan_status = "Plan Status: Not Started"
         if plan_result.is_complete:
-            plan_status = (
-                "Plan Status: Complete"
-                if plan_result.is_complete
-                else "Plan Status: In Progress"
-            )
+            plan_status = "Plan Status: Complete" if plan_result.is_complete else "Plan Status: In Progress"
 
         # Fix the iteration counting display
         max_iterations = params.max_iterations
         # Simplified iteration counting logic
         current_iteration = len(plan_result.step_results)
         current_iteration = min(current_iteration, max_iterations - 1)  # Cap at max-1
-        iterations_remaining = max(
-            0, max_iterations - current_iteration - 1
-        )  # Ensure non-negative
+        iterations_remaining = max(0, max_iterations - current_iteration - 1)  # Ensure non-negative
         iterations_info = f"Planning Budget: Iteration {current_iteration + 1} of {max_iterations} (with {iterations_remaining} remaining)"
 
         prompt = FULL_PLAN_PROMPT_TEMPLATE.format(
@@ -488,18 +455,12 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
 
         # Format agents without numeric prefixes for cleaner XML
         # FIX: Iterate over agent names instead of agent objects
-        agents = "\n".join(
-            [self._format_agent_info(agent_name) for agent_name in self.agents.keys()]
-        )
+        agents = "\n".join([self._format_agent_info(agent_name) for agent_name in self.agents.keys()])
 
         # Create clear plan status indicator for the template
         plan_status = "Plan Status: Not Started"
         if plan_result:
-            plan_status = (
-                "Plan Status: Complete"
-                if plan_result.is_complete
-                else "Plan Status: In Progress"
-            )
+            plan_status = "Plan Status: Complete" if plan_result.is_complete else "Plan Status: In Progress"
 
         # Add max_iterations info for the LLM
         max_iterations = params.max_iterations
@@ -516,9 +477,7 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
         )
 
         # Get raw JSON response from LLM
-        return await self.planner.generate_structured(
-            message=prompt, request_params=params, response_model=NextStep
-        )
+        return await self.planner.generate_structured(message=prompt, request_params=params, response_model=NextStep)
 
     def _format_server_info(self, server_name: str) -> str:
         """Format server information for display to planners using XML tags"""
@@ -573,6 +532,4 @@ class Orchestrator(AugmentedLLM[MessageParamT, MessageT]):
 
             server_info.append({"name": server_name, "description": description})
 
-        return format_agent_info(
-            agent.name, instruction, server_info if server_info else None
-        )
+        return format_agent_info(agent.name, instruction, server_info if server_info else None)

mcp_agent/workflows/orchestrator/orchestrator_models.py

@@ -50,21 +50,15 @@ class Plan(BaseModel):
         description="List of steps to execute sequentially",
         default_factory=list,
     )
-    is_complete: bool = Field(
-        description="Whether the overall plan objective is complete"
-    )
+    is_complete: bool = Field(description="Whether the overall plan objective is complete")
 
 
 class TaskWithResult(Task):
     """An individual task with its result"""
 
-    result: str = Field(
-        description="Result of executing the task", default="Task completed"
-    )
+    result: str = Field(description="Result of executing the task", default="Task completed")
 
-    agent: str = Field(
-        description="Name of the agent that executed this task", default=""
-    )
+    agent: str = Field(description="Name of the agent that executed this task", default="")
 
     model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
 
@@ -73,14 +67,10 @@ class StepResult(BaseModel):
     """Result of executing a step"""
 
     step: Step = Field(description="The step that was executed", default_factory=Step)
-    task_results: List[TaskWithResult] = Field(
-        description="Results of executing each task", default_factory=list
-    )
-    result: str = Field(
-        description="Result of executing the step", default="Step completed"
-    )
+    task_results: List[TaskWithResult] = Field(description="Results of executing each task", default_factory=list)
+    result: str = Field(description="Result of executing the step", default="Step completed")
 
-    def add_task_result(self, task_result: TaskWithResult):
+    def add_task_result(self, task_result: TaskWithResult) -> None:
         """Add a task result to this step"""
         if not isinstance(self.task_results, list):
             self.task_results = []
@@ -108,7 +98,7 @@ class PlanResult(BaseModel):
     result: str | None = None
     """Result of executing the plan"""
 
-    def add_step_result(self, step_result: StepResult):
+    def add_step_result(self, step_result: StepResult) -> None:
         """Add a step result to this plan"""
         if not isinstance(self.step_results, list):
             self.step_results = []
@@ -118,23 +108,17 @@ class PlanResult(BaseModel):
 class NextStep(Step):
     """Single next step in iterative planning"""
 
-    is_complete: bool = Field(
-        description="Whether the overall plan objective is complete"
-    )
+    is_complete: bool = Field(description="Whether the overall plan objective is complete")
 
 
 def format_task_result_text(task_result: TaskWithResult) -> str:
     """Format a task result as plain text for display"""
-    return TASK_RESULT_TEMPLATE.format(
-        task_description=task_result.description, task_result=task_result.result
-    )
+    return TASK_RESULT_TEMPLATE.format(task_description=task_result.description, task_result=task_result.result)
 
 
 def format_step_result_text(step_result: StepResult) -> str:
     """Format a step result as plain text for display"""
-    tasks_str = "\n".join(
-        f"  - {format_task_result_text(task)}" for task in step_result.task_results
-    )
+    tasks_str = "\n".join(f"  - {format_task_result_text(task)}" for task in step_result.task_results)
     return STEP_RESULT_TEMPLATE.format(
         step_description=step_result.step.description,
         step_result=step_result.result,
@@ -145,10 +129,7 @@ def format_step_result_text(step_result: StepResult) -> str:
 def format_plan_result_text(plan_result: PlanResult) -> str:
     """Format the full plan execution state as plain text for display"""
     steps_str = (
-        "\n\n".join(
-            f"{i + 1}:\n{format_step_result_text(step)}"
-            for i, step in enumerate(plan_result.step_results)
-        )
+        "\n\n".join(f"{i + 1}:\n{format_step_result_text(step)}" for i, step in enumerate(plan_result.step_results))
         if plan_result.step_results
         else "No steps executed yet"
     )
@@ -166,13 +147,8 @@ def format_task_result_xml(task_result: TaskWithResult) -> str:
 
     return format_fastagent_tag(
         "task-result",
-        f"\n<fastagent:description>{task_result.description}</fastagent:description>\n"
-        f"<fastagent:result>{task_result.result}</fastagent:result>\n",
-        {
-            "description": task_result.description[:50] + "..."
-            if len(task_result.description) > 50
-            else task_result.description
-        },
+        f"\n<fastagent:description>{task_result.description}</fastagent:description>\n" f"<fastagent:result>{task_result.result}</fastagent:result>\n",
+        {"description": task_result.description[:50] + "..." if len(task_result.description) > 50 else task_result.description},
     )
 
 
@@ -221,9 +197,7 @@ def format_plan_result(plan_result: PlanResult) -> str:
     else:
         # No steps executed yet
         progress_content = (
-            f"{objective_tag}\n"
-            f"<fastagent:steps>No steps executed yet</fastagent:steps>\n"
-            f"<fastagent:status>Not Started</fastagent:status>\n"
+            f"{objective_tag}\n" f"<fastagent:steps>No steps executed yet</fastagent:steps>\n" f"<fastagent:status>Not Started</fastagent:status>\n"
         )
 
     return format_fastagent_tag("progress", progress_content)