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

nat/middleware/dynamic/dynamic_middleware_config.py

@@ -0,0 +1,132 @@
+# 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.
+"""Configuration for dynamic middleware."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel
+from pydantic import Field
+from pydantic import model_validator
+
+from nat.data_models.component import ComponentGroup
+from nat.data_models.component_ref import AuthenticationRef
+from nat.data_models.component_ref import EmbedderRef
+from nat.data_models.component_ref import LLMRef
+from nat.data_models.component_ref import MemoryRef
+from nat.data_models.component_ref import ObjectStoreRef
+from nat.data_models.component_ref import RetrieverRef
+from nat.data_models.middleware import FunctionMiddlewareBaseConfig
+
+
+class AllowedComponentFunctions(BaseModel):
+    """Component functions allowed for auto-registration.
+
+    Default allowlists are provided for each component type. User-provided
+    values are automatically merged with defaults.
+    Set to None or omit to use only defaults.
+    """
+
+    llms: set[str] | None = Field(
+        default=None, description="Additional LLM functions that should be allowed to register with middleware.")
+    embedders: set[str] | None = Field(
+        default=None, description="Additional Embedder functions that should be allowed to register with middleware.")
+    retrievers: set[str] | None = Field(
+        default=None, description="Additional Retriever functions that should be allowed to register with middleware.")
+    memory: set[str] | None = Field(
+        default=None, description="Additional Memory functions that should be allowed to register with middleware.")
+    object_stores: set[str] | None = Field(
+        default=None,
+        description="Additional Object Store functions that should be allowed to register with middleware.")
+    authentication: set[str] | None = Field(
+        default=None,
+        description="Additional Authentication functions that should be allowed to register with middleware.")
+
+    @model_validator(mode='after')
+    def merge_with_defaults(self):
+        """Merge user-provided values with defaults from COMPONENT_FUNCTION_ALLOWLISTS."""
+        from nat.middleware.utils.workflow_inventory import COMPONENT_FUNCTION_ALLOWLISTS
+
+        def merge(component_group: ComponentGroup, user_set: set[str] | None) -> set[str]:
+            defaults = COMPONENT_FUNCTION_ALLOWLISTS[component_group]
+            if user_set is None:
+                return defaults.copy()
+            return defaults | user_set
+
+        self.llms = merge(ComponentGroup.LLMS, self.llms)
+        self.embedders = merge(ComponentGroup.EMBEDDERS, self.embedders)
+        self.retrievers = merge(ComponentGroup.RETRIEVERS, self.retrievers)
+        self.memory = merge(ComponentGroup.MEMORY, self.memory)
+        self.object_stores = merge(ComponentGroup.OBJECT_STORES, self.object_stores)
+        self.authentication = merge(ComponentGroup.AUTHENTICATION, self.authentication)
+
+        return self
+
+
+class DynamicMiddlewareConfig(FunctionMiddlewareBaseConfig, name="dynamic_middleware"):
+    """Configuration for dynamic middleware.
+
+    Controls which components and functions to intercept, and which policies to apply.
+    Supports explicit component references and auto-discovery flags.
+    """
+
+    # === Component References ===
+
+    llms: list[LLMRef] | None = Field(default=None, description="LLMs to intercept")
+
+    embedders: list[EmbedderRef] | None = Field(default=None, description="Embedders component functions to intercept")
+
+    retrievers: list[RetrieverRef] | None = Field(default=None,
+                                                  description="Retrievers component functions to intercept")
+
+    memory: list[MemoryRef] | None = Field(default=None, description="Memory component functions to intercept")
+
+    object_stores: list[ObjectStoreRef] | None = Field(default=None,
+                                                       description="Object stores component functions to intercept")
+
+    auth_providers: list[AuthenticationRef] | None = Field(
+        default=None, description="Authentication providers component functions to intercept")
+
+    # === Component and Function Auto-Discovery Flags ===
+
+    register_llms: bool | None = Field(default=False,
+                                       description="Auto-discover and register all LLMs component functions")
+
+    register_embedders: bool | None = Field(default=False,
+                                            description="Auto-discover and register all embedders component functions")
+
+    register_retrievers: bool | None = Field(
+        default=False, description="Auto-discover and register all retrievers component functions")
+
+    register_memory: bool | None = Field(
+        default=False, description="Auto-discover and register all memory providers component functions")
+
+    register_object_stores: bool | None = Field(
+        default=False, description="Auto-discover and register all object stores component functions")
+
+    register_auth_providers: bool | None = Field(
+        default=False, description="Auto-discover and register all authentication providers component functions")
+
+    register_workflow_functions: bool | None = Field(default=False,
+                                                     description="Auto-discover and register all workflow functions")
+
+    # === Enable/Disable ===
+
+    enabled: bool = Field(default=True, description="Whether this middleware is active")
+
+    # === Component Function Allowlists ===
+
+    allowed_component_functions: AllowedComponentFunctions | None = Field(
+        default=None,
+        description="Functions allowed for auto-registration. Omit to use defaults, provide to extend them")

nat/middleware/dynamic/register.py

@@ -0,0 +1,34 @@
+# 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.
+"""Registration for dynamic middleware."""
+
+from nat.builder.builder import Builder
+from nat.cli.register_workflow import register_middleware
+from nat.middleware.dynamic.dynamic_function_middleware import DynamicFunctionMiddleware
+from nat.middleware.dynamic.dynamic_middleware_config import DynamicMiddlewareConfig
+
+
+@register_middleware(config_type=DynamicMiddlewareConfig)
+async def dynamic_middleware(config: DynamicMiddlewareConfig, builder: Builder):
+    """Build a dynamic middleware from configuration.
+
+    Args:
+        config: The dynamic middleware configuration
+        builder: The workflow builder
+
+    Yields:
+        A configured dynamic middleware instance
+    """
+    yield DynamicFunctionMiddleware(config=config, builder=builder)

nat/middleware/function_middleware.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");
@@ -37,81 +37,250 @@ from typing import Any
 from nat.middleware.middleware import CallNext
 from nat.middleware.middleware import CallNextStream
 from nat.middleware.middleware import FunctionMiddlewareContext
+from nat.middleware.middleware import InvocationContext
 from nat.middleware.middleware import Middleware
 
 
 class FunctionMiddleware(Middleware):
-    """Specialized middleware for function-specific wrapping.
-
-    This class extends the base Middleware class and provides function-specific
-    wrapping methods. Functions that use this middleware type will call
-    ``function_middleware_invoke`` and ``function_middleware_stream`` instead of
-    the base ``middleware_invoke`` and ``middleware_stream`` methods.
+    """Base class for function middleware with pre/post-invoke hooks.
+
+    Middleware intercepts function calls and can:
+    - Transform inputs before execution (pre_invoke)
+    - Transform outputs after execution (post_invoke)
+    - Override function_middleware_invoke for full control
+
+    Lifecycle:
+    - Framework checks ``enabled`` property before calling any methods
+    - If disabled, middleware is skipped entirely (no methods called)
+    - Users do NOT need to check ``enabled`` in their implementations
+
+    Inherited abstract members that must be implemented:
+    - enabled: Property that returns whether middleware should run
+    - pre_invoke: Transform inputs before function execution
+    - post_invoke: Transform outputs after function execution
+
+    Context Flow:
+    - FunctionMiddlewareContext (frozen): Static function metadata only
+    - InvocationContext: Unified context for both pre and post invoke phases
+    - Pre-invoke: output is None, modify modified_args/modified_kwargs
+    - Post-invoke: output has the result, modify output to transform
+
+    Example::
+
+        class LoggingMiddleware(FunctionMiddleware):
+            def __init__(self, config: LoggingConfig):
+                super().__init__()
+                self._config = config
+
+            @property
+            def enabled(self) -> bool:
+                return self._config.enabled
+
+            async def pre_invoke(self, context: InvocationContext) -> InvocationContext | None:
+                logger.info(f"Calling {context.function_context.name} with {context.modified_args}")
+                logger.info(f"Original args: {context.original_args}")
+                return None  # Pass through unchanged
+
+            async def post_invoke(self, context: InvocationContext) -> InvocationContext | None:
+                logger.info(f"Result: {context.output}")
+                return None  # Pass through unchanged
     """
 
