aiqtoolkit 1.2.0.dev0__py3-none-any.whl → 1.2.0rc2__py3-none-any.whl

aiq/agent/base.py

@@ -13,25 +13,32 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import asyncio
+import json
 import logging
 from abc import ABC
 from abc import abstractmethod
 from enum import Enum
+from typing import Any
 
 from colorama import Fore
 from langchain_core.callbacks import AsyncCallbackHandler
 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 RunnableConfig
 from langchain_core.tools import BaseTool
 from langgraph.graph.graph import CompiledGraph
 
-log = logging.getLogger(__name__)
+logger = logging.getLogger(__name__)
 
 TOOL_NOT_FOUND_ERROR_MESSAGE = "There is no tool named {tool_name}. Tool must be one of {tools}."
 INPUT_SCHEMA_MESSAGE = ". Arguments must be provided as a valid JSON object following this format: {schema}"
-NO_INPUT_ERROR_MESSAGE = "No human input recieved to the agent, Please ask a valid question."
+NO_INPUT_ERROR_MESSAGE = "No human input received to the agent, Please ask a valid question."
 
 AGENT_LOG_PREFIX = "[AGENT]"
-AGENT_RESPONSE_LOG_MESSAGE = f"\n{'-' * 30}\n" + \
+AGENT_CALL_LOG_MESSAGE = f"\n{'-' * 30}\n" + \
                                  AGENT_LOG_PREFIX + "\n" + \
                                  Fore.YELLOW + \
                                  "Agent input: %s\n" + \
@@ -40,7 +47,7 @@ AGENT_RESPONSE_LOG_MESSAGE = f"\n{'-' * 30}\n" + \
                                  Fore.RESET + \
                                  f"\n{'-' * 30}"
 
-TOOL_RESPONSE_LOG_MESSAGE = f"\n{'-' * 30}\n" + \
+TOOL_CALL_LOG_MESSAGE = f"\n{'-' * 30}\n" + \
                                  AGENT_LOG_PREFIX + "\n" + \
                                  Fore.WHITE + \
                                  "Calling tools: %s\n" + \
@@ -62,15 +69,170 @@ class BaseAgent(ABC):
     def __init__(self,
                  llm: BaseChatModel,
                  tools: list[BaseTool],
-                 callbacks: list[AsyncCallbackHandler] = None,
-                 detailed_logs: bool = False):
-        log.debug("Initializing Agent Graph")
+                 callbacks: list[AsyncCallbackHandler] | None = None,
+                 detailed_logs: bool = False) -> None:
+        logger.debug("Initializing Agent Graph")
         self.llm = llm
         self.tools = tools
         self.callbacks = callbacks or []
         self.detailed_logs = detailed_logs
         self.graph = None
 
