nvidia-nat-mcp 1.4.0a20251103__py3-none-any.whl → 1.5.0a20260118__py3-none-any.whl

nat/plugins/mcp/server/tool_converter.py

@@ -0,0 +1,290 @@
+# 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.
+
+import json
+import logging
+from inspect import Parameter
+from inspect import Signature
+from typing import TYPE_CHECKING
+from typing import Any
+
+from pydantic import BaseModel
+from pydantic.fields import FieldInfo
+from pydantic_core import PydanticUndefined
+
+from mcp.server.fastmcp import FastMCP
+from nat.builder.function import Function
+from nat.builder.function_base import FunctionBase
+
+if TYPE_CHECKING:
+    from nat.plugins.mcp.server.memory_profiler import MemoryProfiler
+    from nat.runtime.session import SessionManager
+
+logger = logging.getLogger(__name__)
+
+# Sentinel: marks "optional; let Pydantic supply default/factory"
+_USE_PYDANTIC_DEFAULT = object()
+
+
+def is_field_optional(field: FieldInfo) -> tuple[bool, Any]:
+    """Determine if a Pydantic field is optional and extract its default value for MCP signatures.
+
+    For MCP tool signatures, we need to distinguish:
+    - Required fields: marked with Parameter.empty
+    - Optional with concrete default: use that default
+    - Optional with factory: use sentinel so Pydantic can apply the factory later
+
+    Args:
+        field: The Pydantic FieldInfo to check
+
+    Returns:
+        A tuple of (is_optional, default_value):
+        - (False, Parameter.empty) for required fields
+        - (True, actual_default) for optional fields with explicit defaults
+        - (True, _USE_PYDANTIC_DEFAULT) for optional fields with default_factory
+    """
+    if field.is_required():
+        return False, Parameter.empty
+
+    # Field is optional - has either default or factory
+    if field.default is not PydanticUndefined:
+        return True, field.default
+
+    # Factory case: mark optional in signature but don't fabricate a value
+    if field.default_factory is not None:
+        return True, _USE_PYDANTIC_DEFAULT
+
+    # Rare corner case: non-required yet no default surfaced
+    return True, _USE_PYDANTIC_DEFAULT
+
+
+def create_function_wrapper(
+    function_name: str,
+    session_manager: 'SessionManager',
+    schema: type[BaseModel],
+    memory_profiler: 'MemoryProfiler | None' = None,
+):
+    """Create a wrapper function that exposes a NAT Function as an MCP tool using SessionManager.
+
+    Here SessionManager.run() which is used to create a Runner that
+    automatically handles observability (emits intermediate step events, starts exporters, etc).
+
+    Args:
+        function_name (str): The name of the function/tool
+        session_manager (SessionManager): SessionManager wrapping the function/workflow
+        schema (type[BaseModel]): The input schema of the function
+        memory_profiler: Optional memory profiler to track requests
+
+    Returns:
+        A wrapper function suitable for registration with MCP
+    """
+    # Check if we're dealing with ChatRequest - special case
+    is_chat_request = False
+
+    # Check if the schema name is ChatRequest
+    if schema.__name__ == "ChatRequest" or (hasattr(schema, "__qualname__") and "ChatRequest" in schema.__qualname__):
+        is_chat_request = True
+        logger.info("Function %s uses ChatRequest - creating simplified interface", function_name)
+
+        # For ChatRequest, we'll create a simple wrapper with just a query parameter
+        parameters = [Parameter(
+            name="query",
+            kind=Parameter.KEYWORD_ONLY,
+            default=Parameter.empty,
+            annotation=str,
+        )]
+    else:
+        # Regular case - extract parameter information from the input schema
+        # Extract parameter information from the input schema
+        param_fields = schema.model_fields
+
+        parameters = []
+        for name, field in param_fields.items():
+            # Get the field type and convert to appropriate Python type
+            field_type = field.annotation
+
+            # Check if field is optional and get its default value
+            _is_optional, param_default = is_field_optional(field)
+
+            # Add the parameter to our list
+            parameters.append(
+                Parameter(
+                    name=name,
+                    kind=Parameter.KEYWORD_ONLY,
+                    default=param_default,
+                    annotation=field_type,
+                ))
+
+    # Create the function signature WITHOUT the ctx parameter
+    # We'll handle this in the wrapper function internally
+    sig = Signature(parameters=parameters, return_annotation=str)
+
+    # Define the actual wrapper function that accepts ctx but doesn't expose it
+    def create_wrapper():
+
+        async def wrapper_with_ctx(**kwargs):
+            """Internal wrapper that will be called by MCP.
+
+            Uses SessionManager.run() which creates a Runner that automatically handles observability.
+            """
+            # MCP will add a ctx parameter, extract it
+            ctx = kwargs.get("ctx")
+
+            # Remove ctx if present
+            if "ctx" in kwargs:
+                del kwargs["ctx"]
+
+            # Process the function call
+            if ctx:
+                ctx.info("Calling function %s with args: %s", function_name, json.dumps(kwargs, default=str))
+                await ctx.report_progress(0, 100)
+
+            try:
+                # Prepare input payload
+                if is_chat_request:
+                    from nat.data_models.api_server import ChatRequest
+                    # Create a chat request from the query string
+                    query = kwargs.get("query", "")
+                    payload = ChatRequest.from_string(query)
+                else:
+                    # Strip sentinel values so Pydantic can apply defaults/factories
+                    cleaned_kwargs = {k: v for k, v in kwargs.items() if v is not _USE_PYDANTIC_DEFAULT}
+                    # Always validate with the declared schema
+                    payload = schema.model_validate(cleaned_kwargs)
+
+                # Use SessionManager.run() pattern - this automatically handles all observability
+                # The Runner created by session_manager.run() will:
+                # 1. Start the exporter manager
+                # 2. Emit WORKFLOW_START/FUNCTION_START events
+                # 3. Execute the function/workflow
+                # 4. Emit WORKFLOW_END/FUNCTION_END events
+                # 5. Stop the exporter manager
+                async with session_manager.run(payload) as runner:
+                    result = await runner.result()
+
+                # Report completion
+                if ctx:
+                    await ctx.report_progress(100, 100)
+
+                # Track request completion for memory profiling
+                if memory_profiler:
+                    memory_profiler.on_request_complete()
+
+                # Handle different result types for proper formatting
+                if isinstance(result, str):
+                    return result
+                if isinstance(result, dict | list):
+                    return json.dumps(result, default=str)
+                return str(result)
+            except Exception as e:
+                if ctx:
+                    ctx.error("Error calling function %s: %s", function_name, str(e))
+
+                # Track request completion even on error
+                if memory_profiler:
+                    memory_profiler.on_request_complete()
+
+                raise
+
+        return wrapper_with_ctx
+
+    # Create the wrapper function
+    wrapper = create_wrapper()
+
+    # Set the signature on the wrapper function (WITHOUT ctx)
+    wrapper.__signature__ = sig  # type: ignore
+    wrapper.__name__ = function_name
+
+    # Return the wrapper with proper signature
+    return wrapper
+
+
+def get_function_description(function: FunctionBase) -> str:
+    """
+    Retrieve a human-readable description for a NAT function or workflow.
+
+    The description is determined using the following precedence:
+       1. If the function is a Workflow and has a 'description' attribute, use it.
+       2. If the Workflow's config has a 'description', use it.
+       3. If the Workflow's config has a 'topic', use it.
+       4. If the function is a regular Function, use its 'description' attribute.
+
+    Args:
+        function: The NAT FunctionBase instance (Function or Workflow).
+
+    Returns:
+        The best available description string for the function.
+    """
+    function_description = ""
+
+    # Import here to avoid circular imports
+    from nat.builder.workflow import Workflow
+
+    if isinstance(function, Workflow):
+        config = function.config
+
+        # Workflow doesn't have a description, but probably should
+        if hasattr(function, "description") and function.description:
+            function_description = function.description
+        # Try to get description from config
+        elif hasattr(config, "description") and config.description:
+            function_description = config.description
+        # Try to get anything that might be a description
+        elif hasattr(config, "topic") and config.topic:
+            function_description = config.topic
+        # Try to get description from the workflow config
+        elif hasattr(config, "workflow") and hasattr(config.workflow, "description") and config.workflow.description:
+            function_description = config.workflow.description
+
+    elif isinstance(function, Function):
+        function_description = function.description
+
+    return function_description
+
+
+def register_function_with_mcp(mcp: FastMCP,
+                               function_name: str,
+                               session_manager: 'SessionManager',
+                               memory_profiler: 'MemoryProfiler | None' = None,
+                               function: FunctionBase | None = None) -> None:
+    """Register a NAT Function as an MCP tool using SessionManager.
+
+    Each function is wrapped in a SessionManager
+    so that all calls go through Runner that automatically handles observability.
+
+    Args:
+        mcp: The FastMCP instance
+        function_name: The name to register the function under
+        session_manager: SessionManager wrapping the function/workflow
+        memory_profiler: Optional memory profiler to track requests
+    """
+    logger.info("Registering function %s with MCP", function_name)
+
+    # Get the workflow from the session manager
+    workflow = session_manager.workflow
+
+    # Prefer the function's schema/description when available, fall back to workflow
+    target_function = function or workflow
+
+    # Get the input schema from the most specific object available
+    input_schema = getattr(target_function, "input_schema", workflow.input_schema)
+    logger.info("Function %s has input schema: %s", function_name, input_schema)
+
+    # Get function description
+    function_description = get_function_description(target_function)
+
+    # Create and register the wrapper function with MCP
+    wrapper_func = create_function_wrapper(function_name, session_manager, input_schema, memory_profiler)
+    mcp.tool(name=function_name, description=function_description)(wrapper_func)

