nvidia-nat 1.3.0a20250926__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.
 

nat/authentication/api_key/api_key_auth_provider.py

@@ -80,7 +80,7 @@ class APIKeyAuthProvider(AuthProviderBase[APIKeyAuthProviderConfig]):
 
         raise ValueError(f"Unsupported header auth scheme: {header_auth_scheme}")
 
-    async def authenticate(self, user_id: str | None = None) -> AuthResult | None:
+    async def authenticate(self, user_id: str | None = None, **kwargs) -> AuthResult | None:
         """
         Authenticate the user using the API key credentials.
 

nat/authentication/http_basic_auth/http_basic_auth_provider.py

@@ -38,7 +38,7 @@ class HTTPBasicAuthProvider(AuthProviderBase):
 
         self._authenticated_tokens: dict[str, AuthResult] = {}
 
-    async def authenticate(self, user_id: str | None = None) -> AuthResult:
+    async def authenticate(self, user_id: str | None = None, **kwargs) -> AuthResult:
         """
         Performs simple HTTP Authentication using the provided user ID.
         """

nat/authentication/interfaces.py

@@ -54,7 +54,7 @@ class AuthProviderBase(typing.Generic[AuthProviderBaseConfigT], ABC):
         return self._config
 
     @abstractmethod
-    async def authenticate(self, user_id: str | None = None) -> AuthResult:
+    async def authenticate(self, user_id: str | None = None, **kwargs) -> AuthResult:
         """
         Perform the authentication process for the client.
 
@@ -62,6 +62,9 @@ class AuthProviderBase(typing.Generic[AuthProviderBaseConfigT], ABC):
         target API service, which may include obtaining tokens, refreshing credentials,
         or completing multi-step authentication flows.
 
+        Args:
+            user_id: Optional user identifier for authentication
+            kwargs: Additional authentication parameters for example: http response (typically from a 401)
         Raises:
             NotImplementedError: Must be implemented by subclasses.
         """
@@ -71,7 +74,7 @@ class AuthProviderBase(typing.Generic[AuthProviderBaseConfigT], ABC):
 
 class FlowHandlerBase(ABC):
     """
-    Handles front-end specifc flows for authentication clients.
+    Handles front-end specific flows for authentication clients.
 
     Each front end will define a FlowHandler that will implement the authenticate method.
 

nat/authentication/oauth2/oauth2_auth_code_flow_provider.py

@@ -15,6 +15,7 @@
 
 from datetime import datetime
 from datetime import timezone
+from typing import Callable
 
 from authlib.integrations.httpx_client import OAuth2Client as AuthlibOAuth2Client
 from pydantic import SecretStr
@@ -22,6 +23,7 @@ from pydantic import SecretStr
 from nat.authentication.interfaces import AuthProviderBase
 from nat.authentication.oauth2.oauth2_auth_code_flow_provider_config import OAuth2AuthCodeFlowProviderConfig
 from nat.builder.context import Context
+from nat.data_models.authentication import AuthenticatedContext
 from nat.data_models.authentication import AuthFlowType
 from nat.data_models.authentication import AuthResult
 from nat.data_models.authentication import BearerTokenCred
