nvidia-nat 1.2.1__py3-none-any.whl → 1.3.0__py3-none-any.whl

aiq/__init__.py

@@ -13,10 +13,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import sys
 import importlib
 import importlib.abc
 import importlib.util
+import sys
 import warnings
 
 
@@ -26,7 +26,7 @@ class CompatFinder(importlib.abc.MetaPathFinder):
         self.alias_prefix = alias_prefix
         self.target_prefix = target_prefix
 
-    def find_spec(self, fullname, path, target=None):  # pylint: disable=unused-argument
+    def find_spec(self, fullname, path, target=None):
         if fullname == self.alias_prefix or fullname.startswith(self.alias_prefix + "."):
             # Map aiq.something -> nat.something
             target_name = self.target_prefix + fullname[len(self.alias_prefix):]

nat/agent/base.py

@@ -27,9 +27,10 @@ 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.graph import CompiledGraph
+from langgraph.graph.state import CompiledStateGraph
 
 logger = logging.getLogger(__name__)
 
@@ -70,12 +71,14 @@ class BaseAgent(ABC):
                  llm: BaseChatModel,
                  tools: list[BaseTool],
                  callbacks: list[AsyncCallbackHandler] | None = None,
-                 detailed_logs: bool = False) -> None:
+                 detailed_logs: bool = False,
+                 log_response_max_chars: int = 1000) -> None:
         logger.debug("Initializing Agent Graph")
         self.llm = llm
         self.tools = tools
         self.callbacks = callbacks or []
         self.detailed_logs = detailed_logs
+        self.log_response_max_chars = log_response_max_chars
         self.graph = None
 
     async def _stream_llm(self,
@@ -99,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,
@@ -158,6 +165,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:
@@ -179,13 +191,12 @@ class BaseAgent(ABC):
                 logger.debug("%s Retrying tool call for %s in %d seconds...", AGENT_LOG_PREFIX, tool.name, sleep_time)
                 await asyncio.sleep(sleep_time)
 
-        # pylint: disable=C0209
         # 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)
+        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")
 
-    def _log_tool_response(self, tool_name: str, tool_input: Any, tool_response: str, max_chars: int = 1000) -> None:
+    def _log_tool_response(self, tool_name: str, tool_input: Any, tool_response: str) -> None:
         """
         Log tool response with consistent formatting and length limits.
 
@@ -197,13 +208,11 @@ class BaseAgent(ABC):
             The input that was passed to the tool
         tool_response : str
             The response from the tool
-        max_chars : int
-            Maximum number of characters to log (default: 1000)
         """
         if self.detailed_logs:
             # Truncate tool response if too long
-            display_response = tool_response[:max_chars] + "...(rest of response truncated)" if len(
-                tool_response) > max_chars else tool_response
+            display_response = tool_response[:self.log_response_max_chars] + "...(rest of response truncated)" if len(
+                tool_response) > self.log_response_max_chars else tool_response
 
             # Format the tool input for display
             tool_input_str = str(tool_input)
@@ -252,5 +261,5 @@ class BaseAgent(ABC):
         return "\n".join([f"{message.type}: {message.content}" for message in messages[:-1]])
 
     @abstractmethod
-    async def _build_graph(self, state_schema: type) -> CompiledGraph:
+    async def _build_graph(self, state_schema: type) -> CompiledStateGraph:
         pass

nat/agent/dual_node.py

@@ -20,7 +20,7 @@ from langchain_core.callbacks import AsyncCallbackHandler
 from langchain_core.language_models import BaseChatModel
 from langchain_core.tools import BaseTool
 from langgraph.graph import StateGraph
-from langgraph.graph.graph import CompiledGraph
+from langgraph.graph.state import CompiledStateGraph
 from pydantic import BaseModel
 
 from .base import AgentDecision
@@ -35,8 +35,13 @@ class DualNodeAgent(BaseAgent):
                  llm: BaseChatModel,
                  tools: list[BaseTool],
                  callbacks: list[AsyncCallbackHandler] | None = None,
-                 detailed_logs: bool = False):
-        super().__init__(llm=llm, tools=tools, callbacks=callbacks, detailed_logs=detailed_logs)
+                 detailed_logs: bool = False,
+                 log_response_max_chars: int = 1000):
+        super().__init__(llm=llm,
+                         tools=tools,
+                         callbacks=callbacks,
+                         detailed_logs=detailed_logs,
+                         log_response_max_chars=log_response_max_chars)
 
     @abstractmethod
     async def agent_node(self, state: BaseModel) -> BaseModel:
@@ -50,7 +55,7 @@ class DualNodeAgent(BaseAgent):
     async def conditional_edge(self, state: BaseModel) -> str:
         pass
 
