nvidia-nat 1.3.0a20250917__py3-none-any.whl → 1.3.0a20250923__py3-none-any.whl

nat/data_models/agent.py

@@ -0,0 +1,34 @@
+# 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.
+
+from pydantic import Field
+from pydantic import PositiveInt
+
+from nat.data_models.component_ref import LLMRef
+from nat.data_models.function import FunctionBaseConfig
+
+
+class AgentBaseConfig(FunctionBaseConfig):
+    """Base configuration class for all NAT agents with common fields."""
+
+    workflow_alias: str | None = Field(
+        default=None,
+        description=("The alias of the workflow. Useful when the agent is configured as a workflow "
+                     "and needs to expose a customized name as a tool."))
+    llm_name: LLMRef = Field(description="The LLM model to use with the agent.")
+    verbose: bool = Field(default=False, description="Set the verbosity of the agent's logging.")
+    description: str = Field(description="The description of this function's use.")
+    log_response_max_chars: PositiveInt = Field(
+        default=1000, description="Maximum number of characters to display in logs when logging responses.")

nat/data_models/authentication.py

@@ -177,6 +177,26 @@ Credential = typing.Annotated[
 ]
 
 
+class TokenValidationResult(BaseModel):
+    """
+    Standard result for Bearer Token Validation.
+    """
+    model_config = ConfigDict(extra="forbid")
+
+    client_id: str | None = Field(description="OAuth2 client identifier")
+    scopes: list[str] | None = Field(default=None, description="List of granted scopes (introspection only)")
+    expires_at: int | None = Field(default=None, description="Token expiration time (Unix timestamp)")
+    audience: list[str] | None = Field(default=None, description="Token audiences (aud claim)")
+    subject: str | None = Field(default=None, description="Token subject (sub claim)")
+    issuer: str | None = Field(default=None, description="Token issuer (iss claim)")
+    token_type: str = Field(description="Token type")
+    active: bool | None = Field(default=True, description="Token active status")
+    nbf: int | None = Field(default=None, description="Not before time (Unix timestamp)")
+    iat: int | None = Field(default=None, description="Issued at time (Unix timestamp)")
+    jti: str | None = Field(default=None, description="JWT ID")
+    username: str | None = Field(default=None, description="Username (introspection only)")
+
+
 class AuthResult(BaseModel):
     """
     Represents the result of an authentication process.
@@ -229,3 +249,21 @@ class AuthResult(BaseModel):
                 target_kwargs.setdefault(k, {}).update(v)
             else:
                 target_kwargs[k] = v
+
+
+class AuthReason(str, Enum):
+    """
+    Why the caller is asking for auth now.
+    """
+    NORMAL = "normal"
+    RETRY_AFTER_401 = "retry_after_401"
+
+
+class AuthRequest(BaseModel):
+    """
+    Authentication request payload for provider.authenticate(...).
+    """
+    model_config = ConfigDict(extra="forbid")
+
+    reason: AuthReason = Field(default=AuthReason.NORMAL, description="Purpose of this auth attempt.")
+    www_authenticate: str | None = Field(default=None, description="Raw WWW-Authenticate header from a 401 response.")

nat/front_ends/fastapi/dask_client_mixin.py

@@ -16,7 +16,9 @@
 import typing
 from abc import ABC
 from collections.abc import AsyncGenerator
+from collections.abc import Generator
 from contextlib import asynccontextmanager
+from contextlib import contextmanager
 
 if typing.TYPE_CHECKING:
     from dask.distributed import Client
@@ -27,17 +29,37 @@ class DaskClientMixin(ABC):
     @asynccontextmanager
     async def client(self, address: str) -> AsyncGenerator["Client"]:
         """
-        Async context manager for obtaining a Dask client connection.
+        Async context manager for obtaining a Dask client.
 
         Yields
         ------
         Client
