fast-agent-mcp 0.2.55__py3-none-any.whl → 0.2.57__py3-none-any.whl

{fast_agent_mcp-0.2.55.dist-info → fast_agent_mcp-0.2.57.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.2.55
+Version: 0.2.57
 Summary: Define, Prompt and Test MCP enabled Agents and Workflows
 Author-email: Shaun Smith <fastagent@llmindset.co.uk>
 License:                                  Apache License
@@ -211,7 +211,7 @@ Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.13
 Requires-Dist: a2a-sdk>=0.3.0
 Requires-Dist: aiohttp>=3.11.13
-Requires-Dist: anthropic>=0.59.0
+Requires-Dist: anthropic>=0.63.0
 Requires-Dist: azure-identity>=1.14.0
 Requires-Dist: boto3>=1.35.0
 Requires-Dist: deprecated>=1.2.18
@@ -219,7 +219,7 @@ Requires-Dist: email-validator>=2.2.0
 Requires-Dist: fastapi>=0.115.6
 Requires-Dist: google-genai>=1.27.0
 Requires-Dist: mcp==1.12.4
-Requires-Dist: openai>=1.97.1
+Requires-Dist: openai>=1.99.9
 Requires-Dist: opentelemetry-distro>=0.55b0
 Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.7.0
 Requires-Dist: opentelemetry-instrumentation-anthropic>=0.43.1; python_version >= '3.10' and python_version < '4.0'
@@ -234,20 +234,6 @@ Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: rich>=14.1.0
 Requires-Dist: tensorzero>=2025.7.5
 Requires-Dist: typer>=0.15.1
-Provides-Extra: azure
-Requires-Dist: azure-identity>=1.14.0; extra == 'azure'
-Provides-Extra: dev
-Requires-Dist: anthropic>=0.42.0; extra == 'dev'
-Requires-Dist: pre-commit>=4.0.1; extra == 'dev'
-Requires-Dist: pydantic>=2.10.4; extra == 'dev'
-Requires-Dist: pytest-asyncio>=0.21.1; extra == 'dev'
-Requires-Dist: pytest-cov; extra == 'dev'
-Requires-Dist: pytest>=7.4.0; extra == 'dev'
-Requires-Dist: pyyaml>=6.0.2; extra == 'dev'
-Requires-Dist: ruff>=0.8.4; extra == 'dev'
-Requires-Dist: tomli>=2.2.1; extra == 'dev'
-Provides-Extra: openai
-Requires-Dist: openai>=1.58.1; extra == 'openai'
 Description-Content-Type: text/markdown
 
 <p align="center">

{fast_agent_mcp-0.2.55.dist-info → fast_agent_mcp-0.2.57.dist-info}/RECORD

@@ -4,13 +4,13 @@ mcp_agent/config.py,sha256=BjfZmhKnoGHH80puLY90RkZPx5PPm-yvgJEqPsvvNWY,19259
 mcp_agent/console.py,sha256=Gjf2QLFumwG1Lav__c07X_kZxxEUSkzV-1_-YbAwcwo,813
 mcp_agent/context.py,sha256=lzz_Fyf9lz9BBAUt1bRVBlyyHjLkyeuyIziAi4qXYUk,7639
 mcp_agent/context_dependent.py,sha256=QXfhw3RaQCKfscEEBRGuZ3sdMWqkgShz2jJ1ivGGX1I,1455
-mcp_agent/event_progress.py,sha256=EdozJ6a13Ur_zMMbPx-1pKwsLEbHF0bwCEcErhxLCew,4513
+mcp_agent/event_progress.py,sha256=YEk4RxHtblLNIn-ea8c9uHkEKOhtLEWOO662yjkf8Vo,4614
 mcp_agent/mcp_server_registry.py,sha256=lmz-aES-l7Gbg4itDF0iCmpso_KD8bVazVKSVzjwNE4,12398
 mcp_agent/progress_display.py,sha256=GeJU9VUt6qKsFVymG688hCMVCsAygG9ifiiEb5IcbN4,361
 mcp_agent/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_agent/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mcp_agent/agents/agent.py,sha256=EAYlcP1qqI1D0_CS808I806z1048FBjZQxxpcCZPeIU,3154
-mcp_agent/agents/base_agent.py,sha256=4hyEdJJENxIDLCtYOAmRlmM7dRVE0JPEhOYktPTw1I0,34566
+mcp_agent/agents/agent.py,sha256=-vAbAXMt_0jIXyU1_rvcbGTCjwT3I0wyFL7kAdxI1Qk,3361
+mcp_agent/agents/base_agent.py,sha256=IVQNCJMgs9gfUnhS6BvK1bVEe0ZfjzZXmWKbpI980i0,34875
 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=LT81m2B7fxgBZY0CorXFOZJbVhM5fnjDjfrcywO5UrM,12210
@@ -26,25 +26,25 @@ mcp_agent/cli/constants.py,sha256=KawdkaN289nVB02DKPB4IVUJ8-fohIUD0gLfOp0P7B8,55
 mcp_agent/cli/main.py,sha256=Oo13X7LB0Cf7JrkilQXz8Eqi_48cE0Rr2qqDUOQifEQ,3175
 mcp_agent/cli/terminal.py,sha256=GRwD-RGW7saIz2IOWZn5vD6JjiArscELBThm1GTFkuI,1065
 mcp_agent/cli/commands/check_config.py,sha256=15YK0mtDQbVopnMm3HBjOeY2-00FUHj6tt8RvaemKmI,21081
-mcp_agent/cli/commands/go.py,sha256=SHFJlO3SeZzAWvx_Gz72zXKA8n7XfaZ49W6UNS5mbV4,14668
+mcp_agent/cli/commands/go.py,sha256=RfNJQYmuDJicpYM7oT-jfv_9P7kBqCh_5Ezd4RtcYME,14712
 mcp_agent/cli/commands/quickstart.py,sha256=hwIr1F9zGRSQGf7kwvmirMIK7Qke2s6W95inZ-a2SMQ,21171
 mcp_agent/cli/commands/server_helpers.py,sha256=x5tD_qhf1W4D2li09sfOyfRWCOCa6lmpumYAPsEfIQs,3649
 mcp_agent/cli/commands/setup.py,sha256=eOEd4TL-b0DaDeSJMGOfNOsTEItoZ67W88eTP4aP-bo,6482
 mcp_agent/cli/commands/url_parser.py,sha256=5VdtcHRHzi67YignStVbz7u-rcvNNErw9oJLAUFOtEY,5855
 mcp_agent/core/__init__.py,sha256=7xAVBbyrsJwmrzL-we9tBY9PcJxFnajoJcaXSc6gBUw,391
-mcp_agent/core/agent_app.py,sha256=SolGwejEmv9XtsTsmiMkNKPia7RN1VcHXm6JoEo4hvQ,16187
+mcp_agent/core/agent_app.py,sha256=2p-wlQZJ7LNFOIxDdzt7u2p0ar-5To0laiSBCNaZWpw,16834
 mcp_agent/core/agent_types.py,sha256=ClFN7ikstZ5suweeLFf5w9jcg3ygxVhMS7GRj9VJ8yQ,1749
 mcp_agent/core/direct_decorators.py,sha256=mOMLHf_qhWFqcOY0QE1UbHtXAarnetIKp7n0U8WvcyM,24061
 mcp_agent/core/direct_factory.py,sha256=0G1HbVECfdFJGn__lBYGha_qt7Xyp18ST18IOzO134E,20867
-mcp_agent/core/enhanced_prompt.py,sha256=ZIeJCeW7rcGMBZ2OdEQwqOmRT0wNSp0hO2-dZRSnnLE,36068
+mcp_agent/core/enhanced_prompt.py,sha256=QeBajgqu09SyK0ULEzsauAM-xlR4oLtT23udbZzVLuk,36410
 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=HiKuxHsj0wq6_RV0wkJih8br39ciHNnnfVEsknhbiQA,25264
+mcp_agent/core/fastagent.py,sha256=dYN2fpgDSrk7iGHN7JmW0e8eFF47oqDmatzdUHz0eEI,25306
 mcp_agent/core/interactive_prompt.py,sha256=Gpwn7v7m3nw7fR_W7bs5XYArrny_xJK06DOURUwpzI4,32756
 mcp_agent/core/mcp_content.py,sha256=2D7KHY9mG_vxoDwFLKvsPQV9VRIzHItM7V-jcEnACh8,8878
 mcp_agent/core/mermaid_utils.py,sha256=MpcRyVCPMTwU1XeIxnyFg0fQLjcyXZduWRF8NhEqvXE,5332
 mcp_agent/core/prompt.py,sha256=qnintOUGEoDPYLI9bu9G2OlgVMCe5ZPUZilgMzydXhc,7919
-mcp_agent/core/request_params.py,sha256=qmFWZXeYEJyYw2IwonyrTnZWxQG7qX6bKpOPcqETa60,1603
+mcp_agent/core/request_params.py,sha256=OW9WnQAD-I2fz2JzMsqPY2wwwHFG0SI4yAvC1WxTfNY,1735
 mcp_agent/core/usage_display.py,sha256=CcCQbTm5ftMgkoBgr5NWzHmYFBK5cSU-FM8yiBOVzGA,7527
 mcp_agent/core/validation.py,sha256=8D6d3mQanvzC2dXx5yc8-5bkoWEh9cxuT6-YSthSGFk,12676
 mcp_agent/executor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -61,7 +61,7 @@ mcp_agent/human_input/handler.py,sha256=s712Z5ssTCwjL9-VKoIdP5CtgMh43YvepynYisiW
 mcp_agent/human_input/simple_form.py,sha256=u6iCo39IJftB1S1xljdQP3C18RuRCcwp7jKQTTDcLT4,3441
 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=UCAKqlsv3eUBIhOz0p3_bSNKOY3MykJIb7OBKoXJjWI,27973
+mcp_agent/llm/augmented_llm.py,sha256=ZJM3TXGV66aQ_zSDPrOG0r6EMVOOdeh1Equq8uNjDBM,28642
 mcp_agent/llm/augmented_llm_passthrough.py,sha256=bu0DJkjyFPzBZEU7f6MHnOp__9BCYl56tFd5nZVhSeY,8808
 mcp_agent/llm/augmented_llm_playback.py,sha256=rLzgai496e2RlxqQp_Bp0U-Y1FF1SGsWl9COx4GiCNE,5004
 mcp_agent/llm/augmented_llm_silent.py,sha256=IUnK_1Byy4D9TG0Pj46LFeNezgSTQ8d6MQIHWAImBwE,1846
@@ -80,13 +80,13 @@ mcp_agent/llm/providers/anthropic_utils.py,sha256=vYDN5G5jKMhD2CQg8veJYab7tvvzYk
 mcp_agent/llm/providers/augmented_llm_aliyun.py,sha256=Th4qeyihOSfTrojPw8YsgzEyaDwhybk7hkXkFjH-1dY,1277
 mcp_agent/llm/providers/augmented_llm_anthropic.py,sha256=U8znA9HSCOx4FlhIjl-J29nbYc8Y-T6BXevtXuDafio,30352
 mcp_agent/llm/providers/augmented_llm_azure.py,sha256=Xoo6dFst6L9SaGKurqptwwTUzr-sYsolZ-AFb_79puc,6098
-mcp_agent/llm/providers/augmented_llm_bedrock.py,sha256=nfby1udL07zPTOLlN_tFxd1h0JRioo2oIW7v4iP4Bnk,82267
+mcp_agent/llm/providers/augmented_llm_bedrock.py,sha256=lL_au5-QdVNFr7lxQQYk0HVQ3LKUieh2HHnBQsOWoro,82312
 mcp_agent/llm/providers/augmented_llm_deepseek.py,sha256=vphkYMFyukaejBw8SkCN-MqcG9qsfXJfWKZYYtspqPY,3877
 mcp_agent/llm/providers/augmented_llm_generic.py,sha256=5Uq8ZBhcFuQTt7koP_5ykolREh2iWu8zKhNbh3pM9lQ,1210
 mcp_agent/llm/providers/augmented_llm_google_native.py,sha256=c6zczfs-Iw70j3OYELHJ4S7CRwAddkeXinex_yLMhmU,22194
 mcp_agent/llm/providers/augmented_llm_google_oai.py,sha256=g_g46h-YuxqbRZiO_dVo5zO2OkX1yx7nb6xDaQbOvWs,1137
-mcp_agent/llm/providers/augmented_llm_groq.py,sha256=Nj4X7wL7nOz_JYC-3bFOWut-hleZxGqWHNe0U-0ga8Y,4419
-mcp_agent/llm/providers/augmented_llm_openai.py,sha256=d5WeCU6smP7a5egZOBpblF62mK5kOzK4tn2YeQoK34A,25401
+mcp_agent/llm/providers/augmented_llm_groq.py,sha256=w-R1N2B7790v9tXxRCPt2SKnaB-DRdEtN_51fpdYb_I,5355
+mcp_agent/llm/providers/augmented_llm_openai.py,sha256=v0iInSlPt939Dh2kGpGJ9_7qGpL7MhxQ7UNSc42dT6Q,25318
 mcp_agent/llm/providers/augmented_llm_openrouter.py,sha256=m3wS83fabBOmaZJH9gQ9sFw_2TB4xTb44WCOPB-2NJ4,2001
 mcp_agent/llm/providers/augmented_llm_tensorzero_openai.py,sha256=D53Fry2AfBLOB5z9hM19U6_HMJeVNTpiBCAJb11ulNg,5503
 mcp_agent/llm/providers/augmented_llm_xai.py,sha256=MhlX91IUNynQ_NDknx4EQJLwg-NbR8lcHS1P4JuLOnA,1433
@@ -112,9 +112,9 @@ mcp_agent/mcp/gen_client.py,sha256=fAVwFVCgSamw4PwoWOV4wrK9TABx1S_zZv8BctRyF2k,3
 mcp_agent/mcp/hf_auth.py,sha256=7szw4rkwRyK3J-sUTcVZHdwoLIZqlYo8XolJnZdjOww,4571
 mcp_agent/mcp/interfaces.py,sha256=5y7zuXkpGCfsJfZOAEZAZtbFd5rAKjn7oG4JoblPHZ4,8070
 mcp_agent/mcp/logger_textio.py,sha256=vljC1BtNTCxBAda9ExqNB-FwVNUZIuJT3h1nWmCjMws,3172
-mcp_agent/mcp/mcp_agent_client_session.py,sha256=ssRgxMOzyCPyAr25AeRBz3Xr-08OBdmsJf8A-ofc3bY,9115
-mcp_agent/mcp/mcp_aggregator.py,sha256=6fZTgoiUfE7YHjLug1ZQ2VtKYj8HVe_diMwNN6npPGk,53343
-mcp_agent/mcp/mcp_connection_manager.py,sha256=dJxjnv2IRzlFIxrbPFl39-pmGcZHgyeMXVlMfqpREhE,17974
+mcp_agent/mcp/mcp_agent_client_session.py,sha256=WUx-9usO6PHwyfodIPEtd88DNDU-1YDdvQ4TNsEpfqI,13383
+mcp_agent/mcp/mcp_aggregator.py,sha256=9r0EOrb8UR9br6qrjwW4deWWO2Jt7NFrYJenhrePRAk,55915
+mcp_agent/mcp/mcp_connection_manager.py,sha256=VaWH-PWjVfaCDEWT0nfMblJ_3BbvDqDgoeMtGuLS9_M,18716
 mcp_agent/mcp/mime_utils.py,sha256=difepNR_gpb4MpMLkBRAoyhDk-AjXUHTiqKvT_VwS1o,1805
 mcp_agent/mcp/prompt_message_multipart.py,sha256=-oSO0mnc5gkSgulE1gAntPEwAKF4asOjEeVyLjhYrEk,4336
 mcp_agent/mcp/prompt_render.py,sha256=k3v4BZDThGE2gGiOYVQtA6x8WTEdOuXIEnRafANhN1U,2996
@@ -183,10 +183,10 @@ mcp_agent/resources/examples/workflows/router.py,sha256=vmw8aBitByi5PRFIvjYWWn2G
 mcp_agent/resources/examples/workflows/short_story.md,sha256=XN9I2kzCcMmke3dE5F2lyRH5iFUZUQ8Sy-hS3rm_Wlc,1153
 mcp_agent/resources/examples/workflows/short_story.txt,sha256=X3y_1AyhLFN2AKzCKvucJtDgAFIJfnlbsbGZO5bBWu0,1187
 mcp_agent/tools/tool_definition.py,sha256=L3Pxl-uLEXqlVoo-bYuFTFALeI-2pIU44YgFhsTKEtM,398
-mcp_agent/ui/console_display.py,sha256=XXrHr950wSBSedEKUaaGkXjOzuFpQYzUKKiyaZ58Mps,28280
+mcp_agent/ui/console_display.py,sha256=ts2oPxxprzbT9rMqZhzwq6DQkNfbq8XNwbgEPPMi7nI,32083
 mcp_agent/ui/console_display_legacy.py,sha256=sm2v61-IPVafbF7uUaOyhO2tW_zgFWOjNS83IEWqGgI,14931
-fast_agent_mcp-0.2.55.dist-info/METADATA,sha256=wJSX8ZuwOm6h7kbWev3_cv1CQRDHT0C60xwlE9tXPqE,31048
-fast_agent_mcp-0.2.55.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fast_agent_mcp-0.2.55.dist-info/entry_points.txt,sha256=QaX5kLdI0VdMPRdPUF1nkG_WdLUTNjp_icW6e3EhNYU,232
-fast_agent_mcp-0.2.55.dist-info/licenses/LICENSE,sha256=Gx1L3axA4PnuK4FxsbX87jQ1opoOkSFfHHSytW6wLUU,10935
-fast_agent_mcp-0.2.55.dist-info/RECORD,,
+fast_agent_mcp-0.2.57.dist-info/METADATA,sha256=8NJird91GzBusg3XcllAlxSRvG-fHS9KR7A2AFJowhw,30459
+fast_agent_mcp-0.2.57.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fast_agent_mcp-0.2.57.dist-info/entry_points.txt,sha256=QaX5kLdI0VdMPRdPUF1nkG_WdLUTNjp_icW6e3EhNYU,232
+fast_agent_mcp-0.2.57.dist-info/licenses/LICENSE,sha256=Gx1L3axA4PnuK4FxsbX87jQ1opoOkSFfHHSytW6wLUU,10935
+fast_agent_mcp-0.2.57.dist-info/RECORD,,

mcp_agent/agents/agent.py

@@ -10,6 +10,7 @@ from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, TypeVar
 from mcp_agent.agents.base_agent import BaseAgent
 from mcp_agent.core.agent_types import AgentConfig
 from mcp_agent.core.interactive_prompt import InteractivePrompt
+from mcp_agent.core.request_params import RequestParams
 from mcp_agent.human_input.types import HumanInputCallback
 from mcp_agent.logging.logger import get_logger
 from mcp_agent.mcp.interfaces import AugmentedLLMProtocol
@@ -51,13 +52,19 @@ class Agent(BaseAgent):
             **kwargs,
         )
 
