nvidia-nat 1.3.0a20250910__py3-none-any.whl → 1.3.0a20250922__py3-none-any.whl

nat/authentication/oauth2/oauth2_resource_server_config.py

@@ -0,0 +1,124 @@
+# 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 urllib.parse import urlparse
+
+from pydantic import Field
+from pydantic import field_validator
+from pydantic import model_validator
+
+from nat.data_models.authentication import AuthProviderBaseConfig
+
+
+class OAuth2ResourceServerConfig(AuthProviderBaseConfig, name="oauth2_resource_server"):
+    """OAuth 2.0 Resource Server authentication configuration.
+
+    Supports:
+      • JWT access tokens via JWKS / OIDC Discovery / issuer fallback
+      • Opaque access tokens via RFC 7662 introspection
+    """
+
+    issuer_url: str = Field(
+        description=("The unique issuer identifier for an authorization server. "
+                     "Required for validation and used to derive the default JWKS URI "
+                     "(<issuer_url>/.well-known/jwks.json) if `jwks_uri` and `discovery_url` are not provided."), )
+    scopes: list[str] = Field(
+        default_factory=list,
+        description="Scopes required by this API. Validation ensures the token grants all listed scopes.",
+    )
+    audience: str | None = Field(
+        default=None,
+        description=(
+            "Expected audience (`aud`) claim for this API. If set, validation will reject tokens without this audience."
+        ),
+    )
+
+    # JWT verification params
+    jwks_uri: str | None = Field(
+        default=None,
+        description=("Direct JWKS endpoint URI for JWT signature verification. "
+                     "Optional if discovery or issuer is provided."),
+    )
+    discovery_url: str | None = Field(
+        default=None,
+        description=("OIDC discovery metadata URL. Used to automatically resolve JWKS and introspection endpoints."),
+    )
+
+    # Opaque token (introspection) params
+    introspection_endpoint: str | None = Field(
+        default=None,
+        description=("RFC 7662 token introspection endpoint. "
+                     "Required for opaque token validation and must be used with `client_id` and `client_secret`."),
+    )
+    client_id: str | None = Field(
+        default=None,
+        description="OAuth2 client ID for authenticating to the introspection endpoint (opaque token validation).",
+    )
+    client_secret: str | None = Field(
+        default=None,
+        description="OAuth2 client secret for authenticating to the introspection endpoint (opaque token validation).",
+    )
+
+    @staticmethod
+    def _is_https_or_localhost(url: str) -> bool:
+        try:
+            value = urlparse(url)
+            if not value.scheme or not value.netloc:
+                return False
+            if value.scheme == "https":
+                return True
+            return value.scheme == "http" and (value.hostname in {"localhost", "127.0.0.1", "::1"})
+        except Exception:
+            return False
+
+    @field_validator("issuer_url", "jwks_uri", "discovery_url", "introspection_endpoint")
+    @classmethod
+    def _require_valid_url(cls, value: str | None, info):
+        if value is None:
+            return value
+        if not cls._is_https_or_localhost(value):
+            raise ValueError(f"{info.field_name} must be HTTPS (http allowed only for localhost). Got: {value}")
+        return value
+
+    # ---------- Cross-field validation: ensure at least one viable path ----------
+
+    @model_validator(mode="after")
+    def _ensure_verification_path(self):
+        """
+        JWT path viable if any of: jwks_uri OR discovery_url OR issuer_url (fallback JWKS).
+        Opaque path viable if: introspection_endpoint AND client_id AND client_secret.
+        """
+        has_jwt_path = bool(self.jwks_uri or self.discovery_url or self.issuer_url)
+        has_opaque_path = bool(self.introspection_endpoint and self.client_id and self.client_secret)
+
+        # If introspection endpoint is set, enforce creds are present
+        if self.introspection_endpoint:
+            missing = []
+            if not self.client_id:
+                missing.append("client_id")
+            if not self.client_secret:
+                missing.append("client_secret")
+            if missing:
+                raise ValueError(
+                    f"introspection_endpoint configured but missing required credentials: {', '.join(missing)}")
+
+        # Require at least one path
+        if not (has_jwt_path or has_opaque_path):
+            raise ValueError("Invalid configuration: no verification method available. "
+                             "Configure one of the following:\n"
+                             "  • JWT path: set jwks_uri OR discovery_url OR issuer_url (for JWKS fallback)\n"
+                             "  • Opaque path: set introspection_endpoint + client_id + client_secret")
+
+        return self

