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

mcp_agent/workflows/llm/providers/openai_multipart.py

@@ -4,19 +4,18 @@ Clean utilities for converting between PromptMessageMultipart and OpenAI message
 Each function handles all content types consistently and is designed for simple testing.
 """
 
-from typing import Dict, Any, Union, List
-
-from openai.types.chat import (
-    ChatCompletionMessage,
-    ChatCompletionMessageParam,
-)
+from typing import Any, Dict, List, Union
 
 from mcp.types import (
-    TextContent,
-    ImageContent,
+    BlobResourceContents,
     EmbeddedResource,
+    ImageContent,
+    TextContent,
     TextResourceContents,
-    BlobResourceContents,
+)
+from openai.types.chat import (
+    ChatCompletionMessage,
+    ChatCompletionMessageParam,
 )
 
 from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
@@ -64,44 +63,22 @@ def _openai_message_to_multipart(
     # Handle list of content parts
     elif isinstance(content, list):
         for part in content:
-            part_type = (
-                part.get("type")
-                if isinstance(part, dict)
-                else getattr(part, "type", None)
-            )
+            part_type = part.get("type") if isinstance(part, dict) else getattr(part, "type", None)
 
             # Handle text content
             if part_type == "text":
-                text = (
-                    part.get("text")
-                    if isinstance(part, dict)
-                    else getattr(part, "text", "")
-                )
+                text = part.get("text") if isinstance(part, dict) else getattr(part, "text", "")
 
                 # Check if this is a resource marker
-                if (
-                    text
-                    and (
-                        text.startswith("[Resource:")
-                        or text.startswith("[Binary Resource:")
-                    )
-                    and "\n" in text
-                ):
+                if text and (text.startswith("[Resource:") or text.startswith("[Binary Resource:")) and "\n" in text:
                     header, content_text = text.split("\n", 1)
                     if "MIME:" in header:
                         mime_match = header.split("MIME:", 1)[1].split("]")[0].strip()
 
                         # If not text/plain, create an embedded resource
                         if mime_match != "text/plain":
-                            if (
-                                "Resource:" in header
-                                and "Binary Resource:" not in header
-                            ):
-                                uri = (
-                                    header.split("Resource:", 1)[1]
-                                    .split(",")[0]
-                                    .strip()
-                                )
+                            if "Resource:" in header and "Binary Resource:" not in header:
+                                uri = header.split("Resource:", 1)[1].split(",")[0].strip()
                                 mcp_contents.append(
                                     EmbeddedResource(
                                         type="resource",
@@ -119,31 +96,17 @@ def _openai_message_to_multipart(
 
             # Handle image content
             elif part_type == "image_url":
-                image_url = (
-                    part.get("image_url", {})
-                    if isinstance(part, dict)
-                    else getattr(part, "image_url", None)
-                )
+                image_url = part.get("image_url", {}) if isinstance(part, dict) else getattr(part, "image_url", None)
                 if image_url:
-                    url = (
-                        image_url.get("url")
-                        if isinstance(image_url, dict)
-                        else getattr(image_url, "url", "")
-                    )
+                    url = image_url.get("url") if isinstance(image_url, dict) else getattr(image_url, "url", "")
                     if url and url.startswith("data:image/"):
                         # Handle base64 data URLs
                         mime_type = url.split(";")[0].replace("data:", "")
                         data = url.split(",")[1]
-                        mcp_contents.append(
-                            ImageContent(type="image", data=data, mimeType=mime_type)
-                        )
+                        mcp_contents.append(ImageContent(type="image", data=data, mimeType=mime_type))
 
             # Handle explicit resource types
-            elif (
-                part_type == "resource"
-                and isinstance(part, dict)
-                and "resource" in part
-            ):
+            elif part_type == "resource" and isinstance(part, dict) and "resource" in part:
                 resource = part["resource"]
                 if isinstance(resource, dict):
                     # Text resource
@@ -152,9 +115,7 @@ def _openai_message_to_multipart(
                         uri = resource.get("uri", "resource://unknown")
 
                         if mime_type == "text/plain":
-                            mcp_contents.append(
-                                TextContent(type="text", text=resource["text"])
-                            )
+                            mcp_contents.append(TextContent(type="text", text=resource["text"]))
                         else:
                             mcp_contents.append(
                                 EmbeddedResource(
@@ -171,10 +132,7 @@ def _openai_message_to_multipart(
                         mime_type = resource["mimeType"]
                         uri = resource.get("uri", "resource://unknown")
 
-                        if (
-                            mime_type.startswith("image/")
-                            and mime_type != "image/svg+xml"
-                        ):
+                        if mime_type.startswith("image/") and mime_type != "image/svg+xml":
                             mcp_contents.append(
                                 ImageContent(
                                     type="image",

mcp_agent/workflows/llm/providers/sampling_converter_anthropic.py

@@ -1,24 +1,22 @@
-from mcp import StopReason
-from mcp_agent.workflows.llm.providers.multipart_converter_anthropic import (
-    AnthropicConverter,
-)
-from mcp_agent.workflows.llm.sampling_format_converter import SamplingFormatConverter
-
-from mcp.types import (
-    PromptMessage,
-)
-
 from anthropic.types import (
     Message,
     MessageParam,
 )
+from mcp import StopReason
+from mcp.types import (
+    PromptMessage,
+)
 
 from mcp_agent.logging.logger import get_logger
+from mcp_agent.workflows.llm.providers.multipart_converter_anthropic import (
+    AnthropicConverter,
+)
+from mcp_agent.workflows.llm.sampling_format_converter import ProviderFormatConverter
 
 _logger = get_logger(__name__)
 
 
-class AnthropicSamplingConverter(SamplingFormatConverter[MessageParam, Message]):
+class AnthropicSamplingConverter(ProviderFormatConverter[MessageParam, Message]):
     """
     Convert between Anthropic and MCP types.
     """
@@ -46,7 +44,7 @@ def mcp_stop_reason_to_anthropic_stop_reason(stop_reason: StopReason):
 
 def anthropic_stop_reason_to_mcp_stop_reason(stop_reason: str) -> StopReason:
     if not stop_reason:
-        return None
+        return "end_turn"
     elif stop_reason == "end_turn":
         return "endTurn"
     elif stop_reason == "max_tokens":

mcp_agent/workflows/llm/providers/sampling_converter_openai.py

@@ -1,25 +1,21 @@
-from typing import Dict, Any
-
-from openai.types.chat import (
-    ChatCompletionMessage,
-)
+from typing import Any, Dict
 
 from mcp.types import (
     PromptMessage,
 )
-
-from mcp_agent.workflows.llm.sampling_format_converter import (
-    SamplingFormatConverter,
+from openai.types.chat import (
+    ChatCompletionMessage,
 )
 
 from mcp_agent.logging.logger import get_logger
+from mcp_agent.workflows.llm.sampling_format_converter import (
+    ProviderFormatConverter,
+)
 
 _logger = get_logger(__name__)
 
 
-class OpenAISamplingConverter(
-    SamplingFormatConverter[Dict[str, Any], ChatCompletionMessage]
-):
+class OpenAISamplingConverter(ProviderFormatConverter[Dict[str, Any], ChatCompletionMessage]):
     @classmethod
     def from_prompt_message(cls, message: PromptMessage) -> Dict[str, Any]:
         """Convert an MCP PromptMessage to an OpenAI message dict."""

mcp_agent/workflows/llm/sampling_converter.py

@@ -13,8 +13,8 @@ from mcp.types import (
     TextContent,
 )
 
-from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 from mcp_agent.mcp.interfaces import RequestParams
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 
 
 class SamplingConverter:
@@ -63,9 +63,7 @@ class SamplingConverter:
         )
 
     @staticmethod
-    def create_message_result(
-        response: str, model: str, stop_reason: StopReason = "endTurn"
-    ) -> CreateMessageResult:
+    def create_message_result(response: str, model: str, stop_reason: StopReason = "endTurn") -> CreateMessageResult:
         """
         Create a CreateMessageResult from an LLM response.
 
@@ -85,9 +83,7 @@ class SamplingConverter:
         )
 
     @staticmethod
-    def error_result(
-        error_message: str, model: Optional[str] = None
-    ) -> CreateMessageResult:
+    def error_result(error_message: str, model: Optional[str] = None) -> CreateMessageResult:
         """
         Create an error result.
 
@@ -118,7 +114,4 @@ class SamplingConverter:
         Returns:
             List of PromptMessageMultipart objects, each with a single content item
         """
-        return [
-            SamplingConverter.sampling_message_to_prompt_message(msg)
-            for msg in messages
-        ]
+        return [SamplingConverter.sampling_message_to_prompt_message(msg) for msg in messages]

mcp_agent/workflows/llm/sampling_format_converter.py

@@ -1,22 +1,22 @@
-from typing import Generic, List, Protocol, TypeVar
+from typing import Generic, Protocol, TypeVar
 
+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 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)