nvidia-nat 1.3.0a20250928__py3-none-any.whl → 1.3.0a20250929__py3-none-any.whl

nat/agent/rewoo_agent/agent.py

@@ -13,9 +13,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import asyncio
 import json
 import logging
+import re
 from json import JSONDecodeError
+from typing import Dict
+from typing import List
+from typing import Tuple
 
 from langchain_core.callbacks.base import AsyncCallbackHandler
 from langchain_core.language_models import BaseChatModel
@@ -50,15 +55,21 @@ class ReWOOGraphState(BaseModel):
         default_factory=lambda: AIMessage(content=""))  # the plan generated by the planner to solve the task
     steps: AIMessage = Field(
         default_factory=lambda: AIMessage(content=""))  # the steps to solve the task, parsed from the plan
+    # New fields for parallel execution support
+    evidence_map: Dict[str, Dict] = Field(default_factory=dict)  # mapping from placeholders to step info
+    execution_levels: List[List[str]] = Field(default_factory=list)  # levels for parallel execution
+    current_level: int = Field(default=0)  # current execution level
     intermediate_results: dict[str, ToolMessage] = Field(default_factory=dict)  # the intermediate results of each step
     result: AIMessage = Field(
         default_factory=lambda: AIMessage(content=""))  # the final result of the task, generated by the solver
 
 
 class ReWOOAgentGraph(BaseAgent):