-    async def prompt(self, default_prompt: str = "", agent_name: Optional[str] = None) -> str:
+    async def prompt(
+        self, 
+        default_prompt: str = "", 
+        agent_name: Optional[str] = None,
+        request_params: RequestParams | None = None
+    ) -> str:
         """
         Start an interactive prompt session with this agent.
 
         Args:
             default: Default message to use when user presses enter
             agent_name: Ignored for single agents, included for API compatibility
+            request_params: Optional request parameters
 
         Returns:
             The result of the interactive session
@@ -66,14 +73,14 @@ class Agent(BaseAgent):
         agent_name_str = str(self.name)
 
         # Create agent_types dictionary with just this agent
-        agent_types = {agent_name_str: self.agent_type.value}
+        agent_types = {agent_name_str: self.agent_type}
 
         # Create the interactive prompt
         prompt = InteractivePrompt(agent_types=agent_types)
 
         # Define wrapper for send function
         async def send_wrapper(message, agent_name):
-            return await self.send(message)
+            return await self.send(message, request_params)
 
         # Start the prompt loop with just this agent
         return await prompt.prompt_loop(

mcp_agent/agents/base_agent.py

@@ -208,7 +208,11 @@ class BaseAgent(MCPAggregator, AgentProtocol):
         result: PromptMessageMultipart = await self.generate([Prompt.user(message)], request_params)
         return result.first_text()
 
-    async def send(self, message: Union[str, PromptMessage, PromptMessageMultipart]) -> str:
+    async def send(
+        self, 
+        message: Union[str, PromptMessage, PromptMessageMultipart],
+        request_params: RequestParams | None = None
+    ) -> str:
         """
         Send a message to the agent and get a response.
 
