Add files using upload-large-folder tool

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_classic-1.0.7.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) LangChain, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_classic/_api/__init__.py

@@ -0,0 +1,28 @@
+"""Helper functions for managing the LangChain API.
+
+This module is only relevant for LangChain developers, not for users.
+
+!!! warning
+
+    This module and its submodules are for internal use only. Do not use them in your
+    own code.  We may change the API at any time with no warning.
+
+"""
+
+from langchain_classic._api.deprecation import (
+    LangChainDeprecationWarning,
+    deprecated,
+    suppress_langchain_deprecation_warning,
+    surface_langchain_deprecation_warnings,
+    warn_deprecated,
+)
+from langchain_classic._api.module_import import create_importer
+
+__all__ = [
+    "LangChainDeprecationWarning",
+    "create_importer",
+    "deprecated",
+    "suppress_langchain_deprecation_warning",
+    "surface_langchain_deprecation_warnings",
+    "warn_deprecated",
+]

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_classic/_api/deprecation.py

@@ -0,0 +1,27 @@
+from langchain_core._api.deprecation import (
+    LangChainDeprecationWarning,
+    LangChainPendingDeprecationWarning,
+    deprecated,
+    suppress_langchain_deprecation_warning,
+    surface_langchain_deprecation_warnings,
+    warn_deprecated,
+)
+
+AGENT_DEPRECATION_WARNING = (
+    "Use `langchain.agents.create_agent` for new applications. It provides a "
+    "more flexible agent factory with middleware support, structured output, "
+    "and integration with LangGraph for persistence, streaming, and "
+    "human-in-the-loop workflows. Migration guide: "
+    "https://docs.langchain.com/oss/python/migrate/langchain-v1"
+)
+
+
+__all__ = [
+    "AGENT_DEPRECATION_WARNING",
+    "LangChainDeprecationWarning",
+    "LangChainPendingDeprecationWarning",
+    "deprecated",
+    "suppress_langchain_deprecation_warning",
+    "surface_langchain_deprecation_warnings",
+    "warn_deprecated",
+]

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_classic/_api/interactive_env.py

@@ -0,0 +1,5 @@
+def is_interactive_env() -> bool:
+    """Determine if running within IPython or Jupyter."""
+    import sys
+
+    return hasattr(sys, "ps2")

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_classic/_api/module_import.py

@@ -0,0 +1,156 @@
+import importlib
+from collections.abc import Callable
+from typing import Any
+
+from langchain_core._api import internal, warn_deprecated
+
+from langchain_classic._api.interactive_env import is_interactive_env
+
+ALLOWED_TOP_LEVEL_PKGS = {
+    "langchain_community",
+    "langchain_core",
+    "langchain_classic",
+}
+
+
+def create_importer(
+    package: str,
+    *,
+    module_lookup: dict[str, str] | None = None,
+    deprecated_lookups: dict[str, str] | None = None,
+    fallback_module: str | None = None,
+) -> Callable[[str], Any]:
+    """Create a function that helps retrieve objects from their new locations.
+
+    The goal of this function is to help users transition from deprecated
+    imports to new imports.
+
+    The function will raise deprecation warning on loops using
+    `deprecated_lookups` or `fallback_module`.
+
+    Module lookups will import without deprecation warnings (used to speed
+    up imports from large namespaces like llms or chat models).
+
+    This function should ideally only be used with deprecated imports not with
+    existing imports that are valid, as in addition to raising deprecation warnings
+    the dynamic imports can create other issues for developers (e.g.,
+    loss of type information, IDE support for going to definition etc).
+
+    Args:
+        package: Current package. Use `__package__`
+        module_lookup: Maps name of object to the module where it is defined.
+            e.g.,
+            ```json
+            {
+                "MyDocumentLoader": (
+                    "langchain_community.document_loaders.my_document_loader"
+                )
+            }
+            ```
+        deprecated_lookups: Same as module look up, but will raise
+            deprecation warnings.
+        fallback_module: Module to import from if the object is not found in
+            `module_lookup` or if `module_lookup` is not provided.
+
+    Returns:
+        A function that imports objects from the specified modules.
+    """
+    all_module_lookup = {**(deprecated_lookups or {}), **(module_lookup or {})}
+
+    def import_by_name(name: str) -> Any:
+        """Import stores from `langchain_community`."""
+        # If not in interactive env, raise warning.
+        if all_module_lookup and name in all_module_lookup:
+            new_module = all_module_lookup[name]
+            if new_module.split(".")[0] not in ALLOWED_TOP_LEVEL_PKGS:
+                msg = (
+                    f"Importing from {new_module} is not allowed. "
+                    f"Allowed top-level packages are: {ALLOWED_TOP_LEVEL_PKGS}"
+                )
+                raise AssertionError(msg)
+
+            try:
+                module = importlib.import_module(new_module)
+            except ModuleNotFoundError as e:
+                if new_module.startswith("langchain_community"):
+                    msg = (
+                        f"Module {new_module} not found. "
+                        "Please install langchain-community to access this module. "
+                        "You can install it using `pip install -U langchain-community`"
+                    )
+                    raise ModuleNotFoundError(msg) from e
+                raise
+
+            try:
+                result = getattr(module, name)
+                if (
+                    not is_interactive_env()
+                    and deprecated_lookups
+                    and name in deprecated_lookups
+                    # Depth 3:
+                    # -> internal.py
+                    # |-> module_import.py
+                    #  |-> Module in langchain that uses this function
+                    #   |-> [calling code] whose frame we want to inspect.
+                    and not internal.is_caller_internal(depth=3)
+                ):
+                    warn_deprecated(
+                        since="0.1",
+                        pending=False,
+                        removal="2.0.0",
+                        message=(
+                            f"Importing {name} from {package} is deprecated. "
+                            f"Please replace deprecated imports:\n\n"
+                            f">> from {package} import {name}\n\n"
+                            "with new imports of:\n\n"
+                            f">> from {new_module} import {name}\n"
+                            "You can use the langchain cli to **automatically** "
+                            "upgrade many imports. Please see documentation here "
+                            "<https://python.langchain.com/docs/versions/v0_2/>"
+                        ),
+                    )
+            except Exception as e:
+                msg = f"module {new_module} has no attribute {name}"
+                raise AttributeError(msg) from e
+
+            return result
+
+        if fallback_module:
+            try:
+                module = importlib.import_module(fallback_module)
+                result = getattr(module, name)
+                if (
+                    not is_interactive_env()
+                    # Depth 3:
+                    # internal.py
+                    # |-> module_import.py
+                    #  |->Module in langchain that uses this function
+                    #   |-> [calling code] whose frame we want to inspect.
+                    and not internal.is_caller_internal(depth=3)
+                ):
+                    warn_deprecated(
+                        since="0.1",
+                        pending=False,
+                        removal="2.0.0",
+                        message=(
+                            f"Importing {name} from {package} is deprecated. "
+                            f"Please replace deprecated imports:\n\n"
+                            f">> from {package} import {name}\n\n"
+                            "with new imports of:\n\n"
+                            f">> from {fallback_module} import {name}\n"
+                            "You can use the langchain cli to **automatically** "
+                            "upgrade many imports. Please see documentation here "
+                            "<https://python.langchain.com/docs/versions/v0_2/>"
+                        ),
+                    )
+
+            except Exception as e:
+                msg = f"module {fallback_module} has no attribute {name}"
+                raise AttributeError(msg) from e
+
+            return result
+
+        msg = f"module {package} has no attribute {name}"
+        raise AttributeError(msg)
+
+    return import_by_name

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_classic/_api/path.py

@@ -0,0 +1,3 @@
+from langchain_core._api.path import as_import_path, get_relative_path
+
+__all__ = ["as_import_path", "get_relative_path"]

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_classic/adapters/openai.py

@@ -0,0 +1,63 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain_classic._api import create_importer
+
+if TYPE_CHECKING:
+    from langchain_community.adapters.openai import (
+        Chat,
+        ChatCompletion,
+        ChatCompletionChunk,
+        ChatCompletions,
+        Choice,
+        ChoiceChunk,
+        Completions,
+        IndexableBaseModel,
+        chat,
+        convert_dict_to_message,
+        convert_message_to_dict,
+        convert_messages_for_finetuning,
+        convert_openai_messages,
+    )
+
+# Create a way to dynamically look up deprecated imports.
+# Used to consolidate logic for raising deprecation warnings and
+# handling optional imports.
+MODULE_LOOKUP = {
+    "IndexableBaseModel": "langchain_community.adapters.openai",
+    "Choice": "langchain_community.adapters.openai",
+    "ChatCompletions": "langchain_community.adapters.openai",
+    "ChoiceChunk": "langchain_community.adapters.openai",
+    "ChatCompletionChunk": "langchain_community.adapters.openai",
+    "convert_dict_to_message": "langchain_community.adapters.openai",
+    "convert_message_to_dict": "langchain_community.adapters.openai",
+    "convert_openai_messages": "langchain_community.adapters.openai",
+    "ChatCompletion": "langchain_community.adapters.openai",
+    "convert_messages_for_finetuning": "langchain_community.adapters.openai",
+    "Completions": "langchain_community.adapters.openai",
+    "Chat": "langchain_community.adapters.openai",
+    "chat": "langchain_community.adapters.openai",
+}
+
+_import_attribute = create_importer(__file__, deprecated_lookups=MODULE_LOOKUP)
+
+
+def __getattr__(name: str) -> Any:
+    """Look up attributes dynamically."""
+    return _import_attribute(name)
+
+
+__all__ = [
+    "Chat",
+    "ChatCompletion",
+    "ChatCompletionChunk",
+    "ChatCompletions",
+    "Choice",
+    "ChoiceChunk",
+    "Completions",
+    "IndexableBaseModel",
+    "chat",
+    "convert_dict_to_message",
+    "convert_message_to_dict",
+    "convert_messages_for_finetuning",
+    "convert_openai_messages",
+]

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_classic/agents/__init__.py

@@ -0,0 +1,164 @@
+"""**Agent** is a class that uses an LLM to choose a sequence of actions to take.
+
+In Chains, a sequence of actions is hardcoded. In Agents,
+a language model is used as a reasoning engine to determine which actions
+to take and in which order.
+
+Agents select and use **Tools** and **Toolkits** for actions.
+"""
+
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from langchain_core._api.path import as_import_path
+from langchain_core.tools import Tool
+from langchain_core.tools.convert import tool
+
+from langchain_classic._api import create_importer
+from langchain_classic.agents.agent import (
+    Agent,
+    AgentExecutor,
+    AgentOutputParser,
+    BaseMultiActionAgent,
+    BaseSingleActionAgent,
+    LLMSingleActionAgent,
+)
+from langchain_classic.agents.agent_iterator import AgentExecutorIterator
+from langchain_classic.agents.agent_toolkits.vectorstore.base import (
+    create_vectorstore_agent,
+    create_vectorstore_router_agent,
+)
+from langchain_classic.agents.agent_types import AgentType
+from langchain_classic.agents.conversational.base import ConversationalAgent
+from langchain_classic.agents.conversational_chat.base import ConversationalChatAgent
+from langchain_classic.agents.initialize import initialize_agent
+from langchain_classic.agents.json_chat.base import create_json_chat_agent
+from langchain_classic.agents.loading import load_agent
+from langchain_classic.agents.mrkl.base import MRKLChain, ZeroShotAgent
+from langchain_classic.agents.openai_functions_agent.base import (
+    OpenAIFunctionsAgent,
+    create_openai_functions_agent,
+)
+from langchain_classic.agents.openai_functions_multi_agent.base import (
+    OpenAIMultiFunctionsAgent,
+)
+from langchain_classic.agents.openai_tools.base import create_openai_tools_agent
+from langchain_classic.agents.react.agent import create_react_agent
+from langchain_classic.agents.react.base import ReActChain, ReActTextWorldAgent
+from langchain_classic.agents.self_ask_with_search.base import (
+    SelfAskWithSearchChain,
+    create_self_ask_with_search_agent,
+)
+from langchain_classic.agents.structured_chat.base import (
+    StructuredChatAgent,
+    create_structured_chat_agent,
+)
+from langchain_classic.agents.tool_calling_agent.base import create_tool_calling_agent
+from langchain_classic.agents.xml.base import XMLAgent, create_xml_agent
+
+if TYPE_CHECKING:
+    from langchain_community.agent_toolkits.json.base import create_json_agent
+    from langchain_community.agent_toolkits.load_tools import (
+        get_all_tool_names,
+        load_huggingface_tool,
+        load_tools,
+    )
+    from langchain_community.agent_toolkits.openapi.base import create_openapi_agent
+    from langchain_community.agent_toolkits.powerbi.base import create_pbi_agent
+    from langchain_community.agent_toolkits.powerbi.chat_base import (
+        create_pbi_chat_agent,
+    )
+    from langchain_community.agent_toolkits.spark_sql.base import create_spark_sql_agent
+    from langchain_community.agent_toolkits.sql.base import create_sql_agent
+
+DEPRECATED_CODE = [
+    "create_csv_agent",
+    "create_pandas_dataframe_agent",
+    "create_spark_dataframe_agent",
+    "create_xorbits_agent",
+]
+
+# Create a way to dynamically look up deprecated imports.
+# Used to consolidate logic for raising deprecation warnings and
+# handling optional imports.
+DEPRECATED_LOOKUP = {
+    "create_json_agent": "langchain_community.agent_toolkits.json.base",
+    "create_openapi_agent": "langchain_community.agent_toolkits.openapi.base",
+    "create_pbi_agent": "langchain_community.agent_toolkits.powerbi.base",
+    "create_pbi_chat_agent": "langchain_community.agent_toolkits.powerbi.chat_base",
+    "create_spark_sql_agent": "langchain_community.agent_toolkits.spark_sql.base",
+    "create_sql_agent": "langchain_community.agent_toolkits.sql.base",
+    "load_tools": "langchain_community.agent_toolkits.load_tools",
+    "load_huggingface_tool": "langchain_community.agent_toolkits.load_tools",
+    "get_all_tool_names": "langchain_community.agent_toolkits.load_tools",
+}
+
+_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
+
+
+def __getattr__(name: str) -> Any:
+    """Get attr name."""
+    if name in DEPRECATED_CODE:
+        # Get directory of langchain package
+        here = Path(__file__).parents[1]
+        relative_path = as_import_path(
+            Path(__file__).parent,
+            suffix=name,
+            relative_to=here,
+        )
+        old_path = "langchain_classic." + relative_path
+        new_path = "langchain_experimental." + relative_path
+        msg = (
+            f"{name} has been moved to langchain_experimental. "
+            "See https://github.com/langchain-ai/langchain/discussions/11680"
+            "for more information.\n"
+            f"Please update your import statement from: `{old_path}` to `{new_path}`."
+        )
+        raise ImportError(msg)
+    return _import_attribute(name)
+
+
+__all__ = [
+    "Agent",
+    "AgentExecutor",
+    "AgentExecutorIterator",
+    "AgentOutputParser",
+    "AgentType",
+    "BaseMultiActionAgent",
+    "BaseSingleActionAgent",
+    "ConversationalAgent",
+    "ConversationalChatAgent",
+    "LLMSingleActionAgent",
+    "MRKLChain",
+    "OpenAIFunctionsAgent",
+    "OpenAIMultiFunctionsAgent",
+    "ReActChain",
+    "ReActTextWorldAgent",
+    "SelfAskWithSearchChain",
+    "StructuredChatAgent",
+    "Tool",
+    "XMLAgent",
+    "ZeroShotAgent",
+    "create_json_agent",
+    "create_json_chat_agent",
+    "create_openai_functions_agent",
+    "create_openai_tools_agent",
+    "create_openapi_agent",
+    "create_pbi_agent",
+    "create_pbi_chat_agent",
+    "create_react_agent",
+    "create_self_ask_with_search_agent",
+    "create_spark_sql_agent",
+    "create_sql_agent",
+    "create_structured_chat_agent",
+    "create_tool_calling_agent",
+    "create_vectorstore_agent",
+    "create_vectorstore_router_agent",
+    "create_xml_agent",
+    "get_all_tool_names",
+    "initialize_agent",
+    "load_agent",
+    "load_huggingface_tool",
+    "load_tools",
+    "tool",
+]

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_classic/agents/agent.py

