nvidia-nat 1.4.0a20251028__py3-none-any.whl → 1.4.0a20251029__py3-none-any.whl

nat/data_models/common.py

@@ -21,6 +21,8 @@ from hashlib import sha512
 from pydantic import AliasChoices
 from pydantic import BaseModel
 from pydantic import Field
+from pydantic import PlainSerializer
+from pydantic import SecretStr
 from pydantic.json_schema import GenerateJsonSchema
 from pydantic.json_schema import JsonSchemaMode
 
@@ -169,3 +171,26 @@ class TypedBaseModel(BaseModel):
 
 
 TypedBaseModelT = typing.TypeVar("TypedBaseModelT", bound=TypedBaseModel)
+
+
+def get_secret_value(v: SecretStr | None) -> str | None:
+    """
+    Extract the secret value from a SecretStr or return None.
+
+    Parameters
+    ----------
+    v: SecretStr or None.
+        A field defined as OptionalSecretStr, which is either a SecretStr or None.
+
+    Returns
+    -------
+    str | None
+        The secret value as a plain string, or None if v is None.
+    """
+    if v is None:
+        return None
+    return v.get_secret_value()
+
+
+# A SecretStr or None that serializes to plain string
+OptionalSecretStr = typing.Annotated[SecretStr | None, PlainSerializer(get_secret_value)]

nat/front_ends/mcp/mcp_front_end_config.py

@@ -17,6 +17,7 @@ import logging
 from typing import Literal
 
 from pydantic import Field
+from pydantic import field_validator
 from pydantic import model_validator
 
 from nat.authentication.oauth2.oauth2_resource_server_config import OAuth2ResourceServerConfig
@@ -47,10 +48,25 @@ class MCPFrontEndConfig(FrontEndBaseConfig, name="mcp"):
         description="Transport type for the MCP server (default: streamable-http, backwards compatible with sse)")
     runner_class: str | None = Field(
         default=None, description="Custom worker class for handling MCP routes (default: built-in worker)")
+    base_path: str | None = Field(default=None,
+                                  description="Base path to mount the MCP server at (e.g., '/api/v1'). "
+                                  "If specified, the server will be accessible at http://host:port{base_path}/mcp. "
+                                  "If None, server runs at root path /mcp.")
 
     server_auth: OAuth2ResourceServerConfig | None = Field(
         default=None, description=("OAuth 2.0 Resource Server configuration for token verification."))
 
+    @field_validator('base_path')
+    @classmethod
+    def validate_base_path(cls, v: str | None) -> str | None:
+        """Validate that base_path starts with '/' and doesn't end with '/'."""
+        if v is not None:
+            if not v.startswith('/'):
+                raise ValueError("base_path must start with '/'")
+            if v.endswith('/'):
+                raise ValueError("base_path must not end with '/'")
+        return v
+
     # Memory profiling configuration
     enable_memory_profiling: bool = Field(default=False,
                                           description="Enable memory profiling and diagnostics (default: False)")

nat/front_ends/mcp/mcp_front_end_plugin.py

@@ -16,12 +16,14 @@
 import logging
 import typing
 
-from nat.authentication.oauth2.oauth2_resource_server_config import OAuth2ResourceServerConfig
 from nat.builder.front_end import FrontEndBase
 from nat.builder.workflow_builder import WorkflowBuilder
 from nat.front_ends.mcp.mcp_front_end_config import MCPFrontEndConfig
 from nat.front_ends.mcp.mcp_front_end_plugin_worker import MCPFrontEndPluginWorkerBase
 
+if typing.TYPE_CHECKING:
+    from mcp.server.fastmcp import FastMCP
+
 logger = logging.getLogger(__name__)
 
 
@@ -43,7 +45,7 @@ class MCPFrontEndPlugin(FrontEndBase[MCPFrontEndConfig]):
         worker_class = self.get_worker_class()
         return f"{worker_class.__module__}.{worker_class.__qualname__}"
 
-    def _get_worker_instance(self) -> MCPFrontEndPluginWorkerBase:
+    def _get_worker_instance(self):
         """Get an instance of the worker class."""
         # Import the worker class dynamically if specified in config
         if self.front_end_config.runner_class:
