update agents to use tool call messages

libs/core/langchain_core/load/mapping.py

@@ -126,12 +126,12 @@
         "agents",
         "AgentActionMessageLog",
     ),
-    ("langchain", "schema", "agent", "OpenAIToolAgentAction"): (
+    ("langchain", "schema", "agent", "ToolAgentAction"): (
         "langchain",
         "agents",
         "output_parsers",
-        "openai_tools",
-        "OpenAIToolAgentAction",
+        "tools",
+        "ToolAgentAction",
     ),
     ("langchain", "prompts", "chat", "BaseMessagePromptTemplate"): (
         "langchain_core",
@@ -528,6 +528,13 @@
         "image",
         "ImagePromptTemplate",
     ),
+    ("langchain", "schema", "agent", "OpenAIToolAgentAction"): (
+        "langchain",
+        "agents",
+        "output_parsers",
+        "openai_tools",
+        "OpenAIToolAgentAction",
+    ),
 }
 
 # Needed for backwards compatibility for a few versions where we serialized

libs/langchain/langchain/agents/__init__.py

@@ -83,6 +83,7 @@
     create_structured_chat_agent,
 )
 from langchain.agents.tools import Tool, tool
+from langchain.agents.tools_agent.base import create_tools_agent
 from langchain.agents.xml.base import XMLAgent, create_xml_agent
 
 DEPRECATED_CODE = [
@@ -154,4 +155,5 @@ def __getattr__(name: str) -> Any:
     "create_self_ask_with_search_agent",
     "create_json_chat_agent",
     "create_structured_chat_agent",
+    "create_tools_agent",
 ]

libs/langchain/langchain/agents/format_scratchpad/__init__.py

@@ -11,12 +11,14 @@
     format_to_openai_function_messages,
     format_to_openai_functions,
 )
+from langchain.agents.format_scratchpad.tools import format_to_tool_messages
 from langchain.agents.format_scratchpad.xml import format_xml
 
 __all__ = [
     "format_xml",
     "format_to_openai_function_messages",
     "format_to_openai_functions",
+    "format_to_tool_messages",
     "format_log_to_str",
     "format_log_to_messages",
 ]

libs/langchain/langchain/agents/format_scratchpad/openai_tools.py

@@ -1,59 +1,5 @@
-import json
-from typing import List, Sequence, Tuple
-
-from langchain_core.agents import AgentAction
-from langchain_core.messages import (
-    AIMessage,
-    BaseMessage,
-    ToolMessage,
+from langchain.agents.format_scratchpad.tools import (
+    format_to_tool_messages as format_to_openai_tool_messages,
 )
 
-from langchain.agents.output_parsers.openai_tools import OpenAIToolAgentAction
-
-
-def _create_tool_message(
-    agent_action: OpenAIToolAgentAction, observation: str
-) -> ToolMessage:
-    """Convert agent action and observation into a function message.
-    Args:
-        agent_action: the tool invocation request from the agent
-        observation: the result of the tool invocation
-    Returns:
-        FunctionMessage that corresponds to the original tool invocation
-    """
-    if not isinstance(observation, str):
-        try:
-            content = json.dumps(observation, ensure_ascii=False)
-        except Exception:
-            content = str(observation)
-    else:
-        content = observation
-    return ToolMessage(
-        tool_call_id=agent_action.tool_call_id,
-        content=content,
-        additional_kwargs={"name": agent_action.tool},
-    )
-
-
-def format_to_openai_tool_messages(
-    intermediate_steps: Sequence[Tuple[AgentAction, str]],
-) -> List[BaseMessage]:
-    """Convert (AgentAction, tool output) tuples into FunctionMessages.
-
-    Args:
-        intermediate_steps: Steps the LLM has taken to date, along with observations
-
-    Returns:
-        list of messages to send to the LLM for the next prediction
-
-    """
-    messages = []
-    for agent_action, observation in intermediate_steps:
-        if isinstance(agent_action, OpenAIToolAgentAction):
-            new_messages = list(agent_action.message_log) + [
-                _create_tool_message(agent_action, observation)
-            ]
-            messages.extend([new for new in new_messages if new not in messages])
-        else:
-            messages.append(AIMessage(content=agent_action.log))
-    return messages
+__all__ = ["format_to_openai_tool_messages"]

libs/langchain/langchain/agents/format_scratchpad/tools.py

@@ -0,0 +1,59 @@
+import json
+from typing import List, Sequence, Tuple
+
+from langchain_core.agents import AgentAction
+from langchain_core.messages import (
+    AIMessage,
+    BaseMessage,
+    ToolMessage,
+)
+
+from langchain.agents.output_parsers.tools import ToolAgentAction
+
+
+def _create_tool_message(
+    agent_action: ToolAgentAction, observation: str
+) -> ToolMessage:
+    """Convert agent action and observation into a function message.
+    Args:
+        agent_action: the tool invocation request from the agent
+        observation: the result of the tool invocation
+    Returns:
+        FunctionMessage that corresponds to the original tool invocation
+    """
+    if not isinstance(observation, str):
+        try:
+            content = json.dumps(observation, ensure_ascii=False)
+        except Exception:
+            content = str(observation)
+    else:
+        content = observation
+    return ToolMessage(
+        tool_call_id=agent_action.tool_call_id,
+        content=content,
+        additional_kwargs={"name": agent_action.tool},
+    )
+
+
+def format_to_tool_messages(
+    intermediate_steps: Sequence[Tuple[AgentAction, str]],
+) -> List[BaseMessage]:
+    """Convert (AgentAction, tool output) tuples into FunctionMessages.
+
+    Args:
+        intermediate_steps: Steps the LLM has taken to date, along with observations
+
+    Returns:
+        list of messages to send to the LLM for the next prediction
+
+    """
+    messages = []
+    for agent_action, observation in intermediate_steps:
+        if isinstance(agent_action, ToolAgentAction):
+            new_messages = list(agent_action.message_log) + [
+                _create_tool_message(agent_action, observation)
+            ]
+            messages.extend([new for new in new_messages if new not in messages])
+        else:
+            messages.append(AIMessage(content=agent_action.log))
+    return messages

libs/langchain/langchain/agents/output_parsers/__init__.py

@@ -20,11 +20,13 @@
     ReActSingleInputOutputParser,
 )
 from langchain.agents.output_parsers.self_ask import SelfAskOutputParser
