fast-agent-mcp 0.2.23__tar.gz → 0.2.25__tar.gz

{fast_agent_mcp-0.2.23 → fast_agent_mcp-0.2.25}/.gitignore

@@ -197,7 +197,5 @@ tests/integration/prompt-state/history.json
 !tests/integration/api/fastagent.secrets.yaml
 fastagent.jsonl
 
-# JetBrains IDEs
-.idea/
 tests/e2e/smoke/base/weather_location.txt
 tests/integration/roots/fastagent.jsonl

{fast_agent_mcp-0.2.23 → fast_agent_mcp-0.2.25}/PKG-INFO

@@ -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.25/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.23 → fast_agent_mcp-0.2.25}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fast-agent-mcp"
-version = "0.2.23"
+version = "0.2.25"
 description = "Define, Prompt and Test MCP enabled Agents and Workflows"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -25,18 +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; 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",
@@ -56,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.23 → fast_agent_mcp-0.2.25}/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.23 → fast_agent_mcp-0.2.25}/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.23 → fast_agent_mcp-0.2.25}/src/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:

{fast_agent_mcp-0.2.23 → fast_agent_mcp-0.2.25}/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.23 → fast_agent_mcp-0.2.25}/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.23 → fast_agent_mcp-0.2.25}/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.25/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.23 → fast_agent_mcp-0.2.25}/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")
@@ -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:

fast_agent_mcp-0.2.25/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.23 → fast_agent_mcp-0.2.25}/src/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