nat/plugins/mcp/utils.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");

{nvidia_nat_mcp-1.4.0a20251103.dist-info → nvidia_nat_mcp-1.5.0a20260118.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nvidia-nat-mcp
-Version: 1.4.0a20251103
+Version: 1.5.0a20260118
 Summary: Subpackage for MCP client integration in NeMo Agent toolkit
 Author: NVIDIA Corporation
 Maintainer: NVIDIA Corporation
@@ -16,13 +16,13 @@ Requires-Python: <3.14,>=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE-3rd-party.txt
 License-File: LICENSE.md
-Requires-Dist: nvidia-nat==v1.4.0a20251103
-Requires-Dist: aiorwlock~=1.5
-Requires-Dist: mcp~=1.14
+Requires-Dist: nvidia-nat==v1.5.0a20260118
+Requires-Dist: aiorwlock~=1.5.0
+Requires-Dist: mcp~=1.25
 Dynamic: license-file
 
 <!--
-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");

nvidia_nat_mcp-1.5.0a20260118.dist-info/RECORD

@@ -0,0 +1,37 @@
+nat/meta/pypi.md,sha256=-P0JFDuIEDuCRryhXejNke80c_b6AeAzMNKMGgS-NT4,1489
+nat/plugins/mcp/__init__.py,sha256=hiEJ2ajB5zhZuZOUHAyHfTA9w9UNhygij7hp4yfA6QE,685
+nat/plugins/mcp/exception_handler.py,sha256=iEVSZFgiKm6Mr2XB3NRYbYBgyK7GJ6LnnPYXs8MYwJI,7653
+nat/plugins/mcp/exceptions.py,sha256=87fm20cBNijam8n0dYx7drwCZqH1zr9tKls2ayfkK0A,5985
+nat/plugins/mcp/register.py,sha256=-_SHPsqmVuFNlo6fwnXpZA9whIlMKifk4vnBfNX33mA,858
+nat/plugins/mcp/utils.py,sha256=5foCyTdCp0p72FvlP_VjkQe6wgWLc9__XCfGk_iAUbY,9116
+nat/plugins/mcp/auth/__init__.py,sha256=hiEJ2ajB5zhZuZOUHAyHfTA9w9UNhygij7hp4yfA6QE,685
+nat/plugins/mcp/auth/auth_flow_handler.py,sha256=BvrclzC1mmVBsUZ2lx6Cv5NNFtMmUDxsTwLAKRrjiWU,9130
+nat/plugins/mcp/auth/auth_provider.py,sha256=c-Y_FIDVUjEUixvqzeh7Sl0r5aiCR9JDyfudnfC6um8,21326
+nat/plugins/mcp/auth/auth_provider_config.py,sha256=l0jbQZ_lYEK0B1DlkjkoKUcWIvW5pZas_rbE_WWqvq8,4226
+nat/plugins/mcp/auth/register.py,sha256=FEp4L_ff4HQgFI4QDH04NIEIKRvh8bacns957dQlk9g,1759
+nat/plugins/mcp/auth/token_storage.py,sha256=Zuj0tAWqkv8pPt4baeVEL2eEmnCE4AjU4h6eLhyKyKI,9263
+nat/plugins/mcp/auth/service_account/__init__.py,sha256=hiEJ2ajB5zhZuZOUHAyHfTA9w9UNhygij7hp4yfA6QE,685
+nat/plugins/mcp/auth/service_account/provider.py,sha256=Gsb44cy-5Ap_1BcG3Ny9fc94VtfPg4lVrwM3LKeTBA8,5920
+nat/plugins/mcp/auth/service_account/provider_config.py,sha256=rrzHAo1qmK1yI5CNaadNTVsmh5qtYF1UrYz2Q1nLF2E,5332
+nat/plugins/mcp/auth/service_account/token_client.py,sha256=bGAjq_vG8oo8ZoQfRJjEgigGmF0hgF0umaUOWv0_ZOY,5986
+nat/plugins/mcp/cli/__init__.py,sha256=GLpBQw8r1Nj38vIOluSHsTlLINI24tZ_JJbcWWksBJE,709
+nat/plugins/mcp/cli/commands.py,sha256=CFqLqaG2ldKqdbOAfNfUc1wyYRxuq2psoGX0mE_-2Go,48869
+nat/plugins/mcp/client/__init__.py,sha256=SFdgClH-7zCAAcujmdvtfiqSz3Xe1KVRX7fviW-45Zg,714
+nat/plugins/mcp/client/client_base.py,sha256=jWNwb20qWIUuIJg7Ldp_WgiJlQmYin4YvVSJ9_ECP5c,26831
+nat/plugins/mcp/client/client_config.py,sha256=qrBjXCKHpMoS2A5i9DoXkN7hdYnGy77FBcZDGZlyb4w,7179
+nat/plugins/mcp/client/client_impl.py,sha256=dygcLnhnWnMh7u45aLvYbGEP1uv02uSb886YsOucxgs,36661
+nat/plugins/mcp/server/__init__.py,sha256=Ioza5tZX7qlOicklSVbhcXO3r7EjRLENvV5AtBSusAQ,723
+nat/plugins/mcp/server/front_end_config.py,sha256=yFmEMKcz_ANJnef4Zu4dwGtnfNZ0uzVdc_dYYCLmgCg,5749
+nat/plugins/mcp/server/front_end_plugin.py,sha256=WAqgYFHAswUK1WKk_PIUo6Lyf0pvJLelT3esHhmIHFM,6896
+nat/plugins/mcp/server/front_end_plugin_worker.py,sha256=2_PQ938IbYKFKDsmDw6rcgBWHZdbxZetUopU4Ik1FDQ,18187
+nat/plugins/mcp/server/introspection_token_verifier.py,sha256=oyhZkCTo6u3w7m469DicF57BNmhTPLcMYtWuHvcCsRg,2840
+nat/plugins/mcp/server/memory_profiler.py,sha256=KjJw4ARSmEFult2MorFySiucog0bD8ClI9ZbkJhIwns,12816
+nat/plugins/mcp/server/register_frontend.py,sha256=gfHfQaQ4NhkZkDSrFur1bxbG93kbAGBtumm4eKYOzKE,1178
+nat/plugins/mcp/server/tool_converter.py,sha256=v35IILT5S2jE7ZTYQzm8-4CMu5Xa21BACeRP1MS1vzA,11608
+nvidia_nat_mcp-1.5.0a20260118.dist-info/licenses/LICENSE-3rd-party.txt,sha256=fOk5jMmCX9YoKWyYzTtfgl-SUy477audFC5hNY4oP7Q,284609
+nvidia_nat_mcp-1.5.0a20260118.dist-info/licenses/LICENSE.md,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+nvidia_nat_mcp-1.5.0a20260118.dist-info/METADATA,sha256=Iep40v3cqEEYDqdEQrg4XzCSz0oltniRMDvtAdSTLLo,2326
+nvidia_nat_mcp-1.5.0a20260118.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nvidia_nat_mcp-1.5.0a20260118.dist-info/entry_points.txt,sha256=t5HYRfXR-dyZf6BWRz1u1TqPprKpCWt-WLHKQXfiLLU,231
+nvidia_nat_mcp-1.5.0a20260118.dist-info/top_level.txt,sha256=8-CJ2cP6-f0ZReXe5Hzqp-5pvzzHz-5Ds5H2bGqh1-U,4
+nvidia_nat_mcp-1.5.0a20260118.dist-info/RECORD,,

nvidia_nat_mcp-1.5.0a20260118.dist-info/entry_points.txt

@@ -0,0 +1,9 @@
+[nat.cli]
+mcp = nat.plugins.mcp.cli.commands:mcp_command
+
+[nat.components]
+nat_mcp = nat.plugins.mcp.register
+nat_mcp_auth = nat.plugins.mcp.auth.register
+
+[nat.front_ends]
+nat_mcp_server = nat.plugins.mcp.server.register_frontend

nat/plugins/mcp/tool.py

@@ -1,138 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, 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.
-
-import logging
-from typing import Literal
-
-from pydantic import BaseModel
-from pydantic import Field
-from pydantic import HttpUrl
-from pydantic import model_validator
-
-from nat.builder.builder import Builder
-from nat.builder.function_info import FunctionInfo
-from nat.cli.register_workflow import register_function
-from nat.data_models.function import FunctionBaseConfig
-from nat.plugins.mcp.client_base import MCPToolClient
-from nat.utils.decorators import deprecated
-
-logger = logging.getLogger(__name__)
-
-
-class MCPToolConfig(FunctionBaseConfig, name="mcp_tool_wrapper"):
-    """
-    Function which connects to a Model Context Protocol (MCP) server and wraps the selected tool as a NeMo Agent toolkit
-    function.
-    """
-    # Add your custom configuration parameters here
-    url: HttpUrl | None = Field(default=None,
-                                description="The URL of the MCP server (for streamable-http or sse modes)")
-    mcp_tool_name: str = Field(description="The name of the tool served by the MCP Server that you want to use")
-    transport: Literal["sse", "stdio", "streamable-http"] = Field(
-        default="streamable-http",
-        description="The type of transport to use (default: streamable-http, backwards compatible with sse)")
-    command: str | None = Field(default=None,
-                                description="The command to run for stdio mode (e.g. 'docker' or 'python')")
-    args: list[str] | None = Field(default=None, description="Additional arguments for the stdio command")
-    env: dict[str, str] | None = Field(default=None, description="Environment variables to set for the stdio process")
-    description: str | None = Field(default=None,
-                                    description="""
-        Description for the tool that will override the description provided by the MCP server. Should only be used if
-        the description provided by the server is poor or nonexistent
-        """)
-
-    @model_validator(mode="after")
-    def validate_model(self):
-        """Validate that stdio and SSE/Streamable HTTP properties are mutually exclusive."""
-        if self.transport == 'stdio':
-            if self.url is not None:
-                raise ValueError("url should not be set when using stdio client type")
-            if not self.command:
-                raise ValueError("command is required when using stdio client type")
-        elif self.transport in ['streamable-http', 'sse']:
-            if self.command is not None or self.args is not None or self.env is not None:
-                raise ValueError(
-                    "command, args, and env should not be set when using streamable-http or sse client type")
-            if not self.url:
-                raise ValueError("url is required when using streamable-http or sse client type")
-        return self
-
-
-def mcp_tool_function(tool: MCPToolClient) -> FunctionInfo:
-    """
-    Create a NeMo Agent toolkit function from an MCP tool.
-
-    Args:
-        tool: The MCP tool to wrap
-
-    Returns:
-        The NeMo Agent toolkit function
-    """
-
-    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:
-        # Run the tool, catching any errors and sending to agent for correction
-        try:
-            if tool_input:
-                args = tool_input.model_dump()
-                return await tool.acall(args)
-
-            _ = tool.input_schema.model_validate(kwargs)
-            return await tool.acall(kwargs)
-        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])
-
-
-@register_function(config_type=MCPToolConfig)
-@deprecated(
-    reason=
-    "This function is being replaced with the new mcp_client function group that supports additional MCP features",
-    feature_name="mcp_tool_wrapper")
-async def mcp_tool(config: MCPToolConfig, builder: Builder):
-    """
-    Generate a NeMo Agent Toolkit Function that wraps a tool provided by the MCP server.
-    """
-
-    from nat.plugins.mcp.client_base import MCPSSEClient
-    from nat.plugins.mcp.client_base import MCPStdioClient
-    from nat.plugins.mcp.client_base import MCPStreamableHTTPClient
-
-    # Initialize the client
-    if config.transport == 'stdio':
-        client = MCPStdioClient(command=config.command, args=config.args, env=config.env)
-    elif config.transport == 'streamable-http':
-        client = MCPStreamableHTTPClient(url=str(config.url))
-    elif config.transport == 'sse':
-        client = MCPSSEClient(url=str(config.url))
-    else:
-        raise ValueError(f"Invalid transport type: {config.transport}")
-
-    async with client:
-        # If the tool is found create a MCPToolClient object and set the description if provided
-        tool: MCPToolClient = await client.get_tool(config.mcp_tool_name)
-        if config.description:
-            tool.set_description(description=config.description)
-
-        logger.info("Configured to use tool: %s from MCP server at %s", tool.name, client.server_name)
-
-        yield mcp_tool_function(tool)

