feat(core): output_version on invoke / model call

libs/core/langchain_core/language_models/fake_chat_models.py

@@ -12,6 +12,9 @@
     AsyncCallbackManagerForLLMRun,
     CallbackManagerForLLMRun,
 )
+from langchain_core.language_models._utils import (
+    _update_message_content_to_blocks,
+)
 from langchain_core.language_models.chat_models import BaseChatModel, SimpleChatModel
 from langchain_core.messages import AIMessage, AIMessageChunk, BaseMessage
 from langchain_core.outputs import ChatGeneration, ChatGenerationChunk, ChatResult
@@ -248,10 +251,32 @@ def _generate(
         messages: list[BaseMessage],
         stop: Optional[list[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        *,
+        output_version: str = "v0",
         **kwargs: Any,
     ) -> ChatResult:
         message = next(self.messages)
         message_ = AIMessage(content=message) if isinstance(message, str) else message
+
+        if output_version == "v1":
+            message_ = _update_message_content_to_blocks(message_, "v1")
+
+        # Only set in response metadata if output_version is explicitly provided
+        # (If output_version is "v0" and self.output_version is None, it's the default)
+        output_version_explicit = not (
+            output_version == "v0" and getattr(self, "output_version", None) is None
+        )
+        if output_version_explicit:
+            if hasattr(message_, "response_metadata"):
+                message_.response_metadata = {"output_version": output_version}
+            else:
+                message_ = AIMessage(
+                    content=message_.content,
+                    additional_kwargs=message_.additional_kwargs,
+                    response_metadata={"output_version": output_version},
+                    id=message_.id,
+                )
+
         generation = ChatGeneration(message=message_)
         return ChatResult(generations=[generation])
 
@@ -260,10 +285,16 @@ def _stream(
         messages: list[BaseMessage],
         stop: Optional[list[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        *,
+        output_version: str = "v0",
         **kwargs: Any,
     ) -> Iterator[ChatGenerationChunk]:
         chat_result = self._generate(
-            messages, stop=stop, run_manager=run_manager, **kwargs
+            messages,
+            stop=stop,
+            run_manager=run_manager,
+            output_version="v0",  # Always call with v0 to get original string content
+            **kwargs,
         )
         if not isinstance(chat_result, ChatResult):
             msg = (
@@ -302,6 +333,21 @@ def _stream(
                     and not message.additional_kwargs
                 ):
                     chunk.message.chunk_position = "last"
+
+                if output_version == "v1":
+                    chunk.message = _update_message_content_to_blocks(
+                        chunk.message, "v1"
+                    )
+
+                output_version_explicit = not (
+                    output_version == "v0"
+                    and getattr(self, "output_version", None) is None
+                )
+                if output_version_explicit:
+                    chunk.message.response_metadata = {"output_version": output_version}
+                else:
+                    chunk.message.response_metadata = {}
+
                 if run_manager:
                     run_manager.on_llm_new_token(token, chunk=chunk)
                 yield chunk
@@ -321,7 +367,7 @@ def _stream(
                                         id=message.id,
                                         content="",
                                         additional_kwargs={
-                                            "function_call": {fkey: fvalue_chunk}
+                                            "function_call": {fkey: fvalue_chunk},
                                         },
                                     )
                                 )
@@ -336,7 +382,9 @@ def _stream(
                                 message=AIMessageChunk(
                                     id=message.id,
                                     content="",
-                                    additional_kwargs={"function_call": {fkey: fvalue}},
+                                    additional_kwargs={
+                                        "function_call": {fkey: fvalue},
+                                    },
                                 )
                             )
                             if run_manager:
@@ -348,7 +396,9 @@ def _stream(
                 else:
                     chunk = ChatGenerationChunk(
                         message=AIMessageChunk(
-                            id=message.id, content="", additional_kwargs={key: value}
+                            id=message.id,
+                            content="",
+                            additional_kwargs={key: value},
                         )
                     )
                     if run_manager:
@@ -358,6 +408,14 @@ def _stream(
                         )
                     yield chunk
 
+            # Add a final chunk with chunk_position="last" after all additional_kwargs
+            final_chunk = ChatGenerationChunk(
+                message=AIMessageChunk(id=message.id, content="", chunk_position="last")
+            )
+            if run_manager:
+                run_manager.on_llm_new_token("", chunk=final_chunk)
+            yield final_chunk
+
     @property
     def _llm_type(self) -> str:
         return "generic-fake-chat-model"

libs/core/langchain_core/utils/_merge.py

@@ -44,6 +44,16 @@ def merge_dicts(left: dict[str, Any], *others: dict[str, Any]) -> dict[str, Any]
                 )
                 raise TypeError(msg)
             elif isinstance(merged[right_k], str):
+                if right_k == "output_version":
+                    if merged[right_k] == right_v:
+                        continue
+                    msg = (
+                        "Unable to merge. Two different values seen for "
+                        f"'output_version': {merged[right_k]} and {right_v}. "
+                        "'output_version' should have the same value across "
+                        "all chunks in a generation."
+                    )
+                    raise ValueError(msg)
                 # TODO: Add below special handling for 'type' key in 0.3 and remove
                 # merge_lists 'type' logic.
                 #
@@ -58,8 +68,7 @@ def merge_dicts(left: dict[str, Any], *others: dict[str, Any]) -> dict[str, Any]
                 #             "all dicts."
                 #         )
                 if (right_k == "index" and merged[right_k].startswith("lc_")) or (
-                    right_k in ("id", "output_version", "model_provider")
-                    and merged[right_k] == right_v
+                    right_k in ("id", "model_provider") and merged[right_k] == right_v
                 ):
                     continue
                 merged[right_k] += right_v

libs/core/tests/unit_tests/language_models/chat_models/test_base.py

@@ -7,7 +7,10 @@
 import pytest
 from typing_extensions import override
 
-from langchain_core.callbacks import CallbackManagerForLLMRun
+from langchain_core.callbacks import (
+    AsyncCallbackManagerForLLMRun,
+    CallbackManagerForLLMRun,
+)
 from langchain_core.language_models import (
     BaseChatModel,
     FakeListChatModel,
@@ -185,6 +188,8 @@ def _generate(
             messages: list[BaseMessage],
             stop: Optional[list[str]] = None,
             run_manager: Optional[CallbackManagerForLLMRun] = None,
+            *,
+            output_version: str = "v0",
             **kwargs: Any,
         ) -> ChatResult:
             """Top Level call."""
@@ -218,6 +223,8 @@ def _generate(
             messages: list[BaseMessage],
             stop: Optional[list[str]] = None,
             run_manager: Optional[CallbackManagerForLLMRun] = None,
+            *,
+            output_version: str = "v0",
             **kwargs: Any,
         ) -> ChatResult:
             """Top Level call."""
@@ -229,6 +236,8 @@ def _stream(
             messages: list[BaseMessage],
             stop: Optional[list[str]] = None,
             run_manager: Optional[CallbackManagerForLLMRun] = None,
+            *,
+            output_version: str = "v0",
             **kwargs: Any,
         ) -> Iterator[ChatGenerationChunk]:
             """Stream the output of the model."""
@@ -244,19 +253,21 @@ def _llm_type(self) -> str:
     model = ModelWithSyncStream()
     chunks = list(model.stream("anything"))
     assert chunks == [
+        _any_id_ai_message_chunk(content="a"),
         _any_id_ai_message_chunk(
-            content="a",
+            content="b",
+            chunk_position="last",
         ),
-        _any_id_ai_message_chunk(content="b", chunk_position="last"),
     ]
     assert len({chunk.id for chunk in chunks}) == 1
     assert type(model)._astream == BaseChatModel._astream
     astream_chunks = [chunk async for chunk in model.astream("anything")]
     assert astream_chunks == [
+        _any_id_ai_message_chunk(content="a"),
         _any_id_ai_message_chunk(
-            content="a",
+            content="b",
+            chunk_position="last",
         ),
-        _any_id_ai_message_chunk(content="b", chunk_position="last"),
     ]
     assert len({chunk.id for chunk in astream_chunks}) == 1
 
@@ -270,6 +281,8 @@ def _generate(
             messages: list[BaseMessage],
             stop: Optional[list[str]] = None,
             run_manager: Optional[CallbackManagerForLLMRun] = None,
+            *,
+            output_version: str = "v0",
             **kwargs: Any,
         ) -> ChatResult:
             """Top Level call."""
@@ -280,7 +293,9 @@ async def _astream(
             self,
             messages: list[BaseMessage],
             stop: Optional[list[str]] = None,
-            run_manager: Optional[CallbackManagerForLLMRun] = None,  # type: ignore[override]
+            run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+            *,
+            output_version: Optional[str] = "v0",
             **kwargs: Any,
         ) -> AsyncIterator[ChatGenerationChunk]:
             """Stream the output of the model."""
@@ -296,10 +311,11 @@ def _llm_type(self) -> str:
     model = ModelWithAsyncStream()
     chunks = [chunk async for chunk in model.astream("anything")]
     assert chunks == [
+        _any_id_ai_message_chunk(content="a"),
         _any_id_ai_message_chunk(
-            content="a",
+            content="b",
+            chunk_position="last",
         ),
-        _any_id_ai_message_chunk(content="b", chunk_position="last"),
     ]
     assert len({chunk.id for chunk in chunks}) == 1
 
@@ -351,6 +367,8 @@ def _generate(
         messages: list[BaseMessage],
         stop: Optional[list[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        *,
+        output_version: str = "v0",
         **kwargs: Any,
     ) -> ChatResult:
         return ChatResult(generations=[ChatGeneration(message=AIMessage("invoke"))])
@@ -367,6 +385,8 @@ def _stream(
         messages: list[BaseMessage],
         stop: Optional[list[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        *,
+        output_version: str = "v0",
         **kwargs: Any,
     ) -> Iterator[ChatGenerationChunk]:
         yield ChatGenerationChunk(message=AIMessageChunk(content="stream"))