fast-agent-mcp 0.2.21__py3-none-any.whl → 0.2.22__py3-none-any.whl

{fast_agent_mcp-0.2.21.dist-info → fast_agent_mcp-0.2.22.dist-info}/METADATA

@@ -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.dist-info → fast_agent_mcp-0.2.22.dist-info}/RECORD

@@ -1,10 +1,10 @@
 mcp_agent/__init__.py,sha256=18T0AG0W9sJhTY38O9GFFOzliDhxx9p87CvRyti9zbw,1620
 mcp_agent/app.py,sha256=WRsiUdwy_9IAnaGRDwuLm7pzgQpt2wgsg10vBOpfcwM,5539
-mcp_agent/config.py,sha256=_b5JeS2nWHScSUUTu6wYxXzdfKefoqII305ecKcw7Gs,12248
+mcp_agent/config.py,sha256=ZC4SiIVbxVn7-hUfv3RFj6fNrXxvci6gmUNCGM7vzs8,12624
 mcp_agent/console.py,sha256=Gjf2QLFumwG1Lav__c07X_kZxxEUSkzV-1_-YbAwcwo,813
 mcp_agent/context.py,sha256=Kb3s_0MolHx7AeTs1NVcY3ly-xFBd35o8LT7Srpx9is,7334
 mcp_agent/context_dependent.py,sha256=QXfhw3RaQCKfscEEBRGuZ3sdMWqkgShz2jJ1ivGGX1I,1455
-mcp_agent/event_progress.py,sha256=3dqk5Pn1tAG_m_wn4IPNwLWLyzm7CyKIidqHN-4l-JY,2736
+mcp_agent/event_progress.py,sha256=b1VKlQQF2AgPMb6XHjlJAVoPdx8GuxRTUk2g-4lBNm0,2749
 mcp_agent/mcp_server_registry.py,sha256=jUmCdfcpTitXm1-3TxpWsdRWY_8phdKNYgXwB16ZSVU,10100
 mcp_agent/progress_display.py,sha256=GeJU9VUt6qKsFVymG688hCMVCsAygG9ifiiEb5IcbN4,361
 mcp_agent/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -23,7 +23,7 @@ mcp_agent/cli/__main__.py,sha256=AVZ7tQFhU_sDOGuUGJq8ujgKtcxsYJBJwHbVaaiRDlI,166
 mcp_agent/cli/main.py,sha256=XjrgXMBaPKkVqAFo8T9LJz6Tp1-ivrKDOuNYWke99YA,3090
 mcp_agent/cli/terminal.py,sha256=GRwD-RGW7saIz2IOWZn5vD6JjiArscELBThm1GTFkuI,1065
 mcp_agent/cli/commands/check_config.py,sha256=9Ryxo_fLInm3YKdYv46yLrAJgnQtMisGreu6Kkriw2g,16677
-mcp_agent/cli/commands/go.py,sha256=DJpmq4n-p5r8BXH10UqBOexmLND-zSODl5f-w4noR5Q,4304
+mcp_agent/cli/commands/go.py,sha256=2UY8TSDwhh_-p-WYXrZz3pEv3-2eTdBl5Lxy3JyJV0E,6057
 mcp_agent/cli/commands/quickstart.py,sha256=SM3CHMzDgvTxIpKjFuX9BrS_N1vRoXNBDaO90aWx1Rk,14586
 mcp_agent/cli/commands/setup.py,sha256=eOEd4TL-b0DaDeSJMGOfNOsTEItoZ67W88eTP4aP-bo,6482
 mcp_agent/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -38,7 +38,7 @@ mcp_agent/core/fastagent.py,sha256=WEEGz2WBAddDGNeWJwqwFIPLiQnLjaNxZLoMR0peyyU,2
 mcp_agent/core/interactive_prompt.py,sha256=w3VyRzW4hzn0xhWZRwo_qRRAD5WVSrJYe8QDe1XZ55Y,24252
 mcp_agent/core/mcp_content.py,sha256=2D7KHY9mG_vxoDwFLKvsPQV9VRIzHItM7V-jcEnACh8,8878
 mcp_agent/core/prompt.py,sha256=qnintOUGEoDPYLI9bu9G2OlgVMCe5ZPUZilgMzydXhc,7919
-mcp_agent/core/request_params.py,sha256=loYf13DN7e-DsdYRd37jWkJWJGwVBL-iFkcANP1J60Q,1366
+mcp_agent/core/request_params.py,sha256=vRfAz9T6Ir-0oeJ4qEdO62LDOzoLwBuuXcBcdh6WPZ8,1576
 mcp_agent/core/validation.py,sha256=RIBKFlh0GJg4rTcFQXoXp8A0sK1HpsCigKcYSK3gFaY,12090
 mcp_agent/executor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_agent/executor/executor.py,sha256=E44p6d-o3OMRoP_dNs_cDnyti91LQ3P9eNU88mSi1kc,9462
@@ -48,26 +48,28 @@ mcp_agent/human_input/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3h
 mcp_agent/human_input/handler.py,sha256=s712Z5ssTCwjL9-VKoIdP5CtgMh43YvepynYisiWTTA,3144
 mcp_agent/human_input/types.py,sha256=RtWBOVzy8vnYoQrc36jRLn8z8N3C4pDPMBN5vF6qM5Y,1476
 mcp_agent/llm/__init__.py,sha256=d8zgwG-bRFuwiMNMYkywg_qytk4P8lawyld_meuUmHI,68
-mcp_agent/llm/augmented_llm.py,sha256=ASe604OhrMZ9dVoGEUEpUQaY6fFamz4gL8ttzWP_9m0,24212
+mcp_agent/llm/augmented_llm.py,sha256=CqtSGo_QrHE73tz_DHMd0wdt2F41gwuUu5Bue51FNm4,24199
 mcp_agent/llm/augmented_llm_passthrough.py,sha256=zHcctNpwg4EFJvD1x9Eg443SVX-uyzFphLikwF_yVE0,6288
 mcp_agent/llm/augmented_llm_playback.py,sha256=6L_RWIK__R67oZK7u3Xt3hWy1T2LnHXIO-efqgP3tPw,4177
 mcp_agent/llm/memory.py,sha256=HQ_c1QemOUjrkY6Z2omE6BG5fXga7y4jN7KCMOuGjPs,3345
