langchain 0.3.26__py3-none-any.whl → 0.4.0.dev0__py3-none-any.whl

langchain/agents/agent_toolkits/sql/prompt.py

@@ -26,4 +26,4 @@ def __getattr__(name: str) -> Any:
     return _import_attribute(name)
 
 
-__all__ = ["SQL_PREFIX", "SQL_SUFFIX", "SQL_FUNCTIONS_SUFFIX"]
+__all__ = ["SQL_FUNCTIONS_SUFFIX", "SQL_PREFIX", "SQL_SUFFIX"]

langchain/agents/agent_toolkits/sql/toolkit.py

@@ -9,7 +9,7 @@ if TYPE_CHECKING:
 # Used to consolidate logic for raising deprecation warnings and
 # handling optional imports.
 DEPRECATED_LOOKUP = {
-    "SQLDatabaseToolkit": "langchain_community.agent_toolkits.sql.toolkit"
+    "SQLDatabaseToolkit": "langchain_community.agent_toolkits.sql.toolkit",
 }
 
 _import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)

langchain/agents/agent_toolkits/vectorstore/base.py

@@ -35,7 +35,7 @@ def create_vectorstore_agent(
     toolkit: VectorStoreToolkit,
     callback_manager: Optional[BaseCallbackManager] = None,
     prefix: str = PREFIX,
-    verbose: bool = False,
+    verbose: bool = False,  # noqa: FBT001,FBT002
     agent_executor_kwargs: Optional[dict[str, Any]] = None,
     **kwargs: Any,
 ) -> AgentExecutor:
@@ -90,6 +90,7 @@ def create_vectorstore_agent(
 
     Returns:
         AgentExecutor: Returns a callable AgentExecutor object. Either you can call it or use run method with the query to get the response
+
     """  # noqa: E501
     tools = toolkit.get_tools()
     prompt = ZeroShotAgent.create_prompt(tools, prefix=prefix)
@@ -128,7 +129,7 @@ def create_vectorstore_router_agent(
     toolkit: VectorStoreRouterToolkit,
     callback_manager: Optional[BaseCallbackManager] = None,
     prefix: str = ROUTER_PREFIX,
-    verbose: bool = False,
+    verbose: bool = False,  # noqa: FBT001,FBT002
     agent_executor_kwargs: Optional[dict[str, Any]] = None,
     **kwargs: Any,
 ) -> AgentExecutor:
@@ -198,6 +199,7 @@ def create_vectorstore_router_agent(
 
     Returns:
         AgentExecutor: Returns a callable AgentExecutor object. Either you can call it or use run method with the query to get the response.
+
     """  # noqa: E501
     tools = toolkit.get_tools()
     prompt = ZeroShotAgent.create_prompt(tools, prefix=prefix)

langchain/agents/agent_toolkits/vectorstore/prompt.py

@@ -1,13 +1,11 @@
-# flake8: noqa
-
 PREFIX = """You are an agent designed to answer questions about sets of documents.
 You have access to tools for interacting with the documents, and the inputs to the tools are questions.
 Sometimes, you will be asked to provide sources for your questions, in which case you should use the appropriate tool to do so.
 If the question does not seem relevant to any of the tools provided, just return "I don't know" as the answer.
-"""
+"""  # noqa: E501
 
 ROUTER_PREFIX = """You are an agent designed to answer questions.
 You have access to tools for interacting with different sources, and the inputs to the tools are questions.
 Your main task is to decide which of the tools is relevant for answering question at hand.
 For complex questions, you can break the question down into sub questions and use tools to answers the sub questions.
-"""
+"""  # noqa: E501

langchain/agents/agent_toolkits/vectorstore/toolkit.py

@@ -36,12 +36,12 @@ class VectorStoreToolkit(BaseToolkit):
                 VectorStoreQATool,
                 VectorStoreQAWithSourcesTool,
             )
