nvidia-nat 1.4.0a20251112__py3-none-any.whl → 1.4.0a20260113__py3-none-any.whl

nat/builder/child_builder.py

@@ -0,0 +1,385 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import typing
+from collections.abc import Generator
+from collections.abc import Sequence
+from contextlib import contextmanager
+
+from nat.authentication.interfaces import AuthProviderBase
+from nat.builder.builder import Builder
+from nat.builder.builder import UserManagerHolder
+from nat.builder.builder import _current_builder_context
+from nat.builder.framework_enum import LLMFrameworkEnum
+from nat.builder.function import Function
+from nat.builder.function import FunctionGroup
+from nat.builder.sync_builder import SyncBuilder
+from nat.data_models.authentication import AuthProviderBaseConfig
+from nat.data_models.common import TypedBaseModel
+from nat.data_models.component_ref import FunctionGroupRef
+from nat.data_models.component_ref import FunctionRef
+from nat.data_models.component_ref import MiddlewareRef
+from nat.data_models.component_ref import TrainerAdapterRef
+from nat.data_models.component_ref import TrainerRef
+from nat.data_models.component_ref import TrajectoryBuilderRef
+from nat.data_models.component_ref import TTCStrategyRef
+from nat.data_models.embedder import EmbedderBaseConfig
+from nat.data_models.finetuning import TrainerAdapterConfig
+from nat.data_models.finetuning import TrainerConfig
+from nat.data_models.finetuning import TrajectoryBuilderConfig
+from nat.data_models.function import FunctionBaseConfig
+from nat.data_models.function import FunctionGroupBaseConfig
+from nat.data_models.function_dependencies import FunctionDependencies
+from nat.data_models.llm import LLMBaseConfig
+from nat.data_models.memory import MemoryBaseConfig
+from nat.data_models.middleware import MiddlewareBaseConfig
+from nat.data_models.object_store import ObjectStoreBaseConfig
+from nat.data_models.retriever import RetrieverBaseConfig
+from nat.data_models.ttc_strategy import TTCStrategyBaseConfig
+from nat.experimental.decorators.experimental_warning_decorator import experimental
+from nat.experimental.test_time_compute.models.stage_enums import PipelineTypeEnum
+from nat.experimental.test_time_compute.models.stage_enums import StageTypeEnum
+from nat.experimental.test_time_compute.models.strategy_base import StrategyBase
+from nat.finetuning.interfaces.finetuning_runner import Trainer
+from nat.finetuning.interfaces.trainer_adapter import TrainerAdapter
+from nat.finetuning.interfaces.trajectory_builder import TrajectoryBuilder
+from nat.memory.interfaces import MemoryEditor
+from nat.middleware.middleware import Middleware
+from nat.object_store.interfaces import ObjectStore
+from nat.retriever.interface import Retriever
+from nat.utils.type_utils import override
+
+
+class ChildBuilder(Builder):
+
+    def __init__(self, workflow_builder: Builder) -> None:
+
+        self._workflow_builder = workflow_builder
+
+        self._dependencies = FunctionDependencies()
+
+    @override
+    @property
+    def sync_builder(self) -> SyncBuilder:
+        return SyncBuilder(self)
+
+    @property
+    def dependencies(self) -> FunctionDependencies:
+        return self._dependencies
+
+    @override
+    async def add_function(self, name: str, config: FunctionBaseConfig) -> Function:
+        return await self._workflow_builder.add_function(name, config)
+
+    @override
+    async def add_function_group(self, name: str, config: FunctionGroupBaseConfig) -> FunctionGroup:
+        return await self._workflow_builder.add_function_group(name, config)
+
+    @override
+    async def get_function(self, name: str) -> Function:
+        # If a function tries to get another function, we assume it uses it
+        fn = await self._workflow_builder.get_function(name)
+
+        self._dependencies.add_function(name)
+
+        return fn
+
+    @override
+    async def get_function_group(self, name: str) -> FunctionGroup:
+        # If a function tries to get a function group, we assume it uses it
+        function_group = await self._workflow_builder.get_function_group(name)
+
+        self._dependencies.add_function_group(name)
+
+        return function_group
+
+    @override
+    def get_function_config(self, name: str) -> FunctionBaseConfig:
+        return self._workflow_builder.get_function_config(name)
+
+    @override
+    def get_function_group_config(self, name: str) -> FunctionGroupBaseConfig:
+        return self._workflow_builder.get_function_group_config(name)
+
+    @override
+    async def set_workflow(self, config: FunctionBaseConfig) -> Function:
+        return await self._workflow_builder.set_workflow(config)
+
+    @override
+    def get_workflow(self) -> Function:
+        return self._workflow_builder.get_workflow()
+
+    @override
+    def get_workflow_config(self) -> FunctionBaseConfig:
+        return self._workflow_builder.get_workflow_config()
+
+    @override
+    async def get_tools(self,
+                        tool_names: Sequence[str | FunctionRef | FunctionGroupRef],
+                        wrapper_type: LLMFrameworkEnum | str) -> list[typing.Any]:
+        # Import here to avoid cyclic import
+        from nat.builder.per_user_workflow_builder import PerUserWorkflowBuilder
+        from nat.builder.workflow_builder import WorkflowBuilder
+
+        tools = await self._workflow_builder.get_tools(tool_names, wrapper_type)
+        for tool_name in tool_names:
+            if isinstance(self._workflow_builder, WorkflowBuilder):
+                function_groups = self._workflow_builder._function_groups
+            elif isinstance(self._workflow_builder, PerUserWorkflowBuilder):
+                # Per-user components can have dependencies on both shared and per-user function groups
+                function_groups = {
+                    **self._workflow_builder._shared_builder._function_groups,
+                    **self._workflow_builder._per_user_function_groups
+                }
+            else:
+                raise TypeError(f"Invalid workflow builder type: {type(self._workflow_builder)}")
+            if tool_name in function_groups:
+                self._dependencies.add_function_group(tool_name)
+            else:
+                self._dependencies.add_function(tool_name)
+        return tools
+
+    @override
+    async def get_tool(self, fn_name: str | FunctionRef, wrapper_type: LLMFrameworkEnum | str):
+        # If a function tries to get another function as a tool, we assume it uses it
+        fn = await self._workflow_builder.get_tool(fn_name, wrapper_type)
+
+        self._dependencies.add_function(fn_name)
+
+        return fn
+
+    @override
+    async def add_llm(self, name: str, config: LLMBaseConfig) -> None:
+        return await self._workflow_builder.add_llm(name, config)
+
+    @experimental(feature_name="Authentication")
+    @override
+    async def add_auth_provider(self, name: str, config: AuthProviderBaseConfig) -> AuthProviderBase:
+        return await self._workflow_builder.add_auth_provider(name, config)
+
+    @override
+    async def get_auth_provider(self, auth_provider_name: str):
+        return await self._workflow_builder.get_auth_provider(auth_provider_name)
+
+    @override
+    async def get_llm(self, llm_name: str, wrapper_type: LLMFrameworkEnum | str) -> typing.Any:
+        llm = await self._workflow_builder.get_llm(llm_name, wrapper_type)
+
+        self._dependencies.add_llm(llm_name)
+
+        return llm
+
+    @override
+    def get_llm_config(self, llm_name: str) -> LLMBaseConfig:
+        return self._workflow_builder.get_llm_config(llm_name)
+
+    @override
+    async def add_embedder(self, name: str, config: EmbedderBaseConfig) -> None:
+        await self._workflow_builder.add_embedder(name, config)
+
+    @override
+    async def get_embedder(self, embedder_name: str, wrapper_type: LLMFrameworkEnum | str) -> typing.Any:
+        embedder = await self._workflow_builder.get_embedder(embedder_name, wrapper_type)
+
+        self._dependencies.add_embedder(embedder_name)
+
+        return embedder
+
+    @override
+    def get_embedder_config(self, embedder_name: str) -> EmbedderBaseConfig:
+        return self._workflow_builder.get_embedder_config(embedder_name)
+
+    @override
+    async def add_memory_client(self, name: str, config: MemoryBaseConfig) -> MemoryEditor:
+        return await self._workflow_builder.add_memory_client(name, config)
+
+    @override
+    async def get_memory_client(self, memory_name: str) -> MemoryEditor:
+        """
+        Return the instantiated memory client for the given name.
+        """
+        memory_client = await self._workflow_builder.get_memory_client(memory_name)
+
+        self._dependencies.add_memory_client(memory_name)
+
+        return memory_client
+
+    @override
+    def get_memory_client_config(self, memory_name: str) -> MemoryBaseConfig:
+        return self._workflow_builder.get_memory_client_config(memory_name=memory_name)
+
+    @override
+    async def add_object_store(self, name: str, config: ObjectStoreBaseConfig):
+        return await self._workflow_builder.add_object_store(name, config)
+
+    @override
+    async def get_object_store_client(self, object_store_name: str) -> ObjectStore:
+        """
+        Return the instantiated object store client for the given name.
+        """
+        object_store_client = await self._workflow_builder.get_object_store_client(object_store_name)
+
+        self._dependencies.add_object_store(object_store_name)
+
+        return object_store_client
+
+    @override
+    def get_object_store_config(self, object_store_name: str) -> ObjectStoreBaseConfig:
+        return self._workflow_builder.get_object_store_config(object_store_name)
+
+    @override
+    @experimental(feature_name="Finetuning")
+    async def add_trainer(self, name: str | TrainerRef, config: TrainerConfig) -> Trainer:
+        return await self._workflow_builder.add_trainer(name, config)
+
+    @override
+    @experimental(feature_name="Finetuning")
+    async def add_trainer_adapter(self, name: str | TrainerAdapterRef, config: TrainerAdapterConfig) -> TrainerAdapter:
+        return await self._workflow_builder.add_trainer_adapter(name, config)
+
+    @override
+    @experimental(feature_name="Finetuning")
+    async def add_trajectory_builder(self, name: str | TrajectoryBuilderRef,
+                                     config: TrajectoryBuilderConfig) -> TrajectoryBuilder:
+        return await self._workflow_builder.add_trajectory_builder(name, config)
+
+    @override
+    async def get_trainer(self,
+                          trainer_name: str | TrainerRef,
+                          trajectory_builder: TrajectoryBuilder,
+                          trainer_adapter: TrainerAdapter) -> Trainer:
+        return await self._workflow_builder.get_trainer(trainer_name, trajectory_builder, trainer_adapter)
+
+    @override
+    async def get_trainer_config(self, trainer_name: str | TrainerRef) -> TrainerConfig:
+        return await self._workflow_builder.get_trainer_config(trainer_name)
+
+    @override
+    async def get_trainer_adapter_config(self, trainer_adapter_name: str | TrainerAdapterRef) -> TrainerAdapterConfig:
+        return await self._workflow_builder.get_trainer_adapter_config(trainer_adapter_name)
+
+    @override
+    async def get_trajectory_builder_config(
+            self, trajectory_builder_name: str | TrajectoryBuilderRef) -> (TrajectoryBuilderConfig):
+        return await self._workflow_builder.get_trajectory_builder_config(trajectory_builder_name)
+
+    @override
+    async def get_trainer_adapter(self, trainer_adapter_name: str | TrainerAdapterRef) -> TrainerAdapter:
+        return await self._workflow_builder.get_trainer_adapter(trainer_adapter_name)
+
+    @override
+    async def get_trajectory_builder(self, trajectory_builder_name: str | TrajectoryBuilderRef) -> TrajectoryBuilder:
+        return await self._workflow_builder.get_trajectory_builder(trajectory_builder_name)
+
+    @override
+    @experimental(feature_name="TTC")
+    async def add_ttc_strategy(self, name: str, config: TTCStrategyBaseConfig) -> None:
+        await self._workflow_builder.add_ttc_strategy(name, config)
+
+    @override
+    async def get_ttc_strategy(self,
+                               strategy_name: str | TTCStrategyRef,
+                               pipeline_type: PipelineTypeEnum,
+                               stage_type: StageTypeEnum) -> StrategyBase:
+        return await self._workflow_builder.get_ttc_strategy(strategy_name=strategy_name,
+                                                             pipeline_type=pipeline_type,
+                                                             stage_type=stage_type)
+
+    @override
+    async def get_ttc_strategy_config(self,
+                                      strategy_name: str | TTCStrategyRef,
+                                      pipeline_type: PipelineTypeEnum,
+                                      stage_type: StageTypeEnum) -> TTCStrategyBaseConfig:
+        return await self._workflow_builder.get_ttc_strategy_config(strategy_name=strategy_name,
+                                                                    pipeline_type=pipeline_type,
+                                                                    stage_type=stage_type)
+
+    @override
+    async def add_retriever(self, name: str, config: RetrieverBaseConfig) -> None:
+        await self._workflow_builder.add_retriever(name, config)
+
+    @override
+    async def get_retriever(self, retriever_name: str, wrapper_type: LLMFrameworkEnum | str | None = None) -> Retriever:
+        if not wrapper_type:
+            return await self._workflow_builder.get_retriever(retriever_name=retriever_name)
+        return await self._workflow_builder.get_retriever(retriever_name=retriever_name, wrapper_type=wrapper_type)
+
+    @override
+    async def get_retriever_config(self, retriever_name: str) -> RetrieverBaseConfig:
+        return await self._workflow_builder.get_retriever_config(retriever_name=retriever_name)
+
+    @override
+    def get_user_manager(self) -> UserManagerHolder:
+        return self._workflow_builder.get_user_manager()
+
+    @override
+    def get_function_dependencies(self, fn_name: str) -> FunctionDependencies:
+        return self._workflow_builder.get_function_dependencies(fn_name)
+
+    @override
+    def get_function_group_dependencies(self, fn_name: str) -> FunctionDependencies:
+        return self._workflow_builder.get_function_group_dependencies(fn_name)
+
+    @override
+    async def add_middleware(self, name: str | MiddlewareRef, config: MiddlewareBaseConfig) -> Middleware:
+        """Add middleware to the builder."""
+        return await self._workflow_builder.add_middleware(name, config)
+
+    @override
+    async def get_middleware(self, middleware_name: str | MiddlewareRef) -> Middleware:
+        """Get built middleware by name."""
+        return await self._workflow_builder.get_middleware(middleware_name)
+
+    @override
+    def get_middleware_config(self, middleware_name: str | MiddlewareRef) -> MiddlewareBaseConfig:
+        """Get the configuration for middleware."""
+        return self._workflow_builder.get_middleware_config(middleware_name)
+
+    @staticmethod
+    @contextmanager
+    def use(config: TypedBaseModel, builder: Builder) -> Generator["ChildBuilder", None, None]:
+        """
+        Context manager for temporarily setting the Builder object.
+
+        Parameters
+        ----------
+        config : TypedBaseModel
+            The configuration to use within the context. Note: Not used for now, but required by the interface
+            and will be used in the future.
+        builder : Builder
+            The Builder instance to use within the context.
+
+        Yields
+        ------
+        ChildBuilder
+            The Builder instance that was set.
+
+        Examples
+        --------
+        >>> with ChildBuilder.use(config, my_builder) as builder:
+        ...     # builder is active in this context
+        ...     assert Builder.current() == builder
+        >>> # Original builder is restored here
+
+        """
+
+        inner_builder = ChildBuilder(workflow_builder=builder)
+
+        previous = _current_builder_context.get()
+        _current_builder_context.set(inner_builder)
+        try:
+            yield inner_builder
+        finally:
+            _current_builder_context.set(previous)

