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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.2.23
+Version: 0.2.25
 Summary: Define, Prompt and Test MCP enabled Agents and Workflows
 Author-email: Shaun Smith <fastagent@llmindset.co.uk>
 License:                                  Apache License
@@ -212,13 +212,15 @@ Requires-Python: >=3.10
 Requires-Dist: a2a-types>=0.1.0
 Requires-Dist: aiohttp>=3.11.13
 Requires-Dist: anthropic>=0.49.0
+Requires-Dist: azure-identity>=1.14.0
 Requires-Dist: fastapi>=0.115.6
 Requires-Dist: mcp>=1.8.0
 Requires-Dist: openai>=1.63.2
 Requires-Dist: opentelemetry-distro>=0.50b0
 Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.29.0
-Requires-Dist: opentelemetry-instrumentation-anthropic>=0.39.3
-Requires-Dist: opentelemetry-instrumentation-openai>=0.39.3
+Requires-Dist: opentelemetry-instrumentation-anthropic>=0.39.3; python_version >= '3.10' and python_version < '4.0'
+Requires-Dist: opentelemetry-instrumentation-mcp>=0.40.3; python_version >= '3.10' and python_version < '4.0'
+Requires-Dist: opentelemetry-instrumentation-openai>=0.39.3; python_version >= '3.10' and python_version < '4.0'
 Requires-Dist: prompt-toolkit>=3.0.50
 Requires-Dist: pydantic-settings>=2.7.0
 Requires-Dist: pydantic>=2.10.4
@@ -226,6 +228,8 @@ Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: rich>=13.9.4
 Requires-Dist: tensorzero>=2025.4.7
 Requires-Dist: typer>=0.15.1
+Provides-Extra: 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'

{fast_agent_mcp-0.2.23.dist-info → fast_agent_mcp-0.2.25.dist-info}/RECORD

@@ -1,10 +1,10 @@
 mcp_agent/__init__.py,sha256=18T0AG0W9sJhTY38O9GFFOzliDhxx9p87CvRyti9zbw,1620
 mcp_agent/app.py,sha256=WRsiUdwy_9IAnaGRDwuLm7pzgQpt2wgsg10vBOpfcwM,5539
-mcp_agent/config.py,sha256=L_wUWTdqFXaRTBA5tL_j2l_9dufWE_MHHPut5e89lBk,12773
+mcp_agent/config.py,sha256=0a6P_nvr6fhBLMjk1XsfQuS_wVO1dmQ1sJR5RQdf5FA,13321
 mcp_agent/console.py,sha256=Gjf2QLFumwG1Lav__c07X_kZxxEUSkzV-1_-YbAwcwo,813
-mcp_agent/context.py,sha256=Kb3s_0MolHx7AeTs1NVcY3ly-xFBd35o8LT7Srpx9is,7334
+mcp_agent/context.py,sha256=5pnw78LgezCLeO5Os5dgmLDadwXqw_B4Ojib48XP1s4,7431
 mcp_agent/context_dependent.py,sha256=QXfhw3RaQCKfscEEBRGuZ3sdMWqkgShz2jJ1ivGGX1I,1455
-mcp_agent/event_progress.py,sha256=b1VKlQQF2AgPMb6XHjlJAVoPdx8GuxRTUk2g-4lBNm0,2749
+mcp_agent/event_progress.py,sha256=040lrCCclcOuryi07YGSej25kTQF5_JMXY12Yj-3u1U,2773
 mcp_agent/mcp_server_registry.py,sha256=QTzu0elBWzqXks6u5nI5n8uN5CX8CpyV6ybxnyt5LZM,11531
 mcp_agent/progress_display.py,sha256=GeJU9VUt6qKsFVymG688hCMVCsAygG9ifiiEb5IcbN4,361
 mcp_agent/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -22,7 +22,7 @@ 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
 mcp_agent/cli/terminal.py,sha256=GRwD-RGW7saIz2IOWZn5vD6JjiArscELBThm1GTFkuI,1065
-mcp_agent/cli/commands/check_config.py,sha256=9Ryxo_fLInm3YKdYv46yLrAJgnQtMisGreu6Kkriw2g,16677
+mcp_agent/cli/commands/check_config.py,sha256=KJbXUFx5Qih3lb_r-Fcx_uAjgHhgD7qqPewQtIDofKM,18321
 mcp_agent/cli/commands/go.py,sha256=LIsOJQuTdfCUcNm7JT-NQDU8cI-GCnYwYjN2VOWxvqs,8658
 mcp_agent/cli/commands/quickstart.py,sha256=SM3CHMzDgvTxIpKjFuX9BrS_N1vRoXNBDaO90aWx1Rk,14586
 mcp_agent/cli/commands/setup.py,sha256=eOEd4TL-b0DaDeSJMGOfNOsTEItoZ67W88eTP4aP-bo,6482