-mcp_agent/llm/model_factory.py,sha256=QK3RrEhpvafKRlTFYR8Z9oNJRGjO7J9wIx5TGcDu6As,7649
+mcp_agent/llm/model_factory.py,sha256=h3NJSa0yPa9iiLojEqBhIm9wgEBB46ZBibe44MnskHM,8089
 mcp_agent/llm/prompt_utils.py,sha256=yWQHykoK13QRF7evHUKxVF0SpVLN-Bsft0Yixzvn0g0,4825
 mcp_agent/llm/provider_key_manager.py,sha256=-K_FuibN6hdSnweT32lB8mKTfCARnbja6zYYs0ErTKg,2802
-mcp_agent/llm/provider_types.py,sha256=3IRRt9UbIHZHVJq1KF1XYfzsQtF9gj_gBNtU3hukIaY,308
+mcp_agent/llm/provider_types.py,sha256=oWwXTlyr6hIzU_QLJ5T-UwxZGo5e4Pjwtahz2cr1PHg,364
 mcp_agent/llm/sampling_converter.py,sha256=C7wPBlmT0eD90XWabC22zkxsrVHKCrjwIwg6cG628cI,2926
 mcp_agent/llm/sampling_format_converter.py,sha256=xGz4odHpOcP7--eFaJaFtUR8eR9jxZS7MnLH6J7n0EU,1263
 mcp_agent/llm/providers/__init__.py,sha256=heVxtmuqFJOnjjxHz4bWSqTAxXoN1E8twC_gQ_yJpHk,265
 mcp_agent/llm/providers/anthropic_utils.py,sha256=vYDN5G5jKMhD2CQg8veJYab7tvvzYkDMq8M1g_hUAQg,3275
-mcp_agent/llm/providers/augmented_llm_anthropic.py,sha256=RQ4r5Q84VJ_dyuNo23b-EMzvq6RrpspzIQWtfVUfw6M,15468
+mcp_agent/llm/providers/augmented_llm_anthropic.py,sha256=gK_IvllVBNJUUrSfpgFpdhM-d4liCt0MLq7d2lXS7RI,15510
 mcp_agent/llm/providers/augmented_llm_deepseek.py,sha256=NiZK5nv91ZS2VgVFXpbsFNFYLsLcppcbo_RstlRMd7I,1145
 mcp_agent/llm/providers/augmented_llm_generic.py,sha256=5Uq8ZBhcFuQTt7koP_5ykolREh2iWu8zKhNbh3pM9lQ,1210
 mcp_agent/llm/providers/augmented_llm_google.py,sha256=N0a2fphVtkvNYxKQpEX6J4tlO1C_mRw4sw3LBXnrOeI,1130
-mcp_agent/llm/providers/augmented_llm_openai.py,sha256=TumZs1y678IvyvYIehf8xSDqYWqC44dWrIbqFGtz03g,14085
+mcp_agent/llm/providers/augmented_llm_openai.py,sha256=0C7BOB7i3xo0HsMCTagRSQ8Hsywb-31mot26OfohzCU,14478
 mcp_agent/llm/providers/augmented_llm_openrouter.py,sha256=V_TlVKm92GHBxYIo6gpvH_6cAaIdppS25Tz6x5T7LW0,2341
+mcp_agent/llm/providers/augmented_llm_tensorzero.py,sha256=Mol_Wzj_ZtccW-LMw0oFwWUt1m1yfofloay9QYNP23c,20729
 mcp_agent/llm/providers/multipart_converter_anthropic.py,sha256=t5lHYGfFUacJldnrVtMNW-8gEMoto8Y7hJkDrnyZR-Y,16650
 mcp_agent/llm/providers/multipart_converter_openai.py,sha256=XPIulWntNpZWNGWrc240StPzok2RqrDAV7OigDwQ1uU,15850
+mcp_agent/llm/providers/multipart_converter_tensorzero.py,sha256=BFTdyVk42HZskDAuTHicfDTUJq89d1fz8C9nAOuHxlE,8646
 mcp_agent/llm/providers/openai_multipart.py,sha256=qKBn7d3jSabnJmVgWweVzqh8q9mBqr09fsPmP92niAQ,6899
 mcp_agent/llm/providers/openai_utils.py,sha256=T4bTCL9f7DsoS_zoKgQKv_FUv_4n98vgbvaUpdWZJr8,1875
 mcp_agent/llm/providers/sampling_converter_anthropic.py,sha256=35WzBWkPklnuMlu5S6XsQIq0YL58NOy8Ja6A_l4m6eM,1612
@@ -85,7 +87,7 @@ mcp_agent/mcp/interfaces.py,sha256=PAou8znAl2HgtvfCpLQOZFbKra9F72OcVRfBJbboNX8,6
 mcp_agent/mcp/logger_textio.py,sha256=vljC1BtNTCxBAda9ExqNB-FwVNUZIuJT3h1nWmCjMws,3172
 mcp_agent/mcp/mcp_agent_client_session.py,sha256=Ng7epBXq8BEA_3m1GX5LqwafgNUAMSzBugwN6N0VUWQ,4364
 mcp_agent/mcp/mcp_aggregator.py,sha256=lVSt0yp0CnaYjcHCWmluwBeFgl8JXHYEZk0MzXgrQzA,40110