nvidia_nat_mcp-1.4.0a20251103.dist-info/RECORD

@@ -1,23 +0,0 @@
-nat/meta/pypi.md,sha256=EYyJTCCEOWzuuz-uNaYJ_WBk55Jiig87wcUr9E4g0yw,1484
-nat/plugins/mcp/__init__.py,sha256=GUJrgGtpvyMUCjUBvR3faAdv-tZzbU9W-izgx9aMEQg,680
-nat/plugins/mcp/client_base.py,sha256=JIyO2ZJsVkQ1g5BOU2zKXGHg_0yxv16g7_YJAqdCXTA,26504
-nat/plugins/mcp/client_config.py,sha256=l9tVUHe8WdFPJ9rXDg8dZkQi1dvHGYwoqQ8Glqg2LGs,6783
-nat/plugins/mcp/client_impl.py,sha256=j7cKAUBKtZAY3mt5Mm8VqgqMhRZk7kzvUd1nwMU_h0o,27072
-nat/plugins/mcp/exception_handler.py,sha256=4JVdZDJL4LyumZEcMIEBK2LYC6djuSMzqUhQDZZ6dUo,7648
-nat/plugins/mcp/exceptions.py,sha256=EGVOnYlui8xufm8dhJyPL1SUqBLnCGOTvRoeyNcmcWE,5980
-nat/plugins/mcp/register.py,sha256=HOT2Wl2isGuyFc7BUTi58-BbjI5-EtZMZo7stsv5pN4,831
-nat/plugins/mcp/tool.py,sha256=xNfBIF__ugJKFEjkYEM417wWM1PpuTaCMGtSFmxHSuA,6089
-nat/plugins/mcp/utils.py,sha256=dUIig7jeKz0ctb4o38jFGbe2uvM3DMR3PSJjfN_Lr5M,9111
-nat/plugins/mcp/auth/__init__.py,sha256=GUJrgGtpvyMUCjUBvR3faAdv-tZzbU9W-izgx9aMEQg,680
-nat/plugins/mcp/auth/auth_flow_handler.py,sha256=v21IK3IKZ2TLEP6wO9r-sJQiilWPq7Ry40M96SAxQFA,9125
-nat/plugins/mcp/auth/auth_provider.py,sha256=BgH66DlZgzhLDLO4cBERpHvNAmli5fMo_SCy11W9aBU,21251
-nat/plugins/mcp/auth/auth_provider_config.py,sha256=ZdiUObYU_Oj8KDDZ-JqkS6kJgup5EBy2ZREUOBw_kkI,4143
-nat/plugins/mcp/auth/register.py,sha256=L2x69NjJPS4s6CCE5myzWVrWn3e_ttHyojmGXvBipMg,1228
-nat/plugins/mcp/auth/token_storage.py,sha256=aS13ZvEJXcYzkZ0GSbrSor4i5bpjD5BkXHQw1iywC9k,9240
-nvidia_nat_mcp-1.4.0a20251103.dist-info/licenses/LICENSE-3rd-party.txt,sha256=fOk5jMmCX9YoKWyYzTtfgl-SUy477audFC5hNY4oP7Q,284609
-nvidia_nat_mcp-1.4.0a20251103.dist-info/licenses/LICENSE.md,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-nvidia_nat_mcp-1.4.0a20251103.dist-info/METADATA,sha256=fCZDLO4JXpWtFMO7BLRxedZUch6avusurmsdBG_Zz94,2319
-nvidia_nat_mcp-1.4.0a20251103.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nvidia_nat_mcp-1.4.0a20251103.dist-info/entry_points.txt,sha256=rYvUp4i-klBr3bVNh7zYOPXret704vTjvCk1qd7FooI,97
-nvidia_nat_mcp-1.4.0a20251103.dist-info/top_level.txt,sha256=8-CJ2cP6-f0ZReXe5Hzqp-5pvzzHz-5Ds5H2bGqh1-U,4
-nvidia_nat_mcp-1.4.0a20251103.dist-info/RECORD,,

nvidia_nat_mcp-1.4.0a20251103.dist-info/entry_points.txt

@@ -1,3 +0,0 @@
-[nat.components]
-nat_mcp = nat.plugins.mcp.register
-nat_mcp_auth = nat.plugins.mcp.auth.register