@@ -53,19 +53,20 @@ mcp_agent/llm/augmented_llm.py,sha256=CqtSGo_QrHE73tz_DHMd0wdt2F41gwuUu5Bue51FNm
 mcp_agent/llm/augmented_llm_passthrough.py,sha256=zHcctNpwg4EFJvD1x9Eg443SVX-uyzFphLikwF_yVE0,6288
 mcp_agent/llm/augmented_llm_playback.py,sha256=6L_RWIK__R67oZK7u3Xt3hWy1T2LnHXIO-efqgP3tPw,4177
 mcp_agent/llm/memory.py,sha256=HQ_c1QemOUjrkY6Z2omE6BG5fXga7y4jN7KCMOuGjPs,3345
-mcp_agent/llm/model_factory.py,sha256=h3NJSa0yPa9iiLojEqBhIm9wgEBB46ZBibe44MnskHM,8089
+mcp_agent/llm/model_factory.py,sha256=vKR4wI0cDElMc4JSE-WuLXTarAZsi9-5I7B9wUbI6c4,8218
 mcp_agent/llm/prompt_utils.py,sha256=yWQHykoK13QRF7evHUKxVF0SpVLN-Bsft0Yixzvn0g0,4825
 mcp_agent/llm/provider_key_manager.py,sha256=-K_FuibN6hdSnweT32lB8mKTfCARnbja6zYYs0ErTKg,2802
-mcp_agent/llm/provider_types.py,sha256=oWwXTlyr6hIzU_QLJ5T-UwxZGo5e4Pjwtahz2cr1PHg,364
+mcp_agent/llm/provider_types.py,sha256=m7vAQA0MSn4iVCoHQYwZ8pK8nW4iVLxp_Ul1JpnXMpY,408
 mcp_agent/llm/sampling_converter.py,sha256=C7wPBlmT0eD90XWabC22zkxsrVHKCrjwIwg6cG628cI,2926
 mcp_agent/llm/sampling_format_converter.py,sha256=xGz4odHpOcP7--eFaJaFtUR8eR9jxZS7MnLH6J7n0EU,1263
 mcp_agent/llm/providers/__init__.py,sha256=heVxtmuqFJOnjjxHz4bWSqTAxXoN1E8twC_gQ_yJpHk,265
 mcp_agent/llm/providers/anthropic_utils.py,sha256=vYDN5G5jKMhD2CQg8veJYab7tvvzYkDMq8M1g_hUAQg,3275
 mcp_agent/llm/providers/augmented_llm_anthropic.py,sha256=gK_IvllVBNJUUrSfpgFpdhM-d4liCt0MLq7d2lXS7RI,15510
+mcp_agent/llm/providers/augmented_llm_azure.py,sha256=VPrD6lNrEw6EdYUTa9MDvHDNIPjJU5CG5xnKCM3JYdA,5878
 mcp_agent/llm/providers/augmented_llm_deepseek.py,sha256=NiZK5nv91ZS2VgVFXpbsFNFYLsLcppcbo_RstlRMd7I,1145
 mcp_agent/llm/providers/augmented_llm_generic.py,sha256=5Uq8ZBhcFuQTt7koP_5ykolREh2iWu8zKhNbh3pM9lQ,1210
 mcp_agent/llm/providers/augmented_llm_google.py,sha256=N0a2fphVtkvNYxKQpEX6J4tlO1C_mRw4sw3LBXnrOeI,1130
-mcp_agent/llm/providers/augmented_llm_openai.py,sha256=0C7BOB7i3xo0HsMCTagRSQ8Hsywb-31mot26OfohzCU,14478
+mcp_agent/llm/providers/augmented_llm_openai.py,sha256=5CFHKayjm-aeCBpohIK3WelAEuX7_LDGZIKnWR_rq-s,14577
 mcp_agent/llm/providers/augmented_llm_openrouter.py,sha256=V_TlVKm92GHBxYIo6gpvH_6cAaIdppS25Tz6x5T7LW0,2341
 mcp_agent/llm/providers/augmented_llm_tensorzero.py,sha256=Mol_Wzj_ZtccW-LMw0oFwWUt1m1yfofloay9QYNP23c,20729
 mcp_agent/llm/providers/multipart_converter_anthropic.py,sha256=t5lHYGfFUacJldnrVtMNW-8gEMoto8Y7hJkDrnyZR-Y,16650
@@ -83,11 +84,12 @@ mcp_agent/logging/logger.py,sha256=l02OGX_c5FOyH0rspd4ZvnkJcbb0FahhUhlh2KI8mqE,1
 mcp_agent/logging/rich_progress.py,sha256=oY9fjb4Tyw6887v8sgO6EGIK4lnmIoR3NNxhA_-Ln_M,4893
 mcp_agent/logging/transport.py,sha256=m8YsLLu5T8eof_ndpLQs4gHOzqqEL98xsVwBwDsBfxI,17335
 mcp_agent/mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mcp_agent/mcp/common.py,sha256=DiWLH9rxWvCgkKRsHQehY9mDhQl9gki1-q7LVUflDvI,425
 mcp_agent/mcp/gen_client.py,sha256=fAVwFVCgSamw4PwoWOV4wrK9TABx1S_zZv8BctRyF2k,3030
 mcp_agent/mcp/interfaces.py,sha256=PAou8znAl2HgtvfCpLQOZFbKra9F72OcVRfBJbboNX8,6965
 mcp_agent/mcp/logger_textio.py,sha256=vljC1BtNTCxBAda9ExqNB-FwVNUZIuJT3h1nWmCjMws,3172
