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

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

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.2.22
+Version: 0.2.24
 Summary: Define, Prompt and Test MCP enabled Agents and Workflows
-Author-email: Shaun Smith <fastagent@llmindset.co.uk>, Sarmad Qadri <sarmad@lastmileai.dev>
+Author-email: Shaun Smith <fastagent@llmindset.co.uk>
 License:                                  Apache License
                                    Version 2.0, January 2004
                                 http://www.apache.org/licenses/
@@ -218,6 +218,7 @@ Requires-Dist: openai>=1.63.2
 Requires-Dist: opentelemetry-distro>=0.50b0
 Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.29.0
 Requires-Dist: opentelemetry-instrumentation-anthropic>=0.39.3
+Requires-Dist: opentelemetry-instrumentation-mcp>=0.40.3
 Requires-Dist: opentelemetry-instrumentation-openai>=0.39.3
 Requires-Dist: prompt-toolkit>=3.0.50
 Requires-Dist: pydantic-settings>=2.7.0

{fast_agent_mcp-0.2.22.dist-info → fast_agent_mcp-0.2.24.dist-info}/RECORD

@@ -1,11 +1,11 @@
 mcp_agent/__init__.py,sha256=18T0AG0W9sJhTY38O9GFFOzliDhxx9p87CvRyti9zbw,1620
 mcp_agent/app.py,sha256=WRsiUdwy_9IAnaGRDwuLm7pzgQpt2wgsg10vBOpfcwM,5539
-mcp_agent/config.py,sha256=ZC4SiIVbxVn7-hUfv3RFj6fNrXxvci6gmUNCGM7vzs8,12624
+mcp_agent/config.py,sha256=L_wUWTdqFXaRTBA5tL_j2l_9dufWE_MHHPut5e89lBk,12773
 mcp_agent/console.py,sha256=Gjf2QLFumwG1Lav__c07X_kZxxEUSkzV-1_-YbAwcwo,813
-mcp_agent/context.py,sha256=Kb3s_0MolHx7AeTs1NVcY3ly-xFBd35o8LT7Srpx9is,7334
+mcp_agent/context.py,sha256=5pnw78LgezCLeO5Os5dgmLDadwXqw_B4Ojib48XP1s4,7431
 mcp_agent/context_dependent.py,sha256=QXfhw3RaQCKfscEEBRGuZ3sdMWqkgShz2jJ1ivGGX1I,1455
 mcp_agent/event_progress.py,sha256=b1VKlQQF2AgPMb6XHjlJAVoPdx8GuxRTUk2g-4lBNm0,2749
-mcp_agent/mcp_server_registry.py,sha256=jUmCdfcpTitXm1-3TxpWsdRWY_8phdKNYgXwB16ZSVU,10100
+mcp_agent/mcp_server_registry.py,sha256=QTzu0elBWzqXks6u5nI5n8uN5CX8CpyV6ybxnyt5LZM,11531
 mcp_agent/progress_display.py,sha256=GeJU9VUt6qKsFVymG688hCMVCsAygG9ifiiEb5IcbN4,361
 mcp_agent/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_agent/agents/agent.py,sha256=GgaUHoilgqzh9PQYr5k2WiPj4pagwicf9-ZLFsHkNNo,3848
@@ -13,7 +13,7 @@ mcp_agent/agents/base_agent.py,sha256=fjDr01-hZ9sB3ghI4DlXYVePP0s5f9pmtLH-N3X8bR
 mcp_agent/agents/workflow/__init__.py,sha256=HloteEW6kalvgR0XewpiFAqaQlMPlPJYg5p3K33IUzI,25
 mcp_agent/agents/workflow/chain_agent.py,sha256=eIlImirrSXkqBJmPuAJgOKis81Cl6lZEGM0-6IyaUV8,6105
 mcp_agent/agents/workflow/evaluator_optimizer.py,sha256=ysUMGM2NzeCIutgr_vXH6kUPpZMw0cX4J_Wl1r8eT84,13296
-mcp_agent/agents/workflow/orchestrator_agent.py,sha256=byZe4bx7D_7BSZZ3hN8BNUWVFPYeqeUwDUCLTRC8mlI,21583
+mcp_agent/agents/workflow/orchestrator_agent.py,sha256=lArV7wHwPYepSuxe0ybTGJRJv85iebRI4ZOY_m8kMZQ,21593
 mcp_agent/agents/workflow/orchestrator_models.py,sha256=5P_aXADVT4Et8qT4e1cb9RelmHX5dCRrzu8j8T41Kdg,7230
 mcp_agent/agents/workflow/orchestrator_prompts.py,sha256=EXKEI174sshkZyPPEnWbwwNafzSPuA39MXL7iqG9cWc,9106
 mcp_agent/agents/workflow/parallel_agent.py,sha256=JaQFp35nmAdoBRLAwx8BfnK7kirVq9PMw24LQ3ZEzoc,7705
@@ -23,9 +23,10 @@ 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=2UY8TSDwhh_-p-WYXrZz3pEv3-2eTdBl5Lxy3JyJV0E,6057
+mcp_agent/cli/commands/go.py,sha256=LIsOJQuTdfCUcNm7JT-NQDU8cI-GCnYwYjN2VOWxvqs,8658
 mcp_agent/cli/commands/quickstart.py,sha256=SM3CHMzDgvTxIpKjFuX9BrS_N1vRoXNBDaO90aWx1Rk,14586
 mcp_agent/cli/commands/setup.py,sha256=eOEd4TL-b0DaDeSJMGOfNOsTEItoZ67W88eTP4aP-bo,6482
+mcp_agent/cli/commands/url_parser.py,sha256=7QL9bp9tO7w0cPnwhbpt8GwjbOJ1Rrry1o71uVJhSss,5655
 mcp_agent/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_agent/core/agent_app.py,sha256=5nQJNo8DocIRWiX4pVKAHUZF8s6HWpc-hJnfzl_1v1c,9697
 mcp_agent/core/agent_types.py,sha256=bQVQMTwKH7qHIJsNglj4C_d6PNFBBzC_0RIkcENSII4,1459
@@ -34,11 +35,11 @@ mcp_agent/core/direct_factory.py,sha256=d96OM1yS3eIocIiaA9FQt6C2zr6VDUyCJBTZCp_D
 mcp_agent/core/enhanced_prompt.py,sha256=bzvcengS7XzHWB7NWhyxHM3hhO2HI4zP5DbGXAOw0Jw,19155
 mcp_agent/core/error_handling.py,sha256=xoyS2kLe0eG0bj2eSJCJ2odIhGUve2SbDR7jP-A-uRw,624
 mcp_agent/core/exceptions.py,sha256=ENAD_qGG67foxy6vDkIvc-lgopIUQy6O7zvNPpPXaQg,2289
