fast-agent-mcp 0.2.49__py3-none-any.whl → 0.2.51__py3-none-any.whl

mcp_agent/llm/providers/augmented_llm_openai.py

@@ -307,6 +307,7 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
         request_params = self.get_request_params(request_params=request_params)
 
         responses: List[ContentBlock] = []
+        model_name = self.default_request_params.model or DEFAULT_OPENAI_MODEL
 
         # TODO -- move this in to agent context management / agent group handling
         messages: List[ChatCompletionMessageParam] = []
@@ -347,7 +348,6 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
             stream = await self._openai_client().chat.completions.create(**arguments)
             # Process the stream
             response = await self._process_stream(stream, self.default_request_params.model)
-
             # Track usage if response is valid and has usage data
             if (
                 hasattr(response, "usage")
@@ -391,6 +391,14 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
             # Convert to dict and remove None values
             message_dict = message.model_dump()
             message_dict = {k: v for k, v in message_dict.items() if v is not None}
+            if model_name in (
+                "deepseek-r1-distill-llama-70b",
+                "openai/gpt-oss-120b",
+                "openai/gpt-oss-20b",
+            ):
+                message_dict.pop("reasoning", None)
+                message_dict.pop("channel", None)
+
             messages.append(message_dict)
 
             message_text = message.content
@@ -412,9 +420,8 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
                     )
 
                 tool_results = []
-                
+
                 for tool_call in message.tool_calls:
-                    
                     self.show_tool_call(
                         available_tools,
                         tool_call.function.name,
@@ -430,7 +437,7 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
                             else from_json(tool_call.function.arguments, allow_partial=True),
                         ),
                     )
-                    
+
                     try:
                         result = await self.call_tool(tool_call_request, tool_call.id)
                         self.show_tool_result(result)
@@ -439,10 +446,14 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
                     except Exception as e:
                         self.logger.error(f"Tool call {tool_call.id} failed with error: {e}")
                         # Still add the tool_call_id with an error result to prevent missing responses
-                        error_result = CallToolResult(content=[TextContent(type="text", text=f"Tool call failed: {str(e)}")])
+                        error_result = CallToolResult(
+                            content=[TextContent(type="text", text=f"Tool call failed: {str(e)}")]
+                        )
                         tool_results.append((tool_call.id, error_result))