+    async def _stream_llm(self,
+                          runnable: Any,
+                          inputs: dict[str, Any],
+                          config: RunnableConfig | None = None) -> AIMessage:
+        """
+        Stream from LLM runnable. Retry logic is handled automatically by the underlying LLM client.
+
+        Parameters
+        ----------
+        runnable : Any
+            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
+        """
+        output_message = ""
+        async for event in runnable.astream(inputs, config=config):
+            output_message += event.content
+
+        return AIMessage(content=output_message)
+
+    async def _call_llm(self, messages: list[BaseMessage]) -> 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
+
+        Returns
+        -------
+        AIMessage
+            The LLM response
+        """
+        response = await self.llm.ainvoke(messages)
+        return AIMessage(content=str(response.content))
+
+    async def _call_tool(self,
+                         tool: BaseTool,
+                         tool_input: dict[str, Any] | str,
+                         config: RunnableConfig | None = None,
+                         max_retries: int = 3) -> ToolMessage:
+        """
+        Call a tool with retry logic and error handling.
+
+        Parameters
+        ----------
+        tool : BaseTool
+            The tool to call
+        tool_input : Union[Dict[str, Any], str]
+            The input to pass to the tool
+        config : RunnableConfig | None
+            The config to pass to the tool
+        max_retries : int
+            Maximum number of retry attempts (default: 3)
+
+        Returns
+        -------
+        ToolMessage
+            The tool response
+        """
+        last_exception = None
+
+        for attempt in range(max_retries + 1):
+            try:
+                response = await tool.ainvoke(tool_input, config=config)
+
+                # Handle empty responses
+                if response is None or (isinstance(response, str) and response == ""):
+                    return ToolMessage(name=tool.name,
+                                       tool_call_id=tool.name,
+                                       content=f"The tool {tool.name} provided an empty response.")
+
+                return ToolMessage(name=tool.name, tool_call_id=tool.name, content=response)
+
+            except Exception as e:
+                last_exception = e
+                logger.warning("%s Tool call attempt %d/%d failed for tool %s: %s",
+                               AGENT_LOG_PREFIX,
+                               attempt + 1,
+                               max_retries + 1,
+                               tool.name,
+                               str(e))
+
+                # If this was the last attempt, don't sleep
+                if attempt == max_retries:
+                    break
+
+                # Exponential backoff: 2^attempt seconds
+                sleep_time = 2**attempt
+                logger.debug("%s Retrying tool call for %s in %d seconds...", AGENT_LOG_PREFIX, tool.name, sleep_time)
+                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)
+        logger.error("%s %s", AGENT_LOG_PREFIX, error_content)
+        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:
+        """
+        Log tool response with consistent formatting and length limits.
+
+        Parameters
+        ----------
+        tool_name : str
+            The name of the tool that was called
+        tool_input : Any
+            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
+
+            # Format the tool input for display
+            tool_input_str = str(tool_input)
+
+            tool_response_log_message = TOOL_CALL_LOG_MESSAGE % (tool_name, tool_input_str, display_response)
+            logger.info(tool_response_log_message)
+
+    def _parse_json(self, json_string: str) -> dict[str, Any]:
+        """
+        Safely parse JSON with graceful error handling.
+        If JSON parsing fails, returns an empty dict or error info.
+
+        Parameters
+        ----------
+        json_string : str
+            The JSON string to parse
+
+        Returns
+        -------
+        Dict[str, Any]
+            The parsed JSON or error information
+        """
+        try:
+            return json.loads(json_string)
+        except json.JSONDecodeError as e:
+            logger.warning("%s JSON parsing failed, returning the original string: %s", AGENT_LOG_PREFIX, str(e))
+            return {"error": f"JSON parsing failed: {str(e)}", "original_string": json_string}
+        except Exception as e:
+            logger.warning("%s Unexpected error during JSON parsing: %s", AGENT_LOG_PREFIX, str(e))
+            return {"error": f"Unexpected parsing error: {str(e)}", "original_string": json_string}
+
     @abstractmethod
-    async def _build_graph(self, state_schema) -> CompiledGraph:
+    async def _build_graph(self, state_schema: type) -> CompiledGraph:
         pass

aiq/agent/dual_node.py

@@ -34,7 +34,7 @@ class DualNodeAgent(BaseAgent):
     def __init__(self,
                  llm: BaseChatModel,
                  tools: list[BaseTool],
-                 callbacks: list[AsyncCallbackHandler] = None,
+                 callbacks: list[AsyncCallbackHandler] | None = None,
                  detailed_logs: bool = False):
         super().__init__(llm=llm, tools=tools, callbacks=callbacks, detailed_logs=detailed_logs)
 

aiq/agent/react_agent/agent.py

@@ -26,22 +26,25 @@ 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.chat import ChatPromptTemplate
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.prompts import MessagesPlaceholder
 from langchain_core.runnables.config import RunnableConfig
 from langchain_core.tools import BaseTool
 from pydantic import BaseModel
 from pydantic import Field
 
+from aiq.agent.base import AGENT_CALL_LOG_MESSAGE
 from aiq.agent.base import AGENT_LOG_PREFIX
-from aiq.agent.base import AGENT_RESPONSE_LOG_MESSAGE
 from aiq.agent.base import INPUT_SCHEMA_MESSAGE
 from aiq.agent.base import NO_INPUT_ERROR_MESSAGE
 from aiq.agent.base import TOOL_NOT_FOUND_ERROR_MESSAGE