nat/builder/builder.py

@@ -24,9 +24,11 @@ from nat.authentication.interfaces import AuthProviderBase
 from nat.builder.context import Context
 from nat.builder.framework_enum import LLMFrameworkEnum
 from nat.builder.function import Function
+from nat.builder.function import FunctionGroup
 from nat.data_models.authentication import AuthProviderBaseConfig
 from nat.data_models.component_ref import AuthenticationRef
 from nat.data_models.component_ref import EmbedderRef
+from nat.data_models.component_ref import FunctionGroupRef
 from nat.data_models.component_ref import FunctionRef
 from nat.data_models.component_ref import LLMRef
 from nat.data_models.component_ref import MemoryRef
@@ -36,6 +38,7 @@ from nat.data_models.component_ref import TTCStrategyRef
 from nat.data_models.embedder import EmbedderBaseConfig
 from nat.data_models.evaluator import EvaluatorBaseConfig
 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
@@ -64,18 +67,33 @@ class Builder(ABC):
     async def add_function(self, name: str | FunctionRef, config: FunctionBaseConfig) -> Function:
         pass
 
+    @abstractmethod
+    async def add_function_group(self, name: str | FunctionGroupRef, config: FunctionGroupBaseConfig) -> FunctionGroup:
+        pass
+
     @abstractmethod
     def get_function(self, name: str | FunctionRef) -> Function:
         pass
 
+    @abstractmethod
+    def get_function_group(self, name: str | FunctionGroupRef) -> FunctionGroup:
+        pass
+
     def get_functions(self, function_names: Sequence[str | FunctionRef]) -> list[Function]:
 
         return [self.get_function(name) for name in function_names]
 
+    def get_function_groups(self, function_group_names: Sequence[str | FunctionGroupRef]) -> list[FunctionGroup]:
+        return [self.get_function_group(name) for name in function_group_names]
+
     @abstractmethod
     def get_function_config(self, name: str | FunctionRef) -> FunctionBaseConfig:
         pass
 
+    @abstractmethod
+    def get_function_group_config(self, name: str | FunctionGroupRef) -> FunctionGroupBaseConfig:
+        pass
+
     @abstractmethod
     async def set_workflow(self, config: FunctionBaseConfig) -> Function:
         pass
@@ -88,10 +106,11 @@ class Builder(ABC):
     def get_workflow_config(self) -> FunctionBaseConfig:
         pass
 
