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

langchain/agents/openai_functions_multi_agent/base.py

@@ -1,337 +0,0 @@
-"""Module implements an agent that uses OpenAI's APIs function enabled API."""
-
-import json
-from collections.abc import Sequence
-from json import JSONDecodeError
-from typing import Any, Optional, Union
-
-from langchain_core._api import deprecated
-from langchain_core.agents import AgentAction, AgentActionMessageLog, AgentFinish
-from langchain_core.callbacks import BaseCallbackManager, Callbacks
-from langchain_core.exceptions import OutputParserException
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.messages import (
-    AIMessage,
-    BaseMessage,
-    SystemMessage,
-)
-from langchain_core.prompts import BasePromptTemplate
-from langchain_core.prompts.chat import (
-    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
-
-from langchain.agents import BaseMultiActionAgent
-from langchain.agents.format_scratchpad.openai_functions import (
-    format_to_openai_function_messages,
-)
-
-# For backwards compatibility
-_FunctionsAgentAction = AgentActionMessageLog
-
-
-def _parse_ai_message(message: BaseMessage) -> Union[list[AgentAction], AgentFinish]:
-    """Parse an AI message."""
-    if not isinstance(message, AIMessage):
-        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 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) 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:
-            if "action" in tool_schema:
-                _tool_input = tool_schema["action"]
-            else:
-                # drop action_name from schema
-                _tool_input = tool_schema.copy()
-                del _tool_input["action_name"]
-            function_name = tool_schema["action_name"]
-
-            # 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.
-            if "__arg1" in _tool_input:
-                tool_input = _tool_input["__arg1"]
-            else:
-                tool_input = _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"
-            _tool = _FunctionsAgentAction(
-                tool=function_name,
-                tool_input=tool_input,
-                log=log,
-                message_log=[message],
-            )
-            final_tools.append(_tool)
-        return final_tools
-
-    return AgentFinish(
-        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.
-
-    Args:
-        llm: This should be an instance of ChatOpenAI, specifically a model
-            that supports using `functions`.
-        tools: The tools this agent has access to.
-        prompt: The prompt for this agent, should support agent_scratchpad as one
-            of the variables. For an easy way to construct this prompt, use
-            `OpenAIMultiFunctionsAgent.create_prompt(...)`
-    """
-
-    llm: BaseLanguageModel
-    tools: Sequence[BaseTool]
-    prompt: BasePromptTemplate
-
-    def get_allowed_tools(self) -> list[str]:
-        """Get allowed tools."""
-        return [t.name for t in self.tools]
-
-    @model_validator(mode="after")
-    def validate_prompt(self) -> Self:
-        prompt: BasePromptTemplate = self.prompt
-        if "agent_scratchpad" not in prompt.input_variables:
-            msg = (
-                "`agent_scratchpad` should be one of the variables in the prompt, "
-                f"got {prompt.input_variables}"
-            )
-            raise ValueError(msg)
-        return self
-
-    @property
-    def input_keys(self) -> list[str]:
-        """Get input keys. Input refers to user input here."""
-        return ["input"]
-
-    @property
-    def functions(self) -> list[dict]:
-        """Get the functions for the agent."""
-        enum_vals = [t.name for t in self.tools]
-        tool_selection = {
-            # OpenAI functions returns a single tool invocation
-            # Here we force the single tool invocation it returns to
-            # itself be a list of tool invocations. We do this by constructing
-            # a new tool that has one argument which is a list of tools
-            # to use.
-            "name": "tool_selection",
-            "description": "A list of actions to take.",
-            "parameters": {
-                "title": "tool_selection",
-                "description": "A list of actions to take.",
-                "type": "object",
-                "properties": {
-                    "actions": {
-                        "title": "actions",
-                        "type": "array",
-                        "items": {
-                            # This is a custom item which bundles the action_name
-                            # and the action. We do this because some actions
-                            # could have the same schema, and without this there
-                            # is no way to differentiate them.
-                            "title": "tool_call",
-                            "type": "object",
-                            "properties": {
-                                # This is the name of the action to take
-                                "action_name": {
-                                    "title": "action_name",
-                                    "enum": enum_vals,
-                                    "type": "string",
-                                    "description": (
-                                        "Name of the action to take. The name "
-                                        "provided here should match up with the "
-                                        "parameters for the action below."
-                                    ),
-                                },
-                                # This is the action to take.
-                                "action": {
-                                    "title": "Action",
-                                    "anyOf": [
-                                        {
-                                            "title": t.name,
-                                            "type": "object",
-                                            "properties": t.args,
-                                        }
-                                        for t in self.tools
-                                    ],
-                                },
-                            },
-                            "required": ["action_name", "action"],
-                        },
-                    },
-                },
-                "required": ["actions"],
-            },
-        }
-        return [tool_selection]
-
-    def plan(
-        self,
-        intermediate_steps: list[tuple[AgentAction, str]],
-        callbacks: Callbacks = None,
-        **kwargs: Any,
-    ) -> Union[list[AgentAction], AgentFinish]:
-        """Given input, decided what to do.
-
-        Args:
-            intermediate_steps: Steps the LLM has taken to date,
-                along with observations.
-            callbacks: Callbacks to use. Default is None.
-            **kwargs: User inputs.
-
-        Returns:
-            Action specifying what tool to use.
-        """
-        agent_scratchpad = format_to_openai_function_messages(intermediate_steps)
-        selected_inputs = {
-            k: kwargs[k] for k in self.prompt.input_variables if k != "agent_scratchpad"
-        }
-        full_inputs = dict(**selected_inputs, agent_scratchpad=agent_scratchpad)
-        prompt = self.prompt.format_prompt(**full_inputs)
-        messages = prompt.to_messages()
-        predicted_message = self.llm.predict_messages(
-            messages,
-            functions=self.functions,
-            callbacks=callbacks,
-        )
-        return _parse_ai_message(predicted_message)
-
-    async def aplan(
-        self,
-        intermediate_steps: list[tuple[AgentAction, str]],
-        callbacks: Callbacks = None,
-        **kwargs: Any,
-    ) -> Union[list[AgentAction], AgentFinish]:
-        """Async given input, decided what to do.
-
-        Args:
-            intermediate_steps: Steps the LLM has taken to date,
-                along with observations.
-            callbacks: Callbacks to use. Default is None.
-            **kwargs: User inputs.
-
-        Returns:
-            Action specifying what tool to use.
-        """
-        agent_scratchpad = format_to_openai_function_messages(intermediate_steps)
-        selected_inputs = {
-            k: kwargs[k] for k in self.prompt.input_variables if k != "agent_scratchpad"
-        }
-        full_inputs = dict(**selected_inputs, agent_scratchpad=agent_scratchpad)
-        prompt = self.prompt.format_prompt(**full_inputs)
-        messages = prompt.to_messages()
-        predicted_message = await self.llm.apredict_messages(
-            messages,
-            functions=self.functions,
-            callbacks=callbacks,
-        )
-        return _parse_ai_message(predicted_message)
-
-    @classmethod
-    def create_prompt(
-        cls,
-        system_message: Optional[SystemMessage] = _NOT_SET,  # type: ignore[assignment]
-        extra_prompt_messages: Optional[list[BaseMessagePromptTemplate]] = None,
-    ) -> BasePromptTemplate:
-        """Create prompt for this agent.
-
-        Args:
-            system_message: Message to use as the system message that will be the
-                first in the prompt.
-            extra_prompt_messages: Prompt messages that will be placed between the
-                system message and the new human input. Default is None.
-
-        Returns:
-            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]]
-        messages = [system_message_] if system_message_ else []
-
-        messages.extend(
-            [
-                *_prompts,
-                HumanMessagePromptTemplate.from_template("{input}"),
-                MessagesPlaceholder(variable_name="agent_scratchpad"),
-            ],
-        )
-        return ChatPromptTemplate(messages=messages)
-
-    @classmethod
-    def from_llm_and_tools(
-        cls,
-        llm: BaseLanguageModel,
-        tools: Sequence[BaseTool],
-        callback_manager: Optional[BaseCallbackManager] = None,
-        extra_prompt_messages: Optional[list[BaseMessagePromptTemplate]] = None,
-        system_message: Optional[SystemMessage] = _NOT_SET,  # type: ignore[assignment]
-        **kwargs: Any,
-    ) -> BaseMultiActionAgent:
-        """Construct an agent from an LLM and tools.
-
-        Args:
-            llm: The language model to use.
-            tools: A list of tools to use.
-            callback_manager: The callback manager to use. Default is None.
-            extra_prompt_messages: Extra prompt messages to use. Default is None.
-            system_message: The system message to use.
-                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_,
-        )
-        return cls(  # type: ignore[call-arg]
-            llm=llm,
-            prompt=prompt,
-            tools=tools,
-            callback_manager=callback_manager,
-            **kwargs,
-        )

langchain/agents/openai_tools/base.py

@@ -1,108 +0,0 @@
-from collections.abc import Sequence
-from typing import Optional
-
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.prompts.chat import ChatPromptTemplate
-from langchain_core.runnables import Runnable, RunnablePassthrough
-from langchain_core.tools import BaseTool
-from langchain_core.utils.function_calling import convert_to_openai_tool
-
-from langchain.agents.format_scratchpad.openai_tools import (
-    format_to_openai_tool_messages,
-)
-from langchain.agents.output_parsers.openai_tools import OpenAIToolsAgentOutputParser
-
-
-def create_openai_tools_agent(
-    llm: BaseLanguageModel,
-    tools: Sequence[BaseTool],
-    prompt: ChatPromptTemplate,
-    strict: Optional[bool] = None,  # noqa: FBT001
-) -> Runnable:
-    """Create an agent that uses OpenAI tools.
-
-    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 on the expected
-            input variables.
-
-    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.
-
-    Raises:
-        ValueError: If the prompt is missing required variables.
-
-    Example:
-
-        .. code-block:: python
-
-            from langchain import hub
-            from langchain_community.chat_models import ChatOpenAI
-            from langchain.agents import AgentExecutor, create_openai_tools_agent
-
-            prompt = hub.pull("hwchase17/openai-tools-agent")
-            model = ChatOpenAI()
-            tools = ...
-
-            agent = create_openai_tools_agent(model, tools, prompt)
-            agent_executor = AgentExecutor(agent=agent, tools=tools)
-
-            agent_executor.invoke({"input": "hi"})
-
-            # Using with chat history
-            from langchain_core.messages import AIMessage, HumanMessage
-            agent_executor.invoke(
-                {
-                    "input": "what's my name?",
-                    "chat_history": [
-                        HumanMessage(content="hi! my name is bob"),
-                        AIMessage(content="Hello Bob! How can I assist you today?"),
-                    ],
-                }
-            )
-
-    Prompt:
-
-        The agent prompt must have an `agent_scratchpad` key that is a
-            ``MessagesPlaceholder``. Intermediate agent actions and tool output
-            messages will be passed in here.
-
-        Here's an example:
-
-        .. code-block:: python
-
-            from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
-
-            prompt = ChatPromptTemplate.from_messages(
-                [
-                    ("system", "You are a helpful assistant"),
-                    MessagesPlaceholder("chat_history", optional=True),
-                    ("human", "{input}"),
-                    MessagesPlaceholder("agent_scratchpad"),
-                ]
-            )
-    """
-    missing_vars = {"agent_scratchpad"}.difference(
-        prompt.input_variables + list(prompt.partial_variables),
-    )
-    if 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],
-    )
-
-    return (
-        RunnablePassthrough.assign(
-            agent_scratchpad=lambda x: format_to_openai_tool_messages(
-                x["intermediate_steps"],
-            ),
-        )
-        | prompt
-        | llm_with_tools
-        | OpenAIToolsAgentOutputParser()
-    )

langchain/agents/output_parsers/__init__.py

@@ -1,35 +0,0 @@
-"""Parsing utils to go from string to AgentAction or Agent Finish.
-
-AgentAction means that an action should be taken.
-This contains the name of the tool to use, the input to pass to that tool,
-and a `log` variable (which contains a log of the agent's thinking).
-
-AgentFinish means that a response should be given.
-This contains a `return_values` dictionary. This usually contains a
-single `output` key, but can be extended to contain more.
-This also contains a `log` variable (which contains a log of the agent's thinking).
-"""
-
-from langchain.agents.output_parsers.json import JSONAgentOutputParser
-from langchain.agents.output_parsers.openai_functions import (
-    OpenAIFunctionsAgentOutputParser,
-)
-from langchain.agents.output_parsers.react_json_single_input import (
-    ReActJsonSingleInputOutputParser,
-)
-from langchain.agents.output_parsers.react_single_input import (
-    ReActSingleInputOutputParser,
-)
-from langchain.agents.output_parsers.self_ask import SelfAskOutputParser
-from langchain.agents.output_parsers.tools import ToolsAgentOutputParser
-from langchain.agents.output_parsers.xml import XMLAgentOutputParser
-
-__all__ = [
-    "JSONAgentOutputParser",
-    "OpenAIFunctionsAgentOutputParser",
-    "ReActJsonSingleInputOutputParser",
-    "ReActSingleInputOutputParser",
-    "SelfAskOutputParser",
-    "ToolsAgentOutputParser",
-    "XMLAgentOutputParser",
-]

langchain/agents/output_parsers/json.py

@@ -1,62 +0,0 @@
-from __future__ import annotations
-
-import logging
-from typing import Union
-
-from langchain_core.agents import AgentAction, AgentFinish
-from langchain_core.exceptions import OutputParserException
-from langchain_core.utils.json import parse_json_markdown
-
-from langchain.agents.agent import AgentOutputParser
-
-logger = logging.getLogger(__name__)
-
-
-class JSONAgentOutputParser(AgentOutputParser):
-    """Parses tool invocations and final answers 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.
-
-    ```
-    {
-      "action": "search",
-      "action_input": "2+2"
-    }
-    ```
-
-    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.
-
-    ```
-    {
-      "action": "Final Answer",
-      "action_input": "4"
-    }
-    ```
-    """
-
-    def parse(self, text: str) -> Union[AgentAction, AgentFinish]:
-        try:
-            response = parse_json_markdown(text)
-            if isinstance(response, list):
-                # gpt turbo frequently ignores the directive to emit a single action
-                logger.warning("Got multiple action responses: %s", response)
-                response = response[0]
-            if response["action"] == "Final Answer":
-                return AgentFinish({"output": response["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:
-            msg = f"Could not parse LLM output: {text}"
-            raise OutputParserException(msg) from e
-
-    @property
-    def _type(self) -> str:
-        return "json-agent"

langchain/agents/output_parsers/openai_functions.py

@@ -1,96 +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,
-)
-from langchain_core.outputs import ChatGeneration, Generation
-
-from langchain.agents.agent import AgentOutputParser
-
-
-class OpenAIFunctionsAgentOutputParser(AgentOutputParser):
-    """Parses a message into agent action/finish.
-
-    Is meant to be used with OpenAI models, as it relies on the specific
-    function_call parameter from OpenAI to convey what tools to use.
-
-    If a function_call parameter is passed, then that is used to get
-    the tool and tool input.
-
-    If one is not passed, then the AIMessage is assumed to be the final output.
-    """
-
-    @property
-    def _type(self) -> str:
-        return "openai-functions-agent"
-
-    @staticmethod
-    def _parse_ai_message(message: BaseMessage) -> Union[AgentAction, AgentFinish]:
-        """Parse an AI message."""
-        if not isinstance(message, AIMessage):
-            msg = f"Expected an AI message got {type(message)}"
-            raise TypeError(msg)
-
-        function_call = message.additional_kwargs.get("function_call", {})
-
-        if function_call:
-            function_name = function_call["name"]
-            try:
-                if len(function_call["arguments"].strip()) == 0:
-                    # OpenAI returns an empty string for functions containing no args
-                    _tool_input = {}
-                else:
-                    # otherwise it returns a json object
-                    _tool_input = json.loads(function_call["arguments"], strict=False)
-            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
-            # 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.
-            if "__arg1" in _tool_input:
-                tool_input = _tool_input["__arg1"]
-            else:
-                tool_input = _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"
-            return AgentActionMessageLog(
-                tool=function_name,
-                tool_input=tool_input,
-                log=log,
-                message_log=[message],
-            )
-
-        return AgentFinish(
-            return_values={"output": message.content},
-            log=str(message.content),
-        )
-
-    def parse_result(
-        self,
-        result: list[Generation],
-        *,
-        partial: bool = False,
-    ) -> Union[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 self._parse_ai_message(message)
-
-    def parse(self, text: str) -> Union[AgentAction, AgentFinish]:
-        msg = "Can only parse messages"
-        raise ValueError(msg)