-from aiq.agent.base import TOOL_RESPONSE_LOG_MESSAGE
 from aiq.agent.base import AgentDecision
 from aiq.agent.dual_node import DualNodeAgent
 from aiq.agent.react_agent.output_parser import ReActOutputParser
 from aiq.agent.react_agent.output_parser import ReActOutputParserException
+from aiq.agent.react_agent.prompt import SYSTEM_PROMPT
+from aiq.agent.react_agent.prompt import USER_PROMPT
+from aiq.agent.react_agent.register import ReActAgentWorkflowConfig
 
 logger = logging.getLogger(__name__)
 
@@ -63,13 +66,17 @@ class ReActAgentGraph(DualNodeAgent):
                  prompt: ChatPromptTemplate,
                  tools: list[BaseTool],
                  use_tool_schema: bool = True,
-                 callbacks: list[AsyncCallbackHandler] = None,
+                 callbacks: list[AsyncCallbackHandler] | None = None,
                  detailed_logs: bool = False,
-                 retry_parsing_errors: bool = True,
-                 max_retries: int = 1):
+                 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)
-        self.retry_parsing_errors = retry_parsing_errors
-        self.max_tries = (max_retries + 1) if retry_parsing_errors else 1
+        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
         logger.debug(
             "%s Filling the prompt variables 'tools' and 'tool_names', using the tools provided in the config.",
             AGENT_LOG_PREFIX)
@@ -87,12 +94,12 @@ 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
-        llm = llm.bind(stop=["Observation:"])
-        self.agent = prompt | llm
+        bound_llm = llm.bind(stop=["Observation:"])  # type: ignore
+        self.agent = prompt | bound_llm
         self.tools_dict = {tool.name: tool for tool in tools}
         logger.debug("%s Initialized ReAct Agent Graph", AGENT_LOG_PREFIX)
 
-    def _get_tool(self, tool_name):
+    def _get_tool(self, tool_name: str):
         try:
             return self.tools_dict.get(tool_name)
         except Exception as ex:
@@ -109,26 +116,30 @@ class ReActAgentGraph(DualNodeAgent):
             # keeping a working state allows us to resolve parsing errors without polluting the agent scratchpad
             # the agent "forgets" about the parsing error after solving it - prevents hallucinations in next cycles
             working_state = []
-            for attempt in range(1, self.max_tries + 1):
+            # Starting from attempt 1 instead of 0 for logging
+            for attempt in range(1, self.parse_agent_response_max_retries + 1):
                 # the first time we are invoking the ReAct Agent, it won't have any intermediate steps / agent thoughts
                 if len(state.agent_scratchpad) == 0 and len(working_state) == 0:
                     # the user input comes from the "messages" state channel
                     if len(state.messages) == 0:
                         raise RuntimeError('No input received in state: "messages"')
                     # to check is any human input passed or not, if no input passed Agent will return the state
-                    if state.messages[0].content.strip() == "":
+                    content = str(state.messages[0].content)
+                    if content.strip() == "":
                         logger.error("%s No human input passed to the agent.", AGENT_LOG_PREFIX)
                         state.messages += [AIMessage(content=NO_INPUT_ERROR_MESSAGE)]
                         return state
-                    question = state.messages[0].content
+                    question = content
                     logger.debug("%s Querying agent, attempt: %s", AGENT_LOG_PREFIX, attempt)
-                    output_message = ""
-                    async for event in self.agent.astream({"question": question},
-                                                          config=RunnableConfig(callbacks=self.callbacks)):
-                        output_message += event.content
-                    output_message = AIMessage(content=output_message)
+
+                    output_message = await self._stream_llm(
+                        self.agent,
+                        {"question": question},
+                        RunnableConfig(callbacks=self.callbacks)  # type: ignore
+                    )
+
                     if self.detailed_logs:
-                        logger.info(AGENT_RESPONSE_LOG_MESSAGE, question, output_message.content)
+                        logger.info(AGENT_CALL_LOG_MESSAGE, question, output_message.content)
                 else:
                     # ReAct Agents require agentic cycles
                     # in an agentic cycle, preserve the agent's thoughts from the previous cycles,
