
    3fi+                        d dl mZ d dlmZ d dlmZ d dlmZ d dlm	Z	m
Z
 d dlmZ d dlmZmZ d dlmZ d d	lmZ d d
lmZ defdd	 	 	 	 	 	 	 	 	 	 	 	 	 ddZy)    )annotations)Sequence)BaseLanguageModel)BasePromptTemplate)RunnableRunnablePassthrough)BaseTool)ToolsRendererrender_text_description)AgentOutputParserformat_log_to_str)ReActSingleInputOutputParserNT)stop_sequencec          	        h dj                  |j                  t        |j                        z         }|rd| }t	        |      |j                   |t        |            dj                  |D cg c]  }|j                   c}            }|r|du rdgn|}	| j                  |	      }
n| }
|xs
 t               }t        j                  d 	      |z  |
z  |z  S c c}w )
aB  Create an agent that uses ReAct prompting.

    Based on paper "ReAct: Synergizing Reasoning and Acting in Language Models"
    (https://arxiv.org/abs/2210.03629)

    !!! warning
       This implementation is based on the foundational ReAct paper but is older and
       not well-suited for production applications.
       For a more robust and feature-rich implementation, we recommend using the
       `create_react_agent` function from the LangGraph library.
       See the
       [reference doc](https://langchain-ai.github.io/langgraph/reference/prebuilt/#langgraph.prebuilt.chat_agent_executor.create_react_agent)
       for more information.

    Args:
        llm: LLM to use as the agent.
        tools: Tools this agent has access to.
        prompt: The prompt to use. See Prompt section below for more.
        output_parser: AgentOutputParser for parse the LLM output.
        tools_renderer: This controls how the tools are converted into a string and
            then passed into the LLM.
        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.

            You may to set this to False if the LLM you are using
            does not support stop sequences.

    Returns:
        A Runnable sequence representing an agent. It takes as input all the same input
        variables as the prompt passed in does. It returns as output either an
        AgentAction or AgentFinish.

    Examples:
        ```python
        from langchain_classic import hub
        from langchain_openai import OpenAI
        from langchain_classic.agents import AgentExecutor, create_react_agent

        prompt = hub.pull("hwchase17/react")
        model = OpenAI()
        tools = ...

        agent = create_react_agent(model, tools, prompt)
        agent_executor = AgentExecutor(agent=agent, tools=tools)

        agent_executor.invoke({"input": "hi"})

        # Use with chat history
        from langchain_core.messages import AIMessage, HumanMessage

        agent_executor.invoke(
            {
                "input": "what's my name?",
                # Notice that chat_history is a string
                # since this prompt is aimed at LLMs, not chat models
                "chat_history": "Human: My name is Bob\nAI: Hello Bob!",
            }
        )
        ```

    Prompt:

        The prompt must have input keys:
            * `tools`: contains descriptions and arguments for each tool.
            * `tool_names`: contains all tool names.
            * `agent_scratchpad`: contains previous agent actions and tool outputs as a
                string.

        Here's an example:

        ```python
        from langchain_core.prompts import PromptTemplate

        template = '''Answer the following questions as best you can. You have access to the following tools:

        {tools}

        Use the following format:

        Question: the input question you must answer
        Thought: you should always think about what to do
        Action: the action to take, should be one of [{tool_names}]
        Action Input: the input to the action
        Observation: the result of the action
        ... (this Thought/Action/Action Input/Observation can repeat N times)
        Thought: I now know the final answer
        Final Answer: the final answer to the original input question

        Begin!

        Question: {input}
        Thought:{agent_scratchpad}'''

        prompt = PromptTemplate.from_template(template)
        ```
    >   tools
tool_namesagent_scratchpadz#Prompt missing required variables: z, )r   r   Tz
Observation)stopc                    t        | d         S )Nintermediate_stepsr   )xs    b/var/www/auto_recruiter/arenv/lib/python3.12/site-packages/langchain_classic/agents/react/agent.py<lambda>z$create_react_agent.<locals>.<lambda>   s    '8;O9P'Q     )r   )
differenceinput_variableslistpartial_variables
ValueErrorpartialjoinnamebindr   r   assign)llmr   promptoutput_parsertools_rendererr   missing_varsmsgtr   llm_with_stops              r   create_react_agentr.      s    V ?IIf&>&>!??L 3L>Bo^^T%[)99e4aff45  F $1T$9 }d+!C%A%CM""Q	
 	 		
 	 5s   0C)r&   r   r   zSequence[BaseTool]r'   r   r(   zAgentOutputParser | Noner)   r
   r   zbool | list[str]returnr   )
__future__r   collections.abcr   langchain_core.language_modelsr   langchain_core.promptsr   langchain_core.runnablesr   r   langchain_core.toolsr	   langchain_core.tools.renderr
   r   langchain_classic.agentsr   *langchain_classic.agents.format_scratchpadr   'langchain_classic.agents.output_parsersr   r.    r   r   <module>r;      s    " $ < 5 B ) N 6 H P /3$;C '+C	CC C ,	C
 "C $C Cr   