Langgraph does not stop after the tool returns a response

[mrctito]

Hi @dosu,

I’m running an assistant with only one tool, which is being triggered correctly. However, result.tool_calls always returns False, and the process eventually reaches the maximum recursion limit.

I don’t want to increase this limit. Instead, I need the workflow to stop as soon as the tool returns a response.

Below, I’ve provided the details of the tool and the relevant code snippet for review.

@tool
async def tool_informa_o_clima():
    """
    Useful for providing the current weather.
    """
    return {"Response": "The weather is stable and sunny."}
    
   
class Assistant:
    def __init__(self, runnable: Runnable):
        self.runnable = runnable

    def __call__(self, state, config: RunnableConfig):
        while True:
            configuration = config.get("configurable", {})
            context = configuration.get("contexto", {})
            user_id = configuration.get("user_id", None)
            state = {**state, "user_info": user_id, **context}
            result = self.runnable.invoke(state)
            # Re-prompt if LLM returns an empty response
            if not result.tool_calls and (
                not result.content
                or isinstance(result.content, list)
                and not result.content[0].get("text")
            ):
                messages = state["messages"] + [("user", "Respond with a real output.")]
                state = {**state, "messages": messages}
            else:
                print("*** break:" + str(result))
                break
        return {"messages": result}


def handle_tool_error(error):
    msg = f"An error occurred while using the tool: {str(error)}"
    print(msg)
    return msg


def create_tool_node_with_fallback(tools: list) -> dict:
    return ToolNode(tools).with_fallbacks(
        [RunnableLambda(handle_tool_error)], exception_key="error"
    )



self.llm_with_tools = self.llm.bind_tools(self.tools)

primary_assistant_prompt = ChatPromptTemplate.from_messages(
    [
        ("system", self.prompt_str),
        ("human", "{input}"),
        ("placeholder", "{messages}"),
    ]
)
assistant_runnable = primary_assistant_prompt | self.llm_with_tools

builder = StateGraph(MessagesState)
builder.add_node("assistant", Assistant(assistant_runnable))
builder.add_node("tools", create_tool_node_with_fallback(self.tools))
builder.add_edge(START, "assistant")
builder.add_conditional_edges(
    "assistant",
    # If the latest message (result) from assistant is a tool call -> tools_condition routes to tools
    # If the latest message (result) from assistant is not a tool call -> tools_condition routes to END
    tools_condition
)
builder.add_edge("tools", "assistant")
self.graph_builder = builder

checkpointer = await chat.get_memory_checkpoint(memory_type="sqlite")
async with checkpointer as checkpoint:
    self.graph = self.graph_builder.compile(checkpointer=checkpoint)
    thread_id = str(uuid.uuid4())
    config = {
        "configurable": {
            # Fetch the user's id
            "user_id": self.email_usuario,
            # Checkpoints are accessed by thread_id
            "thread_id": thread_id,
            "contexto": self.contexto,
        }
    }

    result = await self.graph.ainvoke(self.contexto, config, debug=True)
    return result


Im running the last version of LanhChain and LangGraph.
Thank you.

[dosubot[bot]]

To address the issue of stopping the LangGraph workflow as soon as the tool returns a response, you can modify the workflow to explicitly handle the tool's response and break the loop when a valid response is detected. Here's a refined approach based on your current setup:

1. Modify the Loop Condition: Ensure that the loop in the Assistant class checks for a valid response from the tool and breaks accordingly.

2. Check for Tool Response: Adjust the condition to properly detect when the tool has returned a response.

Here's an example of how you can modify your code:

class Assistant:
    def __init__(self, runnable: Runnable):
        self.runnable = runnable

    def __call__(self, state, config: RunnableConfig):
        while True:
            configuration = config.get("configurable", {})
            context = configuration.get("contexto", {})
            user_id = configuration.get("user_id", None)
            state = {**state, "user_info": user_id, **context}
            result = self.runnable.invoke(state)
            
            # Check if the tool has returned a response
            if result.tool_calls:
                print("*** break: Tool response received")
                break
            elif not result.content or (isinstance(result.content, list) and not result.content[0].get("text")):
                messages = state["messages"] + [("user", "Respond with a real output.")]
                state = {**state, "messages": messages}
            else:
                print("*** break: " + str(result))
                break
        return {"messages": result}

