nvidia-nat-mcp 1.4.0a20251014__py3-none-any.whl → 1.5.0a20260115__py3-none-any.whl

nat/plugins/mcp/client/__init__.py

@@ -0,0 +1,15 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""MCP client components."""

nat/plugins/mcp/{client_base.py → client/client_base.py}

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -112,14 +112,21 @@ class AuthAdapter(httpx.Auth):
             # Use the user_id passed to this AuthAdapter instance
             auth_result = await self.auth_provider.authenticate(user_id=self.user_id, response=response)
 
-            # Check if we have BearerTokenCred
+            # Build headers from credentials
             from nat.data_models.authentication import BearerTokenCred
-            if auth_result.credentials and isinstance(auth_result.credentials[0], BearerTokenCred):
-                token = auth_result.credentials[0].token.get_secret_value()
-                return {"Authorization": f"Bearer {token}"}
-            else:
-                logger.info("Auth provider did not return BearerTokenCred")
-                return {}
+            from nat.data_models.authentication import HeaderCred
+            headers = {}
+
+            for cred in auth_result.credentials:
+                if isinstance(cred, BearerTokenCred):
+                    # Standard Bearer token
+                    token = cred.token.get_secret_value()
+                    headers["Authorization"] = f"Bearer {token}"
+                elif isinstance(cred, HeaderCred):
+                    # Generic header credential (supports custom formats and service accounts)
+                    headers[cred.name] = cred.value.get_secret_value()
+
+            return headers
         except Exception as e:
             logger.warning("Failed to get auth token: %s", e)
             return {}
@@ -162,8 +169,9 @@ class MCPBaseClient(ABC):
 
         # Convert auth provider to AuthAdapter
         self._auth_provider = auth_provider
-        # Use provided user_id or fall back to auth provider's default_user_id
-        effective_user_id = user_id or (auth_provider.config.default_user_id if auth_provider else None)
+        # Use provided user_id or fall back to auth provider's default_user_id (if available)
+        effective_user_id = user_id or (getattr(auth_provider.config, 'default_user_id', None)
+                                        if auth_provider else None)
         self._httpx_auth = AuthAdapter(auth_provider, effective_user_id) if auth_provider else None
 
         self._tool_call_timeout = tool_call_timeout

nat/plugins/mcp/{client_config.py → client/client_config.py}

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -80,9 +80,9 @@ class MCPServerConfig(BaseModel):
         return self
 
 
-class MCPClientConfig(FunctionGroupBaseConfig, name="mcp_client"):
+class MCPClientBaseConfig(FunctionGroupBaseConfig):
     """
-    Configuration for connecting to an MCP server as a client and exposing selected tools.
+    Base configuration shared by MCP client variants.
     """
     server: MCPServerConfig = Field(..., description="Server connection details (transport, url/command, etc.)")
     tool_call_timeout: timedelta = Field(
@@ -114,6 +114,19 @@ class MCPClientConfig(FunctionGroupBaseConfig, name="mcp_client"):
             calculator_multiply:
               description: "Multiply two numbers"  # alias defaults to original name
         """)
+
+    @model_validator(mode="after")
+    def _validate_reconnect_backoff(self) -> "MCPClientBaseConfig":
+        """Validate reconnect backoff values."""
+        if self.reconnect_max_backoff < self.reconnect_initial_backoff:
+            raise ValueError("reconnect_max_backoff must be greater than or equal to reconnect_initial_backoff")
+        return self
+
+
+class MCPClientConfig(MCPClientBaseConfig, name="mcp_client"):
+    """
+    Configuration for connecting to an MCP server as a client and exposing selected tools.
+    """
     session_aware_tools: bool = Field(default=True,
                                       description="Session-aware tools are created if True. Defaults to True.")
     max_sessions: int = Field(default=100,
@@ -123,9 +136,11 @@ class MCPClientConfig(FunctionGroupBaseConfig, name="mcp_client"):
         default=timedelta(hours=1),
         description="Time after which inactive sessions are cleaned up. Defaults to 1 hour.")
 