-        except ImportError:
-            raise ImportError(
-                "You need to install langchain-community to use this toolkit."
-            )
+        except ImportError as e:
+            msg = "You need to install langchain-community to use this toolkit."
+            raise ImportError(msg) from e
         description = VectorStoreQATool.get_description(
-            self.vectorstore_info.name, self.vectorstore_info.description
+            self.vectorstore_info.name,
+            self.vectorstore_info.description,
         )
         qa_tool = VectorStoreQATool(
             name=self.vectorstore_info.name,
@@ -50,7 +50,8 @@ class VectorStoreToolkit(BaseToolkit):
             llm=self.llm,
         )
         description = VectorStoreQAWithSourcesTool.get_description(
-            self.vectorstore_info.name, self.vectorstore_info.description
+            self.vectorstore_info.name,
+            self.vectorstore_info.description,
         )
         qa_with_sources_tool = VectorStoreQAWithSourcesTool(
             name=f"{self.vectorstore_info.name}_with_sources",
@@ -78,13 +79,13 @@ class VectorStoreRouterToolkit(BaseToolkit):
             from langchain_community.tools.vectorstore.tool import (
                 VectorStoreQATool,
             )
-        except ImportError:
-            raise ImportError(
-                "You need to install langchain-community to use this toolkit."
-            )
+        except ImportError as e:
+            msg = "You need to install langchain-community to use this toolkit."
+            raise ImportError(msg) from e
         for vectorstore_info in self.vectorstores:
             description = VectorStoreQATool.get_description(
-                vectorstore_info.name, vectorstore_info.description
+                vectorstore_info.name,
+                vectorstore_info.description,
             )
             qa_tool = VectorStoreQATool(
                 name=vectorstore_info.name,

langchain/agents/agent_toolkits/xorbits/__init__.py

@@ -14,7 +14,7 @@ def __getattr__(name: str) -> Any:
 
         old_path = "langchain." + here + "." + name
         new_path = "langchain_experimental." + here + "." + name
-        raise ImportError(
+        msg = (
             "This agent has been moved to langchain experiment. "
             "This agent relies on python REPL tool under the hood, so to use it "
             "safely please sandbox the python REPL. "
@@ -23,4 +23,6 @@ def __getattr__(name: str) -> Any:
             "To keep using this code as is, install langchain experimental and "
             f"update your import statement from:\n `{old_path}` to `{new_path}`."
         )
-    raise AttributeError(f"{name} does not exist")
+        raise ImportError(msg)
+    msg = f"{name} does not exist"
+    raise AttributeError(msg)

langchain/agents/agent_toolkits/zapier/toolkit.py

@@ -9,7 +9,7 @@ if TYPE_CHECKING:
 # Used to consolidate logic for raising deprecation warnings and
 # handling optional imports.
 DEPRECATED_LOOKUP = {
-    "ZapierToolkit": "langchain_community.agent_toolkits.zapier.toolkit"
+    "ZapierToolkit": "langchain_community.agent_toolkits.zapier.toolkit",
 }
 
 _import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)

langchain/agents/agent_types.py

@@ -23,22 +23,22 @@ class AgentType(str, Enum):
 
     REACT_DOCSTORE = "react-docstore"
     """A zero shot agent that does a reasoning step before acting.
-    
-    This agent has access to a document store that allows it to look up 
+
+    This agent has access to a document store that allows it to look up
     relevant information to answering the question.
     """
 
     SELF_ASK_WITH_SEARCH = "self-ask-with-search"
     """An agent that breaks down a complex question into a series of simpler questions.
-    
+
     This agent uses a search tool to look up answers to the simpler questions
     in order to answer the original complex question.
     """
     CONVERSATIONAL_REACT_DESCRIPTION = "conversational-react-description"
     CHAT_ZERO_SHOT_REACT_DESCRIPTION = "chat-zero-shot-react-description"
     """A zero shot agent that does a reasoning step before acting.
-    
-    This agent is designed to be used in conjunction 
+
+    This agent is designed to be used in conjunction
     """
 
     CHAT_CONVERSATIONAL_REACT_DESCRIPTION = "chat-conversational-react-description"
@@ -47,7 +47,7 @@ class AgentType(str, Enum):
         "structured-chat-zero-shot-react-description"
     )
     """An zero-shot react agent optimized for chat models.
-    
+
     This agent is capable of invoking tools that have multiple inputs.
     """
 

langchain/agents/chat/base.py

@@ -13,6 +13,7 @@ from langchain_core.prompts.chat import (
 )
 from langchain_core.tools import BaseTool
 from pydantic import Field
+from typing_extensions import override
 
 from langchain._api.deprecation import AGENT_DEPRECATION_WARNING
 from langchain.agents.agent import Agent, AgentOutputParser
@@ -49,21 +50,23 @@ class ChatAgent(Agent):
         return "Thought:"
 
     def _construct_scratchpad(
-        self, intermediate_steps: list[tuple[AgentAction, str]]
+        self,
+        intermediate_steps: list[tuple[AgentAction, str]],
     ) -> str:
         agent_scratchpad = super()._construct_scratchpad(intermediate_steps)
         if not isinstance(agent_scratchpad, str):
-            raise ValueError("agent_scratchpad should be of type string.")
+            msg = "agent_scratchpad should be of type string."
+            raise ValueError(msg)  # noqa: TRY004
         if agent_scratchpad:
             return (
                 f"This was your previous work "
                 f"(but I haven't seen any of it! I only see what "
                 f"you return as final answer):\n{agent_scratchpad}"
             )
-        else:
-            return agent_scratchpad
+        return agent_scratchpad
 
     @classmethod
+    @override
     def _get_default_output_parser(cls, **kwargs: Any) -> AgentOutputParser:
         return ChatOutputParser()
 
@@ -106,14 +109,7 @@ class ChatAgent(Agent):
         tool_strings = "\n".join([f"{tool.name}: {tool.description}" for tool in tools])
         tool_names = ", ".join([tool.name for tool in tools])
         format_instructions = format_instructions.format(tool_names=tool_names)
-        template = "\n\n".join(
-            [
-                system_message_prefix,
-                tool_strings,
-                format_instructions,
-                system_message_suffix,
-            ]
-        )
+        template = f"{system_message_prefix}\n\n{tool_strings}\n\n{format_instructions}\n\n{system_message_suffix}"  # noqa: E501
         messages = [
             SystemMessagePromptTemplate.from_template(template),
             HumanMessagePromptTemplate.from_template(human_message),

langchain/agents/chat/output_parser.py

@@ -45,24 +45,27 @@ class ChatOutputParser(AgentOutputParser):
             found = self.pattern.search(text)
             if not found:
                 # Fast fail to parse Final Answer.
-                raise ValueError("action not found")
+                msg = "action not found"
+                raise ValueError(msg)
             action = found.group(1)
             response = json.loads(action.strip())
             includes_action = "action" in response
             if includes_answer and includes_action:
-                raise OutputParserException(
+                msg = (
                     "Parsing LLM output produced a final answer "
                     f"and a parse-able action: {text}"
                 )
+                raise OutputParserException(msg)
             return AgentAction(
-                response["action"], response.get("action_input", {}), text
+                response["action"],
+                response.get("action_input", {}),
+                text,
             )
 
         except Exception as exc:
             if not includes_answer:
-                raise OutputParserException(
-                    f"Could not parse LLM output: {text}"
-                ) from exc
+                msg = f"Could not parse LLM output: {text}"
+                raise OutputParserException(msg) from exc
             output = text.split(FINAL_ANSWER_ACTION)[-1].strip()
             return AgentFinish({"output": output}, text)
 

langchain/agents/chat/prompt.py

@@ -1,5 +1,4 @@
-# flake8: noqa
-SYSTEM_MESSAGE_PREFIX = """Answer the following questions as best you can. You have access to the following tools:"""
+SYSTEM_MESSAGE_PREFIX = """Answer the following questions as best you can. You have access to the following tools:"""  # noqa: E501
 FORMAT_INSTRUCTIONS = """The way you use the tools is by specifying a json blob.
 Specifically, this json should have a `action` key (with the name of the tool to use) and a `action_input` key (with the input to the tool going here).
 
@@ -25,6 +24,6 @@ $JSON_BLOB
 Observation: the result of the action
 ... (this Thought/Action/Observation can repeat N times)
 Thought: I now know the final answer
-Final Answer: the final answer to the original input question"""
-SYSTEM_MESSAGE_SUFFIX = """Begin! Reminder to always use the exact characters `Final Answer` when responding."""
+Final Answer: the final answer to the original input question"""  # noqa: E501
+SYSTEM_MESSAGE_SUFFIX = """Begin! Reminder to always use the exact characters `Final Answer` when responding."""  # noqa: E501
 HUMAN_MESSAGE = "{input}\n\n{agent_scratchpad}"

langchain/agents/conversational/base.py

@@ -11,6 +11,7 @@ from langchain_core.language_models import BaseLanguageModel
 from langchain_core.prompts import PromptTemplate
 from langchain_core.tools import BaseTool
 from pydantic import Field
+from typing_extensions import override
 
 from langchain._api.deprecation import AGENT_DEPRECATION_WARNING
 from langchain.agents.agent import Agent, AgentOutputParser
@@ -35,8 +36,11 @@ class ConversationalAgent(Agent):
     """Output parser for the agent."""
 
     @classmethod
+    @override
     def _get_default_output_parser(
-        cls, ai_prefix: str = "AI", **kwargs: Any
+        cls,
+        ai_prefix: str = "AI",
+        **kwargs: Any,
     ) -> AgentOutputParser:
         return ConvoOutputParser(ai_prefix=ai_prefix)
 
@@ -93,13 +97,15 @@ class ConversationalAgent(Agent):
             A PromptTemplate with the template assembled from the pieces here.
         """
         tool_strings = "\n".join(
-            [f"> {tool.name}: {tool.description}" for tool in tools]
+            [f"> {tool.name}: {tool.description}" for tool in tools],
         )
         tool_names = ", ".join([tool.name for tool in tools])
         format_instructions = format_instructions.format(
-            tool_names=tool_names, ai_prefix=ai_prefix, human_prefix=human_prefix
+            tool_names=tool_names,
+            ai_prefix=ai_prefix,
+            human_prefix=human_prefix,
         )
-        template = "\n\n".join([prefix, tool_strings, format_instructions, suffix])
+        template = f"{prefix}\n\n{tool_strings}\n\n{format_instructions}\n\n{suffix}"
         if input_variables is None:
             input_variables = ["input", "chat_history", "agent_scratchpad"]
         return PromptTemplate(template=template, input_variables=input_variables)
@@ -161,7 +167,7 @@ class ConversationalAgent(Agent):
         )
         tool_names = [tool.name for tool in tools]
         _output_parser = output_parser or cls._get_default_output_parser(
-            ai_prefix=ai_prefix
+            ai_prefix=ai_prefix,
         )
         return cls(
             llm_chain=llm_chain,

langchain/agents/conversational/output_parser.py

@@ -34,12 +34,14 @@ class ConvoOutputParser(AgentOutputParser):
 
         if f"{self.ai_prefix}:" in text:
             return AgentFinish(
-                {"output": text.split(f"{self.ai_prefix}:")[-1].strip()}, text
+                {"output": text.split(f"{self.ai_prefix}:")[-1].strip()},
+                text,
             )
         regex = r"Action: (.*?)[\n]*Action Input: ([\s\S]*)"
         match = re.search(regex, text, re.DOTALL)
         if not match:
-            raise OutputParserException(f"Could not parse LLM output: `{text}`")
+            msg = f"Could not parse LLM output: `{text}`"
+            raise OutputParserException(msg)
         action = match.group(1)
         action_input = match.group(2)
         return AgentAction(action.strip(), action_input.strip(" ").strip('"'), text)

langchain/agents/conversational/prompt.py

@@ -1,4 +1,3 @@
-# flake8: noqa
 PREFIX = """Assistant is a large language model trained by OpenAI.
 
 Assistant is designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, Assistant is able to generate human-like text based on the input it receives, allowing it to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.
@@ -10,7 +9,7 @@ Overall, Assistant is a powerful tool that can help with a wide range of tasks a
 TOOLS:
 ------
 
-Assistant has access to the following tools:"""
+Assistant has access to the following tools:"""  # noqa: E501
 FORMAT_INSTRUCTIONS = """To use a tool, please use the following format:
 
 ```
@@ -25,7 +24,7 @@ When you have a response to say to the Human, or if you do not need to use a too
 ```
 Thought: Do I need to use a tool? No
 {ai_prefix}: [your response here]
-```"""
+```"""  # noqa: E501
 
 SUFFIX = """Begin!
 

langchain/agents/conversational_chat/base.py

@@ -20,6 +20,7 @@ from langchain_core.prompts.chat import (
 )
 from langchain_core.tools import BaseTool
 from pydantic import Field
+from typing_extensions import override
 
 from langchain.agents.agent import Agent, AgentOutputParser
 from langchain.agents.conversational_chat.output_parser import ConvoOutputParser
@@ -42,6 +43,7 @@ class ConversationalChatAgent(Agent):
     """Template for the tool response."""
 
     @classmethod
+    @override
     def _get_default_output_parser(cls, **kwargs: Any) -> AgentOutputParser:
         return ConvoOutputParser()
 
@@ -96,15 +98,16 @@ class ConversationalChatAgent(Agent):
             A PromptTemplate.
         """
         tool_strings = "\n".join(
-            [f"> {tool.name}: {tool.description}" for tool in tools]
+            [f"> {tool.name}: {tool.description}" for tool in tools],
         )
         tool_names = ", ".join([tool.name for tool in tools])
         _output_parser = output_parser or cls._get_default_output_parser()
         format_instructions = human_message.format(
-            format_instructions=_output_parser.get_format_instructions()
+            format_instructions=_output_parser.get_format_instructions(),
         )
         final_prompt = format_instructions.format(
-            tool_names=tool_names, tools=tool_strings
+            tool_names=tool_names,
+            tools=tool_strings,
         )
         if input_variables is None:
             input_variables = ["input", "chat_history", "agent_scratchpad"]
@@ -117,14 +120,15 @@ class ConversationalChatAgent(Agent):
         return ChatPromptTemplate(input_variables=input_variables, messages=messages)
 
     def _construct_scratchpad(
-        self, intermediate_steps: list[tuple[AgentAction, str]]
+        self,
+        intermediate_steps: list[tuple[AgentAction, str]],
     ) -> list[BaseMessage]:
         """Construct the scratchpad that lets the agent continue its thought process."""
         thoughts: list[BaseMessage] = []
         for action, observation in intermediate_steps:
             thoughts.append(AIMessage(content=action.log))
             human_message = HumanMessage(
-                content=self.template_tool_response.format(observation=observation)
+                content=self.template_tool_response.format(observation=observation),
             )
             thoughts.append(human_message)
         return thoughts

langchain/agents/conversational_chat/output_parser.py

@@ -39,20 +39,18 @@ class ConvoOutputParser(AgentOutputParser):
                 # If the action indicates a final answer, return an AgentFinish
                 if action == "Final Answer":
                     return AgentFinish({"output": action_input}, text)
-                else:
-                    # Otherwise, return an AgentAction with the specified action and
-                    # input
-                    return AgentAction(action, action_input, text)
-            else:
-                # If the necessary keys aren't present in the response, raise an
-                # exception
-                raise OutputParserException(
-                    f"Missing 'action' or 'action_input' in LLM output: {text}"
-                )
+                # Otherwise, return an AgentAction with the specified action and
+                # input
+                return AgentAction(action, action_input, text)
+            # If the necessary keys aren't present in the response, raise an
+            # exception
+            msg = f"Missing 'action' or 'action_input' in LLM output: {text}"
+            raise OutputParserException(msg)
         except Exception as e:
             # If any other exception is raised during parsing, also raise an
             # OutputParserException
-            raise OutputParserException(f"Could not parse LLM output: {text}") from e
+            msg = f"Could not parse LLM output: {text}"
+            raise OutputParserException(msg) from e
 
     @property
     def _type(self) -> str:

langchain/agents/conversational_chat/prompt.py

@@ -1,11 +1,10 @@
-# flake8: noqa
 PREFIX = """Assistant is a large language model trained by OpenAI.
 
 Assistant is designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, Assistant is able to generate human-like text based on the input it receives, allowing it to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.
 
 Assistant is constantly learning and improving, and its capabilities are constantly evolving. It is able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. Additionally, Assistant is able to generate its own text based on the input it receives, allowing it to engage in discussions and provide explanations and descriptions on a wide range of topics.
 
-Overall, Assistant is a powerful system that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether you need help with a specific question or just want to have a conversation about a particular topic, Assistant is here to assist."""
+Overall, Assistant is a powerful system that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether you need help with a specific question or just want to have a conversation about a particular topic, Assistant is here to assist."""  # noqa: E501
 
 FORMAT_INSTRUCTIONS = """RESPONSE FORMAT INSTRUCTIONS
 ----------------------------
@@ -31,7 +30,7 @@ Use this if you want to respond directly to the human. Markdown code snippet for
     "action": "Final Answer",
     "action_input": string \\\\ You should put what you want to return to use here
 }}}}
-```"""
+```"""  # noqa: E501
 
 SUFFIX = """TOOLS
 ------
@@ -45,13 +44,13 @@ USER'S INPUT
 --------------------
 Here is the user's input (remember to respond with a markdown code snippet of a json blob with a single action, and NOTHING else):
 
-{{{{input}}}}"""
+{{{{input}}}}"""  # noqa: E501
 
-TEMPLATE_TOOL_RESPONSE = """TOOL RESPONSE: 
+TEMPLATE_TOOL_RESPONSE = """TOOL RESPONSE:
 ---------------------
 {observation}
 
 USER'S INPUT
 --------------------
 
-Okay, so what is the response to my last comment? If using information obtained from the tools you must mention it explicitly without mentioning the tool names - I have forgotten all TOOL RESPONSES! Remember to respond with a markdown code snippet of a json blob with a single action, and NOTHING else."""
+Okay, so what is the response to my last comment? If using information obtained from the tools you must mention it explicitly without mentioning the tool names - I have forgotten all TOOL RESPONSES! Remember to respond with a markdown code snippet of a json blob with a single action, and NOTHING else."""  # noqa: E501

langchain/agents/format_scratchpad/__init__.py

@@ -16,10 +16,10 @@ from langchain.agents.format_scratchpad.tools import format_to_tool_messages
 from langchain.agents.format_scratchpad.xml import format_xml
 
 __all__ = [
-    "format_xml",
+    "format_log_to_messages",
+    "format_log_to_str",
     "format_to_openai_function_messages",
     "format_to_openai_functions",
     "format_to_tool_messages",
-    "format_log_to_str",
-    "format_log_to_messages",
+    "format_xml",
 ]

langchain/agents/format_scratchpad/log_to_messages.py

@@ -20,7 +20,7 @@ def format_log_to_messages(
     for action, observation in intermediate_steps:
         thoughts.append(AIMessage(content=action.log))
         human_message = HumanMessage(
-            content=template_tool_response.format(observation=observation)
+            content=template_tool_response.format(observation=observation),
         )
         thoughts.append(human_message)
     return thoughts

langchain/agents/format_scratchpad/openai_functions.py

@@ -6,7 +6,8 @@ from langchain_core.messages import AIMessage, BaseMessage, FunctionMessage
 
 
 def _convert_agent_action_to_messages(
-    agent_action: AgentAction, observation: str
+    agent_action: AgentAction,
+    observation: str,
 ) -> list[BaseMessage]:
     """Convert an agent action to a message.
 
@@ -20,15 +21,16 @@ def _convert_agent_action_to_messages(
             the original tool invocation
     """
     if isinstance(agent_action, AgentActionMessageLog):
-        return list(agent_action.message_log) + [
-            _create_function_message(agent_action, observation)
+        return [
+            *list(agent_action.message_log),
+            _create_function_message(agent_action, observation),
         ]
-    else:
-        return [AIMessage(content=agent_action.log)]
+    return [AIMessage(content=agent_action.log)]
 
 
 def _create_function_message(
-    agent_action: AgentAction, observation: str
+    agent_action: AgentAction,
+    observation: str,
 ) -> FunctionMessage:
     """Convert agent action and observation into a function message.
     Args:

langchain/agents/format_scratchpad/tools.py

@@ -12,7 +12,8 @@ from langchain.agents.output_parsers.tools import ToolAgentAction
 
 
 def _create_tool_message(
-    agent_action: ToolAgentAction, observation: str
+    agent_action: ToolAgentAction,
+    observation: str,
 ) -> ToolMessage:
     """Convert agent action and observation into a tool message.
 
@@ -54,8 +55,9 @@ def format_to_tool_messages(
     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)
+            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:

langchain/agents/format_scratchpad/xml.py

@@ -1,21 +1,52 @@
+from typing import Literal, Optional
+
 from langchain_core.agents import AgentAction
 
 
+def _escape(xml: str) -> str:
+    """Replace XML tags with custom safe delimiters."""
+    replacements = {
+        "<tool>": "[[tool]]",
+        "</tool>": "[[/tool]]",
+        "<tool_input>": "[[tool_input]]",
+        "</tool_input>": "[[/tool_input]]",
+        "<observation>": "[[observation]]",
+        "</observation>": "[[/observation]]",
+    }
+    for orig, repl in replacements.items():
+        xml = xml.replace(orig, repl)
+    return xml
+
+
 def format_xml(
     intermediate_steps: list[tuple[AgentAction, str]],
+    *,
+    escape_format: Optional[Literal["minimal"]] = "minimal",
 ) -> str:
     """Format the intermediate steps as XML.
 
     Args:
         intermediate_steps: The intermediate steps.
+        escape_format: The escaping format to use. Currently only 'minimal' is
+            supported, which replaces XML tags with custom delimiters to prevent
+            conflicts.
 
     Returns:
         The intermediate steps as XML.
     """
     log = ""
     for action, observation in intermediate_steps:
+        if escape_format == "minimal":
+            # Escape XML tags in tool names and inputs using custom delimiters
+            tool = _escape(action.tool)
+            tool_input = _escape(str(action.tool_input))
+            observation_ = _escape(str(observation))
+        else:
+            tool = action.tool
+            tool_input = str(action.tool_input)
+            observation_ = str(observation)
         log += (
-            f"<tool>{action.tool}</tool><tool_input>{action.tool_input}"
-            f"</tool_input><observation>{observation}</observation>"
+            f"<tool>{tool}</tool><tool_input>{tool_input}"
+            f"</tool_input><observation>{observation_}</observation>"
         )
     return log