nvidia-nat 1.3.0a20250828__py3-none-any.whl → 1.3.0a20250830__py3-none-any.whl

nat/agent/base.py

@@ -160,6 +160,11 @@ class BaseAgent(ABC):
                                        tool_call_id=tool.name,
                                        content=f"The tool {tool.name} provided an empty response.")
 
+                # ToolMessage only accepts str or list[str | dict] as content.
+                # Convert into list if the response is a dict.
+                if isinstance(response, dict):
+                    response = [response]
+
                 return ToolMessage(name=tool.name, tool_call_id=tool.name, content=response)
 
             except Exception as e:
@@ -183,7 +188,7 @@ class BaseAgent(ABC):
 
         # All retries exhausted, return error message
         error_content = "Tool call failed after all retry attempts. Last error: %s" % str(last_exception)
-        logger.error("%s %s", AGENT_LOG_PREFIX, error_content)
+        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")
 
     def _log_tool_response(self, tool_name: str, tool_input: Any, tool_response: str) -> None:

nat/agent/react_agent/agent.py

@@ -77,7 +77,8 @@ class ReActAgentGraph(DualNodeAgent):
                  retry_agent_response_parsing_errors: bool = True,
                  parse_agent_response_max_retries: int = 1,
                  tool_call_max_retries: int = 1,
-                 pass_tool_call_errors_to_agent: bool = True):
+                 pass_tool_call_errors_to_agent: bool = True,
+                 normalize_tool_input_quotes: bool = True):
         super().__init__(llm=llm,
                          tools=tools,
                          callbacks=callbacks,
@@ -87,6 +88,7 @@ class ReActAgentGraph(DualNodeAgent):
                                                  if retry_agent_response_parsing_errors else 1)
         self.tool_call_max_retries = tool_call_max_retries
         self.pass_tool_call_errors_to_agent = pass_tool_call_errors_to_agent
+        self.normalize_tool_input_quotes = normalize_tool_input_quotes
         logger.debug(
             "%s Filling the prompt variables 'tools' and 'tool_names', using the tools provided in the config.",
             AGENT_LOG_PREFIX)
@@ -129,12 +131,8 @@ class ReActAgentGraph(DualNodeAgent):
         try:
             return self.tools_dict.get(tool_name)
         except Exception as ex:
-            logger.exception("%s Unable to find tool with the name %s\n%s",
-                             AGENT_LOG_PREFIX,
-                             tool_name,
-                             ex,
-                             exc_info=True)
-            raise ex
+            logger.error("%s Unable to find tool with the name %s\n%s", AGENT_LOG_PREFIX, tool_name, ex)
+            raise
 
     async def agent_node(self, state: ReActGraphState):
         try:
@@ -238,8 +236,8 @@ class ReActAgentGraph(DualNodeAgent):
                     working_state.append(output_message)
                     working_state.append(HumanMessage(content=str(ex.observation)))
         except Exception as ex:
-            logger.exception("%s Failed to call agent_node: %s", AGENT_LOG_PREFIX, ex, exc_info=True)
-            raise ex
+            logger.error("%s Failed to call agent_node: %s", AGENT_LOG_PREFIX, ex)
+            raise
 
     async def conditional_edge(self, state: ReActGraphState):
         try:
@@ -257,7 +255,7 @@ class ReActAgentGraph(DualNodeAgent):
                          agent_output.tool_input)
             return AgentDecision.TOOL
         except Exception as ex:
-            logger.exception("Failed to determine whether agent is calling a tool: %s", ex, exc_info=True)
+            logger.exception("Failed to determine whether agent is calling a tool: %s", ex)
             logger.warning("%s Ending graph traversal", AGENT_LOG_PREFIX)
             return AgentDecision.END
 
@@ -290,35 +288,45 @@ class ReActAgentGraph(DualNodeAgent):
                      agent_thoughts.tool_input)
 
         # Run the tool. Try to use structured input, if possible.
+        tool_input_str = agent_thoughts.tool_input.strip()
+
         try:
-            tool_input_str = str(agent_thoughts.tool_input).strip().replace("'", '"')
-            tool_input_dict = json.loads(tool_input_str) if tool_input_str != 'None' else tool_input_str
+            tool_input = json.loads(tool_input_str) if tool_input_str != 'None' else tool_input_str
             logger.debug("%s Successfully parsed structured tool input from Action Input", AGENT_LOG_PREFIX)
 