-    """Configurable LangGraph ReWOO Agent. A ReWOO Agent performs reasoning by interacting with other objects or tools
-    and utilizes their outputs to make decisions. Supports retrying on output parsing errors. Argument
-    "detailed_logs" toggles logging of inputs, outputs, and intermediate steps."""
+    """Configurable ReWOO Agent.
+
+    Args:
+        detailed_logs: Toggles logging of inputs, outputs, and intermediate steps.
+    """
 
     def __init__(self,
                  llm: BaseChatModel,
@@ -109,16 +120,27 @@ class ReWOOAgentGraph(BaseAgent):
             raise
 
     @staticmethod
-    def _get_current_step(state: ReWOOGraphState) -> int:
-        steps = state.steps.content
-        if len(steps) == 0:
-            raise RuntimeError('No steps received in ReWOOGraphState')
+    def _get_current_level_status(state: ReWOOGraphState) -> tuple[int, bool]:
+        """
+        Get the current execution level and whether it's complete.
+        :param state: The ReWOO graph state.
+        :return: Tuple of (current_level, is_complete). Level -1 means all execution is complete.
+        :rtype: tuple[int, bool]
+        """
+        if not state.execution_levels:
+            return -1, True
+
+        current_level = state.current_level
 
-        if len(state.intermediate_results) == len(steps):
-            # all steps are done
-            return -1
+        # Check if we've completed all levels
+        if current_level >= len(state.execution_levels):
+            return -1, True
 
-        return len(state.intermediate_results)
+        # Check if current level is complete
+        current_level_placeholders = state.execution_levels[current_level]
+        level_complete = all(placeholder in state.intermediate_results for placeholder in current_level_placeholders)
+
+        return current_level, level_complete
 
     @staticmethod
     def _parse_planner_output(planner_output: str) -> AIMessage:
@@ -130,6 +152,75 @@ class ReWOOAgentGraph(BaseAgent):
 
         return AIMessage(content=steps)
 
+    @staticmethod
+    def _parse_planner_dependencies(steps: List[Dict]) -> Tuple[Dict[str, Dict], List[List[str]]]:
+        """
+        Parse planner steps to identify dependencies and create execution levels for parallel processing.
+        This creates a dependency map and identifies which evidence placeholders can be executed in parallel.
+
+        :param steps: List of plan steps from the planner.
+        :type steps: List[Dict]
+        :return: A mapping from evidence placeholders to step info and execution levels for parallel processing.
+        :rtype: Tuple[Dict[str, Dict], List[List[str]]]
+        """
+        evidences = {}
+        dependence = {}
+
+        # First pass: collect all evidence placeholders and their info
+        for step in steps:
+            if "evidence" not in step:
+                continue
+
+            evidence_info = step["evidence"]
+            placeholder = evidence_info.get("placeholder", "")
+
+            if placeholder:
+                # Store the complete step info for this evidence
+                evidences[placeholder] = {"plan": step.get("plan", ""), "evidence": evidence_info}
+
+        # Second pass: find dependencies now that we have all placeholders
+        for step in steps:
+            if "evidence" not in step:
+                continue
+
+            evidence_info = step["evidence"]
+            placeholder = evidence_info.get("placeholder", "")
+            tool_input = evidence_info.get("tool_input", "")
+
+            if placeholder:
+                # Find dependencies by looking for other placeholders in tool_input
+                dependence[placeholder] = []
+
+                # Convert tool_input to string to search for placeholders
+                tool_input_str = str(tool_input)
+                for var in re.findall(r"#E\d+", tool_input_str):
+                    if var in evidences and var != placeholder:
+                        dependence[placeholder].append(var)
+
+        # Create execution levels using topological sort
+        levels = []
+        remaining = dict(dependence)
+
+        while remaining:
+            # Find items with no dependencies (can be executed in parallel)
+            ready = [placeholder for placeholder, deps in remaining.items() if not deps]
+
+            if not ready:
+                raise ValueError("Circular dependency detected in planner output")
+
+            levels.append(ready)
+
+            # Remove completed items from remaining
+            for placeholder in ready:
+                remaining.pop(placeholder)
+
+            # Remove completed items from other dependencies
+            # for placeholder in remaining.items():
+            #     remaining[placeholder] = [dep for dep in remaining[placeholder] if dep not in ready]
+            for ph, deps in list(remaining.items()):
+                remaining[ph] = [dep for dep in deps if dep not in ready]
+        return evidences, levels
+
     @staticmethod
     def _replace_placeholder(placeholder: str, tool_input: str | dict, tool_output: str | dict) -> str | dict:
 
@@ -201,119 +292,204 @@ class ReWOOAgentGraph(BaseAgent):
 
             steps = self._parse_planner_output(str(plan.content))
 
+            # Parse dependencies and create execution levels for parallel processing
+            evidence_map, execution_levels = self._parse_planner_dependencies(steps.content)
+
             if self.detailed_logs:
                 agent_response_log_message = AGENT_CALL_LOG_MESSAGE % (task, str(plan.content))
                 logger.info("ReWOO agent planner output: %s", agent_response_log_message)
+                logger.info("ReWOO agent execution levels: %s", execution_levels)
 
-            return {"plan": plan, "steps": steps}
+            return {
+                "plan": plan,
+                "steps": steps,
+                "evidence_map": evidence_map,
+                "execution_levels": execution_levels,
+                "current_level": 0
+            }
 
         except Exception as ex:
             logger.error("%s Failed to call planner_node: %s", AGENT_LOG_PREFIX, ex)
             raise
 
     async def executor_node(self, state: ReWOOGraphState):
+        """
+        Execute tools in parallel for the current dependency level.
+
+        This replaces the sequential execution with parallel execution of tools
+        that have no dependencies between them.
+        """
         try:
             logger.debug("%s Starting the ReWOO Executor Node", AGENT_LOG_PREFIX)
 
-            current_step = self._get_current_step(state)
-            # The executor node should not be invoked after all steps are finished
-            if current_step < 0:
-                logger.error("%s ReWOO Executor is invoked with an invalid step number: %s",
-                             AGENT_LOG_PREFIX,
-                             current_step)
-                raise RuntimeError(f"ReWOO Executor is invoked with an invalid step number: {current_step}")
-
-            steps_content = state.steps.content
-            if isinstance(steps_content, list) and current_step < len(steps_content):
-                step = steps_content[current_step]
-                if isinstance(step, dict) and "evidence" in step:
-                    step_info = step["evidence"]
-                    placeholder = step_info.get("placeholder", "")
-                    tool = step_info.get("tool", "")
-                    tool_input = step_info.get("tool_input", "")
+            current_level, level_complete = self._get_current_level_status(state)
+
+            # Should not be invoked if all levels are complete
+            if current_level < 0:
+                logger.error("%s ReWOO Executor invoked after all levels complete", AGENT_LOG_PREFIX)
+                raise RuntimeError("ReWOO Executor invoked after all levels complete")
+
+            # If current level is already complete, move to next level
+            if level_complete:
+                new_level = current_level + 1
+                logger.debug("%s Level %s complete, moving to level %s", AGENT_LOG_PREFIX, current_level, new_level)
+                return {"current_level": new_level}
+
+            # Get placeholders for current level
+            current_level_placeholders = state.execution_levels[current_level]
+
+            # Filter to only placeholders not yet completed
+            pending_placeholders = [p for p in current_level_placeholders if p not in state.intermediate_results]
+
+            if not pending_placeholders:
+                # All placeholders in this level are done, move to next level
+                new_level = current_level + 1
+                return {"current_level": new_level}
+
+            logger.debug("%s Executing level %s with %s tools in parallel: %s",
+                         AGENT_LOG_PREFIX,
+                         current_level,
+                         len(pending_placeholders),
+                         pending_placeholders)
+
+            # Execute all tools in current level in parallel
+            tasks = []
+            for placeholder in pending_placeholders:
+                step_info = state.evidence_map[placeholder]
+                task = self._execute_single_tool(placeholder, step_info, state.intermediate_results)
+                tasks.append(task)
+
+            # Wait for all tasks in current level to complete
+            results = await asyncio.gather(*tasks, return_exceptions=True)
+
+            # Process results and update intermediate_results
+            updated_intermediate_results = dict(state.intermediate_results)
+
+            for i, result in enumerate(results):
+                placeholder = pending_placeholders[i]
+
+                if isinstance(result, Exception):
+                    logger.error("%s Tool execution failed for %s: %s", AGENT_LOG_PREFIX, placeholder, result)
+                    # Create error tool message
+                    error_message = f"Tool execution failed: {str(result)}"
+                    updated_intermediate_results[placeholder] = ToolMessage(content=error_message,
+                                                                            tool_call_id=placeholder)
+                    if self.raise_tool_call_error:
+                        raise result
                 else:
-                    logger.error("%s Invalid step format at index %s", AGENT_LOG_PREFIX, current_step)
-                    return {"intermediate_results": state.intermediate_results}
-            else:
-                logger.error("%s Invalid steps content or index %s", AGENT_LOG_PREFIX, current_step)
-                return {"intermediate_results": state.intermediate_results}
-
-            intermediate_results = state.intermediate_results
-
-            # Replace the placeholder in the tool input with the previous tool output
-            for _placeholder, _tool_output in intermediate_results.items():
-                _tool_output = _tool_output.content
-                # If the content is a list, get the first element which should be a dict
-                if isinstance(_tool_output, list):
-                    _tool_output = _tool_output[0]
-                    assert isinstance(_tool_output, dict)
-
-                tool_input = self._replace_placeholder(_placeholder, tool_input, _tool_output)
-
-            requested_tool = self._get_tool(tool)
-            if not requested_tool:
-                configured_tool_names = list(self.tools_dict.keys())
-                logger.warning(
-                    "%s ReWOO Agent wants to call tool %s. In the ReWOO Agent's configuration within the config file,"
-                    "there is no tool with that name: %s",
-                    AGENT_LOG_PREFIX,
-                    tool,
-                    configured_tool_names)
-
-                intermediate_results[placeholder] = ToolMessage(content=TOOL_NOT_FOUND_ERROR_MESSAGE.format(
-                    tool_name=tool, tools=configured_tool_names),
-                                                                tool_call_id=tool)
-                return {"intermediate_results": intermediate_results}
-
-            if self.detailed_logs:
-                logger.debug("%s Calling tool %s with input: %s", AGENT_LOG_PREFIX, requested_tool.name, tool_input)
-
-            # Run the tool. Try to use structured input, if possible
-            tool_input_parsed = self._parse_tool_input(tool_input)
-            tool_response = await self._call_tool(requested_tool,
-                                                  tool_input_parsed,
-                                                  RunnableConfig(callbacks=self.callbacks),
-                                                  max_retries=self.tool_call_max_retries)
+                    updated_intermediate_results[placeholder] = result
+                    # Check if the ToolMessage has error status and raise_tool_call_error is True
+                    if (isinstance(result, ToolMessage) and hasattr(result, 'status') and result.status == "error"
+                            and self.raise_tool_call_error):
+                        logger.error("%s Tool call failed for %s: %s", AGENT_LOG_PREFIX, placeholder, result.content)
+                        raise RuntimeError(f"Tool call failed: {result.content}")
 
             if self.detailed_logs:
-                self._log_tool_response(requested_tool.name, tool_input_parsed, str(tool_response))
+                logger.info("%s Completed level %s with %s tools",
+                            AGENT_LOG_PREFIX,
+                            current_level,
+                            len(pending_placeholders))
 
-            if self.raise_tool_call_error and tool_response.status == "error":
-                raise RuntimeError(f"Tool call failed: {tool_response.content}")
-
-            intermediate_results[placeholder] = tool_response
-            return {"intermediate_results": intermediate_results}
+            return {"intermediate_results": updated_intermediate_results}
 
         except Exception as ex:
             logger.error("%s Failed to call executor_node: %s", AGENT_LOG_PREFIX, ex)
             raise
 
+    async def _execute_single_tool(self,
+                                   placeholder: str,
+                                   step_info: Dict,
+                                   intermediate_results: Dict[str, ToolMessage]) -> ToolMessage:
+        """
+        Execute a single tool with proper placeholder replacement.
+
+        :param placeholder: The evidence placeholder (e.g., "#E1").
+        :param step_info: Step information containing tool and tool_input.
+        :param intermediate_results: Current intermediate results for placeholder replacement.
+        :return: ToolMessage with the tool execution result.
+        """
+        evidence_info = step_info["evidence"]
+        tool_name = evidence_info.get("tool", "")
+        tool_input = evidence_info.get("tool_input", "")
+
+        # Replace placeholders in tool input with previous results
+        for _placeholder, _tool_output in intermediate_results.items():
+            _tool_output_content = _tool_output.content
+            # If the content is a list, get the first element which should be a dict
+            if isinstance(_tool_output_content, list):
+                _tool_output_content = _tool_output_content[0]
+                assert isinstance(_tool_output_content, dict)
+
+            tool_input = self._replace_placeholder(_placeholder, tool_input, _tool_output_content)
+
+        # Get the requested tool
+        requested_tool = self._get_tool(tool_name)
+        if not requested_tool:
+            configured_tool_names = list(self.tools_dict.keys())
+            logger.warning(
+                "%s ReWOO Agent wants to call tool %s. In the ReWOO Agent's configuration within the config file,"
+                "there is no tool with that name: %s",
+                AGENT_LOG_PREFIX,
+                tool_name,
+                configured_tool_names)
+
+            return ToolMessage(content=TOOL_NOT_FOUND_ERROR_MESSAGE.format(tool_name=tool_name,
+                                                                           tools=configured_tool_names),
+                               tool_call_id=placeholder)
+
+        if self.detailed_logs:
+            logger.debug("%s Calling tool %s with input: %s", AGENT_LOG_PREFIX, requested_tool.name, tool_input)
+
+        # Parse and execute the tool
+        tool_input_parsed = self._parse_tool_input(tool_input)
+        tool_response = await self._call_tool(requested_tool,
+                                              tool_input_parsed,
+                                              RunnableConfig(callbacks=self.callbacks),
+                                              max_retries=self.tool_call_max_retries)
+
+        if self.detailed_logs:
+            self._log_tool_response(requested_tool.name, tool_input_parsed, str(tool_response))
+
+        return tool_response
+
     async def solver_node(self, state: ReWOOGraphState):
         try:
             logger.debug("%s Starting the ReWOO Solver Node", AGENT_LOG_PREFIX)
 
             plan = ""
-            # Add the tool outputs of each step to the plan
-            for step in state.steps.content:
-                step_info = step["evidence"]
-                placeholder = step_info.get("placeholder", "")
-                tool_input = step_info.get("tool_input", "")
-
-                intermediate_results = state.intermediate_results
-                for _placeholder, _tool_output in intermediate_results.items():
-                    _tool_output = _tool_output.content
+            # Add the tool outputs of each step to the plan using evidence_map
+            for placeholder, step_info in state.evidence_map.items():
+                evidence_info = step_info["evidence"]
+                original_tool_input = evidence_info.get("tool_input", "")
+                tool_name = evidence_info.get("tool", "")
+
+                # Replace placeholders in tool input with actual results
+                final_tool_input = original_tool_input
+                for _placeholder, _tool_output in state.intermediate_results.items():
+                    _tool_output_content = _tool_output.content
                     # If the content is a list, get the first element which should be a dict
-                    if isinstance(_tool_output, list):
-                        _tool_output = _tool_output[0]
-                        assert isinstance(_tool_output, dict)
-
-                    tool_input = self._replace_placeholder(_placeholder, tool_input, _tool_output)
-
-                    placeholder = placeholder.replace(_placeholder, str(_tool_output))
-
-                _plan = step.get("plan")
-                tool = step_info.get("tool")
-                plan += f"Plan: {_plan}\n{placeholder} = {tool}[{tool_input}]"
+                    if isinstance(_tool_output_content, list):
+                        _tool_output_content = _tool_output_content[0]
+                        assert isinstance(_tool_output_content, dict)
+
+                    final_tool_input = self._replace_placeholder(_placeholder, final_tool_input, _tool_output_content)
+
+                # Get the final result for this placeholder
+                final_result = ""
+                if placeholder in state.intermediate_results:
+                    result_content = state.intermediate_results[placeholder].content
+                    if isinstance(result_content, list):
+                        result_content = result_content[0]
+                        if isinstance(result_content, dict):
+                            final_result = str(result_content)
+                        else:
+                            final_result = str(result_content)
+                    else:
+                        final_result = str(result_content)
+
+                step_plan = step_info.get("plan", "")
+                plan += f"Plan: {step_plan}\n{placeholder} = \
+                    {tool_name}[{final_tool_input}]\nResult: {final_result}\n\n"
 
             task = str(state.task.content)
             solver_prompt = self.solver_prompt.partial(plan=plan)
@@ -336,12 +512,24 @@ class ReWOOAgentGraph(BaseAgent):
         try:
             logger.debug("%s Starting the ReWOO Conditional Edge", AGENT_LOG_PREFIX)
 
-            current_step = self._get_current_step(state)
-            if current_step == -1:
-                logger.debug("%s The ReWOO Executor has finished its task", AGENT_LOG_PREFIX)
+            current_level, level_complete = self._get_current_level_status(state)
+
+            # If all levels are complete, move to solver
+            if current_level == -1:
+                logger.debug("%s All execution levels complete, moving to solver", AGENT_LOG_PREFIX)
                 return AgentDecision.END
 
-            logger.debug("%s The ReWOO Executor is still working on the task", AGENT_LOG_PREFIX)
+            # If current level is complete, check if there are more levels
+            if level_complete:
+                next_level = current_level + 1
+                if next_level >= len(state.execution_levels):
+                    logger.debug("%s All execution levels complete, moving to solver", AGENT_LOG_PREFIX)
+                    return AgentDecision.END
+
+            logger.debug("%s Continuing with executor (level %s, complete: %s)",
+                         AGENT_LOG_PREFIX,
+                         current_level,
+                         level_complete)
             return AgentDecision.TOOL
 
         except Exception as ex:

nat/agent/rewoo_agent/prompt.py

@@ -18,33 +18,29 @@ For the following task, make plans that can solve the problem step by step. For
 which external tool together with tool input to retrieve evidence. You can store the evidence into a \
 placeholder #E that can be called by later tools. (Plan, #E1, Plan, #E2, Plan, ...)
 
-You may ask the human to the following tools:
+The following tools and respective requirements are available to you:
 
 {tools}
 
-The tools should be one of the following: [{tool_names}]
+The tool calls you make should be one of the following: [{tool_names}]
 
 You are not required to use all the tools listed. Choose only the ones that best fit the needs of each plan step.
 
-Your output must be a JSON array where each element represents one planning step. Each step must be an object with
-
+Your output must be a JSON array where each element represents one planning step. Each step must be an object with \
 exactly two keys:
 
 1. "plan": A string that describes in detail the action or reasoning for that step.
 
-2. "evidence": An object representing the external tool call associated with that plan step. This object must have the
+2. "evidence": An object representing the external tool call associated with that plan step. This object must have the \
 following keys:
 
-   -"placeholder": A string that identifies the evidence placeholder (e.g., "#E1", "#E2", etc.). The numbering should
-                   be sequential based on the order of steps.
+   -"placeholder": A string that identifies the evidence placeholder ("#E1", "#E2", ...). The numbering should \
+be sequential based on the order of steps.
 
    -"tool": A string specifying the name of the external tool used.
 
-   -"tool_input": The input to the tool. This can be a string, array, or object, depending on the requirements of the
-                  tool.
-
-Do not include any additional keys or characters in your output, and do not wrap your response with markdown formatting.
-Your output must be strictly valid JSON.
+   -"tool_input": The input to the tool. This can be a string, array, or object, depending on the requirements of the \
+tool. Be careful about type assumptions because the output of former tools might contain noise.
 
 Important instructions:
 
@@ -58,27 +54,28 @@ Here is an example of how a valid JSON output should look:
 
 [
   \'{{
-    "plan": "Calculate the result of 2023 minus 25.",
+    "plan": "Find Alex's schedule on Sep 25, 2025",
     "evidence": \'{{
       "placeholder": "#E1",
-      "tool": "calculator_subtract",
-      "tool_input": [2023, 25]
+      "tool": "search_calendar",
+      "tool_input": ("Alex", "09/25/2025")
     }}\'
   }}\',
   \'{{