-mcp_agent/core/fastagent.py,sha256=WEEGz2WBAddDGNeWJwqwFIPLiQnLjaNxZLoMR0peyyU,22884
+mcp_agent/core/fastagent.py,sha256=uS_NSXeniUYFu6xce8OHGJ9PbEYNU-gm1XVpa1r0rZc,22893
 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=vRfAz9T6Ir-0oeJ4qEdO62LDOzoLwBuuXcBcdh6WPZ8,1576
+mcp_agent/core/request_params.py,sha256=qmFWZXeYEJyYw2IwonyrTnZWxQG7qX6bKpOPcqETa60,1603
 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
@@ -64,7 +65,7 @@ mcp_agent/llm/providers/augmented_llm_anthropic.py,sha256=gK_IvllVBNJUUrSfpgFpdh
 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=0C7BOB7i3xo0HsMCTagRSQ8Hsywb-31mot26OfohzCU,14478
+mcp_agent/llm/providers/augmented_llm_openai.py,sha256=jbLG9t0iuneRPX0Cscim6K48SJEB5vPopDE3IBmJ708,14515
 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
@@ -85,9 +86,9 @@ mcp_agent/mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_agent/mcp/gen_client.py,sha256=fAVwFVCgSamw4PwoWOV4wrK9TABx1S_zZv8BctRyF2k,3030
 mcp_agent/mcp/interfaces.py,sha256=PAou8znAl2HgtvfCpLQOZFbKra9F72OcVRfBJbboNX8,6965
 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=6jtjclh4YNJZsNwYnSWmQ6cPzapAwsRUxir1c_gVNfM,16051
+mcp_agent/mcp/mcp_agent_client_session.py,sha256=4597ww1ihSKh-zKc9xMF3ODqosVPU_A4xVmUbk1DvcE,6002
+mcp_agent/mcp/mcp_aggregator.py,sha256=_zqSuWGwRTLleXldQjqPSNqV0RRRr1luJIZOvB2AdRg,46011
+mcp_agent/mcp/mcp_connection_manager.py,sha256=jlqaAdS4zc1UfVBHQU0TkTbVr0-rOkbN9bkrLPrZVLk,17159
 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
@@ -101,10 +102,10 @@ mcp_agent/mcp/prompts/__main__.py,sha256=gr1Tdz9fcK0EXjEuZg_BOnKUmvhYq5AH2lFZicV
 mcp_agent/mcp/prompts/prompt_constants.py,sha256=Q9W0t3rOXl2LHIG9wcghApUV2QZ1iICuo7SwVwHUf3c,566
 mcp_agent/mcp/prompts/prompt_helpers.py,sha256=Joqo2t09pTKDP-Wge3G-ozPEHikzjaqwV6GVk8hNR50,7534
 mcp_agent/mcp/prompts/prompt_load.py,sha256=Zo0FogqWFEG5FtF1d9ZH-RWsCSSMsi5FIEQHpJD8N7M,5404
-mcp_agent/mcp/prompts/prompt_server.py,sha256=DbuDcYCMbsbqwBeebpNGInAQ4-DP1Jjp49y8uZ-0XlY,18872
+mcp_agent/mcp/prompts/prompt_server.py,sha256=VAKS4rHTE5Mp7e0NV6qADslR_5vSLab8RUhNxCkAdJE,19234
 mcp_agent/mcp/prompts/prompt_template.py,sha256=EejiqGkau8OizORNyKTUwUjrPof5V-hH1H_MBQoQfXw,15732
 mcp_agent/mcp_server/__init__.py,sha256=zBU51ITHIEPScd9nRafnhEddsWqXRPAAvHhkrbRI2_4,155
-mcp_agent/mcp_server/agent_server.py,sha256=s-nI0uTNWx4nYDDM_5GmuY5x6ZeFkymfNoCSuwuBRd8,19891
+mcp_agent/mcp_server/agent_server.py,sha256=df3UbPLg52e_SS98F3lc4T8BqqzvQRBl6kplODsaq-M,20096
 mcp_agent/resources/examples/data-analysis/analysis-campaign.py,sha256=16gxrQ5kM8fb8tPwSCMXaitonk3PSEhz28njWwPxXrw,7269
 mcp_agent/resources/examples/data-analysis/analysis.py,sha256=M9z8Q4YC5OGuqSa5uefYmmfmctqMn-WqCSfg5LI407o,2609
 mcp_agent/resources/examples/data-analysis/fastagent.config.yaml,sha256=ini94PHyJCfgpjcjHKMMbGuHs6LIj46F1NwY0ll5HVk,1609
@@ -123,7 +124,7 @@ mcp_agent/resources/examples/internal/sizer.py,sha256=xP1TBJkp4xIdtJnyk2MP4BufTh
 mcp_agent/resources/examples/internal/social.py,sha256=pTKcpHAcvA-vQYgjVfDuU1FivCR004Nq4N2GXd5OMs0,1716
 mcp_agent/resources/examples/mcp/state-transfer/agent_one.py,sha256=HR-Igr8k68HU0tqIpaXujtJxnKSUwwtZqTdZk8QHNgo,455
 mcp_agent/resources/examples/mcp/state-transfer/agent_two.py,sha256=TY9SPzJZFv3TL6VEP3IpdJvTjYup5txF_DjpvEzlmbw,476
-mcp_agent/resources/examples/mcp/state-transfer/fastagent.config.yaml,sha256=-IIocaehANnWiwFHSNNzDRdV80ApicNmxAY4flKETpk,797
+mcp_agent/resources/examples/mcp/state-transfer/fastagent.config.yaml,sha256=e3Esqw850p9GcapVVhPhAAHWwtt2gH2ivsVIULD9n6Q,798
 mcp_agent/resources/examples/mcp/state-transfer/fastagent.secrets.yaml.example,sha256=0n3F2S_Z2CeLHZueZqCGy37mxiMDHLplvxUHYiCpD2A,421
 mcp_agent/resources/examples/prompting/__init__.py,sha256=2GSrs9MSDIKo-uDrUI0O311F0UH0RW02ZNdvItJzjfI,50
 mcp_agent/resources/examples/prompting/agent.py,sha256=HxzUsidfxoc7Th0Ws55ppQCHNLkdZvcbiAcc2fMd4KI,490