-    @model_validator(mode="after")
-    def _validate_reconnect_backoff(self) -> "MCPClientConfig":
-        """Validate reconnect backoff values."""
-        if self.reconnect_max_backoff < self.reconnect_initial_backoff:
-            raise ValueError("reconnect_max_backoff must be greater than or equal to reconnect_initial_backoff")
-        return self
+
+class PerUserMCPClientConfig(MCPClientBaseConfig, name="per_user_mcp_client"):
+    """
+    MCP Client configuration for per-user workflows that are registered with @register_per_user_function,
+
+    and each user gets their own MCP client instance.
+    """
+    pass

nat/plugins/mcp/{client_impl.py → client/client_impl.py}

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -26,16 +26,77 @@ from pydantic import BaseModel
 
 from nat.authentication.interfaces import AuthProviderBase
 from nat.builder.builder import Builder
+from nat.builder.context import Context
 from nat.builder.function import FunctionGroup
 from nat.cli.register_workflow import register_function_group
-from nat.plugins.mcp.client_base import MCPBaseClient
-from nat.plugins.mcp.client_config import MCPClientConfig
-from nat.plugins.mcp.client_config import MCPToolOverrideConfig
+from nat.cli.register_workflow import register_per_user_function_group
+from nat.plugins.mcp.client.client_base import MCPBaseClient
+from nat.plugins.mcp.client.client_config import MCPClientConfig
+from nat.plugins.mcp.client.client_config import MCPToolOverrideConfig
+from nat.plugins.mcp.client.client_config import PerUserMCPClientConfig
 from nat.plugins.mcp.utils import truncate_session_id
 
 logger = logging.getLogger(__name__)
 
 
