The agent engineering platform.
Python agentsaiai-agentsanthropicchatgptdeepagentsenterpriseframeworkgeminigenerative-ailangchainlanggraphllmmultiagentopen-sourceopenaipydanticpythonragtypescript
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.pyindex 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 BaseChatModelfrom langchain_core.messages import AIMessage, AnyMessage, SystemMessage, ToolMessagefrom 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: PLR0915Example:```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 resulthandler = _chain_model_call_handlers([auth, retry])@@ -140,138 +139,103 @@ def _chain_model_call_handlers( # noqa: PLR0915if 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: PLR0915middleware_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 = Noneif 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: PLR0915effective_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: PLR0915raise TypeError(msg)# Execute with or without handler- current_request: ModelRequest | AIMessage = request- internal_response: _InternalModelResponseeffective_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: PLR0915effective_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: PLR0915request = 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: _InternalModelResponseeffective_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.pyindex 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_modelif TYPE_CHECKING:- from collections.abc import Generator+ from collections.abc import Callablefrom langchain_core.language_models.chat_models import BaseChatModelfrom langchain_core.messages import AIMessage@@ -72,36 +72,36 @@ class ModelFallbackMiddleware(AgentMiddleware):request: ModelRequest,state: Any, # noqa: ARG002runtime: 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: Exceptiontry:- yield request+ return handler(request)except Exception as e: # noqa: BLE001last_exception = e- else:- return+ # Try fallback modelsfor fallback_model in self.models:request.model = fallback_modeltry:- yield request+ return handler(request)except Exception as e: # noqa: BLE001last_exception = econtinue- else:- returnraise last_exceptiondiff --git a/libs/langchain_v1/langchain/agents/middleware/types.py b/libs/langchain_v1/langchain/agents/middleware/types.pyindex 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, Generatorfrom dataclasses import dataclass, fieldfrom inspect import iscoroutinefunctionfrom 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 middlewarecompose 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(@overloaddef 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 = 3for 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 modeltry:- yield request- return # Success+ return handler(request)except Exception:pass# Try fallback modelrequest.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: ARG001request: 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.pyindex 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 instanceassert 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 resultmodel = 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 resultclass 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 resultmodel = 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 = Nonefor 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 attemptif 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 resultmodel = 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 promptmodified_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: uppercasecontent = result.content.upper()# Second transformation: add prefix and suffixcontent = 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.pyindex 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 resultmodel = 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 resultexcept Exception:self.retry_count += 1- result = yield request- # Generator ends+ result = handler(request)+ return resultretry_middleware = RetryOnceMiddleware()model = FailOnceThenSucceed(messages=iter([AIMessage(content="Success")]))@@ -122,13 +120,13 @@ class TestRetryMiddleware:self.max_retries = max_retriesself.attempts = []- def on_model_call(self, request, state, runtime):+ def on_model_call(self, request, state, runtime, handler):last_exception = Nonefor attempt in range(self.max_retries):self.attempts.append(attempt + 1)try:- result = yield request- # Generator ends+ result = handler(request)+ return resultexcept Exception as e:last_exception = econtinue@@ -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 fallbackmodel = 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 fallbackmodel = 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 resultexcept Exception:call_log.append("caught-error")fallback = AIMessage(content="Recovered from error")- yield fallback+ return fallback# Test 1: Success pathcall_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 messagecache_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 resultclass 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 promptmodified_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 statestate_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 = 2for attempt in range(max_retries):try:- yield request+ return handler(request)break # Successexcept 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 responseclass 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 responsemodel = 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 resultclass 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 resultexcept Exception:log.append("retry-retrying")- result = yield request+ result = handler(request)log.append("retry-after")- # Generator ends+ return resultmodel = 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 resultexcept Exception:- result = yield request- # Generator ends+ result = handler(request)+ return resultclass 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 responseclass 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 responseclass 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 responsemodel = 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 resultclass 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 resultclass 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 resultclass 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 resultmodel = 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 requestmodified_request = requestmodified_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 resultexcept Exception:attempts.append("retry-attempt")- result = yield request- # Generator ends+ result = handler(request)+ return resultcall_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.pyindex 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 pytestfrom 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 resultcomposed = _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 resultcomposed = _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 thirdassert 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 runtimeassert 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.pyindex 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 errorself.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 = 3last_exception = Nonefor 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 = eif 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_retriesself.attempt_count = 0- def on_model_call(self, request, state, runtime):+ def on_model_call(self, request, state, runtime, handler):last_exception = Nonefor attempt in range(self.max_retries):self.attempt_count += 1try:- 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 errorself.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()