Key Changes:

• The loop now checks if result.tool_calls: to determine if a tool call was made and a response was received. This should help in breaking the loop as soon as the tool provides a response.

Ensure that your tool is correctly configured to return a response that can be detected by this condition. If result.tool_calls is not behaving as expected, verify that the tool's output is being captured correctly in the result object. Adjust the condition based on the actual structure of the result object if necessary.

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Other}

[dosubot[bot]]

If result.tool_calls is always returning a valid tool call but result.content is always an empty string, there are a few potential reasons and solutions to consider:

1. Tool Message Handling: Ensure that the tool's response is being correctly processed and returned as a ToolMessage. Each ToolMessage should include a tool_call_id that matches the id in the original tool calls. This helps the model match tool responses with tool calls ^[1].

2. Tool Execution and Return: Verify that the tool function (tool_informa_o_clima) is correctly returning the expected response. The tool should return a response that can be captured and processed by the LangChain framework.

3. Tool Message Configuration: Check if the ToolNode is correctly configured to handle the tool's output. Ensure that the tool's response is being added to the state as a ToolMessage and that this message is being passed back to the model.

4. Custom Executor Issues: If you are using a custom executor, ensure that it is correctly invoking and returning the result for the tool call. Any mismatch or misconfiguration here can lead to an empty result.content ^[2].

5. Debugging: Add logging to check the state of the result object after the tool call. This can help identify if the tool's response is being captured but not correctly processed into result.content.

By ensuring that the tool's response is correctly captured and processed, you should be able to resolve the issue of result.content being empty.

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Other}

[mrctito]

@dosu,

These are messages generated:

AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_abaMKeYrnxGmwM5NysZFR7Gw', 'function': {'arguments': '{}', 'name': 'tool_informa_o_clima'}, 'type': 'function'}], 'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 14, 'prompt_tokens': 1497, 'total_tokens': 1511, 'completion_tokens_details': {'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 0, 'rejected_prediction_tokens': 0}, 'prompt_tokens_details': {'audio_tokens': 0, 'cached_tokens': 0}}, 'model_name': 'gpt-4o-mini-2024-07-18', 'system_fingerprint': 'fp_6fc10e10eb', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-b811bf68-2461-4708-8d19-b8829ac822b6-0', tool_calls=[{'name': 'tool_informa_o_clima', 'args': {}, 'id': 'call_abaMKeYrnxGmwM5NysZFR7Gw', 'type': 'tool_call'}], usage_metadata={'input_tokens': 1497, 'output_tokens': 14, 'total_tokens': 1511, 'input_token_details': {'audio': 0, 'cache_read': 0}, 'output_token_details': {'audio': 0, 'reasoning': 0}}),
ToolMessage(content='{"Resposta": "O clima é estável com sol."}', name='tool_informa_o_clima', id='11d75e45-eb86-4ac7-a887-f0ac01301ce4', tool_call_id='call_abaMKeYrnxGmwM5NysZFR7Gw')]}

I am not using custom executor or anything else. I am using the LangGraph documents code.

Tool Execution and Return: Verify that the tool function (tool_informa_o_clima) is correctly returning the expected response. The tool should return a response that can be captured and processed by the LangChain framework. -> Yes, it is.

Tool Message Configuration: Check if the ToolNode is correctly configured to handle the tool's output. Ensure that the tool's response is being added to the state as a ToolMessage and that this message is being passed back to the model. - How do I do that?

Thank you

[dosubot[bot]]

To ensure that the ToolNode is correctly configured to handle the tool's output and that the tool's response is being added to the state as a ToolMessage and passed back to the model, follow these steps:

1. Define the Tool: Make sure your tool function is properly defined and decorated with @tool, specifying the response_format. This ensures the tool's output is correctly formatted and returned.

   from langchain_core.tools import tool
   
   @tool(response_format="content_and_artifact")
   def tool_informa_o_clima():
       """Useful for providing the current weather."""
       return {"Resposta": "O clima é estável com sol."}

2. Integrate with ToolNode: Ensure that the tool is integrated into a ToolNode, which will execute the tool and add the result as a ToolMessage to the state.

   from langgraph.prebuilt import ToolNode
   
   tools = ToolNode([tool_informa_o_clima])

3. Build the Graph: Construct the graph with nodes that handle user input, execute the tool, and generate the final response. Ensure that the ToolNode is part of this sequence.

   from langgraph.graph import StateGraph
   
   graph_builder = StateGraph(MessagesState)
   graph_builder.add_node("assistant", Assistant(assistant_runnable))
   graph_builder.add_node("tools", tools)
   graph_builder.add_edge(START, "assistant")
   graph_builder.add_conditional_edges(
       "assistant",
       tools_condition,
       {END: END, "tools": "tools"},
   )
   graph_builder.add_edge("tools", "assistant")
   graph = graph_builder.compile()

4. Verify Message Handling: Ensure that the ToolNode correctly appends the ToolMessage to the state. Each ToolMessage should include a tool_call_id that matches an id in the original tool calls. This helps the model match tool responses with tool calls ^[1].

5. Check ToolMessage Content: Ensure that the content of the ToolMessage is correctly formatted. The content should be a string or a list of strings/dicts. If the content is not in the correct format, it will be coerced to a string ^[2].

By following these steps, you can ensure that the ToolNode is properly configured to handle the tool's output and that the tool's response is correctly added to the state as a ToolMessage and passed back to the model.

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Other}

[mrctito]

@dosu,

Wich is the content and wich is artifact?

@tool(response_format="content_and_artifact")
def tool_informa_o_clima():
"""Useful for providing the current weather."""
return {"Resposta": "O clima é estável com sol."}

[dosubot[bot]]

In the context of the tool_informa_o_clima function with response_format="content_and_artifact", you need to return a tuple containing two elements: content and artifact. The content is the part of the response intended for the model, typically a string summarizing the result, while the artifact is additional data or the raw output that might be used elsewhere in the application.

Here's how you can modify your function to return both content and artifact:

from langchain_core.tools import tool

@tool(response_format="content_and_artifact")
def tool_informa_o_clima():
    """Useful for providing the current weather."""
    content = "O clima é estável com sol."  # This is the content for the model
    artifact = {"Resposta": "O clima é estável com sol."}  # This is the artifact for external use
    return content, artifact

In this example, content is a string summarizing the weather, and artifact is a dictionary containing the detailed response ^[1].

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Other}

[mrctito]

@dosu, I give up.

It is still not working.

[dosubot[bot]]

This is a tough nut to crack, could really use your help on this, @eyurtsev.

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Other}

[mrctito]

Dear @dosu and @eyurtsev,

I’m certainly doing something wrong, but I’m following this example, replacing it with my own tools. In fact, it’s just a single tool that always returns a string. It’s only for testing purposes, with the difference that I’m using graph.ainvoke instead of graph.stream.

Thank you

[dosubot[bot]]

It seems like you're having trouble getting the tool to work correctly with graph.ainvoke. Here are a few steps to help troubleshoot and resolve the issue:

1. Asynchronous Compatibility: Since you're using graph.ainvoke, ensure that your tool function and any related code are compatible with asynchronous execution. This means using async def for your tool function and ensuring any I/O operations are non-blocking.

2. Tool Return Format: Make sure your tool returns a tuple with content and artifact if you're using response_format="content_and_artifact". The content should be a string for the model, and the artifact can be any additional data.

3. Tool Response Handling: Verify that the tool's response is correctly captured and processed in the result object. The result.tool_calls should reflect the tool's execution, and the result.content should not be empty if the tool is returning a valid response.

4. Debugging: Add logging to check the state of the result object after the tool call. This can help identify if the tool's response is being captured but not correctly processed into result.content.

