The agent engineering platform.
Python agentsaiai-agentsanthropicchatgptdeepagentsenterpriseframeworkgeminigenerative-ailangchainlanggraphllmmultiagentopen-sourceopenaipydanticpythonragtypescript
chore(infra): merge v1.4 into master (#37350)
Nick Hollonda380bccf812
diff --git a/libs/core/langchain_core/callbacks/base.py b/libs/core/langchain_core/callbacks/base.pyindex 383b256cb2..2341931904 100644--- a/libs/core/langchain_core/callbacks/base.py+++ b/libs/core/langchain_core/callbacks/base.py@@ -134,7 +134,10 @@ class LLMManagerMixin:tags: list[str] | None = None,**kwargs: Any,) -> Any:- """Run on each protocol event produced by `stream_v2` / `astream_v2`.+ """Run on each protocol event from `stream_events(version="v3")`.++ Also fires for the async equivalent+ (`astream_events(version="v3")`).Fires once per `MessagesData` event — `message-start`, per-block`content-block-start` / `content-block-delta` /@@ -699,7 +702,7 @@ class AsyncCallbackHandler(BaseCallbackHandler):tags: list[str] | None = None,**kwargs: Any,) -> None:- """Run on each protocol event produced by `astream_v2`.+ """Run on each protocol event produced by `astream_events(version="v3")`.See :meth:`LLMManagerMixin.on_stream_event` for the full contract.Fires once per `MessagesData` event at event granularity, uniformlydiff --git a/libs/core/langchain_core/callbacks/manager.py b/libs/core/langchain_core/callbacks/manager.pyindex 0efab4ad04..c1ba9b76c0 100644--- a/libs/core/langchain_core/callbacks/manager.py+++ b/libs/core/langchain_core/callbacks/manager.py@@ -749,7 +749,7 @@ class CallbackManagerForLLMRun(RunManager, LLMManagerMixin):)def on_stream_event(self, event: MessagesData, **kwargs: Any) -> None:- """Run on each protocol event from `stream_v2`.+ """Run on each protocol event from `stream_events(version="v3")`.Args:event: The protocol event.@@ -871,7 +871,7 @@ class AsyncCallbackManagerForLLMRun(AsyncRunManager, LLMManagerMixin):)async def on_stream_event(self, event: MessagesData, **kwargs: Any) -> None:- """Run on each protocol event from `astream_v2`.+ """Run on each protocol event from `astream_events(version="v3")`.Args:event: The protocol event.diff --git a/libs/core/langchain_core/language_models/_compat_bridge.py b/libs/core/langchain_core/language_models/_compat_bridge.pyindex bc6928d898..5c2cdf0ba0 100644--- a/libs/core/langchain_core/language_models/_compat_bridge.py+++ b/libs/core/langchain_core/language_models/_compat_bridge.py@@ -61,6 +61,15 @@ from langchain_core.messages import AIMessageChunk, BaseMessageif TYPE_CHECKING:from collections.abc import AsyncIterator, Iterator+ from langchain_protocol.protocol import (+ BlockDelta,+ BlockDeltaFields,+ ContentBlockDelta,+ DataDelta,+ ReasoningDelta,+ TextDelta,+ )+from langchain_core.outputs import ChatGenerationChunk@@ -101,6 +110,38 @@ def _to_finalized_block(block: CompatBlock) -> FinalizedContentBlock:return cast("FinalizedContentBlock", block)+def _to_block_delta_fields(block: CompatBlock) -> BlockDeltaFields:+ """Narrow an internal working dict to protocol block-delta fields."""+ return cast("BlockDeltaFields", block)+++def _to_content_delta(block: CompatBlock) -> ContentBlockDelta:+ """Convert a content-block slice/snapshot to an explicit protocol delta."""+ btype = block.get("type")+ if btype == "text":+ return cast("TextDelta", {"type": "text-delta", "text": block.get("text", "")})+ if btype == "reasoning":+ return cast(+ "ReasoningDelta",+ {+ "type": "reasoning-delta",+ "reasoning": block.get("reasoning", ""),+ },+ )+ if "data" in block:+ delta = cast("DataDelta", {"type": "data-delta", "data": block.get("data", "")})+ if block.get("encoding") == "base64":+ delta["encoding"] = "base64"+ return delta+ return cast(+ "BlockDelta",+ {+ "type": "block-delta",+ "fields": _to_block_delta_fields(block),+ },+ )++# ---------------------------------------------------------------------------# Block iteration# ---------------------------------------------------------------------------@@ -236,6 +277,8 @@ def _should_emit_delta(block: CompatBlock) -> bool:return bool(block.get("args") or block.get("id") or block.get("name"),)+ if "data" in block:+ return bool(block.get("data"))return False@@ -281,6 +324,15 @@ def _accumulate(state: CompatBlock | None, delta: CompatBlock) -> CompatBlock:state["id"] = delta["id"]if delta.get("name") is not None:state["name"] = delta["name"]+ elif btype == dtype and "data" in delta:+ state["data"] = (state.get("data", "") or "") + (delta.get("data") or "")+ for key, value in delta.items():+ if key in ("type", "data") or value is None:+ continue+ if key == "extras" and isinstance(value, dict):+ state["extras"] = {**(state.get("extras") or {}), **value}+ else:+ state[key] = valueelse:# Self-contained or already-finalized types: replace wholesale.state.clear()@@ -429,11 +481,11 @@ def _to_protocol_usage(usage: dict[str, Any] | None) -> UsageInfo | None:"""Convert accumulated usage to the protocol's `UsageInfo` shape."""if usage is None:return None- result: UsageInfo = {}+ result: dict[str, Any] = {}for key in ("input_tokens", "output_tokens", "total_tokens", "cached_tokens"):if key in usage:result[key] = usage[key]- return result or None+ return cast("UsageInfo", result) if result else None# ---------------------------------------------------------------------------@@ -445,10 +497,10 @@ def _build_message_start(msg: BaseMessage,message_id: str | None,) -> MessageStartData:- start_data = MessageStartData(event="message-start", role="ai")+ start_data = MessageStartData(event="message-start", role="ai", id="")resolved_id = message_id if message_id is not None else getattr(msg, "id", None)if resolved_id:- start_data["message_id"] = resolved_id+ start_data["id"] = resolved_idstart_metadata = _extract_start_metadata(msg.response_metadata or {})if start_metadata:start_data["metadata"] = start_metadata@@ -464,13 +516,13 @@ def _build_message_finish(# `MessageFinishData`; the provider's raw `finish_reason` /# `stop_reason` now rides inside `metadata` alongside other# response metadata. Pass it through unchanged.- finish_data = MessageFinishData(event="message-finish")+ finish_data: dict[str, Any] = {"event": "message-finish"}usage_info = _to_protocol_usage(usage)if usage_info is not None:finish_data["usage"] = usage_infoif response_metadata:finish_data["metadata"] = dict(response_metadata)- return finish_data+ return cast("MessageFinishData", finish_data)def _finalize_and_build_finish(@@ -481,7 +533,7 @@ def _finalize_and_build_finish(return ContentBlockFinishData(event="content-block-finish",index=wire_idx,- content_block=_finalize_block(block),+ content=_finalize_block(block),)@@ -497,12 +549,12 @@ def chunks_to_events() -> Iterator[MessagesData]:"""Convert a stream of `ChatGenerationChunk` to protocol events.- Blocks stream one at a time: when a chunk carries a different block- identifier than the currently-open one, the open block is finished- before the new block starts, matching the protocol's no-interleave- rule. Source-side identifiers (from the block's `index` field, which- may be int or string) are translated to sequential `uint` wire- indices.+ Blocks are tracked independently by source-side identifier. Providers+ such as Anthropic can interleave parallel tool-call chunks by index, so+ each first-seen block gets a `content-block-start`, deltas keep their+ stable wire index, and all open blocks are finalized at message end.+ Source-side identifiers (from the block's `index` field, which may be+ int or string) are translated to sequential `uint` wire indices.Args:chunks: Iterator of `ChatGenerationChunk` from `_stream()`.@@ -512,9 +564,7 @@ def chunks_to_events(`MessagesData` lifecycle events."""started = False- open_key: Any = None- open_block: CompatBlock | None = None- open_wire_idx: int = 0+ blocks: dict[Any, tuple[int, CompatBlock]] = {}next_wire_idx = 0usage: dict[str, Any] | None = Noneresponse_metadata: dict[str, Any] = {}@@ -545,25 +595,29 @@ def chunks_to_events(yield _build_message_start(msg, message_id)for key, block in _iter_protocol_blocks(msg):- if key != open_key:- if open_block is not None:- yield _finalize_and_build_finish(open_wire_idx, open_block)- open_key = key- open_wire_idx = next_wire_idx+ if key not in blocks:+ wire_idx = next_wire_idxnext_wire_idx += 1- open_block = dict(block)+ blocks[key] = (wire_idx, dict(block))yield ContentBlockStartData(event="content-block-start",- index=open_wire_idx,- content_block=_start_skeleton(block),+ index=wire_idx,+ content=_start_skeleton(block),)else:- open_block = _accumulate(open_block, block)+ wire_idx, existing = blocks[key]+ blocks[key] = (wire_idx, _accumulate(existing, block))if _should_emit_delta(block):+ wire_idx, current = blocks[key]+ is_block_delta = block.get("type") in (+ "tool_call_chunk",+ "server_tool_call_chunk",+ )+ delta_source = current if is_block_delta else blockyield ContentBlockDeltaData(event="content-block-delta",- index=open_wire_idx,- content_block=_to_protocol_block(block),+ index=wire_idx,+ delta=_to_content_delta(delta_source or block),)if msg.usage_metadata:@@ -572,8 +626,8 @@ def chunks_to_events(if not started:return- if open_block is not None:- yield _finalize_and_build_finish(open_wire_idx, open_block)+ for wire_idx, block in blocks.values():+ yield _finalize_and_build_finish(wire_idx, block)yield _build_message_finish(usage=usage,@@ -588,9 +642,7 @@ async def achunks_to_events() -> AsyncIterator[MessagesData]:"""Async variant of `chunks_to_events`."""started = False- open_key: Any = None- open_block: CompatBlock | None = None- open_wire_idx: int = 0+ blocks: dict[Any, tuple[int, CompatBlock]] = {}next_wire_idx = 0usage: dict[str, Any] | None = Noneresponse_metadata: dict[str, Any] = {}@@ -615,25 +667,29 @@ async def achunks_to_events(yield _build_message_start(msg, message_id)for key, block in _iter_protocol_blocks(msg):- if key != open_key:- if open_block is not None:- yield _finalize_and_build_finish(open_wire_idx, open_block)- open_key = key- open_wire_idx = next_wire_idx+ if key not in blocks:+ wire_idx = next_wire_idxnext_wire_idx += 1- open_block = dict(block)+ blocks[key] = (wire_idx, dict(block))yield ContentBlockStartData(event="content-block-start",- index=open_wire_idx,- content_block=_start_skeleton(block),+ index=wire_idx,+ content=_start_skeleton(block),)else:- open_block = _accumulate(open_block, block)+ wire_idx, existing = blocks[key]+ blocks[key] = (wire_idx, _accumulate(existing, block))if _should_emit_delta(block):+ wire_idx, current = blocks[key]+ is_block_delta = block.get("type") in (+ "tool_call_chunk",+ "server_tool_call_chunk",+ )+ delta_source = current if is_block_delta else blockyield ContentBlockDeltaData(event="content-block-delta",- index=open_wire_idx,- content_block=_to_protocol_block(block),+ index=wire_idx,+ delta=_to_content_delta(delta_source or block),)if msg.usage_metadata:@@ -642,8 +698,8 @@ async def achunks_to_events(if not started:return- if open_block is not None:- yield _finalize_and_build_finish(open_wire_idx, open_block)+ for wire_idx, block in blocks.values():+ yield _finalize_and_build_finish(wire_idx, block)yield _build_message_finish(usage=usage,@@ -682,18 +738,18 @@ def message_to_events(yield ContentBlockStartData(event="content-block-start",index=wire_idx,- content_block=_start_skeleton(block),+ content=_start_skeleton(block),)if _should_emit_delta(block):yield ContentBlockDeltaData(event="content-block-delta",index=wire_idx,- content_block=_to_protocol_block(block),+ delta=_to_content_delta(block),)yield ContentBlockFinishData(event="content-block-finish",index=wire_idx,- content_block=_finalize_block(block),+ content=_finalize_block(block),)yield _build_message_finish(diff --git a/libs/core/langchain_core/language_models/chat_model_stream.py b/libs/core/langchain_core/language_models/chat_model_stream.pyindex 27b200b58b..6b25a66fd2 100644--- a/libs/core/langchain_core/language_models/chat_model_stream.py+++ b/libs/core/langchain_core/language_models/chat_model_stream.py@@ -1,8 +1,8 @@"""Per-message streaming objects for content-block protocol events.`ChatModelStream` is the synchronous variant returned by-`BaseChatModel.stream_v2()`. `AsyncChatModelStream` is the-asynchronous variant returned by `BaseChatModel.astream_v2()`.+`BaseChatModel.stream_events(version="v3")`. `AsyncChatModelStream` is the+asynchronous variant returned by `BaseChatModel.astream_events(version="v3")`.Both expose typed projection properties (`.text`, `.reasoning`,`.tool_calls`, `.usage`, `.output`) that accumulate protocol@@ -24,7 +24,7 @@ from langchain_core.language_models._compat_bridge import finalize_tool_call_chufrom langchain_core.messages import AIMessageif TYPE_CHECKING:- from collections.abc import Awaitable, Callable, Generator, Iterator+ from collections.abc import Awaitable, Callable, Generator, Iterator, Mappingfrom langchain_protocol.protocol import (ContentBlockDeltaData,@@ -65,6 +65,54 @@ def _merge_chunk_into_store(store[idx] = existing+def _merge_block_delta_into_store(+ store: dict[int, dict[str, Any]],+ idx: int,+ fields: dict[str, Any],+) -> None:+ """Shallow-merge a block-delta snapshot into an indexed chunk store."""+ existing = store.get(idx, {})+ for key, value in fields.items():+ if value is not None:+ existing[key] = value+ store[idx] = existing+++def _event_content_block(data: Mapping[str, Any]) -> dict[str, Any] | None:+ """Return start/finish content, tolerating the pre-delta field name."""+ block = data.get("content") or data.get("content_block")+ return block if isinstance(block, dict) else None+++def _legacy_block_to_delta(block: Mapping[str, Any]) -> dict[str, Any]:+ """Convert the old content-block delta shape to an explicit delta."""+ btype = block.get("type")+ if btype == "text":+ return {"type": "text-delta", "text": block.get("text", "")}+ if btype == "reasoning":+ return {+ "type": "reasoning-delta",+ "reasoning": block.get("reasoning", ""),+ }+ if "data" in block:+ delta = {"type": "data-delta", "data": block.get("data", "")}+ if block.get("encoding") == "base64":+ delta["encoding"] = "base64"+ return delta+ return {"type": "legacy-block-delta", "fields": block}+++def _event_delta(data: Mapping[str, Any]) -> dict[str, Any] | None:+ """Return an explicit delta, converting legacy content-block deltas."""+ delta = data.get("delta")+ if isinstance(delta, dict):+ return delta+ block = data.get("content_block")+ if isinstance(block, dict):+ return _legacy_block_to_delta(block)+ return None++def _sweep_chunk_store(store: dict[int, dict[str, Any]],*,@@ -498,9 +546,9 @@ class _ChatModelStreamBase:def set_message_id(self, message_id: str) -> None:"""Assign the stable message identifier once the run starts.- Called by the stream driver (`stream_v2` / `astream_v2`) after- `on_chat_model_start` produces a run id. Not intended for- end-user code.+ Called by the stream driver (`stream_events(version="v3")` /+ `astream_events(version="v3")`) after `on_chat_model_start` produces a run+ id. Not intended for end-user code."""self._message_id = message_id@@ -520,19 +568,21 @@ class _ChatModelStreamBase:Unlike `ChatModelStream.output` (which blocks until the streamfinishes), this never pumps, blocks, or raises. Intended for the- stream driver (`stream_v2` / `astream_v2`) to check whether the- stream produced a message before firing `on_llm_end` callbacks.+ stream driver (`stream_events(version="v3")` and its async+ equivalent) to check whether the stream produced a message before+ firing `on_llm_end` callbacks."""return self._output_message# -- Event ingestion (public) ------------------------------------------- def dispatch(self, event: MessagesData) -> None:+ def dispatch(self, event: Mapping[str, Any]) -> None:"""Route a protocol event to the appropriate internal handler.Public entry point for feeding events into the stream. Called by- the stream driver (`stream_v2` / `astream_v2`'s pump) and by- any observer or test that needs to inject protocol events.+ the stream driver (the `stream_events(version="v3")` pump and its+ async equivalent) and by any observer or test that needs to+ inject protocol events."""self._record_event(event)event_type = event.get("event")@@ -550,25 +600,27 @@ class _ChatModelStreamBase:# -- Internal push API (called by dispatch) ----------------------------- def _record_event(self, event: MessagesData) -> None:+ def _record_event(self, event: Mapping[str, Any]) -> None:"""Append a raw event to the replay buffer."""- self._events.append(event)+ self._events.append(cast("MessagesData", event))def _push_message_start(self, data: MessageStartData) -> None:"""Process a `message-start` event."""self._start_metadata = data.get("metadata")+ message_id = data.get("id")+ if message_id:+ self._message_id = message_iddef _push_content_block_delta(self, data: ContentBlockDeltaData) -> None:"""Process a `content-block-delta` event."""- block = data.get("content_block")- if block is None:+ delta = _event_delta(data)+ if delta is None:return- btype = block.get("type", "")event_idx = data.get("index")+ dtype = delta.get("type", "")- if btype == "text":- text_block = cast("TextContentBlock", block)- delta_text = text_block.get("text", "")+ if dtype == "text-delta":+ delta_text = delta.get("text", "")if delta_text:self._text_acc += delta_textif event_idx is not None:@@ -576,9 +628,8 @@ class _ChatModelStreamBase:self._text_per_block.get(event_idx, "") + delta_text)self._text_proj.push(delta_text)- elif btype == "reasoning":- reasoning_block = cast("ReasoningContentBlock", block)- delta_r = reasoning_block.get("reasoning", "")+ elif dtype == "reasoning-delta":+ delta_r = delta.get("reasoning", "")if delta_r:self._reasoning_acc += delta_rif event_idx is not None:@@ -586,35 +637,94 @@ class _ChatModelStreamBase:self._reasoning_per_block.get(event_idx, "") + delta_r)self._reasoning_proj.push(delta_r)- elif btype == "tool_call_chunk":+ elif dtype == "block-delta":+ fields = delta.get("fields")+ if not isinstance(fields, dict):+ return+ btype = fields.get("type", "")+ if btype == "tool_call_chunk":+ tcc = cast("ToolCallChunk", fields)+ idx = data.get("index")+ if idx is None:+ idx = tcc.get("index", len(self._tool_call_chunks))+ _merge_block_delta_into_store(self._tool_call_chunks, idx, dict(tcc))+ chunk_block: ToolCallChunk = {+ "type": "tool_call_chunk",+ "id": tcc.get("id"),+ "name": tcc.get("name"),+ "args": tcc.get("args"),+ }+ if "index" in tcc:+ chunk_block["index"] = tcc["index"]+ self._tool_calls_proj.push(chunk_block)+ elif btype == "server_tool_call_chunk":+ stcc = cast("ServerToolCallChunk", fields)+ idx = data.get("index")+ if idx is None:+ idx = len(self._server_tool_call_chunks)+ _merge_block_delta_into_store(+ self._server_tool_call_chunks,+ idx,+ dict(stcc),+ )+ elif dtype == "legacy-block-delta":+ fields = delta.get("fields")+ if not isinstance(fields, dict):+ return+ btype = fields.get("type", "")+ if btype == "tool_call_chunk":+ tcc = cast("ToolCallChunk", fields)+ idx = data.get("index")+ if idx is None:+ idx = tcc.get("index", len(self._tool_call_chunks))+ _merge_chunk_into_store(self._tool_call_chunks, idx, dict(tcc))+ legacy_chunk_block: ToolCallChunk = {+ "type": "tool_call_chunk",+ "id": tcc.get("id"),+ "name": tcc.get("name"),+ "args": tcc.get("args"),+ }+ if "index" in tcc:+ legacy_chunk_block["index"] = tcc["index"]+ self._tool_calls_proj.push(legacy_chunk_block)+ elif btype == "server_tool_call_chunk":+ stcc = cast("ServerToolCallChunk", fields)+ idx = data.get("index")+ if idx is None:+ idx = len(self._server_tool_call_chunks)+ _merge_chunk_into_store(+ self._server_tool_call_chunks,+ idx,+ dict(stcc),+ )+ elif dtype == "data-delta":+ # Binary/modal payload deltas are reflected in the final+ # content-block finish event; there is no dedicated projection.+ return+ else:+ # Transitional legacy path for old `content_block` deltas that+ # should not be reachable after `_event_delta` conversion, kept+ # here for custom in-tree test fixtures or third-party emitters.+ block = data.get("content_block")+ if not isinstance(block, dict):+ return+ btype = block.get("type", "")+ if btype != "tool_call_chunk":+ returntcc = cast("ToolCallChunk", block)- # The protocol puts the block index on the event- # (`ContentBlockDeltaData`), not inside `content_block`.- # Fall back to `content_block.index` for providers that echo- # it there.idx = data.get("index")if idx is None:idx = tcc.get("index", len(self._tool_call_chunks))_merge_chunk_into_store(self._tool_call_chunks, idx, dict(tcc))- chunk_block: ToolCallChunk = {+ fallback_chunk_block: ToolCallChunk = {"type": "tool_call_chunk","id": tcc.get("id"),"name": tcc.get("name"),"args": tcc.get("args"),}if "index" in tcc:- chunk_block["index"] = tcc["index"]- self._tool_calls_proj.push(chunk_block)- elif btype == "server_tool_call_chunk":- stcc = cast("ServerToolCallChunk", block)- idx = data.get("index")- if idx is None:- idx = len(self._server_tool_call_chunks)- _merge_chunk_into_store(- self._server_tool_call_chunks,- idx,- dict(stcc),- )+ fallback_chunk_block["index"] = tcc["index"]+ self._tool_calls_proj.push(fallback_chunk_block)def _resolve_block_text(self, idx: int | None, full_text: str) -> str:"""Return authoritative text for a single text block at `idx`.@@ -681,7 +791,7 @@ class _ChatModelStreamBase:def _push_content_block_finish(self, data: ContentBlockFinishData) -> None:"""Process a `content-block-finish` event."""- block = data.get("content_block")+ block = _event_content_block(data)if block is None:returnbtype = block.get("type", "")@@ -764,7 +874,7 @@ class _ChatModelStreamBase:):if btype == "server_tool_call" and idx is not None:self._server_tool_call_chunks.pop(idx, None)- finalized = block+ finalized = cast("FinalizedContentBlock", block)if finalized is not None and idx is not None:# Backfill the wire index onto the finalized block when the@@ -785,7 +895,7 @@ class _ChatModelStreamBase:"""Process a `message-finish` event."""self._done = Trueself._usage_value = data.get("usage")- self._finish_metadata = data.get("metadata")+ self._finish_metadata = cast("dict[str, Any] | None", data.get("metadata"))# Finalize any unswept chunks — both client- and server-side._sweep_chunk_store(@@ -829,8 +939,8 @@ class _ChatModelStreamBase:def fail(self, error: BaseException) -> None:"""Mark the stream as errored and propagate to all projections.- Public API — called by the stream driver (`stream_v2` /- `astream_v2`) when the underlying producer raises, by+ Public API — called by the stream driver (`stream_events(version="v3")` /+ `astream_events(version="v3")`) when the underlying producer raises, by`dispatch` when an `error` protocol event arrives, and bycancellation paths."""@@ -871,8 +981,9 @@ class _ChatModelStreamBase:response_metadata["model_name"] = self._start_metadata["model"]if self._finish_metadata:response_metadata.update(self._finish_metadata)- # Pin `output_version` last: `stream_v2` always assembles content as v1- # protocol blocks, regardless of the provider's configured output format.+ # Pin `output_version` last: `stream_events(version="v3")` always+ # assembles content as v1 protocol blocks, regardless of the+ # provider's configured output format.# A provider-supplied `output_version` in finish metadata (e.g.# `"responses/v1"` from `ChatOpenAI(use_responses_api=True, ...)`) would# otherwise cause `AIMessage.content_blocks` to re-run the wrong@@ -918,7 +1029,7 @@ class _ChatModelStreamBase:class ChatModelStream(_ChatModelStreamBase):"""Synchronous per-message streaming object for a single LLM response.- Returned by `BaseChatModel.stream_v2()`. Content-block protocol+ Returned by `BaseChatModel.stream_events(version="v3")`. Content-block protocolevents are fed into this object and accumulated into typed projections.Projections (always return the same cached object):@@ -973,7 +1084,7 @@ class ChatModelStream(_ChatModelStreamBase):"""Bind a pump for standalone streaming.Delegates to `set_request_more`. Used by- `BaseChatModel.stream_v2()`.+ `BaseChatModel.stream_events(version="v3")`."""self.set_request_more(pump_one)@@ -1074,7 +1185,7 @@ class ChatModelStream(_ChatModelStreamBase):class AsyncChatModelStream(_ChatModelStreamBase):"""Asynchronous per-message streaming object for a single LLM response.- Returned by `BaseChatModel.astream_v2()`. Content-block events+ Returned by `BaseChatModel.astream_events(version="v3")`. Content-block eventsare fed into this object by a background producer task.Projections:@@ -1120,7 +1231,7 @@ class AsyncChatModelStream(_ChatModelStreamBase):# Teardown callback invoked by `aclose()` only when the producer# task was cancelled before its body ran (so the normal# `_produce` CancelledError handler — which fires- # `on_llm_error` — never executed). Set by `astream_v2`.+ # `on_llm_error` — never executed). Set by `astream_events(version="v3")`.self._on_aclose_fail: Callable[[BaseException], Awaitable[None]] | None = None# -- Pump/pull wiring (async) ------------------------------------------@@ -1261,7 +1372,7 @@ class AsyncChatModelStream(_ChatModelStreamBase):task.remove_done_callback(_link)# If the task was cancelled before `_produce` ran (e.g.- # `astream_v2()` immediately followed by `aclose()`), the stream+ # `astream_events(version="v3")` immediately followed by `aclose()`), the stream# never reached `_produce`'s CancelledError handler — its# projections are still pending and no end-of-lifecycle callback# has fired. Resolve both here so callers of `await stream.output`@@ -1290,10 +1401,10 @@ class AsyncChatModelStream(_ChatModelStreamBase):# -- Internal API (extend base to drive async projections) -------------- def _record_event(self, event: MessagesData) -> None:+ def _record_event(self, event: Mapping[str, Any]) -> None:"""Record event and push to async event replay projection."""super()._record_event(event)- self._events_proj.push(event)+ self._events_proj.push(cast("MessagesData", event))def _finish(self, data: MessageFinishData) -> None:"""Finish base projections and async-only projections."""diff --git a/libs/core/langchain_core/language_models/chat_models.py b/libs/core/langchain_core/language_models/chat_models.pyindex 2f5df7a3e4..ea4194e69c 100644--- a/libs/core/langchain_core/language_models/chat_models.py+++ b/libs/core/langchain_core/language_models/chat_models.py@@ -10,7 +10,7 @@ from abc import ABC, abstractmethodfrom collections.abc import AsyncIterator, Callable, Iterator, Sequencefrom functools import cached_propertyfrom operator import itemgetter-from typing import TYPE_CHECKING, Any, Literal, cast+from typing import TYPE_CHECKING, Any, Literal, cast, overloadfrom langchain_protocol.protocol import MessageFinishDatafrom pydantic import BaseModel, ConfigDict, Field, model_validator@@ -79,7 +79,7 @@ from langchain_core.outputs import (from langchain_core.outputs.chat_generation import merge_chat_generation_chunksfrom langchain_core.prompt_values import ChatPromptValue, PromptValue, StringPromptValuefrom langchain_core.rate_limiters import BaseRateLimiter-from langchain_core.runnables import RunnableMap, RunnablePassthrough+from langchain_core.runnables import RunnableBinding, RunnableMap, RunnablePassthroughfrom langchain_core.runnables.config import ensure_config, run_in_executorfrom langchain_core.tracers._streaming import (_StreamingCallbackHandler,@@ -95,11 +95,13 @@ from langchain_core.utils.utils import LC_ID_PREFIX, from_envif TYPE_CHECKING:import builtinsimport uuid+ from collections.abc import Awaitablefrom langchain_protocol.protocol import MessagesDatafrom langchain_core.output_parsers.base import OutputParserLikefrom langchain_core.runnables import Runnable, RunnableConfig+ from langchain_core.runnables.schema import StreamEventfrom langchain_core.tools import BaseTool@@ -510,7 +512,7 @@ class BaseChatModel(BaseLanguageModel[AIMessage], ABC):"""Return whether streaming is hard-disabled for this call.Shared opt-outs honored by both `_should_stream` and- `_should_stream_v2` — these override any affirmative trigger+ `_should_use_protocol_streaming` — these override any affirmative trigger(attached handler, `stream=True`, etc.):- `self.disable_streaming is True`@@ -568,7 +570,7 @@ class BaseChatModel(BaseLanguageModel[AIMessage], ABC):handlers = run_manager.handlers if run_manager else []return any(isinstance(h, _StreamingCallbackHandler) for h in handlers)- def _should_stream_v2(+ def _should_use_protocol_streaming(self,*,async_api: bool,@@ -637,8 +639,8 @@ class BaseChatModel(BaseLanguageModel[AIMessage], ABC):) -> Iterator[MessagesData]:"""Drive the v2 event generator with per-event dispatch.- Shared between `stream_v2`'s pump and the invoke-time v2 branch- in `_generate_with_cache`. Picks the native+ Shared between the `stream_events(version="v3")` pump and the+ invoke-time v2 branch in `_generate_with_cache`. Picks the native`_stream_chat_model_events` hook when the subclass provides one,else bridges `_stream` chunks via `chunks_to_events`. Each eventis dispatched into `stream` and fired as `on_stream_event` on@@ -969,10 +971,10 @@ class BaseChatModel(BaseLanguageModel[AIMessage], ABC):LLMResult(generations=[[generation]]),)- # --- stream_v2 / astream_v2 ---+ # --- stream_events v3 ---@beta()- def stream_v2(+ def _chat_model_stream_v3(self,input: LanguageModelInput,config: RunnableConfig | None = None,@@ -980,43 +982,19 @@ class BaseChatModel(BaseLanguageModel[AIMessage], ABC):stop: list[str] | None = None,**kwargs: Any,) -> ChatModelStream:- """Stream content-block lifecycle events for a single model call.+ """Internal v3 sync streaming implementation.- Returns a `ChatModelStream` with typed projections- (`.text`, `.reasoning`, `.tool_calls`, `.output`).-- !!! warning-- This API is experimental and may change.-- !!! note "Always produces v1-shaped content"-- `ChatModelStream.output.content` is always a list of v1- content blocks (text / reasoning / tool_call / image / …),- regardless of the model's `output_version` attribute. The- setting only affects the legacy `stream()` / `astream()` /- `invoke()` paths. If you're mixing `stream_v2` with those- paths in the same pipeline and need a consistent output- shape across them, set `output_version="v1"` on the model.-- Args:- input: The model input.- config: Optional runnable config.- stop: Optional list of stop words.- **kwargs: Additional keyword arguments passed to the model.-- Returns:- A `ChatModelStream` with typed projections.+ Public entry point: `stream_events(version='v3')`."""config = ensure_config(config)messages = self._convert_input(input).to_messages()input_messages = _normalize_messages(messages)# Strip tracing-only kwargs before forwarding to `_stream` — matches- # `stream()` / `astream()`. Provider clients reject unknown kwargs, so- # `.with_structured_output().stream_v2(...)` and any other binding that- # carries `ls_structured_output_format` / `structured_output_format`- # would raise without this pop.+ # `stream()` / `astream()`. Provider clients reject unknown kwargs,+ # so `.with_structured_output().stream_events(version="v3", ...)`+ # and any other binding that carries `ls_structured_output_format`+ # / `structured_output_format` would raise without this pop.ls_structured_output_format = kwargs.pop("ls_structured_output_format", None) or kwargs.pop("structured_output_format", None)@@ -1133,7 +1111,7 @@ class BaseChatModel(BaseLanguageModel[AIMessage], ABC):return stream@beta()- async def astream_v2(+ async def _achat_model_stream_v3(self,input: LanguageModelInput,config: RunnableConfig | None = None,@@ -1141,36 +1119,16 @@ class BaseChatModel(BaseLanguageModel[AIMessage], ABC):stop: list[str] | None = None,**kwargs: Any,) -> AsyncChatModelStream:- """Async variant of `stream_v2`.-- Returns an `AsyncChatModelStream` whose projections are- async-iterable and awaitable.-- !!! warning-- This API is experimental and may change.+ """Internal v3 async streaming implementation.- !!! note "Always produces v1-shaped content"-- The assembled message's content is always a list of v1- content blocks, regardless of the model's `output_version`- attribute — see `stream_v2` for the full rationale.-- Args:- input: The model input.- config: Optional runnable config.- stop: Optional list of stop words.- **kwargs: Additional keyword arguments passed to the model.-- Returns:- An `AsyncChatModelStream` with typed projections.+ Public entry point: `astream_events(version='v3')`."""config = ensure_config(config)messages = self._convert_input(input).to_messages()input_messages = _normalize_messages(messages)- # Strip tracing-only kwargs before forwarding — see `stream_v2` for the- # full rationale.+ # Strip tracing-only kwargs before forwarding — see the sync v3+ # implementation for the full rationale.ls_structured_output_format = kwargs.pop("ls_structured_output_format", None) or kwargs.pop("structured_output_format", None)@@ -1299,6 +1257,118 @@ class BaseChatModel(BaseLanguageModel[AIMessage], ABC):stream._on_aclose_fail = _on_aclose_fail # noqa: SLF001return stream+ @overload # type: ignore[override]+ def stream_events(+ self,+ input: LanguageModelInput,+ config: RunnableConfig | None = None,+ *,+ version: Literal["v1", "v2"] = "v2",+ **kwargs: Any,+ ) -> Iterator[StreamEvent]: ...++ @overload+ def stream_events(+ self,+ input: LanguageModelInput,+ config: RunnableConfig | None = None,+ *,+ version: Literal["v3"],+ stop: list[str] | None = None,+ **kwargs: Any,+ ) -> ChatModelStream: ...++ def stream_events(+ self,+ input: LanguageModelInput,+ config: RunnableConfig | None = None,+ *,+ version: Literal["v1", "v2", "v3"] = "v2",+ stop: list[str] | None = None,+ **kwargs: Any,+ ) -> Iterator[StreamEvent] | ChatModelStream:+ """Stream events from this chat model.++ For `version="v1"` / `"v2"`, yields `StreamEvent` dicts (see+ `Runnable.stream_events`). For `version="v3"`, returns a+ `ChatModelStream` exposing typed projections (`.text`,+ `.reasoning`, `.tool_calls`, `.output`).++ !!! warning "Beta"++ `version="v3"` is in beta. The protocol shape, return type,+ and surface area may change in future releases. Calling it+ emits a `LangChainBetaWarning` at runtime.++ !!! note "v3 always produces v1-shaped content"++ `ChatModelStream.output.content` is always a list of v1+ content blocks (text / reasoning / tool_call / image / …),+ regardless of the model's `output_version` attribute. The+ setting only affects the legacy `stream()` / `astream()` /+ `invoke()` paths. If you're mixing+ `stream_events(version="v3")` with those paths in the same+ pipeline and need a consistent output shape across them,+ set `output_version="v1"` on the model.++ Args:+ input: The model input.+ config: Optional runnable config.+ version: Streaming-event schema version. `"v3"` selects the+ content-block-centric streaming protocol.+ stop: Optional stop sequences. Only used for `version="v3"`;+ ignored otherwise.+ **kwargs: Additional keyword arguments. For `version="v3"`,+ forwarded to the model.++ Returns:+ For `version="v3"`, a `ChatModelStream` with typed+ projections. Otherwise an `Iterator[StreamEvent]`.+ """+ if version == "v3":+ return self._chat_model_stream_v3(input, config, stop=stop, **kwargs)+ return super().stream_events(+ input, config, version=version, stop=stop, **kwargs+ )++ @overload+ def astream_events(+ self,+ input: LanguageModelInput,+ config: RunnableConfig | None = None,+ *,+ version: Literal["v1", "v2"] = "v2",+ **kwargs: Any,+ ) -> AsyncIterator[StreamEvent]: ...++ @overload+ def astream_events(+ self,+ input: LanguageModelInput,+ config: RunnableConfig | None = None,+ *,+ version: Literal["v3"],+ stop: list[str] | None = None,+ **kwargs: Any,+ ) -> Awaitable[AsyncChatModelStream]: ...++ def astream_events(+ self,+ input: LanguageModelInput,+ config: RunnableConfig | None = None,+ *,+ version: Literal["v1", "v2", "v3"] = "v2",+ stop: list[str] | None = None,+ **kwargs: Any,+ ) -> AsyncIterator[StreamEvent] | Awaitable[AsyncChatModelStream]:+ """Async variant of `stream_events`. See `stream_events` for full docs."""+ if version == "v3":+ return self._achat_model_stream_v3(input, config, stop=stop, **kwargs)+ # v1/v2: forward to Runnable.astream_events (async generator).+ return super().astream_events(+ input, config, version=version, stop=stop, **kwargs+ )+# --- Custom methods ---def _combine_llm_outputs(self, _llm_outputs: list[dict | None], /) -> dict:@@ -1352,12 +1422,13 @@ class BaseChatModel(BaseLanguageModel[AIMessage], ABC):) -> None:"""Replay cached messages as v2 events when a v2 handler is attached.- A warm cache must produce the same `on_stream_event` stream as a cold- call so LangGraph-style consumers do not observe behavior that depends- on cache state. Gated by `_should_stream_v2` so a `disable_streaming`- config that suppresses v2 on cold calls also suppresses it here.+ A warm cache must produce the same `on_stream_event` stream as a+ cold call so LangGraph-style consumers do not observe behavior+ that depends on cache state. Gated by+ `_should_use_protocol_streaming` so a `disable_streaming` config+ that suppresses v2 on cold calls also suppresses it here."""- if run_manager is None or not self._should_stream_v2(+ if run_manager is None or not self._should_use_protocol_streaming(async_api=False, run_manager=run_manager, **kwargs):return@@ -1377,7 +1448,7 @@ class BaseChatModel(BaseLanguageModel[AIMessage], ABC):**kwargs: Any,) -> None:"""Async counterpart to `_replay_v2_events_for_cache_hit`."""- if run_manager is None or not self._should_stream_v2(+ if run_manager is None or not self._should_use_protocol_streaming(async_api=True, run_manager=run_manager, **kwargs):return@@ -1814,7 +1885,7 @@ class BaseChatModel(BaseLanguageModel[AIMessage], ABC):# (native or `_stream` compat bridge) through the shared helper so# `on_stream_event` fires per event, then returns a normal `ChatResult`# so caching / `on_llm_end` stay on the existing generate path.- if self._should_stream_v2(+ if self._should_use_protocol_streaming(async_api=False,run_manager=run_manager,**kwargs,@@ -1971,7 +2042,7 @@ class BaseChatModel(BaseLanguageModel[AIMessage], ABC):await self.rate_limiter.aacquire(blocking=True)# v2 streaming: see sync counterpart in `_generate_with_cache`.- if self._should_stream_v2(+ if self._should_use_protocol_streaming(async_api=True,run_manager=run_manager,**kwargs,@@ -2215,6 +2286,18 @@ class BaseChatModel(BaseLanguageModel[AIMessage], ABC):starter_dict["_type"] = self._llm_typereturn starter_dict+ @override+ def bind(self, **kwargs: Any) -> _ChatModelBinding:+ """Bind kwargs to this chat model, returning a typed `_ChatModelBinding`.++ Overrides `Runnable.bind` so the result preserves chat-model-specific+ `stream_events` / `astream_events` overloads. Without this override,+ `model.bind(...).stream_events(version="v3")` would type as+ `Iterator[Any]` and `await model.bind(...).astream_events(version="v3")`+ as `Any`, forcing callers to `cast`.+ """+ return _ChatModelBinding(bound=self, kwargs=kwargs, config={})+def bind_tools(self,tools: Sequence[builtins.dict[str, Any] | type | Callable | BaseTool],@@ -2418,6 +2501,95 @@ class BaseChatModel(BaseLanguageModel[AIMessage], ABC):return llm | output_parser+class _ChatModelBinding(RunnableBinding[LanguageModelInput, AIMessage]): # type: ignore[no-redef]+ """`RunnableBinding` that preserves chat-model-typed v3 overloads.++ Returned by `BaseChatModel.bind` so that callers of the bound runnable's+ `stream_events(version="v3")` / `astream_events(version="v3")` get the+ typed `ChatModelStream` / `AsyncChatModelStream` back without needing+ `cast`. At runtime this is a plain `RunnableBinding`; the subclass+ exists purely to give the type checker a more specific surface.++ The chat-model narrowing is preserved across further `bind` /+ `with_config` calls because `RunnableBinding.bind` constructs its+ result via `self.__class__(...)`.+ """++ @classmethod+ @override+ def lc_id(cls) -> list[str]:+ """Serialize as `RunnableBinding`.++ At runtime this class is behaviorally identical to `RunnableBinding`;+ keeping the serialized id stable means existing snapshots and the+ load mapping continue to work without registering a new entry.+ """+ return [*cls.get_lc_namespace(), "RunnableBinding"]++ @overload # type: ignore[override]+ def stream_events(+ self,+ input: LanguageModelInput,+ config: RunnableConfig | None = None,+ *,+ version: Literal["v1", "v2"] = "v2",+ **kwargs: Any,+ ) -> Iterator[StreamEvent]: ...++ @overload+ def stream_events(+ self,+ input: LanguageModelInput,+ config: RunnableConfig | None = None,+ *,+ version: Literal["v3"],+ stop: list[str] | None = None,+ **kwargs: Any,+ ) -> ChatModelStream: ...++ def stream_events(+ self,+ input: LanguageModelInput,+ config: RunnableConfig | None = None,+ *,+ version: Literal["v1", "v2", "v3"] = "v2",+ **kwargs: Any,+ ) -> Iterator[StreamEvent] | ChatModelStream:+ return super().stream_events(input, config, version=version, **kwargs)++ @overload+ def astream_events(+ self,+ input: LanguageModelInput,+ config: RunnableConfig | None = None,+ *,+ version: Literal["v1", "v2"] = "v2",+ **kwargs: Any,+ ) -> AsyncIterator[StreamEvent]: ...++ @overload+ def astream_events(+ self,+ input: LanguageModelInput,+ config: RunnableConfig | None = None,+ *,+ version: Literal["v3"],+ stop: list[str] | None = None,+ **kwargs: Any,+ ) -> Awaitable[AsyncChatModelStream]: ...++ def astream_events(+ self,+ input: LanguageModelInput,+ config: RunnableConfig | None = None,+ **kwargs: Any,+ ) -> AsyncIterator[StreamEvent] | Awaitable[AsyncChatModelStream]:+ return cast(+ "AsyncIterator[StreamEvent] | Awaitable[AsyncChatModelStream]",+ super().astream_events(input, config, **kwargs),+ )++class SimpleChatModel(BaseChatModel):"""Simplified implementation for a chat model to inherit from.diff --git a/libs/core/langchain_core/runnables/base.py b/libs/core/langchain_core/runnables/base.pyindex 6aa33c919c..3a9b0cdcfc 100644--- a/libs/core/langchain_core/runnables/base.py+++ b/libs/core/langchain_core/runnables/base.py@@ -104,10 +104,6 @@ if TYPE_CHECKING:AsyncCallbackManagerForChainRun,CallbackManagerForChainRun,)- from langchain_core.language_models.chat_model_stream import (- AsyncChatModelStream,- ChatModelStream,- )from langchain_core.prompts.base import BasePromptTemplatefrom langchain_core.runnables.fallbacks import (RunnableWithFallbacks as RunnableWithFallbacksT,@@ -1174,46 +1170,6 @@ class Runnable(ABC, Generic[Input, Output]):"""yield await self.ainvoke(input, config, **kwargs)- def stream_v2(- self,- input: Input,- config: RunnableConfig | None = None,- **kwargs: Any | None,- ) -> ChatModelStream:- """Stream content-block lifecycle events (v2 protocol).-- Implemented by `BaseChatModel` (and forwarded by `RunnableBinding`).- Generic `Runnable`s don't participate in the v2 event protocol —- use `.stream()` instead.-- Raises:- NotImplementedError: Always, on the base `Runnable` class.- """- msg = (- f"{type(self).__name__} does not implement `stream_v2`. "- "`stream_v2` is only implemented by chat models; use `.stream()` "- "for generic Runnables."- )- raise NotImplementedError(msg)-- async def astream_v2(- self,- input: Input,- config: RunnableConfig | None = None,- **kwargs: Any | None,- ) -> AsyncChatModelStream:- """Async variant of `stream_v2`. See that method.-- Raises:- NotImplementedError: Always, on the base `Runnable` class.- """- msg = (- f"{type(self).__name__} does not implement `astream_v2`. "- "`astream_v2` is only implemented by chat models; use `.astream()` "- "for generic Runnables."- )- raise NotImplementedError(msg)-@overloaddef astream_log(self,@@ -1320,7 +1276,8 @@ class Runnable(ABC, Generic[Input, Output]):):yield item- async def astream_events(+ @overload+ def astream_events(self,input: Any,config: RunnableConfig | None = None,@@ -1333,7 +1290,32 @@ class Runnable(ABC, Generic[Input, Output]):exclude_types: Sequence[str] | None = None,exclude_tags: Sequence[str] | None = None,**kwargs: Any,- ) -> AsyncIterator[StreamEvent]:+ ) -> AsyncIterator[StreamEvent]: ...++ @overload+ def astream_events(+ self,+ input: Any,+ config: RunnableConfig | None = None,+ *,+ version: Literal["v3"],+ **kwargs: Any,+ ) -> Awaitable[Any]: ...++ def astream_events(+ self,+ input: Any,+ config: RunnableConfig | None = None,+ *,+ version: Literal["v1", "v2", "v3"] = "v2",+ include_names: Sequence[str] | None = None,+ include_types: Sequence[str] | None = None,+ include_tags: Sequence[str] | None = None,+ exclude_names: Sequence[str] | None = None,+ exclude_types: Sequence[str] | None = None,+ exclude_tags: Sequence[str] | None = None,+ **kwargs: Any,+ ) -> AsyncIterator[StreamEvent] | Awaitable[Any]:"""Generate a stream of events.Use to create an iterator over `StreamEvent` that provide real-time information@@ -1503,15 +1485,23 @@ class Runnable(ABC, Generic[Input, Output]):Args:input: The input to the `Runnable`.config: The config to use for the `Runnable`.- version: The version of the schema to use, either `'v2'` or `'v1'`.-- Users should use `'v2'`.-- `'v1'` is for backwards compatibility and will be deprecated- in `0.4.0`.-- No default will be assigned until the API is stabilized.- custom events will only be surfaced in `'v2'`.+ version: The version of the schema to use. One of `'v1'`, `'v2'`,+ or `'v3'`.++ Most callers should use `'v2'` (the default), which yields+ `StreamEvent` dicts and supports custom events.++ `'v3'` selects the typed, content-block-centric streaming+ protocol and is only supported on `Runnable` subclasses that+ implement it (currently `BaseChatModel` and+ `langgraph.CompiledGraph`); on a generic `Runnable` it raises+ `NotImplementedError`. The `'v3'` API is in beta and may+ change. See the subclass override (e.g.+ `BaseChatModel.astream_events`) for the v3 return shape.++ `'v1'` is retained for backwards compatibility and will be+ deprecated in `0.4.0`. Custom events are only surfaced in+ `'v2'` / `'v3'`.include_names: Only include events from `Runnable` objects with matching names.include_types: Only include events from `Runnable` objects with matching types.include_tags: Only include events from `Runnable` objects with matching tags.@@ -1520,16 +1510,59 @@ class Runnable(ABC, Generic[Input, Output]):exclude_tags: Exclude events from `Runnable` objects with matching tags.**kwargs: Additional keyword arguments to pass to the `Runnable`.- These will be passed to `astream_log` as this implementation- of `astream_events` is built on top of `astream_log`.-Yields:An async stream of `StreamEvent`.Raises:- NotImplementedError: If the version is not `'v1'` or `'v2'`.+ NotImplementedError: If the version is not `'v1'`, `'v2'`, or `'v3'`, or+ if `'v3'` is requested on a `Runnable` that does not implement the v3+ streaming protocol.""" # noqa: E501+ if version == "v3":+ return self._astream_events_v3_unsupported()+ return self._astream_events_v1_v2(+ input,+ config=config,+ version=version,+ include_names=include_names,+ include_types=include_types,+ include_tags=include_tags,+ exclude_names=exclude_names,+ exclude_types=exclude_types,+ exclude_tags=exclude_tags,+ **kwargs,+ )++ async def _astream_events_v3_unsupported(self) -> Any:+ """Coroutine that raises when v3 isn't implemented on this Runnable.++ Lets the public `astream_events(version="v3")` return an awaitable+ whose error surfaces on `await`, matching the v3 contract on+ subclasses that do implement the protocol.+ """+ msg = (+ "astream_events(version='v3') is only supported on Runnable "+ "subclasses that implement the v3 streaming protocol "+ "(BaseChatModel, CompiledGraph). "+ f"Got: {type(self).__name__}"+ )+ raise NotImplementedError(msg)++ async def _astream_events_v1_v2(+ self,+ input: Any,+ config: RunnableConfig | None = None,+ *,+ version: Literal["v1", "v2"] = "v2",+ include_names: Sequence[str] | None = None,+ include_types: Sequence[str] | None = None,+ include_tags: Sequence[str] | None = None,+ exclude_names: Sequence[str] | None = None,+ exclude_types: Sequence[str] | None = None,+ exclude_tags: Sequence[str] | None = None,+ **kwargs: Any,+ ) -> AsyncIterator[StreamEvent]:if version == "v2":event_stream = _astream_events_implementation_v2(self,@@ -1567,13 +1600,100 @@ class Runnable(ABC, Generic[Input, Output]):**kwargs,)else:- msg = 'Only versions "v1" and "v2" of the schema is currently supported.'+ msg = f"Unsupported version: {version!r}. Expected 'v1', 'v2', or 'v3'."raise NotImplementedError(msg)async with aclosing(event_stream):async for event in event_stream:yield event+ @overload+ def stream_events(+ self,+ input: Any,+ config: RunnableConfig | None = None,+ *,+ version: Literal["v1", "v2"] = "v2",+ include_names: Sequence[str] | None = None,+ include_types: Sequence[str] | None = None,+ include_tags: Sequence[str] | None = None,+ exclude_names: Sequence[str] | None = None,+ exclude_types: Sequence[str] | None = None,+ exclude_tags: Sequence[str] | None = None,+ **kwargs: Any,+ ) -> Iterator[StreamEvent]: ...++ @overload+ def stream_events(+ self,+ input: Any,+ config: RunnableConfig | None = None,+ *,+ version: Literal["v3"],+ **kwargs: Any,+ ) -> Iterator[Any]: ...++ def stream_events(+ self,+ input: Any,+ config: RunnableConfig | None = None,+ *,+ version: Literal["v1", "v2", "v3"] = "v2",+ include_names: Sequence[str] | None = None,+ include_types: Sequence[str] | None = None,+ include_tags: Sequence[str] | None = None,+ exclude_names: Sequence[str] | None = None,+ exclude_types: Sequence[str] | None = None,+ exclude_tags: Sequence[str] | None = None,+ **kwargs: Any,+ ) -> Iterator[StreamEvent] | Iterator[Any]:+ """Generate a stream of events synchronously.++ Synchronous counterpart to `astream_events`. For `version='v3'`, subclasses+ that implement the v3 streaming protocol (`BaseChatModel`, `CompiledGraph`)+ override this method. All other versions and base-class calls raise+ `NotImplementedError`.++ Args:+ input: The input to the `Runnable`.+ config: The config to use for the `Runnable`.+ version: The version of the schema to use. `'v3'` requires a subclass+ that implements the v3 streaming protocol. `'v1'` and `'v2'` are not+ supported on the sync path.+ include_names: Only include events from `Runnable` objects with matching+ names.+ include_types: Only include events from `Runnable` objects with matching+ types.+ include_tags: Only include events from `Runnable` objects with matching+ tags.+ exclude_names: Exclude events from `Runnable` objects with matching names.+ exclude_types: Exclude events from `Runnable` objects with matching types.+ exclude_tags: Exclude events from `Runnable` objects with matching tags.+ **kwargs: Additional keyword arguments to pass to the `Runnable`.++ Raises:+ NotImplementedError: Always. Subclasses override this method for supported+ versions.++ """+ # Base impl always raises; consume args so they don't trip ARG002.+ del input, config, include_names, include_types, include_tags+ del exclude_names, exclude_types, exclude_tags, kwargs+ if version == "v3":+ msg = (+ "stream_events(version='v3') is only supported on Runnable subclasses "+ "that implement the v3 streaming protocol "+ "(BaseChatModel, CompiledGraph). "+ f"Got: {type(self).__name__}"+ )+ raise NotImplementedError(msg)+ msg = (+ f"stream_events(version={version!r}) is not supported. "+ "Use astream_events() for v1/v2, or stream_events(version='v3') "+ "on a supported subclass."+ )+ raise NotImplementedError(msg)+def transform(self,input: Iterator[Input],@@ -5453,19 +5573,27 @@ class RunnableEachBase(RunnableSerializable[list[Input], list[Output]]):return await self._acall_with_config(self._ainvoke, input, config, **kwargs)@override- async def astream_events(+ def astream_events( # type: ignore[override]self,input: Input,config: RunnableConfig | None = None,+ *,+ version: Literal["v1", "v2", "v3"] = "v2",**kwargs: Any | None,- ) -> AsyncIterator[StreamEvent]:- def _error_stream_event(message: str) -> StreamEvent:- raise NotImplementedError(message)+ ) -> AsyncIterator[StreamEvent] | Awaitable[Any]:+ del input, config, kwargs+ if version == "v3":+ return self._astream_events_unsupported_v3()+ return self._astream_events_unsupported_v1_v2()++ async def _astream_events_unsupported_v3(self) -> Any:+ msg = "RunnableEach does not support astream_events yet."+ raise NotImplementedError(msg)- for _ in range(1):- yield _error_stream_event(- "RunnableEach does not support astream_events yet."- )+ async def _astream_events_unsupported_v1_v2(self) -> AsyncIterator[StreamEvent]:+ msg = "RunnableEach does not support astream_events yet."+ raise NotImplementedError(msg)+ yield # makes this an async generator (never reached)class RunnableEach(RunnableEachBase[Input, Output]):@@ -5947,54 +6075,144 @@ class RunnableBindingBase(RunnableSerializable[Input, Output]): # type: ignore[):yield item- @override- def stream_v2(+ @overload+ def stream_events(self,input: Input,config: RunnableConfig | None = None,- **kwargs: Any | None,- ) -> ChatModelStream:- """Forward `stream_v2` to the bound runnable with bound kwargs merged.+ *,+ version: Literal["v1", "v2"] = "v2",+ **kwargs: Any,+ ) -> Iterator[StreamEvent]: ...++ @overload+ def stream_events(+ self,+ input: Input,+ config: RunnableConfig | None = None,+ *,+ version: Literal["v3"],+ **kwargs: Any,+ ) -> Any: ...++ def stream_events(+ self,+ input: Input,+ config: RunnableConfig | None = None,+ *,+ version: Literal["v1", "v2", "v3"] = "v2",+ **kwargs: Any,+ ) -> Iterator[StreamEvent] | Any:+ """Forward `stream_events` to the bound runnable with bound kwargs merged.- Chat-model-specific: the bound runnable must implement `stream_v2`- (see `BaseChatModel`). Without this override, `__getattr__` would- forward the call but drop `self.kwargs` — losing tools bound via- `bind_tools`, `stop` sequences, etc.+ For `version="v3"`, the bound runnable's typed stream object (e.g.+ `ChatModelStream`) is returned. For `version="v1"` / `"v2"`, dispatches+ to the base `Runnable.stream_events`.++ Without this override, `__getattr__` would drop `self.kwargs` — losing+ tools bound via `bind_tools`, `stop` sequences, etc."""- return self.bound.stream_v2(+ # Probe `version` from the merged view so `bind(version="v3")` routes+ # correctly even when the caller doesn't repeat `version` at the call+ # site, and strip it before forwarding so it isn't passed twice.+ merged_kwargs = {**self.kwargs, **kwargs}+ version = merged_kwargs.get("version", version)+ merged_without_version = {+ k: v for k, v in merged_kwargs.items() if k != "version"+ }+ if version == "v3":+ return self.bound.stream_events(+ input,+ self._merge_configs(config),+ version="v3",+ **merged_without_version,+ )+ return super().stream_events(input,self._merge_configs(config),- **{**self.kwargs, **kwargs},+ version=version,+ **merged_without_version,)- @override- async def astream_v2(+ async def _astream_events_v3(self,input: Input,config: RunnableConfig | None = None,- **kwargs: Any | None,- ) -> AsyncChatModelStream:- """Forward `astream_v2` to the bound runnable with bound kwargs merged.+ **kwargs: Any,+ ) -> Any:+ """Return the v3 async stream object from the bound runnable.++ Returns an awaitable (an `async def` coroutine, not an async+ generator) so callers can `await` it to obtain the typed stream+ (e.g. `AsyncChatModelStream`) directly — Python does not allow+ `return <value>` inside an async generator.- Async variant of `stream_v2`. See that method for the full rationale.+ The caller is responsible for merging `self.kwargs` and stripping+ `version`; this method passes `version="v3"` explicitly and would+ raise on a duplicate keyword."""- return await self.bound.astream_v2(+ return await self.bound.astream_events(input,self._merge_configs(config),- **{**self.kwargs, **kwargs},+ version="v3",+ **kwargs,)+ @overload+ def astream_events(+ self,+ input: Input,+ config: RunnableConfig | None = None,+ *,+ version: Literal["v1", "v2"] = "v2",+ **kwargs: Any,+ ) -> AsyncIterator[StreamEvent]: ...++ @overload+ def astream_events(+ self,+ input: Input,+ config: RunnableConfig | None = None,+ *,+ version: Literal["v3"],+ **kwargs: Any,+ ) -> Awaitable[Any]: ...+@override- async def astream_events(+ def astream_events(self,input: Input,config: RunnableConfig | None = None,**kwargs: Any | None,- ) -> AsyncIterator[StreamEvent]:- async for item in self.bound.astream_events(- input, self._merge_configs(config), **{**self.kwargs, **kwargs}- ):- yield item+ ) -> AsyncIterator[StreamEvent] | Awaitable[Any]:+ """Forward `astream_events` to the bound runnable with bound kwargs merged.++ For `version="v3"`, returns an awaitable that resolves to the+ bound runnable's typed stream object (e.g. `AsyncChatModelStream`).+ For `version="v1"` / `"v2"`, returns an async iterator over+ `StreamEvent` items.++ Without this override, `__getattr__` would drop `self.kwargs` — losing+ tools bound via `bind_tools`, `stop` sequences, etc.+ """+ # Probe `version` from the merged view so `bind(version="v3")` routes+ # correctly even when the caller doesn't repeat `version` at the call+ # site.+ merged_kwargs = {**self.kwargs, **kwargs}+ version = merged_kwargs.get("version", "v2")+ if version == "v3":+ merged_without_version = {+ k: v for k, v in merged_kwargs.items() if k != "version"+ }+ return self._astream_events_v3(input, config, **merged_without_version)+ # v1/v2: bound.astream_events is a real async generator — iterate it+ # directly without an extra wrapper layer.+ return cast(+ "AsyncIterator[StreamEvent]",+ self.bound.astream_events(+ input, self._merge_configs(config), **merged_kwargs+ ),+ )@overridedef transform(diff --git a/libs/core/langchain_core/tracers/_streaming.py b/libs/core/langchain_core/tracers/_streaming.pyindex 2c2b54c0e4..7f5071bdc0 100644--- a/libs/core/langchain_core/tracers/_streaming.py+++ b/libs/core/langchain_core/tracers/_streaming.py@@ -33,8 +33,9 @@ class _V2StreamingCallbackHandler:"""Marker base class for handlers that consume `on_stream_event` (v2).A handler inheriting from this class signals that it wants content-- block lifecycle events from `stream_v2` / `astream_v2` rather than- the v1 `on_llm_new_token` chunks. `BaseChatModel.invoke` uses+ block lifecycle events from `stream_events(version="v3")` (and its+ async equivalent) rather than the v1 `on_llm_new_token` chunks.+ `BaseChatModel.invoke` uses`isinstance(handler, _V2StreamingCallbackHandler)` to decide whetherto route an invoke through the v2 event generator.diff --git a/libs/core/langchain_core/version.py b/libs/core/langchain_core/version.pyindex 39cc02afc4..ac08df4481 100644--- a/libs/core/langchain_core/version.py+++ b/libs/core/langchain_core/version.py@@ -1,3 +1,3 @@"""langchain-core version information and utilities."""-VERSION = "1.3.3"+VERSION = "1.4.0"diff --git a/libs/core/pyproject.toml b/libs/core/pyproject.tomlindex e7a43447fa..9b17a184d5 100644--- a/libs/core/pyproject.toml+++ b/libs/core/pyproject.toml@@ -21,7 +21,7 @@ classifiers = ["Topic :: Software Development :: Libraries :: Python Modules",]-version = "1.3.3"+version = "1.4.0"requires-python = ">=3.10.0,<4.0.0"dependencies = ["langsmith>=0.3.45,<1.0.0",@@ -32,7 +32,7 @@ dependencies = ["packaging>=23.2.0","pydantic>=2.7.4,<3.0.0","uuid-utils>=0.12.0,<1.0",- "langchain-protocol>=0.0.10",+ "langchain-protocol>=0.0.14",][project.urls]diff --git a/libs/core/tests/unit_tests/language_models/chat_models/test_base.py b/libs/core/tests/unit_tests/language_models/chat_models/test_base.pyindex b1668123a6..9594ad23d9 100644--- a/libs/core/tests/unit_tests/language_models/chat_models/test_base.py+++ b/libs/core/tests/unit_tests/language_models/chat_models/test_base.py@@ -473,7 +473,7 @@ class _FakeV2Handler(BaseCallbackHandler, _V2StreamingCallbackHandler):async def test_streaming_attribute_overrides_v2_callback() -> None:"""`self.streaming=False` must opt out of the v2 event path too.- `_should_stream_v2` shares the `_streaming_disabled` opt-outs with+ `_should_use_protocol_streaming` shares the `_streaming_disabled` opt-outs with`_should_stream`, so an instance-level `streaming=False` takesprecedence over an attached `_V2StreamingCallbackHandler`."""@@ -1561,16 +1561,17 @@ def test_invocation_params_passed_to_tracer_metadata() -> None:assert run.metadata == run.extra["metadata"]-def test_stream_v2_invocation_params_passed_to_tracer_metadata() -> None:- """`stream_v2()` must preserve filtered invocation params for tracing."""+def test_stream_events_v3_invocation_params_passed_to_tracer_metadata() -> None:+ """`stream_events(version="v3")` preserves filtered invocation params."""llm = FakeStreamingChatModelWithInvocationParams()collector = LangChainTracerRunCollector()with collector.tracing_callback() as tracer:- _ = llm.stream_v2(+ _ = llm.stream_events([HumanMessage(content="Hello")],config={"callbacks": [tracer]},stop=["done"],+ version="v3",).outputassert len(collector.runs) == 1@@ -1581,16 +1582,17 @@ def test_stream_v2_invocation_params_passed_to_tracer_metadata() -> None:assert metadata["temperature"] == 0.7-async def test_astream_v2_invocation_params_passed_to_tracer_metadata() -> None:- """`astream_v2()` must preserve filtered invocation params for tracing."""+async def test_astream_events_v3_invocation_params_passed_to_tracer_metadata() -> None:+ """`astream_events(version="v3")` preserves filtered invocation params."""llm = FakeStreamingChatModelWithInvocationParams()collector = LangChainTracerRunCollector()with collector.tracing_callback() as tracer:- stream = await llm.astream_v2(+ stream = await llm.astream_events([HumanMessage(content="Hello")],config={"callbacks": [tracer]},stop=["done"],+ version="v3",)_ = await streamdiff --git a/libs/core/tests/unit_tests/language_models/test_chat_model_stream.py b/libs/core/tests/unit_tests/language_models/test_chat_model_stream.pyindex a27a9e9d10..1230e2b23c 100644--- a/libs/core/tests/unit_tests/language_models/test_chat_model_stream.py+++ b/libs/core/tests/unit_tests/language_models/test_chat_model_stream.py@@ -16,7 +16,7 @@ from langchain_core.language_models.chat_model_stream import ()if TYPE_CHECKING:- from langchain_protocol.protocol import ContentBlockFinishData, MessagesData+ from langchain_protocol.protocol import ContentBlockFinishData# ---------------------------------------------------------------------------# Projection unit tests@@ -244,7 +244,7 @@ class TestAsyncProjection:"""Concurrent `stream.text` + `await stream.output` both drive the pump."""stream = AsyncChatModelStream(message_id="m1")- events: list[MessagesData] = [+ events: list[dict[str, Any]] = [{"event": "message-start","role": "ai",@@ -313,7 +313,7 @@ class TestChatModelStream:def test_text_deltas_via_pump(self) -> None:stream = ChatModelStream()- events: list[MessagesData] = [+ events: list[dict[str, Any]] = [{"event": "message-start", "role": "ai"},{"event": "content-block-delta",@@ -363,7 +363,7 @@ class TestChatModelStream:})stream.dispatch(- { # type: ignore[arg-type,misc]+ {"event": "content-block-delta","index": 0,"content_block": {diff --git a/libs/core/tests/unit_tests/language_models/test_chat_model_streamer.py b/libs/core/tests/unit_tests/language_models/test_chat_model_streamer.pyindex 4390825bee..1d7a3063ad 100644--- a/libs/core/tests/unit_tests/language_models/test_chat_model_streamer.py+++ b/libs/core/tests/unit_tests/language_models/test_chat_model_streamer.py@@ -1,9 +1,9 @@-"""Tests for BaseChatModel.stream_v2() / astream_v2()."""+"""Tests for `BaseChatModel.stream_events(version="v3")` and its async equivalent."""from __future__ import annotationsimport asyncio-from typing import TYPE_CHECKING, Any+from typing import TYPE_CHECKING, Any, castimport pytestfrom pydantic import Field@@ -19,7 +19,7 @@ from langchain_core.messages import AIMessageChunkfrom langchain_core.outputs import ChatGeneration, ChatGenerationChunk, ChatResultif TYPE_CHECKING:- from collections.abc import AsyncIterator, Iterator+ from collections.abc import AsyncIterator, Awaitable, Iteratorfrom langchain_protocol.protocol import MessagesData@@ -32,11 +32,11 @@ if TYPE_CHECKING:class TestStreamV2Sync:- """Test BaseChatModel.stream_v2() with FakeListChatModel."""+ """Test `BaseChatModel.stream_events(version="v3")` with `FakeListChatModel`."""def test_stream_text(self) -> None:model = FakeListChatModel(responses=["Hello world!"])- stream = model.stream_v2("test")+ stream = model.stream_events("test", version="v3")assert isinstance(stream, ChatModelStream)deltas = list(stream.text)@@ -45,7 +45,7 @@ class TestStreamV2Sync:def test_stream_output(self) -> None:model = FakeListChatModel(responses=["Hello!"])- stream = model.stream_v2("test")+ stream = model.stream_events("test", version="v3")msg = stream.outputassert isinstance(msg.content, list)@@ -54,7 +54,7 @@ class TestStreamV2Sync:def test_stream_usage_none_for_fake(self) -> None:model = FakeListChatModel(responses=["Hi"])- stream = model.stream_v2("test")+ stream = model.stream_events("test", version="v3")# Drainfor _ in stream.text:pass@@ -62,7 +62,7 @@ class TestStreamV2Sync:def test_stream_raw_events(self) -> None:model = FakeListChatModel(responses=["ab"])- stream = model.stream_v2("test")+ stream = model.stream_events("test", version="v3")events = list(stream)event_types = [e.get("event") for e in events]@@ -72,12 +72,12 @@ class TestStreamV2Sync:class TestAstreamV2:- """Test BaseChatModel.astream_v2() with FakeListChatModel."""+ """Test `BaseChatModel.astream_events(version="v3")` with `FakeListChatModel`."""@pytest.mark.asyncioasync def test_astream_text_await(self) -> None:model = FakeListChatModel(responses=["Hello!"])- stream = await model.astream_v2("test")+ stream = await model.astream_events("test", version="v3")assert isinstance(stream, AsyncChatModelStream)full = await stream.text@@ -86,7 +86,7 @@ class TestAstreamV2:@pytest.mark.asyncioasync def test_astream_text_deltas(self) -> None:model = FakeListChatModel(responses=["Hi"])- stream = await model.astream_v2("test")+ stream = await model.astream_events("test", version="v3")deltas = [d async for d in stream.text]assert "".join(deltas) == "Hi"@@ -94,7 +94,7 @@ class TestAstreamV2:@pytest.mark.asyncioasync def test_astream_await_output(self) -> None:model = FakeListChatModel(responses=["Hey"])- stream = await model.astream_v2("test")+ stream = await model.astream_events("test", version="v3")msg = await streamassert msg.content == [{"type": "text", "text": "Hey", "index": 0}]@@ -193,13 +193,13 @@ class _EmptyStreamModel(BaseChatModel):class TestCallbacks:- """Verify stream_v2 fires on_llm_end / on_llm_error callbacks."""+ """Verify v3 streaming fires `on_llm_end` / `on_llm_error` callbacks."""- def test_stream_v2_defers_on_chat_model_start_until_consumed(self) -> None:+ def test_stream_events_v3_defers_on_chat_model_start_until_consumed(self) -> None:handler = _RecordingHandler()model = FakeListChatModel(responses=["done"], callbacks=[handler])- stream = model.stream_v2("test")+ stream = model.stream_events("test", version="v3")assert handler.events == []@@ -210,7 +210,7 @@ class TestCallbacks:def test_on_llm_end_fires_after_drain(self) -> None:handler = _RecordingHandler()model = FakeListChatModel(responses=["done"], callbacks=[handler])- stream = model.stream_v2("test")+ stream = model.stream_events("test", version="v3")for _ in stream.text:pass_ = stream.output@@ -225,18 +225,20 @@ class TestCallbacks:async def test_on_llm_end_fires_async(self) -> None:handler = _AsyncRecordingHandler()model = FakeListChatModel(responses=["done"], callbacks=[handler])- stream = await model.astream_v2("test")+ stream = await model.astream_events("test", version="v3")_ = await streamassert "on_chat_model_start" in handler.eventsassert "on_llm_end" in handler.events@pytest.mark.asyncio- async def test_astream_v2_defers_on_chat_model_start_until_consumed(self) -> None:+ async def test_astream_events_v3_defers_on_chat_model_start_until_consumed(+ self,+ ) -> None:handler = _AsyncRecordingHandler()model = FakeListChatModel(responses=["done"], callbacks=[handler])- stream = await model.astream_v2("test")+ stream = await model.astream_events("test", version="v3")assert handler.events == []@@ -251,7 +253,7 @@ class TestCallbacks:"""handler = _RecordingHandler()model = FakeListChatModel(responses=["hello"], callbacks=[handler])- stream = model.stream_v2("test")+ stream = model.stream_events("test", version="v3")_ = stream.outputresponse = handler.last_llm_end_response@@ -265,7 +267,7 @@ class TestCallbacks:async def test_on_llm_end_receives_assembled_message_async(self) -> None:handler = _AsyncRecordingHandler()model = FakeListChatModel(responses=["hello"], callbacks=[handler])- stream = await model.astream_v2("test")+ stream = await model.astream_events("test", version="v3")_ = await streamresponse = handler.last_llm_end_response@@ -277,7 +279,9 @@ class TestCallbacks:def test_empty_stream_reports_error_without_finish_only_lifecycle(self) -> None:handler = _RecordingHandler()- stream = _EmptyStreamModel(callbacks=[handler]).stream_v2("test")+ stream = _EmptyStreamModel(callbacks=[handler]).stream_events(+ "test", version="v3"+ )with pytest.raises(ValueError, match="No generation chunks were returned"):list(stream)@@ -289,7 +293,9 @@ class TestCallbacks:@pytest.mark.asyncioasync def test_empty_astream_reports_error(self) -> None:handler = _AsyncRecordingHandler()- stream = await _EmptyStreamModel(callbacks=[handler]).astream_v2("test")+ stream = await _EmptyStreamModel(callbacks=[handler]).astream_events(+ "test", version="v3"+ )with pytest.raises(ValueError, match="No generation chunks were returned"):await stream@@ -303,12 +309,12 @@ class TestCallbacks:class TestOnStreamEvent:- """`on_stream_event` must fire once per protocol event from stream_v2."""+ """`on_stream_event` fires once per protocol event from v3 streaming."""def test_on_stream_event_fires_for_every_event_sync(self) -> None:handler = _RecordingHandler()model = FakeListChatModel(responses=["Hi"], callbacks=[handler])- stream = model.stream_v2("test")+ stream = model.stream_events("test", version="v3")_ = stream.output# Every event the stream sees should also reach the observer.@@ -322,7 +328,7 @@ class TestOnStreamEvent:async def test_on_stream_event_fires_for_every_event_async(self) -> None:handler = _AsyncRecordingHandler()model = FakeListChatModel(responses=["Hi"], callbacks=[handler])- stream = await model.astream_v2("test")+ stream = await model.astream_events("test", version="v3")_ = await streamevent_types = [e["event"] for e in handler.stream_events]@@ -334,7 +340,7 @@ class TestOnStreamEvent:"""Stream events must all fire between on_chat_model_start and on_llm_end."""handler = _RecordingHandler()model = FakeListChatModel(responses=["Hi"], callbacks=[handler])- stream = model.stream_v2("test")+ stream = model.stream_events("test", version="v3")_ = stream.output# on_stream_event doesn't show up in `events` (different list), but@@ -346,10 +352,10 @@ class TestOnStreamEvent:class TestCancellation:- """Cancellation of `astream_v2` must propagate, not be swallowed."""+ """Cancellation of `astream_events(version="v3")` must propagate."""@pytest.mark.asyncio- async def test_astream_v2_cancellation_propagates(self) -> None:+ async def test_astream_events_v3_cancellation_propagates(self) -> None:"""Cancelling the producer task must raise CancelledError.Regression test: the producer's `except BaseException` previously@@ -357,7 +363,7 @@ class TestCancellation:`on_llm_error` + `stream._fail` pair that never propagated."""model = FakeListChatModel(responses=["abcdefghij"], sleep=0.05)- stream = await model.astream_v2("test")+ stream = await model.astream_events("test", version="v3")aiter_ = stream.text.__aiter__()await aiter_.__anext__()task = stream._producer_task@@ -401,7 +407,7 @@ class _KwargRecordingModel(FakeListChatModel):class TestRunnableBindingForwarding:- """`RunnableBinding.stream_v2` must merge bound kwargs into the call.+ """`RunnableBinding.stream_events(version="v3")` merges bound kwargs.Without the explicit override on `RunnableBinding`, `__getattr__`forwards the call but drops `self.kwargs` — so tools bound via@@ -409,12 +415,12 @@ class TestRunnableBindingForwarding:ignored."""- def test_bound_kwargs_reach_stream_v2(self) -> None:+ def test_bound_kwargs_reach_stream_events_v3(self) -> None:model = _KwargRecordingModel(responses=["hi"])model.received_kwargs = []bound = model.bind(my_marker="sentinel-42")- stream = bound.stream_v2("test")+ stream = bound.stream_events("test", version="v3")for _ in stream.text:pass@@ -426,20 +432,53 @@ class TestRunnableBindingForwarding:model.received_kwargs = []bound = model.bind(my_marker="from-bind")- stream = bound.stream_v2("test", my_marker="from-call")+ stream = bound.stream_events("test", my_marker="from-call", version="v3")for _ in stream.text:passassert model.received_kwargs[0].get("my_marker") == "from-call"@pytest.mark.asyncio- async def test_bound_kwargs_reach_astream_v2(self) -> None:+ async def test_bound_kwargs_reach_astream_events_v3(self) -> None:model = _KwargRecordingModel(responses=["hi"])model.received_kwargs = []bound = model.bind(my_marker="sentinel-async")- stream = await bound.astream_v2("test")+ stream = await bound.astream_events("test", version="v3")_ = await streamassert len(model.received_kwargs) == 1assert model.received_kwargs[0].get("my_marker") == "sentinel-async"++ def test_bound_version_routes_to_v3_without_call_site_repeat(self) -> None:+ # `bind(version="v3").stream_events(input)` must route to the v3+ # branch (using the bound `version`) and must not forward `version`+ # to the underlying model as an extra kwarg.+ model = _KwargRecordingModel(responses=["hi"])+ model.received_kwargs = []+ bound = model.bind(version="v3")++ # `version` is in `self.kwargs`, not at the call site, so the+ # static return type is the v1/v2 iterator overload — narrow it.+ stream = cast("ChatModelStream", bound.stream_events("test"))+ chunks = list(stream.text)++ assert "".join(chunks) == "hi"+ assert len(model.received_kwargs) == 1+ assert "version" not in model.received_kwargs[0]++ @pytest.mark.asyncio+ async def test_bound_version_routes_to_v3_async_without_call_site_repeat(+ self,+ ) -> None:+ model = _KwargRecordingModel(responses=["hi"])+ model.received_kwargs = []+ bound = model.bind(version="v3")++ stream = await cast(+ "Awaitable[AsyncChatModelStream]", bound.astream_events("test")+ )+ _ = await stream++ assert len(model.received_kwargs) == 1+ assert "version" not in model.received_kwargs[0]diff --git a/libs/core/tests/unit_tests/language_models/test_stream_v2.py b/libs/core/tests/unit_tests/language_models/test_chat_model_v3_stream.pysimilarity index 89%rename from libs/core/tests/unit_tests/language_models/test_stream_v2.pyrename to libs/core/tests/unit_tests/language_models/test_chat_model_v3_stream.pyindex a46629a5fe..ec8f89c801 100644--- a/libs/core/tests/unit_tests/language_models/test_stream_v2.py+++ b/libs/core/tests/unit_tests/language_models/test_chat_model_v3_stream.py@@ -1,4 +1,4 @@-"""Tests for stream_v2 / astream_v2 and ChatModelStream."""+"""Tests for `stream_events(version="v3")` (sync + async) and `ChatModelStream`."""from __future__ import annotations@@ -133,7 +133,7 @@ class TestChatModelStream:ContentBlockDeltaData(event="content-block-delta",index=0,- content_block=TextContentBlock(type="text", text="Hello"),+ delta={"type": "text-delta", "text": "Hello"},))assert stream._text_acc == "Hello"@@ -144,9 +144,7 @@ class TestChatModelStream:ContentBlockDeltaData(event="content-block-delta",index=0,- content_block=ReasoningContentBlock(- type="reasoning", reasoning="think"- ),+ delta={"type": "reasoning-delta", "reasoning": "think"},))assert stream._reasoning_acc == "think"@@ -157,7 +155,7 @@ class TestChatModelStream:ContentBlockFinishData(event="content-block-finish",index=0,- content_block=ToolCall(+ content=ToolCall(type="tool_call",id="tc1",name="search",@@ -188,12 +186,12 @@ class TestChatModelStream:ContentBlockDeltaData(event="content-block-delta",index=0,- content_block=TextContentBlock(type="text", text="Hi"),+ delta={"type": "text-delta", "text": "Hi"},),ContentBlockDeltaData(event="content-block-delta",index=0,- content_block=TextContentBlock(type="text", text=" there"),+ delta={"type": "text-delta", "text": " there"},),]finish = MessageFinishData(event="message-finish")@@ -228,14 +226,14 @@ class TestAsyncChatModelStream:ContentBlockDeltaData(event="content-block-delta",index=0,- content_block=TextContentBlock(type="text", text="Hello"),+ delta={"type": "text-delta", "text": "Hello"},))stream._push_content_block_delta(ContentBlockDeltaData(event="content-block-delta",index=0,- content_block=TextContentBlock(type="text", text=" world"),+ delta={"type": "text-delta", "text": " world"},))stream._finish(MessageFinishData(event="message-finish"))@@ -253,7 +251,7 @@ class TestAsyncChatModelStream:ContentBlockDeltaData(event="content-block-delta",index=0,- content_block=TextContentBlock(type="text", text="a"),+ delta={"type": "text-delta", "text": "a"},))await asyncio.sleep(0)@@ -261,7 +259,7 @@ class TestAsyncChatModelStream:ContentBlockDeltaData(event="content-block-delta",index=0,- content_block=TextContentBlock(type="text", text="b"),+ delta={"type": "text-delta", "text": "b"},))await asyncio.sleep(0)@@ -279,7 +277,7 @@ class TestAsyncChatModelStream:ContentBlockFinishData(event="content-block-finish",index=0,- content_block=ToolCall(+ content=ToolCall(type="tool_call",id="tc1",name="search",@@ -303,20 +301,20 @@ class TestAsyncChatModelStream:class TestStreamV2:- """Test BaseChatModel.stream_v2() with FakeListChatModel."""+ """Test `BaseChatModel.stream_events(version="v3")` with `FakeListChatModel`."""- def test_stream_v2_text(self) -> None:+ def test_stream_events_v3_text(self) -> None:model = FakeListChatModel(responses=["Hello world!"])- stream = model.stream_v2("test")+ stream = model.stream_events("test", version="v3")assert isinstance(stream, ChatModelStream)deltas = list(stream.text)assert "".join(deltas) == "Hello world!"assert stream.done- def test_stream_v2_usage(self) -> None:+ def test_stream_events_v3_usage(self) -> None:model = FakeListChatModel(responses=["Hi"])- stream = model.stream_v2("test")+ stream = model.stream_events("test", version="v3")# Drain streamfor _ in stream.text:@@ -325,10 +323,12 @@ class TestStreamV2:assert stream.output.usage_metadata is Noneassert stream.done- def test_stream_v2_malformed_tool_args_produce_invalid_tool_call(self) -> None:+ def test_stream_events_v3_malformed_tool_args_produce_invalid_tool_call(+ self,+ ) -> None:"""End-to-end: malformed tool-call JSON becomes invalid_tool_calls."""model = _MalformedToolCallModel()- stream = model.stream_v2("test")+ stream = model.stream_events("test", version="v3")msg = stream.outputassert msg.tool_calls == []@@ -338,10 +338,12 @@ class TestStreamV2:assert itc["args"] == '{"q": 'assert itc["id"] == "call_1"- def test_stream_v2_translates_anthropic_server_tool_use_to_protocol(self) -> None:+ def test_stream_events_v3_translates_anthropic_server_tool_use_to_protocol(+ self,+ ) -> None:"""Phase E end-to-end: server_tool_use becomes server_tool_call in output."""model = _AnthropicStyleServerToolModel()- stream = model.stream_v2("weather?")+ stream = model.stream_events("weather?", version="v3")msg = stream.outputassert isinstance(msg.content, list)@@ -355,21 +357,21 @@ class TestStreamV2:class TestAstreamV2:- """Test BaseChatModel.astream_v2() with FakeListChatModel."""+ """Test `BaseChatModel.astream_events(version="v3")` with `FakeListChatModel`."""@pytest.mark.asyncio- async def test_astream_v2_text(self) -> None:+ async def test_astream_events_v3_text(self) -> None:model = FakeListChatModel(responses=["Hello!"])- stream = await model.astream_v2("test")+ stream = await model.astream_events("test", version="v3")assert isinstance(stream, AsyncChatModelStream)full = await stream.textassert full == "Hello!"@pytest.mark.asyncio- async def test_astream_v2_deltas(self) -> None:+ async def test_astream_events_v3_deltas(self) -> None:model = FakeListChatModel(responses=["Hi"])- stream = await model.astream_v2("test")+ stream = await model.astream_events("test", version="v3")deltas = [d async for d in stream.text]assert "".join(deltas) == "Hi"@@ -391,14 +393,14 @@ class TestPerBlockAccumulation:ContentBlockDeltaData(event="content-block-delta",index=0,- content_block=TextContentBlock(type="text", text="A"),+ delta={"type": "text-delta", "text": "A"},))stream.dispatch(ContentBlockFinishData(event="content-block-finish",index=0,- content_block=TextContentBlock(type="text", text="A"),+ content=TextContentBlock(type="text", text="A"),))# Block 1: "B"@@ -406,14 +408,14 @@ class TestPerBlockAccumulation:ContentBlockDeltaData(event="content-block-delta",index=1,- content_block=TextContentBlock(type="text", text="B"),+ delta={"type": "text-delta", "text": "B"},))stream.dispatch(ContentBlockFinishData(event="content-block-finish",index=1,- content_block=TextContentBlock(type="text", text="B"),+ content=TextContentBlock(type="text", text="B"),))stream.dispatch(MessageFinishData(event="message-finish"))@@ -437,14 +439,14 @@ class TestPerBlockAccumulation:ContentBlockDeltaData(event="content-block-delta",index=0,- content_block=ReasoningContentBlock(type="reasoning", reasoning="one"),+ delta={"type": "reasoning-delta", "reasoning": "one"},))stream.dispatch(ContentBlockFinishData(event="content-block-finish",index=0,- content_block=ReasoningContentBlock(type="reasoning", reasoning="one"),+ content=ReasoningContentBlock(type="reasoning", reasoning="one"),))# Block 1: "two"@@ -452,14 +454,14 @@ class TestPerBlockAccumulation:ContentBlockDeltaData(event="content-block-delta",index=1,- content_block=ReasoningContentBlock(type="reasoning", reasoning="two"),+ delta={"type": "reasoning-delta", "reasoning": "two"},))stream.dispatch(ContentBlockFinishData(event="content-block-finish",index=1,- content_block=ReasoningContentBlock(type="reasoning", reasoning="two"),+ content=ReasoningContentBlock(type="reasoning", reasoning="two"),))stream.dispatch(MessageFinishData(event="message-finish"))@@ -484,14 +486,14 @@ class TestPerBlockAccumulation:ContentBlockDeltaData(event="content-block-delta",index=0,- content_block=TextContentBlock(type="text", text="hel"),+ delta={"type": "text-delta", "text": "hel"},))stream.dispatch(ContentBlockFinishData(event="content-block-finish",index=0,- content_block=TextContentBlock(type="text", text="hello"),+ content=TextContentBlock(type="text", text="hello"),))stream.dispatch(MessageFinishData(event="message-finish"))@@ -522,7 +524,7 @@ class TestPerBlockAccumulation:ContentBlockDeltaData(event="content-block-delta",index=0,- content_block=TextContentBlock(type="text", text="aaa"),+ delta={"type": "text-delta", "text": "aaa"},))# Block 1 streams deltas before block 0 finishes.@@ -530,7 +532,7 @@ class TestPerBlockAccumulation:ContentBlockDeltaData(event="content-block-delta",index=1,- content_block=TextContentBlock(type="text", text="bb"),+ delta={"type": "text-delta", "text": "bb"},))# Block 0 finishes with authoritative text different from deltas.@@ -538,14 +540,14 @@ class TestPerBlockAccumulation:ContentBlockFinishData(event="content-block-finish",index=0,- content_block=TextContentBlock(type="text", text="XXX"),+ content=TextContentBlock(type="text", text="XXX"),))stream.dispatch(ContentBlockFinishData(event="content-block-finish",index=1,- content_block=TextContentBlock(type="text", text="bb"),+ content=TextContentBlock(type="text", text="bb"),))stream.dispatch(MessageFinishData(event="message-finish"))@@ -568,16 +570,14 @@ class TestPerBlockAccumulation:ContentBlockDeltaData(event="content-block-delta",index=0,- content_block=ReasoningContentBlock(type="reasoning", reasoning="thi"),+ delta={"type": "reasoning-delta", "reasoning": "thi"},))stream.dispatch(ContentBlockFinishData(event="content-block-finish",index=0,- content_block=ReasoningContentBlock(- type="reasoning", reasoning="thinking"- ),+ content=ReasoningContentBlock(type="reasoning", reasoning="thinking"),))stream.dispatch(MessageFinishData(event="message-finish"))@@ -598,14 +598,14 @@ class TestPerBlockAccumulation:ContentBlockDeltaData(event="content-block-delta",index=0,- content_block=TextContentBlock(type="text", text="before"),+ delta={"type": "text-delta", "text": "before"},))stream.dispatch(ContentBlockFinishData(event="content-block-finish",index=0,- content_block=TextContentBlock(type="text", text="before"),+ content=TextContentBlock(type="text", text="before"),))# Block 1: tool_call@@ -613,7 +613,7 @@ class TestPerBlockAccumulation:ContentBlockFinishData(event="content-block-finish",index=1,- content_block=ToolCall(+ content=ToolCall(type="tool_call",id="tc1",name="search",@@ -626,14 +626,14 @@ class TestPerBlockAccumulation:ContentBlockDeltaData(event="content-block-delta",index=2,- content_block=TextContentBlock(type="text", text="after"),+ delta={"type": "text-delta", "text": "after"},))stream.dispatch(ContentBlockFinishData(event="content-block-finish",index=2,- content_block=TextContentBlock(type="text", text="after"),+ content=TextContentBlock(type="text", text="after"),))stream.dispatch(MessageFinishData(event="message-finish"))@@ -694,33 +694,34 @@ class TestStructuredOutputKwargStripping:`stream()` / `astream()` pop `ls_structured_output_format` and`structured_output_format` before forwarding kwargs to `_stream` —- provider clients reject unknown kwargs. `stream_v2` / `astream_v2`- must do the same, or `.with_structured_output().stream_v2()` breaks.+ provider clients reject unknown kwargs. `stream_events(version="v3")` /+ `astream_events(version="v3")` must do the same, or+ `.with_structured_output().stream_events(version="v3")` breaks."""- def test_stream_v2_strips_ls_structured_output_format(self) -> None:+ def test_stream_events_v3_strips_ls_structured_output_format(self) -> None:model = _RecordingStreamModel()bound = model.bind(ls_structured_output_format={"schema": {"type": "object"}})- stream = bound.stream_v2("test")- _ = stream.output # drain+ stream = bound.stream_events("test", version="v3")+ _ = stream.outputrecorded = _RecordingStreamModel.last_stream_kwargsassert "ls_structured_output_format" not in recordedassert "structured_output_format" not in recorded- def test_stream_v2_strips_structured_output_format(self) -> None:+ def test_stream_events_v3_strips_structured_output_format(self) -> None:model = _RecordingStreamModel()bound = model.bind(structured_output_format={"schema": {"type": "object"}})- stream = bound.stream_v2("test")+ stream = bound.stream_events("test", version="v3")_ = stream.outputrecorded = _RecordingStreamModel.last_stream_kwargsassert "ls_structured_output_format" not in recordedassert "structured_output_format" not in recorded@pytest.mark.asyncio- async def test_astream_v2_strips_ls_structured_output_format(self) -> None:+ async def test_astream_events_v3_strips_ls_structured_output_format(self) -> None:model = _RecordingStreamModel()bound = model.bind(ls_structured_output_format={"schema": {"type": "object"}})- stream = await bound.astream_v2("test")+ stream = await bound.astream_events("test", version="v3")_ = await streamassert ("ls_structured_output_format"@@ -731,10 +732,10 @@ class TestStructuredOutputKwargStripping:)@pytest.mark.asyncio- async def test_astream_v2_strips_structured_output_format(self) -> None:+ async def test_astream_events_v3_strips_structured_output_format(self) -> None:model = _RecordingStreamModel()bound = model.bind(structured_output_format={"schema": {"type": "object"}})- stream = await bound.astream_v2("test")+ stream = await bound.astream_events("test", version="v3")_ = await streamassert ("ls_structured_output_format"@@ -849,7 +850,7 @@ class TestAsyncStreamAclose:async def test_aclose_cancels_producer_task(self) -> None:gate = asyncio.Event()model = _GatedStreamModel(gate=gate)- stream = await model.astream_v2("test")+ stream = await model.astream_events("test", version="v3")# Pull the first delta so the producer enters the gated section.aiter_ = stream.text.__aiter__()@@ -867,7 +868,7 @@ class TestAsyncStreamAclose:async def test_aclose_is_idempotent(self) -> None:gate = asyncio.Event()model = _GatedStreamModel(gate=gate)- stream = await model.astream_v2("test")+ stream = await model.astream_events("test", version="v3")aiter_ = stream.text.__aiter__()await aiter_.__anext__()@@ -878,7 +879,7 @@ class TestAsyncStreamAclose:async def test_async_context_manager_closes_stream(self) -> None:gate = asyncio.Event()model = _GatedStreamModel(gate=gate)- stream = await model.astream_v2("test")+ stream = await model.astream_events("test", version="v3")async with stream as s:assert s is stream@@ -901,7 +902,7 @@ class TestAsyncStreamAclose:"""teardown_gate = asyncio.Event()model = _SlowTeardownModel(teardown_gate=teardown_gate)- stream = await model.astream_v2("test")+ stream = await model.astream_events("test", version="v3")# Prime the producer so it enters `_astream`'s forever-blocking# await.@@ -951,7 +952,7 @@ class TestAsyncStreamAclose:async def test_aclose_before_producer_starts_resolves_projections(self) -> None:"""Early-cancel path: `_produce` never runs.- If a consumer calls `astream_v2()` and immediately `aclose()`+ If a consumer calls `astream_events(version="v3")` and immediately `aclose()`(or `async with` exits before the loop schedules `_produce`),`task.cancel()` marks the task cancelled without ever invokingits body — so neither `stream.fail` nor `on_llm_error` fires.@@ -967,10 +968,12 @@ class TestAsyncStreamAclose:handler = RecordingHandler()gate = asyncio.Event()model = _GatedStreamModel(gate=gate)- stream = await model.astream_v2("test", config={"callbacks": [handler]})- # No yield to the event loop between `astream_v2` returning and- # `aclose()` — the producer task has been created but its body- # has not executed.+ stream = await model.astream_events(+ "test", config={"callbacks": [handler]}, version="v3"+ )+ # No yield to the event loop between `astream_events(version="v3")`+ # returning and `aclose()` — the producer task has been created+ # but its body has not executed.await stream.aclose()# `await stream.output` must resolve (with CancelledError)@@ -1007,7 +1010,9 @@ class TestAsyncStreamAclose:handler = RecordingHandler()gate = asyncio.Event()model = _GatedStreamModel(gate=gate)- stream = await model.astream_v2("test", config={"callbacks": [handler]})+ stream = await model.astream_events(+ "test", config={"callbacks": [handler]}, version="v3"+ )aiter_ = stream.text.__aiter__()await aiter_.__anext__()@@ -1047,7 +1052,9 @@ class TestAsyncStreamAclose:handler = SlowEndHandler()model = FakeListChatModel(responses=["ok"])- stream = await model.astream_v2("test", config={"callbacks": [handler]})+ stream = await model.astream_events(+ "test", config={"callbacks": [handler]}, version="v3"+ )# Wait until the stream has assembled the message and the# slow on_llm_end handler has started running.@@ -1167,9 +1174,9 @@ class TestCacheHitV2Replay:class _ProviderMetadataStreamModel(BaseChatModel):"""Fake model that advertises `output_version="responses/v1"` in metadata.- Verifies `stream_v2` pins the assembled message's `output_version` to- `"v1"` — the shape it actually produces — regardless of what the- provider's chunk metadata claims.+ Verifies that `stream_events(version="v3")` pins the assembled+ message's `output_version` to `"v1"` — the shape it actually+ produces — regardless of what the provider's chunk metadata claims."""@property@@ -1203,11 +1210,11 @@ class _ProviderMetadataStreamModel(BaseChatModel):class TestOutputVersionPinning:- """`stream_v2().output` always serializes as v1 content blocks."""+ """`stream_events(version="v3").output` always serializes as v1 content blocks."""def test_output_version_pinned_to_v1(self) -> None:model = _ProviderMetadataStreamModel()- stream = model.stream_v2("hi")+ stream = model.stream_events("hi", version="v3")msg = stream.output# Assembled message must claim `"v1"` even though the provider# chunk metadata advertised `"responses/v1"`.@@ -1329,7 +1336,7 @@ class TestBedrockConverseToolCallArgs:def test_bedrock_tool_call_assembles_without_error(self) -> None:model = _BedrockConverseToolCallModel()- stream = model.stream_v2("What's the weather in Boston?")+ stream = model.stream_events("What's the weather in Boston?", version="v3")# Drive the stream to completion — the raise would have surfaced here.events = list(stream)diff --git a/libs/core/tests/unit_tests/language_models/test_compat_bridge.py b/libs/core/tests/unit_tests/language_models/test_compat_bridge.pyindex ce9f2f75a5..27f1fc87ec 100644--- a/libs/core/tests/unit_tests/language_models/test_compat_bridge.py+++ b/libs/core/tests/unit_tests/language_models/test_compat_bridge.py@@ -1,5 +1,6 @@"""Tests for the compat bridge (chunk-to-event conversion)."""+from collections.abc import AsyncIteratorfrom typing import TYPE_CHECKING, Any, castimport pytest@@ -9,6 +10,7 @@ from langchain_core.language_models._compat_bridge import (CompatBlock,_finalize_block,_to_protocol_usage,+ achunks_to_events,amessage_to_events,chunks_to_events,message_to_events,@@ -22,13 +24,17 @@ if TYPE_CHECKING:InvalidToolCall,MessageFinishData,MessageStartData,- ReasoningContentBlock,ServerToolCall,TextContentBlock,ToolCall,)+def _event_metadata(event: Any) -> dict[str, Any]:+ """Return event metadata for protocol versions that type it as extensible."""+ return cast("dict[str, Any]", cast("dict[str, Any]", event).get("metadata") or {})++# ---------------------------------------------------------------------------# Pure helpers# ---------------------------------------------------------------------------@@ -135,7 +141,7 @@ def test_chunks_to_events_text_only() -> None:# No provider finish_reason in fixtures — metadata carries no# `finish_reason` key (the bridge passes response_metadata through# unchanged).- assert "finish_reason" not in (finish.get("metadata") or {})+ assert "finish_reason" not in _event_metadata(finish)def test_chunks_to_events_empty_iterator() -> None:@@ -143,14 +149,14 @@ def test_chunks_to_events_empty_iterator() -> None:assert list(chunks_to_events(iter([]))) == []-def test_chunks_to_events_block_transitions_close_previous_block() -> None:+def test_chunks_to_events_block_transitions_keep_stable_indices() -> None:"""String-keyed blocks that transition mid-stream each get their own lifecycle.Regression test for OpenAI `responses/v1` style streams where`content_blocks` uses string identifiers (e.g. `"lc_rs_305f30"`) todistinguish blocks. Each distinct block must get its own`content-block-start` / `content-block-finish` pair, with sequential- `uint` wire indices, and blocks must not interleave.+ `uint` wire indices, and deltas keep that stable wire index."""chunks = [ChatGenerationChunk(@@ -199,12 +205,12 @@ def test_chunks_to_events_block_transitions_close_previous_block() -> None:starts: list[Any] = [e for e in events if e["event"] == "content-block-start"]finishes: list[Any] = [e for e in events if e["event"] == "content-block-finish"]- assert [s["content_block"]["type"] for s in starts] == [+ assert [s["content"]["type"] for s in starts] == ["reasoning","reasoning","text",]- assert [f["content_block"]["type"] for f in finishes] == [+ assert [f["content"]["type"] for f in finishes] == ["reasoning","reasoning","text",@@ -213,8 +219,8 @@ def test_chunks_to_events_block_transitions_close_previous_block() -> None:assert [s["index"] for s in starts] == [0, 1, 2]assert [f["index"] for f in finishes] == [0, 1, 2]- # Finish events must be interleaved with starts (no-interleave rule):- # block 0 finishes before block 1 starts, etc.+ # Blocks are finalized at message end so providers can interleave+ # deltas for parallel content blocks without closing them early.events_any: list[Any] = eventslifecycle = [(e["event"], e["index"])@@ -223,17 +229,17 @@ def test_chunks_to_events_block_transitions_close_previous_block() -> None:]assert lifecycle == [("content-block-start", 0),- ("content-block-finish", 0),("content-block-start", 1),- ("content-block-finish", 1),("content-block-start", 2),+ ("content-block-finish", 0),+ ("content-block-finish", 1),("content-block-finish", 2),]# Each finish carries the accumulated content for its block.- assert finishes[0]["content_block"]["reasoning"] == "hmm then"- assert finishes[1]["content_block"]["reasoning"] == "different"- assert finishes[2]["content_block"]["text"] == "answer: 42"+ assert finishes[0]["content"]["reasoning"] == "hmm then"+ assert finishes[1]["content"]["reasoning"] == "different"+ assert finishes[2]["content"]["text"] == "answer: 42"def test_chunks_to_events_tool_call_multichunk() -> None:@@ -284,7 +290,7 @@ def test_chunks_to_events_tool_call_multichunk() -> None:e for e in events if e["event"] == "content-block-finish"]assert len(finish_events) == 1- finalized = cast("ToolCall", finish_events[0]["content_block"])+ finalized = cast("ToolCall", finish_events[0]["content"])assert finalized["type"] == "tool_call"assert finalized["args"] == {"q": "test"}@@ -292,10 +298,126 @@ def test_chunks_to_events_tool_call_multichunk() -> None:# not synthesize one. It deliberately does not infer `"tool_use"`# from the presence of a valid tool_call either; terminal reasons# are provider-specific (see `_build_message_finish`).- assert "finish_reason" not in (- cast("MessageFinishData", events[-1]).get("metadata") or {}+ assert "finish_reason" not in _event_metadata(events[-1])+++def test_chunks_to_events_interleaved_parallel_tool_calls() -> None:+ """Parallel tool-call chunks can interleave without losing block lifecycles."""+ events = list(+ chunks_to_events(+ iter(_interleaved_parallel_tool_call_chunks()), message_id="msg-1"+ ))+ _assert_interleaved_parallel_tool_call_events(events)+++async def test_achunks_to_events_interleaved_parallel_tool_calls() -> None:+ """Async bridge preserves lifecycles for interleaved parallel tool calls."""+ events = [+ event+ async for event in achunks_to_events(+ _aiter_chunks(_interleaved_parallel_tool_call_chunks()),+ message_id="msg-1",+ )+ ]++ _assert_interleaved_parallel_tool_call_events(events)+++def _interleaved_parallel_tool_call_chunks() -> list[ChatGenerationChunk]:+ return [+ ChatGenerationChunk(+ message=AIMessageChunk(+ content="",+ id="msg-1",+ tool_call_chunks=[+ {+ "index": 0,+ "id": "tc1",+ "name": "task",+ "args": '{"subagent_type": "haiku"',+ "type": "tool_call_chunk",+ }+ ],+ )+ ),+ ChatGenerationChunk(+ message=AIMessageChunk(+ content="",+ id="msg-1",+ tool_call_chunks=[+ {+ "index": 1,+ "id": "tc2",+ "name": "task",+ "args": '{"subagent_type": "limerick"',+ "type": "tool_call_chunk",+ }+ ],+ )+ ),+ ChatGenerationChunk(+ message=AIMessageChunk(+ content="",+ id="msg-1",+ tool_call_chunks=[+ {+ "index": 0,+ "id": None,+ "name": None,+ "args": ', "description": "Write a haiku"}',+ "type": "tool_call_chunk",+ }+ ],+ )+ ),+ ChatGenerationChunk(+ message=AIMessageChunk(+ content="",+ id="msg-1",+ tool_call_chunks=[+ {+ "index": 1,+ "id": None,+ "name": None,+ "args": ', "description": "Write a limerick"}',+ "type": "tool_call_chunk",+ }+ ],+ )+ ),+ ]+++async def _aiter_chunks(+ chunks: list[ChatGenerationChunk],+) -> AsyncIterator[ChatGenerationChunk]:+ for chunk in chunks:+ yield chunk+++def _assert_interleaved_parallel_tool_call_events(events: list[Any]) -> None:+ assert_valid_event_stream(events)++ starts: list[Any] = [e for e in events if e["event"] == "content-block-start"]+ finishes: list[Any] = [e for e in events if e["event"] == "content-block-finish"]+ assert [s["index"] for s in starts] == [0, 1]+ assert [f["index"] for f in finishes] == [0, 1]++ finalized = [cast("ToolCall", event["content"]) for event in finishes]+ assert finalized[0]["id"] == "tc1"+ assert finalized[0]["args"] == {+ "subagent_type": "haiku",+ "description": "Write a haiku",+ }+ assert finalized[1]["id"] == "tc2"+ assert finalized[1]["args"] == {+ "subagent_type": "limerick",+ "description": "Write a limerick",+ }+def test_chunks_to_events_invalid_tool_call_keeps_stop_reason() -> None:"""Malformed tool-args become invalid_tool_call; finish_reason stays `stop`."""@@ -323,10 +445,8 @@ def test_chunks_to_events_invalid_tool_call_keeps_stop_reason() -> None:e for e in events if e["event"] == "content-block-finish"]assert len(finish_events) == 1- assert finish_events[0]["content_block"]["type"] == "invalid_tool_call"- assert "finish_reason" not in (- cast("MessageFinishData", events[-1]).get("metadata") or {}- )+ assert finish_events[0]["content"]["type"] == "invalid_tool_call"+ assert "finish_reason" not in _event_metadata(events[-1])def test_chunks_to_events_anthropic_server_tool_use_routes_through_translator() -> None:@@ -350,7 +470,7 @@ def test_chunks_to_events_anthropic_server_tool_use_routes_through_translator()events = list(chunks_to_events(iter(chunks)))finish_blocks: list[Any] = [- e["content_block"] for e in events if e["event"] == "content-block-finish"+ e["content"] for e in events if e["event"] == "content-block-finish"]block_types = [b.get("type") for b in finish_blocks]assert "server_tool_call" in block_types@@ -372,7 +492,7 @@ def test_chunks_to_events_unregistered_provider_falls_back() -> None:finish_events: list[Any] = [e for e in events if e["event"] == "content-block-finish"]- assert [e["content_block"]["type"] for e in finish_events] == ["text"]+ assert [e["content"]["type"] for e in finish_events] == ["text"]def test_chunks_to_events_no_provider_text_plus_tool_call() -> None:@@ -402,7 +522,7 @@ def test_chunks_to_events_no_provider_text_plus_tool_call() -> None:events = list(chunks_to_events(iter(chunks)))finish_blocks: list[Any] = [- e["content_block"] for e in events if e["event"] == "content-block-finish"+ e["content"] for e in events if e["event"] == "content-block-finish"]types = [b.get("type") for b in finish_blocks]assert "text" in types@@ -423,7 +543,7 @@ def test_chunks_to_events_reasoning_in_additional_kwargs() -> None:events = list(chunks_to_events(iter(chunks)))finish_blocks: list[Any] = [- e["content_block"] for e in events if e["event"] == "content-block-finish"+ e["content"] for e in events if e["event"] == "content-block-finish"]types = [b.get("type") for b in finish_blocks]assert "reasoning" in types@@ -448,14 +568,13 @@ def test_message_to_events_text_only() -> None:"message-finish",]start = cast("MessageStartData", events[0])- assert start["message_id"] == "msg-1"+ assert start["id"] == "msg-1"delta_event = cast("ContentBlockDeltaData", events[2])- delta = cast("TextContentBlock", delta_event["content_block"])- assert delta["text"] == "Hello world"+ assert delta_event["delta"] == {"type": "text-delta", "text": "Hello world"}final = cast("MessageFinishData", events[-1])- assert "finish_reason" not in (final.get("metadata") or {})+ assert "finish_reason" not in _event_metadata(final)def test_message_to_events_empty_content_yields_start_finish_only() -> None:@@ -477,15 +596,16 @@ def test_message_to_events_reasoning_text_order() -> None:starts: list[Any] = [e for e in events if e["event"] == "content-block-start"]finishes: list[Any] = [e for e in events if e["event"] == "content-block-finish"]- assert [s["content_block"]["type"] for s in starts] == ["reasoning", "text"]- assert [f["content_block"]["type"] for f in finishes] == ["reasoning", "text"]+ assert [s["content"]["type"] for s in starts] == ["reasoning", "text"]+ assert [f["content"]["type"] for f in finishes] == ["reasoning", "text"]deltas: list[Any] = [e for e in events if e["event"] == "content-block-delta"]assert len(deltas) == 2- assert cast("ReasoningContentBlock", deltas[0]["content_block"])["reasoning"] == (- "think hard"- )- assert cast("TextContentBlock", deltas[1]["content_block"])["text"] == "the answer"+ assert deltas[0]["delta"] == {+ "type": "reasoning-delta",+ "reasoning": "think hard",+ }+ assert deltas[1]["delta"] == {"type": "text-delta", "text": "the answer"}def test_message_to_events_tool_call_skips_delta() -> None:@@ -505,7 +625,7 @@ def test_message_to_events_tool_call_skips_delta() -> None:finishes: list[Any] = [e for e in events if e["event"] == "content-block-finish"]assert len(finishes) == 1- tc = cast("ToolCall", finishes[0]["content_block"])+ tc = cast("ToolCall", finishes[0]["content"])assert tc["type"] == "tool_call"assert tc["args"] == {"q": "hi"}@@ -513,7 +633,7 @@ def test_message_to_events_tool_call_skips_delta() -> None:# bridge does not synthesize one and does not second-guess based on# the presence of a tool_call.final = cast("MessageFinishData", events[-1])- assert "finish_reason" not in (final.get("metadata") or {})+ assert "finish_reason" not in _event_metadata(final)def test_message_to_events_invalid_tool_calls_surfaced_from_field() -> None:@@ -536,7 +656,7 @@ def test_message_to_events_invalid_tool_calls_surfaced_from_field() -> None:)events = list(message_to_events(msg))finishes: list[Any] = [e for e in events if e["event"] == "content-block-finish"]- types = [f["content_block"]["type"] for f in finishes]+ types = [f["content"]["type"] for f in finishes]assert "invalid_tool_call" in types@@ -558,7 +678,7 @@ def test_message_to_events_preserves_finish_reason_and_metadata() -> None:# Passthrough: response_metadata lands on `metadata` unchanged,# including the raw provider `finish_reason`.final = cast("MessageFinishData", events[-1])- assert final["metadata"] == {+ assert _event_metadata(final) == {"finish_reason": "length","model_name": "test-model","stop_sequence": "</end>",@@ -585,7 +705,7 @@ def test_message_to_events_message_id_override() -> None:msg = AIMessage(content="x", id="msg-orig")events = list(message_to_events(msg, message_id="msg-override"))start = cast("MessageStartData", events[0])- assert start["message_id"] == "msg-override"+ assert start["id"] == "msg-override"def test_message_to_events_self_contained_start_strips_heavy_fields() -> None:@@ -622,32 +742,32 @@ def test_message_to_events_self_contained_start_strips_heavy_fields() -> None:events = list(message_to_events(msg))starts: list[Any] = [e for e in events if e["event"] == "content-block-start"]- assert [s["content_block"]["type"] for s in starts] == [+ assert [s["content"]["type"] for s in starts] == ["image","audio","non_standard",]- image_start = starts[0]["content_block"]+ image_start = starts[0]["content"]assert image_start["id"] == "img-1"assert image_start["mime_type"] == "image/png"assert "data" not in image_start- audio_start = starts[1]["content_block"]+ audio_start = starts[1]["content"]assert audio_start["id"] == "aud-1"assert audio_start["mime_type"] == "audio/mp3"assert "data" not in audio_startassert "transcript" not in audio_start- ns_start = starts[2]["content_block"]+ ns_start = starts[2]["content"]assert ns_start["type"] == "non_standard"assert ns_start["value"] == {}finishes: list[Any] = [e for e in events if e["event"] == "content-block-finish"]- assert finishes[0]["content_block"]["data"] == "A" * 1024- assert finishes[1]["content_block"]["data"] == "B" * 1024- assert finishes[1]["content_block"]["transcript"] == "hello"- assert finishes[2]["content_block"]["value"] == {"big": "C" * 1024}+ assert finishes[0]["content"]["data"] == "A" * 1024+ assert finishes[1]["content"]["data"] == "B" * 1024+ assert finishes[1]["content"]["transcript"] == "hello"+ assert finishes[2]["content"]["value"] == {"big": "C" * 1024}def test_message_to_events_finalized_tool_call_start_strips_args() -> None:@@ -668,14 +788,14 @@ def test_message_to_events_finalized_tool_call_start_strips_args() -> None:starts: list[Any] = [e for e in events if e["event"] == "content-block-start"]assert len(starts) == 1- tc_start = starts[0]["content_block"]+ tc_start = starts[0]["content"]assert tc_start["type"] == "tool_call"assert tc_start["id"] == "tc1"assert tc_start["name"] == "search"assert tc_start["args"] == {}finishes: list[Any] = [e for e in events if e["event"] == "content-block-finish"]- tc_finish = cast("ToolCall", finishes[0]["content_block"])+ tc_finish = cast("ToolCall", finishes[0]["content"])assert tc_finish["args"] == {"q": "big payload " * 100}@@ -756,10 +876,10 @@ def test_lifecycle_validator_openai_chat_completions_style() -> None:assert_valid_event_stream(events)finishes: list[Any] = [e for e in events if e["event"] == "content-block-finish"]- types = [f["content_block"]["type"] for f in finishes]+ types = [f["content"]["type"] for f in finishes]assert types == ["text", "tool_call"]- assert finishes[0]["content_block"]["text"] == "Hello there"- assert finishes[1]["content_block"]["args"] == {"q": "pie"}+ assert finishes[0]["content"]["text"] == "Hello there"+ assert finishes[1]["content"]["args"] == {"q": "pie"}def test_lifecycle_validator_openai_responses_style() -> None:@@ -783,7 +903,7 @@ def test_lifecycle_validator_openai_responses_style() -> None:starts: list[Any] = [e for e in events if e["event"] == "content-block-start"]finishes: list[Any] = [e for e in events if e["event"] == "content-block-finish"]# Four distinct blocks: reasoning, text, reasoning, text- assert [s["content_block"]["type"] for s in starts] == [+ assert [s["content"]["type"] for s in starts] == ["reasoning","text","reasoning",@@ -791,10 +911,10 @@ def test_lifecycle_validator_openai_responses_style() -> None:]assert [s["index"] for s in starts] == [0, 1, 2, 3]assert [f["index"] for f in finishes] == [0, 1, 2, 3]- assert finishes[0]["content_block"]["reasoning"] == "hmm first"- assert finishes[1]["content_block"]["text"] == "Answer: 42"- assert finishes[2]["content_block"]["reasoning"] == "actually"- assert finishes[3]["content_block"]["text"] == "42!"+ assert finishes[0]["content"]["reasoning"] == "hmm first"+ assert finishes[1]["content"]["text"] == "Answer: 42"+ assert finishes[2]["content"]["reasoning"] == "actually"+ assert finishes[3]["content"]["text"] == "42!"def test_lifecycle_validator_anthropic_style_text_and_thinking() -> None:@@ -815,9 +935,9 @@ def test_lifecycle_validator_anthropic_style_text_and_thinking() -> None:assert_valid_event_stream(events)finishes: list[Any] = [e for e in events if e["event"] == "content-block-finish"]- assert [f["content_block"]["type"] for f in finishes] == ["reasoning", "text"]- assert finishes[0]["content_block"]["reasoning"] == "Let me think more"- assert finishes[1]["content_block"]["text"] == "The answer is 42."+ assert [f["content"]["type"] for f in finishes] == ["reasoning", "text"]+ assert finishes[0]["content"]["reasoning"] == "Let me think more"+ assert finishes[1]["content"]["text"] == "The answer is 42."def test_lifecycle_validator_anthropic_reasoning_preserves_signature() -> None:@@ -853,7 +973,7 @@ def test_lifecycle_validator_anthropic_reasoning_preserves_signature() -> None:assert_valid_event_stream(events)finishes: list[Any] = [e for e in events if e["event"] == "content-block-finish"]- reasoning_finish = finishes[0]["content_block"]+ reasoning_finish = finishes[0]["content"]assert reasoning_finish["type"] == "reasoning"assert reasoning_finish["reasoning"] == "Let me think more"assert reasoning_finish.get("extras", {}).get("signature") == "sig-abc123"@@ -899,9 +1019,9 @@ def test_lifecycle_validator_anthropic_style_tool_use_after_text() -> None:assert_valid_event_stream(events)finishes: list[Any] = [e for e in events if e["event"] == "content-block-finish"]- assert [f["content_block"]["type"] for f in finishes] == ["text", "tool_call"]- assert finishes[1]["content_block"]["args"] == {"query": "42"}- assert finishes[1]["content_block"]["id"] == "toolu_1"+ assert [f["content"]["type"] for f in finishes] == ["text", "tool_call"]+ assert finishes[1]["content"]["args"] == {"query": "42"}+ assert finishes[1]["content"]["id"] == "toolu_1"def test_lifecycle_validator_inline_image_block() -> None:@@ -925,11 +1045,17 @@ def test_lifecycle_validator_inline_image_block() -> None:starts: list[Any] = [e for e in events if e["event"] == "content-block-start"]deltas: list[Any] = [e for e in events if e["event"] == "content-block-delta"]finishes: list[Any] = [e for e in events if e["event"] == "content-block-finish"]- assert [s["content_block"]["type"] for s in starts] == ["image"]- # Self-contained block: no delta, and start has heavy fields stripped.- assert deltas == []- assert "data" not in starts[0]["content_block"]- assert finishes[0]["content_block"]["data"] == "AAAA"+ assert [s["content"]["type"] for s in starts] == ["image"]+ # Data payload rides as an explicit data-delta; start has heavy fields stripped.+ assert deltas == [+ {+ "event": "content-block-delta",+ "index": 0,+ "delta": {"type": "data-delta", "data": "AAAA"},+ }+ ]+ assert "data" not in starts[0]["content"]+ assert finishes[0]["content"]["data"] == "AAAA"def test_lifecycle_validator_invalid_tool_call_args() -> None:@@ -956,7 +1082,7 @@ def test_lifecycle_validator_invalid_tool_call_args() -> None:finishes: list[Any] = [e for e in events if e["event"] == "content-block-finish"]assert len(finishes) == 1- assert finishes[0]["content_block"]["type"] == "invalid_tool_call"+ assert finishes[0]["content"]["type"] == "invalid_tool_call"def test_lifecycle_validator_empty_stream() -> None:diff --git a/libs/core/tests/unit_tests/language_models/test_v1_parity.py b/libs/core/tests/unit_tests/language_models/test_v1_parity.pyindex d7f3f3a602..36b0141e23 100644--- a/libs/core/tests/unit_tests/language_models/test_v1_parity.py+++ b/libs/core/tests/unit_tests/language_models/test_v1_parity.py@@ -1,7 +1,7 @@-"""V1 parity tests: stream_v2() output must match model.stream() output.+"""V1 parity tests: `stream_events(version="v3")` must match `model.stream()` output.-These are the acceptance criteria for streaming v2 — if any test fails,-v2 has a regression vs v1.+These are the acceptance criteria for the v3 streaming API — if any test fails,+v3 has a regression vs v1."""from __future__ import annotations@@ -128,8 +128,8 @@ def _collect_v1_message(model: BaseChatModel, input_text: str) -> AIMessage:def _collect_v2_message(model: BaseChatModel, input_text: str) -> AIMessage:- """Run model.stream_v2() and get .output."""- stream = model.stream_v2(input_text)+ """Run `model.stream_events(version="v3")` and get `.output`."""+ stream = model.stream_events(input_text, version="v3")return stream.output@@ -156,13 +156,13 @@ class TestV1ParityBasic:def test_empty_response(self) -> None:"""A truly empty stream is an error, matching `stream()` parity.- `stream_v2` distinguishes "producer emitted events but no terminal- `message-finish`" (which is synthesized, for native-event providers+ `stream_events(version="v3")` distinguishes "producer emitted events but no+ terminal `message-finish`" (which is synthesized, for native-event providersthat omit it) from "producer emitted nothing at all" (which failswith `ValueError`, same as `stream()`)."""model = FakeListChatModel(responses=[""])- stream = model.stream_v2("test")+ stream = model.stream_events("test", version="v3")with pytest.raises(ValueError, match="No generation chunks"):_ = stream.output@@ -179,7 +179,7 @@ class TestV1ParityBasic:def test_text_deltas_reconstruct_content(self) -> None:model = FakeListChatModel(responses=["Hello!"])- stream = model.stream_v2("test")+ stream = model.stream_events("test", version="v3")deltas = list(stream.text)content = stream.output.content@@ -233,7 +233,7 @@ class TestV1ParityToolCalls:def test_tool_calls_via_projection(self) -> None:model = self._make_model()- stream = model.stream_v2("weather?")+ stream = model.stream_events("weather?", version="v3")finalized = stream.tool_calls.get()assert len(finalized) == 1assert finalized[0]["name"] == "get_weather"@@ -276,7 +276,7 @@ class TestV1ParityUsage:assert v1.usage_metadata["total_tokens"] == v2.usage_metadata["total_tokens"]def test_usage_projection_matches(self) -> None:- stream = self._make_model().stream_v2("hello")+ stream = self._make_model().stream_events("hello", version="v3")# Drain so usage is availablefor _ in stream.text:pass@@ -352,7 +352,7 @@ class TestV1ParityReasoning:assert types_in_order == ["reasoning", "text"]def test_reasoning_projection(self) -> None:- stream = self._make_model().stream_v2("think")+ stream = self._make_model().stream_events("think", version="v3")full_reasoning = str(stream.reasoning)assert full_reasoning == "Let me think. Done."@@ -366,7 +366,7 @@ class TestV1ParityError:]model = _ScriptedChunkModel(scripted_chunks=chunks, raise_after=True)- stream = model.stream_v2("boom")+ stream = model.stream_events("boom", version="v3")# Drain first; error may surface here or at .output access.try:list(stream.text)@@ -382,7 +382,7 @@ class TestV1ParityError:]model = _ScriptedChunkModel(scripted_chunks=chunks, raise_after=True)- stream = await model.astream_v2("boom")+ stream = await model.astream_events("boom", version="v3")try:async for _ in stream.text:passdiff --git a/libs/core/tests/unit_tests/runnables/test_runnable_events_v3.py b/libs/core/tests/unit_tests/runnables/test_runnable_events_v3.pynew file mode 100644index 0000000000..bc79b27078--- /dev/null+++ b/libs/core/tests/unit_tests/runnables/test_runnable_events_v3.py@@ -0,0 +1,23 @@+"""Tests for the v3 dispatch path on Runnable.astream_events / stream_events."""++from __future__ import annotations++import pytest++from langchain_core.runnables import RunnableLambda+++def _double(x: int) -> int:+ return x * 2+++def test_v3_on_plain_runnable_raises_not_implemented_sync() -> None:+ runnable = RunnableLambda(_double)+ with pytest.raises(NotImplementedError, match="v3"):+ runnable.stream_events(2, version="v3")+++async def test_v3_on_plain_runnable_raises_not_implemented_async() -> None:+ runnable = RunnableLambda(_double)+ with pytest.raises(NotImplementedError, match="v3"):+ await runnable.astream_events(2, version="v3")diff --git a/libs/core/uv.lock b/libs/core/uv.lockindex 951e7ebe5f..885d7c8310 100644--- a/libs/core/uv.lock+++ b/libs/core/uv.lock@@ -891,7 +891,7 @@ wheels = [[[package]]name = "jupyter-server"-version = "2.18.0"+version = "2.17.0"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "anyio" },@@ -914,9 +914,9 @@ dependencies = [{ name = "traitlets" },{ name = "websocket-client" },]-sdist = { url = "https://files.pythonhosted.org/packages/f1/ec/9302cec1ccacdd33c1b1312ac31681c8975cae56c626d783ab49edf9c681/jupyter_server-2.18.0.tar.gz", hash = "sha256:568b27bce4320a53c3eebf1bdcbee9acf48a8ab7f66ec83d900ca9909d4fb770", size = 751152, upload-time = "2026-05-04T13:39:29.685Z" }+sdist = { url = "https://files.pythonhosted.org/packages/5b/ac/e040ec363d7b6b1f11304cc9f209dac4517ece5d5e01821366b924a64a50/jupyter_server-2.17.0.tar.gz", hash = "sha256:c38ea898566964c888b4772ae1ed58eca84592e88251d2cfc4d171f81f7e99d5", size = 731949, upload-time = "2025-08-21T14:42:54.042Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/cf/f9/050312d92072ddb9ce14c11171804c07435790c98d4350935a780d9e10c2/jupyter_server-2.18.0-py3-none-any.whl", hash = "sha256:69a5397a039d689da81a45955f9b23e95ee167f6d8a8d64372fb616f2aac650a", size = 391687, upload-time = "2026-05-04T13:39:27.549Z" },+ { url = "https://files.pythonhosted.org/packages/92/80/a24767e6ca280f5a49525d987bf3e4d7552bf67c8be07e8ccf20271f8568/jupyter_server-2.17.0-py3-none-any.whl", hash = "sha256:e8cb9c7db4251f51ed307e329b81b72ccf2056ff82d50524debde1ee1870e13f", size = 388221, upload-time = "2025-08-21T14:42:52.034Z" },][[package]]@@ -995,7 +995,7 @@ wheels = [[[package]]name = "langchain-core"-version = "1.3.3"+version = "1.4.0"source = { editable = "." }dependencies = [{ name = "jsonpatch" },@@ -1046,7 +1046,7 @@ typing = [[package.metadata]requires-dist = [{ name = "jsonpatch", specifier = ">=1.33.0,<2.0.0" },- { name = "langchain-protocol", specifier = ">=0.0.10" },+ { name = "langchain-protocol", specifier = ">=0.0.14" },{ name = "langsmith", specifier = ">=0.3.45,<1.0.0" },{ name = "packaging", specifier = ">=23.2.0" },{ name = "pydantic", specifier = ">=2.7.4,<3.0.0" },@@ -1091,14 +1091,14 @@ typing = [[[package]]name = "langchain-protocol"-version = "0.0.10"+version = "0.0.14"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "typing-extensions" },]-sdist = { url = "https://files.pythonhosted.org/packages/bf/c3/0d3911d3274f097040e92133f18a425980cd4085e72b6cd65add1f25327c/langchain_protocol-0.0.10.tar.gz", hash = "sha256:5bc530e0b350d3a15a3ab6889abb8132692a2c8a15eed536bce46624751acaaf", size = 6528, upload-time = "2026-04-23T17:31:34.212Z" }+sdist = { url = "https://files.pythonhosted.org/packages/05/bf/efb5e2ed832e4d6d45590e25a9e5191986b291b543bc6a807b48bee070b0/langchain_protocol-0.0.14.tar.gz", hash = "sha256:bc1e8553122e6ede310280462d5813023a172ff2785ccbbdec54d43f3a15e5f2", size = 5862, upload-time = "2026-04-29T16:40:18.657Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/f8/11/6c89bc86b5494cfe29ee23420c398406cc147a09b5cf756e323070e358d7/langchain_protocol-0.0.10-py3-none-any.whl", hash = "sha256:040bb2ae966a06ffcd0051a1d1ca7e4926f12e951e83b07440cb80e0e8e12268", size = 6677, upload-time = "2026-04-23T17:31:33.367Z" },+ { url = "https://files.pythonhosted.org/packages/c2/e9/06c47ecb2aff08f83dfa30058da3bf86be64862c19569043ed5331bbeecd/langchain_protocol-0.0.14-py3-none-any.whl", hash = "sha256:ffc35089779bd8ca217015180cef5e660fc3b074efdaa0f2e95df73583f1a047", size = 6984, upload-time = "2026-04-29T16:40:17.841Z" },][[package]]@@ -1414,14 +1414,14 @@ wheels = [[[package]]name = "mistune"-version = "3.2.1"+version = "3.1.4"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "typing-extensions", marker = "python_full_version < '3.11'" },]-sdist = { url = "https://files.pythonhosted.org/packages/ca/84/620cc3f7e3adf6f5067e10f4dbae71295d8f9e16d5d3f9ef97c40f2f592c/mistune-3.2.1.tar.gz", hash = "sha256:7c8e5501d38bac1582e067e46c8343f17d57ea1aaa735823f3aba1fd59c88a28", size = 98003, upload-time = "2026-05-03T14:33:22.312Z" }+sdist = { url = "https://files.pythonhosted.org/packages/d7/02/a7fb8b21d4d55ac93cdcde9d3638da5dd0ebdd3a4fed76c7725e10b81cbe/mistune-3.1.4.tar.gz", hash = "sha256:b5a7f801d389f724ec702840c11d8fc48f2b33519102fc7ee739e8177b672164", size = 94588, upload-time = "2025-08-29T07:20:43.594Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/2a/7f/a946aa4f8752b37102b41e64dca18a1976ac705c3a0d1dfe74d820a02552/mistune-3.2.1-py3-none-any.whl", hash = "sha256:78cdb0ba5e938053ccf63651b352508d2efa9411dc8810bfb05f2dc5140c0048", size = 53749, upload-time = "2026-05-03T14:33:20.551Z" },+ { url = "https://files.pythonhosted.org/packages/7a/f0/8282d9641415e9e33df173516226b404d367a0fc55e1a60424a152913abc/mistune-3.1.4-py3-none-any.whl", hash = "sha256:93691da911e5d9d2e23bc54472892aff676df27a75274962ff9edc210364266d", size = 53481, upload-time = "2025-08-29T07:20:42.218Z" },][[package]]diff --git a/libs/langchain/langchain_classic/chat_models/base.py b/libs/langchain/langchain_classic/chat_models/base.pyindex ffdf680951..0e7802719f 100644--- a/libs/langchain/langchain_classic/chat_models/base.py+++ b/libs/langchain/langchain_classic/chat_models/base.py@@ -1023,7 +1023,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):yield x@override- async def astream_events(+ async def astream_events( # type: ignore[override]self,input: Any,config: RunnableConfig | None = None,diff --git a/libs/langchain/uv.lock b/libs/langchain/uv.lockindex 31e63f6073..697a74ef25 100644--- a/libs/langchain/uv.lock+++ b/libs/langchain/uv.lock@@ -2909,7 +2909,7 @@ dependencies = [[package.metadata]requires-dist = [{ name = "jsonpatch", specifier = ">=1.33.0,<2.0.0" },- { name = "langchain-protocol", specifier = ">=0.0.10" },+ { name = "langchain-protocol", specifier = ">=0.0.14" },{ name = "langsmith", specifier = ">=0.3.45,<1.0.0" },{ name = "packaging", specifier = ">=23.2.0" },{ name = "pydantic", specifier = ">=2.7.4,<3.0.0" },@@ -3140,14 +3140,14 @@ wheels = [[[package]]name = "langchain-protocol"-version = "0.0.10"+version = "0.0.14"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "typing-extensions" },]-sdist = { url = "https://files.pythonhosted.org/packages/bf/c3/0d3911d3274f097040e92133f18a425980cd4085e72b6cd65add1f25327c/langchain_protocol-0.0.10.tar.gz", hash = "sha256:5bc530e0b350d3a15a3ab6889abb8132692a2c8a15eed536bce46624751acaaf", size = 6528, upload-time = "2026-04-23T17:31:34.212Z" }+sdist = { url = "https://files.pythonhosted.org/packages/05/bf/efb5e2ed832e4d6d45590e25a9e5191986b291b543bc6a807b48bee070b0/langchain_protocol-0.0.14.tar.gz", hash = "sha256:bc1e8553122e6ede310280462d5813023a172ff2785ccbbdec54d43f3a15e5f2", size = 5862, upload-time = "2026-04-29T16:40:18.657Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/f8/11/6c89bc86b5494cfe29ee23420c398406cc147a09b5cf756e323070e358d7/langchain_protocol-0.0.10-py3-none-any.whl", hash = "sha256:040bb2ae966a06ffcd0051a1d1ca7e4926f12e951e83b07440cb80e0e8e12268", size = 6677, upload-time = "2026-04-23T17:31:33.367Z" },+ { url = "https://files.pythonhosted.org/packages/c2/e9/06c47ecb2aff08f83dfa30058da3bf86be64862c19569043ed5331bbeecd/langchain_protocol-0.0.14-py3-none-any.whl", hash = "sha256:ffc35089779bd8ca217015180cef5e660fc3b074efdaa0f2e95df73583f1a047", size = 6984, upload-time = "2026-04-29T16:40:17.841Z" },][[package]]diff --git a/libs/langchain_v1/langchain/__init__.py b/libs/langchain_v1/langchain/__init__.pyindex 05e835b52f..f3608ac63c 100644--- a/libs/langchain_v1/langchain/__init__.py+++ b/libs/langchain_v1/langchain/__init__.py@@ -1,3 +1,3 @@"""Main entrypoint into LangChain."""-__version__ = "1.2.18"+__version__ = "1.3.0a2"diff --git a/libs/langchain_v1/langchain/agents/factory.py b/libs/langchain_v1/langchain/agents/factory.pyindex 38c7a09224..c671b4ddb4 100644--- a/libs/langchain_v1/langchain/agents/factory.py+++ b/libs/langchain_v1/langchain/agents/factory.py@@ -22,6 +22,7 @@ from langchain_core.tools import BaseToolfrom langgraph._internal._runnable import RunnableCallablefrom langgraph.constants import END, STARTfrom langgraph.graph.state import StateGraph+from langgraph.prebuilt import ToolCallTransformerfrom langgraph.prebuilt.tool_node import ToolNodefrom langgraph.types import Command, Sendfrom langsmith import traceable@@ -406,8 +407,13 @@ def _get_schema_type_hints(schema: type) -> dict[str, Any]:return get_type_hints(schema, include_extras=True)-def _resolve_schemas(schemas: set[type]) -> tuple[type, type, type]:- """Resolve state, input, and output schemas for the given schemas."""+def _resolve_schemas(schemas: list[type]) -> tuple[type, type, type]:+ """Resolve state, input, and output schemas for the given schemas.++ Schemas are merged in list order; later entries override earlier ones when the+ same field is declared by multiple schemas. Duplicates are harmless — a type+ that appears more than once is processed at its last position.+ """schema_hints = {schema: _get_schema_type_hints(schema) for schema in schemas}return (_resolve_schema(schema_hints, "StateSchema", None),@@ -704,6 +710,7 @@ def create_agent(debug: bool = False,name: str | None = None,cache: BaseCache[Any] | None = None,+ transformers: Sequence[Callable[[tuple[str, ...]], Any]] | None = None,) -> CompiledStateGraph[AgentState[ResponseT], ContextT, _InputAgentState, _OutputAgentState[ResponseT]]:@@ -799,6 +806,11 @@ def create_agent(another graph as a subgraph node - particularly useful for buildingmulti-agent systems.cache: An optional `BaseCache` instance to enable caching of graph execution.+ transformers: Optional sequence of scope-aware `StreamTransformer`+ factories to register on the compiled graph in addition to+ the agent defaults. Each factory is invoked per-scope+ (`factory(scope)`) so subgraph mini-muxes get fresh+ instances. Appended after the built-in `ToolCallTransformer`.Returns:A compiled `StateGraph` that can be used for chat interactions.@@ -1023,10 +1035,13 @@ def create_agent(]awrap_model_call_handler = _chain_async_model_call_handlers(async_handlers)- state_schemas: set[type] = {m.state_schema for m in middleware}- # Use provided state_schema if available, otherwise use base AgentStatebase_state = state_schema if state_schema is not None else AgentState- state_schemas.add(base_state)+ # Build an ordered list: middleware schemas first (in registration order),+ # base_state last so it wins any field conflict. This lets the caller's+ # explicit state_schema override middleware annotations — e.g. passing+ # a DeltaChannel-annotated schema wins over BinaryOperatorAggregate from+ # AgentState without requiring a post-compilation patch.+ state_schemas: list[type] = [*(m.state_schema for m in middleware), base_state]resolved_state_schema, input_schema, output_schema = _resolve_schemas(state_schemas)@@ -1660,6 +1675,7 @@ def create_agent(debug=debug,name=name,cache=cache,+ transformers=[ToolCallTransformer, *(transformers or ())],).with_config(config)diff --git a/libs/langchain_v1/langchain/chat_models/base.py b/libs/langchain_v1/langchain/chat_models/base.pyindex 471e0b0fc5..490535d0c2 100644--- a/libs/langchain_v1/langchain/chat_models/base.py+++ b/libs/langchain_v1/langchain/chat_models/base.py@@ -988,7 +988,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):yield x@override- async def astream_events(+ async def astream_events( # type: ignore[override]self,input: Any,config: RunnableConfig | None = None,diff --git a/libs/langchain_v1/pyproject.toml b/libs/langchain_v1/pyproject.tomlindex 0fb60cf3b5..26d0ea632e 100644--- a/libs/langchain_v1/pyproject.toml+++ b/libs/langchain_v1/pyproject.toml@@ -21,11 +21,11 @@ classifiers = ["Topic :: Software Development :: Libraries :: Python Modules",]-version = "1.2.18"+version = "1.3.0a2"requires-python = ">=3.10.0,<4.0.0"dependencies = [- "langchain-core>=1.3.3,<2.0.0",- "langgraph>=1.1.10,<1.2.0",+ "langchain-core>=1.4.0a2,<2.0.0",+ "langgraph>=1.2.0a5,<1.3.0","pydantic>=2.7.4,<3.0.0",]@@ -34,7 +34,7 @@ community = ["langchain-community"]anthropic = ["langchain-anthropic"]openai = ["langchain-openai"]azure-ai = ["langchain-azure-ai"]-cohere = ["langchain-cohere"]+#cohere = ["langchain-cohere"]google-vertexai = ["langchain-google-vertexai"]google-genai = ["langchain-google-genai"]fireworks = ["langchain-fireworks"]diff --git a/libs/langchain_v1/tests/unit_tests/agents/test_agent_streaming.py b/libs/langchain_v1/tests/unit_tests/agents/test_agent_streaming.pynew file mode 100644index 0000000000..8b5275137e--- /dev/null+++ b/libs/langchain_v1/tests/unit_tests/agents/test_agent_streaming.py@@ -0,0 +1,285 @@+"""Unit tests for create_agent graphs streaming via `stream_events(version="v3")`."""++from __future__ import annotations++from typing import TYPE_CHECKING, Any++import pytest+from langchain_core.messages import HumanMessage+from langchain_core.runnables import RunnableConfig # noqa: TC002+from langchain_core.tools import tool+from langgraph.prebuilt import ToolCallTransformer+from langgraph.stream import StreamChannel, StreamTransformer++from langchain.agents import create_agent+from langchain.tools import ToolRuntime # noqa: TC001+from tests.unit_tests.agents.model import FakeToolCallingModel++if TYPE_CHECKING:+ from langgraph.prebuilt._tool_call_stream import ToolCallStream+ from langgraph.stream._types import ProtocolEvent+++@tool+def echo(text: str) -> str:+ """Return the input unchanged."""+ return text+++@tool+def streamer(text: str, runtime: ToolRuntime) -> str:+ """Stream two chunks, then return the full text."""+ for chunk in ("one", "two"):+ runtime.emit_output_delta(chunk)+ return text+++@tool+async def astreamer(text: str, runtime: ToolRuntime) -> str:+ """Async: stream two chunks, then return the full text."""+ runtime.emit_output_delta(text)+ runtime.emit_output_delta(text + "!")+ return text+++@tool+def boom() -> str:+ """Raise unconditionally."""+ msg = "nope"+ raise ValueError(msg)+++def _single_tool_call_script(name: str, **args: Any) -> list[list[dict[str, Any]]]:+ """Script: one tool call on turn 0, finish on turn 1."""+ return [+ [{"name": name, "args": args, "id": "tc1"}],+ [],+ ]+++class TestAgentStreamV3Sync:+ def test_stream_returns_agent_run_stream(self) -> None:+ model = FakeToolCallingModel(tool_calls=_single_tool_call_script("echo", text="x"))+ agent = create_agent(model, [echo])++ run = agent.stream_events({"messages": [HumanMessage("hi")]}, version="v3")++ # Drain so the run closes cleanly.+ list(run.tool_calls)++ def test_tool_calls_populated_without_opt_in(self) -> None:+ """`ToolCallTransformer` is registered by default on the agent streamer."""+ model = FakeToolCallingModel(tool_calls=_single_tool_call_script("echo", text="x"))+ agent = create_agent(model, [echo])++ run = agent.stream_events({"messages": [HumanMessage("hi")]}, version="v3")++ collected: list[ToolCallStream] = list(run.tool_calls)+ assert len(collected) == 1+ tc = collected[0]+ assert tc.tool_name == "echo"+ assert tc.tool_call_id == "tc1"+ assert tc.completed is True+ assert tc.error is None++ def test_tool_output_deltas_flow_through(self) -> None:+ model = FakeToolCallingModel(tool_calls=_single_tool_call_script("streamer", text="x"))+ agent = create_agent(model, [streamer])++ run = agent.stream_events({"messages": [HumanMessage("hi")]}, version="v3")++ tool_calls: list[ToolCallStream] = []+ for tc in run.tool_calls:+ tool_calls.append(tc)+ assert list(tc.output_deltas) == ["one", "two"]+ assert len(tool_calls) == 1++ def test_no_tools_run_is_still_usable(self) -> None:+ """`.tool_calls` is empty when the model never calls a tool."""+ model = FakeToolCallingModel() # no tool calls scripted+ agent = create_agent(model, [])++ run = agent.stream_events({"messages": [HumanMessage("hi")]}, version="v3")+ assert list(run.tool_calls) == []+ assert run.output is not None++ def test_messages_projection_present(self) -> None:+ """`MessagesTransformer` is inherited from `GraphStreamer.builtin_factories`."""+ model = FakeToolCallingModel(tool_calls=_single_tool_call_script("echo", text="x"))+ agent = create_agent(model, [echo])++ run = agent.stream_events({"messages": [HumanMessage("hi")]}, version="v3")+ # The native `messages` projection is bound as an instance attribute+ # by `BaseRunStream.__init__` whenever `MessagesTransformer` is+ # registered. Content population is covered by langgraph tests —+ # here we only assert the agent streamer inherits the built-in.+ assert "messages" in run._mux.extensions # type: ignore[attr-defined]+ assert hasattr(run, "messages")+ # Drain so the run closes cleanly.+ for tc in run.tool_calls:+ list(tc.output_deltas)++ def test_caller_transformers_appended_not_replaced(self) -> None:+ """User-supplied transformers add to, rather than replace, the agent defaults."""++ class _Marker(StreamTransformer):+ required_stream_modes = ()++ def __init__(self, scope: tuple[str, ...] = ()) -> None:+ super().__init__(scope)+ self._log: StreamChannel[int] = StreamChannel()++ def init(self) -> dict[str, Any]:+ return {"marker": self._log}++ def process(self, event: ProtocolEvent) -> bool:+ del event+ return True++ model = FakeToolCallingModel(tool_calls=_single_tool_call_script("echo", text="x"))+ agent = create_agent(model, [echo])++ run = agent.stream_events(+ {"messages": [HumanMessage("hi")]},+ version="v3",+ transformers=[_Marker],+ )+ # Both the agent default and the user transformer are registered.+ assert "tool_calls" in run._mux.extensions # type: ignore[attr-defined]+ assert "marker" in run._mux.extensions # type: ignore[attr-defined]++ # `ToolCallTransformer` must come BEFORE the user's transformer in+ # the registration order so it processes `tools` events first. The+ # docstring on `create_agent` promises caller transformers are+ # appended after the built-in.+ transformers = run._mux._transformers # type: ignore[attr-defined]+ tool_call_idx = next(+ i for i, t in enumerate(transformers) if isinstance(t, ToolCallTransformer)+ )+ marker_idx = next(i for i, t in enumerate(transformers) if isinstance(t, _Marker))+ assert tool_call_idx < marker_idx, (+ "ToolCallTransformer must be registered before user-supplied transformers"+ )++ list(run.tool_calls)++ def test_tool_error_sets_error_field(self) -> None:+ """Tool errors are surfaced on the `ToolCallStream.error` field.++ `create_agent`'s default tool-error handler re-raises, so the+ overall run fails — the assertion here is that the error is+ attached to the scoped `ToolCallStream` *before* the run raises.+ """+ model = FakeToolCallingModel(tool_calls=_single_tool_call_script("boom"))+ agent = create_agent(model, [boom])++ run = agent.stream_events({"messages": [HumanMessage("hi")]}, version="v3")++ collected: list[ToolCallStream] = []++ def _drive() -> None:+ for tc in run.tool_calls:+ collected.append(tc)+ list(tc.output_deltas)++ with pytest.raises(ValueError, match="nope"):+ _drive()+ assert len(collected) == 1+ assert collected[0].error is not None+ assert "nope" in collected[0].error+ assert collected[0].completed is True++ def test_inner_agent_tool_calls_via_subgraph(self) -> None:+ """An inner `create_agent` invoked from a tool exposes its own tool calls.++ Wiring a sub-agent through a `@tool` is the canonical pattern+ for hierarchical agents. The outer caller iterates `run.subgraphs`+ and finds a `tool_calls` projection on each subgraph handle+ — populated by a fresh per-scope `ToolCallTransformer` instance.+ """++ @tool+ def inner_echo(text: str) -> str:+ """Echo via inner agent."""+ return text++ inner_model = FakeToolCallingModel(+ tool_calls=_single_tool_call_script("inner_echo", text="leaf"),+ )+ inner_agent = create_agent(inner_model, [inner_echo])++ @tool+ def run_inner(query: str, config: RunnableConfig) -> str:+ """Delegate `query` to the inner agent and return its reply."""+ result = inner_agent.invoke(+ {"messages": [HumanMessage(query)]},+ config,+ )+ return str(result["messages"][-1].content)++ outer_model = FakeToolCallingModel(+ tool_calls=_single_tool_call_script("run_inner", query="leaf"),+ )+ outer_agent = create_agent(outer_model, [run_inner])++ run = outer_agent.stream_events(+ {"messages": [HumanMessage("go")]},+ version="v3",+ )++ outer_tool_calls: list[ToolCallStream] = []+ inner_tool_calls: list[ToolCallStream] = []++ # `tool_calls` and `subgraphs` are single-subscriber channels, so+ # interleave them through the run's round-robin cursor. Drilling+ # into `sub.tool_calls` inside the loop body subscribes the inner+ # mini-mux before the next pump cycle, satisfying the lazy-subscribe+ # contract on subgraph handles.+ for name, item in run.interleave("tool_calls", "subgraphs"):+ if name == "tool_calls":+ outer_tool_calls.append(item)+ else: # "subgraphs"+ for tc in item.tool_calls:+ inner_tool_calls.append(tc)+ list(tc.output_deltas)++ # Outer's `tool_calls` projection owns only its own scope: it has+ # the call to `run_inner` and nothing from the inner subgraph.+ assert len(outer_tool_calls) == 1+ assert outer_tool_calls[0].tool_name == "run_inner"+ assert outer_tool_calls[0].completed is True+ assert outer_tool_calls[0].error is None++ # The inner agent's `inner_echo` tool call is reachable via the+ # subgraph's per-scope `tool_calls` projection.+ assert len(inner_tool_calls) == 1+ assert inner_tool_calls[0].tool_name == "inner_echo"+ assert inner_tool_calls[0].completed is True+ assert inner_tool_calls[0].error is None+++class TestAgentStreamV3Async:+ @pytest.mark.anyio+ async def test_astream_returns_async_agent_run_stream(self) -> None:+ model = FakeToolCallingModel(tool_calls=_single_tool_call_script("echo", text="x"))+ agent = create_agent(model, [echo])++ run = await agent.astream_events({"messages": [HumanMessage("hi")]}, version="v3")+ async for tc in run.tool_calls:+ async for _ in tc.output_deltas:+ pass++ @pytest.mark.anyio+ async def test_async_tool_deltas_flow(self) -> None:+ model = FakeToolCallingModel(tool_calls=_single_tool_call_script("astreamer", text="hi"))+ agent = create_agent(model, [astreamer])++ run = await agent.astream_events({"messages": [HumanMessage("hi")]}, version="v3")++ collected: list[ToolCallStream] = []+ async for tc in run.tool_calls:+ collected.append(tc)+ deltas = [d async for d in tc.output_deltas]+ assert deltas == ["hi", "hi!"]+ assert len(collected) == 1+ assert collected[0].completed is Truediff --git a/libs/langchain_v1/tests/unit_tests/agents/test_state_schema.py b/libs/langchain_v1/tests/unit_tests/agents/test_state_schema.pyindex cbd66d4a0a..26d8dbe36b 100644--- a/libs/langchain_v1/tests/unit_tests/agents/test_state_schema.py+++ b/libs/langchain_v1/tests/unit_tests/agents/test_state_schema.py@@ -6,7 +6,7 @@ AgentState without needing to create custom middleware.from __future__ import annotations-from typing import TYPE_CHECKING, Annotated, Any+from typing import TYPE_CHECKING, Annotated, Any, get_args, get_type_hintsfrom langchain_core.messages import HumanMessagefrom langchain_core.tools import tool@@ -256,6 +256,27 @@ def test_state_schema_with_private_state_field() -> None:assert len(result["messages"]) == 4 # Human, AI (tool call), Tool result, AI (final)+def test_last_schema_wins_for_conflicting_field() -> None:+ """The last schema in the list wins when multiple schemas declare the same field.++ In practice this means state_schema (passed last) overrides middleware annotations,+ and a later middleware overrides an earlier one.+ """++ class FirstState(AgentState[Any]):+ shared_field: Annotated[str, "first"]++ class MiddleState(AgentState[Any]):+ shared_field: Annotated[str, "middle"]++ class LastState(AgentState[Any]):+ shared_field: Annotated[str, "last"]++ resolved, _, _ = factory._resolve_schemas([FirstState, MiddleState, LastState])+ hints = get_type_hints(resolved, include_extras=True)+ assert get_args(hints["shared_field"])[1] == "last"++def test_get_schema_type_hints_cache_hits_for_reused_schema() -> None:"""Test repeated schema resolution reuses cached type hints for the same schema."""@@ -266,9 +287,9 @@ def test_get_schema_type_hints_cache_hits_for_reused_schema() -> None:factory._get_schema_type_hints.cache_clear()- factory._resolve_schemas({CachedState})+ factory._resolve_schemas([CachedState])first_info = factory._get_schema_type_hints.cache_info()- factory._resolve_schemas({CachedState})+ factory._resolve_schemas([CachedState])second_info = factory._get_schema_type_hints.cache_info()assert first_info.misses == 1@@ -293,9 +314,9 @@ def test_get_schema_type_hints_cache_accepts_distinct_local_schema_types() -> Noschema_a = make_state_schema("LocalStateA")schema_b = make_state_schema("LocalStateB")- factory._resolve_schemas({schema_a, schema_b})+ factory._resolve_schemas([schema_a, schema_b])first_info = factory._get_schema_type_hints.cache_info()- factory._resolve_schemas({schema_a, schema_b})+ factory._resolve_schemas([schema_a, schema_b])second_info = factory._get_schema_type_hints.cache_info()assert first_info.misses == 2diff --git a/libs/langchain_v1/uv.lock b/libs/langchain_v1/uv.lockindex d3b6dddf88..3347bda119 100644--- a/libs/langchain_v1/uv.lock+++ b/libs/langchain_v1/uv.lock@@ -14,6 +14,9 @@ resolution-markers = ["python_full_version < '3.11' and platform_python_implementation == 'PyPy'",]+[options]+prerelease-mode = "allow"+[manifest]constraints = [{ name = "pygments", specifier = ">=2.20.0" },@@ -779,25 +782,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/db/d3/9dcc0f5797f070ec8edf30fbadfb200e71d9db6b84d211e3b2085a7589a0/click-8.3.0-py3-none-any.whl", hash = "sha256:9b9f285302c6e3064f4330c05f05b81945b2a39544279343e6e7c5f27a9baddc", size = 107295, upload-time = "2025-09-18T17:32:22.42Z" },]-[[package]]-name = "cohere"-version = "5.21.1"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "fastavro" },- { name = "httpx" },- { name = "pydantic" },- { name = "pydantic-core" },- { name = "requests" },- { name = "tokenizers" },- { name = "types-requests" },- { name = "typing-extensions" },-]-sdist = { url = "https://files.pythonhosted.org/packages/d2/75/4c346f6e2322e545f8452692304bd4eca15a2a0209ab9af6a0d1a7810b67/cohere-5.21.1.tar.gz", hash = "sha256:e5ade4423b928b01ff2038980e1b62b2a5bb412c8ab83e30882753b810a5509f", size = 191272, upload-time = "2026-03-26T15:09:27.857Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/0a/50/5538f02ec6d10fbb84f29c1b18c68ff2a03d7877926a80275efdf8755a9f/cohere-5.21.1-py3-none-any.whl", hash = "sha256:f15592ec60d8cf12f01563db94ec28c388c61269d9617f23c2d6d910e505344e", size = 334262, upload-time = "2026-03-26T15:09:26.284Z" },-]-[[package]]name = "colorama"version = "0.4.6"@@ -1023,58 +1007,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/ab/84/02fc1827e8cdded4aa65baef11296a9bbe595c474f0d6d758af082d849fd/execnet-2.1.2-py3-none-any.whl", hash = "sha256:67fba928dd5a544b783f6056f449e5e3931a5c378b128bc18501f7ea79e296ec", size = 40708, upload-time = "2025-11-12T09:56:36.333Z" },]-[[package]]-name = "fastavro"-version = "1.12.2"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/6e/5b/ccb338db71f347e3bc031d268bf6dc41e5ead63b6997b8e72af92f05e18e/fastavro-1.12.2.tar.gz", hash = "sha256:3c79502d56cf6b76210032e1c53494ddfbc73c140bccf2ef4092b3f0825323ab", size = 1030127, upload-time = "2026-04-24T14:36:01.269Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/3c/91/16c3508447e7cf9f413a6a01792a990ed94d17505fc80a7fb76027078aed/fastavro-1.12.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:c7c6d26c731a0e1e8e7d4ae8f13ae524eb6ec0e90d99c8147a19fdbae14eb807", size = 976824, upload-time = "2026-04-24T14:36:04.233Z" },- { url = "https://files.pythonhosted.org/packages/2d/3a/97534561a1b4615366345ac066ad1f54698a59aa510eece3153c3a603d29/fastavro-1.12.2-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7caeecf519eff50f007ca4bee16b6e0a8252e5fe682c94432192a20867239888", size = 3185186, upload-time = "2026-04-24T14:36:06.395Z" },- { url = "https://files.pythonhosted.org/packages/ee/e4/26512b52f58305b9d2194169de2e82c16d5131f0a0b6359e50d34faf4021/fastavro-1.12.2-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:731aefe6c4bf2bafa0798ef83927676d06e44d1d18202cfb56d63b40422ab900", size = 3196799, upload-time = "2026-04-24T14:36:09.028Z" },- { url = "https://files.pythonhosted.org/packages/58/69/22f3b29a4555eb805a26f209f12532df8aafa48685d1cd1879aa42758d04/fastavro-1.12.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:f089f24225a28ddafa5cfad7c41cfa84db1a55f2d473370769a95c0e3bac60c9", size = 3112396, upload-time = "2026-04-24T14:36:11.401Z" },- { url = "https://files.pythonhosted.org/packages/e9/2a/fc61ef522050e1079ccf1aee07192881f3b11129f5e2b76811fd4fc3bb2f/fastavro-1.12.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:653c4f90dd21d8a1e74309919e08934e420d9aef51d051d14bf5a1c0e8293c22", size = 3180452, upload-time = "2026-04-24T14:36:13.634Z" },- { url = "https://files.pythonhosted.org/packages/a6/6a/43ce9d713e9f1122e19c80d94d0dc0a356b8562d33eea90081dac781dd97/fastavro-1.12.2-cp310-cp310-win_amd64.whl", hash = "sha256:030f17eb4c7978538a31b55dea451ceace851a88dc9816b1923f8fb8a260db4c", size = 445396, upload-time = "2026-04-24T14:36:15.243Z" },- { url = "https://files.pythonhosted.org/packages/89/77/058f3c93348624cb695399b27f3f0c1c3d1190586065797e4a48f75d4147/fastavro-1.12.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:d48cd7094598a7e9d4297e8bf4bbe0dc9dc2ba4367d83dbb603e3b3c6aa35566", size = 974559, upload-time = "2026-04-24T14:36:17.172Z" },- { url = "https://files.pythonhosted.org/packages/a5/ef/08bbfa643addd2b98a9ce536613e2098928aa5e3ca098fd5b74f3c03b96a/fastavro-1.12.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:070c6134604bd7b6fd44409406ac50445339682b2e872885db2e859f92d22e93", size = 3352777, upload-time = "2026-04-24T14:36:19.679Z" },- { url = "https://files.pythonhosted.org/packages/d3/ec/55c11108529bdb59e635899f737651f729485ea5af36e128fb6560969c3d/fastavro-1.12.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2b73d50978d5e57416fa68461f9f3c8f39ea39e761cb1e12f919745adefe26a7", size = 3387036, upload-time = "2026-04-24T14:36:21.794Z" },- { url = "https://files.pythonhosted.org/packages/d9/b3/4459f7c61804e9b42b49f02fba8fbbb041af76c7cab43cee4018532ecd00/fastavro-1.12.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c57a9920400166398695d92580eca21fd7a79f3c67d691ac7e20a7d1b5300735", size = 3284780, upload-time = "2026-04-24T14:36:24.193Z" },- { url = "https://files.pythonhosted.org/packages/5d/e3/d7f510b9b8c7b73409a6232a9a8d282faa8560f85d024d7212e4c5dff3df/fastavro-1.12.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:81f6108f3ac292fb6cd05758c9e531389d8fc5e94e8c949b9298f4fb0a239662", size = 3368557, upload-time = "2026-04-24T14:36:26.667Z" },- { url = "https://files.pythonhosted.org/packages/cb/10/14fa0abf8e7da07258393ae2b783dd4bb60d1fb93ad790296d27561f33ce/fastavro-1.12.2-cp311-cp311-win_amd64.whl", hash = "sha256:eec44256856fd59d29d1f1d0950ace18a58e4228e7d49de5d5e1b1875b227dde", size = 446499, upload-time = "2026-04-24T14:36:28.547Z" },- { url = "https://files.pythonhosted.org/packages/86/d2/c36f646296794c05d29a07bec84a6c56bfd285203e389a8954987ec1c515/fastavro-1.12.2-cp311-cp311-win_arm64.whl", hash = "sha256:ecd1b23ea7f9af09c865ac8503d07afd7e6bf782d76bb83cbbdba15b7a0db807", size = 388198, upload-time = "2026-04-24T14:36:29.791Z" },- { url = "https://files.pythonhosted.org/packages/0e/bc/fe5731d6724d978694fbd3196bc1c0d7cab3fd0766e9551c40c39f798b52/fastavro-1.12.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0e331896e8efffc72fa03e63b87ebfc37960113127da8e0f5152d91664ffed68", size = 964331, upload-time = "2026-04-24T14:36:31.297Z" },- { url = "https://files.pythonhosted.org/packages/98/36/50abf1145e4f1c4f418cd4b5f2ac806643d0b14e360b60e953826edf1b34/fastavro-1.12.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7f01ebaada59d74fdf6d28e5031a961a413b3752e9edb0c03866fa18480cf4c8", size = 3340170, upload-time = "2026-04-24T14:36:33.364Z" },- { url = "https://files.pythonhosted.org/packages/fc/8c/76ef4641e6c1c1aa3e6bb3c9efb5533ffda5dd975c8b5ae54e794322d9e3/fastavro-1.12.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:25ef6855935f67582740ffa6bb978e40ec51be876117a3555c36fa2488dcdf25", size = 3425061, upload-time = "2026-04-24T14:36:35.497Z" },- { url = "https://files.pythonhosted.org/packages/31/10/379ff23425b2b470d5209cbc6736a6e5cbc34392ff17bb7355b8fd4aa0ca/fastavro-1.12.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:84a4f76a0aece0aa72b5ed8162ba2ff8c78908b8361b5a5d92ddd161977ccb74", size = 3243618, upload-time = "2026-04-24T14:36:37.969Z" },- { url = "https://files.pythonhosted.org/packages/88/29/4c8f9e7cd78f932f0d82823899e67a6d7f7e8f2524992db03956f9d9f5ef/fastavro-1.12.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:81e8da77d201916f6771fc357fda8267c2a256d7aa11923d43bc5f2fc155878b", size = 3378427, upload-time = "2026-04-24T14:36:40.278Z" },- { url = "https://files.pythonhosted.org/packages/e2/a1/eafeb302aaaea6055d4a9c11272b4aeaf713e43fe8eaf782f43a1fee2b44/fastavro-1.12.2-cp312-cp312-win_amd64.whl", hash = "sha256:1924349c74666c89417bd5cc2749f598e2f15f1d56ee81428b2317ab02c88aae", size = 441077, upload-time = "2026-04-24T14:36:41.791Z" },- { url = "https://files.pythonhosted.org/packages/56/9d/67e831041ba8efc16265c65bd71ba92e1095bba19b91be99e102f19d9be6/fastavro-1.12.2-cp312-cp312-win_arm64.whl", hash = "sha256:4c346cf449baf3b113e997c34151ad205e7135bc429469b005b180ade7e65e28", size = 378205, upload-time = "2026-04-24T14:36:43.679Z" },- { url = "https://files.pythonhosted.org/packages/83/39/f489a441d41cc9c0a8449fb1325d7a9c9eb57a5634e6ab19dfb0a1105324/fastavro-1.12.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:57bb6b908cb2e05baab63b04c3a31be3b4545a10bfab9748b8763016b5256704", size = 958566, upload-time = "2026-04-24T14:36:45.49Z" },- { url = "https://files.pythonhosted.org/packages/31/69/776cc025aee2d02acacb734cf690d2fbc295eaadde1b5d47caf8c77a6a2b/fastavro-1.12.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a007f95cc682f56e6d83f1d17c29c00bf719d6fe8e003282b535af3a1ba09c0", size = 3276390, upload-time = "2026-04-24T14:36:47.875Z" },- { url = "https://files.pythonhosted.org/packages/8c/bc/b7e15fa788f42cbe65827af2ec06c9ad91bb9f72c213110dbef61b53a5b0/fastavro-1.12.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5e90460b0cd21f62be3cb26087e706e2cebb7b3fcef9e05b4473b61bb0415b5e", size = 3372779, upload-time = "2026-04-24T14:36:50.122Z" },- { url = "https://files.pythonhosted.org/packages/79/c2/98993ca810231fc1397212f48c3d46626983722a24bbaaa5c27ee0963751/fastavro-1.12.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:7ccd15966b8218d41b06ec3e7c2556be89a8a693026c771e6564d2e40bbaf8ea", size = 3187591, upload-time = "2026-04-24T14:36:52.451Z" },- { url = "https://files.pythonhosted.org/packages/c6/bb/c180f340eba6478f1b20deccdd17e2b4a4d5074dafd812e3c4254fd035f7/fastavro-1.12.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:06b6971d3dae10cb34353b857d16ad21ebd6f0ea394e86c96abdcad109005d6e", size = 3320589, upload-time = "2026-04-24T14:36:54.647Z" },- { url = "https://files.pythonhosted.org/packages/4d/e9/aca0456216b5b8992e7b0a8542711b66799c05bfe24c8e32ef6f56e7eb93/fastavro-1.12.2-cp313-cp313-win_amd64.whl", hash = "sha256:98dfcdfaf1498ae2f0e2fafe900a82e8320cc81d8ae5a95b8b8879eaa3298c39", size = 440883, upload-time = "2026-04-24T14:36:56.585Z" },- { url = "https://files.pythonhosted.org/packages/e3/7e/984896e716af504927be71b80a1e9661aa96c6f9e1e777d52823aacb99f2/fastavro-1.12.2-cp313-cp313-win_arm64.whl", hash = "sha256:3888ef7a51adc77cdf07251bc762566a1be36211e1cff689f13980f3776a2f36", size = 377536, upload-time = "2026-04-24T14:36:58.274Z" },- { url = "https://files.pythonhosted.org/packages/e9/42/09a1e1f8d9998d73848a6ff0aad6713ae6abf0dbf99918776f8ef33344a7/fastavro-1.12.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:283dcd3129b632021894425974bedd0eb6db3bbf5994e448ccad10db4d803d31", size = 1049506, upload-time = "2026-04-24T14:36:59.797Z" },- { url = "https://files.pythonhosted.org/packages/52/ef/80cc16f43919d532f25a707f34b275cccc09dca87a05b000fbbfc8e8f255/fastavro-1.12.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2d125e210d5a0a1f701f12c0ecad9a03f1b04b5eddbce6ca36a1fc217da977ef", size = 3495899, upload-time = "2026-04-24T14:37:02.306Z" },- { url = "https://files.pythonhosted.org/packages/c1/54/a0817d1d0236e9e0233f5c996f450cc795b056b8e06edb531f24b9df82ed/fastavro-1.12.2-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2d4d66afad78e8f47feaa307728a6b71fe3effc63ba2b9eeb109ee687c9bd397", size = 3399232, upload-time = "2026-04-24T14:37:04.837Z" },- { url = "https://files.pythonhosted.org/packages/38/0a/650f256c15f5875b6081544b9ba7ed8254329213e7e49e3db0aec68b5bee/fastavro-1.12.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:2328ec07925c04c89719e3971c9068a165c7fd474ea87675b1204de0440e71ff", size = 3320222, upload-time = "2026-04-24T14:37:07.281Z" },- { url = "https://files.pythonhosted.org/packages/f5/54/8351d388f94fbb0870e8cffaae41d3cc607acc8d6a8a6a217e2794829593/fastavro-1.12.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:55dea7e74b834d4b70467fc19c5b9ccb5509fe39abc4d26891187c1b22176423", size = 3337096, upload-time = "2026-04-24T14:37:09.452Z" },- { url = "https://files.pythonhosted.org/packages/da/eb/b36ba9a88826e8c272df02e2f8b5da717e88b6eb508fddca3ca450043731/fastavro-1.12.2-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8d37c87826ae7195cfbd20fcd448801f2f563bb38f2691ec6574e39cb9eca6c8", size = 963119, upload-time = "2026-04-24T14:37:11.557Z" },- { url = "https://files.pythonhosted.org/packages/e1/02/3d7f540fb26ba4ea1f4ebd2783c586614da9ac00906a3092e92fd3f104a2/fastavro-1.12.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4c463a3701f293e30d3d62e71e1989f112028d07f87432baf4507eeb57ec3831", size = 3266238, upload-time = "2026-04-24T14:37:13.84Z" },- { url = "https://files.pythonhosted.org/packages/4c/0b/b77be56c5109da0fc7dcfd7e6b6752fe0a61d0a5c58c6a65e38b4501946a/fastavro-1.12.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f604ba83498e209fff4c7ecc5063a39421dc538dace694bc592f9f338254f3dc", size = 3324020, upload-time = "2026-04-24T14:37:16.096Z" },- { url = "https://files.pythonhosted.org/packages/e7/6e/951d41f244107e91bf2f59245b71783c03eaab4bdbc960d58316c19652bb/fastavro-1.12.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:bfac2dada8ddc002e8b7d8289d6fad4f070bc1fec20371cec684a7d10d932e96", size = 3170160, upload-time = "2026-04-24T14:37:18.168Z" },- { url = "https://files.pythonhosted.org/packages/94/6f/2adb571fda448d4afd2466e1cef2963fefdc6b37847da05249983e415f17/fastavro-1.12.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:bc44ba6289fb1f5ee318335958dde6ad6d742dcb4bb8930de843e9024c64b68c", size = 3281842, upload-time = "2026-04-24T14:37:20.833Z" },- { url = "https://files.pythonhosted.org/packages/17/07/4bad2e96c4c6bae40253be2573cc09c1e5b9ccf821e1ff74e0d33b64bf90/fastavro-1.12.2-cp314-cp314-win_amd64.whl", hash = "sha256:a475418f71c5aed69899813ecccf392429c08c3a63df3030129db71760b0db8f", size = 450903, upload-time = "2026-04-24T14:37:23.059Z" },- { url = "https://files.pythonhosted.org/packages/5b/b7/180f67ba9a46ba23a1ff6432f48d3087d4f2048579ecc262b00426cb1c63/fastavro-1.12.2-cp314-cp314-win_arm64.whl", hash = "sha256:daec9f9655a1d4636613c47d6d3343f6e039150d66cdce62543e20ca36612a8a", size = 391076, upload-time = "2026-04-24T14:37:24.756Z" },- { url = "https://files.pythonhosted.org/packages/dd/8f/18f60329b627d2118a4a2b19e8741fbd807d60bf0470554e1bbfb7f1bca3/fastavro-1.12.2-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:57594b72cf663bbd0f3ad8a319a999fc3d7c71065a6799b2c1d1a6a137894c5b", size = 1055430, upload-time = "2026-05-09T21:53:14.364Z" },- { url = "https://files.pythonhosted.org/packages/d2/ac/a1fa1fc29df0efc89d4946a743b09bdc9500591b5b92083eaf8e93664916/fastavro-1.12.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:74412132bbfb153cbf704517f2c89f7d3e170feb681b13bceace690f66f8d5fa", size = 3503075, upload-time = "2026-04-24T14:37:26.826Z" },- { url = "https://files.pythonhosted.org/packages/82/bf/4f669e10b6bc38a731ee3400aed1a1e2d0a3e3cf411e72f6b320d3af0eaf/fastavro-1.12.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e367a84c9133018e0a3bc822abe78d7f1f9a6092991a0ec409468cf4ef260282", size = 3410900, upload-time = "2026-04-24T14:37:29.233Z" },- { url = "https://files.pythonhosted.org/packages/10/39/ecb19fdae4158a7730b5963fbf1b6d38d74678392d73083be518642af0c1/fastavro-1.12.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:044fafca0853e9ae14009de7763ac9e8e8f8b96f8a4e90bd58b695443266a370", size = 3335637, upload-time = "2026-04-24T14:37:31.472Z" },- { url = "https://files.pythonhosted.org/packages/32/f1/f21bd5319113e89ceceed2df840df21e9c5150d181db74b6ba80400f9f48/fastavro-1.12.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:afede7324822800e4f90e96b9514188a237a60f35e8e7a10b2129c10c78f6e4d", size = 3356664, upload-time = "2026-04-24T14:37:34.231Z" },-]-[[package]]name = "filelock"version = "3.20.3"@@ -1983,7 +1915,7 @@ wheels = [[[package]]name = "langchain"-version = "1.2.18"+version = "1.3.0a2"source = { editable = "." }dependencies = [{ name = "langchain-core" },@@ -2004,9 +1936,6 @@ azure-ai = [baseten = [{ name = "langchain-baseten" },]-cohere = [- { name = "langchain-cohere" },-]community = [{ name = "langchain-community" },]@@ -2085,7 +2014,6 @@ requires-dist = [{ name = "langchain-aws", marker = "extra == 'aws'" },{ name = "langchain-azure-ai", marker = "extra == 'azure-ai'" },{ name = "langchain-baseten", marker = "extra == 'baseten'", specifier = ">=0.2.0" },- { name = "langchain-cohere", marker = "extra == 'cohere'" },{ name = "langchain-community", marker = "extra == 'community'" },{ name = "langchain-core", editable = "../core" },{ name = "langchain-deepseek", marker = "extra == 'deepseek'" },@@ -2100,10 +2028,10 @@ requires-dist = [{ name = "langchain-perplexity", marker = "extra == 'perplexity'" },{ name = "langchain-together", marker = "extra == 'together'" },{ name = "langchain-xai", marker = "extra == 'xai'" },- { name = "langgraph", specifier = ">=1.1.10,<1.2.0" },+ { name = "langgraph", specifier = ">=1.2.0a5,<1.3.0" },{ name = "pydantic", specifier = ">=2.7.4,<3.0.0" },]-provides-extras = ["community", "anthropic", "openai", "azure-ai", "cohere", "google-vertexai", "google-genai", "fireworks", "ollama", "together", "mistralai", "huggingface", "groq", "aws", "baseten", "deepseek", "xai", "perplexity"]+provides-extras = ["community", "anthropic", "openai", "azure-ai", "google-vertexai", "google-genai", "fireworks", "ollama", "together", "mistralai", "huggingface", "groq", "aws", "baseten", "deepseek", "xai", "perplexity"][package.metadata.requires-dev]lint = [{ name = "ruff", specifier = ">=0.15.0,<0.16.0" }]@@ -2257,22 +2185,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/74/74/246f809a3741c21982f985ca0113ec92d3c84896308561cc4414823f6951/langchain_classic-1.0.0-py3-none-any.whl", hash = "sha256:97f71f150c10123f5511c08873f030e35ede52311d729a7688c721b4e1e01f33", size = 1040701, upload-time = "2025-10-17T16:02:46.35Z" },]-[[package]]-name = "langchain-cohere"-version = "0.5.1"-source = { registry = "https://pypi.org/simple" }-dependencies = [- { name = "cohere" },- { name = "langchain-community" },- { name = "langchain-core" },- { name = "pydantic" },- { name = "types-pyyaml" },-]-sdist = { url = "https://files.pythonhosted.org/packages/d6/d3/a890492d77ba46b01297398c7d614f3f8750f3224a36fca1076554ff19ff/langchain_cohere-0.5.1.tar.gz", hash = "sha256:11128c04e0cf3d0731b7db4af0fdc2edc41be135647fc1e534ab60a9236a01b0", size = 37207, upload-time = "2026-04-15T17:35:11.24Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/33/8a/b6a99085e0ac2fd97d831a30b964508fa79256dc0779cc6f8d0733a46fea/langchain_cohere-0.5.1-py3-none-any.whl", hash = "sha256:db58cd05b80340d903c31cbc402f7dcad87c8bbe57bb61b7b2a076bf7beeb7fb", size = 43013, upload-time = "2026-04-15T17:35:09.949Z" },-]-[[package]]name = "langchain-community"version = "0.4.1"@@ -2299,7 +2211,7 @@ wheels = [[[package]]name = "langchain-core"-version = "1.3.3"+version = "1.4.0"source = { editable = "../core" }dependencies = [{ name = "jsonpatch" },@@ -2316,7 +2228,7 @@ dependencies = [[package.metadata]requires-dist = [{ name = "jsonpatch", specifier = ">=1.33.0,<2.0.0" },- { name = "langchain-protocol", specifier = ">=0.0.10" },+ { name = "langchain-protocol", specifier = ">=0.0.14" },{ name = "langsmith", specifier = ">=0.3.45,<1.0.0" },{ name = "packaging", specifier = ">=23.2.0" },{ name = "pydantic", specifier = ">=2.7.4,<3.0.0" },@@ -2547,14 +2459,14 @@ wheels = [[[package]]name = "langchain-protocol"-version = "0.0.10"+version = "0.0.15"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "typing-extensions" },]-sdist = { url = "https://files.pythonhosted.org/packages/bf/c3/0d3911d3274f097040e92133f18a425980cd4085e72b6cd65add1f25327c/langchain_protocol-0.0.10.tar.gz", hash = "sha256:5bc530e0b350d3a15a3ab6889abb8132692a2c8a15eed536bce46624751acaaf", size = 6528, upload-time = "2026-04-23T17:31:34.212Z" }+sdist = { url = "https://files.pythonhosted.org/packages/4f/24/9777489d6fbbee64af0c8f96d4f840239c408cf694f3394672807dafc490/langchain_protocol-0.0.15.tar.gz", hash = "sha256:9ab2d11ee73944754f10e037e717098d3a6796f0e58afa9cadda6154e7655ade", size = 5862, upload-time = "2026-05-01T22:30:04.748Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/f8/11/6c89bc86b5494cfe29ee23420c398406cc147a09b5cf756e323070e358d7/langchain_protocol-0.0.10-py3-none-any.whl", hash = "sha256:040bb2ae966a06ffcd0051a1d1ca7e4926f12e951e83b07440cb80e0e8e12268", size = 6677, upload-time = "2026-04-23T17:31:33.367Z" },+ { url = "https://files.pythonhosted.org/packages/1d/7a/9c97a7b9cbe4c5dc6a44cdb1545450c28f0c8ce89b9c1f0ee7fbad896263/langchain_protocol-0.0.15-py3-none-any.whl", hash = "sha256:461eb794358f83d5e42635a5797799ffec7b4702314e34edf73ac21e75d3ef79", size = 6982, upload-time = "2026-05-01T22:30:03.877Z" },][[package]]@@ -2694,7 +2606,7 @@ wheels = [[[package]]name = "langgraph"-version = "1.1.10"+version = "1.2.0a7"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "langchain-core" },@@ -2704,35 +2616,35 @@ dependencies = [{ name = "pydantic" },{ name = "xxhash" },]-sdist = { url = "https://files.pythonhosted.org/packages/9a/b3/7dec224369c7938eb3227ff69542a0d0f517862a0d27945b8c395f2a781f/langgraph-1.1.10.tar.gz", hash = "sha256:3115beb58203283c98d8752a90c034f3432177d2979a1fe205f76e5f1b744500", size = 560685, upload-time = "2026-04-27T17:19:10.426Z" }+sdist = { url = "https://files.pythonhosted.org/packages/d9/ce/df390d7174df1a089cee99aadc004f9559a99cf672d01578c66782a7bcb4/langgraph-1.2.0a7.tar.gz", hash = "sha256:3dfb5a97aa991b77c9f8654d93273318e91788bafc3ba26f203a042447071c45", size = 678797, upload-time = "2026-05-04T19:35:24.443Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/80/07/057dc1aa7991115fca53f1fa6573a7cc0dd296c05360c672cc67fdb6245b/langgraph-1.1.10-py3-none-any.whl", hash = "sha256:8a4f163f72f4401648d0c11b48ee906947d938ba8cf1f474540fe591534f0d17", size = 173750, upload-time = "2026-04-27T17:19:09.073Z" },+ { url = "https://files.pythonhosted.org/packages/c0/c3/d73266b5801a752346cb3e235b506042a3a45d3bcb99d6f73dc649c48087/langgraph-1.2.0a7-py3-none-any.whl", hash = "sha256:b3ede4d3d27efd10dcc955b62b3ba43c0b0a2a963b150b41fc2e12e411350c92", size = 229121, upload-time = "2026-05-04T19:35:22.347Z" },][[package]]name = "langgraph-checkpoint"-version = "4.0.0"+version = "4.1.0a4"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "langchain-core" },{ name = "ormsgpack" },]-sdist = { url = "https://files.pythonhosted.org/packages/98/76/55a18c59dedf39688d72c4b06af73a5e3ea0d1a01bc867b88fbf0659f203/langgraph_checkpoint-4.0.0.tar.gz", hash = "sha256:814d1bd050fac029476558d8e68d87bce9009a0262d04a2c14b918255954a624", size = 137320, upload-time = "2026-01-12T20:30:26.38Z" }+sdist = { url = "https://files.pythonhosted.org/packages/b4/dc/53f2eb893a268e61f225b20be0e021152fb955b076a1366857ba1c3f46d3/langgraph_checkpoint-4.1.0a4.tar.gz", hash = "sha256:be3d0c702fa6e31f3820c47dbfa272c98c17aec2cdf050b8c488f3522d3ec8fa", size = 179885, upload-time = "2026-05-04T19:32:18.611Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/4a/de/ddd53b7032e623f3c7bcdab2b44e8bf635e468f62e10e5ff1946f62c9356/langgraph_checkpoint-4.0.0-py3-none-any.whl", hash = "sha256:3fa9b2635a7c5ac28b338f631abf6a030c3b508b7b9ce17c22611513b589c784", size = 46329, upload-time = "2026-01-12T20:30:25.2Z" },+ { url = "https://files.pythonhosted.org/packages/e9/c7/78dbe4bc02bb30c8a2520269bf146ecd2b17903586894b74eb95caef674c/langgraph_checkpoint-4.1.0a4-py3-none-any.whl", hash = "sha256:70e405bef16a51fcc831f78bda1e85cccc812ca5754685b44af03f84935917f1", size = 54664, upload-time = "2026-05-04T19:32:17.389Z" },][[package]]name = "langgraph-prebuilt"-version = "1.0.12"+version = "1.1.0a2"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "langchain-core" },{ name = "langgraph-checkpoint" },]-sdist = { url = "https://files.pythonhosted.org/packages/ed/8b/5fff4c63bbfef1475d577e13f5970f91955a4069d8dc4adbaeef92f36732/langgraph_prebuilt-1.0.12.tar.gz", hash = "sha256:edcb11ff29996def816243f267fb2c85c0a2e4fb618c275f3d238aee8dd6a5ec", size = 172831, upload-time = "2026-04-27T17:14:27.152Z" }+sdist = { url = "https://files.pythonhosted.org/packages/25/4a/591a5c39f318c5b3059504133aa58ca39b47c37e61cc71ac8bd42f546772/langgraph_prebuilt-1.1.0a2.tar.gz", hash = "sha256:0ed039cd83afee5a626d0e631fcae758c9a4d5d76ff45775c85c0f310827564d", size = 178837, upload-time = "2026-05-01T18:03:06.226Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/53/75/1e6e6fd478a1b1e643de03505570103dcb89c57c429c0fd3084d521e522e/langgraph_prebuilt-1.0.12-py3-none-any.whl", hash = "sha256:ab83822d2724d434d3536dc127b86c7d16fe3fb8dc02a89a683bc77b2e55f6e9", size = 37195, upload-time = "2026-04-27T17:14:25.788Z" },+ { url = "https://files.pythonhosted.org/packages/3c/e0/99653a3776d018c9382eae9167da257e7d0a831cb76829652a1d8ed83a8f/langgraph_prebuilt-1.1.0a2-py3-none-any.whl", hash = "sha256:6e59b8a37d897d926c44c5bc4c5f0348930fa95a9ecebfde6c5e825078fa9441", size = 41062, upload-time = "2026-05-01T18:03:05.254Z" },][[package]]@@ -4968,15 +4880,6 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/62/39/82c9d3e10979851847361d922a373bdfef4091020da7f893acfaf07c0225/typer-0.9.4-py3-none-any.whl", hash = "sha256:aa6c4a4e2329d868b80ecbaf16f807f2b54e192209d7ac9dd42691d63f7a54eb", size = 45973, upload-time = "2024-03-23T17:07:53.985Z" },]-[[package]]-name = "types-pyyaml"-version = "6.0.12.20260408"-source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/74/73/b759b1e413c31034cc01ecdfb96b38115d0ab4db55a752a3929f0cd449fd/types_pyyaml-6.0.12.20260408.tar.gz", hash = "sha256:92a73f2b8d7f39ef392a38131f76b970f8c66e4c42b3125ae872b7c93b556307", size = 17735, upload-time = "2026-04-08T04:30:50.974Z" }-wheels = [- { url = "https://files.pythonhosted.org/packages/1c/f0/c391068b86abb708882c6d75a08cd7d25b2c7227dab527b3a3685a3c635b/types_pyyaml-6.0.12.20260408-py3-none-any.whl", hash = "sha256:fbc42037d12159d9c801ebfcc79ebd28335a7c13b08a4cfbc6916df78fee9384", size = 20339, upload-time = "2026-04-08T04:30:50.113Z" },-]-[[package]]name = "types-requests"version = "2.31.0.6"diff --git a/libs/partners/anthropic/tests/integration_tests/test_chat_models.py b/libs/partners/anthropic/tests/integration_tests/test_chat_models.pyindex 113ae45c79..3c63ddd5d1 100644--- a/libs/partners/anthropic/tests/integration_tests/test_chat_models.py+++ b/libs/partners/anthropic/tests/integration_tests/test_chat_models.py@@ -6,7 +6,7 @@ import asyncioimport jsonimport osfrom base64 import b64encode-from typing import Any, Literal, cast+from typing import TYPE_CHECKING, Any, Literal, castimport anthropicimport httpx@@ -28,6 +28,14 @@ from langchain_core.messages import (from langchain_core.outputs import ChatGeneration, LLMResultfrom langchain_core.prompts import ChatPromptTemplatefrom langchain_core.tools import tool++if TYPE_CHECKING:+ from collections.abc import Awaitable++ from langchain_core.language_models.chat_model_stream import (+ AsyncChatModelStream,+ ChatModelStream,+ )from langchain_tests.utils.stream_lifecycle import assert_valid_event_streamfrom pydantic import BaseModel, Fieldfrom typing_extensions import TypedDict@@ -927,7 +935,10 @@ def test_agent_loop_streaming(llm_with_tools = llm.bind_tools([get_weather])input_message = HumanMessage("What is the weather in San Francisco, CA?")if use_v2_stream:- tool_call_message = llm_with_tools.stream_v2([input_message]).output+ tool_call_message = cast(+ "ChatModelStream",+ llm_with_tools.stream_events([input_message], version="v3"),+ ).outputelse:tool_call_message = llm_with_tools.invoke([input_message])assert isinstance(tool_call_message, AIMessage)@@ -938,8 +949,12 @@ def test_agent_loop_streaming(tool_message = get_weather.invoke(tool_call)assert isinstance(tool_message, ToolMessage)if use_v2_stream:- response = llm_with_tools.stream_v2(- [input_message, tool_call_message, tool_message]+ response = cast(+ "ChatModelStream",+ llm_with_tools.stream_events(+ [input_message, tool_call_message, tool_message],+ version="v3",+ ),).outputelse:response = llm_with_tools.invoke(@@ -954,8 +969,8 @@ def test_agent_loop_streaming(@pytest.mark.default_cassette("test_agent_loop_streaming.yaml.gz")@pytest.mark.vcr-async def test_agent_loop_streaming_astream_v2_v1() -> None:- """Async multi-turn through `astream_v2`.+async def test_agent_loop_streaming_astream_events_v3_v1() -> None:+ """Async multi-turn through `astream_events(version="v3")`.Mirrors `test_agent_loop_streaming` for `output_version="v1"` butexercises `AsyncChatModelStream` end-to-end.@@ -973,7 +988,12 @@ async def test_agent_loop_streaming_astream_v2_v1() -> None:)llm_with_tools = llm.bind_tools([get_weather])input_message = HumanMessage("What is the weather in San Francisco, CA?")- tool_call_message = await (await llm_with_tools.astream_v2([input_message]))+ tool_call_message = await (+ await cast(+ "Awaitable[AsyncChatModelStream]",+ llm_with_tools.astream_events([input_message], version="v3"),+ )+ )assert isinstance(tool_call_message, AIMessage)tool_calls = tool_call_message.tool_callsassert len(tool_calls) == 1@@ -981,8 +1001,12 @@ async def test_agent_loop_streaming_astream_v2_v1() -> None:tool_message = get_weather.invoke(tool_call)assert isinstance(tool_message, ToolMessage)response = await (- await llm_with_tools.astream_v2(- [input_message, tool_call_message, tool_message]+ await cast(+ "Awaitable[AsyncChatModelStream]",+ llm_with_tools.astream_events(+ [input_message, tool_call_message, tool_message],+ version="v3",+ ),))assert isinstance(response, AIMessage)@@ -1030,7 +1054,7 @@ def test_citations(output_version: Literal["v0", "v1"], *, use_v2_stream: bool)# Test streamingfull: BaseMessageif use_v2_stream:- full = llm.stream_v2(messages).output+ full = llm.stream_events(messages, version="v3").outputelse:aggregated: BaseMessageChunk | None = Nonefor chunk in llm.stream(messages):@@ -1124,7 +1148,7 @@ def test_thinking_v1(*, use_v2_stream: bool) -> None:# Test streamingfull: BaseMessageif use_v2_stream:- full = llm.stream_v2([input_message]).output+ full = llm.stream_events([input_message], version="v3").outputelse:aggregated: BaseMessageChunk | None = Nonefor chunk in llm.stream([input_message]):@@ -2618,10 +2642,10 @@ def _stable_blocks(blocks: Any) -> list[dict[str, Any]]:@pytest.mark.default_cassette("test_streaming_tool_call_v1_v2_parity.yaml.gz")@pytest.mark.vcrdef test_streaming_tool_call_v1_v2_parity() -> None:- """`AIMessage` parity between `stream()` reduction and `stream_v2().output`.+ """`AIMessage` parity between `stream()` and `stream_events(version="v3")` output.Runs the same forced-tool-call prompt through both the legacy chunk- stream (reduced with `AIMessageChunk.__add__`) and the `stream_v2`+ stream (reduced with `AIMessageChunk.__add__`) and the `stream_events(version="v3")`bridge path on a `v1`-output `ChatAnthropic`, then compares theresulting messages on path-independent invariants:@@ -2649,7 +2673,7 @@ def test_streaming_tool_call_v1_v2_parity() -> None:v1_full = chunk if v1_full is None else v1_full + chunkassert isinstance(v1_full, AIMessageChunk)- stream = with_tool.stream_v2(prompt)+ stream = cast("ChatModelStream", with_tool.stream_events(prompt, version="v3"))events = list(stream)assert_valid_event_stream(events)v2_message = stream.outputdiff --git a/libs/partners/anthropic/tests/unit_tests/test_chat_models.py b/libs/partners/anthropic/tests/unit_tests/test_chat_models.pyindex 710cc9d24e..61549b645f 100644--- a/libs/partners/anthropic/tests/unit_tests/test_chat_models.py+++ b/libs/partners/anthropic/tests/unit_tests/test_chat_models.py@@ -3053,15 +3053,15 @@ def test_no_task_budget_no_beta() -> None:assert "task-budgets-2026-03-13" not in betas-def test_anthropic_stream_v2_lifecycle() -> None:+def test_anthropic_stream_events_v3_lifecycle() -> None:"""Validate lifecycle events across a thinking + text + tool_use stream.Anthropic emits raw `content_block_start` / `content_block_delta` /`content_block_stop` events with integer `index` fields, interleavedwith `message_start` and `message_delta`. This test threads arealistic event sequence through `_stream` via a mocked raw client- and asserts that `stream_v2` produces a spec-conformant event- stream: paired start/finish per block, no interleaving, sequential+ and asserts that `stream_events(version="v3")` produces a spec-conformant+ event stream: paired start/finish per block, no interleaving, sequential`uint` wire indices."""from unittest.mock import patch@@ -3182,21 +3182,21 @@ def test_anthropic_stream_v2_lifecycle() -> None:return eventswith patch.object(llm, "_create", mock_create):- stream_events = list(llm.stream_v2("Test query"))+ stream_events = list(llm.stream_events("Test query", version="v3"))assert_valid_event_stream(stream_events)finishes = [e for e in stream_events if e["event"] == "content-block-finish"]- types = [f["content_block"]["type"] for f in finishes]+ types = [f["content"]["type"] for f in finishes]assert types == ["reasoning", "text", "tool_call"]wire_indices = [f["index"] for f in finishes]assert wire_indices == [0, 1, 2]# Content accumulation reaches content-block-finish intact.- reasoning_block = cast("dict[str, Any]", finishes[0]["content_block"])- text_block = cast("dict[str, Any]", finishes[1]["content_block"])- tool_block = cast("dict[str, Any]", finishes[2]["content_block"])+ reasoning_block = cast("dict[str, Any]", finishes[0]["content"])+ text_block = cast("dict[str, Any]", finishes[1]["content"])+ tool_block = cast("dict[str, Any]", finishes[2]["content"])assert reasoning_block["reasoning"] == "Let me think."assert text_block["text"] == "The answer is 42."assert tool_block["args"] == {"q": "weather"}@@ -3206,6 +3206,6 @@ def test_anthropic_stream_v2_lifecycle() -> None:# (protocol 0.0.9 moved the finish reason off the top-level event# and into `metadata`, where the bridge deposits the provider's raw# `stop_reason` alongside other response metadata).- message_finish = stream_events[-1]+ message_finish = cast("dict[str, Any]", stream_events[-1])assert message_finish["event"] == "message-finish"assert message_finish["metadata"]["stop_reason"] == "tool_use"diff --git a/libs/partners/anthropic/uv.lock b/libs/partners/anthropic/uv.lockindex 46f67f58c3..4406cb12e3 100644--- a/libs/partners/anthropic/uv.lock+++ b/libs/partners/anthropic/uv.lock@@ -10,6 +10,9 @@ resolution-markers = ["python_full_version < '3.11' and platform_python_implementation == 'PyPy'",]+[options]+prerelease-mode = "allow"+[manifest]constraints = [{ name = "pygments", specifier = ">=2.20.0" },@@ -510,7 +513,7 @@ wheels = [[[package]]name = "langchain"-version = "1.2.18"+version = "1.3.0a2"source = { editable = "../../langchain_v1" }dependencies = [{ name = "langchain-core" },@@ -524,7 +527,6 @@ requires-dist = [{ name = "langchain-aws", marker = "extra == 'aws'" },{ name = "langchain-azure-ai", marker = "extra == 'azure-ai'" },{ name = "langchain-baseten", marker = "extra == 'baseten'", specifier = ">=0.2.0" },- { name = "langchain-cohere", marker = "extra == 'cohere'" },{ name = "langchain-community", marker = "extra == 'community'" },{ name = "langchain-core", editable = "../../core" },{ name = "langchain-deepseek", marker = "extra == 'deepseek'" },@@ -539,10 +541,10 @@ requires-dist = [{ name = "langchain-perplexity", marker = "extra == 'perplexity'" },{ name = "langchain-together", marker = "extra == 'together'" },{ name = "langchain-xai", marker = "extra == 'xai'" },- { name = "langgraph", specifier = ">=1.1.10,<1.2.0" },+ { name = "langgraph", specifier = ">=1.2.0a5,<1.3.0" },{ name = "pydantic", specifier = ">=2.7.4,<3.0.0" },]-provides-extras = ["community", "anthropic", "openai", "azure-ai", "cohere", "google-vertexai", "google-genai", "fireworks", "ollama", "together", "mistralai", "huggingface", "groq", "aws", "baseten", "deepseek", "xai", "perplexity"]+provides-extras = ["community", "anthropic", "openai", "azure-ai", "google-vertexai", "google-genai", "fireworks", "ollama", "together", "mistralai", "huggingface", "groq", "aws", "baseten", "deepseek", "xai", "perplexity"][package.metadata.requires-dev]lint = [{ name = "ruff", specifier = ">=0.15.0,<0.16.0" }]@@ -661,7 +663,7 @@ typing = [[[package]]name = "langchain-core"-version = "1.3.3"+version = "1.4.0"source = { editable = "../../core" }dependencies = [{ name = "jsonpatch" },@@ -678,7 +680,7 @@ dependencies = [[package.metadata]requires-dist = [{ name = "jsonpatch", specifier = ">=1.33.0,<2.0.0" },- { name = "langchain-protocol", specifier = ">=0.0.10" },+ { name = "langchain-protocol", specifier = ">=0.0.14" },{ name = "langsmith", specifier = ">=0.3.45,<1.0.0" },{ name = "packaging", specifier = ">=23.2.0" },{ name = "pydantic", specifier = ">=2.7.4,<3.0.0" },@@ -723,14 +725,14 @@ typing = [[[package]]name = "langchain-protocol"-version = "0.0.10"+version = "0.0.14"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "typing-extensions" },]-sdist = { url = "https://files.pythonhosted.org/packages/bf/c3/0d3911d3274f097040e92133f18a425980cd4085e72b6cd65add1f25327c/langchain_protocol-0.0.10.tar.gz", hash = "sha256:5bc530e0b350d3a15a3ab6889abb8132692a2c8a15eed536bce46624751acaaf", size = 6528, upload-time = "2026-04-23T17:31:34.212Z" }+sdist = { url = "https://files.pythonhosted.org/packages/05/bf/efb5e2ed832e4d6d45590e25a9e5191986b291b543bc6a807b48bee070b0/langchain_protocol-0.0.14.tar.gz", hash = "sha256:bc1e8553122e6ede310280462d5813023a172ff2785ccbbdec54d43f3a15e5f2", size = 5862, upload-time = "2026-04-29T16:40:18.657Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/f8/11/6c89bc86b5494cfe29ee23420c398406cc147a09b5cf756e323070e358d7/langchain_protocol-0.0.10-py3-none-any.whl", hash = "sha256:040bb2ae966a06ffcd0051a1d1ca7e4926f12e951e83b07440cb80e0e8e12268", size = 6677, upload-time = "2026-04-23T17:31:33.367Z" },+ { url = "https://files.pythonhosted.org/packages/c2/e9/06c47ecb2aff08f83dfa30058da3bf86be64862c19569043ed5331bbeecd/langchain_protocol-0.0.14-py3-none-any.whl", hash = "sha256:ffc35089779bd8ca217015180cef5e660fc3b074efdaa0f2e95df73583f1a047", size = 6984, upload-time = "2026-04-29T16:40:17.841Z" },][[package]]@@ -780,7 +782,7 @@ typing = [[[package]]name = "langgraph"-version = "1.1.10"+version = "1.2.0a7"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "langchain-core" },@@ -790,35 +792,35 @@ dependencies = [{ name = "pydantic" },{ name = "xxhash" },]-sdist = { url = "https://files.pythonhosted.org/packages/9a/b3/7dec224369c7938eb3227ff69542a0d0f517862a0d27945b8c395f2a781f/langgraph-1.1.10.tar.gz", hash = "sha256:3115beb58203283c98d8752a90c034f3432177d2979a1fe205f76e5f1b744500", size = 560685, upload-time = "2026-04-27T17:19:10.426Z" }+sdist = { url = "https://files.pythonhosted.org/packages/d9/ce/df390d7174df1a089cee99aadc004f9559a99cf672d01578c66782a7bcb4/langgraph-1.2.0a7.tar.gz", hash = "sha256:3dfb5a97aa991b77c9f8654d93273318e91788bafc3ba26f203a042447071c45", size = 678797, upload-time = "2026-05-04T19:35:24.443Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/80/07/057dc1aa7991115fca53f1fa6573a7cc0dd296c05360c672cc67fdb6245b/langgraph-1.1.10-py3-none-any.whl", hash = "sha256:8a4f163f72f4401648d0c11b48ee906947d938ba8cf1f474540fe591534f0d17", size = 173750, upload-time = "2026-04-27T17:19:09.073Z" },+ { url = "https://files.pythonhosted.org/packages/c0/c3/d73266b5801a752346cb3e235b506042a3a45d3bcb99d6f73dc649c48087/langgraph-1.2.0a7-py3-none-any.whl", hash = "sha256:b3ede4d3d27efd10dcc955b62b3ba43c0b0a2a963b150b41fc2e12e411350c92", size = 229121, upload-time = "2026-05-04T19:35:22.347Z" },][[package]]name = "langgraph-checkpoint"-version = "4.0.0"+version = "4.1.0a4"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "langchain-core" },{ name = "ormsgpack" },]-sdist = { url = "https://files.pythonhosted.org/packages/98/76/55a18c59dedf39688d72c4b06af73a5e3ea0d1a01bc867b88fbf0659f203/langgraph_checkpoint-4.0.0.tar.gz", hash = "sha256:814d1bd050fac029476558d8e68d87bce9009a0262d04a2c14b918255954a624", size = 137320, upload-time = "2026-01-12T20:30:26.38Z" }+sdist = { url = "https://files.pythonhosted.org/packages/b4/dc/53f2eb893a268e61f225b20be0e021152fb955b076a1366857ba1c3f46d3/langgraph_checkpoint-4.1.0a4.tar.gz", hash = "sha256:be3d0c702fa6e31f3820c47dbfa272c98c17aec2cdf050b8c488f3522d3ec8fa", size = 179885, upload-time = "2026-05-04T19:32:18.611Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/4a/de/ddd53b7032e623f3c7bcdab2b44e8bf635e468f62e10e5ff1946f62c9356/langgraph_checkpoint-4.0.0-py3-none-any.whl", hash = "sha256:3fa9b2635a7c5ac28b338f631abf6a030c3b508b7b9ce17c22611513b589c784", size = 46329, upload-time = "2026-01-12T20:30:25.2Z" },+ { url = "https://files.pythonhosted.org/packages/e9/c7/78dbe4bc02bb30c8a2520269bf146ecd2b17903586894b74eb95caef674c/langgraph_checkpoint-4.1.0a4-py3-none-any.whl", hash = "sha256:70e405bef16a51fcc831f78bda1e85cccc812ca5754685b44af03f84935917f1", size = 54664, upload-time = "2026-05-04T19:32:17.389Z" },][[package]]name = "langgraph-prebuilt"-version = "1.0.12"+version = "1.1.0a2"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "langchain-core" },{ name = "langgraph-checkpoint" },]-sdist = { url = "https://files.pythonhosted.org/packages/ed/8b/5fff4c63bbfef1475d577e13f5970f91955a4069d8dc4adbaeef92f36732/langgraph_prebuilt-1.0.12.tar.gz", hash = "sha256:edcb11ff29996def816243f267fb2c85c0a2e4fb618c275f3d238aee8dd6a5ec", size = 172831, upload-time = "2026-04-27T17:14:27.152Z" }+sdist = { url = "https://files.pythonhosted.org/packages/25/4a/591a5c39f318c5b3059504133aa58ca39b47c37e61cc71ac8bd42f546772/langgraph_prebuilt-1.1.0a2.tar.gz", hash = "sha256:0ed039cd83afee5a626d0e631fcae758c9a4d5d76ff45775c85c0f310827564d", size = 178837, upload-time = "2026-05-01T18:03:06.226Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/53/75/1e6e6fd478a1b1e643de03505570103dcb89c57c429c0fd3084d521e522e/langgraph_prebuilt-1.0.12-py3-none-any.whl", hash = "sha256:ab83822d2724d434d3536dc127b86c7d16fe3fb8dc02a89a683bc77b2e55f6e9", size = 37195, upload-time = "2026-04-27T17:14:25.788Z" },+ { url = "https://files.pythonhosted.org/packages/3c/e0/99653a3776d018c9382eae9167da257e7d0a831cb76829652a1d8ed83a8f/langgraph_prebuilt-1.1.0a2-py3-none-any.whl", hash = "sha256:6e59b8a37d897d926c44c5bc4c5f0348930fa95a9ecebfde6c5e825078fa9441", size = 41062, upload-time = "2026-05-01T18:03:05.254Z" },][[package]]diff --git a/libs/partners/openai/tests/integration_tests/chat_models/test_base.py b/libs/partners/openai/tests/integration_tests/chat_models/test_base.pyindex d939877346..56123308fd 100644--- a/libs/partners/openai/tests/integration_tests/chat_models/test_base.py+++ b/libs/partners/openai/tests/integration_tests/chat_models/test_base.py@@ -6,7 +6,7 @@ import osfrom collections.abc import AsyncIteratorfrom pathlib import Pathfrom textwrap import dedent-from typing import Any, Literal, cast+from typing import TYPE_CHECKING, Any, Literal, castimport httpximport pytest@@ -29,6 +29,9 @@ from typing_extensions import TypedDictfrom langchain_openai import ChatOpenAIfrom tests.unit_tests.fake.callbacks import FakeCallbackHandler+if TYPE_CHECKING:+ from langchain_core.language_models.chat_model_stream import ChatModelStream+MAX_TOKEN_COUNT = 100@@ -1289,7 +1292,7 @@ class _Person(BaseModel):@pytest.mark.vcrdef test_streaming_tool_call_v1_v2_parity() -> None:- """`stream()` and `stream_v2()` must agree on their final `AIMessage`.+ """`stream()` and `stream_events(version="v3")` agree on their final `AIMessage`.Both paths are invoked against the same HTTP response (the cassette'ssingle recorded interaction, replayed for both calls via@@ -1310,7 +1313,7 @@ def test_streaming_tool_call_v1_v2_parity() -> None:v1 = chunk if v1 is None else v1 + chunkassert isinstance(v1, AIMessageChunk)- stream = with_tool.stream_v2(prompt)+ stream = cast("ChatModelStream", with_tool.stream_events(prompt, version="v3"))events = list(stream)assert_valid_event_stream(events)v2 = stream.outputdiff --git a/libs/partners/openai/tests/integration_tests/chat_models/test_responses_api.py b/libs/partners/openai/tests/integration_tests/chat_models/test_responses_api.pyindex 33531867c8..22c30cbe31 100644--- a/libs/partners/openai/tests/integration_tests/chat_models/test_responses_api.py+++ b/libs/partners/openai/tests/integration_tests/chat_models/test_responses_api.py@@ -3,7 +3,7 @@import base64import jsonimport os-from typing import Annotated, Any, Literal, cast+from typing import TYPE_CHECKING, Annotated, Any, Literal, castimport openaiimport pytest@@ -32,6 +32,14 @@ from typing_extensions import TypedDictfrom langchain_openai import ChatOpenAI, custom_toolfrom langchain_openai.chat_models.base import _convert_to_openai_response_format+if TYPE_CHECKING:+ from collections.abc import Awaitable++ from langchain_core.language_models.chat_model_stream import (+ AsyncChatModelStream,+ ChatModelStream,+ )+MODEL_NAME = "gpt-4o-mini"@@ -113,9 +121,10 @@ def test_web_search(# Test streamingfull: BaseMessageif use_v2_stream:- full = llm.stream_v2(+ full = llm.stream_events("What was a positive news story from today?",tools=[{"type": "web_search_preview"}],+ version="v3",).outputelse:aggregated: BaseMessageChunk | None = None@@ -284,7 +293,10 @@ def test_agent_loop_streaming(llm_with_tools = llm.bind_tools([get_weather])input_message = HumanMessage("What is the weather in San Francisco, CA?")if use_v2_stream:- tool_call_message = llm_with_tools.stream_v2([input_message]).output+ tool_call_message = cast(+ "ChatModelStream",+ llm_with_tools.stream_events([input_message], version="v3"),+ ).outputelse:tool_call_message = llm_with_tools.invoke([input_message])assert isinstance(tool_call_message, AIMessage)@@ -294,8 +306,12 @@ def test_agent_loop_streaming(tool_message = get_weather.invoke(tool_call)assert isinstance(tool_message, ToolMessage)if use_v2_stream:- response = llm_with_tools.stream_v2(- [input_message, tool_call_message, tool_message]+ response = cast(+ "ChatModelStream",+ llm_with_tools.stream_events(+ [input_message, tool_call_message, tool_message],+ version="v3",+ ),).outputelse:response = llm_with_tools.invoke(@@ -310,8 +326,8 @@ def test_agent_loop_streaming(@pytest.mark.default_cassette("test_agent_loop_streaming.yaml.gz")@pytest.mark.vcr-async def test_agent_loop_streaming_astream_v2_v1() -> None:- """Async multi-turn through `astream_v2`.+async def test_agent_loop_streaming_astream_events_v3_v1() -> None:+ """Async multi-turn through `astream_events(version="v3")`.Mirrors `test_agent_loop_streaming` for `output_version="v1"` butexercises `AsyncChatModelStream` end-to-end: aggregation in the@@ -335,7 +351,10 @@ async def test_agent_loop_streaming_astream_v2_v1() -> None:)llm_with_tools = llm.bind_tools([get_weather])input_message = HumanMessage("What is the weather in San Francisco, CA?")- stream = await llm_with_tools.astream_v2([input_message])+ stream = await cast(+ "Awaitable[AsyncChatModelStream]",+ llm_with_tools.astream_events([input_message], version="v3"),+ )tool_call_message = await streamassert isinstance(tool_call_message, AIMessage)tool_calls = tool_call_message.tool_calls@@ -343,8 +362,12 @@ async def test_agent_loop_streaming_astream_v2_v1() -> None:tool_call = tool_calls[0]tool_message = get_weather.invoke(tool_call)assert isinstance(tool_message, ToolMessage)- stream = await llm_with_tools.astream_v2(- [input_message, tool_call_message, tool_message]+ stream = await cast(+ "Awaitable[AsyncChatModelStream]",+ llm_with_tools.astream_events(+ [input_message, tool_call_message, tool_message],+ version="v3",+ ),)response = await streamassert isinstance(response, AIMessage)@@ -647,7 +670,7 @@ def test_stream_reasoning_summary(}response_1: BaseMessageif use_v2_stream:- response_1 = llm.stream_v2([message_1]).output+ response_1 = llm.stream_events([message_1], version="v3").outputelse:aggregated: BaseMessageChunk | None = Nonefor chunk in llm.stream([message_1]):@@ -769,7 +792,10 @@ def test_code_interpreter(full: BaseMessageif use_v2_stream:- full = llm_with_tools.stream_v2([input_message]).output+ full = cast(+ "ChatModelStream",+ llm_with_tools.stream_events([input_message], version="v3"),+ ).outputelse:aggregated: BaseMessageChunk | None = Nonefor chunk in llm_with_tools.stream([input_message]):@@ -933,7 +959,10 @@ def test_mcp_builtin_zdr_v1(use_v2_stream: bool) -> None:}full: BaseMessageif use_v2_stream:- full = llm_with_tools.stream_v2([input_message]).output+ full = cast(+ "ChatModelStream",+ llm_with_tools.stream_events([input_message], version="v3"),+ ).outputelse:aggregated: BaseMessageChunk | None = Nonefor chunk in llm_with_tools.stream([input_message]):@@ -1365,7 +1394,7 @@ def test_compaction_streaming(def _run(messages: list) -> AIMessage:if use_v2_stream:- return llm.stream_v2(messages).output+ return llm.stream_events(messages, version="v3").outputresult = llm.invoke(messages)assert isinstance(result, AIMessage)return result@@ -1746,7 +1775,7 @@ def test_client_executed_tool_search() -> None:@pytest.mark.default_cassette("test_reasoning_text_v1_v2_parity.yaml.gz")@pytest.mark.vcrdef test_reasoning_text_v1_v2_parity() -> None:- """`stream()` and `stream_v2()` must agree on reasoning + text output.+ """`stream()` and `stream_events(version="v3")` agree on reasoning + text.Exercises the non-tool-call branch of the parity claim: a reasoningmodel (`o4-mini` via the Responses API) produces one or more@@ -1767,7 +1796,7 @@ def test_reasoning_text_v1_v2_parity() -> None:v1 = chunk if v1 is None else v1 + chunkassert isinstance(v1, AIMessageChunk)- stream = llm.stream_v2([prompt])+ stream = llm.stream_events([prompt], version="v3")events = list(stream)assert_valid_event_stream(events)v2 = stream.outputdiff --git a/libs/partners/openai/tests/unit_tests/chat_models/test_base.py b/libs/partners/openai/tests/unit_tests/chat_models/test_base.pyindex 88d1b97aa6..08b0850fd5 100644--- a/libs/partners/openai/tests/unit_tests/chat_models/test_base.py+++ b/libs/partners/openai/tests/unit_tests/chat_models/test_base.py@@ -616,8 +616,8 @@ def test_openai_stream(mock_openai_completion: list) -> None:assert "stream_options" not in call_kwargs[-1]-def test_openai_stream_v2_lifecycle(mock_openai_completion: list) -> None:- """`stream_v2` on chat completions emits a spec-conformant lifecycle."""+def test_openai_stream_events_v3_lifecycle(mock_openai_completion: list) -> None:+ """`stream_events(version="v3")` on chat completions emits a valid lifecycle."""from langchain_tests.utils.stream_lifecycle import assert_valid_event_streamllm = ChatOpenAI(model="gpt-4o")@@ -628,13 +628,13 @@ def test_openai_stream_v2_lifecycle(mock_openai_completion: list) -> None:mock_client.create = mock_createwith patch.object(llm, "client", mock_client):- events = list(llm.stream_v2("你的名字叫什么?只回答名字"))+ events = list(llm.stream_events("你的名字叫什么?只回答名字", version="v3"))assert_valid_event_stream(events)# At minimum, a text block with the accumulated answer.finishes = [e for e in events if e["event"] == "content-block-finish"]assert len(finishes) >= 1- text_finishes = [f for f in finishes if f["content_block"]["type"] == "text"]+ text_finishes = [f for f in finishes if f["content"]["type"] == "text"]assert len(text_finishes) == 1diff --git a/libs/partners/openai/tests/unit_tests/chat_models/test_responses_stream.py b/libs/partners/openai/tests/unit_tests/chat_models/test_responses_stream.pyindex 1a4edfca60..5f218cd9be 100644--- a/libs/partners/openai/tests/unit_tests/chat_models/test_responses_stream.py+++ b/libs/partners/openai/tests/unit_tests/chat_models/test_responses_stream.py@@ -763,8 +763,8 @@ def test_responses_stream(output_version: str, expected_content: list[dict]) ->assert dumped == payload["input"][idx]-def test_responses_stream_v2_emits_reasoning_lifecycle() -> None:- """`stream_v2` must emit `content-block-finish` events for reasoning blocks.+def test_responses_stream_events_v3_emits_reasoning_lifecycle() -> None:+ """v3 streaming emits `content-block-finish` events for reasoning blocks.Regression test: the protocol bridge should surface the full lifecycle(`content-block-start` / `content-block-delta` / `content-block-finish`)@@ -779,21 +779,19 @@ def test_responses_stream_v2_emits_reasoning_lifecycle() -> None:mock_client.responses.create = mock_createwith patch.object(llm, "root_client", mock_client):- events = list(llm.stream_v2("test"))+ events = list(llm.stream_events("test", version="v3"))assert_valid_event_stream(events)reasoning_starts = [efor e in events- if e["event"] == "content-block-start"- and e["content_block"]["type"] == "reasoning"+ if e["event"] == "content-block-start" and e["content"]["type"] == "reasoning"]reasoning_finishes = [efor e in events- if e["event"] == "content-block-finish"- and e["content_block"]["type"] == "reasoning"+ if e["event"] == "content-block-finish" and e["content"]["type"] == "reasoning"]# The mock stream carries four reasoning summary parts (two per reasoning@@ -803,9 +801,7 @@ def test_responses_stream_v2_emits_reasoning_lifecycle() -> None:f"expected 4 reasoning start events, got {len(reasoning_starts)}")all_finish_types = [- e["content_block"]["type"]- for e in events- if e["event"] == "content-block-finish"+ e["content"]["type"] for e in events if e["event"] == "content-block-finish"]assert len(reasoning_finishes) == 4, (f"expected 4 reasoning finish events, got {len(reasoning_finishes)}: "@@ -814,8 +810,7 @@ def test_responses_stream_v2_emits_reasoning_lifecycle() -> None:# Finish events must carry the accumulated reasoning text.reasoning_texts = [- cast("dict[str, Any]", f["content_block"])["reasoning"]- for f in reasoning_finishes+ cast("dict[str, Any]", f["content"])["reasoning"] for f in reasoning_finishes]assert reasoning_texts == ["reasoning block one",diff --git a/libs/partners/openai/uv.lock b/libs/partners/openai/uv.lockindex 69e0e720ab..8de9891486 100644--- a/libs/partners/openai/uv.lock+++ b/libs/partners/openai/uv.lock@@ -10,6 +10,9 @@ resolution-markers = ["python_full_version < '3.11' and platform_python_implementation != 'PyPy'",]+[options]+prerelease-mode = "allow"+[manifest]constraints = [{ name = "pygments", specifier = ">=2.20.0" },@@ -559,7 +562,7 @@ wheels = [[[package]]name = "langchain"-version = "1.2.18"+version = "1.3.0a2"source = { editable = "../../langchain_v1" }dependencies = [{ name = "langchain-core" },@@ -573,7 +576,6 @@ requires-dist = [{ name = "langchain-aws", marker = "extra == 'aws'" },{ name = "langchain-azure-ai", marker = "extra == 'azure-ai'" },{ name = "langchain-baseten", marker = "extra == 'baseten'", specifier = ">=0.2.0" },- { name = "langchain-cohere", marker = "extra == 'cohere'" },{ name = "langchain-community", marker = "extra == 'community'" },{ name = "langchain-core", editable = "../../core" },{ name = "langchain-deepseek", marker = "extra == 'deepseek'" },@@ -588,10 +590,10 @@ requires-dist = [{ name = "langchain-perplexity", marker = "extra == 'perplexity'" },{ name = "langchain-together", marker = "extra == 'together'" },{ name = "langchain-xai", marker = "extra == 'xai'" },- { name = "langgraph", specifier = ">=1.1.10,<1.2.0" },+ { name = "langgraph", specifier = ">=1.2.0a5,<1.3.0" },{ name = "pydantic", specifier = ">=2.7.4,<3.0.0" },]-provides-extras = ["community", "anthropic", "openai", "azure-ai", "cohere", "google-vertexai", "google-genai", "fireworks", "ollama", "together", "mistralai", "huggingface", "groq", "aws", "baseten", "deepseek", "xai", "perplexity"]+provides-extras = ["community", "anthropic", "openai", "azure-ai", "google-vertexai", "google-genai", "fireworks", "ollama", "together", "mistralai", "huggingface", "groq", "aws", "baseten", "deepseek", "xai", "perplexity"][package.metadata.requires-dev]lint = [{ name = "ruff", specifier = ">=0.15.0,<0.16.0" }]@@ -625,7 +627,7 @@ typing = [[[package]]name = "langchain-core"-version = "1.3.3"+version = "1.4.0"source = { editable = "../../core" }dependencies = [{ name = "jsonpatch" },@@ -642,7 +644,7 @@ dependencies = [[package.metadata]requires-dist = [{ name = "jsonpatch", specifier = ">=1.33.0,<2.0.0" },- { name = "langchain-protocol", specifier = ">=0.0.10" },+ { name = "langchain-protocol", specifier = ">=0.0.14" },{ name = "langsmith", specifier = ">=0.3.45,<1.0.0" },{ name = "packaging", specifier = ">=23.2.0" },{ name = "pydantic", specifier = ">=2.7.4,<3.0.0" },@@ -774,14 +776,14 @@ typing = [[[package]]name = "langchain-protocol"-version = "0.0.10"+version = "0.0.14"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "typing-extensions" },]-sdist = { url = "https://files.pythonhosted.org/packages/bf/c3/0d3911d3274f097040e92133f18a425980cd4085e72b6cd65add1f25327c/langchain_protocol-0.0.10.tar.gz", hash = "sha256:5bc530e0b350d3a15a3ab6889abb8132692a2c8a15eed536bce46624751acaaf", size = 6528, upload-time = "2026-04-23T17:31:34.212Z" }+sdist = { url = "https://files.pythonhosted.org/packages/05/bf/efb5e2ed832e4d6d45590e25a9e5191986b291b543bc6a807b48bee070b0/langchain_protocol-0.0.14.tar.gz", hash = "sha256:bc1e8553122e6ede310280462d5813023a172ff2785ccbbdec54d43f3a15e5f2", size = 5862, upload-time = "2026-04-29T16:40:18.657Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/f8/11/6c89bc86b5494cfe29ee23420c398406cc147a09b5cf756e323070e358d7/langchain_protocol-0.0.10-py3-none-any.whl", hash = "sha256:040bb2ae966a06ffcd0051a1d1ca7e4926f12e951e83b07440cb80e0e8e12268", size = 6677, upload-time = "2026-04-23T17:31:33.367Z" },+ { url = "https://files.pythonhosted.org/packages/c2/e9/06c47ecb2aff08f83dfa30058da3bf86be64862c19569043ed5331bbeecd/langchain_protocol-0.0.14-py3-none-any.whl", hash = "sha256:ffc35089779bd8ca217015180cef5e660fc3b074efdaa0f2e95df73583f1a047", size = 6984, upload-time = "2026-04-29T16:40:17.841Z" },][[package]]@@ -831,7 +833,7 @@ typing = [[[package]]name = "langgraph"-version = "1.1.10"+version = "1.2.0a7"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "langchain-core" },@@ -841,35 +843,35 @@ dependencies = [{ name = "pydantic" },{ name = "xxhash" },]-sdist = { url = "https://files.pythonhosted.org/packages/9a/b3/7dec224369c7938eb3227ff69542a0d0f517862a0d27945b8c395f2a781f/langgraph-1.1.10.tar.gz", hash = "sha256:3115beb58203283c98d8752a90c034f3432177d2979a1fe205f76e5f1b744500", size = 560685, upload-time = "2026-04-27T17:19:10.426Z" }+sdist = { url = "https://files.pythonhosted.org/packages/d9/ce/df390d7174df1a089cee99aadc004f9559a99cf672d01578c66782a7bcb4/langgraph-1.2.0a7.tar.gz", hash = "sha256:3dfb5a97aa991b77c9f8654d93273318e91788bafc3ba26f203a042447071c45", size = 678797, upload-time = "2026-05-04T19:35:24.443Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/80/07/057dc1aa7991115fca53f1fa6573a7cc0dd296c05360c672cc67fdb6245b/langgraph-1.1.10-py3-none-any.whl", hash = "sha256:8a4f163f72f4401648d0c11b48ee906947d938ba8cf1f474540fe591534f0d17", size = 173750, upload-time = "2026-04-27T17:19:09.073Z" },+ { url = "https://files.pythonhosted.org/packages/c0/c3/d73266b5801a752346cb3e235b506042a3a45d3bcb99d6f73dc649c48087/langgraph-1.2.0a7-py3-none-any.whl", hash = "sha256:b3ede4d3d27efd10dcc955b62b3ba43c0b0a2a963b150b41fc2e12e411350c92", size = 229121, upload-time = "2026-05-04T19:35:22.347Z" },][[package]]name = "langgraph-checkpoint"-version = "4.0.0"+version = "4.1.0a4"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "langchain-core" },{ name = "ormsgpack" },]-sdist = { url = "https://files.pythonhosted.org/packages/98/76/55a18c59dedf39688d72c4b06af73a5e3ea0d1a01bc867b88fbf0659f203/langgraph_checkpoint-4.0.0.tar.gz", hash = "sha256:814d1bd050fac029476558d8e68d87bce9009a0262d04a2c14b918255954a624", size = 137320, upload-time = "2026-01-12T20:30:26.38Z" }+sdist = { url = "https://files.pythonhosted.org/packages/b4/dc/53f2eb893a268e61f225b20be0e021152fb955b076a1366857ba1c3f46d3/langgraph_checkpoint-4.1.0a4.tar.gz", hash = "sha256:be3d0c702fa6e31f3820c47dbfa272c98c17aec2cdf050b8c488f3522d3ec8fa", size = 179885, upload-time = "2026-05-04T19:32:18.611Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/4a/de/ddd53b7032e623f3c7bcdab2b44e8bf635e468f62e10e5ff1946f62c9356/langgraph_checkpoint-4.0.0-py3-none-any.whl", hash = "sha256:3fa9b2635a7c5ac28b338f631abf6a030c3b508b7b9ce17c22611513b589c784", size = 46329, upload-time = "2026-01-12T20:30:25.2Z" },+ { url = "https://files.pythonhosted.org/packages/e9/c7/78dbe4bc02bb30c8a2520269bf146ecd2b17903586894b74eb95caef674c/langgraph_checkpoint-4.1.0a4-py3-none-any.whl", hash = "sha256:70e405bef16a51fcc831f78bda1e85cccc812ca5754685b44af03f84935917f1", size = 54664, upload-time = "2026-05-04T19:32:17.389Z" },][[package]]name = "langgraph-prebuilt"-version = "1.0.13"+version = "1.1.0a2"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "langchain-core" },{ name = "langgraph-checkpoint" },]-sdist = { url = "https://files.pythonhosted.org/packages/b5/a4/f8ac75fa7c503103f0cf7680944e28bbaaef74c19a8d163d7346869cc369/langgraph_prebuilt-1.0.13.tar.gz", hash = "sha256:ad219782a80e1718e7e7794de49e0ae307111d45cbcffab9a52725a66a609456", size = 172913, upload-time = "2026-04-30T01:48:15.742Z" }+sdist = { url = "https://files.pythonhosted.org/packages/25/4a/591a5c39f318c5b3059504133aa58ca39b47c37e61cc71ac8bd42f546772/langgraph_prebuilt-1.1.0a2.tar.gz", hash = "sha256:0ed039cd83afee5a626d0e631fcae758c9a4d5d76ff45775c85c0f310827564d", size = 178837, upload-time = "2026-05-01T18:03:06.226Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/69/ef/5ada0bef4013ef5ae53a0ca1de5736517f1076a54d313f156ca545ec65d5/langgraph_prebuilt-1.0.13-py3-none-any.whl", hash = "sha256:7055e9fad41fbd3593800aed0aea0a6e974b17f33ed51b80d3d3a031212dd7c0", size = 37214, upload-time = "2026-04-30T01:48:14.507Z" },+ { url = "https://files.pythonhosted.org/packages/3c/e0/99653a3776d018c9382eae9167da257e7d0a831cb76829652a1d8ed83a8f/langgraph_prebuilt-1.1.0a2-py3-none-any.whl", hash = "sha256:6e59b8a37d897d926c44c5bc4c5f0348930fa95a9ecebfde6c5e825078fa9441", size = 41062, upload-time = "2026-05-01T18:03:05.254Z" },][[package]]diff --git a/libs/standard-tests/langchain_tests/integration_tests/chat_models.py b/libs/standard-tests/langchain_tests/integration_tests/chat_models.pyindex 02d842ca0a..e09ba9bfed 100644--- a/libs/standard-tests/langchain_tests/integration_tests/chat_models.py+++ b/libs/standard-tests/langchain_tests/integration_tests/chat_models.py@@ -912,25 +912,26 @@ class ChatModelIntegrationTests(ChatModelTests):f"got {last_chunk.chunk_position!r}")- def test_stream_v2(self, model: BaseChatModel) -> None:- """Test that `model.stream_v2(simple_message)` works.+ def test_stream_events_v3(self, model: BaseChatModel) -> None:+ """Test that `model.stream_events("Hello", version="v3")` works.Exercises the content-block-centric streaming protocol. Passing this- test indicates the model participates in `stream_v2` either natively- (via `_stream_chat_model_events`) or through the compat bridge that+ test indicates the model participates in `stream_events(version="v3")` either+ natively (via `_stream_chat_model_events`) or through the compat bridge thatconverts `_stream` chunks into protocol events.??? question "Troubleshooting"First, debug`langchain_tests.integration_tests.chat_models.ChatModelIntegrationTests.test_stream`- — `stream_v2` falls back to the same `_stream` path via the compat- bridge when the model does not implement+ — `stream_events(version="v3")` falls back to the same+ `_stream` path via the compat bridge when the model does not+ implement`_stream_chat_model_events`. If `test_stream` passes but this doesnot, inspect the raised lifecycle violation: it identifies theevent index and the rule broken."""- stream = model.stream_v2("Hello")+ stream = model.stream_events("Hello", version="v3")assert isinstance(stream, ChatModelStream)events = list(stream)@@ -942,13 +943,13 @@ class ChatModelIntegrationTests(ChatModelTests):assert message.contentassert len(message.content_blocks) == 1assert message.content_blocks[0]["type"] == "text"- # `stream_v2` always assembles content as v1 protocol blocks.+ # `stream_events(version="v3")` always assembles content as v1 protocol blocks.assert message.response_metadata.get("output_version") == "v1"- async def test_astream_v2(self, model: BaseChatModel) -> None:- """Test that `await model.astream_v2(simple_message)` works.+ async def test_astream_events_v3(self, model: BaseChatModel) -> None:+ """Test that `await model.astream_events("Hello", version="v3")` works.- Async counterpart to `test_stream_v2`. Exercises the+ Async counterpart to `test_stream_events_v3`. Exercises the`AsyncChatModelStream` path end-to-end: the background producer task,replay-buffer-backed event iteration, and the awaitable `output`projection.@@ -961,7 +962,7 @@ class ChatModelIntegrationTests(ChatModelTests):lifecycle violation; it identifies the event index and the rulebroken."""- stream = await model.astream_v2("Hello")+ stream = await model.astream_events("Hello", version="v3")assert isinstance(stream, AsyncChatModelStream)events = [event async for event in stream]diff --git a/libs/standard-tests/langchain_tests/utils/stream_lifecycle.py b/libs/standard-tests/langchain_tests/utils/stream_lifecycle.pyindex 29bb02ae9d..4e294caea4 100644--- a/libs/standard-tests/langchain_tests/utils/stream_lifecycle.py+++ b/libs/standard-tests/langchain_tests/utils/stream_lifecycle.py@@ -1,13 +1,14 @@"""Validator for LangChain content-block protocol event streams.-Checks that an event stream emitted by a chat model (via `stream_v2`,+Checks that an event stream emitted by a chat model (via `stream_events(version="v3")`,or by the compat bridge's `chunks_to_events` / `message_to_events`)conforms to the protocol lifecycle rules:- `message-start` opens and `message-finish` closes the stream.-- Content blocks do not interleave: each block runs+- Content blocks may interleave: each block index runs`content-block-start` → optional `content-block-delta`s →- `content-block-finish` before the next block begins.+ `content-block-finish`, while other block indices may start or receive+ deltas before that block finishes.- Wire indices on content-block events are sequential `uint` valuesstarting at 0.- For deltaable block types (`text`, `reasoning`, `tool_call_chunk`,@@ -37,7 +38,7 @@ def assert_valid_event_stream(events: Iterable[Any]) -> None:Args:events: Iterable of protocol event dicts (as yielded by- `stream_v2` or `chunks_to_events`).+ `stream_events(version="v3")` or `chunks_to_events`).Raises:AssertionError: On the first lifecycle violation found. The@@ -71,7 +72,7 @@ def assert_valid_event_stream(events: Iterable[Any]) -> None:"`message-finish` must be the final event")- open_idx: int | None = None+ open_indices: set[int] = set()expected_next_idx = 0start_events: dict[int, dict[str, Any]] = {}finish_events: dict[int, dict[str, Any]] = {}@@ -83,8 +84,9 @@ def assert_valid_event_stream(events: Iterable[Any]) -> None:assert i == 0, f"duplicate `message-start` at event {i}"continueif ev == "message-finish":- assert open_idx is None, (- f"`message-finish` while block {open_idx} still open (event {i})"+ assert not open_indices, (+ f"`message-finish` while blocks {sorted(open_indices)} "+ f"still open (event {i})")continueif ev == "error":@@ -102,36 +104,41 @@ def assert_valid_event_stream(events: Iterable[Any]) -> None:assert idx == expected_next_idx, (f"expected next wire index {expected_next_idx}, got {idx} at event {i}")- assert open_idx is None, (- f"content-block-start at idx={idx} while block {open_idx} "- f"still open (event {i}); blocks must not interleave"+ assert idx not in start_events, (+ f"duplicate content-block-start for idx={idx} at event {i}")- open_idx = idx- start_events[idx] = event["content_block"]+ open_indices.add(idx)+ start_events[idx] = event.get("content") or event["content_block"]delta_accum[idx] = {}expected_next_idx += 1elif ev == "content-block-delta":idx = event["index"]- assert idx == open_idx, (- f"content-block-delta at idx={idx} but currently-open block is "- f"{open_idx} (event {i})"+ assert idx in open_indices, (+ f"content-block-delta at idx={idx} but that block is not open "+ f"(event {i})")- block = event["content_block"]- _accumulate_delta(delta_accum[idx], block)+ delta = event.get("delta")+ if delta is None and "content_block" in event:+ delta = _legacy_block_to_delta(event["content_block"])+ _accumulate_delta(delta_accum[idx], delta)elif ev == "content-block-finish":idx = event["index"]- assert idx == open_idx, (- f"content-block-finish at idx={idx} but currently-open block is "- f"{open_idx} (event {i})"+ assert idx in open_indices, (+ f"content-block-finish at idx={idx} but that block is not open "+ f"(event {i})")- finish_events[idx] = event["content_block"]- open_idx = None+ assert idx not in finish_events, (+ f"duplicate content-block-finish for idx={idx} at event {i}"+ )+ finish_events[idx] = event.get("content") or event["content_block"]+ open_indices.remove(idx)else:# Unknown event types are accepted; the CDDL allows extensions.continue- assert open_idx is None, (- f"block {open_idx} still open at end of stream — no content-block-finish"+ assert not open_indices, (+ f"blocks {sorted(open_indices)} still open at end of stream — "+ "no content-block-finish")missing = set(start_events) - set(finish_events)assert not missing, (@@ -143,21 +150,40 @@ def assert_valid_event_stream(events: Iterable[Any]) -> None:_assert_delta_matches_finish(idx, delta_accum[idx], finish_block)-def _accumulate_delta(accum: dict[str, Any], block: dict[str, Any]) -> None:- """Fold a delta block into the running accumulator for its index."""+def _legacy_block_to_delta(block: dict[str, Any]) -> dict[str, Any]:+ """Convert the old content-block delta shape to an explicit delta."""btype = block.get("type")- if btype not in _DELTAABLE_TYPES:- returnif btype == "text":- accum["text"] = accum.get("text", "") + block.get("text", "")- elif btype == "reasoning":- accum["reasoning"] = accum.get("reasoning", "") + block.get("reasoning", "")- else: # tool_call_chunk / server_tool_call_chunk- accum["args"] = accum.get("args", "") + (block.get("args") or "")- if block.get("id") is not None:- accum["id"] = block["id"]- if block.get("name") is not None:- accum["name"] = block["name"]+ return {"type": "text-delta", "text": block.get("text", "")}+ if btype == "reasoning":+ return {+ "type": "reasoning-delta",+ "reasoning": block.get("reasoning", ""),+ }+ if "data" in block:+ return {"type": "data-delta", "data": block.get("data", "")}+ return {"type": "block-delta", "fields": block}+++def _accumulate_delta(accum: dict[str, Any], delta: dict[str, Any] | None) -> None:+ """Fold a delta block into the running accumulator for its index."""+ if delta is None:+ return+ dtype = delta.get("type")+ if dtype == "text-delta":+ accum["text"] = accum.get("text", "") + delta.get("text", "")+ elif dtype == "reasoning-delta":+ accum["reasoning"] = accum.get("reasoning", "") + delta.get("reasoning", "")+ elif dtype == "data-delta":+ accum["data"] = accum.get("data", "") + delta.get("data", "")+ elif dtype == "block-delta":+ fields = delta.get("fields")+ if not isinstance(fields, dict):+ return+ btype = fields.get("type")+ if btype not in _DELTAABLE_TYPES:+ return+ accum.update({k: v for k, v in fields.items() if v is not None})def _assert_delta_matches_finish(@@ -197,6 +223,8 @@ def _assert_delta_matches_finish(except json.JSONDecodeError:parsed = Noneassert finish_block.get("args") == parsed+ elif "data" in accum:+ assert finish_block.get("data") == accum["data"]__all__ = ["assert_valid_event_stream"]diff --git a/libs/standard-tests/uv.lock b/libs/standard-tests/uv.lockindex 3018daa2c6..b068e14a74 100644--- a/libs/standard-tests/uv.lock+++ b/libs/standard-tests/uv.lock@@ -341,7 +341,7 @@ dependencies = [[package.metadata]requires-dist = [{ name = "jsonpatch", specifier = ">=1.33.0,<2.0.0" },- { name = "langchain-protocol", specifier = ">=0.0.10" },+ { name = "langchain-protocol", specifier = ">=0.0.14" },{ name = "langsmith", specifier = ">=0.3.45,<1.0.0" },{ name = "packaging", specifier = ">=23.2.0" },{ name = "pydantic", specifier = ">=2.7.4,<3.0.0" },@@ -386,14 +386,14 @@ typing = [[[package]]name = "langchain-protocol"-version = "0.0.10"+version = "0.0.14"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "typing-extensions" },]-sdist = { url = "https://files.pythonhosted.org/packages/bf/c3/0d3911d3274f097040e92133f18a425980cd4085e72b6cd65add1f25327c/langchain_protocol-0.0.10.tar.gz", hash = "sha256:5bc530e0b350d3a15a3ab6889abb8132692a2c8a15eed536bce46624751acaaf", size = 6528, upload-time = "2026-04-23T17:31:34.212Z" }+sdist = { url = "https://files.pythonhosted.org/packages/05/bf/efb5e2ed832e4d6d45590e25a9e5191986b291b543bc6a807b48bee070b0/langchain_protocol-0.0.14.tar.gz", hash = "sha256:bc1e8553122e6ede310280462d5813023a172ff2785ccbbdec54d43f3a15e5f2", size = 5862, upload-time = "2026-04-29T16:40:18.657Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/f8/11/6c89bc86b5494cfe29ee23420c398406cc147a09b5cf756e323070e358d7/langchain_protocol-0.0.10-py3-none-any.whl", hash = "sha256:040bb2ae966a06ffcd0051a1d1ca7e4926f12e951e83b07440cb80e0e8e12268", size = 6677, upload-time = "2026-04-23T17:31:33.367Z" },+ { url = "https://files.pythonhosted.org/packages/c2/e9/06c47ecb2aff08f83dfa30058da3bf86be64862c19569043ed5331bbeecd/langchain_protocol-0.0.14-py3-none-any.whl", hash = "sha256:ffc35089779bd8ca217015180cef5e660fc3b074efdaa0f2e95df73583f1a047", size = 6984, upload-time = "2026-04-29T16:40:17.841Z" },][[package]]