-            An active Dask client connected to the scheduler. The client is automatically closed when exiting the
+            An async Dask client connected to the scheduler. The client is automatically closed when exiting the
             context manager.
         """
         from dask.distributed import Client
         client = await Client(address=address, asynchronous=True)
 
-        yield client
+        try:
+            yield client
+        finally:
+            await client.close()
 
-        await client.close()
+    @contextmanager
+    def blocking_client(self, address: str) -> Generator["Client"]:
+        """
+        context manager for obtaining a blocking Dask client.
+
+        Yields
+        ------
+        Client
+            A blocking Dask client connected to the scheduler. The client is automatically closed when exiting the
+            context manager.
+        """
+        from dask.distributed import Client
+        client = Client(address=address)
+
+        try:
+            yield client
+        finally:
+            client.close()

nat/front_ends/fastapi/fastapi_front_end_config.py

@@ -211,6 +211,10 @@ class FastApiFrontEndConfig(FrontEndBaseConfig, name="fastapi"):
             "Maximum number of async jobs to run concurrently, this controls the number of dask workers created. "
             "This parameter is only used when scheduler_address is `None` and a Dask local cluster is created."),
         ge=1)
+    dask_log_level: str = Field(
+        default="WARNING",
+        description="Logging level for Dask.",
+    )
     step_adaptor: StepAdaptorConfig = StepAdaptorConfig()
 
     workflow: typing.Annotated[EndpointBase, Field(description="Endpoint for the default workflow.")] = EndpointBase(

nat/front_ends/fastapi/fastapi_front_end_plugin.py

@@ -27,6 +27,7 @@ from nat.front_ends.fastapi.fastapi_front_end_plugin_worker import FastApiFrontE
 from nat.front_ends.fastapi.main import get_app
 from nat.front_ends.fastapi.utils import get_class_name
 from nat.utils.io.yaml_tools import yaml_dump
+from nat.utils.log_levels import LOG_LEVELS
 
 if (typing.TYPE_CHECKING):
     from nat.data_models.config import Config
@@ -79,16 +80,23 @@ class FastApiFrontEndPlugin(DaskClientMixin, FrontEndBase[FastApiFrontEndConfig]
             except:  # noqa: E722
                 logger.exception("Error during job cleanup")
 
-    async def _submit_cleanup_task(self, scheduler_address: str, db_url: str):
+    async def _submit_cleanup_task(self, scheduler_address: str, db_url: str, log_level: int = logging.INFO):
         """Submit a cleanup task to the cluster to remove the job after expiry."""
-        logger.info("Submitting periodic cleanup task to Dask cluster at %s", scheduler_address)
+        logger.debug("Submitting periodic cleanup task to Dask cluster at %s", scheduler_address)
         async with self.client(self._scheduler_address) as client:
             self._periodic_cleanup_future = client.submit(self._periodic_cleanup,
                                                           scheduler_address=self._scheduler_address,
                                                           db_url=db_url,
-                                                          log_level=logger.getEffectiveLevel())
+                                                          log_level=log_level)
 
-        logger.info("Submitted periodic cleanup task to Dask cluster at %s", scheduler_address)
+    @staticmethod
+    def _setup_worker():
+        """
+        Setup function to be run in each worker process. This moves each worker into it's own process group.
+        This fixes an issue where a Ctrl-C in the terminal sends a SIGINT to all workers, which then causes the
+        workers to exit before the main process can shutdown the cluster gracefully.
+        """
+        os.setsid()
 
     async def run(self):
 
@@ -102,15 +110,27 @@ class FastApiFrontEndPlugin(DaskClientMixin, FrontEndBase[FastApiFrontEndConfig]
             # 1. Dask is installed and scheduler_address is None, we create a LocalCluster
             # 2. Dask is installed and scheduler_address is set, we use the existing cluster
             # 3. Dask is not installed, we skip the cluster setup
+            dask_log_level = LOG_LEVELS.get(self.front_end_config.dask_log_level.upper(), logging.WARNING)
+            dask_logger = logging.getLogger("distributed")
+            dask_logger.setLevel(dask_log_level)
+
             self._scheduler_address = self.front_end_config.scheduler_address
             if self._scheduler_address is None:
                 try:
+
                     from dask.distributed import LocalCluster
 
-                    self._cluster = LocalCluster(n_workers=self.front_end_config.max_running_async_jobs,
+                    self._cluster = LocalCluster(processes=True,
+                                                 silence_logs=dask_log_level,
+                                                 n_workers=self.front_end_config.max_running_async_jobs,
                                                  threads_per_worker=1)
 
                     self._scheduler_address = self._cluster.scheduler.address
+
+                    with self.blocking_client(self._scheduler_address) as client:
+                        # Client.run submits a function to be run on each worker
+                        client.run(self._setup_worker)
+
                     logger.info("Created local Dask cluster with scheduler at %s", self._scheduler_address)
 
                 except ImportError:
@@ -128,7 +148,9 @@ class FastApiFrontEndPlugin(DaskClientMixin, FrontEndBase[FastApiFrontEndConfig]
 
                 # If self.front_end_config.db_url is None, then we need to get the actual url from the engine
                 db_url = str(db_engine.url)
-                await self._submit_cleanup_task(scheduler_address=self._scheduler_address, db_url=db_url)
+                await self._submit_cleanup_task(scheduler_address=self._scheduler_address,
+                                                db_url=db_url,
+                                                log_level=dask_log_level)
 
                 # Set environment variabls such that the worker subprocesses will know how to connect to dask and to
                 # the database
@@ -216,8 +238,9 @@ class FastApiFrontEndPlugin(DaskClientMixin, FrontEndBase[FastApiFrontEndConfig]
 
             if self._cluster is not None:
                 # Only shut down the cluster if we created it
-                logger.info("Closing Local Dask cluster.")
+                logger.debug("Closing Local Dask cluster.")
                 self._cluster.close()
+
             try:
                 os.remove(config_file_name)
             except OSError as e:

nat/front_ends/mcp/introspection_token_verifier.py

@@ -0,0 +1,73 @@
+# 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.
+"""OAuth 2.0 Token Introspection verifier implementation for MCP servers."""
+
+import logging
+
+from mcp.server.auth.provider import AccessToken
+from mcp.server.auth.provider import TokenVerifier
+
+from nat.authentication.credential_validator.bearer_token_validator import BearerTokenValidator
+from nat.authentication.oauth2.oauth2_resource_server_config import OAuth2ResourceServerConfig
+
+logger = logging.getLogger(__name__)
+
+
+class IntrospectionTokenVerifier(TokenVerifier):
+    """Token verifier that delegates token verification to BearerTokenValidator."""
+
+    def __init__(self, config: OAuth2ResourceServerConfig):
+        """Create IntrospectionTokenVerifier from OAuth2ResourceServerConfig.
+
+        Args:
+            config: OAuth2ResourceServerConfig
+        """
+        issuer = config.issuer_url
+        scopes = config.scopes or []
+        audience = config.audience
+        jwks_uri = config.jwks_uri
+        introspection_endpoint = config.introspection_endpoint
+        discovery_url = config.discovery_url
+        client_id = config.client_id
+        client_secret = config.client_secret
+
+        self._bearer_token_validator = BearerTokenValidator(
+            issuer=issuer,
+            audience=audience,
+            scopes=scopes,
+            jwks_uri=jwks_uri,
+            introspection_endpoint=introspection_endpoint,
+            discovery_url=discovery_url,
+            client_id=client_id,
+            client_secret=client_secret,
+        )
+
+    async def verify_token(self, token: str) -> AccessToken | None:
+        """Verify token by delegating to BearerTokenValidator.
+
+        Args:
+            token: The Bearer token to verify
+
+        Returns:
+            AccessToken | None: AccessToken if valid, None if invalid
+        """
+        validation_result = await self._bearer_token_validator.verify(token)
+
+        if validation_result.active:
+            return AccessToken(token=token,
+                               expires_at=validation_result.expires_at,
+                               scopes=validation_result.scopes or [],
+                               client_id=validation_result.client_id or "")
+        return None

nat/front_ends/mcp/mcp_front_end_config.py

@@ -17,13 +17,14 @@ from typing import Literal
 
 from pydantic import Field
 
+from nat.authentication.oauth2.oauth2_resource_server_config import OAuth2ResourceServerConfig
 from nat.data_models.front_end import FrontEndBaseConfig
 
 
 class MCPFrontEndConfig(FrontEndBaseConfig, name="mcp"):
     """MCP front end configuration.
 
