langchain 0.3.27__py3-none-any.whl → 1.0.0a1__py3-none-any.whl

langchain/agents/output_parsers/openai_tools.py

@@ -1,70 +0,0 @@
-from typing import Union
-
-from langchain_core.agents import AgentAction, AgentFinish
-from langchain_core.messages import BaseMessage
-from langchain_core.outputs import ChatGeneration, Generation
-
-from langchain.agents.agent import MultiActionAgentOutputParser
-from langchain.agents.output_parsers.tools import (
-    ToolAgentAction,
-    parse_ai_message_to_tool_action,
-)
-
-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"
-
-    def parse_result(
-        self,
-        result: list[Generation],
-        *,
-        partial: bool = False,
-    ) -> Union[list[AgentAction], AgentFinish]:
-        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)
-
-    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,84 +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 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."""
-
-    def get_format_instructions(self) -> str:
-        return FORMAT_INSTRUCTIONS
-
-    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,99 +0,0 @@
-import re
-from typing import Union
-
-from langchain_core.agents import AgentAction, AgentFinish
-from langchain_core.exceptions import OutputParserException
-
-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
-    ```
-
-    """
-
-    def get_format_instructions(self) -> str:
-        return FORMAT_INSTRUCTIONS
-
-    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,51 +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 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: "
-
-    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,107 +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.outputs import ChatGeneration, Generation
-
-from langchain.agents.agent import MultiActionAgentOutputParser
-
-
-class ToolAgentAction(AgentActionMessageLog):
-    tool_call_id: str
-    """Tool call that this message is responding to."""
-
-
-def parse_ai_message_to_tool_action(
-    message: BaseMessage,
-) -> Union[list[AgentAction], AgentFinish]:
-    """Parse an AI message potentially containing tool_calls."""
-    if not isinstance(message, AIMessage):
-        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"]),
-                )
-            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"
-
-    def parse_result(
-        self,
-        result: list[Generation],
-        *,
-        partial: bool = False,
-    ) -> Union[list[AgentAction], AgentFinish]:
-        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)
-
-    def parse(self, text: str) -> Union[list[AgentAction], AgentFinish]:
-        msg = "Can only parse messages"
-        raise ValueError(msg)

langchain/agents/output_parsers/xml.py

@@ -1,123 +0,0 @@
-import re
-from typing import Literal, Optional, Union
-
-from langchain_core.agents import AgentAction, AgentFinish
-from pydantic import Field
-
-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.
-    """
-
-    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)
-
-    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."""

langchain/agents/react/agent.py

@@ -1,144 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Sequence
-from typing import Optional, Union
-
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.prompts import BasePromptTemplate
-from langchain_core.runnables import Runnable, RunnablePassthrough
-from langchain_core.tools import BaseTool
-from langchain_core.tools.render import ToolsRenderer, render_text_description
-
-from langchain.agents import AgentOutputParser
-from langchain.agents.format_scratchpad import format_log_to_str
-from langchain.agents.output_parsers import ReActSingleInputOutputParser
-
-
-def create_react_agent(
-    llm: BaseLanguageModel,
-    tools: Sequence[BaseTool],
-    prompt: BasePromptTemplate,
-    output_parser: Optional[AgentOutputParser] = None,
-    tools_renderer: ToolsRenderer = render_text_description,
-    *,
-    stop_sequence: Union[bool, list[str]] = True,
-) -> Runnable:
-    """Create an agent that uses ReAct prompting.
-
-    Based on paper "ReAct: Synergizing Reasoning and Acting in Language Models"
-    (https://arxiv.org/abs/2210.03629)
-
-    .. warning::
-       This implementation is based on the foundational ReAct paper but is older and not well-suited for production applications.
-       For a more robust and feature-rich implementation, we recommend using the `create_react_agent` function from the LangGraph library.
-       See the [reference doc](https://langchain-ai.github.io/langgraph/reference/prebuilt/#langgraph.prebuilt.chat_agent_executor.create_react_agent)
-       for more information.
-
-    Args:
-        llm: LLM to use as the agent.
-        tools: Tools this agent has access to.
-        prompt: The prompt to use. See Prompt section below for more.
-        output_parser: AgentOutputParser for parse the LLM output.
-        tools_renderer: This controls how the tools are converted into a string and
-            then passed into the LLM. Default is `render_text_description`.
-        stop_sequence: bool or list of str.
-            If True, adds a stop token of "Observation:" to avoid hallucinates.
-            If False, does not add a stop token.
-            If a list of str, uses the provided list as the stop tokens.
-
-            Default is True. You may to set this to False if the LLM you are using
-            does not support stop sequences.
-
-    Returns:
-        A Runnable sequence representing an agent. It takes as input all the same input
-        variables as the prompt passed in does. It returns as output either an
-        AgentAction or AgentFinish.
-
-    Examples:
-
-        .. code-block:: python
-
-            from langchain import hub
-            from langchain_community.llms import OpenAI
-            from langchain.agents import AgentExecutor, create_react_agent
-
-            prompt = hub.pull("hwchase17/react")
-            model = OpenAI()
-            tools = ...
-
-            agent = create_react_agent(model, tools, prompt)
-            agent_executor = AgentExecutor(agent=agent, tools=tools)
-
-            agent_executor.invoke({"input": "hi"})
-
-            # Use with chat history
-            from langchain_core.messages import AIMessage, HumanMessage
-            agent_executor.invoke(
-                {
-                    "input": "what's my name?",
-                    # Notice that chat_history is a string
-                    # since this prompt is aimed at LLMs, not chat models
-                    "chat_history": "Human: My name is Bob\\nAI: Hello Bob!",
-                }
-            )
-
-    Prompt:
-
-        The prompt must have input keys:
-            * `tools`: contains descriptions and arguments for each tool.
-            * `tool_names`: contains all tool names.
-            * `agent_scratchpad`: contains previous agent actions and tool outputs as a string.
-
-        Here's an example:
-
-        .. code-block:: python
-
-            from langchain_core.prompts import PromptTemplate
-
-            template = '''Answer the following questions as best you can. You have access to the following tools:
-
-            {tools}
-
-            Use the following format:
-
-            Question: the input question you must answer
-            Thought: you should always think about what to do
-            Action: the action to take, should be one of [{tool_names}]
-            Action Input: the input to the action
-            Observation: the result of the action
-            ... (this Thought/Action/Action Input/Observation can repeat N times)
-            Thought: I now know the final answer
-            Final Answer: the final answer to the original input question
-
-            Begin!
-
-            Question: {input}
-            Thought:{agent_scratchpad}'''
-
-            prompt = PromptTemplate.from_template(template)
-    """  # noqa: E501
-    missing_vars = {"tools", "tool_names", "agent_scratchpad"}.difference(
-        prompt.input_variables + list(prompt.partial_variables),
-    )
-    if missing_vars:
-        msg = f"Prompt missing required variables: {missing_vars}"
-        raise ValueError(msg)
-
-    prompt = prompt.partial(
-        tools=tools_renderer(list(tools)),
-        tool_names=", ".join([t.name for t in tools]),
-    )
-    if stop_sequence:
-        stop = ["\nObservation"] if stop_sequence is True else stop_sequence
-        llm_with_stop = llm.bind(stop=stop)
-    else:
-        llm_with_stop = llm
-    output_parser = output_parser or ReActSingleInputOutputParser()
-    return (
-        RunnablePassthrough.assign(
-            agent_scratchpad=lambda x: format_log_to_str(x["intermediate_steps"]),
-        )
-        | prompt
-        | llm_with_stop
-        | output_parser
-    )