5. Review the Example: Double-check the example you are following to ensure all necessary configurations and setups are correctly implemented in your code. Pay special attention to how the tool is integrated into the graph and how the graph is invoked.

If these steps do not resolve the issue, consider simplifying your setup to isolate the problem, such as testing the tool independently to ensure it returns the expected output. A maintainer has already been looped in, so they might be able to provide additional insights or assistance.

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Other}

[mrctito]

@dosu, did not work with invoke too.

[dosubot[bot]]

A maintainer has already been looped in.

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Other}

[mrctito]

@dosu and @eyurtsev,

Maybe this log could help you understand the issue. Ypu can see that the tool was called and returned a response:

User input=> 'qual o clima?
Tool answer: 'O clima é estável com sol.'

[0:writes] Finished step 0 with writes to 1 channel:

• messages -> [HumanMessage(content='qual o clima?', additional_kwargs={}, response_metadata={})]
  [0:checkpoint] State at the end of step 0:
  {'messages': [HumanMessage(content='qual o clima?', additional_kwargs={}, response_metadata={}, id='dd3047e8-3c07-4815-8737-16c59ed3dd0e')]}
  [1:tasks] Starting 1 task for step 1:
• assistant -> {'messages': [HumanMessage(content='qual o clima?', additional_kwargs={}, response_metadata={}, id='dd3047e8-3c07-4815-8737-16c59ed3dd0e')]}
  [1:writes] Finished step 1 with writes to 1 channel:
• messages -> AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_0HKuIVw5lIqKIPmP0TS9E232', 'function': {'arguments': '{}', 'name': 'tool_informa_o_clima'}, 'type': 'function'}], 'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 14, 'prompt_tokens': 2681, 'total_tokens': 2695, 'completion_tokens_details': {'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 0, 'rejected_prediction_tokens': 0}, 'prompt_tokens_details': {'audio_tokens': 0, 'cached_tokens': 0}}, 'model_name': 'gpt-4o-mini-2024-07-18', 'system_fingerprint': 'fp_39a40c96a0', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-f29ad467-98cd-419c-b762-86efe3c73476-0', tool_calls=[{'name': 'tool_informa_o_clima', 'args': {}, 'id': 'call_0HKuIVw5lIqKIPmP0TS9E232', 'type': 'tool_call'}], usage_metadata={'input_tokens': 2681, 'output_tokens': 14, 'total_tokens': 2695, 'input_token_details': {'audio': 0, 'cache_read': 0}, 'output_token_details': {'audio': 0, 'reasoning': 0}})
  [1:checkpoint] State at the end of step 1:
  {'messages': [HumanMessage(content='qual o clima?', additional_kwargs={}, response_metadata={}, id='dd3047e8-3c07-4815-8737-16c59ed3dd0e'),
  AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_0HKuIVw5lIqKIPmP0TS9E232', 'function': {'arguments': '{}', 'name': 'tool_informa_o_clima'}, 'type': 'function'}], 'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 14, 'prompt_tokens': 2681, 'total_tokens': 2695, 'completion_tokens_details': {'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 0, 'rejected_prediction_tokens': 0}, 'prompt_tokens_details': {'audio_tokens': 0, 'cached_tokens': 0}}, 'model_name': 'gpt-4o-mini-2024-07-18', 'system_fingerprint': 'fp_39a40c96a0', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-f29ad467-98cd-419c-b762-86efe3c73476-0', tool_calls=[{'name': 'tool_informa_o_clima', 'args': {}, 'id': 'call_0HKuIVw5lIqKIPmP0TS9E232', 'type': 'tool_call'}], usage_metadata={'input_tokens': 2681, 'output_tokens': 14, 'total_tokens': 2695, 'input_token_details': {'audio': 0, 'cache_read': 0}, 'output_token_details': {'audio': 0, 'reasoning': 0}})]}
  [2:tasks] Starting 1 task for step 2:
• tools -> {'messages': [HumanMessage(content='qual o clima?', additional_kwargs={}, response_metadata={}, id='dd3047e8-3c07-4815-8737-16c59ed3dd0e'),
  AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_0HKuIVw5lIqKIPmP0TS9E232', 'function': {'arguments': '{}', 'name': 'tool_informa_o_clima'}, 'type': 'function'}], 'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 14, 'prompt_tokens': 2681, 'total_tokens': 2695, 'completion_tokens_details': {'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 0, 'rejected_prediction_tokens': 0}, 'prompt_tokens_details': {'audio_tokens': 0, 'cached_tokens': 0}}, 'model_name': 'gpt-4o-mini-2024-07-18', 'system_fingerprint': 'fp_39a40c96a0', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-f29ad467-98cd-419c-b762-86efe3c73476-0', tool_calls=[{'name': 'tool_informa_o_clima', 'args': {}, 'id': 'call_0HKuIVw5lIqKIPmP0TS9E232', 'type': 'tool_call'}], usage_metadata={'input_tokens': 2681, 'output_tokens': 14, 'total_tokens': 2695, 'input_token_details': {'audio': 0, 'cache_read': 0}, 'output_token_details': {'audio': 0, 'reasoning': 0}})]}
  [2:writes] Finished step 2 with writes to 1 channel:
• messages -> [ToolMessage(content='O clima é estável com sol.', name='tool_informa_o_clima', tool_call_id='call_0HKuIVw5lIqKIPmP0TS9E232')]
  [2:checkpoint] State at the end of step 2:
  {'messages': [HumanMessage(content='qual o clima?', additional_kwargs={}, response_metadata={}, id='dd3047e8-3c07-4815-8737-16c59ed3dd0e'),
  AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_0HKuIVw5lIqKIPmP0TS9E232', 'function': {'arguments': '{}', 'name': 'tool_informa_o_clima'}, 'type': 'function'}], 'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 14, 'prompt_tokens': 2681, 'total_tokens': 2695, 'completion_tokens_details': {'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 0, 'rejected_prediction_tokens': 0}, 'prompt_tokens_details': {'audio_tokens': 0, 'cached_tokens': 0}}, 'model_name': 'gpt-4o-mini-2024-07-18', 'system_fingerprint': 'fp_39a40c96a0', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-f29ad467-98cd-419c-b762-86efe3c73476-0', tool_calls=[{'name': 'tool_informa_o_clima', 'args': {}, 'id': 'call_0HKuIVw5lIqKIPmP0TS9E232', 'type': 'tool_call'}], usage_metadata={'input_tokens': 2681, 'output_tokens': 14, 'total_tokens': 2695, 'input_token_details': {'audio': 0, 'cache_read': 0}, 'output_token_details': {'audio': 0, 'reasoning': 0}}),
  ToolMessage(content='O clima é estável com sol.', name='tool_informa_o_clima', id='b6e81810-2bd0-40bd-a03a-2357ccc47417', tool_call_id='call_0HKuIVw5lIqKIPmP0TS9E232')]}
  [3:tasks] Starting 1 task for step 3:
• assistant -> {'messages': [HumanMessage(content='qual o clima?', additional_kwargs={}, response_metadata={}, id='dd3047e8-3c07-4815-8737-16c59ed3dd0e'),
  AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_0HKuIVw5lIqKIPmP0TS9E232', 'function': {'arguments': '{}', 'name': 'tool_informa_o_clima'}, 'type': 'function'}], 'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 14, 'prompt_tokens': 2681, 'total_tokens': 2695, 'completion_tokens_details': {'accepted_prediction_tokens': 0, 'audio_tokens': 0, 'reasoning_tokens': 0, 'rejected_prediction_tokens': 0}, 'prompt_tokens_details': {'audio_tokens': 0, 'cached_tokens': 0}}, 'model_name': 'gpt-4o-mini-2024-07-18', 'system_fingerprint': 'fp_39a40c96a0', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-f29ad467-98cd-419c-b762-86efe3c73476-0', tool_calls=[{'name': 'tool_informa_o_clima', 'args': {}, 'id': 'call_0HKuIVw5lIqKIPmP0TS9E232', 'type': 'tool_call'}], usage_metadata={'input_tokens': 2681, 'output_tokens': 14, 'total_tokens': 2695, 'input_token_details': {'audio': 0, 'cache_read': 0}, 'output_token_details': {'audio': 0, 'reasoning': 0}}),
  ToolMessage(content='O clima é estável com sol.', name='tool_informa_o_clima', id='b6e81810-2bd0-40bd-a03a-2357ccc47417', tool_call_id='call_0HKuIVw5lIqKIPmP0TS9E232')]}