@@ -144,9 +145,9 @@ mcp_agent/resources/examples/workflows/orchestrator.py,sha256=rOGilFTliWWnZ3Jx5w
 mcp_agent/resources/examples/workflows/parallel.py,sha256=DQ5vY5-h8Qa5QHcYjsWXhZ_FYrYoloVWOdgeXV9p2gI,1890
 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.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/ui/console_display.py,sha256=EUeMJ7yqtxJ0-hAjXNZFJFTlmfyKlENdfzTlw0e5ETg,9949
+fast_agent_mcp-0.2.24.dist-info/METADATA,sha256=BxBQ5fsAWpeZ2UhH_zChQb816cZp6_ipY05ea60lKJA,30213
+fast_agent_mcp-0.2.24.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fast_agent_mcp-0.2.24.dist-info/entry_points.txt,sha256=bRniFM5zk3Kix5z7scX0gf9VnmGQ2Cz_Q1Gh7Ir4W00,186
+fast_agent_mcp-0.2.24.dist-info/licenses/LICENSE,sha256=cN3FxDURL9XuzE5mhK9L2paZo82LTfjwCYVT7e3j0e4,10939
+fast_agent_mcp-0.2.24.dist-info/RECORD,,

mcp_agent/agents/workflow/orchestrator_agent.py

@@ -229,7 +229,7 @@ class OrchestratorAgent(BaseAgent):
                     self.logger.warning(
                         f"Reached maximum step limit ({max_steps}) without completing objective"
                     )
-                    plan_result.max_steps_reached = True
+                    plan_result.max_iterations_reached = True
                     break
 
                 # Execute the step and collect results
@@ -239,7 +239,7 @@ class OrchestratorAgent(BaseAgent):
                 total_steps_executed += 1
 
             # Check if we need to break due to hitting max steps
-            if getattr(plan_result, "max_steps_reached", False):
+            if getattr(plan_result, "max_iterations_reached", False):
                 break
 
             # If the plan is marked complete, finalize the result

mcp_agent/cli/commands/go.py

@@ -2,16 +2,18 @@
 
 import asyncio
 import sys
-from typing import List, Optional
+from typing import Dict, List, Optional
 
 import typer
 
+from mcp_agent.cli.commands.url_parser import generate_server_configs, parse_server_urls
 from mcp_agent.core.fastagent import FastAgent
 
 app = typer.Typer(
     help="Run an interactive agent directly from the command line without creating an agent.py file"
 )
 
