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

langchain/agents/self_ask_with_search/base.py

@@ -1,219 +0,0 @@
-"""Chain that does self-ask with search."""
-
-from __future__ import annotations
-
-from collections.abc import Sequence
-from typing import TYPE_CHECKING, Any, Union
-
-from langchain_core._api import deprecated
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.prompts import BasePromptTemplate
-from langchain_core.runnables import Runnable, RunnablePassthrough
-from langchain_core.tools import BaseTool, Tool
-from pydantic import Field
-from typing_extensions import override
-
-from langchain.agents.agent import Agent, AgentExecutor, AgentOutputParser
-from langchain.agents.agent_types import AgentType
-from langchain.agents.format_scratchpad import format_log_to_str
-from langchain.agents.self_ask_with_search.output_parser import SelfAskOutputParser
-from langchain.agents.self_ask_with_search.prompt import PROMPT
-from langchain.agents.utils import validate_tools_single_input
-
-if TYPE_CHECKING:
-    from langchain_community.utilities.google_serper import GoogleSerperAPIWrapper
-    from langchain_community.utilities.searchapi import SearchApiAPIWrapper
-    from langchain_community.utilities.serpapi import SerpAPIWrapper
-
-
-@deprecated("0.1.0", alternative="create_self_ask_with_search", removal="1.0")
-class SelfAskWithSearchAgent(Agent):
-    """Agent for the self-ask-with-search paper."""
-
-    output_parser: AgentOutputParser = Field(default_factory=SelfAskOutputParser)
-
-    @classmethod
-    @override
-    def _get_default_output_parser(cls, **kwargs: Any) -> AgentOutputParser:
-        return SelfAskOutputParser()
-
-    @property
-    def _agent_type(self) -> str:
-        """Return Identifier of an agent type."""
-        return AgentType.SELF_ASK_WITH_SEARCH
-
-    @classmethod
-    @override
-    def create_prompt(cls, tools: Sequence[BaseTool]) -> BasePromptTemplate:
-        """Prompt does not depend on tools."""
-        return PROMPT
-
-    @classmethod
-    def _validate_tools(cls, tools: Sequence[BaseTool]) -> None:
-        validate_tools_single_input(cls.__name__, tools)
-        super()._validate_tools(tools)
-        if len(tools) != 1:
-            msg = f"Exactly one tool must be specified, but got {tools}"
-            raise ValueError(msg)
-        tool_names = {tool.name for tool in tools}
-        if tool_names != {"Intermediate Answer"}:
-            msg = f"Tool name should be Intermediate Answer, got {tool_names}"
-            raise ValueError(msg)
-
-    @property
-    def observation_prefix(self) -> str:
-        """Prefix to append the observation with."""
-        return "Intermediate answer: "
-
-    @property
-    def llm_prefix(self) -> str:
-        """Prefix to append the LLM call with."""
-        return ""
-
-
-@deprecated("0.1.0", removal="1.0")
-class SelfAskWithSearchChain(AgentExecutor):
-    """[Deprecated] Chain that does self-ask with search."""
-
-    def __init__(
-        self,
-        llm: BaseLanguageModel,
-        search_chain: Union[
-            GoogleSerperAPIWrapper,
-            SearchApiAPIWrapper,
-            SerpAPIWrapper,
-        ],
-        **kwargs: Any,
-    ):
-        """Initialize only with an LLM and a search chain."""
-        search_tool = Tool(
-            name="Intermediate Answer",
-            func=search_chain.run,
-            coroutine=search_chain.arun,
-            description="Search",
-        )
-        agent = SelfAskWithSearchAgent.from_llm_and_tools(llm, [search_tool])
-        super().__init__(agent=agent, tools=[search_tool], **kwargs)
-
-
-def create_self_ask_with_search_agent(
-    llm: BaseLanguageModel,
-    tools: Sequence[BaseTool],
-    prompt: BasePromptTemplate,
-) -> Runnable:
-    """Create an agent that uses self-ask with search prompting.
-
-    Args:
-        llm: LLM to use as the agent.
-        tools: List of tools. Should just be of length 1, with that tool having
-            name `Intermediate Answer`
-        prompt: The prompt to use, must have input key `agent_scratchpad` which will
-            contain agent actions and tool outputs.
-
-    Returns:
-        A Runnable sequence representing an agent. It takes as input all the same input
-        variables as the prompt passed in does. It returns as output either an
-        AgentAction or AgentFinish.
-
-    Examples:
-
-        .. code-block:: python
-
-            from langchain import hub
-            from langchain_community.chat_models import ChatAnthropic
-            from langchain.agents import (
-                AgentExecutor, create_self_ask_with_search_agent
-            )
-
-            prompt = hub.pull("hwchase17/self-ask-with-search")
-            model = ChatAnthropic(model="claude-3-haiku-20240307")
-            tools = [...]  # Should just be one tool with name `Intermediate Answer`
-
-            agent = create_self_ask_with_search_agent(model, tools, prompt)
-            agent_executor = AgentExecutor(agent=agent, tools=tools)
-
-            agent_executor.invoke({"input": "hi"})
-
-    Prompt:
-
-        The prompt must have input key `agent_scratchpad` which will
-            contain agent actions and tool outputs as a string.
-
-        Here's an example:
-
-        .. code-block:: python
-
-            from langchain_core.prompts import PromptTemplate
-
-            template = '''Question: Who lived longer, Muhammad Ali or Alan Turing?
-            Are follow up questions needed here: Yes.
-            Follow up: How old was Muhammad Ali when he died?
-            Intermediate answer: Muhammad Ali was 74 years old when he died.
-            Follow up: How old was Alan Turing when he died?
-            Intermediate answer: Alan Turing was 41 years old when he died.
-            So the final answer is: Muhammad Ali
-
-            Question: When was the founder of craigslist born?
-            Are follow up questions needed here: Yes.
-            Follow up: Who was the founder of craigslist?
-            Intermediate answer: Craigslist was founded by Craig Newmark.
-            Follow up: When was Craig Newmark born?
-            Intermediate answer: Craig Newmark was born on December 6, 1952.
-            So the final answer is: December 6, 1952
-
-            Question: Who was the maternal grandfather of George Washington?
-            Are follow up questions needed here: Yes.
-            Follow up: Who was the mother of George Washington?
-            Intermediate answer: The mother of George Washington was Mary Ball Washington.
-            Follow up: Who was the father of Mary Ball Washington?
-            Intermediate answer: The father of Mary Ball Washington was Joseph Ball.
-            So the final answer is: Joseph Ball
-
-            Question: Are both the directors of Jaws and Casino Royale from the same country?
-            Are follow up questions needed here: Yes.
-            Follow up: Who is the director of Jaws?
-            Intermediate answer: The director of Jaws is Steven Spielberg.
-            Follow up: Where is Steven Spielberg from?
-            Intermediate answer: The United States.
-            Follow up: Who is the director of Casino Royale?
-            Intermediate answer: The director of Casino Royale is Martin Campbell.
-            Follow up: Where is Martin Campbell from?
-            Intermediate answer: New Zealand.
-            So the final answer is: No
-
-            Question: {input}
-            Are followup questions needed here:{agent_scratchpad}'''
-
-            prompt = PromptTemplate.from_template(template)
-
-    """  # noqa: E501
-    missing_vars = {"agent_scratchpad"}.difference(
-        prompt.input_variables + list(prompt.partial_variables),
-    )
-    if missing_vars:
-        msg = f"Prompt missing required variables: {missing_vars}"
-        raise ValueError(msg)
-
-    if len(tools) != 1:
-        msg = "This agent expects exactly one tool"
-        raise ValueError(msg)
-    tool = next(iter(tools))
-    if tool.name != "Intermediate Answer":
-        msg = "This agent expects the tool to be named `Intermediate Answer`"
-        raise ValueError(msg)
-
-    llm_with_stop = llm.bind(stop=["\nIntermediate answer:"])
-    return (
-        RunnablePassthrough.assign(
-            agent_scratchpad=lambda x: format_log_to_str(
-                x["intermediate_steps"],
-                observation_prefix="\nIntermediate answer: ",
-                llm_prefix="",
-            ),
-            # Give it a default
-            chat_history=lambda x: x.get("chat_history", ""),
-        )
-        | prompt
-        | llm_with_stop
-        | SelfAskOutputParser()
-    )