-    async def middleware_invoke(self, value: Any, call_next: CallNext, context: FunctionMiddlewareContext) -> Any:
+    @property
+    def enabled(self) -> bool:
+        """Check if this middleware is enabled.
+
+        Returns:
+            True if the middleware should be applied, False otherwise.
+            Default implementation always returns True.
+        """
+        return True
+
+    async def pre_invoke(self, context: InvocationContext) -> InvocationContext | None:
+        """Pre-invocation hook called before the function is invoked.
+
+        Args:
+            context: Invocation context containing function metadata and args
+
+        Returns:
+            InvocationContext if modified, or None to pass through unchanged.
+            Default implementation does nothing.
+        """
+        del context  # Unused by default implementation
+        return None
+
+    async def post_invoke(self, context: InvocationContext) -> InvocationContext | None:
+        """Post-invocation hook called after the function returns.
+
+        Args:
+            context: Invocation context containing function metadata, args, and output
+
+        Returns:
+            InvocationContext if modified, or None to pass through unchanged.
+            Default implementation does nothing.
+        """
+        del context  # Unused by default implementation
+        return None
+
+    # ==================== Middleware Delegation ====================
+    async def middleware_invoke(self,
+                                *args: Any,
+                                call_next: CallNext,
+                                context: FunctionMiddlewareContext,
+                                **kwargs: Any) -> Any:
         """Delegate to function_middleware_invoke for function-specific handling."""