@@ -56,61 +58,94 @@ class MCPFrontEndPlugin(FrontEndBase[MCPFrontEndConfig]):
 
         return worker_class(self.full_config)
 
-    async def _create_token_verifier(self, token_verifier_config: OAuth2ResourceServerConfig):
-        """Create a token verifier based on configuration."""
-        from nat.front_ends.mcp.introspection_token_verifier import IntrospectionTokenVerifier
-
-        if not self.front_end_config.server_auth:
-            return None
-
-        return IntrospectionTokenVerifier(token_verifier_config)
-
     async def run(self) -> None:
         """Run the MCP server."""
-        # Import FastMCP
-        from mcp.server.fastmcp import FastMCP
-
-        # Create auth settings and token verifier if auth is required
-        auth_settings = None
-        token_verifier = None
-
         # Build the workflow and add routes using the worker
         async with WorkflowBuilder.from_config(config=self.full_config) as builder:
 
-            if self.front_end_config.server_auth:
-                from mcp.server.auth.settings import AuthSettings
-                from pydantic import AnyHttpUrl
-
-                server_url = f"http://{self.front_end_config.host}:{self.front_end_config.port}"
-
-                auth_settings = AuthSettings(issuer_url=AnyHttpUrl(self.front_end_config.server_auth.issuer_url),
-                                             required_scopes=self.front_end_config.server_auth.scopes,
-                                             resource_server_url=AnyHttpUrl(server_url))
-
-                token_verifier = await self._create_token_verifier(self.front_end_config.server_auth)
-
-            # Create an MCP server with the configured parameters
-            mcp = FastMCP(name=self.front_end_config.name,
-                          host=self.front_end_config.host,
-                          port=self.front_end_config.port,
-                          debug=self.front_end_config.debug,
-                          auth=auth_settings,
-                          token_verifier=token_verifier)
-
-            # Get the worker instance and set up routes
+            # Get the worker instance
             worker = self._get_worker_instance()
 
+            # Let the worker create the MCP server (allows plugins to customize)
+            mcp = await worker.create_mcp_server()
+
             # Add routes through the worker (includes health endpoint and function registration)
             await worker.add_routes(mcp, builder)
 
             # Start the MCP server with configurable transport
             # streamable-http is the default, but users can choose sse if preferred
             try:
-                if self.front_end_config.transport == "sse":
+                # If base_path is configured, mount server at sub-path using FastAPI wrapper
+                if self.front_end_config.base_path:
+                    if self.front_end_config.transport == "sse":
+                        logger.warning(
+                            "base_path is configured but SSE transport does not support mounting at sub-paths. "
+                            "Use streamable-http transport for base_path support.")
+                        logger.info("Starting MCP server with SSE endpoint at /sse")
+                        await mcp.run_sse_async()
+                    else:
+                        full_url = f"http://{self.front_end_config.host}:{self.front_end_config.port}{self.front_end_config.base_path}/mcp"
+                        logger.info(
+                            "Mounting MCP server at %s/mcp on %s:%s",
+                            self.front_end_config.base_path,
+                            self.front_end_config.host,
+                            self.front_end_config.port,
+                        )
+                        logger.info("MCP server URL: %s", full_url)
+                        await self._run_with_mount(mcp)
+                # Standard behavior - run at root path
+                elif self.front_end_config.transport == "sse":
                     logger.info("Starting MCP server with SSE endpoint at /sse")
                     await mcp.run_sse_async()
                 else:  # streamable-http
-                    logger.info("Starting MCP server with streamable-http endpoint at /mcp/")
+                    full_url = f"http://{self.front_end_config.host}:{self.front_end_config.port}/mcp"
+                    logger.info("MCP server URL: %s", full_url)
                     await mcp.run_streamable_http_async()
             except KeyboardInterrupt:
                 logger.info("MCP server shutdown requested (Ctrl+C). Shutting down gracefully.")