@@ -217,6 +221,7 @@ class BaseAgent(MCPAggregator, AgentProtocol):
                 - String: Converted to a user PromptMessageMultipart
                 - PromptMessage: Converted to PromptMessageMultipart
                 - PromptMessageMultipart: Used directly
+                - request_params: Optional request parameters
 
         Returns:
             The agent's response as a string
@@ -225,7 +230,7 @@ class BaseAgent(MCPAggregator, AgentProtocol):
         prompt = self._normalize_message_input(message)
 
         # Use the LLM to generate a response
-        response = await self.generate([prompt], None)
+        response = await self.generate([prompt], request_params)
         return response.all_text()
 
     def _normalize_message_input(
@@ -364,12 +369,15 @@ class BaseAgent(MCPAggregator, AgentProtocol):
         if self.config.tools is not None:
             filtered_tools = []
             for tool in result.tools:
-                # Extract server name from tool name (e.g., "mathematics-add" -> "mathematics")
-                if "-" in tool.name:
-                    server_name = tool.name.split("-", 1)[0]
+                # Extract server name from tool name, handling server names with hyphens
+                server_name = None
+                for configured_server in self.config.tools.keys():
+                    if tool.name.startswith(f"{configured_server}-"):
+                        server_name = configured_server
+                        break
 
-                    # Check if this server has tool filters
-                    if server_name in self.config.tools:
+                # Check if this server has tool filters
+                if server_name and server_name in self.config.tools:
                         # Check if tool matches any pattern for this server
                         for pattern in self.config.tools[server_name]:
                             if self._matches_pattern(tool.name, pattern, server_name):

mcp_agent/cli/commands/go.py

@@ -121,9 +121,9 @@ async def _run_agent(
                     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())
+                    response = await agent.agent.generate(prompt)
+                    print(f"\nLoaded {len(prompt)} messages from prompt file '{prompt_file}'")
+                    await agent.interactive()
                 else:
                     await agent.interactive()
 

mcp_agent/core/agent_app.py

@@ -11,6 +11,7 @@ from rich import print as rich_print
 from mcp_agent.agents.agent import Agent
 from mcp_agent.core.agent_types import AgentType
 from mcp_agent.core.interactive_prompt import InteractivePrompt
+from mcp_agent.core.request_params import RequestParams
 from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 from mcp_agent.progress_display import progress_display
 
@@ -53,6 +54,7 @@ class AgentApp:
         message: Union[str, PromptMessage, PromptMessageMultipart] | None = None,
         agent_name: str | None = None,
         default_prompt: str = "",
+        request_params: RequestParams | None = None,
     ) -> str:
         """
         Make the object callable to send messages or start interactive prompt.
@@ -65,19 +67,21 @@ class AgentApp:
                 - PromptMessageMultipart: Used directly
             agent_name: Optional name of the agent to send to (defaults to first agent)
             default_prompt: Default message to use in interactive prompt mode
+            request_params: Optional request parameters including MCP metadata
 
         Returns:
             The agent's response as a string or the result of the interactive session
         """
         if message:
-            return await self._agent(agent_name).send(message)
+            return await self._agent(agent_name).send(message, request_params)
 
-        return await self.interactive(agent_name=agent_name, default_prompt=default_prompt)
+        return await self.interactive(agent_name=agent_name, default_prompt=default_prompt, request_params=request_params)
 
     async def send(
         self,
         message: Union[str, PromptMessage, PromptMessageMultipart],
         agent_name: Optional[str] = None,
+        request_params: RequestParams | None = None,
     ) -> str:
         """
         Send a message to the specified agent (or to all agents).
@@ -88,11 +92,12 @@ class AgentApp:
                 - PromptMessage: Converted to PromptMessageMultipart
                 - PromptMessageMultipart: Used directly
             agent_name: Optional name of the agent to send to
+            request_params: Optional request parameters including MCP metadata
 
         Returns:
             The agent's response as a string
         """
-        return await self._agent(agent_name).send(message)
+        return await self._agent(agent_name).send(message, request_params)
 
     def _agent(self, agent_name: str | None) -> Agent:
         if agent_name:
@@ -233,17 +238,23 @@ class AgentApp:
         )
 
     @deprecated
-    async def prompt(self, agent_name: str | None = None, default_prompt: str = "") -> str:
+    async def prompt(
+        self, 
+        agent_name: str | None = None, 
+        default_prompt: str = "",
+        request_params: RequestParams | None = None
+    ) -> str:
         """
         Deprecated - use interactive() instead.
         """
-        return await self.interactive(agent_name=agent_name, default_prompt=default_prompt)
+        return await self.interactive(agent_name=agent_name, default_prompt=default_prompt, request_params=request_params)
 
     async def interactive(
         self,
         agent_name: str | None = None,
         default_prompt: str = "",
         pretty_print_parallel: bool = False,
+        request_params: RequestParams | None = None,
     ) -> str:
         """
         Interactive prompt for sending messages with advanced features.
@@ -252,6 +263,7 @@ class AgentApp:
             agent_name: Optional target agent name (uses default if not specified)
             default: Default message to use when user presses enter
             pretty_print_parallel: Enable clean parallel results display for parallel agents
+            request_params: Optional request parameters including MCP metadata
 
         Returns:
             The result of the interactive session
@@ -285,7 +297,7 @@ class AgentApp:
 
         # Define the wrapper for send function
         async def send_wrapper(message, agent_name):
-            result = await self.send(message, agent_name)
+            result = await self.send(message, agent_name, request_params)
 
             # Show parallel results if enabled and this is a parallel agent
             if pretty_print_parallel:

mcp_agent/core/enhanced_prompt.py

@@ -428,9 +428,14 @@ def create_keybindings(on_toggle_multiline=None, app=None, agent_provider=None,
         """Enter: accept input when not in multiline mode."""
         event.current_buffer.validate_and_handle()
 
+    @kb.add("c-j", filter=Condition(lambda: not in_multiline_mode))
+    def _(event) -> None:
+        """Ctrl+J: Insert newline when in normal mode."""
+        event.current_buffer.insert_text("\n")
+
     @kb.add("c-m", filter=Condition(lambda: in_multiline_mode))
     def _(event) -> None:
-        """Enter: insert newline when in multiline mode."""
+        """Enter: Insert newline when in multiline mode."""
         event.current_buffer.insert_text("\n")
 
     # Use c-j (Ctrl+J) as an alternative to represent Ctrl+Enter in multiline mode
@@ -581,13 +586,15 @@ async def get_enhanced_input(
 
         shortcuts = [
             ("Ctrl+T", toggle_text),
+            ("Ctrl+J", "Newline" if not in_multiline_mode else None),
             ("Ctrl+E", "External"),
             ("Ctrl+Y", "Copy"),
             ("Ctrl+L", "Clear"),
             ("↑/↓", "History"),
+            ("EXIT", "Exit")
         ]
 
-        newline = "Ctrl+<Enter>:Submit" if in_multiline_mode else "<Enter>:Submit"
+        newline = "Ctrl+J:Submit" if in_multiline_mode else "<Enter>:Submit"
 
         # Only show relevant shortcuts based on mode
         shortcuts = [(k, v) for k, v in shortcuts if v]
@@ -669,6 +676,8 @@ async def get_enhanced_input(
     def pre_process_input(text):
         # Command processing
         if text and text.startswith("/"):
+            if text == "/": 
+                return ""
             cmd_parts = text[1:].strip().split(maxsplit=1)
             cmd = cmd_parts[0].lower()
 

mcp_agent/core/fastagent.py

@@ -87,6 +87,7 @@ class FastAgent:
         ignore_unknown_args: bool = False,
         parse_cli_args: bool = True,
         quiet: bool = False,  # Add quiet parameter
+        **kwargs
     ) -> None:
         """
         Initialize the fast-agent application.