-mcp_agent/mcp/mcp_connection_manager.py,sha256=L5Dk4cyarN_v2rfktkrfZJR4xUuD3yN_hUyQnKHBWgM,14044
+mcp_agent/mcp/mcp_connection_manager.py,sha256=6jtjclh4YNJZsNwYnSWmQ6cPzapAwsRUxir1c_gVNfM,16051
 mcp_agent/mcp/mime_utils.py,sha256=difepNR_gpb4MpMLkBRAoyhDk-AjXUHTiqKvT_VwS1o,1805
 mcp_agent/mcp/prompt_message_multipart.py,sha256=BDwRdNwyWHb2q2bccDb2iR2VlORqVvkvoG3xYzcMpCE,4403
 mcp_agent/mcp/prompt_render.py,sha256=k3v4BZDThGE2gGiOYVQtA6x8WTEdOuXIEnRafANhN1U,2996
@@ -143,8 +145,8 @@ mcp_agent/resources/examples/workflows/parallel.py,sha256=DQ5vY5-h8Qa5QHcYjsWXhZ
 mcp_agent/resources/examples/workflows/router.py,sha256=E4x_-c3l4YW9w1i4ARcDtkdeqIdbWEGfsMzwLYpdbVc,1677
 mcp_agent/resources/examples/workflows/short_story.txt,sha256=X3y_1AyhLFN2AKzCKvucJtDgAFIJfnlbsbGZO5bBWu0,1187
 mcp_agent/ui/console_display.py,sha256=TVGDtJ37hc6UG0ei9g7ZPZZfFNeS1MYozt-Mx8HsPCk,9752
-fast_agent_mcp-0.2.21.dist-info/METADATA,sha256=c-Aq5664t9xi4iW2mcDHUGaDL_jRUznn_nyeMVFJzgY,30142
-fast_agent_mcp-0.2.21.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fast_agent_mcp-0.2.21.dist-info/entry_points.txt,sha256=bRniFM5zk3Kix5z7scX0gf9VnmGQ2Cz_Q1Gh7Ir4W00,186
-fast_agent_mcp-0.2.21.dist-info/licenses/LICENSE,sha256=cN3FxDURL9XuzE5mhK9L2paZo82LTfjwCYVT7e3j0e4,10939
-fast_agent_mcp-0.2.21.dist-info/RECORD,,
+fast_agent_mcp-0.2.22.dist-info/METADATA,sha256=HbiOG6NhC3IEfEyBsUDQnihh2LbU4CEZEe19X4Y7VTQ,30194
+fast_agent_mcp-0.2.22.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fast_agent_mcp-0.2.22.dist-info/entry_points.txt,sha256=bRniFM5zk3Kix5z7scX0gf9VnmGQ2Cz_Q1Gh7Ir4W00,186
+fast_agent_mcp-0.2.22.dist-info/licenses/LICENSE,sha256=cN3FxDURL9XuzE5mhK9L2paZo82LTfjwCYVT7e3j0e4,10939
+fast_agent_mcp-0.2.22.dist-info/RECORD,,

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
     )

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"""
 

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
+    """

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"),
     )

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}
 

mcp_agent/llm/model_factory.py

@@ -15,6 +15,7 @@ from mcp_agent.llm.providers.augmented_llm_generic import GenericAugmentedLLM
 from mcp_agent.llm.providers.augmented_llm_google import GoogleAugmentedLLM
 from mcp_agent.llm.providers.augmented_llm_openai import OpenAIAugmentedLLM
 from mcp_agent.llm.providers.augmented_llm_openrouter import OpenRouterAugmentedLLM
+from mcp_agent.llm.providers.augmented_llm_tensorzero import TensorZeroAugmentedLLM
 from mcp_agent.mcp.interfaces import AugmentedLLMProtocol
 
 # from mcp_agent.workflows.llm.augmented_llm_deepseek import DeekSeekAugmentedLLM
@@ -28,6 +29,7 @@ LLMClass = Union[
     Type[PlaybackLLM],
     Type[DeepSeekAugmentedLLM],
     Type[OpenRouterAugmentedLLM],
+    Type[TensorZeroAugmentedLLM],
 ]
 
 
@@ -110,6 +112,7 @@ class ModelFactory:
         Provider.GENERIC: GenericAugmentedLLM,
         Provider.GOOGLE: GoogleAugmentedLLM,  # type: ignore
         Provider.OPENROUTER: OpenRouterAugmentedLLM,
+        Provider.TENSORZERO: TensorZeroAugmentedLLM,
     }
 
     # Mapping of special model names to their specific LLM classes
@@ -142,6 +145,11 @@ class ModelFactory:
                 provider = Provider(potential_provider)
                 model_parts = model_parts[1:]
 
+        if provider == Provider.TENSORZERO and not model_parts:
+            raise ModelConfigError(
+                f"TensorZero provider requires a function name after the provider "
+                f"(e.g., tensorzero.my-function), got: {model_string}"
+            )
         # Join remaining parts as model name
         model_name = ".".join(model_parts)
 

mcp_agent/llm/provider_types.py

@@ -15,3 +15,4 @@ class Provider(Enum):
     DEEPSEEK = "deepseek"
     GENERIC = "generic"
     OPENROUTER = "openrouter"
+    TENSORZERO = "tensorzero"  # For TensorZero Gateway

mcp_agent/llm/providers/augmented_llm_anthropic.py

@@ -62,6 +62,7 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
         AugmentedLLM.PARAM_USE_HISTORY,
         AugmentedLLM.PARAM_MAX_ITERATIONS,
         AugmentedLLM.PARAM_PARALLEL_TOOL_CALLS,
+        AugmentedLLM.PARAM_TEMPLATE_VARS,
     }
 
     def __init__(self, *args, **kwargs) -> None:

mcp_agent/llm/providers/augmented_llm_openai.py

@@ -56,6 +56,7 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
         AugmentedLLM.PARAM_PARALLEL_TOOL_CALLS,
         AugmentedLLM.PARAM_USE_HISTORY,
         AugmentedLLM.PARAM_MAX_ITERATIONS,
+        AugmentedLLM.PARAM_TEMPLATE_VARS,
     }
 
     def __init__(self, provider: Provider = Provider.OPENAI, *args, **kwargs) -> None:
@@ -143,7 +144,7 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
                 function={
                     "name": tool.name,
                     "description": tool.description if tool.description else "",
-                    "parameters": tool.inputSchema,
+                    "parameters": self.adjust_schema(tool.inputSchema),
                 },
             )
             for tool in response.tools