langchain/agents/self_ask_with_search/output_parser.py

@@ -1,4 +0,0 @@
-from langchain.agents.output_parsers.self_ask import SelfAskOutputParser
-
-# For backwards compatibility
-__all__ = ["SelfAskOutputParser"]

langchain/agents/self_ask_with_search/prompt.py

@@ -1,43 +0,0 @@
-from langchain_core.prompts.prompt import PromptTemplate
-
-_DEFAULT_TEMPLATE = """Question: Who lived longer, Muhammad Ali or Alan Turing?
-Are follow up questions needed here: Yes.
-Follow up: How old was Muhammad Ali when he died?
-Intermediate answer: Muhammad Ali was 74 years old when he died.
-Follow up: How old was Alan Turing when he died?
-Intermediate answer: Alan Turing was 41 years old when he died.
-So the final answer is: Muhammad Ali
-
-Question: When was the founder of craigslist born?
-Are follow up questions needed here: Yes.
-Follow up: Who was the founder of craigslist?
-Intermediate answer: Craigslist was founded by Craig Newmark.
-Follow up: When was Craig Newmark born?
-Intermediate answer: Craig Newmark was born on December 6, 1952.
-So the final answer is: December 6, 1952
-
-Question: Who was the maternal grandfather of George Washington?
-Are follow up questions needed here: Yes.
-Follow up: Who was the mother of George Washington?
-Intermediate answer: The mother of George Washington was Mary Ball Washington.
-Follow up: Who was the father of Mary Ball Washington?
-Intermediate answer: The father of Mary Ball Washington was Joseph Ball.
-So the final answer is: Joseph Ball
-
-Question: Are both the directors of Jaws and Casino Royale from the same country?
-Are follow up questions needed here: Yes.
-Follow up: Who is the director of Jaws?
-Intermediate answer: The director of Jaws is Steven Spielberg.
-Follow up: Where is Steven Spielberg from?
-Intermediate answer: The United States.
-Follow up: Who is the director of Casino Royale?
-Intermediate answer: The director of Casino Royale is Martin Campbell.
-Follow up: Where is Martin Campbell from?
-Intermediate answer: New Zealand.
-So the final answer is: No
-
-Question: {input}
-Are followup questions needed here:{agent_scratchpad}"""
-PROMPT = PromptTemplate(
-    input_variables=["input", "agent_scratchpad"], template=_DEFAULT_TEMPLATE
-)