@@ -203,6 +204,7 @@ class FastAgent:
             self.app = MCPApp(
                 name=name,
                 settings=config.Settings(**self.config) if hasattr(self, "config") else None,
+                **kwargs
             )
 
             # Stop progress display immediately if quiet mode is requested

mcp_agent/core/request_params.py

@@ -52,3 +52,8 @@ class RequestParams(CreateMessageRequestParams):
     """
     Optional dictionary of template variables for dynamic templates. Currently only works for TensorZero inference backend
     """
+
+    mcp_metadata: Dict[str, Any] | None = None
+    """
+    Metadata to pass through to MCP tool calls via the _meta field.
+    """

mcp_agent/event_progress.py

@@ -25,6 +25,9 @@ class ProgressAction(str, Enum):
     FINISHED = "Finished"
     SHUTDOWN = "Shutdown"
     AGGREGATOR_INITIALIZED = "Running"
+    SERVER_OFFLINE = "Offline"
+    SERVER_RECONNECTING = "Reconnecting"
+    SERVER_ONLINE = "Online"
     FATAL_ERROR = "Error"
 
 

mcp_agent/llm/augmented_llm.py

@@ -1,4 +1,5 @@
 from abc import abstractmethod
+from contextvars import ContextVar
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -61,6 +62,9 @@ if TYPE_CHECKING:
 # TODO -- move this to a constant
 HUMAN_INPUT_TOOL_NAME = "__human_input__"
 
+# Context variable for storing MCP metadata
+_mcp_metadata_var: ContextVar[Dict[str, Any] | None] = ContextVar('mcp_metadata', default=None)
+
 
 def deep_merge(dict1: Dict[Any, Any], dict2: Dict[Any, Any]) -> Dict[Any, Any]:
     """
@@ -232,6 +236,11 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
 
         self._precall(multipart_messages)
 
+        # Store MCP metadata in context variable
+        final_request_params = self.get_request_params(request_params)
+        if final_request_params.mcp_metadata:
+            _mcp_metadata_var.set(final_request_params.mcp_metadata)
+
         assistant_response: PromptMessageMultipart = await self._apply_prompt_provider_specific(
             multipart_messages, request_params
         )
@@ -275,6 +284,12 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
             multipart_messages = PromptMessageMultipart.to_multipart(multipart_messages)
 
         self._precall(multipart_messages)
+        
+        # Store MCP metadata in context variable
+        final_request_params = self.get_request_params(request_params)
+        if final_request_params.mcp_metadata:
+            _mcp_metadata_var.set(final_request_params.mcp_metadata)
+            
         result, assistant_response = await self._apply_prompt_provider_specific_structured(
             multipart_messages, model, request_params
         )

mcp_agent/llm/providers/augmented_llm_bedrock.py

@@ -86,6 +86,7 @@ class BedrockAugmentedLLM(AugmentedLLM[BedrockMessageParam, BedrockMessage]):
             r"^cohere\..*",  # Cohere models
             r"^ai21\..*",  # AI21 models
             r"^stability\..*",  # Stability AI models
+            r"^openai\..*",  # OpenAI models
         ]
 
         import re

mcp_agent/llm/providers/augmented_llm_groq.py

@@ -49,35 +49,22 @@ class GroqAugmentedLLM(OpenAIAugmentedLLM):
         if "object" == json_mode:
             request_params.response_format = {"type": "json_object"}
 
-        # Get the full schema and extract just the properties
-        full_schema = model.model_json_schema()
-        properties = full_schema.get("properties", {})
-        required_fields = full_schema.get("required", [])
-
-        # Create a cleaner format description
-        format_description = "{\n"
-        for field_name, field_info in properties.items():
-            field_type = field_info.get("type", "string")
-            description = field_info.get("description", "")
-            format_description += f'  "{field_name}": "{field_type}"'
-            if description:
-                format_description += f"  // {description}"
-            if field_name in required_fields:
-                format_description += "  // REQUIRED"
-            format_description += "\n"
-        format_description += "}"
-
-        multipart_messages[-1].add_text(
-            f"""YOU MUST RESPOND WITH A JSON OBJECT IN EXACTLY THIS FORMAT:
-            {format_description}
-
-            IMPORTANT RULES:
-            - Respond ONLY with the JSON object, no other text
-            - Do NOT include "properties" or "schema" wrappers
-            - Do NOT use code fences or markdown
-            - The response must be valid JSON that matches the format above
-            - All required fields must be included"""
-        )
+            # Create a cleaner format description from full schema
+            full_schema = model.model_json_schema()
+            format_description = self._schema_to_json_object(
+                full_schema, full_schema.get("$defs")
+            )
+
+            multipart_messages[-1].add_text(
+                f"""YOU MUST RESPOND WITH A JSON OBJECT IN EXACTLY THIS FORMAT:
+{format_description}
+
+IMPORTANT RULES:
+- Respond ONLY with the JSON object, no other text
+- Do NOT include "properties" or "schema" wrappers
+- Do NOT use code fences or markdown
+- The response must be valid JSON that matches the format above
+- All required fields must be included""")
 
         result: PromptMessageMultipart = await self._apply_prompt_provider_specific(
             multipart_messages, request_params
@@ -101,3 +88,45 @@ class GroqAugmentedLLM(OpenAIAugmentedLLM):
             base_url = self.context.config.groq.base_url
 
         return base_url if base_url else GROQ_BASE_URL
+
+    def _schema_to_json_object(
+        self, schema: dict, defs: dict | None = None, visited: set | None = None
+    ) -> str:
+        visited = visited or set()
+
+        if id(schema) in visited:
+            return '"<recursive>"'
+        visited.add(id(schema))
+
+        if "$ref" in schema:
+            ref = schema.get("$ref", "")
+            if ref.startswith("#/$defs/"):
+                target = ref.split("/")[-1]
+                if defs and target in defs:
+                    return self._schema_to_json_object(defs[target], defs, visited)
+            return f'"<ref:{ref}>"'
+
+        schema_type = schema.get("type")
+        description = schema.get("description", "")
+        required = schema.get("required", [])
+
+        if schema_type == "object":
+            props = schema.get("properties", {})
+            result = "{\n"
+            for prop_name, prop_schema in props.items():
+                is_required = prop_name in required
+                prop_str = self._schema_to_json_object(prop_schema, defs, visited)
+                if is_required:
+                    prop_str += " // REQUIRED"
+                result += f'  "{prop_name}": {prop_str},\n'
+            result += "}"
+            return result
+        elif schema_type == "array":
+            items = schema.get("items", {})
+            items_str = self._schema_to_json_object(items, defs, visited)
+            return f"[{items_str}]"
+        elif schema_type:
+            comment = f" // {description}" if description else ""
+            return f'"{schema_type}"' + comment
+
+        return '"<unknown>"'

mcp_agent/llm/providers/augmented_llm_openai.py

@@ -171,7 +171,6 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
     async def _process_stream_manual(self, stream, model: str):
         """Manual stream processing for providers like Ollama that may not work with ChatCompletionStreamState."""
         from openai.types.chat import ChatCompletionMessageToolCall
-        from openai.types.chat.chat_completion_message_tool_call import Function
 
         # Track estimated output tokens by counting text chunks
         estimated_tokens = 0
@@ -249,10 +248,10 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
                         ChatCompletionMessageToolCall(
                             id=tool_call_data["id"],
                             type=tool_call_data["type"],
-                            function=Function(
-                                name=tool_call_data["function"]["name"],
-                                arguments=tool_call_data["function"]["arguments"],
-                            ),
+                            function={
+                                "name": tool_call_data["function"]["name"],
+                                "arguments": tool_call_data["function"]["arguments"],
+                            },
                         )
                     )
 

mcp_agent/mcp/mcp_agent_client_session.py

@@ -14,8 +14,17 @@ from mcp.shared.session import (
     SendRequestT,
 )
 from mcp.types import (
+    CallToolRequest,
+    CallToolRequestParams,
+    CallToolResult,
+    GetPromptRequest,
+    GetPromptRequestParams,
+    GetPromptResult,
     Implementation,
     ListRootsResult,
+    ReadResourceRequest,
+    ReadResourceRequestParams,
+    ReadResourceResult,
     Root,
     ToolListChangedNotification,
 )
@@ -180,8 +189,17 @@ class MCPAgentClientSession(ClientSession, ContextDependent):
             )
             return result
         except Exception as e:
-            logger.error(f"send_request failed: {str(e)}")
-            raise
+            # Handle connection errors cleanly
+            from anyio import ClosedResourceError
+            
+            if isinstance(e, ClosedResourceError):
+                # Show clean offline message and convert to ConnectionError
+                from mcp_agent import console
+                console.console.print(f"[dim red]MCP server {self.session_server_name} offline[/dim red]")
+                raise ConnectionError(f"MCP server {self.session_server_name} offline") from e
+            else:
+                logger.error(f"send_request failed: {str(e)}")
+                raise
 
     async def _received_notification(self, notification: ServerNotification) -> None:
         """