-    "plan": "Retrieve the year represented by the result stored in #E1.",
+    "plan": "Find Bill's schedule on sep 25, 2025",
     "evidence": \'{{
       "placeholder": "#E2",
-      "tool": "haystack_chitchat_agent",
-      "tool_input": "Response with the result number contained in #E1"
+      "tool": "search_calendar",
+      "tool_input": ("Bill", "09/25/2025")
     }}\'
   }}\',
   \'{{
-    "plan": "Search for the CEO of Golden State Warriors in the year stored in #E2.",
+    "plan": "Suggest a time for 1-hour meeting given Alex's and Bill's schedule.",
     "evidence": \'{{
       "placeholder": "#E3",
-      "tool": "internet_search",
-      "tool_input": "Who was the CEO of Golden State Warriors in the year #E2?"
+      "tool": "llm_chat",
+      "tool_input": "Find a common 1-hour time slot for Alex and Bill given their schedules. \
+Alex's schedule: #E1; Bill's schedule: #E2?"
     }}\'
   }}\'
 ]
@@ -94,7 +91,7 @@ task: {task}
 """
 
 SOLVER_SYSTEM_PROMPT = """
-Solve the following task or problem. To solve the problem, we have made step-by-step Plan and \
+Solve the following task or problem. To solve the problem, we have made some Plans ahead and \
 retrieved corresponding Evidence to each Plan. Use them with caution since long evidence might \
 contain irrelevant information.
 