-            tool_response = await self._call_tool(requested_tool,
-                                                  tool_input_dict,
-                                                  RunnableConfig(callbacks=self.callbacks),
-                                                  max_retries=self.tool_call_max_retries)
-
-            if self.detailed_logs:
-                self._log_tool_response(requested_tool.name, tool_input_dict, str(tool_response.content))
-
-        except JSONDecodeError as ex:
-            logger.debug(
-                "%s Unable to parse structured tool input from Action Input. Using Action Input as is."
-                "\nParsing error: %s",
-                AGENT_LOG_PREFIX,
-                ex,
-                exc_info=True)
-            tool_input_str = str(agent_thoughts.tool_input)
-
-            tool_response = await self._call_tool(requested_tool,
-                                                  tool_input_str,
-                                                  RunnableConfig(callbacks=self.callbacks),
-                                                  max_retries=self.tool_call_max_retries)
+        except JSONDecodeError as original_ex:
+            if self.normalize_tool_input_quotes:
+                # If initial JSON parsing fails, try with quote normalization as a fallback
+                normalized_str = tool_input_str.replace("'", '"')
+                try:
+                    tool_input = json.loads(normalized_str)
+                    logger.debug("%s Successfully parsed structured tool input after quote normalization",
+                                 AGENT_LOG_PREFIX)
+                except JSONDecodeError:
+                    # the quote normalization failed, use raw string input
+                    logger.debug(
+                        "%s Unable to parse structured tool input after quote normalization. Using Action Input as is."
+                        "\nParsing error: %s",
+                        AGENT_LOG_PREFIX,
+                        original_ex)
+                    tool_input = tool_input_str
+            else:
+                # use raw string input
+                logger.debug(
+                    "%s Unable to parse structured tool input from Action Input. Using Action Input as is."
+                    "\nParsing error: %s",
+                    AGENT_LOG_PREFIX,
+                    original_ex)
+                tool_input = tool_input_str
+
+        # Call tool once with the determined input (either parsed dict or raw string)
+        tool_response = await self._call_tool(requested_tool,
+                                              tool_input,
+                                              RunnableConfig(callbacks=self.callbacks),
+                                              max_retries=self.tool_call_max_retries)
 
         if self.detailed_logs:
-            self._log_tool_response(requested_tool.name, tool_input_str, str(tool_response.content))
+            self._log_tool_response(requested_tool.name, tool_input, str(tool_response.content))
 
         if not self.pass_tool_call_errors_to_agent:
             if tool_response.status == "error":
@@ -334,8 +342,8 @@ class ReActAgentGraph(DualNodeAgent):
             logger.debug("%s ReAct Graph built and compiled successfully", AGENT_LOG_PREFIX)
             return self.graph
         except Exception as ex:
-            logger.exception("%s Failed to build ReAct Graph: %s", AGENT_LOG_PREFIX, ex, exc_info=ex)
-            raise ex
+            logger.error("%s Failed to build ReAct Graph: %s", AGENT_LOG_PREFIX, ex)
+            raise
 
     @staticmethod
     def validate_system_prompt(system_prompt: str) -> bool:
@@ -351,7 +359,7 @@ class ReActAgentGraph(DualNodeAgent):
                 errors.append(error_message)
         if errors:
             error_text = "\n".join(errors)
-            logger.exception("%s %s", AGENT_LOG_PREFIX, error_text)
+            logger.error("%s %s", AGENT_LOG_PREFIX, error_text)
             raise ValueError(error_text)
         return True
 
@@ -378,7 +386,7 @@ def create_react_agent_prompt(config: "ReActAgentWorkflowConfig") -> ChatPromptT
 
     valid_prompt = ReActAgentGraph.validate_system_prompt(prompt_str)
     if not valid_prompt:
-        logger.exception("%s Invalid system_prompt", AGENT_LOG_PREFIX)
+        logger.error("%s Invalid system_prompt", AGENT_LOG_PREFIX)
         raise ValueError("Invalid system_prompt")
     prompt = ChatPromptTemplate([("system", prompt_str), ("user", USER_PROMPT),
                                  MessagesPlaceholder(variable_name='agent_scratchpad', optional=True)])

nat/agent/react_agent/register.py

@@ -62,6 +62,10 @@ class ReActAgentWorkflowConfig(FunctionBaseConfig, name="react_agent"):
     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. "
