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

langchain/agents/output_parsers/openai_tools.py

@@ -1,77 +0,0 @@
-from typing import Union
-
-from langchain_core.agents import AgentAction, AgentFinish
-from langchain_core.messages import BaseMessage
-from langchain_core.messages.utils import convert_from_v1_message
-from langchain_core.outputs import ChatGeneration, Generation
-from langchain_core.v1.messages import AIMessage as AIMessageV1
-from typing_extensions import override
-
-from langchain.agents.agent import MultiActionAgentOutputParser
-from langchain.agents.output_parsers.tools import (
-    ToolAgentAction,
-    parse_ai_message_to_tool_action,
-)
-
-OpenAIToolAgentAction = ToolAgentAction
-
-
-def parse_ai_message_to_openai_tool_action(
-    message: BaseMessage,
-) -> Union[list[AgentAction], AgentFinish]:
-    """Parse an AI message potentially containing tool_calls."""
-    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,
-                ),
-            )
-        else:
-            final_actions.append(action)
-    return final_actions
-
-
-class OpenAIToolsAgentOutputParser(MultiActionAgentOutputParser):
-    """Parses a message into agent actions/finish.
-
-    Is meant to be used with OpenAI models, as it relies on the specific
-    tool_calls parameter from OpenAI to convey what tools to use.
-
-    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 "openai-tools-agent-output-parser"
-
-    @override
-    def parse_result(
-        self,
-        result: Union[list[Generation], AIMessageV1],
-        *,
-        partial: bool = False,
-    ) -> Union[list[AgentAction], AgentFinish]:
-        if isinstance(result, AIMessageV1):
-            result = [ChatGeneration(message=convert_from_v1_message(result))]
-        if not isinstance(result[0], ChatGeneration):
-            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)
-
-    @override
-    def parse(self, text: str) -> Union[list[AgentAction], AgentFinish]:
-        msg = "Can only parse messages"
-        raise ValueError(msg)

langchain/agents/output_parsers/react_json_single_input.py

@@ -1,87 +0,0 @@
-import json
-import re
-from re import Pattern
-from typing import Union
-
-from langchain_core.agents import AgentAction, AgentFinish
-from langchain_core.exceptions import OutputParserException
-from typing_extensions import override
-
-from langchain.agents.agent import AgentOutputParser
-from langchain.agents.chat.prompt import FORMAT_INSTRUCTIONS
-
-FINAL_ANSWER_ACTION = "Final Answer:"
-
-
-class ReActJsonSingleInputOutputParser(AgentOutputParser):
-    """Parses ReAct-style LLM calls that have a single tool input in json format.
-
-    Expects output to be in one of two formats.
-
-    If the output signals that an action should be taken,
-    should be in the below format. This will result in an AgentAction
-    being returned.
-
-    ```
-    Thought: agent thought here
-    Action:
-    ```
-    {
-        "action": "search",
-        "action_input": "what is the temperature in SF"
-    }
-    ```
-    ```
-
-    If the output signals that a final answer should be given,
-    should be in the below format. This will result in an AgentFinish
-    being returned.
-
-    ```
-    Thought: agent thought here
-    Final Answer: The temperature is 100 degrees
-    ```
-
-    """
-
-    pattern: Pattern = re.compile(r"^.*?`{3}(?:json)?\n?(.*?)`{3}.*?$", re.DOTALL)
-    """Regex pattern to parse the output."""
-
-    @override
-    def get_format_instructions(self) -> str:
-        return FORMAT_INSTRUCTIONS
-
-    @override
-    def parse(self, text: str) -> Union[AgentAction, AgentFinish]:
-        includes_answer = FINAL_ANSWER_ACTION in text
-        try:
-            found = self.pattern.search(text)
-            if not found:
-                # Fast fail to parse Final Answer.
-                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:
-                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,
-            )
-
-        except Exception as e:
-            if not includes_answer:
-                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)
-
-    @property
-    def _type(self) -> str:
-        return "react-json-single-input"

langchain/agents/output_parsers/react_single_input.py

@@ -1,102 +0,0 @@
-import re
-from typing import Union
-
-from langchain_core.agents import AgentAction, AgentFinish
-from langchain_core.exceptions import OutputParserException
-from typing_extensions import override
-
-from langchain.agents.agent import AgentOutputParser
-from langchain.agents.mrkl.prompt import FORMAT_INSTRUCTIONS
-
-FINAL_ANSWER_ACTION = "Final Answer:"
-MISSING_ACTION_AFTER_THOUGHT_ERROR_MESSAGE = (
-    "Invalid Format: Missing 'Action:' after 'Thought:'"
-)
-MISSING_ACTION_INPUT_AFTER_ACTION_ERROR_MESSAGE = (
-    "Invalid Format: Missing 'Action Input:' after 'Action:'"
-)
-FINAL_ANSWER_AND_PARSABLE_ACTION_ERROR_MESSAGE = (
-    "Parsing LLM output produced both a final answer and a parse-able action:"
-)
-
-
-class ReActSingleInputOutputParser(AgentOutputParser):
-    """Parses ReAct-style LLM calls that have a single tool input.
-
-    Expects output to be in one of two formats.
-
-    If the output signals that an action should be taken,
-    should be in the below format. This will result in an AgentAction
-    being returned.
-
-    ```
-    Thought: agent thought here
-    Action: search
-    Action Input: what is the temperature in SF?
-    ```
-
-    If the output signals that a final answer should be given,
-    should be in the below format. This will result in an AgentFinish
-    being returned.
-
-    ```
-    Thought: agent thought here
-    Final Answer: The temperature is 100 degrees
-    ```
-
-    """
-
-    @override
-    def get_format_instructions(self) -> str:
-        return FORMAT_INSTRUCTIONS
-
-    @override
-    def parse(self, text: str) -> Union[AgentAction, AgentFinish]:
-        includes_answer = FINAL_ANSWER_ACTION in text
-        regex = (
-            r"Action\s*\d*\s*:[\s]*(.*?)[\s]*Action\s*\d*\s*Input\s*\d*\s*:[\s]*(.*)"
-        )
-        action_match = re.search(regex, text, re.DOTALL)
-        if action_match:
-            if includes_answer:
-                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(" ")
-            tool_input = tool_input.strip('"')
-
-            return AgentAction(action, tool_input, text)
-
-        if includes_answer:
-            return AgentFinish(
-                {"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(
-                msg,
-                observation=MISSING_ACTION_AFTER_THOUGHT_ERROR_MESSAGE,
-                llm_output=text,
-                send_to_llm=True,
-            )
-        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(
-                msg,
-                observation=MISSING_ACTION_INPUT_AFTER_ACTION_ERROR_MESSAGE,
-                llm_output=text,
-                send_to_llm=True,
-            )
-        msg = f"Could not parse LLM output: `{text}`"
-        raise OutputParserException(msg)
-
-    @property
-    def _type(self) -> str:
-        return "react-single-input"

langchain/agents/output_parsers/self_ask.py

@@ -1,53 +0,0 @@
-from collections.abc import Sequence
-from typing import Union
-
-from langchain_core.agents import AgentAction, AgentFinish
-from langchain_core.exceptions import OutputParserException
-from typing_extensions import override
-
-from langchain.agents.agent import AgentOutputParser
-
-
-class SelfAskOutputParser(AgentOutputParser):
-    """Parses self-ask style LLM calls.
-
-    Expects output to be in one of two formats.
-
-    If the output signals that an action should be taken,
-    should be in the below format. This will result in an AgentAction
-    being returned.
-
-    ```
-    Thoughts go here...
-    Follow up: what is the temperature in SF?
-    ```
-
-    If the output signals that a final answer should be given,
-    should be in the below format. This will result in an AgentFinish
-    being returned.
-
-    ```
-    Thoughts go here...
-    So the final answer is: The temperature is 100 degrees
-    ```
-
-    """
-
-    followups: Sequence[str] = ("Follow up:", "Followup:")
-    finish_string: str = "So the final answer is: "
-
-    @override
-    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 self.finish_string not in last_line:
-                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()
-        return AgentAction("Intermediate Answer", after_colon, text)
-
-    @property
-    def _type(self) -> str:
-        return "self_ask"

langchain/agents/output_parsers/tools.py

@@ -1,121 +0,0 @@
-import json
-from json import JSONDecodeError
-from typing import 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.messages.utils import convert_from_v1_message
-from langchain_core.outputs import ChatGeneration, Generation
-from langchain_core.v1.messages import AIMessage as AIMessageV1
-from typing_extensions import override
-
-from langchain.agents.agent import MultiActionAgentOutputParser
-
-
-class ToolAgentAction(AgentActionMessageLog):
-    """ "Tool agent action."""
-
-    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):
-        msg = f"Expected an AI message got {type(message)}"
-        raise TypeError(msg)
-
-    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"],
-                        type="tool_call",
-                    )
-                )
-            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
-        # 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"]
-        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"
-        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"
-
-    @override
-    def parse_result(
-        self,
-        result: Union[list[Generation], AIMessageV1],
-        *,
-        partial: bool = False,
-    ) -> Union[list[AgentAction], AgentFinish]:
-        if isinstance(result, AIMessageV1):
-            result = [ChatGeneration(message=convert_from_v1_message(result))]
-        if not isinstance(result[0], ChatGeneration):
-            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)
-
-    @override
-    def parse(self, text: str) -> Union[list[AgentAction], AgentFinish]:
-        msg = "Can only parse messages"
-        raise ValueError(msg)

