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

langchain/agents/openai_functions_multi_agent/base.py

@@ -17,11 +17,11 @@ from langchain_core.messages import (
 )
 from langchain_core.prompts import BasePromptTemplate
 from langchain_core.prompts.chat import (
-    BaseMessagePromptTemplate,
     ChatPromptTemplate,
     HumanMessagePromptTemplate,
     MessagesPlaceholder,
 )
+from langchain_core.prompts.message import BaseMessagePromptTemplate
 from langchain_core.tools import BaseTool
 from pydantic import model_validator
 from typing_extensions import Self
@@ -38,26 +38,29 @@ _FunctionsAgentAction = AgentActionMessageLog
 def _parse_ai_message(message: BaseMessage) -> Union[list[AgentAction], AgentFinish]:
     """Parse an AI message."""
     if not isinstance(message, AIMessage):
-        raise TypeError(f"Expected an AI message got {type(message)}")
+        msg = f"Expected an AI message got {type(message)}"
+        raise TypeError(msg)
 
     function_call = message.additional_kwargs.get("function_call", {})
 
     if function_call:
         try:
             arguments = json.loads(function_call["arguments"], strict=False)
-        except JSONDecodeError:
-            raise OutputParserException(
+        except JSONDecodeError as e:
+            msg = (
                 f"Could not parse tool input: {function_call} because "
                 f"the `arguments` is not valid JSON."
             )
+            raise OutputParserException(msg) from e
 
         try:
             tools = arguments["actions"]
-        except (TypeError, KeyError):
-            raise OutputParserException(
+        except (TypeError, KeyError) as e:
+            msg = (
                 f"Could not parse tool input: {function_call} because "
                 f"the `arguments` JSON does not contain `actions` key."
             )
+            raise OutputParserException(msg) from e
 
         final_tools: list[AgentAction] = []
         for tool_schema in tools:
@@ -92,10 +95,14 @@ def _parse_ai_message(message: BaseMessage) -> Union[list[AgentAction], AgentFin
         return final_tools
 
     return AgentFinish(
-        return_values={"output": message.content}, log=str(message.content)
+        return_values={"output": message.content},
+        log=str(message.content),
     )
 
 
+_NOT_SET = object()
+
+
 @deprecated("0.1.0", alternative="create_openai_tools_agent", removal="1.0")
 class OpenAIMultiFunctionsAgent(BaseMultiActionAgent):
     """Agent driven by OpenAIs function powered API.
@@ -121,10 +128,11 @@ class OpenAIMultiFunctionsAgent(BaseMultiActionAgent):
     def validate_prompt(self) -> Self:
         prompt: BasePromptTemplate = self.prompt
         if "agent_scratchpad" not in prompt.input_variables:
-            raise ValueError(
+            msg = (
                 "`agent_scratchpad` should be one of the variables in the prompt, "
                 f"got {prompt.input_variables}"
             )
+            raise ValueError(msg)
         return self
 
     @property
@@ -186,7 +194,7 @@ class OpenAIMultiFunctionsAgent(BaseMultiActionAgent):
                             },
                             "required": ["action_name", "action"],
                         },
-                    }
+                    },
                 },
                 "required": ["actions"],
             },
@@ -218,10 +226,11 @@ class OpenAIMultiFunctionsAgent(BaseMultiActionAgent):
         prompt = self.prompt.format_prompt(**full_inputs)
         messages = prompt.to_messages()
         predicted_message = self.llm.predict_messages(
-            messages, functions=self.functions, callbacks=callbacks
+            messages,
+            functions=self.functions,
+            callbacks=callbacks,
         )
-        agent_decision = _parse_ai_message(predicted_message)
-        return agent_decision
+        return _parse_ai_message(predicted_message)
 
     async def aplan(
         self,
@@ -248,17 +257,16 @@ class OpenAIMultiFunctionsAgent(BaseMultiActionAgent):
         prompt = self.prompt.format_prompt(**full_inputs)
         messages = prompt.to_messages()
         predicted_message = await self.llm.apredict_messages(
-            messages, functions=self.functions, callbacks=callbacks
+            messages,
+            functions=self.functions,
+            callbacks=callbacks,
         )
-        agent_decision = _parse_ai_message(predicted_message)
-        return agent_decision
+        return _parse_ai_message(predicted_message)
 
     @classmethod
     def create_prompt(
         cls,
-        system_message: Optional[SystemMessage] = SystemMessage(
-            content="You are a helpful AI assistant."
-        ),
+        system_message: Optional[SystemMessage] = _NOT_SET,  # type: ignore[assignment]
         extra_prompt_messages: Optional[list[BaseMessagePromptTemplate]] = None,
     ) -> BasePromptTemplate:
         """Create prompt for this agent.
@@ -273,18 +281,20 @@ class OpenAIMultiFunctionsAgent(BaseMultiActionAgent):
             A prompt template to pass into this agent.
         """
         _prompts = extra_prompt_messages or []
+        system_message_ = (
+            system_message
+            if system_message is not _NOT_SET
+            else SystemMessage(content="You are a helpful AI assistant.")
+        )
         messages: list[Union[BaseMessagePromptTemplate, BaseMessage]]
-        if system_message:
-            messages = [system_message]
-        else:
-            messages = []
+        messages = [system_message_] if system_message_ else []
 
         messages.extend(
             [
                 *_prompts,
                 HumanMessagePromptTemplate.from_template("{input}"),
                 MessagesPlaceholder(variable_name="agent_scratchpad"),
-            ]
+            ],
         )
         return ChatPromptTemplate(messages=messages)
 
@@ -295,9 +305,7 @@ class OpenAIMultiFunctionsAgent(BaseMultiActionAgent):
         tools: Sequence[BaseTool],
         callback_manager: Optional[BaseCallbackManager] = None,
         extra_prompt_messages: Optional[list[BaseMessagePromptTemplate]] = None,
-        system_message: Optional[SystemMessage] = SystemMessage(
-            content="You are a helpful AI assistant."
-        ),
+        system_message: Optional[SystemMessage] = _NOT_SET,  # type: ignore[assignment]
         **kwargs: Any,
     ) -> BaseMultiActionAgent:
         """Construct an agent from an LLM and tools.
@@ -311,9 +319,14 @@ class OpenAIMultiFunctionsAgent(BaseMultiActionAgent):
                 Default is a default system message.
             kwargs: Additional arguments.
         """
+        system_message_ = (
+            system_message
+            if system_message is not _NOT_SET
+            else SystemMessage(content="You are a helpful AI assistant.")
+        )
         prompt = cls.create_prompt(
             extra_prompt_messages=extra_prompt_messages,
-            system_message=system_message,
+            system_message=system_message_,
         )
         return cls(  # type: ignore[call-arg]
             llm=llm,

langchain/agents/openai_tools/base.py

@@ -17,7 +17,7 @@ def create_openai_tools_agent(
     llm: BaseLanguageModel,
     tools: Sequence[BaseTool],
     prompt: ChatPromptTemplate,
-    strict: Optional[bool] = None,
+    strict: Optional[bool] = None,  # noqa: FBT001
 ) -> Runnable:
     """Create an agent that uses OpenAI tools.
 
@@ -86,23 +86,23 @@ def create_openai_tools_agent(
             )
     """
     missing_vars = {"agent_scratchpad"}.difference(
-        prompt.input_variables + list(prompt.partial_variables)
+        prompt.input_variables + list(prompt.partial_variables),
     )
     if missing_vars:
-        raise ValueError(f"Prompt missing required variables: {missing_vars}")
+        msg = f"Prompt missing required variables: {missing_vars}"
+        raise ValueError(msg)
 
     llm_with_tools = llm.bind(
-        tools=[convert_to_openai_tool(tool, strict=strict) for tool in tools]
+        tools=[convert_to_openai_tool(tool, strict=strict) for tool in tools],
     )
 
-    agent = (
+    return (
         RunnablePassthrough.assign(
             agent_scratchpad=lambda x: format_to_openai_tool_messages(
-                x["intermediate_steps"]
-            )
+                x["intermediate_steps"],
+            ),
         )
         | prompt
         | llm_with_tools
         | OpenAIToolsAgentOutputParser()
     )
-    return agent

langchain/agents/output_parsers/__init__.py

@@ -25,11 +25,11 @@ from langchain.agents.output_parsers.tools import ToolsAgentOutputParser
 from langchain.agents.output_parsers.xml import XMLAgentOutputParser
 
 __all__ = [
+    "JSONAgentOutputParser",
+    "OpenAIFunctionsAgentOutputParser",
+    "ReActJsonSingleInputOutputParser",
     "ReActSingleInputOutputParser",
     "SelfAskOutputParser",
     "ToolsAgentOutputParser",
-    "ReActJsonSingleInputOutputParser",
-    "OpenAIFunctionsAgentOutputParser",
     "XMLAgentOutputParser",
-    "JSONAgentOutputParser",
 ]

langchain/agents/output_parsers/json.py

@@ -5,7 +5,7 @@ from typing import Union
 
 from langchain_core.agents import AgentAction, AgentFinish
 from langchain_core.exceptions import OutputParserException
-from langchain_core.output_parsers.json import parse_json_markdown
+from langchain_core.utils.json import parse_json_markdown
 
 from langchain.agents.agent import AgentOutputParser
 
@@ -49,13 +49,13 @@ class JSONAgentOutputParser(AgentOutputParser):
                 response = response[0]
             if response["action"] == "Final Answer":
                 return AgentFinish({"output": response["action_input"]}, text)
-            else:
-                action_input = response.get("action_input", {})
-                if action_input is None:
-                    action_input = {}
-                return AgentAction(response["action"], action_input, text)
+            action_input = response.get("action_input", {})
+            if action_input is None:
+                action_input = {}
+            return AgentAction(response["action"], action_input, text)
         except Exception as e:
-            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/output_parsers/openai_functions.py

@@ -33,7 +33,8 @@ class OpenAIFunctionsAgentOutputParser(AgentOutputParser):
     def _parse_ai_message(message: BaseMessage) -> Union[AgentAction, AgentFinish]:
         """Parse an AI message."""
         if not isinstance(message, AIMessage):
-            raise TypeError(f"Expected an AI message got {type(message)}")
+            msg = f"Expected an AI message got {type(message)}"
+            raise TypeError(msg)
 
         function_call = message.additional_kwargs.get("function_call", {})
 
@@ -46,11 +47,12 @@ class OpenAIFunctionsAgentOutputParser(AgentOutputParser):
                 else:
                     # otherwise it returns a json object
                     _tool_input = json.loads(function_call["arguments"], strict=False)
-            except JSONDecodeError:
-                raise OutputParserException(
+            except JSONDecodeError as e:
+                msg = (
                     f"Could not parse tool input: {function_call} because "
                     f"the `arguments` is not valid JSON."
                 )
+                raise OutputParserException(msg) from e
 
             # HACK HACK HACK:
             # The code that encodes tool input into Open AI uses a special variable
@@ -73,16 +75,22 @@ class OpenAIFunctionsAgentOutputParser(AgentOutputParser):
             )
 
         return AgentFinish(
-            return_values={"output": message.content}, log=str(message.content)
+            return_values={"output": message.content},
+            log=str(message.content),
         )
 
     def parse_result(
-        self, result: list[Generation], *, partial: bool = False
+        self,
+        result: list[Generation],
+        *,
+        partial: bool = False,
     ) -> Union[AgentAction, AgentFinish]:
         if not isinstance(result[0], ChatGeneration):
-            raise ValueError("This output parser only works on ChatGeneration output")
+            msg = "This output parser only works on ChatGeneration output"
+            raise ValueError(msg)  # noqa: TRY004
         message = result[0].message
         return self._parse_ai_message(message)
 
     def parse(self, text: str) -> Union[AgentAction, AgentFinish]:
-        raise ValueError("Can only parse messages")
+        msg = "Can only parse messages"
+        raise ValueError(msg)

langchain/agents/output_parsers/openai_tools.py

@@ -30,7 +30,7 @@ def parse_ai_message_to_openai_tool_action(
                     log=action.log,
                     message_log=action.message_log,
                     tool_call_id=action.tool_call_id,
-                )
+                ),
             )
         else:
             final_actions.append(action)
@@ -54,12 +54,17 @@ class OpenAIToolsAgentOutputParser(MultiActionAgentOutputParser):
         return "openai-tools-agent-output-parser"
 
     def parse_result(
-        self, result: list[Generation], *, partial: bool = False
+        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")
+            msg = "This output parser only works on ChatGeneration output"
+            raise ValueError(msg)  # noqa: TRY004
         message = result[0].message
         return parse_ai_message_to_openai_tool_action(message)
 
     def parse(self, text: str) -> Union[list[AgentAction], AgentFinish]:
-        raise ValueError("Can only parse messages")
+        msg = "Can only parse messages"
+        raise ValueError(msg)

langchain/agents/output_parsers/react_json_single_input.py

@@ -55,22 +55,27 @@ class ReActJsonSingleInputOutputParser(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:
+        except Exception as e:
             if not includes_answer:
-                raise OutputParserException(f"Could not parse LLM output: {text}")
+                msg = f"Could not parse LLM output: {text}"
+                raise OutputParserException(msg) from e
             output = text.split(FINAL_ANSWER_ACTION)[-1].strip()
             return AgentFinish({"output": output}, text)
 

langchain/agents/output_parsers/react_single_input.py

@@ -56,9 +56,8 @@ class ReActSingleInputOutputParser(AgentOutputParser):
         action_match = re.search(regex, text, re.DOTALL)
         if action_match:
             if includes_answer:
-                raise OutputParserException(
-                    f"{FINAL_ANSWER_AND_PARSABLE_ACTION_ERROR_MESSAGE}: {text}"
-                )
+                msg = f"{FINAL_ANSWER_AND_PARSABLE_ACTION_ERROR_MESSAGE}: {text}"
+                raise OutputParserException(msg)
             action = action_match.group(1).strip()
             action_input = action_match.group(2)
             tool_input = action_input.strip(" ")
@@ -66,29 +65,34 @@ class ReActSingleInputOutputParser(AgentOutputParser):
 
             return AgentAction(action, tool_input, text)
 
-        elif includes_answer:
+        if includes_answer:
             return AgentFinish(
-                {"output": text.split(FINAL_ANSWER_ACTION)[-1].strip()}, text
+                {"output": text.split(FINAL_ANSWER_ACTION)[-1].strip()},
+                text,
             )
 
         if not re.search(r"Action\s*\d*\s*:[\s]*(.*?)", text, re.DOTALL):
+            msg = f"Could not parse LLM output: `{text}`"
             raise OutputParserException(
-                f"Could not parse LLM output: `{text}`",
+                msg,
                 observation=MISSING_ACTION_AFTER_THOUGHT_ERROR_MESSAGE,
                 llm_output=text,
                 send_to_llm=True,
             )
-        elif not re.search(
-            r"[\s]*Action\s*\d*\s*Input\s*\d*\s*:[\s]*(.*)", text, re.DOTALL
+        if not re.search(
+            r"[\s]*Action\s*\d*\s*Input\s*\d*\s*:[\s]*(.*)",
+            text,
+            re.DOTALL,
         ):
+            msg = f"Could not parse LLM output: `{text}`"
             raise OutputParserException(
-                f"Could not parse LLM output: `{text}`",
+                msg,
                 observation=MISSING_ACTION_INPUT_AFTER_ACTION_ERROR_MESSAGE,
                 llm_output=text,
                 send_to_llm=True,
             )
-        else:
-            raise OutputParserException(f"Could not parse LLM output: `{text}`")
+        msg = f"Could not parse LLM output: `{text}`"
+        raise OutputParserException(msg)
 
     @property
     def _type(self) -> str:

langchain/agents/output_parsers/self_ask.py

@@ -37,9 +37,10 @@ class SelfAskOutputParser(AgentOutputParser):
 
     def parse(self, text: str) -> Union[AgentAction, AgentFinish]:
         last_line = text.split("\n")[-1]
-        if not any([follow in last_line for follow in self.followups]):
+        if not any(follow in last_line for follow in self.followups):
             if self.finish_string not in last_line:
-                raise OutputParserException(f"Could not parse output: {text}")
+                msg = f"Could not parse output: {text}"
+                raise OutputParserException(msg)
             return AgentFinish({"output": last_line[len(self.finish_string) :]}, text)
 
         after_colon = text.split(":")[-1].strip()

langchain/agents/output_parsers/tools.py

@@ -24,7 +24,8 @@ def parse_ai_message_to_tool_action(
 ) -> 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)}")
+        msg = f"Expected an AI message got {type(message)}"
+        raise TypeError(msg)
 
     actions: list = []
     if message.tool_calls:
@@ -32,7 +33,8 @@ def parse_ai_message_to_tool_action(
     else:
         if not message.additional_kwargs.get("tool_calls"):
             return AgentFinish(
-                return_values={"output": message.content}, log=str(message.content)
+                return_values={"output": message.content},
+                log=str(message.content),
             )
         # Best-effort parsing
         tool_calls = []
@@ -42,13 +44,14 @@ def parse_ai_message_to_tool_action(
             try:
                 args = json.loads(function["arguments"] or "{}")
                 tool_calls.append(
-                    ToolCall(name=function_name, args=args, id=tool_call["id"])
+                    ToolCall(name=function_name, args=args, id=tool_call["id"]),
                 )
-            except JSONDecodeError:
-                raise OutputParserException(
+            except JSONDecodeError as e:
+                msg = (
                     f"Could not parse tool input: {function} because "
                     f"the `arguments` is not valid JSON."
                 )
+                raise OutputParserException(msg) from e
     for tool_call in tool_calls:
         # HACK HACK HACK:
         # The code that encodes tool input into Open AI uses a special variable
@@ -58,10 +61,7 @@ def parse_ai_message_to_tool_action(
         # 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
+        tool_input = _tool_input.get("__arg1", _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"
@@ -72,7 +72,7 @@ def parse_ai_message_to_tool_action(
                 log=log,
                 message_log=[message],
                 tool_call_id=tool_call["id"],
-            )
+            ),
         )
     return actions
 
@@ -91,12 +91,17 @@ class ToolsAgentOutputParser(MultiActionAgentOutputParser):
         return "tools-agent-output-parser"
 
     def parse_result(
-        self, result: list[Generation], *, partial: bool = False
+        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")
+            msg = "This output parser only works on ChatGeneration output"
+            raise ValueError(msg)  # noqa: TRY004
         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")
+        msg = "Can only parse messages"
+        raise ValueError(msg)