nvidia-nat 1.3.0a20250910__py3-none-any.whl → 1.4.0a20251112__py3-none-any.whl

nat/agent/base.py

@@ -27,6 +27,7 @@ from langchain_core.language_models import BaseChatModel
 from langchain_core.messages import AIMessage
 from langchain_core.messages import BaseMessage
 from langchain_core.messages import ToolMessage
+from langchain_core.runnables import Runnable
 from langchain_core.runnables import RunnableConfig
 from langchain_core.tools import BaseTool
 from langgraph.graph.state import CompiledStateGraph
@@ -101,27 +102,31 @@ class BaseAgent(ABC):
         AIMessage
             The LLM response
         """
-        output_message = ""
+        output_message = []
         async for event in runnable.astream(inputs, config=config):
-            output_message += event.content
+            output_message.append(event.content)
 
-        return AIMessage(content=output_message)
+        return AIMessage(content="".join(output_message))
 
-    async def _call_llm(self, messages: list[BaseMessage]) -> AIMessage:
+    async def _call_llm(self, llm: Runnable, inputs: dict[str, Any], config: RunnableConfig | None = None) -> AIMessage:
         """
         Call the LLM directly. Retry logic is handled automatically by the underlying LLM client.
 
         Parameters
         ----------
-        messages : list[BaseMessage]
-            The messages to send to the LLM
+        llm : Runnable
+            The LLM runnable (prompt | llm or similar)
+        inputs : dict[str, Any]
+            The inputs to pass to the runnable
+        config : RunnableConfig | None
+            The config to pass to the runnable (should include callbacks)
 
         Returns
         -------
         AIMessage
             The LLM response
         """
-        response = await self.llm.ainvoke(messages)
+        response = await llm.ainvoke(inputs, config=config)
         return AIMessage(content=str(response.content))
 
     async def _call_tool(self,
@@ -187,7 +192,7 @@ class BaseAgent(ABC):
                 await asyncio.sleep(sleep_time)
 
         # All retries exhausted, return error message
-        error_content = "Tool call failed after all retry attempts. Last error: %s" % str(last_exception)
+        error_content = f"Tool call failed after all retry attempts. Last error: {str(last_exception)}"
         logger.error("%s %s", AGENT_LOG_PREFIX, error_content, exc_info=True)
         return ToolMessage(name=tool.name, tool_call_id=tool.name, content=error_content, status="error")
 

nat/agent/prompt_optimizer/prompt.py

@@ -0,0 +1,68 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# flake8: noqa W291
+
+mutator_prompt = """
+
+## CORE DIRECTIVES
+- **Preserve the original objective and task.** Do not change what the prompt is meant to accomplish.  
+- **Keep the intent intact.** The improved prompt must solve the same problem as the original.  
+- **Do not invent new goals.** Only improve clarity, structure, constraints, and usability.  
+- **Do not drop critical instructions.** Everything essential from the original prompt must remain.  
+- **Return only the mutated prompt text.** No rationale, no diffs, no explanations.  
+- **Be Creative within bounds.** You may rephrase, reorganize, and enhance, but not alter meaning.
+- **DO NOT use curly braces in your prompt** for anything other than existing variables in the prompt as the string
+will be treated as an f-string.
+- **Examples are a good idea** if the original prompt lacks them. They help clarify expected output.
+
+---
+
+## IMPROVEMENT HINTS
+When modifying, apply these principles:
+1. **Clarity & Precision** – remove vague language, strengthen directives.  
+2. **Structure & Flow** – order sections as: *Objective → Constraints → Tools → Steps → Output Schema → Examples*.  
+3. **Schema Adherence** – enforce a single canonical output schema (JSON/XML) with `schema_version`.  
+4. **Tool Governance** – clarify when/how tools are used, their inputs/outputs, and fallback behavior.  
+5. **Error Handling** – specify behavior if tools fail or inputs are insufficient.  
+6. **Budget Awareness** – minimize verbosity, respect token/latency limits.  
+7. **Safety** – include refusals for unsafe requests, enforce compliance with rules.  
+8. **Consistency** – avoid format drift; always maintain the same schema.  
+9. **Integrity** – confirm the task, objective, and intent are preserved.  
+
+---
+
+## MUTATION OPERATORS
+You may:
+- **Tighten** (remove fluff, redundancies)  
+- **Reorder** (improve logical flow)  
+- **Constrain** (add explicit rules/limits)  
+- **Harden** (improve error handling/fallbacks)  
+- **Defuse** (replace ambiguous verbs with measurable actions)  
+- **Format-lock** (wrap outputs in JSON/XML fenced blocks)
+- **Example-ify** (add examples if missing or weak)  
+
+---
+
+## INPUT
+Here is the prompt to mutate:
+{original_prompt}
+
+## OBJECTIVE
+The prompt must acheive the following objective:
+{objective}
+
+The modified prompt is: \n
+
+"""

nat/agent/prompt_optimizer/register.py

@@ -0,0 +1,149 @@
+# SPDX-FileCopyrightText: Copyright (c) 2021-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from pydantic import Field
+
+from nat.builder.builder import Builder
+from nat.builder.framework_enum import LLMFrameworkEnum
+from nat.builder.function_info import FunctionInfo
+from nat.cli.register_workflow import register_function
+from nat.data_models.component_ref import LLMRef
+from nat.data_models.function import FunctionBaseConfig
+from nat.profiler.parameter_optimization.prompt_optimizer import PromptOptimizerInputSchema
+
+
+class PromptOptimizerConfig(FunctionBaseConfig, name="prompt_init"):
+
+    optimizer_llm: LLMRef = Field(description="LLM to use for prompt optimization")
+    optimizer_prompt: str = Field(
+        description="Prompt template for the optimizer",
+        default=(
+            "You are an expert at optimizing prompts for LLMs. "
+            "Your task is to take a given prompt and suggest an optimized version of it. "
+            "Note that the prompt might be a template with variables and curly braces. Remember to always keep the "
+            "variables and curly braces in the prompt the same. Only modify the instructions in the prompt that are"
+            "not variables. The system is meant to achieve the following objective\n"
+            "{system_objective}\n Of which, the prompt is one part. The details of the prompt and context as below.\n"))
+    system_objective: str = Field(description="Objective of the workflow")
+
+
+@register_function(config_type=PromptOptimizerConfig, framework_wrappers=[LLMFrameworkEnum.LANGCHAIN])
+async def prompt_optimizer_function(config: PromptOptimizerConfig, builder: Builder):
+    """
+    Function to optimize prompts for LLMs.
+    """
+
+    try:
+        from langchain_core.prompts import PromptTemplate
+
+        from .prompt import mutator_prompt
+    except ImportError as exc:
+        raise ImportError("langchain-core is not installed. Please install it to use MultiLLMPlanner.\n"
+                          "This error can be resolve by installing \"nvidia-nat[langchain]\".") from exc
+
+    llm = await builder.get_llm(config.optimizer_llm, wrapper_type=LLMFrameworkEnum.LANGCHAIN)
+
+    template = PromptTemplate(template=config.optimizer_prompt,
+                              input_variables=["system_objective"],
+                              validate_template=True)
+
+    base_prompt: str = (await template.ainvoke(input={"system_objective": config.system_objective})).to_string()
+    prompt_extension_template = PromptTemplate(template=mutator_prompt,
+                                               input_variables=["original_prompt", "objective"],
+                                               validate_template=True)
+
+    async def _inner(input_message: PromptOptimizerInputSchema) -> str:
+        """
+        Optimize the prompt using the provided LLM.
+        """
+
+        original_prompt = input_message.original_prompt
+        prompt_objective = input_message.objective
+
+        prompt_extension = (await prompt_extension_template.ainvoke(input={
+            "original_prompt": original_prompt,
+            "objective": prompt_objective,
+        })).to_string()
+
+        prompt = f"{base_prompt}\n\n{prompt_extension}"
+
+        optimized_prompt = await llm.ainvoke(prompt)
+        return optimized_prompt.content
+
+    yield FunctionInfo.from_fn(
+        fn=_inner,
+        description="Optimize prompts for LLMs using a feedback LLM.",
+    )
+
+
+class PromptRecombinerConfig(FunctionBaseConfig, name="prompt_recombiner"):
+
+    optimizer_llm: LLMRef = Field(description="LLM to use for prompt recombination")
+    optimizer_prompt: str = Field(
+        description="Prompt template for the recombiner",
+        default=("You are an expert at combining prompt instructions for LLMs. "
+                 "Your task is to merge two prompts for the same objective into a single, stronger prompt. "
+                 "Do not introduce new variables or modify existing placeholders."),
+    )
+    system_objective: str = Field(description="Objective of the workflow")
+
+
+@register_function(config_type=PromptRecombinerConfig, framework_wrappers=[LLMFrameworkEnum.LANGCHAIN])
+async def prompt_recombiner_function(config: PromptRecombinerConfig, builder: Builder):
+    """
+    Function to recombine two parent prompts into a child prompt using the optimizer LLM.
+    Uses the same base template and objective instructions.
+    """
+
+    try:
+        from langchain_core.prompts import PromptTemplate
+    except ImportError as exc:
+        raise ImportError("langchain-core is not installed. Please install it to use MultiLLMPlanner.\n"
+                          "This error can be resolve by installing \"nvidia-nat[langchain]\".") from exc
+
+    llm = await builder.get_llm(config.optimizer_llm, wrapper_type=LLMFrameworkEnum.LANGCHAIN)
+
+    template = PromptTemplate(template=config.optimizer_prompt,
+                              input_variables=["system_objective"],
+                              validate_template=True)
+
+    base_prompt: str = (await template.ainvoke(input={"system_objective": config.system_objective})).to_string()
+
+    class RecombineSchema(PromptOptimizerInputSchema):
+        parent_b: str | None = None
+
+    async def _inner(input_message: RecombineSchema) -> str:
+        parent_a = input_message.original_prompt
+        parent_b = input_message.parent_b or ""
+        prompt_objective = input_message.objective
+
+        prompt = (
+            f"{base_prompt}\n\n"
+            "We are performing genetic recombination between two prompts that satisfy the same objective.\n"
+            f"Objective: {prompt_objective}\n\n"
+            f"Parent A:\n{parent_a}\n\n"
+            f"Parent B:\n{parent_b}\n\n"
+            "Combine the strongest instructions and phrasing from both parents to produce a single, coherent child "
+            "prompt.\n"
+            "Maintain variables and placeholders unchanged.\n"
+            "Return only the child prompt text, with no additional commentary.")
+
+        child_prompt = await llm.ainvoke(prompt)
+        return child_prompt.content
+
+    yield FunctionInfo.from_fn(
+        fn=_inner,
+        description="Recombine two prompts into a stronger child prompt.",
+    )

nat/agent/react_agent/agent.py

@@ -59,6 +59,7 @@ class ReActGraphState(BaseModel):
     messages: list[BaseMessage] = Field(default_factory=list)  # input and output of the ReAct Agent
     agent_scratchpad: list[AgentAction] = Field(default_factory=list)  # agent thoughts / intermediate steps
     tool_responses: list[BaseMessage] = Field(default_factory=list)  # the responses from any tool calls
+    final_answer: str | None = Field(default=None)  # the final answer from the ReAct Agent
 
 
 class ReActAgentGraph(DualNodeAgent):
@@ -204,6 +205,7 @@ class ReActAgentGraph(DualNodeAgent):
                         # this is where we handle the final output of the Agent, we can clean-up/format/postprocess here
                         # the final answer goes in the "messages" state channel
                         state.messages += [AIMessage(content=final_answer)]
+                        state.final_answer = final_answer
                     else:
                         # the agent wants to call a tool, ensure the thoughts are preserved for the next agentic cycle
                         agent_output.log = output_message.content
@@ -242,10 +244,9 @@ class ReActAgentGraph(DualNodeAgent):
     async def conditional_edge(self, state: ReActGraphState):
         try:
             logger.debug("%s Starting the ReAct Conditional Edge", AGENT_LOG_PREFIX)
-            if len(state.messages) > 1:
-                # the ReAct Agent has finished executing, the last agent output was AgentFinish
-                last_message_content = str(state.messages[-1].content)
-                logger.debug("%s Final answer:\n%s", AGENT_LOG_PREFIX, last_message_content)
+            if state.final_answer:
+                # the ReAct Agent has finished executing
+                logger.debug("%s Final answer:\n%s", AGENT_LOG_PREFIX, state.final_answer)
                 return AgentDecision.END
             # else the agent wants to call a tool
             agent_output = state.agent_scratchpad[-1]
@@ -360,7 +361,7 @@ class ReActAgentGraph(DualNodeAgent):
         if errors:
             error_text = "\n".join(errors)
             logger.error("%s %s", AGENT_LOG_PREFIX, error_text)
-            raise ValueError(error_text)
+            return False
         return True
 
 

nat/agent/react_agent/register.py

@@ -17,32 +17,34 @@ import logging
 
 from pydantic import AliasChoices
 from pydantic import Field
-from pydantic import PositiveInt
 
 from nat.builder.builder import Builder
 from nat.builder.framework_enum import LLMFrameworkEnum
 from nat.builder.function_info import FunctionInfo
 from nat.cli.register_workflow import register_function
+from nat.data_models.agent import AgentBaseConfig
 from nat.data_models.api_server import ChatRequest
+from nat.data_models.api_server import ChatRequestOrMessage
 from nat.data_models.api_server import ChatResponse
+from nat.data_models.api_server import Usage
+from nat.data_models.component_ref import FunctionGroupRef
 from nat.data_models.component_ref import FunctionRef
-from nat.data_models.component_ref import LLMRef
-from nat.data_models.function import FunctionBaseConfig
+from nat.data_models.optimizable import OptimizableField
+from nat.data_models.optimizable import OptimizableMixin
+from nat.data_models.optimizable import SearchSpace
 from nat.utils.type_converter import GlobalTypeConverter
 
 logger = logging.getLogger(__name__)
 
 
-class ReActAgentWorkflowConfig(FunctionBaseConfig, name="react_agent"):
+class ReActAgentWorkflowConfig(AgentBaseConfig, OptimizableMixin, name="react_agent"):
     """
     Defines a NAT function that uses a ReAct Agent performs reasoning inbetween tool calls, and utilizes the
     tool names and descriptions to select the optimal tool.
     """
-
-    tool_names: list[FunctionRef] = Field(default_factory=list,
-                                          description="The list of tools to provide to the react agent.")
-    llm_name: LLMRef = Field(description="The LLM model to use with the react agent.")
-    verbose: bool = Field(default=False, description="Set the verbosity of the react agent's logging.")
+    description: str = Field(default="ReAct Agent Workflow", description="The description of this functions use.")
+    tool_names: list[FunctionRef | FunctionGroupRef] = Field(
+        default_factory=list, description="The list of tools to provide to the react agent.")
     retry_agent_response_parsing_errors: bool = Field(
         default=True,
         validation_alias=AliasChoices("retry_agent_response_parsing_errors", "retry_parsing_errors"),
@@ -61,7 +63,6 @@ class ReActAgentWorkflowConfig(FunctionBaseConfig, name="react_agent"):
         description="Whether to pass tool call errors to agent. If False, failed tool calls will raise an exception.")
     include_tool_input_schema_in_tool_description: bool = Field(
         default=True, description="Specify inclusion of tool input schemas in the prompt.")
-    description: str = Field(default="ReAct Agent Workflow", description="The description of this functions use.")
     normalize_tool_input_quotes: bool = Field(
         default=True,
         description="Whether to replace single quotes with double quotes in the tool input. "
@@ -70,13 +71,14 @@ class ReActAgentWorkflowConfig(FunctionBaseConfig, name="react_agent"):
         default=None,
         description="Provides the SYSTEM_PROMPT to use with the agent")  # defaults to SYSTEM_PROMPT in prompt.py
     max_history: int = Field(default=15, description="Maximum number of messages to keep in the conversation history.")
-    log_response_max_chars: PositiveInt = Field(
-        default=1000, description="Maximum number of characters to display in logs when logging tool responses.")
-    use_openai_api: bool = Field(default=False,
-                                 description=("Use OpenAI API for the input/output types to the function. "
-                                              "If False, strings will be used."))
-    additional_instructions: str | None = Field(
-        default=None, description="Additional instructions to provide to the agent in addition to the base prompt.")
+    additional_instructions: str | None = OptimizableField(
+        default=None,
+        description="Additional instructions to provide to the agent in addition to the base prompt.",
+        space=SearchSpace(
+            is_prompt=True,
+            prompt="No additional instructions.",
+            prompt_purpose="Additional instructions to provide to the agent in addition to the base prompt.",
+        ))
 
 
 @register_function(config_type=ReActAgentWorkflowConfig, framework_wrappers=[LLMFrameworkEnum.LANGCHAIN])
@@ -96,7 +98,7 @@ async def react_agent_workflow(config: ReActAgentWorkflowConfig, builder: Builde
     llm = await builder.get_llm(config.llm_name, wrapper_type=LLMFrameworkEnum.LANGCHAIN)
     # the agent can run any installed tool, simply install the tool and add it to the config file
     # the sample tool provided can easily be copied or changed
-    tools = builder.get_tools(tool_names=config.tool_names, wrapper_type=LLMFrameworkEnum.LANGCHAIN)
+    tools = await builder.get_tools(tool_names=config.tool_names, wrapper_type=LLMFrameworkEnum.LANGCHAIN)
     if not tools:
         raise ValueError(f"No tools specified for ReAct Agent '{config.llm_name}'")
     # configure callbacks, for sending intermediate steps
@@ -114,10 +116,23 @@ async def react_agent_workflow(config: ReActAgentWorkflowConfig, builder: Builde
         pass_tool_call_errors_to_agent=config.pass_tool_call_errors_to_agent,
         normalize_tool_input_quotes=config.normalize_tool_input_quotes).build_graph()
 
-    async def _response_fn(input_message: ChatRequest) -> ChatResponse:
+    async def _response_fn(chat_request_or_message: ChatRequestOrMessage) -> ChatResponse | str:
+        """
+        Main workflow entry function for the ReAct Agent.
+
+        This function invokes the ReAct Agent Graph and returns the response.
+
+        Args:
+            chat_request_or_message (ChatRequestOrMessage): The input message to process
+
+        Returns:
+            ChatResponse | str: The response from the agent or error message
+        """
         try:
+            message = GlobalTypeConverter.get().convert(chat_request_or_message, to_type=ChatRequest)
+
             # initialize the starting state with the user query
-            messages: list[BaseMessage] = trim_messages(messages=[m.model_dump() for m in input_message.messages],
+            messages: list[BaseMessage] = trim_messages(messages=[m.model_dump() for m in message.messages],
                                                         max_tokens=config.max_history,
                                                         strategy="last",
                                                         token_counter=len,
@@ -135,24 +150,19 @@ async def react_agent_workflow(config: ReActAgentWorkflowConfig, builder: Builde
             # get and return the output from the state
             state = ReActGraphState(**state)
             output_message = state.messages[-1]
-            return ChatResponse.from_string(str(output_message.content))
-
+            content = str(output_message.content)
+
+            # Create usage statistics for the response
+            prompt_tokens = sum(len(str(msg.content).split()) for msg in message.messages)
+            completion_tokens = len(content.split()) if content else 0
+            total_tokens = prompt_tokens + completion_tokens
+            usage = Usage(prompt_tokens=prompt_tokens, completion_tokens=completion_tokens, total_tokens=total_tokens)
+            response = ChatResponse.from_string(content, usage=usage)
+            if chat_request_or_message.is_string:
+                return GlobalTypeConverter.get().convert(response, to_type=str)
+            return response
         except Exception as ex:
-            logger.exception("%s ReAct Agent failed with exception: %s", AGENT_LOG_PREFIX, ex)
-            # here, we can implement custom error messages
-            if config.verbose:
-                return ChatResponse.from_string(str(ex))
-            return ChatResponse.from_string("I seem to be having a problem.")
-
-    if (config.use_openai_api):
-        yield FunctionInfo.from_fn(_response_fn, description=config.description)
-    else:
-
-        async def _str_api_fn(input_message: str) -> str:
-            oai_input = GlobalTypeConverter.get().try_convert(input_message, to_type=ChatRequest)
-
-            oai_output = await _response_fn(oai_input)
-
-            return GlobalTypeConverter.get().try_convert(oai_output, to_type=str)
+            logger.error("%s ReAct Agent failed with exception: %s", AGENT_LOG_PREFIX, str(ex))
+            raise
 
-        yield FunctionInfo.from_fn(_str_api_fn, description=config.description)
+    yield FunctionInfo.from_fn(_response_fn, description=config.description)

nat/agent/reasoning_agent/reasoning_agent.py

@@ -23,25 +23,22 @@ from nat.builder.builder import Builder
 from nat.builder.framework_enum import LLMFrameworkEnum
 from nat.builder.function_info import FunctionInfo
 from nat.cli.register_workflow import register_function
+from nat.data_models.agent import AgentBaseConfig
 from nat.data_models.api_server import ChatRequest
 from nat.data_models.component_ref import FunctionRef
-from nat.data_models.component_ref import LLMRef
-from nat.data_models.function import FunctionBaseConfig
 
 logger = logging.getLogger(__name__)
 
 
-class ReasoningFunctionConfig(FunctionBaseConfig, name="reasoning_agent"):
+class ReasoningFunctionConfig(AgentBaseConfig, name="reasoning_agent"):
     """
     Defines a NAT function that performs reasoning on the input data.
     Output is passed to the next function in the workflow.
 
     Designed to be used with an InterceptingFunction.
     """
-
-    llm_name: LLMRef = Field(description="The name of the LLM to use for reasoning.")
+    description: str = Field(default="Reasoning Agent", description="The description of this function's use.")
     augmented_fn: FunctionRef = Field(description="The name of the function to reason on.")
-    verbose: bool = Field(default=False, description="Whether to log detailed information.")
     reasoning_prompt_template: str = Field(
         default=("You are an expert reasoning model task with creating a detailed execution plan"
                  " for a system that has the following description:\n\n"
@@ -102,7 +99,7 @@ async def build_reasoning_function(config: ReasoningFunctionConfig, builder: Bui
     llm: BaseChatModel = await builder.get_llm(config.llm_name, wrapper_type=LLMFrameworkEnum.LANGCHAIN)
 
     # Get the augmented function's description
-    augmented_function = builder.get_function(config.augmented_fn)
+    augmented_function = await builder.get_function(config.augmented_fn)
 
     # For now, we rely on runtime checking for type conversion
 
@@ -113,11 +110,16 @@ async def build_reasoning_function(config: ReasoningFunctionConfig, builder: Bui
                          f"function without a description.")
 
     # Get the function dependencies of the augmented function
-    function_used_tools = builder.get_function_dependencies(config.augmented_fn).functions
+    function_dependencies = builder.get_function_dependencies(config.augmented_fn)
+    function_used_tools = set()
+    function_used_tools.update(function_dependencies.functions)
+    for function_group in function_dependencies.function_groups:
+        function_used_tools.update(builder.get_function_group_dependencies(function_group).functions)
+
     tool_names_with_desc: list[tuple[str, str]] = []
 
     for tool in function_used_tools:
-        tool_impl = builder.get_function(tool)
+        tool_impl = await builder.get_function(tool)
         tool_names_with_desc.append((tool, tool_impl.description if hasattr(tool_impl, "description") else ""))
 
     # Draft the reasoning prompt for the augmented function
@@ -155,12 +157,12 @@ async def build_reasoning_function(config: ReasoningFunctionConfig, builder: Bui
             prompt = prompt.to_string()
 
             # Get the reasoning output from the LLM
-            reasoning_output = ""
+            reasoning_output = []
 
             async for chunk in llm.astream(prompt):
-                reasoning_output += chunk.content
+                reasoning_output.append(chunk.content)
 
-            reasoning_output = remove_r1_think_tags(reasoning_output)
+            reasoning_output = remove_r1_think_tags("".join(reasoning_output))
 
             output = await downstream_template.ainvoke(input={
                 "input_text": input_text, "reasoning_output": reasoning_output
@@ -198,12 +200,12 @@ async def build_reasoning_function(config: ReasoningFunctionConfig, builder: Bui
             prompt = prompt.to_string()
 
             # Get the reasoning output from the LLM
-            reasoning_output = ""
+            reasoning_output = []
 
             async for chunk in llm.astream(prompt):
-                reasoning_output += chunk.content
+                reasoning_output.append(chunk.content)
 
-            reasoning_output = remove_r1_think_tags(reasoning_output)
+            reasoning_output = remove_r1_think_tags("".join(reasoning_output))
 
             output = await downstream_template.ainvoke(input={
                 "input_text": input_text, "reasoning_output": reasoning_output

nat/agent/register.py

@@ -16,7 +16,9 @@
 # flake8: noqa
 
 # Import any workflows which need to be automatically registered here
+from .prompt_optimizer import register as prompt_optimizer
 from .react_agent import register as react_agent
 from .reasoning_agent import reasoning_agent
+from .responses_api_agent import register as responses_api_agent
 from .rewoo_agent import register as rewoo_agent
 from .tool_calling_agent import register as tool_calling_agent

nat/agent/responses_api_agent/__init__.py

@@ -0,0 +1,14 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.