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

langchain/agents/agent_toolkits/steam/toolkit.py

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

langchain/agents/agent_toolkits/vectorstore/__init__.py

@@ -1 +0,0 @@
-"""Agent toolkit for interacting with vector stores."""

langchain/agents/agent_toolkits/vectorstore/base.py

@@ -1,219 +0,0 @@
-"""VectorStore agent."""
-
-from typing import Any, Optional
-
-from langchain_core._api import deprecated
-from langchain_core.callbacks.base import BaseCallbackManager
-from langchain_core.language_models import BaseLanguageModel
-
-from langchain.agents.agent import AgentExecutor
-from langchain.agents.agent_toolkits.vectorstore.prompt import PREFIX, ROUTER_PREFIX
-from langchain.agents.agent_toolkits.vectorstore.toolkit import (
-    VectorStoreRouterToolkit,
-    VectorStoreToolkit,
-)
-from langchain.agents.mrkl.base import ZeroShotAgent
-from langchain.chains.llm import LLMChain
-
-
-@deprecated(
-    since="0.2.13",
-    removal="1.0",
-    message=(
-        "This function will continue to be supported, but it is recommended for new "
-        "use cases to be built with LangGraph. LangGraph offers a more flexible and "
-        "full-featured framework for building agents, including support for "
-        "tool-calling, persistence of state, and human-in-the-loop workflows. "
-        "See API reference for this function for a replacement implementation: "
-        "https://api.python.langchain.com/en/latest/agents/langchain.agents.agent_toolkits.vectorstore.base.create_vectorstore_agent.html "  # noqa: E501
-        "Read more here on how to create agents that query vector stores: "
-        "https://python.langchain.com/docs/how_to/qa_chat_history_how_to/#agents"
-    ),
-)
-def create_vectorstore_agent(
-    llm: BaseLanguageModel,
-    toolkit: VectorStoreToolkit,
-    callback_manager: Optional[BaseCallbackManager] = None,
-    prefix: str = PREFIX,
-    verbose: bool = False,  # noqa: FBT001,FBT002
-    agent_executor_kwargs: Optional[dict[str, Any]] = None,
-    **kwargs: Any,
-) -> AgentExecutor:
-    """Construct a VectorStore agent from an LLM and tools.
-
-    Note: this class is deprecated. See below for a replacement that uses tool
-    calling methods and LangGraph. Install LangGraph with:
-
-        .. code-block:: bash
-
-            pip install -U langgraph
-
-        .. code-block:: python
-
-            from langchain_core.tools import create_retriever_tool
-            from langchain_core.vectorstores import InMemoryVectorStore
-            from langchain_openai import ChatOpenAI, OpenAIEmbeddings
-            from langgraph.prebuilt import create_react_agent
-
-            llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
-
-            vector_store = InMemoryVectorStore.from_texts(
-                [
-                    "Dogs are great companions, known for their loyalty and friendliness.",
-                    "Cats are independent pets that often enjoy their own space.",
-                ],
-                OpenAIEmbeddings(),
-            )
-
-            tool = create_retriever_tool(
-                vector_store.as_retriever(),
-                "pet_information_retriever",
-                "Fetches information about pets.",
-            )
-
-            agent = create_react_agent(llm, [tool])
-
-            for step in agent.stream(
-                {"messages": [("human", "What are dogs known for?")]},
-                stream_mode="values",
-            ):
-                step["messages"][-1].pretty_print()
-
-    Args:
-        llm (BaseLanguageModel): LLM that will be used by the agent
-        toolkit (VectorStoreToolkit): Set of tools for the agent
-        callback_manager (Optional[BaseCallbackManager], optional): Object to handle the callback [ Defaults to None. ]
-        prefix (str, optional): The prefix prompt for the agent. If not provided uses default PREFIX.
-        verbose (bool, optional): If you want to see the content of the scratchpad. [ Defaults to False ]
-        agent_executor_kwargs (Optional[Dict[str, Any]], optional): If there is any other parameter you want to send to the agent. [ Defaults to None ]
-        kwargs: Additional named parameters to pass to the ZeroShotAgent.
-
-    Returns:
-        AgentExecutor: Returns a callable AgentExecutor object. Either you can call it or use run method with the query to get the response
-
-    """  # noqa: E501
-    tools = toolkit.get_tools()
-    prompt = ZeroShotAgent.create_prompt(tools, prefix=prefix)
-    llm_chain = LLMChain(
-        llm=llm,
-        prompt=prompt,
-        callback_manager=callback_manager,
-    )
-    tool_names = [tool.name for tool in tools]
-    agent = ZeroShotAgent(llm_chain=llm_chain, allowed_tools=tool_names, **kwargs)
-    return AgentExecutor.from_agent_and_tools(
-        agent=agent,
-        tools=tools,
-        callback_manager=callback_manager,
-        verbose=verbose,
-        **(agent_executor_kwargs or {}),
-    )
-
-
-@deprecated(
-    since="0.2.13",
-    removal="1.0",
-    message=(
-        "This function will continue to be supported, but it is recommended for new "
-        "use cases to be built with LangGraph. LangGraph offers a more flexible and "
-        "full-featured framework for building agents, including support for "
-        "tool-calling, persistence of state, and human-in-the-loop workflows. "
-        "See API reference for this function for a replacement implementation: "
-        "https://api.python.langchain.com/en/latest/agents/langchain.agents.agent_toolkits.vectorstore.base.create_vectorstore_router_agent.html "  # noqa: E501
-        "Read more here on how to create agents that query vector stores: "
-        "https://python.langchain.com/docs/how_to/qa_chat_history_how_to/#agents"
-    ),
-)
-def create_vectorstore_router_agent(
-    llm: BaseLanguageModel,
-    toolkit: VectorStoreRouterToolkit,
-    callback_manager: Optional[BaseCallbackManager] = None,
-    prefix: str = ROUTER_PREFIX,
-    verbose: bool = False,  # noqa: FBT001,FBT002
-    agent_executor_kwargs: Optional[dict[str, Any]] = None,
-    **kwargs: Any,
-) -> AgentExecutor:
-    """Construct a VectorStore router agent from an LLM and tools.
-
-    Note: this class is deprecated. See below for a replacement that uses tool
-    calling methods and LangGraph. Install LangGraph with:
-
-        .. code-block:: bash
-
-            pip install -U langgraph
-
-        .. code-block:: python
-
-            from langchain_core.tools import create_retriever_tool
-            from langchain_core.vectorstores import InMemoryVectorStore
-            from langchain_openai import ChatOpenAI, OpenAIEmbeddings
-            from langgraph.prebuilt import create_react_agent
-
-            llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
-
-            pet_vector_store = InMemoryVectorStore.from_texts(
-                [
-                    "Dogs are great companions, known for their loyalty and friendliness.",
-                    "Cats are independent pets that often enjoy their own space.",
-                ],
-                OpenAIEmbeddings(),
-            )
-
-            food_vector_store = InMemoryVectorStore.from_texts(
-                [
-                    "Carrots are orange and delicious.",
-                    "Apples are red and delicious.",
-                ],
-                OpenAIEmbeddings(),
-            )
-
-            tools = [
-                create_retriever_tool(
-                    pet_vector_store.as_retriever(),
-                    "pet_information_retriever",
-                    "Fetches information about pets.",
-                ),
-                create_retriever_tool(
-                    food_vector_store.as_retriever(),
-                    "food_information_retriever",
-                    "Fetches information about food.",
-                )
-            ]
-
-            agent = create_react_agent(llm, tools)
-
-            for step in agent.stream(
-                {"messages": [("human", "Tell me about carrots.")]},
-                stream_mode="values",
-            ):
-                step["messages"][-1].pretty_print()
-
-    Args:
-        llm (BaseLanguageModel): LLM that will be used by the agent
-        toolkit (VectorStoreRouterToolkit): Set of tools for the agent which have routing capability with multiple vector stores
-        callback_manager (Optional[BaseCallbackManager], optional): Object to handle the callback [ Defaults to None. ]
-        prefix (str, optional): The prefix prompt for the router agent. If not provided uses default ROUTER_PREFIX.
-        verbose (bool, optional): If you want to see the content of the scratchpad. [ Defaults to False ]
-        agent_executor_kwargs (Optional[Dict[str, Any]], optional): If there is any other parameter you want to send to the agent. [ Defaults to None ]
-        kwargs: Additional named parameters to pass to the ZeroShotAgent.
-
-    Returns:
-        AgentExecutor: Returns a callable AgentExecutor object. Either you can call it or use run method with the query to get the response.
-
-    """  # noqa: E501
-    tools = toolkit.get_tools()
-    prompt = ZeroShotAgent.create_prompt(tools, prefix=prefix)
-    llm_chain = LLMChain(
-        llm=llm,
-        prompt=prompt,
-        callback_manager=callback_manager,
-    )
-    tool_names = [tool.name for tool in tools]
-    agent = ZeroShotAgent(llm_chain=llm_chain, allowed_tools=tool_names, **kwargs)
-    return AgentExecutor.from_agent_and_tools(
-        agent=agent,
-        tools=tools,
-        callback_manager=callback_manager,
-        verbose=verbose,
-        **(agent_executor_kwargs or {}),
-    )

