Skip to content

The agent engineering platform.

chore(langchain_v1): simplify on model call logic (#33358)

Eugene Yurtsevb665b81a0e04
diff --git a/libs/langchain_v1/langchain/agents/factory.py b/libs/langchain_v1/langchain/agents/factory.py
index 31477d2937..687ac33170 100644
--- a/libs/langchain_v1/langchain/agents/factory.py
+++ b/libs/langchain_v1/langchain/agents/factory.py
@@ -14,6 +14,9 @@ from typing import (
get_type_hints,
)
+if TYPE_CHECKING:
+ from collections.abc import Awaitable
+
from langchain_core.language_models.chat_models import BaseChatModel
from langchain_core.messages import AIMessage, AnyMessage, SystemMessage, ToolMessage
from langchain_core.tools import BaseTool
@@ -81,24 +84,24 @@ class _InternalModelResponse:
"""Cached response format after auto-detection."""
-def _chain_model_call_handlers( # noqa: PLR0915
+def _chain_model_call_handlers(
handlers: Sequence[
Callable[
- [ModelRequest, Any, Any],
- Generator[ModelRequest | AIMessage, AIMessage, None],
+ [ModelRequest, Any, Any, Callable[[ModelRequest], AIMessage]],
+ AIMessage,
]
],
) -> (
Callable[
- [ModelRequest, Any, Any],
- Generator[ModelRequest | AIMessage, AIMessage, None],
+ [ModelRequest, Any, Any, Callable[[ModelRequest], AIMessage]],
+ AIMessage,
]
| None
):
"""Compose multiple on_model_call handlers into single middleware stack.
Composes handlers so first in list becomes outermost layer. Each handler
- can intercept and modify both requests (going down) and responses (coming up).
+ receives a handler callback to execute inner layers.
Args:
handlers: List of handlers. First handler wraps all others.
@@ -109,26 +112,22 @@ def _chain_model_call_handlers( # noqa: PLR0915
Example:
```python
# handlers=[auth, retry] means: auth wraps retry
- # Flow: auth-before -> retry-before -> model -> retry-after -> auth-after
- def auth(req, state, runtime):
+ # Flow: auth calls retry, retry calls base handler
+ def auth(req, state, runtime, handler):
try:
- result = yield req
- return result
+ return handler(req)
except UnauthorizedError:
refresh_token()
- result = yield req
- return result
+ return handler(req)
- def retry(req, state, runtime):
+ def retry(req, state, runtime, handler):
for attempt in range(3):
try:
- result = yield req
- return result
+ return handler(req)
except Exception:
if attempt == 2:
raise
- return result
handler = _chain_model_call_handlers([auth, retry])
@@ -140,138 +139,103 @@ def _chain_model_call_handlers( # noqa: PLR0915
if len(handlers) == 1:
return handlers[0]
- def compose_two( # noqa: PLR0915
+ def compose_two(
outer: Callable[
- [ModelRequest, Any, Any],
- Generator[ModelRequest | AIMessage, AIMessage, None],
+ [ModelRequest, Any, Any, Callable[[ModelRequest], AIMessage]],
+ AIMessage,
],
inner: Callable[
- [ModelRequest, Any, Any],
- Generator[ModelRequest | AIMessage, AIMessage, None],
+ [ModelRequest, Any, Any, Callable[[ModelRequest], AIMessage]],
+ AIMessage,
],
) -> Callable[
- [ModelRequest, Any, Any],
- Generator[ModelRequest | AIMessage, AIMessage, None],
+ [ModelRequest, Any, Any, Callable[[ModelRequest], AIMessage]],
+ AIMessage,
]:
- """Compose two handlers where outer wraps inner.
-
- Yields ModelRequest for execution or AIMessage for short-circuit results.
- Never uses return values - relies on last yield being tracked by caller.
- """
+ """Compose two handlers where outer wraps inner."""
- def composed( # noqa: PLR0915
+ def composed(
request: ModelRequest,
state: Any,
runtime: Any,
- ) -> Generator[ModelRequest | AIMessage, AIMessage, None]:
- outer_gen = outer(request, state, runtime)
+ handler: Callable[[ModelRequest], AIMessage],
+ ) -> AIMessage:
+ # Create a wrapper that calls inner with the base handler
+ def inner_handler(req: ModelRequest) -> AIMessage:
+ return inner(req, state, runtime, handler)
- # Initialize outer generator
- try:
- outer_request = next(outer_gen)
- except StopIteration:
- msg = "on_model_call handler must yield at least once"
- raise ValueError(msg)
+ # Call outer with the wrapped inner as its handler
+ return outer(request, state, runtime, inner_handler)
- # Outer retry loop
- while True:
- # Check if outer yielded AIMessage (short-circuit)
- if isinstance(outer_request, AIMessage):
- # Outer is short-circuiting, yield it to caller
- yield outer_request
- # Consume outer to completion
- try:
- next(outer_gen)
- msg = "on_model_call handler should not yield after yielding AIMessage"
- raise ValueError(msg)
- except StopIteration:
- pass
- return
+ return composed
- # Outer yielded ModelRequest - pass to inner
- inner_gen = inner(outer_request, state, runtime)
+ # Compose right-to-left: outer(inner(innermost(handler)))
+ result = handlers[-1]
+ for handler in reversed(handlers[:-1]):
+ result = compose_two(handler, result)
- # Initialize inner generator
- try:
- inner_request = next(inner_gen)
- except StopIteration:
- msg = "on_model_call handler must yield at least once"
- raise ValueError(msg)
+ return result
- # Inner retry loop
- inner_result: AIMessage | None = None
- outer_is_retrying = False
- while True:
- # Check if inner yielded AIMessage (short-circuit)
- if isinstance(inner_request, AIMessage):
- # Inner is short-circuiting, send to outer
- inner_result = inner_request
- # Consume inner to completion
- try:
- next(inner_gen)
- msg = "on_model_call handler should not yield after yielding AIMessage"
- raise ValueError(msg)
- except StopIteration:
- pass
- break # Exit inner loop
- try:
- # Yield inner's request to caller for execution
- model_result = yield inner_request
-
- # Send result to inner
- try:
- inner_request = inner_gen.send(model_result)
- # Inner yielded again - check type in next iteration
- except StopIteration:
- # Inner finished, use the result we got
- inner_result = model_result
- break
-
- except Exception as exc: # noqa: BLE001
- # Caller threw exception, route to inner
- try:
- inner_request = inner_gen.throw(exc)
- # Inner caught and yielded again
- except StopIteration:
- # Inner finished after handling exception
- inner_result = None
- break
- except Exception as inner_unhandled: # noqa: BLE001
- # Inner didn't catch, propagate to outer
- try:
- outer_request = outer_gen.throw(inner_unhandled)
- # Outer caught and is retrying
- outer_is_retrying = True
- break
- except StopIteration:
- # Outer finished after handling exception
- return
- except Exception:
- # Outer didn't catch either
- raise
-
- # If outer is retrying, continue outer loop with new request
- if outer_is_retrying:
- continue
+def _chain_async_model_call_handlers(
+ handlers: Sequence[
+ Callable[
+ [ModelRequest, Any, Any, Callable[[ModelRequest], Awaitable[AIMessage]]],
+ Awaitable[AIMessage],
+ ]
+ ],
+) -> (
+ Callable[
+ [ModelRequest, Any, Any, Callable[[ModelRequest], Awaitable[AIMessage]]],
+ Awaitable[AIMessage],
+ ]
+ | None
+):
+ """Compose multiple async on_model_call handlers into single middleware stack.
- # Inner finished - send result to outer
- if inner_result is None:
- # Inner failed without result
- return
+ Args:
+ handlers: List of async handlers. First handler wraps all others.
- try:
- outer_request = outer_gen.send(inner_result)
- # Outer yielded again - continue outer loop to check type
- except StopIteration:
- # Outer finished - yield the inner result for caller to see
- if inner_result is not None:
- yield inner_result
- return
+ Returns:
+ Composed async handler, or None if handlers empty.
+ """
+ if not handlers:
+ return None
+
+ if len(handlers) == 1:
+ return handlers[0]
+
+ def compose_two(
+ outer: Callable[
+ [ModelRequest, Any, Any, Callable[[ModelRequest], Awaitable[AIMessage]]],
+ Awaitable[AIMessage],
+ ],
+ inner: Callable[
+ [ModelRequest, Any, Any, Callable[[ModelRequest], Awaitable[AIMessage]]],
+ Awaitable[AIMessage],
+ ],
+ ) -> Callable[
+ [ModelRequest, Any, Any, Callable[[ModelRequest], Awaitable[AIMessage]]],
+ Awaitable[AIMessage],
+ ]:
+ """Compose two async handlers where outer wraps inner."""
+
+ async def composed(
+ request: ModelRequest,
+ state: Any,
+ runtime: Any,
+ handler: Callable[[ModelRequest], Awaitable[AIMessage]],
+ ) -> AIMessage:
+ # Create a wrapper that calls inner with the base handler
+ async def inner_handler(req: ModelRequest) -> AIMessage:
+ return await inner(req, state, runtime, handler)
+
+ # Call outer with the wrapped inner as its handler
+ return await outer(request, state, runtime, inner_handler)
return composed
- # Compose right-to-left: handlers[0](handlers[1](...(handlers[-1](model))))
+ # Compose right-to-left: outer(inner(innermost(handler)))
result = handlers[-1]
for handler in reversed(handlers[:-1]):
result = compose_two(handler, result)
@@ -704,13 +668,22 @@ def create_agent( # noqa: PLR0915
middleware_w_on_model_call = [
m for m in middleware if m.__class__.on_model_call is not AgentMiddleware.on_model_call
]
+ middleware_w_aon_model_call = [
+ m for m in middleware if m.__class__.aon_model_call is not AgentMiddleware.aon_model_call
+ ]
- # Compose on_model_call handlers into a single middleware stack
+ # Compose on_model_call handlers into a single middleware stack (sync)
on_model_call_handler = None
if middleware_w_on_model_call:
sync_handlers = [m.on_model_call for m in middleware_w_on_model_call]
on_model_call_handler = _chain_model_call_handlers(sync_handlers)
+ # Compose aon_model_call handlers into a single middleware stack (async)
+ aon_model_call_handler = None
+ if middleware_w_aon_model_call:
+ async_handlers = [m.aon_model_call for m in middleware_w_aon_model_call]
+ aon_model_call_handler = _chain_async_model_call_handlers(async_handlers)
+
state_schemas = {m.state_schema for m in middleware}
state_schemas.add(AgentState)
@@ -964,7 +937,7 @@ def create_agent( # noqa: PLR0915
effective_response_format=None,
)
- def model_node(state: AgentState, runtime: Runtime[ContextT]) -> dict[str, Any]: # noqa: PLR0915
+ def model_node(state: AgentState, runtime: Runtime[ContextT]) -> dict[str, Any]:
"""Sync model request handler with sequential middleware processing."""
request = ModelRequest(
model=model,
@@ -989,78 +962,26 @@ def create_agent( # noqa: PLR0915
raise TypeError(msg)
# Execute with or without handler
- current_request: ModelRequest | AIMessage = request
- internal_response: _InternalModelResponse
effective_response_format: Any = None
- if on_model_call_handler is None:
- # No handlers - execute directly
- internal_response = _execute_model_sync(request)
+ # Define base handler that executes the model
+ def base_handler(req: ModelRequest) -> AIMessage:
+ nonlocal effective_response_format
+ internal_response = _execute_model_sync(req)
if internal_response.exception is not None:
raise internal_response.exception
- output = internal_response.result
+ if internal_response.result is None:
+ msg = "Model execution succeeded but returned no result"
+ raise RuntimeError(msg)
effective_response_format = internal_response.effective_response_format
- else:
- # Use composed handler with generator protocol
- gen = on_model_call_handler(request, state, runtime)
-
- try:
- current_request = next(gen)
- except StopIteration:
- msg = "on_model_call handler must yield at least once to request model execution"
- raise ValueError(msg)
-
- # Execution loop - track last AIMessage seen
- last_ai_message: AIMessage | None = None
- while True:
- # Check if handler yielded AIMessage (short-circuit result)
- if isinstance(current_request, AIMessage):
- # Handler short-circuited with this result
- last_ai_message = current_request
- # Try to get next yield (should be done)
- try:
- current_request = next(gen)
- # Handler yielded again after AIMessage - continue loop
- except StopIteration:
- # Handler finished, use the AIMessage
- break
- elif isinstance(current_request, ModelRequest):
- # Execute the model request
- internal_response = _execute_model_sync(current_request)
- effective_response_format = internal_response.effective_response_format
+ return internal_response.result
- try:
- if internal_response.exception is None:
- # Success - send AIMessage to handler
- assert internal_response.result is not None # noqa: S101
- last_ai_message = internal_response.result
- current_request = gen.send(internal_response.result)
- else:
- # Error - throw exception to handler
- current_request = gen.throw(internal_response.exception)
- # Handler yielded again - check what it yielded in next iteration
- except StopIteration:
- # Handler finished
- break
- except Exception:
- # Handler didn't catch exception - propagate
- raise
- else:
- msg = f"Handler yielded unexpected type: {type(current_request).__name__}"
- raise TypeError(msg)
-
- output = last_ai_message
-
- # Validate final result
- if output is None:
- msg = "on_model_call handler must complete with at least one successful model call"
- raise ValueError(msg)
- if not isinstance(output, AIMessage):
- msg = f"on_model_call handler must end with AIMessage, got {type(output).__name__}"
- raise TypeError(msg)
-
- # output is guaranteed to be AIMessage at this point
- assert isinstance(output, AIMessage) # noqa: S101
+ if on_model_call_handler is None:
+ # No handlers - execute directly
+ output = base_handler(request)
+ else:
+ # Call composed handler with base handler
+ output = on_model_call_handler(request, state, runtime, base_handler)
return {
"thread_model_call_count": state.get("thread_model_call_count", 0) + 1,
"run_model_call_count": state.get("run_model_call_count", 0) + 1,
@@ -1093,7 +1014,7 @@ def create_agent( # noqa: PLR0915
effective_response_format=None,
)
- async def amodel_node(state: AgentState, runtime: Runtime[ContextT]) -> dict[str, Any]: # noqa: PLR0915
+ async def amodel_node(state: AgentState, runtime: Runtime[ContextT]) -> dict[str, Any]:
"""Async model request handler with sequential middleware processing."""
request = ModelRequest(
model=model,
@@ -1109,79 +1030,26 @@ def create_agent( # noqa: PLR0915
request = await m.amodify_model_request(request, state, runtime)
# Execute with or without handler
- # Note: handler is sync generator, but model execution is async
- current_request: ModelRequest | AIMessage = request
- internal_response: _InternalModelResponse
effective_response_format: Any = None
- if on_model_call_handler is None:
- # No handlers - execute directly
- internal_response = await _execute_model_async(request)
+ # Define base async handler that executes the model
+ async def base_handler(req: ModelRequest) -> AIMessage:
+ nonlocal effective_response_format
+ internal_response = await _execute_model_async(req)
if internal_response.exception is not None:
raise internal_response.exception
- output = internal_response.result
+ if internal_response.result is None:
+ msg = "Model execution succeeded but returned no result"
+ raise RuntimeError(msg)
effective_response_format = internal_response.effective_response_format
- else:
- # Use composed handler with generator protocol (sync generator, async execution)
- gen = on_model_call_handler(request, state, runtime)
+ return internal_response.result
- try:
- current_request = next(gen)
- except StopIteration:
- msg = "on_model_call handler must yield at least once to request model execution"
- raise ValueError(msg)
-
- # Execution loop - track last AIMessage seen
- last_ai_message: AIMessage | None = None
- while True:
- # Check if handler yielded AIMessage (short-circuit result)
- if isinstance(current_request, AIMessage):
- # Handler short-circuited with this result
- last_ai_message = current_request
- # Try to get next yield (should be done)
- try:
- current_request = next(gen)
- # Handler yielded again after AIMessage - continue loop
- except StopIteration:
- # Handler finished, use the AIMessage
- break
- elif isinstance(current_request, ModelRequest):
- # Execute the model request
- internal_response = await _execute_model_async(current_request)
- effective_response_format = internal_response.effective_response_format
-
- try:
- if internal_response.exception is None:
- # Success - send AIMessage to handler
- assert internal_response.result is not None # noqa: S101
- last_ai_message = internal_response.result
- current_request = gen.send(internal_response.result)
- else:
- # Error - throw exception to handler
- current_request = gen.throw(internal_response.exception)
- # Handler yielded again - check what it yielded in next iteration
- except StopIteration:
- # Handler finished
- break
- except Exception:
- # Handler didn't catch exception - propagate
- raise
- else:
- msg = f"Handler yielded unexpected type: {type(current_request).__name__}"
- raise TypeError(msg)
-
- output = last_ai_message
-
- # Validate final result
- if output is None:
- msg = "on_model_call handler must complete with at least one successful model call"
- raise ValueError(msg)
- if not isinstance(output, AIMessage):
- msg = f"on_model_call handler must end with AIMessage, got {type(output).__name__}"
- raise TypeError(msg)
-
- # output is guaranteed to be AIMessage at this point
- assert isinstance(output, AIMessage) # noqa: S101
+ if aon_model_call_handler is None:
+ # No async handlers - execute directly
+ output = await base_handler(request)
+ else:
+ # Call composed async handler with base handler
+ output = await aon_model_call_handler(request, state, runtime, base_handler)
return {
"thread_model_call_count": state.get("thread_model_call_count", 0) + 1,
"run_model_call_count": state.get("run_model_call_count", 0) + 1,
diff --git a/libs/langchain_v1/langchain/agents/middleware/model_fallback.py b/libs/langchain_v1/langchain/agents/middleware/model_fallback.py
index d1ec7ac614..a0b8a2d1c2 100644
--- a/libs/langchain_v1/langchain/agents/middleware/model_fallback.py
+++ b/libs/langchain_v1/langchain/agents/middleware/model_fallback.py
@@ -11,7 +11,7 @@ from langchain.agents.middleware.types import (
from langchain.chat_models import init_chat_model
if TYPE_CHECKING:
- from collections.abc import Generator
+ from collections.abc import Callable
from langchain_core.language_models.chat_models import BaseChatModel
from langchain_core.messages import AIMessage
@@ -72,36 +72,36 @@ class ModelFallbackMiddleware(AgentMiddleware):
request: ModelRequest,
state: Any, # noqa: ARG002
runtime: Runtime[ContextT], # noqa: ARG002
- ) -> Generator[ModelRequest | AIMessage, AIMessage, None]:
+ handler: Callable[[ModelRequest], AIMessage],
+ ) -> AIMessage:
"""Try fallback models in sequence on errors.
Args:
request: Initial model request.
state: Current agent state.
runtime: LangGraph runtime.
+ handler: Callback to execute the model.
- Yields:
- ModelRequest to execute.
+ Returns:
+ AIMessage from successful model call.
Raises:
Exception: If all models fail, re-raises last exception.
"""
- last_exception = None
+ # Try primary model first
+ last_exception: Exception
try:
- yield request
+ return handler(request)
except Exception as e: # noqa: BLE001
last_exception = e
- else:
- return
+ # Try fallback models
for fallback_model in self.models:
request.model = fallback_model
try:
- yield request
+ return handler(request)
except Exception as e: # noqa: BLE001
last_exception = e
continue
- else:
- return
raise last_exception
diff --git a/libs/langchain_v1/langchain/agents/middleware/types.py b/libs/langchain_v1/langchain/agents/middleware/types.py
index 32f6db965d..e4333356dd 100644
--- a/libs/langchain_v1/langchain/agents/middleware/types.py
+++ b/libs/langchain_v1/langchain/agents/middleware/types.py
@@ -2,7 +2,7 @@
from __future__ import annotations
-from collections.abc import Callable, Generator
+from collections.abc import Awaitable, Callable, Generator
from dataclasses import dataclass, field
from inspect import iscoroutinefunction
from typing import (
@@ -188,39 +188,33 @@ class AgentMiddleware(Generic[StateT, ContextT]):
request: ModelRequest,
state: StateT,
runtime: Runtime[ContextT],
- ) -> Generator[ModelRequest | AIMessage, AIMessage, None]:
- """Intercept and control model execution via generator protocol.
+ handler: Callable[[ModelRequest], AIMessage],
+ ) -> AIMessage:
+ """Intercept and control model execution via handler callback.
- Protocol:
- 1. Yield ModelRequest to execute the model.
- 2. Receive AIMessage via .send() on success, or exception via .throw() on error.
- 3. Optionally yield again to retry.
- 4. Generator ends naturally - consumer uses last successful AIMessage.
-
- Middleware can implement retry logic, error handling, response rewriting,
- and request modification using standard try/except. Multiple middleware
+ The handler callback executes the model request and returns an AIMessage.
+ Middleware can call the handler multiple times for retry logic, skip calling
+ it to short-circuit, or modify the request/response. Multiple middleware
compose with first in list as outermost layer.
Args:
request: Initial model request to execute.
state: Current agent state.
runtime: LangGraph runtime context.
+ handler: Callback that executes the model request and returns AIMessage.
+ Call this to execute the model. Can be called multiple times
+ for retry logic. Can skip calling it to short-circuit.
- Yields:
- ModelRequest to execute.
-
- Receives:
- AIMessage via .send() on success.
- Exception via .throw() on error.
+ Returns:
+ Final AIMessage to use (from handler or custom).
Examples:
Retry on error:
```python
- def on_model_call(self, request, state, runtime):
+ def on_model_call(self, request, state, runtime, handler):
for attempt in range(3):
try:
- yield request
- break # Success
+ return handler(request)
except Exception:
if attempt == 2:
raise
@@ -228,29 +222,60 @@ class AgentMiddleware(Generic[StateT, ContextT]):
Rewrite response:
```python
- def on_model_call(self, request, state, runtime):
- result = yield request
- modified = AIMessage(content=f"[{result.content}]")
- yield modified
+ def on_model_call(self, request, state, runtime, handler):
+ result = handler(request)
+ return AIMessage(content=f"[{result.content}]")
```
Error to fallback:
```python
- def on_model_call(self, request, state, runtime):
+ def on_model_call(self, request, state, runtime, handler):
try:
- yield request
+ return handler(request)
except Exception:
- fallback = AIMessage(content="Service unavailable")
- yield fallback
+ return AIMessage(content="Service unavailable")
+ ```
Cache/short-circuit:
```python
- def on_model_call(self, request, state, runtime):
+ def on_model_call(self, request, state, runtime, handler):
if cached := get_cache(request):
- yield cached # Short-circuit with cached result
- else:
- result = yield request
- save_cache(request, result)
+ return cached # Short-circuit with cached result
+ result = handler(request)
+ save_cache(request, result)
+ return result
+ ```
+ """
+ raise NotImplementedError
+
+ async def aon_model_call(
+ self,
+ request: ModelRequest,
+ state: StateT,
+ runtime: Runtime[ContextT],
+ handler: Callable[[ModelRequest], Awaitable[AIMessage]],
+ ) -> AIMessage:
+ """Async version of on_model_call.
+
+ Args:
+ request: Initial model request to execute.
+ state: Current agent state.
+ runtime: LangGraph runtime context.
+ handler: Async callback that executes the model request.
+
+ Returns:
+ Final AIMessage to use (from handler or custom).
+
+ Examples:
+ Retry on error:
+ ```python
+ async def aon_model_call(self, request, state, runtime, handler):
+ for attempt in range(3):
+ try:
+ return await handler(request)
+ except Exception:
+ if attempt == 2:
+ raise
```
"""
raise NotImplementedError
@@ -334,17 +359,20 @@ class _CallableReturningPromptString(Protocol[StateT_contra, ContextT]):
...
-class _CallableReturningModelResponseGenerator(Protocol[StateT_contra, ContextT]):
- """Callable returning generator for model call interception.
+class _CallableReturningModelResponse(Protocol[StateT_contra, ContextT]):
+ """Callable for model call interception with handler callback.
- Returns sync generator that works with both sync and async model execution.
- Generator receives AIMessage via .send() or exception via .throw().
+ Receives handler callback to execute model and returns final AIMessage.
"""
def __call__(
- self, request: ModelRequest, state: StateT_contra, runtime: Runtime[ContextT]
- ) -> Generator[ModelRequest, AIMessage, AIMessage]:
- """Return generator to intercept model execution."""
+ self,
+ request: ModelRequest,
+ state: StateT_contra,
+ runtime: Runtime[ContextT],
+ handler: Callable[[ModelRequest], AIMessage],
+ ) -> AIMessage:
+ """Intercept model execution via handler callback."""
...
@@ -1207,7 +1235,7 @@ def dynamic_prompt(
@overload
def on_model_call(
- func: _CallableReturningModelResponseGenerator[StateT, ContextT],
+ func: _CallableReturningModelResponse[StateT, ContextT],
) -> AgentMiddleware[StateT, ContextT]: ...
@@ -1219,34 +1247,32 @@ def on_model_call(
tools: list[BaseTool] | None = None,
name: str | None = None,
) -> Callable[
- [_CallableReturningModelResponseGenerator[StateT, ContextT]],
+ [_CallableReturningModelResponse[StateT, ContextT]],
AgentMiddleware[StateT, ContextT],
]: ...
def on_model_call(
- func: _CallableReturningModelResponseGenerator[StateT, ContextT] | None = None,
+ func: _CallableReturningModelResponse[StateT, ContextT] | None = None,
*,
state_schema: type[StateT] | None = None,
tools: list[BaseTool] | None = None,
name: str | None = None,
) -> (
Callable[
- [_CallableReturningModelResponseGenerator[StateT, ContextT]],
+ [_CallableReturningModelResponse[StateT, ContextT]],
AgentMiddleware[StateT, ContextT],
]
| AgentMiddleware[StateT, ContextT]
):
- """Create middleware with on_model_call hook from a generator function.
+ """Create middleware with on_model_call hook from a function.
- Converts a generator function into middleware that can intercept model calls,
- implement retry logic, handle errors, and rewrite responses using standard
- Python exception handling.
+ Converts a function with handler callback into middleware that can intercept
+ model calls, implement retry logic, handle errors, and rewrite responses.
Args:
- func: Generator function accepting (request, state, runtime) that yields
- ModelRequest, receives AIMessage via .send() on success or exception
- via .throw() on error, and returns final AIMessage.
+ func: Function accepting (request, state, runtime, handler) that calls
+ handler(request) to execute the model and returns final AIMessage.
state_schema: Custom state schema. Defaults to AgentState.
tools: Additional tools to register with this middleware.
name: Middleware class name. Defaults to function name.
@@ -1258,14 +1284,11 @@ def on_model_call(
Basic retry logic:
```python
@on_model_call
- def retry_on_error(
- request: ModelRequest, state: AgentState, runtime: Runtime
- ) -> Generator[ModelRequest, AIMessage, AIMessage]:
+ def retry_on_error(request, state, runtime, handler):
max_retries = 3
for attempt in range(max_retries):
try:
- yield request
- break # Success
+ return handler(request)
except Exception:
if attempt == max_retries - 1:
raise
@@ -1274,43 +1297,65 @@ def on_model_call(
Model fallback:
```python
@on_model_call
- def fallback_model(
- request: ModelRequest, state: AgentState, runtime: Runtime
- ) -> Generator[ModelRequest, AIMessage, AIMessage]:
+ def fallback_model(request, state, runtime, handler):
# Try primary model
try:
- yield request
- return # Success
+ return handler(request)
except Exception:
pass
# Try fallback model
request.model = fallback_model_instance
- yield request
+ return handler(request)
```
Rewrite response content:
```python
@on_model_call
- def uppercase_responses(
- request: ModelRequest, state: AgentState, runtime: Runtime
- ) -> Generator[ModelRequest, AIMessage, AIMessage]:
- result = yield request
- modified = AIMessage(content=result.content.upper())
- yield modified
+ def uppercase_responses(request, state, runtime, handler):
+ result = handler(request)
+ return AIMessage(content=result.content.upper())
```
"""
def decorator(
- func: _CallableReturningModelResponseGenerator[StateT, ContextT],
+ func: _CallableReturningModelResponse[StateT, ContextT],
) -> AgentMiddleware[StateT, ContextT]:
+ is_async = iscoroutinefunction(func)
+
+ if is_async:
+
+ async def async_wrapped(
+ self: AgentMiddleware[StateT, ContextT], # noqa: ARG001
+ request: ModelRequest,
+ state: StateT,
+ runtime: Runtime[ContextT],
+ handler: Callable[[ModelRequest], Awaitable[AIMessage]],
+ ) -> AIMessage:
+ return await func(request, state, runtime, handler) # type: ignore[misc, arg-type]
+
+ middleware_name = name or cast(
+ "str", getattr(func, "__name__", "OnModelCallMiddleware")
+ )
+
+ return type(
+ middleware_name,
+ (AgentMiddleware,),
+ {
+ "state_schema": state_schema or AgentState,
+ "tools": tools or [],
+ "aon_model_call": async_wrapped,
+ },
+ )()
+
def wrapped(
self: AgentMiddleware[StateT, ContextT], # noqa: ARG001
request: ModelRequest,
state: StateT,
runtime: Runtime[ContextT],
- ) -> Generator[ModelRequest, AIMessage, AIMessage]:
- return func(request, state, runtime)
+ handler: Callable[[ModelRequest], AIMessage],
+ ) -> AIMessage:
+ return func(request, state, runtime, handler)
middleware_name = name or cast("str", getattr(func, "__name__", "OnModelCallMiddleware"))
diff --git a/libs/langchain_v1/tests/unit_tests/agents/middleware/test_on_model_call_decorator.py b/libs/langchain_v1/tests/unit_tests/agents/middleware/test_on_model_call_decorator.py
index b0cdcee3e7..7c0c582f1a 100644
--- a/libs/langchain_v1/tests/unit_tests/agents/middleware/test_on_model_call_decorator.py
+++ b/libs/langchain_v1/tests/unit_tests/agents/middleware/test_on_model_call_decorator.py
@@ -20,9 +20,8 @@ class TestOnModelCallDecorator:
"""Test basic decorator usage without parameters."""
@on_model_call
- def passthrough_middleware(request, state, runtime):
- response = yield request
- # Generator ends
+ def passthrough_middleware(request, state, runtime, handler):
+ return handler(request)
# Should return an AgentMiddleware instance
assert isinstance(passthrough_middleware, AgentMiddleware)
@@ -39,9 +38,8 @@ class TestOnModelCallDecorator:
"""Test decorator with custom middleware name."""
@on_model_call(name="CustomMiddleware")
- def my_middleware(request, state, runtime):
- response = yield request
- # Generator ends
+ def my_middleware(request, state, runtime, handler):
+ return handler(request)
assert isinstance(my_middleware, AgentMiddleware)
assert my_middleware.__class__.__name__ == "CustomMiddleware"
@@ -58,14 +56,12 @@ class TestOnModelCallDecorator:
return super()._generate(messages, **kwargs)
@on_model_call
- def retry_once(request, state, runtime):
+ def retry_once(request, state, runtime, handler):
try:
- result = yield request
- # Generator ends
+ return handler(request)
except Exception:
# Retry once
- result = yield request
- # Generator ends
+ return handler(request)
model = FailOnceThenSucceed(messages=iter([AIMessage(content="Success")]))
agent = create_agent(model=model, middleware=[retry_once])
@@ -79,10 +75,9 @@ class TestOnModelCallDecorator:
"""Test decorator for rewriting responses."""
@on_model_call
- def uppercase_responses(request, state, runtime):
- result = yield request
- modified = AIMessage(content=result.content.upper())
- yield modified
+ def uppercase_responses(request, state, runtime, handler):
+ result = handler(request)
+ return AIMessage(content=result.content.upper())
model = GenericFakeChatModel(messages=iter([AIMessage(content="hello world")]))
agent = create_agent(model=model, middleware=[uppercase_responses])
@@ -99,12 +94,11 @@ class TestOnModelCallDecorator:
raise ValueError("Model error")
@on_model_call
- def error_to_fallback(request, state, runtime):
+ def error_to_fallback(request, state, runtime, handler):
try:
- result = yield request
+ return handler(request)
except Exception:
- fallback = AIMessage(content="Fallback response")
- yield fallback
+ return AIMessage(content="Fallback response")
model = AlwaysFailModel(messages=iter([]))
agent = create_agent(model=model, middleware=[error_to_fallback])
@@ -118,10 +112,9 @@ class TestOnModelCallDecorator:
state_values = []
@on_model_call
- def log_state(request, state, runtime):
+ def log_state(request, state, runtime, handler):
state_values.append(state.get("messages"))
- response = yield request
- # Generator ends
+ return handler(request)
model = GenericFakeChatModel(messages=iter([AIMessage(content="Response")]))
agent = create_agent(model=model, middleware=[log_state])
@@ -138,18 +131,18 @@ class TestOnModelCallDecorator:
execution_order = []
@on_model_call
- def outer_middleware(request, state, runtime):
+ def outer_middleware(request, state, runtime, handler):
execution_order.append("outer-before")
- response = yield request
+ result = handler(request)
execution_order.append("outer-after")
- # Generator ends
+ return result
@on_model_call
- def inner_middleware(request, state, runtime):
+ def inner_middleware(request, state, runtime, handler):
execution_order.append("inner-before")
- response = yield request
+ result = handler(request)
execution_order.append("inner-after")
- # Generator ends
+ return result
model = GenericFakeChatModel(messages=iter([AIMessage(content="Response")]))
agent = create_agent(model=model, middleware=[outer_middleware, inner_middleware])
@@ -172,9 +165,8 @@ class TestOnModelCallDecorator:
custom_field: str
@on_model_call(state_schema=CustomState)
- def middleware_with_schema(request, state, runtime):
- response = yield request
- # Generator ends
+ def middleware_with_schema(request, state, runtime, handler):
+ return handler(request)
assert isinstance(middleware_with_schema, AgentMiddleware)
# Custom state schema should be set
@@ -190,9 +182,8 @@ class TestOnModelCallDecorator:
return f"Result: {query}"
@on_model_call(tools=[test_tool])
- def middleware_with_tools(request, state, runtime):
- response = yield request
- # Generator ends
+ def middleware_with_tools(request, state, runtime, handler):
+ return handler(request)
assert isinstance(middleware_with_tools, AgentMiddleware)
assert len(middleware_with_tools.tools) == 1
@@ -203,15 +194,13 @@ class TestOnModelCallDecorator:
# Without parentheses
@on_model_call
- def middleware_no_parens(request, state, runtime):
- response = yield request
- # Generator ends
+ def middleware_no_parens(request, state, runtime, handler):
+ return handler(request)
# With parentheses
@on_model_call()
- def middleware_with_parens(request, state, runtime):
- response = yield request
- # Generator ends
+ def middleware_with_parens(request, state, runtime, handler):
+ return handler(request)
assert isinstance(middleware_no_parens, AgentMiddleware)
assert isinstance(middleware_with_parens, AgentMiddleware)
@@ -220,9 +209,8 @@ class TestOnModelCallDecorator:
"""Test that decorator uses function name for class name."""
@on_model_call
- def my_custom_middleware(request, state, runtime):
- response = yield request
- # Generator ends
+ def my_custom_middleware(request, state, runtime, handler):
+ return handler(request)
assert my_custom_middleware.__class__.__name__ == "my_custom_middleware"
@@ -231,18 +219,18 @@ class TestOnModelCallDecorator:
execution_order = []
@on_model_call
- def decorated_middleware(request, state, runtime):
+ def decorated_middleware(request, state, runtime, handler):
execution_order.append("decorated-before")
- response = yield request
+ result = handler(request)
execution_order.append("decorated-after")
- # Generator ends
+ return result
class ClassMiddleware(AgentMiddleware):
- def on_model_call(self, request, state, runtime):
+ def on_model_call(self, request, state, runtime, handler):
execution_order.append("class-before")
- response = yield request
+ result = handler(request)
execution_order.append("class-after")
- # Generator ends
+ return result
model = GenericFakeChatModel(messages=iter([AIMessage(content="Response")]))
agent = create_agent(
@@ -273,14 +261,15 @@ class TestOnModelCallDecorator:
return super()._generate(messages, **kwargs)
@on_model_call
- def retry_with_tracking(request, state, runtime):
+ def retry_with_tracking(request, state, runtime, handler):
max_retries = 3
+ last_exception = None
for attempt in range(max_retries):
attempts.append(attempt + 1)
try:
- result = yield request
- # Generator ends
- except Exception:
+ return handler(request)
+ except Exception as e:
+ last_exception = e
# On error, continue to next attempt
if attempt < max_retries - 1:
continue # Retry
@@ -300,11 +289,11 @@ class TestOnModelCallDecorator:
call_log = []
@on_model_call
- def logging_middleware(request, state, runtime):
+ async def logging_middleware(request, state, runtime, handler):
call_log.append("before")
- response = yield request
+ result = await handler(request)
call_log.append("after")
- # Generator ends
+ return result
model = GenericFakeChatModel(messages=iter([AIMessage(content="Async response")]))
agent = create_agent(model=model, middleware=[logging_middleware])
@@ -319,7 +308,7 @@ class TestOnModelCallDecorator:
modified_prompts = []
@on_model_call
- def add_system_prompt(request, state, runtime):
+ def add_system_prompt(request, state, runtime, handler):
# Modify request to add system prompt
modified_request = ModelRequest(
messages=request.messages,
@@ -330,8 +319,7 @@ class TestOnModelCallDecorator:
response_format=request.response_format,
)
modified_prompts.append(modified_request.system_prompt)
- response = yield modified_request
- # Generator ends
+ return handler(modified_request)
model = GenericFakeChatModel(messages=iter([AIMessage(content="Response")]))
agent = create_agent(model=model, middleware=[add_system_prompt])
@@ -344,15 +332,14 @@ class TestOnModelCallDecorator:
"""Test decorator applying multiple transformations."""
@on_model_call
- def multi_transform(request, state, runtime):
- result = yield request
+ def multi_transform(request, state, runtime, handler):
+ result = handler(request)
# First transformation: uppercase
content = result.content.upper()
# Second transformation: add prefix and suffix
content = f"[START] {content} [END]"
- modified = AIMessage(content=content)
- yield modified
+ return AIMessage(content=content)
model = GenericFakeChatModel(messages=iter([AIMessage(content="hello")]))
agent = create_agent(model=model, middleware=[multi_transform])
diff --git a/libs/langchain_v1/tests/unit_tests/agents/middleware/test_on_model_call_middleware.py b/libs/langchain_v1/tests/unit_tests/agents/middleware/test_on_model_call_middleware.py
index 189c669f77..ac0375e537 100644
--- a/libs/langchain_v1/tests/unit_tests/agents/middleware/test_on_model_call_middleware.py
+++ b/libs/langchain_v1/tests/unit_tests/agents/middleware/test_on_model_call_middleware.py
@@ -19,9 +19,8 @@ class TestBasicOnModelCall:
"""Test middleware that simply passes through without modification."""
class PassthroughMiddleware(AgentMiddleware):
- def on_model_call(self, request, state, runtime):
- response = yield request
- # Generator ends
+ def on_model_call(self, request, state, runtime, handler):
+ return handler(request)
model = GenericFakeChatModel(messages=iter([AIMessage(content="Hello")]))
agent = create_agent(model=model, middleware=[PassthroughMiddleware()])
@@ -36,11 +35,11 @@ class TestBasicOnModelCall:
call_log = []
class LoggingMiddleware(AgentMiddleware):
- def on_model_call(self, request, state, runtime):
+ def on_model_call(self, request, state, runtime, handler):
call_log.append("before")
- result = yield request
+ result = handler(request)
call_log.append("after")
- # Generator ends
+ return result
model = GenericFakeChatModel(messages=iter([AIMessage(content="Response")]))
agent = create_agent(model=model, middleware=[LoggingMiddleware()])
@@ -58,10 +57,9 @@ class TestBasicOnModelCall:
super().__init__()
self.call_count = 0
- def on_model_call(self, request, state, runtime):
+ def on_model_call(self, request, state, runtime, handler):
self.call_count += 1
- response = yield request
- # Generator ends
+ return handler(request)
counter = CountingMiddleware()
model = GenericFakeChatModel(messages=iter([AIMessage(content="Reply")]))
@@ -91,14 +89,14 @@ class TestRetryMiddleware:
super().__init__()
self.retry_count = 0
- def on_model_call(self, request, state, runtime):
+ def on_model_call(self, request, state, runtime, handler):
try:
- result = yield request
- # Generator ends
+ result = handler(request)
+ return result
except Exception:
self.retry_count += 1
- result = yield request
- # Generator ends
+ result = handler(request)
+ return result
retry_middleware = RetryOnceMiddleware()
model = FailOnceThenSucceed(messages=iter([AIMessage(content="Success")]))
@@ -122,13 +120,13 @@ class TestRetryMiddleware:
self.max_retries = max_retries
self.attempts = []
- def on_model_call(self, request, state, runtime):
+ def on_model_call(self, request, state, runtime, handler):
last_exception = None
for attempt in range(self.max_retries):
self.attempts.append(attempt + 1)
try:
- result = yield request
- # Generator ends
+ result = handler(request)
+ return result
except Exception as e:
last_exception = e
continue
@@ -153,10 +151,9 @@ class TestResponseRewriting:
"""Test middleware that transforms response to uppercase."""
class UppercaseMiddleware(AgentMiddleware):
- def on_model_call(self, request, state, runtime):
- result = yield request
- modified = AIMessage(content=result.content.upper())
- yield modified
+ def on_model_call(self, request, state, runtime, handler):
+ result = handler(request)
+ return AIMessage(content=result.content.upper())
model = GenericFakeChatModel(messages=iter([AIMessage(content="hello world")]))
agent = create_agent(model=model, middleware=[UppercaseMiddleware()])
@@ -173,10 +170,9 @@ class TestResponseRewriting:
super().__init__()
self.prefix = prefix
- def on_model_call(self, request, state, runtime):
- result = yield request
- modified = AIMessage(content=f"{self.prefix}{result.content}")
- yield modified
+ def on_model_call(self, request, state, runtime, handler):
+ result = handler(request)
+ return AIMessage(content=f"{self.prefix}{result.content}")
model = GenericFakeChatModel(messages=iter([AIMessage(content="Response")]))
agent = create_agent(model=model, middleware=[PrefixMiddleware(prefix="[BOT]: ")])
@@ -197,12 +193,12 @@ class TestErrorHandling:
raise ValueError("Model error")
class ErrorToSuccessMiddleware(AgentMiddleware):
- def on_model_call(self, request, state, runtime):
+ def on_model_call(self, request, state, runtime, handler):
try:
- yield request
+ return handler(request)
except Exception:
fallback = AIMessage(content="Error handled gracefully")
- yield fallback
+ return fallback
model = AlwaysFailModel(messages=iter([]))
agent = create_agent(model=model, middleware=[ErrorToSuccessMiddleware()])
@@ -220,12 +216,12 @@ class TestErrorHandling:
raise ConnectionError("Network error")
class SelectiveErrorMiddleware(AgentMiddleware):
- def on_model_call(self, request, state, runtime):
+ def on_model_call(self, request, state, runtime, handler):
try:
- yield request
+ return handler(request)
except ConnectionError:
fallback = AIMessage(content="Network issue, try again later")
- yield fallback
+ return fallback
model = SpecificErrorModel(messages=iter([]))
agent = create_agent(model=model, middleware=[SelectiveErrorMiddleware()])
@@ -239,15 +235,16 @@ class TestErrorHandling:
call_log = []
class ErrorRecoveryMiddleware(AgentMiddleware):
- def on_model_call(self, request, state, runtime):
+ def on_model_call(self, request, state, runtime, handler):
try:
call_log.append("before-yield")
- yield request
+ result = handler(request)
call_log.append("after-yield-success")
+ return result
except Exception:
call_log.append("caught-error")
fallback = AIMessage(content="Recovered from error")
- yield fallback
+ return fallback
# Test 1: Success path
call_log.clear()
@@ -282,17 +279,18 @@ class TestShortCircuit:
model_calls = []
class CachingMiddleware(AgentMiddleware):
- def on_model_call(self, request, state, runtime):
+ def on_model_call(self, request, state, runtime, handler):
# Simple cache key based on last message
cache_key = str(request.messages[-1].content) if request.messages else ""
if cache_key in cache:
# Short-circuit with cached result
- yield cache[cache_key]
+ return cache[cache_key]
else:
# Execute and cache
- result = yield request
+ result = handler(request)
cache[cache_key] = result
+ return result
class TrackingModel(GenericFakeChatModel):
def _generate(self, messages, **kwargs):
@@ -337,7 +335,7 @@ class TestRequestModification:
super().__init__()
self.system_prompt = system_prompt
- def on_model_call(self, request, state, runtime):
+ def on_model_call(self, request, state, runtime, handler):
# Modify request to add system prompt
modified_request = ModelRequest(
model=request.model,
@@ -349,7 +347,7 @@ class TestRequestModification:
model_settings=request.model_settings,
)
received_requests.append(modified_request)
- yield modified_request
+ return handler(modified_request)
model = GenericFakeChatModel(messages=iter([AIMessage(content="Response")]))
agent = create_agent(
@@ -372,7 +370,7 @@ class TestStateAndRuntime:
state_values = []
class StateAwareMiddleware(AgentMiddleware):
- def on_model_call(self, request, state, runtime):
+ def on_model_call(self, request, state, runtime, handler):
# Access state
state_values.append(
{
@@ -380,7 +378,7 @@ class TestStateAndRuntime:
"messages_count": len(state.get("messages", [])),
}
)
- yield request
+ return handler(request)
model = GenericFakeChatModel(messages=iter([AIMessage(content="Response")]))
agent = create_agent(model=model, middleware=[StateAwareMiddleware()])
@@ -395,11 +393,11 @@ class TestStateAndRuntime:
"""Test middleware that tracks retry count in state."""
class StateTrackingRetryMiddleware(AgentMiddleware):
- def on_model_call(self, request, state, runtime):
+ def on_model_call(self, request, state, runtime, handler):
max_retries = 2
for attempt in range(max_retries):
try:
- yield request
+ return handler(request)
break # Success
except Exception:
if attempt == max_retries - 1:
@@ -431,18 +429,18 @@ class TestMiddlewareComposition:
execution_order = []
class OuterMiddleware(AgentMiddleware):
- def on_model_call(self, request, state, runtime):
+ def on_model_call(self, request, state, runtime, handler):
execution_order.append("outer-before")
- response = yield request
+ response = handler(request)
execution_order.append("outer-after")
- # Generator ends
+ return response
class InnerMiddleware(AgentMiddleware):
- def on_model_call(self, request, state, runtime):
+ def on_model_call(self, request, state, runtime, handler):
execution_order.append("inner-before")
- response = yield request
+ response = handler(request)
execution_order.append("inner-after")
- # Generator ends
+ return response
model = GenericFakeChatModel(messages=iter([AIMessage(content="Response")]))
agent = create_agent(model=model, middleware=[OuterMiddleware(), InnerMiddleware()])
@@ -470,24 +468,24 @@ class TestMiddlewareComposition:
return super()._generate(messages, **kwargs)
class LoggingMiddleware(AgentMiddleware):
- def on_model_call(self, request, state, runtime):
+ def on_model_call(self, request, state, runtime, handler):
log.append("logging-before")
- result = yield request
+ result = handler(request)
log.append("logging-after")
- # Generator ends
+ return result
class RetryMiddleware(AgentMiddleware):
- def on_model_call(self, request, state, runtime):
+ def on_model_call(self, request, state, runtime, handler):
log.append("retry-before")
try:
- result = yield request
+ result = handler(request)
log.append("retry-after")
- # Generator ends
+ return result
except Exception:
log.append("retry-retrying")
- result = yield request
+ result = handler(request)
log.append("retry-after")
- # Generator ends
+ return result
model = FailOnceThenSucceed(messages=iter([AIMessage(content="Success")]))
# Logging is outer, Retry is inner
@@ -509,16 +507,14 @@ class TestMiddlewareComposition:
"""Test multiple middleware that each transform the response."""
class PrefixMiddleware(AgentMiddleware):
- def on_model_call(self, request, state, runtime):
- result = yield request
- modified = AIMessage(content=f"[PREFIX] {result.content}")
- yield modified
+ def on_model_call(self, request, state, runtime, handler):
+ result = handler(request)
+ return AIMessage(content=f"[PREFIX] {result.content}")
class SuffixMiddleware(AgentMiddleware):
- def on_model_call(self, request, state, runtime):
- result = yield request
- modified = AIMessage(content=f"{result.content} [SUFFIX]")
- yield modified
+ def on_model_call(self, request, state, runtime, handler):
+ result = handler(request)
+ return AIMessage(content=f"{result.content} [SUFFIX]")
model = GenericFakeChatModel(messages=iter([AIMessage(content="Middle")]))
# Prefix is outer, Suffix is inner
@@ -542,19 +538,18 @@ class TestMiddlewareComposition:
return super()._generate(messages, **kwargs)
class RetryMiddleware(AgentMiddleware):
- def on_model_call(self, request, state, runtime):
+ def on_model_call(self, request, state, runtime, handler):
try:
- result = yield request
- # Generator ends
+ result = handler(request)
+ return result
except Exception:
- result = yield request
- # Generator ends
+ result = handler(request)
+ return result
class UppercaseMiddleware(AgentMiddleware):
- def on_model_call(self, request, state, runtime):
- result = yield request
- modified = AIMessage(content=result.content.upper())
- yield modified
+ def on_model_call(self, request, state, runtime, handler):
+ result = handler(request)
+ return AIMessage(content=result.content.upper())
model = FailOnceThenSucceed(messages=iter([AIMessage(content="success")]))
# Retry outer, Uppercase inner
@@ -570,25 +565,25 @@ class TestMiddlewareComposition:
execution_order = []
class FirstMiddleware(AgentMiddleware):
- def on_model_call(self, request, state, runtime):
+ def on_model_call(self, request, state, runtime, handler):
execution_order.append("first-before")
- response = yield request
+ response = handler(request)
execution_order.append("first-after")
- # Generator ends
+ return response
class SecondMiddleware(AgentMiddleware):
- def on_model_call(self, request, state, runtime):
+ def on_model_call(self, request, state, runtime, handler):
execution_order.append("second-before")
- response = yield request
+ response = handler(request)
execution_order.append("second-after")
- # Generator ends
+ return response
class ThirdMiddleware(AgentMiddleware):
- def on_model_call(self, request, state, runtime):
+ def on_model_call(self, request, state, runtime, handler):
execution_order.append("third-before")
- response = yield request
+ response = handler(request)
execution_order.append("third-after")
- # Generator ends
+ return response
model = GenericFakeChatModel(messages=iter([AIMessage(content="Response")]))
agent = create_agent(
@@ -614,25 +609,28 @@ class TestMiddlewareComposition:
model_calls = []
class OuterMiddleware(AgentMiddleware):
- def on_model_call(self, request, state, runtime):
+ def on_model_call(self, request, state, runtime, handler):
execution_order.append("outer-before")
- yield request
+ result = handler(request)
execution_order.append("outer-after")
+ return result
class MiddleRetryMiddleware(AgentMiddleware):
- def on_model_call(self, request, state, runtime):
+ def on_model_call(self, request, state, runtime, handler):
execution_order.append("middle-before")
- # Always retry once (yield twice)
- yield request
+ # Always retry once (call handler twice)
+ result = handler(request)
execution_order.append("middle-retry")
- yield request
+ result = handler(request)
execution_order.append("middle-after")
+ return result
class InnerMiddleware(AgentMiddleware):
- def on_model_call(self, request, state, runtime):
+ def on_model_call(self, request, state, runtime, handler):
execution_order.append("inner-before")
- yield request
+ result = handler(request)
execution_order.append("inner-after")
+ return result
class TrackingModel(GenericFakeChatModel):
def _generate(self, messages, **kwargs):
@@ -673,11 +671,12 @@ class TestAsyncOnModelCall:
log = []
class LoggingMiddleware(AgentMiddleware):
- def on_model_call(self, request, state, runtime):
+ async def aon_model_call(self, request, state, runtime, handler):
log.append("before")
- response = yield request
+ result = await handler(request)
log.append("after")
- # Generator ends
+
+ return result
model = GenericFakeChatModel(messages=iter([AIMessage(content="Async response")]))
agent = create_agent(model=model, middleware=[LoggingMiddleware()])
@@ -699,13 +698,11 @@ class TestAsyncOnModelCall:
return await super()._agenerate(messages, **kwargs)
class RetryMiddleware(AgentMiddleware):
- def on_model_call(self, request, state, runtime):
+ async def aon_model_call(self, request, state, runtime, handler):
try:
- result = yield request
- # Generator ends
+ return await handler(request)
except Exception:
- result = yield request
- # Generator ends
+ return await handler(request)
model = AsyncFailOnceThenSucceed(messages=iter([AIMessage(content="Async success")]))
agent = create_agent(model=model, middleware=[RetryMiddleware()])
@@ -724,12 +721,11 @@ class TestEdgeCases:
modified_messages = []
class RequestModifyingMiddleware(AgentMiddleware):
- def on_model_call(self, request, state, runtime):
+ def on_model_call(self, request, state, runtime, handler):
# Add a system message to the request
modified_request = request
modified_messages.append(len(modified_request.messages))
- response = yield modified_request
- # Generator ends
+ return handler(modified_request)
model = GenericFakeChatModel(messages=iter([AIMessage(content="Response")]))
agent = create_agent(model=model, middleware=[RequestModifyingMiddleware()])
@@ -743,15 +739,15 @@ class TestEdgeCases:
attempts = []
class MultiModelRetryMiddleware(AgentMiddleware):
- def on_model_call(self, request, state, runtime):
+ def on_model_call(self, request, state, runtime, handler):
attempts.append("first-attempt")
try:
- result = yield request
- # Generator ends
+ result = handler(request)
+ return result
except Exception:
attempts.append("retry-attempt")
- result = yield request
- # Generator ends
+ result = handler(request)
+ return result
call_count = {"value": 0}
diff --git a/libs/langchain_v1/tests/unit_tests/agents/test_handler_composition.py b/libs/langchain_v1/tests/unit_tests/agents/test_handler_composition.py
index 9b51ffc625..2b7713fcb4 100644
--- a/libs/langchain_v1/tests/unit_tests/agents/test_handler_composition.py
+++ b/libs/langchain_v1/tests/unit_tests/agents/test_handler_composition.py
@@ -1,4 +1,4 @@
-"""Unit tests for _chain_model_call_handlers generator composition."""
+"""Unit tests for _chain_model_call_handlers handler composition."""
import pytest
from langchain_core.messages import AIMessage
@@ -32,8 +32,8 @@ class TestChainModelCallHandlers:
def test_single_handler_returns_unchanged(self) -> None:
"""Test that single handler is returned without composition."""
- def handler(request, state, runtime):
- yield request
+ def handler(request, state, runtime, base_handler):
+ return base_handler(request)
result = _chain_model_call_handlers([handler])
assert result is handler
@@ -42,30 +42,26 @@ class TestChainModelCallHandlers:
"""Test basic composition of two handlers."""
execution_order = []
- def outer(request, state, runtime):
+ def outer(request, state, runtime, handler):
execution_order.append("outer-before")
- yield request
+ result = handler(request)
execution_order.append("outer-after")
+ return result
- def inner(request, state, runtime):
+ def inner(request, state, runtime, handler):
execution_order.append("inner-before")
- yield request
+ result = handler(request)
execution_order.append("inner-after")
+ return result
composed = _chain_model_call_handlers([outer, inner])
assert composed is not None
# Execute the composed handler
- gen = composed(create_test_request(), None, None)
- request = next(gen)
+ def mock_base_handler(req):
+ return AIMessage(content="test")
- # Simulate model response
- model_response = AIMessage(content="test")
-
- try:
- gen.send(model_response)
- except StopIteration:
- pass # Expected - generator ends after processing
+ result = composed(create_test_request(), None, None, mock_base_handler)
assert execution_order == [
"outer-before",
@@ -73,41 +69,37 @@ class TestChainModelCallHandlers:
"inner-after",
"outer-after",
]
+ assert result.content == "test"
def test_three_handlers_composition(self) -> None:
"""Test composition of three handlers."""
execution_order = []
- def first(request, state, runtime):
+ def first(request, state, runtime, handler):
execution_order.append("first-before")
- response = yield request
+ result = handler(request)
execution_order.append("first-after")
- # Generator ends here
+ return result
- def second(request, state, runtime):
+ def second(request, state, runtime, handler):
execution_order.append("second-before")
- response = yield request
+ result = handler(request)
execution_order.append("second-after")
- # Generator ends here
+ return result
- def third(request, state, runtime):
+ def third(request, state, runtime, handler):
execution_order.append("third-before")
- response = yield request
+ result = handler(request)
execution_order.append("third-after")
- # Generator ends here
+ return result
composed = _chain_model_call_handlers([first, second, third])
assert composed is not None
- gen = composed(create_test_request(), None, None)
- request = next(gen)
-
- model_response = AIMessage(content="test")
+ def mock_base_handler(req):
+ return AIMessage(content="test")
- try:
- gen.send(model_response)
- except StopIteration as e:
- final_response = e.value
+ result = composed(create_test_request(), None, None, mock_base_handler)
# First wraps second wraps third
assert execution_order == [
@@ -118,118 +110,102 @@ class TestChainModelCallHandlers:
"second-after",
"first-after",
]
- # Assertion removed - no longer using ModelResponse
+ assert result.content == "test"
def test_inner_handler_retry(self) -> None:
"""Test inner handler retrying before outer sees response."""
inner_attempts = []
- def outer_passthrough(request, state, runtime):
- response = yield request
- # Generator ends here
+ def outer_passthrough(request, state, runtime, handler):
+ return handler(request)
- def inner_with_retry(request, state, runtime):
+ def inner_with_retry(request, state, runtime, handler):
for attempt in range(3):
inner_attempts.append(attempt)
- yield request
+ try:
+ return handler(request)
+ except ValueError:
+ if attempt == 2:
+ raise
+ return AIMessage(content="should not reach")
composed = _chain_model_call_handlers([outer_passthrough, inner_with_retry])
assert composed is not None
- gen = composed(create_test_request(), None, None)
-
- # Inner will retry twice before success
- request = next(gen)
- error_response = ValueError("fail")
- request = gen.send(error_response)
-
- request = gen.send(error_response)
+ call_count = {"value": 0}
- success_response = AIMessage(content="success")
+ def mock_base_handler(req):
+ call_count["value"] += 1
+ if call_count["value"] < 3:
+ raise ValueError("fail")
+ return AIMessage(content="success")
- try:
- gen.send(success_response)
- except StopIteration as e:
- final_response = e.value
+ result = composed(create_test_request(), None, None, mock_base_handler)
assert inner_attempts == [0, 1, 2]
- # Assertion removed - no longer using ModelResponse
+ assert result.content == "success"
def test_error_to_success_conversion(self) -> None:
"""Test handler converting error to success response."""
- def outer_error_handler(request, state, runtime):
+ def outer_error_handler(request, state, runtime, handler):
try:
- yield request
+ return handler(request)
except Exception:
- fallback = AIMessage(content="Fallback response")
- yield fallback
+ return AIMessage(content="Fallback response")
- def inner_passthrough(request, state, runtime):
- yield request
+ def inner_passthrough(request, state, runtime, handler):
+ return handler(request)
composed = _chain_model_call_handlers([outer_error_handler, inner_passthrough])
assert composed is not None
- gen = composed(create_test_request(), None, None)
- request = next(gen)
+ def mock_base_handler(req):
+ raise ValueError("Model failed")
- # Throw error into the generator
- try:
- gen.throw(ValueError("Model failed"))
- except StopIteration:
- pass # Generator ends after handling error
+ result = composed(create_test_request(), None, None, mock_base_handler)
- # The test needs to be restructured - error handling with composition is complex
- # For now, just verify the composed generator doesn't crash
+ assert result.content == "Fallback response"
def test_request_modification(self) -> None:
"""Test handlers modifying the request."""
requests_seen = []
- def outer_add_context(request, state, runtime):
+ def outer_add_context(request, state, runtime, handler):
modified_request = create_test_request(
messages=[*request.messages], system_prompt="Added by outer"
)
- response = yield modified_request
- # Generator ends here
+ return handler(modified_request)
- def inner_track_request(request, state, runtime):
+ def inner_track_request(request, state, runtime, handler):
requests_seen.append(request.system_prompt)
- response = yield request
- # Generator ends here
+ return handler(request)
composed = _chain_model_call_handlers([outer_add_context, inner_track_request])
assert composed is not None
- gen = composed(create_test_request(), None, None)
- request = next(gen)
+ def mock_base_handler(req):
+ return AIMessage(content="response")
- model_response = AIMessage(content="response")
-
- try:
- gen.send(model_response)
- except StopIteration:
- pass
+ result = composed(create_test_request(), None, None, mock_base_handler)
assert requests_seen == ["Added by outer"]
+ assert result.content == "response"
def test_composition_preserves_state_and_runtime(self) -> None:
"""Test that state and runtime are passed through composition."""
state_values = []
runtime_values = []
- def outer(request, state, runtime):
+ def outer(request, state, runtime, handler):
state_values.append(("outer", state))
runtime_values.append(("outer", runtime))
- response = yield request
- # Generator ends here
+ return handler(request)
- def inner(request, state, runtime):
+ def inner(request, state, runtime, handler):
state_values.append(("inner", state))
runtime_values.append(("inner", runtime))
- response = yield request
- # Generator ends here
+ return handler(request)
composed = _chain_model_call_handlers([outer, inner])
assert composed is not None
@@ -237,52 +213,45 @@ class TestChainModelCallHandlers:
test_state = {"test": "state"}
test_runtime = {"test": "runtime"}
- gen = composed(create_test_request(), test_state, test_runtime)
- request = next(gen)
-
- model_response = AIMessage(content="test")
+ def mock_base_handler(req):
+ return AIMessage(content="test")
- try:
- gen.send(model_response)
- except StopIteration:
- pass
+ result = composed(create_test_request(), test_state, test_runtime, mock_base_handler)
# Both handlers should see same state and runtime
assert state_values == [("outer", test_state), ("inner", test_state)]
assert runtime_values == [("outer", test_runtime), ("inner", test_runtime)]
+ assert result.content == "test"
def test_multiple_yields_in_retry_loop(self) -> None:
- """Test handler that yields multiple times in a loop."""
- yield_count = {"value": 0}
+ """Test handler that retries multiple times."""
+ call_count = {"value": 0}
- def outer_counts_yields(request, state, runtime):
- response = yield request
- yield_count["value"] += 1
- # Generator ends here
+ def outer_counts_calls(request, state, runtime, handler):
+ call_count["value"] += 1
+ return handler(request)
- def inner_retries(request, state, runtime):
- response = yield request
- if isinstance(response, Exception):
- response = yield request # Second attempt
- # Generator ends here
+ def inner_retries(request, state, runtime, handler):
+ try:
+ return handler(request)
+ except ValueError:
+ # Retry once on error
+ return handler(request)
- composed = _chain_model_call_handlers([outer_counts_yields, inner_retries])
+ composed = _chain_model_call_handlers([outer_counts_calls, inner_retries])
assert composed is not None
- gen = composed(create_test_request(), None, None)
-
- # First attempt - error
- request = next(gen)
- error = ValueError("fail")
- request = gen.send(error)
+ attempt = {"value": 0}
- # Second attempt - success
- success = AIMessage(content="ok")
+ def mock_base_handler(req):
+ attempt["value"] += 1
+ if attempt["value"] == 1:
+ raise ValueError("fail")
+ return AIMessage(content="ok")
- try:
- gen.send(success)
- except StopIteration as e:
- final_response = e.value
+ result = composed(create_test_request(), None, None, mock_base_handler)
- assert yield_count["value"] == 1
- # Assertion removed - no longer using ModelResponse
+ # Outer called once, inner retried so base handler called twice
+ assert call_count["value"] == 1
+ assert attempt["value"] == 2
+ assert result.content == "ok"
diff --git a/libs/langchain_v1/tests/unit_tests/agents/test_middleware_agent.py b/libs/langchain_v1/tests/unit_tests/agents/test_middleware_agent.py
index 043465d65a..39e62456c3 100644
--- a/libs/langchain_v1/tests/unit_tests/agents/test_middleware_agent.py
+++ b/libs/langchain_v1/tests/unit_tests/agents/test_middleware_agent.py
@@ -2179,15 +2179,13 @@ def test_on_model_call_hook() -> None:
super().__init__()
self.retry_count = 0
- def on_model_call(self, request, state, runtime):
+ def on_model_call(self, request, state, runtime, handler):
try:
- result = yield request
- # Generator ends
+ return handler(request)
except Exception:
# Retry on error
self.retry_count += 1
- result = yield request
- # Generator ends
+ return handler(request)
failing_model = FailingModel()
retry_middleware = RetryMiddleware()
@@ -2221,14 +2219,13 @@ def test_on_model_call_retry_count() -> None:
super().__init__()
self.attempts = []
- def on_model_call(self, request, state, runtime):
+ def on_model_call(self, request, state, runtime, handler):
max_retries = 3
last_exception = None
for attempt in range(max_retries):
self.attempts.append(attempt + 1)
try:
- result = yield request
- # Generator ends
+ return handler(request)
except Exception as e:
last_exception = e
if attempt < max_retries - 1:
@@ -2264,10 +2261,8 @@ def test_on_model_call_no_retry() -> None:
return "failing"
class NoRetryMiddleware(AgentMiddleware):
- def on_model_call(self, request, state, runtime):
- response = yield request
- # Don't retry, just return the error response
- # Generator ends
+ def on_model_call(self, request, state, runtime, handler):
+ return handler(request)
agent = create_agent(model=FailingModel(), middleware=[NoRetryMiddleware()])
@@ -2383,13 +2378,12 @@ def test_on_model_call_max_attempts() -> None:
self.max_retries = max_retries
self.attempt_count = 0
- def on_model_call(self, request, state, runtime):
+ def on_model_call(self, request, state, runtime, handler):
last_exception = None
for attempt in range(self.max_retries):
self.attempt_count += 1
try:
- result = yield request
- # Generator ends
+ return handler(request)
except Exception as e:
last_exception = e
# Continue to retry
@@ -2438,15 +2432,13 @@ async def test_on_model_call_async() -> None:
super().__init__()
self.retry_count = 0
- def on_model_call(self, request, state, runtime):
+ async def aon_model_call(self, request, state, runtime, handler):
try:
- result = yield request
- # Generator ends
+ return await handler(request)
except Exception:
# Retry on error
self.retry_count += 1
- result = yield request
- # Generator ends
+ return await handler(request)
failing_model = AsyncFailingModel()
retry_middleware = AsyncRetryMiddleware()
@@ -2480,12 +2472,11 @@ def test_on_model_call_rewrite_response() -> None:
class ResponseRewriteMiddleware(AgentMiddleware):
"""Middleware that rewrites the response."""
- def on_model_call(self, request, state, runtime):
- result = yield request
+ def on_model_call(self, request, state, runtime, handler):
+ result = handler(request)
# Rewrite the response
- rewritten_message = AIMessage(content=f"REWRITTEN: {result.content}")
- yield rewritten_message
+ return AIMessage(content=f"REWRITTEN: {result.content}")
model = SimpleModel()
middleware = ResponseRewriteMiddleware()
@@ -2514,16 +2505,12 @@ def test_on_model_call_convert_error_to_response() -> None:
class ErrorToResponseMiddleware(AgentMiddleware):
"""Middleware that converts errors to success responses."""
- def on_model_call(self, request, state, runtime):
+ def on_model_call(self, request, state, runtime, handler):
try:
- result = yield request
- # Generator ends
+ return handler(request)
except Exception as e:
# Convert error to success response
- fallback_message = AIMessage(
- content=f"Error occurred: {e}. Using fallback response."
- )
- yield fallback_message
+ return AIMessage(content=f"Error occurred: {e}. Using fallback response.")
model = AlwaysFailingModel()
middleware = ErrorToResponseMiddleware()