{nvidia_nat-1.3.0a20250928.dist-info → nvidia_nat-1.3.0a20250929.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nvidia-nat
-Version: 1.3.0a20250928
+Version: 1.3.0a20250929
 Summary: NVIDIA NeMo Agent toolkit
 Author: NVIDIA Corporation
 Maintainer: NVIDIA Corporation

{nvidia_nat-1.3.0a20250928.dist-info → nvidia_nat-1.3.0a20250929.dist-info}/RECORD

@@ -14,8 +14,8 @@ nat/agent/react_agent/register.py,sha256=b97dfNtA0I3bNBOGdr9_akQ89UDwPHPPb7LqpsZ
 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=ogTtUsNqbAjEprBKp2ZEoYfuHvgxnjV7NgygvSgMz7M,19264
-nat/agent/rewoo_agent/prompt.py,sha256=nFMav3Zl_vmKPLzAIhbQHlldWnurPJb1GlwnekUuxDs,3720
+nat/agent/rewoo_agent/agent.py,sha256=920IYuVBq9Kg4h3pbe_p4Gpz2mBjpGJxdLivYYo3ce8,27594
+nat/agent/rewoo_agent/prompt.py,sha256=B0JeL1xDX4VKcShlkkviEcAsOKAwzSlX8NcAQdmUUPw,3645
 nat/agent/rewoo_agent/register.py,sha256=668zAag6eqajX_PIfh6c-0I0UQN5D-lRiz_mNKHXXjM,8954
 nat/agent/tool_calling_agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nat/agent/tool_calling_agent/agent.py,sha256=4SIp29I56oznPRQu7B3HCoX53Ri3_o3BRRYNJjeBkF8,11006
@@ -469,10 +469,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.3.0a20250928.dist-info/licenses/LICENSE-3rd-party.txt,sha256=fOk5jMmCX9YoKWyYzTtfgl-SUy477audFC5hNY4oP7Q,284609
-nvidia_nat-1.3.0a20250928.dist-info/licenses/LICENSE.md,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-nvidia_nat-1.3.0a20250928.dist-info/METADATA,sha256=wgL7swlr3yFBn22PDRQ4CdjY7nIE_q2IgV_bKmiuZVc,22918
-nvidia_nat-1.3.0a20250928.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nvidia_nat-1.3.0a20250928.dist-info/entry_points.txt,sha256=4jCqjyETMpyoWbCBf4GalZU8I_wbstpzwQNezdAVbbo,698
-nvidia_nat-1.3.0a20250928.dist-info/top_level.txt,sha256=lgJWLkigiVZuZ_O1nxVnD_ziYBwgpE2OStdaCduMEGc,8
-nvidia_nat-1.3.0a20250928.dist-info/RECORD,,
+nvidia_nat-1.3.0a20250929.dist-info/licenses/LICENSE-3rd-party.txt,sha256=fOk5jMmCX9YoKWyYzTtfgl-SUy477audFC5hNY4oP7Q,284609
+nvidia_nat-1.3.0a20250929.dist-info/licenses/LICENSE.md,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+nvidia_nat-1.3.0a20250929.dist-info/METADATA,sha256=3m2Kp0KWB9oXqVUBoOmGesvEgobUxMEenPMV6W1llDo,22918
+nvidia_nat-1.3.0a20250929.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nvidia_nat-1.3.0a20250929.dist-info/entry_points.txt,sha256=4jCqjyETMpyoWbCBf4GalZU8I_wbstpzwQNezdAVbbo,698
+nvidia_nat-1.3.0a20250929.dist-info/top_level.txt,sha256=lgJWLkigiVZuZ_O1nxVnD_ziYBwgpE2OStdaCduMEGc,8
+nvidia_nat-1.3.0a20250929.dist-info/RECORD,,