feat(langchain_v1): on_tool_call interceptor (wip)

[eyurtsev]

Still WIP:

• Need to update the API in the middleware

Changes:

• Goal is to remove ToolNode from accepted types in create_agent, but re-introduce support for tool handling. (Removing ToolNode as it's not obvious how it should interact with tools brought by middleware).
• Adds an interceptor ToolNode
• Adds an middleware on_tool_call
• Allows composing middlewares for handling tool calls.

from langchain.agents.middleware import RetryMiddleware

# Retry network errors up to 3 times with 1 second delay
retry = RetryMiddleware(
    max_retries=3,
    delay=1.0,
    retry_on=(TimeoutError, ConnectionError),
)

agent = create_agent(
    model="openai:gpt-4o",
    tools=[my_tool],
    middleware=[retry],
)

class SimpleRetryMiddleware(AgentMiddleware):
    def __init__(self, max_retries=3, delay=1.0):
        super().__init__()
        self.max_retries = max_retries
        self.delay = delay

    def on_tool_call(self, request):
        for attempt in range(self.max_retries + 1):
            response = yield request

            if response.action == "return":
                return response

            if response.action == "raise":
                if attempt < self.max_retries:
                    time.sleep(self.delay)
                    continue
                return response

[sydney-runkle]

Initial pass, just looking at types

[sydney-runkle]

We don't actually need this right?

[sydney-runkle]

continue?

[eyurtsev]

yeah i've been debatinc continue vs. return

[sydney-runkle]

Like

from typing import Literal
from typing_extensions TypedDict, NotRequired

class _ContinueToolCallResponse(TypedDict):
    """Response when tool execution completed successfully.
    
    Attributes:
        action: Always "continue" to indicate normal flow.
        result: ToolMessage or Command to be processed.
        exception: Optional exception for logging purposes.
    """
    action: Literal["continue"]
    result: ToolMessage | Command
    exception: NotRequired[Exception]

class _RaiseToolCallResponse(TypedDict):
    """Response when tool execution wants to propagate an exception.
    
    Attributes:
        action: Always "raise" to indicate exception propagation.
        exception: The exception to be raised.
    """
    action: Literal["raise"]
    exception: Exception

ToolCallResponse = _ContinueToolCallResponse | _RaiseToolCallResponse

[sydney-runkle]

ToolCallRequest

[sydney-runkle]

more fun thoughts :)

[sydney-runkle]

Suggested change

	class RetryMiddleware(AgentMiddleware):
	class ToolRetryMiddleware(AgentMiddleware):