-mcp_agent/mcp/mcp_agent_client_session.py,sha256=Ng7epBXq8BEA_3m1GX5LqwafgNUAMSzBugwN6N0VUWQ,4364
-mcp_agent/mcp/mcp_aggregator.py,sha256=lVSt0yp0CnaYjcHCWmluwBeFgl8JXHYEZk0MzXgrQzA,40110
+mcp_agent/mcp/mcp_agent_client_session.py,sha256=4597ww1ihSKh-zKc9xMF3ODqosVPU_A4xVmUbk1DvcE,6002
+mcp_agent/mcp/mcp_aggregator.py,sha256=KAtQTg6CBpTiHoMg6NKcMSiJ7Cvl-BgS0Lff784qwrs,46063
 mcp_agent/mcp/mcp_connection_manager.py,sha256=jlqaAdS4zc1UfVBHQU0TkTbVr0-rOkbN9bkrLPrZVLk,17159
 mcp_agent/mcp/mime_utils.py,sha256=difepNR_gpb4MpMLkBRAoyhDk-AjXUHTiqKvT_VwS1o,1805
 mcp_agent/mcp/prompt_message_multipart.py,sha256=BDwRdNwyWHb2q2bccDb2iR2VlORqVvkvoG3xYzcMpCE,4403
@@ -145,9 +147,9 @@ mcp_agent/resources/examples/workflows/orchestrator.py,sha256=rOGilFTliWWnZ3Jx5w
 mcp_agent/resources/examples/workflows/parallel.py,sha256=DQ5vY5-h8Qa5QHcYjsWXhZ_FYrYoloVWOdgeXV9p2gI,1890
 mcp_agent/resources/examples/workflows/router.py,sha256=E4x_-c3l4YW9w1i4ARcDtkdeqIdbWEGfsMzwLYpdbVc,1677
 mcp_agent/resources/examples/workflows/short_story.txt,sha256=X3y_1AyhLFN2AKzCKvucJtDgAFIJfnlbsbGZO5bBWu0,1187
-mcp_agent/ui/console_display.py,sha256=EUeMJ7yqtxJ0-hAjXNZFJFTlmfyKlENdfzTlw0e5ETg,9949
-fast_agent_mcp-0.2.23.dist-info/METADATA,sha256=Vtk96ocWT3Xk_Y8f3ZLUILhh2aybr8OebCPn5jZeZOY,30156
-fast_agent_mcp-0.2.23.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fast_agent_mcp-0.2.23.dist-info/entry_points.txt,sha256=bRniFM5zk3Kix5z7scX0gf9VnmGQ2Cz_Q1Gh7Ir4W00,186
-fast_agent_mcp-0.2.23.dist-info/licenses/LICENSE,sha256=cN3FxDURL9XuzE5mhK9L2paZo82LTfjwCYVT7e3j0e4,10939
-fast_agent_mcp-0.2.23.dist-info/RECORD,,
+mcp_agent/ui/console_display.py,sha256=UKqax5V2TC0hkZZORmmd6UqUk0DGX7A25E3h1k9f42k,10982
+fast_agent_mcp-0.2.25.dist-info/METADATA,sha256=V-sL9gUnTgSUvsV2plQm3Spj4nJAnKYjermxRjIPCxc,30488
+fast_agent_mcp-0.2.25.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fast_agent_mcp-0.2.25.dist-info/entry_points.txt,sha256=bRniFM5zk3Kix5z7scX0gf9VnmGQ2Cz_Q1Gh7Ir4W00,186
+fast_agent_mcp-0.2.25.dist-info/licenses/LICENSE,sha256=cN3FxDURL9XuzE5mhK9L2paZo82LTfjwCYVT7e3j0e4,10939
+fast_agent_mcp-0.2.25.dist-info/RECORD,,

mcp_agent/cli/commands/check_config.py

@@ -92,42 +92,73 @@ def get_secrets_summary(secrets_path: Optional[Path]) -> dict:
     return result
 
 
-def check_api_keys(secrets_summary: dict) -> dict:
-    """Check if API keys are configured in secrets file or environment."""
+def check_api_keys(secrets_summary: dict, config_summary: dict) -> dict:
+    """Check if API keys are configured in secrets file or environment, including Azure DefaultAzureCredential.
+    Now also checks Azure config in main config file for retrocompatibility.
+    """
     import os
 
-    # Initialize results dict using Provider enum values
     results = {
-        provider.value: {"env": None, "config": None}
+        provider.value: {"env": "", "config": ""}
         for provider in Provider
         if provider != Provider.FAST_AGENT
-    }  # Include GENERIC but exclude FAST_AGENT
+    }
 
     # Get secrets if available
     secrets = secrets_summary.get("secrets", {})
     secrets_status = secrets_summary.get("status", "not_found")