-        return await self.function_middleware_invoke(value, call_next, context)
+        return await self.function_middleware_invoke(*args, call_next=call_next, context=context, **kwargs)
 
-    async def middleware_stream(self, value: Any, call_next: CallNextStream,
-                                context: FunctionMiddlewareContext) -> AsyncIterator[Any]:
+    async def middleware_stream(self,
+                                *args: Any,
+                                call_next: CallNextStream,
+                                context: FunctionMiddlewareContext,
+                                **kwargs: Any) -> AsyncIterator[Any]:
         """Delegate to function_middleware_stream for function-specific handling."""
-        async for chunk in self.function_middleware_stream(value, call_next, context):
+        async for chunk in self.function_middleware_stream(*args, call_next=call_next, context=context, **kwargs):
             yield chunk
 
-    async def function_middleware_invoke(self, value: Any, call_next: CallNext,
-                                         context: FunctionMiddlewareContext) -> Any:
-        """Function-specific middleware for single-output invocations.
+    # ==================== Orchestration ====================
+
+    async def function_middleware_invoke(
+        self,
+        *args: Any,
+        call_next: CallNext,
+        context: FunctionMiddlewareContext,
+        **kwargs: Any,
+    ) -> Any:
+        """Execute middleware hooks around function call.
+
+        Default implementation orchestrates: pre_invoke → call_next → post_invoke
+
+        Override for full control over execution flow (e.g., caching,
+        retry logic, conditional execution).
+
+        Note: Framework checks ``enabled`` before calling this method.
+        You do NOT need to check ``enabled`` yourself.
 
         Args:
-            value: The input value to process
-            call_next: Callable to invoke the next middleware or function
-            context: Metadata about the function being wrapped
+            args: Positional arguments for the function (first arg is typically the input value).
+            call_next: Callable to invoke next middleware or target function.
+            context: Static function metadata.
+            kwargs: Keyword arguments for the function.
 
         Returns:
-            The (potentially modified) output from the function
-
-        The default implementation simply delegates to ``call_next``. Override this
-        in subclasses to add function-specific preprocessing and postprocessing.
+            The (potentially transformed) function output.
         """
-        return await call_next(value)
-
-    async def function_middleware_stream(self,
-                                         value: Any,
-                                         call_next: CallNextStream,
-                                         context: FunctionMiddlewareContext) -> AsyncIterator[Any]:
-        """Function-specific middleware for streaming invocations.
+        # Build invocation context with frozen originals + mutable current
+        # output starts as None (pre-invoke phase)
+        ctx = InvocationContext(
+            function_context=context,
+            original_args=args,
+            original_kwargs=dict(kwargs),
+            modified_args=args,
+            modified_kwargs=dict(kwargs),
+            output=None,
+        )
+
+        # Pre-invoke transformation (output is None at this phase)
+        result = await self.pre_invoke(ctx)
+        if result is not None:
+            ctx = result
+
+        # Execute function with (potentially modified) args/kwargs
+        ctx.output = await call_next(*ctx.modified_args, **ctx.modified_kwargs)
+
+        # Post-invoke transformation (output now has the result)
+        result = await self.post_invoke(ctx)
+        if result is not None:
+            ctx = result
+
+        return ctx.output
+
+    async def function_middleware_stream(
+        self,
+        *args: Any,
+        call_next: CallNextStream,
+        context: FunctionMiddlewareContext,
+        **kwargs: Any,
+    ) -> AsyncIterator[Any]:
+        """Execute middleware hooks around streaming function call.
+
+        Pre-invoke runs once before streaming starts.
+        Post-invoke runs per-chunk as they stream through.
+
+        Override for custom streaming behavior (e.g., buffering,
+        aggregation, chunk filtering).
+
+        Note: Framework checks ``enabled`` before calling this method.
+        You do NOT need to check ``enabled`` yourself.
 
         Args:
-            value: The input value to process
-            call_next: Callable to invoke the next middleware or function stream
-            context: Metadata about the function being wrapped
+            args: Positional arguments for the function (first arg is typically the input value).
+            call_next: Callable to invoke next middleware or target stream.
+            context: Static function metadata.
+            kwargs: Keyword arguments for the function.
 
         Yields:
-            Chunks from the stream (potentially modified)
-
-        The default implementation forwards to ``call_next`` untouched. Override this
-        in subclasses to add function-specific preprocessing and chunk transformations.
+            Stream chunks (potentially transformed by post_invoke).
         """