Thank you

[dosubot[bot]]

The log indicates that the tool is being called and returning a response correctly, but the workflow is not stopping as expected. Here are a few things to check and adjust:

1. Ensure Correct Handling of ToolMessage: Verify that the ToolMessage is being processed correctly in your workflow. The ToolMessage should be recognized as a valid response that can terminate the loop or transition to the next state.

2. Check tools_condition Function: Ensure that the tools_condition function is correctly implemented to detect when a ToolMessage has been received and route the flow to the 'END' node. This function should check for the presence of a ToolMessage and decide the next step based on its presence.

3. Review StateGraph Logic: Double-check the logic in your StateGraph to ensure that it correctly transitions to the end state when a tool response is received. The graph should not continue looping if a valid tool response is present.

4. Debugging: Add logging or print statements in the tools_condition function and the loop in the Assistant class to verify that the tool response is being detected and processed correctly.

5. Simplify and Test: If possible, simplify your setup to isolate the issue. Test the tool independently to ensure it returns the expected output and that the StateGraph transitions correctly when a ToolMessage is received.

By focusing on these areas, you should be able to identify why the workflow is not stopping as expected and make the necessary adjustments.

A maintainer has already been looped in, so they might be able to provide additional insights or assistance.

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Other}

[mrctito]

Hello @dosu,

I appreciate your suggestions, but as I already explained, I am running the standard code provided in the LangGraph documentation. Below are the relevant parts of the code. So, when you suggest things like "Check tools_condition," it doesn’t seem to make sense because none of the examples I’ve seen do anything different from what my code does.

I am executing a single tool that simply returns a string. It’s way too simple, far too basic.

Thank you.

class Assistant:
def init(self, runnable: Runnable):
self.runnable = runnable

def __call__(self, state, config: RunnableConfig):
    while True:
        configuration = config.get("configurable", {})
        contexto = configuration.get("contexto", {})
        user_id = configuration.get("user_id", None)
        state = {**state, "user_info": user_id, **contexto}
        result = self.runnable.invoke(state)

        # If the LLM happens to return an empty response, we will re-prompt it
        # for an actual response.
        if not result.tool_calls and (
            not result.content
            or isinstance(result.content, list)
            and not result.content[0].get("text")
        ):
            messages = state["messages"] + [("user", "Respond with a real output.")]
            state = {**state, "messages": messages}
        else:
            break

    return {"messages": result}

def handle_tool_error(state) -> dict:
error = state.get("error")
tool_calls = state["messages"][-1].tool_calls
return {
"messages": [
ToolMessage(
content=f"Error: {repr(error)}\n please fix your mistakes.",
tool_call_id=tc["id"],
)
for tc in tool_calls
]
}

def create_tool_node_with_fallback(tools: list) -> RunnableWithFallbacks[Any, dict]:
return ToolNode(tools).with_fallbacks(
[RunnableLambda(handle_tool_error)], exception_key="error"
)