langchain/agents/agent_toolkits/vectorstore/prompt.py

@@ -1,11 +0,0 @@
-PREFIX = """You are an agent designed to answer questions about sets of documents.
-You have access to tools for interacting with the documents, and the inputs to the tools are questions.
-Sometimes, you will be asked to provide sources for your questions, in which case you should use the appropriate tool to do so.
-If the question does not seem relevant to any of the tools provided, just return "I don't know" as the answer.
-"""  # noqa: E501
-
-ROUTER_PREFIX = """You are an agent designed to answer questions.
-You have access to tools for interacting with different sources, and the inputs to the tools are questions.
-Your main task is to decide which of the tools is relevant for answering question at hand.
-For complex questions, you can break the question down into sub questions and use tools to answers the sub questions.
-"""  # noqa: E501

langchain/agents/agent_toolkits/vectorstore/toolkit.py

@@ -1,97 +0,0 @@
-"""Toolkit for interacting with a vector store."""
-
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.tools import BaseTool
-from langchain_core.tools.base import BaseToolkit
-from langchain_core.vectorstores import VectorStore
-from pydantic import BaseModel, ConfigDict, Field
-
-
-class VectorStoreInfo(BaseModel):
-    """Information about a VectorStore."""
-
-    vectorstore: VectorStore = Field(exclude=True)
-    name: str
-    description: str
-
-    model_config = ConfigDict(
-        arbitrary_types_allowed=True,
-    )
-
-
-class VectorStoreToolkit(BaseToolkit):
-    """Toolkit for interacting with a Vector Store."""
-
-    vectorstore_info: VectorStoreInfo = Field(exclude=True)
-    llm: BaseLanguageModel
-
-    model_config = ConfigDict(
-        arbitrary_types_allowed=True,
-    )
-
-    def get_tools(self) -> list[BaseTool]:
-        """Get the tools in the toolkit."""
-        try:
-            from langchain_community.tools.vectorstore.tool import (
-                VectorStoreQATool,
-                VectorStoreQAWithSourcesTool,
-            )
-        except ImportError as e:
-            msg = "You need to install langchain-community to use this toolkit."
-            raise ImportError(msg) from e
-        description = VectorStoreQATool.get_description(
-            self.vectorstore_info.name,
-            self.vectorstore_info.description,
-        )
-        qa_tool = VectorStoreQATool(
-            name=self.vectorstore_info.name,
-            description=description,
-            vectorstore=self.vectorstore_info.vectorstore,
-            llm=self.llm,
-        )
-        description = VectorStoreQAWithSourcesTool.get_description(
-            self.vectorstore_info.name,
-            self.vectorstore_info.description,
-        )
-        qa_with_sources_tool = VectorStoreQAWithSourcesTool(
-            name=f"{self.vectorstore_info.name}_with_sources",
-            description=description,
-            vectorstore=self.vectorstore_info.vectorstore,
-            llm=self.llm,
-        )
-        return [qa_tool, qa_with_sources_tool]
-
-
-class VectorStoreRouterToolkit(BaseToolkit):
-    """Toolkit for routing between Vector Stores."""
-
-    vectorstores: list[VectorStoreInfo] = Field(exclude=True)
-    llm: BaseLanguageModel
-
-    model_config = ConfigDict(
-        arbitrary_types_allowed=True,
-    )
-
-    def get_tools(self) -> list[BaseTool]:
-        """Get the tools in the toolkit."""
-        tools: list[BaseTool] = []
-        try:
-            from langchain_community.tools.vectorstore.tool import (
-                VectorStoreQATool,
-            )
-        except ImportError as e:
-            msg = "You need to install langchain-community to use this toolkit."
-            raise ImportError(msg) from e
-        for vectorstore_info in self.vectorstores:
-            description = VectorStoreQATool.get_description(
-                vectorstore_info.name,
-                vectorstore_info.description,
-            )
-            qa_tool = VectorStoreQATool(
-                name=vectorstore_info.name,
-                description=description,
-                vectorstore=vectorstore_info.vectorstore,
-                llm=self.llm,
-            )
-            tools.append(qa_tool)
-        return tools

