Did not find 1 tool_result block(s) at the beginning of this message

[ofa5er]

I get this error around 1 every 10 time when using langgraph. I am wondering if anyone encountered a similar issue and how to fix it.

BadRequestError("Error code: 400 - {'type': 'error', 'error': {'type': 'invalid_request_error', 'message': 'messages.6: Did not find 1 tool_result block(s) at the beginning of this message. Messages following tool_use blocks must begin with a matching number of tool_result blocks.'}}")Traceback (most recent call last):

[eyurtsev]

Could you share a minimal reproducible example?

It's basically saying that the chat history is not valid because an AI message that requested a tool call was not followed by a tool result message.

These conceptual guides have more information -- hope it will be helpful:

https://python.langchain.com/docs/concepts/chat_history/
https://python.langchain.com/docs/concepts/messages/#toolmessage

[ofa5er]

This a simplified example. The problem is that it doesn't reproduce every time. It is about 1 every 10 times.

class ChatMessage(BaseModel):

    type: Literal["human", "ai", "tool"] = Field(
        description="Role of the message.",
        examples=["human", "ai", "tool"],
    )
    content: str = Field(
        description="Content of the message.",
        examples=["Hello, world!"],
    )
    tool_calls: list[ToolCall] = Field(
        description="Tool calls in the message.",
        default=[],
    )
    tool_call_id: str | None = Field(
        description="Tool call that this message is responding to.",
        default=None,
        examples=["call_Jja7J89XsjrOLA5r!MEOW!SL"],
    )
    run_id: str | None = Field(
        description="Run ID of the message.",
        default=None,
        examples=["847c6285-8fc9-4560-a83f-4e6285809254"],
    )
    original: dict[str, Any] = Field(
        description="Original LangChain message in serialized form.",
        default={},
    )
    def convert_message_content_to_string(content: str | list[str | dict]) -> str:
        if isinstance(content, str):
            return content
        text: list[str] = []
        for content_item in content:
            if isinstance(content_item, str):
                text.append(content_item)
                continue
            if content_item["type"] == "text":
                text.append(content_item["text"])
        return "".join(text)

    @classmethod
    def from_langchain(cls, message: BaseMessage) -> "ChatMessage":
        """Create a ChatMessage from a LangChain message."""
        original = message_to_dict(message)
        match message:
            case HumanMessage():
                human_message = cls(
                    type="human",
                    content=convert_message_content_to_string(message.content),
                    original=original,
                )
                return human_message
            case AIMessage():
                ai_message = cls(
                    type="ai",
                    content=convert_message_content_to_string(message.content),
                    original=original,
                )
                if message.tool_calls:
                    ai_message.tool_calls = message.tool_calls
                return ai_message
            case ToolMessage():
                tool_message = cls(
                    type="tool",
                    content=convert_message_content_to_string(message.content),
                    tool_call_id=message.tool_call_id,
                    original=original,
                )
                return tool_message
            case _:
                raise ValueError(f"Unsupported message type: {message.__class__.__name__}")

    def to_langchain(self) -> BaseMessage:
        """Convert the ChatMessage to a LangChain message."""
        if self.original:
            raw_original = messages_from_dict([self.original])[0]
            raw_original.content = self.content
            return raw_original
        match self.type:
            case "human":
                return HumanMessage(content=self.content)
            case _:
                raise NotImplementedError(f"Unsupported message type: {self.type}")

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

    def __call__(self, state: State, config: RunnableConfig):
        
        # Invoke runnable until non-empty response
        while True:
            result = self.runnable.invoke(state)

            # Check for empty response and re-prompt if necessary
            if not result.tool_calls and (not result.content or not result.content[0].get("text", '')):
                state["messages"].append(("user", "Respond with a real output."))
            else:
                break
        
        # Update state with new messages and return
        state["messages"].append(result)
        return state

# Initialize Chat Model
llm = ChatAnthropic(model="claude-3-5-sonnet-20240620")

# Define the Prompt Template
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are an assistant optimized for..."),
    ("placeholder", "{messages}"),
]).partial(time=datetime.now().strftime("%A, %Y-%m-%d"))

# Define Tools
tools = [
    tool1,
    tool2
]

# Bind prompt to tools
assistant_runnable = prompt | llm.bind_tools(tools)

# Define tool error handling
def handle_tool_error(state) -> dict:
    error = state.get("error")
    tool_calls = state["messages"][-1].tool_calls
    return {
        **state,
        "messages": state["messages"] + [
            ToolMessage(content=f"Error: {repr(error)}\n please fix your mistakes.", tool_call_id=tc["id"])
            for tc in tool_calls
        ],
    }
    
# Define fallback handling for tools
def create_tool_node_with_fallback(tools: list) -> dict:
    return ToolNode(tools).with_fallbacks([RunnableLambda(handle_tool_error)], exception_key="error")

# Build State Graph
builder = StateGraph(State)
builder.add_node("fetch_info", info)
builder.add_edge(START, "fetch_info")
builder.add_node("get_data", get_context)
builder.add_edge("fetch_info", "get_data")

# Define main assistant node
builder.add_node("assistant", Assistant(assistant_runnable))
builder.add_edge("get_data", "assistant")
builder.add_node("tools", create_tool_node_with_fallback(tools))

# Define edges and control flow conditions
builder.add_conditional_edges("assistant", tools_condition)
builder.add_edge("tools", "assistant")

# Compile the supervisor assistant
assistant = builder.compile()

############################
### Function to invoke #####
###########################
async def invoke_assistant(input_content):
    input_message = ChatMessage(type="human", content=input_content)
    initial_state = {
        "messages": [input_message.to_langchain()]
    }
    
    kwargs = dict(
        input=initial_state,
        config=RunnableConfig(
            configurable={"thread_id": task_id, "task_id": task_id, "user_id": user_id}
        ),
    )
    response = await assistant.ainvoke(**kwargs)