+
+    async def _run_with_mount(self, mcp: "FastMCP") -> None:
+        """Run MCP server mounted at configured base_path using FastAPI wrapper.
+
+        Args:
+            mcp: The FastMCP server instance to mount
+        """
+        import contextlib
+
+        import uvicorn
+        from fastapi import FastAPI
+
+        @contextlib.asynccontextmanager
+        async def lifespan(_app: FastAPI):
+            """Manage MCP server session lifecycle."""
+            logger.info("Starting MCP server session manager...")
+            async with contextlib.AsyncExitStack() as stack:
+                try:
+                    # Initialize the MCP server's session manager
+                    await stack.enter_async_context(mcp.session_manager.run())
+                    logger.info("MCP server session manager started successfully")
+                    yield
+                except Exception as e:
+                    logger.error("Failed to start MCP server session manager: %s", e)
+                    raise
+            logger.info("MCP server session manager stopped")
+
+        # Create a FastAPI wrapper app with lifespan management
+        app = FastAPI(
+            title=self.front_end_config.name,
+            description="MCP server mounted at custom base path",
+            lifespan=lifespan,
+        )
+
+        # Mount the MCP server's ASGI app at the configured base_path
+        app.mount(self.front_end_config.base_path, mcp.streamable_http_app())
+
+        # Configure and start uvicorn server
+        config = uvicorn.Config(
+            app,
+            host=self.front_end_config.host,
+            port=self.front_end_config.port,
+            log_level=self.front_end_config.log_level.lower(),
+        )
+        server = uvicorn.Server(config)
+        await server.serve()

nat/front_ends/mcp/mcp_front_end_plugin_worker.py

@@ -35,7 +35,12 @@ logger = logging.getLogger(__name__)
 
 
 class MCPFrontEndPluginWorkerBase(ABC):
-    """Base class for MCP front end plugin workers."""
+    """Base class for MCP front end plugin workers.
+
+    This abstract base class provides shared utilities and defines the contract
+    for MCP worker implementations. Most users should inherit from
+    MCPFrontEndPluginWorker instead of this class directly.
+    """
 
     def __init__(self, config: Config):
         """Initialize the MCP worker with configuration.
@@ -83,15 +88,86 @@ class MCPFrontEndPluginWorkerBase(ABC):
                 },
                                     status_code=503)
 
+    @abstractmethod
+    async def create_mcp_server(self) -> FastMCP:
+        """Create and configure the MCP server instance.
+
+        This is the main extension point. Plugins can return FastMCP or any subclass
+        to customize server behavior (for example, add authentication, custom transports).
+
+        Returns:
+            FastMCP instance or a subclass with custom behavior
+        """
+        ...
+
     @abstractmethod
     async def add_routes(self, mcp: FastMCP, builder: WorkflowBuilder):
         """Add routes to the MCP server.
 
+        Plugins must implement this method. Most plugins can call
+        _default_add_routes() for standard behavior and then add
+        custom enhancements.
+
+        Args:
+            mcp: The FastMCP server instance
+            builder: The workflow builder instance
+        """
+        ...
+
+    async def _default_add_routes(self, mcp: FastMCP, builder: WorkflowBuilder):
+        """Default route registration logic - reusable by subclasses.
+
+        This is a protected helper method that plugins can call to get
+        standard route registration behavior. Plugins typically call this
+        from their add_routes() implementation and then add custom features.
+
+        This method:
+        - Sets up the health endpoint
+        - Builds the workflow and extracts all functions
+        - Filters functions based on tool_names config
+        - Registers each function as an MCP tool
+        - Sets up debug endpoints for tool introspection
+
         Args:
             mcp: The FastMCP server instance
-            builder (WorkflowBuilder): The workflow builder instance
+            builder: The workflow builder instance
         """
-        pass
+        from nat.front_ends.mcp.tool_converter import register_function_with_mcp
+
+        # Set up the health endpoint
+        self._setup_health_endpoint(mcp)
+
+        # Build the workflow and register all functions with MCP
+        workflow = await builder.build()
+
+        # Get all functions from the workflow
+        functions = await self._get_all_functions(workflow)
+
+        # Filter functions based on tool_names if provided
+        if self.front_end_config.tool_names:
+            logger.info("Filtering functions based on tool_names: %s", self.front_end_config.tool_names)
+            filtered_functions: dict[str, Function] = {}
+            for function_name, function in functions.items():
+                if function_name in self.front_end_config.tool_names:
+                    # Treat current tool_names as function names, so check if the function name is in the list
+                    filtered_functions[function_name] = function
+                elif any(function_name.startswith(f"{group_name}.") for group_name in self.front_end_config.tool_names):
+                    # Treat tool_names as function group names, so check if the function name starts with the group name
+                    filtered_functions[function_name] = function
+                else:
+                    logger.debug("Skipping function %s as it's not in tool_names", function_name)
+            functions = filtered_functions
+
+        # Register each function with MCP, passing workflow context for observability
+        for function_name, function in functions.items():
+            register_function_with_mcp(mcp, function_name, function, workflow, self.memory_profiler)
+
+        # Add a simple fallback function if no functions were found
+        if not functions:
+            raise RuntimeError("No functions found in workflow. Please check your configuration.")
+
+        # After registration, expose debug endpoints for tool/schema inspection
+        self._setup_debug_endpoints(mcp, functions)
 
     async def _get_all_functions(self, workflow: Workflow) -> dict[str, Function]:
         """Get all functions from the workflow.