langchain/agents/agent_toolkits/xorbits/__init__.py

@@ -1,28 +0,0 @@
-from pathlib import Path
-from typing import Any
-
-from langchain_core._api.path import as_import_path
-
-
-def __getattr__(name: str) -> Any:
-    """Get attr name."""
-
-    if name == "create_xorbits_agent":
-        # Get directory of langchain package
-        HERE = Path(__file__).parents[3]
-        here = as_import_path(Path(__file__).parent, relative_to=HERE)
-
-        old_path = "langchain." + here + "." + name
-        new_path = "langchain_experimental." + here + "." + name
-        msg = (
-            "This agent has been moved to langchain experiment. "
-            "This agent relies on python REPL tool under the hood, so to use it "
-            "safely please sandbox the python REPL. "
-            "Read https://github.com/langchain-ai/langchain/blob/master/SECURITY.md "
-            "and https://github.com/langchain-ai/langchain/discussions/11680"
-            "To keep using this code as is, install langchain experimental and "
-            f"update your import statement from:\n `{old_path}` to `{new_path}`."
-        )
-        raise ImportError(msg)
-    msg = f"{name} does not exist"
-    raise AttributeError(msg)

langchain/agents/agent_toolkits/zapier/__init__.py

@@ -1 +0,0 @@
-"""Zapier Toolkit."""

