fast-agent-mcp 0.2.18__py3-none-any.whl → 0.2.19__py3-none-any.whl

{fast_agent_mcp-0.2.18.dist-info → fast_agent_mcp-0.2.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.2.18
+Version: 0.2.19
 Summary: Define, Prompt and Test MCP enabled Agents and Workflows
 Author-email: Shaun Smith <fastagent@llmindset.co.uk>, Sarmad Qadri <sarmad@lastmileai.dev>
 License:                                  Apache License
@@ -214,16 +214,16 @@ Requires-Dist: aiohttp>=3.11.13
 Requires-Dist: anthropic>=0.49.0
 Requires-Dist: fastapi>=0.115.6
 Requires-Dist: mcp==1.6.0
-Requires-Dist: numpy>=2.2.1
 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-openai>=0.39.3
 Requires-Dist: prompt-toolkit>=3.0.50
 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: scikit-learn>=1.6.0
 Requires-Dist: typer>=0.15.1
 Provides-Extra: dev
 Requires-Dist: anthropic>=0.42.0; extra == 'dev'
@@ -251,7 +251,7 @@ Description-Content-Type: text/markdown
 ## Overview
 
 > [!TIP]
-> Documentation site is in production here : https://fast-agent.ai. Feel free to feed back what's helpful and what's not. llms.txt link is here: https://fast-agent.ai/llms.txt
+> Documentation site is in production here : https://fast-agent.ai. Feel free to feed back what's helpful and what's not. There is also an LLMs.txt [here](https://fast-agent.ai/llms.txt)
 
 **`fast-agent`** enables you to create and interact with sophisticated Agents and Workflows in minutes. It is the first framework with complete, end-to-end tested MCP Feature support including Sampling. Both Anthropic (Haiku, Sonnet, Opus) and OpenAI models (gpt-4o/gpt-4.1 family, o1/o3 family) are supported.
 
@@ -259,8 +259,8 @@ 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.
 
-> [!TIP]
-> `fast-agent` is now MCP Native! Coming Soon - Full Documentation Site and Further MCP Examples.
+> [!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
 
@@ -450,10 +450,10 @@ If the Generator has `use_history` off, the previous iteration is returned when
 
 ```python
 @fast.evaluator_optimizer(
-  name="researcher"
-  generator="web_searcher"
-  evaluator="quality_assurance"
-  min_rating="EXCELLENT"
+  name="researcher",
+  generator="web_searcher",
+  evaluator="quality_assurance",
+  min_rating="EXCELLENT",
   max_refinements=3
 )
 
@@ -471,8 +471,8 @@ Routers use an LLM to assess a message, and route it to the most appropriate Age
 
 ```python
 @fast.router(
-  name="route"
-  agents["agent1","agent2","agent3"]
+  name="route",
+  agents=["agent1","agent2","agent3"]
 )
 ```
 
@@ -484,7 +484,7 @@ Given a complex task, the Orchestrator uses an LLM to generate a plan to divide
 
 ```python
 @fast.orchestrator(
-  name="orchestrate"
+  name="orchestrate",
   agents=["task1","task2","task3"]
 )
 ```
@@ -524,7 +524,7 @@ agent["greeter"].send("Good Evening!")          # Dictionary access is supported
   servers=["filesystem"],                # list of MCP Servers for the agent
   model="o3-mini.high",                  # specify a model for the agent
   use_history=True,                      # agent maintains chat history
-  request_params=RequestParams(temperature= 0.7)), # additional parameters for the LLM (or RequestParams())
+  request_params=RequestParams(temperature= 0.7), # additional parameters for the LLM (or RequestParams())
   human_input=True,                      # agent can request human input
 )
 ```
@@ -536,7 +536,7 @@ agent["greeter"].send("Good Evening!")          # Dictionary access is supported
   name="chain",                          # name of the chain
   sequence=["agent1", "agent2", ...],    # list of agents in execution order
   instruction="instruction",             # instruction to describe the chain for other workflows
-  cumulative=False                       # whether to accumulate messages through the chain
+  cumulative=False,                      # whether to accumulate messages through the chain
   continue_with_final=True,              # open chat with agent at end of chain after prompting
 )
 ```

{fast_agent_mcp-0.2.18.dist-info → fast_agent_mcp-0.2.19.dist-info}/RECORD

@@ -1,23 +1,23 @@
 mcp_agent/__init__.py,sha256=-AIoeL4c9UAp_P4U0z-uIWTTmQWdihOis5nbQ5L_eao,1664
 mcp_agent/app.py,sha256=WRsiUdwy_9IAnaGRDwuLm7pzgQpt2wgsg10vBOpfcwM,5539
-mcp_agent/config.py,sha256=eEknK8I7DCrh1iGqzva0TemHMzjlbfhFhgwULqaKjDs,12218
+mcp_agent/config.py,sha256=4MB8QBwGb6MPPRc85p-xdCzRloGwpWsPfEgxsoS_4N0,12159
 mcp_agent/console.py,sha256=Gjf2QLFumwG1Lav__c07X_kZxxEUSkzV-1_-YbAwcwo,813
-mcp_agent/context.py,sha256=GEZQ64UCvLj6bRXGNm35Hxd5jxrI_P52vhC3opnWwsg,7246
+mcp_agent/context.py,sha256=fHyDjeZpHYRBOCVY58hVcFQxybOXSJmuui2o51kLbuA,7307
 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=pSD3euU-Oc2LAVenqkLU7UmutAzk6A9liYVLjCj4J70,10068
 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
-mcp_agent/agents/base_agent.py,sha256=c_jhC6tt6LdvS1IY4AVdMNj3n_OtluzHQ1-_NEOseEQ,25039
+mcp_agent/agents/base_agent.py,sha256=fjDr01-hZ9sB3ghI4DlXYVePP0s5f9pmtLH-N3X8bRg,25294
 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_models.py,sha256=5P_aXADVT4Et8qT4e1cb9RelmHX5dCRrzu8j8T41Kdg,7230
 mcp_agent/agents/workflow/orchestrator_prompts.py,sha256=EXKEI174sshkZyPPEnWbwwNafzSPuA39MXL7iqG9cWc,9106
-mcp_agent/agents/workflow/parallel_agent.py,sha256=GQTxAqwrPEdle-rPWMvoLOuzE_X69_HYEgYSm98eXdM,7087
-mcp_agent/agents/workflow/router_agent.py,sha256=NugAJcA1ooZ-TNLNh7H26xIFChZoryxofJ7fTkrw4cU,9128
+mcp_agent/agents/workflow/parallel_agent.py,sha256=JaQFp35nmAdoBRLAwx8BfnK7kirVq9PMw24LQ3ZEzoc,7705
+mcp_agent/agents/workflow/router_agent.py,sha256=yZUUhAmni2wAutQJ32EQ264Uh_MIriVP-AmhKFrYTeQ,9472
 mcp_agent/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_agent/cli/__main__.py,sha256=AVZ7tQFhU_sDOGuUGJq8ujgKtcxsYJBJwHbVaaiRDlI,166
 mcp_agent/cli/main.py,sha256=XjrgXMBaPKkVqAFo8T9LJz6Tp1-ivrKDOuNYWke99YA,3090
@@ -34,21 +34,21 @@ 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=nj2o7T-ClI8ZeUHEr0pSfVxGIkbUffoJ9jT11DNKD_c,20195
+mcp_agent/core/fastagent.py,sha256=OkS1mazgMUJyA02RbW-9z2nI6XQ4kKCLfyjgAkgv0O8,22708
 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/validation.py,sha256=RIBKFlh0GJg4rTcFQXoXp8A0sK1HpsCigKcYSK3gFaY,12090
 mcp_agent/executor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mcp_agent/executor/executor.py,sha256=MzLSnW9nHrLHYChR3oQa5B8dajQGX26q6-S2BJCxv0o,9507
+mcp_agent/executor/executor.py,sha256=E44p6d-o3OMRoP_dNs_cDnyti91LQ3P9eNU88mSi1kc,9462
 mcp_agent/executor/task_registry.py,sha256=PCALFeYtkQrPBg4RBJnlA0aDI8nHclrNkHGUS4kV3W8,1242
 mcp_agent/executor/workflow_signal.py,sha256=Cg1uZBk3fn8kXhPOg-wINNuVaf3v9pvLD6NbqWy5Z6E,11142
 mcp_agent/human_input/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 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=4zKEErhSROrcc1fojCXRFb13UlaOzWvB0jO_XdlcCWM,23378
+mcp_agent/llm/augmented_llm.py,sha256=fP2uWIFY9qaEuY0mehti4A3NjhvGuj-TebLI0FVTbcM,23380
 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
@@ -64,7 +64,7 @@ mcp_agent/llm/providers/augmented_llm_anthropic.py,sha256=poouQMsDoZSH-5a_TL2Z2E
 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=ypK1pDwBKjvdemyEsfzhebinQ6fSAnJS5OUsDVlvdOw,14001
+mcp_agent/llm/providers/augmented_llm_openai.py,sha256=XFFoIMmXCoigC98zrR0_1c7DsyS4ep7hLvklmdn4jqU,14085
 mcp_agent/llm/providers/augmented_llm_openrouter.py,sha256=V_TlVKm92GHBxYIo6gpvH_6cAaIdppS25Tz6x5T7LW0,2341
 mcp_agent/llm/providers/multipart_converter_anthropic.py,sha256=t5lHYGfFUacJldnrVtMNW-8gEMoto8Y7hJkDrnyZR-Y,16650
 mcp_agent/llm/providers/multipart_converter_openai.py,sha256=XPIulWntNpZWNGWrc240StPzok2RqrDAV7OigDwQ1uU,15850
@@ -78,15 +78,14 @@ mcp_agent/logging/json_serializer.py,sha256=qkfxnR9ka6OgvwSpM2CggELbEtzzkApm0s_K
 mcp_agent/logging/listeners.py,sha256=_S4Jp5_KWp0kUfrx4BxDdNCeQK3MNT3Zi9AaolPri7A,6648
 mcp_agent/logging/logger.py,sha256=l02OGX_c5FOyH0rspd4ZvnkJcbb0FahhUhlh2KI8mqE,10724
 mcp_agent/logging/rich_progress.py,sha256=oY9fjb4Tyw6887v8sgO6EGIK4lnmIoR3NNxhA_-Ln_M,4893
-mcp_agent/logging/tracing.py,sha256=d5lSXakzzi5PtQpUkVkOnYaGX8NduGPq__S7vx-Ln8U,5187
 mcp_agent/logging/transport.py,sha256=m8YsLLu5T8eof_ndpLQs4gHOzqqEL98xsVwBwDsBfxI,17335
 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=RMYNltc2pDIzxwEJSS5589RbvPO0KWV4Y3jSyAmhKf0,4181
-mcp_agent/mcp/mcp_aggregator.py,sha256=YVLqcv5dS5Z8yEpQggru69NzqQBFKpXG8_CG0XAN3qk,40219
-mcp_agent/mcp/mcp_connection_manager.py,sha256=FGFF3DruVcHD_8J-VadrRyyrOiiq-N9-_ZzIdx4NUOA,13973
+mcp_agent/mcp/mcp_aggregator.py,sha256=RjRcYHMKt5Wn85JWVar6X0hZLYtBeHrctiBBAK5AYcc,40584
+mcp_agent/mcp/mcp_connection_manager.py,sha256=R_oGvFkolZJ_i3SizIIlKS_NPjXscsWLSOf1x9Zu0dM,14008
 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
@@ -144,8 +143,8 @@ mcp_agent/resources/examples/workflows/parallel.py,sha256=DQ5vY5-h8Qa5QHcYjsWXhZ
 mcp_agent/resources/examples/workflows/router.py,sha256=E4x_-c3l4YW9w1i4ARcDtkdeqIdbWEGfsMzwLYpdbVc,1677
 mcp_agent/resources/examples/workflows/short_story.txt,sha256=X3y_1AyhLFN2AKzCKvucJtDgAFIJfnlbsbGZO5bBWu0,1187
 mcp_agent/ui/console_display.py,sha256=TVGDtJ37hc6UG0ei9g7ZPZZfFNeS1MYozt-Mx8HsPCk,9752
-fast_agent_mcp-0.2.18.dist-info/METADATA,sha256=gFL_3akF6ZiJirx5mn_IxBhdp_wJ4OkJGx5YF2hAu38,29893
-fast_agent_mcp-0.2.18.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fast_agent_mcp-0.2.18.dist-info/entry_points.txt,sha256=bRniFM5zk3Kix5z7scX0gf9VnmGQ2Cz_Q1Gh7Ir4W00,186
-fast_agent_mcp-0.2.18.dist-info/licenses/LICENSE,sha256=cN3FxDURL9XuzE5mhK9L2paZo82LTfjwCYVT7e3j0e4,10939
-fast_agent_mcp-0.2.18.dist-info/RECORD,,
+fast_agent_mcp-0.2.19.dist-info/METADATA,sha256=slU0l8N_MAEEmGn3bla4jeHibkCq3DGTtngvii6xrro,30142
+fast_agent_mcp-0.2.19.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fast_agent_mcp-0.2.19.dist-info/entry_points.txt,sha256=bRniFM5zk3Kix5z7scX0gf9VnmGQ2Cz_Q1Gh7Ir4W00,186
+fast_agent_mcp-0.2.19.dist-info/licenses/LICENSE,sha256=cN3FxDURL9XuzE5mhK9L2paZo82LTfjwCYVT7e3j0e4,10939
+fast_agent_mcp-0.2.19.dist-info/RECORD,,

mcp_agent/agents/base_agent.py

@@ -31,6 +31,7 @@ from mcp.types import (
     TextContent,
     Tool,
 )
+from opentelemetry import trace
 from pydantic import BaseModel
 
 from mcp_agent.core.agent_types import AgentConfig, AgentType
@@ -92,6 +93,7 @@ class BaseAgent(MCPAggregator, AgentProtocol):
         )
 
         self._context = context
+        self.tracer = trace.get_tracer(__name__)
         self.name = self.config.name
         self.instruction = self.config.instruction
         self.functions = functions or []
@@ -588,7 +590,8 @@ class BaseAgent(MCPAggregator, AgentProtocol):
             The LLM's response as a PromptMessageMultipart
         """
         assert self._llm
-        return await self._llm.generate(multipart_messages, request_params)
+        with self.tracer.start_as_current_span(f"Agent: '{self.name}' generate"):
+            return await self._llm.generate(multipart_messages, request_params)
 
     async def structured(
         self,
@@ -609,7 +612,8 @@ class BaseAgent(MCPAggregator, AgentProtocol):
             An instance of the specified model, or None if coercion fails
         """
         assert self._llm
-        return await self._llm.structured(multipart_messages, model, request_params)
+        with self.tracer.start_as_current_span(f"Agent: '{self.name}' structured"):
+            return await self._llm.structured(multipart_messages, model, request_params)
 
     async def apply_prompt_messages(
         self, prompts: List[PromptMessageMultipart], request_params: RequestParams | None = None

mcp_agent/agents/workflow/parallel_agent.py

@@ -2,6 +2,7 @@ import asyncio
 from typing import Any, List, Optional, Tuple
 
 from mcp.types import TextContent
+from opentelemetry import trace
 
 from mcp_agent.agents.agent import Agent
 from mcp_agent.agents.base_agent import BaseAgent
@@ -18,7 +19,7 @@ class ParallelAgent(BaseAgent):
     This workflow performs both the fan-out and fan-in operations using LLMs.
     From the user's perspective, an input is specified and the output is returned.
     """
-    
+
     @property
     def agent_type(self) -> AgentType:
         """Return the type of this agent."""
@@ -62,31 +63,37 @@ class ParallelAgent(BaseAgent):
         Returns:
             The aggregated response from the fan-in agent
         """
-        # Execute all fan-out agents in parallel
-        responses: List[PromptMessageMultipart] = await asyncio.gather(
-            *[agent.generate(multipart_messages, request_params) for agent in self.fan_out_agents]
-        )
 
-        # Extract the received message from the input
-        received_message: Optional[str] = (
-            multipart_messages[-1].all_text() if multipart_messages else None
-        )
+        tracer = trace.get_tracer(__name__)
+        with tracer.start_as_current_span(f"Parallel: '{self.name}' generate"):
+            # Execute all fan-out agents in parallel
+            responses: List[PromptMessageMultipart] = await asyncio.gather(
+                *[
+                    agent.generate(multipart_messages, request_params)
+                    for agent in self.fan_out_agents
+                ]
+            )
 
-        # Convert responses to strings for aggregation
-        string_responses = []
-        for response in responses:
-            string_responses.append(response.all_text())
+            # Extract the received message from the input
+            received_message: Optional[str] = (
+                multipart_messages[-1].all_text() if multipart_messages else None
+            )
 
-        # Format the responses and send to the fan-in agent
-        aggregated_prompt = self._format_responses(string_responses, received_message)
+            # Convert responses to strings for aggregation
+            string_responses = []
+            for response in responses:
+                string_responses.append(response.all_text())
 
-        # Create a new multipart message with the formatted responses
-        formatted_prompt = PromptMessageMultipart(
-            role="user", content=[TextContent(type="text", text=aggregated_prompt)]
-        )
+            # Format the responses and send to the fan-in agent
+            aggregated_prompt = self._format_responses(string_responses, received_message)
+
+            # Create a new multipart message with the formatted responses
+            formatted_prompt = PromptMessageMultipart(
+                role="user", content=[TextContent(type="text", text=aggregated_prompt)]
+            )
 
-        # Use the fan-in agent to aggregate the responses
-        return await self.fan_in_agent.generate([formatted_prompt], request_params)
+            # Use the fan-in agent to aggregate the responses
+            return await self.fan_in_agent.generate([formatted_prompt], request_params)
 
     def _format_responses(self, responses: List[Any], message: Optional[str] = None) -> str:
         """
@@ -116,7 +123,7 @@ class ParallelAgent(BaseAgent):
 
     async def structured(
         self,
-        prompt: List[PromptMessageMultipart],
+        multipart_messages: List[PromptMessageMultipart],
         model: type[ModelT],
         request_params: Optional[RequestParams] = None,
     ) -> Tuple[ModelT | None, PromptMessageMultipart]:
@@ -133,27 +140,35 @@ class ParallelAgent(BaseAgent):
         Returns:
             An instance of the specified model, or None if coercion fails
         """
-        # Generate parallel responses first
-        responses: List[PromptMessageMultipart] = await asyncio.gather(
-            *[agent.generate(prompt, request_params) for agent in self.fan_out_agents]
-        )
 
-        # Extract the received message
-        received_message: Optional[str] = prompt[-1].all_text() if prompt else None
+        tracer = trace.get_tracer(__name__)
+        with tracer.start_as_current_span(f"Parallel: '{self.name}' generate"):
+            # Generate parallel responses first
+            responses: List[PromptMessageMultipart] = await asyncio.gather(
+                *[
+                    agent.generate(multipart_messages, request_params)
+                    for agent in self.fan_out_agents
+                ]
+            )
 
-        # Convert responses to strings
-        string_responses = [response.all_text() for response in responses]
+            # Extract the received message
+            received_message: Optional[str] = (
+                multipart_messages[-1].all_text() if multipart_messages else None
+            )
 
-        # Format the responses for the fan-in agent
-        aggregated_prompt = self._format_responses(string_responses, received_message)
+            # Convert responses to strings
+            string_responses = [response.all_text() for response in responses]
 
-        # Create a multipart message
-        formatted_prompt = PromptMessageMultipart(
-            role="user", content=[TextContent(type="text", text=aggregated_prompt)]
-        )
+            # Format the responses for the fan-in agent
+            aggregated_prompt = self._format_responses(string_responses, received_message)
+
+            # Create a multipart message
+            formatted_prompt = PromptMessageMultipart(
+                role="user", content=[TextContent(type="text", text=aggregated_prompt)]
+            )
 
-        # Use the fan-in agent to parse the structured output
-        return await self.fan_in_agent.structured([formatted_prompt], model, request_params)
+            # Use the fan-in agent to parse the structured output
+            return await self.fan_in_agent.structured([formatted_prompt], model, request_params)
 
     async def initialize(self) -> None:
         """

mcp_agent/agents/workflow/router_agent.py

@@ -7,6 +7,7 @@ by determining the best agent for a request and dispatching to it.
 
 from typing import TYPE_CHECKING, Callable, List, Optional, Tuple, Type
 
+from opentelemetry import trace
 from pydantic import BaseModel
 
 from mcp_agent.agents.agent import Agent
@@ -158,17 +159,18 @@ class RouterAgent(BaseAgent):
         Returns:
             The response from the selected agent
         """
+        tracer = trace.get_tracer(__name__)
+        with tracer.start_as_current_span(f"Routing: '{self.name}' generate"):
+            route, warn = await self._route_request(multipart_messages[-1])
 
-        route, warn = await self._route_request(multipart_messages[-1])
+            if not route:
+                return Prompt.assistant(warn or "No routing result or warning received")
 
-        if not route:
-            return Prompt.assistant(warn or "No routing result or warning received")
+            # Get the selected agent
+            agent: Agent = self.agent_map[route.agent]
 
-        # Get the selected agent
-        agent: Agent = self.agent_map[route.agent]
-
-        # Dispatch the request to the selected agent
-        return await agent.generate(multipart_messages, request_params)
+            # Dispatch the request to the selected agent
+            return await agent.generate(multipart_messages, request_params)
 
     async def structured(
         self,
@@ -187,18 +189,21 @@ class RouterAgent(BaseAgent):
         Returns:
             The parsed response from the selected agent, or None if parsing fails
         """
-        route, warn = await self._route_request(multipart_messages[-1])
 
-        if not route:
-            return None, Prompt.assistant(
-                warn or "No routing result or warning received (structured)"
-            )
+        tracer = trace.get_tracer(__name__)
+        with tracer.start_as_current_span(f"Routing: '{self.name}' structured"):
+            route, warn = await self._route_request(multipart_messages[-1])
+
+            if not route:
+                return None, Prompt.assistant(
+                    warn or "No routing result or warning received (structured)"
+                )
 
-        # Get the selected agent
-        agent: Agent = self.agent_map[route.agent]
+            # Get the selected agent
+            agent: Agent = self.agent_map[route.agent]
 
-        # Dispatch the request to the selected agent
-        return await agent.structured(multipart_messages, model, request_params)
+            # Dispatch the request to the selected agent
+            return await agent.structured(multipart_messages, model, request_params)
 
     async def _route_request(
         self, message: PromptMessageMultipart

mcp_agent/config.py

@@ -181,13 +181,11 @@ class OpenTelemetrySettings(BaseModel):
     OTEL settings for the fast-agent application.
     """
 
-    enabled: bool = True
+    enabled: bool = False
 
     service_name: str = "fast-agent"
-    service_instance_id: str | None = None
-    service_version: str | None = None
 
-    otlp_endpoint: str | None = None
+    otlp_endpoint: str = "http://localhost:4318/v1/traces"
     """OTLP endpoint for OpenTelemetry tracing"""
 
     console_debug: bool = False

mcp_agent/context.py

@@ -9,6 +9,8 @@ from typing import TYPE_CHECKING, Any, Optional, Union
 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.openai import OpenAIInstrumentor
 from opentelemetry.propagate import set_global_textmap
 from opentelemetry.sdk.resources import Resource
 from opentelemetry.sdk.trace import TracerProvider
@@ -51,7 +53,7 @@ class Context(BaseModel):
     server_registry: Optional[ServerRegistry] = None
     task_registry: Optional[ActivityRegistry] = None
 
-    tracer: Optional[trace.Tracer] = None
+    tracer: trace.Tracer | None = None
 
     model_config = ConfigDict(
         extra="allow",
@@ -63,19 +65,19 @@ async def configure_otel(config: "Settings") -> None:
     """
     Configure OpenTelemetry based on the application config.
     """
-    if not config.otel.enabled:
-        return
-
-    # Check if a provider is already set to avoid re-initialization
-    if trace.get_tracer_provider().__class__.__name__ != "NoOpTracerProvider":
+    if not config.otel or not config.otel.enabled:
         return
 
     # Set up global textmap propagator first
     set_global_textmap(TraceContextTextMapPropagator())
 
     service_name = config.otel.service_name
-    service_instance_id = config.otel.service_instance_id
-    service_version = config.otel.service_version
+    from importlib.metadata import version
+
+    try:
+        app_version = version("fast-agent-mcp")
+    except:  # noqa: E722
+        app_version = "unknown"
 
     # Create resource identifying this service
     resource = Resource.create(
@@ -83,8 +85,7 @@ async def configure_otel(config: "Settings") -> None:
             key: value
             for key, value in {
                 "service.name": service_name,
-                "service.instance.id": service_instance_id,
-                "service.version": service_version,
+                "service.version": app_version,
             }.items()
             if value is not None
         }
@@ -107,6 +108,8 @@ async def configure_otel(config: "Settings") -> None:
 
     # Set as global tracer provider
     trace.set_tracer_provider(tracer_provider)
+    AnthropicInstrumentor().instrument()
+    OpenAIInstrumentor().instrument()
 
 
 async def configure_logger(config: "Settings") -> None:

mcp_agent/core/fastagent.py

@@ -13,6 +13,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, TypeVar
 
 import yaml
+from opentelemetry import trace
 
 from mcp_agent import config
 from mcp_agent.app import MCPApp
@@ -76,81 +77,97 @@ class FastAgent:
         name: str,
         config_path: str | None = None,
         ignore_unknown_args: bool = False,
+        parse_cli_args: bool = True,  # Add new parameter with default True
     ) -> None:
         """
-        Initialize the DirectFastAgent application.
+        Initialize the fast-agent application.
 
         Args:
             name: Name of the application
             config_path: Optional path to config file
             ignore_unknown_args: Whether to ignore unknown command line arguments
+                                 when parse_cli_args is True.
+            parse_cli_args: If True, parse command line arguments using argparse.
+                            Set to False when embedding FastAgent in another framework
+                            (like FastAPI/Uvicorn) that handles its own arguments.
         """
-        # Setup command line argument parsing
-        parser = argparse.ArgumentParser(description="DirectFastAgent Application")
-        parser.add_argument(
-            "--model",
-            help="Override the default model for all agents",
-        )
-        parser.add_argument(
-            "--agent",
-            default="default",
-            help="Specify the agent to send a message to (used with --message)",
-        )
-        parser.add_argument(
-            "-m",
-            "--message",
-            help="Message to send to the specified agent",
-        )
-        parser.add_argument(
-            "-p", "--prompt-file", help="Path to a prompt file to use (either text or JSON)"
-        )
-        parser.add_argument(
-            "--quiet",
-            action="store_true",
-            help="Disable progress display, tool and message logging for cleaner output",
-        )
-        parser.add_argument(
-            "--version",
-            action="store_true",
-            help="Show version and exit",
-        )
-        parser.add_argument(
-            "--server",
-            action="store_true",
-            help="Run as an MCP server",
-        )
-        parser.add_argument(
-            "--transport",
-            choices=["sse", "stdio"],
-            default="sse",
-            help="Transport protocol to use when running as a server (sse or stdio)",
-        )
-        parser.add_argument(
-            "--port",
-            type=int,
-            default=8000,
-            help="Port to use when running as a server with SSE transport",
-        )
-        parser.add_argument(
-            "--host",
-            default="0.0.0.0",
-            help="Host address to bind to when running as a server with SSE transport",
-        )
-
-        if ignore_unknown_args:
-            known_args, _ = parser.parse_known_args()
-            self.args = known_args
-        else:
-            self.args = parser.parse_args()
+        self.args = argparse.Namespace()  # Initialize args always
+
+        # --- Wrap argument parsing logic ---
+        if parse_cli_args:
+            # Setup command line argument parsing
+            parser = argparse.ArgumentParser(description="DirectFastAgent Application")
+            parser.add_argument(
+                "--model",
+                help="Override the default model for all agents",
+            )
+            parser.add_argument(
+                "--agent",
+                default="default",
+                help="Specify the agent to send a message to (used with --message)",
+            )
+            parser.add_argument(
+                "-m",
+                "--message",
+                help="Message to send to the specified agent",
+            )
+            parser.add_argument(
+                "-p", "--prompt-file", help="Path to a prompt file to use (either text or JSON)"
+            )
+            parser.add_argument(
+                "--quiet",
+                action="store_true",
+                help="Disable progress display, tool and message logging for cleaner output",
+            )
+            parser.add_argument(
+                "--version",
+                action="store_true",
+                help="Show version and exit",
+            )
+            parser.add_argument(
+                "--server",
+                action="store_true",
+                help="Run as an MCP server",
+            )
+            parser.add_argument(
+                "--transport",
+                choices=["sse", "stdio"],
+                default="sse",
+                help="Transport protocol to use when running as a server (sse or stdio)",
+            )
+            parser.add_argument(
+                "--port",
+                type=int,
+                default=8000,
+                help="Port to use when running as a server with SSE transport",
+            )
+            parser.add_argument(
+                "--host",
+                default="0.0.0.0",
+                help="Host address to bind to when running as a server with SSE transport",
+            )
 
-        # Handle version flag
-        if self.args.version:
-            try:
-                app_version = get_version("fast-agent-mcp")
-            except:  # noqa: E722
-                app_version = "unknown"
-            print(f"fast-agent-mcp v{app_version}")
-            sys.exit(0)
+            if ignore_unknown_args:
+                known_args, _ = parser.parse_known_args()
+                self.args = known_args
+            else:
+                # Use parse_known_args here too, to avoid crashing on uvicorn args etc.
+                # even if ignore_unknown_args is False, we only care about *our* args.
+                known_args, unknown = parser.parse_known_args()
+                self.args = known_args
+                # Optionally, warn about unknown args if not ignoring?
+                # if unknown and not ignore_unknown_args:
+                #     logger.warning(f"Ignoring unknown command line arguments: {unknown}")
+
+            # Handle version flag
+            if self.args.version:
+                try:
+                    app_version = get_version("fast-agent-mcp")
+                except:  # noqa: E722
+                    app_version = "unknown"
+                print(f"fast-agent-mcp v{app_version}")
+                sys.exit(0)
+        # --- End of wrapped logic ---
 
         self.name = name
         self.config_path = config_path
@@ -220,164 +237,175 @@ class FastAgent:
         had_error = False
         await self.app.initialize()
 
-        # Handle quiet mode
-        quiet_mode = hasattr(self, "args") and self.args.quiet
-
-        try:
-            async with self.app.run():
-                # Apply quiet mode if requested
-                if (
-                    quiet_mode
-                    and hasattr(self.app.context, "config")
-                    and hasattr(self.app.context.config, "logger")
-                ):
-                    # Update our app's config directly
-                    self.app.context.config.logger.progress_display = False
-                    self.app.context.config.logger.show_chat = False
-                    self.app.context.config.logger.show_tools = False
-
-                    # Directly disable the progress display singleton
-                    from mcp_agent.progress_display import progress_display
-
-                    progress_display.stop()
-
-                # Pre-flight validation
-                if 0 == len(self.agents):
-                    raise AgentConfigError("No agents defined. Please define at least one agent.")
-                validate_server_references(self.context, self.agents)
-                validate_workflow_references(self.agents)
-
-                # Get a model factory function
-                def model_factory_func(model=None, request_params=None):
-                    return get_model_factory(
-                        self.context,
-                        model=model,
-                        request_params=request_params,
-                        cli_model=self.args.model if hasattr(self, "args") else None,
-                    )
-
-                # Create all agents in dependency order
-                active_agents = await create_agents_in_dependency_order(
-                    self.app,
-                    self.agents,
-                    model_factory_func,
-                )
-
-                # Create a wrapper with all agents for simplified access
-                wrapper = AgentApp(active_agents)
-
-                # Handle command line options that should be processed after agent initialization
-
-                # Handle --server option
-                if hasattr(self, "args") and self.args.server:
-                    try:
-                        # Print info message if not in quiet mode
-                        if not quiet_mode:
-                            print(f"Starting FastAgent '{self.name}' in server mode")
-                            print(f"Transport: {self.args.transport}")
-                            if self.args.transport == "sse":
-                                print(f"Listening on {self.args.host}:{self.args.port}")
-                            print("Press Ctrl+C to stop")
-
-                        # Create the MCP server
-                        from mcp_agent.mcp_server import AgentMCPServer
-
-                        mcp_server = AgentMCPServer(
-                            agent_app=wrapper,
-                            server_name=f"{self.name}-MCP-Server",
-                        )
-
-                        # Run the server directly (this is a blocking call)
-                        await mcp_server.run_async(
-                            transport=self.args.transport, host=self.args.host, port=self.args.port
+        # Handle quiet mode and CLI model override safely
+        # Define these *before* they are used, checking if self.args exists and has the attributes
+        quiet_mode = hasattr(self.args, "quiet") and self.args.quiet
+        cli_model_override = (
+            self.args.model if hasattr(self.args, "model") and self.args.model else None
+        )  # Define cli_model_override here
+        tracer = trace.get_tracer(__name__)
+        with tracer.start_as_current_span(self.name):
+            try:
+                async with self.app.run():
+                    # Apply quiet mode if requested
+                    if (
+                        quiet_mode
+                        and hasattr(self.app.context, "config")
+                        and hasattr(self.app.context.config, "logger")
+                    ):
+                        # Update our app's config directly
+                        self.app.context.config.logger.progress_display = False
+                        self.app.context.config.logger.show_chat = False
+                        self.app.context.config.logger.show_tools = False
+
+                        # Directly disable the progress display singleton
+                        from mcp_agent.progress_display import progress_display
+
+                        progress_display.stop()
+
+                    # Pre-flight validation
+                    if 0 == len(self.agents):
+                        raise AgentConfigError(
+                            "No agents defined. Please define at least one agent."
                         )
-                    except KeyboardInterrupt:
-                        if not quiet_mode:
-                            print("\nServer stopped by user (Ctrl+C)")
-                    except Exception as e:
-                        if not quiet_mode:
-                            print(f"\nServer stopped with error: {e}")
-
-                    # Exit after server shutdown
-                    raise SystemExit(0)
-
-                # Handle direct message sending if  --message is provided
-                if self.args.message:
-                    agent_name = self.args.agent
-                    message = self.args.message
-
-                    if agent_name not in active_agents:
-                        available_agents = ", ".join(active_agents.keys())
-                        print(
-                            f"\n\nError: Agent '{agent_name}' not found. Available agents: {available_agents}"
+                    validate_server_references(self.context, self.agents)
+                    validate_workflow_references(self.agents)
+
+                    # Get a model factory function
+                    # Now cli_model_override is guaranteed to be defined
+                    def model_factory_func(model=None, request_params=None):
+                        return get_model_factory(
+                            self.context,
+                            model=model,
+                            request_params=request_params,
+                            cli_model=cli_model_override,  # Use the variable defined above
                         )
-                        raise SystemExit(1)
 
-                    try:
-                        # Get response from the agent
-                        agent = active_agents[agent_name]
-                        response = await agent.send(message)
-
-                        # In quiet mode, just print the raw response
-                        # The chat display should already be turned off by the configuration
-                        if self.args.quiet:
-                            print(f"{response}")
-
-                        raise SystemExit(0)
-                    except Exception as e:
-                        print(f"\n\nError sending message to agent '{agent_name}': {str(e)}")
-                        raise SystemExit(1)
-
-                if self.args.prompt_file:
-                    agent_name = self.args.agent
-                    prompt: List[PromptMessageMultipart] = load_prompt_multipart(
-                        Path(self.args.prompt_file)
+                    # Create all agents in dependency order
+                    active_agents = await create_agents_in_dependency_order(
+                        self.app,
+                        self.agents,
+                        model_factory_func,
                     )
-                    if agent_name not in active_agents:
-                        available_agents = ", ".join(active_agents.keys())
-                        print(
-                            f"\n\nError: Agent '{agent_name}' not found. Available agents: {available_agents}"
-                        )
-                        raise SystemExit(1)
-
-                    try:
-                        # Get response from the agent
-                        agent = active_agents[agent_name]
-                        response = await agent.generate(prompt)
-
-                        # In quiet mode, just print the raw response
-                        # The chat display should already be turned off by the configuration
-                        if self.args.quiet:
-                            print(f"{response.last_text()}")
 
+                    # Create a wrapper with all agents for simplified access
+                    wrapper = AgentApp(active_agents)
+
+                    # Handle command line options that should be processed after agent initialization
+
+                    # Handle --server option
+                    # Check if parse_cli_args was True before checking self.args.server
+                    if hasattr(self.args, "server") and self.args.server:
+                        try:
+                            # Print info message if not in quiet mode
+                            if not quiet_mode:
+                                print(f"Starting FastAgent '{self.name}' in server mode")
+                                print(f"Transport: {self.args.transport}")
+                                if self.args.transport == "sse":
+                                    print(f"Listening on {self.args.host}:{self.args.port}")
+                                print("Press Ctrl+C to stop")
+
+                            # Create the MCP server
+                            from mcp_agent.mcp_server import AgentMCPServer
+
+                            mcp_server = AgentMCPServer(
+                                agent_app=wrapper,
+                                server_name=f"{self.name}-MCP-Server",
+                            )
+
+                            # Run the server directly (this is a blocking call)
+                            await mcp_server.run_async(
+                                transport=self.args.transport,
+                                host=self.args.host,
+                                port=self.args.port,
+                            )
+                        except KeyboardInterrupt:
+                            if not quiet_mode:
+                                print("\nServer stopped by user (Ctrl+C)")
+                        except Exception as e:
+                            if not quiet_mode:
+                                print(f"\nServer stopped with error: {e}")
+
+                        # Exit after server shutdown
                         raise SystemExit(0)
-                    except Exception as e:
-                        print(f"\n\nError sending message to agent '{agent_name}': {str(e)}")
-                        raise SystemExit(1)
-
-                yield wrapper
-
-        except (
-            ServerConfigError,
-            ProviderKeyError,
-            AgentConfigError,
-            ServerInitializationError,
-            ModelConfigError,
-            CircularDependencyError,
-            PromptExitError,
-        ) as e:
-            had_error = True
-            self._handle_error(e)
-            raise SystemExit(1)
 
-        finally:
-            # Clean up any active agents
-            if active_agents and not had_error:
-                for agent in active_agents.values():
-                    try:
-                        await agent.shutdown()
-                    except Exception:
-                        pass
+                    # Handle direct message sending if  --message is provided
+                    if self.args.message:
+                        agent_name = self.args.agent
+                        message = self.args.message
+
+                        if agent_name not in active_agents:
+                            available_agents = ", ".join(active_agents.keys())
+                            print(
+                                f"\n\nError: Agent '{agent_name}' not found. Available agents: {available_agents}"
+                            )
+                            raise SystemExit(1)
+
+                        try:
+                            # Get response from the agent
+                            agent = active_agents[agent_name]
+                            response = await agent.send(message)
+
+                            # In quiet mode, just print the raw response
+                            # The chat display should already be turned off by the configuration
+                            if self.args.quiet:
+                                print(f"{response}")
+
+                            raise SystemExit(0)
+                        except Exception as e:
+                            print(f"\n\nError sending message to agent '{agent_name}': {str(e)}")
+                            raise SystemExit(1)
+
+                    if self.args.prompt_file:
+                        agent_name = self.args.agent
+                        prompt: List[PromptMessageMultipart] = load_prompt_multipart(
+                            Path(self.args.prompt_file)
+                        )
+                        if agent_name not in active_agents:
+                            available_agents = ", ".join(active_agents.keys())
+                            print(
+                                f"\n\nError: Agent '{agent_name}' not found. Available agents: {available_agents}"
+                            )
+                            raise SystemExit(1)
+
+                        try:
+                            # Get response from the agent
+                            agent = active_agents[agent_name]
+                            response = await agent.generate(prompt)
+
+                            # In quiet mode, just print the raw response
+                            # The chat display should already be turned off by the configuration
+                            if self.args.quiet:
+                                print(f"{response.last_text()}")
+
+                            raise SystemExit(0)
+                        except Exception as e:
+                            print(f"\n\nError sending message to agent '{agent_name}': {str(e)}")
+                            raise SystemExit(1)
+
+                    yield wrapper
+
+            except (
+                ServerConfigError,
+                ProviderKeyError,
+                AgentConfigError,
+                ServerInitializationError,
+                ModelConfigError,
+                CircularDependencyError,
+                PromptExitError,
+            ) as e:
+                had_error = True
+                self._handle_error(e)
+                raise SystemExit(1)
+
+            finally:
+                # Clean up any active agents
+                if active_agents and not had_error:
+                    for agent in active_agents.values():
+                        try:
+                            await agent.shutdown()
+                        except Exception:
+                            pass
 
     def _handle_error(self, e: Exception, error_type: Optional[str] = None) -> None:
         """

mcp_agent/executor/executor.py

@@ -1,4 +1,5 @@
 import asyncio
+import contextvars
 import functools
 from abc import ABC, abstractmethod
 from contextlib import asynccontextmanager
@@ -206,13 +207,13 @@ class AsyncioExecutor(Executor):
                 else:
                     # Execute the callable and await if it returns a coroutine
                     loop = asyncio.get_running_loop()
-
+                    ctx = contextvars.copy_context()
                     # If kwargs are provided, wrap the function with partial
                     if kwargs:
                         wrapped_task = functools.partial(task, **kwargs)
-                        result = await loop.run_in_executor(None, wrapped_task)
+                        result = await loop.run_in_executor(None, lambda: ctx.run(wrapped_task))
                     else:
-                        result = await loop.run_in_executor(None, task)
+                        result = await loop.run_in_executor(None, lambda: ctx.run(task))
 
                     # Handle case where the sync function returns a coroutine
                     if asyncio.iscoroutine(result):
@@ -234,12 +235,10 @@ class AsyncioExecutor(Executor):
         *tasks: Callable[..., R] | Coroutine[Any, Any, R],
         **kwargs: Any,
     ) -> List[R | BaseException]:
-        # TODO: saqadri - validate if async with self.execution_context() is needed here
-        async with self.execution_context():
-            return await asyncio.gather(
-                *(self._execute_task(task, **kwargs) for task in tasks),
-                return_exceptions=True,
-            )
+        return await asyncio.gather(
+            *(self._execute_task(task, **kwargs) for task in tasks),
+            return_exceptions=True,
+        )
 
     async def execute_streaming(
         self,

mcp_agent/llm/augmented_llm.py

@@ -171,6 +171,7 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
         # We never expect this for structured() calls - this is for interactive use - developers
         # can do this programatically
         # TODO -- create a "fast-agent" control role rather than magic strings
+
         if multipart_messages[-1].first_text().startswith("***SAVE_HISTORY"):
             parts: list[str] = multipart_messages[-1].first_text().split(" ", 1)
             filename: str = (
@@ -220,6 +221,7 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
         request_params: RequestParams | None = None,
     ) -> Tuple[ModelT | None, PromptMessageMultipart]:
         """Return a structured response from the LLM using the provided messages."""
+
         self._precall(multipart_messages)
         result, assistant_response = await self._apply_prompt_provider_specific_structured(
             multipart_messages, model, request_params

mcp_agent/llm/providers/augmented_llm_openai.py

@@ -222,7 +222,10 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
                         method="tools/call",
                         params=CallToolRequestParams(
                             name=tool_call.function.name,
-                            arguments={} if not tool_call.function.arguments or tool_call.function.arguments.strip() == '' else from_json(tool_call.function.arguments, allow_partial=True),
+                            arguments={}
+                            if not tool_call.function.arguments
+                            or tool_call.function.arguments.strip() == ""
+                            else from_json(tool_call.function.arguments, allow_partial=True),
                         ),
                     )
                     result = await self.call_tool(tool_call_request, tool_call.id)

mcp_agent/mcp/mcp_aggregator.py

@@ -21,6 +21,7 @@ from mcp.types import (
     TextContent,
     Tool,
 )
+from opentelemetry import trace
 from pydantic import AnyUrl, BaseModel, ConfigDict
 
 from mcp_agent.context_dependent import ContextDependent
@@ -469,16 +470,20 @@ class MCPAggregator(ContextDependent):
             },
         )
 
-        return await self._execute_on_server(
-            server_name=server_name,
-            operation_type="tool",
-            operation_name=local_tool_name,
-            method_name="call_tool",
-            method_args={"name": local_tool_name, "arguments": arguments},
-            error_factory=lambda msg: CallToolResult(
-                isError=True, content=[TextContent(type="text", text=msg)]
-            ),
-        )
+        tracer = trace.get_tracer(__name__)
+        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)
+            return await self._execute_on_server(
+                server_name=server_name,
+                operation_type="tool",
+                operation_name=local_tool_name,
+                method_name="call_tool",
+                method_args={"name": local_tool_name, "arguments": arguments},
+                error_factory=lambda msg: CallToolResult(
+                    isError=True, content=[TextContent(type="text", text=msg)]
+                ),
+            )
 
     async def get_prompt(
         self,

mcp_agent/mcp/mcp_connection_manager.py

@@ -262,7 +262,7 @@ class MCPConnectionManager(ContextDependent):
             if config.transport == "stdio":
                 server_params = StdioServerParameters(
                     command=config.command,
-                    args=config.args,
+                    args=config.args if config.args is not None else [],
                     env={**get_default_environment(), **(config.env or {})},
                 )
                 # Create custom error handler to ensure all output is captured

mcp_agent/logging/tracing.py

@@ -1,138 +0,0 @@
-"""
-Telemetry manager that defines distributed tracing decorators for OpenTelemetry traces/spans
-for the Logger module for MCP Agent
-"""
-
-import asyncio
-import functools
-from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Tuple
-
-from opentelemetry import trace
-from opentelemetry.context import Context as OtelContext
-from opentelemetry.propagate import extract as otel_extract
-from opentelemetry.trace import SpanKind, Status, StatusCode, set_span_in_context
-from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
-
-from mcp_agent.context_dependent import ContextDependent
-
-if TYPE_CHECKING:
-    from mcp_agent.context import Context
-
-
-class TelemetryManager(ContextDependent):
-    """
-    Simple manager for creating OpenTelemetry spans automatically.
-    Decorator usage: @telemetry.traced("SomeSpanName")
-    """
-
-    def __init__(self, context: Optional["Context"] = None, **kwargs) -> None:
-        # If needed, configure resources, exporters, etc.
-        # E.g.: from opentelemetry.sdk.trace import TracerProvider
-        # trace.set_tracer_provider(TracerProvider(...))
-        super().__init__(context=context, **kwargs)
-
-    def traced(
-        self,
-        name: str | None = None,
-        kind: SpanKind = SpanKind.INTERNAL,
-        attributes: Dict[str, Any] = None,
-    ) -> Callable:
-        """
-        Decorator that automatically creates and manages a span for a function.
-        Works for both async and sync functions.
-        """
-
-        def decorator(func):
-            span_name = name or f"{func.__module__}.{func.__qualname__}"
-
-            tracer = self.context.tracer or trace.get_tracer("mcp_agent")
-
-            @functools.wraps(func)
-            async def async_wrapper(*args, **kwargs):
-                with tracer.start_as_current_span(span_name, kind=kind) as span:
-                    if attributes:
-                        for k, v in attributes.items():
-                            span.set_attribute(k, v)
-                    # Record simple args
-                    self._record_args(span, args, kwargs)
-                    try:
-                        res = await func(*args, **kwargs)
-                        return res
-                    except Exception as e:
-                        span.record_exception(e)
-                        span.set_status(Status(StatusCode.ERROR))
-                        raise
-
-            @functools.wraps(func)
-            def sync_wrapper(*args, **kwargs):
-                with tracer.start_as_current_span(span_name, kind=kind) as span:
-                    if attributes:
-                        for k, v in attributes.items():
-                            span.set_attribute(k, v)
-                    # Record simple args
-                    self._record_args(span, args, kwargs)
-                    try:
-                        res = func(*args, **kwargs)
-                        return res
-                    except Exception as e:
-                        span.record_exception(e)
-                        span.set_status(Status(StatusCode.ERROR))
-                        raise
-
-            if asyncio.iscoroutinefunction(func):
-                return async_wrapper
-            else:
-                return sync_wrapper
-
-        return decorator
-
-    def _record_args(self, span, args, kwargs) -> None:
-        """Optionally record primitive args as span attributes."""
-        for i, arg in enumerate(args):
-            if isinstance(arg, (str, int, float, bool)):
-                span.set_attribute(f"arg_{i}", str(arg))
-        for k, v in kwargs.items():
-            if isinstance(v, (str, int, float, bool)):
-                span.set_attribute(k, str(v))
-
-
-class MCPRequestTrace:
-    """Helper class for trace context propagation in MCP"""
-
-    @staticmethod
-    def start_span_from_mcp_request(
-        method: str, params: Dict[str, Any]
-    ) -> Tuple[trace.Span, OtelContext]:
-        """Extract trace context from incoming MCP request and start a new span"""
-        # Extract trace context from _meta if present
-        carrier = {}
-        _meta = params.get("_meta", {})
-        if "traceparent" in _meta:
-            carrier["traceparent"] = _meta["traceparent"]
-        if "tracestate" in _meta:
-            carrier["tracestate"] = _meta["tracestate"]
-
-        # Extract context and start span
-        ctx = otel_extract(carrier, context=OtelContext())
-        tracer = trace.get_tracer(__name__)
-        span = tracer.start_span(method, context=ctx, kind=SpanKind.SERVER)
-        return span, set_span_in_context(span)
-
-    @staticmethod
-    def inject_trace_context(arguments: Dict[str, Any]) -> Dict[str, Any]:
-        """Inject current trace context into outgoing MCP request arguments"""
-        carrier = {}
-        TraceContextTextMapPropagator().inject(carrier)
-
-        # Create or update _meta with trace context
-        _meta = arguments.get("_meta", {})
-        if "traceparent" in carrier:
-            _meta["traceparent"] = carrier["traceparent"]
-        if "tracestate" in carrier:
-            _meta["tracestate"] = carrier["tracestate"]
-        arguments["_meta"] = _meta
-
-        return arguments
-
-
-telemetry = TelemetryManager()