langchain 0.3.26__py3-none-any.whl → 0.3.27__py3-none-any.whl

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

@@ -49,19 +49,20 @@ 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
     def _get_default_output_parser(cls, **kwargs: Any) -> AgentOutputParser:
@@ -106,14 +107,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

@@ -36,7 +36,9 @@ class ConversationalAgent(Agent):
 
     @classmethod
     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 +95,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 +165,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

@@ -96,15 +96,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 +118,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

langchain/agents/initialize.py

@@ -1,5 +1,6 @@
 """Load agent."""
 
+import contextlib
 from collections.abc import Sequence
 from typing import Any, Optional
 
@@ -59,35 +60,42 @@ def initialize_agent(
     if agent is None and agent_path is None:
         agent = AgentType.ZERO_SHOT_REACT_DESCRIPTION
     if agent is not None and agent_path is not None:
-        raise ValueError(
+        msg = (
             "Both `agent` and `agent_path` are specified, "
             "but at most only one should be."
         )
+        raise ValueError(msg)
     if agent is not None:
         if agent not in AGENT_TO_CLASS:
-            raise ValueError(
+            msg = (
                 f"Got unknown agent type: {agent}. "
                 f"Valid types are: {AGENT_TO_CLASS.keys()}."
             )
+            raise ValueError(msg)
         tags_.append(agent.value if isinstance(agent, AgentType) else agent)
         agent_cls = AGENT_TO_CLASS[agent]
         agent_kwargs = agent_kwargs or {}
         agent_obj = agent_cls.from_llm_and_tools(
-            llm, tools, callback_manager=callback_manager, **agent_kwargs
+            llm,
+            tools,
+            callback_manager=callback_manager,
+            **agent_kwargs,
         )
     elif agent_path is not None:
         agent_obj = load_agent(
-            agent_path, llm=llm, tools=tools, callback_manager=callback_manager
+            agent_path,
+            llm=llm,
+            tools=tools,
+            callback_manager=callback_manager,
         )
-        try:
+        with contextlib.suppress(NotImplementedError):
             # TODO: Add tags from the serialized object directly.
             tags_.append(agent_obj._agent_type)
-        except NotImplementedError:
-            pass
     else:
-        raise ValueError(
+        msg = (
             "Somehow both `agent` and `agent_path` are None, this should never happen."
         )
+        raise ValueError(msg)
     return AgentExecutor.from_agent_and_tools(
         agent=agent_obj,
         tools=tools,