+class PerUserMCPFunctionGroup(FunctionGroup):
+    """
+    A specialized FunctionGroup for per-user MCP clients.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.mcp_client: MCPBaseClient | None = None  # Will be set to the actual MCP client instance
+        self.mcp_client_server_name: str | None = None
+        self.mcp_client_transport: str | None = None
+        self.user_id: str | None = None
+
+
+def mcp_per_user_tool_function(tool, client: MCPBaseClient):
+    """
+    Create a per-user NAT function for an MCP tool.
+
+    Args:
+        tool: The MCP tool to create a function for
+        client: The MCP client to use for the function
+
+    Returns:
+        The NAT function
+    """
+    from nat.builder.function import FunctionInfo
+
+    def _convert_from_str(input_str: str) -> tool.input_schema:
+        return tool.input_schema.model_validate_json(input_str)
+
+    async def _response_fn(tool_input: BaseModel | None = None, **kwargs) -> str:
+        try:
+            mcp_tool = await client.get_tool(tool.name)
+
+            if tool_input:
+                args = tool_input.model_dump(exclude_none=True, mode='json')
+                return await mcp_tool.acall(args)
+
+            # kwargs arrives with all optional fields set to None because NAT's framework
+            # converts the input dict to a Pydantic model (filling in all Field(default=None)),
+            # then dumps it back to a dict. We need to strip out these None values because
+            # many MCP servers (e.g., Kaggle) reject requests with excessive null fields.
+            # We re-validate here (yes, redundant) to leverage Pydantic's exclude_none with
+            # mode='json' for recursive None removal in nested models.
+            # Reference: function_info.py:_convert_input_pydantic
+            validated_input = mcp_tool.input_schema.model_validate(kwargs)
+            args = validated_input.model_dump(exclude_none=True, mode='json')
+            return await mcp_tool.acall(args)
+        except Exception as e:
+            logger.warning("Error calling tool %s", tool.name, exc_info=True)
+            return str(e)
+
+    return FunctionInfo.create(single_fn=_response_fn,
+                               description=tool.description,
+                               input_schema=tool.input_schema,
+                               converters=[_convert_from_str])
+
+
 @dataclass
 class SessionData:
     """Container for all session-related data."""
@@ -91,9 +152,9 @@ class MCPFunctionGroup(FunctionGroup):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         # MCP client attributes with proper typing
-        self._mcp_client = None  # Will be set to the actual MCP client instance
-        self._mcp_client_server_name: str | None = None
-        self._mcp_client_transport: str | None = None
+        self.mcp_client: MCPBaseClient | None = None  # Will be set to the actual MCP client instance
+        self.mcp_client_server_name: str | None = None
+        self.mcp_client_transport: str | None = None
 
         # Session management - consolidated data structure
         self._sessions: dict[str, SessionData] = {}
@@ -109,39 +170,13 @@ class MCPFunctionGroup(FunctionGroup):
         self._shared_auth_provider: AuthProviderBase | None = None
         self._client_config: MCPClientConfig | None = None
 
+        # Auth provider config defaults (set when auth provider is assigned)
+        self._default_user_id: str | None = None
+        self._allow_default_user_id_for_tool_calls: bool = True
+
         # Use random session id for testing only
         self._use_random_session_id_for_testing: bool = False
 
-    @property
-    def mcp_client(self):
-        """Get the MCP client instance."""
-        return self._mcp_client
-
-    @mcp_client.setter
-    def mcp_client(self, client):
-        """Set the MCP client instance."""
-        self._mcp_client = client
-
-    @property
-    def mcp_client_server_name(self) -> str | None:
-        """Get the MCP client server name."""
-        return self._mcp_client_server_name
-
-    @mcp_client_server_name.setter
-    def mcp_client_server_name(self, server_name: str | None):
-        """Set the MCP client server name."""
-        self._mcp_client_server_name = server_name
-
-    @property
-    def mcp_client_transport(self) -> str | None:
-        """Get the MCP client transport type."""
-        return self._mcp_client_transport
-
-    @mcp_client_transport.setter
-    def mcp_client_transport(self, transport: str | None):
-        """Set the MCP client transport type."""
-        self._mcp_client_transport = transport
-
     @property
     def session_count(self) -> int:
         """Current number of active sessions."""
@@ -176,9 +211,8 @@ class MCPFunctionGroup(FunctionGroup):
 
             if not session_id:
                 # use default user id if allowed
-                if self._shared_auth_provider and \
-                    self._shared_auth_provider.config.allow_default_user_id_for_tool_calls:
-                    session_id = self._shared_auth_provider.config.default_user_id
+                if self._shared_auth_provider and self._allow_default_user_id_for_tool_calls:
+                    session_id = self._default_user_id
             return session_id
         except Exception:
             return None
@@ -255,7 +289,7 @@ class MCPFunctionGroup(FunctionGroup):
             except Exception as e:
                 logger.warning("Error cleaning up session client %s: %s", truncate_session_id(session_id), e)
 
-    async def _get_session_client(self, session_id: str) -> MCPBaseClient:
+    async def _get_session_client(self, session_id: str) -> MCPBaseClient | None:
         """Get the appropriate MCP client for the session."""
         # Throttled cleanup on access
         now = datetime.now()
@@ -266,8 +300,7 @@ class MCPFunctionGroup(FunctionGroup):
         # If the session_id equals the configured default_user_id use the base client
         # instead of creating a per-session client
         if self._shared_auth_provider:
-            default_uid = self._shared_auth_provider.config.default_user_id
-            if default_uid and session_id == default_uid:
+            if self._default_user_id and session_id == self._default_user_id:
                 return self.mcp_client
 
         # Fast path: check if session already exists (reader lock for concurrent access)
@@ -346,7 +379,7 @@ class MCPFunctionGroup(FunctionGroup):
 
     async def _create_session_client(self, session_id: str) -> tuple[MCPBaseClient, asyncio.Event, asyncio.Task]:
         """Create a new MCP client instance for the session."""
-        from nat.plugins.mcp.client_base import MCPStreamableHTTPClient
+        from nat.plugins.mcp.client.client_base import MCPStreamableHTTPClient
 
         config = self._client_config
         if not config:
@@ -435,13 +468,16 @@ def mcp_session_tool_function(tool, function_group: MCPFunctionGroup):
                 return "User not authorized to call the tool"
 
             # Check if this is the default user - if so, use base client directly
-            if (not function_group._shared_auth_provider
-                    or session_id == function_group._shared_auth_provider.config.default_user_id):
+            if (not function_group._shared_auth_provider or session_id == function_group._default_user_id):
                 # Use base client directly for default user
                 client = function_group.mcp_client
+                if client is None:
+                    return "Tool temporarily unavailable. Try again."
                 session_tool = await client.get_tool(tool.name)
             else:
                 # Use session usage context to prevent cleanup during tool execution
+                if session_id is None:
+                    return "Tool temporarily unavailable. Try again."
                 async with function_group._session_usage_context(session_id) as client:
                     if client is None:
                         return "Tool temporarily unavailable. Try again."
@@ -449,11 +485,19 @@ def mcp_session_tool_function(tool, function_group: MCPFunctionGroup):
 
             # Preserve original calling convention
             if tool_input:
-                args = tool_input.model_dump()
+                args = tool_input.model_dump(exclude_none=True, mode='json')
                 return await session_tool.acall(args)
 
-            _ = session_tool.input_schema.model_validate(kwargs)
-            return await session_tool.acall(kwargs)
+            # kwargs arrives with all optional fields set to None because NAT's framework
+            # converts the input dict to a Pydantic model (filling in all Field(default=None)),
+            # then dumps it back to a dict. We need to strip out these None values because
+            # many MCP servers (e.g., Kaggle) reject requests with excessive null fields.
+            # We re-validate here (yes, redundant) to leverage Pydantic's exclude_none with
+            # mode='json' for recursive None removal in nested models.
+            # Reference: function_info.py:_convert_input_pydantic
+            validated_input = session_tool.input_schema.model_validate(kwargs)
+            args = validated_input.model_dump(exclude_none=True, mode='json')
+            return await session_tool.acall(args)
         except Exception as e:
             logger.warning("Error calling tool %s", tool.name, exc_info=True)
             return str(e)
@@ -475,9 +519,9 @@ async def mcp_client_function_group(config: MCPClientConfig, _builder: Builder):
     Returns:
         The function group
     """