@@ -350,3 +351,15 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
             base_args, request_params, self.OPENAI_EXCLUDE_FIELDS.union(self.BASE_EXCLUDE_FIELDS)
         )
         return arguments
+
+    def adjust_schema(self, inputSchema: Dict) -> Dict:
+        # return inputSchema
+        if not Provider.OPENAI == self.provider:
+            return inputSchema
+
+        if "properties" in inputSchema:
+            return inputSchema
+
+        result = inputSchema.copy()
+        result["properties"] = {}
+        return result

mcp_agent/llm/providers/augmented_llm_tensorzero.py

@@ -0,0 +1,442 @@
+import json
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from mcp.types import (
+    CallToolRequest,
+    CallToolRequestParams,
+    CallToolResult,
+    EmbeddedResource,
+    ImageContent,
+    TextContent,
+)
+from tensorzero import AsyncTensorZeroGateway
+from tensorzero.types import (
+    ChatInferenceResponse,
+    JsonInferenceResponse,
+    TensorZeroError,
+)
+
+from mcp_agent.agents.agent import Agent
+from mcp_agent.core.exceptions import ModelConfigError
+from mcp_agent.core.request_params import RequestParams
+from mcp_agent.llm.augmented_llm import AugmentedLLM
+from mcp_agent.llm.memory import Memory, SimpleMemory
+from mcp_agent.llm.provider_types import Provider
+from mcp_agent.llm.providers.multipart_converter_tensorzero import TensorZeroConverter
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+
+
+class TensorZeroAugmentedLLM(AugmentedLLM[Dict[str, Any], Any]):
+    """
+    AugmentedLLM implementation for TensorZero using its native API.
+    Uses the Converter pattern for message formatting.
+    Implements multi-turn tool calling logic, storing API dicts in history.
+    """
+
+    def __init__(
+        self,
+        agent: Agent,
+        model: str,
+        request_params: Optional[RequestParams] = None,
+        **kwargs: Any,
+    ):
+        self._t0_gateway: Optional[AsyncTensorZeroGateway] = None
+        self._t0_function_name: str = model
+        self._t0_episode_id: Optional[str] = kwargs.get("episode_id")
+
+        super().__init__(
+            agent=agent,
+            model=model,
+            provider=Provider.TENSORZERO,
+            request_params=request_params,
+            **kwargs,
+        )
+
+        self.history: Memory[Dict[str, Any]] = SimpleMemory[Dict[str, Any]]()
+
+        self.logger.info(
+            f"TensorZero LLM provider initialized for function '{self._t0_function_name}'. History type: {type(self.history)}"
+        )
+
+    @staticmethod
+    def block_to_dict(block: Any) -> Dict[str, Any]:
+        if hasattr(block, "model_dump"):
+            try:
+                dumped = block.model_dump(mode="json")
+                if dumped:
+                    return dumped
+            except Exception:
+                pass
+        if hasattr(block, "__dict__"):
+            try:
+                block_vars = vars(block)
+                if block_vars:
+                    return block_vars
+            except Exception:
+                pass
+        if isinstance(block, (str, int, float, bool, list, dict, type(None))):
+            return {"type": "raw", "content": block}
+
+        # Basic attribute extraction as fallback
+        d = {"type": getattr(block, "type", "unknown")}
+        for attr in ["id", "name", "text", "arguments"]:
+            if hasattr(block, attr):
+                d[attr] = getattr(block, attr)
+        if len(d) == 1 and d.get("type") == "unknown":
+            d["content"] = str(block)
+        return d
+
+    def _initialize_default_params(self, kwargs: dict) -> RequestParams:
+        func_name = kwargs.get("model", self._t0_function_name or "unknown_t0_function")
+        return RequestParams(
+            model=func_name,
+            systemPrompt=self.instruction,
+            maxTokens=4096,
+            use_history=True,
+            max_iterations=10,  # Max iterations for tool use loop
+            parallel_tool_calls=True,
+        )
+
+    async def _initialize_gateway(self) -> AsyncTensorZeroGateway:
+        if self._t0_gateway is None:
+            self.logger.debug("Initializing AsyncTensorZeroGateway client...")
+            try:
+                base_url: Optional[str] = None
+                default_url = "http://localhost:3000"
+
+                if (
+                    self.context
+                    and self.context.config
+                    and hasattr(self.context.config, "tensorzero")
+                    and self.context.config.tensorzero
+                ):
+                    base_url = getattr(self.context.config.tensorzero, "base_url", None)
+
+                if not base_url:
+                    if not self.context:
+                        # Handle case where context itself is missing, log and use default
+                        self.logger.warning(
+                            f"LLM context not found. Cannot read TensorZero Gateway base URL configuration. "
+                            f"Using default: {default_url}"
+                        )
+                    else:
+                        self.logger.warning(
+                            f"TensorZero Gateway base URL not configured in context.config.tensorzero.base_url. "
+                            f"Using default: {default_url}"
+                        )
+
+                    base_url = default_url
+
+                self._t0_gateway = await AsyncTensorZeroGateway.build_http(gateway_url=base_url)  # type: ignore
+                self.logger.info(f"TensorZero Gateway client initialized for URL: {base_url}")
+            except Exception as e:
+                self.logger.error(f"Failed to initialize TensorZero Gateway: {e}")
+                raise ModelConfigError(f"Failed to initialize TensorZero Gateway lazily: {e}")
+
+        return self._t0_gateway
+
+    async def _apply_prompt_provider_specific(
+        self,
+        multipart_messages: List[PromptMessageMultipart],
+        request_params: Optional[RequestParams] = None,
+        is_template: bool = False,
+    ) -> PromptMessageMultipart:
+        gateway = await self._initialize_gateway()
+        merged_params = self.get_request_params(request_params)
+
+        # [1] Retrieve history
+        current_api_messages: List[Dict[str, Any]] = []
+        if merged_params.use_history:
+            try:
+                current_api_messages = self.history.get() or []
+                self.logger.debug(
+                    f"Retrieved {len(current_api_messages)} API dict messages from history."
+                )
+            except Exception as e:
+                self.logger.error(f"Error retrieving history: {e}")
+
+        # [2] Convert *new* incoming PromptMessageMultipart messages to API dicts
+        for msg in multipart_messages:
+            msg_dict = TensorZeroConverter.convert_mcp_to_t0_message(msg)
+            if msg_dict:
+                current_api_messages.append(msg_dict)
+
+        t0_system_vars = self._prepare_t0_system_params(merged_params)
+        if t0_system_vars:
+            t0_api_input_dict = {"system": t0_system_vars}
+        else:
+            t0_api_input_dict = {}
+        available_tools: Optional[List[Dict[str, Any]]] = await self._prepare_t0_tools()
+
+        # [3] Initialize storage arrays for the text content of the assistant message reply and, optionally, tool calls and results, and begin inference loop
+        final_assistant_message: List[Union[TextContent, ImageContent, EmbeddedResource]] = []
+        last_executed_results: Optional[List[CallToolResult]] = None
+
+        for i in range(merged_params.max_iterations):
+            use_parallel_calls = merged_params.parallel_tool_calls if available_tools else False
+            current_t0_episode_id = self._t0_episode_id
+
+            try:
+                self.logger.debug(
+                    f"Calling TensorZero inference (Iteration {i + 1}/{merged_params.max_iterations})..."
+                )
+                t0_api_input_dict["messages"] = current_api_messages  # type: ignore
+
+                # [4] Call the TensorZero inference API
+                response_iter_or_completion = await gateway.inference(
+                    function_name=self._t0_function_name,
+                    input=t0_api_input_dict,
+                    additional_tools=available_tools,
+                    parallel_tool_calls=use_parallel_calls,
+                    stream=False,
+                    episode_id=current_t0_episode_id,
+                )
+
+                if not isinstance(
+                    response_iter_or_completion, (ChatInferenceResponse, JsonInferenceResponse)
+                ):
+                    self.logger.error(
+                        f"Unexpected TensorZero response type: {type(response_iter_or_completion)}"
+                    )
+                    final_assistant_message = [
+                        TextContent(type="text", text="Unexpected response type")
+                    ]
+                    break  # Exit loop
+
+                # [5] quick check to confirm that episode_id is present and being used correctly by TensorZero
+                completion = response_iter_or_completion
+                if completion.episode_id:  #
+                    self._t0_episode_id = str(completion.episode_id)
+                    if (
+                        self._t0_episode_id != current_t0_episode_id
+                        and current_t0_episode_id is not None
+                    ):
+                        raise Exception(
+                            f"Episode ID mismatch: {self._t0_episode_id} != {current_t0_episode_id}"
+                        )
+
+                # [6] Adapt TensorZero inference response to a format compatible with the broader framework
+                (
+                    content_parts_this_turn,  # Text/Image content ONLY
+                    executed_results_this_iter,  # Results from THIS iteration
+                    raw_tool_call_blocks,
+                ) = await self._adapt_t0_native_completion(completion, available_tools)
+
+                last_executed_results = (
+                    executed_results_this_iter  # Track results from this iteration
+                )
+
+                # [7] If a text message was returned from the assistant, format that message using the multipart_converter_tensorzero.py helper methods and add this to the current list of API messages
+                assistant_api_content = []
+                for part in content_parts_this_turn:
+                    api_part = TensorZeroConverter._convert_content_part(part)
+                    if api_part:
+                        assistant_api_content.append(api_part)
+                if raw_tool_call_blocks:
+                    assistant_api_content.extend(
+                        [self.block_to_dict(b) for b in raw_tool_call_blocks]
+                    )
+
+                if assistant_api_content:
+                    assistant_api_message_dict = {
+                        "role": "assistant",
+                        "content": assistant_api_content,
+                    }
+                    current_api_messages.append(assistant_api_message_dict)
+                elif executed_results_this_iter:
+                    self.logger.debug(
+                        "Assistant turn contained only tool calls, no API message added."
+                    )
+
+                final_assistant_message = content_parts_this_turn
+
+                # [8] If there were no tool calls we're done. If not, format the tool results and add them to the current list of API messages
+                if not executed_results_this_iter:
+                    self.logger.debug(f"Iteration {i + 1}: No tool calls detected. Finishing loop.")
+                    break
+                else:
+                    user_message_with_results = (
+                        TensorZeroConverter.convert_tool_results_to_t0_user_message(
+                            executed_results_this_iter
+                        )
+                    )
+                    if user_message_with_results:
+                        current_api_messages.append(user_message_with_results)
+                    else:
+                        self.logger.error("Converter failed to format tool results, breaking loop.")
+                        break
+
+                # Check max iterations: TODO: implement logic in the future to handle this dynamically, checking for the presence of a tool call in the last iteration
+                if i == merged_params.max_iterations - 1:
+                    self.logger.warning(f"Max iterations ({merged_params.max_iterations}) reached.")
+                    break
+
+            # --- Error Handling for Inference Call ---
+            except TensorZeroError as e:
+                error_details = getattr(e, "detail", str(e.args[0] if e.args else e))
+                self.logger.error(f"TensorZero Error (HTTP {e.status_code}): {error_details}")
+                error_content = TextContent(type="text", text=f"TensorZero Error: {error_details}")
+                return PromptMessageMultipart(role="assistant", content=[error_content])
+            except Exception as e:
+                import traceback
+
+                self.logger.error(f"Unexpected Error: {e}\n{traceback.format_exc()}")
+                error_content = TextContent(type="text", text=f"Unexpected error: {e}")
+                return PromptMessageMultipart(role="assistant", content=[error_content])
+
+        # [9] Construct the final assistant message and update history
+        final_message_to_return = PromptMessageMultipart(
+            role="assistant", content=final_assistant_message
+        )
+
+        if merged_params.use_history:
+            try:
+                # Store the final list of API DICTIONARIES in history
+                self.history.set(current_api_messages)
+                self.logger.debug(
+                    f"Updated self.history with {len(current_api_messages)} API message dicts."
+                )
+            except Exception as e:
+                self.logger.error(f"Failed to update self.history after loop: {e}")
+
+        # [10] Post final assistant message to display
+        display_text = final_message_to_return.all_text()
+        if display_text and display_text != "<no text>":
+            title = f"ASSISTANT/{self._t0_function_name}"
+            await self.show_assistant_message(message_text=display_text, title=title)
+
+        elif not final_assistant_message and last_executed_results:
+            self.logger.debug("Final assistant turn involved only tool calls, no text to display.")
+
+        return final_message_to_return
+
+    def _prepare_t0_system_params(self, merged_params: RequestParams) -> Dict[str, Any]:
+        """Prepares the 'system' dictionary part of the main input."""
+        t0_func_input = merged_params.template_vars.copy()
+
+        metadata_args = None
+        if merged_params.metadata and isinstance(merged_params.metadata, dict):
+            metadata_args = merged_params.metadata.get("tensorzero_arguments")
+        if isinstance(metadata_args, dict):
+            t0_func_input.update(metadata_args)
+            self.logger.debug(f"Merged tensorzero_arguments from metadata: {metadata_args}")
+        return t0_func_input
+
+    async def _prepare_t0_tools(self) -> Optional[List[Dict[str, Any]]]:
+        """Fetches and formats tools for the additional_tools parameter."""
+        formatted_tools: List[Dict[str, Any]] = []
+        try:
+            tools_response = await self.aggregator.list_tools()
+            if tools_response and hasattr(tools_response, "tools") and tools_response.tools:
+                for mcp_tool in tools_response.tools:
+                    if (
+                        not isinstance(mcp_tool.inputSchema, dict)
+                        or mcp_tool.inputSchema.get("type") != "object"
+                    ):
+                        self.logger.warning(
+                            f"Tool '{mcp_tool.name}' has invalid parameters schema. Skipping."
+                        )
+                        continue
+                    t0_tool_dict = {
+                        "name": mcp_tool.name,
+                        "description": mcp_tool.description if mcp_tool.description else "",
+                        "parameters": mcp_tool.inputSchema,
+                    }
+                    formatted_tools.append(t0_tool_dict)
+                return formatted_tools if formatted_tools else None
+        except Exception as e:
+            self.logger.error(f"Failed to fetch or format tools: {e}")
+        return None
+
+    async def _adapt_t0_native_completion(
+        self,
+        completion: Union[ChatInferenceResponse, JsonInferenceResponse],
+        available_tools_for_display: Optional[List[Dict[str, Any]]] = None,
+    ) -> Tuple[
+        List[Union[TextContent, ImageContent, EmbeddedResource]],  # Text/Image content ONLY
+        List[CallToolResult],  # Executed results
+        List[Any],  # Raw tool_call blocks
+    ]:
+        content_parts_this_turn: List[Union[TextContent, ImageContent, EmbeddedResource]] = []
+        executed_tool_results: List[CallToolResult] = []
+        raw_tool_call_blocks_from_t0: List[Any] = []
+
+        if isinstance(completion, ChatInferenceResponse) and hasattr(completion, "content"):
+            for block in completion.content:
+                block_type = getattr(block, "type", "UNKNOWN")
+
+                if block_type == "text":
+                    text_val = getattr(block, "text", None)
+                    if text_val is not None:
+                        content_parts_this_turn.append(TextContent(type="text", text=text_val))
+
+                elif block_type == "tool_call":
+                    raw_tool_call_blocks_from_t0.append(block)
+                    tool_use_id = getattr(block, "id", None)
+                    tool_name = getattr(block, "name", None)
+                    tool_input_raw = getattr(block, "arguments", None)
+                    tool_input = {}
+                    if isinstance(tool_input_raw, dict):
+                        tool_input = tool_input_raw
+                    elif isinstance(tool_input_raw, str):
+                        try:
+                            tool_input = json.loads(tool_input_raw)
+                        except json.JSONDecodeError:
+                            tool_input = {}
+                    elif tool_input_raw is not None:
+                        tool_input = {}
+
+                    if tool_use_id and tool_name:
+                        self.show_tool_call(
+                            available_tools_for_display, tool_name, json.dumps(tool_input)
+                        )
+                        mcp_tool_request = CallToolRequest(
+                            method="tools/call",
+                            params=CallToolRequestParams(name=tool_name, arguments=tool_input),
+                        )
+                        try:
+                            result: CallToolResult = await self.call_tool(
+                                mcp_tool_request, tool_use_id
+                            )
+                            setattr(result, "_t0_tool_use_id_temp", tool_use_id)
+                            setattr(result, "_t0_tool_name_temp", tool_name)
+                            setattr(result, "_t0_is_error_temp", False)
+                            executed_tool_results.append(result)
+                            self.show_oai_tool_result(str(result))
+                        except Exception as e:
+                            self.logger.error(
+                                f"Error executing tool {tool_name} (id: {tool_use_id}): {e}"
+                            )
+                            error_text = f"Error executing tool {tool_name}: {str(e)}"
+                            error_result = CallToolResult(
+                                isError=True, content=[TextContent(type="text", text=error_text)]
+                            )
+                            setattr(error_result, "_t0_tool_use_id_temp", tool_use_id)
+                            setattr(error_result, "_t0_tool_name_temp", tool_name)
+                            setattr(error_result, "_t0_is_error_temp", True)
+                            executed_tool_results.append(error_result)
+                            self.show_oai_tool_result(f"ERROR: {error_text}")
+
+                elif block_type == "thought":
+                    thought_text = getattr(block, "text", None)
+                    self.logger.debug(f"TensorZero thought: {thought_text}")
+                else:
+                    self.logger.warning(
+                        f"TensorZero Adapt: Skipping unknown block type: {block_type}"
+                    )
+
+        elif isinstance(completion, JsonInferenceResponse):
+            # `completion.output.raw` should always be present unless the LLM provider returns unexpected data
+            if completion.output.raw:
+                content_parts_this_turn.append(TextContent(type="text", text=completion.output.raw))
+
+        return content_parts_this_turn, executed_tool_results, raw_tool_call_blocks_from_t0
+
+    async def shutdown(self):
+        """Close the TensorZero gateway client if initialized."""
+        if self._t0_gateway:
+            try:
+                await self._t0_gateway.close()
+                self.logger.debug("TensorZero Gateway client closed.")
+            except Exception as e:
+                self.logger.error(f"Error closing TensorZero Gateway client: {e}")