-        async for chunk in call_next(value):
-            yield chunk
+        # Build invocation context with frozen originals + mutable current
+        # output starts as None (pre-invoke phase)
+        ctx = InvocationContext(
+            function_context=context,
+            original_args=args,
+            original_kwargs=dict(kwargs),
+            modified_args=args,
+            modified_kwargs=dict(kwargs),
+            output=None,
+        )
+
+        # Pre-invoke transformation (once before streaming)
+        result = await self.pre_invoke(ctx)
+        if result is not None:
+            ctx = result
+
+        # Stream with per-chunk post-invoke
+        async for chunk in call_next(*ctx.modified_args, **ctx.modified_kwargs):
+            # Set output for this chunk
+            ctx.output = chunk
+
+            # Post-invoke transformation per chunk
+            result = await self.post_invoke(ctx)
+            if result is not None:
+                ctx = result
+
+            yield ctx.output
 
 
 class FunctionMiddlewareChain:
-    """Utility that composes middleware-style callables.
+    """Composes middleware into an execution chain.
+
+    The chain builder checks each middleware's ``enabled`` property.
+    Disabled middleware is skipped entirely—no methods are called.
 
-    This class builds a chain of middleware that executes in order,
-    with each middleware able to preprocess inputs, call the next middleware,
-    and postprocess outputs.
+    Execution order:
+    - Pre-invoke: first middleware → last middleware → function
+    - Post-invoke: function → last middleware → first middleware
+
+    Context:
+    - FunctionMiddlewareContext contains only static function metadata
+    - Original args/kwargs are captured by the orchestration layer
+    - Middleware receives InvocationContext with frozen originals and mutable args/output
     """
 
-    def __init__(self, *, middleware: Sequence[Middleware], context: FunctionMiddlewareContext) -> None:
+    def __init__(self, *, middleware: Sequence[FunctionMiddleware], context: FunctionMiddlewareContext) -> None:
+        """Initialize the middleware chain.
+
+        Args:
+            middleware: Sequence of middleware to chain (order matters)
+            context: Static function metadata
+        """
         self._middleware = tuple(middleware)
         self._context = context
 
     def build_single(self, final_call: CallNext) -> CallNext:
         """Build the middleware chain for single-output invocations.
 
+        Disabled middleware (enabled=False) is skipped entirely.
+
         Args:
             final_call: The final function to call (the actual function implementation)
 
@@ -121,18 +290,28 @@ class FunctionMiddlewareChain:
         call = final_call
 
         for mw in reversed(self._middleware):
+            # Framework-enforced: skip disabled middleware
+            if not mw.enabled:
+                continue
+
             call_next = call
 
-            async def wrapped(value: Any, *, _middleware: Middleware = mw, _call_next: CallNext = call_next) -> Any:
-                return await _middleware.middleware_invoke(value, _call_next, self._context)
+            async def wrapped(*args: Any,
+                              _middleware: FunctionMiddleware = mw,
+                              _call_next: CallNext = call_next,
+                              _context: FunctionMiddlewareContext = self._context,
+                              **kwargs: Any) -> Any:
+                return await _middleware.middleware_invoke(*args, call_next=_call_next, context=_context, **kwargs)
 