+        "This is useful for tools that expect structured json input.")
     system_prompt: str | None = Field(
         default=None,
         description="Provides the SYSTEM_PROMPT to use with the agent")  # defaults to SYSTEM_PROMPT in prompt.py
@@ -107,7 +111,8 @@ async def react_agent_workflow(config: ReActAgentWorkflowConfig, builder: Builde
         retry_agent_response_parsing_errors=config.retry_agent_response_parsing_errors,
         parse_agent_response_max_retries=config.parse_agent_response_max_retries,
         tool_call_max_retries=config.tool_call_max_retries,
-        pass_tool_call_errors_to_agent=config.pass_tool_call_errors_to_agent).build_graph()
+        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:
         try:
@@ -133,7 +138,7 @@ async def react_agent_workflow(config: ReActAgentWorkflowConfig, builder: Builde
             return ChatResponse.from_string(str(output_message.content))
 
         except Exception as ex:
-            logger.exception("%s ReAct Agent failed with exception: %s", AGENT_LOG_PREFIX, ex, exc_info=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))

nat/agent/rewoo_agent/agent.py

@@ -100,12 +100,8 @@ class ReWOOAgentGraph(BaseAgent):
         try:
             return self.tools_dict.get(tool_name)
         except Exception as ex:
-            logger.exception("%s Unable to find tool with the name %s\n%s",
-                             AGENT_LOG_PREFIX,
-                             tool_name,
-                             ex,
-                             exc_info=True)
-            raise ex
+            logger.error("%s Unable to find tool with the name %s\n%s", AGENT_LOG_PREFIX, tool_name, ex)
+            raise
 
     @staticmethod
     def _get_current_step(state: ReWOOGraphState) -> int:
@@ -207,8 +203,8 @@ class ReWOOAgentGraph(BaseAgent):
             return {"plan": plan, "steps": steps}
 
         except Exception as ex:
-            logger.exception("%s Failed to call planner_node: %s", AGENT_LOG_PREFIX, ex, exc_info=True)
-            raise ex
+            logger.error("%s Failed to call planner_node: %s", AGENT_LOG_PREFIX, ex)
+            raise
 
     async def executor_node(self, state: ReWOOGraphState):
         try:
@@ -274,22 +270,15 @@ class ReWOOAgentGraph(BaseAgent):
                                                   RunnableConfig(callbacks=self.callbacks),
                                                   max_retries=3)
 
-            # ToolMessage only accepts str or list[str | dict] as content.
-            # Convert into list if the response is a dict.
-            if isinstance(tool_response, dict):
-                tool_response = [tool_response]
-
-            tool_response_message = ToolMessage(name=tool, tool_call_id=tool, content=tool_response)
-
             if self.detailed_logs:
                 self._log_tool_response(requested_tool.name, tool_input_parsed, str(tool_response))
 
-            intermediate_results[placeholder] = tool_response_message
+            intermediate_results[placeholder] = tool_response
             return {"intermediate_results": intermediate_results}
 
         except Exception as ex:
-            logger.exception("%s Failed to call executor_node: %s", AGENT_LOG_PREFIX, ex, exc_info=True)
-            raise ex
+            logger.error("%s Failed to call executor_node: %s", AGENT_LOG_PREFIX, ex)
+            raise
 
     async def solver_node(self, state: ReWOOGraphState):
         try:
@@ -332,8 +321,8 @@ class ReWOOAgentGraph(BaseAgent):
             return {"result": output_message}
 
         except Exception as ex:
-            logger.exception("%s Failed to call solver_node: %s", AGENT_LOG_PREFIX, ex, exc_info=True)
-            raise ex
+            logger.error("%s Failed to call solver_node: %s", AGENT_LOG_PREFIX, ex)
+            raise
 
     async def conditional_edge(self, state: ReWOOGraphState):
         try:
@@ -348,10 +337,7 @@ class ReWOOAgentGraph(BaseAgent):
             return AgentDecision.TOOL
 
         except Exception as ex:
-            logger.exception("%s Failed to determine whether agent is calling a tool: %s",
-                             AGENT_LOG_PREFIX,
-                             ex,
-                             exc_info=True)
+            logger.exception("%s Failed to determine whether agent is calling a tool: %s", AGENT_LOG_PREFIX, ex)
             logger.warning("%s Ending graph traversal", AGENT_LOG_PREFIX)
             return AgentDecision.END
 