mcp_agent/llm/providers/multipart_converter_tensorzero.py

@@ -0,0 +1,200 @@
+import json
+from typing import Any, Dict, List, Optional, Union
+
+from mcp.types import (
+    CallToolResult,
+    EmbeddedResource,
+    ImageContent,
+    TextContent,
+)
+
+from mcp_agent.logging.logger import get_logger
+from mcp_agent.mcp.helpers.content_helpers import (
+    get_text,
+)
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+
+_logger = get_logger(__name__)
+
+
+class TensorZeroConverter:
+    """Converts MCP message types to/from TensorZero API format."""
+
+    @staticmethod
+    def _convert_content_part(
+        part: Union[TextContent, ImageContent, EmbeddedResource],
+    ) -> Optional[Dict[str, Any]]:
+        """Converts a single MCP content part to a T0 content block dictionary."""
+        if isinstance(part, TextContent):
+            text = get_text(part)
+            if text is not None:
+                return {"type": "text", "text": text}
+        elif isinstance(part, ImageContent):
+            # Handle Base64: needs data, mimeType (and mimeType must not be empty)
+            if hasattr(part, "data") and part.data and hasattr(part, "mimeType") and part.mimeType:
+                _logger.debug(
+                    f"Converting ImageContent as base64 for T0 native: mime={part.mimeType}, data_len={len(part.data) if isinstance(part.data, str) else 'N/A'}"
+                )
+                supported_mime_types = ["image/jpeg", "image/png", "image/webp"]
+                mime_type = getattr(part, "mimeType", "")
+
+                # Use the provided mime_type if supported, otherwise default to png
+                if mime_type not in supported_mime_types:
+                    _logger.warning(
+                        f"Unsupported mimeType '{mime_type}' for T0 base64 image, defaulting to image/png."
+                    )
+                    mime_type = "image/png"
+
+                return {
+                    "type": "image",
+                    "mime_type": mime_type,  # Note: T0 uses mime_type, not media_type
+                    "data": getattr(part, "data", ""),  # Data is direct property
+                }
+            else:
+                # Log cases where it's an ImageContent but doesn't fit Base64 criteria
+                _logger.warning(
+                    f"Skipping ImageContent: Missing required base64 fields (mimeType/data), or mimeType is empty: {part}"
+                )
+
+        elif isinstance(part, EmbeddedResource):
+            _logger.warning(f"Skipping EmbeddedResource, T0 conversion not implemented: {part}")
+        else:
+            _logger.error(
+                f"Unsupported content part type for T0 conversion: {type(part)}"
+            )  # Changed to error
+
+        return None  # Return None if no block was successfully created
+
+    @staticmethod
+    def _get_text_from_call_tool_result(result: CallToolResult) -> str:
+        """Helper to extract combined text from a CallToolResult's content list."""
+        texts = []
+        if result.content:
+            for part in result.content:
+                text = get_text(part)
+                if text:
+                    texts.append(text)
+        return "\n".join(texts)
+
+    @staticmethod
+    def convert_tool_results_to_t0_user_message(
+        results: List[CallToolResult],
+    ) -> Optional[Dict[str, Any]]:
+        """Formats CallToolResult list into T0's tool_result blocks within a user message dict."""
+        t0_tool_result_blocks = []
+        for result in results:
+            tool_use_id = getattr(result, "_t0_tool_use_id_temp", None)
+            tool_name = getattr(result, "_t0_tool_name_temp", None)
+
+            if tool_use_id and tool_name:
+                result_content_str = TensorZeroConverter._get_text_from_call_tool_result(result)
+                try:
+                    # Attempt to treat result as JSON if possible, else use raw string
+                    try:
+                        json_result = json.loads(result_content_str)
+                    except json.JSONDecodeError:
+                        json_result = result_content_str  # Fallback to string if not valid JSON
+                except Exception as e:
+                    _logger.error(f"Unexpected error processing tool result content: {e}")
+                    json_result = str(result_content_str)  # Safest fallback
+
+                t0_block = {
+                    "type": "tool_result",
+                    "id": tool_use_id,
+                    "name": tool_name,
+                    "result": json_result,  # T0 expects the result directly
+                }
+                t0_tool_result_blocks.append(t0_block)
+
+                # Clean up temporary attributes
+                try:
+                    delattr(result, "_t0_tool_use_id_temp")
+                    delattr(result, "_t0_tool_name_temp")
+                    if hasattr(result, "_t0_is_error_temp"):
+                        delattr(result, "_t0_is_error_temp")
+                except AttributeError:
+                    pass
+            else:
+                _logger.warning(
+                    f"Could not find id/name temp attributes for CallToolResult: {result}"
+                )
+
+        if not t0_tool_result_blocks:
+            return None
+
+        return {"role": "user", "content": t0_tool_result_blocks}
+
+    @staticmethod
+    def convert_mcp_to_t0_message(msg: PromptMessageMultipart) -> Optional[Dict[str, Any]]:
+        """
+        Converts a single PromptMessageMultipart to a T0 API message dictionary.
+        Handles Text, Image, and embedded CallToolResult content.
+        Skips system messages.
+        """
+        if msg.role == "system":
+            return None
+
+        t0_content_blocks = []
+        contains_tool_result = False
+
+        for part in msg.content:
+            # Use the corrected _convert_content_part
+            converted_block = TensorZeroConverter._convert_content_part(part)
+            if converted_block:
+                t0_content_blocks.append(converted_block)
+            elif isinstance(part, CallToolResult):
+                # Existing logic for handling embedded CallToolResult (seems compatible with T0 tool_result spec)
+                contains_tool_result = True
+                tool_use_id = getattr(part, "_t0_tool_use_id_temp", None)
+                tool_name = getattr(part, "_t0_tool_name_temp", None)
+                if tool_use_id and tool_name:
+                    result_content_str = TensorZeroConverter._get_text_from_call_tool_result(part)
+                    # Try to format result as JSON object/string
+                    try:
+                        json_result = json.loads(result_content_str)
+                    except json.JSONDecodeError:
+                        json_result = result_content_str  # Fallback
+                    except Exception as e:
+                        _logger.error(f"Error processing embedded tool result: {e}")
+                        json_result = str(result_content_str)
+
+                    t0_content_blocks.append(
+                        {
+                            "type": "tool_result",
+                            "id": tool_use_id,
+                            "name": tool_name,
+                            "result": json_result,
+                        }
+                    )
+                    # Clean up temp attributes
+                    try:
+                        delattr(part, "_t0_tool_use_id_temp")
+                        delattr(part, "_t0_tool_name_temp")
+                    except AttributeError:
+                        pass
+                else:
+                    _logger.warning(
+                        f"Found embedded CallToolResult without required temp attributes: {part}"
+                    )
+            # Note: The _convert_content_part handles logging for other skipped/unsupported types
+
+        if not t0_content_blocks:
+            return None
+
+        # Determine role - logic remains the same
+        valid_role = msg.role if msg.role in ["user", "assistant"] else "user"
+        if contains_tool_result and all(
+            block.get("type") == "tool_result" for block in t0_content_blocks
+        ):
+            final_role = "user"
+            if valid_role != final_role:
+                _logger.debug(f"Overriding role to '{final_role}' for tool result message.")
+        else:
+            final_role = valid_role
+            if valid_role != msg.role:
+                _logger.warning(f"Mapping message role '{msg.role}' to '{valid_role}' for T0.")
+
+        return {"role": final_role, "content": t0_content_blocks}
+
+    # Add methods here if needed to convert *from* T0 format back to MCP types
+    # e.g., adapt_t0_response_to_mcp(...) - this logic stays in the LLM class for now

