How does AgentFinish class actually work behind the scenes ? What is the clue for Agent to Finish ? What part of the open ai sdk is being used here ?

[krishnazanwar1407]

Checked other resources

• I added a very descriptive title to this question.
• I searched the LangChain documentation with the integrated search.
• I used the GitHub search to find a similar question and didn't find it.

Commit to Help

• I commit to help with one of those options 👆

Example Code

class langchain_core.agents.AgentFinish[source]¶

Description

I want to understand what's special about AgentFinish

System Info

langchain 0.2.11

[krishnazanwar1407]

@dosu Can you help answer this please

[dosubot[bot]]

Hey @krishnazanwar1407! I'm here to help you with any bugs, questions, or contributions you have. I'm currently waiting for a human maintainer, but in the meantime, feel free to ask me anything.

The AgentFinish class in the langchain_core.agents module is used to signal that an agent has reached a stopping condition and is ready to return its final result. Here's a breakdown of how it works:

1. Triggering an Agent to Finish:

   • An agent finishes when it reaches a predefined stopping condition, such as an iteration limit or a time limit. This is indicated by the agent returning an AgentFinish object.
   • For example, if the early stopping method is "force", the agent will return an AgentFinish object with a message indicating that it stopped due to the iteration or time limit.

2. OpenAI SDK Usage:

   • The AIMessage class from the OpenAI SDK is used to return messages that correspond to the agent's observations. This is part of the AgentFinish class's messages property.

3. Class Definition:

   • The AgentFinish class contains a dictionary of return values and a log string for additional information. The log can include the full LLM prediction for debugging or observability purposes.

Here's a snippet of the AgentFinish class:

class AgentFinish(Serializable):
    """The final return value of an ActionAgent.

    Agents return an AgentFinish when they have reached a stopping condition.
    """

    return_values: dict
    """Dictionary of return values."""
    log: str
    """Additional information to log about the return value.
    This is used to pass along the full LLM prediction, not just the parsed out
    return value. For example, if the full LLM prediction was
    `Final Answer: 2` you may want to just return `2` as a return value, but pass
    along the full string as a `log` (for debugging or observability purposes).
    """
    type: Literal["AgentFinish"] = "AgentFinish"

    def __init__(self, return_values: dict, log: str, **kwargs: Any):
        """Override init to support instantiation by position for backward compat."""
        super().__init__(return_values=return_values, log=log, **kwargs)

    @property
    def messages(self) -> Sequence[BaseMessage]:
        """Return the messages that correspond to this observation."""
        return [AIMessage(content=self.log)]

Additionally, the plan method in the OpenAIFunctionsAgent class demonstrates how the AgentFinish object is handled when an agent finishes its task:

def plan(
        self,
        intermediate_steps: List[Tuple[AgentAction, str]],
        callbacks: Callbacks = None,
        with_functions: bool = True,
        **kwargs: Any,
    ) -> Union[AgentAction, AgentFinish]:
        """Given input, decided what to do.

        Args:
            intermediate_steps: Steps the LLM has taken to date,
                along with observations.
            callbacks: Callbacks to use. Defaults to None.
            with_functions: Whether to use functions. Defaults to True.
            **kwargs: User inputs.

        Returns:
            Action specifying what tool to use.
            If the agent is finished, returns an AgentFinish.
            If the agent is not finished, returns an AgentAction.
        """
        agent_scratchpad = format_to_openai_function_messages(intermediate_steps)
        selected_inputs = {
            k: kwargs[k] for k in self.prompt.input_variables if k != "agent_scratchpad"
        }
        full_inputs = dict(**selected_inputs, agent_scratchpad=agent_scratchpad)
        prompt = self.prompt.format_prompt(**full_inputs)
        messages = prompt.to_messages()
        if with_functions:
            predicted_message = self.llm.predict_messages(
                messages,
                functions=self.functions,
                callbacks=callbacks,
            )
        else:
            predicted_message = self.llm.predict_messages(
                messages,
                callbacks=callbacks,
            )
        agent_decision = self.output_parser._parse_ai_message(predicted_message)
        return agent_decision

In summary, the AgentFinish class is used to signal the completion of an agent's task, and it leverages the AIMessage class from the OpenAI SDK to return the final messages ^[1][2].

To continue talking to Dosu, mention @dosu.

[krishnazanwar1407]

@dosu give me a real example please

[dosubot[bot]]

To demonstrate how to use the AgentFinish class in the langchain_core.agents module, we can create an example where an agent signals that it has reached a stopping condition and is ready to return its final result. This example will also show how it interacts with the OpenAI SDK, particularly the AIMessage class.

Here is a real example:

from langchain_core.agents import AgentFinish
from langchain_core.messages import AIMessage
from langchain_core.outputs import ChatGeneration

# Simulate the final return values and log from an agent
return_values = {"final_answer": 42}
log = "Final Answer: 42"

# Create an instance of AgentFinish
agent_finish = AgentFinish(return_values=return_values, log=log)

# Access the messages property to get the corresponding AIMessage
messages = agent_finish.messages

# Print the messages to see the interaction
for message in messages:
    print(f"Message content: {message.content}")

# Output:
# Message content: Final Answer: 42

In this example:

1. We create an instance of AgentFinish with the final return values and a log message.
2. We access the messages property of the AgentFinish instance, which returns a sequence of AIMessage objects.
3. We print the content of each message to see the interaction.

Additionally, the OpenAIFunctionsAgentOutputParser class from the langchain library can be used to parse messages into agent actions or an AgentFinish instance. This class is designed to work with OpenAI models and relies on the specific tool_calls parameter from OpenAI to convey what tools to use. If no tool_calls parameter is passed, the AIMessage is assumed to be the final output.

Here is an example of how the OpenAIFunctionsAgentOutputParser can be used:

from langchain_core.agents import AgentFinish
from langchain_core.messages import BaseMessage
from langchain_core.outputs import ChatGeneration, Generation
from langchain.agents.output_parsers.openai_functions import OpenAIFunctionsAgentOutputParser

# Simulate a ChatGeneration result from OpenAI
chat_generation = ChatGeneration(message=BaseMessage(content="Final Answer: 42"))

# Create an instance of OpenAIFunctionsAgentOutputParser
parser = OpenAIFunctionsAgentOutputParser()

# Parse the result to get either a list of AgentActions or an AgentFinish
parsed_result = parser.parse_result([chat_generation])

if isinstance(parsed_result, AgentFinish):
    print(f"Final result: {parsed_result.return_values}")
else:
    for action in parsed_result:
        print(f"Action: {action}")

In this example:

1. We simulate a ChatGeneration result from OpenAI.
2. We create an instance of OpenAIFunctionsAgentOutputParser.
3. We parse the result to get either a list of AgentAction instances or an AgentFinish instance.
4. We print the final result if it is an AgentFinish instance, or the actions if they are AgentAction instances.

This demonstrates how an agent signals that it has reached a stopping condition and how it interacts with the AIMessage class from the OpenAI SDK, as well as how to use the OpenAIFunctionsAgentOutputParser to parse the final output ^[1][2][3].

To continue talking to Dosu, mention @dosu.