@@ -377,8 +363,8 @@ class ReWOOAgentGraph(BaseAgent):
             return self.graph
 
         except Exception as ex:
-            logger.exception("%s Failed to build ReWOO Graph: %s", AGENT_LOG_PREFIX, ex, exc_info=ex)
-            raise ex
+            logger.error("%s Failed to build ReWOO Graph: %s", AGENT_LOG_PREFIX, ex)
+            raise
 
     async def build_graph(self):
         try:
@@ -386,8 +372,8 @@ class ReWOOAgentGraph(BaseAgent):
             logger.debug("%s ReWOO Graph built and compiled successfully", AGENT_LOG_PREFIX)
             return self.graph
         except Exception as ex:
-            logger.exception("%s Failed to build ReWOO Graph: %s", AGENT_LOG_PREFIX, ex, exc_info=ex)
-            raise ex
+            logger.error("%s Failed to build ReWOO Graph: %s", AGENT_LOG_PREFIX, ex)
+            raise
 
     @staticmethod
     def validate_planner_prompt(planner_prompt: str) -> bool:
@@ -403,7 +389,7 @@ class ReWOOAgentGraph(BaseAgent):
                 errors.append(error_message)
         if errors:
             error_text = "\n".join(errors)
-            logger.exception("%s %s", AGENT_LOG_PREFIX, error_text)
+            logger.error("%s %s", AGENT_LOG_PREFIX, error_text)
             raise ValueError(error_text)
         return True
 
@@ -414,6 +400,6 @@ class ReWOOAgentGraph(BaseAgent):
             errors.append("The solver prompt cannot be empty.")
         if errors:
             error_text = "\n".join(errors)
-            logger.exception("%s %s", AGENT_LOG_PREFIX, error_text)
+            logger.error("%s %s", AGENT_LOG_PREFIX, error_text)
             raise ValueError(error_text)
         return True

nat/agent/rewoo_agent/register.py