mcp_agent/mcp/mcp_connection_manager.py

@@ -15,6 +15,7 @@ from typing import (
 
 from anyio import Event, Lock, create_task_group
 from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
+from httpx import HTTPStatusError
 from mcp import ClientSession
 from mcp.client.sse import sse_client
 from mcp.client.stdio import (
@@ -162,14 +163,26 @@ async def _server_lifecycle_task(server_conn: ServerConnection) -> None:
         transport_context = server_conn._transport_context_factory()
 
         async with transport_context as (read_stream, write_stream):
-            #      try:
             server_conn.create_session(read_stream, write_stream)
 
             async with server_conn.session:
                 await server_conn.initialize_session()
-
                 await server_conn.wait_for_shutdown_request()
 
+    except HTTPStatusError as http_exc:
+        logger.error(
+            f"{server_name}: Lifecycle task encountered HTTP error: {http_exc}",
+            exc_info=True,
+            data={
+                "progress_action": ProgressAction.FATAL_ERROR,
+                "server_name": server_name,
+            },
+        )
+        server_conn._error_occurred = True
+        server_conn._error_message = f"HTTP Error: {http_exc.response.status_code} {http_exc.response.reason_phrase} for URL: {http_exc.request.url}"
+        server_conn._initialized_event.set()
+        # No raise - let get_server handle it with a friendly message
+
     except Exception as exc:
         logger.error(
             f"{server_name}: Lifecycle task encountered an error: {exc}",
@@ -180,7 +193,27 @@ async def _server_lifecycle_task(server_conn: ServerConnection) -> None:
             },
         )
         server_conn._error_occurred = True
-        server_conn._error_message = traceback.format_exception(exc)
+
+        if "ExceptionGroup" in type(exc).__name__ and hasattr(exc, "exceptions"):
+            # Handle ExceptionGroup better by extracting the actual errors
+            error_messages = []
+            for subexc in exc.exceptions:
+                if isinstance(subexc, HTTPStatusError):
+                    # Special handling for HTTP errors to make them more user-friendly
+                    error_messages.append(
+                        f"HTTP Error: {subexc.response.status_code} {subexc.response.reason_phrase} for URL: {subexc.request.url}"
+                    )
+                else:
+                    error_messages.append(f"Error: {type(subexc).__name__}: {subexc}")
+                if hasattr(subexc, "__cause__") and subexc.__cause__:
+                    error_messages.append(
+                        f"Caused by: {type(subexc.__cause__).__name__}: {subexc.__cause__}"
+                    )
+            server_conn._error_message = error_messages
+        else:
+            # For regular exceptions, keep the traceback but format it more cleanly
+            server_conn._error_message = traceback.format_exception(exc)
+
         # If there's an error, we should also set the event so that
         # 'get_server' won't hang
         server_conn._initialized_event.set()
@@ -277,6 +310,7 @@ class MCPConnectionManager(ContextDependent):
                     config.headers,
                     sse_read_timeout=config.read_transport_sse_timeout_seconds,
                 )
+
             else:
                 raise ValueError(f"Unsupported transport: {config.transport}")
 
@@ -333,9 +367,17 @@ class MCPConnectionManager(ContextDependent):
         # Check if the server is healthy after initialization
         if not server_conn.is_healthy():
             error_msg = server_conn._error_message or "Unknown error"
+
+            # Format the error message for better display
+            if isinstance(error_msg, list):
+                # Join the list with newlines for better readability
+                formatted_error = "\n".join(error_msg)
+            else:
+                formatted_error = str(error_msg)
+
             raise ServerInitializationError(
                 f"MCP Server: '{server_name}': Failed to initialize - see details. Check fastagent.config.yaml?",
-                error_msg,
+                formatted_error,
             )
 
         return server_conn