nat/builder/component_utils.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -29,18 +29,25 @@ from nat.data_models.component_ref import ComponentRefNode
 from nat.data_models.component_ref import generate_instance_id
 from nat.data_models.config import Config
 from nat.data_models.embedder import EmbedderBaseConfig
+from nat.data_models.finetuning import TrainerAdapterConfig
+from nat.data_models.finetuning import TrainerConfig
+from nat.data_models.finetuning import TrajectoryBuilderConfig
 from nat.data_models.function import FunctionBaseConfig
 from nat.data_models.function import FunctionGroupBaseConfig
 from nat.data_models.llm import LLMBaseConfig
 from nat.data_models.memory import MemoryBaseConfig
+from nat.data_models.middleware import MiddlewareBaseConfig
 from nat.data_models.object_store import ObjectStoreBaseConfig
 from nat.data_models.retriever import RetrieverBaseConfig
 from nat.data_models.ttc_strategy import TTCStrategyBaseConfig
 from nat.utils.type_utils import DecomposedType
 
+WORKFLOW_COMPONENT_NAME = "<workflow>"
+
 logger = logging.getLogger(__name__)
 
 # Order in which we want to process the component groups
+# IMPORTANT: MIDDLEWARE must be built before FUNCTIONS
 _component_group_order = [
     ComponentGroup.AUTHENTICATION,
     ComponentGroup.EMBEDDERS,
@@ -49,8 +56,12 @@ _component_group_order = [
     ComponentGroup.OBJECT_STORES,
     ComponentGroup.RETRIEVERS,
     ComponentGroup.TTC_STRATEGIES,
+    ComponentGroup.MIDDLEWARE,
     ComponentGroup.FUNCTION_GROUPS,
     ComponentGroup.FUNCTIONS,
+    ComponentGroup.TRAINER_ADAPTERS,
+    ComponentGroup.TRAJECTORY_BUILDERS,
+    ComponentGroup.TRAINERS
 ]
 
 
@@ -107,10 +118,18 @@ def group_from_component(component: TypedBaseModel) -> ComponentGroup | None:
         return ComponentGroup.AUTHENTICATION
     if (isinstance(component, EmbedderBaseConfig)):
         return ComponentGroup.EMBEDDERS
+    if (isinstance(component, TrainerConfig)):
+        return ComponentGroup.TRAINERS
+    if (isinstance(component, TrainerAdapterConfig)):
+        return ComponentGroup.TRAINER_ADAPTERS
+    if (isinstance(component, TrajectoryBuilderConfig)):
+        return ComponentGroup.TRAJECTORY_BUILDERS
     if (isinstance(component, FunctionBaseConfig)):
         return ComponentGroup.FUNCTIONS
     if (isinstance(component, FunctionGroupBaseConfig)):
         return ComponentGroup.FUNCTION_GROUPS
+    if (isinstance(component, MiddlewareBaseConfig)):
+        return ComponentGroup.MIDDLEWARE
     if (isinstance(component, LLMBaseConfig)):
         return ComponentGroup.LLMS
     if (isinstance(component, MemoryBaseConfig)):
@@ -158,7 +177,16 @@ def recursive_componentref_discovery(cls: TypedBaseModel, value: typing.Any,
             yield from recursive_componentref_discovery(cls, field_data, field_info.annotation)
     if (decomposed_type.is_union):
         for arg in decomposed_type.args:
-            if arg is typing.Any or DecomposedType(arg).is_instance(value):
+            # Check if value matches this union arg type
+            # TypedDict and some other types don't support isinstance checks,
+            # so we catch the TypeError and skip them
+            try:
+                is_match = arg is typing.Any or DecomposedType(arg).is_instance(value)
+            except TypeError:
+                # Skip types that don't support isinstance (e.g., TypedDict)
+                continue
+
+            if is_match:
                 yield from recursive_componentref_discovery(cls, value, arg)
     else:
         for arg in decomposed_type.args:
@@ -236,7 +264,7 @@ def config_to_dependency_objects(config: "Config") -> tuple[dict[str, ComponentI
     dependency_map[workflow_instance_id] = ComponentInstanceData(
         component_group=ComponentGroup.FUNCTIONS,
         instance_id=workflow_instance_id,
-        name="<workflow>",  # type: ignore
+        name=WORKFLOW_COMPONENT_NAME,  # type: ignore
         config=config.workflow,
         is_root=True)
 
@@ -260,7 +288,9 @@ def build_dependency_sequence(config: "Config") -> list[ComponentInstanceData]:
 
     total_node_count = (len(config.embedders) + len(config.functions) + len(config.function_groups) + len(config.llms) +
                         len(config.memory) + len(config.object_stores) + len(config.retrievers) +
-                        len(config.ttc_strategies) + len(config.authentication) + 1)  # +1 for the workflow
+                        len(config.ttc_strategies) + len(config.authentication) + len(config.middleware) +
+                        len(config.trainers) + len(config.trajectory_builders) + len(config.trainer_adapters) + 1
+                        )  # +1 for the workflow
 
     dependency_map: dict
     dependency_graph: nx.DiGraph

nat/builder/context.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -34,6 +34,7 @@ from nat.data_models.intermediate_step import IntermediateStepType
 from nat.data_models.intermediate_step import StreamEventData
 from nat.data_models.intermediate_step import TraceMetadata
 from nat.data_models.invocation_node import InvocationNode
+from nat.data_models.runtime_enum import RuntimeTypeEnum
 from nat.runtime.user_metadata import RequestAttributes
 from nat.utils.reactive.subject import Subject
 
@@ -68,10 +69,14 @@ class ContextState(metaclass=Singleton):
     def __init__(self):
         self.conversation_id: ContextVar[str | None] = ContextVar("conversation_id", default=None)
         self.user_message_id: ContextVar[str | None] = ContextVar("user_message_id", default=None)
+        self.user_id: ContextVar[str | None] = ContextVar("user_id", default=None)
         self.workflow_run_id: ContextVar[str | None] = ContextVar("workflow_run_id", default=None)
         self.workflow_trace_id: ContextVar[int | None] = ContextVar("workflow_trace_id", default=None)
+        self.observability_trace_id: ContextVar[str | None] = ContextVar("observability_trace_id", default=None)
         self.input_message: ContextVar[typing.Any] = ContextVar("input_message", default=None)
         self.user_manager: ContextVar[typing.Any] = ContextVar("user_manager", default=None)
+        self.runtime_type: ContextVar[RuntimeTypeEnum] = ContextVar("runtime_type",
+                                                                    default=RuntimeTypeEnum.RUN_OR_SERVE)
         self._metadata: ContextVar[RequestAttributes | None] = ContextVar("request_attributes", default=None)
         self._event_stream: ContextVar[Subject[IntermediateStep] | None] = ContextVar("event_stream", default=None)
         self._active_function: ContextVar[InvocationNode | None] = ContextVar("active_function", default=None)
@@ -199,6 +204,13 @@ class Context:
         """
         return self._context_state.user_message_id.get()
 
+    @property
+    def user_id(self) -> str | None:
+        """
+        This property retrieves the user ID which is the unique identifier for the current user.
+        """
+        return self._context_state.user_id.get()
+
     @property
     def workflow_run_id(self) -> str | None:
         """
@@ -213,6 +225,13 @@ class Context:
         """
         return self._context_state.workflow_trace_id.get()
 
+    @property
+    def observability_trace_id(self) -> str | None:
+        """
+        Returns the root observability trace identifier for the current run.
+        """
+        return self._context_state.observability_trace_id.get()
+
     @contextmanager
     def push_active_function(self,
                              function_name: str,
@@ -302,6 +321,20 @@ class Context:
             raise RuntimeError("User authentication callback is not set in the context.")
         return callback
 
+    @property
+    def is_evaluating(self) -> bool:
+        """
+        Indicates whether the current context is in evaluation mode.
+
+        This property checks the context state to determine if the current
+        operation is being performed in evaluation mode. It returns a boolean
+        value indicating the evaluation status.
+
+        Returns:
+            bool: True if in evaluation mode, False otherwise.
+        """
+        return self._context_state.runtime_type.get() == RuntimeTypeEnum.EVALUATE
+
     @staticmethod
     def get() -> "Context":
         """

nat/builder/embedder.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

nat/builder/eval_builder.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -22,7 +22,9 @@ from pathlib import Path
 from nat.builder.builder import EvalBuilder
 from nat.builder.evaluator import EvaluatorInfo
 from nat.builder.framework_enum import LLMFrameworkEnum
+from nat.builder.function import FunctionGroup
 from nat.builder.workflow_builder import WorkflowBuilder
+from nat.builder.workflow_builder import _log_build_failure
 from nat.cli.type_registry import TypeRegistry
 from nat.data_models.config import Config
 from nat.data_models.config import GeneralConfig
@@ -95,6 +97,16 @@ class WorkflowEvalBuilder(WorkflowBuilder, EvalBuilder):
         tool_wrapper_reg = self._registry.get_tool_wrapper(llm_framework=wrapper_type)
 
         async def get_tool(fn_name: str):
+            # Maintain backwards compatibility with the old function group name format
+            new_fn_name = fn_name.replace(FunctionGroup.LEGACY_SEPARATOR, FunctionGroup.SEPARATOR)
+            if (fn_name not in self._functions) and (new_fn_name in self._functions):
+                logger.warning(
+                    f"Function `{fn_name}` is deprecated and will be removed in a future release." + \
+                        f"Use `{new_fn_name}` instead."
+                )
+                fn_name = new_fn_name
+            # end of backwards compatibility check
+
             fn = await self.get_function(fn_name)
             try:
                 return tool_wrapper_reg.build_fn(fn_name, fn, self)
@@ -124,12 +136,12 @@ class WorkflowEvalBuilder(WorkflowBuilder, EvalBuilder):
         completed_components = [(name, "evaluator") for name in completed_evaluators]
         remaining_components = [(name, "evaluator") for name in remaining_evaluators]
 
-        # Use the inherited common logging method from WorkflowBuilder
-        self._log_build_failure(failing_evaluator_name,
-                                "evaluator",
-                                completed_components,
-                                remaining_components,
-                                original_error)
+        # Use the common logging function from workflow_builder
+        _log_build_failure(failing_evaluator_name,
+                           "evaluator",
+                           completed_components,
+                           remaining_components,
+                           original_error)
 
     @override
     async def populate_builder(self, config: Config, skip_workflow: bool = False):

nat/builder/evaluator.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

nat/builder/framework_enum.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -23,3 +23,5 @@ class LLMFrameworkEnum(str, Enum):
     SEMANTIC_KERNEL = "semantic_kernel"
     AGNO = "agno"
     ADK = "adk"
+    STRANDS = "strands"
+    AUTOGEN = "autogen"

nat/builder/front_end.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");