nvidia-nat-mcp 1.4.0a20260107__py3-none-any.whl

nat/plugins/mcp/utils.py

@@ -0,0 +1,228 @@
+# 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.
+
+from enum import Enum
+from typing import Any
+
+from pydantic import BaseModel
+from pydantic import Field
+from pydantic import create_model
+
+
+def truncate_session_id(session_id: str, max_length: int = 10) -> str:
+    """
+    Truncate a session ID for logging purposes.
+
+    Args:
+        session_id: The session ID to truncate
+        max_length: Maximum length before truncation (default: 10)
+
+    Returns:
+        Truncated session ID with "..." if longer than max_length, otherwise full ID
+    """
+    if len(session_id) > max_length:
+        return session_id[:max_length] + "..."
+    return session_id
+
+
+def model_from_mcp_schema(name: str, mcp_input_schema: dict) -> type[BaseModel]:
+    """
+    Create a pydantic model from the input schema of the MCP tool
+    """
+    _type_map = {
+        "string": str,
+        "number": float,
+        "integer": int,
+        "boolean": bool,
+        "array": list,
+        "null": type(None),
+        "object": dict,
+    }
+
+    properties = mcp_input_schema.get("properties", {})
+    required_fields = set(mcp_input_schema.get("required", []))
+    schema_dict = {}
+
+    def _generate_valid_classname(class_name: str):
+        return class_name.replace('_', ' ').replace('-', ' ').title().replace(' ', '')
+
+    def _resolve_schema_type(schema: dict[str, Any], name: str) -> Any:
+        """
+        Recursively resolve a JSON schema to a Python type.
+        Handles nested anyOf/oneOf, arrays, objects, enums, and primitive types.
+        """
+        # Check for anyOf/oneOf first
+        any_of = schema.get("anyOf")
+        one_of = schema.get("oneOf")
+
+        if any_of or one_of:
+            union_schemas = any_of if any_of else one_of
+            resolved_type: Any = None
+
+            if union_schemas:
+                for sub_schema in union_schemas:
+                    mapped = _resolve_schema_type(sub_schema, name)
+                    if resolved_type is None:
+                        resolved_type = mapped
+                    elif mapped is not type(None):
+                        # Don't add None here, handle separately
+                        resolved_type = resolved_type | mapped
+                    else:
+                        # If we encounter null, combine with None at the end
+                        resolved_type = resolved_type | None if resolved_type else type(None)
+
+            return resolved_type if resolved_type is not None else Any
+
+        # Handle enum values
+        enum_vals = schema.get("enum")
+        if enum_vals:
+            # Check if enum contains null
+            has_null = any(val is None or val == "null" for val in enum_vals)
+            # Filter out None/null values from enum
+            non_null_vals = [v for v in enum_vals if v is not None and v != "null"]
+
+            if non_null_vals:
+                enum_name = f"{name.capitalize()}Enum"
+                enum_type: Any = Enum(enum_name, {item: item for item in non_null_vals})
+                # If enum had null, make it a union with None
+                return enum_type | None if has_null else enum_type
+            elif has_null:
+                # Enum only contains null
+                return type(None)
+            else:
+                # Empty enum (shouldn't happen but handle gracefully)
+                return Any
+
+        schema_type = schema.get("type")
+
+        # Handle type as list (e.g., ["string", "integer", "null"])
+        if isinstance(schema_type, list):
+            list_type: Any = None
+            for t in schema_type:
+                if t == "array":
+                    # Incorporate the mapped type of items
+                    item_schema = schema.get("items", {})
+                    if item_schema:
+                        item_type = _resolve_schema_type(item_schema, name)
+                        mapped = list[item_type]
+                    else:
+                        mapped = _type_map.get(t, Any)
+                elif t == "object":
+                    # Incorporate the mapped type from properties
+                    if "properties" in schema:
+                        mapped = model_from_mcp_schema(name=name, mcp_input_schema=schema)
+                    else:
+                        mapped = _type_map.get(t, Any)
+                else:
+                    mapped = _type_map.get(t, Any)
+
+                list_type = mapped if list_type is None else list_type | mapped
+            return list_type if list_type is not None else Any
+
+        # Handle null type
+        if schema_type == "null":
+            return type(None)
+
+        # Handle object type
+        if schema_type == "object" and "properties" in schema:
+            return model_from_mcp_schema(name=name, mcp_input_schema=schema)
+
+        # Handle array type
+        if schema_type == "array" and "items" in schema:
+            item_schema = schema.get("items", {})
+            # Recursively resolve item type (handles nested anyOf/oneOf)
+            item_type = _resolve_schema_type(item_schema, name)
+            return list[item_type]
+
+        # Handle primitive types
+        if schema_type is not None:
+            return _type_map.get(schema_type, Any)
+
+        return Any
+
+    def _has_null_in_type(field_properties: dict[str, Any]) -> bool:
+        """Check if a schema contains null as a valid type."""
+        # Check anyOf/oneOf for null
+        any_of = field_properties.get("anyOf")
+        one_of = field_properties.get("oneOf")
+        if any_of or one_of:
+            union_schemas = any_of if any_of else one_of
+            if union_schemas:
+                for schema in union_schemas:
+                    if schema.get("type") == "null":
+                        return True
+
+        # Check type list for null
+        json_type = field_properties.get("type")
+        if isinstance(json_type, list) and "null" in json_type:
+            return True
+
+        # Check enum for null (Python None or string "null")
+        enum_vals = field_properties.get("enum")
+        if enum_vals:
+            for val in enum_vals:
+                if val is None or val == "null":
+                    return True
+
+        # Check const for null (Python None or string "null")
+        if "const" in field_properties:
+            const_val = field_properties.get("const")
+            if const_val is None or const_val == "null":
+                return True
+
+        return False
+
+    def _generate_field(field_name: str, field_properties: dict[str, Any]) -> tuple:
+        """
+        Generate a Pydantic field from JSON schema properties.
+        Uses _resolve_schema_type for type resolution and handles field-specific logic.
+        """
+        # Resolve the field type using the unified resolver
+        field_type = _resolve_schema_type(field_properties, field_name)
+
+        # Check if the type includes null
+        has_null = _has_null_in_type(field_properties)
+
+        # Determine the default value based on whether the field is required
+        default_value = field_properties.get("default")
+
+        if field_name in required_fields:
+            # Field is required - use explicit default if provided, otherwise use ... to enforce presence
+            if default_value is None and "default" not in field_properties:
+                # Required field without explicit default: always use ... even if nullable
+                default_value = ...
+            # Make the field type nullable if it allows null
+            if has_null:
+                field_type = field_type | None
+        else:
+            # Field is optional - use explicit default if provided, otherwise None
+            if default_value is None:
+                default_value = None
+            # Make the type optional if no default was provided and not already nullable
+            if "default" not in field_properties and not has_null:
+                field_type = field_type | None
+
+        # Handle nullable property (less common, but still supported)
+        nullable = field_properties.get("nullable", False)
+        if nullable and not has_null:
+            field_type = field_type | None
+
+        description = field_properties.get("description", "")
+
+        return field_type, Field(default=default_value, description=description)
+
+    for field_name, field_props in properties.items():
+        schema_dict[field_name] = _generate_field(field_name=field_name, field_properties=field_props)
+    return create_model(f"{_generate_valid_classname(name)}InputSchema", **schema_dict)

