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

nat/cli/entrypoint.py

@@ -35,6 +35,7 @@ from nat.utils.log_levels import LOG_LEVELS
 from .commands.configure.configure import configure_command
 from .commands.evaluate import eval_command
 from .commands.info.info import info_command
+from .commands.mcp.mcp import mcp_command
 from .commands.object_store.object_store import object_store_command
 from .commands.optimize import optimizer_command
 from .commands.registry.registry import registry_command
@@ -104,11 +105,11 @@ cli.add_command(workflow_command, name="workflow")
 cli.add_command(sizing, name="sizing")
 cli.add_command(optimizer_command, name="optimize")
 cli.add_command(object_store_command, name="object-store")
+cli.add_command(mcp_command, name="mcp")
 
 # Aliases
 cli.add_command(start_command.get_command(None, "console"), name="run")  # type: ignore
 cli.add_command(start_command.get_command(None, "fastapi"), name="serve")  # type: ignore
-cli.add_command(start_command.get_command(None, "mcp"), name="mcp")  # type: ignore
 
 
 @cli.result_callback()

nat/control_flow/router_agent/register.py

@@ -53,7 +53,7 @@ async def router_agent_workflow(config: RouterAgentWorkflowConfig, builder: Buil
 
     prompt = create_router_agent_prompt(config)
     llm = await builder.get_llm(config.llm_name, wrapper_type=LLMFrameworkEnum.LANGCHAIN)
-    branches = builder.get_tools(tool_names=config.branches, wrapper_type=LLMFrameworkEnum.LANGCHAIN)
+    branches = await builder.get_tools(tool_names=config.branches, wrapper_type=LLMFrameworkEnum.LANGCHAIN)
     if not branches:
         raise ValueError(f"No branches specified for Router Agent '{config.llm_name}'")
 

nat/control_flow/sequential_executor.py

@@ -80,14 +80,12 @@ def _validate_function_type_compatibility(src_fn: Function,
             f"the input type of the {target_fn.instance_name} function, which is {str(target_input_type)}")
 
 
-def _validate_tool_list_type_compatibility(sequential_executor_config: SequentialExecutorConfig,
-                                           builder: Builder) -> tuple[type, type]:
+async def _validate_tool_list_type_compatibility(sequential_executor_config: SequentialExecutorConfig,
+                                                 builder: Builder) -> tuple[type, type]:
     tool_list = sequential_executor_config.tool_list
     tool_execution_config = sequential_executor_config.tool_execution_config
 
-    function_list: list[Function] = []
-    for function_ref in tool_list:
-        function_list.append(builder.get_function(function_ref))
+    function_list = await builder.get_functions(tool_list)
     if not function_list:
         raise RuntimeError("The function list is empty")
     input_type = function_list[0].input_type
@@ -110,11 +108,12 @@ def _validate_tool_list_type_compatibility(sequential_executor_config: Sequentia
 async def sequential_execution(config: SequentialExecutorConfig, builder: Builder):
     logger.debug(f"Initializing sequential executor with tool list: {config.tool_list}")
 
-    tools: list[BaseTool] = builder.get_tools(tool_names=config.tool_list, wrapper_type=LLMFrameworkEnum.LANGCHAIN)
+    tools: list[BaseTool] = await builder.get_tools(tool_names=config.tool_list,
+                                                    wrapper_type=LLMFrameworkEnum.LANGCHAIN)
     tools_dict: dict[str, BaseTool] = {tool.name: tool for tool in tools}
 
     try:
-        input_type, output_type = _validate_tool_list_type_compatibility(config, builder)
+        input_type, output_type = await _validate_tool_list_type_compatibility(config, builder)
     except ValueError as e:
         if config.raise_type_incompatibility:
             logger.error(f"The sequential executor tool list has incompatible types: {e}")

nat/eval/evaluate.py

@@ -520,7 +520,8 @@ class EvaluationRun:
                     await self.run_workflow_remote()
                 elif not self.config.skip_workflow:
                     if session_manager is None:
-                        session_manager = SessionManager(eval_workflow.build(),
+                        workflow = await eval_workflow.build()
+                        session_manager = SessionManager(workflow,
                                                          max_concurrency=self.eval_config.general.max_concurrency)
                     await self.run_workflow_local(session_manager)
 

nat/eval/trajectory_evaluator/register.py

@@ -33,7 +33,7 @@ async def register_trajectory_evaluator(config: TrajectoryEvaluatorConfig, build
 
     from .evaluate import TrajectoryEvaluator
     llm = await builder.get_llm(config.llm_name, wrapper_type=LLMFrameworkEnum.LANGCHAIN)
-    tools = builder.get_all_tools(wrapper_type=LLMFrameworkEnum.LANGCHAIN)
+    tools = await builder.get_all_tools(wrapper_type=LLMFrameworkEnum.LANGCHAIN)
 
     _evaluator = TrajectoryEvaluator(llm, tools, builder.get_max_concurrency())
 

nat/experimental/decorators/experimental_warning_decorator.py

@@ -16,7 +16,12 @@
 import functools
 import inspect
 import logging
+from collections.abc import AsyncGenerator
+from collections.abc import Callable
+from collections.abc import Generator
 from typing import Any
+from typing import TypeVar
+from typing import overload
 
 logger = logging.getLogger(__name__)
 
@@ -25,6 +30,9 @@ BASE_WARNING_MESSAGE = ("is experimental and the API may change in future releas
 
 _warning_issued = set()
 
+# Type variables for overloads
+F = TypeVar('F', bound=Callable[..., Any])
+
 
 def issue_experimental_warning(function_name: str,
                                feature_name: str | None = None,
@@ -53,7 +61,20 @@ def issue_experimental_warning(function_name: str,
         _warning_issued.add(function_name)
 
 
-def experimental(func: Any = None, *, feature_name: str | None = None, metadata: dict[str, Any] | None = None):
+# Overloads for different function types
+@overload
+def experimental(func: F, *, feature_name: str | None = None, metadata: dict[str, Any] | None = None) -> F:
+    """Overload for when a function is passed directly."""
+    ...
+
+
+@overload
+def experimental(*, feature_name: str | None = None, metadata: dict[str, Any] | None = None) -> Callable[[F], F]:
+    """Overload for decorator factory usage (when called with parentheses)."""
+    ...
+
+
+def experimental(func: Any = None, *, feature_name: str | None = None, metadata: dict[str, Any] | None = None) -> Any:
     """
     Decorator that can wrap any type of function (sync, async, generator,
     async generator) and logs a warning that the function is experimental.
@@ -90,7 +111,7 @@ def experimental(func: Any = None, *, feature_name: str | None = None, metadata:
         # ---------------------
 
         @functools.wraps(func)
-        async def async_gen_wrapper(*args, **kwargs):
+        async def async_gen_wrapper(*args, **kwargs) -> AsyncGenerator[Any, Any]:
             issue_experimental_warning(function_name, feature_name, metadata)
             async for item in func(*args, **kwargs):
                 yield item  # yield the original item
@@ -102,7 +123,7 @@ def experimental(func: Any = None, *, feature_name: str | None = None, metadata:
         # ASYNC FUNCTION
         # ---------------------
         @functools.wraps(func)
-        async def async_wrapper(*args, **kwargs):
+        async def async_wrapper(*args, **kwargs) -> Any:
             issue_experimental_warning(function_name, feature_name, metadata)
             result = await func(*args, **kwargs)
             return result
@@ -114,7 +135,7 @@ def experimental(func: Any = None, *, feature_name: str | None = None, metadata:
         # SYNC GENERATOR
         # ---------------------
         @functools.wraps(func)
-        def sync_gen_wrapper(*args, **kwargs):
+        def sync_gen_wrapper(*args, **kwargs) -> Generator[Any, Any, Any]:
             issue_experimental_warning(function_name, feature_name, metadata)
             for item in func(*args, **kwargs):
                 yield item  # yield the original item
@@ -122,7 +143,7 @@ def experimental(func: Any = None, *, feature_name: str | None = None, metadata:
         return sync_gen_wrapper
 
     @functools.wraps(func)
-    def sync_wrapper(*args, **kwargs):
+    def sync_wrapper(*args, **kwargs) -> Any:
         issue_experimental_warning(function_name, feature_name, metadata)
         result = func(*args, **kwargs)
         return result

nat/experimental/test_time_compute/functions/plan_select_execute_function.py

@@ -86,7 +86,7 @@ async def plan_select_execute_function(config: PlanSelectExecuteFunctionConfig,
                           "This error can be resolved by installing nvidia-nat-langchain.")
 
     # Get the augmented function's description
-    augmented_function = builder.get_function(config.augmented_fn)
+    augmented_function = await builder.get_function(config.augmented_fn)
 
     # For now, we rely on runtime checking for type conversion
 
@@ -105,7 +105,7 @@ async def plan_select_execute_function(config: PlanSelectExecuteFunctionConfig,
     tool_list = "Tool: Description\n"
 
     for tool in function_used_tools:
-        tool_impl = builder.get_function(tool)
+        tool_impl = await builder.get_function(tool)
         tool_list += f"- {tool}: {tool_impl.description if hasattr(tool_impl, 'description') else ''}\n"
 
     # Draft the reasoning prompt for the augmented function

nat/experimental/test_time_compute/functions/ttc_tool_orchestration_function.py

@@ -82,7 +82,7 @@ async def register_ttc_tool_orchestration_function(
     function_map = {}
     for fn_ref in config.augmented_fns:
         # Retrieve the actual function from the builder
-        fn_obj = builder.get_function(fn_ref)
+        fn_obj = await builder.get_function(fn_ref)
         function_map[fn_ref] = fn_obj
 
     # 2) Instantiate search, editing, scoring, selection strategies (if any)

nat/experimental/test_time_compute/functions/ttc_tool_wrapper_function.py

@@ -80,7 +80,7 @@ async def register_ttc_tool_wrapper_function(
         raise ImportError("langchain-core is not installed. Please install it to use SingleShotMultiPlanPlanner.\n"
                           "This error can be resolved by installing nvidia-nat-langchain.")
 
-    augmented_function: Function = builder.get_function(config.augmented_fn)
+    augmented_function: Function = await builder.get_function(config.augmented_fn)
     input_llm: BaseChatModel = await builder.get_llm(config.input_llm, wrapper_type=LLMFrameworkEnum.LANGCHAIN)
 
     if not augmented_function.has_single_output:

nat/experimental/test_time_compute/models/strategy_base.py

@@ -46,11 +46,11 @@ class StrategyBase(ABC):
                       items: list[TTCItem],
                       original_prompt: str | None = None,
                       agent_context: str | None = None,
-                      **kwargs) -> [TTCItem]:
+                      **kwargs) -> list[TTCItem]:
         pass
 
     @abstractmethod
-    def supported_pipeline_types(self) -> [PipelineTypeEnum]:
+    def supported_pipeline_types(self) -> list[PipelineTypeEnum]:
         """Return the stage types supported by this selector."""
         pass
 

nat/front_ends/console/console_front_end_plugin.py

@@ -55,9 +55,10 @@ class ConsoleFrontEndPlugin(SimpleFrontEndPluginBase[ConsoleFrontEndConfig]):
         self.auth_flow_handler = ConsoleAuthenticationFlowHandler()
 
     async def pre_run(self):
-
-        if (not self.front_end_config.input_query and not self.front_end_config.input_file):
-            raise click.UsageError("Must specify either --input_query or --input_file")
+        if (self.front_end_config.input_query is not None and self.front_end_config.input_file is not None):
+            raise click.UsageError("Must specify either --input or --input_file, not both")
+        if (self.front_end_config.input_query is None and self.front_end_config.input_file is None):
+            raise click.UsageError("Must specify either --input or --input_file")
 
     async def run_workflow(self, session_manager: SessionManager):
 

nat/front_ends/fastapi/fastapi_front_end_plugin_worker.py

@@ -237,14 +237,14 @@ class FastApiFrontEndPluginWorker(FastApiFrontEndPluginWorkerBase):
 
     async def add_routes(self, app: FastAPI, builder: WorkflowBuilder):
 
-        await self.add_default_route(app, SessionManager(builder.build()))
-        await self.add_evaluate_route(app, SessionManager(builder.build()))
+        await self.add_default_route(app, SessionManager(await builder.build()))
+        await self.add_evaluate_route(app, SessionManager(await builder.build()))
         await self.add_static_files_route(app, builder)
         await self.add_authorization_route(app)
 
         for ep in self.front_end_config.endpoints:
 
-            entry_workflow = builder.build(entry_function=ep.function_name)
+            entry_workflow = await builder.build(entry_function=ep.function_name)
 
             await self.add_route(app, endpoint=ep, session_manager=SessionManager(entry_workflow))
 

nat/front_ends/mcp/mcp_front_end_plugin_worker.py

@@ -86,7 +86,7 @@ class MCPFrontEndPluginWorkerBase(ABC):
         """
         pass
 
-    def _get_all_functions(self, workflow: Workflow) -> dict[str, Function]:
+    async def _get_all_functions(self, workflow: Workflow) -> dict[str, Function]:
         """Get all functions from the workflow.
 
         Args:
@@ -100,7 +100,7 @@ class MCPFrontEndPluginWorkerBase(ABC):
         # Extract all functions from the workflow
         functions.update(workflow.functions)
         for function_group in workflow.function_groups.values():
-            functions.update(function_group.get_accessible_functions())
+            functions.update(await function_group.get_accessible_functions())
 
         if workflow.config.workflow.workflow_alias:
             functions[workflow.config.workflow.workflow_alias] = workflow
@@ -223,10 +223,10 @@ class MCPFrontEndPluginWorker(MCPFrontEndPluginWorkerBase):
         self._setup_health_endpoint(mcp)
 
         # Build the workflow and register all functions with MCP
-        workflow = builder.build()
+        workflow = await builder.build()
 
         # Get all functions from the workflow
-        functions = self._get_all_functions(workflow)
+        functions = await self._get_all_functions(workflow)
 
         # Filter functions based on tool_names if provided
         if self.front_end_config.tool_names:

nat/front_ends/simple_base/simple_front_end_plugin_base.py

@@ -35,6 +35,8 @@ class SimpleFrontEndPluginBase(FrontEndBase[FrontEndConfigT], ABC):
 
     async def run(self):
 
+        await self.pre_run()
+
         # Must yield the workflow function otherwise it cleans up
         async with WorkflowBuilder.from_config(config=self.full_config) as builder:
 
@@ -45,7 +47,7 @@ class SimpleFrontEndPluginBase(FrontEndBase[FrontEndConfigT], ABC):
 
                 click.echo(stream.getvalue())
 
-            workflow = builder.build()
+            workflow = await builder.build()
             session_manager = SessionManager(workflow)
             await self.run_workflow(session_manager)
 

nat/llm/litellm_llm.py

@@ -0,0 +1,69 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-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 collections.abc import AsyncIterator
+
+from pydantic import AliasChoices
+from pydantic import ConfigDict
+from pydantic import Field
+
+from nat.builder.builder import Builder
+from nat.builder.llm import LLMProviderInfo
+from nat.cli.register_workflow import register_llm_provider
+from nat.data_models.llm import LLMBaseConfig
+from nat.data_models.retry_mixin import RetryMixin
+from nat.data_models.temperature_mixin import TemperatureMixin
+from nat.data_models.thinking_mixin import ThinkingMixin
+from nat.data_models.top_p_mixin import TopPMixin
+
+
+class LiteLlmModelConfig(
+        LLMBaseConfig,
+        RetryMixin,
+        TemperatureMixin,
+        TopPMixin,
+        ThinkingMixin,
+        name="litellm",
+):
+    """A LiteLlm provider to be used with an LLM client."""
+
+    model_config = ConfigDict(protected_namespaces=(), extra="allow")
+
+    api_key: str | None = Field(default=None, description="API key to interact with hosted model.")
+    base_url: str | None = Field(default=None,
+                                 description="Base url to the hosted model.",
+                                 validation_alias=AliasChoices("base_url", "api_base"),
+                                 serialization_alias="api_base")
+    model_name: str = Field(validation_alias=AliasChoices("model_name", "model"),
+                            serialization_alias="model",
+                            description="The LiteLlm hosted model name.")
+    seed: int | None = Field(default=None, description="Random seed to set for generation.")
+
+
+@register_llm_provider(config_type=LiteLlmModelConfig)
+async def litellm_model(
+    config: LiteLlmModelConfig,
+    _builder: Builder,
+) -> AsyncIterator[LLMProviderInfo]:
+    """Litellm model provider.
+
+    Args:
+        config (LiteLlmModelConfig): The LiteLlm model configuration.
+        _builder (Builder): The NAT builder instance.
+
+    Returns:
+        AsyncIterator[LLMProviderInfo]: An async iterator that yields an LLMProviderInfo object.
+    """
+    yield LLMProviderInfo(config=config, description="A LiteLlm model for use with an LLM client.")

nat/llm/register.py

@@ -15,9 +15,13 @@
 
 # flake8: noqa
 # isort:skip_file
+"""Register LLM providers via import side effects.
 
+This module is imported by the NeMo Agent Toolkit runtime to ensure providers are registered and discoverable.
+"""
 # Import any providers which need to be automatically registered here
 from . import aws_bedrock_llm
 from . import azure_openai_llm
 from . import nim_llm
 from . import openai_llm
+from . import litellm_llm

nat/profiler/decorators/framework_wrapper.py

@@ -17,6 +17,7 @@ from __future__ import annotations
 
 import functools
 import logging
+from collections.abc import AsyncIterator
 from collections.abc import Callable
 from contextlib import AbstractAsyncContextManager as AsyncContextManager
 from contextlib import asynccontextmanager
@@ -32,20 +33,37 @@ _library_instrumented = {
     "crewai": False,
     "semantic_kernel": False,
     "agno": False,
+    "adk": False,
 }
 
 callback_handler_var: ContextVar[Any | None] = ContextVar("callback_handler_var", default=None)
 
 
 def set_framework_profiler_handler(
-    workflow_llms: dict = None,
-    frameworks: list[LLMFrameworkEnum] = None,
+    workflow_llms: dict | None = None,
+    frameworks: list[LLMFrameworkEnum] | None = None,
 ) -> Callable[[Callable[..., AsyncContextManager[Any]]], Callable[..., AsyncContextManager[Any]]]:
     """
     Decorator that wraps an async context manager function to set up framework-specific profiling.
+
+    Args:
+        workflow_llms (dict | None): A dictionary of workflow LLM configurations.
+        frameworks (list[LLMFrameworkEnum] | None): A list of LLM frameworks used in the workflow functions.
+
+    Returns:
+        Callable[[Callable[..., AsyncContextManager[Any]]], Callable[..., AsyncContextManager[Any]]]:
+        A decorator that wraps the original function with profiling setup.
     """
 
     def decorator(func: Callable[..., AsyncContextManager[Any]]) -> Callable[..., AsyncContextManager[Any]]:
+        """The actual decorator that wraps the function.
+
+        Args:
+            func (Callable[..., AsyncContextManager[Any]]): The function to wrap.
+
+        Returns:
+            Callable[..., AsyncContextManager[Any]]: The wrapped function.
+        """
 
         @functools.wraps(func)
         @asynccontextmanager
@@ -99,6 +117,20 @@ def set_framework_profiler_handler(
                 _library_instrumented["agno"] = True
                 logger.info("Agno callback handler registered")
 
+            if LLMFrameworkEnum.ADK in frameworks and not _library_instrumented["adk"]:
+                try:
+                    from nat.plugins.adk.adk_callback_handler import ADKProfilerHandler
+                except ImportError as e:
+                    logger.warning(
+                        "ADK profiler not available. " +
+                        "Install NAT with ADK extras: pip install 'nvidia-nat[adk]'. Error: %s",
+                        e)
+                else:
+                    handler = ADKProfilerHandler()
+                    handler.instrument()
+                    _library_instrumented["adk"] = True
+                    logger.debug("ADK callback handler registered")
+
             # IMPORTANT: actually call the wrapped function as an async context manager
             async with func(workflow_config, builder) as result:
                 yield result
@@ -117,11 +149,28 @@ def chain_wrapped_build_fn(
     Convert an original build function into an async context manager that
     wraps it with a single call to set_framework_profiler_handler, passing
     all frameworks at once.
+
+    Args:
+        original_build_fn (Callable[..., AsyncContextManager]): The original build function to wrap.
+        workflow_llms (dict): A dictionary of workflow LLM configurations.
+        function_frameworks (list[LLMFrameworkEnum]): A list of LLM frameworks used in the workflow functions.
+
+    Returns:
+        Callable[..., AsyncContextManager]: The wrapped build function.
     """
 
     # Define a base async context manager that simply calls the original build function.
     @asynccontextmanager
-    async def base_fn(*args, **kwargs):
+    async def base_fn(*args, **kwargs) -> AsyncIterator[Any]:
+        """Base async context manager that calls the original build function.
+
+        Args:
+            *args: Positional arguments to pass to the original build function.
+            **kwargs: Keyword arguments to pass to the original build function.
+
+        Yields:
+            The result of the original build function.
+        """
         async with original_build_fn(*args, **kwargs) as w:
             yield w
 

nat/profiler/decorators/function_tracking.py

@@ -18,7 +18,9 @@ import inspect
 import uuid
 from collections.abc import Callable
 from typing import Any
+from typing import TypeVar
 from typing import cast
+from typing import overload
 
 from pydantic import BaseModel
 
@@ -77,7 +79,24 @@ def push_intermediate_step(step_manager: IntermediateStepManager,
     step_manager.push_intermediate_step(payload)
 
 
-def track_function(func: Any = None, *, metadata: dict[str, Any] | None = None):
+# Type variable for overloads
+F = TypeVar('F', bound=Callable[..., Any])
+
+
+# Overloads for different function types
+@overload
+def track_function(func: F, *, metadata: dict[str, Any] | None = None) -> F:
+    """Overload for when a function is passed directly."""
+    ...
+
+
+@overload
+def track_function(*, metadata: dict[str, Any] | None = None) -> Callable[[F], F]:
+    """Overload for decorator factory usage (when called with parentheses)."""
+    ...
+
+
+def track_function(func: Any = None, *, metadata: dict[str, Any] | None = None) -> Any:
     """
     Decorator that can wrap any type of function (sync, async, generator,
     async generator) and executes "tracking logic" around it.
@@ -256,6 +275,19 @@ def track_function(func: Any = None, *, metadata: dict[str, Any] | None = None):
     return sync_wrapper
 
 
+# Overloads for track_unregistered_function
+@overload
+def track_unregistered_function(func: F, *, name: str | None = None, metadata: dict[str, Any] | None = None) -> F:
+    """Overload for when a function is passed directly."""
+    ...
+
+
+@overload
+def track_unregistered_function(*, name: str | None = None, metadata: dict[str, Any] | None = None) -> Callable[[F], F]:
+    """Overload for decorator factory usage (when called with parentheses)."""
+    ...
+
+
 def track_unregistered_function(func: Callable[..., Any] | None = None,
                                 *,
                                 name: str | None = None,

nat/profiler/parameter_optimization/prompt_optimizer.py

@@ -151,11 +151,11 @@ async def optimize_prompts(
         if not init_fn_name:
             raise ValueError(
                 "No prompt optimization function configured. Set optimizer.prompt_population_init_function")
-        init_fn = builder.get_function(init_fn_name)
+        init_fn = await builder.get_function(init_fn_name)
 
         recombine_fn = None
         if optimizer_config.prompt.prompt_recombination_function:
-            recombine_fn = builder.get_function(optimizer_config.prompt.prompt_recombination_function)
+            recombine_fn = await builder.get_function(optimizer_config.prompt.prompt_recombination_function)
 
         logger.info(
             "GA Prompt optimization ready: init_fn=%s, recombine_fn=%s",

nat/runtime/loader.py

@@ -114,7 +114,7 @@ async def load_workflow(config_file: StrPath, max_concurrency: int = -1):
     # Must yield the workflow function otherwise it cleans up
     async with WorkflowBuilder.from_config(config=config) as workflow:
 
-        yield SessionManager(workflow.build(), max_concurrency=max_concurrency)
+        yield SessionManager(await workflow.build(), max_concurrency=max_concurrency)
 
 
 @lru_cache

nat/utils/type_converter.py

@@ -90,7 +90,7 @@ class TypeConverter:
         decomposed = DecomposedType(to_type)
 
         # 1) If data is already correct type, return it
-        if to_type is None or decomposed.is_instance((data, to_type)):
+        if to_type is None or decomposed.is_instance(data):
             return data
 
         root = decomposed.root
@@ -198,16 +198,17 @@ class TypeConverter:
         """
         visited = set()
         final = self._try_indirect_conversion(data, to_type, visited)
+        src_type = type(data)
         if final is not None:
             # Warn once if found a chain
-            self._maybe_warn_indirect(type(data), to_type)
+            self._maybe_warn_indirect(src_type, to_type)
             return final
 
         # If no success, try parent's indirect
         if self._parent is not None:
             parent_final = self._parent._try_indirect_convert(data, to_type)
             if parent_final is not None:
-                self._maybe_warn_indirect(type(data), to_type)
+                self._maybe_warn_indirect(src_type, to_type)
                 return parent_final
 
         return None

nat/utils/type_utils.py

@@ -353,7 +353,7 @@ class DecomposedType:
             True if the current type is an instance of the specified instance, False otherwise
         """
 
-        return isinstance(instance, self.root)
+        return isinstance(instance, self.get_base_type().root)
 
     def get_pydantic_schema(self,
                             converters: list[collections.abc.Callable] | None = None) -> type[BaseModel] | type[None]:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nvidia-nat
-Version: 1.3.0a20250923
+Version: 1.3.0a20250925
 Summary: NVIDIA NeMo Agent toolkit
 Author: NVIDIA Corporation
 Maintainer: NVIDIA Corporation
@@ -215,7 +215,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE-3rd-party.txt
 License-File: LICENSE.md
 Requires-Dist: aioboto3>=11.0.0
-Requires-Dist: authlib~=1.3.1
+Requires-Dist: authlib~=1.5
 Requires-Dist: click~=8.1
 Requires-Dist: colorama~=0.4.6
 Requires-Dist: datasets~=4.0
@@ -241,10 +241,12 @@ Requires-Dist: PyYAML~=6.0
 Requires-Dist: ragas~=0.2.14
 Requires-Dist: rich~=13.9
 Requires-Dist: tabulate~=0.9
-Requires-Dist: uvicorn[standard]~=0.32.0
+Requires-Dist: uvicorn[standard]~=0.34
 Requires-Dist: wikipedia~=1.4
 Provides-Extra: all
 Requires-Dist: nvidia-nat-all; extra == "all"
+Provides-Extra: adk
+Requires-Dist: nvidia-nat-adk; extra == "adk"
 Provides-Extra: agno
 Requires-Dist: nvidia-nat-agno; extra == "agno"
 Provides-Extra: crewai
@@ -287,6 +289,7 @@ Requires-Dist: nvidia-nat-weave; extra == "weave"
 Provides-Extra: zep-cloud
 Requires-Dist: nvidia-nat-zep-cloud; extra == "zep-cloud"
 Provides-Extra: examples
+Requires-Dist: nat_adk_demo; extra == "examples"
 Requires-Dist: nat_agno_personal_finance; extra == "examples"
 Requires-Dist: nat_alert_triage_agent; extra == "examples"
 Requires-Dist: nat_automated_description_generation; extra == "examples"