-    async def _build_graph(self, state_schema) -> CompiledGraph:
+    async def _build_graph(self, state_schema: type) -> CompiledStateGraph:
         log.debug("Building and compiling the Agent Graph")
 
         graph = StateGraph(state_schema)

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

@@ -14,21 +14,23 @@
 # limitations under the License.
 
 import json
-# pylint: disable=R0917
 import logging
+import re
+import typing
 from json import JSONDecodeError
-from typing import TYPE_CHECKING
 
 from langchain_core.agents import AgentAction
 from langchain_core.agents import AgentFinish
 from langchain_core.callbacks.base import AsyncCallbackHandler
 from langchain_core.language_models import BaseChatModel
+from langchain_core.language_models import LanguageModelInput
 from langchain_core.messages.ai import AIMessage
 from langchain_core.messages.base import BaseMessage
 from langchain_core.messages.human import HumanMessage
 from langchain_core.messages.tool import ToolMessage
 from langchain_core.prompts import ChatPromptTemplate
 from langchain_core.prompts import MessagesPlaceholder
+from langchain_core.runnables import Runnable
 from langchain_core.runnables.config import RunnableConfig
 from langchain_core.tools import BaseTool
 from pydantic import BaseModel
@@ -46,8 +48,7 @@ from nat.agent.react_agent.output_parser import ReActOutputParserException
 from nat.agent.react_agent.prompt import SYSTEM_PROMPT
 from nat.agent.react_agent.prompt import USER_PROMPT
 
-# To avoid circular imports
-if TYPE_CHECKING:
+if typing.TYPE_CHECKING:
     from nat.agent.react_agent.register import ReActAgentWorkflowConfig
 
 logger = logging.getLogger(__name__)
@@ -58,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):
@@ -72,15 +74,22 @@ class ReActAgentGraph(DualNodeAgent):
                  use_tool_schema: bool = True,
                  callbacks: list[AsyncCallbackHandler] | None = None,
                  detailed_logs: bool = False,
+                 log_response_max_chars: int = 1000,
                  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):
-        super().__init__(llm=llm, tools=tools, callbacks=callbacks, detailed_logs=detailed_logs)
+                 pass_tool_call_errors_to_agent: bool = True,
+                 normalize_tool_input_quotes: bool = True):
+        super().__init__(llm=llm,
+                         tools=tools,
+                         callbacks=callbacks,
+                         detailed_logs=detailed_logs,
+                         log_response_max_chars=log_response_max_chars)
         self.parse_agent_response_max_retries = (parse_agent_response_max_retries
                                                  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)
@@ -98,21 +107,33 @@ class ReActAgentGraph(DualNodeAgent):
                          f"{INPUT_SCHEMA_MESSAGE.format(schema=tools[-1].input_schema.model_fields)}")
         prompt = prompt.partial(tools=tool_names_and_descriptions, tool_names=tool_names)
         # construct the ReAct Agent
-        bound_llm = llm.bind(stop=["Observation:"])  # type: ignore
-        self.agent = prompt | bound_llm
+        self.agent = prompt | self._maybe_bind_llm_and_yield()
         self.tools_dict = {tool.name: tool for tool in tools}
         logger.debug("%s Initialized ReAct Agent Graph", AGENT_LOG_PREFIX)
 
+    def _maybe_bind_llm_and_yield(self) -> Runnable[LanguageModelInput, BaseMessage]:
+        """
+        Bind additional parameters to the LLM if needed
+        - if the LLM is a smart model, no need to bind any additional parameters
+        - if the LLM is a non-smart model, bind a stop sequence to the LLM
+
+        Returns:
+            Runnable[LanguageModelInput, BaseMessage]: The LLM with any additional parameters bound.
+        """
+        # models that don't need (or don't support)a stop sequence
+        smart_models = re.compile(r"gpt-?5", re.IGNORECASE)
+        if any(smart_models.search(getattr(self.llm, model, "")) for model in ["model", "model_name"]):
+            # no need to bind any additional parameters to the LLM
+            return self.llm
+        # add a stop sequence to the LLM
+        return self.llm.bind(stop=["Observation:"])
+
     def _get_tool(self, tool_name: str):
         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:
@@ -184,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
@@ -216,16 +238,15 @@ 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:
             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]
@@ -235,7 +256,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
 
@@ -268,35 +289,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":
@@ -312,8 +343,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:
@@ -329,8 +360,8 @@ class ReActAgentGraph(DualNodeAgent):
                 errors.append(error_message)
         if errors:
             error_text = "\n".join(errors)
-            logger.exception("%s %s", AGENT_LOG_PREFIX, error_text)
-            raise ValueError(error_text)
+            logger.error("%s %s", AGENT_LOG_PREFIX, error_text)
+            return False
         return True
 
 
@@ -356,7 +387,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)])