-            call = wrapped
+            call = wrapped  # type: ignore[assignment]
 
         return call
 
     def build_stream(self, final_call: CallNextStream) -> CallNextStream:
         """Build the middleware chain for streaming invocations.
 
+        Disabled middleware (enabled=False) is skipped entirely.
+
         Args:
             final_call: The final function to call (the actual function implementation)
 
@@ -142,16 +321,21 @@ class FunctionMiddlewareChain:
         call = final_call
 
         for mw in reversed(self._middleware):
+            if not mw.enabled:
+                continue
+
             call_next = call
 
-            async def wrapped(value: Any,
-                              *,
-                              _middleware: Middleware = mw,
-                              _call_next: CallNextStream = call_next) -> AsyncIterator[Any]:
-                async for chunk in _middleware.middleware_stream(value, _call_next, self._context):
+            async def wrapped(*args: Any,
+                              _middleware: FunctionMiddleware = mw,
+                              _call_next: CallNextStream = call_next,
+                              _context: FunctionMiddlewareContext = self._context,
+                              **kwargs: Any) -> AsyncIterator[Any]:
+                stream = _middleware.middleware_stream(*args, call_next=_call_next, context=_context, **kwargs)
+                async for chunk in stream:
                     yield chunk
 
-            call = wrapped
+            call = wrapped  # type: ignore[assignment]
 
         return call
 

nat/middleware/logging/__init__.py

@@ -0,0 +1,14 @@
+# 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.

nat/middleware/logging/logging_middleware.py

@@ -0,0 +1,67 @@
+# 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 logging
+
+from nat.builder.builder import Builder
+from nat.middleware.dynamic.dynamic_function_middleware import DynamicFunctionMiddleware
+from nat.middleware.logging.logging_middleware_config import LoggingMiddlewareConfig
+from nat.middleware.middleware import InvocationContext
+
+logger = logging.getLogger(__name__)
+
+
+class LoggingMiddleware(DynamicFunctionMiddleware):
+    """Middleware that logs intercepted function inputs/outputs.
+
+    This middleware extends DynamicFunctionMiddleware to get automatic chain
+    orchestration and dynamic discovery features. Custom logic is implemented
+    through the pre_invoke and post_invoke hooks.
+    """
+
+    def __init__(self, config: LoggingMiddlewareConfig, builder: Builder):
+        """Initialize logging middleware.
+
+        Args:
+            config: Logging middleware configuration
+            builder: Workflow builder
+        """
+        super().__init__(config=config, builder=builder)
+        self._config: LoggingMiddlewareConfig = config
+
+    async def pre_invoke(self, context: InvocationContext) -> InvocationContext | None:
+        """Log inputs before function execution.
+
+        Returns:
+            None to pass through unchanged (logging only, no modification)
+        """
+        log_level = getattr(logging, self._config.log_level.upper(), logging.INFO)
+        logger.log(log_level, f"Calling {context.function_context.name} with args: {context.modified_args}")
+
+        # Log if args were modified by prior middleware
+        if context.modified_args != context.original_args:
+            logger.log(log_level, f"  (original args were: {context.original_args})")
+
+        return None  # Pass through unchanged
+
+    async def post_invoke(self, context: InvocationContext) -> InvocationContext | None:
+        """Log outputs after function execution.
+
+        Returns:
+            None to pass through unchanged (logging only, no modification)
+        """
+        log_level = getattr(logging, self._config.log_level.upper(), logging.INFO)
+        logger.log(log_level, f"Function {context.function_context.name} returned: {context.output}")
+        return None  # Pass through unchanged

nat/middleware/logging/logging_middleware_config.py

@@ -0,0 +1,28 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from pydantic import Field
+
+from nat.middleware.dynamic.dynamic_middleware_config import DynamicMiddlewareConfig
+
+
+class LoggingMiddlewareConfig(DynamicMiddlewareConfig, name="logging_middleware"):
+    """Configuration for logging middleware.
+
+    Extends DynamicMiddlewareConfig to inherit all dynamic discovery features
+    (register_llms, register_workflow_functions, and so on) and the enabled toggle.
+    """
+
+    log_level: str = Field(default="INFO", description="Logging level (DEBUG, INFO, WARNING, ERROR)")

nat/middleware/logging/register.py

@@ -0,0 +1,33 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from nat.builder.builder import Builder
+from nat.cli.register_workflow import register_middleware
+from nat.middleware.logging.logging_middleware import LoggingMiddleware
+from nat.middleware.logging.logging_middleware_config import LoggingMiddlewareConfig
+
+
+@register_middleware(config_type=LoggingMiddlewareConfig)
+async def logging_middleware(config: LoggingMiddlewareConfig, builder: Builder):
+    """Build a logging middleware from configuration.
+
+    Args:
+        config: The logging middleware configuration
+        builder: The workflow builder
+
+    Yields:
+        A configured logging middleware instance
+    """
+    yield LoggingMiddleware(config=config, builder=builder)