+    # Get config if available
+    config = config_summary if config_summary.get("status") == "parsed" else {}
+    config_azure = {}
+    if config and "azure" in config.get("config", {}):
+        config_azure = config["config"]["azure"]
 
-    # Check both environment variables and config file for each provider
     for provider_value in results:
-        # Check environment variables using ProviderKeyManager
-        env_key_name = ProviderKeyManager.get_env_key_name(provider_value)
-        env_key_value = os.environ.get(env_key_name)
-        if env_key_value:
-            # Store the last 5 characters if key is long enough
-            if len(env_key_value) > 5:
-                results[provider_value]["env"] = f"...{env_key_value[-5:]}"
-            else:
-                results[provider_value]["env"] = "...***"
-
-        # Check secrets file if it was parsed successfully
-        if secrets_status == "parsed":
-            config_key = ProviderKeyManager.get_config_file_key(provider_value, secrets)
-            if config_key and config_key != API_KEY_HINT_TEXT:
-                # Store the last 5 characters if key is long enough
-                if len(config_key) > 5:
-                    results[provider_value]["config"] = f"...{config_key[-5:]}"
+        # Special handling for Azure: support api_key and DefaultAzureCredential
+        if provider_value == "azure":
+            # Prefer secrets if present, else fallback to config
+            azure_cfg = {}
+            if secrets_status == "parsed" and "azure" in secrets:
+                azure_cfg = secrets.get("azure", {})
+            elif config_azure:
+                azure_cfg = config_azure
+
+            use_default_cred = azure_cfg.get("use_default_azure_credential", False)
+            base_url = azure_cfg.get("base_url")
+            api_key = azure_cfg.get("api_key")
+            # DefaultAzureCredential mode
+            if use_default_cred and base_url:
+                results[provider_value]["config"] = "DefaultAzureCredential"
+            # API key mode (retrocompatible)
+            if api_key and api_key != API_KEY_HINT_TEXT:
+                if len(api_key) > 5:
+                    if results[provider_value]["config"]:
+                        results[provider_value]["config"] += " + api_key"
+                    else:
+                        results[provider_value]["config"] = f"...{api_key[-5:]}"
                 else:
-                    results[provider_value]["config"] = "...***"
+                    if results[provider_value]["config"]:
+                        results[provider_value]["config"] += " + api_key"
+                    else:
+                        results[provider_value]["config"] = "...***"
+        else:
+            # Check environment variables using ProviderKeyManager
+            env_key_name = ProviderKeyManager.get_env_key_name(provider_value)
+            env_key_value = os.environ.get(env_key_name)
+            if env_key_value:
+                if len(env_key_value) > 5:
+                    results[provider_value]["env"] = f"...{env_key_value[-5:]}"
+                else:
+                    results[provider_value]["env"] = "...***"
+
+            # Check secrets file if it was parsed successfully
+            if secrets_status == "parsed":
+                config_key = ProviderKeyManager.get_config_file_key(provider_value, secrets)
+                if config_key and config_key != API_KEY_HINT_TEXT:
+                    if len(config_key) > 5:
+                        results[provider_value]["config"] = f"...{config_key[-5:]}"
+                    else:
+                        results[provider_value]["config"] = "...***"
 
     return results
 
@@ -235,7 +266,7 @@ def show_check_summary() -> None:
     system_info = get_system_info()
     config_summary = get_config_summary(config_files["config"])
     secrets_summary = get_secrets_summary(config_files["secrets"])
-    api_keys = check_api_keys(secrets_summary)
+    api_keys = check_api_keys(secrets_summary, config_summary)
     fastagent_version = get_fastagent_version()
 
     # System info panel
@@ -341,8 +372,10 @@ def show_check_summary() -> None:
 
         keys_table.add_row(provider.capitalize(), env_status, config_status, active)
 
-    console.print(Panel(keys_table, title="API Keys", border_style="blue"))
-    
+    # Print the API Keys panel (fix: this was missing)
+    keys_panel = Panel(keys_table, title="API Keys", border_style="blue", subtitle_align="left")
+    console.print(keys_panel)
+
     # MCP Servers panel (shown after API Keys)
     if config_summary.get("status") == "parsed":
         mcp_servers = config_summary.get("mcp_servers", [])