@@ -0,0 +1,1792 @@
+"""Chain that takes in an input and produces an action and action input."""
+
+from __future__ import annotations
+
+import asyncio
+import builtins
+import contextlib
+import json
+import logging
+import time
+from abc import abstractmethod
+from collections.abc import AsyncIterator, Callable, Iterator, Sequence
+from pathlib import Path
+from typing import (
+    Any,
+    cast,
+)
+
+import yaml
+from langchain_core._api import deprecated
+from langchain_core.agents import AgentAction, AgentFinish, AgentStep
+from langchain_core.callbacks import (
+    AsyncCallbackManagerForChainRun,
+    AsyncCallbackManagerForToolRun,
+    BaseCallbackManager,
+    CallbackManagerForChainRun,
+    CallbackManagerForToolRun,
+    Callbacks,
+)
+from langchain_core.exceptions import OutputParserException
+from langchain_core.language_models import BaseLanguageModel
+from langchain_core.messages import BaseMessage
+from langchain_core.output_parsers import BaseOutputParser
+from langchain_core.prompts import BasePromptTemplate
+from langchain_core.prompts.few_shot import FewShotPromptTemplate
+from langchain_core.prompts.prompt import PromptTemplate
+from langchain_core.runnables import Runnable, RunnableConfig, ensure_config
+from langchain_core.runnables.utils import AddableDict
+from langchain_core.tools import BaseTool
+from langchain_core.utils.input import get_color_mapping
+from pydantic import BaseModel, ConfigDict, model_validator
+from typing_extensions import Self, override
+
+from langchain_classic._api.deprecation import AGENT_DEPRECATION_WARNING
+from langchain_classic.agents.agent_iterator import AgentExecutorIterator
+from langchain_classic.agents.agent_types import AgentType
+from langchain_classic.agents.tools import InvalidTool
+from langchain_classic.chains.base import Chain
+from langchain_classic.chains.llm import LLMChain
+from langchain_classic.utilities.asyncio import asyncio_timeout
+
+logger = logging.getLogger(__name__)
+
+
+class BaseSingleActionAgent(BaseModel):
+    """Base Single Action Agent class."""
+
+    @property
+    def return_values(self) -> list[str]:
+        """Return values of the agent."""
+        return ["output"]
+
+    def get_allowed_tools(self) -> list[str] | None:
+        """Get allowed tools."""
+        return None
+
+    @abstractmethod
+    def plan(
+        self,
+        intermediate_steps: list[tuple[AgentAction, str]],
+        callbacks: Callbacks = None,
+        **kwargs: Any,
+    ) -> AgentAction | AgentFinish:
+        """Given input, decided what to do.
+
+        Args:
+            intermediate_steps: Steps the LLM has taken to date,
+                along with observations.
+            callbacks: Callbacks to run.
+            **kwargs: User inputs.
+
+        Returns:
+            Action specifying what tool to use.
+        """
+
+    @abstractmethod
+    async def aplan(
+        self,
+        intermediate_steps: list[tuple[AgentAction, str]],
+        callbacks: Callbacks = None,
+        **kwargs: Any,
+    ) -> 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 run.
+            **kwargs: User inputs.
+
+        Returns:
+            Action specifying what tool to use.
+        """
+
+    @property
+    @abstractmethod
+    def input_keys(self) -> list[str]:
+        """Return the input keys."""
+
+    def return_stopped_response(
+        self,
+        early_stopping_method: str,
+        intermediate_steps: list[tuple[AgentAction, str]],  # noqa: ARG002
+        **_: Any,
+    ) -> AgentFinish:
+        """Return response when agent has been stopped due to max iterations.
+
+        Args:
+            early_stopping_method: Method to use for early stopping.
+            intermediate_steps: Steps the LLM has taken to date,
+                along with observations.
+
+        Returns:
+            Agent finish object.
+
+        Raises:
+            ValueError: If `early_stopping_method` is not supported.
+        """
+        if early_stopping_method == "force":
+            # `force` just returns a constant string
+            return AgentFinish(
+                {"output": "Agent stopped due to iteration limit or time limit."},
+                "",
+            )
+        msg = f"Got unsupported early_stopping_method `{early_stopping_method}`"
+        raise ValueError(msg)
+
+    @classmethod
+    def from_llm_and_tools(
+        cls,
+        llm: BaseLanguageModel,
+        tools: Sequence[BaseTool],
+        callback_manager: BaseCallbackManager | None = None,
+        **kwargs: Any,
+    ) -> BaseSingleActionAgent:
+        """Construct an agent from an LLM and tools.
+
+        Args:
+            llm: Language model to use.
+            tools: Tools to use.
+            callback_manager: Callback manager to use.
+            kwargs: Additional arguments.
+
+        Returns:
+            Agent object.
+        """
+        raise NotImplementedError
+
+    @property
+    def _agent_type(self) -> str:
+        """Return Identifier of an agent type."""
+        raise NotImplementedError
+
+    @override
+    def dict(self, **kwargs: Any) -> builtins.dict:
+        """Return dictionary representation of agent.
+
+        Returns:
+            Dictionary representation of agent.
+        """
+        _dict = super().model_dump()
+        try:
+            _type = self._agent_type
+        except NotImplementedError:
+            _type = None
+        if isinstance(_type, AgentType):
+            _dict["_type"] = str(_type.value)
+        elif _type is not None:
+            _dict["_type"] = _type
+        return _dict
+
+    def save(self, file_path: Path | str) -> None:
+        """Save the agent.
+
+        Args:
+            file_path: Path to file to save the agent to.
+
+        Example:
+        ```python
+        # If working with agent executor
+        agent.agent.save(file_path="path/agent.yaml")
+        ```
+        """
+        # Convert file to Path object.
+        save_path = Path(file_path) if isinstance(file_path, str) else file_path
+
+        directory_path = save_path.parent
+        directory_path.mkdir(parents=True, exist_ok=True)
+
+        # Fetch dictionary to save
+        agent_dict = self.dict()
+        if "_type" not in agent_dict:
+            msg = f"Agent {self} does not support saving"
+            raise NotImplementedError(msg)
+
+        if save_path.suffix == ".json":
+            with save_path.open("w") as f:
+                json.dump(agent_dict, f, indent=4)
+        elif save_path.suffix.endswith((".yaml", ".yml")):
+            with save_path.open("w") as f:
+                yaml.dump(agent_dict, f, default_flow_style=False)
+        else:
+            msg = f"{save_path} must be json or yaml"
+            raise ValueError(msg)
+
+    def tool_run_logging_kwargs(self) -> builtins.dict:
+        """Return logging kwargs for tool run."""
+        return {}
+
+
+class BaseMultiActionAgent(BaseModel):
+    """Base Multi Action Agent class."""
+
+    @property
+    def return_values(self) -> list[str]:
+        """Return values of the agent."""
+        return ["output"]
+
+    def get_allowed_tools(self) -> list[str] | None:
+        """Get allowed tools.
+
+        Returns:
+            Allowed tools.
+        """
+        return None
+
+    @abstractmethod
+    def plan(
+        self,
+        intermediate_steps: list[tuple[AgentAction, str]],
+        callbacks: Callbacks = None,
+        **kwargs: Any,
+    ) -> list[AgentAction] | AgentFinish:
+        """Given input, decided what to do.
+
+        Args:
+            intermediate_steps: Steps the LLM has taken to date,
+                along with the observations.
+            callbacks: Callbacks to run.
+            **kwargs: User inputs.
+
+        Returns:
+            Actions specifying what tool to use.
+        """
+
+    @abstractmethod
+    async def aplan(
+        self,
+        intermediate_steps: list[tuple[AgentAction, str]],
+        callbacks: Callbacks = None,
+        **kwargs: Any,
+    ) -> list[AgentAction] | AgentFinish:
+        """Async given input, decided what to do.
+
+        Args:
+            intermediate_steps: Steps the LLM has taken to date,
+                along with the observations.
+            callbacks: Callbacks to run.
+            **kwargs: User inputs.
+
+        Returns:
+            Actions specifying what tool to use.
+        """
+
+    @property
+    @abstractmethod
+    def input_keys(self) -> list[str]:
+        """Return the input keys."""
+
+    def return_stopped_response(
+        self,
+        early_stopping_method: str,
+        intermediate_steps: list[tuple[AgentAction, str]],  # noqa: ARG002
+        **_: Any,
+    ) -> AgentFinish:
+        """Return response when agent has been stopped due to max iterations.
+
+        Args:
+            early_stopping_method: Method to use for early stopping.
+            intermediate_steps: Steps the LLM has taken to date,
+                along with observations.
+
+        Returns:
+            Agent finish object.
+
+        Raises:
+            ValueError: If `early_stopping_method` is not supported.
+        """
+        if early_stopping_method == "force":
+            # `force` just returns a constant string
+            return AgentFinish({"output": "Agent stopped due to max iterations."}, "")
+        msg = f"Got unsupported early_stopping_method `{early_stopping_method}`"
+        raise ValueError(msg)
+
+    @property
+    def _agent_type(self) -> str:
+        """Return Identifier of an agent type."""
+        raise NotImplementedError
+
+    @override
+    def dict(self, **kwargs: Any) -> builtins.dict:
+        """Return dictionary representation of agent."""
+        _dict = super().model_dump()
+        with contextlib.suppress(NotImplementedError):
+            _dict["_type"] = str(self._agent_type)
+        return _dict
+
+    def save(self, file_path: Path | str) -> None:
+        """Save the agent.
+
+        Args:
+            file_path: Path to file to save the agent to.
+
+        Raises:
+            NotImplementedError: If agent does not support saving.
+            ValueError: If `file_path` is not json or yaml.
+
+        Example:
+        ```python
+        # If working with agent executor
+        agent.agent.save(file_path="path/agent.yaml")
+        ```
+        """
+        # Convert file to Path object.
+        save_path = Path(file_path) if isinstance(file_path, str) else file_path
+
+        # Fetch dictionary to save
+        agent_dict = self.dict()
+        if "_type" not in agent_dict:
+            msg = f"Agent {self} does not support saving."
+            raise NotImplementedError(msg)
+
+        directory_path = save_path.parent
+        directory_path.mkdir(parents=True, exist_ok=True)
+
+        if save_path.suffix == ".json":
+            with save_path.open("w") as f:
+                json.dump(agent_dict, f, indent=4)
+        elif save_path.suffix.endswith((".yaml", ".yml")):
+            with save_path.open("w") as f:
+                yaml.dump(agent_dict, f, default_flow_style=False)
+        else:
+            msg = f"{save_path} must be json or yaml"
+            raise ValueError(msg)
+
+    def tool_run_logging_kwargs(self) -> builtins.dict:
+        """Return logging kwargs for tool run."""
+        return {}
+
+
+class AgentOutputParser(BaseOutputParser[AgentAction | AgentFinish]):
+    """Base class for parsing agent output into agent action/finish."""
+
+    @abstractmethod
+    def parse(self, text: str) -> AgentAction | AgentFinish:
+        """Parse text into agent action/finish."""
+
+
+class MultiActionAgentOutputParser(
+    BaseOutputParser[list[AgentAction] | AgentFinish],
+):
+    """Base class for parsing agent output into agent actions/finish.
+
+    This is used for agents that can return multiple actions.
+    """
+
+    @abstractmethod
+    def parse(self, text: str) -> list[AgentAction] | AgentFinish:
+        """Parse text into agent actions/finish.
+
+        Args:
+            text: Text to parse.
+
+        Returns:
+            List of agent actions or agent finish.
+        """
+
+
+class RunnableAgent(BaseSingleActionAgent):
+    """Agent powered by Runnables."""
+
+    runnable: Runnable[dict, AgentAction | AgentFinish]
+    """Runnable to call to get agent action."""
+    input_keys_arg: list[str] = []
+    return_keys_arg: list[str] = []
+    stream_runnable: bool = True
+    """Whether to stream from the runnable or not.
+
+    If `True` then underlying LLM is invoked in a streaming fashion to make it possible
+        to get access to the individual LLM tokens when using stream_log with the
+        `AgentExecutor`. If `False` then LLM is invoked in a non-streaming fashion and
+        individual LLM tokens will not be available in stream_log.
+    """
+
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+    )
+
+    @property
+    def return_values(self) -> list[str]:
+        """Return values of the agent."""
+        return self.return_keys_arg
+
+    @property
+    def input_keys(self) -> list[str]:
+        """Return the input keys."""
+        return self.input_keys_arg
+
+    def plan(
+        self,
+        intermediate_steps: list[tuple[AgentAction, str]],
+        callbacks: Callbacks = None,
+        **kwargs: Any,
+    ) -> AgentAction | AgentFinish:
+        """Based on past history and current inputs, decide what to do.
+
+        Args:
+            intermediate_steps: Steps the LLM has taken to date,
+                along with the observations.
+            callbacks: Callbacks to run.
+            **kwargs: User inputs.
+
+        Returns:
+            Action specifying what tool to use.
+        """
+        inputs = {**kwargs, "intermediate_steps": intermediate_steps}
+        final_output: Any = None
+        if self.stream_runnable:
+            # Use streaming to make sure that the underlying LLM is invoked in a
+            # streaming
+            # fashion to make it possible to get access to the individual LLM tokens
+            # when using stream_log with the AgentExecutor.
+            # Because the response from the plan is not a generator, we need to
+            # accumulate the output into final output and return that.
+            for chunk in self.runnable.stream(inputs, config={"callbacks": callbacks}):
+                if final_output is None:
+                    final_output = chunk
+                else:
+                    final_output += chunk
+        else:
+            final_output = self.runnable.invoke(inputs, config={"callbacks": callbacks})
+
+        return final_output
+
+    async def aplan(
+        self,
+        intermediate_steps: list[tuple[AgentAction, str]],
+        callbacks: Callbacks = None,
+        **kwargs: Any,
+    ) -> AgentAction | AgentFinish:
+        """Async based on past history and current inputs, decide what to do.
+
+        Args:
+            intermediate_steps: Steps the LLM has taken to date,
+                along with observations.
+            callbacks: Callbacks to run.
+            **kwargs: User inputs.
+
+        Returns:
+            Action specifying what tool to use.
+        """
+        inputs = {**kwargs, "intermediate_steps": intermediate_steps}
+        final_output: Any = None
+        if self.stream_runnable:
+            # Use streaming to make sure that the underlying LLM is invoked in a
+            # streaming
+            # fashion to make it possible to get access to the individual LLM tokens
+            # when using stream_log with the AgentExecutor.
+            # Because the response from the plan is not a generator, we need to
+            # accumulate the output into final output and return that.
+            async for chunk in self.runnable.astream(
+                inputs,
+                config={"callbacks": callbacks},
+            ):
+                if final_output is None:
+                    final_output = chunk
+                else:
+                    final_output += chunk
+        else:
+            final_output = await self.runnable.ainvoke(
+                inputs,
+                config={"callbacks": callbacks},
+            )
+        return final_output
+
+
+class RunnableMultiActionAgent(BaseMultiActionAgent):
+    """Agent powered by Runnables."""
+
+    runnable: Runnable[dict, list[AgentAction] | AgentFinish]
+    """Runnable to call to get agent actions."""
+    input_keys_arg: list[str] = []
+    return_keys_arg: list[str] = []
+    stream_runnable: bool = True
+    """Whether to stream from the runnable or not.
+
+    If `True` then underlying LLM is invoked in a streaming fashion to make it possible
+        to get access to the individual LLM tokens when using stream_log with the
+        `AgentExecutor`. If `False` then LLM is invoked in a non-streaming fashion and
+        individual LLM tokens will not be available in stream_log.
+    """
+
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+    )
+
+    @property
+    def return_values(self) -> list[str]:
+        """Return values of the agent."""
+        return self.return_keys_arg
+
+    @property
+    def input_keys(self) -> list[str]:
+        """Return the input keys.
+
+        Returns:
+            List of input keys.
+        """
+        return self.input_keys_arg
+
+    def plan(
+        self,
+        intermediate_steps: list[tuple[AgentAction, str]],
+        callbacks: Callbacks = None,
+        **kwargs: Any,
+    ) -> list[AgentAction] | AgentFinish:
+        """Based on past history and current inputs, decide what to do.
+
+        Args:
+            intermediate_steps: Steps the LLM has taken to date,
+                along with the observations.
+            callbacks: Callbacks to run.
+            **kwargs: User inputs.
+
+        Returns:
+            Action specifying what tool to use.
+        """
+        inputs = {**kwargs, "intermediate_steps": intermediate_steps}
+        final_output: Any = None
+        if self.stream_runnable:
+            # Use streaming to make sure that the underlying LLM is invoked in a
+            # streaming
+            # fashion to make it possible to get access to the individual LLM tokens
+            # when using stream_log with the AgentExecutor.
+            # Because the response from the plan is not a generator, we need to
+            # accumulate the output into final output and return that.
+            for chunk in self.runnable.stream(inputs, config={"callbacks": callbacks}):
+                if final_output is None:
+                    final_output = chunk
+                else:
+                    final_output += chunk
+        else:
+            final_output = self.runnable.invoke(inputs, config={"callbacks": callbacks})
+
+        return final_output
+
+    async def aplan(
+        self,
+        intermediate_steps: list[tuple[AgentAction, str]],
+        callbacks: Callbacks = None,
+        **kwargs: Any,
+    ) -> list[AgentAction] | AgentFinish:
+        """Async based on past history and current inputs, decide what to do.
+
+        Args:
+            intermediate_steps: Steps the LLM has taken to date,
+                along with observations.
+            callbacks: Callbacks to run.
+            **kwargs: User inputs.
+
+        Returns:
+            Action specifying what tool to use.
+        """
+        inputs = {**kwargs, "intermediate_steps": intermediate_steps}
+        final_output: Any = None
+        if self.stream_runnable:
+            # Use streaming to make sure that the underlying LLM is invoked in a
+            # streaming
+            # fashion to make it possible to get access to the individual LLM tokens
+            # when using stream_log with the AgentExecutor.
+            # Because the response from the plan is not a generator, we need to
+            # accumulate the output into final output and return that.
+            async for chunk in self.runnable.astream(
+                inputs,
+                config={"callbacks": callbacks},
+            ):
+                if final_output is None:
+                    final_output = chunk
+                else:
+                    final_output += chunk
+        else:
+            final_output = await self.runnable.ainvoke(
+                inputs,
+                config={"callbacks": callbacks},
+            )
+
+        return final_output
+
+
+@deprecated(
+    "0.1.0",
+    message=AGENT_DEPRECATION_WARNING,
+    removal="2.0.0",
+)
+class LLMSingleActionAgent(BaseSingleActionAgent):
+    """Base class for single action agents."""
+
+    llm_chain: LLMChain
+    """LLMChain to use for agent."""
+    output_parser: AgentOutputParser
+    """Output parser to use for agent."""
+    stop: list[str]
+    """List of strings to stop on."""
+
+    @property
+    def input_keys(self) -> list[str]:
+        """Return the input keys.
+
+        Returns:
+            List of input keys.
+        """
+        return list(set(self.llm_chain.input_keys) - {"intermediate_steps"})
+
+    @override
+    def dict(self, **kwargs: Any) -> builtins.dict:
+        """Return dictionary representation of agent."""
+        _dict = super().dict()
+        del _dict["output_parser"]
+        return _dict
+
+    def plan(
+        self,
+        intermediate_steps: list[tuple[AgentAction, str]],
+        callbacks: Callbacks = None,
+        **kwargs: Any,
+    ) -> AgentAction | AgentFinish:
+        """Given input, decided what to do.
+
+        Args:
+            intermediate_steps: Steps the LLM has taken to date,
+                along with the observations.
+            callbacks: Callbacks to run.
+            **kwargs: User inputs.
+
+        Returns:
+            Action specifying what tool to use.
+        """
+        output = self.llm_chain.run(
+            intermediate_steps=intermediate_steps,
+            stop=self.stop,
+            callbacks=callbacks,
+            **kwargs,
+        )
+        return self.output_parser.parse(output)
+
+    async def aplan(
+        self,
+        intermediate_steps: list[tuple[AgentAction, str]],
+        callbacks: Callbacks = None,
+        **kwargs: Any,
+    ) -> 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 run.
+            **kwargs: User inputs.
+
+        Returns:
+            Action specifying what tool to use.
+        """
+        output = await self.llm_chain.arun(
+            intermediate_steps=intermediate_steps,
+            stop=self.stop,
+            callbacks=callbacks,
+            **kwargs,
+        )
+        return self.output_parser.parse(output)
+
+    def tool_run_logging_kwargs(self) -> builtins.dict:
+        """Return logging kwargs for tool run."""
+        return {
+            "llm_prefix": "",
+            "observation_prefix": "" if len(self.stop) == 0 else self.stop[0],
+        }
+
+
+@deprecated(
+    "0.1.0",
+    message=AGENT_DEPRECATION_WARNING,
+    removal="2.0.0",
+)
+class Agent(BaseSingleActionAgent):
+    """Agent that calls the language model and deciding the action.
+
+    This is driven by a LLMChain. The prompt in the LLMChain MUST include
+    a variable called "agent_scratchpad" where the agent can put its
+    intermediary work.
+    """
+
+    llm_chain: LLMChain
+    """LLMChain to use for agent."""
+    output_parser: AgentOutputParser
+    """Output parser to use for agent."""
+    allowed_tools: list[str] | None = None
+    """Allowed tools for the agent. If `None`, all tools are allowed."""
+
+    @override
+    def dict(self, **kwargs: Any) -> builtins.dict:
+        """Return dictionary representation of agent."""
+        _dict = super().dict()
+        del _dict["output_parser"]
+        return _dict
+
+    def get_allowed_tools(self) -> list[str] | None:
+        """Get allowed tools."""
+        return self.allowed_tools
+
+    @property
+    def return_values(self) -> list[str]:
+        """Return values of the agent."""
+        return ["output"]
+
+    @property
+    def _stop(self) -> list[str]:
+        return [
+            f"\n{self.observation_prefix.rstrip()}",
+            f"\n\t{self.observation_prefix.rstrip()}",
+        ]
+
+    def _construct_scratchpad(
+        self,
+        intermediate_steps: list[tuple[AgentAction, str]],
+    ) -> str | list[BaseMessage]:
+        """Construct the scratchpad that lets the agent continue its thought process."""
+        thoughts = ""
+        for action, observation in intermediate_steps:
+            thoughts += action.log
+            thoughts += f"\n{self.observation_prefix}{observation}\n{self.llm_prefix}"
+        return thoughts
+
+    def plan(
+        self,
+        intermediate_steps: list[tuple[AgentAction, str]],
+        callbacks: Callbacks = None,
+        **kwargs: Any,
+    ) -> AgentAction | AgentFinish:
+        """Given input, decided what to do.
+
+        Args:
+            intermediate_steps: Steps the LLM has taken to date,
+                along with observations.
+            callbacks: Callbacks to run.
+            **kwargs: User inputs.
+
+        Returns:
+            Action specifying what tool to use.
+        """
+        full_inputs = self.get_full_inputs(intermediate_steps, **kwargs)
+        full_output = self.llm_chain.predict(callbacks=callbacks, **full_inputs)
+        return self.output_parser.parse(full_output)
+
+    async def aplan(
+        self,
+        intermediate_steps: list[tuple[AgentAction, str]],
+        callbacks: Callbacks = None,
+        **kwargs: Any,
+    ) -> 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 run.
+            **kwargs: User inputs.
+
+        Returns:
+            Action specifying what tool to use.
+        """
+        full_inputs = self.get_full_inputs(intermediate_steps, **kwargs)
+        full_output = await self.llm_chain.apredict(callbacks=callbacks, **full_inputs)
+        return await self.output_parser.aparse(full_output)
+
+    def get_full_inputs(
+        self,
+        intermediate_steps: list[tuple[AgentAction, str]],
+        **kwargs: Any,
+    ) -> builtins.dict[str, Any]:
+        """Create the full inputs for the LLMChain from intermediate steps.
+
+        Args:
+            intermediate_steps: Steps the LLM has taken to date,
+                along with observations.
+            **kwargs: User inputs.
+
+        Returns:
+            Full inputs for the LLMChain.
+        """
+        thoughts = self._construct_scratchpad(intermediate_steps)
+        new_inputs = {"agent_scratchpad": thoughts, "stop": self._stop}
+        return {**kwargs, **new_inputs}
+
+    @property
+    def input_keys(self) -> list[str]:
+        """Return the input keys."""
+        return list(set(self.llm_chain.input_keys) - {"agent_scratchpad"})
+
+    @model_validator(mode="after")
+    def validate_prompt(self) -> Self:
+        """Validate that prompt matches format.
+
+        Args:
+            values: Values to validate.
+
+        Returns:
+            Validated values.
+
+        Raises:
+            ValueError: If `agent_scratchpad` is not in prompt.input_variables
+                and prompt is not a FewShotPromptTemplate or a PromptTemplate.
+        """
+        prompt = self.llm_chain.prompt
+        if "agent_scratchpad" not in prompt.input_variables:
+            logger.warning(
+                "`agent_scratchpad` should be a variable in prompt.input_variables."
+                " Did not find it, so adding it at the end.",
+            )
+            prompt.input_variables.append("agent_scratchpad")
+            if isinstance(prompt, PromptTemplate):
+                prompt.template += "\n{agent_scratchpad}"
+            elif isinstance(prompt, FewShotPromptTemplate):
+                prompt.suffix += "\n{agent_scratchpad}"
+            else:
+                msg = f"Got unexpected prompt type {type(prompt)}"
+                raise ValueError(msg)
+        return self
+
+    @property
+    @abstractmethod
+    def observation_prefix(self) -> str:
+        """Prefix to append the observation with."""
+
+    @property
+    @abstractmethod
+    def llm_prefix(self) -> str:
+        """Prefix to append the LLM call with."""
+
+    @classmethod
+    @abstractmethod
+    def create_prompt(cls, tools: Sequence[BaseTool]) -> BasePromptTemplate:
+        """Create a prompt for this class.
+
+        Args:
+            tools: Tools to use.
+
+        Returns:
+            Prompt template.
+        """
+
+    @classmethod
+    def _validate_tools(cls, tools: Sequence[BaseTool]) -> None:
+        """Validate that appropriate tools are passed in.
+
+        Args:
+            tools: Tools to use.
+        """
+
+    @classmethod
+    @abstractmethod
+    def _get_default_output_parser(cls, **kwargs: Any) -> AgentOutputParser:
+        """Get default output parser for this class."""
+
+    @classmethod
+    def from_llm_and_tools(
+        cls,
+        llm: BaseLanguageModel,
+        tools: Sequence[BaseTool],
+        callback_manager: BaseCallbackManager | None = None,
+        output_parser: AgentOutputParser | None = None,
+        **kwargs: Any,
+    ) -> Agent:
+        """Construct an agent from an LLM and tools.
+
+        Args:
+            llm: Language model to use.
+            tools: Tools to use.
+            callback_manager: Callback manager to use.
+            output_parser: Output parser to use.
+            kwargs: Additional arguments.
+
+        Returns:
+            Agent object.
+        """
+        cls._validate_tools(tools)
+        llm_chain = LLMChain(
+            llm=llm,
+            prompt=cls.create_prompt(tools),
+            callback_manager=callback_manager,
+        )
+        tool_names = [tool.name for tool in tools]
+        _output_parser = output_parser or cls._get_default_output_parser()
+        return cls(
+            llm_chain=llm_chain,
+            allowed_tools=tool_names,
+            output_parser=_output_parser,
+            **kwargs,
+        )
+
+    def return_stopped_response(
+        self,
+        early_stopping_method: str,
+        intermediate_steps: list[tuple[AgentAction, str]],
+        **kwargs: Any,
+    ) -> AgentFinish:
+        """Return response when agent has been stopped due to max iterations.
+
+        Args:
+            early_stopping_method: Method to use for early stopping.
+            intermediate_steps: Steps the LLM has taken to date,
+                along with observations.
+            **kwargs: User inputs.
+
+        Returns:
+            Agent finish object.
+
+        Raises:
+            ValueError: If `early_stopping_method` is not in ['force', 'generate'].
+        """
+        if early_stopping_method == "force":
+            # `force` just returns a constant string
+            return AgentFinish(
+                {"output": "Agent stopped due to iteration limit or time limit."},
+                "",
+            )
+        if early_stopping_method == "generate":
+            # Generate does one final forward pass
+            thoughts = ""
+            for action, observation in intermediate_steps:
+                thoughts += action.log
+                thoughts += (
+                    f"\n{self.observation_prefix}{observation}\n{self.llm_prefix}"
+                )
+            # Adding to the previous steps, we now tell the LLM to make a final pred
+            thoughts += (
+                "\n\nI now need to return a final answer based on the previous steps:"
+            )
+            new_inputs = {"agent_scratchpad": thoughts, "stop": self._stop}
+            full_inputs = {**kwargs, **new_inputs}
+            full_output = self.llm_chain.predict(**full_inputs)
+            # We try to extract a final answer
+            parsed_output = self.output_parser.parse(full_output)
+            if isinstance(parsed_output, AgentFinish):
+                # If we can extract, we send the correct stuff
+                return parsed_output
+            # If we can extract, but the tool is not the final tool,
+            # we just return the full output
+            return AgentFinish({"output": full_output}, full_output)
+        msg = (
+            "early_stopping_method should be one of `force` or `generate`, "
+            f"got {early_stopping_method}"
+        )
+        raise ValueError(msg)
+
+    def tool_run_logging_kwargs(self) -> builtins.dict:
+        """Return logging kwargs for tool run."""
+        return {
+            "llm_prefix": self.llm_prefix,
+            "observation_prefix": self.observation_prefix,
+        }
+
+
+class ExceptionTool(BaseTool):
+    """Tool that just returns the query."""
+
+    name: str = "_Exception"
+    """Name of the tool."""
+    description: str = "Exception tool"
+    """Description of the tool."""
+
+    @override
+    def _run(
+        self,
+        query: str,
+        run_manager: CallbackManagerForToolRun | None = None,
+    ) -> str:
+        return query
+
+    @override
+    async def _arun(
+        self,
+        query: str,
+        run_manager: AsyncCallbackManagerForToolRun | None = None,
+    ) -> str:
+        return query
+
+
+NextStepOutput = list[AgentFinish | AgentAction | AgentStep]
+RunnableAgentType = RunnableAgent | RunnableMultiActionAgent
+
+
+class AgentExecutor(Chain):
+    """Agent that is using tools."""
+
+    agent: BaseSingleActionAgent | BaseMultiActionAgent | Runnable
+    """The agent to run for creating a plan and determining actions
+    to take at each step of the execution loop."""
+    tools: Sequence[BaseTool]
+    """The valid tools the agent can call."""
+    return_intermediate_steps: bool = False
+    """Whether to return the agent's trajectory of intermediate steps
+    at the end in addition to the final output."""
+    max_iterations: int | None = 15
+    """The maximum number of steps to take before ending the execution
+    loop.
+
+    Setting to 'None' could lead to an infinite loop."""
+    max_execution_time: float | None = None
+    """The maximum amount of wall clock time to spend in the execution
+    loop.
+    """
+    early_stopping_method: str = "force"
+    """The method to use for early stopping if the agent never
+    returns `AgentFinish`. Either 'force' or 'generate'.
+
+    `"force"` returns a string saying that it stopped because it met a
+        time or iteration limit.
+
+    `"generate"` calls the agent's LLM Chain one final time to generate
+        a final answer based on the previous steps.
+    """
+    handle_parsing_errors: bool | str | Callable[[OutputParserException], str] = False
+    """How to handle errors raised by the agent's output parser.
+    Defaults to `False`, which raises the error.
+    If `true`, the error will be sent back to the LLM as an observation.
+    If a string, the string itself will be sent to the LLM as an observation.
+    If a callable function, the function will be called with the exception as an
+    argument, and the result of that function will be passed to the agent as an
+    observation.
+    """
+    trim_intermediate_steps: (
+        int | Callable[[list[tuple[AgentAction, str]]], list[tuple[AgentAction, str]]]
+    ) = -1
+    """How to trim the intermediate steps before returning them.
+    Defaults to -1, which means no trimming.
+    """
+
+    @classmethod
+    def from_agent_and_tools(
+        cls,
+        agent: BaseSingleActionAgent | BaseMultiActionAgent | Runnable,
+        tools: Sequence[BaseTool],
+        callbacks: Callbacks = None,
+        **kwargs: Any,
+    ) -> AgentExecutor:
+        """Create from agent and tools.
+
+        Args:
+            agent: Agent to use.
+            tools: Tools to use.
+            callbacks: Callbacks to use.
+            kwargs: Additional arguments.
+
+        Returns:
+            Agent executor object.
+        """
+        return cls(
+            agent=agent,
+            tools=tools,
+            callbacks=callbacks,
+            **kwargs,
+        )
+
+    @model_validator(mode="after")
+    def validate_tools(self) -> Self:
+        """Validate that tools are compatible with agent.
+
+        Args:
+            values: Values to validate.
+
+        Returns:
+            Validated values.
+
+        Raises:
+            ValueError: If allowed tools are different than provided tools.
+        """
+        agent = self.agent
+        tools = self.tools
+        allowed_tools = agent.get_allowed_tools()  # type: ignore[union-attr]
+        if allowed_tools is not None and set(allowed_tools) != {
+            tool.name for tool in tools
+        }:
+            msg = (
+                f"Allowed tools ({allowed_tools}) different than "
+                f"provided tools ({[tool.name for tool in tools]})"
+            )
+            raise ValueError(msg)
+        return self
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_runnable_agent(cls, values: dict) -> Any:
+        """Convert runnable to agent if passed in.
+
+        Args:
+            values: Values to validate.
+
+        Returns:
+            Validated values.
+        """
+        agent = values.get("agent")
+        if agent and isinstance(agent, Runnable):
+            try:
+                output_type = agent.OutputType
+            except TypeError:
+                multi_action = False
+            except Exception:
+                logger.exception("Unexpected error getting OutputType from agent")
+                multi_action = False
+            else:
+                multi_action = output_type == list[AgentAction] | AgentFinish
+
+            stream_runnable = values.pop("stream_runnable", True)
+            if multi_action:
+                values["agent"] = RunnableMultiActionAgent(
+                    runnable=agent,
+                    stream_runnable=stream_runnable,
+                )
+            else:
+                values["agent"] = RunnableAgent(
+                    runnable=agent,
+                    stream_runnable=stream_runnable,
+                )
+        return values
+
+    @property
+    def _action_agent(self) -> BaseSingleActionAgent | BaseMultiActionAgent:
+        """Type cast self.agent.
+
+        If the `agent` attribute is a Runnable, it will be converted one of
+        RunnableAgentType in the validate_runnable_agent root_validator.
+
+        To support instantiating with a Runnable, here we explicitly cast the type
+        to reflect the changes made in the root_validator.
+        """
+        if isinstance(self.agent, Runnable):
+            return cast("RunnableAgentType", self.agent)
+        return self.agent
+
+    @override
+    def save(self, file_path: Path | str) -> None:
+        """Raise error - saving not supported for Agent Executors.
+
+        Args:
+            file_path: Path to save to.
+
+        Raises:
+            ValueError: Saving not supported for agent executors.
+        """
+        msg = (
+            "Saving not supported for agent executors. "
+            "If you are trying to save the agent, please use the "
+            "`.save_agent(...)`"
+        )
+        raise ValueError(msg)
+
+    def save_agent(self, file_path: Path | str) -> None:
+        """Save the underlying agent.
+
+        Args:
+            file_path: Path to save to.
+        """
+        return self._action_agent.save(file_path)
+
+    def iter(
+        self,
+        inputs: Any,
+        callbacks: Callbacks = None,
+        *,
+        include_run_info: bool = False,
+        async_: bool = False,  # noqa: ARG002 arg kept for backwards compat, but ignored
+    ) -> AgentExecutorIterator:
+        """Enables iteration over steps taken to reach final output.
+
+        Args:
+            inputs: Inputs to the agent.
+            callbacks: Callbacks to run.
+            include_run_info: Whether to include run info.
+            async_: Whether to run async. (Ignored)
+
+        Returns:
+            Agent executor iterator object.
+        """
+        return AgentExecutorIterator(
+            self,
+            inputs,
+            callbacks,
+            tags=self.tags,
+            include_run_info=include_run_info,
+        )
+
+    @property
+    def input_keys(self) -> list[str]:
+        """Return the input keys."""
+        return self._action_agent.input_keys
+
+    @property
+    def output_keys(self) -> list[str]:
+        """Return the singular output key."""
+        if self.return_intermediate_steps:
+            return [*self._action_agent.return_values, "intermediate_steps"]
+        return self._action_agent.return_values
+
+    def lookup_tool(self, name: str) -> BaseTool:
+        """Lookup tool by name.
+
+        Args:
+            name: Name of tool.
+
+        Returns:
+            Tool object.
+        """
+        return {tool.name: tool for tool in self.tools}[name]
+
+    def _should_continue(self, iterations: int, time_elapsed: float) -> bool:
+        if self.max_iterations is not None and iterations >= self.max_iterations:
+            return False
+        return self.max_execution_time is None or time_elapsed < self.max_execution_time
+
+    def _return(
+        self,
+        output: AgentFinish,
+        intermediate_steps: list,
+        run_manager: CallbackManagerForChainRun | None = None,
+    ) -> dict[str, Any]:
+        if run_manager:
+            run_manager.on_agent_finish(output, color="green", verbose=self.verbose)
+        final_output = output.return_values
+        if self.return_intermediate_steps:
+            final_output["intermediate_steps"] = intermediate_steps
+        return final_output
+
+    async def _areturn(
+        self,
+        output: AgentFinish,
+        intermediate_steps: list,
+        run_manager: AsyncCallbackManagerForChainRun | None = None,
+    ) -> dict[str, Any]:
+        if run_manager:
+            await run_manager.on_agent_finish(
+                output,
+                color="green",
+                verbose=self.verbose,
+            )
+        final_output = output.return_values
+        if self.return_intermediate_steps:
+            final_output["intermediate_steps"] = intermediate_steps
+        return final_output
+
+    def _consume_next_step(
+        self,
+        values: NextStepOutput,
+    ) -> AgentFinish | list[tuple[AgentAction, str]]:
+        if isinstance(values[-1], AgentFinish):
+            if len(values) != 1:
+                msg = "Expected a single AgentFinish output, but got multiple values."
+                raise ValueError(msg)
+            return values[-1]
+        return [(a.action, a.observation) for a in values if isinstance(a, AgentStep)]
+
+    def _take_next_step(
+        self,
+        name_to_tool_map: dict[str, BaseTool],
+        color_mapping: dict[str, str],
+        inputs: dict[str, str],
+        intermediate_steps: list[tuple[AgentAction, str]],
+        run_manager: CallbackManagerForChainRun | None = None,
+    ) -> AgentFinish | list[tuple[AgentAction, str]]:
+        return self._consume_next_step(
+            list(
+                self._iter_next_step(
+                    name_to_tool_map,
+                    color_mapping,
+                    inputs,
+                    intermediate_steps,
+                    run_manager,
+                ),
+            ),
+        )
+
+    def _iter_next_step(
+        self,
+        name_to_tool_map: dict[str, BaseTool],
+        color_mapping: dict[str, str],
+        inputs: dict[str, str],
+        intermediate_steps: list[tuple[AgentAction, str]],
+        run_manager: CallbackManagerForChainRun | None = None,
+    ) -> Iterator[AgentFinish | AgentAction | AgentStep]:
+        """Take a single step in the thought-action-observation loop.
+
+        Override this to take control of how the agent makes and acts on choices.
+        """
+        try:
+            intermediate_steps = self._prepare_intermediate_steps(intermediate_steps)
+
+            # Call the LLM to see what to do.
+            output = self._action_agent.plan(
+                intermediate_steps,
+                callbacks=run_manager.get_child() if run_manager else None,
+                **inputs,
+            )
+        except OutputParserException as e:
+            if isinstance(self.handle_parsing_errors, bool):
+                raise_error = not self.handle_parsing_errors
+            else:
+                raise_error = False
+            if raise_error:
+                msg = (
+                    "An output parsing error occurred. "
+                    "In order to pass this error back to the agent and have it try "
+                    "again, pass `handle_parsing_errors=True` to the AgentExecutor. "
+                    f"This is the error: {e!s}"
+                )
+                raise ValueError(msg) from e
+            text = str(e)
+            if isinstance(self.handle_parsing_errors, bool):
+                if e.send_to_llm:
+                    observation = str(e.observation)
+                    text = str(e.llm_output)
+                else:
+                    observation = "Invalid or incomplete response"
+            elif isinstance(self.handle_parsing_errors, str):
+                observation = self.handle_parsing_errors
+            elif callable(self.handle_parsing_errors):
+                observation = self.handle_parsing_errors(e)
+            else:
+                msg = "Got unexpected type of `handle_parsing_errors`"  # type: ignore[unreachable]
+                raise ValueError(msg) from e  # noqa: TRY004
+            output = AgentAction("_Exception", observation, text)
+            if run_manager:
+                run_manager.on_agent_action(output, color="green")
+            tool_run_kwargs = self._action_agent.tool_run_logging_kwargs()
+            observation = ExceptionTool().run(
+                output.tool_input,
+                verbose=self.verbose,
+                color=None,
+                callbacks=run_manager.get_child() if run_manager else None,
+                **tool_run_kwargs,
+            )
+            yield AgentStep(action=output, observation=observation)
+            return
+
+        # If the tool chosen is the finishing tool, then we end and return.
+        if isinstance(output, AgentFinish):
+            yield output
+            return
+
+        actions: list[AgentAction]
+        actions = [output] if isinstance(output, AgentAction) else output
+        for agent_action in actions:
+            yield agent_action
+        for agent_action in actions:
+            yield self._perform_agent_action(
+                name_to_tool_map,
+                color_mapping,
+                agent_action,
+                run_manager,
+            )
+
+    def _perform_agent_action(
+        self,
+        name_to_tool_map: dict[str, BaseTool],
+        color_mapping: dict[str, str],
+        agent_action: AgentAction,
+        run_manager: CallbackManagerForChainRun | None = None,
+    ) -> AgentStep:
+        if run_manager:
+            run_manager.on_agent_action(agent_action, color="green")
+        # Otherwise we lookup the tool
+        if agent_action.tool in name_to_tool_map:
+            tool = name_to_tool_map[agent_action.tool]
+            return_direct = tool.return_direct
+            color = color_mapping[agent_action.tool]
+            tool_run_kwargs = self._action_agent.tool_run_logging_kwargs()
+            if return_direct:
+                tool_run_kwargs["llm_prefix"] = ""
+            # We then call the tool on the tool input to get an observation
+            observation = tool.run(
+                agent_action.tool_input,
+                verbose=self.verbose,
+                color=color,
+                callbacks=run_manager.get_child() if run_manager else None,
+                **tool_run_kwargs,
+            )
+        else:
+            tool_run_kwargs = self._action_agent.tool_run_logging_kwargs()
+            observation = InvalidTool().run(
+                {
+                    "requested_tool_name": agent_action.tool,
+                    "available_tool_names": list(name_to_tool_map.keys()),
+                },
+                verbose=self.verbose,
+                color=None,
+                callbacks=run_manager.get_child() if run_manager else None,
+                **tool_run_kwargs,
+            )
+        return AgentStep(action=agent_action, observation=observation)
+
+    async def _atake_next_step(
+        self,
+        name_to_tool_map: dict[str, BaseTool],
+        color_mapping: dict[str, str],
+        inputs: dict[str, str],
+        intermediate_steps: list[tuple[AgentAction, str]],
+        run_manager: AsyncCallbackManagerForChainRun | None = None,
+    ) -> AgentFinish | list[tuple[AgentAction, str]]:
+        return self._consume_next_step(
+            [
+                a
+                async for a in self._aiter_next_step(
+                    name_to_tool_map,
+                    color_mapping,
+                    inputs,
+                    intermediate_steps,
+                    run_manager,
+                )
+            ],
+        )
+
+    async def _aiter_next_step(
+        self,
+        name_to_tool_map: dict[str, BaseTool],
+        color_mapping: dict[str, str],
+        inputs: dict[str, str],
+        intermediate_steps: list[tuple[AgentAction, str]],
+        run_manager: AsyncCallbackManagerForChainRun | None = None,
+    ) -> AsyncIterator[AgentFinish | AgentAction | AgentStep]:
+        """Take a single step in the thought-action-observation loop.
+
+        Override this to take control of how the agent makes and acts on choices.
+        """
+        try:
+            intermediate_steps = self._prepare_intermediate_steps(intermediate_steps)
+
+            # Call the LLM to see what to do.
+            output = await self._action_agent.aplan(
+                intermediate_steps,
+                callbacks=run_manager.get_child() if run_manager else None,
+                **inputs,
+            )
+        except OutputParserException as e:
+            if isinstance(self.handle_parsing_errors, bool):
+                raise_error = not self.handle_parsing_errors
+            else:
+                raise_error = False
+            if raise_error:
+                msg = (
+                    "An output parsing error occurred. "
+                    "In order to pass this error back to the agent and have it try "
+                    "again, pass `handle_parsing_errors=True` to the AgentExecutor. "
+                    f"This is the error: {e!s}"
+                )
+                raise ValueError(msg) from e
+            text = str(e)
+            if isinstance(self.handle_parsing_errors, bool):
+                if e.send_to_llm:
+                    observation = str(e.observation)
+                    text = str(e.llm_output)
+                else:
+                    observation = "Invalid or incomplete response"
+            elif isinstance(self.handle_parsing_errors, str):
+                observation = self.handle_parsing_errors
+            elif callable(self.handle_parsing_errors):
+                observation = self.handle_parsing_errors(e)
+            else:
+                msg = "Got unexpected type of `handle_parsing_errors`"  # type: ignore[unreachable]
+                raise ValueError(msg) from e  # noqa: TRY004
+            output = AgentAction("_Exception", observation, text)
+            tool_run_kwargs = self._action_agent.tool_run_logging_kwargs()
+            observation = await ExceptionTool().arun(
+                output.tool_input,
+                verbose=self.verbose,
+                color=None,
+                callbacks=run_manager.get_child() if run_manager else None,
+                **tool_run_kwargs,
+            )
+            yield AgentStep(action=output, observation=observation)
+            return
+
+        # If the tool chosen is the finishing tool, then we end and return.
+        if isinstance(output, AgentFinish):
+            yield output
+            return
+
+        actions: list[AgentAction]
+        actions = [output] if isinstance(output, AgentAction) else output
+        for agent_action in actions:
+            yield agent_action
+
+        # Use asyncio.gather to run multiple tool.arun() calls concurrently
+        result = await asyncio.gather(
+            *[
+                self._aperform_agent_action(
+                    name_to_tool_map,
+                    color_mapping,
+                    agent_action,
+                    run_manager,
+                )
+                for agent_action in actions
+            ],
+        )
+
+        # TODO: This could yield each result as it becomes available
+        for chunk in result:
+            yield chunk
+
+    async def _aperform_agent_action(
+        self,
+        name_to_tool_map: dict[str, BaseTool],
+        color_mapping: dict[str, str],
+        agent_action: AgentAction,
+        run_manager: AsyncCallbackManagerForChainRun | None = None,
+    ) -> AgentStep:
+        if run_manager:
+            await run_manager.on_agent_action(
+                agent_action,
+                verbose=self.verbose,
+                color="green",
+            )
+        # Otherwise we lookup the tool
+        if agent_action.tool in name_to_tool_map:
+            tool = name_to_tool_map[agent_action.tool]
+            return_direct = tool.return_direct
+            color = color_mapping[agent_action.tool]
+            tool_run_kwargs = self._action_agent.tool_run_logging_kwargs()
+            if return_direct:
+                tool_run_kwargs["llm_prefix"] = ""
+            # We then call the tool on the tool input to get an observation
+            observation = await tool.arun(
+                agent_action.tool_input,
+                verbose=self.verbose,
+                color=color,
+                callbacks=run_manager.get_child() if run_manager else None,
+                **tool_run_kwargs,
+            )
+        else:
+            tool_run_kwargs = self._action_agent.tool_run_logging_kwargs()
+            observation = await InvalidTool().arun(
+                {
+                    "requested_tool_name": agent_action.tool,
+                    "available_tool_names": list(name_to_tool_map.keys()),
+                },
+                verbose=self.verbose,
+                color=None,
+                callbacks=run_manager.get_child() if run_manager else None,
+                **tool_run_kwargs,
+            )
+        return AgentStep(action=agent_action, observation=observation)
+
+    def _call(
+        self,
+        inputs: dict[str, str],
+        run_manager: CallbackManagerForChainRun | None = None,
+    ) -> dict[str, Any]:
+        """Run text through and get agent response."""
+        # Construct a mapping of tool name to tool for easy lookup
+        name_to_tool_map = {tool.name: tool for tool in self.tools}
+        # We construct a mapping from each tool to a color, used for logging.
+        color_mapping = get_color_mapping(
+            [tool.name for tool in self.tools],
+            excluded_colors=["green", "red"],
+        )
+        intermediate_steps: list[tuple[AgentAction, str]] = []
+        # Let's start tracking the number of iterations and time elapsed
+        iterations = 0
+        time_elapsed = 0.0
+        start_time = time.time()
+        # We now enter the agent loop (until it returns something).
+        while self._should_continue(iterations, time_elapsed):
+            next_step_output = self._take_next_step(
+                name_to_tool_map,
+                color_mapping,
+                inputs,
+                intermediate_steps,
+                run_manager=run_manager,
+            )
+            if isinstance(next_step_output, AgentFinish):
+                return self._return(
+                    next_step_output,
+                    intermediate_steps,
+                    run_manager=run_manager,
+                )
+
+            intermediate_steps.extend(next_step_output)
+            if len(next_step_output) == 1:
+                next_step_action = next_step_output[0]
+                # See if tool should return directly
+                tool_return = self._get_tool_return(next_step_action)
+                if tool_return is not None:
+                    return self._return(
+                        tool_return,
+                        intermediate_steps,
+                        run_manager=run_manager,
+                    )
+            iterations += 1
+            time_elapsed = time.time() - start_time
+        output = self._action_agent.return_stopped_response(
+            self.early_stopping_method,
+            intermediate_steps,
+            **inputs,
+        )
+        return self._return(output, intermediate_steps, run_manager=run_manager)
+
+    async def _acall(
+        self,
+        inputs: dict[str, str],
+        run_manager: AsyncCallbackManagerForChainRun | None = None,
+    ) -> dict[str, str]:
+        """Async run text through and get agent response."""
+        # Construct a mapping of tool name to tool for easy lookup
+        name_to_tool_map = {tool.name: tool for tool in self.tools}
+        # We construct a mapping from each tool to a color, used for logging.
+        color_mapping = get_color_mapping(
+            [tool.name for tool in self.tools],
+            excluded_colors=["green"],
+        )
+        intermediate_steps: list[tuple[AgentAction, str]] = []
+        # Let's start tracking the number of iterations and time elapsed
+        iterations = 0
+        time_elapsed = 0.0
+        start_time = time.time()
+        # We now enter the agent loop (until it returns something).
+        try:
+            async with asyncio_timeout(self.max_execution_time):
+                while self._should_continue(iterations, time_elapsed):
+                    next_step_output = await self._atake_next_step(
+                        name_to_tool_map,
+                        color_mapping,
+                        inputs,
+                        intermediate_steps,
+                        run_manager=run_manager,
+                    )
+                    if isinstance(next_step_output, AgentFinish):
+                        return await self._areturn(
+                            next_step_output,
+                            intermediate_steps,
+                            run_manager=run_manager,
+                        )
+
+                    intermediate_steps.extend(next_step_output)
+                    if len(next_step_output) == 1:
+                        next_step_action = next_step_output[0]
+                        # See if tool should return directly
+                        tool_return = self._get_tool_return(next_step_action)
+                        if tool_return is not None:
+                            return await self._areturn(
+                                tool_return,
+                                intermediate_steps,
+                                run_manager=run_manager,
+                            )
+
+                    iterations += 1
+                    time_elapsed = time.time() - start_time
+                output = self._action_agent.return_stopped_response(
+                    self.early_stopping_method,
+                    intermediate_steps,
+                    **inputs,
+                )
+                return await self._areturn(
+                    output,
+                    intermediate_steps,
+                    run_manager=run_manager,
+                )
+        except (TimeoutError, asyncio.TimeoutError):
+            # stop early when interrupted by the async timeout
+            output = self._action_agent.return_stopped_response(
+                self.early_stopping_method,
+                intermediate_steps,
+                **inputs,
+            )
+            return await self._areturn(
+                output,
+                intermediate_steps,
+                run_manager=run_manager,
+            )
+
+    def _get_tool_return(
+        self,
+        next_step_output: tuple[AgentAction, str],
+    ) -> AgentFinish | None:
+        """Check if the tool is a returning tool."""
+        agent_action, observation = next_step_output
+        name_to_tool_map = {tool.name: tool for tool in self.tools}
+        return_value_key = "output"
+        if len(self._action_agent.return_values) > 0:
+            return_value_key = self._action_agent.return_values[0]
+        # Invalid tools won't be in the map, so we return False.
+        if (
+            agent_action.tool in name_to_tool_map
+            and name_to_tool_map[agent_action.tool].return_direct
+        ):
+            return AgentFinish(
+                {return_value_key: observation},
+                "",
+            )
+        return None
+
+    def _prepare_intermediate_steps(
+        self,
+        intermediate_steps: list[tuple[AgentAction, str]],
+    ) -> list[tuple[AgentAction, str]]:
+        if (
+            isinstance(self.trim_intermediate_steps, int)
+            and self.trim_intermediate_steps > 0
+        ):
+            return intermediate_steps[-self.trim_intermediate_steps :]
+        if callable(self.trim_intermediate_steps):
+            return self.trim_intermediate_steps(intermediate_steps)
+        return intermediate_steps
+
+    @override
+    def stream(
+        self,
+        input: dict[str, Any] | Any,
+        config: RunnableConfig | None = None,
+        **kwargs: Any,
+    ) -> Iterator[AddableDict]:
+        """Enables streaming over steps taken to reach final output.
+
+        Args:
+            input: Input to the agent.
+            config: Config to use.
+            kwargs: Additional arguments.
+
+        Yields:
+            Addable dictionary.
+        """
+        config = ensure_config(config)
+        iterator = AgentExecutorIterator(
+            self,
+            input,
+            config.get("callbacks"),
+            tags=config.get("tags"),
+            metadata=config.get("metadata"),
+            run_name=config.get("run_name"),
+            run_id=config.get("run_id"),
+            yield_actions=True,
+            **kwargs,
+        )
+        yield from iterator
+
+    @override
+    async def astream(
+        self,
+        input: dict[str, Any] | Any,
+        config: RunnableConfig | None = None,
+        **kwargs: Any,
+    ) -> AsyncIterator[AddableDict]:
+        """Async enables streaming over steps taken to reach final output.
+
+        Args:
+            input: Input to the agent.
+            config: Config to use.
+            kwargs: Additional arguments.
+
+        Yields:
+            Addable dictionary.
+        """
+        config = ensure_config(config)
+        iterator = AgentExecutorIterator(
+            self,
+            input,
+            config.get("callbacks"),
+            tags=config.get("tags"),
+            metadata=config.get("metadata"),
+            run_name=config.get("run_name"),
+            run_id=config.get("run_id"),
+            yield_actions=True,
+            **kwargs,
+        )
+        async for step in iterator:
+            yield step

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_classic/agents/agent_iterator.py

@@ -0,0 +1,432 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+from collections.abc import AsyncIterator, Iterator
+from typing import (
+    TYPE_CHECKING,
+    Any,
+)
+from uuid import UUID
+
+from langchain_core.agents import (
+    AgentAction,
+    AgentFinish,
+    AgentStep,
+)
+from langchain_core.callbacks import (
+    AsyncCallbackManager,
+    AsyncCallbackManagerForChainRun,
+    CallbackManager,
+    CallbackManagerForChainRun,
+    Callbacks,
+)
+from langchain_core.load.dump import dumpd
+from langchain_core.outputs import RunInfo
+from langchain_core.runnables.utils import AddableDict
+from langchain_core.tools import BaseTool
+from langchain_core.utils.input import get_color_mapping
+
+from langchain_classic.schema import RUN_KEY
+from langchain_classic.utilities.asyncio import asyncio_timeout
+
+if TYPE_CHECKING:
+    from langchain_classic.agents.agent import AgentExecutor, NextStepOutput
+
+logger = logging.getLogger(__name__)
+
+
+class AgentExecutorIterator:
+    """Iterator for AgentExecutor."""
+
+    def __init__(
+        self,
+        agent_executor: AgentExecutor,
+        inputs: Any,
+        callbacks: Callbacks = None,
+        *,
+        tags: list[str] | None = None,
+        metadata: dict[str, Any] | None = None,
+        run_name: str | None = None,
+        run_id: UUID | None = None,
+        include_run_info: bool = False,
+        yield_actions: bool = False,
+    ):
+        """Initialize the `AgentExecutorIterator`.
+
+        Initialize the `AgentExecutorIterator` with the given `AgentExecutor`,
+        inputs, and optional callbacks.
+
+        Args:
+            agent_executor: The `AgentExecutor` to iterate over.
+            inputs: The inputs to the `AgentExecutor`.
+            callbacks: The callbacks to use during iteration.
+            tags: The tags to use during iteration.
+            metadata: The metadata to use during iteration.
+            run_name: The name of the run.
+            run_id: The ID of the run.
+            include_run_info: Whether to include run info in the output.
+            yield_actions: Whether to yield actions as they are generated.
+        """
+        self._agent_executor = agent_executor
+        self.inputs = inputs
+        self.callbacks = callbacks
+        self.tags = tags
+        self.metadata = metadata
+        self.run_name = run_name
+        self.run_id = run_id
+        self.include_run_info = include_run_info
+        self.yield_actions = yield_actions
+        self.reset()
+
+    _inputs: dict[str, str]
+    callbacks: Callbacks
+    tags: list[str] | None
+    metadata: dict[str, Any] | None
+    run_name: str | None
+    run_id: UUID | None
+    include_run_info: bool
+    yield_actions: bool
+
+    @property
+    def inputs(self) -> dict[str, str]:
+        """The inputs to the `AgentExecutor`."""
+        return self._inputs
+
+    @inputs.setter
+    def inputs(self, inputs: Any) -> None:
+        self._inputs = self.agent_executor.prep_inputs(inputs)
+
+    @property
+    def agent_executor(self) -> AgentExecutor:
+        """The `AgentExecutor` to iterate over."""
+        return self._agent_executor
+
+    @agent_executor.setter
+    def agent_executor(self, agent_executor: AgentExecutor) -> None:
+        self._agent_executor = agent_executor
+        # force re-prep inputs in case agent_executor's prep_inputs fn changed
+        self.inputs = self.inputs
+
+    @property
+    def name_to_tool_map(self) -> dict[str, BaseTool]:
+        """A mapping of tool names to tools."""
+        return {tool.name: tool for tool in self.agent_executor.tools}
+
+    @property
+    def color_mapping(self) -> dict[str, str]:
+        """A mapping of tool names to colors."""
+        return get_color_mapping(
+            [tool.name for tool in self.agent_executor.tools],
+            excluded_colors=["green", "red"],
+        )
+
+    def reset(self) -> None:
+        """Reset the iterator to its initial state.
+
+        Reset the iterator to its initial state, clearing intermediate steps,
+        iterations, and time elapsed.
+        """
+        logger.debug("(Re)setting AgentExecutorIterator to fresh state")
+        self.intermediate_steps: list[tuple[AgentAction, str]] = []
+        self.iterations = 0
+        # maybe better to start these on the first __anext__ call?
+        self.time_elapsed = 0.0
+        self.start_time = time.time()
+
+    def update_iterations(self) -> None:
+        """Increment the number of iterations and update the time elapsed."""
+        self.iterations += 1
+        self.time_elapsed = time.time() - self.start_time
+        logger.debug(
+            "Agent Iterations: %s (%.2fs elapsed)",
+            self.iterations,
+            self.time_elapsed,
+        )
+
+    def make_final_outputs(
+        self,
+        outputs: dict[str, Any],
+        run_manager: CallbackManagerForChainRun | AsyncCallbackManagerForChainRun,
+    ) -> AddableDict:
+        """Make final outputs for the iterator.
+
+        Args:
+            outputs: The outputs from the agent executor.
+            run_manager: The run manager to use for callbacks.
+        """
+        # have access to intermediate steps by design in iterator,
+        # so return only outputs may as well always be true.
+
+        prepared_outputs = AddableDict(
+            self.agent_executor.prep_outputs(
+                self.inputs,
+                outputs,
+                return_only_outputs=True,
+            ),
+        )
+        if self.include_run_info:
+            prepared_outputs[RUN_KEY] = RunInfo(run_id=run_manager.run_id)
+        return prepared_outputs
+
+    def __iter__(self: AgentExecutorIterator) -> Iterator[AddableDict]:
+        """Create an async iterator for the `AgentExecutor`."""
+        logger.debug("Initialising AgentExecutorIterator")
+        self.reset()
+        callback_manager = CallbackManager.configure(
+            self.callbacks,
+            self.agent_executor.callbacks,
+            self.agent_executor.verbose,
+            self.tags,
+            self.agent_executor.tags,
+            self.metadata,
+            self.agent_executor.metadata,
+        )
+        run_manager = callback_manager.on_chain_start(
+            dumpd(self.agent_executor),
+            self.inputs,
+            self.run_id,
+            name=self.run_name,
+        )
+        try:
+            while self.agent_executor._should_continue(  # noqa: SLF001
+                self.iterations,
+                self.time_elapsed,
+            ):
+                # take the next step: this plans next action, executes it,
+                # yielding action and observation as they are generated
+                next_step_seq: NextStepOutput = []
+                for chunk in self.agent_executor._iter_next_step(  # noqa: SLF001
+                    self.name_to_tool_map,
+                    self.color_mapping,
+                    self.inputs,
+                    self.intermediate_steps,
+                    run_manager,
+                ):
+                    next_step_seq.append(chunk)
+                    # if we're yielding actions, yield them as they come
+                    # do not yield AgentFinish, which will be handled below
+                    if self.yield_actions:
+                        if isinstance(chunk, AgentAction):
+                            yield AddableDict(actions=[chunk], messages=chunk.messages)
+                        elif isinstance(chunk, AgentStep):
+                            yield AddableDict(steps=[chunk], messages=chunk.messages)
+
+                # convert iterator output to format handled by _process_next_step_output
+                next_step = self.agent_executor._consume_next_step(next_step_seq)  # noqa: SLF001
+                # update iterations and time elapsed
+                self.update_iterations()
+                # decide if this is the final output
+                output = self._process_next_step_output(next_step, run_manager)
+                is_final = "intermediate_step" not in output
+                # yield the final output always
+                # for backwards compat, yield int. output if not yielding actions
+                if not self.yield_actions or is_final:
+                    yield output
+                # if final output reached, stop iteration
+                if is_final:
+                    return
+        except BaseException as e:
+            run_manager.on_chain_error(e)
+            raise
+
+        # if we got here means we exhausted iterations or time
+        yield self._stop(run_manager)
+
+    async def __aiter__(self) -> AsyncIterator[AddableDict]:
+        """Create an async iterator for the `AgentExecutor`.
+
+        N.B. __aiter__ must be a normal method, so need to initialize async run manager
+        on first __anext__ call where we can await it.
+        """
+        logger.debug("Initialising AgentExecutorIterator (async)")
+        self.reset()
+        callback_manager = AsyncCallbackManager.configure(
+            self.callbacks,
+            self.agent_executor.callbacks,
+            self.agent_executor.verbose,
+            self.tags,
+            self.agent_executor.tags,
+            self.metadata,
+            self.agent_executor.metadata,
+        )
+        run_manager = await callback_manager.on_chain_start(
+            dumpd(self.agent_executor),
+            self.inputs,
+            self.run_id,
+            name=self.run_name,
+        )
+        try:
+            async with asyncio_timeout(self.agent_executor.max_execution_time):
+                while self.agent_executor._should_continue(  # noqa: SLF001
+                    self.iterations,
+                    self.time_elapsed,
+                ):
+                    # take the next step: this plans next action, executes it,
+                    # yielding action and observation as they are generated
+                    next_step_seq: NextStepOutput = []
+                    async for chunk in self.agent_executor._aiter_next_step(  # noqa: SLF001
+                        self.name_to_tool_map,
+                        self.color_mapping,
+                        self.inputs,
+                        self.intermediate_steps,
+                        run_manager,
+                    ):
+                        next_step_seq.append(chunk)
+                        # if we're yielding actions, yield them as they come
+                        # do not yield AgentFinish, which will be handled below
+                        if self.yield_actions:
+                            if isinstance(chunk, AgentAction):
+                                yield AddableDict(
+                                    actions=[chunk],
+                                    messages=chunk.messages,
+                                )
+                            elif isinstance(chunk, AgentStep):
+                                yield AddableDict(
+                                    steps=[chunk],
+                                    messages=chunk.messages,
+                                )
+
+                    # convert iterator output to format handled by _process_next_step
+                    next_step = self.agent_executor._consume_next_step(next_step_seq)  # noqa: SLF001
+                    # update iterations and time elapsed
+                    self.update_iterations()
+                    # decide if this is the final output
+                    output = await self._aprocess_next_step_output(
+                        next_step,
+                        run_manager,
+                    )
+                    is_final = "intermediate_step" not in output
+                    # yield the final output always
+                    # for backwards compat, yield int. output if not yielding actions
+                    if not self.yield_actions or is_final:
+                        yield output
+                    # if final output reached, stop iteration
+                    if is_final:
+                        return
+        except (TimeoutError, asyncio.TimeoutError):
+            yield await self._astop(run_manager)
+            return
+        except BaseException as e:
+            await run_manager.on_chain_error(e)
+            raise
+
+        # if we got here means we exhausted iterations or time
+        yield await self._astop(run_manager)
+
+    def _process_next_step_output(
+        self,
+        next_step_output: AgentFinish | list[tuple[AgentAction, str]],
+        run_manager: CallbackManagerForChainRun,
+    ) -> AddableDict:
+        """Process the output of the next step.
+
+        Process the output of the next step,
+        handling AgentFinish and tool return cases.
+        """
+        logger.debug("Processing output of Agent loop step")
+        if isinstance(next_step_output, AgentFinish):
+            logger.debug(
+                "Hit AgentFinish: _return -> on_chain_end -> run final output logic",
+            )
+            return self._return(next_step_output, run_manager=run_manager)
+
+        self.intermediate_steps.extend(next_step_output)
+        logger.debug("Updated intermediate_steps with step output")
+
+        # Check for tool return
+        if len(next_step_output) == 1:
+            next_step_action = next_step_output[0]
+            tool_return = self.agent_executor._get_tool_return(next_step_action)  # noqa: SLF001
+            if tool_return is not None:
+                return self._return(tool_return, run_manager=run_manager)
+
+        return AddableDict(intermediate_step=next_step_output)
+
+    async def _aprocess_next_step_output(
+        self,
+        next_step_output: AgentFinish | list[tuple[AgentAction, str]],
+        run_manager: AsyncCallbackManagerForChainRun,
+    ) -> AddableDict:
+        """Process the output of the next async step.
+
+        Process the output of the next async step,
+        handling AgentFinish and tool return cases.
+        """
+        logger.debug("Processing output of async Agent loop step")
+        if isinstance(next_step_output, AgentFinish):
+            logger.debug(
+                "Hit AgentFinish: _areturn -> on_chain_end -> run final output logic",
+            )
+            return await self._areturn(next_step_output, run_manager=run_manager)
+
+        self.intermediate_steps.extend(next_step_output)
+        logger.debug("Updated intermediate_steps with step output")
+
+        # Check for tool return
+        if len(next_step_output) == 1:
+            next_step_action = next_step_output[0]
+            tool_return = self.agent_executor._get_tool_return(next_step_action)  # noqa: SLF001
+            if tool_return is not None:
+                return await self._areturn(tool_return, run_manager=run_manager)
+
+        return AddableDict(intermediate_step=next_step_output)
+
+    def _stop(self, run_manager: CallbackManagerForChainRun) -> AddableDict:
+        """Stop the iterator.
+
+        Stop the iterator and raise a StopIteration exception with the stopped response.
+        """
+        logger.warning("Stopping agent prematurely due to triggering stop condition")
+        # this manually constructs agent finish with output key
+        output = self.agent_executor._action_agent.return_stopped_response(  # noqa: SLF001
+            self.agent_executor.early_stopping_method,
+            self.intermediate_steps,
+            **self.inputs,
+        )
+        return self._return(output, run_manager=run_manager)
+
+    async def _astop(self, run_manager: AsyncCallbackManagerForChainRun) -> AddableDict:
+        """Stop the async iterator.
+
+        Stop the async iterator and raise a StopAsyncIteration exception with
+        the stopped response.
+        """
+        logger.warning("Stopping agent prematurely due to triggering stop condition")
+        output = self.agent_executor._action_agent.return_stopped_response(  # noqa: SLF001
+            self.agent_executor.early_stopping_method,
+            self.intermediate_steps,
+            **self.inputs,
+        )
+        return await self._areturn(output, run_manager=run_manager)
+
+    def _return(
+        self,
+        output: AgentFinish,
+        run_manager: CallbackManagerForChainRun,
+    ) -> AddableDict:
+        """Return the final output of the iterator."""
+        returned_output = self.agent_executor._return(  # noqa: SLF001
+            output,
+            self.intermediate_steps,
+            run_manager=run_manager,
+        )
+        returned_output["messages"] = output.messages
+        run_manager.on_chain_end(returned_output)
+        return self.make_final_outputs(returned_output, run_manager)
+
+    async def _areturn(
+        self,
+        output: AgentFinish,
+        run_manager: AsyncCallbackManagerForChainRun,
+    ) -> AddableDict:
+        """Return the final output of the async iterator."""
+        returned_output = await self.agent_executor._areturn(  # noqa: SLF001
+            output,
+            self.intermediate_steps,
+            run_manager=run_manager,
+        )
+        returned_output["messages"] = output.messages
+        await run_manager.on_chain_end(returned_output)
+        return self.make_final_outputs(returned_output, run_manager)

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_classic/agents/agent_types.py

@@ -0,0 +1,54 @@
+"""Module definitions of agent types together with corresponding agents."""
+
+from enum import Enum
+
+from langchain_core._api import deprecated
+
+from langchain_classic._api.deprecation import AGENT_DEPRECATION_WARNING
+
+
+@deprecated(
+    "0.1.0",
+    message=AGENT_DEPRECATION_WARNING,
+    removal="2.0.0",
+)
+class AgentType(str, Enum):
+    """An enum for agent types."""
+
+    ZERO_SHOT_REACT_DESCRIPTION = "zero-shot-react-description"
+    """A zero shot agent that does a reasoning step before acting."""
+
+    REACT_DOCSTORE = "react-docstore"
+    """A zero shot agent that does a reasoning step before acting.
+
+    This agent has access to a document store that allows it to look up
+    relevant information to answering the question.
+    """
+
+    SELF_ASK_WITH_SEARCH = "self-ask-with-search"
+    """An agent that breaks down a complex question into a series of simpler questions.
+
+    This agent uses a search tool to look up answers to the simpler questions
+    in order to answer the original complex question.
+    """
+    CONVERSATIONAL_REACT_DESCRIPTION = "conversational-react-description"
+    CHAT_ZERO_SHOT_REACT_DESCRIPTION = "chat-zero-shot-react-description"
+    """A zero shot agent that does a reasoning step before acting.
+
+    This agent is designed to be used in conjunction
+    """
+
+    CHAT_CONVERSATIONAL_REACT_DESCRIPTION = "chat-conversational-react-description"
+
+    STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION = (
+        "structured-chat-zero-shot-react-description"
+    )
+    """An zero-shot react agent optimized for chat models.
+
+    This agent is capable of invoking tools that have multiple inputs.
+    """
+
+    OPENAI_FUNCTIONS = "openai-functions"
+    """An agent optimized for using open AI functions."""
+
+    OPENAI_MULTI_FUNCTIONS = "openai-multi-functions"

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_classic/agents/initialize.py

@@ -0,0 +1,116 @@
+"""Load agent."""
+
+import contextlib
+from collections.abc import Sequence
+from typing import Any
+
+from langchain_core._api import deprecated
+from langchain_core.callbacks import BaseCallbackManager
+from langchain_core.language_models import BaseLanguageModel
+from langchain_core.tools import BaseTool
+
+from langchain_classic._api.deprecation import AGENT_DEPRECATION_WARNING
+from langchain_classic.agents.agent import AgentExecutor
+from langchain_classic.agents.agent_types import AgentType
+from langchain_classic.agents.loading import load_agent
+from langchain_classic.agents.types import AGENT_TO_CLASS
+
+
+@deprecated(
+    "0.1.0",
+    message=AGENT_DEPRECATION_WARNING,
+    removal="2.0.0",
+)
+def initialize_agent(
+    tools: Sequence[BaseTool],
+    llm: BaseLanguageModel,
+    agent: AgentType | None = None,
+    callback_manager: BaseCallbackManager | None = None,
+    agent_path: str | None = None,
+    agent_kwargs: dict | None = None,
+    *,
+    tags: Sequence[str] | None = None,
+    **kwargs: Any,
+) -> AgentExecutor:
+    """Load an agent executor given tools and LLM.
+
+    !!! warning
+
+        This function is no deprecated in favor of
+        [`create_agent`][langchain.agents.create_agent] from the `langchain`
+        package, which provides a more flexible agent factory with middleware
+        support, structured output, and integration with LangGraph.
+
+        For migration guidance, see
+        [Migrating to langchain v1](https://docs.langchain.com/oss/python/migrate/langchain-v1)
+        and
+        [Migrating from AgentExecutor](https://python.langchain.com/docs/how_to/migrate_agent/).
+
+    Args:
+        tools: List of tools this agent has access to.
+        llm: Language model to use as the agent.
+        agent: Agent type to use. If `None` and agent_path is also None, will default
+            to AgentType.ZERO_SHOT_REACT_DESCRIPTION.
+        callback_manager: CallbackManager to use. Global callback manager is used if
+            not provided.
+        agent_path: Path to serialized agent to use. If `None` and agent is also None,
+            will default to AgentType.ZERO_SHOT_REACT_DESCRIPTION.
+        agent_kwargs: Additional keyword arguments to pass to the underlying agent.
+        tags: Tags to apply to the traced runs.
+        kwargs: Additional keyword arguments passed to the agent executor.
+
+    Returns:
+        An agent executor.
+
+    Raises:
+        ValueError: If both `agent` and `agent_path` are specified.
+        ValueError: If `agent` is not a valid agent type.
+        ValueError: If both `agent` and `agent_path` are None.
+    """
+    tags_ = list(tags) if tags else []
+    if agent is None and agent_path is None:
+        agent = AgentType.ZERO_SHOT_REACT_DESCRIPTION
+    if agent is not None and agent_path is not None:
+        msg = (
+            "Both `agent` and `agent_path` are specified, "
+            "but at most only one should be."
+        )
+        raise ValueError(msg)
+    if agent is not None:
+        if agent not in AGENT_TO_CLASS:
+            msg = (
+                f"Got unknown agent type: {agent}. "
+                f"Valid types are: {AGENT_TO_CLASS.keys()}."
+            )
+            raise ValueError(msg)
+        tags_.append(agent.value if isinstance(agent, AgentType) else agent)
+        agent_cls = AGENT_TO_CLASS[agent]
+        agent_kwargs = agent_kwargs or {}
+        agent_obj = agent_cls.from_llm_and_tools(
+            llm,
+            tools,
+            callback_manager=callback_manager,
+            **agent_kwargs,
+        )
+    elif agent_path is not None:
+        agent_obj = load_agent(
+            agent_path,
+            llm=llm,
+            tools=tools,
+            callback_manager=callback_manager,
+        )
+        with contextlib.suppress(NotImplementedError):
+            # TODO: Add tags from the serialized object directly.
+            tags_.append(agent_obj._agent_type)  # noqa: SLF001
+    else:
+        msg = (
+            "Somehow both `agent` and `agent_path` are None, this should never happen."
+        )
+        raise ValueError(msg)
+    return AgentExecutor.from_agent_and_tools(
+        agent=agent_obj,
+        tools=tools,
+        callback_manager=callback_manager,
+        tags=tags_,
+        **kwargs,
+    )

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_classic/agents/load_tools.py

@@ -0,0 +1,13 @@
+from typing import Any
+
+from langchain_classic._api import create_importer
+
+_importer = create_importer(
+    __package__,
+    fallback_module="langchain_community.agent_toolkits.load_tools",
+)
+
+
+def __getattr__(name: str) -> Any:
+    """Look up attributes dynamically."""
+    return _importer(name)

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_classic/agents/loading.py

@@ -0,0 +1,148 @@
+"""Functionality for loading agents."""
+
+import json
+import logging
+from pathlib import Path
+from typing import Any
+
+import yaml
+from langchain_core._api import deprecated
+from langchain_core.language_models import BaseLanguageModel
+from langchain_core.tools import Tool
+
+from langchain_classic.agents.agent import BaseMultiActionAgent, BaseSingleActionAgent
+from langchain_classic.agents.types import AGENT_TO_CLASS
+from langchain_classic.chains.loading import load_chain, load_chain_from_config
+
+logger = logging.getLogger(__name__)
+
+URL_BASE = "https://raw.githubusercontent.com/hwchase17/langchain-hub/master/agents/"
+
+
+def _load_agent_from_tools(
+    config: dict,
+    llm: BaseLanguageModel,
+    tools: list[Tool],
+    **kwargs: Any,
+) -> BaseSingleActionAgent | BaseMultiActionAgent:
+    config_type = config.pop("_type")
+    if config_type not in AGENT_TO_CLASS:
+        msg = f"Loading {config_type} agent not supported"
+        raise ValueError(msg)
+
+    agent_cls = AGENT_TO_CLASS[config_type]
+    combined_config = {**config, **kwargs}
+    return agent_cls.from_llm_and_tools(llm, tools, **combined_config)
+
+
+@deprecated("0.1.0", removal="2.0.0")
+def load_agent_from_config(
+    config: dict,
+    llm: BaseLanguageModel | None = None,
+    tools: list[Tool] | None = None,
+    **kwargs: Any,
+) -> BaseSingleActionAgent | BaseMultiActionAgent:
+    """Load agent from Config Dict.
+
+    Args:
+        config: Config dict to load agent from.
+        llm: Language model to use as the agent.
+        tools: List of tools this agent has access to.
+        kwargs: Additional keyword arguments passed to the agent executor.
+
+    Returns:
+        An agent executor.
+
+    Raises:
+        ValueError: If agent type is not specified in the config.
+    """
+    if "_type" not in config:
+        msg = "Must specify an agent Type in config"
+        raise ValueError(msg)
+    load_from_tools = config.pop("load_from_llm_and_tools", False)
+    if load_from_tools:
+        if llm is None:
+            msg = (
+                "If `load_from_llm_and_tools` is set to True, then LLM must be provided"
+            )
+            raise ValueError(msg)
+        if tools is None:
+            msg = (
+                "If `load_from_llm_and_tools` is set to True, "
+                "then tools must be provided"
+            )
+            raise ValueError(msg)
+        return _load_agent_from_tools(config, llm, tools, **kwargs)
+    config_type = config.pop("_type")
+
+    if config_type not in AGENT_TO_CLASS:
+        msg = f"Loading {config_type} agent not supported"
+        raise ValueError(msg)
+
+    agent_cls = AGENT_TO_CLASS[config_type]
+    if "llm_chain" in config:
+        config["llm_chain"] = load_chain_from_config(config.pop("llm_chain"))
+    elif "llm_chain_path" in config:
+        config["llm_chain"] = load_chain(config.pop("llm_chain_path"))
+    else:
+        msg = "One of `llm_chain` and `llm_chain_path` should be specified."
+        raise ValueError(msg)
+    if "output_parser" in config:
+        logger.warning(
+            "Currently loading output parsers on agent is not supported, "
+            "will just use the default one.",
+        )
+        del config["output_parser"]
+
+    combined_config = {**config, **kwargs}
+    return agent_cls(**combined_config)
+
+
+@deprecated("0.1.0", removal="2.0.0")
+def load_agent(
+    path: str | Path,
+    **kwargs: Any,
+) -> BaseSingleActionAgent | BaseMultiActionAgent:
+    """Unified method for loading an agent from LangChainHub or local fs.
+
+    Args:
+        path: Path to the agent file.
+        kwargs: Additional keyword arguments passed to the agent executor.
+
+    Returns:
+        An agent executor.
+
+    Raises:
+        RuntimeError: If loading from the deprecated github-based
+            Hub is attempted.
+    """
+    if isinstance(path, str) and path.startswith("lc://"):
+        msg = (
+            "Loading from the deprecated github-based Hub is no longer supported. "
+            "Please use the new LangChain Hub at https://smith.langchain.com/hub "
+            "instead."
+        )
+        raise RuntimeError(msg)
+    return _load_agent_from_file(path, **kwargs)
+
+
+def _load_agent_from_file(
+    file: str | Path,
+    **kwargs: Any,
+) -> BaseSingleActionAgent | BaseMultiActionAgent:
+    """Load agent from file."""
+    valid_suffixes = {"json", "yaml"}
+    # Convert file to Path object.
+    file_path = Path(file) if isinstance(file, str) else file
+    # Load from either json or yaml.
+    if file_path.suffix[1:] == "json":
+        with file_path.open() as f:
+            config = json.load(f)
+    elif file_path.suffix[1:] == "yaml":
+        with file_path.open() as f:
+            config = yaml.safe_load(f)
+    else:
+        msg = f"Unsupported file type, must be one of {valid_suffixes}."
+        raise ValueError(msg)
+    # Load the agent from the config now.
+    return load_agent_from_config(config, **kwargs)

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_classic/agents/schema.py

@@ -0,0 +1,37 @@
+from typing import Any
+
+from langchain_core.agents import AgentAction
+from langchain_core.prompts.chat import ChatPromptTemplate
+from typing_extensions import override
+
+
+class AgentScratchPadChatPromptTemplate(ChatPromptTemplate):
+    """Chat prompt template for the agent scratchpad."""
+
+    @classmethod
+    @override
+    def is_lc_serializable(cls) -> bool:
+        return False
+
+    def _construct_agent_scratchpad(
+        self,
+        intermediate_steps: list[tuple[AgentAction, str]],
+    ) -> str:
+        if len(intermediate_steps) == 0:
+            return ""
+        thoughts = ""
+        for action, observation in intermediate_steps:
+            thoughts += action.log
+            thoughts += f"\nObservation: {observation}\nThought: "
+        return (
+            f"This was your previous work "
+            f"(but I haven't seen any of it! I only see what "
+            f"you return as final answer):\n{thoughts}"
+        )
+
+    def _merge_partial_and_user_variables(self, **kwargs: Any) -> dict[str, Any]:
+        intermediate_steps = kwargs.pop("intermediate_steps")
+        kwargs["agent_scratchpad"] = self._construct_agent_scratchpad(
+            intermediate_steps,
+        )
+        return kwargs

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_classic/agents/tools.py

@@ -0,0 +1,48 @@
+"""Interface for tools."""
+
+from langchain_core.callbacks import (
+    AsyncCallbackManagerForToolRun,
+    CallbackManagerForToolRun,
+)
+from langchain_core.tools import BaseTool, tool
+from typing_extensions import override
+
+
+class InvalidTool(BaseTool):
+    """Tool that is run when invalid tool name is encountered by agent."""
+
+    name: str = "invalid_tool"
+    """Name of the tool."""
+    description: str = "Called when tool name is invalid. Suggests valid tool names."
+    """Description of the tool."""
+
+    @override
+    def _run(
+        self,
+        requested_tool_name: str,
+        available_tool_names: list[str],
+        run_manager: CallbackManagerForToolRun | None = None,
+    ) -> str:
+        """Use the tool."""
+        available_tool_names_str = ", ".join(list(available_tool_names))
+        return (
+            f"{requested_tool_name} is not a valid tool, "
+            f"try one of [{available_tool_names_str}]."
+        )
+
+    @override
+    async def _arun(
+        self,
+        requested_tool_name: str,
+        available_tool_names: list[str],
+        run_manager: AsyncCallbackManagerForToolRun | None = None,
+    ) -> str:
+        """Use the tool asynchronously."""
+        available_tool_names_str = ", ".join(list(available_tool_names))
+        return (
+            f"{requested_tool_name} is not a valid tool, "
+            f"try one of [{available_tool_names_str}]."
+        )
+
+
+__all__ = ["InvalidTool", "tool"]

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_classic/agents/types.py

@@ -0,0 +1,27 @@
+from langchain_classic.agents.agent import BaseSingleActionAgent
+from langchain_classic.agents.agent_types import AgentType
+from langchain_classic.agents.chat.base import ChatAgent
+from langchain_classic.agents.conversational.base import ConversationalAgent
+from langchain_classic.agents.conversational_chat.base import ConversationalChatAgent
+from langchain_classic.agents.mrkl.base import ZeroShotAgent
+from langchain_classic.agents.openai_functions_agent.base import OpenAIFunctionsAgent
+from langchain_classic.agents.openai_functions_multi_agent.base import (
+    OpenAIMultiFunctionsAgent,
+)
+from langchain_classic.agents.react.base import ReActDocstoreAgent
+from langchain_classic.agents.self_ask_with_search.base import SelfAskWithSearchAgent
+from langchain_classic.agents.structured_chat.base import StructuredChatAgent
+
+AGENT_TYPE = type[BaseSingleActionAgent] | type[OpenAIMultiFunctionsAgent]
+
+AGENT_TO_CLASS: dict[AgentType, AGENT_TYPE] = {
+    AgentType.ZERO_SHOT_REACT_DESCRIPTION: ZeroShotAgent,
+    AgentType.REACT_DOCSTORE: ReActDocstoreAgent,
+    AgentType.SELF_ASK_WITH_SEARCH: SelfAskWithSearchAgent,
+    AgentType.CONVERSATIONAL_REACT_DESCRIPTION: ConversationalAgent,
+    AgentType.CHAT_ZERO_SHOT_REACT_DESCRIPTION: ChatAgent,
+    AgentType.CHAT_CONVERSATIONAL_REACT_DESCRIPTION: ConversationalChatAgent,
+    AgentType.STRUCTURED_CHAT_ZERO_SHOT_REACT_DESCRIPTION: StructuredChatAgent,
+    AgentType.OPENAI_FUNCTIONS: OpenAIFunctionsAgent,
+    AgentType.OPENAI_MULTI_FUNCTIONS: OpenAIMultiFunctionsAgent,
+}

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_classic/agents/utils.py

@@ -0,0 +1,19 @@
+from collections.abc import Sequence
+
+from langchain_core.tools import BaseTool
+
+
+def validate_tools_single_input(class_name: str, tools: Sequence[BaseTool]) -> None:
+    """Validate tools for single input.
+
+    Args:
+        class_name: Name of the class.
+        tools: List of tools to validate.
+
+    Raises:
+        ValueError: If a multi-input tool is found in tools.
+    """
+    for tool in tools:
+        if not tool.is_single_input:
+            msg = f"{class_name} does not support multi-input tool {tool.name}."
+            raise ValueError(msg)

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_classic/callbacks/__init__.py

@@ -0,0 +1,130 @@
+"""**Callback handlers** allow listening to events in LangChain."""
+
+from typing import TYPE_CHECKING, Any
+
+from langchain_core.callbacks import (
+    FileCallbackHandler,
+    StdOutCallbackHandler,
+    StreamingStdOutCallbackHandler,
+)
+from langchain_core.tracers.context import (
+    collect_runs,
+    tracing_v2_enabled,
+)
+from langchain_core.tracers.langchain import LangChainTracer
+
+from langchain_classic._api import create_importer
+from langchain_classic.callbacks.streaming_aiter import AsyncIteratorCallbackHandler
+from langchain_classic.callbacks.streaming_stdout_final_only import (
+    FinalStreamingStdOutCallbackHandler,
+)
+
+if TYPE_CHECKING:
+    from langchain_community.callbacks.aim_callback import AimCallbackHandler
+    from langchain_community.callbacks.argilla_callback import ArgillaCallbackHandler
+    from langchain_community.callbacks.arize_callback import ArizeCallbackHandler
+    from langchain_community.callbacks.arthur_callback import ArthurCallbackHandler
+    from langchain_community.callbacks.clearml_callback import ClearMLCallbackHandler
+    from langchain_community.callbacks.comet_ml_callback import CometCallbackHandler
+    from langchain_community.callbacks.context_callback import ContextCallbackHandler
+    from langchain_community.callbacks.flyte_callback import FlyteCallbackHandler
+    from langchain_community.callbacks.human import HumanApprovalCallbackHandler
+    from langchain_community.callbacks.infino_callback import InfinoCallbackHandler
+    from langchain_community.callbacks.labelstudio_callback import (
+        LabelStudioCallbackHandler,
+    )
+    from langchain_community.callbacks.llmonitor_callback import (
+        LLMonitorCallbackHandler,
+    )
+    from langchain_community.callbacks.manager import (
+        get_openai_callback,
+        wandb_tracing_enabled,
+    )
+    from langchain_community.callbacks.mlflow_callback import MlflowCallbackHandler
+    from langchain_community.callbacks.openai_info import OpenAICallbackHandler
+    from langchain_community.callbacks.promptlayer_callback import (
+        PromptLayerCallbackHandler,
+    )
+    from langchain_community.callbacks.sagemaker_callback import (
+        SageMakerCallbackHandler,
+    )
+    from langchain_community.callbacks.streamlit import StreamlitCallbackHandler
+    from langchain_community.callbacks.streamlit.streamlit_callback_handler import (
+        LLMThoughtLabeler,
+    )
+    from langchain_community.callbacks.trubrics_callback import TrubricsCallbackHandler
+    from langchain_community.callbacks.wandb_callback import WandbCallbackHandler
+    from langchain_community.callbacks.whylabs_callback import WhyLabsCallbackHandler
+
+# Create a way to dynamically look up deprecated imports.
+# Used to consolidate logic for raising deprecation warnings and
+# handling optional imports.
+DEPRECATED_LOOKUP = {
+    "AimCallbackHandler": "langchain_community.callbacks.aim_callback",
+    "ArgillaCallbackHandler": "langchain_community.callbacks.argilla_callback",
+    "ArizeCallbackHandler": "langchain_community.callbacks.arize_callback",
+    "PromptLayerCallbackHandler": "langchain_community.callbacks.promptlayer_callback",
+    "ArthurCallbackHandler": "langchain_community.callbacks.arthur_callback",
+    "ClearMLCallbackHandler": "langchain_community.callbacks.clearml_callback",
+    "CometCallbackHandler": "langchain_community.callbacks.comet_ml_callback",
+    "ContextCallbackHandler": "langchain_community.callbacks.context_callback",
+    "HumanApprovalCallbackHandler": "langchain_community.callbacks.human",
+    "InfinoCallbackHandler": "langchain_community.callbacks.infino_callback",
+    "MlflowCallbackHandler": "langchain_community.callbacks.mlflow_callback",
+    "LLMonitorCallbackHandler": "langchain_community.callbacks.llmonitor_callback",
+    "OpenAICallbackHandler": "langchain_community.callbacks.openai_info",
+    "LLMThoughtLabeler": (
+        "langchain_community.callbacks.streamlit.streamlit_callback_handler"
+    ),
+    "StreamlitCallbackHandler": "langchain_community.callbacks.streamlit",
+    "WandbCallbackHandler": "langchain_community.callbacks.wandb_callback",
+    "WhyLabsCallbackHandler": "langchain_community.callbacks.whylabs_callback",
+    "get_openai_callback": "langchain_community.callbacks.manager",
+    "wandb_tracing_enabled": "langchain_community.callbacks.manager",
+    "FlyteCallbackHandler": "langchain_community.callbacks.flyte_callback",
+    "SageMakerCallbackHandler": "langchain_community.callbacks.sagemaker_callback",
+    "LabelStudioCallbackHandler": "langchain_community.callbacks.labelstudio_callback",
+    "TrubricsCallbackHandler": "langchain_community.callbacks.trubrics_callback",
+}
+
+_import_attribute = create_importer(__file__, deprecated_lookups=DEPRECATED_LOOKUP)
+
+
+def __getattr__(name: str) -> Any:
+    """Look up attributes dynamically."""
+    return _import_attribute(name)
+
+
+__all__ = [
+    "AimCallbackHandler",
+    "ArgillaCallbackHandler",
+    "ArizeCallbackHandler",
+    "ArthurCallbackHandler",
+    "AsyncIteratorCallbackHandler",
+    "ClearMLCallbackHandler",
+    "CometCallbackHandler",
+    "ContextCallbackHandler",
+    "FileCallbackHandler",
+    "FinalStreamingStdOutCallbackHandler",
+    "FlyteCallbackHandler",
+    "HumanApprovalCallbackHandler",
+    "InfinoCallbackHandler",
+    "LLMThoughtLabeler",
+    "LLMonitorCallbackHandler",
+    "LabelStudioCallbackHandler",
+    "LangChainTracer",
+    "MlflowCallbackHandler",
+    "OpenAICallbackHandler",
+    "PromptLayerCallbackHandler",
+    "SageMakerCallbackHandler",
+    "StdOutCallbackHandler",
+    "StreamingStdOutCallbackHandler",
+    "StreamlitCallbackHandler",
+    "TrubricsCallbackHandler",
+    "WandbCallbackHandler",
+    "WhyLabsCallbackHandler",
+    "collect_runs",
+    "get_openai_callback",
+    "tracing_v2_enabled",
+    "wandb_tracing_enabled",
+]

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_classic/callbacks/aim_callback.py

@@ -0,0 +1,33 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain_classic._api import create_importer
+
+if TYPE_CHECKING:
+    from langchain_community.callbacks.aim_callback import (
+        AimCallbackHandler,
+        BaseMetadataCallbackHandler,
+        import_aim,
+    )
+
+# Create a way to dynamically look up deprecated imports.
+# Used to consolidate logic for raising deprecation warnings and
+# handling optional imports.
+DEPRECATED_LOOKUP = {
+    "import_aim": "langchain_community.callbacks.aim_callback",
+    "BaseMetadataCallbackHandler": "langchain_community.callbacks.aim_callback",
+    "AimCallbackHandler": "langchain_community.callbacks.aim_callback",
+}
+
+_import_attribute = create_importer(__file__, deprecated_lookups=DEPRECATED_LOOKUP)
+
+
+def __getattr__(name: str) -> Any:
+    """Look up attributes dynamically."""
+    return _import_attribute(name)
+
+
+__all__ = [
+    "AimCallbackHandler",
+    "BaseMetadataCallbackHandler",
+    "import_aim",
+]

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_classic/callbacks/argilla_callback.py

@@ -0,0 +1,25 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain_classic._api import create_importer
+
+if TYPE_CHECKING:
+    from langchain_community.callbacks.argilla_callback import ArgillaCallbackHandler
+
+# Create a way to dynamically look up deprecated imports.
+# Used to consolidate logic for raising deprecation warnings and
+# handling optional imports.
+DEPRECATED_LOOKUP = {
+    "ArgillaCallbackHandler": "langchain_community.callbacks.argilla_callback",
+}
+
+_import_attribute = create_importer(__file__, deprecated_lookups=DEPRECATED_LOOKUP)
+
+
+def __getattr__(name: str) -> Any:
+    """Look up attributes dynamically."""
+    return _import_attribute(name)
+
+
+__all__ = [
+    "ArgillaCallbackHandler",
+]

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_classic/callbacks/arize_callback.py

@@ -0,0 +1,25 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain_classic._api import create_importer
+
+if TYPE_CHECKING:
+    from langchain_community.callbacks.arize_callback import ArizeCallbackHandler
+
+# Create a way to dynamically look up deprecated imports.
+# Used to consolidate logic for raising deprecation warnings and
+# handling optional imports.
+DEPRECATED_LOOKUP = {
+    "ArizeCallbackHandler": "langchain_community.callbacks.arize_callback",
+}
+
+_import_attribute = create_importer(__file__, deprecated_lookups=DEPRECATED_LOOKUP)
+
+
+def __getattr__(name: str) -> Any:
+    """Look up attributes dynamically."""
+    return _import_attribute(name)
+
+
+__all__ = [
+    "ArizeCallbackHandler",
+]

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_classic/callbacks/arthur_callback.py

@@ -0,0 +1,25 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain_classic._api import create_importer
+
+if TYPE_CHECKING:
+    from langchain_community.callbacks.arthur_callback import ArthurCallbackHandler
+
+# Create a way to dynamically look up deprecated imports.
+# Used to consolidate logic for raising deprecation warnings and
+# handling optional imports.
+DEPRECATED_LOOKUP = {
+    "ArthurCallbackHandler": "langchain_community.callbacks.arthur_callback",
+}
+
+_import_attribute = create_importer(__file__, deprecated_lookups=DEPRECATED_LOOKUP)
+
+
+def __getattr__(name: str) -> Any:
+    """Look up attributes dynamically."""
+    return _import_attribute(name)
+
+
+__all__ = [
+    "ArthurCallbackHandler",
+]

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_classic/callbacks/base.py

@@ -0,0 +1,29 @@
+"""Base callback handler that can be used to handle callbacks in langchain."""
+
+from __future__ import annotations
+
+from langchain_core.callbacks import (
+    AsyncCallbackHandler,
+    BaseCallbackHandler,
+    BaseCallbackManager,
+    CallbackManagerMixin,
+    Callbacks,
+    ChainManagerMixin,
+    LLMManagerMixin,
+    RetrieverManagerMixin,
+    RunManagerMixin,
+    ToolManagerMixin,
+)
+
+__all__ = [
+    "AsyncCallbackHandler",
+    "BaseCallbackHandler",
+    "BaseCallbackManager",
+    "CallbackManagerMixin",
+    "Callbacks",
+    "ChainManagerMixin",
+    "LLMManagerMixin",
+    "RetrieverManagerMixin",
+    "RunManagerMixin",
+    "ToolManagerMixin",
+]

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_classic/callbacks/clearml_callback.py

@@ -0,0 +1,25 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain_classic._api import create_importer
+
+if TYPE_CHECKING:
+    from langchain_community.callbacks.clearml_callback import ClearMLCallbackHandler
+
+# Create a way to dynamically look up deprecated imports.
+# Used to consolidate logic for raising deprecation warnings and
+# handling optional imports.
+DEPRECATED_LOOKUP = {
+    "ClearMLCallbackHandler": "langchain_community.callbacks.clearml_callback",
+}
+
+_import_attribute = create_importer(__file__, deprecated_lookups=DEPRECATED_LOOKUP)
+
+
+def __getattr__(name: str) -> Any:
+    """Look up attributes dynamically."""
+    return _import_attribute(name)
+
+
+__all__ = [
+    "ClearMLCallbackHandler",
+]

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_classic/callbacks/comet_ml_callback.py

@@ -0,0 +1,25 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain_classic._api import create_importer
+
+if TYPE_CHECKING:
+    from langchain_community.callbacks.comet_ml_callback import CometCallbackHandler
+
+# Create a way to dynamically look up deprecated imports.
+# Used to consolidate logic for raising deprecation warnings and
+# handling optional imports.
+DEPRECATED_LOOKUP = {
+    "CometCallbackHandler": "langchain_community.callbacks.comet_ml_callback",
+}
+
+_import_attribute = create_importer(__file__, deprecated_lookups=DEPRECATED_LOOKUP)
+
+
+def __getattr__(name: str) -> Any:
+    """Look up attributes dynamically."""
+    return _import_attribute(name)
+
+
+__all__ = [
+    "CometCallbackHandler",
+]

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_classic/callbacks/confident_callback.py

@@ -0,0 +1,25 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain_classic._api import create_importer
+
+if TYPE_CHECKING:
+    from langchain_community.callbacks.confident_callback import DeepEvalCallbackHandler
+
+# Create a way to dynamically look up deprecated imports.
+# Used to consolidate logic for raising deprecation warnings and
+# handling optional imports.
+DEPRECATED_LOOKUP = {
+    "DeepEvalCallbackHandler": "langchain_community.callbacks.confident_callback",
+}
+
+_import_attribute = create_importer(__file__, deprecated_lookups=DEPRECATED_LOOKUP)
+
+
+def __getattr__(name: str) -> Any:
+    """Look up attributes dynamically."""
+    return _import_attribute(name)
+
+
+__all__ = [
+    "DeepEvalCallbackHandler",
+]

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_classic/callbacks/context_callback.py

@@ -0,0 +1,25 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain_classic._api import create_importer
+
+if TYPE_CHECKING:
+    from langchain_community.callbacks.context_callback import ContextCallbackHandler
+
+# Create a way to dynamically look up deprecated imports.
+# Used to consolidate logic for raising deprecation warnings and
+# handling optional imports.
+DEPRECATED_LOOKUP = {
+    "ContextCallbackHandler": "langchain_community.callbacks.context_callback",
+}
+
+_import_attribute = create_importer(__file__, deprecated_lookups=DEPRECATED_LOOKUP)
+
+
+def __getattr__(name: str) -> Any:
+    """Look up attributes dynamically."""
+    return _import_attribute(name)
+
+
+__all__ = [
+    "ContextCallbackHandler",
+]