@@ -32,7 +34,7 @@ class OAuth2AuthCodeFlowProvider(AuthProviderBase[OAuth2AuthCodeFlowProviderConf
     def __init__(self, config: OAuth2AuthCodeFlowProviderConfig):
         super().__init__(config)
         self._authenticated_tokens: dict[str, AuthResult] = {}
-        self._context = Context.get()
+        self._auth_callback = None
 
     async def _attempt_token_refresh(self, user_id: str, auth_result: AuthResult) -> AuthResult | None:
         refresh_token = auth_result.raw.get("refresh_token")
@@ -62,7 +64,12 @@ class OAuth2AuthCodeFlowProvider(AuthProviderBase[OAuth2AuthCodeFlowProviderConf
 
         return new_auth_result
 
-    async def authenticate(self, user_id: str | None = None) -> AuthResult:
+    def _set_custom_auth_callback(self,
+                                  auth_callback: Callable[[OAuth2AuthCodeFlowProviderConfig, AuthFlowType],
+                                                          AuthenticatedContext]):
+        self._auth_callback = auth_callback
+
+    async def authenticate(self, user_id: str | None = None, **kwargs) -> AuthResult:
         if user_id is None and hasattr(Context.get(), "metadata") and hasattr(
                 Context.get().metadata, "cookies") and Context.get().metadata.cookies is not None:
             session_id = Context.get().metadata.cookies.get("nat-session", None)
@@ -80,7 +87,12 @@ class OAuth2AuthCodeFlowProvider(AuthProviderBase[OAuth2AuthCodeFlowProviderConf
             if refreshed_auth_result:
                 return refreshed_auth_result
 
-        auth_callback = self._context.user_auth_callback
+        # Try getting callback from the context if that's not set, use the default callback
+        try:
+            auth_callback = Context.get().user_auth_callback
+        except RuntimeError:
+            auth_callback = self._auth_callback
+
         if not auth_callback:
             raise RuntimeError("Authentication callback not set on Context.")
 

nat/cli/commands/mcp/mcp.py

@@ -157,6 +157,66 @@ def print_tool(tool_dict: dict[str, str | None], detail: bool = False) -> None:
         click.echo("-" * 60)
 
 
+def _set_auth_defaults(auth: bool,
+                       url: str | None,
+                       auth_redirect_uri: str | None,
+                       auth_user_id: str | None,
+                       auth_scopes: str | None) -> tuple[str | None, str | None, list[str] | None]:
+    """Set default auth values when --auth flag is used.
+
+    Args:
+        auth: Whether --auth flag was used
+        url: MCP server URL
+        auth_redirect_uri: OAuth2 redirect URI
+        auth_user_id: User ID for authentication
+        auth_scopes: OAuth2 scopes (comma-separated string)
+
+    Returns:
+        Tuple of (auth_redirect_uri, auth_user_id, auth_scopes_list) with defaults applied
+    """
+    if auth:
+        auth_redirect_uri = auth_redirect_uri or "http://localhost:8000/auth/redirect"
+        auth_user_id = auth_user_id or url
+        auth_scopes = auth_scopes or ""
+
+    # Convert comma-separated string to list, stripping whitespace
+    auth_scopes_list = [scope.strip() for scope in auth_scopes.split(',')] if auth_scopes else None
+
+    return auth_redirect_uri, auth_user_id, auth_scopes_list
+
+
+async def _create_mcp_client_config(
+    builder,
+    server_cfg,
+    url: str | None,
+    transport: str,
+    auth_redirect_uri: str | None,
+    auth_user_id: str | None,
+    auth_scopes: list[str] | None,
+):
+    from nat.plugins.mcp.client_impl import MCPClientConfig
+
+    if url and transport == "streamable-http" and auth_redirect_uri:
+        try:
+            from nat.plugins.mcp.auth.auth_provider_config import MCPOAuth2ProviderConfig
+            auth_config = MCPOAuth2ProviderConfig(
+                server_url=url,
+                redirect_uri=auth_redirect_uri,
+                default_user_id=auth_user_id or url,
+                scopes=auth_scopes or [],
+            )
+            auth_provider_name = "mcp_oauth2_cli"
+            await builder.add_auth_provider(auth_provider_name, auth_config)
+            server_cfg.auth_provider = auth_provider_name
+        except ImportError:
+            click.echo(
+                "[WARNING] MCP OAuth2 authentication requires nvidia-nat-mcp package.",
+                err=True,
+            )
+
+    return MCPClientConfig(server=server_cfg)
+
+
 async def list_tools_via_function_group(
     command: str | None,
     url: str | None,
@@ -164,6 +224,9 @@ async def list_tools_via_function_group(
     transport: str = 'sse',
     args: list[str] | None = None,
     env: dict[str, str] | None = None,
+    auth_redirect_uri: str | None = None,
+    auth_user_id: str | None = None,
+    auth_scopes: list[str] | None = None,
 ) -> list[dict[str, str | None]]:
     """List tools by constructing the mcp_client function group and introspecting functions.
 
@@ -192,15 +255,24 @@ async def list_tools_via_function_group(
         args=args if transport == 'stdio' else None,
         env=env if transport == 'stdio' else None,
     )
+
     group_cfg = MCPClientConfig(server=server_cfg)
 
     tools: list[dict[str, str | None]] = []
 
     async with WorkflowBuilder() as builder:  # type: ignore
+        # Add auth provider if url is provided and auth_redirect_uri is given (only for streamable-http)
+        group_cfg = await _create_mcp_client_config(builder,
+                                                    server_cfg,
+                                                    url,
+                                                    transport,
+                                                    auth_redirect_uri,
+                                                    auth_user_id,
+                                                    auth_scopes)
         group = await builder.add_function_group("mcp_client", group_cfg)
 
         # Access functions exposed by the group
-        fns = group.get_accessible_functions()
+        fns = await group.get_accessible_functions()
 
         def to_tool_entry(full_name: str, fn_obj) -> dict[str, str | None]:
             # full_name like "mcp_client.<tool>"
@@ -324,7 +396,10 @@ async def ping_mcp_server(url: str,
                           transport: str = 'streamable-http',
                           command: str | None = None,
                           args: list[str] | None = None,
-                          env: dict[str, str] | None = None) -> MCPPingResult:
+                          env: dict[str, str] | None = None,
+                          auth_redirect_uri: str | None = None,
+                          auth_user_id: str | None = None,
+                          auth_scopes: list[str] | None = None) -> MCPPingResult:
     """Ping an MCP server to check if it's responsive.
 
     Args:
@@ -383,7 +458,13 @@ def mcp_client_command():
     """
     MCP client commands.
     """
-    return None
+    try:
+        from nat.runtime.loader import PluginTypes
+        from nat.runtime.loader import discover_and_register_plugins
+        discover_and_register_plugins(PluginTypes.CONFIG_OBJECT)
+    except ImportError:
+        click.echo("[WARNING] MCP client functionality requires nvidia-nat-mcp package.", err=True)
+        pass
 
 
 @mcp_client_command.group(name="tool", invoke_without_command=False, help="Inspect and call MCP tools.")
@@ -412,14 +493,36 @@ def mcp_client_tool_group():
 @click.option('--tool', default=None, help='Get details for a specific tool by name')
 @click.option('--detail', is_flag=True, help='Show full details for all tools')
 @click.option('--json-output', is_flag=True, help='Output tool metadata in JSON format')
+@click.option('--auth',
+              is_flag=True,
+              help='Enable OAuth2 authentication with default settings (streamable-http only, not with --direct)')
+@click.option('--auth-redirect-uri',
+              help='OAuth2 redirect URI for authentication (streamable-http only, not with --direct)')
+@click.option('--auth-user-id', help='User ID for authentication (streamable-http only, not with --direct)')
+@click.option('--auth-scopes', help='OAuth2 scopes (comma-separated, streamable-http only, not with --direct)')
 @click.pass_context
-def mcp_client_tool_list(ctx, direct, url, transport, command, args, env, tool, detail, json_output):
+def mcp_client_tool_list(ctx,
+                         direct,
+                         url,
+                         transport,
+                         command,
+                         args,
+                         env,
+                         tool,
+                         detail,
+                         json_output,
+                         auth,
+                         auth_redirect_uri,
+                         auth_user_id,
+                         auth_scopes):
     """List MCP tool names (default) or show detailed tool information.
 
     Use --detail for full output including descriptions and input schemas.
     If --tool is provided, always shows full output for that specific tool.
     Use --direct to bypass MCPBuilder and use raw MCP protocol.
     Use --json-output to get structured JSON data instead of formatted text.
+    Use --auth to enable auth with default settings (streamable-http only, not with --direct).
+    Use --auth-redirect-uri to enable auth for protected MCP servers (streamable-http only, not with --direct).
 
     Args:
         ctx (click.Context): Click context object for command invocation
@@ -428,13 +531,22 @@ def mcp_client_tool_list(ctx, direct, url, transport, command, args, env, tool,
         tool (str | None): Optional specific tool name to retrieve detailed info for
         detail (bool): Whether to show full details (description + schema) for all tools
         json_output (bool): Whether to output tool metadata in JSON format instead of text
+        auth (bool): Whether to enable OAuth2 authentication (streamable-http only, not with --direct)
+        auth_redirect_uri (str | None): redirect URI for auth (streamable-http only, not with --direct)
+        auth_user_id (str | None): User ID for authentication (streamable-http only, not with --direct)
+        auth_scopes (str | None): OAuth2 scopes (comma-separated, streamable-http only, not with --direct)
 
     Examples:
         nat mcp client tool list                           # List tool names only
         nat mcp client tool list --detail                  # Show all tools with full details
         nat mcp client tool list --tool my_tool            # Show details for specific tool
         nat mcp client tool list --json-output             # Get JSON format output
-        nat mcp client tool list --direct --url http://... # Use direct protocol with custom URL
+        nat mcp client tool list --direct --url http://... # Use direct protocol with custom URL (no auth)
+        nat mcp client tool list --url https://example.com/mcp/ --auth # With auth using defaults
+        nat mcp client tool list --url https://example.com/mcp/ --transport streamable-http \
+            --auth-redirect-uri http://localhost:8000/auth/redirect # With custom auth settings
+        nat mcp client tool list --url https://example.com/mcp/ --transport streamable-http \
+            --auth-redirect-uri http://localhost:8000/auth/redirect --auth-user-id myuser # With auth and user ID
     """
     if ctx.invoked_subcommand is not None:
         return
@@ -447,11 +559,28 @@ def mcp_client_tool_list(ctx, direct, url, transport, command, args, env, tool,
             click.echo("[ERROR] --url is required when using sse or streamable-http client type", err=True)
             return
 
+    # Set auth defaults if --auth flag is used
+    auth_redirect_uri, auth_user_id, auth_scopes_list = _set_auth_defaults(
+        auth, url, auth_redirect_uri, auth_user_id, auth_scopes
+    )
+
     stdio_args = args.split() if args else []
     stdio_env = dict(var.split('=', 1) for var in env.split()) if env else None
 
-    fetcher = list_tools_direct if direct else list_tools_via_function_group
-    tools = asyncio.run(fetcher(command, url, tool, transport, stdio_args, stdio_env))
+    if direct:
+        tools = asyncio.run(
+            list_tools_direct(command, url, tool_name=tool, transport=transport, args=stdio_args, env=stdio_env))
+    else:
+        tools = asyncio.run(
+            list_tools_via_function_group(command,
+                                          url,
+                                          tool_name=tool,
+                                          transport=transport,
+                                          args=stdio_args,
+                                          env=stdio_env,
+                                          auth_redirect_uri=auth_redirect_uri,
+                                          auth_user_id=auth_user_id,
+                                          auth_scopes=auth_scopes_list))
 
     if json_output:
         click.echo(json.dumps(tools, indent=2))
@@ -482,13 +611,20 @@ def mcp_client_tool_list(ctx, direct, url, transport, command, args, env, tool,
 @click.option('--env', help='For stdio: Environment variables in KEY=VALUE format (space-separated)')
 @click.option('--timeout', default=60, show_default=True, help='Timeout in seconds for ping request')
 @click.option('--json-output', is_flag=True, help='Output ping result in JSON format')
+@click.option('--auth-redirect-uri',
+              help='OAuth2 redirect URI for authentication (streamable-http only, not with --direct)')
+@click.option('--auth-user-id', help='User ID for authentication (streamable-http only, not with --direct)')
+@click.option('--auth-scopes', help='OAuth2 scopes (comma-separated, streamable-http only, not with --direct)')
 def mcp_client_ping(url: str,
                     transport: str,
                     command: str | None,
                     args: str | None,
                     env: str | None,
                     timeout: int,
-                    json_output: bool) -> None:
+                    json_output: bool,
+                    auth_redirect_uri: str | None,
+                    auth_user_id: str | None,
+                    auth_scopes: str | None) -> None:
     """Ping an MCP server to check if it's responsive.
 
     This command sends a ping request to the MCP server and measures the response time.
@@ -498,12 +634,16 @@ def mcp_client_ping(url: str,
         url (str): MCP server URL to ping (default: http://localhost:9901/mcp)
         timeout (int): Timeout in seconds for the ping request (default: 60)
         json_output (bool): Whether to output the result in JSON format
+        auth_redirect_uri (str | None): redirect URI for auth (streamable-http only, not with --direct)
+        auth_user_id (str | None): User ID for auth (streamable-http only, not with --direct)
+        auth_scopes (str | None): OAuth2 scopes (comma-separated, streamable-http only, not with --direct)
 
     Examples:
         nat mcp client ping                                    # Ping default server
         nat mcp client ping --url http://custom-server:9901/mcp # Ping custom server
         nat mcp client ping --timeout 10                      # Use 10 second timeout
         nat mcp client ping --json-output                     # Get JSON format output
+        nat mcp client ping --url https://example.com/mcp/ --transport streamable-http --auth # With auth
     """
     # Validate combinations similar to list command
     if not validate_transport_cli_args(transport, command, args, env):
@@ -512,7 +652,24 @@ def mcp_client_ping(url: str,
     stdio_args = args.split() if args else []
     stdio_env = dict(var.split('=', 1) for var in env.split()) if env else None
 
-    result = asyncio.run(ping_mcp_server(url, timeout, transport, command, stdio_args, stdio_env))
+    # Auth validation: if user_id or scopes provided, require redirect_uri
+    if (auth_user_id or auth_scopes) and not auth_redirect_uri:
+        click.echo("[ERROR] --auth-redirect-uri is required when using --auth-user-id or --auth-scopes", err=True)
+        return
+
+    # Parse auth scopes, stripping whitespace
+    auth_scopes_list = [scope.strip() for scope in auth_scopes.split(',')] if auth_scopes else None
+
+    result = asyncio.run(
+        ping_mcp_server(url,
+                        timeout,
+                        transport,
+                        command,
+                        stdio_args,
+                        stdio_env,
+                        auth_redirect_uri,
+                        auth_user_id,
+                        auth_scopes_list))
 
     if json_output:
         click.echo(result.model_dump_json(indent=2))
@@ -635,7 +792,10 @@ async def call_tool_and_print(command: str | None,
                               args: list[str] | None,
                               env: dict[str, str] | None,
                               tool_args: dict[str, Any] | None,
-                              direct: bool) -> str:
+                              direct: bool,
+                              auth_redirect_uri: str | None = None,
+                              auth_user_id: str | None = None,
+                              auth_scopes: list[str] | None = None) -> str:
     """Call an MCP tool either directly or via the function group and return output.
 
     When ``direct`` is True, uses the raw MCP protocol client (bypassing the
@@ -681,11 +841,25 @@ async def call_tool_and_print(command: str | None,
         args=args if transport == 'stdio' else None,
         env=env if transport == 'stdio' else None,
     )
+
     group_cfg = MCPClientConfig(server=server_cfg)
 
     async with WorkflowBuilder() as builder:  # type: ignore
+        # Add auth provider if url is provided and auth_redirect_uri is given (only for streamable-http)
+        if url and transport == 'streamable-http' and auth_redirect_uri:
+            try:
+                group_cfg = await _create_mcp_client_config(builder,
+                                                            server_cfg,
+                                                            url,
+                                                            transport,
+                                                            auth_redirect_uri,
+                                                            auth_user_id,
+                                                            auth_scopes)
+            except ImportError:
+                click.echo("[WARNING] MCP OAuth2 authentication requires nvidia-nat-mcp package.", err=True)
+
         group = await builder.add_function_group("mcp_client", group_cfg)
-        fns = group.get_accessible_functions()
+        fns = await group.get_accessible_functions()
         full = f"mcp_client.{tool_name}"
         fn = fns.get(full)
         if fn is None:
@@ -713,6 +887,13 @@ async def call_tool_and_print(command: str | None,
 @click.option('--args', help='For stdio: Additional arguments for the command (space-separated)')
 @click.option('--env', help='For stdio: Environment variables in KEY=VALUE format (space-separated)')
 @click.option('--json-args', default=None, help='Pass tool args as a JSON object string')
+@click.option('--auth',
+              is_flag=True,
+              help='Enable OAuth2 authentication with default settings (streamable-http only, not with --direct)')
+@click.option('--auth-redirect-uri',
+              help='OAuth2 redirect URI for authentication (streamable-http only, not with --direct)')
+@click.option('--auth-user-id', help='User ID for authentication (streamable-http only, not with --direct)')
+@click.option('--auth-scopes', help='OAuth2 scopes (comma-separated, streamable-http only, not with --direct)')
 def mcp_client_tool_call(tool_name: str,
                          direct: bool,
                          url: str | None,
@@ -720,7 +901,11 @@ def mcp_client_tool_call(tool_name: str,
                          command: str | None,
                          args: str | None,
                          env: str | None,
-                         json_args: str | None) -> None:
+                         json_args: str | None,
+                         auth: bool,
+                         auth_redirect_uri: str | None,
+                         auth_user_id: str | None,
+                         auth_scopes: str | None) -> None:
     """Call an MCP tool by name with optional JSON arguments.
 
     Validates transport parameters, parses ``--json-args`` into a dictionary,
@@ -737,13 +922,20 @@ def mcp_client_tool_call(tool_name: str,
         args (str | None): For ``stdio`` transport, space-separated command arguments.
         env (str | None): For ``stdio`` transport, space-separated ``KEY=VALUE`` pairs.
         json_args (str | None): JSON object string with tool arguments (e.g. '{"q": "hello"}').
+        auth_redirect_uri (str | None): redirect URI for auth (streamable-http only, not with --direct)
+        auth_user_id (str | None): User ID for authentication (streamable-http only, not with --direct)
+        auth_scopes (str | None): OAuth2 scopes (comma-separated, streamable-http only, not with --direct)
 
     Examples:
         nat mcp client tool call echo --json-args '{"text": "Hello"}'
         nat mcp client tool call search --direct --url http://localhost:9901/mcp \
-            --json-args '{"query": "NVIDIA"}'
+            --json-args '{"query": "NVIDIA"}' # Direct mode (no auth)
         nat mcp client tool call run --transport stdio --command mcp-server \
             --args "--flag1 --flag2" --env "ENV1=V1 ENV2=V2" --json-args '{}'
+        nat mcp client tool call search --url https://example.com/mcp/ --auth \
+            --json-args '{"query": "test"}' # With auth using defaults
+        nat mcp client tool call search --url https://example.com/mcp/ \
+            --transport streamable-http --json-args '{"query": "test"}' --auth
     """
     # Validate transport args
     if not validate_transport_cli_args(transport, command, args, env):
@@ -753,6 +945,11 @@ def mcp_client_tool_call(tool_name: str,
     stdio_args = args.split() if args else []
     stdio_env = dict(var.split('=', 1) for var in env.split()) if env else None
 
+    # Set auth defaults if --auth flag is used
+    auth_redirect_uri, auth_user_id, auth_scopes_list = _set_auth_defaults(
+        auth, url, auth_redirect_uri, auth_user_id, auth_scopes
+    )
+
     # Parse tool args
     arg_obj: dict[str, Any] = {}
     if json_args:
@@ -777,6 +974,9 @@ def mcp_client_tool_call(tool_name: str,
                 env=stdio_env,
                 tool_args=arg_obj,
                 direct=direct,
+                auth_redirect_uri=auth_redirect_uri,
+                auth_user_id=auth_user_id,
+                auth_scopes=auth_scopes_list,
             ))
         if output:
             click.echo(output)

nat/data_models/authentication.py

@@ -249,21 +249,3 @@ class AuthResult(BaseModel):
                 target_kwargs.setdefault(k, {}).update(v)
             else:
                 target_kwargs[k] = v
-
-
-class AuthReason(str, Enum):
-    """
-    Why the caller is asking for auth now.
-    """
-    NORMAL = "normal"
-    RETRY_AFTER_401 = "retry_after_401"
-
-
-class AuthRequest(BaseModel):
-    """
-    Authentication request payload for provider.authenticate(...).
-    """
-    model_config = ConfigDict(extra="forbid")
-
-    reason: AuthReason = Field(default=AuthReason.NORMAL, description="Purpose of this auth attempt.")
-    www_authenticate: str | None = Field(default=None, description="Raw WWW-Authenticate header from a 401 response.")

nat/runtime/session.py

@@ -111,7 +111,7 @@ class SessionManager:
             token_user_authentication = self._context_state.user_auth_callback.set(user_authentication_callback)
 
         if isinstance(http_connection, WebSocket):
-            self.set_metadata_from_websocket(user_message_id, conversation_id)
+            self.set_metadata_from_websocket(http_connection, user_message_id, conversation_id)
 
         if isinstance(http_connection, Request):
             self.set_metadata_from_http_request(http_connection)
@@ -161,11 +161,31 @@ class SessionManager:
         if request.headers.get("user-message-id"):
             self._context_state.user_message_id.set(request.headers["user-message-id"])
 
-    def set_metadata_from_websocket(self, user_message_id: str | None, conversation_id: str | None) -> None:
+    def set_metadata_from_websocket(self,
+                                    websocket: WebSocket,
+                                    user_message_id: str | None,
+                                    conversation_id: str | None) -> None:
         """
         Extracts and sets user metadata for Websocket connections.
         """
 
+        # Extract cookies from WebSocket headers (similar to HTTP request)
+        if websocket and hasattr(websocket, 'scope') and 'headers' in websocket.scope:
+            cookies = {}
+            for header_name, header_value in websocket.scope.get('headers', []):
+                if header_name == b'cookie':
+                    cookie_header = header_value.decode('utf-8')
+                    # Parse cookie header: "name1=value1; name2=value2"
+                    for cookie in cookie_header.split(';'):
+                        cookie = cookie.strip()
+                        if '=' in cookie:
+                            name, value = cookie.split('=', 1)
+                            cookies[name.strip()] = value.strip()
+
+            # Set cookies in metadata (same as HTTP request)
+            self._context.metadata._request.cookies = cookies
+            self._context_state.metadata.set(self._context.metadata)
+
         if conversation_id is not None:
             self._context_state.conversation_id.set(conversation_id)
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nvidia-nat
-Version: 1.3.0a20250926
+Version: 1.3.0a20250929
 Summary: NVIDIA NeMo Agent toolkit
 Author: NVIDIA Corporation
 Maintainer: NVIDIA Corporation
@@ -305,6 +305,7 @@ Requires-Dist: nat_router_agent; extra == "examples"
 Requires-Dist: nat_semantic_kernel_demo; extra == "examples"
 Requires-Dist: nat_sequential_executor; extra == "examples"
 Requires-Dist: nat_simple_auth; extra == "examples"
+Requires-Dist: nat_simple_auth_mcp; extra == "examples"
 Requires-Dist: nat_simple_web_query; extra == "examples"
 Requires-Dist: nat_simple_web_query_eval; extra == "examples"
 Requires-Dist: nat_simple_calculator; extra == "examples"

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

@@ -14,17 +14,17 @@ 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
 nat/agent/tool_calling_agent/register.py,sha256=ijiRfgDVtt2p7_q1YbIQZmUVV8-jf3yT18HwtKyReUI,6822
 nat/authentication/__init__.py,sha256=Xs1JQ16L9btwreh4pdGKwskffAw1YFO48jKrU4ib_7c,685
-nat/authentication/interfaces.py,sha256=FAYM-QXVUn3a_8bmAZ7kP-lmN_BrLW8mo6krZJ3e0ME,3314
+nat/authentication/interfaces.py,sha256=1J2CWEJ_n6CLA3_HD3XV28CSbyfxrPAHzr7Q4kKDFdc,3511
 nat/authentication/register.py,sha256=lFhswYUk9iZ53mq33fClR9UfjJPdjGIivGGNHQeWiYo,915
 nat/authentication/api_key/__init__.py,sha256=GUJrgGtpvyMUCjUBvR3faAdv-tZzbU9W-izgx9aMEQg,680
-nat/authentication/api_key/api_key_auth_provider.py,sha256=DoN1MoeB_uOWQMHUz2OiyhwbFxQkj0FOifN2TFr4sds,4022
+nat/authentication/api_key/api_key_auth_provider.py,sha256=QGRZZilD2GryhRJoODfKqypH54IwQp0I-Cck40Dc7dM,4032
 nat/authentication/api_key/api_key_auth_provider_config.py,sha256=zfkxH3yvUSKKldRf1K4PPm0rJLXGH0GDH8xj7anPYGQ,5472
 nat/authentication/api_key/register.py,sha256=Mhv3WyZ9H7C2JN8VuPvwlsJEZrwXJCLXCIokkN9RrP0,1147
 nat/authentication/credential_validator/__init__.py,sha256=GUJrgGtpvyMUCjUBvR3faAdv-tZzbU9W-izgx9aMEQg,680
@@ -32,10 +32,10 @@ nat/authentication/credential_validator/bearer_token_validator.py,sha256=cwGENd_
 nat/authentication/exceptions/__init__.py,sha256=Xs1JQ16L9btwreh4pdGKwskffAw1YFO48jKrU4ib_7c,685
 nat/authentication/exceptions/api_key_exceptions.py,sha256=6wnz951BI77rFYuHxoHOthz-y5oE08uxsuM6G5EvOyM,1545
 nat/authentication/http_basic_auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nat/authentication/http_basic_auth/http_basic_auth_provider.py,sha256=vmukbeI32aK6Ulc-yoaFHszr6BqmCvZHIpKr4-arMhs,3442
+nat/authentication/http_basic_auth/http_basic_auth_provider.py,sha256=OXr5TV87SiZtzSK9i_E6WXWyVhWq2MfqO_SS1aZ3p6U,3452
 nat/authentication/http_basic_auth/register.py,sha256=N2VD0vw7cYABsLxsGXl5yw0htc8adkrB0Y_EMxKwFfk,1235
 nat/authentication/oauth2/__init__.py,sha256=Xs1JQ16L9btwreh4pdGKwskffAw1YFO48jKrU4ib_7c,685
-nat/authentication/oauth2/oauth2_auth_code_flow_provider.py,sha256=iFp_kImFwDrweFHGTg4n9RGybH3-wRSJkyh-FPOxwDA,4538
+nat/authentication/oauth2/oauth2_auth_code_flow_provider.py,sha256=TDZvGbpCLW6EDCI-a4Z9KnQyUEcRaJ5hBCPVyIuy-KY,5099
 nat/authentication/oauth2/oauth2_auth_code_flow_provider_config.py,sha256=e165ysd2pX2WTbV3_FQKEjEaa4TAXkJ7B98WUGbqnGE,2204
 nat/authentication/oauth2/oauth2_resource_server_config.py,sha256=ltcNp8Dwb2Q4tlwMN5Cl0B5pouTLtXRoV-QopfqV45M,5314
 nat/authentication/oauth2/register.py,sha256=7rXhf-ilgSS_bUJsd9pOOCotL1FM8dKUt3ke1TllKkQ,1228
@@ -83,7 +83,7 @@ nat/cli/commands/info/info.py,sha256=BGqshIEDpNRH9hM-06k-Gq-QX-qNddPICSWCN-ReC-g
 nat/cli/commands/info/list_channels.py,sha256=K97TE6wtikgImY-wAbFNi0HHUGtkvIFd2woaG06VkT0,1277
 nat/cli/commands/info/list_components.py,sha256=QlAJVONBA77xW8Lx6Autw5NTAZNy_VrJGr1GL9MfnHM,4532
 nat/cli/commands/mcp/__init__.py,sha256=GUJrgGtpvyMUCjUBvR3faAdv-tZzbU9W-izgx9aMEQg,680
-nat/cli/commands/mcp/mcp.py,sha256=CrpOOZZGq1nSsuFU_6h_VBL5ZE92Yr30WV9c5iirtzY,33332
+nat/cli/commands/mcp/mcp.py,sha256=Phtxegf0Ww89NHrwj4dEZh3vaHxjm7RV7NZMByUGhpM,43860
 nat/cli/commands/object_store/__init__.py,sha256=GUJrgGtpvyMUCjUBvR3faAdv-tZzbU9W-izgx9aMEQg,680
 nat/cli/commands/object_store/object_store.py,sha256=_ivB-R30a-66fNy-fUzi58HQ0Ay0gYsGz7T1xXoRa3Y,8576
 nat/cli/commands/registry/__init__.py,sha256=GUJrgGtpvyMUCjUBvR3faAdv-tZzbU9W-izgx9aMEQg,680
@@ -113,7 +113,7 @@ nat/control_flow/router_agent/register.py,sha256=p15Jy05PjJhXRrjqWiEgy47zmc-CFCu
 nat/data_models/__init__.py,sha256=Xs1JQ16L9btwreh4pdGKwskffAw1YFO48jKrU4ib_7c,685
 nat/data_models/agent.py,sha256=IwDyb9Zc3R4Zd5rFeqt7q0EQswczAl5focxV9KozIzs,1625
 nat/data_models/api_server.py,sha256=Zl0eAd-yV9PD8vUH8eWRvXFcUBdY2tENKe73q-Uxxgg,25699
-nat/data_models/authentication.py,sha256=t9-2CQaIfk74DM3CLaJU5NAYGs7m6BjdFFm1hj8WwtY,9064
+nat/data_models/authentication.py,sha256=wpH8tpy_wt1aA3eKIgbc8HfYdr_g6AfM7-NfWBZh-KA,8528
 nat/data_models/common.py,sha256=nXXfGrjpxebzBUa55mLdmzePLt7VFHvTAc6Znj3yEv0,5875
 nat/data_models/component.py,sha256=b_hXOA8Gm5UNvlFkAhsR6kEvf33ST50MKtr5kWf75Ao,1894
 nat/data_models/component_ref.py,sha256=KFDWFVCcvJCfBBcXTh9f3R802EVHBtHXh9OdbRqFmdM,4747
@@ -407,7 +407,7 @@ nat/retriever/nemo_retriever/retriever.py,sha256=gi3_qJFqE-iqRh3of_cmJg-SwzaQ3z2
 nat/runtime/__init__.py,sha256=Xs1JQ16L9btwreh4pdGKwskffAw1YFO48jKrU4ib_7c,685
 nat/runtime/loader.py,sha256=obUdAgZVYCPGC0R8u3wcoKFJzzSPQgJvrbU4OWygtog,7953
 nat/runtime/runner.py,sha256=Kzm5GRrGUFMQ_fbLOCJumYc4R-JXdTm5tUw2yMMDJpE,6450
-nat/runtime/session.py,sha256=U3UHQpdCBkCiJetsWdq9r6wUEVDBa2gv1VQedE64kY8,6959
+nat/runtime/session.py,sha256=DG4cpVg6GCVFY0cGzZnz55eLj0LoK5Q9Vg3NgbTqOHM,8029
 nat/runtime/user_metadata.py,sha256=ce37NRYJWnMOWk6A7VAQ1GQztjMmkhMOq-uYf2gNCwo,3692
 nat/settings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nat/settings/global_settings.py,sha256=JSlYnW3CeGJYGxlaXLz5F9xXf72I5TUz-w6qngG5di0,12476
@@ -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.0a20250926.dist-info/licenses/LICENSE-3rd-party.txt,sha256=fOk5jMmCX9YoKWyYzTtfgl-SUy477audFC5hNY4oP7Q,284609
-nvidia_nat-1.3.0a20250926.dist-info/licenses/LICENSE.md,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-nvidia_nat-1.3.0a20250926.dist-info/METADATA,sha256=AsBqos4EXJEwd-G-QSIF4iXItfZ7ULCpgwh0QCVd1lQ,22862
-nvidia_nat-1.3.0a20250926.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nvidia_nat-1.3.0a20250926.dist-info/entry_points.txt,sha256=4jCqjyETMpyoWbCBf4GalZU8I_wbstpzwQNezdAVbbo,698
-nvidia_nat-1.3.0a20250926.dist-info/top_level.txt,sha256=lgJWLkigiVZuZ_O1nxVnD_ziYBwgpE2OStdaCduMEGc,8
-nvidia_nat-1.3.0a20250926.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,,