fast-agent-mcp 0.2.21__tar.gz → 0.2.22__tar.gz

{fast_agent_mcp-0.2.21 → fast_agent_mcp-0.2.22}/.gitignore

@@ -182,6 +182,7 @@ fastagent.secrets.yaml
 CLAUDE.md
 example-outputs/
 
+tests/integration/api/weather_location.txt
 tests/integration/prompt-state/simple.txt
 tests/integration/workflow/router/fastagent.jsonl
 tests/e2e/smoke/weather_location.txt
@@ -195,3 +196,7 @@ tests/integration/prompt-state/multipart.json
 tests/integration/prompt-state/history.json
 !tests/integration/api/fastagent.secrets.yaml
 fastagent.jsonl
+
+# JetBrains IDEs
+.idea/
+tests/e2e/smoke/base/weather_location.txt

{fast_agent_mcp-0.2.21 → fast_agent_mcp-0.2.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.2.21
+Version: 0.2.22
 Summary: Define, Prompt and Test MCP enabled Agents and Workflows
 Author-email: Shaun Smith <fastagent@llmindset.co.uk>, Sarmad Qadri <sarmad@lastmileai.dev>
 License:                                  Apache License
@@ -213,7 +213,7 @@ Requires-Dist: a2a-types>=0.1.0
 Requires-Dist: aiohttp>=3.11.13
 Requires-Dist: anthropic>=0.49.0
 Requires-Dist: fastapi>=0.115.6
-Requires-Dist: mcp~=1.7.0
+Requires-Dist: mcp>=1.8.0
 Requires-Dist: openai>=1.63.2
 Requires-Dist: opentelemetry-distro>=0.50b0
 Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.29.0
@@ -224,6 +224,7 @@ Requires-Dist: pydantic-settings>=2.7.0
 Requires-Dist: pydantic>=2.10.4
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: rich>=13.9.4
+Requires-Dist: tensorzero>=2025.4.7
 Requires-Dist: typer>=0.15.1
 Provides-Extra: dev
 Requires-Dist: anthropic>=0.42.0; extra == 'dev'
@@ -260,6 +261,7 @@ The simple declarative syntax lets you concentrate on composing your Prompts and
 `fast-agent` is multi-modal, supporting Images and PDFs for both Anthropic and OpenAI endpoints via Prompts, Resources and MCP Tool Call results. The inclusion of passthrough and playback LLMs enable rapid development and test of Python glue-code for your applications.
 
 > [!IMPORTANT]
+>
 > `fast-agent` The fast-agent documentation repo is here: https://github.com/evalstate/fast-agent-docs. Please feel free to submit PRs for documentation, experience reports or other content you think others may find helpful. All help and feedback warmly received.
 
 ### Agent Application Development
@@ -277,12 +279,12 @@ Simple model selection makes testing Model <-> MCP Server interaction painless.
 Start by installing the [uv package manager](https://docs.astral.sh/uv/) for Python. Then:
 
 ```bash
-uv pip install fast-agent-mcp       # install fast-agent!
+uv pip install fast-agent-mcp          # install fast-agent!
 
-fast-agent setup                    # create an example agent and config files
-uv run agent.py                     # run your first agent
-uv run agent.py --model=o3-mini.low # specify a model
-fast-agent quickstart workflow       # create "building effective agents" examples
+uv run fast-agent setup                # create an example agent and config files
+uv run agent.py                        # run your first agent
+uv run agent.py --model=o3-mini.low    # specify a model
+uv run fast-agent quickstart workflow  # create "building effective agents" examples
 ```
 
 Other quickstart examples include a Researcher Agent (with Evaluator-Optimizer workflow) and Data Analysis Agent (similar to the ChatGPT experience), demonstrating MCP Roots support.

{fast_agent_mcp-0.2.21 → fast_agent_mcp-0.2.22}/README.md

@@ -19,6 +19,7 @@ The simple declarative syntax lets you concentrate on composing your Prompts and
 `fast-agent` is multi-modal, supporting Images and PDFs for both Anthropic and OpenAI endpoints via Prompts, Resources and MCP Tool Call results. The inclusion of passthrough and playback LLMs enable rapid development and test of Python glue-code for your applications.
 
 > [!IMPORTANT]
+>
 > `fast-agent` The fast-agent documentation repo is here: https://github.com/evalstate/fast-agent-docs. Please feel free to submit PRs for documentation, experience reports or other content you think others may find helpful. All help and feedback warmly received.
 
 ### Agent Application Development
@@ -36,12 +37,12 @@ Simple model selection makes testing Model <-> MCP Server interaction painless.
 Start by installing the [uv package manager](https://docs.astral.sh/uv/) for Python. Then:
 
 ```bash
-uv pip install fast-agent-mcp       # install fast-agent!
+uv pip install fast-agent-mcp          # install fast-agent!
 
-fast-agent setup                    # create an example agent and config files
-uv run agent.py                     # run your first agent
-uv run agent.py --model=o3-mini.low # specify a model
-fast-agent quickstart workflow       # create "building effective agents" examples
+uv run fast-agent setup                # create an example agent and config files
+uv run agent.py                        # run your first agent
+uv run agent.py --model=o3-mini.low    # specify a model
+uv run fast-agent quickstart workflow  # create "building effective agents" examples
 ```
 
 Other quickstart examples include a Researcher Agent (with Evaluator-Optimizer workflow) and Data Analysis Agent (similar to the ChatGPT experience), demonstrating MCP Roots support.

fast_agent_mcp-0.2.22/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

fast_agent_mcp-0.2.22/examples/tensorzero/agent.py

@@ -0,0 +1,36 @@
+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
+        agent_name = "default"
+        print("\nStarting interactive session with template_vars set via decorator...")
+        await agent_app.interactive(agent=agent_name)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())  # type: ignore

fast_agent_mcp-0.2.22/examples/tensorzero/docker-compose.yml

@@ -0,0 +1,104 @@
+# This is a simplified example for learning purposes. Do not use this in production.
+# For production-ready deployments, see: https://www.tensorzero.com/docs/gateway/deployment
+
+# Top-level volumes definition
+volumes:
+  minio_data: {}
+
+services:
+  clickhouse:
+    image: clickhouse/clickhouse-server:24.12-alpine
+    environment:
+      CLICKHOUSE_USER: chuser
+      CLICKHOUSE_DEFAULT_ACCESS_MANAGEMENT: 1
+      CLICKHOUSE_PASSWORD: chpassword
+    ports:
+      - "8123:8123"
+    healthcheck:
+      test: wget --spider --tries 1 http://chuser:chpassword@clickhouse:8123/ping
+      start_period: 30s
+      start_interval: 1s
+      timeout: 1s
+
+  gateway:
+    image: tensorzero/gateway
+    volumes:
+      - ./tensorzero_config:/app/config:ro
+    env_file:
+      - ./.env
+    command: --config-file /app/config/tensorzero.toml
+    environment: # WARNING: Insecure default credentials for local testing ONLY. Don't send this to production.
+      TENSORZERO_CLICKHOUSE_URL: http://chuser:chpassword@clickhouse:8123/tensorzero
+      S3_ACCESS_KEY_ID: user
+      S3_SECRET_ACCESS_KEY: password
+    ports:
+      - "3000:3000"
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+    depends_on:
+      clickhouse:
+        condition: service_healthy
+      minio:
+        condition: service_healthy
+      mcp-server:
+        condition: service_healthy
+
+  gateway-ui:
+    image: tensorzero/ui
+    volumes:
+      - ./tensorzero_config:/app/config:ro
+    env_file:
+      - ./.env
+    command: --config-file /app/config/tensorzero.toml
+    environment:
+      TENSORZERO_CLICKHOUSE_URL: http://chuser:chpassword@clickhouse:8123/tensorzero
+      TENSORZERO_GATEWAY_URL: http://gateway:3000
+      S3_ACCESS_KEY_ID: user
+      S3_SECRET_ACCESS_KEY: password
+    ports:
+      - "4000:4000"
+    depends_on:
+      clickhouse:
+        condition: service_healthy
+
+  mcp-server:
+    build:
+      context: ../..
+      dockerfile: examples/tensorzero/mcp_server/Dockerfile
+    volumes:
+      - ./mcp_server:/app
+    ports:
+      - "8000:8000"
+    depends_on:
+      minio:
+        condition: service_healthy
+    healthcheck:
+      test:
+        [
+          "CMD",
+          "wget",
+          "--spider",
+          "--tries=1",
+          "http://localhost:8000/t0-example-server/sse",
+        ]
+      interval: 10s
+      timeout: 5s
+      retries: 12
+      start_period: 20s
+
+  minio:
+    image: minio/minio:latest
+    ports:
+      - "9000:9000" # API port
+      - "9001:9001" # Console port
+    volumes:
+      - minio_data:/data
+    environment: # WARNING: Insecure default credentials for local testing ONLY.
+      MINIO_ROOT_USER: user
+      MINIO_ROOT_PASSWORD: password
+    command: server /data --console-address :9001
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
+      interval: 30s
+      timeout: 20s
+      retries: 3

fast_agent_mcp-0.2.22/examples/tensorzero/fastagent.config.yaml

@@ -0,0 +1,18 @@
+default_model: haiku
+
+tensorzero:
+  base_url: http://localhost:3000
+
+logger:
+  level: "info"
+  progress_display: true
+  show_chat: true
+  show_tools: true
+  truncate_tools: true
+
+mcp:
+  servers:
+    tester:
+      transport: "sse"
+      url: "http://localhost:8000/t0-example-server/sse"
+      read_transport_sse_timeout_seconds: 300

fast_agent_mcp-0.2.22/examples/tensorzero/image_demo.py

@@ -0,0 +1,67 @@
+import asyncio
+import base64
+import mimetypes
+from pathlib import Path
+from typing import List, Union
+
+from mcp.types import ImageContent, TextContent
+
+from mcp_agent.core.fastagent import FastAgent
+from mcp_agent.core.prompt import Prompt
+from mcp_agent.core.request_params import RequestParams
+
+AGENT_NAME = "tensorzero_image_tester"
+TENSORZERO_MODEL = "tensorzero.test_chat"
+TEXT_PROMPT = (
+    "Provide a description of the similarities and differences between these three images."
+)
+LOCAL_IMAGE_FILES = [
+    Path("./demo_images/clam.jpg"),
+    Path("./demo_images/shrimp.png"),
+    Path("./demo_images/crab.png"),
+]
+
+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 = FastAgent("TensorZero Image Demo - Base64 Only")
+
+
+@fast.agent(
+    name=AGENT_NAME,
+    model=TENSORZERO_MODEL,
+    request_params=RequestParams(template_vars=MY_T0_SYSTEM_VARS),
+)
+async def main():
+    content_parts: List[Union[TextContent, ImageContent]] = []
+    content_parts.append(TextContent(type="text", text=TEXT_PROMPT))
+
+    for file_path in LOCAL_IMAGE_FILES:
+        mime_type, _ = mimetypes.guess_type(file_path)
+        if not mime_type or not mime_type.startswith("image/"):
+            ext = file_path.suffix.lower()
+            if ext == ".jpg" or ext == ".jpeg":
+                mime_type = "image/jpeg"
+            elif ext == ".png":
+                mime_type = "image/png"
+        if mime_type is None:
+            mime_type = "image/png"  # Default fallback if still None
+
+        with open(file_path, "rb") as image_file:
+            image_bytes = image_file.read()
+
+        encoded_data = base64.b64encode(image_bytes).decode("utf-8")
+        content_parts.append(ImageContent(type="image", mimeType=mime_type, data=encoded_data))
+
+    message = Prompt.user(*content_parts)
+    async with fast.run() as agent_app:
+        agent = getattr(agent_app, AGENT_NAME)
+        await agent.send(message)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())  # type: ignore

fast_agent_mcp-0.2.22/examples/tensorzero/mcp_server/mcp_server.py

@@ -0,0 +1,31 @@
+import uvicorn
+from mcp.server.fastmcp.server import FastMCP
+from starlette.applications import Starlette
+from starlette.routing import Mount
+
+SERVER_PATH = "t0-example-server"
+
+
+mcp_instance = FastMCP(name="t0-example-server")
+mcp_instance.settings.message_path = f"/{SERVER_PATH}/messages/"
+mcp_instance.settings.sse_path = f"/{SERVER_PATH}/sse"
+
+
+@mcp_instance.tool()
+def example_tool(input_text: str) -> str:
+    """Example tool that reverses the text of a given string."""
+    reversed_text = input_text[::-1]
+    return reversed_text
+
+
+app = Starlette(
+    routes=[
+        Mount("/", app=mcp_instance.sse_app()),
+    ]
+)
+
+if __name__ == "__main__":
+    print(f"Starting minimal MCP server ({mcp_instance.name}) on http://127.0.0.1:8000")
+    print(f" -> SSE endpoint: {mcp_instance.settings.sse_path}")
+    print(f" -> Message endpoint: {mcp_instance.settings.message_path}")
+    uvicorn.run(app, host="127.0.0.1", port=8000)

fast_agent_mcp-0.2.22/examples/tensorzero/simple_agent.py

@@ -0,0 +1,25 @@
+import asyncio
+
+from mcp_agent.core.fastagent import FastAgent
+
+CONFIG_FILE = "fastagent.config.yaml"
+fast = FastAgent("fast-agent example", config_path=CONFIG_FILE, ignore_unknown_args=True)
+
+
+@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"],
+)
+async def main():
+    async with fast.run() as agent_app:
+        agent_name = "default"
+        print("\nStarting interactive session with template_vars set via decorator...")
+        await agent_app.interactive(agent=agent_name)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())  # type: ignore

