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

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

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.2.21
+Version: 0.2.23
 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/
@@ -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.23.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=_b5JeS2nWHScSUUTu6wYxXzdfKefoqII305ecKcw7Gs,12248
+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_dependent.py,sha256=QXfhw3RaQCKfscEEBRGuZ3sdMWqkgShz2jJ1ivGGX1I,1455
-mcp_agent/event_progress.py,sha256=3dqk5Pn1tAG_m_wn4IPNwLWLyzm7CyKIidqHN-4l-JY,2736
-mcp_agent/mcp_server_registry.py,sha256=jUmCdfcpTitXm1-3TxpWsdRWY_8phdKNYgXwB16ZSVU,10100
+mcp_agent/event_progress.py,sha256=b1VKlQQF2AgPMb6XHjlJAVoPdx8GuxRTUk2g-4lBNm0,2749
+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=DJpmq4n-p5r8BXH10UqBOexmLND-zSODl5f-w4noR5Q,4304
+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=loYf13DN7e-DsdYRd37jWkJWJGwVBL-iFkcANP1J60Q,1366
+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
@@ -48,26 +49,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 +88,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=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
@@ -99,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
@@ -121,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
@@ -142,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.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,,
+mcp_agent/ui/console_display.py,sha256=EUeMJ7yqtxJ0-hAjXNZFJFTlmfyKlENdfzTlw0e5ETg,9949
+fast_agent_mcp-0.2.23.dist-info/METADATA,sha256=Vtk96ocWT3Xk_Y8f3ZLUILhh2aybr8OebCPn5jZeZOY,30156
+fast_agent_mcp-0.2.23.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fast_agent_mcp-0.2.23.dist-info/entry_points.txt,sha256=bRniFM5zk3Kix5z7scX0gf9VnmGQ2Cz_Q1Gh7Ir4W00,186
+fast_agent_mcp-0.2.23.dist-info/licenses/LICENSE,sha256=cN3FxDURL9XuzE5mhK9L2paZo82LTfjwCYVT7e3j0e4,10939
+fast_agent_mcp-0.2.23.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,60 +2,133 @@
 
 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.",
     config_path: Optional[str] = None,
     server_list: Optional[List[str]] = None,
     model: Optional[str] = None,
+    message: 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
-    
-    @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.default.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()
 
+
 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,
-    model: Optional[str] = None
+    urls: Optional[str] = None,
+    auth: 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
-    
+    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()
@@ -68,22 +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
-        ))
+        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))
@@ -92,6 +170,7 @@ def run_async_agent(
         except Exception:
             pass
 
+
 @app.callback(invoke_without_command=True)
 def go(
     ctx: typer.Context,
@@ -105,29 +184,53 @@ 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)"
     ),
+    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
+        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
     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
+        --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,
-        model=model
-    )
+        urls=urls,
+        auth=auth,
+        model=model,
+        message=message,
+        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