@@ -225,48 +301,62 @@ class MCPFrontEndPluginWorkerBase(ABC):
 
 
 class MCPFrontEndPluginWorker(MCPFrontEndPluginWorkerBase):
-    """Default MCP front end plugin worker implementation."""
+    """Default MCP server worker implementation.
 
-    async def add_routes(self, mcp: FastMCP, builder: WorkflowBuilder):
-        """Add default routes to the MCP server.
+    Inherit from this class to create custom MCP workers that extend or modify
+    server behavior. Override create_mcp_server() to use a different server type,
+    and override add_routes() to add custom functionality.
 
-        Args:
-            mcp: The FastMCP server instance
-            builder (WorkflowBuilder): The workflow builder instance
+    Example:
+        class CustomWorker(MCPFrontEndPluginWorker):
+            async def create_mcp_server(self):
+                # Return custom MCP server instance
+                return MyCustomFastMCP(...)
+
+            async def add_routes(self, mcp, builder):
+                # Get default routes
+                await super().add_routes(mcp, builder)
+                # Add custom features
+                self._add_my_custom_features(mcp)
+    """
+
+    async def create_mcp_server(self) -> FastMCP:
+        """Create default MCP server with optional authentication.
+
+        Returns:
+            FastMCP instance configured with settings from NAT config
         """
-        from nat.front_ends.mcp.tool_converter import register_function_with_mcp
+        # Handle auth if configured
+        auth_settings = None
+        token_verifier = None
 
-        # Set up the health endpoint
-        self._setup_health_endpoint(mcp)
+        if self.front_end_config.server_auth:
+            from mcp.server.auth.settings import AuthSettings
+            from pydantic import AnyHttpUrl
 
-        # Build the workflow and register all functions with MCP
-        workflow = await builder.build()
+            server_url = f"http://{self.front_end_config.host}:{self.front_end_config.port}"
+            auth_settings = AuthSettings(issuer_url=AnyHttpUrl(self.front_end_config.server_auth.issuer_url),
+                                         required_scopes=self.front_end_config.server_auth.scopes,
+                                         resource_server_url=AnyHttpUrl(server_url))
 
-        # Get all functions from the workflow
-        functions = await self._get_all_functions(workflow)
+            # Create token verifier
+            from nat.front_ends.mcp.introspection_token_verifier import IntrospectionTokenVerifier
 
-        # Filter functions based on tool_names if provided
-        if self.front_end_config.tool_names:
-            logger.info("Filtering functions based on tool_names: %s", self.front_end_config.tool_names)
-            filtered_functions: dict[str, Function] = {}
-            for function_name, function in functions.items():
-                if function_name in self.front_end_config.tool_names:
-                    # Treat current tool_names as function names, so check if the function name is in the list
-                    filtered_functions[function_name] = function
-                elif any(function_name.startswith(f"{group_name}.") for group_name in self.front_end_config.tool_names):
-                    # Treat tool_names as function group names, so check if the function name starts with the group name
-                    filtered_functions[function_name] = function
-                else:
-                    logger.debug("Skipping function %s as it's not in tool_names", function_name)
-            functions = filtered_functions
+            token_verifier = IntrospectionTokenVerifier(self.front_end_config.server_auth)
 
-        # Register each function with MCP, passing workflow context for observability
-        for function_name, function in functions.items():
-            register_function_with_mcp(mcp, function_name, function, workflow, self.memory_profiler)
+        return FastMCP(name=self.front_end_config.name,
+                       host=self.front_end_config.host,
+                       port=self.front_end_config.port,
+                       debug=self.front_end_config.debug,
+                       auth=auth_settings,
+                       token_verifier=token_verifier)
 
-        # Add a simple fallback function if no functions were found
-        if not functions:
-            raise RuntimeError("No functions found in workflow. Please check your configuration.")
+    async def add_routes(self, mcp: FastMCP, builder: WorkflowBuilder):
+        """Add default routes to the MCP server.
 