{fast_agent_mcp-0.2.21 → fast_agent_mcp-0.2.22}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fast-agent-mcp"
-version = "0.2.21"
+version = "0.2.22"
 description = "Define, Prompt and Test MCP enabled Agents and Workflows"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -16,7 +16,7 @@ classifiers = [
 requires-python = ">=3.10"
 dependencies = [
     "fastapi>=0.115.6",
-    "mcp~=1.7.0",
+    "mcp>=1.8.0",
     "opentelemetry-distro>=0.50b0",
     "opentelemetry-exporter-otlp-proto-http>=1.29.0",
     "pydantic-settings>=2.7.0",
@@ -31,6 +31,7 @@ dependencies = [
     "a2a-types>=0.1.0",
     "opentelemetry-instrumentation-openai>=0.39.3",
     "opentelemetry-instrumentation-anthropic>=0.39.3",
+    "tensorzero>=2025.4.7",
 ]
 
 [project.optional-dependencies]
@@ -100,6 +101,7 @@ dev = [
     "pytest>=7.4.0",
     "pytest-asyncio>=0.21.1",
     "pytest-cov>=6.1.1",
+    "ipdb>=0.13.13",
 ]
 
 [project.scripts]

{fast_agent_mcp-0.2.21 → fast_agent_mcp-0.2.22}/src/mcp_agent/cli/commands/go.py

@@ -18,8 +18,13 @@ async def _run_agent(
     config_path: Optional[str] = None,
     server_list: Optional[List[str]] = None,
     model: Optional[str] = None,
+    message: Optional[str] = None,
+    prompt_file: Optional[str] = None
 ) -> None:
     """Async implementation to run an interactive agent."""
+    from pathlib import Path
+
+    from mcp_agent.mcp.prompts.prompt_load import load_prompt_multipart
 
     # Create the FastAgent instance with CLI arg parsing enabled
     # It will automatically parse args like --model, --quiet, etc.
@@ -27,6 +32,7 @@ async def _run_agent(
         "name": name,
         "config_path": config_path,
         "ignore_unknown_args": True,
+        "parse_cli_args": False,  # Don't parse CLI args, we're handling it ourselves
     }
     
     fast = FastAgent(**fast_kwargs)
@@ -38,10 +44,26 @@ async def _run_agent(
     if model:
         agent_kwargs["model"] = model
     
-    @fast.agent(**agent_kwargs)
-    async def cli_agent():
-        async with fast.run() as agent:
-            await agent.interactive()
+    # Handle prompt file and message options
+    if message or prompt_file:
+        @fast.agent(**agent_kwargs)
+        async def cli_agent():
+            async with fast.run() as agent:
+                if message:
+                    response = await agent.send(message)
+                    # Print the response and exit
+                    print(response)
+                elif prompt_file:
+                    prompt = load_prompt_multipart(Path(prompt_file))
+                    response = await agent.generate(prompt)
+                    # Print the response text and exit
+                    print(response.last_text())
+    else:
+        # Standard interactive mode
+        @fast.agent(**agent_kwargs)
+        async def cli_agent():
+            async with fast.run() as agent:
+                await agent.interactive()
 
     # Run the agent
     await cli_agent()
@@ -51,7 +73,9 @@ def run_async_agent(
     instruction: str, 
     config_path: Optional[str] = None, 
     servers: Optional[str] = None,
-    model: Optional[str] = None
+    model: Optional[str] = None,
+    message: Optional[str] = None,
+    prompt_file: Optional[str] = None
 ):
     """Run the async agent function with proper loop handling."""
     server_list = servers.split(',') if servers else None
@@ -75,7 +99,9 @@ def run_async_agent(
             instruction=instruction, 
             config_path=config_path, 
             server_list=server_list,
-            model=model
+            model=model,
+            message=message,
+            prompt_file=prompt_file
         ))
     finally:
         try:
@@ -108,26 +134,38 @@ def go(
     model: Optional[str] = typer.Option(
         None, "--model", help="Override the default model (e.g., haiku, sonnet, gpt-4)"
     ),
+    message: Optional[str] = typer.Option(
+        None, "--message", "-m", help="Message to send to the agent (skips interactive mode)"
+    ),
+    prompt_file: Optional[str] = typer.Option(
+        None, "--prompt-file", "-p", help="Path to a prompt file to use (either text or JSON)"
+    ),
 ) -> None:
     """
     Run an interactive agent directly from the command line.
 
-    Example:
+    Examples:
         fast-agent go --model=haiku --instruction="You are a coding assistant" --servers=fetch,filesystem
+        fast-agent go --message="What is the weather today?" --model=haiku
+        fast-agent go --prompt-file=my-prompt.txt --model=haiku
 
     This will start an interactive session with the agent, using the specified model
     and instruction. It will use the default configuration from fastagent.config.yaml
     unless --config-path is specified.
 
     Common options:
-        --model: Override the default model (e.g., --model=haiku)
-        --quiet: Disable progress display and logging
-        --servers: Comma-separated list of server names to enable from config
+        --model               Override the default model (e.g., --model=haiku)
+        --quiet               Disable progress display and logging
+        --servers             Comma-separated list of server names to enable from config
+        --message, -m         Send a single message and exit
+        --prompt-file, -p     Use a prompt file instead of interactive mode
     """
     run_async_agent(
         name=name, 
         instruction=instruction, 
         config_path=config_path, 
         servers=servers,
-        model=model
+        model=model,
+        message=message,
+        prompt_file=prompt_file
     )

{fast_agent_mcp-0.2.21 → fast_agent_mcp-0.2.22}/src/mcp_agent/config.py

@@ -198,6 +198,16 @@ class OpenTelemetrySettings(BaseModel):
     """Sample rate for tracing (1.0 = sample everything)"""
 
 
+class TensorZeroSettings(BaseModel):
+    """
+    Settings for using TensorZero via its OpenAI-compatible API.
+    """
+
+    base_url: Optional[str] = None
+    api_key: Optional[str] = None
+    model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
+
+
 class LoggerSettings(BaseModel):
     """
     Logger settings for the fast-agent application.
@@ -287,6 +297,9 @@ class Settings(BaseSettings):
     generic: GenericSettings | None = None
     """Settings for using Generic models in the fast-agent application"""
 
+    tensorzero: Optional[TensorZeroSettings] = None
+    """Settings for using TensorZero inference gateway"""
+
     logger: LoggerSettings | None = LoggerSettings()
     """Logger settings for the fast-agent application"""
 

{fast_agent_mcp-0.2.21 → fast_agent_mcp-0.2.22}/src/mcp_agent/core/request_params.py

@@ -2,7 +2,7 @@
 Request parameters definitions for LLM interactions.
 """
 
-from typing import Any, List
+from typing import Any, Dict, List
 
 from mcp import SamplingMessage
 from mcp.types import CreateMessageRequestParams
@@ -48,3 +48,8 @@ class RequestParams(CreateMessageRequestParams):
     """
     Override response format for structured calls. Prefer sending pydantic model - only use in exceptional circumstances
     """
+
+    template_vars: Dict[str, Any] = Field(default_factory=dict)
+    """
+    Optional dictionary of template variables for dynamic templates. Currently only works for TensorZero inference backend
+    """

{fast_agent_mcp-0.2.21 → fast_agent_mcp-0.2.22}/src/mcp_agent/event_progress.py

@@ -88,7 +88,7 @@ def convert_log_event(event: Event) -> Optional[ProgressEvent]:
 
     return ProgressEvent(
         action=ProgressAction(progress_action),
-        target=target,
+        target=target or "unknown",
         details=details,
         agent_name=event_data.get("agent_name"),
     )

{fast_agent_mcp-0.2.21 → fast_agent_mcp-0.2.22}/src/mcp_agent/llm/augmented_llm.py

@@ -76,20 +76,14 @@ def deep_merge(dict1: Dict[Any, Any], dict2: Dict[Any, Any]) -> Dict[Any, Any]:
         Dict: The updated `dict1`.
     """
     for key in dict2:
-        if (
-            key in dict1
-            and isinstance(dict1[key], dict)
-            and isinstance(dict2[key], dict)
-        ):
+        if key in dict1 and isinstance(dict1[key], dict) and isinstance(dict2[key], dict):
             deep_merge(dict1[key], dict2[key])
         else:
             dict1[key] = dict2[key]
     return dict1
 
 
-class AugmentedLLM(
-    ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT, MessageT]
-):
+class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT, MessageT]):
     # Common parameter names used across providers
     PARAM_MESSAGES = "messages"
     PARAM_MODEL = "model"
@@ -100,7 +94,7 @@ class AugmentedLLM(
     PARAM_METADATA = "metadata"
     PARAM_USE_HISTORY = "use_history"
     PARAM_MAX_ITERATIONS = "max_iterations"
-
+    PARAM_TEMPLATE_VARS = "template_vars"
     # Base set of fields that should always be excluded
     BASE_EXCLUDE_FIELDS = {PARAM_METADATA}