@@ -226,3 +244,88 @@ class MCPAgentClientSession(ClientSession, ContextDependent):
             await self._tool_list_changed_callback(server_name)
         except Exception as e:
             logger.error(f"Error in tool list changed callback: {e}")
+
+    async def call_tool(
+        self, 
+        name: str, 
+        arguments: dict | None = None, 
+        _meta: dict | None = None,
+        **kwargs
+    ) -> CallToolResult:
+        """Call a tool with optional metadata support."""
+        if _meta:
+            from mcp.types import RequestParams
+            
+            # Safe merge - preserve existing meta fields like progressToken
+            existing_meta = kwargs.get('meta')
+            if existing_meta:
+                meta_dict = existing_meta.model_dump() if hasattr(existing_meta, 'model_dump') else {}
+                meta_dict.update(_meta)
+                meta_obj = RequestParams.Meta(**meta_dict)
+            else:
+                meta_obj = RequestParams.Meta(**_meta)
+                
+            # Create CallToolRequestParams without meta, then add _meta via model_dump
+            params = CallToolRequestParams(name=name, arguments=arguments)
+            params_dict = params.model_dump(by_alias=True)
+            params_dict["_meta"] = meta_obj.model_dump()
+            
+            # Create request with proper types
+            request = CallToolRequest(
+                method="tools/call",
+                params=CallToolRequestParams.model_validate(params_dict)
+            )
+            
+            return await self.send_request(request, CallToolResult)
+        else:
+            return await super().call_tool(name, arguments, **kwargs)
+
+    async def read_resource(self, uri: str, _meta: dict | None = None, **kwargs) -> ReadResourceResult:
+        """Read a resource with optional metadata support."""
+        if _meta:
+            from mcp.types import RequestParams
+            
+            # Safe merge - preserve existing meta fields like progressToken
+            existing_meta = kwargs.get('meta')
+            if existing_meta:
+                meta_dict = existing_meta.model_dump() if hasattr(existing_meta, 'model_dump') else {}
+                meta_dict.update(_meta)
+                meta_obj = RequestParams.Meta(**meta_dict)
+            else:
+                meta_obj = RequestParams.Meta(**_meta)
+                
+            request = ReadResourceRequest(
+                method="resources/read",
+                params=ReadResourceRequestParams(uri=uri, meta=meta_obj)
+            )
+            return await self.send_request(request, ReadResourceResult)
+        else:
+            return await super().read_resource(uri, **kwargs)
+
+    async def get_prompt(
+        self, 
+        name: str, 
+        arguments: dict | None = None, 
+        _meta: dict | None = None,
+        **kwargs
+    ) -> GetPromptResult:
+        """Get a prompt with optional metadata support."""
+        if _meta:
+            from mcp.types import RequestParams
+            
+            # Safe merge - preserve existing meta fields like progressToken
+            existing_meta = kwargs.get('meta')
+            if existing_meta:
+                meta_dict = existing_meta.model_dump() if hasattr(existing_meta, 'model_dump') else {}
+                meta_dict.update(_meta)
+                meta_obj = RequestParams.Meta(**meta_dict)
+            else:
+                meta_obj = RequestParams.Meta(**_meta)
+                
+            request = GetPromptRequest(
+                method="prompts/get",
+                params=GetPromptRequestParams(name=name, arguments=arguments, meta=meta_obj)
+            )
+            return await self.send_request(request, GetPromptResult)
+        else:
+            return await super().get_prompt(name, arguments, **kwargs)

mcp_agent/mcp/mcp_aggregator.py

@@ -139,7 +139,10 @@ class MCPAggregator(ContextDependent):
 
     def _create_progress_callback(self, server_name: str, tool_name: str) -> "ProgressFnT":
         """Create a progress callback function for tool execution."""
-        async def progress_callback(progress: float, total: float | None, message: str | None) -> None:
+
+        async def progress_callback(
+            progress: float, total: float | None, message: str | None
+        ) -> None:
             """Handle progress notifications from MCP tool execution."""
             logger.info(
                 "Tool progress update",
@@ -153,6 +156,7 @@ class MCPAggregator(ContextDependent):
                     "details": message or "",  # Put the message in details column
                 },
             )
+
         return progress_callback
 
     async def close(self) -> None:
@@ -508,12 +512,28 @@ class MCPAggregator(ContextDependent):
         async def try_execute(client: ClientSession):
             try:
                 method = getattr(client, method_name)
+
+                # Get metadata from context for tool, resource, and prompt calls
+                metadata = None
+                if method_name in ["call_tool", "read_resource", "get_prompt"]:
+                    from mcp_agent.llm.augmented_llm import _mcp_metadata_var
+
+                    metadata = _mcp_metadata_var.get()
+
+                # Prepare kwargs
+                kwargs = method_args or {}
+                if metadata:
+                    kwargs["_meta"] = metadata
+
                 # For call_tool method, check if we need to add progress_callback
                 if method_name == "call_tool" and progress_callback:
                     # The call_tool method signature includes progress_callback parameter
-                    return await method(**method_args, progress_callback=progress_callback)
+                    return await method(progress_callback=progress_callback, **kwargs)
                 else:
-                    return await method(**method_args)
+                    return await method(**(kwargs or {}))
+            except ConnectionError:
+                # Let ConnectionError pass through for reconnection logic
+                raise
             except Exception as e:
                 error_msg = (
                     f"Failed to {method_name} '{operation_name}' on server '{server_name}': {e}"
@@ -525,34 +545,77 @@ class MCPAggregator(ContextDependent):
                     # Re-raise the original exception to propagate it
                     raise e
 
-        if self.connection_persistence:
-            server_connection = await self._persistent_connection_manager.get_server(
-                server_name, client_session_factory=MCPAgentClientSession
-            )
-            return await try_execute(server_connection.session)
-        else:
-            logger.debug(
-                f"Creating temporary connection to server: {server_name}",
-                data={
-                    "progress_action": ProgressAction.STARTING,
-                    "server_name": server_name,
-                    "agent_name": self.agent_name,
-                },
-            )
-            async with gen_client(
-                server_name, server_registry=self.context.server_registry
-            ) as client:
-                result = await try_execute(client)
+        # Try initial execution
+        try:
+            if self.connection_persistence:
+                server_connection = await self._persistent_connection_manager.get_server(
+                    server_name, client_session_factory=MCPAgentClientSession
+                )
+                return await try_execute(server_connection.session)
+            else:
                 logger.debug(
-                    f"Closing temporary connection to server: {server_name}",
+                    f"Creating temporary connection to server: {server_name}",
                     data={
-                        "progress_action": ProgressAction.SHUTDOWN,
+                        "progress_action": ProgressAction.STARTING,
                         "server_name": server_name,
                         "agent_name": self.agent_name,
                     },
                 )
+                async with gen_client(
+                    server_name, server_registry=self.context.server_registry
+                ) as client:
+                    result = await try_execute(client)
+                    logger.debug(
+                        f"Closing temporary connection to server: {server_name}",
+                        data={
+                            "progress_action": ProgressAction.SHUTDOWN,
+                            "server_name": server_name,
+                            "agent_name": self.agent_name,
+                        },
+                    )
+                    return result
+        except ConnectionError:
+            # Server offline - attempt reconnection
+            from mcp_agent import console
+
+            console.console.print(
+                f"[dim yellow]MCP server {server_name} reconnecting...[/dim yellow]"
+            )
+
+            try:
+                if self.connection_persistence:
+                    # Force disconnect and create fresh connection
+                    await self._persistent_connection_manager.disconnect_server(server_name)
+                    import asyncio
+
+                    await asyncio.sleep(0.1)
+
+                    server_connection = await self._persistent_connection_manager.get_server(
+                        server_name, client_session_factory=MCPAgentClientSession
+                    )
+                    result = await try_execute(server_connection.session)
+                else:
+                    # For non-persistent connections, just try again
+                    async with gen_client(
+                        server_name, server_registry=self.context.server_registry
+                    ) as client:
+                        result = await try_execute(client)
+
+                # Success!
+                console.console.print(f"[dim green]MCP server {server_name} online[/dim green]")
                 return result
 
+            except Exception:
+                # Reconnection failed
+                console.console.print(
+                    f"[dim red]MCP server {server_name} offline - failed to reconnect[/dim red]"
+                )
+                error_msg = f"MCP server {server_name} offline - failed to reconnect"
+                if error_factory:
+                    return error_factory(error_msg)
+                else:
+                    raise Exception(error_msg)
+
     async def _parse_resource_name(self, name: str, resource_type: str) -> tuple[str, str]:
         """
         Parse a possibly namespaced resource name into server name and local resource name.
@@ -572,14 +635,13 @@ class MCPAggregator(ContextDependent):
 
         # Next, attempt to interpret as a namespaced name
         if is_namespaced_name(name):
-            parts = name.split(SEP, 1)
-            server_name, local_name = parts[0], parts[1]
+            # Try to match against known server names, handling server names with hyphens
+            for server_name in self.server_names:
+                if name.startswith(f"{server_name}{SEP}"):
+                    local_name = name[len(server_name) + len(SEP) :]
+                    return server_name, local_name
 
-            # Validate that the parsed server actually exists
-            if server_name in self.server_names:
-                return server_name, local_name
-
-            # If the server name doesn't exist, it might be a tool with a hyphen in its name
+            # If no server name matched, it might be a tool with a hyphen in its name
             # Fall through to the next checks
 
         # For tools, search all servers for the tool by exact name match
@@ -623,10 +685,10 @@ class MCPAggregator(ContextDependent):
         with tracer.start_as_current_span(f"MCP Tool: {server_name}/{local_tool_name}"):
             trace.get_current_span().set_attribute("tool_name", local_tool_name)
             trace.get_current_span().set_attribute("server_name", server_name)
-            
+
             # Create progress callback for this tool execution
             progress_callback = self._create_progress_callback(server_name, local_tool_name)
-            
+
             return await self._execute_on_server(
                 server_name=server_name,
                 operation_type="tool",
@@ -1236,11 +1298,11 @@ class MCPAggregator(ContextDependent):
     async def list_mcp_tools(self, server_name: str | None = None) -> Dict[str, List[Tool]]:
         """
         List available tools from one or all servers, grouped by server name.
-        
+
         Args:
             server_name: Optional server name to list tools from. If not provided,
                         lists tools from all servers.
-        
+
         Returns:
             Dictionary mapping server names to lists of Tool objects (with original names, not namespaced)
         """
@@ -1249,7 +1311,7 @@ class MCPAggregator(ContextDependent):
 
         results: Dict[str, List[Tool]] = {}
 
-        # Get the list of servers to check  
+        # Get the list of servers to check
         servers_to_check = [server_name] if server_name else self.server_names
 
         # For each server, try to list its tools

mcp_agent/mcp/mcp_connection_manager.py

@@ -272,6 +272,7 @@ class MCPConnectionManager(ContextDependent):
         # Manage our own task group - independent of task context
         self._task_group = None
         self._task_group_active = False
+        self._mcp_sse_filter_added = False
 
     async def __aenter__(self):
         # Create a task group that isn't tied to a specific task
@@ -300,6 +301,21 @@ class MCPConnectionManager(ContextDependent):
         except Exception as e:
             logger.error(f"Error during connection manager shutdown: {e}")
 
+    def _suppress_mcp_sse_errors(self) -> None:
+        """Suppress MCP library's 'Error in sse_reader' messages."""
+        if self._mcp_sse_filter_added:
+            return
+            
+        import logging
+        
+        class MCPSSEErrorFilter(logging.Filter):
+            def filter(self, record):
+                return not (record.name == "mcp.client.sse" and "Error in sse_reader" in record.getMessage())
+        
+        mcp_sse_logger = logging.getLogger("mcp.client.sse")
+        mcp_sse_logger.addFilter(MCPSSEErrorFilter())
+        self._mcp_sse_filter_added = True
+
     async def launch_server(
         self,
         server_name: str,
@@ -341,6 +357,9 @@ class MCPConnectionManager(ContextDependent):
                 logger.debug(f"{server_name}: Creating stdio client with custom error handler")
                 return _add_none_to_context(stdio_client(server_params, errlog=error_handler))
             elif config.transport == "sse":
+                # Suppress MCP library error spam
+                self._suppress_mcp_sse_errors()
+                
                 return _add_none_to_context(
                     sse_client(
                         config.url,

mcp_agent/ui/console_display.py

@@ -19,6 +19,61 @@ from mcp_agent.mcp.mcp_aggregator import MCPAggregator
 HUMAN_INPUT_TOOL_NAME = "__human_input__"
 CODE_STYLE = "native"
 
+HTML_ESCAPE_CHARS = {"&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;"}
+
+
+def _prepare_markdown_content(content: str, escape_xml: bool = True) -> str:
+    """Prepare content for markdown rendering by escaping HTML/XML tags
+    while preserving code blocks and inline code.
+
+    This ensures XML/HTML tags are displayed as visible text rather than
+    being interpreted as markup by the markdown renderer.
+
+    Note: This method does not handle overlapping code blocks (e.g., if inline
+    code appears within a fenced code block range). In practice, this is not
+    an issue since markdown syntax doesn't support such overlapping.
+    """
+    if not escape_xml or not isinstance(content, str):
+        return content
+
+    protected_ranges = []
+    import re
+
+    # Protect fenced code blocks (don't escape anything inside these)
+    code_block_pattern = r"```[\s\S]*?```"
+    for match in re.finditer(code_block_pattern, content):
+        protected_ranges.append((match.start(), match.end()))
+
+    # Protect inline code (don't escape anything inside these)
+    inline_code_pattern = r"(?<!`)`(?!``)[^`\n]+`(?!`)"
+    for match in re.finditer(inline_code_pattern, content):
+        protected_ranges.append((match.start(), match.end()))
+
+    protected_ranges.sort(key=lambda x: x[0])
+
+    # Build the escaped content
+    result = []
+    last_end = 0
+
+    for start, end in protected_ranges:
+        # Escape everything outside protected ranges
+        unprotected_text = content[last_end:start]
+        for char, replacement in HTML_ESCAPE_CHARS.items():
+            unprotected_text = unprotected_text.replace(char, replacement)
+        result.append(unprotected_text)
+
+        # Keep protected ranges (code blocks) as-is
+        result.append(content[start:end])
+        last_end = end
+
+    # Escape any remaining content after the last protected range
+    remainder_text = content[last_end:]
+    for char, replacement in HTML_ESCAPE_CHARS.items():
+        remainder_text = remainder_text.replace(char, replacement)
+    result.append(remainder_text)
+
+    return "".join(result)
+
 
 class ConsoleDisplay:
     """
@@ -35,6 +90,49 @@ class ConsoleDisplay:
         """
         self.config = config
         self._markup = config.logger.enable_markup if config else True
+        self._escape_xml = True
+
+    def _render_content_smartly(self, content: str, check_markdown_markers: bool = False) -> None:
+        """
+        Helper method to intelligently render content based on its type.
+
+        - Pure XML: Use syntax highlighting for readability
+        - Markdown (with markers): Use markdown rendering with proper escaping
+        - Plain text: Display as-is (when check_markdown_markers=True and no markers found)
+
+        Args:
+            content: The text content to render
+            check_markdown_markers: If True, only use markdown rendering when markers are present
+        """
+        import re
+
+        from rich.markdown import Markdown
+
+        # Check if content appears to be primarily XML
+        xml_pattern = r"^<[a-zA-Z_][a-zA-Z0-9_-]*[^>]*>"
+        is_xml_content = bool(re.match(xml_pattern, content.strip())) and content.count("<") > 5
+
+        if is_xml_content:
+            # Display XML content with syntax highlighting for better readability
+            from rich.syntax import Syntax
+
+            syntax = Syntax(content, "xml", theme=CODE_STYLE, line_numbers=False)
+            console.console.print(syntax, markup=self._markup)
+        elif check_markdown_markers:
+            # Check for markdown markers before deciding to use markdown rendering
+            if any(marker in content for marker in ["##", "**", "*", "`", "---", "###"]):
+                # Has markdown markers - render as markdown with escaping
+                prepared_content = _prepare_markdown_content(content, self._escape_xml)
+                md = Markdown(prepared_content, code_theme=CODE_STYLE)
+                console.console.print(md, markup=self._markup)
+            else:
+                # Plain text - display as-is
+                console.console.print(content, markup=self._markup)
+        else:
+            # Always treat as markdown with proper escaping
+            prepared_content = _prepare_markdown_content(content, self._escape_xml)
+            md = Markdown(prepared_content, code_theme=CODE_STYLE)
+            console.console.print(md, markup=self._markup)
 
     def show_tool_result(self, result: CallToolResult, name: str | None = None) -> None:
         """Display a tool result in the new visual style."""
@@ -341,7 +439,6 @@ class ConsoleDisplay:
         model: str | None = None,
     ) -> None:
         """Display an assistant message in a formatted panel."""
-        from rich.markdown import Markdown
 
         if not self.config or not self.config.logger.show_chat:
             return
@@ -385,9 +482,8 @@ class ConsoleDisplay:
                 json = JSON(message_text)
                 console.console.print(json, markup=self._markup)
             except (JSONDecodeError, TypeError, ValueError):
-                # Not JSON, treat as markdown
-                md = Markdown(content, code_theme=CODE_STYLE)
-                console.console.print(md, markup=self._markup)
+                # Use the smart rendering helper to handle XML vs Markdown
+                self._render_content_smartly(content)
         else:
             # Handle Rich Text objects directly
             console.console.print(message_text, markup=self._markup)
@@ -475,7 +571,6 @@ class ConsoleDisplay:
         self, message, model: str | None = None, chat_turn: int = 0, name: str | None = None
     ) -> None:
         """Display a user message in the new visual style."""
-        from rich.markdown import Markdown
 
         if not self.config or not self.config.logger.show_chat:
             return
@@ -495,9 +590,8 @@ class ConsoleDisplay:
 
         # Display content as markdown if it looks like markdown, otherwise as text
         if isinstance(message, str):
-            content = message
-            md = Markdown(content, code_theme=CODE_STYLE)
-            console.console.print(md, markup=self._markup)
+            # Use the smart rendering helper to handle XML vs Markdown
+            self._render_content_smartly(message)
         else:
             # Handle Text objects directly
             console.console.print(message, markup=self._markup)
@@ -587,7 +681,7 @@ class ConsoleDisplay:
         Args:
             parallel_agent: The parallel agent containing fan_out_agents with results
         """
-        from rich.markdown import Markdown
+
         from rich.text import Text
 
         if self.config and not self.config.logger.show_chat:
@@ -674,13 +768,9 @@ class ConsoleDisplay:
             console.console.print(left + " " * padding + right, markup=self._markup)
             console.console.print()
 
-            # Display content as markdown if it looks like markdown, otherwise as text
+            # Display content based on its type (check for markdown markers in parallel results)
             content = result["content"]
-            if any(marker in content for marker in ["##", "**", "*", "`", "---", "###"]):
-                md = Markdown(content, code_theme=CODE_STYLE)
-                console.console.print(md, markup=self._markup)
-            else:
-                console.console.print(content, markup=self._markup)
+            self._render_content_smartly(content, check_markdown_markers=True)
 
         # Summary
         console.console.print()