-    from nat.plugins.mcp.client_base import MCPSSEClient
-    from nat.plugins.mcp.client_base import MCPStdioClient
-    from nat.plugins.mcp.client_base import MCPStreamableHTTPClient
+    from nat.plugins.mcp.client.client_base import MCPSSEClient
+    from nat.plugins.mcp.client.client_base import MCPStdioClient
+    from nat.plugins.mcp.client.client_base import MCPStreamableHTTPClient
 
     # Resolve auth provider if specified
     auth_provider = None
@@ -507,7 +551,9 @@ async def mcp_client_function_group(config: MCPClientConfig, _builder: Builder):
                               reconnect_max_backoff=config.reconnect_max_backoff)
     elif config.server.transport == "streamable-http":
         # Use default_user_id for the base client
-        base_user_id = auth_provider.config.default_user_id if auth_provider else None
+        # For interactive OAuth2: from config. For service accounts: defaults to server URL
+        base_user_id = getattr(auth_provider.config, 'default_user_id', str(
+            config.server.url)) if auth_provider else None
         client = MCPStreamableHTTPClient(str(config.server.url),
                                          auth_provider=auth_provider,
                                          user_id=base_user_id,
@@ -529,6 +575,18 @@ async def mcp_client_function_group(config: MCPClientConfig, _builder: Builder):
     group._shared_auth_provider = auth_provider
     group._client_config = config
 
+    # Set auth provider config defaults
+    # For interactive OAuth2: use config values
+    # For service accounts: default_user_id = server URL, allow_default_user_id_for_tool_calls = True
+    if auth_provider:
+        group._default_user_id = getattr(auth_provider.config, 'default_user_id', str(config.server.url))
+        group._allow_default_user_id_for_tool_calls = getattr(auth_provider.config,
+                                                              'allow_default_user_id_for_tool_calls',
+                                                              True)
+    else:
+        group._default_user_id = None
+        group._allow_default_user_id_for_tool_calls = True
+
     async with client:
         # Expose the live MCP client on the function group instance so other components (e.g., HTTP endpoints)
         # can reuse the already-established session instead of creating a new client per request.
@@ -551,23 +609,16 @@ async def mcp_client_function_group(config: MCPClientConfig, _builder: Builder):
             # Create the tool function according to configuration
             tool_fn = mcp_session_tool_function(tool, group)
 
-            # Normalize optional typing for linter/type-checker compatibility
-            single_fn = tool_fn.single_fn
-            if single_fn is None:
-                # Should not happen because FunctionInfo always sets a single_fn
-                logger.warning("Skipping tool %s because single_fn is None", function_name)
-                continue
-
             input_schema = tool_fn.input_schema
             # Convert NoneType sentinel to None for FunctionGroup.add_function signature
-            if input_schema is type(None):  # noqa: E721
+            if input_schema is type(None):
                 input_schema = None
 
             # Add to group
             logger.info("Adding tool %s to group", function_name)
             group.add_function(name=function_name,
                                description=description,
-                               fn=single_fn,
+                               fn=tool_fn.single_fn,
                                input_schema=input_schema,
                                converters=tool_fn.converters)
 
@@ -589,3 +640,143 @@ def mcp_apply_tool_alias_and_description(
         return {}
 
     return {name: override for name, override in tool_overrides.items() if name in all_tools}
+
+
+@register_per_user_function_group(config_type=PerUserMCPClientConfig)
+async def per_user_mcp_client_function_group(config: PerUserMCPClientConfig, _builder: Builder):
+    """
+    Connect to an MCP server and expose tools as a function group for per-user workflows.
+
+    Args:
+        config: The configuration for the MCP client
+        _builder: The builder
+    Returns:
+        The function group
+    """
+    from nat.plugins.mcp.client.client_base import MCPSSEClient
+    from nat.plugins.mcp.client.client_base import MCPStdioClient
+    from nat.plugins.mcp.client.client_base import MCPStreamableHTTPClient
+
+    # Resolve auth provider if specified
+    auth_provider = None
+    if config.server.auth_provider:
+        auth_provider = await _builder.get_auth_provider(config.server.auth_provider)
+
+    user_id = Context.get().user_id
+
+    # Build the appropriate client
+    if config.server.transport == "stdio":
+        if not config.server.command:
+            raise ValueError("command is required for stdio transport")
+        client = MCPStdioClient(config.server.command,
+                                config.server.args,
+                                config.server.env,
+                                tool_call_timeout=config.tool_call_timeout,
+                                auth_flow_timeout=config.auth_flow_timeout,
+                                reconnect_enabled=config.reconnect_enabled,
+                                reconnect_max_attempts=config.reconnect_max_attempts,
+                                reconnect_initial_backoff=config.reconnect_initial_backoff,
+                                reconnect_max_backoff=config.reconnect_max_backoff)
+    elif config.server.transport == "sse":
+        client = MCPSSEClient(str(config.server.url),
+                              tool_call_timeout=config.tool_call_timeout,
+                              auth_flow_timeout=config.auth_flow_timeout,
+                              reconnect_enabled=config.reconnect_enabled,
+                              reconnect_max_attempts=config.reconnect_max_attempts,
+                              reconnect_initial_backoff=config.reconnect_initial_backoff,
+                              reconnect_max_backoff=config.reconnect_max_backoff)
+    elif config.server.transport == "streamable-http":
+        client = MCPStreamableHTTPClient(str(config.server.url),
+                                         auth_provider=auth_provider,
+                                         user_id=user_id,
+                                         tool_call_timeout=config.tool_call_timeout,
+                                         auth_flow_timeout=config.auth_flow_timeout,
+                                         reconnect_enabled=config.reconnect_enabled,
+                                         reconnect_max_attempts=config.reconnect_max_attempts,
+                                         reconnect_initial_backoff=config.reconnect_initial_backoff,
+                                         reconnect_max_backoff=config.reconnect_max_backoff)
+    else:
+        raise ValueError(f"Unsupported transport: {config.server.transport}")
+
+    logger.info("Per-user MCP client configured for server: %s (user: %s)", client.server_name, user_id)
+
+    group = PerUserMCPFunctionGroup(config=config)
+
+    # Use a lifetime task to ensure the client context is entered and exited in the same task.
+    # This avoids anyio's "Attempted to exit cancel scope in a different task" error.
+    ready = asyncio.Event()
+    stop_event = asyncio.Event()
+
+    async def _lifetime():
+        """Lifetime task that owns the client's async context."""
+        try:
+            async with client:
+                ready.set()
+                await stop_event.wait()
+        except Exception:
+            ready.set()  # Ensure we don't hang the waiter
+            raise
+
+    lifetime_task = asyncio.create_task(_lifetime(), name=f"mcp-per-user-{user_id}")
+
+    # Wait for client initialization
+    timeout = config.tool_call_timeout.total_seconds()
+    try:
+        await asyncio.wait_for(ready.wait(), timeout=timeout)
+    except TimeoutError:
+        lifetime_task.cancel()
+        try:
+            await lifetime_task
+        except asyncio.CancelledError:
+            pass
+        raise RuntimeError(f"Per-user MCP client initialization timed out after {timeout}s")
+
+    # Check if initialization failed
+    if lifetime_task.done():
+        try:
+            await lifetime_task
+        except Exception as e:
+            raise RuntimeError(f"Failed to initialize per-user MCP client: {e}") from e
+
+    try:
+        # Expose the live MCP client on the function group instance so other components (e.g., HTTP endpoints)
+        # can reuse the already-established session instead of creating a new client per request.
+        group.mcp_client = client
+        group.mcp_client_server_name = client.server_name
+        group.mcp_client_transport = client.transport
+        group.user_id = user_id
+
+        all_tools = await client.get_tools()
+        tool_overrides = mcp_apply_tool_alias_and_description(all_tools, config.tool_overrides)
+
+        # Add each tool as a function to the group
+        for tool_name, tool in all_tools.items():
+            # Get override if it exists
+            override = tool_overrides.get(tool_name)
+
+            # Use override values or defaults
+            function_name = override.alias if override and override.alias else tool_name
+            description = override.description if override and override.description else tool.description
+
+            # Create the tool function according to configuration
+            tool_fn = mcp_per_user_tool_function(tool, client)
+
+            input_schema = tool_fn.input_schema
+            # Convert NoneType sentinel to None for FunctionGroup.add_function signature
+            if input_schema is type(None):
+                input_schema = None
+
+            # Add to group
+            logger.info("Adding tool %s to group", function_name)
+            group.add_function(name=function_name,
+                               description=description,
+                               fn=tool_fn.single_fn,
+                               input_schema=input_schema,
+                               converters=tool_fn.converters)
+
+        yield group
+    finally:
+        # Signal the lifetime task to exit and wait for clean shutdown
+        stop_event.set()
+        if not lifetime_task.done():
+            await lifetime_task

nat/plugins/mcp/exception_handler.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

nat/plugins/mcp/exceptions.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

nat/plugins/mcp/register.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,7 +16,8 @@
 # flake8: noqa
 # isort:skip_file
 
-# Import any providers which need to be automatically registered here
+# Register client components
+from .client import client_impl
 
-from . import client_impl
-from . import tool
+# Register server/frontend components
+from .server import register_frontend

nat/plugins/mcp/server/__init__.py

@@ -0,0 +1,15 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""MCP server/frontend components."""