-        # After registration, expose debug endpoints for tool/schema inspection
-        self._setup_debug_endpoints(mcp, functions)
+        Args:
+            mcp: The FastMCP server instance
+            builder: The workflow builder instance
+        """
+        # Use the default implementation from base class to add the tools to the MCP server
+        await self._default_add_routes(mcp, builder)

{nvidia_nat-1.4.0a20251028.dist-info → nvidia_nat-1.4.0a20251029.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nvidia-nat
-Version: 1.4.0a20251028
+Version: 1.4.0a20251029
 Summary: NVIDIA NeMo Agent toolkit
 Author: NVIDIA Corporation
 Maintainer: NVIDIA Corporation
@@ -22,7 +22,7 @@ Requires-Dist: click~=8.1
 Requires-Dist: colorama~=0.4.6
 Requires-Dist: datasets~=4.0
 Requires-Dist: expandvars~=1.0
-Requires-Dist: fastapi~=0.115.5
+Requires-Dist: fastapi~=0.120.1
 Requires-Dist: httpx~=0.27
 Requires-Dist: jinja2~=3.1
 Requires-Dist: jsonpath-ng~=1.7

{nvidia_nat-1.4.0a20251028.dist-info → nvidia_nat-1.4.0a20251029.dist-info}/RECORD

@@ -116,7 +116,7 @@ nat/data_models/__init__.py,sha256=Xs1JQ16L9btwreh4pdGKwskffAw1YFO48jKrU4ib_7c,6
 nat/data_models/agent.py,sha256=IwDyb9Zc3R4Zd5rFeqt7q0EQswczAl5focxV9KozIzs,1625
 nat/data_models/api_server.py,sha256=oQtSiP7jpkHIZ75g21A_lTiidNsQo54pq3qy2StIJcs,30652
 nat/data_models/authentication.py,sha256=XPu9W8nh4XRSuxPv3HxO-FMQ_JtTEoK6Y02JwnzDwTg,8457
-nat/data_models/common.py,sha256=nXXfGrjpxebzBUa55mLdmzePLt7VFHvTAc6Znj3yEv0,5875
+nat/data_models/common.py,sha256=0SL3qcQpY1SUJvFsup9HJW62n5ltgXgKMlKdvL6n5Zg,6542
 nat/data_models/component.py,sha256=b_hXOA8Gm5UNvlFkAhsR6kEvf33ST50MKtr5kWf75Ao,1894
 nat/data_models/component_ref.py,sha256=KFDWFVCcvJCfBBcXTh9f3R802EVHBtHXh9OdbRqFmdM,4747
 nat/data_models/config.py,sha256=P0JJmjqvUHUkpZ3Yc0IrMPoA2qP8HkmOjl7CwNq-nQQ,18833
@@ -262,9 +262,9 @@ nat/front_ends/fastapi/html_snippets/__init__.py,sha256=GUJrgGtpvyMUCjUBvR3faAdv
 nat/front_ends/fastapi/html_snippets/auth_code_grant_success.py,sha256=BNpWwzmA58UM0GK4kZXG4PHJy_5K9ihaVHu8SgCs5JA,1131
 nat/front_ends/mcp/__init__.py,sha256=Xs1JQ16L9btwreh4pdGKwskffAw1YFO48jKrU4ib_7c,685
 nat/front_ends/mcp/introspection_token_verifier.py,sha256=s7Q4Q6rWZJ0ZVujSxxpvVI6Bnhkg1LJQ3RLkvhzFIGE,2836
-nat/front_ends/mcp/mcp_front_end_config.py,sha256=dnNsf487XZtoipU3DcmCAZ9eqtyF5a2p_1huQ_4uwPI,4919
-nat/front_ends/mcp/mcp_front_end_plugin.py,sha256=4u_kpen_T-_Uh62V5M7dfW9KyzbqXI7tGBG4AxJXWm0,5231
-nat/front_ends/mcp/mcp_front_end_plugin_worker.py,sha256=IuwCcrBYmN6hyVra5vnwVVEjCuj2YO9ZUs-mhJnNNSQ,11626
+nat/front_ends/mcp/mcp_front_end_config.py,sha256=QHmz0OdB6pdUU9TH65NjLk7JsAnR-F6xisel5Bv2Po4,5744
+nat/front_ends/mcp/mcp_front_end_plugin.py,sha256=MVYJBCOhZAzUPlnXest6CYP3Gf0Ef1lbURaezgHpoyg,6701
+nat/front_ends/mcp/mcp_front_end_plugin_worker.py,sha256=qoRbYLC_HWqSH_jSNb-w7R_qwOmLyXaUA5JK0SX33GA,15362
 nat/front_ends/mcp/memory_profiler.py,sha256=OpcpLBAGCdQwYSFZbtAqdfncrnGYVjDcMpWydB71hjY,12811
 nat/front_ends/mcp/register.py,sha256=3aJtgG5VaiqujoeU1-Eq7Hl5pWslIlIwGFU2ASLTXgM,1173
 nat/front_ends/mcp/tool_converter.py,sha256=14NweQN3cPFBw7ZNiGyUHO4VhMGHrtfLGgvu4_H38oU,12426
@@ -475,10 +475,10 @@ nat/utils/reactive/base/observer_base.py,sha256=6BiQfx26EMumotJ3KoVcdmFBYR_fnAss
 nat/utils/reactive/base/subject_base.py,sha256=UQOxlkZTIeeyYmG5qLtDpNf_63Y7p-doEeUA08_R8ME,2521
 nat/utils/settings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nat/utils/settings/global_settings.py,sha256=9JaO6pxKT_Pjw6rxJRsRlFCXdVKCl_xUKU2QHZQWWNM,7294
-nvidia_nat-1.4.0a20251028.dist-info/licenses/LICENSE-3rd-party.txt,sha256=fOk5jMmCX9YoKWyYzTtfgl-SUy477audFC5hNY4oP7Q,284609
-nvidia_nat-1.4.0a20251028.dist-info/licenses/LICENSE.md,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-nvidia_nat-1.4.0a20251028.dist-info/METADATA,sha256=6E0nFJWcfW8aO-1e4hi1UaxEdQvZ73jfFtMCE7n-5Gk,10248
-nvidia_nat-1.4.0a20251028.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nvidia_nat-1.4.0a20251028.dist-info/entry_points.txt,sha256=4jCqjyETMpyoWbCBf4GalZU8I_wbstpzwQNezdAVbbo,698
-nvidia_nat-1.4.0a20251028.dist-info/top_level.txt,sha256=lgJWLkigiVZuZ_O1nxVnD_ziYBwgpE2OStdaCduMEGc,8
-nvidia_nat-1.4.0a20251028.dist-info/RECORD,,
+nvidia_nat-1.4.0a20251029.dist-info/licenses/LICENSE-3rd-party.txt,sha256=fOk5jMmCX9YoKWyYzTtfgl-SUy477audFC5hNY4oP7Q,284609
+nvidia_nat-1.4.0a20251029.dist-info/licenses/LICENSE.md,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+nvidia_nat-1.4.0a20251029.dist-info/METADATA,sha256=tiz911ksuk9pmFsLqH1gUexiw_Y6H5fqLvquikF0_Lo,10248
+nvidia_nat-1.4.0a20251029.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nvidia_nat-1.4.0a20251029.dist-info/entry_points.txt,sha256=4jCqjyETMpyoWbCBf4GalZU8I_wbstpzwQNezdAVbbo,698
+nvidia_nat-1.4.0a20251029.dist-info/top_level.txt,sha256=lgJWLkigiVZuZ_O1nxVnD_ziYBwgpE2OStdaCduMEGc,8
+nvidia_nat-1.4.0a20251029.dist-info/RECORD,,