nvidia-nat 1.4.0a20251010__py3-none-any.whl → 1.4.0a20251011__py3-none-any.whl

nat/agent/react_agent/register.py

@@ -24,6 +24,7 @@ from nat.builder.function_info import FunctionInfo
 from nat.cli.register_workflow import register_function
 from nat.data_models.agent import AgentBaseConfig
 from nat.data_models.api_server import ChatRequest
+from nat.data_models.api_server import ChatRequestOrMessage
 from nat.data_models.api_server import ChatResponse
 from nat.data_models.api_server import Usage
 from nat.data_models.component_ref import FunctionGroupRef
@@ -70,9 +71,6 @@ class ReActAgentWorkflowConfig(AgentBaseConfig, OptimizableMixin, name="react_ag
         default=None,
         description="Provides the SYSTEM_PROMPT to use with the agent")  # defaults to SYSTEM_PROMPT in prompt.py
     max_history: int = Field(default=15, description="Maximum number of messages to keep in the conversation history.")
-    use_openai_api: bool = Field(default=False,
-                                 description=("Use OpenAI API for the input/output types to the function. "
-                                              "If False, strings will be used."))
     additional_instructions: str | None = OptimizableField(
         default=None,
         description="Additional instructions to provide to the agent in addition to the base prompt.",
@@ -118,21 +116,23 @@ async def react_agent_workflow(config: ReActAgentWorkflowConfig, builder: Builde
         pass_tool_call_errors_to_agent=config.pass_tool_call_errors_to_agent,
         normalize_tool_input_quotes=config.normalize_tool_input_quotes).build_graph()
 
-    async def _response_fn(input_message: ChatRequest) -> ChatResponse:
+    async def _response_fn(chat_request_or_message: ChatRequestOrMessage) -> ChatResponse | str:
         """
         Main workflow entry function for the ReAct Agent.
 
         This function invokes the ReAct Agent Graph and returns the response.
 
         Args:
-            input_message (ChatRequest): The input message to process
+            chat_request_or_message (ChatRequestOrMessage): The input message to process
 
         Returns:
-            ChatResponse: The response from the agent or error message
+            ChatResponse | str: The response from the agent or error message
         """
         try:
+            message = GlobalTypeConverter.get().convert(chat_request_or_message, to_type=ChatRequest)
+
             # initialize the starting state with the user query
-            messages: list[BaseMessage] = trim_messages(messages=[m.model_dump() for m in input_message.messages],
+            messages: list[BaseMessage] = trim_messages(messages=[m.model_dump() for m in message.messages],
                                                         max_tokens=config.max_history,
                                                         strategy="last",
                                                         token_counter=len,
@@ -153,25 +153,16 @@ async def react_agent_workflow(config: ReActAgentWorkflowConfig, builder: Builde
             content = str(output_message.content)
 
             # Create usage statistics for the response
-            prompt_tokens = sum(len(str(msg.content).split()) for msg in input_message.messages)
+            prompt_tokens = sum(len(str(msg.content).split()) for msg in message.messages)
             completion_tokens = len(content.split()) if content else 0
             total_tokens = prompt_tokens + completion_tokens
             usage = Usage(prompt_tokens=prompt_tokens, completion_tokens=completion_tokens, total_tokens=total_tokens)
-            return ChatResponse.from_string(content, usage=usage)
-
+            response = ChatResponse.from_string(content, usage=usage)
+            if chat_request_or_message.is_string:
+                return GlobalTypeConverter.get().convert(response, to_type=str)
+            return response
         except Exception as ex:
-            logger.exception("%s ReAct Agent failed with exception: %s", AGENT_LOG_PREFIX, str(ex))
-            raise RuntimeError
-
-    if (config.use_openai_api):
-        yield FunctionInfo.from_fn(_response_fn, description=config.description)
-    else:
-
-        async def _str_api_fn(input_message: str) -> str:
-            oai_input = GlobalTypeConverter.get().try_convert(input_message, to_type=ChatRequest)
-
-            oai_output = await _response_fn(oai_input)
-
-            return GlobalTypeConverter.get().try_convert(oai_output, to_type=str)
+            logger.error("%s ReAct Agent failed with exception: %s", AGENT_LOG_PREFIX, str(ex))
+            raise
 
-        yield FunctionInfo.from_fn(_str_api_fn, description=config.description)
+    yield FunctionInfo.from_fn(_response_fn, description=config.description)

nat/agent/rewoo_agent/register.py

@@ -25,6 +25,7 @@ from nat.builder.function_info import FunctionInfo
 from nat.cli.register_workflow import register_function
 from nat.data_models.agent import AgentBaseConfig
 from nat.data_models.api_server import ChatRequest
+from nat.data_models.api_server import ChatRequestOrMessage
 from nat.data_models.api_server import ChatResponse
 from nat.data_models.api_server import Usage
 from nat.data_models.component_ref import FunctionGroupRef
@@ -54,9 +55,6 @@ class ReWOOAgentWorkflowConfig(AgentBaseConfig, name="rewoo_agent"):
                                                description="The number of retries before raising a tool call error.",
                                                ge=1)
     max_history: int = Field(default=15, description="Maximum number of messages to keep in the conversation history.")
-    use_openai_api: bool = Field(default=False,
-                                 description=("Use OpenAI API for the input/output types to the function. "
-                                              "If False, strings will be used."))
     additional_planner_instructions: str | None = Field(
         default=None,
         validation_alias=AliasChoices("additional_planner_instructions", "additional_instructions"),
@@ -125,21 +123,23 @@ async def rewoo_agent_workflow(config: ReWOOAgentWorkflowConfig, builder: Builde
         tool_call_max_retries=config.tool_call_max_retries,
         raise_tool_call_error=config.raise_tool_call_error).build_graph()
 
-    async def _response_fn(input_message: ChatRequest) -> ChatResponse:
+    async def _response_fn(chat_request_or_message: ChatRequestOrMessage) -> ChatResponse | str:
         """
         Main workflow entry function for the ReWOO Agent.
 
         This function invokes the ReWOO Agent Graph and returns the response.
 
         Args:
-            input_message (ChatRequest): The input message to process
+            chat_request_or_message (ChatRequestOrMessage): The input message to process
 
         Returns:
-            ChatResponse: The response from the agent or error message
+            ChatResponse | str: The response from the agent or error message
         """
         try:
+            message = GlobalTypeConverter.get().convert(chat_request_or_message, to_type=ChatRequest)
+
             # initialize the starting state with the user query
-            messages: list[BaseMessage] = trim_messages(messages=[m.model_dump() for m in input_message.messages],
+            messages: list[BaseMessage] = trim_messages(messages=[m.model_dump() for m in message.messages],
                                                         max_tokens=config.max_history,
                                                         strategy="last",
                                                         token_counter=len,
@@ -160,25 +160,16 @@ async def rewoo_agent_workflow(config: ReWOOAgentWorkflowConfig, builder: Builde
                 output_message = str(output_message)
 
             # Create usage statistics for the response
-            prompt_tokens = sum(len(str(msg.content).split()) for msg in input_message.messages)
+            prompt_tokens = sum(len(str(msg.content).split()) for msg in message.messages)
             completion_tokens = len(output_message.split()) if output_message else 0
             total_tokens = prompt_tokens + completion_tokens
             usage = Usage(prompt_tokens=prompt_tokens, completion_tokens=completion_tokens, total_tokens=total_tokens)
-            return ChatResponse.from_string(output_message, usage=usage)
-
+            response = ChatResponse.from_string(output_message, usage=usage)
+            if chat_request_or_message.is_string:
+                return GlobalTypeConverter.get().convert(response, to_type=str)
+            return response
         except Exception as ex:
-            logger.exception("ReWOO Agent failed with exception: %s", ex)
-            raise RuntimeError
-
-    if (config.use_openai_api):
-        yield FunctionInfo.from_fn(_response_fn, description=config.description)
-
-    else:
-
-        async def _str_api_fn(input_message: str) -> str:
-            oai_input = GlobalTypeConverter.get().try_convert(input_message, to_type=ChatRequest)
-            oai_output = await _response_fn(oai_input)
-
-            return GlobalTypeConverter.get().try_convert(oai_output, to_type=str)
+            logger.error("ReWOO Agent failed with exception: %s", ex)
+            raise
 
-        yield FunctionInfo.from_fn(_str_api_fn, description=config.description)
+    yield FunctionInfo.from_fn(_response_fn, description=config.description)

nat/agent/tool_calling_agent/register.py

@@ -23,8 +23,10 @@ from nat.builder.function_info import FunctionInfo
 from nat.cli.register_workflow import register_function
 from nat.data_models.agent import AgentBaseConfig
 from nat.data_models.api_server import ChatRequest
+from nat.data_models.api_server import ChatRequestOrMessage
 from nat.data_models.component_ref import FunctionGroupRef
 from nat.data_models.component_ref import FunctionRef
+from nat.utils.type_converter import GlobalTypeConverter
 
 logger = logging.getLogger(__name__)
 
@@ -81,21 +83,23 @@ async def tool_calling_agent_workflow(config: ToolCallAgentWorkflowConfig, build
                                                          handle_tool_errors=config.handle_tool_errors,
                                                          return_direct=return_direct_tools).build_graph()
 
-    async def _response_fn(input_message: ChatRequest) -> str:
+    async def _response_fn(chat_request_or_message: ChatRequestOrMessage) -> str:
         """
         Main workflow entry function for the Tool Calling Agent.
 
         This function invokes the Tool Calling Agent Graph and returns the response.
 
         Args:
-            input_message (ChatRequest): The input message to process
+            chat_request_or_message (ChatRequestOrMessage): The input message to process
 
         Returns:
             str: The response from the agent or error message
         """
         try:
+            message = GlobalTypeConverter.get().convert(chat_request_or_message, to_type=ChatRequest)
+
             # initialize the starting state with the user query
-            messages: list[BaseMessage] = trim_messages(messages=[m.model_dump() for m in input_message.messages],
+            messages: list[BaseMessage] = trim_messages(messages=[m.model_dump() for m in message.messages],
                                                         max_tokens=config.max_history,
                                                         strategy="last",
                                                         token_counter=len,
@@ -114,8 +118,8 @@ async def tool_calling_agent_workflow(config: ToolCallAgentWorkflowConfig, build
             output_message = state.messages[-1]
             return str(output_message.content)
         except Exception as ex:
-            logger.exception("%s Tool Calling Agent failed with exception: %s", AGENT_LOG_PREFIX, ex)
-            raise RuntimeError
+            logger.error("%s Tool Calling Agent failed with exception: %s", AGENT_LOG_PREFIX, ex)
+            raise
 
     try:
         yield FunctionInfo.from_fn(_response_fn, description=config.description)

nat/builder/function.py

@@ -159,8 +159,7 @@ class Function(FunctionBase[InputT, StreamingOutputT, SingleOutputT], ABC):
 
                 return result
             except Exception as e:
-                err_msg = f"Error: {e}" if str(e).strip() else ""
-                logger.error("Error with ainvoke in function with input: %s. %s", value, err_msg)
+                logger.error("Error with ainvoke in function with input: %s. Error: %s", value, e)
                 raise
 
     @typing.final
@@ -416,8 +415,9 @@ class FunctionGroup:
         """
         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 not re.match(r"^[a-zA-Z0-9_.-]+$", name):
+            raise ValueError(
+                f"Function name can only contain letters, numbers, underscores, periods, and hyphens: {name}")
         if name in self._functions:
             raise ValueError(f"Function {name} already exists in function group {self._instance_name}")
 

nat/builder/intermediate_step_manager.py

@@ -16,6 +16,8 @@
 import dataclasses
 import logging
 import typing
+import weakref
+from typing import ClassVar
 
 from nat.data_models.intermediate_step import IntermediateStep
 from nat.data_models.intermediate_step import IntermediateStepPayload
@@ -46,11 +48,19 @@ class IntermediateStepManager:
     Manages updates to the NAT Event Stream for intermediate steps
     """
 
+    # Class-level tracking for debugging and monitoring
+    _instance_count: ClassVar[int] = 0
+    _active_instances: ClassVar[set[weakref.ref]] = set()
+
     def __init__(self, context_state: "ContextState"):  # noqa: F821
         self._context_state = context_state
 
         self._outstanding_start_steps: dict[str, OpenStep] = {}
 
+        # Track instance creation
+        IntermediateStepManager._instance_count += 1
+        IntermediateStepManager._active_instances.add(weakref.ref(self, self._cleanup_instance_tracking))
+
     def push_intermediate_step(self, payload: IntermediateStepPayload) -> None:
         """
         Pushes an intermediate step to the NAT Event Stream
@@ -172,3 +182,25 @@ class IntermediateStepManager:
         """
 
         return self._context_state.event_stream.get().subscribe(on_next, on_error, on_complete)
+
+    @classmethod
+    def _cleanup_instance_tracking(cls, ref: weakref.ref) -> None:
+        """Cleanup callback for weakref when instance is garbage collected."""
+        cls._active_instances.discard(ref)
+
+    @classmethod
+    def get_active_instance_count(cls) -> int:
+        """Get the number of active IntermediateStepManager instances.
+
+        Returns:
+            int: Number of active instances (cleaned up automatically via weakref)
+        """
+        return len(cls._active_instances)
+
+    def get_outstanding_step_count(self) -> int:
+        """Get the number of outstanding (started but not ended) steps.
+
+        Returns:
+            int: Number of steps that have been started but not yet ended
+        """
+        return len(self._outstanding_start_steps)

nat/data_models/api_server.py

@@ -28,6 +28,7 @@ from pydantic import HttpUrl
 from pydantic import conlist
 from pydantic import field_serializer
 from pydantic import field_validator
+from pydantic import model_validator
 from pydantic_core.core_schema import ValidationInfo
 
 from nat.data_models.interactive import HumanPrompt
@@ -120,15 +121,7 @@ class Message(BaseModel):
     role: UserMessageContentRoleType
 
 
-class ChatRequest(BaseModel):
-    """
-    ChatRequest is a data model that represents a request to the NAT chat API.
-    Fully compatible with OpenAI Chat Completions API specification.
-    """
-
-    # Required fields
-    messages: typing.Annotated[list[Message], conlist(Message, min_length=1)]
-
+class ChatRequestOptionals(BaseModel):
     # Optional fields (OpenAI Chat Completions API compatible)
     model: str | None = Field(default=None, description="name of the model to use")
     frequency_penalty: float | None = Field(default=0.0,
@@ -153,6 +146,16 @@ class ChatRequest(BaseModel):
     parallel_tool_calls: bool | None = Field(default=True, description="Whether to enable parallel function calling")
     user: str | None = Field(default=None, description="Unique identifier representing end-user")
 
+
+class ChatRequest(ChatRequestOptionals):
+    """
+    ChatRequest is a data model that represents a request to the NAT chat API.
+    Fully compatible with OpenAI Chat Completions API specification.
+    """
+
+    # Required fields
+    messages: typing.Annotated[list[Message], conlist(Message, min_length=1)]
+
     model_config = ConfigDict(extra="allow",
                               json_schema_extra={
                                   "example": {
@@ -194,6 +197,42 @@ class ChatRequest(BaseModel):
                            top_p=top_p)
 
 
+class ChatRequestOrMessage(ChatRequestOptionals):
+    """
+    ChatRequestOrMessage is a data model that represents either a conversation or a string input.
+    This is useful for functions that can handle either type of input.
+
+    `messages` is compatible with the OpenAI Chat Completions API specification.
+
+    `input_string` is a string input that can be used for functions that do not require a conversation.
+    """
+
+    messages: typing.Annotated[list[Message] | None, conlist(Message, min_length=1)] = Field(
+        default=None, description="The conversation messages to process.")
+
+    input_string: str | None = Field(default=None, alias="input_message", description="The input message to process.")
+
+    @property
+    def is_string(self) -> bool:
+        return self.input_string is not None
+
+    @property
+    def is_conversation(self) -> bool:
+        return self.messages is not None
+
+    @model_validator(mode="after")
+    def validate_messages_or_input_string(self):
+        if self.messages is not None and self.input_string is not None:
+            raise ValueError("Either messages or input_message/input_string must be provided, not both")
+        if self.messages is None and self.input_string is None:
+            raise ValueError("Either messages or input_message/input_string must be provided")
+        if self.input_string is not None:
+            extra_fields = self.model_dump(exclude={"input_string"}, exclude_none=True, exclude_unset=True)
+            if len(extra_fields) > 0:
+                raise ValueError("no extra fields are permitted when input_message/input_string is provided")
+        return self
+
+
 class ChoiceMessage(BaseModel):
     content: str | None = None
     role: UserMessageContentRoleType | None = None
@@ -661,6 +700,36 @@ def _string_to_nat_chat_request(data: str) -> ChatRequest:
 GlobalTypeConverter.register_converter(_string_to_nat_chat_request)
 
 
+def _chat_request_or_message_to_chat_request(data: ChatRequestOrMessage) -> ChatRequest:
+    if data.input_string is not None:
+        return _string_to_nat_chat_request(data.input_string)
+    return ChatRequest(**data.model_dump(exclude={"input_string"}))
+
+
+GlobalTypeConverter.register_converter(_chat_request_or_message_to_chat_request)
+
+
+def _chat_request_to_chat_request_or_message(data: ChatRequest) -> ChatRequestOrMessage:
+    return ChatRequestOrMessage(**data.model_dump(by_alias=True))
+
+
+GlobalTypeConverter.register_converter(_chat_request_to_chat_request_or_message)
+
+
+def _chat_request_or_message_to_string(data: ChatRequestOrMessage) -> str:
+    return data.input_string or ""
+
+
+GlobalTypeConverter.register_converter(_chat_request_or_message_to_string)
+
+
+def _string_to_chat_request_or_message(data: str) -> ChatRequestOrMessage:
+    return ChatRequestOrMessage(input_message=data)
+
+
+GlobalTypeConverter.register_converter(_string_to_chat_request_or_message)
+
+
 # ======== ChatResponse Converters ========
 def _nat_chat_response_to_string(data: ChatResponse) -> str:
     if data.choices and data.choices[0].message:

nat/front_ends/mcp/mcp_front_end_config.py

@@ -43,3 +43,16 @@ class MCPFrontEndConfig(FrontEndBaseConfig, name="mcp"):
 
     server_auth: OAuth2ResourceServerConfig | None = Field(
         default=None, description=("OAuth 2.0 Resource Server configuration for token verification."))
+
+    # Memory profiling configuration
+    enable_memory_profiling: bool = Field(default=False,
+                                          description="Enable memory profiling and diagnostics (default: False)")
+    memory_profile_interval: int = Field(default=50,
+                                         description="Log memory stats every N requests (default: 50)",
+                                         ge=1)
+    memory_profile_top_n: int = Field(default=10,
+                                      description="Number of top memory allocations to log (default: 10)",
+                                      ge=1,
+                                      le=50)
+    memory_profile_log_level: str = Field(default="DEBUG",
+                                          description="Log level for memory profiling output (default: DEBUG)")

nat/front_ends/mcp/mcp_front_end_plugin_worker.py

@@ -29,6 +29,7 @@ from nat.builder.workflow import Workflow
 from nat.builder.workflow_builder import WorkflowBuilder
 from nat.data_models.config import Config
 from nat.front_ends.mcp.mcp_front_end_config import MCPFrontEndConfig
+from nat.front_ends.mcp.memory_profiler import MemoryProfiler
 
 logger = logging.getLogger(__name__)
 
@@ -45,6 +46,12 @@ class MCPFrontEndPluginWorkerBase(ABC):
         self.full_config = config
         self.front_end_config: MCPFrontEndConfig = config.general.front_end
 
+        # Initialize memory profiler if enabled
+        self.memory_profiler = MemoryProfiler(enabled=self.front_end_config.enable_memory_profiling,
+                                              log_interval=self.front_end_config.memory_profile_interval,
+                                              top_n=self.front_end_config.memory_profile_top_n,
+                                              log_level=self.front_end_config.memory_profile_log_level)
+
     def _setup_health_endpoint(self, mcp: FastMCP):
         """Set up the HTTP health endpoint that exercises MCP ping handler."""
 
@@ -115,6 +122,7 @@ class MCPFrontEndPluginWorkerBase(ABC):
         Exposes:
           - GET /debug/tools/list: List tools. Optional query param `name` (one or more, repeatable or comma separated)
             selects a subset and returns details for those tools.
+          - GET /debug/memory/stats: Get current memory profiling statistics (read-only)
         """
 
         @mcp.custom_route("/debug/tools/list", methods=["GET"])
@@ -206,6 +214,15 @@ class MCPFrontEndPluginWorkerBase(ABC):
             return JSONResponse(
                 _build_final_json(functions_to_include, _parse_detail_param(detail_raw, has_names=bool(names))))
 
+        # Memory profiling endpoint (read-only)
+        @mcp.custom_route("/debug/memory/stats", methods=["GET"])
+        async def get_memory_stats(_request: Request):
+            """Get current memory profiling statistics."""
+            from starlette.responses import JSONResponse
+
+            stats = self.memory_profiler.get_stats()
+            return JSONResponse(stats)
+
 
 class MCPFrontEndPluginWorker(MCPFrontEndPluginWorkerBase):
     """Default MCP front end plugin worker implementation."""
@@ -241,7 +258,7 @@ class MCPFrontEndPluginWorker(MCPFrontEndPluginWorkerBase):
 
         # Register each function with MCP, passing workflow context for observability
         for function_name, function in functions.items():
-            register_function_with_mcp(mcp, function_name, function, workflow)
+            register_function_with_mcp(mcp, function_name, function, workflow, self.memory_profiler)
 
         # Add a simple fallback function if no functions were found
         if not functions:

nat/front_ends/mcp/memory_profiler.py

@@ -0,0 +1,320 @@
+# 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.
+"""Memory profiling utilities for MCP frontend."""
+
+import gc
+import logging
+import tracemalloc
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+class MemoryProfiler:
+    """Memory profiler for tracking memory usage and potential leaks."""
+
+    def __init__(self, enabled: bool = False, log_interval: int = 50, top_n: int = 10, log_level: str = "DEBUG"):
+        """Initialize the memory profiler.
+
+        Args:
+            enabled: Whether memory profiling is enabled
+            log_interval: Log stats every N requests
+            top_n: Number of top allocations to log
+            log_level: Log level for memory profiling output (e.g., "DEBUG", "INFO")
+        """
+        self.enabled = enabled
+        # normalize interval to avoid modulo-by-zero
+        self.log_interval = max(1, int(log_interval))
+        self.top_n = top_n
+        self.log_level = getattr(logging, log_level.upper(), logging.DEBUG)
+        self.request_count = 0
+        self.baseline_snapshot = None
+
+        # Track whether this instance started tracemalloc (to avoid resetting external tracing)
+        self._we_started_tracemalloc = False
+
+        if self.enabled:
+            logger.info("Memory profiling ENABLED (interval=%d, top_n=%d, log_level=%s)",
+                        self.log_interval,
+                        top_n,
+                        log_level)
+            try:
+                if not tracemalloc.is_tracing():
+                    tracemalloc.start()
+                    self._we_started_tracemalloc = True
+                # Take baseline snapshot
+                gc.collect()
+                self.baseline_snapshot = tracemalloc.take_snapshot()
+            except RuntimeError as e:
+                logger.warning("tracemalloc unavailable or not tracing: %s", e)
+        else:
+            logger.info("Memory profiling DISABLED")
+
+    def _log(self, message: str, *args: Any) -> None:
+        """Log a message at the configured log level.
+
+        Args:
+            message: Log message format string
+            args: Arguments for the format string
+        """
+        logger.log(self.log_level, message, *args)
+
+    def on_request_complete(self) -> None:
+        """Called after each request completes."""
+        if not self.enabled:
+            return
+        self.request_count += 1
+        if self.request_count % self.log_interval == 0:
+            self.log_memory_stats()
+
+    def _ensure_tracing(self) -> bool:
+        """Ensure tracemalloc is running if we started it originally.
+
+        Returns:
+            True if tracemalloc is active, False otherwise
+        """
+        if tracemalloc.is_tracing():
+            return True
+
+        # Only restart if we started it originally (respect external control)
+        if not self._we_started_tracemalloc:
+            return False
+
+        # Attempt to restart
+        try:
+            logger.warning("tracemalloc was stopped externally; restarting (we started it originally)")
+            tracemalloc.start()
+
+            # Reset baseline since old tracking data is lost
+            gc.collect()
+            self.baseline_snapshot = tracemalloc.take_snapshot()
+            logger.info("Baseline snapshot reset after tracemalloc restart")
+
+            return True
+        except RuntimeError as e:
+            logger.error("Failed to restart tracemalloc: %s", e)
+            return False
+
+    def _safe_traced_memory(self) -> tuple[float, float] | None:
+        """Return (current, peak usage in MB) if tracemalloc is active, else None."""
+        if not self._ensure_tracing():
+            return None
+
+        try:
+            current, peak = tracemalloc.get_traced_memory()
+            megabyte = (1 << 20)
+            return (current / megabyte, peak / megabyte)
+        except RuntimeError:
+            return None
+
+    def _safe_snapshot(self) -> tracemalloc.Snapshot | None:
+        """Return a tracemalloc Snapshot if available, else None."""
+        if not self._ensure_tracing():
+            return None
+
+        try:
+            return tracemalloc.take_snapshot()
+        except RuntimeError:
+            return None
+
+    def log_memory_stats(self) -> dict[str, Any]:
+        """Log current memory statistics and return them."""
+        if not self.enabled:
+            return {}
+
+        # Force garbage collection first
+        gc.collect()
+
+        # Get current memory usage
+        mem = self._safe_traced_memory()
+        if mem is None:
+            logger.info("tracemalloc is not active; cannot collect memory stats.")
+            # still return structural fields
+            stats = {
+                "request_count": self.request_count,
+                "current_memory_mb": None,
+                "peak_memory_mb": None,
+                "active_intermediate_managers": self._safe_intermediate_step_manager_count(),
+                "outstanding_steps": self._safe_outstanding_step_count(),
+                "active_exporters": self._safe_exporter_count(),
+                "isolated_exporters": self._safe_isolated_exporter_count(),
+                "subject_instances": self._count_instances_of_type("Subject"),
+            }
+            return stats
+
+        current_mb, peak_mb = mem
+
+        # Take snapshot and compare to baseline
+        snapshot = self._safe_snapshot()
+
+        # Track BaseExporter instances (observability layer)
+        exporter_count = self._safe_exporter_count()
+        isolated_exporter_count = self._safe_isolated_exporter_count()
+
+        # Track Subject instances (event streams)
+        subject_count = self._count_instances_of_type("Subject")
+
+        stats = {
+            "request_count": self.request_count,
+            "current_memory_mb": round(current_mb, 2),
+            "peak_memory_mb": round(peak_mb, 2),
+            "active_intermediate_managers": self._safe_intermediate_step_manager_count(),
+            "outstanding_steps": self._safe_outstanding_step_count(),
+            "active_exporters": exporter_count,
+            "isolated_exporters": isolated_exporter_count,
+            "subject_instances": subject_count,
+        }
+
+        self._log("=" * 80)
+        self._log("MEMORY PROFILE AFTER %d REQUESTS:", self.request_count)
+        self._log("  Current Memory: %.2f MB", current_mb)
+        self._log("  Peak Memory: %.2f MB", peak_mb)
+        self._log("")
+        self._log("NAT COMPONENT INSTANCES:")
+        self._log("  IntermediateStepManagers: %d active (%d outstanding steps)",
+                  stats["active_intermediate_managers"],
+                  stats["outstanding_steps"])
+        self._log("  BaseExporters: %d active (%d isolated)", stats["active_exporters"], stats["isolated_exporters"])
+        self._log("  Subject (event streams): %d instances", stats["subject_instances"])
+
+        # Show top allocations
+        if snapshot is None:
+            self._log("tracemalloc snapshot unavailable.")
+        else:
+            if self.baseline_snapshot:
+                self._log("TOP %d MEMORY GROWTH SINCE BASELINE:", self.top_n)
+                top_stats = snapshot.compare_to(self.baseline_snapshot, 'lineno')
+            else:
+                self._log("TOP %d MEMORY ALLOCATIONS:", self.top_n)
+                top_stats = snapshot.statistics('lineno')
+
+            for i, stat in enumerate(top_stats[:self.top_n], 1):
+                self._log("  #%d: %s", i, stat)
+
+        self._log("=" * 80)
+
+        return stats
+
+    def _count_instances_of_type(self, type_name: str) -> int:
+        """Count instances of a specific type in memory."""
+        count = 0
+        for obj in gc.get_objects():
+            try:
+                if type(obj).__name__ == type_name:
+                    count += 1
+            except Exception:
+                pass
+        return count
+
+    def _safe_exporter_count(self) -> int:
+        try:
+            from nat.observability.exporter.base_exporter import BaseExporter
+            return BaseExporter.get_active_instance_count()
+        except Exception as e:
+            logger.debug("Could not get BaseExporter stats: %s", e)
+            return 0
+
+    def _safe_isolated_exporter_count(self) -> int:
+        try:
+            from nat.observability.exporter.base_exporter import BaseExporter
+            return BaseExporter.get_isolated_instance_count()
+        except Exception:
+            return 0
+
+    def _safe_intermediate_step_manager_count(self) -> int:
+        try:
+            from nat.builder.intermediate_step_manager import IntermediateStepManager
+            # len() is atomic in CPython, but catch RuntimeError just in case
+            try:
+                return IntermediateStepManager.get_active_instance_count()
+            except RuntimeError:
+                # Set was modified during len() - very rare
+                logger.debug("Set changed during count, returning 0")
+                return 0
+        except Exception as e:
+            logger.debug("Could not get IntermediateStepManager stats: %s", e)
+            return 0
+
+    def _safe_outstanding_step_count(self) -> int:
+        """Get total outstanding steps across all active IntermediateStepManager instances."""
+        try:
+            from nat.builder.intermediate_step_manager import IntermediateStepManager
+
+            # Make a snapshot to avoid "Set changed size during iteration" if GC runs
+            try:
+                instances_snapshot = list(IntermediateStepManager._active_instances)
+            except RuntimeError:
+                # Set changed during list() call - rare but possible
+                logger.debug("Set changed during snapshot, returning 0 for outstanding steps")
+                return 0
+
+            total_outstanding = 0
+            # Iterate through snapshot safely
+            for ref in instances_snapshot:
+                try:
+                    manager = ref()
+                    if manager is not None:
+                        total_outstanding += manager.get_outstanding_step_count()
+                except (ReferenceError, AttributeError):
+                    # Manager was GC'd or in invalid state - skip it
+                    continue
+            return total_outstanding
+        except Exception as e:
+            logger.debug("Could not get outstanding step count: %s", e)
+            return 0
+
+    def get_stats(self) -> dict[str, Any]:
+        """Get current memory statistics without logging."""
+        if not self.enabled:
+            return {"enabled": False}
+
+        mem = self._safe_traced_memory()
+        if mem is None:
+            return {
+                "enabled": True,
+                "request_count": self.request_count,
+                "current_memory_mb": None,
+                "peak_memory_mb": None,
+                "active_intermediate_managers": self._safe_intermediate_step_manager_count(),
+                "outstanding_steps": self._safe_outstanding_step_count(),
+                "active_exporters": self._safe_exporter_count(),
+                "isolated_exporters": self._safe_isolated_exporter_count(),
+                "subject_instances": self._count_instances_of_type("Subject"),
+            }
+
+        current_mb, peak_mb = mem
+        return {
+            "enabled": True,
+            "request_count": self.request_count,
+            "current_memory_mb": round(current_mb, 2),
+            "peak_memory_mb": round(peak_mb, 2),
+            "active_intermediate_managers": self._safe_intermediate_step_manager_count(),
+            "outstanding_steps": self._safe_outstanding_step_count(),
+            "active_exporters": self._safe_exporter_count(),
+            "isolated_exporters": self._safe_isolated_exporter_count(),
+            "subject_instances": self._count_instances_of_type("Subject"),
+        }
+
+    def reset_baseline(self) -> None:
+        """Reset the baseline snapshot to current state."""
+        if not self.enabled:
+            return
+        gc.collect()
+        snap = self._safe_snapshot()
+        if snap is None:
+            logger.info("Cannot reset baseline: tracemalloc is not active.")
+            return
+        self.baseline_snapshot = snap
+        logger.info("Memory profiling baseline reset at request %d", self.request_count)

nat/front_ends/mcp/tool_converter.py

@@ -28,6 +28,7 @@ from nat.builder.function_base import FunctionBase
 
 if TYPE_CHECKING:
     from nat.builder.workflow import Workflow
+    from nat.front_ends.mcp.memory_profiler import MemoryProfiler
 
 logger = logging.getLogger(__name__)
 
@@ -38,6 +39,7 @@ def create_function_wrapper(
     schema: type[BaseModel],
     is_workflow: bool = False,
     workflow: 'Workflow | None' = None,
+    memory_profiler: 'MemoryProfiler | None' = None,
 ):
     """Create a wrapper function that exposes the actual parameters of a NAT Function as an MCP tool.
 
@@ -47,6 +49,7 @@ def create_function_wrapper(
         schema (type[BaseModel]): The input schema of the function
         is_workflow (bool): Whether the function is a Workflow
         workflow (Workflow | None): The parent workflow for observability context
+        memory_profiler: Optional memory profiler to track requests
 
     Returns:
         A wrapper function suitable for registration with MCP
@@ -172,6 +175,10 @@ def create_function_wrapper(
                 if ctx:
                     await ctx.report_progress(100, 100)
 
+                # Track request completion for memory profiling
+                if memory_profiler:
+                    memory_profiler.on_request_complete()
+
                 # Handle different result types for proper formatting
                 if isinstance(result, str):
                     return result
@@ -181,6 +188,11 @@ def create_function_wrapper(
             except Exception as e:
                 if ctx:
                     ctx.error("Error calling function %s: %s", function_name, str(e))
+
+                # Track request completion even on error
+                if memory_profiler:
+                    memory_profiler.on_request_complete()
+
                 raise
 
         return wrapper_with_ctx
@@ -242,7 +254,8 @@ def get_function_description(function: FunctionBase) -> str:
 def register_function_with_mcp(mcp: FastMCP,
                                function_name: str,
                                function: FunctionBase,
-                               workflow: 'Workflow | None' = None) -> None:
+                               workflow: 'Workflow | None' = None,
+                               memory_profiler: 'MemoryProfiler | None' = None) -> None:
     """Register a NAT Function as an MCP tool.
 
     Args:
@@ -250,6 +263,7 @@ def register_function_with_mcp(mcp: FastMCP,
         function_name: The name to register the function under
         function: The NAT Function to register
         workflow: The parent workflow for observability context (if available)
+        memory_profiler: Optional memory profiler to track requests
     """
     logger.info("Registering function %s with MCP", function_name)
 
@@ -267,5 +281,10 @@ def register_function_with_mcp(mcp: FastMCP,
     function_description = get_function_description(function)
 
     # Create and register the wrapper function with MCP
-    wrapper_func = create_function_wrapper(function_name, function, input_schema, is_workflow, workflow)
+    wrapper_func = create_function_wrapper(function_name,
+                                           function,
+                                           input_schema,
+                                           is_workflow,
+                                           workflow,
+                                           memory_profiler)
     mcp.tool(name=function_name, description=function_description)(wrapper_func)

nat/runtime/runner.py

@@ -196,8 +196,7 @@ class Runner:
 
             return result
         except Exception as e:
-            err_msg = f": {e}" if str(e).strip() else "."
-            logger.error("Error running workflow%s", err_msg)
+            logger.error("Error running workflow: %s", e)
             event_stream = self._context_state.event_stream.get()
             if event_stream:
                 event_stream.on_complete()

nat/utils/type_converter.py

@@ -93,6 +93,14 @@ class TypeConverter:
         if to_type is None or decomposed.is_instance(data):
             return data
 
+        # 2) If data is a union type, try to convert to each type in the union
+        if decomposed.is_union:
+            for union_type in decomposed.args:
+                result = self._convert(data, union_type)
+                if result is not None:
+                    return result
+            return None
+
         root = decomposed.root
 
         # 2) Attempt direct in *this* converter

{nvidia_nat-1.4.0a20251010.dist-info → nvidia_nat-1.4.0a20251011.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: nvidia-nat
-Version: 1.4.0a20251010
+Version: 1.4.0a20251011
 Summary: NVIDIA NeMo Agent toolkit
 Author: NVIDIA Corporation
 Maintainer: NVIDIA Corporation
-License-Expression: Apache-2.0
+License: Apache-2.0
 Project-URL: documentation, https://docs.nvidia.com/nemo/agent-toolkit/latest/
 Project-URL: source, https://github.com/NVIDIA/NeMo-Agent-Toolkit
 Keywords: ai,rag,agents
@@ -14,8 +14,8 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: <3.14,>=3.11
 Description-Content-Type: text/markdown
-License-File: LICENSE.md
 License-File: LICENSE-3rd-party.txt
+License-File: LICENSE.md
 Requires-Dist: aioboto3>=11.0.0
 Requires-Dist: authlib~=1.5
 Requires-Dist: click~=8.1

{nvidia_nat-1.4.0a20251010.dist-info → nvidia_nat-1.4.0a20251011.dist-info}/RECORD

@@ -10,16 +10,16 @@ nat/agent/react_agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3h
 nat/agent/react_agent/agent.py,sha256=sWrg9WrglTKQQyG3EcjNm2JTEchCPEo9li-Po7TJKss,21294
 nat/agent/react_agent/output_parser.py,sha256=m7K6wRwtckBBpAHqOf3BZ9mqZLwrP13Kxz5fvNxbyZE,4219
 nat/agent/react_agent/prompt.py,sha256=N47JJrT6xwYQCv1jedHhlul2AE7EfKsSYfAbgJwWRew,1758
-nat/agent/react_agent/register.py,sha256=wAoPkly7dE8bb5x8XFf5-C1qJQausLKQwQcFCby_dwU,9307
+nat/agent/react_agent/register.py,sha256=qkPaK6AvXjolL-q_Z3waVobXDz24GMfuqGqCn-2un2Q,8991
 nat/agent/reasoning_agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nat/agent/reasoning_agent/reasoning_agent.py,sha256=k_0wEDqACQn1Rn1MAKxoXyqOKsthHCQ1gt990YYUqHU,9575
 nat/agent/rewoo_agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nat/agent/rewoo_agent/agent.py,sha256=XXgVXY9xwkyxnr093KXUtfgyNxAQbyGAecoGqN5mMLY,26199
 nat/agent/rewoo_agent/prompt.py,sha256=B0JeL1xDX4VKcShlkkviEcAsOKAwzSlX8NcAQdmUUPw,3645
-nat/agent/rewoo_agent/register.py,sha256=GfJRQgpFWl-LQ-pPaG7EUeBH5u7pDZZNVP5cSweZJdM,9599
+nat/agent/rewoo_agent/register.py,sha256=XArlOR37QOBtAvsdKJUjRok5qTmx39S2mJHSteOwU58,9283
 nat/agent/tool_calling_agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nat/agent/tool_calling_agent/agent.py,sha256=4SIp29I56oznPRQu7B3HCoX53Ri3_o3BRRYNJjeBkF8,11006
-nat/agent/tool_calling_agent/register.py,sha256=ijiRfgDVtt2p7_q1YbIQZmUVV8-jf3yT18HwtKyReUI,6822
+nat/agent/tool_calling_agent/register.py,sha256=OucceyELA2xZL3KdANWK9w12fnVP75eVbZgzOnmXHys,7057
 nat/authentication/__init__.py,sha256=Xs1JQ16L9btwreh4pdGKwskffAw1YFO48jKrU4ib_7c,685
 nat/authentication/interfaces.py,sha256=1J2CWEJ_n6CLA3_HD3XV28CSbyfxrPAHzr7Q4kKDFdc,3511
 nat/authentication/register.py,sha256=lFhswYUk9iZ53mq33fClR9UfjJPdjGIivGGNHQeWiYo,915
@@ -48,10 +48,10 @@ nat/builder/eval_builder.py,sha256=I-ScvupmorClYoVBIs_PhSsB7Xf9e2nGWe0rCZp3txo,6
 nat/builder/evaluator.py,sha256=xWHMND2vcAUkdFP7FU3jnVki1rUHeTa0-9saFh2hWKs,1162
 nat/builder/framework_enum.py,sha256=n7IaTQBxhFozIQqRMcX9kXntw28JhFzCj82jJ0C5tNU,901
 nat/builder/front_end.py,sha256=FCJ87NSshVVuTg8zZrq3YAr_u0RaYVZVcibnqlRFy-M,2173
-nat/builder/function.py,sha256=RrfKSCt9WunPhwn5fk8X7wuvb9A21iO8T-IySHUi3KM,27763
+nat/builder/function.py,sha256=eZZWLwhphgQTnPvbga8sGleX7HCP46usZPIegE7zFzs,27725
 nat/builder/function_base.py,sha256=0Eg8RtjWhEU3Yme0CVxcRutobA0Qo8-YHZLI6L2qAgM,13116
 nat/builder/function_info.py,sha256=7Rmrn-gOFrT2TIJklJwA_O-ycx_oimwZ0-qMYpbuZrU,25161
-nat/builder/intermediate_step_manager.py,sha256=iOuMLWTaES0J0XzaLxhTUqFvuoCAChJu3V69T43K0k0,7599
+nat/builder/intermediate_step_manager.py,sha256=E4syoUNn0BGHnNqqmTYn2oMXKSHkf8GCmTpVeJX3zTY,8764
 nat/builder/llm.py,sha256=DW-2q64A06VChsXNEL5PfBjH3DcsnTKVoCEWDuP7MF4,951
 nat/builder/retriever.py,sha256=ZyEqc7pFK31t_yr6Jaxa34c-tRas2edKqJZCNiVh9-0,970
 nat/builder/user_interaction_manager.py,sha256=-Z2qbQes7a2cuXgT7KEbWeuok0HcCnRdw9WB8Ghyl9k,3081
@@ -112,7 +112,7 @@ nat/control_flow/router_agent/prompt.py,sha256=fIAiNsAs1zXRAatButR76zSpHJNxSkXXK
 nat/control_flow/router_agent/register.py,sha256=4RGmS9sy-QtIMmvh8mfMcR1VqxFPLpG4RckWCIExh40,4144
 nat/data_models/__init__.py,sha256=Xs1JQ16L9btwreh4pdGKwskffAw1YFO48jKrU4ib_7c,685
 nat/data_models/agent.py,sha256=IwDyb9Zc3R4Zd5rFeqt7q0EQswczAl5focxV9KozIzs,1625
-nat/data_models/api_server.py,sha256=V8y1v9-5p4kmaQmmDU2N6m_V_CFJeozDzJEoIHOSV8w,26177
+nat/data_models/api_server.py,sha256=NWT1ChN2qaakD2DgyYCy_7MhfzvEBQX15qnUXnpCQmk,28883
 nat/data_models/authentication.py,sha256=XPu9W8nh4XRSuxPv3HxO-FMQ_JtTEoK6Y02JwnzDwTg,8457
 nat/data_models/common.py,sha256=nXXfGrjpxebzBUa55mLdmzePLt7VFHvTAc6Znj3yEv0,5875
 nat/data_models/component.py,sha256=b_hXOA8Gm5UNvlFkAhsR6kEvf33ST50MKtr5kWf75Ao,1894
@@ -259,11 +259,12 @@ nat/front_ends/fastapi/html_snippets/__init__.py,sha256=GUJrgGtpvyMUCjUBvR3faAdv
 nat/front_ends/fastapi/html_snippets/auth_code_grant_success.py,sha256=BNpWwzmA58UM0GK4kZXG4PHJy_5K9ihaVHu8SgCs5JA,1131
 nat/front_ends/mcp/__init__.py,sha256=Xs1JQ16L9btwreh4pdGKwskffAw1YFO48jKrU4ib_7c,685
 nat/front_ends/mcp/introspection_token_verifier.py,sha256=s7Q4Q6rWZJ0ZVujSxxpvVI6Bnhkg1LJQ3RLkvhzFIGE,2836
-nat/front_ends/mcp/mcp_front_end_config.py,sha256=fFbg800FDJfwv-nXc0jEPaNVtW4ApESmVRexr-werks,2313
+nat/front_ends/mcp/mcp_front_end_config.py,sha256=aDgNAyzl_09GfMCWKRGPV8_-16PAov5N40UMMD4yg8c,3143
 nat/front_ends/mcp/mcp_front_end_plugin.py,sha256=NiIIgApk1X2yAEwtG9tHaY6SexQMbZrd6Drs7uIJix8,5055
-nat/front_ends/mcp/mcp_front_end_plugin_worker.py,sha256=jMclC0qEd910oTGCqd1kQ8WjP3WPdQKTl854-2bU_KI,10200
+nat/front_ends/mcp/mcp_front_end_plugin_worker.py,sha256=NUYu2FFrHat_U4VBAm3c9YMpWSyVr2pKUYyseSFw2pM,11208
+nat/front_ends/mcp/memory_profiler.py,sha256=OpcpLBAGCdQwYSFZbtAqdfncrnGYVjDcMpWydB71hjY,12811
 nat/front_ends/mcp/register.py,sha256=3aJtgG5VaiqujoeU1-Eq7Hl5pWslIlIwGFU2ASLTXgM,1173
-nat/front_ends/mcp/tool_converter.py,sha256=jyH6tFKUDXSfRBKkv8WjvJsQt05zk3FJBTCwnIuUh5M,11547
+nat/front_ends/mcp/tool_converter.py,sha256=14NweQN3cPFBw7ZNiGyUHO4VhMGHrtfLGgvu4_H38oU,12426
 nat/front_ends/simple_base/__init__.py,sha256=Xs1JQ16L9btwreh4pdGKwskffAw1YFO48jKrU4ib_7c,685
 nat/front_ends/simple_base/simple_front_end_plugin_base.py,sha256=py_yA9XAw-yHfK5cQJLM8ElnubEEM2ac8M0bvz-ScWs,1801
 nat/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -406,7 +407,7 @@ nat/retriever/nemo_retriever/register.py,sha256=3XdrvEJzX2Zc8wpdm__4YYlEWBW-FK3t
 nat/retriever/nemo_retriever/retriever.py,sha256=gi3_qJFqE-iqRh3of_cmJg-SwzaQ3z24zA9LwY_MSLY,6930
 nat/runtime/__init__.py,sha256=Xs1JQ16L9btwreh4pdGKwskffAw1YFO48jKrU4ib_7c,685
 nat/runtime/loader.py,sha256=obUdAgZVYCPGC0R8u3wcoKFJzzSPQgJvrbU4OWygtog,7953
-nat/runtime/runner.py,sha256=sUF-zJMgqcFq4xRx8y5bxct2EzgiKbmFkvWkYxlDsQg,11798
+nat/runtime/runner.py,sha256=qa_AqtmB8TUHX6nVJ0TLEYCKUsm2L99kq5O72AuL3yc,11736
 nat/runtime/session.py,sha256=E8RTbnAhPbY5KCoSfiHzOJksmBh7xWjsoX0BC7Rn1ck,9101
 nat/runtime/user_metadata.py,sha256=ce37NRYJWnMOWk6A7VAQ1GQztjMmkhMOq-uYf2gNCwo,3692
 nat/settings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -448,7 +449,7 @@ nat/utils/metadata_utils.py,sha256=BSsiB6jIWd8oEuEynJi55qCG762UuTYFaiUH0OT9HdY,2
 nat/utils/optional_imports.py,sha256=jQSVBc2fBSRw-2d6r8cEwvh5-di2EUUPakuuo9QbbwA,4039
 nat/utils/producer_consumer_queue.py,sha256=AcSYkAMBxLx06A5Xdy960PP3AJ7YaSPGJ7rbN_hJsjI,6599
 nat/utils/string_utils.py,sha256=71HuIzGx7rF8ocTmeoUBpnCi1Qf1yynYlNLLIKP4BVs,1415
-nat/utils/type_converter.py,sha256=-2PwMsEm7tlmrniZzO7x2DnRxhOEeJGVAIJc3c5n2g4,10655
+nat/utils/type_converter.py,sha256=vDZzrZ9ycWgZJdkWB1sHB2ivZX-E8fPfkrB-vAAxroI,10968
 nat/utils/type_utils.py,sha256=SMo5hM4dKf2G3U_0J0wvdFX6-lzMVSh8vd-W34Oixow,14836
 nat/utils/url_utils.py,sha256=UzDP_xaS6brWTu7vAws0B4jZyrITIK9Si3U6pZBZqDE,1028
 nat/utils/data_models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -470,10 +471,10 @@ nat/utils/reactive/base/observer_base.py,sha256=6BiQfx26EMumotJ3KoVcdmFBYR_fnAss
 nat/utils/reactive/base/subject_base.py,sha256=UQOxlkZTIeeyYmG5qLtDpNf_63Y7p-doEeUA08_R8ME,2521
 nat/utils/settings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nat/utils/settings/global_settings.py,sha256=9JaO6pxKT_Pjw6rxJRsRlFCXdVKCl_xUKU2QHZQWWNM,7294
-nvidia_nat-1.4.0a20251010.dist-info/licenses/LICENSE-3rd-party.txt,sha256=fOk5jMmCX9YoKWyYzTtfgl-SUy477audFC5hNY4oP7Q,284609
-nvidia_nat-1.4.0a20251010.dist-info/licenses/LICENSE.md,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-nvidia_nat-1.4.0a20251010.dist-info/METADATA,sha256=00VTeVFR2xV-WeSbD9_vuaSgV-cmgEgGTxnDpualLPM,10239
-nvidia_nat-1.4.0a20251010.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nvidia_nat-1.4.0a20251010.dist-info/entry_points.txt,sha256=4jCqjyETMpyoWbCBf4GalZU8I_wbstpzwQNezdAVbbo,698
-nvidia_nat-1.4.0a20251010.dist-info/top_level.txt,sha256=lgJWLkigiVZuZ_O1nxVnD_ziYBwgpE2OStdaCduMEGc,8
-nvidia_nat-1.4.0a20251010.dist-info/RECORD,,
+nvidia_nat-1.4.0a20251011.dist-info/licenses/LICENSE-3rd-party.txt,sha256=fOk5jMmCX9YoKWyYzTtfgl-SUy477audFC5hNY4oP7Q,284609
+nvidia_nat-1.4.0a20251011.dist-info/licenses/LICENSE.md,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+nvidia_nat-1.4.0a20251011.dist-info/METADATA,sha256=kBMZinQbnPKYYzxF1s7BvCytUn0HncnbGG6yKrtCIqo,10228
+nvidia_nat-1.4.0a20251011.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nvidia_nat-1.4.0a20251011.dist-info/entry_points.txt,sha256=4jCqjyETMpyoWbCBf4GalZU8I_wbstpzwQNezdAVbbo,698
+nvidia_nat-1.4.0a20251011.dist-info/top_level.txt,sha256=lgJWLkigiVZuZ_O1nxVnD_ziYBwgpE2OStdaCduMEGc,8
+nvidia_nat-1.4.0a20251011.dist-info/RECORD,,