fast-agent-mcp 0.2.24__tar.gz → 0.2.26__tar.gz

{fast_agent_mcp-0.2.24 → fast_agent_mcp-0.2.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.2.24
+Version: 0.2.26
 Summary: Define, Prompt and Test MCP enabled Agents and Workflows
 Author-email: Shaun Smith <fastagent@llmindset.co.uk>
 License:                                  Apache License
@@ -212,14 +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: 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-mcp>=0.40.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
@@ -227,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.26/examples/azure-openai/fastagent.config.yaml

@@ -0,0 +1,54 @@
+# NOTE: Since version X.X, the Azure OpenAI integration in FastAgent reuses the OpenAI logic.
+# Authentication (API Key or DefaultAzureCredential) and connectivity are managed automatically.
+# You only need to configure the 'azure' section as indicated below; the system will select the appropriate method.
+#
+# Example configuration for Azure OpenAI in fast-agent
+#
+# There are three supported authentication/configuration modes for Azure OpenAI:
+#
+# 1. Using 'resource_name' and 'api_key' (recommended for most users)
+# 2. Using 'base_url' and 'api_key' (for custom endpoints or sovereign clouds)
+# 3. Using 'base_url' and DefaultAzureCredential (for managed identity, Azure CLI, etc.)
+#
+# Use ONLY one of the parameters: 'resource_name' or 'base_url'.
+# - If you define 'base_url', it will be used directly as the endpoint and 'resource_name' will be ignored.
+# - If you define 'resource_name' (and not 'base_url'), the endpoint will be constructed automatically.
+# - If both are missing, the configuration is invalid.
+#
+# Do not include both at the same time.
+
+# --- OPTION 1: Using resource_name and api_key (recommended for standard Azure) ---
+default_model: "azure.my-deployment"
+
+azure:
+  api_key: "YOUR_AZURE_OPENAI_API_KEY"
+  resource_name: "your-resource-name"
+  azure_deployment: "my-deployment"
+  api_version: "2023-05-15"
+  # Do not include base_url if you use resource_name
+
+# --- OPTION 2: Using base_url and api_key (for custom endpoints or sovereign clouds) ---
+# default_model: "azure.my-deployment"
+#
+# azure:
+#   api_key: "YOUR_AZURE_OPENAI_API_KEY"
+#   base_url: "https://your-resource-name.openai.azure.com/"
+#   azure_deployment: "my-deployment"
+#   api_version: "2023-05-15"
+#   # Do not include resource_name if you use base_url
+
+# --- OPTION 3: Using base_url and DefaultAzureCredential (for managed identity, Azure CLI, etc.) ---
+# Requires the 'azure-identity' package to be installed.
+# No api_key or resource_name should be present in this mode.
+# base_url is required and must be the full endpoint URL.
+#
+# default_model: "azure.my-deployment"
+#
+# azure:
+#   use_default_azure_credential: true
+#   base_url: "https://your-resource-name.openai.azure.com/"
+#   azure_deployment: "my-deployment"
+#   api_version: "2023-05-15"
+#   # Do not include api_key or resource_name in this mode
+
+# You can add other providers or settings as needed.

{fast_agent_mcp-0.2.24 → fast_agent_mcp-0.2.26}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fast-agent-mcp"
-version = "0.2.24"
+version = "0.2.26"
 description = "Define, Prompt and Test MCP enabled Agents and Workflows"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -15,7 +15,7 @@ classifiers = [
 requires-python = ">=3.10"
 dependencies = [
     "fastapi>=0.115.6",
-    "mcp>=1.8.0",
+    "mcp==1.8.0",
     "opentelemetry-distro>=0.50b0",
     "opentelemetry-exporter-otlp-proto-http>=1.29.0",
     "pydantic-settings>=2.7.0",
@@ -25,19 +25,24 @@ dependencies = [
     "typer>=0.15.1",
     "anthropic>=0.49.0",
     "openai>=1.63.2",
+    "azure-identity>=1.14.0",
     "prompt-toolkit>=3.0.50",
     "aiohttp>=3.11.13",
     "a2a-types>=0.1.0",
-    "opentelemetry-instrumentation-openai>=0.39.3",
-    "opentelemetry-instrumentation-anthropic>=0.39.3",
+    "opentelemetry-instrumentation-openai>=0.39.3; python_version >= '3.10' and python_version < '4.0'",
+    "opentelemetry-instrumentation-anthropic>=0.39.3; python_version >= '3.10' and python_version < '4.0'",
     "tensorzero>=2025.4.7",
-    "opentelemetry-instrumentation-mcp>=0.40.3",
+    "opentelemetry-instrumentation-mcp>=0.40.3; python_version >= '3.10' and python_version < '4.0'",
 ]
 
 [project.optional-dependencies]
 openai = [
     "openai>=1.58.1",
 ]
+# For Azure OpenAI with DefaultAzureCredential support, install with: pip install fast-agent-mcp[azure]
+azure = [
+    "azure-identity>=1.14.0"
+]
 dev = [
     "anthropic>=0.42.0",
     "pre-commit>=4.0.1",
@@ -57,6 +62,10 @@ build-backend = "hatchling.build"
 [tool.hatch.build.targets.wheel]
 packages = ["src/mcp_agent"]
 
+[[tool.poetry.packages]]
+include = "mcp_agent"
+from = "src"
+
 [tool.hatch.build]
 include = [
     "src/mcp_agent/**/*.py",

{fast_agent_mcp-0.2.24 → fast_agent_mcp-0.2.26}/src/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()

{fast_agent_mcp-0.2.24 → fast_agent_mcp-0.2.26}/src/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"""
 

{fast_agent_mcp-0.2.24 → fast_agent_mcp-0.2.26}/src/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"

{fast_agent_mcp-0.2.24 → fast_agent_mcp-0.2.26}/src/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

{fast_agent_mcp-0.2.24 → fast_agent_mcp-0.2.26}/src/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

fast_agent_mcp-0.2.26/src/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

{fast_agent_mcp-0.2.24 → fast_agent_mcp-0.2.26}/src/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")
@@ -325,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
 
@@ -345,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)
@@ -356,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:

fast_agent_mcp-0.2.26/src/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

{fast_agent_mcp-0.2.24 → fast_agent_mcp-0.2.26}/src/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
 
@@ -227,12 +221,11 @@ class MCPAggregator(ContextDependent):
                         write_stream,
                         read_timeout,
                         server_name=server_name,
-                        tool_list_changed_callback=self._handle_tool_list_changed
+                        tool_list_changed_callback=self._handle_tool_list_changed,
                     )
 
                 await self._persistent_connection_manager.get_server(
-                    server_name,
-                    client_session_factory=session_factory
+                    server_name, client_session_factory=session_factory
                 )
 
             logger.info(
@@ -282,13 +275,13 @@ class MCPAggregator(ContextDependent):
                         write_stream,
                         read_timeout,
                         server_name=server_name,
-                        tool_list_changed_callback=self._handle_tool_list_changed
+                        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
+                    client_session_factory=create_session,
                 ) as client:
                     tools = await fetch_tools(client)
                     prompts = await fetch_prompts(client, server_name)
@@ -923,6 +916,8 @@ class MCPAggregator(ContextDependent):
             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
@@ -934,12 +929,11 @@ class MCPAggregator(ContextDependent):
                             write_stream,
                             read_timeout,
                             server_name=server_name,
-                            tool_list_changed_callback=self._handle_tool_list_changed
+                            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
+                        server_name, client_session_factory=create_session
                     )
                     tools_result = await server_connection.session.list_tools()
                     new_tools = tools_result.tools or []
@@ -951,13 +945,13 @@ class MCPAggregator(ContextDependent):
                             write_stream,
                             read_timeout,
                             server_name=server_name,
-                            tool_list_changed_callback=self._handle_tool_list_changed
+                            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
+                        client_session_factory=create_session,
                     ) as client:
                         tools_result = await client.list_tools()
                         new_tools = tools_result.tools or []