-    A simple MCP (Modular Communication Protocol) front end for NeMo Agent toolkit.
+    A simple MCP (Model Context Protocol) front end for NeMo Agent toolkit.
     """
 
     name: str = Field(default="NeMo Agent Toolkit MCP",
@@ -39,3 +40,6 @@ 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)")
+
+    server_auth: OAuth2ResourceServerConfig | None = Field(
+        default=None, description=("OAuth 2.0 Resource Server configuration for token verification."))

nat/front_ends/mcp/mcp_front_end_plugin.py

@@ -16,6 +16,7 @@
 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
@@ -55,25 +56,50 @@ 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 an MCP server with the configured parameters
-        mcp = FastMCP(
-            self.front_end_config.name,
-            host=self.front_end_config.host,
-            port=self.front_end_config.port,
-            debug=self.front_end_config.debug,
-            log_level=self.front_end_config.log_level,
-        )
-
-        # Get the worker instance and set up routes
-        worker = self._get_worker_instance()
+        # 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
+            worker = self._get_worker_instance()
+
             # Add routes through the worker (includes health endpoint and function registration)
             await worker.add_routes(mcp, builder)
 

nat/front_ends/mcp/mcp_front_end_plugin_worker.py

@@ -16,11 +16,15 @@
 import logging
 from abc import ABC
 from abc import abstractmethod
+from collections.abc import Mapping
+from typing import Any
 
 from mcp.server.fastmcp import FastMCP
+from starlette.exceptions import HTTPException
 from starlette.requests import Request
 
 from nat.builder.function import Function
+from nat.builder.function_base import FunctionBase
 from nat.builder.workflow import Workflow
 from nat.builder.workflow_builder import WorkflowBuilder
 from nat.data_models.config import Config
@@ -98,10 +102,110 @@ class MCPFrontEndPluginWorkerBase(ABC):
         for function_group in workflow.function_groups.values():
             functions.update(function_group.get_accessible_functions())
 
-        functions[workflow.config.workflow.type] = workflow
+        if workflow.config.workflow.workflow_alias:
+            functions[workflow.config.workflow.workflow_alias] = workflow
+        else:
+            functions[workflow.config.workflow.type] = workflow
 
         return functions
 
+    def _setup_debug_endpoints(self, mcp: FastMCP, functions: Mapping[str, FunctionBase]) -> None:
+        """Set up HTTP debug endpoints for introspecting tools and schemas.
+
+        Exposes:
+          - GET /debug/tools/list: List tools. Optional query param `name` (one or more, repeatable or comma separated)
+            selects a subset and returns details for those tools.
+        """
+
+        @mcp.custom_route("/debug/tools/list", methods=["GET"])
+        async def list_tools(request: Request):
+            """HTTP list tools endpoint."""
+
+            from starlette.responses import JSONResponse
+
+            from nat.front_ends.mcp.tool_converter import get_function_description
+
+            # Query params
+            # Support repeated names and comma-separated lists
+            names_param_list = set(request.query_params.getlist("name"))
+            names: list[str] = []
+            for raw in names_param_list:
+                # if p.strip() is empty, it won't be included in the list!
+                parts = [p.strip() for p in raw.split(",") if p.strip()]
+                names.extend(parts)
+            detail_raw = request.query_params.get("detail")
+
+            def _parse_detail_param(detail_param: str | None, has_names: bool) -> bool:
+                if detail_param is None:
+                    if has_names:
+                        return True
+                    return False
+                v = detail_param.strip().lower()
+                if v in ("0", "false", "no", "off"):
+                    return False
+                if v in ("1", "true", "yes", "on"):
+                    return True
+                # For invalid values, default based on whether names are present
+                return has_names
+
+            # Helper function to build the input schema info
+            def _build_schema_info(fn: FunctionBase) -> dict[str, Any] | None:
+                schema = getattr(fn, "input_schema", None)
+                if schema is None:
+                    return None
+
+                # check if schema is a ChatRequest
+                schema_name = getattr(schema, "__name__", "")
+                schema_qualname = getattr(schema, "__qualname__", "")
+                if "ChatRequest" in schema_name or "ChatRequest" in schema_qualname:
+                    # Simplified interface used by MCP wrapper for ChatRequest
+                    return {
+                        "type": "object",
+                        "properties": {
+                            "query": {
+                                "type": "string", "description": "User query string"
+                            }
+                        },
+                        "required": ["query"],
+                        "title": "ChatRequestQuery",
+                    }
+
+                # Pydantic models provide model_json_schema
+                if schema is not None and hasattr(schema, "model_json_schema"):
+                    return schema.model_json_schema()
+
+                return None
+
+            def _build_final_json(functions_to_include: Mapping[str, FunctionBase],
+                                  include_schemas: bool = False) -> dict[str, Any]:
+                tools = []
+                for name, fn in functions_to_include.items():
+                    list_entry: dict[str, Any] = {
+                        "name": name, "description": get_function_description(fn), "is_workflow": hasattr(fn, "run")
+                    }
+                    if include_schemas:
+                        list_entry["schema"] = _build_schema_info(fn)
+                    tools.append(list_entry)
+
+                return {
+                    "count": len(tools),
+                    "tools": tools,
+                    "server_name": mcp.name,
+                }
+
+            if names:
+                # Return selected tools
+                try:
+                    functions_to_include = {n: functions[n] for n in names}
+                except KeyError as e:
+                    raise HTTPException(status_code=404, detail=f"Tool \"{e.args[0]}\" not found.") from e
+            else:
+                functions_to_include = functions
+
+            # Default for listing all: detail defaults to False unless explicitly set true
+            return JSONResponse(
+                _build_final_json(functions_to_include, _parse_detail_param(detail_raw, has_names=bool(names))))
+
 
 class MCPFrontEndPluginWorker(MCPFrontEndPluginWorkerBase):
     """Default MCP front end plugin worker implementation."""
@@ -142,3 +246,6 @@ class MCPFrontEndPluginWorker(MCPFrontEndPluginWorkerBase):
         # 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)

nat/front_ends/mcp/tool_converter.py

@@ -229,6 +229,9 @@ def get_function_description(function: FunctionBase) -> str:
         # 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

nat/observability/mixin/type_introspection_mixin.py

@@ -15,6 +15,7 @@
 
 import inspect
 import logging
+import types
 from functools import lru_cache
 from typing import Any
 from typing import TypeVar
@@ -475,3 +476,21 @@ class TypeIntrospectionMixin:
         except ValidationError:
             logger.warning("Item %s is not compatible with output type %s", item, self.output_type)
             return False
+
+    @lru_cache
+    def extract_non_optional_type(self, type_obj: type | types.UnionType) -> Any:
+        """Extract the non-None type from Optional[T] or Union[T, None] types.
+
+        This is useful when you need to pass a type to a system that doesn't
+        understand Optional types (like registries that expect concrete types).
+
+        Args:
+            type_obj (type | types.UnionType): The type to extract from (could be Optional[T] or Union[T, None])
+
+        Returns:
+            Any: The actual type without None, or the original type if not a union with None
+        """
+        decomposed = DecomposedType(type_obj)  # type: ignore[arg-type]
+        if decomposed.is_optional:
+            return decomposed.get_optional_type().type
+        return type_obj

nat/profiler/parameter_optimization/parameter_optimizer.py

@@ -28,7 +28,6 @@ from nat.eval.evaluate import EvaluationRun
 from nat.eval.evaluate import EvaluationRunConfig
 from nat.experimental.decorators.experimental_warning_decorator import experimental
 from nat.profiler.parameter_optimization.parameter_selection import pick_trial
-from nat.profiler.parameter_optimization.pareto_visualizer import create_pareto_visualization
 from nat.profiler.parameter_optimization.update_helpers import apply_suggestions
 
 logger = logging.getLogger(__name__)
@@ -133,6 +132,7 @@ def optimize_parameters(
 
     # Generate Pareto front visualizations
     try:
+        from nat.profiler.parameter_optimization.pareto_visualizer import create_pareto_visualization
         logger.info("Generating Pareto front visualizations...")
         create_pareto_visualization(
             data_source=study,
@@ -143,6 +143,10 @@ def optimize_parameters(
             show_plots=False  # Don't show plots in automated runs
         )
         logger.info("Pareto visualizations saved to: %s", out_dir / "plots")
+    except ImportError as ie:
+        logger.warning("Could not import visualization dependencies: %s. "
+                       "Have you installed nvidia-nat-profiling?",
+                       ie)
     except Exception as e:
         logger.warning("Failed to generate visualizations: %s", e)
 

nat/utils/log_levels.py

@@ -0,0 +1,25 @@
+# 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
+
+# Define log level choices
+LOG_LEVELS = {
+    'DEBUG': logging.DEBUG,
+    'INFO': logging.INFO,
+    'WARNING': logging.WARNING,
+    'ERROR': logging.ERROR,
+    'CRITICAL': logging.CRITICAL
+}

{nvidia_nat-1.3.0a20250917.dist-info → nvidia_nat-1.3.0a20250923.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nvidia-nat
-Version: 1.3.0a20250917
+Version: 1.3.0a20250923
 Summary: NVIDIA NeMo Agent toolkit
 Author: NVIDIA Corporation
 Maintainer: NVIDIA Corporation
@@ -225,6 +225,7 @@ Requires-Dist: httpx~=0.27
 Requires-Dist: jinja2~=3.1
 Requires-Dist: jsonpath-ng~=1.7
 Requires-Dist: mcp~=1.13
+Requires-Dist: nest-asyncio~=1.6
 Requires-Dist: networkx~=3.4
 Requires-Dist: numpy~=1.26; python_version < "3.12"
 Requires-Dist: numpy~=2.3; python_version >= "3.12"
@@ -299,6 +300,7 @@ Requires-Dist: nat_redact_pii; extra == "examples"
 Requires-Dist: nat_retail_sales_agent; extra == "examples"
 Requires-Dist: nat_router_agent; extra == "examples"
 Requires-Dist: nat_semantic_kernel_demo; extra == "examples"
+Requires-Dist: nat_sequential_executor; extra == "examples"
 Requires-Dist: nat_simple_auth; extra == "examples"
 Requires-Dist: nat_simple_web_query; extra == "examples"
 Requires-Dist: nat_simple_web_query_eval; extra == "examples"