+from langchain.agents.output_parsers.tools import ToolsAgentOutputParser
 from langchain.agents.output_parsers.xml import XMLAgentOutputParser
 
 __all__ = [
     "ReActSingleInputOutputParser",
     "SelfAskOutputParser",
+    "ToolsAgentOutputParser",
     "ReActJsonSingleInputOutputParser",
     "OpenAIFunctionsAgentOutputParser",
     "XMLAgentOutputParser",

libs/langchain/langchain/agents/output_parsers/openai_tools.py

@@ -1,70 +1,40 @@
-import json
-from json import JSONDecodeError
 from typing import List, Union
 
-from langchain_core.agents import AgentAction, AgentActionMessageLog, AgentFinish
-from langchain_core.exceptions import OutputParserException
-from langchain_core.messages import (
-    AIMessage,
-    BaseMessage,
-)
+from langchain_core.agents import AgentAction, AgentFinish
+from langchain_core.messages import BaseMessage
 from langchain_core.outputs import ChatGeneration, Generation
 
 from langchain.agents.agent import MultiActionAgentOutputParser
+from langchain.agents.output_parsers.tools import (
+    ToolAgentAction,
+    parse_ai_message_to_tool_action,
+)
 
-
-class OpenAIToolAgentAction(AgentActionMessageLog):
-    tool_call_id: str
-    """Tool call that this message is responding to."""
+OpenAIToolAgentAction = ToolAgentAction
 
 
 def parse_ai_message_to_openai_tool_action(
     message: BaseMessage,
 ) -> Union[List[AgentAction], AgentFinish]:
     """Parse an AI message potentially containing tool_calls."""
-    if not isinstance(message, AIMessage):
-        raise TypeError(f"Expected an AI message got {type(message)}")
-
-    if not message.additional_kwargs.get("tool_calls"):
-        return AgentFinish(
-            return_values={"output": message.content}, log=str(message.content)
-        )
-
-    actions: List = []
-    for tool_call in message.additional_kwargs["tool_calls"]:
-        function = tool_call["function"]
-        function_name = function["name"]
-        try:
-            _tool_input = json.loads(function["arguments"] or "{}")
-        except JSONDecodeError:
-            raise OutputParserException(
-                f"Could not parse tool input: {function} because "
-                f"the `arguments` is not valid JSON."
+    tool_actions = parse_ai_message_to_tool_action(message)
+    if isinstance(tool_actions, AgentFinish):
+        return tool_actions
+    final_actions: List[AgentAction] = []
+    for action in tool_actions:
+        if isinstance(action, ToolAgentAction):
+            final_actions.append(
+                OpenAIToolAgentAction(
+                    tool=action.tool,
+                    tool_input=action.tool_input,
+                    log=action.log,
+                    message_log=action.message_log,
+                    tool_call_id=action.tool_call_id,
+                )
             )
-
-        # HACK HACK HACK:
-        # The code that encodes tool input into Open AI uses a special variable
-        # name called `__arg1` to handle old style tools that do not expose a
-        # schema and expect a single string argument as an input.
-        # We unpack the argument here if it exists.
-        # Open AI does not support passing in a JSON array as an argument.
-        if "__arg1" in _tool_input:
-            tool_input = _tool_input["__arg1"]
         else:
-            tool_input = _tool_input
-
-        content_msg = f"responded: {message.content}\n" if message.content else "\n"
-        log = f"\nInvoking: `{function_name}` with `{tool_input}`\n{content_msg}\n"
-        actions.append(
-            OpenAIToolAgentAction(
-                tool=function_name,
-                tool_input=tool_input,
-                log=log,
-                message_log=[message],
-                tool_call_id=tool_call["id"],
-            )
-        )
-    return actions
+            final_actions.append(action)
+    return final_actions
 
 
 class OpenAIToolsAgentOutputParser(MultiActionAgentOutputParser):

libs/langchain/langchain/agents/output_parsers/tools.py

@@ -0,0 +1,102 @@
+import json
+from json import JSONDecodeError
+from typing import List, Union
+
+from langchain_core.agents import AgentAction, AgentActionMessageLog, AgentFinish
+from langchain_core.exceptions import OutputParserException
+from langchain_core.messages import (
+    AIMessage,
+    BaseMessage,
+    ToolCall,
+)
+from langchain_core.outputs import ChatGeneration, Generation
+
+from langchain.agents.agent import MultiActionAgentOutputParser
+
+
+class ToolAgentAction(AgentActionMessageLog):
+    tool_call_id: str
+    """Tool call that this message is responding to."""
+
+
+def parse_ai_message_to_tool_action(
+    message: BaseMessage,
+) -> Union[List[AgentAction], AgentFinish]:
+    """Parse an AI message potentially containing tool_calls."""
+    if not isinstance(message, AIMessage):
+        raise TypeError(f"Expected an AI message got {type(message)}")
+
+    actions: List = []
+    if message.tool_calls:
+        tool_calls = message.tool_calls
+    else:
+        if not message.additional_kwargs.get("tool_calls"):
+            return AgentFinish(
+                return_values={"output": message.content}, log=str(message.content)
+            )
+        # Best-effort parsing
+        tool_calls = []
+        for tool_call in message.additional_kwargs["tool_calls"]:
+            function = tool_call["function"]
+            function_name = function["name"]
+            try:
+                args = json.loads(function["arguments"] or "{}")
+                tool_calls.append(
+                    ToolCall(name=function_name, args=args, id=tool_call["id"])
+                )
+            except JSONDecodeError:
+                raise OutputParserException(
+                    f"Could not parse tool input: {function} because "
+                    f"the `arguments` is not valid JSON."
+                )
+    for tool_call in tool_calls:
+        # HACK HACK HACK:
+        # The code that encodes tool input into Open AI uses a special variable
+        # name called `__arg1` to handle old style tools that do not expose a
+        # schema and expect a single string argument as an input.
+        # We unpack the argument here if it exists.
+        # Open AI does not support passing in a JSON array as an argument.
+        function_name = tool_call["name"]
+        _tool_input = tool_call["args"]
+        if "__arg1" in _tool_input:
+            tool_input = _tool_input["__arg1"]
+        else:
+            tool_input = _tool_input
+
+        content_msg = f"responded: {message.content}\n" if message.content else "\n"
+        log = f"\nInvoking: `{function_name}` with `{tool_input}`\n{content_msg}\n"
+        actions.append(
+            ToolAgentAction(
+                tool=function_name,
+                tool_input=tool_input,
+                log=log,
+                message_log=[message],
+                tool_call_id=tool_call["id"],
+            )
+        )
+    return actions
+
+
+class ToolsAgentOutputParser(MultiActionAgentOutputParser):
+    """Parses a message into agent actions/finish.
+
+    If a tool_calls parameter is passed, then that is used to get
+    the tool names and tool inputs.
+
+    If one is not passed, then the AIMessage is assumed to be the final output.
+    """
+
+    @property
+    def _type(self) -> str:
+        return "tools-agent-output-parser"
+
+    def parse_result(
+        self, result: List[Generation], *, partial: bool = False
+    ) -> Union[List[AgentAction], AgentFinish]:
+        if not isinstance(result[0], ChatGeneration):
+            raise ValueError("This output parser only works on ChatGeneration output")
+        message = result[0].message
+        return parse_ai_message_to_tool_action(message)
+
+    def parse(self, text: str) -> Union[List[AgentAction], AgentFinish]:
+        raise ValueError("Can only parse messages")