langchain/agents/agent_toolkits/zapier/toolkit.py

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

langchain/agents/agent_types.py

@@ -1,57 +0,0 @@
-"""Module definitions of agent types together with corresponding agents."""
-
-from enum import Enum
-
-from langchain_core._api import deprecated
-
-from langchain._api.deprecation import AGENT_DEPRECATION_WARNING
-
-
-@deprecated(
-    "0.1.0",
-    message=AGENT_DEPRECATION_WARNING,
-    removal="1.0",
-)
-class AgentType(str, Enum):
-    """An enum for agent types.
-
-    See documentation: https://python.langchain.com/api_reference/langchain/agents/langchain.agents.agent_types.AgentType.html
-    """
-
-    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"

langchain/agents/chat/base.py

@@ -1,180 +0,0 @@
-from collections.abc import Sequence
-from typing import Any, Optional
-
-from langchain_core._api import deprecated
-from langchain_core.agents import AgentAction
-from langchain_core.callbacks import BaseCallbackManager
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.prompts import BasePromptTemplate
-from langchain_core.prompts.chat import (
-    ChatPromptTemplate,
-    HumanMessagePromptTemplate,
-    SystemMessagePromptTemplate,
-)
-from langchain_core.tools import BaseTool
-from pydantic import Field
-from typing_extensions import override
-
-from langchain._api.deprecation import AGENT_DEPRECATION_WARNING
-from langchain.agents.agent import Agent, AgentOutputParser
-from langchain.agents.chat.output_parser import ChatOutputParser
-from langchain.agents.chat.prompt import (
-    FORMAT_INSTRUCTIONS,
-    HUMAN_MESSAGE,
-    SYSTEM_MESSAGE_PREFIX,
-    SYSTEM_MESSAGE_SUFFIX,
-)
-from langchain.agents.utils import validate_tools_single_input
-from langchain.chains.llm import LLMChain
-
-
-@deprecated(
-    "0.1.0",
-    message=AGENT_DEPRECATION_WARNING,
-    removal="1.0",
-)
-class ChatAgent(Agent):
-    """Chat Agent."""
-
-    output_parser: AgentOutputParser = Field(default_factory=ChatOutputParser)
-    """Output parser for the agent."""
-
-    @property
-    def observation_prefix(self) -> str:
-        """Prefix to append the observation with."""
-        return "Observation: "
-
-    @property
-    def llm_prefix(self) -> str:
-        """Prefix to append the llm call with."""
-        return "Thought:"
-
-    def _construct_scratchpad(
-        self,
-        intermediate_steps: list[tuple[AgentAction, str]],
-    ) -> str:
-        agent_scratchpad = super()._construct_scratchpad(intermediate_steps)
-        if not isinstance(agent_scratchpad, str):
-            msg = "agent_scratchpad should be of type string."
-            raise ValueError(msg)  # noqa: TRY004
-        if agent_scratchpad:
-            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{agent_scratchpad}"
-            )
-        return agent_scratchpad
-
-    @classmethod
-    @override
-    def _get_default_output_parser(cls, **kwargs: Any) -> AgentOutputParser:
-        return ChatOutputParser()
-
-    @classmethod
-    def _validate_tools(cls, tools: Sequence[BaseTool]) -> None:
-        super()._validate_tools(tools)
-        validate_tools_single_input(class_name=cls.__name__, tools=tools)
-
-    @property
-    def _stop(self) -> list[str]:
-        return ["Observation:"]
-
-    @classmethod
-    def create_prompt(
-        cls,
-        tools: Sequence[BaseTool],
-        system_message_prefix: str = SYSTEM_MESSAGE_PREFIX,
-        system_message_suffix: str = SYSTEM_MESSAGE_SUFFIX,
-        human_message: str = HUMAN_MESSAGE,
-        format_instructions: str = FORMAT_INSTRUCTIONS,
-        input_variables: Optional[list[str]] = None,
-    ) -> BasePromptTemplate:
-        """Create a prompt from a list of tools.
-
-        Args:
-            tools: A list of tools.
-            system_message_prefix: The system message prefix.
-                Default is SYSTEM_MESSAGE_PREFIX.
-            system_message_suffix: The system message suffix.
-                Default is SYSTEM_MESSAGE_SUFFIX.
-            human_message: The human message. Default is HUMAN_MESSAGE.
-            format_instructions: The format instructions.
-                Default is FORMAT_INSTRUCTIONS.
-            input_variables: The input variables. Default is None.
-
-        Returns:
-            A prompt template.
-        """
-
-        tool_strings = "\n".join([f"{tool.name}: {tool.description}" for tool in tools])
-        tool_names = ", ".join([tool.name for tool in tools])
-        format_instructions = format_instructions.format(tool_names=tool_names)
-        template = f"{system_message_prefix}\n\n{tool_strings}\n\n{format_instructions}\n\n{system_message_suffix}"  # noqa: E501
-        messages = [
-            SystemMessagePromptTemplate.from_template(template),
-            HumanMessagePromptTemplate.from_template(human_message),
-        ]
-        if input_variables is None:
-            input_variables = ["input", "agent_scratchpad"]
-        return ChatPromptTemplate(input_variables=input_variables, messages=messages)
-
-    @classmethod
-    def from_llm_and_tools(
-        cls,
-        llm: BaseLanguageModel,
-        tools: Sequence[BaseTool],
-        callback_manager: Optional[BaseCallbackManager] = None,
-        output_parser: Optional[AgentOutputParser] = None,
-        system_message_prefix: str = SYSTEM_MESSAGE_PREFIX,
-        system_message_suffix: str = SYSTEM_MESSAGE_SUFFIX,
-        human_message: str = HUMAN_MESSAGE,
-        format_instructions: str = FORMAT_INSTRUCTIONS,
-        input_variables: Optional[list[str]] = None,
-        **kwargs: Any,
-    ) -> Agent:
-        """Construct an agent from an LLM and tools.
-
-        Args:
-            llm: The language model.
-            tools: A list of tools.
-            callback_manager: The callback manager. Default is None.
-            output_parser: The output parser. Default is None.
-            system_message_prefix: The system message prefix.
-                Default is SYSTEM_MESSAGE_PREFIX.
-            system_message_suffix: The system message suffix.
-                Default is SYSTEM_MESSAGE_SUFFIX.
-            human_message: The human message. Default is HUMAN_MESSAGE.
-            format_instructions: The format instructions.
-                Default is FORMAT_INSTRUCTIONS.
-            input_variables: The input variables. Default is None.
-            kwargs: Additional keyword arguments.
-
-        Returns:
-            An agent.
-        """
-        cls._validate_tools(tools)
-        prompt = cls.create_prompt(
-            tools,
-            system_message_prefix=system_message_prefix,
-            system_message_suffix=system_message_suffix,
-            human_message=human_message,
-            format_instructions=format_instructions,
-            input_variables=input_variables,
-        )
-        llm_chain = LLMChain(
-            llm=llm,
-            prompt=prompt,
-            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,
-        )
-
-    @property
-    def _agent_type(self) -> str:
-        raise ValueError