nvidia_nat_mcp-1.4.0a20260107.dist-info/METADATA

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: nvidia-nat-mcp
+Version: 1.4.0a20260107
+Summary: Subpackage for MCP client integration in NeMo Agent toolkit
+Author: NVIDIA Corporation
+Maintainer: NVIDIA Corporation
+License: Apache-2.0
+Project-URL: documentation, https://docs.nvidia.com/nemo/agent-toolkit/latest/
+Project-URL: source, https://github.com/NVIDIA/NeMo-Agent-Toolkit
+Keywords: ai,rag,agents,mcp
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.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.0a20260107
+Requires-Dist: aiorwlock~=1.5.0
+Requires-Dist: mcp~=1.25
+Dynamic: license-file
+
+<!--
+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.
+-->
+
+![NVIDIA NeMo Agent Toolkit](https://media.githubusercontent.com/media/NVIDIA/NeMo-Agent-Toolkit/refs/heads/main/docs/source/_static/banner.png "NeMo Agent toolkit banner image")
+
+
+# NVIDIA NeMo Agent Toolkit MCP Subpackage
+Subpackage for MCP integration in NeMo Agent toolkit.
+
+This package provides MCP (Model Context Protocol) functionality, allowing NeMo Agent toolkit workflows to connect to external MCP servers and use their tools as functions.
+
+## Features
+
+- Connect to MCP servers via streamable-http, SSE, or stdio transports
+- Wrap individual MCP tools as NeMo Agent toolkit functions
+- Connect to MCP servers and dynamically discover available tools
+
+For more information about the NVIDIA NeMo Agent toolkit, please visit the [NeMo Agent toolkit GitHub Repo](https://github.com/NVIDIA/NeMo-Agent-Toolkit).

nvidia_nat_mcp-1.4.0a20260107.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=qWyeDgieorQC4IziiOxMrITqpyvZGh7w11F7QTKwuCk,4148
+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=cBdNXslsihsHOXbS5MoDbabbEB4milfRHLGOTEodDDg,46602
+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=OBk1sMjH_1coBXj3dYXNWyoK4wofVQERt3_0gLscP4I,17992
+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=Y-3Cr8jNrRjQFFFmmILIeUI6kO3C_CUpCZ2k9NJnJdk,11339
+nvidia_nat_mcp-1.4.0a20260107.dist-info/licenses/LICENSE-3rd-party.txt,sha256=fOk5jMmCX9YoKWyYzTtfgl-SUy477audFC5hNY4oP7Q,284609
+nvidia_nat_mcp-1.4.0a20260107.dist-info/licenses/LICENSE.md,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+nvidia_nat_mcp-1.4.0a20260107.dist-info/METADATA,sha256=9otJsZHNUMeKwR5lTUW4cTfwSZ9VKrIcODC38JNm2Mc,2326
+nvidia_nat_mcp-1.4.0a20260107.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nvidia_nat_mcp-1.4.0a20260107.dist-info/entry_points.txt,sha256=t5HYRfXR-dyZf6BWRz1u1TqPprKpCWt-WLHKQXfiLLU,231
+nvidia_nat_mcp-1.4.0a20260107.dist-info/top_level.txt,sha256=8-CJ2cP6-f0ZReXe5Hzqp-5pvzzHz-5Ds5H2bGqh1-U,4
+nvidia_nat_mcp-1.4.0a20260107.dist-info/RECORD,,

nvidia_nat_mcp-1.4.0a20260107.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

nvidia_nat_mcp-1.4.0a20260107.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