langchain-dev-utils 1.2.7__py3-none-any.whl → 1.2.9__py3-none-any.whl

langchain_dev_utils/__init__.py

@@ -1 +1 @@
-__version__ = "1.2.7"
+__version__ = "1.2.9"

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/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,
+    ReasoningKeepPolicy,
+    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_keep_policy: ReasoningKeepPolicy = Field(default="never")
+    """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,18 +158,29 @@ class _BaseChatOpenAICompatible(BaseChatOpenAI):
             kwargs["stop"] = stop
 
         payload_messages = []
+        last_human_index = -1
+        if self.reasoning_keep_policy == "current":
+            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(
+                if self.reasoning_keep_policy == "all" and m.additional_kwargs.get(
                     "reasoning_content"
                 ):
                     msg_dict["reasoning_content"] = m.additional_kwargs.get(
                         "reasoning_content"
                     )
+                elif (
+                    self.reasoning_keep_policy == "current"
+                    and index > last_human_index
+                    and m.additional_kwargs.get("reasoning_content")
+                ):
+                    msg_dict["reasoning_content"] = m.additional_kwargs.get(
+                        "reasoning_content"
+                    )
                 payload_messages.append(msg_dict)
             else:
                 payload_messages.append(_convert_message_to_dict(m))
@@ -316,7 +327,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 +349,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 +433,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 +454,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 +472,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 +480,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 +527,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 +557,13 @@ 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_keep_policy=(
+            ReasoningKeepPolicy,
+            Field(default=compatibility_options.get("reasoning_keep_policy", "never")),
         ),
-        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/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"]]
+
+ReasoningKeepPolicy = Literal["never", "current", "all"]
+
 
 class CompatibilityOptions(TypedDict):
     supported_tool_choice: NotRequired[ToolChoiceType]
-    keep_reasoning_content: NotRequired[bool]
-    support_json_mode: NotRequired[bool]
+    supported_response_format: NotRequired[ResponseFormatType]
+    reasoning_keep_policy: NotRequired[ReasoningKeepPolicy]
     include_usage: NotRequired[bool]

langchain_dev_utils/embeddings/base.py

@@ -218,30 +218,30 @@ def load_embeddings(
     ):
         raise ValueError(f"Provider {provider} not registered")
 
-    if provider in _SUPPORTED_PROVIDERS:
-        return init_embeddings(model, provider=provider, **kwargs)
-
-    embeddings = _EMBEDDINGS_PROVIDERS_DICT[provider]["embeddings_model"]
-    if isinstance(embeddings, str):
-        if not (api_key := kwargs.get("api_key")):
-            api_key = secret_from_env(f"{provider.upper()}_API_KEY", default=None)()
-            if not api_key:
-                raise ValueError(
-                    f"API key for {provider} not found. Please set it in the environment."
-                )
-            kwargs["api_key"] = api_key
-            if embeddings == "openai-compatible":
-                kwargs["check_embedding_ctx_length"] = False
-                embeddings = "openai"
-        return init_embeddings(
-            model=model,
-            provider=embeddings,
-            base_url=_EMBEDDINGS_PROVIDERS_DICT[provider]["base_url"],
-            **kwargs,
-        )
+    if provider in _EMBEDDINGS_PROVIDERS_DICT:
+        embeddings = _EMBEDDINGS_PROVIDERS_DICT[provider]["embeddings_model"]
+        if isinstance(embeddings, str):
+            if not (api_key := kwargs.get("api_key")):
+                api_key = secret_from_env(f"{provider.upper()}_API_KEY", default=None)()
+                if not api_key:
+                    raise ValueError(
+                        f"API key for {provider} not found. Please set it in the environment."
+                    )
+                kwargs["api_key"] = api_key
+                if embeddings == "openai-compatible":
+                    kwargs["check_embedding_ctx_length"] = False
+                    embeddings = "openai"
+            return init_embeddings(
+                model=model,
+                provider=embeddings,
+                base_url=_EMBEDDINGS_PROVIDERS_DICT[provider]["base_url"],
+                **kwargs,
+            )
+        else:
+            if base_url := _EMBEDDINGS_PROVIDERS_DICT[provider].get("base_url"):
+                url_key = _get_base_url_field_name(embeddings)
+                if url_key is not None:
+                    kwargs.update({url_key: base_url})
+            return embeddings(model=model, **kwargs)
     else:
-        if base_url := _EMBEDDINGS_PROVIDERS_DICT[provider].get("base_url"):
-            url_key = _get_base_url_field_name(embeddings)
-            if url_key is not None:
-                kwargs.update({url_key: base_url})
-        return embeddings(model=model, **kwargs)
+        return init_embeddings(model, provider=provider, **kwargs)

langchain_dev_utils/message_convert/content.py

@@ -52,8 +52,10 @@ def convert_reasoning_content_for_ai_message(
     reasoning_content = _get_reasoning_content(model_response)
 
     if reasoning_content:
-        model_response.content = (
-            f"{think_tag[0]}{reasoning_content}{think_tag[1]}{model_response.content}"
+        return model_response.model_copy(
+            update={
+                "content": f"{think_tag[0]}{reasoning_content}{think_tag[1]}{model_response.content}"
+            }
         )
     return model_response
 
@@ -99,12 +101,16 @@ def convert_reasoning_content_for_chunk_iterator(
             reasoning_content = _get_reasoning_content(chunk)
             if reasoning_content:
                 if isfirst:
-                    chunk.content = f"{think_tag[0]}{reasoning_content}"
+                    chunk = chunk.model_copy(
+                        update={"content": f"{think_tag[0]}{reasoning_content}"}
+                    )
                     isfirst = False
                 else:
-                    chunk.content = reasoning_content
+                    chunk = chunk.model_copy(update={"content": reasoning_content})
             elif chunk.content and isend and not isfirst:
-                chunk.content = f"{think_tag[1]}{chunk.content}"
+                chunk = chunk.model_copy(
+                    update={"content": f"{think_tag[1]}{chunk.content}"}
+                )
                 isend = False
         yield chunk
 
@@ -149,12 +155,16 @@ async def aconvert_reasoning_content_for_chunk_iterator(
             reasoning_content = _get_reasoning_content(chunk)
             if reasoning_content:
                 if isfirst:
-                    chunk.content = f"{think_tag[0]}{reasoning_content}"
+                    chunk = chunk.model_copy(
+                        update={"content": f"{think_tag[0]}{reasoning_content}"}
+                    )
                     isfirst = False
                 else:
-                    chunk.content = reasoning_content
+                    chunk = chunk.model_copy(update={"content": reasoning_content})
             elif chunk.content and isend and not isfirst:
-                chunk.content = f"{think_tag[1]}{chunk.content}"
+                chunk = chunk.model_copy(
+                    update={"content": f"{think_tag[1]}{chunk.content}"}
+                )
                 isend = False
         yield chunk
 

langchain_dev_utils/tool_calling/utils.py

@@ -62,20 +62,20 @@ def parse_tool_calling(
         ...     tool_calls = parse_tool_calling(response)
     """
 