langchain/agents/output_parsers/xml.py

@@ -1,126 +0,0 @@
-import re
-from typing import Literal, Optional, Union
-
-from langchain_core.agents import AgentAction, AgentFinish
-from pydantic import Field
-from typing_extensions import override
-
-from langchain.agents import AgentOutputParser
-
-
-def _unescape(text: str) -> str:
-    """Convert custom tag delimiters back into XML tags."""
-    replacements = {
-        "[[tool]]": "<tool>",
-        "[[/tool]]": "</tool>",
-        "[[tool_input]]": "<tool_input>",
-        "[[/tool_input]]": "</tool_input>",
-        "[[observation]]": "<observation>",
-        "[[/observation]]": "</observation>",
-    }
-    for repl, orig in replacements.items():
-        text = text.replace(repl, orig)
-    return text
-
-
-class XMLAgentOutputParser(AgentOutputParser):
-    """Parses tool invocations and final answers from XML-formatted agent output.
-
-    This parser extracts structured information from XML tags to determine whether
-    an agent should perform a tool action or provide a final answer. It includes
-    built-in escaping support to safely handle tool names and inputs
-    containing XML special characters.
-
-    Args:
-        escape_format: The escaping format to use when parsing XML content.
-            Supports 'minimal' which uses custom delimiters like [[tool]] to replace
-            XML tags within content, preventing parsing conflicts.
-            Use 'minimal' if using a corresponding encoding format that uses
-            the _escape function when formatting the output (e.g., with format_xml).
-
-    Expected formats:
-        Tool invocation (returns AgentAction):
-            <tool>search</tool>
-            <tool_input>what is 2 + 2</tool_input>
-
-        Final answer (returns AgentFinish):
-            <final_answer>The answer is 4</final_answer>
-
-    Note:
-        Minimal escaping allows tool names containing XML tags to be safely
-        represented. For example, a tool named "search<tool>nested</tool>" would be
-        escaped as "search[[tool]]nested[[/tool]]" in the XML and automatically
-        unescaped during parsing.
-
-    Raises:
-        ValueError: If the input doesn't match either expected XML format or
-            contains malformed XML structure.
-    """
-
-    escape_format: Optional[Literal["minimal"]] = Field(default="minimal")
-    """The format to use for escaping XML characters.
-
-    minimal - uses custom delimiters to replace XML tags within content,
-    preventing parsing conflicts. This is the only supported format currently.
-
-    None - no escaping is applied, which may lead to parsing conflicts.
-    """
-
-    @override
-    def parse(self, text: str) -> Union[AgentAction, AgentFinish]:
-        # Check for tool invocation first
-        tool_matches = re.findall(r"<tool>(.*?)</tool>", text, re.DOTALL)
-        if tool_matches:
-            if len(tool_matches) != 1:
-                msg = (
-                    f"Malformed tool invocation: expected exactly one <tool> block, "
-                    f"but found {len(tool_matches)}."
-                )
-                raise ValueError(msg)
-            _tool = tool_matches[0]
-
-            # Match optional tool input
-            input_matches = re.findall(
-                r"<tool_input>(.*?)</tool_input>", text, re.DOTALL
-            )
-            if len(input_matches) > 1:
-                msg = (
-                    f"Malformed tool invocation: expected at most one <tool_input> "
-                    f"block, but found {len(input_matches)}."
-                )
-                raise ValueError(msg)
-            _tool_input = input_matches[0] if input_matches else ""
-
-            # Unescape if minimal escape format is used
-            if self.escape_format == "minimal":
-                _tool = _unescape(_tool)
-                _tool_input = _unescape(_tool_input)
-
-            return AgentAction(tool=_tool, tool_input=_tool_input, log=text)
-        # Check for final answer
-        if "<final_answer>" in text and "</final_answer>" in text:
-            matches = re.findall(r"<final_answer>(.*?)</final_answer>", text, re.DOTALL)
-            if len(matches) != 1:
-                msg = (
-                    "Malformed output: expected exactly one "
-                    "<final_answer>...</final_answer> block."
-                )
-                raise ValueError(msg)
-            answer = matches[0]
-            # Unescape custom delimiters in final answer
-            if self.escape_format == "minimal":
-                answer = _unescape(answer)
-            return AgentFinish(return_values={"output": answer}, log=text)
-        msg = (
-            "Malformed output: expected either a tool invocation "
-            "or a final answer in XML format."
-        )
-        raise ValueError(msg)
-
-    @override
-    def get_format_instructions(self) -> str:
-        raise NotImplementedError
-
-    @property
-    def _type(self) -> str:
-        return "xml-agent"

langchain/agents/react/__init__.py

@@ -1 +0,0 @@
-"""Implements the ReAct paper from https://arxiv.org/pdf/2210.03629.pdf."""