-    def get_tools(self, tool_names: Sequence[str | FunctionRef],
+    @abstractmethod
+    def get_tools(self,
+                  tool_names: Sequence[str | FunctionRef | FunctionGroupRef],
                   wrapper_type: LLMFrameworkEnum | str) -> list[typing.Any]:
-
-        return [self.get_tool(fn_name=n, wrapper_type=wrapper_type) for n in tool_names]
+        pass
 
     @abstractmethod
     def get_tool(self, fn_name: str | FunctionRef, wrapper_type: LLMFrameworkEnum | str) -> typing.Any:
@@ -257,8 +276,12 @@ class Builder(ABC):
     def get_function_dependencies(self, fn_name: str) -> FunctionDependencies:
         pass
 
+    @abstractmethod
+    def get_function_group_dependencies(self, fn_name: str) -> FunctionDependencies:
+        pass
+
 
-class EvalBuilder(Builder):
+class EvalBuilder(ABC):
 
     @abstractmethod
     async def add_evaluator(self, name: str, config: EvaluatorBaseConfig):

nat/builder/component_utils.py

@@ -30,6 +30,7 @@ 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.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.object_store import ObjectStoreBaseConfig
@@ -48,6 +49,7 @@ _component_group_order = [
     ComponentGroup.OBJECT_STORES,
     ComponentGroup.RETRIEVERS,
     ComponentGroup.TTC_STRATEGIES,
+    ComponentGroup.FUNCTION_GROUPS,
     ComponentGroup.FUNCTIONS,
 ]
 
@@ -107,6 +109,8 @@ def group_from_component(component: TypedBaseModel) -> ComponentGroup | None:
         return ComponentGroup.EMBEDDERS
     if (isinstance(component, FunctionBaseConfig)):
         return ComponentGroup.FUNCTIONS
+    if (isinstance(component, FunctionGroupBaseConfig)):
+        return ComponentGroup.FUNCTION_GROUPS
     if (isinstance(component, LLMBaseConfig)):
         return ComponentGroup.LLMS
     if (isinstance(component, MemoryBaseConfig)):
@@ -254,9 +258,9 @@ def build_dependency_sequence(config: "Config") -> list[ComponentInstanceData]:
             runtime instance references.
     """
 
-    total_node_count = len(config.embedders) + len(config.functions) + 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
+    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
 
     dependency_map: dict
     dependency_graph: nx.DiGraph

nat/builder/context.py

@@ -69,12 +69,10 @@ class ContextState(metaclass=Singleton):
         self.user_message_id: ContextVar[str | None] = ContextVar("user_message_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.metadata: ContextVar[RequestAttributes] = ContextVar("request_attributes", default=RequestAttributes())
-        self.event_stream: ContextVar[Subject[IntermediateStep] | None] = ContextVar("event_stream", default=Subject())
-        self.active_function: ContextVar[InvocationNode] = ContextVar("active_function",
-                                                                      default=InvocationNode(function_id="root",
-                                                                                             function_name="root"))
-        self.active_span_id_stack: ContextVar[list[str]] = ContextVar("active_span_id_stack", default=["root"])
+        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)
+        self._active_span_id_stack: ContextVar[list[str] | None] = ContextVar("active_span_id_stack", default=None)
 
         # Default is a lambda no-op which returns NoneType
         self.user_input_callback: ContextVar[Callable[[InteractionPrompt], Awaitable[HumanResponse | None]]
@@ -85,6 +83,30 @@ class ContextState(metaclass=Singleton):
                                                      Awaitable[AuthenticatedContext]]
                                             | None] = ContextVar("user_auth_callback", default=None)
 
+    @property
+    def metadata(self) -> ContextVar[RequestAttributes]:
+        if self._metadata.get() is None:
+            self._metadata.set(RequestAttributes())
+        return typing.cast(ContextVar[RequestAttributes], self._metadata)
+
+    @property
+    def active_function(self) -> ContextVar[InvocationNode]:
+        if self._active_function.get() is None:
+            self._active_function.set(InvocationNode(function_id="root", function_name="root"))
+        return typing.cast(ContextVar[InvocationNode], self._active_function)
+
+    @property
+    def event_stream(self) -> ContextVar[Subject[IntermediateStep]]:
+        if self._event_stream.get() is None:
+            self._event_stream.set(Subject())
+        return typing.cast(ContextVar[Subject[IntermediateStep]], self._event_stream)
+
+    @property
+    def active_span_id_stack(self) -> ContextVar[list[str]]:
+        if self._active_span_id_stack.get() is None:
+            self._active_span_id_stack.set(["root"])
+        return typing.cast(ContextVar[list[str]], self._active_span_id_stack)
+
     @staticmethod
     def get() -> "ContextState":
         return ContextState()

nat/builder/function.py

@@ -14,12 +14,14 @@
 # limitations under the License.
 
 import logging
+import re
 import typing
 from abc import ABC
 from abc import abstractmethod
 from collections.abc import AsyncGenerator
 from collections.abc import Awaitable
 from collections.abc import Callable
+from collections.abc import Sequence
 
 from pydantic import BaseModel
 
@@ -29,7 +31,9 @@ from nat.builder.function_base import InputT
 from nat.builder.function_base import SingleOutputT
 from nat.builder.function_base import StreamingOutputT
 from nat.builder.function_info import FunctionInfo
+from nat.data_models.function import EmptyFunctionConfig
 from nat.data_models.function import FunctionBaseConfig
+from nat.data_models.function import FunctionGroupBaseConfig
 
 _InvokeFnT = Callable[[InputT], Awaitable[SingleOutputT]]
 _StreamFnT = Callable[[InputT], AsyncGenerator[StreamingOutputT]]
@@ -342,3 +346,312 @@ class LambdaFunction(Function[InputT, StreamingOutputT, SingleOutputT]):
             pass
 
         return FunctionImpl(config=config, info=info, instance_name=instance_name)
+
+
+class FunctionGroup:
+    """
+    A group of functions that can be used together, sharing the same configuration, context, and resources.
+    """
+
+    def __init__(self,
+                 *,
+                 config: FunctionGroupBaseConfig,
+                 instance_name: str | None = None,
+                 filter_fn: Callable[[Sequence[str]], Sequence[str]] | None = None):
+        """
+        Creates a new function group.
+
+        Parameters
+        ----------
+        config : FunctionGroupBaseConfig
+            The configuration for the function group.
+        instance_name : str | None, optional
+            The name of the function group. If not provided, the type of the function group will be used.
+        filter_fn : Callable[[Sequence[str]], Sequence[str]] | None, optional
+            A callback function to additionally filter the functions in the function group dynamically when
+            the functions are accessed via any accessor method.
+        """
+        self._config = config
+        self._instance_name = instance_name or config.type
+        self._functions: dict[str, Function] = dict()
+        self._filter_fn = filter_fn
+        self._per_function_filter_fn: dict[str, Callable[[str], bool]] = dict()
+
+    def add_function(self,
+                     name: str,
+                     fn: Callable,
+                     *,
+                     input_schema: type[BaseModel] | None = None,
+                     description: str | None = None,
+                     converters: list[Callable] | None = None,
+                     filter_fn: Callable[[str], bool] | None = None):
+        """
+        Adds a function to the function group.
+
+        Parameters
+        ----------
+        name : str
+            The name of the function.
+        fn : Callable
+            The function to add to the function group.
+        input_schema : type[BaseModel] | None, optional
+            The input schema for the function.
+        description : str | None, optional
+            The description of the function.
+        converters : list[Callable] | None, optional
+            The converters to use for the function.
+        filter_fn : Callable[[str], bool] | None, optional
+            A callback to determine if the function should be included in the function group. The
+            callback will be called with the function name. The callback is invoked dynamically when
+            the functions are accessed via any accessor method such as `get_accessible_functions`,
+            `get_included_functions`, `get_excluded_functions`, `get_all_functions`.
+
+        Raises
+        ------
+        ValueError
+            When the function name is empty or blank.
+            When the function name contains invalid characters.
+            When the function already exists in the function group.
+        """
+        if not name.strip():
+            raise ValueError("Function name cannot be empty or blank")
+        if not re.match(r"^[a-zA-Z0-9_-]+$", name):
+            raise ValueError(f"Function name can only contain letters, numbers, underscores, and hyphens: {name}")
+        if name in self._functions:
+            raise ValueError(f"Function {name} already exists in function group {self._instance_name}")
+
+        info = FunctionInfo.from_fn(fn, input_schema=input_schema, description=description, converters=converters)
+        full_name = self._get_fn_name(name)
+        lambda_fn = LambdaFunction.from_info(config=EmptyFunctionConfig(), info=info, instance_name=full_name)
+        self._functions[name] = lambda_fn
+        if filter_fn:
+            self._per_function_filter_fn[name] = filter_fn
+
+    def get_config(self) -> FunctionGroupBaseConfig:
+        """
+        Returns the configuration for the function group.
+
+        Returns
+        -------
+        FunctionGroupBaseConfig
+            The configuration for the function group.
+        """
+        return self._config
+
+    def _get_fn_name(self, name: str) -> str:
+        return f"{self._instance_name}.{name}"
+
+    def _fn_should_be_included(self, name: str) -> bool:
+        return (name not in self._per_function_filter_fn or self._per_function_filter_fn[name](name))
+
+    def _get_all_but_excluded_functions(
+        self,
+        filter_fn: Callable[[Sequence[str]], Sequence[str]] | None = None,
+    ) -> dict[str, Function]:
+        """
+        Returns a dictionary of all functions in the function group except the excluded functions.
+        """
+        missing = set(self._config.exclude) - set(self._functions.keys())
+        if missing:
+            raise ValueError(f"Unknown excluded functions: {sorted(missing)}")
+        filter_fn = filter_fn or self._filter_fn or (lambda x: x)
+        excluded = set(self._config.exclude)
+        included = set(filter_fn(list(self._functions.keys())))
+
+        def predicate(name: str) -> bool:
+            if name in excluded:
+                return False
+            if not self._fn_should_be_included(name):
+                return False
+            return name in included
+
+        return {self._get_fn_name(name): self._functions[name] for name in self._functions if predicate(name)}
+
+    def get_accessible_functions(
+        self,
+        filter_fn: Callable[[Sequence[str]], Sequence[str]] | None = None,
+    ) -> dict[str, Function]:
+        """
+        Returns a dictionary of all accessible functions in the function group.
+
+        First, the functions are filtered by the function group's configuration.
+        If the function group is configured to:
+        - include some functions, this will return only the included functions.
+        - not include or exclude any function, this will return all functions in the group.
+        - exclude some functions, this will return all functions in the group except the excluded functions.
+
+        Then, the functions are filtered by filter function and per-function filter functions.
+
+        Parameters
+        ----------
+        filter_fn : Callable[[Sequence[str]], Sequence[str]] | None, optional
+            A callback function to additionally filter the functions in the function group dynamically. If not provided
+            then fall back to the function group's filter function. If no filter function is set for the function group
+            all functions will be returned.
+
+        Returns
+        -------
+        dict[str, Function]
+            A dictionary of all accessible functions in the function group.
+
+        Raises
+        ------
+        ValueError
+            When the function group is configured to include functions that are not found in the group.
+        """
+        if self._config.include:
+            return self.get_included_functions(filter_fn=filter_fn)
+        if self._config.exclude:
+            return self._get_all_but_excluded_functions(filter_fn=filter_fn)
+        return self.get_all_functions(filter_fn=filter_fn)
+
+    def get_excluded_functions(
+        self,
+        filter_fn: Callable[[Sequence[str]], Sequence[str]] | None = None,
+    ) -> dict[str, Function]:
+        """
+        Returns a dictionary of all functions in the function group which are configured to be excluded or filtered
+        out by a filter function or per-function filter function.
+
+        Parameters
+        ----------
+        filter_fn : Callable[[Sequence[str]], Sequence[str]] | None, optional
+            A callback function to additionally filter the functions in the function group dynamically. If not provided
+            then fall back to the function group's filter function. If no filter function is set for the function group
+            then no functions will be added to the returned dictionary.
+
+        Returns
+        -------
+        dict[str, Function]
+            A dictionary of all excluded functions in the function group.
+
+        Raises
+        ------
+        ValueError
+            When the function group is configured to exclude functions that are not found in the group.
+        """
+        missing = set(self._config.exclude) - set(self._functions.keys())
+        if missing:
+            raise ValueError(f"Unknown excluded functions: {sorted(missing)}")
+        filter_fn = filter_fn or self._filter_fn or (lambda x: x)
+        excluded = set(self._config.exclude)
+        included = set(filter_fn(list(self._functions.keys())))
+
+        def predicate(name: str) -> bool:
+            if name in excluded:
+                return True
+            if not self._fn_should_be_included(name):
+                return True
+            return name not in included
+
+        return {self._get_fn_name(name): self._functions[name] for name in self._functions if predicate(name)}
+
+    def get_included_functions(
+        self,
+        filter_fn: Callable[[Sequence[str]], Sequence[str]] | None = None,
+    ) -> dict[str, Function]:
+        """
+        Returns a dictionary of all functions in the function group which are:
+        - configured to be included and added to the global function registry
+        - not configured to be excluded.
+        - not filtered out by a filter function.
+
+        Parameters
+        ----------
+        filter_fn : Callable[[Sequence[str]], Sequence[str]] | None, optional
+            A callback function to additionally filter the functions in the function group dynamically. If not provided
+            then fall back to the function group's filter function. If no filter function is set for the function group
+            all functions will be returned.
+
+        Returns
+        -------
+        dict[str, Function]
+            A dictionary of all included functions in the function group.
+
+        Raises
+        ------
+        ValueError
+            When the function group is configured to include functions that are not found in the group.
+        """
+        missing = set(self._config.include) - set(self._functions.keys())
+        if missing:
+            raise ValueError(f"Unknown included functions: {sorted(missing)}")
+        filter_fn = filter_fn or self._filter_fn or (lambda x: x)
+        included = set(filter_fn(list(self._config.include)))
+        included = {name for name in included if self._fn_should_be_included(name)}
+        return {self._get_fn_name(name): self._functions[name] for name in included}
+
+    def get_all_functions(
+        self,
+        filter_fn: Callable[[Sequence[str]], Sequence[str]] | None = None,
+    ) -> dict[str, Function]:
+        """
+        Returns a dictionary of all functions in the function group, regardless if they are included or excluded.
+
+        If a filter function has been set, the returned functions will additionally be filtered by the callback.
+
+        Parameters
+        ----------
+        filter_fn : Callable[[Sequence[str]], Sequence[str]] | None, optional
+            A callback function to additionally filter the functions in the function group dynamically. If not provided
+            then fall back to the function group's filter function. If no filter function is set for the function group
+            all functions will be returned.
+
+        Returns
+        -------
+        dict[str, Function]
+            A dictionary of all functions in the function group.
+        """
+        filter_fn = filter_fn or self._filter_fn or (lambda x: x)
+        included = set(filter_fn(list(self._functions.keys())))
+        included = {name for name in included if self._fn_should_be_included(name)}
+        return {self._get_fn_name(name): self._functions[name] for name in included}
+
+    def set_filter_fn(self, filter_fn: Callable[[Sequence[str]], Sequence[str]]):
+        """
+        Sets the filter function for the function group.
+
+        Parameters
+        ----------
+        filter_fn : Callable[[Sequence[str]], Sequence[str]]
+            The filter function to set for the function group.
+        """
+        self._filter_fn = filter_fn
+
+    def set_per_function_filter_fn(self, name: str, filter_fn: Callable[[str], bool]):
+        """
+        Sets the a per-function filter function for the a function within the function group.
+
+        Parameters
+        ----------
+        name : str
+            The name of the function.
+        filter_fn : Callable[[str], bool]
+            The per-function filter function to set for the function group.
+
+        Raises
+        ------
+        ValueError
+            When the function is not found in the function group.
+        """
+        if name not in self._functions:
+            raise ValueError(f"Function {name} not found in function group {self._instance_name}")
+        self._per_function_filter_fn[name] = filter_fn
+
+    def set_instance_name(self, instance_name: str):
+        """
+        Sets the instance name for the function group.
+
+        Parameters
+        ----------
+        instance_name : str
+            The instance name to set for the function group.
+        """
+        self._instance_name = instance_name
+
+    @property
+    def instance_name(self) -> str:
+        """
+        Returns the instance name for the function group.
+        """
+        return self._instance_name

nat/builder/function_info.py

@@ -233,7 +233,7 @@ class FunctionDescriptor:
 
             is_input_typed = all([a != sig.empty for a in annotations])
 
-            input_type = tuple[*annotations] if is_input_typed else None  # noqa: syntax-error
+            input_type = tuple[*annotations] if is_input_typed else None
 
         # Get the base type here removing all annotations and async generators
         output_annotation_decomp = DecomposedType(sig.return_annotation).get_base_type()

nat/builder/workflow.py

@@ -20,6 +20,7 @@ from typing import Any
 from nat.builder.context import ContextState
 from nat.builder.embedder import EmbedderProviderInfo
 from nat.builder.function import Function
+from nat.builder.function import FunctionGroup
 from nat.builder.function_base import FunctionBase
 from nat.builder.function_base import InputT
 from nat.builder.function_base import SingleOutputT
@@ -44,6 +45,7 @@ class Workflow(FunctionBase[InputT, StreamingOutputT, SingleOutputT]):
                  config: Config,
                  entry_fn: Function[InputT, StreamingOutputT, SingleOutputT],
                  functions: dict[str, Function] | None = None,
+                 function_groups: dict[str, FunctionGroup] | None = None,
                  llms: dict[str, LLMProviderInfo] | None = None,
                  embeddings: dict[str, EmbedderProviderInfo] | None = None,
                  memory: dict[str, MemoryEditor] | None = None,
@@ -59,6 +61,7 @@ class Workflow(FunctionBase[InputT, StreamingOutputT, SingleOutputT]):
 
         self.config = config
         self.functions = functions or {}
+        self.function_groups = function_groups or {}
         self.llms = llms or {}
         self.embeddings = embeddings or {}
         self.memory = memory or {}
@@ -126,6 +129,7 @@ class Workflow(FunctionBase[InputT, StreamingOutputT, SingleOutputT]):
                       config: Config,
                       entry_fn: Function[InputT, StreamingOutputT, SingleOutputT],
                       functions: dict[str, Function] | None = None,
+                      function_groups: dict[str, FunctionGroup] | None = None,
                       llms: dict[str, LLMProviderInfo] | None = None,
                       embeddings: dict[str, EmbedderProviderInfo] | None = None,
                       memory: dict[str, MemoryEditor] | None = None,
@@ -145,6 +149,7 @@ class Workflow(FunctionBase[InputT, StreamingOutputT, SingleOutputT]):
         return WorkflowImpl(config=config,
                             entry_fn=entry_fn,
                             functions=functions,
+                            function_groups=function_groups,
                             llms=llms,
                             embeddings=embeddings,
                             memory=memory,