langchain-dev-utils 1.2.7__tar.gz → 1.2.8__tar.gz

{langchain_dev_utils-1.2.7 → langchain_dev_utils-1.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langchain-dev-utils
-Version: 1.2.7
+Version: 1.2.8
 Summary: A practical utility library for LangChain and LangGraph development
 Project-URL: Source Code, https://github.com/TBice123123/langchain-dev-utils
 Project-URL: repository, https://github.com/TBice123123/langchain-dev-utils

{langchain_dev_utils-1.2.7 → langchain_dev_utils-1.2.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "langchain-dev-utils"
-version = "1.2.7"
+version = "1.2.8"
 description = "A practical utility library for LangChain and LangGraph development"
 readme = "README.md"
 authors = [{ name = "tiebingice", email = "tiebingice123@outlook.com" }]

langchain_dev_utils-1.2.8/src/langchain_dev_utils/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.2.8"

{langchain_dev_utils-1.2.7 → langchain_dev_utils-1.2.8}/src/langchain_dev_utils/_utils.py

@@ -8,9 +8,10 @@ def _check_pkg_install(
     pkg: Literal["langchain_openai", "json_repair"],
 ) -> None:
     if not util.find_spec(pkg):
-        msg = (
-            "Please install langchain_dev_utils[standard],when use 'openai-compatible'"
-        )
+        if pkg == "langchain_openai":
+            msg = "Please install langchain_dev_utils[standard],when use 'openai-compatible'"
+        else:
+            msg = "Please install langchain_dev_utils[standard] to use ToolCallRepairMiddleware."
         raise ImportError(msg)
 
 

{langchain_dev_utils-1.2.7 → langchain_dev_utils-1.2.8}/src/langchain_dev_utils/chat_models/adapters/openai_compatible.py

@@ -20,7 +20,7 @@ from langchain_core.callbacks import (
     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
@@ -39,47 +39,63 @@ 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, 
+    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).
+    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. 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.
+    **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 
+    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 
+    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 
+    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()`.
     """
 
@@ -101,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}"
@@ -158,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"
@@ -316,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(
@@ -338,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(
@@ -422,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 = {
@@ -443,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,
@@ -460,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
@@ -468,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(
@@ -502,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,
@@ -532,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-1.2.7 → langchain_dev_utils-1.2.8}/src/langchain_dev_utils/chat_models/types.py

@@ -7,9 +7,13 @@ 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-1.2.7/src/langchain_dev_utils/__init__.py

@@ -1 +0,0 @@
-__version__ = "1.2.7"