@tool
def tool_informa_o_clima():
    """
    Útil para informar o clima atual.
    """
    return "O clima é estável com sol."



    self.llm_with_tools = self.llm.bind_tools(self.tools)

    primary_assistant_prompt = ChatPromptTemplate.from_messages(
        [
            ("system", self.prompt_str),
            ("human", "{input}"),
            ("placeholder", "{messages}"),
        ]
    )
    assistant_runnable = primary_assistant_prompt | self.llm_with_tools

    builder = StateGraph(State)
    builder.add_node("assistant", Assistant(assistant_runnable))
    builder.add_node("tools", create_tool_node_with_fallback(self.tools))
    builder.add_edge(START, "assistant")
    builder.add_conditional_edges(
        "assistant",
        # If the latest message (result) from assistant is a tool call -> tools_condition routes to tools
        # If the latest message (result) from assistant is a not a tool call -> tools_condition routes to END
        tools_condition)
    builder.add_edge("tools", "assistant")

    memory = MemorySaver()
    graph = builder.compile(checkpointer=memory)
    thread_id = str(uuid.uuid4())
    config = {
        "configurable": {
            # fetch the user's id
            "user_id": self.email_usuario,
            # Checkpoints are accessed by thread_id
            "thread_id": thread_id,
            "contexto": self.contexto
        }
    }

    result = await graph.ainvoke(self.contexto, config, debug=True)
    return result

[dosubot[bot]]

A maintainer has already been looped in.

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Other}

[mrctito]

@dosu,

Just to tell you, I created a Jupyter Notebook with my isolated project to reproduce the issue.

Here you are the link: https://github.com/mrctito/tests/blob/master/langgraph_tools.ipynb

Thank you!

[dosubot[bot]]

Hey @mrctito! I see you've put a lot of effort into isolating the issue in a Jupyter Notebook. However, diving into external links or specific project files is a bit outside my wheelhouse. I'm here to help solve bugs, answer technical questions, and gather engineering knowledge. If you think I should be able to handle this request, feel free to reach out to the Dosu Team. They'll know what to do! 😊

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Other}

[mrctito]

@dosu, ok. Maybe this could help a maintainer?

[dosubot[bot]]

Hey @mrctito! I appreciate your proactive approach in trying to help a maintainer. However, diving into specific project files or external links is a bit outside my wheelhouse. I'm here to help solve bugs, answer technical questions, and gather engineering knowledge. If you think I should be able to handle this request, feel free to reach out to the Dosu Team. They'll know what to do! 😊

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Other}

[mrctito]

@dosu, It's because you mentioned that @eyurtsev would help, so I thought this notebook could assist him.

If not, which forum do you suggest I post my issue to so that humans can help?

Thank you.

[dosubot[bot]]

A maintainer has already been looped in.

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Other}

[mrctito]

[dosubot[bot]]

The issue you're encountering, where the state variable is arriving empty in the __call__ method of the Assistant class, could be due to how the StateGraph is initialized and how the state is being passed through the graph. Here are a few things to check and adjust:

1. Initialization of State: Ensure that the initial state is correctly set up when invoking the graph. The contexto dictionary should be passed as the initial state, and it should contain all necessary keys and values.

2. StateGraph Configuration: Double-check the configuration of the StateGraph to ensure that it is correctly passing the state between nodes. The state_schema should match the structure of the state you are using.

3. State Updates: In the Assistant class, when you update the state with state = {**state, "user_info": user_id, **contexto}, ensure that contexto contains all the necessary information. If contexto is empty or missing keys, the state will not be updated correctly.

4. Debugging: Add print statements or logging to verify the contents of contexto and config before they are used to update the state. This can help identify if any expected data is missing.

5. Check for Overwrites: Ensure that the state is not being overwritten or reset elsewhere in the code. Each node in the graph should correctly pass the updated state to the next node.

By ensuring that the initial state is correctly set and that the state is being properly updated and passed through the graph, you should be able to resolve the issue of the state arriving empty in the __call__ method.

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Other}

[mrctito]

@dosu, I´m sorry. the empty state is not true, it was my mistake.

[dosubot[bot]]

Hey @mrctito! No worries at all about the mix-up. I'm here to help solve bugs, answer technical questions, and gather engineering knowledge. If you think I should have been able to assist with this, feel free to reach out to the Dosu Team. They'll know what to do! 😊

To continue talking to Dosu, mention @dosu.

---

^{Help Dosu learn! Give it feedback: Great Response | Irrelevant Answer | Incorrect Sources | Too Verbose | Hallucination | Other}