langchain/agents/structured_chat/base.py

@@ -1,309 +0,0 @@
-import re
-from collections.abc import Sequence
-from typing import Any, Optional, Union
-
-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.runnables import Runnable, RunnablePassthrough
-from langchain_core.tools import BaseTool
-from langchain_core.tools.render import ToolsRenderer
-from pydantic import Field
-from typing_extensions import override
-
-from langchain.agents.agent import Agent, AgentOutputParser
-from langchain.agents.format_scratchpad import format_log_to_str
-from langchain.agents.output_parsers import JSONAgentOutputParser
-from langchain.agents.structured_chat.output_parser import (
-    StructuredChatOutputParserWithRetries,
-)
-from langchain.agents.structured_chat.prompt import FORMAT_INSTRUCTIONS, PREFIX, SUFFIX
-from langchain.chains.llm import LLMChain
-from langchain.tools.render import render_text_description_and_args
-
-HUMAN_MESSAGE_TEMPLATE = "{input}\n\n{agent_scratchpad}"
-
-
-@deprecated("0.1.0", alternative="create_structured_chat_agent", removal="1.0")
-class StructuredChatAgent(Agent):
-    """Structured Chat Agent."""
-
-    output_parser: AgentOutputParser = Field(
-        default_factory=StructuredChatOutputParserWithRetries,
-    )
-    """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
-    def _validate_tools(cls, tools: Sequence[BaseTool]) -> None:
-        pass
-
-    @classmethod
-    @override
-    def _get_default_output_parser(
-        cls,
-        llm: Optional[BaseLanguageModel] = None,
-        **kwargs: Any,
-    ) -> AgentOutputParser:
-        return StructuredChatOutputParserWithRetries.from_llm(llm=llm)
-
-    @property
-    @override
-    def _stop(self) -> list[str]:
-        return ["Observation:"]
-
-    @classmethod
-    @override
-    def create_prompt(
-        cls,
-        tools: Sequence[BaseTool],
-        prefix: str = PREFIX,
-        suffix: str = SUFFIX,
-        human_message_template: str = HUMAN_MESSAGE_TEMPLATE,
-        format_instructions: str = FORMAT_INSTRUCTIONS,
-        input_variables: Optional[list[str]] = None,
-        memory_prompts: Optional[list[BasePromptTemplate]] = None,
-    ) -> BasePromptTemplate:
-        tool_strings = []
-        for tool in tools:
-            args_schema = re.sub("}", "}}", re.sub("{", "{{", str(tool.args)))
-            tool_strings.append(f"{tool.name}: {tool.description}, args: {args_schema}")
-        formatted_tools = "\n".join(tool_strings)
-        tool_names = ", ".join([tool.name for tool in tools])
-        format_instructions = format_instructions.format(tool_names=tool_names)
-        template = f"{prefix}\n\n{formatted_tools}\n\n{format_instructions}\n\n{suffix}"
-        if input_variables is None:
-            input_variables = ["input", "agent_scratchpad"]
-        _memory_prompts = memory_prompts or []
-        messages = [
-            SystemMessagePromptTemplate.from_template(template),
-            *_memory_prompts,
-            HumanMessagePromptTemplate.from_template(human_message_template),
-        ]
-        return ChatPromptTemplate(input_variables=input_variables, messages=messages)  # type: ignore[arg-type]
-
-    @classmethod
-    def from_llm_and_tools(
-        cls,
-        llm: BaseLanguageModel,
-        tools: Sequence[BaseTool],
-        callback_manager: Optional[BaseCallbackManager] = None,
-        output_parser: Optional[AgentOutputParser] = None,
-        prefix: str = PREFIX,
-        suffix: str = SUFFIX,
-        human_message_template: str = HUMAN_MESSAGE_TEMPLATE,
-        format_instructions: str = FORMAT_INSTRUCTIONS,
-        input_variables: Optional[list[str]] = None,
-        memory_prompts: Optional[list[BasePromptTemplate]] = None,
-        **kwargs: Any,
-    ) -> Agent:
-        """Construct an agent from an LLM and tools."""
-        cls._validate_tools(tools)
-        prompt = cls.create_prompt(
-            tools,
-            prefix=prefix,
-            suffix=suffix,
-            human_message_template=human_message_template,
-            format_instructions=format_instructions,
-            input_variables=input_variables,
-            memory_prompts=memory_prompts,
-        )
-        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(llm=llm)
-        return cls(
-            llm_chain=llm_chain,
-            allowed_tools=tool_names,
-            output_parser=_output_parser,
-            **kwargs,
-        )
-
-    @property
-    def _agent_type(self) -> str:
-        raise ValueError
-
-
-def create_structured_chat_agent(
-    llm: BaseLanguageModel,
-    tools: Sequence[BaseTool],
-    prompt: ChatPromptTemplate,
-    tools_renderer: ToolsRenderer = render_text_description_and_args,
-    *,
-    stop_sequence: Union[bool, list[str]] = True,
-) -> Runnable:
-    """Create an agent aimed at supporting tools with multiple inputs.
-
-    Args:
-        llm: LLM to use as the agent.
-        tools: Tools this agent has access to.
-        prompt: The prompt to use. See Prompt section below for more.
-        stop_sequence: bool or list of str.
-            If True, adds a stop token of "Observation:" to avoid hallucinates.
-            If False, does not add a stop token.
-            If a list of str, uses the provided list as the stop tokens.
-
-            Default is True. You may to set this to False if the LLM you are using
-            does not support stop sequences.
-        tools_renderer: This controls how the tools are converted into a string and
-            then passed into the LLM. Default is `render_text_description`.
-
-    Returns:
-        A Runnable sequence representing an agent. It takes as input all the same input
-        variables as the prompt passed in does. It returns as output either an
-        AgentAction or AgentFinish.
-
-    Examples:
-
-        .. code-block:: python
-
-            from langchain import hub
-            from langchain_community.chat_models import ChatOpenAI
-            from langchain.agents import AgentExecutor, create_structured_chat_agent
-
-            prompt = hub.pull("hwchase17/structured-chat-agent")
-            model = ChatOpenAI()
-            tools = ...
-
-            agent = create_structured_chat_agent(model, tools, prompt)
-            agent_executor = AgentExecutor(agent=agent, tools=tools)
-
-            agent_executor.invoke({"input": "hi"})
-
-            # Using with chat history
-            from langchain_core.messages import AIMessage, HumanMessage
-            agent_executor.invoke(
-                {
-                    "input": "what's my name?",
-                    "chat_history": [
-                        HumanMessage(content="hi! my name is bob"),
-                        AIMessage(content="Hello Bob! How can I assist you today?"),
-                    ],
-                }
-            )
-
-    Prompt:
-
-        The prompt must have input keys:
-            * `tools`: contains descriptions and arguments for each tool.
-            * `tool_names`: contains all tool names.
-            * `agent_scratchpad`: contains previous agent actions and tool outputs as a string.
-
-        Here's an example:
-
-        .. code-block:: python
-
-            from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
-
-            system = '''Respond to the human as helpfully and accurately as possible. You have access to the following tools:
-
-            {tools}
-
-            Use a json blob to specify a tool by providing an action key (tool name) and an action_input key (tool input).
-
-            Valid "action" values: "Final Answer" or {tool_names}
-
-            Provide only ONE action per $JSON_BLOB, as shown:
-
-            ```
-            {{
-              "action": $TOOL_NAME,
-              "action_input": $INPUT
-            }}
-            ```
-
-            Follow this format:
-
-            Question: input question to answer
-            Thought: consider previous and subsequent steps
-            Action:
-            ```
-            $JSON_BLOB
-            ```
-            Observation: action result
-            ... (repeat Thought/Action/Observation N times)
-            Thought: I know what to respond
-            Action:
-            ```
-            {{
-              "action": "Final Answer",
-              "action_input": "Final response to human"
-            }}
-
-            Begin! Reminder to ALWAYS respond with a valid json blob of a single action. Use tools if necessary. Respond directly if appropriate. Format is Action:```$JSON_BLOB```then Observation'''
-
-            human = '''{input}
-
-            {agent_scratchpad}
-
-            (reminder to respond in a JSON blob no matter what)'''
-
-            prompt = ChatPromptTemplate.from_messages(
-                [
-                    ("system", system),
-                    MessagesPlaceholder("chat_history", optional=True),
-                    ("human", human),
-                ]
-            )
-
-    """  # noqa: E501
-    missing_vars = {"tools", "tool_names", "agent_scratchpad"}.difference(
-        prompt.input_variables + list(prompt.partial_variables),
-    )
-    if missing_vars:
-        msg = f"Prompt missing required variables: {missing_vars}"
-        raise ValueError(msg)
-
-    prompt = prompt.partial(
-        tools=tools_renderer(list(tools)),
-        tool_names=", ".join([t.name for t in tools]),
-    )
-    if stop_sequence:
-        stop = ["\nObservation"] if stop_sequence is True else stop_sequence
-        llm_with_stop = llm.bind(stop=stop)
-    else:
-        llm_with_stop = llm
-
-    return (
-        RunnablePassthrough.assign(
-            agent_scratchpad=lambda x: format_log_to_str(x["intermediate_steps"]),
-        )
-        | prompt
-        | llm_with_stop
-        | JSONAgentOutputParser()
-    )

langchain/agents/structured_chat/output_parser.py

@@ -1,112 +0,0 @@
-from __future__ import annotations
-
-import json
-import logging
-import re
-from re import Pattern
-from typing import Optional, Union
-
-from langchain_core.agents import AgentAction, AgentFinish
-from langchain_core.exceptions import OutputParserException
-from langchain_core.language_models import BaseLanguageModel
-from pydantic import Field
-from typing_extensions import override
-
-from langchain.agents.agent import AgentOutputParser
-from langchain.agents.structured_chat.prompt import FORMAT_INSTRUCTIONS
-from langchain.output_parsers import OutputFixingParser
-
-logger = logging.getLogger(__name__)
-
-
-class StructuredChatOutputParser(AgentOutputParser):
-    """Output parser for the structured chat agent."""
-
-    format_instructions: str = FORMAT_INSTRUCTIONS
-    """Default formatting instructions"""
-
-    pattern: Pattern = re.compile(r"```(?:json\s+)?(\W.*?)```", re.DOTALL)
-    """Regex pattern to parse the output."""
-
-    @override
-    def get_format_instructions(self) -> str:
-        """Returns formatting instructions for the given output parser."""
-        return self.format_instructions
-
-    @override
-    def parse(self, text: str) -> Union[AgentAction, AgentFinish]:
-        try:
-            action_match = self.pattern.search(text)
-            if action_match is not None:
-                response = json.loads(action_match.group(1).strip(), strict=False)
-                if isinstance(response, list):
-                    # gpt turbo frequently ignores the directive to emit a single action
-                    logger.warning("Got multiple action responses: %s", response)
-                    response = response[0]
-                if response["action"] == "Final Answer":
-                    return AgentFinish({"output": response["action_input"]}, text)
-                return AgentAction(
-                    response["action"],
-                    response.get("action_input", {}),
-                    text,
-                )
-            return AgentFinish({"output": text}, text)
-        except Exception as e:
-            msg = f"Could not parse LLM output: {text}"
-            raise OutputParserException(msg) from e
-
-    @property
-    def _type(self) -> str:
-        return "structured_chat"
-
-
-class StructuredChatOutputParserWithRetries(AgentOutputParser):
-    """Output parser with retries for the structured chat agent."""
-
-    base_parser: AgentOutputParser = Field(default_factory=StructuredChatOutputParser)
-    """The base parser to use."""
-    output_fixing_parser: Optional[OutputFixingParser] = None
-    """The output fixing parser to use."""
-
-    @override
-    def get_format_instructions(self) -> str:
-        return FORMAT_INSTRUCTIONS
-
-    @override
-    def parse(self, text: str) -> Union[AgentAction, AgentFinish]:
-        try:
-            if self.output_fixing_parser is not None:
-                return self.output_fixing_parser.parse(text)
-            return self.base_parser.parse(text)
-        except Exception as e:
-            msg = f"Could not parse LLM output: {text}"
-            raise OutputParserException(msg) from e
-
-    @classmethod
-    def from_llm(
-        cls,
-        llm: Optional[BaseLanguageModel] = None,
-        base_parser: Optional[StructuredChatOutputParser] = None,
-    ) -> StructuredChatOutputParserWithRetries:
-        """Create a StructuredChatOutputParserWithRetries from a language model.
-
-        Args:
-            llm: The language model to use.
-            base_parser: An optional StructuredChatOutputParser to use.
-        Returns:
-            An instance of StructuredChatOutputParserWithRetries.
-        """
-        if llm is not None:
-            base_parser = base_parser or StructuredChatOutputParser()
-            output_fixing_parser: OutputFixingParser = OutputFixingParser.from_llm(
-                llm=llm,
-                parser=base_parser,
-            )
-            return cls(output_fixing_parser=output_fixing_parser)
-        if base_parser is not None:
-            return cls(base_parser=base_parser)
-        return cls()
-
-    @property
-    def _type(self) -> str:
-        return "structured_chat_with_retries"