@@ -447,4 +480,4 @@ def show(
 def main(ctx: typer.Context) -> None:
     """Check and diagnose FastAgent configuration."""
     if ctx.invoked_subcommand is None:
-        show_check_summary()
+        show_check_summary()

mcp_agent/config.py

@@ -179,6 +179,20 @@ class OpenRouterSettings(BaseModel):
     model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
 
 
+class AzureSettings(BaseModel):
+    """
+    Settings for using Azure OpenAI Service in the fast-agent application.
+    """
+
+    api_key: str | None = None
+    resource_name: str | None = None
+    azure_deployment: str | None = None
+    api_version: str | None = None
+    base_url: str | None = None  # Optional, can be constructed from resource_name
+
+    model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
+
+
 class OpenTelemetrySettings(BaseModel):
     """
     OTEL settings for the fast-agent application.
@@ -302,6 +316,9 @@ class Settings(BaseSettings):
     tensorzero: Optional[TensorZeroSettings] = None
     """Settings for using TensorZero inference gateway"""
 
+    azure: AzureSettings | None = None
+    """Settings for using Azure OpenAI Service in the fast-agent application"""
+
     logger: LoggerSettings | None = LoggerSettings()
     """Logger settings for the fast-agent application"""
 

mcp_agent/context.py

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

mcp_agent/event_progress.py

@@ -19,6 +19,7 @@ class ProgressAction(str, Enum):
     PLANNING = "Planning"
     READY = "Ready"
     CALLING_TOOL = "Calling Tool"
+    UPDATED = "Updated"
     FINISHED = "Finished"
     SHUTDOWN = "Shutdown"
     AGGREGATOR_INITIALIZED = "Running"

mcp_agent/llm/model_factory.py

@@ -10,6 +10,7 @@ from mcp_agent.llm.augmented_llm_passthrough import PassthroughLLM
 from mcp_agent.llm.augmented_llm_playback import PlaybackLLM
 from mcp_agent.llm.provider_types import Provider
 from mcp_agent.llm.providers.augmented_llm_anthropic import AnthropicAugmentedLLM
+from mcp_agent.llm.providers.augmented_llm_azure import AzureOpenAIAugmentedLLM
 from mcp_agent.llm.providers.augmented_llm_deepseek import DeepSeekAugmentedLLM
 from mcp_agent.llm.providers.augmented_llm_generic import GenericAugmentedLLM
 from mcp_agent.llm.providers.augmented_llm_google import GoogleAugmentedLLM
@@ -113,6 +114,7 @@ class ModelFactory:
         Provider.GOOGLE: GoogleAugmentedLLM,  # type: ignore
         Provider.OPENROUTER: OpenRouterAugmentedLLM,
         Provider.TENSORZERO: TensorZeroAugmentedLLM,
+        Provider.AZURE: AzureOpenAIAugmentedLLM,
     }
 
     # Mapping of special model names to their specific LLM classes

mcp_agent/llm/provider_types.py

@@ -16,3 +16,4 @@ class Provider(Enum):
     GENERIC = "generic"
     OPENROUTER = "openrouter"
     TENSORZERO = "tensorzero"  # For TensorZero Gateway
+    AZURE = "azure"  # Azure OpenAI Service

mcp_agent/llm/providers/augmented_llm_azure.py

@@ -0,0 +1,137 @@
+from openai import AuthenticationError, AzureOpenAI, OpenAI
+
+from mcp_agent.core.exceptions import ProviderKeyError
+from mcp_agent.llm.provider_types import Provider
+from mcp_agent.llm.providers.augmented_llm_openai import OpenAIAugmentedLLM
+
+try:
+    from azure.identity import DefaultAzureCredential
+except ImportError:
+    DefaultAzureCredential = None
+
+
+def _extract_resource_name(url: str) -> str | None:
+    from urllib.parse import urlparse
+
+    host = urlparse(url).hostname or ""
+    suffix = ".openai.azure.com"
+    return host.replace(suffix, "") if host.endswith(suffix) else None
+
+
+DEFAULT_AZURE_API_VERSION = "2023-05-15"
+
+
+class AzureOpenAIAugmentedLLM(OpenAIAugmentedLLM):
+    """
+    Azure OpenAI implementation extending OpenAIAugmentedLLM.
+    Handles both API Key and DefaultAzureCredential authentication.
+    """
+
+    def __init__(self, provider: Provider = Provider.AZURE, *args, **kwargs):
+        # Set provider to AZURE, pass through to base
+        super().__init__(provider=provider, *args, **kwargs)
+
+        # Context/config extraction
+        context = getattr(self, "context", None)
+        config = getattr(context, "config", None) if context else None
+        azure_cfg = getattr(config, "azure", None) if config else None
+
+        if azure_cfg is None:
+            raise ProviderKeyError(
+                "Missing Azure configuration",
+                "Azure provider requires configuration section 'azure' in your config file.",
+            )
+
+        self.use_default_cred = getattr(azure_cfg, "use_default_azure_credential", False)
+        default_request_params = getattr(self, "default_request_params", None)
+        self.deployment_name = getattr(default_request_params, "model", None) or getattr(
+            azure_cfg, "azure_deployment", None
+        )
+        self.api_version = getattr(azure_cfg, "api_version", None) or DEFAULT_AZURE_API_VERSION
+
+        if self.use_default_cred:
+            self.base_url = getattr(azure_cfg, "base_url", None)
+            if not self.base_url:
+                raise ProviderKeyError(
+                    "Missing Azure endpoint",
+                    "When using 'use_default_azure_credential', 'base_url' is required in azure config.",
+                )
+            if DefaultAzureCredential is None:
+                raise ProviderKeyError(
+                    "azure-identity not installed",
+                    "You must install 'azure-identity' to use DefaultAzureCredential authentication.",
+                )
+            self.credential = DefaultAzureCredential()
+
+            def get_azure_token():
+                token = self.credential.get_token("https://cognitiveservices.azure.com/.default")
+                return token.token
+
+            self.get_azure_token = get_azure_token
+        else:
+            self.api_key = getattr(azure_cfg, "api_key", None)
+            self.resource_name = getattr(azure_cfg, "resource_name", None)
+            self.base_url = getattr(azure_cfg, "base_url", None) or (
+                f"https://{self.resource_name}.openai.azure.com/" if self.resource_name else None
+            )
+            if not self.api_key:
+                raise ProviderKeyError(
+                    "Missing Azure OpenAI credentials",
+                    "Field 'api_key' is required in azure config.",
+                )
+            if not (self.resource_name or self.base_url):
+                raise ProviderKeyError(
+                    "Missing Azure endpoint",
+                    "Provide either 'resource_name' or 'base_url' under azure config.",
+                )
+            if not self.deployment_name:
+                raise ProviderKeyError(
+                    "Missing deployment name",
+                    "Set 'azure_deployment' in config or pass model=<deployment>.",
+                )
+            # If resource_name was missing, try to extract it from base_url
+            if not self.resource_name and self.base_url:
+                self.resource_name = _extract_resource_name(self.base_url)
+
+    def _openai_client(self) -> OpenAI:
+        """
+        Returns an AzureOpenAI client, handling both API Key and DefaultAzureCredential.
+        """
+        try:
+            if self.use_default_cred:
+                if self.base_url is None:
+                    raise ProviderKeyError(
+                        "Missing Azure endpoint",
+                        "azure_endpoint (base_url) is None at client creation time.",
+                    )
+                return AzureOpenAI(
+                    azure_ad_token_provider=self.get_azure_token,
+                    azure_endpoint=self.base_url,
+                    api_version=self.api_version,
+                    azure_deployment=self.deployment_name,
+                )
+            else:
+                if self.base_url is None:
+                    raise ProviderKeyError(
+                        "Missing Azure endpoint",
+                        "azure_endpoint (base_url) is None at client creation time.",
+                    )
+                return AzureOpenAI(
+                    api_key=self.api_key,
+                    azure_endpoint=self.base_url,
+                    api_version=self.api_version,
+                    azure_deployment=self.deployment_name,
+                )
+        except AuthenticationError as e:
+            if self.use_default_cred:
+                raise ProviderKeyError(
+                    "Invalid Azure AD credentials",
+                    "The configured Azure AD credentials were rejected.\n"
+                    "Please check your Azure identity setup.",
+                ) from e
+            else:
+                raise ProviderKeyError(
+                    "Invalid Azure OpenAI API key",
+                    "The configured Azure OpenAI API key was rejected.\n"
+                    "Please check that your API key is valid and not expired.",
+                ) from e

mcp_agent/llm/providers/augmented_llm_openai.py

@@ -78,7 +78,7 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
                 self._reasoning_effort = self.context.config.openai.reasoning_effort
 
         # Determine if we're using a reasoning model
-        # TODO -- move this to model capabiltities, add o4.
+        # TODO -- move this to model capabilities, add o4.
         chosen_model = self.default_request_params.model if self.default_request_params else None
         self._reasoning = chosen_model and (
             chosen_model.startswith("o3") or chosen_model.startswith("o1")
@@ -274,7 +274,9 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
             # Calculate new conversation messages (excluding prompts)
             new_messages = messages[len(prompt_messages) :]
 
-            # Update conversation history
+            if system_prompt:
+                new_messages = new_messages[1:]
+
             self.history.set(new_messages)
 
         self._log_chat_finished(model=self.default_request_params.model)
@@ -323,7 +325,7 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
         return result
 
     def _prepare_api_request(
-        self, messages, tools, request_params: RequestParams
+        self, messages, tools: List[ChatCompletionToolParam] | None, request_params: RequestParams
     ) -> dict[str, str]:
         # Create base arguments dictionary
 
@@ -343,9 +345,8 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
             )
         else:
             base_args["max_tokens"] = request_params.maxTokens
-
-        if tools:
-            base_args["parallel_tool_calls"] = request_params.parallel_tool_calls
+            if tools:
+                base_args["parallel_tool_calls"] = request_params.parallel_tool_calls
 
         arguments: Dict[str, str] = self.prepare_provider_arguments(
             base_args, request_params, self.OPENAI_EXCLUDE_FIELDS.union(self.BASE_EXCLUDE_FIELDS)
@@ -354,7 +355,7 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
 
     def adjust_schema(self, inputSchema: Dict) -> Dict:
         # return inputSchema
-        if not Provider.OPENAI == self.provider:
+        if self.provider not in [Provider.OPENAI, Provider.AZURE]:
             return inputSchema
 
         if "properties" in inputSchema:

mcp_agent/mcp/common.py

@@ -0,0 +1,16 @@
+"""
+Common constants and utilities shared between modules to avoid circular imports.
+"""
+
+# Constants
+SEP = "-"
+
+
+def create_namespaced_name(server_name: str, resource_name: str) -> str:
+    """Create a namespaced resource name from server and resource names"""
+    return f"{server_name}{SEP}{resource_name}"
+
+
+def is_namespaced_name(name: str) -> bool:
+    """Check if a name is already namespaced"""
+    return SEP in name

mcp_agent/mcp/mcp_agent_client_session.py

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

mcp_agent/mcp/mcp_aggregator.py

@@ -25,6 +25,7 @@ from pydantic import AnyUrl, BaseModel, ConfigDict
 from mcp_agent.context_dependent import ContextDependent
 from mcp_agent.event_progress import ProgressAction
 from mcp_agent.logging.logger import get_logger
+from mcp_agent.mcp.common import SEP, create_namespaced_name, is_namespaced_name
 from mcp_agent.mcp.gen_client import gen_client
 from mcp_agent.mcp.mcp_agent_client_session import MCPAgentClientSession
 from mcp_agent.mcp.mcp_connection_manager import MCPConnectionManager
@@ -35,23 +36,11 @@ if TYPE_CHECKING:
 
 logger = get_logger(__name__)  # This will be replaced per-instance when agent_name is available
 
-SEP = "-"
-
 # Define type variables for the generalized method
 T = TypeVar("T")
 R = TypeVar("R")
 
 
-def create_namespaced_name(server_name: str, resource_name: str) -> str:
-    """Create a namespaced resource name from server and resource names"""
-    return f"{server_name}{SEP}{resource_name}"
-
-
-def is_namespaced_name(name: str) -> bool:
-    """Check if a name is already namespaced"""
-    return SEP in name
-
-
 class NamespacedTool(BaseModel):
     """
     A tool that is namespaced by server name.
@@ -94,6 +83,11 @@ class MCPAggregator(ContextDependent):
             self._persistent_connection_manager = self.context._connection_manager
 
         await self.load_servers()
+        # Import the display component here to avoid circular imports
+        from mcp_agent.ui.console_display import ConsoleDisplay
+
+        # Initialize the display component
+        self.display = ConsoleDisplay(config=self.context.config)
 
         return self
 
@@ -138,6 +132,9 @@ class MCPAggregator(ContextDependent):
         self._prompt_cache: Dict[str, List[Prompt]] = {}
         self._prompt_cache_lock = Lock()
 
+        # Lock for refreshing tools from a server
+        self._refresh_lock = Lock()
+
     async def close(self) -> None:
         """
         Close all persistent connections when the aggregator is deleted.
@@ -217,8 +214,18 @@ class MCPAggregator(ContextDependent):
                     },
                 )
 
+                # Create a wrapper to capture the parameters for the client session
+                def session_factory(read_stream, write_stream, read_timeout):
+                    return MCPAgentClientSession(
+                        read_stream,
+                        write_stream,
+                        read_timeout,
+                        server_name=server_name,
+                        tool_list_changed_callback=self._handle_tool_list_changed,
+                    )
+
                 await self._persistent_connection_manager.get_server(
-                    server_name, client_session_factory=MCPAgentClientSession
+                    server_name, client_session_factory=session_factory
                 )
 
             logger.info(
@@ -261,8 +268,20 @@ class MCPAggregator(ContextDependent):
                 tools = await fetch_tools(server_connection.session)
                 prompts = await fetch_prompts(server_connection.session, server_name)
             else:
+                # Create a factory function for the client session
+                def create_session(read_stream, write_stream, read_timeout):
+                    return MCPAgentClientSession(
+                        read_stream,
+                        write_stream,
+                        read_timeout,
+                        server_name=server_name,
+                        tool_list_changed_callback=self._handle_tool_list_changed,
+                    )
+
                 async with gen_client(
-                    server_name, server_registry=self.context.server_registry
+                    server_name,
+                    server_registry=self.context.server_registry,
+                    client_session_factory=create_session,
                 ) as client:
                     tools = await fetch_tools(client)
                     prompts = await fetch_prompts(client, server_name)
@@ -384,6 +403,15 @@ class MCPAggregator(ContextDependent):
             ]
         )
 
+    async def refresh_all_tools(self) -> None:
+        """
+        Refresh the tools for all servers.
+        This is useful when you know tools have changed but haven't received notifications.
+        """
+        logger.info("Refreshing tools for all servers")
+        for server_name in self.server_names:
+            await self._refresh_server_tools(server_name)
+
     async def _execute_on_server(
         self,
         server_name: str,
@@ -864,6 +892,103 @@ class MCPAggregator(ContextDependent):
         logger.debug(f"Available prompts across servers: {results}")
         return results
 
+    async def _handle_tool_list_changed(self, server_name: str) -> None:
+        """
+        Callback handler for ToolListChangedNotification.
+        This will refresh the tools for the specified server.
+
+        Args:
+            server_name: The name of the server whose tools have changed
+        """
+        logger.info(f"Tool list changed for server '{server_name}', refreshing tools")
+
+        # Refresh the tools for this server
+        await self._refresh_server_tools(server_name)
+
+    async def _refresh_server_tools(self, server_name: str) -> None:
+        """
+        Refresh the tools for a specific server.
+
+        Args:
+            server_name: The name of the server to refresh tools for
+        """
+        if not await self.validate_server(server_name):
+            logger.error(f"Cannot refresh tools for unknown server '{server_name}'")
+            return
+
+        await self.display.show_tool_update(aggregator=self, updated_server=server_name)
+
+        async with self._refresh_lock:
+            try:
+                # Fetch new tools from the server
+                if self.connection_persistence:
+                    # Create a factory function that will include our parameters
+                    def create_session(read_stream, write_stream, read_timeout):
+                        return MCPAgentClientSession(
+                            read_stream,
+                            write_stream,
+                            read_timeout,
+                            server_name=server_name,
+                            tool_list_changed_callback=self._handle_tool_list_changed,
+                        )
+
+                    server_connection = await self._persistent_connection_manager.get_server(
+                        server_name, client_session_factory=create_session
+                    )
+                    tools_result = await server_connection.session.list_tools()
+                    new_tools = tools_result.tools or []
+                else:
+                    # Create a factory function for the client session
+                    def create_session(read_stream, write_stream, read_timeout):
+                        return MCPAgentClientSession(
+                            read_stream,
+                            write_stream,
+                            read_timeout,
+                            server_name=server_name,
+                            tool_list_changed_callback=self._handle_tool_list_changed,
+                        )
+
+                    async with gen_client(
+                        server_name,
+                        server_registry=self.context.server_registry,
+                        client_session_factory=create_session,
+                    ) as client:
+                        tools_result = await client.list_tools()
+                        new_tools = tools_result.tools or []
+
+                # Update tool maps
+                async with self._tool_map_lock:
+                    # Remove old tools for this server
+                    old_tools = self._server_to_tool_map.get(server_name, [])
+                    for old_tool in old_tools:
+                        if old_tool.namespaced_tool_name in self._namespaced_tool_map:
+                            del self._namespaced_tool_map[old_tool.namespaced_tool_name]
+
+                    # Add new tools
+                    self._server_to_tool_map[server_name] = []
+                    for tool in new_tools:
+                        namespaced_tool_name = create_namespaced_name(server_name, tool.name)
+                        namespaced_tool = NamespacedTool(
+                            tool=tool,
+                            server_name=server_name,
+                            namespaced_tool_name=namespaced_tool_name,
+                        )
+
+                        self._namespaced_tool_map[namespaced_tool_name] = namespaced_tool
+                        self._server_to_tool_map[server_name].append(namespaced_tool)
+
+                logger.info(
+                    f"Successfully refreshed tools for server '{server_name}'",
+                    data={
+                        "progress_action": ProgressAction.UPDATED,
+                        "server_name": server_name,
+                        "agent_name": self.agent_name,
+                        "tool_count": len(new_tools),
+                    },
+                )
+            except Exception as e:
+                logger.error(f"Failed to refresh tools for server '{server_name}': {e}")
+
     async def get_resource(
         self, resource_uri: str, server_name: str | None = None
     ) -> ReadResourceResult:

mcp_agent/ui/console_display.py

@@ -5,7 +5,8 @@ from rich.panel import Panel
 from rich.text import Text
 
 from mcp_agent import console
-from mcp_agent.mcp.mcp_aggregator import SEP
+from mcp_agent.mcp.common import SEP
+from mcp_agent.mcp.mcp_aggregator import MCPAggregator
 
 # Constants
 HUMAN_INPUT_TOOL_NAME = "__human_input__"
@@ -96,6 +97,32 @@ class ConsoleDisplay:
         console.console.print(panel, markup=self._markup)
         console.console.print("\n")
 
+    async def show_tool_update(self, aggregator: MCPAggregator | None, updated_server: str) -> None:
+        """Show a tool update for a server"""
+        if not self.config or not self.config.logger.show_tools:
+            return
+
+        display_server_list = Text()
+
+        if aggregator:
+            for server_name in await aggregator.list_servers():
+                style = "green" if updated_server == server_name else "dim white"
+                display_server_list.append(f"[{server_name}] ", style)
+
+        panel = Panel(
+            f"[dim green]Updating tools for server {updated_server}[/]",
+            title="[TOOL UPDATE]",
+            title_align="left",
+            style="green",
+            border_style="bold white",
+            padding=(1, 2),
+            subtitle=display_server_list,
+            subtitle_align="left",
+        )
+        console.console.print("\n")
+        console.console.print(panel, markup=self._markup)
+        console.console.print("\n")
+
     def _format_tool_list(self, available_tools, selected_tool_name):
         """Format the list of available tools, highlighting the selected one."""
         display_tool_list = Text()