+
 async def _run_agent(
     name: str = "FastAgent CLI",
     instruction: str = "You are a helpful AI Agent.",
@@ -19,33 +21,61 @@ async def _run_agent(
     server_list: Optional[List[str]] = None,
     model: Optional[str] = None,
     message: Optional[str] = None,
-    prompt_file: Optional[str] = None
+    prompt_file: Optional[str] = None,
+    url_servers: Optional[Dict[str, Dict[str, str]]] = None,
 ) -> None:
     """Async implementation to run an interactive agent."""
     from pathlib import Path
 
+    from mcp_agent.config import MCPServerSettings, MCPSettings
     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.
+    # Create the FastAgent instance
     fast_kwargs = {
         "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)
 
+    # Add URL-based servers to the context configuration
+    if url_servers:
+        # Initialize the app to ensure context is ready
+        await fast.app.initialize()
+
+        # Initialize mcp settings if needed
+        if not hasattr(fast.app.context.config, "mcp"):
+            fast.app.context.config.mcp = MCPSettings()
+
+        # Initialize servers dictionary if needed
+        if (
+            not hasattr(fast.app.context.config.mcp, "servers")
+            or fast.app.context.config.mcp.servers is None
+        ):
+            fast.app.context.config.mcp.servers = {}
+
+        # Add each URL server to the config
+        for server_name, server_config in url_servers.items():
+            server_settings = {"transport": server_config["transport"], "url": server_config["url"]}
+
+            # Add headers if present in the server config
+            if "headers" in server_config:
+                server_settings["headers"] = server_config["headers"]
+
+            fast.app.context.config.mcp.servers[server_name] = MCPServerSettings(**server_settings)
+
     # Define the agent with specified parameters
     agent_kwargs = {"instruction": instruction}
     if server_list:
         agent_kwargs["servers"] = server_list
     if model:
         agent_kwargs["model"] = model
-    
+
     # 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:
@@ -55,7 +85,7 @@ async def _run_agent(
                     print(response)
                 elif prompt_file:
                     prompt = load_prompt_multipart(Path(prompt_file))
-                    response = await agent.generate(prompt)
+                    response = await agent.default.generate(prompt)
                     # Print the response text and exit
                     print(response.last_text())
     else:
@@ -68,18 +98,37 @@ async def _run_agent(
     # Run the agent
     await cli_agent()
 
+
 def run_async_agent(
-    name: str, 
-    instruction: str, 
-    config_path: Optional[str] = None, 
+    name: str,
+    instruction: str,
+    config_path: Optional[str] = None,
     servers: Optional[str] = None,
+    urls: Optional[str] = None,
+    auth: Optional[str] = None,
     model: Optional[str] = None,
     message: Optional[str] = None,
-    prompt_file: 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
-    
+    server_list = servers.split(",") if servers else None
+
+    # Parse URLs and generate server configurations if provided
+    url_servers = None
+    if urls:
+        try:
+            parsed_urls = parse_server_urls(urls, auth)
+            url_servers = generate_server_configs(parsed_urls)
+            # If we have servers from URLs, add their names to the server_list
+            if url_servers and not server_list:
+                server_list = list(url_servers.keys())
+            elif url_servers and server_list:
+                # Merge both lists
+                server_list.extend(list(url_servers.keys()))
+        except ValueError as e:
+            print(f"Error parsing URLs: {e}")
+            return
+
     # Check if we're already in an event loop
     try:
         loop = asyncio.get_event_loop()
@@ -92,24 +141,27 @@ def run_async_agent(
         # No event loop exists, so we'll create one
         loop = asyncio.new_event_loop()
         asyncio.set_event_loop(loop)
-    
+
     try:
-        loop.run_until_complete(_run_agent(
-            name=name, 
-            instruction=instruction, 
-            config_path=config_path, 
-            server_list=server_list,
-            model=model,
-            message=message,
-            prompt_file=prompt_file
-        ))
+        loop.run_until_complete(
+            _run_agent(
+                name=name,
+                instruction=instruction,
+                config_path=config_path,
+                server_list=server_list,
+                model=model,
+                message=message,
+                prompt_file=prompt_file,
+                url_servers=url_servers,
+            )
+        )
     finally:
         try:
             # Clean up the loop
             tasks = asyncio.all_tasks(loop)
             for task in tasks:
                 task.cancel()
-            
+
             # Run the event loop until all tasks are done
             if sys.version_info >= (3, 7):
                 loop.run_until_complete(asyncio.gather(*tasks, return_exceptions=True))
@@ -118,6 +170,7 @@ def run_async_agent(
         except Exception:
             pass
 
+
 @app.callback(invoke_without_command=True)
 def go(
     ctx: typer.Context,
@@ -131,6 +184,12 @@ def go(
     servers: Optional[str] = typer.Option(
         None, "--servers", help="Comma-separated list of server names to enable from config"
     ),
+    urls: Optional[str] = typer.Option(
+        None, "--url", help="Comma-separated list of HTTP/SSE URLs to connect to"
+    ),
+    auth: Optional[str] = typer.Option(
+        None, "--auth", help="Bearer token for authorization with URL-based servers"
+    ),
     model: Optional[str] = typer.Option(
         None, "--model", help="Override the default model (e.g., haiku, sonnet, gpt-4)"
     ),
@@ -148,6 +207,8 @@ def go(
         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
+        fast-agent go --url=http://localhost:8001/mcp,http://api.example.com/sse
+        fast-agent go --url=https://api.example.com/mcp --auth=YOUR_API_TOKEN
 
     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
@@ -157,15 +218,19 @@ def go(
         --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
+        --url                 Comma-separated list of HTTP/SSE URLs to connect to
+        --auth                Bearer token for authorization with URL-based servers
         --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, 
+        name=name,
+        instruction=instruction,
+        config_path=config_path,
         servers=servers,
+        urls=urls,
+        auth=auth,
         model=model,
         message=message,
-        prompt_file=prompt_file
-    )
+        prompt_file=prompt_file,
+    )

mcp_agent/cli/commands/url_parser.py

@@ -0,0 +1,185 @@
+"""
+URL parsing utility for the fast-agent CLI.
+Provides functions to parse URLs and determine MCP server configurations.
+"""
+
+import hashlib
+import re
+from typing import Dict, List, Literal, Tuple
+from urllib.parse import urlparse
+
+
+def parse_server_url(
+    url: str,
+) -> Tuple[str, Literal["http", "sse"], str]:
+    """
+    Parse a server URL and determine the transport type and server name.
+
+    Args:
+        url: The URL to parse
+
+    Returns:
+        Tuple containing:
+        - server_name: A generated name for the server
+        - transport_type: Either "http" or "sse" based on URL
+        - url: The parsed and validated URL
+
+    Raises:
+        ValueError: If the URL is invalid or unsupported
+    """
+    # Basic URL validation
+    if not url:
+        raise ValueError("URL cannot be empty")
+
+    # Parse the URL
+    parsed_url = urlparse(url)
+
+    # Ensure scheme is present and is either http or https
+    if not parsed_url.scheme or parsed_url.scheme not in ("http", "https"):
+        raise ValueError(f"URL must have http or https scheme: {url}")
+
+    # Ensure netloc (hostname) is present
+    if not parsed_url.netloc:
+        raise ValueError(f"URL must include a hostname: {url}")
+
+    # Determine transport type based on URL path
+    transport_type: Literal["http", "sse"] = "http"
+    if parsed_url.path.endswith("/sse"):
+        transport_type = "sse"
+    elif not parsed_url.path.endswith("/mcp"):
+        # If path doesn't end with /mcp or /sse, append /mcp
+        url = url if url.endswith("/") else f"{url}/"
+        url = f"{url}mcp"
+
+    # Generate a server name based on hostname and port
+    server_name = generate_server_name(url)
+
+    return server_name, transport_type, url
+
+
+def generate_server_name(url: str) -> str:
+    """
+    Generate a unique and readable server name from a URL.
+
+    Args:
+        url: The URL to generate a name for
+
+    Returns:
+        A server name string
+    """
+    parsed_url = urlparse(url)
+
+    # Extract hostname and port
+    hostname = parsed_url.netloc.split(":")[0]
+
+    # Clean the hostname for use in a server name
+    # Replace non-alphanumeric characters with underscores
+    clean_hostname = re.sub(r"[^a-zA-Z0-9]", "_", hostname)
+
+    if len(clean_hostname) > 15:
+        clean_hostname = clean_hostname[:9] + clean_hostname[-5:]
+
+    # If it's localhost or an IP, add a more unique identifier
+    if clean_hostname in ("localhost", "127_0_0_1") or re.match(r"^(\d+_){3}\d+$", clean_hostname):
+        # Use the path as part of the name for uniqueness
+        path = parsed_url.path.strip("/")
+        path = re.sub(r"[^a-zA-Z0-9]", "_", path)
+
+        # Include port if specified
+        port = ""
+        if ":" in parsed_url.netloc:
+            port = f"_{parsed_url.netloc.split(':')[1]}"
+
+        if path:
+            return f"{clean_hostname}{port}_{path[:20]}"  # Limit path length
+        else:
+            # Use a hash if no path for uniqueness
+            url_hash = hashlib.md5(url.encode()).hexdigest()[:8]
+            return f"{clean_hostname}{port}_{url_hash}"
+
+    return clean_hostname
+
+
+def parse_server_urls(
+    urls_param: str, auth_token: str = None
+) -> List[Tuple[str, Literal["http", "sse"], str, Dict[str, str] | None]]:
+    """
+    Parse a comma-separated list of URLs into server configurations.
+
+    Args:
+        urls_param: Comma-separated list of URLs
+        auth_token: Optional bearer token for authorization
+
+    Returns:
+        List of tuples containing (server_name, transport_type, url, headers)
+
+    Raises:
+        ValueError: If any URL is invalid
+    """
+    if not urls_param:
+        return []
+
+    # Split by comma and strip whitespace
+    url_list = [url.strip() for url in urls_param.split(",")]
+
+    # Prepare headers if auth token is provided
+    headers = None
+    if auth_token:
+        headers = {"Authorization": f"Bearer {auth_token}"}
+
+    # Parse each URL
+    result = []
+    for url in url_list:
+        server_name, transport_type, parsed_url = parse_server_url(url)
+        result.append((server_name, transport_type, parsed_url, headers))
+
+    return result
+
+
+def generate_server_configs(
+    parsed_urls: List[Tuple[str, Literal["http", "sse"], str, Dict[str, str] | None]],
+) -> Dict[str, Dict[str, str | Dict[str, str]]]:
+    """
+    Generate server configurations from parsed URLs.
+
+    Args:
+        parsed_urls: List of tuples containing (server_name, transport_type, url, headers)
+
+    Returns:
+        Dictionary of server configurations
+    """
+    server_configs = {}
+    # Keep track of server name occurrences to handle collisions
+    name_counts = {}
+
+    for server_name, transport_type, url, headers in parsed_urls:
+        # Handle name collisions by adding a suffix
+        final_name = server_name
+        if server_name in server_configs:
+            # Initialize counter if we haven't seen this name yet
+            if server_name not in name_counts:
+                name_counts[server_name] = 1
+
+            # Generate a new name with suffix
+            suffix = name_counts[server_name]
+            final_name = f"{server_name}_{suffix}"
+            name_counts[server_name] += 1
+
+            # Ensure the new name is also unique
+            while final_name in server_configs:
+                suffix = name_counts[server_name]
+                final_name = f"{server_name}_{suffix}"
+                name_counts[server_name] += 1
+
+        config = {
+            "transport": transport_type,
+            "url": url,
+        }
+
+        # Add headers if provided
+        if headers:
+            config["headers"] = headers
+
+        server_configs[final_name] = config
+
+    return server_configs

mcp_agent/config.py

@@ -60,7 +60,7 @@ class MCPServerSettings(BaseModel):
     description: str | None = None
     """The description of the server."""
 
-    transport: Literal["stdio", "sse"] = "stdio"
+    transport: Literal["stdio", "sse", "http"] = "stdio"
     """The transport mechanism."""
 
     command: str | None = None
@@ -249,6 +249,8 @@ class LoggerSettings(BaseModel):
     """Show MCP Sever tool calls on the console"""
     truncate_tools: bool = True
     """Truncate display of long tool calls"""
+    enable_markup: bool = True
+    """Enable markup in console output. Disable for outputs that may conflict with rich console formatting"""
 
 
 class Settings(BaseSettings):

mcp_agent/context.py

@@ -11,6 +11,7 @@ from mcp import ServerSession
 from opentelemetry import trace
 from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
 from opentelemetry.instrumentation.anthropic import AnthropicInstrumentor
+from opentelemetry.instrumentation.mcp import McpInstrumentor
 from opentelemetry.instrumentation.openai import OpenAIInstrumentor
 from opentelemetry.propagate import set_global_textmap
 from opentelemetry.sdk.resources import Resource
@@ -111,6 +112,7 @@ async def configure_otel(config: "Settings") -> None:
     trace.set_tracer_provider(tracer_provider)
     AnthropicInstrumentor().instrument()
     OpenAIInstrumentor().instrument()
+    McpInstrumentor().instrument()
 
 
 async def configure_logger(config: "Settings") -> None:

mcp_agent/core/fastagent.py

@@ -131,8 +131,8 @@ class FastAgent:
             )
             parser.add_argument(
                 "--transport",
-                choices=["sse", "stdio"],
-                default="sse",
+                choices=["sse", "http", "stdio"],
+                default="http",
                 help="Transport protocol to use when running as a server (sse or stdio)",
             )
             parser.add_argument(

mcp_agent/core/request_params.py

@@ -25,24 +25,23 @@ class RequestParams(CreateMessageRequestParams):
 
     model: str | None = None
     """
-    The model to use for the LLM generation.
+    The model to use for the LLM generation. This can only be set during Agent creation.
     If specified, this overrides the 'modelPreferences' selection criteria.
     """
 
     use_history: bool = True
     """
-    Include the message history in the generate request.
+    Agent/LLM maintains conversation history. Does not include applied Prompts
     """
 
-    max_iterations: int = 10
+    max_iterations: int = 20
     """
-    The maximum number of iterations to run the LLM for.
+    The maximum number of tool calls allowed in a conversation turn
     """
 
     parallel_tool_calls: bool = True
     """
-    Whether to allow multiple tool calls per iteration.
-    Also known as multi-step tool use.
+    Whether to allow simultaneous tool calls
     """
     response_format: Any | None = None
     """

mcp_agent/llm/providers/augmented_llm_openai.py

@@ -274,7 +274,9 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
             # Calculate new conversation messages (excluding prompts)
             new_messages = messages[len(prompt_messages) :]
 
-            # Update conversation history
+            if system_prompt:
+                new_messages = new_messages[1:]
+
             self.history.set(new_messages)
 
         self._log_chat_finished(model=self.default_request_params.model)

mcp_agent/mcp/mcp_agent_client_session.py

@@ -6,21 +6,16 @@ It adds logging and supports sampling requests.
 from datetime import timedelta
 from typing import TYPE_CHECKING, Optional
 
-from mcp import ClientSession
+from mcp import ClientSession, ServerNotification
 from mcp.shared.session import (
-    ReceiveNotificationT,
     ReceiveResultT,
     RequestId,
     SendNotificationT,
     SendRequestT,
     SendResultT,
 )
-from mcp.types import (
-    ErrorData,
-    ListRootsResult,
-    Root,
-)
-from pydantic import AnyUrl
+from mcp.types import ErrorData, ListRootsResult, Root, ToolListChangedNotification
+from pydantic import FileUrl
 
 from mcp_agent.context_dependent import ContextDependent
 from mcp_agent.logging.logger import get_logger
@@ -45,7 +40,7 @@ async def list_roots(ctx: ClientSession) -> ListRootsResult:
     ):
         roots = [
             Root(
-                uri=AnyUrl(
+                uri=FileUrl(
                     root.server_uri_alias or root.uri,
                 ),
                 name=root.name,
@@ -67,6 +62,11 @@ class MCPAgentClientSession(ClientSession, ContextDependent):
     """
 
     def __init__(self, *args, **kwargs) -> None:
+        # Extract server_name if provided in kwargs
+        self.session_server_name = kwargs.pop("server_name", None)
+        # Extract the notification callbacks if provided
+        self._tool_list_changed_callback = kwargs.pop("tool_list_changed_callback", None)
+
         super().__init__(*args, **kwargs, list_roots_callback=list_roots, sampling_callback=sample)
         self.server_config: Optional[MCPServerSettings] = None
 
@@ -104,7 +104,7 @@ class MCPAgentClientSession(ClientSession, ContextDependent):
         )
         return await super()._send_response(request_id, response)
 
-    async def _received_notification(self, notification: ReceiveNotificationT) -> None:
+    async def _received_notification(self, notification: ServerNotification) -> None:
         """
         Can be overridden by subclasses to handle a notification without needing
         to listen on the message stream.
@@ -113,7 +113,37 @@ class MCPAgentClientSession(ClientSession, ContextDependent):
             "_received_notification: notification=",
             data=notification.model_dump(),
         )
-        return await super()._received_notification(notification)
+
+        # Call parent notification handler first
+        await super()._received_notification(notification)
+
+        # Then process our specific notification types
+        match notification.root:
+            case ToolListChangedNotification():
+                # Simple notification handling - just call the callback if it exists
+                if self._tool_list_changed_callback and self.session_server_name:
+                    logger.info(
+                        f"Tool list changed for server '{self.session_server_name}', triggering callback"
+                    )
+                    # Use asyncio.create_task to prevent blocking the notification handler
+                    import asyncio
+                    asyncio.create_task(self._handle_tool_list_change_callback(self.session_server_name))
+                else:
+                    logger.debug(
+                        f"Tool list changed for server '{self.session_server_name}' but no callback registered"
+                    )
+
+        return None
+
+    async def _handle_tool_list_change_callback(self, server_name: str) -> None:
+        """
+        Helper method to handle tool list change callback in a separate task
+        to prevent blocking the notification handler
+        """
+        try:
+            await self._tool_list_changed_callback(server_name)
+        except Exception as e:
+            logger.error(f"Error in tool list changed callback: {e}")
 
     async def send_progress_notification(
         self, progress_token: str | int, progress: float, total: float | None = None

mcp_agent/mcp/mcp_aggregator.py

@@ -138,6 +138,9 @@ class MCPAggregator(ContextDependent):
         self._prompt_cache: Dict[str, List[Prompt]] = {}
         self._prompt_cache_lock = Lock()
 
+        # Lock for refreshing tools from a server
+        self._refresh_lock = Lock()
+
     async def close(self) -> None:
         """
         Close all persistent connections when the aggregator is deleted.
@@ -217,8 +220,19 @@ class MCPAggregator(ContextDependent):
                     },
                 )
 
+                # Create a wrapper to capture the parameters for the client session
+                def session_factory(read_stream, write_stream, read_timeout):
+                    return MCPAgentClientSession(
+                        read_stream,
+                        write_stream,
+                        read_timeout,
+                        server_name=server_name,
+                        tool_list_changed_callback=self._handle_tool_list_changed
+                    )
+
                 await self._persistent_connection_manager.get_server(
-                    server_name, client_session_factory=MCPAgentClientSession
+                    server_name,
+                    client_session_factory=session_factory
                 )
 
             logger.info(
@@ -261,8 +275,20 @@ class MCPAggregator(ContextDependent):
                 tools = await fetch_tools(server_connection.session)
                 prompts = await fetch_prompts(server_connection.session, server_name)
             else:
+                # Create a factory function for the client session
+                def create_session(read_stream, write_stream, read_timeout):
+                    return MCPAgentClientSession(
+                        read_stream,
+                        write_stream,
+                        read_timeout,
+                        server_name=server_name,
+                        tool_list_changed_callback=self._handle_tool_list_changed
+                    )
+
                 async with gen_client(
-                    server_name, server_registry=self.context.server_registry
+                    server_name,
+                    server_registry=self.context.server_registry,
+                    client_session_factory=create_session
                 ) as client:
                     tools = await fetch_tools(client)
                     prompts = await fetch_prompts(client, server_name)
@@ -384,6 +410,15 @@ class MCPAggregator(ContextDependent):
             ]
         )
 
+    async def refresh_all_tools(self) -> None:
+        """
+        Refresh the tools for all servers.
+        This is useful when you know tools have changed but haven't received notifications.
+        """
+        logger.info("Refreshing tools for all servers")
+        for server_name in self.server_names:
+            await self._refresh_server_tools(server_name)
+
     async def _execute_on_server(
         self,
         server_name: str,
@@ -864,6 +899,102 @@ class MCPAggregator(ContextDependent):
         logger.debug(f"Available prompts across servers: {results}")
         return results
 
+    async def _handle_tool_list_changed(self, server_name: str) -> None:
+        """
+        Callback handler for ToolListChangedNotification.
+        This will refresh the tools for the specified server.
+
+        Args:
+            server_name: The name of the server whose tools have changed
+        """
+        logger.info(f"Tool list changed for server '{server_name}', refreshing tools")
+
+        # Refresh the tools for this server
+        await self._refresh_server_tools(server_name)
+
+    async def _refresh_server_tools(self, server_name: str) -> None:
+        """
+        Refresh the tools for a specific server.
+
+        Args:
+            server_name: The name of the server to refresh tools for
+        """
+        if not await self.validate_server(server_name):
+            logger.error(f"Cannot refresh tools for unknown server '{server_name}'")
+            return
+
+        async with self._refresh_lock:
+            try:
+                # Fetch new tools from the server
+                if self.connection_persistence:
+                    # Create a factory function that will include our parameters
+                    def create_session(read_stream, write_stream, read_timeout):
+                        return MCPAgentClientSession(
+                            read_stream,
+                            write_stream,
+                            read_timeout,
+                            server_name=server_name,
+                            tool_list_changed_callback=self._handle_tool_list_changed
+                        )
+
+                    server_connection = await self._persistent_connection_manager.get_server(
+                        server_name,
+                        client_session_factory=create_session
+                    )
+                    tools_result = await server_connection.session.list_tools()
+                    new_tools = tools_result.tools or []
+                else:
+                    # Create a factory function for the client session
+                    def create_session(read_stream, write_stream, read_timeout):
+                        return MCPAgentClientSession(
+                            read_stream,
+                            write_stream,
+                            read_timeout,
+                            server_name=server_name,
+                            tool_list_changed_callback=self._handle_tool_list_changed
+                        )
+
+                    async with gen_client(
+                        server_name,
+                        server_registry=self.context.server_registry,
+                        client_session_factory=create_session
+                    ) as client:
+                        tools_result = await client.list_tools()
+                        new_tools = tools_result.tools or []
+
+                # Update tool maps
+                async with self._tool_map_lock:
+                    # Remove old tools for this server
+                    old_tools = self._server_to_tool_map.get(server_name, [])
+                    for old_tool in old_tools:
+                        if old_tool.namespaced_tool_name in self._namespaced_tool_map:
+                            del self._namespaced_tool_map[old_tool.namespaced_tool_name]
+
+                    # Add new tools
+                    self._server_to_tool_map[server_name] = []
+                    for tool in new_tools:
+                        namespaced_tool_name = create_namespaced_name(server_name, tool.name)
+                        namespaced_tool = NamespacedTool(
+                            tool=tool,
+                            server_name=server_name,
+                            namespaced_tool_name=namespaced_tool_name,
+                        )
+
+                        self._namespaced_tool_map[namespaced_tool_name] = namespaced_tool
+                        self._server_to_tool_map[server_name].append(namespaced_tool)
+
+                logger.info(
+                    f"Successfully refreshed tools for server '{server_name}'",
+                    data={
+                        "progress_action": ProgressAction.UPDATED,
+                        "server_name": server_name,
+                        "agent_name": self.agent_name,
+                        "tool_count": len(new_tools),
+                    },
+                )
+            except Exception as e:
+                logger.error(f"Failed to refresh tools for server '{server_name}': {e}")
+
     async def get_resource(
         self, resource_uri: str, server_name: str | None = None
     ) -> ReadResourceResult:

mcp_agent/mcp/mcp_connection_manager.py

@@ -23,6 +23,7 @@ from mcp.client.stdio import (
     get_default_environment,
     stdio_client,
 )
+from mcp.client.streamable_http import GetSessionIdCallback, streamablehttp_client
 from mcp.types import JSONRPCMessage, ServerCapabilities
 
 from mcp_agent.config import MCPServerSettings
@@ -40,6 +41,27 @@ if TYPE_CHECKING:
 logger = get_logger(__name__)
 
 
+class StreamingContextAdapter:
+    """Adapter to provide a 3-value context from a 2-value context manager"""
+
+    def __init__(self, context_manager):
+        self.context_manager = context_manager
+        self.cm_instance = None
+
+    async def __aenter__(self):
+        self.cm_instance = await self.context_manager.__aenter__()
+        read_stream, write_stream = self.cm_instance
+        return read_stream, write_stream, None
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        return await self.context_manager.__aexit__(exc_type, exc_val, exc_tb)
+
+
+def _add_none_to_context(context_manager):
+    """Helper to add a None value to context managers that return 2 values instead of 3"""
+    return StreamingContextAdapter(context_manager)
+
+
 class ServerConnection:
     """
     Represents a long-lived MCP server connection, including:
@@ -57,6 +79,7 @@ class ServerConnection:
                 tuple[
                     MemoryObjectReceiveStream[JSONRPCMessage | Exception],
                     MemoryObjectSendStream[JSONRPCMessage],
+                    GetSessionIdCallback | None,
                 ],
                 None,
             ],
@@ -162,7 +185,7 @@ async def _server_lifecycle_task(server_conn: ServerConnection) -> None:
     try:
         transport_context = server_conn._transport_context_factory()
 
-        async with transport_context as (read_stream, write_stream):
+        async with transport_context as (read_stream, write_stream, _):
             server_conn.create_session(read_stream, write_stream)
 
             async with server_conn.session:
@@ -303,14 +326,17 @@ class MCPConnectionManager(ContextDependent):
                 error_handler = get_stderr_handler(server_name)
                 # Explicitly ensure we're using our custom logger for stderr
                 logger.debug(f"{server_name}: Creating stdio client with custom error handler")
-                return stdio_client(server_params, errlog=error_handler)
+                return _add_none_to_context(stdio_client(server_params, errlog=error_handler))
             elif config.transport == "sse":
-                return sse_client(
-                    config.url,
-                    config.headers,
-                    sse_read_timeout=config.read_transport_sse_timeout_seconds,
+                return _add_none_to_context(
+                    sse_client(
+                        config.url,
+                        config.headers,
+                        sse_read_timeout=config.read_transport_sse_timeout_seconds,
+                    )
                 )
-
+            elif config.transport == "http":
+                return streamablehttp_client(config.url, config.headers)
             else:
                 raise ValueError(f"Unsupported transport: {config.transport}")
 

mcp_agent/mcp/prompts/prompt_server.py

@@ -335,7 +335,7 @@ def parse_args():
     parser.add_argument(
         "--transport",
         type=str,
-        choices=["stdio", "sse"],
+        choices=["stdio", "sse", "http"],
         default="stdio",
         help="Transport to use (default: stdio)",
     )
@@ -502,14 +502,22 @@ async def async_main() -> int:
         return await test_prompt(args.test, config)
 
     # Start the server with the specified transport
-    if config.transport == "stdio":
-        await mcp.run_stdio_async()
-    else:  # sse
+    if config.transport == "sse":  # sse
         # Set the host and port in settings before running the server
         mcp.settings.host = config.host
         mcp.settings.port = config.port
         logger.info(f"Starting SSE server on {config.host}:{config.port}")
         await mcp.run_sse_async()
+    elif config.transport == "http":
+        mcp.settings.host = config.host
+        mcp.settings.port = config.port
+        logger.info(f"Starting SSE server on {config.host}:{config.port}")
+        await mcp.run_streamable_http_async()
+    elif config.transport == "stdio":
+        await mcp.run_stdio_async()
+    else:
+        logger.error(f"Unknown transport: {config.transport}")
+        return 1
     return 0
 
 

mcp_agent/mcp_server/agent_server.py

@@ -140,9 +140,9 @@ class AgentMCPServer:
         print("Press Ctrl+C again to force exit.")
         self._graceful_shutdown_event.set()
 
-    def run(self, transport: str = "sse", host: str = "0.0.0.0", port: int = 8000) -> None:
+    def run(self, transport: str = "http", host: str = "0.0.0.0", port: int = 8000) -> None:
         """Run the MCP server synchronously."""
-        if transport == "sse":
+        if transport in ["sse", "http"]:
             self.mcp_server.settings.host = host
             self.mcp_server.settings.port = port
 
@@ -180,12 +180,12 @@ class AgentMCPServer:
                 asyncio.run(self._cleanup_stdio())
 
     async def run_async(
-        self, transport: str = "sse", host: str = "0.0.0.0", port: int = 8000
+        self, transport: str = "http", host: str = "0.0.0.0", port: int = 8000
     ) -> None:
         """Run the MCP server asynchronously with improved shutdown handling."""
         # Use different handling strategies based on transport type
-        if transport == "sse":
-            # For SSE, use our enhanced shutdown handling
+        if transport in ["sse", "http"]:
+            # For SSE/HTTP, use our enhanced shutdown handling
             self._setup_signal_handlers()
 
             self.mcp_server.settings.host = host
@@ -236,9 +236,9 @@ class AgentMCPServer:
 
     async def _run_server_with_shutdown(self, transport: str):
         """Run the server with proper shutdown handling."""
-        # This method is only used for SSE transport
-        if transport != "sse":
-            raise ValueError("This method should only be used with SSE transport")
+        # This method is used for SSE/HTTP transport
+        if transport not in ["sse", "http"]:
+            raise ValueError("This method should only be used with SSE or HTTP transport")
 
         # Start a monitor task for shutdown
         shutdown_monitor = asyncio.create_task(self._monitor_shutdown())
@@ -262,8 +262,11 @@ class AgentMCPServer:
                 # Replace with our tracking version
                 self.mcp_server._sse_transport.connect_sse = tracked_connect_sse
 
-            # Run the server (SSE only)
-            await self.mcp_server.run_sse_async()
+            # Run the server based on transport type
+            if transport == "sse":
+                await self.mcp_server.run_sse_async()
+            elif transport == "http":
+                await self.mcp_server.run_streamable_http_async()
         finally:
             # Cancel the monitor when the server exits
             shutdown_monitor.cancel()

mcp_agent/mcp_server_registry.py

@@ -18,6 +18,7 @@ from mcp.client.stdio import (
     StdioServerParameters,
     get_default_environment,
 )
+from mcp.client.streamable_http import GetSessionIdCallback, streamablehttp_client
 
 from mcp_agent.config import (
     MCPServerAuthSettings,
@@ -27,7 +28,10 @@ from mcp_agent.config import (
 )
 from mcp_agent.logging.logger import get_logger
 from mcp_agent.mcp.logger_textio import get_stderr_handler
-from mcp_agent.mcp.mcp_connection_manager import MCPConnectionManager
+from mcp_agent.mcp.mcp_connection_manager import (
+    MCPConnectionManager,
+    _add_none_to_context,
+)
 
 logger = get_logger(__name__)
 
@@ -93,7 +97,12 @@ class ServerRegistry:
         self,
         server_name: str,
         client_session_factory: Callable[
-            [MemoryObjectReceiveStream, MemoryObjectSendStream, timedelta | None],
+            [
+                MemoryObjectReceiveStream,
+                MemoryObjectSendStream,
+                timedelta | None,
+                GetSessionIdCallback | None,
+            ],
             ClientSession,
         ] = ClientSession,
     ) -> AsyncGenerator[ClientSession, None]:
@@ -132,14 +141,18 @@ class ServerRegistry:
             )
 
             # Create a stderr handler that logs to our application logger
-            async with stdio_client(server_params, errlog=get_stderr_handler(server_name)) as (
+            async with _add_none_to_context(
+                stdio_client(server_params, errlog=get_stderr_handler(server_name))
+            ) as (
                 read_stream,
                 write_stream,
+                _,
             ):
                 session = client_session_factory(
                     read_stream,
                     write_stream,
                     read_timeout_seconds,
+                    None,  # No callback for stdio
                 )
                 async with session:
                     logger.info(f"{server_name}: Connected to server using stdio transport.")
@@ -153,15 +166,18 @@ class ServerRegistry:
                 raise ValueError(f"URL is required for SSE transport: {server_name}")
 
             # Use sse_client to get the read and write streams
-            async with sse_client(
-                config.url,
-                config.headers,
-                sse_read_timeout=config.read_transport_sse_timeout_seconds,
-            ) as (read_stream, write_stream):
+            async with _add_none_to_context(
+                sse_client(
+                    config.url,
+                    config.headers,
+                    sse_read_timeout=config.read_transport_sse_timeout_seconds,
+                )
+            ) as (read_stream, write_stream, _):
                 session = client_session_factory(
                     read_stream,
                     write_stream,
                     read_timeout_seconds,
+                    None,  # No callback for stdio
                 )
                 async with session:
                     logger.info(f"{server_name}: Connected to server using SSE transport.")
@@ -169,6 +185,27 @@ class ServerRegistry:
                         yield session
                     finally:
                         logger.debug(f"{server_name}: Closed session to server")
+        elif config.transport == "http":
+            if not config.url:
+                raise ValueError(f"URL is required for SSE transport: {server_name}")
+
+            async with streamablehttp_client(config.url, config.headers) as (
+                read_stream,
+                write_stream,
+                _,
+            ):
+                session = client_session_factory(
+                    read_stream,
+                    write_stream,
+                    read_timeout_seconds,
+                    None,  # No callback for stdio
+                )
+                async with session:
+                    logger.info(f"{server_name}: Connected to server using HTTP transport.")
+                    try:
+                        yield session
+                    finally:
+                        logger.debug(f"{server_name}: Closed session to server")
 
         # Unsupported transport
         else:
@@ -179,7 +216,12 @@ class ServerRegistry:
         self,
         server_name: str,
         client_session_factory: Callable[
-            [MemoryObjectReceiveStream, MemoryObjectSendStream, timedelta | None],
+            [
+                MemoryObjectReceiveStream,
+                MemoryObjectSendStream,
+                timedelta | None,
+                GetSessionIdCallback,
+            ],
             ClientSession,
         ] = ClientSession,
         init_hook: InitHookCallable = None,

mcp_agent/resources/examples/mcp/state-transfer/fastagent.config.yaml

@@ -23,5 +23,5 @@ logger:
 mcp:
   servers:
     agent_one:
-      transport: sse
-      url: http://localhost:8001/sse
+      transport: http
+      url: http://localhost:8001/mcp

mcp_agent/ui/console_display.py

@@ -25,6 +25,7 @@ class ConsoleDisplay:
             config: Configuration object containing display preferences
         """
         self.config = config
+        self._markup = config.logger.enable_markup if config else True
 
     def show_tool_result(self, result: CallToolResult) -> None:
         """Display a tool result in a formatted panel."""
@@ -46,7 +47,7 @@ class ConsoleDisplay:
             if len(str(result.content)) > 360:
                 panel.height = 8
 
-        console.console.print(panel)
+        console.console.print(panel, markup=self._markup)
         console.console.print("\n")
 
     def show_oai_tool_result(self, result) -> None:
@@ -67,7 +68,7 @@ class ConsoleDisplay:
             if len(str(result)) > 360:
                 panel.height = 8
 
-        console.console.print(panel)
+        console.console.print(panel, markup=self._markup)
         console.console.print("\n")
 
     def show_tool_call(self, available_tools, tool_name, tool_args) -> None:
@@ -92,7 +93,7 @@ class ConsoleDisplay:
             if len(str(tool_args)) > 360:
                 panel.height = 8
 
-        console.console.print(panel)
+        console.console.print(panel, markup=self._markup)
         console.console.print("\n")
 
     def _format_tool_list(self, available_tools, selected_tool_name):
@@ -172,7 +173,7 @@ class ConsoleDisplay:
             subtitle=display_server_list,
             subtitle_align="left",
         )
-        console.console.print(panel)
+        console.console.print(panel, markup=self._markup)
         console.console.print("\n")
 
     def show_user_message(
@@ -196,7 +197,7 @@ class ConsoleDisplay:
             subtitle=subtitle_text,
             subtitle_align="left",
         )
-        console.console.print(panel)
+        console.console.print(panel, markup=self._markup)
         console.console.print("\n")
 
     async def show_prompt_loaded(
@@ -270,5 +271,5 @@ class ConsoleDisplay:
             subtitle_align="left",
         )
 
-        console.console.print(panel)
+        console.console.print(panel, markup=self._markup)
         console.console.print("\n")