@@ -89,7 +89,7 @@ async def rewoo_agent_workflow(config: ReWOOAgentWorkflowConfig, builder: Builde
     if config.additional_planner_instructions:
         planner_system_prompt += f"{config.additional_planner_instructions}"
     if not ReWOOAgentGraph.validate_planner_prompt(planner_system_prompt):
-        logger.exception("Invalid planner prompt")
+        logger.error("Invalid planner prompt")
         raise ValueError("Invalid planner prompt")
     planner_prompt = ChatPromptTemplate([("system", planner_system_prompt), ("user", PLANNER_USER_PROMPT)])
 
@@ -97,7 +97,7 @@ async def rewoo_agent_workflow(config: ReWOOAgentWorkflowConfig, builder: Builde
     if config.additional_solver_instructions:
         solver_system_prompt += f"{config.additional_solver_instructions}"
     if not ReWOOAgentGraph.validate_solver_prompt(solver_system_prompt):
-        logger.exception("Invalid solver prompt")
+        logger.error("Invalid solver prompt")
         raise ValueError("Invalid solver prompt")
     solver_prompt = ChatPromptTemplate([("system", solver_system_prompt), ("user", SOLVER_USER_PROMPT)])
 
@@ -141,7 +141,7 @@ async def rewoo_agent_workflow(config: ReWOOAgentWorkflowConfig, builder: Builde
             return ChatResponse.from_string(output_message)
 
         except Exception as ex:
-            logger.exception("ReWOO Agent failed with exception: %s", ex, exc_info=ex)
+            logger.exception("ReWOO Agent failed with exception: %s", ex)
             # here, we can implement custom error messages
             if config.verbose:
                 return ChatResponse.from_string(str(ex))

nat/agent/tool_calling_agent/agent.py

@@ -69,8 +69,8 @@ class ToolCallAgentGraph(DualNodeAgent):
             # in tool calling agents, we bind the tools to the LLM, to pass the tools' input schemas at runtime
             self.bound_llm = llm.bind_tools(tools)
         except NotImplementedError as ex:
-            logger.error("%s Failed to bind tools: %s", AGENT_LOG_PREFIX, ex, exc_info=True)
-            raise ex
+            logger.error("%s Failed to bind tools: %s", AGENT_LOG_PREFIX, ex)
+            raise
 
         if prompt is not None:
             system_prompt = SystemMessage(content=prompt)
@@ -105,8 +105,8 @@ class ToolCallAgentGraph(DualNodeAgent):
             state.messages += [response]
             return state
         except Exception as ex:
-            logger.exception("%s Failed to call agent_node: %s", AGENT_LOG_PREFIX, ex, exc_info=True)
-            raise ex
+            logger.error("%s Failed to call agent_node: %s", AGENT_LOG_PREFIX, ex)
+            raise
 
     async def conditional_edge(self, state: ToolCallAgentGraphState):
         try:
@@ -120,12 +120,7 @@ class ToolCallAgentGraph(DualNodeAgent):
                 logger.debug("%s Final answer:\n%s", AGENT_LOG_PREFIX, state.messages[-1].content)
             return AgentDecision.END
         except Exception as ex:
-            logger.exception(
-                "%s Failed to determine whether agent is calling a tool: %s",
-                AGENT_LOG_PREFIX,
-                ex,
-                exc_info=True,
-            )
+            logger.exception("%s Failed to determine whether agent is calling a tool: %s", AGENT_LOG_PREFIX, ex)
             logger.warning("%s Ending graph traversal", AGENT_LOG_PREFIX)
             return AgentDecision.END
 
@@ -148,8 +143,8 @@ class ToolCallAgentGraph(DualNodeAgent):
 
             return state
         except Exception as ex:
-            logger.exception("%s Failed to call tool_node: %s", AGENT_LOG_PREFIX, ex, exc_info=ex)
-            raise ex
+            logger.error("%s Failed to call tool_node: %s", AGENT_LOG_PREFIX, ex)
+            raise
 
     async def build_graph(self):
         try:
@@ -160,13 +155,8 @@ class ToolCallAgentGraph(DualNodeAgent):
             )
             return self.graph
         except Exception as ex:
-            logger.exception(
-                "%s Failed to build Tool Calling Agent Graph: %s",
-                AGENT_LOG_PREFIX,
-                ex,
-                exc_info=ex,
-            )
-            raise ex
+            logger.error("%s Failed to build Tool Calling Agent Graph: %s", AGENT_LOG_PREFIX, ex)
+            raise
 
 
 def create_tool_calling_agent_prompt(config: "ToolCallAgentWorkflowConfig") -> str | None:

nat/agent/tool_calling_agent/register.py

@@ -93,7 +93,7 @@ async def tool_calling_agent_workflow(config: ToolCallAgentWorkflowConfig, build
             output_message = state.messages[-1]
             return output_message.content
         except Exception as ex:
-            logger.exception("%s Tool Calling Agent failed with exception: %s", AGENT_LOG_PREFIX, ex, exc_info=ex)
+            logger.exception("%s Tool Calling Agent failed with exception: %s", AGENT_LOG_PREFIX, ex)
             if config.verbose:
                 return str(ex)
             return "I seem to be having a problem."
@@ -101,6 +101,6 @@ async def tool_calling_agent_workflow(config: ToolCallAgentWorkflowConfig, build
     try:
         yield FunctionInfo.from_fn(_response_fn, description=config.description)
     except GeneratorExit:
-        logger.exception("%s Workflow exited early!", AGENT_LOG_PREFIX, exc_info=True)
+        logger.exception("%s Workflow exited early!", AGENT_LOG_PREFIX)
     finally:
         logger.debug("%s Cleaning up react_agent workflow.", AGENT_LOG_PREFIX)

nat/builder/eval_builder.py

@@ -61,7 +61,7 @@ class WorkflowEvalBuilder(WorkflowBuilder, EvalBuilder):
             # Store the evaluator
             self._evaluators[name] = ConfiguredEvaluator(config=config, instance=info_obj)
         except Exception as e:
-            logger.error("Error %s adding evaluator `%s` with config `%s`", e, name, config, exc_info=True)
+            logger.error("Error %s adding evaluator `%s` with config `%s`", e, name, config)
             raise
 
     @override
@@ -98,7 +98,7 @@ class WorkflowEvalBuilder(WorkflowBuilder, EvalBuilder):
             try:
                 tools.append(tool_wrapper_reg.build_fn(fn_name, fn, self))
             except Exception:
-                logger.exception("Error fetching tool `%s`", fn_name, exc_info=True)
+                logger.exception("Error fetching tool `%s`", fn_name)
 
         return tools
 

nat/builder/function.py

@@ -155,8 +155,8 @@ class Function(FunctionBase[InputT, StreamingOutputT, SingleOutputT], ABC):
 
                 return result
             except Exception as e:
-                logger.error("Error with ainvoke in function with input: %s.", value, exc_info=True)
-                raise e
+                logger.error("Error with ainvoke in function with input: %s. Error: %s", value, e)
+                raise
 
     @typing.final
     async def acall_invoke(self, *args, **kwargs):
@@ -186,14 +186,14 @@ class Function(FunctionBase[InputT, StreamingOutputT, SingleOutputT], ABC):
             input_obj = self.input_schema(*args, **kwargs)
 
             return await self.ainvoke(value=input_obj)
-        except Exception as e:
+        except Exception:
             logger.error(
                 "Error in acall_invoke() converting input to function schema. Both args and kwargs were "
                 "supplied which could not be converted to the input schema. args: %s\nkwargs: %s\nschema: %s",
                 args,
                 kwargs,
                 self.input_schema)
-            raise e
+            raise
 
     @abstractmethod
     async def _astream(self, value: InputT) -> AsyncGenerator[StreamingOutputT]:
@@ -252,8 +252,8 @@ class Function(FunctionBase[InputT, StreamingOutputT, SingleOutputT], ABC):
                 manager.set_output(final_output)
 
             except Exception as e:
-                logger.error("Error with astream in function with input: %s.", value, exc_info=True)
-                raise e
+                logger.error("Error with astream in function with input: %s. Error: %s", value, e)
+                raise
 
     @typing.final
     async def acall_stream(self, *args, **kwargs):
@@ -287,14 +287,14 @@ class Function(FunctionBase[InputT, StreamingOutputT, SingleOutputT], ABC):
 
                 async for x in self.astream(value=input_obj):
                     yield x
-            except Exception as e:
+            except Exception:
                 logger.error(
                     "Error in acall_stream() converting input to function schema. Both args and kwargs were "
                     "supplied which could not be converted to the input schema. args: %s\nkwargs: %s\nschema: %s",
                     args,
                     kwargs,
                     self.input_schema)
-                raise e
+                raise
 
 
 class LambdaFunction(Function[InputT, StreamingOutputT, SingleOutputT]):

nat/builder/workflow.py

@@ -84,7 +84,11 @@ class Workflow(FunctionBase[InputT, StreamingOutputT, SingleOutputT]):
         return self._entry_fn.has_single_output
 
     async def get_all_exporters(self) -> dict[str, BaseExporter]:
-        return await self._exporter_manager.get_all_exporters()
+        return await self.exporter_manager.get_all_exporters()
+
+    @property
+    def exporter_manager(self) -> ExporterManager:
+        return self._exporter_manager.get()
 
     @asynccontextmanager
     async def run(self, message: InputT):
@@ -96,7 +100,7 @@ class Workflow(FunctionBase[InputT, StreamingOutputT, SingleOutputT]):
         async with Runner(input_message=message,
                           entry_fn=self._entry_fn,
                           context_state=self._context_state,
-                          exporter_manager=self._exporter_manager.get()) as runner:
+                          exporter_manager=self.exporter_manager) as runner:
 
             # The caller can `yield runner` so they can do `runner.result()` or `runner.result_stream()`
             yield runner

nat/builder/workflow_builder.py

@@ -420,8 +420,8 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
             # Wrap in the correct wrapper
             return tool_wrapper_reg.build_fn(fn_name, fn.instance, self)
         except Exception as e:
-            logger.error("Error fetching tool `%s`", fn_name, exc_info=True)
-            raise e
+            logger.error("Error fetching tool `%s`: %s", fn_name, e)
+            raise
 
     @override
     async def add_llm(self, name: str | LLMRef, config: LLMBaseConfig):
@@ -436,8 +436,8 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
 
             self._llms[name] = ConfiguredLLM(config=config, instance=info_obj)
         except Exception as e:
-            logger.error("Error adding llm `%s` with config `%s`", name, config, exc_info=True)
-            raise e
+            logger.error("Error adding llm `%s` with config `%s`: %s", name, config, e)
+            raise
 
     @override
     async def get_llm(self, llm_name: str | LLMRef, wrapper_type: LLMFrameworkEnum | str):
@@ -457,8 +457,8 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
             # Return a frameworks specific client
             return client
         except Exception as e:
-            logger.error("Error getting llm `%s` with wrapper `%s`", llm_name, wrapper_type, exc_info=True)
-            raise e
+            logger.error("Error getting llm `%s` with wrapper `%s`: %s", llm_name, wrapper_type, e)
+            raise
 
     @override
     def get_llm_config(self, llm_name: str | LLMRef) -> LLMBaseConfig:
@@ -508,8 +508,8 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
 
             return info_obj
         except Exception as e:
-            logger.error("Error adding authentication `%s` with config `%s`", name, config, exc_info=True)
-            raise e
+            logger.error("Error adding authentication `%s` with config `%s`: %s", name, config, e)
+            raise
 
     @override
     async def get_auth_provider(self, auth_provider_name: str) -> AuthProviderBase:
@@ -552,9 +552,8 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
 
             self._embedders[name] = ConfiguredEmbedder(config=config, instance=info_obj)
         except Exception as e:
-            logger.error("Error adding embedder `%s` with config `%s`", name, config, exc_info=True)
-
-            raise e
+            logger.error("Error adding embedder `%s` with config `%s`: %s", name, config, e)
+            raise
 
     @override
     async def get_embedder(self, embedder_name: str | EmbedderRef, wrapper_type: LLMFrameworkEnum | str):
@@ -574,8 +573,8 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
             # Return a frameworks specific client
             return client
         except Exception as e:
-            logger.error("Error getting embedder `%s` with wrapper `%s`", embedder_name, wrapper_type, exc_info=True)
-            raise e
+            logger.error("Error getting embedder `%s` with wrapper `%s`: %s", embedder_name, wrapper_type, e)
+            raise
 
     @override
     def get_embedder_config(self, embedder_name: str | EmbedderRef) -> EmbedderBaseConfig:
@@ -660,9 +659,8 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
             self._retrievers[name] = ConfiguredRetriever(config=config, instance=info_obj)
 
         except Exception as e:
-            logger.error("Error adding retriever `%s` with config `%s`", name, config, exc_info=True)
-
-            raise e
+            logger.error("Error adding retriever `%s` with config `%s`: %s", name, config, e)
+            raise
 
         # return info_obj
 
@@ -687,8 +685,8 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
             # Return a frameworks specific client
             return client
         except Exception as e:
-            logger.error("Error getting retriever `%s` with wrapper `%s`", retriever_name, wrapper_type, exc_info=True)
-            raise e
+            logger.error("Error getting retriever `%s` with wrapper `%s`: %s", retriever_name, wrapper_type, e)
+            raise
 
     @override
     async def get_retriever_config(self, retriever_name: str | RetrieverRef) -> RetrieverBaseConfig:
@@ -712,9 +710,8 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
             self._ttc_strategies[name] = ConfiguredTTCStrategy(config=config, instance=info_obj)
 
         except Exception as e:
-            logger.error("Error adding TTC strategy `%s` with config `%s`", name, config, exc_info=True)
-
-            raise e
+            logger.error("Error adding TTC strategy `%s` with config `%s`: %s", name, config, e)
+            raise
 
     @override
     async def get_ttc_strategy(self,
@@ -742,8 +739,8 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
 
             return instance
         except Exception as e:
-            logger.error("Error getting TTC strategy `%s`", strategy_name, exc_info=True)
-            raise e
+            logger.error("Error getting TTC strategy `%s`: %s", strategy_name, e)
+            raise
 
     @override
     async def get_ttc_strategy_config(self,
@@ -820,7 +817,7 @@ class WorkflowBuilder(Builder, AbstractAsyncContextManager):
         else:
             logger.error("No remaining components to build")
 
-        logger.error("Original error:", exc_info=original_error)
+        logger.error("Original error: %s", original_error, exc_info=True)
 
     def _log_build_failure_component(self,
                                      failing_component: ComponentInstanceData,

nat/cli/cli_utils/config_override.py

@@ -213,7 +213,7 @@ def load_and_override_config(config_file: Path, overrides: tuple[tuple[str, str]
                 yaml.dump(effective_config, default_flow_style=False),
             )
         except Exception as e:
-            logger.exception("Modified configuration failed validation: %s", e, exc_info=True)
+            logger.error("Modified configuration failed validation: %s", e)
             raise click.BadParameter(f"Modified configuration failed validation: {str(e)}")
         finally:
             # Clean up the temporary file

nat/cli/commands/info/list_channels.py

@@ -29,4 +29,4 @@ def list_channels(channel_type: str):
     try:
         settings.print_channel_settings(channel_type=channel_type)
     except Exception as e:
-        logger.exception("Error listing channels: %s", e, exc_info=True)
+        logger.exception("Error listing channels: %s", e)