-    tool_call = None
+    tool_calls = None
 
     tool_call_blocks = [
         block for block in message.content_blocks if block["type"] == "tool_call"
     ]
     if tool_call_blocks:
-        tool_call = tool_call_blocks
+        tool_calls = tool_call_blocks
 
-    if not tool_call:
-        tool_call = message.tool_calls
+    if not tool_calls:
+        tool_calls = message.tool_calls
 
-    if not tool_call:
+    if not tool_calls:
         raise ValueError("No tool call found in message")
 
     if first_tool_call_only:
-        return (tool_call[0]["name"], tool_call[0]["args"])
-    return [(tool_call["name"], tool_call["args"]) for tool_call in tool_call]
+        return (tool_calls[0]["name"], tool_calls[0]["args"])
+    return [(tool_call["name"], tool_call["args"]) for tool_call in tool_calls]

{langchain_dev_utils-1.2.7.dist-info → langchain_dev_utils-1.2.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langchain-dev-utils
-Version: 1.2.7
+Version: 1.2.9
 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
@@ -192,52 +192,66 @@ def get_current_time() -> str:
 
 ### 4. **Agent Development**
 
-Includes the following features:
+Includes the following capabilities:
 
-- Predefined agent factory functions
-- Common middleware components
+- Multi-agent construction  
+- Commonly used middleware components  
 
-#### 4.1 Agent Factory Functions
+#### 4.1 Multi-Agent Construction
 
-In LangChain v1, the official `create_agent` function can be used to create a single agent; its `model` parameter accepts either a BaseChatModel instance or a specific string (when a string is provided, only models supported by `init_chat_model` are allowed). To extend the flexibility of specifying models via string, this library provides an equivalent `create_agent` function that lets you designate any model supported by `load_chat_model` (registration required beforehand).
+Wrapping an agent as a tool is a common implementation pattern in multi-agent systems, as elaborated in the official LangChain documentation. To support this pattern, this library provides a pre-built utility function `wrap_agent_as_tool`, which encapsulates an agent instance into a tool that can be invoked by other agents.
 
-Usage example:
+**Usage Example**:
 
 ```python
-from langchain_dev_utils.agents import create_agent
+import datetime
+from langchain_dev_utils.agents import create_agent, wrap_agent_as_tool
 from langchain.agents import AgentState
 
+
+@tool
+def get_current_time() -> str:
+    """Get the current time."""
+    return datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+
 agent = create_agent("vllm:qwen3-4b", tools=[get_current_time], name="time-agent")
-response = agent.invoke({"messages": [{"role": "user", "content": "What time is it?"}]})
+call_time_agent_tool = wrap_agent_as_tool(agent)
+response = call_time_agent_tool.invoke(
+    {"messages": [{"role": "user", "content": "What time is it now?"}]}
+)
 print(response)
 ```
 
 #### 4.2 Middleware
 
-Provides some commonly used middleware components. Below, we illustrate with `ToolCallRepairMiddleware` and `PlanMiddleware`.
-
-`ToolCallRepairMiddleware` is used to repair `invalid_tool_calls` generated by large language models.
+Provides several commonly used middleware components. Below are examples using `ToolCallRepairMiddleware` and `PlanMiddleware`.
 
-`PlanMiddleware` is used for agent planning.
+- `ToolCallRepairMiddleware` automatically repairs malformed tool calls found in the model's `invalid_tool_calls` output.
+- `PlanMiddleware` enables task planning capabilities for agents.
 
 ```python
 from langchain_dev_utils.agents.middleware import (
-    ToolcallRepairMiddleware,
+    ToolCallRepairMiddleware,
     PlanMiddleware,
 )
 
 agent = create_agent(
     "vllm:qwen3-4b",
     name="plan-agent",
-    middleware=[ToolCallRepairMiddleware(), PlanMiddleware(
-        use_read_plan_tool=False
-    )]
+    middleware=[
+        ToolCallRepairMiddleware(),
+        PlanMiddleware(use_read_plan_tool=False)
+    ]
 )
-response = agent.invoke({"messages": [{"role": "user", "content": "Give me a travel plan to New York"}]})
+response = agent.invoke({"messages": [{"role": "user", "content": "Give me a travel plan for visiting New York."}]})
 print(response)
 ```
 
-**For more information about agent development and all built-in middleware, please refer to**: [Pre-built Agent Functions](https://tbice123123.github.io/langchain-dev-utils-docs/en/agent-development/prebuilt.html), [Middleware](https://tbice123123.github.io/langchain-dev-utils-docs/en/agent-development/middleware.html)
+**For more details on agent development and a complete list of built-in middleware, please refer to**:  
+[Multi-Agent Construction](https://tbice123123.github.io/langchain-dev-utils-docs/en/agent-development/multi-agent.html),  
+[Middleware](https://tbice123123.github.io/langchain-dev-utils-docs/en/agent-development/middleware.html)
+
 
 ### 5. **State Graph Orchestration**
 

{langchain_dev_utils-1.2.7.dist-info → langchain_dev_utils-1.2.9.dist-info}/RECORD

@@ -1,5 +1,5 @@
-langchain_dev_utils/__init__.py,sha256=49prCLbE3fFzLfxem5rd2dr1iV4_L-bN0N4J7jxU5yA,22
-langchain_dev_utils/_utils.py,sha256=8Y8qzE9tWuF2UoDGa6xrTyEZRWtOmrGvXNroIF0SOCU,1207
+langchain_dev_utils/__init__.py,sha256=Oh3Y6CIypkhAjW-aquBTyP3_cA-gKgKTwq9EpcWpjps,22
+langchain_dev_utils/_utils.py,sha256=MFEzR1BjXMj6HEVwt2x2omttFuDJ_rYAEbNqe99r9pM,1338
 langchain_dev_utils/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langchain_dev_utils/agents/__init__.py,sha256=PJ-lSDZv_AXMYA3H4fx-HzJa14tPbkGmq1HX8LNfaPo,125
 langchain_dev_utils/agents/factory.py,sha256=XdGjktksfTDys7X4SgfPrQz10HUo5fTNAWESDQenIlE,3728
@@ -16,13 +16,13 @@ langchain_dev_utils/agents/middleware/tool_emulator.py,sha256=OgtPhqturaWzF4fRSJ
 langchain_dev_utils/agents/middleware/tool_selection.py,sha256=dRH5ejR6N02Djwxt6Gd63MYkg6SV5pySlzaRt53OoZk,3113
 langchain_dev_utils/chat_models/__init__.py,sha256=YSLUyHrWEEj4y4DtGFCOnDW02VIYZdfAH800m4Klgeg,224
 langchain_dev_utils/chat_models/base.py,sha256=CVMfgqMRnIKv8z4babusa2c4RKVuiWTL39mPD8cHAf4,11880
-langchain_dev_utils/chat_models/types.py,sha256=ch0t30oqjR-nePXWt_U5ybTohKeBZ1snTIOeQUEEBa8,510
+langchain_dev_utils/chat_models/types.py,sha256=kVLbT-IbvNtWPVmyVmh58le5r8XCqrEwuFB9-TWCBJk,672
 langchain_dev_utils/chat_models/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langchain_dev_utils/chat_models/adapters/openai_compatible.py,sha256=sG_qvdGyYN3bRFN28OyuR57tiqMv5QCq1gNA1QHAWco,20273
+langchain_dev_utils/chat_models/adapters/openai_compatible.py,sha256=YgC8ups0owOVmY-Fwi7oxiktsC9LG6UZka8XNTCBW9g,21457
 langchain_dev_utils/embeddings/__init__.py,sha256=zbEOaV86TUi9Zrg_dH9dpdgacWg31HMJTlTQknA9EKk,244
-langchain_dev_utils/embeddings/base.py,sha256=l4uCB5ecr3GAkfYGpYxqamOPIM6fkP1H_QK-277YEic,9295
+langchain_dev_utils/embeddings/base.py,sha256=BGoWY0L7nG9iRV3d4sSagXhECXrwvS1xA-A_OVltn3k,9406
 langchain_dev_utils/message_convert/__init__.py,sha256=ZGrHGXPKMrZ_p9MqfIVZ4jgbEyb7aC4Q7X-muuThIYU,457
-langchain_dev_utils/message_convert/content.py,sha256=LhrFXL1zYkkpp4ave6SBorDLig5xnllQ2VYCgFz-eR4,7681
+langchain_dev_utils/message_convert/content.py,sha256=2V1g21byg3iLv5RjUW8zv3jwYwV7IH2hNim7jGRsIes,8096
 langchain_dev_utils/message_convert/format.py,sha256=1TOcJ09atH7LRtn_IIuBshKDXAyqoy3Q9b0Po-S-F9g,2377
 langchain_dev_utils/pipeline/__init__.py,sha256=eE6WktaLHDkqMeXDIDaLtm-OPTwtsX_Av8iK9uYrceo,186
 langchain_dev_utils/pipeline/parallel.py,sha256=nwZWbdSNeyanC9WufoJBTceotgT--UnPOfStXjgNMOc,5271
@@ -30,8 +30,8 @@ langchain_dev_utils/pipeline/sequential.py,sha256=sYJXQzVHDKUc-UV-HMv38JTPnse1A7
 langchain_dev_utils/pipeline/types.py,sha256=T3aROKKXeWvd0jcH5XkgMDQfEkLfPaiOhhV2q58fDHs,112
 langchain_dev_utils/tool_calling/__init__.py,sha256=mu_WxKMcu6RoTf4vkTPbA1WSBSNc6YIqyBtOQ6iVQj4,322
 langchain_dev_utils/tool_calling/human_in_the_loop.py,sha256=7Z_QO5OZUR6K8nLoIcafc6osnvX2IYNorOJcbx6bVso,9672
-langchain_dev_utils/tool_calling/utils.py,sha256=W2ZRRMhn7SHHZxFfCXVaPIh2uFkY2XkO6EWrdRuv6VE,2757
-langchain_dev_utils-1.2.7.dist-info/METADATA,sha256=roKP7w_tdYwiRQiELlz1Bt_0U5F3uaE-cwa8iqk46-8,13100
-langchain_dev_utils-1.2.7.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-langchain_dev_utils-1.2.7.dist-info/licenses/LICENSE,sha256=AWAOzNEcsvCEzHOF0qby5OKxviVH_eT9Yce1sgJTico,1084
-langchain_dev_utils-1.2.7.dist-info/RECORD,,
+langchain_dev_utils/tool_calling/utils.py,sha256=S4-KXQ8jWmpGTXYZitovF8rxKpaSSUkFruM8LDwvcvE,2765
+langchain_dev_utils-1.2.9.dist-info/METADATA,sha256=zzBTgY8EUmuz08ofh1t1letaKywRXuqQgfPdqWBVw2Q,13279
+langchain_dev_utils-1.2.9.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+langchain_dev_utils-1.2.9.dist-info/licenses/LICENSE,sha256=AWAOzNEcsvCEzHOF0qby5OKxviVH_eT9Yce1sgJTico,1084
+langchain_dev_utils-1.2.9.dist-info/RECORD,,