-                
-                converted_messages = OpenAIConverter.convert_function_results_to_openai(tool_results)
+
+                converted_messages = OpenAIConverter.convert_function_results_to_openai(
+                    tool_results
+                )
                 messages.extend(converted_messages)
 
                 self.logger.debug(

mcp_agent/llm/providers/augmented_llm_openrouter.py

@@ -17,24 +17,19 @@ class OpenRouterAugmentedLLM(OpenAIAugmentedLLM):
 
     def _initialize_default_params(self, kwargs: dict) -> RequestParams:
         """Initialize OpenRouter-specific default parameters."""
+        # Get base defaults from parent (includes ModelDatabase lookup)
+        base_params = super()._initialize_default_params(kwargs)
+        
+        # Override with OpenRouter-specific settings
         # OpenRouter model names include the provider, e.g., "google/gemini-flash-1.5"
         # The model should be passed in the 'model' kwarg during factory creation.
         chosen_model = kwargs.get("model", DEFAULT_OPENROUTER_MODEL)
-        if not chosen_model:
-            # Unlike Deepseek, OpenRouter *requires* a model path in the identifier.
-            # The factory should extract this before calling the constructor.
-            # We rely on the model being passed correctly via kwargs.
-            # If it's still None here, it indicates an issue upstream (factory or user input).
-            # However, the base class _get_model handles the error if model is None.
-            pass
-
-        return RequestParams(
-            model=chosen_model,  # Will be validated by base class
-            systemPrompt=self.instruction,
-            parallel_tool_calls=True,  # Default based on OpenAI provider
-            max_iterations=20,  # Default based on OpenAI provider
-            use_history=True,  # Default based on OpenAI provider
-        )
+        if chosen_model:
+            base_params.model = chosen_model
+        # If it's still None here, it indicates an issue upstream (factory or user input).
+        # However, the base class _get_model handles the error if model is None.
+        
+        return base_params
 
     def _base_url(self) -> str:
         """Retrieve the OpenRouter base URL from config or use the default."""

mcp_agent/llm/providers/augmented_llm_tensorzero_openai.py

@@ -0,0 +1,127 @@
+from typing import Any, Dict, List, Optional
+
+from openai.types.chat import ChatCompletionMessageParam, ChatCompletionSystemMessageParam
+
+from mcp_agent.core.request_params import RequestParams
+from mcp_agent.llm.provider_types import Provider
+from mcp_agent.llm.providers.augmented_llm_openai import OpenAIAugmentedLLM
+
+
+class TensorZeroOpenAIAugmentedLLM(OpenAIAugmentedLLM):
+    """
+    An LLM augmentation that interacts with TensorZero's OpenAI-compatible inference endpoint.
+    This class extends the base OpenAIAugmentedLLM to handle TensorZero-specific
+    features, such as system template variables and custom parameters.
+    """
+
+    def __init__(self, *args, **kwargs) -> None:
+        """
+        Initializes the TensorZeroOpenAIAugmentedLLM.
+
+        Args:
+            *args: Variable length argument list.
+            **kwargs: Arbitrary keyword arguments.
+        """
+        self._t0_episode_id = kwargs.pop("episode_id", None)
+        self._t0_function_name = kwargs.get("model", "")
+
+        super().__init__(*args, provider=Provider.TENSORZERO, **kwargs)
+        self.logger.info("TensorZeroOpenAIAugmentedLLM initialized.")
+
+    def _initialize_default_params(self, kwargs: dict) -> RequestParams:
+        """
+        Initializes TensorZero-specific default parameters. Ensures the model name
+        is correctly prefixed for the TensorZero API.
+        """
+        model = kwargs.get("model", "")
+        if not model.startswith("tensorzero::"):
+            model = f"tensorzero::function_name::{model}"
+
+        self.logger.debug(f"Initializing with TensorZero model: {model}")
+
+        return RequestParams(
+            model=model,
+            systemPrompt=self.instruction,
+            parallel_tool_calls=True,
+            max_iterations=10,
+            use_history=True,
+        )
+
+    def _base_url(self) -> str:
+        """
+        Constructs the TensorZero OpenAI-compatible endpoint URL.
+        """
+        default_url = "http://localhost:3000/openai/v1"
+        if self.context and self.context.config and hasattr(self.context.config, "tensorzero"):
+            base_url = getattr(self.context.config.tensorzero, "base_url", default_url)
+            # Ensure the path is correctly appended
+            if not base_url.endswith('/openai/v1'):
+                base_url = f"{base_url.rstrip('/')}/openai/v1"
+            self.logger.debug(f"Using TensorZero base URL from config: {base_url}")
+            return base_url
+        self.logger.debug(f"Using default TensorZero base URL: {default_url}")
+        return default_url
+
+    def _prepare_api_request(
+            self,
+            messages: List[ChatCompletionMessageParam],
+            tools: Optional[List[Any]],
+            request_params: RequestParams
+    ) -> Dict[str, Any]:
+        """
+        Prepares the API request for the TensorZero OpenAI-compatible endpoint.
+        This method injects system template variables and other TensorZero-specific
+        parameters into the request. It also handles multimodal inputs.
+        """
+        self.logger.debug("Preparing API request for TensorZero OpenAI endpoint.")
+
+        # Start with the base arguments from the parent class
+        arguments = super()._prepare_api_request(messages, tools, request_params)
+
+        # Handle system template variables
+        if request_params.template_vars:
+            self.logger.debug(f"Injecting template variables: {request_params.template_vars}")
+            system_message_found = False
+            for i, msg in enumerate(messages):
+                if msg.get("role") == "system":
+                    # If content is a string, convert it to the TensorZero format
+                    if isinstance(msg.get("content"), str):
+                        messages[i] = ChatCompletionSystemMessageParam(
+                            role="system",
+                            content=[request_params.template_vars]
+                        )
+                    elif isinstance(msg.get("content"), list):
+                        # If content is already a list, merge the template vars
+                        msg["content"][0].update(request_params.template_vars)
+                    system_message_found = True
+                    break
+
+            if not system_message_found:
+                # If no system message exists, create one
+                messages.insert(0, ChatCompletionSystemMessageParam(
+                    role="system",
+                    content=[request_params.template_vars]
+                ))
+
+        # Add TensorZero-specific extra body parameters
+        extra_body = arguments.get("extra_body", {})
+
+        if self._t0_episode_id:
+            extra_body["tensorzero::episode_id"] = str(self._t0_episode_id)
+            self.logger.debug(f"Added tensorzero::episode_id: {self._t0_episode_id}")
+
+        # Merge metadata arguments
+        if request_params.metadata and isinstance(request_params.metadata, dict):
+            t0_args = request_params.metadata.get("tensorzero_arguments")
+            if t0_args:
+                self.logger.debug(f"Merging tensorzero_arguments from metadata: {t0_args}")
+                for msg in messages:
+                    if msg.get("role") == "system" and isinstance(msg.get("content"), list):
+                        msg["content"][0].update(t0_args)
+                        break
+
+        if extra_body:
+            arguments["extra_body"] = extra_body
+
+        self.logger.debug(f"Final API request arguments: {arguments}")
+        return arguments

mcp_agent/llm/providers/augmented_llm_xai.py

@@ -16,15 +16,15 @@ class XAIAugmentedLLM(OpenAIAugmentedLLM):
 
     def _initialize_default_params(self, kwargs: dict) -> RequestParams:
         """Initialize xAI parameters"""
+        # Get base defaults from parent (includes ModelDatabase lookup)
+        base_params = super()._initialize_default_params(kwargs)
+        
+        # Override with xAI-specific settings
         chosen_model = kwargs.get("model", DEFAULT_XAI_MODEL)
-
-        return RequestParams(
-            model=chosen_model,
-            systemPrompt=self.instruction,
-            parallel_tool_calls=False,
-            max_iterations=20,
-            use_history=True,
-        )
+        base_params.model = chosen_model
+        base_params.parallel_tool_calls = False
+        
+        return base_params
 
     def _base_url(self) -> str:
         base_url = os.getenv("XAI_BASE_URL", XAI_BASE_URL)

mcp_agent/llm/providers/google_converter.py

@@ -336,6 +336,10 @@ class GoogleConverter:
         """
         Converts a single google.genai types.Content to a fast-agent PromptMessageMultipart.
         """
+        # Official fix for GitHub issue #207: Handle None content or content.parts
+        if content is None or not hasattr(content, "parts") or content.parts is None:
+            return PromptMessageMultipart(role="assistant", content=[])
+
         if content.role == "model" and any(part.function_call for part in content.parts):
             return PromptMessageMultipart(role="assistant", content=[])
 

mcp_agent/logging/rich_progress.py

@@ -82,6 +82,7 @@ class RichProgressDisplay:
             ProgressAction.PLANNING: "bold blue",
             ProgressAction.READY: "dim green",
             ProgressAction.CALLING_TOOL: "bold magenta",
+            ProgressAction.TOOL_PROGRESS: "bold magenta",
             ProgressAction.FINISHED: "black on green",
             ProgressAction.SHUTDOWN: "black on red",
             ProgressAction.AGGREGATOR_INITIALIZED: "bold green",
@@ -118,16 +119,38 @@ class RichProgressDisplay:
             # Add special formatting for calling tool with dimmed arrow
             formatted_text = f"▎[dim]◀[/dim] {event.action.value}".ljust(17 + 11)
             description = f"[{self._get_action_style(event.action)}]{formatted_text}"
+        elif event.action == ProgressAction.TOOL_PROGRESS:
+            # Format similar to streaming - show progress numbers
+            if event.progress is not None:
+                if event.total is not None:
+                    progress_display = f"{int(event.progress)}/{int(event.total)}"
+                else:
+                    progress_display = str(int(event.progress))
+            else:
+                progress_display = "Processing"
+            formatted_text = f"▎[dim]▶[/dim] {progress_display}".ljust(17 + 11)
+            description = f"[{self._get_action_style(event.action)}]{formatted_text}"
         else:
             description = f"[{self._get_action_style(event.action)}]▎ {event.action.value:<15}"
 
-        self._progress.update(
-            task_id,
-            description=description,
-            target=event.target or task_name,  # Use task_name as fallback for target
-            details=event.details or "",
-            task_name=task_name,
-        )
+        # Update basic task information
+        update_kwargs = {
+            "description": description,
+            "target": event.target or task_name,  # Use task_name as fallback for target
+            "details": event.details or "",
+            "task_name": task_name,
+        }
+        
+        # For TOOL_PROGRESS events, update progress if available
+        if event.action == ProgressAction.TOOL_PROGRESS and event.progress is not None:
+            if event.total is not None:
+                update_kwargs["completed"] = event.progress
+                update_kwargs["total"] = event.total
+            else:
+                # If no total, just show as indeterminate progress
+                self._progress.reset(task_id)
+        
+        self._progress.update(task_id, **update_kwargs)
 
         if (
             event.action == ProgressAction.INITIALIZED

mcp_agent/mcp/helpers/content_helpers.py

@@ -156,3 +156,32 @@ def get_resource_text(result: ReadResourceResult, index: int = 0) -> Optional[st
         return content.text
 
     return None
+
+
+def split_thinking_content(message: str) -> tuple[Optional[str], str]:
+    """
+    Split a message into thinking and content parts.
+
+    Extracts content between <thinking> tags and returns it along with the remaining content.
+
+    Args:
+        message: A string that may contain a <thinking>...</thinking> block followed by content
+
+    Returns:
+        A tuple of (thinking_content, main_content) where:
+        - thinking_content: The content inside <thinking> tags, or None if not found/parsing fails
+        - main_content: The content after the thinking block, or the entire message if no thinking block
+    """
+    import re
+
+    # Pattern to match <thinking>...</thinking> at the start of the message
+    pattern = r"^<think>(.*?)</think>\s*(.*)$"
+    match = re.match(pattern, message, re.DOTALL)
+
+    if match:
+        thinking_content = match.group(1).strip()
+        main_content = match.group(2).strip()
+        return (thinking_content, main_content)
+    else:
+        # No thinking block found or parsing failed
+        return (None, message)

mcp_agent/mcp/mcp_aggregator.py

@@ -12,6 +12,7 @@ from typing import (
 
 from mcp import GetPromptResult, ReadResourceResult
 from mcp.client.session import ClientSession
+from mcp.shared.session import ProgressFnT
 from mcp.types import (
     CallToolResult,
     ListToolsResult,
@@ -136,6 +137,24 @@ class MCPAggregator(ContextDependent):
         # Lock for refreshing tools from a server
         self._refresh_lock = Lock()
 
+    def _create_progress_callback(self, server_name: str, tool_name: str) -> "ProgressFnT":
+        """Create a progress callback function for tool execution."""
+        async def progress_callback(progress: float, total: float | None, message: str | None) -> None:
+            """Handle progress notifications from MCP tool execution."""
+            logger.info(
+                "Tool progress update",
+                data={
+                    "progress_action": ProgressAction.TOOL_PROGRESS,
+                    "tool_name": tool_name,
+                    "server_name": server_name,
+                    "agent_name": self.agent_name,
+                    "progress": progress,
+                    "total": total,
+                    "details": message or "",  # Put the message in details column
+                },
+            )
+        return progress_callback
+
     async def close(self) -> None:
         """
         Close all persistent connections when the aggregator is deleted.
@@ -468,6 +487,7 @@ class MCPAggregator(ContextDependent):
         method_name: str,
         method_args: Dict[str, Any] = None,
         error_factory: Callable[[str], R] = None,
+        progress_callback: ProgressFnT | None = None,
     ) -> R:
         """
         Generic method to execute operations on a specific server.
@@ -479,6 +499,7 @@ class MCPAggregator(ContextDependent):
             method_name: Name of the method to call on the client session
             method_args: Arguments to pass to the method
             error_factory: Function to create an error return value if the operation fails
+            progress_callback: Optional progress callback for operations that support it
 
         Returns:
             Result from the operation or an error result
@@ -487,7 +508,12 @@ class MCPAggregator(ContextDependent):
         async def try_execute(client: ClientSession):
             try:
                 method = getattr(client, method_name)
-                return await method(**method_args)
+                # For call_tool method, check if we need to add progress_callback
+                if method_name == "call_tool" and progress_callback:
+                    # The call_tool method signature includes progress_callback parameter
+                    return await method(**method_args, progress_callback=progress_callback)
+                else:
+                    return await method(**method_args)
             except Exception as e:
                 error_msg = (
                     f"Failed to {method_name} '{operation_name}' on server '{server_name}': {e}"
@@ -597,6 +623,10 @@ class MCPAggregator(ContextDependent):
         with tracer.start_as_current_span(f"MCP Tool: {server_name}/{local_tool_name}"):
             trace.get_current_span().set_attribute("tool_name", local_tool_name)
             trace.get_current_span().set_attribute("server_name", server_name)
+            
+            # Create progress callback for this tool execution
+            progress_callback = self._create_progress_callback(server_name, local_tool_name)
+            
             return await self._execute_on_server(
                 server_name=server_name,
                 operation_type="tool",
@@ -609,6 +639,7 @@ class MCPAggregator(ContextDependent):
                 error_factory=lambda msg: CallToolResult(
                     isError=True, content=[TextContent(type="text", text=msg)]
                 ),
+                progress_callback=progress_callback,
             )
 
     async def get_prompt(

mcp_agent/resources/examples/tensorzero/.env.sample

@@ -0,0 +1,2 @@
+OPENAI_API_KEY=
+ANTHROPIC_API_KEY=

mcp_agent/resources/examples/tensorzero/Makefile

@@ -0,0 +1,31 @@
+.PHONY: all
+
+build:
+	docker compose build
+
+up:
+	docker compose up -d
+
+logs:
+	docker compose logs -f
+
+tensorzero-logs:
+	docker compose logs -f gateway
+
+mcp-logs:
+	docker compose logs -f mcp-server
+
+minio-logs:
+	docker compose logs -f minio
+
+stop:
+	docker compose stop
+
+agent:
+	uv run agent.py --model=tensorzero.test_chat
+
+simple-agent:
+	uv run simple_agent.py --model=tensorzero.simple_chat
+
+image-test:
+	uv run image_demo.py 

mcp_agent/resources/examples/tensorzero/README.md

@@ -0,0 +1,55 @@
+# About the tensorzero / fast-agent integration
+
+[TensorZero](https://www.tensorzero.com/) is an open source project designed to help LLM application developers rapidly improve their inference calls. Its core features include:
+
+- A uniform inference interface to all leading LLM platforms.
+- The ability to dynamic route to different platforms and program failovers.
+- Automated parameter tuning and training
+- Advance templating features for your system prompts
+- Organization of LLM inference data into a Clickhouse DB allowing for sophisticated downstream analytics
+- A bunch of other good stuff is always in development
+
+`tensorzero` is powerful heavy, so we provide here a quickstart example that combines the basic components of `fast-agent`, an MCP server, `tensorzero`, and other supporting services into a cohesive whole.
+
+## Quickstart guide
+
+- Build and activate the `uv` `fast-agent` environment
+- Ensure that ports `3000`, `4000`, `8000`, `9000`, and `9001` are unallocated before running this demo.
+- Run `cp .env.sample .env` and then drop in at least one of `OPENAI_API_KEY` or `ANTHROPIC_API_KEY`. Make sure the accounts are funded.
+- `make up`
+- `make agent`
+
+The demo test's our implementation's ability to:
+
+- Implement the T0 model gateway as an inference backend
+- Implement T0's dynamic templating feature
+- Have in-conversation memory
+- Describe and execute tool calls
+- Remember previous tool calls
+
+A version of a conversation to test all of this could be:
+
+```
+Hi.
+
+Tell me a poem.
+
+Do you have any tools that you can use?
+
+Please demonstrate the use of that tool on your last response.
+
+Please summarize the conversation so far.
+
+What tool calls have you executed in this session, and what were their results?
+```
+
+## Multimodal support
+
+Run `make image-test` to test the gateway's ability to handle base64-encoded image data
+
+## Development notes:
+
+- `make stop` will stop the MCP server and the tensorzero server
+- `make tenzorzero-logs` will tail the tensorzero server logs
+- `make mcp-logs` will tail the MCP server logs
+- Generic `make logs` dumps all log output from all services to terminal

mcp_agent/resources/examples/tensorzero/agent.py

@@ -0,0 +1,35 @@
+import asyncio
+
+from mcp_agent.core.fastagent import FastAgent
+from mcp_agent.core.request_params import RequestParams
+
+# Explicitly provide the path to the config file in the current directory
+CONFIG_FILE = "fastagent.config.yaml"
+fast = FastAgent("fast-agent example", config_path=CONFIG_FILE, ignore_unknown_args=True)
+
+# Define T0 system variables here
+my_t0_system_vars = {
+    "TEST_VARIABLE_1": "Roses are red",
+    "TEST_VARIABLE_2": "Violets are blue",
+    "TEST_VARIABLE_3": "Sugar is sweet",
+    "TEST_VARIABLE_4": "Vibe code responsibly 👍",
+}
+
+
+@fast.agent(
+    name="default",
+    instruction="""
+        You are an agent dedicated to helping developers understand the relationship between TensoZero and fast-agent. If the user makes a request 
+        that requires you to invoke the test tools, please do so. When you use the tool, describe your rationale for doing so. 
+    """,
+    servers=["tester"],
+    request_params=RequestParams(template_vars=my_t0_system_vars),
+)
+async def main():
+    async with fast.run() as agent_app:  # Get the AgentApp wrapper
+        print("\nStarting interactive session with template_vars set via decorator...")
+        await agent_app.interactive()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())  # type: ignore