langchain-dev-utils 1.2.6__py3-none-any.whl → 1.2.8__py3-none-any.whl

langchain_dev_utils/chat_models/adapters/openai_compatible.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 from collections.abc import AsyncIterator, Iterator
 from json import JSONDecodeError
 from typing import (
@@ -13,12 +14,13 @@ from typing import (
     Union,
 )
 
+import openai
 from langchain_core.callbacks import (
     AsyncCallbackManagerForLLMRun,
     CallbackManagerForLLMRun,
 )
 from langchain_core.language_models import LangSmithParams, LanguageModelInput
-from langchain_core.messages import AIMessage, AIMessageChunk, BaseMessage
+from langchain_core.messages import AIMessage, AIMessageChunk, BaseMessage, HumanMessage
 from langchain_core.outputs import ChatGenerationChunk, ChatResult
 from langchain_core.runnables import Runnable
 from langchain_core.tools import BaseTool
@@ -26,7 +28,6 @@ from langchain_core.utils import from_env, secret_from_env
 from langchain_core.utils.function_calling import convert_to_openai_tool
 from langchain_openai.chat_models._compat import _convert_from_v1_to_chat_completions
 from langchain_openai.chat_models.base import BaseChatOpenAI, _convert_message_to_dict
-import openai
 from pydantic import (
     BaseModel,
     ConfigDict,
@@ -38,33 +39,64 @@ from pydantic import (
 )
 from typing_extensions import Self
 
-from ..types import CompatibilityOptions, ToolChoiceType
+from ..types import (
+    CompatibilityOptions,
+    ReasoningContentKeepType,
+    ResponseFormatType,
+    ToolChoiceType,
+)
 
 _BM = TypeVar("_BM", bound=BaseModel)
 _DictOrPydanticClass = Union[dict[str, Any], type[_BM], type]
 _DictOrPydantic = Union[dict, _BM]
 
 
+def _get_last_human_message_index(messages: list[BaseMessage]) -> int:
+    """find the index of the last HumanMessage in the messages list, return -1 if not found."""
+    return next(
+        (
+            i
+            for i in range(len(messages) - 1, -1, -1)
+            if isinstance(messages[i], HumanMessage)
+        ),
+        -1,
+    )
+
+
 class _BaseChatOpenAICompatible(BaseChatOpenAI):
     """
     Base template class for OpenAI-compatible chat model implementations.
 
-    This class provides a foundation for integrating various LLM providers that offer OpenAI-compatible APIs (such as vLLM, OpenRouter, ZAI, Moonshot, and many others).
-    It enhances the base OpenAI functionality by:
-
-    **1.Supports output of more types of reasoning content (reasoning_content)**
-    ChatOpenAI can only output reasoning content natively supported by official OpenAI models, while OpenAICompatibleChatModel can output reasoning content from other model providers (e.g., OpenRouter).
-
-    **2.Optimizes default behavior for structured output**
-    When calling with_structured_output, the default value of the method parameter is adjusted to "function_calling" (instead of the default "json_schema" in ChatOpenAI), providing better compatibility with other models.
-
-    **3.Supports configuration of related parameters**
-    For cases where parameters differ from the official OpenAI API, this library provides the compatibility_options parameter to address this issue. For example, when different model providers have inconsistent support for tool_choice, you can adapt by setting supported_tool_choice in compatibility_options.
-
-    Built on top of `langchain-openai`'s `BaseChatOpenAI`, this template class extends capabilities to better support diverse OpenAI-compatible model providers while maintaining full compatibility with LangChain's chat model interface.
-
-    Note: This is a template class and should not be exported or instantiated directly.
-    Instead, use it as a base class and provide the specific provider name through inheritance or the factory function `_create_openai_compatible_model()`.
+    This class provides a foundation for integrating various LLM providers that
+    offer OpenAI-compatible APIs (such as vLLM, OpenRouter, ZAI, Moonshot,
+    and many others). It enhances the base OpenAI functionality by:
+
+    **1. Supports output of more types of reasoning content (reasoning_content)**
+    ChatOpenAI can only output reasoning content natively supported by official
+    OpenAI models, while OpenAICompatibleChatModel can output reasoning content
+    from other model providers (e.g., OpenRouter, vLLM).
+
+    **2. Dynamically adapts to choose the most suitable structured-output method**
+    OpenAICompatibleChatModel adds method="auto" (default), which selects the best
+    structured-output method (function_calling or json_schema) based on the actual
+    capabilities of the model provider.
+
+    **3. Supports configuration of related parameters**
+    For cases where parameters differ from the official OpenAI API, this library
+    provides the compatibility_options parameter to address this issue. For
+    example, when different model providers have inconsistent support for
+    tool_choice, you can adapt by setting supported_tool_choice in
+    compatibility_options.
+
+    Built on top of `langchain-openai`'s `BaseChatOpenAI`, this template class
+    extends capabilities to better support diverse OpenAI-compatible model
+    providers while maintaining full compatibility with LangChain's chat model
+    interface.
+
+    Note: This is a template class and should not be exported or instantiated
+    directly. Instead, use it as a base class and provide the specific provider
+    name through inheritance or the factory function
+    `_create_openai_compatible_model()`.
     """
 
     model_name: str = Field(alias="model", default="openai compatible model")
@@ -85,29 +117,13 @@ class _BaseChatOpenAICompatible(BaseChatOpenAI):
     """Provider Compatibility Options"""
     supported_tool_choice: ToolChoiceType = Field(default_factory=list)
     """Supported tool choice"""
-    keep_reasoning_content: bool = Field(default=False)
-    """Whether to keep reasoning content in the messages"""
-    support_json_mode: bool = Field(default=False)
-    """Whether to support JSON mode"""
+    supported_response_format: ResponseFormatType = Field(default_factory=list)
+    """Supported response format"""
+    reasoning_content_keep_type: ReasoningContentKeepType = Field(default="discard")
+    """How to keep reasoning content in the messages"""
     include_usage: bool = Field(default=True)
     """Whether to include usage information in the output"""
 
-    @property
-    def _supported_tool_choice(self) -> ToolChoiceType:
-        return self.supported_tool_choice
-
-    @property
-    def _keep_reasoning_content(self) -> bool:
-        return self.keep_reasoning_content
-
-    @property
-    def _support_json_mode(self) -> bool:
-        return self.support_json_mode
-
-    @property
-    def _include_usage(self) -> bool:
-        return self.include_usage
-
     @property
     def _llm_type(self) -> str:
         return f"chat-{self._provider}"
@@ -142,14 +158,26 @@ class _BaseChatOpenAICompatible(BaseChatOpenAI):
             kwargs["stop"] = stop
 
         payload_messages = []
+        last_human_index = -1
+        if self.reasoning_content_keep_type == "temp":
+            last_human_index = _get_last_human_message_index(messages)
 
-        for m in messages:
+        for index, m in enumerate(messages):
             if isinstance(m, AIMessage):
                 msg_dict = _convert_message_to_dict(
                     _convert_from_v1_to_chat_completions(m)
                 )
-                if self._keep_reasoning_content and m.additional_kwargs.get(
-                    "reasoning_content"
+                if (
+                    self.reasoning_content_keep_type == "retain"
+                    and m.additional_kwargs.get("reasoning_content")
+                ):
+                    msg_dict["reasoning_content"] = m.additional_kwargs.get(
+                        "reasoning_content"
+                    )
+                elif (
+                    self.reasoning_content_keep_type == "temp"
+                    and index > last_human_index
+                    and m.additional_kwargs.get("reasoning_content")
                 ):
                     msg_dict["reasoning_content"] = m.additional_kwargs.get(
                         "reasoning_content"
@@ -300,7 +328,7 @@ class _BaseChatOpenAICompatible(BaseChatOpenAI):
         run_manager: Optional[CallbackManagerForLLMRun] = None,
         **kwargs: Any,
     ) -> Iterator[ChatGenerationChunk]:
-        if self._include_usage:
+        if self.include_usage:
             kwargs["stream_options"] = {"include_usage": True}
         try:
             for chunk in super()._stream(
@@ -322,7 +350,7 @@ class _BaseChatOpenAICompatible(BaseChatOpenAI):
         run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
         **kwargs: Any,
     ) -> AsyncIterator[ChatGenerationChunk]:
-        if self._include_usage:
+        if self.include_usage:
             kwargs["stream_options"] = {"include_usage": True}
         try:
             async for chunk in super()._astream(
@@ -406,11 +434,11 @@ class _BaseChatOpenAICompatible(BaseChatOpenAI):
             if isinstance(tool_choice, str):
                 if (
                     tool_choice in ["auto", "none", "required"]
-                    and tool_choice in self._supported_tool_choice
+                    and tool_choice in self.supported_tool_choice
                 ):
                     support_tool_choice = True
 
-                elif "specific" in self._supported_tool_choice:
+                elif "specific" in self.supported_tool_choice:
                     if tool_choice in tool_names:
                         support_tool_choice = True
                         tool_choice = {
@@ -427,10 +455,11 @@ class _BaseChatOpenAICompatible(BaseChatOpenAI):
         schema: Optional[_DictOrPydanticClass] = None,
         *,
         method: Literal[
+            "auto",
             "function_calling",
             "json_mode",
             "json_schema",
-        ] = "function_calling",
+        ] = "auto",
         include_raw: bool = False,
         strict: Optional[bool] = None,
         **kwargs: Any,
@@ -444,7 +473,7 @@ class _BaseChatOpenAICompatible(BaseChatOpenAI):
 
         Args:
             schema: Output schema (Pydantic model class or dictionary definition)
-            method: Extraction method - defaults to function_calling for compatibility
+            method: Extraction method - defaults to auto,it will choice best method based on provider supported response format
             include_raw: Whether to include raw model response alongside parsed output
             strict: Schema enforcement strictness (provider-dependent)
             **kwargs: Additional structured output parameters
@@ -452,10 +481,23 @@ class _BaseChatOpenAICompatible(BaseChatOpenAI):
         Returns:
             Runnable configured for structured output extraction
         """
-        # Many providers do not support json_schema method, so fallback to function_calling
-        if method == "json_schema":
+        if method not in ["auto", "function_calling", "json_mode", "json_schema"]:
+            raise ValueError(
+                f"Unsupported method: {method}. Please choose from 'auto', 'function_calling', 'json_mode', 'json_schema'."
+            )
+        if method == "auto":
+            if "json_schema" in self.supported_response_format:
+                method = "json_schema"
+            else:
+                method = "function_calling"
+        elif (
+            method == "json_schema"
+            and "json_schema" not in self.supported_response_format
+        ):
             method = "function_calling"
-        if method == "json_mode" and not self._support_json_mode:
+        elif (
+            method == "json_mode" and "json_mode" not in self.supported_response_format
+        ):
             method = "function_calling"
 
         return super().with_structured_output(
@@ -486,8 +528,8 @@ def _create_openai_compatible_model(
         Configured model class ready for instantiation with provider-specific settings
     """
     chat_model_cls_name = f"Chat{provider.title()}"
-
-    compatibility_options = compatibility_options or {}
+    if compatibility_options is None:
+        compatibility_options = {}
 
     return create_model(
         chat_model_cls_name,
@@ -516,13 +558,17 @@ def _create_openai_compatible_model(
             ToolChoiceType,
             Field(default=compatibility_options.get("supported_tool_choice", ["auto"])),
         ),
-        keep_reasoning_content=(
-            bool,
-            Field(default=compatibility_options.get("keep_reasoning_content", False)),
+        reasoning_content_keep_type=(
+            ReasoningContentKeepType,
+            Field(
+                default=compatibility_options.get(
+                    "reasoning_content_keep_type", "discard"
+                )
+            ),
         ),
-        support_json_mode=(
-            bool,
-            Field(default=compatibility_options.get("support_json_mode", False)),
+        supported_response_format=(
+            ResponseFormatType,
+            Field(default=compatibility_options.get("supported_response_format", [])),
         ),
         include_usage=(
             bool,

langchain_dev_utils/chat_models/base.py

@@ -5,7 +5,7 @@ from langchain_core.language_models.chat_models import BaseChatModel
 from langchain_core.utils import from_env
 
 from langchain_dev_utils._utils import (
-    _check_langchain_openai_install,
+    _check_pkg_install,
     _get_base_url_field_name,
 )
 
@@ -95,11 +95,22 @@ def register_model_provider(
     string identifiers for supported providers.
 
     Args:
-        provider_name: The name of the model provider, used as an identifier for loading models later.
-        chat_model: The chat model, which can be either a `ChatModel` instance or a string (currently only `"openai-compatible"` is supported).
-        base_url: The API endpoint URL of the model provider (optional; applicable to both `chat_model` types, but primarily used when `chat_model` is a string with value `"openai-compatible"`).
-        model_profiles: Declares the capabilities and parameters supported by each model provided by this provider (optional; applicable to both `chat_model` types). The configuration corresponding to the `model_name` will be loaded and assigned to `model.profile` (e.g., fields such as `max_input_tokens`, `tool_calling`etc.).
-        compatibility_options: Compatibility options for the model provider (optional; only effective when `chat_model` is a string with value `"openai-compatible"`). Used to declare support for OpenAI-compatible features (e.g., `tool_choice` strategies, JSON mode, etc.) to ensure correct functional adaptation.
+        provider_name: The name of the model provider, used as an identifier for
+            loading models later.
+        chat_model: The chat model, which can be either a `ChatModel` instance or
+            a string (currently only `"openai-compatible"` is supported).
+        base_url: The API endpoint URL of the model provider (optional; applicable
+            to both `chat_model` types, but primarily used when `chat_model` is a
+            string with value `"openai-compatible"`).
+        model_profiles: Declares the capabilities and parameters supported by each
+            model provided by this provider (optional; applicable to both `chat_model`
+            types). The configuration corresponding to the `model_name` will be loaded
+            and assigned to `model.profile` (e.g., fields such as `max_input_tokens`,
+            `tool_calling`etc.).
+        compatibility_options: Compatibility options for the model provider (optional;
+            only effective when `chat_model` is a string with value `"openai-compatible"`).
+            Used to declare support for OpenAI-compatible features (e.g., `tool_choice`
+            strategies, JSON mode, etc.) to ensure correct functional adaptation.
     Raises:
         ValueError: If base_url is not provided when chat_model is a string,
                    or if chat_model string is not in supported providers
@@ -109,19 +120,23 @@ def register_model_provider(
         >>> from langchain_dev_utils.chat_models import register_model_provider, load_chat_model
         >>> from langchain_core.language_models.fake_chat_models import FakeChatModel
         >>>
-        >>> # Register custom model provider
+        # Register custom model provider
         >>> register_model_provider("fakechat", FakeChatModel)
         >>> model = load_chat_model(model="fakechat:fake-model")
         >>> model.invoke("Hello")
         >>>
-        >>> # Using with OpenAI-compatible API:
-        >>> register_model_provider("vllm","openai-compatible",base_url="http://localhost:8000/v1")
+        # Using with OpenAI-compatible API:
+        >>> register_model_provider(
+        ...     provider_name="vllm",
+        ...     chat_model="openai-compatible",
+        ...     base_url="http://localhost:8000/v1",
+        ... )
         >>> model = load_chat_model(model="vllm:qwen3-4b")
         >>> model.invoke("Hello")
     """
     base_url = base_url or from_env(f"{provider_name.upper()}_API_BASE", default=None)()
     if isinstance(chat_model, str):
-        _check_langchain_openai_install()
+        _check_pkg_install("langchain_openai")
         from .adapters.openai_compatible import _create_openai_compatible_model
 
         if base_url is None:
@@ -204,7 +219,7 @@ def batch_register_model_provider(
             >>> from langchain_dev_utils.chat_models import batch_register_model_provider, load_chat_model
             >>> from langchain_core.language_models.fake_chat_models import FakeChatModel
             >>>
-            >>> # Register multiple providers
+            # Register multiple providers
             >>> batch_register_model_provider([
             ...     {
             ...         "provider_name": "fakechat",
@@ -217,7 +232,7 @@ def batch_register_model_provider(
             ...     },
             ... ])
             >>>
-            >>> # Use registered providers
+            # Use registered providers
             >>> model = load_chat_model("fakechat:fake-model")
             >>> model.invoke("Hello")
             >>>
@@ -257,16 +272,16 @@ def load_chat_model(
         BaseChatModel: Initialized chat model instance
 
     Example:
-        Load model with provider prefix:
+        # Load model with provider prefix:
         >>> from langchain_dev_utils.chat_models import load_chat_model
         >>> model = load_chat_model("vllm:qwen3-4b")
         >>> model.invoke("hello")
 
-        Load model with separate provider parameter:
+        # Load model with separate provider parameter:
         >>> model = load_chat_model("qwen3-4b", model_provider="vllm")
         >>> model.invoke("hello")
 
-        Load model with additional parameters:
+        # Load model with additional parameters:
         >>> model = load_chat_model(
         ...     "vllm:qwen3-4b",
         ...     temperature=0.7

langchain_dev_utils/chat_models/types.py

@@ -2,15 +2,18 @@ from typing import Literal, NotRequired, TypedDict, Union
 
 from langchain_core.language_models.chat_models import BaseChatModel
 
-
 ChatModelType = Union[type[BaseChatModel], Literal["openai-compatible"]]
 
 
 ToolChoiceType = list[Literal["auto", "none", "required", "specific"]]
 
+ResponseFormatType = list[Literal["json_schema", "json_mode"]]
+
+ReasoningContentKeepType = Literal["discard", "temp", "retain"]
+
 
 class CompatibilityOptions(TypedDict):
     supported_tool_choice: NotRequired[ToolChoiceType]
-    keep_reasoning_content: NotRequired[bool]
-    support_json_mode: NotRequired[bool]
+    supported_response_format: NotRequired[ResponseFormatType]
+    reasoning_content_keep_type: NotRequired[ReasoningContentKeepType]
     include_usage: NotRequired[bool]

langchain_dev_utils/embeddings/base.py

@@ -1,10 +1,10 @@
 from typing import Any, Literal, NotRequired, Optional, TypedDict, Union
 
-from langchain.embeddings.base import Embeddings, _SUPPORTED_PROVIDERS, init_embeddings
+from langchain.embeddings.base import _SUPPORTED_PROVIDERS, Embeddings, init_embeddings
 from langchain_core.utils import from_env, secret_from_env
 
 from langchain_dev_utils._utils import (
-    _check_langchain_openai_install,
+    _check_pkg_install,
     _get_base_url_field_name,
 )
 
@@ -60,14 +60,17 @@ def register_embeddings_provider(
 
     Args:
         provider_name: Name of the provider to register
-        embeddings_model: Either an Embeddings class or a string identifier for a supported provider
-        base_url: The API address of the Embedding model provider (optional, valid for both types of `embeddings_model`, but mainly used when `embeddings_model` is a string and is "openai-compatible")
+        embeddings_model: Either an Embeddings class or a string identifier
+            for a supported provider
+        base_url: The API address of the Embedding model provider (optional,
+            valid for both types of `embeddings_model`, but mainly used when
+            `embeddings_model` is a string and is "openai-compatible")
 
     Raises:
         ValueError: If base_url is not provided when embeddings_model is a string
 
     Example:
-        Register with custom model class:
+        # Register with custom model class:
         >>> from langchain_dev_utils.embeddings import register_embeddings_provider, load_embeddings
         >>> from langchain_core.embeddings.fake import FakeEmbeddings
         >>>
@@ -75,9 +78,11 @@ def register_embeddings_provider(
         >>> embeddings = load_embeddings("fakeembeddings:fake-embeddings",size=1024)
         >>> embeddings.embed_query("hello world")
 
-        Register with OpenAI-compatible API:
+        # Register with OpenAI-compatible API:
         >>> register_embeddings_provider(
-        ...     "vllm", "openai-compatible", base_url="http://localhost:8000/v1"
+        ...     "vllm",
+        ...     "openai-compatible",
+        ...     base_url="http://localhost:8000/v1"
         ... )
         >>> embeddings = load_embeddings("vllm:qwen3-embedding-4b")
         >>> embeddings.embed_query("hello world")
@@ -95,7 +100,7 @@ def register_embeddings_provider(
                 "when embeddings_model is a string, the value must be 'openai-compatible'"
             )
 
-        _check_langchain_openai_install()
+        _check_pkg_install("langchain_openai")
 
         _EMBEDDINGS_PROVIDERS_DICT.update(
             {
@@ -126,32 +131,44 @@ def batch_register_embeddings_provider(
 ):
     """Batch register embeddings providers.
 
-    This function allows you to register multiple embeddings providers at once, which is
-    useful when setting up applications that need to work with multiple embedding services.
+    This function allows you to register multiple embeddings providers at once,
+    which is useful when setting up applications that need to work with multiple
+    embedding services.
 
     Args:
         providers: List of EmbeddingProvider dictionaries, each containing:
             - provider_name: str - Provider name
-            - embeddings_model: Union[Type[Embeddings], str] - Model class or provider string
-            - base_url: The API address of the Embedding model provider (optional, valid for both types of `embeddings_model`, but mainly used when `embeddings_model` is a string and is "openai-compatible")
+            - embeddings_model: Union[Type[Embeddings], str] - Model class or
+                provider string
+            - base_url: The API address of the Embedding model provider
+                (optional, valid for both types of `embeddings_model`, but
+                mainly used when `embeddings_model` is a string and is
+                "openai-compatible")
 
     Raises:
         ValueError: If any of the providers are invalid
 
     Example:
-        Register multiple providers at once:
+        # Register multiple providers at once:
         >>> from langchain_dev_utils.embeddings import batch_register_embeddings_provider, load_embeddings
         >>> from langchain_core.embeddings.fake import FakeEmbeddings
         >>>
         >>> batch_register_embeddings_provider(
         ...     [
-        ...         {"provider_name": "fakeembeddings", "embeddings_model": FakeEmbeddings},
-        ...         {"provider_name": "vllm", "embeddings_model": "openai-compatible", "base_url": "http://localhost:8000/v1"},
+        ...         {
+        ...             "provider_name": "fakeembeddings",
+        ...             "embeddings_model": FakeEmbeddings,
+        ...         },
+        ...         {
+        ...             "provider_name": "vllm",
+        ...             "embeddings_model":  "openai-compatible",
+        ...             "base_url": "http://localhost:8000/v1"
+        ...         },
         ...     ]
         ... )
         >>> embeddings = load_embeddings("vllm:qwen3-embedding-4b")
         >>> embeddings.embed_query("hello world")
-        >>> embeddings = load_embeddings("fakeembeddings:fake-embeddings",size=1024)
+        >>> embeddings = load_embeddings("fakeembeddings:fake-embeddings", size=1024)
         >>> embeddings.embed_query("hello world")
     """
     for provider in providers:
@@ -185,12 +202,12 @@ def load_embeddings(
         ValueError: If provider is not registered or API key is not found
 
     Example:
-        Load model with provider prefix:
+        # Load model with provider prefix:
         >>> from langchain_dev_utils.embeddings import load_embeddings
         >>> embeddings = load_embeddings("vllm:qwen3-embedding-4b")
         >>> embeddings.embed_query("hello world")
 
-        Load model with separate provider parameter:
+        # Load model with separate provider parameter:
         >>> embeddings = load_embeddings("qwen3-embedding-4b", provider="vllm")
         >>> embeddings.embed_query("hello world")
     """

langchain_dev_utils/message_convert/__init__.py

@@ -6,7 +6,6 @@ from .content import (
 )
 from .format import format_sequence
 
-
 __all__ = [
     "convert_reasoning_content_for_ai_message",
     "convert_reasoning_content_for_chunk_iterator",

langchain_dev_utils/message_convert/content.py

@@ -36,13 +36,13 @@ def convert_reasoning_content_for_ai_message(
         AIMessage: Modified AI message with reasoning content in visible content
 
     Example:
-        Basic usage with default tags:
+        # Basic usage with default tags:
         >>> from langchain_dev_utils.message_convert import convert_reasoning_content_for_ai_message
         >>> response = model.invoke("Explain quantum computing")
         >>> response = convert_reasoning_content_for_ai_message(response)
         >>> response.content
 
-        Custom tags for reasoning content:
+        # Custom tags for reasoning content:
         >>> response = convert_reasoning_content_for_ai_message(
         ...     response, think_tag=('<reasoning>', '</reasoning>')
         ... )
@@ -77,14 +77,14 @@ def convert_reasoning_content_for_chunk_iterator(
         BaseMessageChunk: Modified message chunks with reasoning content
 
     Example:
-        Process streaming response:
+        # Process streaming response:
         >>> from langchain_dev_utils.message_convert import convert_reasoning_content_for_chunk_iterator
         >>> for chunk in convert_reasoning_content_for_chunk_iterator(
         ...     model.stream("What is the capital of France?")
         ... ):
         ...     print(chunk.content, end="", flush=True)
 
-        Custom tags for streaming:
+        # Custom tags for streaming:
         >>> for chunk in convert_reasoning_content_for_chunk_iterator(
         ...     model.stream("Explain quantum computing"),
         ...     think_tag=('<reasoning>', '</reasoning>')
@@ -127,14 +127,14 @@ async def aconvert_reasoning_content_for_chunk_iterator(
         BaseMessageChunk: Modified message chunks with reasoning content
 
     Example:
-        Process async streaming response:
+        # Process async streaming response:
         >>> from langchain_dev_utils.message_convert import aconvert_reasoning_content_for_chunk_iterator
         >>> async for chunk in aconvert_reasoning_content_for_chunk_iterator(
         ...     model.astream("What is the capital of France?")
         ... ):
         ...     print(chunk.content, end="", flush=True)
 
-        Custom tags for async streaming:
+        # Custom tags for async streaming:
         >>> async for chunk in aconvert_reasoning_content_for_chunk_iterator(
         ...     model.astream("Explain quantum computing"),
         ...     think_tag=('<reasoning>', '</reasoning>')
@@ -172,12 +172,9 @@ def merge_ai_message_chunk(chunks: Sequence[AIMessageChunk]) -> AIMessage:
         AIMessage: Merged AIMessage
 
     Example:
-        Merge streaming chunks:
+        # Merge streaming chunks:
         >>> from langchain_dev_utils.message_convert import merge_ai_message_chunk
-        >>> chunks = []
-        >>> for chunk in model.stream("What is the capital of France?"):
-        ...     chunks.append(chunk)
-        >>> merged_message = merge_ai_message_chunk(chunks)
+        >>> merged_message = merge_ai_message_chunk(list(model.stream("What is the capital of France?")))
         >>> merged_message.content
     """
     ai_message_chunk = cast(AIMessageChunk, reduce(lambda x, y: x + y, chunks))

langchain_dev_utils/message_convert/format.py

@@ -34,7 +34,7 @@ def format_sequence(
         A formatted string composed of the input contents, joined by `separator`.
 
     Example:
-        Format messages with default separator:
+        # Format messages with default separator:
         >>> from langchain_dev_utils.message_convert import format_sequence
         >>> from langchain_core.messages import HumanMessage, AIMessage
         >>> messages = [
@@ -44,7 +44,7 @@ def format_sequence(
         >>> formatted = format_sequence(messages)
         >>> formatted
 
-        Format with custom separator and numbering:
+        # Format with custom separator and numbering:
         >>> formatted = format_sequence(messages, separator="---", with_num=True)
         >>> formatted
     """