How to update graph state with tool execution result

[jiwonmik]

class HumanInputRun(BaseTool):
    """Tool that asks user for input."""

    name: str = "human"
    description: str = (
        "You can ask a human for getting answer for the clarifying question. "
        "The input should be a question and the answer options for the human."
    )
    prompt_func: Callable[[str], None] = Field(default_factory=lambda: _print_func)
    input_func: Callable = Field(default_factory=lambda: input)

    def _run(
        self,
        question: str,
        answer_options: List[str],
        run_manager: Optional[CallbackManagerForToolRun] = None,
    ) -> str:
        """Use the Human input tool."""
        self.prompt_func(question, answer_options)
        answer = self.input_func()
        return {"clarifying_question_answer": answer, "clarifying_question": question, "answer_options": answer_options}
    
tool = HumanInputRun(input_func=get_input)
tools = [tool]
tool_node = ToolNode(tools)

I have this tool and I want to update the state with what this tool returns.

However, it only returns Toolmessage with the return dict in content
(e.g., messages=[..., Toolmessage(content='{"clarifying_question_answer": answer, "clarifying_question": question, "answer_options": answer_options}'])

What I want to do is to update the graph state with this {"clarifying_question_answer": answer, "clarifying_question": question, "answer_options": answer_options}.

How can I do that?

[hwchase17]

if you want to update the state directly, you should probably add this as a node, not as a tool. currently I dont think we have great way for tools to update state - they generate a tool message

[antoremin]

• 1 to the question.
  ToolNode is nice because it enables parallel tool calling out of the box, whereas adding it as a node wouldn't enable this by default I think?

However, ToolNode doesn't let you to update the state directly, which means if I want to pop an item from a list after this item has been processed by a tool, I don't have good tools to make it happen,

[alessnet]

@hwchase17 Just to clarify, does it mean it's ok to pass graph state but it's not possible to update state? I checked this doc Does this doc say it allows reading state but not updating ?

I might be wrong, but just by looking at the source code it seems safe to modify the injected State from the tool call, because the state is simply passed from the ToolNode to the BaseTool without copy.

class GetTableDetailsTool(BaseTool):
    """...."""
    async def _arun(
        self,
        table_logical_name: str,
        
        state: Annotated[State, InjectedState]
    ) -> str:
        
       metadata = await get_entity_metadata(table_logical_name)
       state["visited_tables"][table_logical_name] = metadata # here we modify the state
       return "some string"

However it would be nice to have a confirmation this is indeed a feature and not a private implementation detail.
Can someone confirm?

Thank you :)

[markmcd]

However it would be nice to have a confirmation this is indeed a feature and not a private implementation detail.

I believe it's covered by Hyrum's Law

[vbarda]

State should only be modified via the state updates returned from the individual nodes (including the nodes with tool execution results, like ToolNode). We strongly recommend against manually mutating the state. Will post an update here as soon as we have a solution for this

[alessnet]

ok thanks for the clarification :)

It would have been easy (but not clean) to just return a special object (instead of a string) to inform Langgraph that the tool is returning a State modification as well. e.g.

return ToolResult("result of the tool", state={"new_state": "xxx"})

However, the BaseTool class from langchain_core always coerse the return of the tool to a string, even before Langgraph's ToolNode could do anything about it.

So maybe we could inject a kind of "State Modifier" in the tool call using the Annotated[] typehint ?

def _run(
        self,
        question: str,
        answer_options: List[str],

        state_modifier: Annotated[StateModifier, InjectedStateModifier], # <-----
        run_manager: Optional[CallbackManagerForToolRun] = None,
    ) -> str:
        """Use the Human input tool."""
        self.prompt_func(question, answer_options)
        answer = self.input_func()

        # state change would be accepted only if the tool didn't crash
        state_modifier.push({"clarifying_question_answer": answer, "clarifying_question": question, "answer_options": answer_options})

        return answser 
    

[chensylz]

I have the same problem.

[kaushik143]

@hwchase17 Is there any plan to add capability to update state from tools too in future? Not sure if ToolsMessage will have all the information returned from tools.

[NathanAP]

This should be addressed because ToolMessage's content is just a string. You probably want to return something else more complex/complete/normalized from your tools.