@@ -137,20 +148,20 @@ class ReActAgentGraph(DualNodeAgent):
                     for index, intermediate_step in enumerate(state.agent_scratchpad):
                         agent_thoughts = AIMessage(content=intermediate_step.log)
                         agent_scratchpad.append(agent_thoughts)
-                        tool_response = HumanMessage(content=state.tool_responses[index].content)
+                        tool_response_content = str(state.tool_responses[index].content)
+                        tool_response = HumanMessage(content=tool_response_content)
                         agent_scratchpad.append(tool_response)
                     agent_scratchpad += working_state
-                    question = state.messages[0].content
+                    question = str(state.messages[0].content)
                     logger.debug("%s Querying agent, attempt: %s", AGENT_LOG_PREFIX, attempt)
-                    output_message = ""
-                    async for event in self.agent.astream({
-                            "question": question, "agent_scratchpad": agent_scratchpad
+
+                    output_message = await self._stream_llm(self.agent, {
+                        "question": question, "agent_scratchpad": agent_scratchpad
                     },
-                                                          config=RunnableConfig(callbacks=self.callbacks)):
-                        output_message += event.content
-                    output_message = AIMessage(content=output_message)
+                                                            RunnableConfig(callbacks=self.callbacks))
+
                     if self.detailed_logs:
-                        logger.info(AGENT_RESPONSE_LOG_MESSAGE, question, output_message.content)
+                        logger.info(AGENT_CALL_LOG_MESSAGE, question, output_message.content)
                         logger.debug("%s The agent's scratchpad (with tool result) was:\n%s",
                                      AGENT_LOG_PREFIX,
                                      agent_scratchpad)
@@ -158,11 +169,7 @@ class ReActAgentGraph(DualNodeAgent):
                     # check if the agent has the final answer yet
                     logger.debug("%s Successfully obtained agent response. Parsing agent's response", AGENT_LOG_PREFIX)
                     agent_output = await ReActOutputParser().aparse(output_message.content)
-                    logger.debug("%s Successfully parsed agent's response", AGENT_LOG_PREFIX)
-                    if attempt > 1:
-                        logger.debug("%s Successfully parsed agent response after %s attempts",
-                                     AGENT_LOG_PREFIX,
-                                     attempt)
+                    logger.debug("%s Successfully parsed agent response after %s attempts", AGENT_LOG_PREFIX, attempt)
                     if isinstance(agent_output, AgentFinish):
                         final_answer = agent_output.return_values.get('output', output_message.content)
                         logger.debug("%s The agent has finished, and has the final answer", AGENT_LOG_PREFIX)
@@ -174,31 +181,33 @@ class ReActAgentGraph(DualNodeAgent):
                         agent_output.log = output_message.content
                         logger.debug("%s The agent wants to call a tool: %s", AGENT_LOG_PREFIX, agent_output.tool)
                         state.agent_scratchpad += [agent_output]
+
                     return state
                 except ReActOutputParserException as ex:
                     # the agent output did not meet the expected ReAct output format. This can happen for a few reasons:
                     # the agent mentioned a tool, but already has the final answer, this can happen with Llama models
                     #   - the ReAct Agent already has the answer, and is reflecting on how it obtained the answer
                     # the agent might have also missed Action or Action Input in its output
-                    logger.warning("%s Error parsing agent output\nObservation:%s\nAgent Output:\n%s",
-                                   AGENT_LOG_PREFIX,
-                                   ex.observation,
-                                   output_message.content)
-                    if attempt == self.max_tries:
-                        logger.exception(
+                    logger.debug("%s Error parsing agent output\nObservation:%s\nAgent Output:\n%s",
+                                 AGENT_LOG_PREFIX,
+                                 ex.observation,
+                                 output_message.content)
+                    if attempt == self.parse_agent_response_max_retries:
+                        logger.error(
                             "%s Failed to parse agent output after %d attempts, consider enabling or "
-                            "increasing max_retries",
+                            "increasing parse_agent_response_max_retries",
                             AGENT_LOG_PREFIX,
                             attempt,
                             exc_info=True)
                         # the final answer goes in the "messages" state channel
-                        output_message.content = ex.observation + '\n' + output_message.content
+                        combined_content = str(ex.observation) + '\n' + str(output_message.content)
+                        output_message.content = combined_content
                         state.messages += [output_message]
                         return state
                     # retry parsing errors, if configured
                     logger.info("%s Retrying ReAct Agent, including output parsing Observation", AGENT_LOG_PREFIX)
                     working_state.append(output_message)
-                    working_state.append(HumanMessage(content=ex.observation))
+                    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
@@ -208,7 +217,8 @@ class ReActAgentGraph(DualNodeAgent):
             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
-                logger.debug("%s Final answer:\n%s", AGENT_LOG_PREFIX, state.messages[-1].content)
+                last_message_content = str(state.messages[-1].content)
+                logger.debug("%s Final answer:\n%s", AGENT_LOG_PREFIX, last_message_content)
                 return AgentDecision.END
             # else the agent wants to call a tool
             agent_output = state.agent_scratchpad[-1]
@@ -223,76 +233,71 @@ class ReActAgentGraph(DualNodeAgent):
             return AgentDecision.END
 
     async def tool_node(self, state: ReActGraphState):
-        try:
-            logger.debug("%s Starting the Tool Call Node", AGENT_LOG_PREFIX)
-            if len(state.agent_scratchpad) == 0:
-                raise RuntimeError('No tool input received in state: "agent_scratchpad"')
-            agent_thoughts = state.agent_scratchpad[-1]
-            # the agent can run any installed tool, simply install the tool and add it to the config file
-            requested_tool = self._get_tool(agent_thoughts.tool)
-            if not requested_tool:
-                configured_tool_names = list(self.tools_dict.keys())
-                logger.warning(
-                    "%s ReAct Agent wants to call tool %s. In the ReAct Agent's configuration within the config file,"
-                    "there is no tool with that name: %s",
-                    AGENT_LOG_PREFIX,
-                    agent_thoughts.tool,
-                    configured_tool_names)
-                tool_response = ToolMessage(name='agent_error',
-                                            tool_call_id='agent_error',
-                                            content=TOOL_NOT_FOUND_ERROR_MESSAGE.format(tool_name=agent_thoughts.tool,
-                                                                                        tools=configured_tool_names))
-                state.tool_responses += [tool_response]
-                return state
-
-            logger.debug("%s Calling tool %s with input: %s",
-                         AGENT_LOG_PREFIX,
-                         requested_tool.name,
-                         agent_thoughts.tool_input)
-
-            # Run the tool. Try to use structured input, if possible.
-            try:
-                tool_input_str = agent_thoughts.tool_input.strip().replace("'", '"')
-                tool_input_dict = 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 requested_tool.ainvoke(tool_input_dict,
-                                                             config=RunnableConfig(callbacks=self.callbacks))
-                if self.detailed_logs:
-                    # The tool response can be very large, so we log only the first 1000 characters
-                    tool_response_str = str(tool_response)
-                    tool_response_str = tool_response_str[:1000] + "..." if len(
-                        tool_response_str) > 1000 else tool_response_str
-                    tool_response_log_message = TOOL_RESPONSE_LOG_MESSAGE % (
-                        requested_tool.name, tool_input_str, tool_response_str)
-                    logger.info(tool_response_log_message)
-            except JSONDecodeError as ex:
-                logger.warning(
-                    "%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 = agent_thoughts.tool_input
-                tool_response = await requested_tool.ainvoke(tool_input_str,
-                                                             config=RunnableConfig(callbacks=self.callbacks))
-
-            # some tools, such as Wikipedia, will return an empty response when no search results are found
-            if tool_response is None or tool_response == "":
-                tool_response = "The tool provided an empty response.\n"
-            # put the tool response in the graph state
-            tool_response = ToolMessage(name=agent_thoughts.tool,
-                                        tool_call_id=agent_thoughts.tool,
-                                        content=tool_response)
-            logger.debug("%s Called tool %s with input: %s\nThe tool returned: %s",
-                         AGENT_LOG_PREFIX,
-                         requested_tool.name,
-                         agent_thoughts.tool_input,
-                         tool_response.content)
+
+        logger.debug("%s Starting the Tool Call Node", AGENT_LOG_PREFIX)
+        if len(state.agent_scratchpad) == 0:
+            raise RuntimeError('No tool input received in state: "agent_scratchpad"')
+        agent_thoughts = state.agent_scratchpad[-1]
+        # the agent can run any installed tool, simply install the tool and add it to the config file
+        requested_tool = self._get_tool(agent_thoughts.tool)
+        if not requested_tool:
+            configured_tool_names = list(self.tools_dict.keys())
+            logger.warning(
+                "%s ReAct Agent wants to call tool %s. In the ReAct Agent's configuration within the config file,"
+                "there is no tool with that name: %s",
+                AGENT_LOG_PREFIX,
+                agent_thoughts.tool,
+                configured_tool_names)
+            tool_response = ToolMessage(name='agent_error',
+                                        tool_call_id='agent_error',
+                                        content=TOOL_NOT_FOUND_ERROR_MESSAGE.format(tool_name=agent_thoughts.tool,
+                                                                                    tools=configured_tool_names))
             state.tool_responses += [tool_response]
             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.debug("%s Calling tool %s with input: %s",
+                     AGENT_LOG_PREFIX,
+                     requested_tool.name,
+                     agent_thoughts.tool_input)
+
+        # Run the tool. Try to use structured input, if possible.
+        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
+            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)
+
+        if self.detailed_logs:
+            self._log_tool_response(requested_tool.name, tool_input_str, str(tool_response.content))
+
+        if not self.pass_tool_call_errors_to_agent:
+            if tool_response.status == "error":
+                logger.error("%s Tool %s failed: %s", AGENT_LOG_PREFIX, requested_tool.name, tool_response.content)
+                raise RuntimeError("Tool call failed: " + str(tool_response.content))
+
+        state.tool_responses += [tool_response]
+        return state
 
     async def build_graph(self):
         try:
@@ -320,3 +325,32 @@ class ReActAgentGraph(DualNodeAgent):
             logger.exception("%s %s", AGENT_LOG_PREFIX, error_text)
             raise ValueError(error_text)
         return True
+
+
+def create_react_agent_prompt(config: ReActAgentWorkflowConfig) -> ChatPromptTemplate:
+    """
+    Create a ReAct Agent prompt from the config.
+
+    Args:
+        config (ReActAgentWorkflowConfig): The config to use for the prompt.
+
+    Returns:
+        ChatPromptTemplate: The ReAct Agent prompt.
+    """
+    # the ReAct Agent prompt can be customized via config option system_prompt and additional_instructions.
+
+    if config.system_prompt:
+        prompt_str = config.system_prompt
+    else:
+        prompt_str = SYSTEM_PROMPT
+
+    if config.additional_instructions:
+        prompt_str += f" {config.additional_instructions}"
+
+    valid_prompt = ReActAgentGraph.validate_system_prompt(prompt_str)
+    if not valid_prompt:
+        logger.exception("%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)])
+    return prompt

aiq/agent/react_agent/prompt.py

@@ -14,8 +14,6 @@
 # limitations under the License.
 
 # flake8: noqa
-from langchain_core.prompts.chat import ChatPromptTemplate
-from langchain_core.prompts.chat import MessagesPlaceholder
 
 SYSTEM_PROMPT = """
 Answer the following questions as best you can. You may ask the human to use the following tools:
@@ -37,10 +35,7 @@ Use the following format once you have the final answer:
 Thought: I now know the final answer
 Final Answer: the final answer to the original input question
 """
+
 USER_PROMPT = """
 Question: {question}
 """
-
-# This is the prompt - (ReAct Agent prompt)
-react_agent_prompt = ChatPromptTemplate([("system", SYSTEM_PROMPT), ("user", USER_PROMPT),
-                                         MessagesPlaceholder(variable_name='agent_scratchpad', optional=True)])