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

langchain_dev_utils/__init__.py

@@ -1 +1 @@
-__version__ = "1.2.4"
+__version__ = "1.2.6"

langchain_dev_utils/_utils.py

@@ -0,0 +1,39 @@
+from importlib import util
+
+from pydantic import BaseModel
+
+
+def _check_langchain_openai_install() -> None:
+    if not util.find_spec("langchain_openai"):
+        msg = (
+            "Please install langchain_dev_utils[standard],when use 'openai-compatible'"
+        )
+        raise ImportError(msg)
+
+
+def _get_base_url_field_name(model_cls: type[BaseModel]) -> str | None:
+    """
+    Return 'base_url' if the model has a field named or aliased as 'base_url',
+    else return 'api_base' if it has a field named or aliased as 'api_base',
+    else return None.
+    The return value is always either 'base_url', 'api_base', or None.
+    """
+    model_fields = model_cls.model_fields
+
+    # try model_fields first
+    if "base_url" in model_fields:
+        return "base_url"
+
+    if "api_base" in model_fields:
+        return "api_base"
+
+    # then try aliases
+    for field_info in model_fields.values():
+        if field_info.alias == "base_url":
+            return "base_url"
+
+    for field_info in model_fields.values():
+        if field_info.alias == "api_base":
+            return "api_base"
+
+    return None

langchain_dev_utils/agents/factory.py

@@ -10,6 +10,7 @@ from langchain.agents.middleware.types import (
     _OutputAgentState,
 )
 from langchain.agents.structured_output import ResponseFormat
+from langchain_core.messages import SystemMessage
 from langchain_core.tools import BaseTool
 from langgraph.cache.base import BaseCache
 from langgraph.graph.state import CompiledStateGraph
@@ -24,7 +25,7 @@ def create_agent(  # noqa: PLR0915
     model: str,
     tools: Sequence[BaseTool | Callable | dict[str, Any]] | None = None,
     *,
-    system_prompt: str | None = None,
+    system_prompt: str | SystemMessage | None = None,
     middleware: Sequence[AgentMiddleware[AgentState[ResponseT], ContextT]] = (),
     response_format: ResponseFormat[ResponseT] | type[ResponseT] | None = None,
     state_schema: type[AgentState[ResponseT]] | None = None,

langchain_dev_utils/agents/middleware/model_router.py

@@ -78,24 +78,6 @@ class ModelRouterMiddleware(AgentMiddleware):
     Examples:
         ```python
         from langchain_dev_utils.agents.middleware import ModelRouterMiddleware
-
-        model_list = [
-            {
-                "model_name": "vllm:qwen3-8b",
-                "model_description": "Suitable for general conversation and text generation tasks"
-            },
-            {
-                "model_name": "openrouter:qwen/qwen3-vl-32b-instruct",
-                "model_description": "For visual tasks",
-                "tools": []
-            },
-            {
-                "model_name": "openrouter:qwen/qwen3-coder-plus",
-                "model_description": "For code generation tasks",
-                "tools": [run_python_code]
-            }
-        ]
-
         middleware = ModelRouterMiddleware(
             router_model="vllm:qwen3-4b",
             model_list=model_list

langchain_dev_utils/chat_models/adapters/openai_compatible.py

@@ -38,7 +38,7 @@ from pydantic import (
 )
 from typing_extensions import Self
 
-from ..types import ProviderConfig, ToolChoiceType
+from ..types import CompatibilityOptions, ToolChoiceType
 
 _BM = TypeVar("_BM", bound=BaseModel)
 _DictOrPydanticClass = Union[dict[str, Any], type[_BM], type]
@@ -59,7 +59,7 @@ class _BaseChatOpenAICompatible(BaseChatOpenAI):
     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 provider_config 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 provider_config.
+    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.
 
@@ -82,9 +82,15 @@ class _BaseChatOpenAICompatible(BaseChatOpenAI):
 
     _provider: str = PrivateAttr(default="openai-compatible")
 
+    """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"""
+    include_usage: bool = Field(default=True)
+    """Whether to include usage information in the output"""
 
     @property
     def _supported_tool_choice(self) -> ToolChoiceType:
@@ -98,6 +104,10 @@ class _BaseChatOpenAICompatible(BaseChatOpenAI):
     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}"
@@ -290,7 +300,8 @@ class _BaseChatOpenAICompatible(BaseChatOpenAI):
         run_manager: Optional[CallbackManagerForLLMRun] = None,
         **kwargs: Any,
     ) -> Iterator[ChatGenerationChunk]:
-        kwargs["stream_options"] = {"include_usage": True}
+        if self._include_usage:
+            kwargs["stream_options"] = {"include_usage": True}
         try:
             for chunk in super()._stream(
                 messages, stop=stop, run_manager=run_manager, **kwargs
@@ -311,7 +322,8 @@ class _BaseChatOpenAICompatible(BaseChatOpenAI):
         run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
         **kwargs: Any,
     ) -> AsyncIterator[ChatGenerationChunk]:
-        kwargs["stream_options"] = {"include_usage": True}
+        if self._include_usage:
+            kwargs["stream_options"] = {"include_usage": True}
         try:
             async for chunk in super()._astream(
                 messages, stop=stop, run_manager=run_manager, **kwargs
@@ -458,8 +470,7 @@ class _BaseChatOpenAICompatible(BaseChatOpenAI):
 def _create_openai_compatible_model(
     provider: str,
     base_url: str,
-    provider_config: Optional[ProviderConfig] = None,
-    chat_model_cls_name: Optional[str] = None,
+    compatibility_options: Optional[CompatibilityOptions] = None,
 ) -> Type[_BaseChatOpenAICompatible]:
     """Factory function for creating provider-specific OpenAI-compatible model classes.
 
@@ -469,16 +480,15 @@ def _create_openai_compatible_model(
     Args:
         provider: Provider identifier (e.g., `vllm`,`openrouter`)
         base_url: Default API base URL for the provider
-        provider_config: Optional configuration for the provider
-        chat_model_cls_name: Optional custom name for the chat model class
+        compatibility_options: Optional configuration for the provider
 
     Returns:
         Configured model class ready for instantiation with provider-specific settings
     """
-    chat_model_cls_name = chat_model_cls_name or f"Chat{provider.title()}"
+    chat_model_cls_name = f"Chat{provider.title()}"
+
+    compatibility_options = compatibility_options or {}
 
-    if provider_config is None:
-        provider_config = {}
     return create_model(
         chat_model_cls_name,
         __base__=_BaseChatOpenAICompatible,
@@ -504,14 +514,18 @@ def _create_openai_compatible_model(
         ),
         supported_tool_choice=(
             ToolChoiceType,
-            Field(default=provider_config.get("supported_tool_choice", ["auto"])),
+            Field(default=compatibility_options.get("supported_tool_choice", ["auto"])),
         ),
         keep_reasoning_content=(
             bool,
-            Field(default=provider_config.get("keep_reasoning_content", False)),
+            Field(default=compatibility_options.get("keep_reasoning_content", False)),
         ),
         support_json_mode=(
             bool,
-            Field(default=provider_config.get("support_json_mode", False)),
+            Field(default=compatibility_options.get("support_json_mode", False)),
+        ),
+        include_usage=(
+            bool,
+            Field(default=compatibility_options.get("include_usage", True)),
         ),
     )

langchain_dev_utils/chat_models/base.py

@@ -3,9 +3,13 @@ from typing import Any, NotRequired, Optional, TypedDict, cast
 from langchain.chat_models.base import _SUPPORTED_PROVIDERS, _init_chat_model_helper
 from langchain_core.language_models.chat_models import BaseChatModel
 from langchain_core.utils import from_env
-from pydantic import BaseModel
 
-from .types import ChatModelType, ProviderConfig
+from langchain_dev_utils._utils import (
+    _check_langchain_openai_install,
+    _get_base_url_field_name,
+)
+
+from .types import ChatModelType, CompatibilityOptions
 
 _MODEL_PROVIDERS_DICT = {}
 
@@ -14,36 +18,8 @@ class ChatModelProvider(TypedDict):
     provider_name: str
     chat_model: ChatModelType
     base_url: NotRequired[str]
-    provider_profile: NotRequired[dict[str, dict[str, Any]]]
-    provider_config: NotRequired[ProviderConfig]
-
-
-def _get_base_url_field_name(model_cls: type[BaseModel]) -> str | None:
-    """
-    Return 'base_url' if the model has a field named or aliased as 'base_url',
-    else return 'api_base' if it has a field named or aliased as 'api_base',
-    else return None.
-    The return value is always either 'base_url', 'api_base', or None.
-    """
-    model_fields = model_cls.model_fields
-
-    # try model_fields first
-    if "base_url" in model_fields:
-        return "base_url"
-
-    if "api_base" in model_fields:
-        return "api_base"
-
-    # then try aliases
-    for field_info in model_fields.values():
-        if field_info.alias == "base_url":
-            return "base_url"
-
-    for field_info in model_fields.values():
-        if field_info.alias == "api_base":
-            return "api_base"
-
-    return None
+    model_profiles: NotRequired[dict[str, dict[str, Any]]]
+    compatibility_options: NotRequired[CompatibilityOptions]
 
 
 def _parse_model(model: str, model_provider: Optional[str]) -> tuple[str, str]:
@@ -89,17 +65,17 @@ def _load_chat_model_helper(
         BaseChatModel: Initialized chat model instance
     """
     model, model_provider = _parse_model(model, model_provider)
-    if model_provider in _MODEL_PROVIDERS_DICT.keys():
+    if model_provider in _MODEL_PROVIDERS_DICT:
         chat_model = _MODEL_PROVIDERS_DICT[model_provider]["chat_model"]
         if base_url := _MODEL_PROVIDERS_DICT[model_provider].get("base_url"):
             url_key = _get_base_url_field_name(chat_model)
             if url_key:
                 kwargs.update({url_key: base_url})
-        if provider_profile := _MODEL_PROVIDERS_DICT[model_provider].get(
-            "provider_profile"
+        if model_profiles := _MODEL_PROVIDERS_DICT[model_provider].get(
+            "model_profiles"
         ):
-            if model in provider_profile:
-                kwargs.update({"profile": provider_profile[model]})
+            if model in model_profiles and "profile" not in kwargs:
+                kwargs.update({"profile": model_profiles[model]})
         return chat_model(model=model, **kwargs)
 
     return _init_chat_model_helper(model, model_provider=model_provider, **kwargs)
@@ -109,8 +85,8 @@ def register_model_provider(
     provider_name: str,
     chat_model: ChatModelType,
     base_url: Optional[str] = None,
-    provider_profile: Optional[dict[str, dict[str, Any]]] = None,
-    provider_config: Optional[ProviderConfig] = None,
+    model_profiles: Optional[dict[str, dict[str, Any]]] = None,
+    compatibility_options: Optional[CompatibilityOptions] = None,
 ):
     """Register a new model provider.
 
@@ -119,12 +95,11 @@ def register_model_provider(
     string identifiers for supported providers.
 
     Args:
-        provider_name: Name of the provider to register
-        chat_model: Either a BaseChatModel class or a string identifier for a supported provider
-        base_url: The API address of the model provider (optional, valid for both types of `chat_model`, but mainly used when `chat_model` is a string and is "openai-compatible")
-        provider_profile: Model provider's model configuration file (optional, valid for both types of `chat_model`); finally, it will read the corresponding model configuration parameters based on `model_name` and set them to `model.profile`.
-        provider_config: The configuration of the model provider (Optional parameter;effective only when `chat_model` is a string and is "openai-compatible".)
-           It can be configured to configure some related parameters of the provider, such as whether to support json_mode structured output mode, the list of supported tool_choice
+        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
@@ -146,12 +121,9 @@ def register_model_provider(
     """
     base_url = base_url or from_env(f"{provider_name.upper()}_API_BASE", default=None)()
     if isinstance(chat_model, str):
-        try:
-            from .adapters.openai_compatible import _create_openai_compatible_model
-        except ImportError:
-            raise ImportError(
-                "Please install langchain_dev_utils[standard],when chat_model is a 'openai-compatible'"
-            )
+        _check_langchain_openai_install()
+        from .adapters.openai_compatible import _create_openai_compatible_model
+
         if base_url is None:
             raise ValueError(
                 f"base_url must be provided or set {provider_name.upper()}_API_BASE environment variable when chat_model is a string"
@@ -164,15 +136,14 @@ def register_model_provider(
         chat_model = _create_openai_compatible_model(
             provider_name,
             base_url,
-            provider_config=provider_config,
+            compatibility_options=compatibility_options,
         )
         _MODEL_PROVIDERS_DICT.update(
             {
                 provider_name: {
                     "chat_model": chat_model,
-                    "provider_config": provider_config,
                     "base_url": base_url,
-                    "provider_profile": provider_profile,
+                    "model_profiles": model_profiles,
                 }
             }
         )
@@ -183,7 +154,7 @@ def register_model_provider(
                     provider_name: {
                         "chat_model": chat_model,
                         "base_url": base_url,
-                        "provider_profile": provider_profile,
+                        "model_profiles": model_profiles,
                     }
                 }
             )
@@ -192,7 +163,7 @@ def register_model_provider(
                 {
                     provider_name: {
                         "chat_model": chat_model,
-                        "provider_profile": provider_profile,
+                        "model_profiles": model_profiles,
                     }
                 }
             )
@@ -208,36 +179,50 @@ def batch_register_model_provider(
 
     Args:
         providers: List of ChatModelProvider dictionaries, each containing:
-            - provider_name: Name of the provider to register
-            - chat_model: Either a BaseChatModel class or a string identifier for a supported provider
-            - base_url: The API address of the model provider (optional, valid for both types of `chat_model`, but mainly used when `chat_model` is a string and is "openai-compatible")
-            - provider_profile: Model provider's model configuration file (optional, valid for both types of `chat_model`); finally, it will read the corresponding model configuration parameters based on `model_name` and set them to `model.profile`.
-            - provider_config: The configuration of the model provider(Optional parameter; effective only when `chat_model` is a string and is "openai-compatible".)
-                It can be configured to configure some related parameters of the provider, such as whether to support json_mode structured output mode, the list of supported tool_choice
+            - provider_name (str): The name of the model provider, used as an
+              identifier for loading models later.
+            - chat_model (ChatModel | str): The chat model, which can be either
+              a `ChatModel` instance or a string (currently only `"openai-compatible"`
+              is supported).
+            - base_url (str, optional): The API endpoint URL of the model provider.
+              Applicable to both `chat_model` types, but primarily used when `chat_model`
+              is `"openai-compatible"`.
+            - model_profiles (dict, optional): Declares the capabilities and parameters
+              supported by each model. The configuration will be loaded and assigned to
+              `model.profile` (e.g., `max_input_tokens`, `tool_calling`, etc.).
+            - compatibility_options (CompatibilityOptions, optional): Compatibility
+              options for the model provider. Only effective when `chat_model` is
+              `"openai-compatible"`. Used to declare support for OpenAI-compatible features
+              (e.g., `tool_choice` strategies, JSON mode, etc.).
 
     Raises:
         ValueError: If any of the providers are invalid
 
     Example:
-        Register multiple providers at once:
-        >>> from langchain_dev_utils.chat_models import batch_register_model_provider, load_chat_model
-        >>> from langchain_core.language_models.fake_chat_models import FakeChatModel
-        >>>
-        >>> batch_register_model_provider([
-        ...     {
-        ...         "provider_name": "fakechat",
-        ...         "chat_model": FakeChatModel,
-        ...     },
-        ...     {
-        ...         "provider_name": "vllm",
-        ...         "chat_model": "openai-compatible",
-        ...         "base_url": "http://localhost:8000/v1",
-        ...     },
-        ... ])
-        >>> model = load_chat_model(model="fakechat:fake-model")
-        >>> model.invoke("Hello")
-        >>> model = load_chat_model(model="vllm:qwen3-4b")
-        >>> model.invoke("Hello")
+        Register multiple providers at once::
+
+            >>> 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
+            >>> batch_register_model_provider([
+            ...     {
+            ...         "provider_name": "fakechat",
+            ...         "chat_model": FakeChatModel,
+            ...     },
+            ...     {
+            ...         "provider_name": "vllm",
+            ...         "chat_model": "openai-compatible",
+            ...         "base_url": "http://localhost:8000/v1",
+            ...     },
+            ... ])
+            >>>
+            >>> # Use registered providers
+            >>> model = load_chat_model("fakechat:fake-model")
+            >>> model.invoke("Hello")
+            >>>
+            >>> model = load_chat_model("vllm:qwen3-4b")
+            >>> model.invoke("Hello")
     """
 
     for provider in providers:
@@ -245,8 +230,8 @@ def batch_register_model_provider(
             provider["provider_name"],
             provider["chat_model"],
             provider.get("base_url"),
-            provider_profile=provider.get("provider_profile"),
-            provider_config=provider.get("provider_config"),
+            model_profiles=provider.get("model_profiles"),
+            compatibility_options=provider.get("compatibility_options"),
         )
 
 

langchain_dev_utils/chat_models/types.py

@@ -9,7 +9,8 @@ ChatModelType = Union[type[BaseChatModel], Literal["openai-compatible"]]
 ToolChoiceType = list[Literal["auto", "none", "required", "specific"]]
 
 
-class ProviderConfig(TypedDict):
+class CompatibilityOptions(TypedDict):
     supported_tool_choice: NotRequired[ToolChoiceType]
     keep_reasoning_content: NotRequired[bool]
     support_json_mode: NotRequired[bool]
+    include_usage: NotRequired[bool]

langchain_dev_utils/embeddings/base.py

@@ -2,7 +2,11 @@ from typing import Any, Literal, NotRequired, Optional, TypedDict, Union
 
 from langchain.embeddings.base import Embeddings, _SUPPORTED_PROVIDERS, init_embeddings
 from langchain_core.utils import from_env, secret_from_env
-from pydantic import BaseModel
+
+from langchain_dev_utils._utils import (
+    _check_langchain_openai_install,
+    _get_base_url_field_name,
+)
 
 _EMBEDDINGS_PROVIDERS_DICT = {}
 
@@ -15,34 +19,6 @@ class EmbeddingProvider(TypedDict):
     base_url: NotRequired[str]
 
 
-def _get_base_url_field_name(model_cls: type[BaseModel]) -> str | None:
-    """
-    Return 'base_url' if the model has a field named or aliased as 'base_url',
-    else return 'api_base' if it has a field named or aliased as 'api_base',
-    else return None.
-    The return value is always either 'base_url', 'api_base', or None.
-    """
-    model_fields = model_cls.model_fields
-
-    # try model_fields first
-    if "base_url" in model_fields:
-        return "base_url"
-
-    if "api_base" in model_fields:
-        return "api_base"
-
-    # then try aliases
-    for field_info in model_fields.values():
-        if field_info.alias == "base_url":
-            return "base_url"
-
-    for field_info in model_fields.values():
-        if field_info.alias == "api_base":
-            return "api_base"
-
-    return None
-
-
 def _parse_model_string(model_name: str) -> tuple[str, str]:
     """Parse model string into provider and model name.
 
@@ -119,6 +95,8 @@ def register_embeddings_provider(
                 "when embeddings_model is a string, the value must be 'openai-compatible'"
             )
 
+        _check_langchain_openai_install()
+
         _EMBEDDINGS_PROVIDERS_DICT.update(
             {
                 provider_name: {
@@ -238,7 +216,6 @@ def load_embeddings(
             if embeddings == "openai-compatible":
                 kwargs["check_embedding_ctx_length"] = False
                 embeddings = "openai"
-
         return init_embeddings(
             model=model,
             provider=embeddings,

{langchain_dev_utils-1.2.4.dist-info → langchain_dev_utils-1.2.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langchain-dev-utils
-Version: 1.2.4
+Version: 1.2.6
 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
@@ -57,19 +57,23 @@ Mainly consists of the following two functions:
 - `register_model_provider`: Register a chat model provider
 - `load_chat_model`: Load a chat model
 
-`register_model_provider` parameter description:
+**`register_model_provider` Parameters:**
 
-- `provider_name`: Model provider name, used as an identifier for subsequent model loading
-- `chat_model`: Chat model, can be a ChatModel or a string (currently supports "openai-compatible")
-- `base_url`: The API address of the model provider (optional, valid for both types of `chat_model`, but mainly used when `chat_model` is a string and is "openai-compatible")
-- `provider_profile`: Model provider's model configuration file (optional, valid for both types of `chat_model`); finally, it will read the corresponding model configuration parameters based on `model_name` and set them to `model.profile`.
-- `provider_config`: Relevant configuration for the model provider (optional, valid when `chat_model` is a string and is "openai-compatible"), can configure some provider-related parameters, such as whether to support structured output in json_mode, list of supported tool_choices, etc.
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `provider_name` | str | Yes | - | The name of the model provider, used as an identifier for loading models later. |
+| `chat_model` | ChatModel \| str | Yes | - | The chat model, which can be either a `ChatModel` instance or a string (currently only `"openai-compatible"` is supported). |
+| `base_url` | str | No | - | The API endpoint URL of the model provider (applicable to both `chat_model` types, but primarily used when `chat_model` is a string with value `"openai-compatible"`). |
+| `model_profiles` | dict | No | - | Declares the capabilities and parameters supported by each model provided by this provider. 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` | dict | No | - | Compatibility options for the model provider (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. |
 
-`load_chat_model` parameter description:
+**`load_chat_model` Parameters:**
 
-- `model`: Chat model name, type str
-- `model_provider`: Chat model provider name, type str, optional
-- `kwargs`: Additional parameters passed to the chat model class, e.g., temperature, top_p, etc.
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `model` | str | Yes | - | Chat model name |
+| `model_provider` | str | No | - | Chat model provider name |
+| `kwargs` | dict | No | - | Additional parameters passed to the chat model class, e.g., temperature, top_p, etc. |
 
 Example for integrating a qwen3-4b model deployed using `vllm`:
 
@@ -98,17 +102,21 @@ Mainly consists of the following two functions:
 - `register_embeddings_provider`: Register an embedding model provider
 - `load_embeddings`: Load an embedding model
 
-`register_embeddings_provider` parameter description:
+**`register_embeddings_provider` Parameters:**
 
-- `provider_name`: Embedding model provider name, used as an identifier for subsequent model loading
-- `embeddings_model`: Embedding model, can be Embeddings or a string (currently supports "openai-compatible")
-- `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")
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `provider_name` | str | Yes | - | Embedding model provider name, used as an identifier for subsequent model loading |
+| `embeddings_model` | Embeddings \| str | Yes | - | Embedding model, can be Embeddings or a string (currently supports "openai-compatible") |
+| `base_url` | str | No | - | The API address of the Embedding model provider (valid for both types of `embeddings_model`, but mainly used when `embeddings_model` is a string and is "openai-compatible") |
 
-`load_embeddings` parameter description:
+**`load_embeddings` Parameters:**
 
-- `model`: Embedding model name, type str
-- `provider`: Embedding model provider name, type str, optional
-- `kwargs`: Other additional parameters
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `model` | str | Yes | - | Embedding model name |
+| `provider` | str | No | - | Embedding model provider name |
+| `kwargs` | dict | No | - | Other additional parameters |
 
 Example for integrating a qwen3-embedding-4b model deployed using `vllm`:
 
@@ -142,11 +150,15 @@ Includes the following features:
 
 For stream responses obtained using `stream()` and `astream()`, you can use `merge_ai_message_chunk` to merge them into a final AIMessage.
 
-`merge_ai_message_chunk` parameter description:
+**`merge_ai_message_chunk` Parameters:**
 
-- `chunks`: List of AIMessageChunk
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `chunks` | List[AIMessageChunk] | Yes | - | List of AIMessageChunk objects |
 
 ```python
+from langchain_dev_utils.message_convert import merge_ai_message_chunk
+
 chunks = list(model.stream("Hello"))
 merged = merge_ai_message_chunk(chunks)
 ```
@@ -155,16 +167,16 @@ merged = merge_ai_message_chunk(chunks)
 
 For a list, you can use `format_sequence` to format it.
 
-`format_sequence` parameter description:
+**`format_sequence` Parameters:**
 
-- `inputs`: A list containing any of the following types:
-  - langchain_core.messages: HumanMessage, AIMessage, SystemMessage, ToolMessage
-  - langchain_core.documents.Document
-  - str
-- `separator`: String used to join the content, defaults to "-".
-- `with_num`: If True, add a numeric prefix to each item (e.g., "1. Hello"), defaults to False.
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `inputs` | List | Yes | - | A list containing any of the following types: langchain_core.messages, langchain_core.documents.Document, str |
+| `separator` | str | No | "-" | String used to join the content |
+| `with_num` | bool | No | False | If True, add a numeric prefix to each item (e.g., "1. Hello") |
 
 ```python
+from langchain_dev_utils.message_convert import format_sequence
 text = format_sequence([
     "str1",
     "str2",
@@ -185,14 +197,18 @@ Includes the following features:
 
 `has_tool_calling` and `parse_tool_calling` are used to check and parse tool calls.
 
-`has_tool_calling` parameter description:
+**`has_tool_calling` Parameters:**
 
-- `message`: AIMessage object
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `message` | AIMessage | Yes | - | AIMessage object |
 
-`parse_tool_calling` parameter description:
+**`parse_tool_calling` Parameters:**
 
-- `message`: AIMessage object
-- `first_tool_call_only`: Whether to only check the first tool call
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `message` | AIMessage | Yes | - | AIMessage object |
+| `first_tool_call_only` | bool | No | False | Whether to only parse the first tool call |
 
 ```python
 import datetime
@@ -221,7 +237,7 @@ if has_tool_calling(response):
 Both can accept a `handler` parameter for custom breakpoint return and response handling logic.
 
 ```python
-from langchain_dev_utils import human_in_the_loop
+from langchain_dev_utils.tool_calling import human_in_the_loop
 from langchain_core.tools import tool
 import datetime
 
@@ -245,6 +261,13 @@ Includes the following features:
 
 In LangChain v1, the officially provided `create_agent` function can be used to create a single agent, where the model parameter supports passing a BaseChatModel instance or a specific string (when passing a string, it is limited to the models supported by `init_chat_model`). To extend the flexibility of specifying models via strings, this library provides a functionally identical `create_agent` function, allowing you to directly use models supported by `load_chat_model` (requires prior registration).
 
+**`create_agent` Parameters:**
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `model` | str  | Yes | - | Model name or model instance. Can be a string identifier for a model registered with `register_model_provider` or a BaseChatModel instance. |
+| Other parameters | Various | No | - | All other parameters are the same as in `langchain.agents.create_agent` |
+
 Usage example:
 
 ```python
@@ -293,15 +316,19 @@ Includes the following features:
 Sequential graph orchestration:
 Uses `create_sequential_pipeline`, supported parameters:
 
-- `sub_graphs`: List of state graphs to combine (must be StateGraph instances)
-- `state_schema`: State Schema for the final generated graph
-- `graph_name`: Name of the final generated graph (optional)
-- `context_schema`: Context Schema for the final generated graph (optional)
-- `input_schema`: Input Schema for the final generated graph (optional)
-- `output_schema`: Output Schema for the final generated graph (optional)
-- `checkpoint`: LangGraph persistence Checkpoint (optional)
-- `store`: LangGraph persistence Store (optional)
-- `cache`: LangGraph Cache (optional)
+**`create_sequential_pipeline` Parameters:**
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `sub_graphs` | List[StateGraph\|CompiledStateGraph] | Yes | - | List of state graphs to combine (must be StateGraph instances or CompiledStateGraph instances) |
+| `state_schema` | type | Yes | - | State Schema for the final generated graph |
+| `graph_name` | str | No | - | Name of the final generated graph |
+| `context_schema` | type | No | - | Context Schema for the final generated graph |
+| `input_schema` | type | No | - | Input Schema for the final generated graph |
+| `output_schema` | type | No | - | Output Schema for the final generated graph |
+| `checkpoint` | BaseCheckpointSaver | No | - | LangGraph persistence Checkpoint |
+| `store` | BaseStore | No | - | LangGraph persistence Store |
+| `cache` | BaseCache | No | - | LangGraph Cache |
 
 ```python
 from langchain.agents import AgentState
@@ -350,16 +377,20 @@ print(response)
 Parallel graph orchestration:
 Uses `create_parallel_pipeline`, supported parameters:
 
-- `sub_graphs`: List of state graphs to combine
-- `state_schema`: State Schema for the final generated graph
-- `branches_fn`: Parallel branch function, returns a list of Send objects to control parallel execution
-- `graph_name`: Name of the final generated graph (optional)
-- `context_schema`: Context Schema for the final generated graph (optional)
-- `input_schema`: Input Schema for the final generated graph (optional)
-- `output_schema`: Output Schema for the final generated graph (optional)
-- `checkpoint`: LangGraph persistence Checkpoint (optional)
-- `store`: LangGraph persistence Store (optional)
-- `cache`: LangGraph Cache (optional)
+**`create_parallel_pipeline` Parameters:**
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `sub_graphs` | List[StateGraph\|CompiledStateGraph] | Yes | - | List of state graphs to combine (must be StateGraph instances or CompiledStateGraph instances) |
+| `state_schema` | type | Yes | - | State Schema for the final generated graph |
+| `branches_fn` | Callable | Yes | - | Parallel branch function, returns a list of Send objects to control parallel execution |
+| `graph_name` | str | No | - | Name of the final generated graph |
+| `context_schema` | type | No | - | Context Schema for the final generated graph |
+| `input_schema` | type | No | - | Input Schema for the final generated graph |
+| `output_schema` | type | No | - | Output Schema for the final generated graph |
+| `checkpoint` | BaseCheckpointSaver | No | - | LangGraph persistence Checkpoint |
+| `store` | BaseStore | No | - | LangGraph persistence Store |
+| `cache` | BaseCache | No | - | LangGraph Cache |
 
 ```python
 from langchain_dev_utils.pipeline import create_parallel_pipeline
@@ -398,4 +429,4 @@ print(response)
 
 - [GitHub Repository](https://github.com/TBice123123/langchain-dev-utils) — Browse source code, submit Pull Requests
 - [Issue Tracker](https://github.com/TBice123123/langchain-dev-utils/issues) — Report bugs or suggest improvements
-- We welcome contributions in all forms — whether code, documentation, or usage examples. Let's build a more powerful and practical LangChain development ecosystem together!
+- We welcome contributions in all forms — whether code, documentation, or usage examples. Let's build a more powerful and practical LangChain development ecosystem together!

{langchain_dev_utils-1.2.4.dist-info → langchain_dev_utils-1.2.6.dist-info}/RECORD

@@ -1,24 +1,25 @@
-langchain_dev_utils/__init__.py,sha256=XBKH8E1LmDxv06U39yqMBbXZapOERFgICEDYZs_kRso,22
+langchain_dev_utils/__init__.py,sha256=vMQK58X8_YZGKzRm0ThvPAKFtpfyejGmUnDrY9RQ13w,22
+langchain_dev_utils/_utils.py,sha256=5bFs4cf3HvkMNkv35V8Sowu4YSXmfF5VNwmv_eHfkgQ,1151
 langchain_dev_utils/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langchain_dev_utils/agents/__init__.py,sha256=e17SMQdJIQngbUCr2N1tY-yw0tD3tEnH7PSvyDmVPeQ,127
-langchain_dev_utils/agents/factory.py,sha256=h4uAkid2NJMMs4qV6RYFexew-ixfhEvpa254eDeDEcU,3912
+langchain_dev_utils/agents/factory.py,sha256=JjdJwPTJpQwAlwQlBalbuGej5Jcpy2Fz6lH3EwEaxQo,3979
 langchain_dev_utils/agents/file_system.py,sha256=S6RUEmQI2eerW0gBQp0IP0X5ak5FwvqgIGRiycr2iyw,8468
 langchain_dev_utils/agents/plan.py,sha256=ydJuJLlNydheQvLPl2uCc3TBVv42YxGzPhKgtldIdIk,6497
 langchain_dev_utils/agents/wrap.py,sha256=4BWksU9DRz8c3ZHQiUi4GHwGhNysDLNs8pmLWV7BeAI,5165
 langchain_dev_utils/agents/middleware/__init__.py,sha256=cjrb8Rue5uukl9pKPF7CjSrHtcYsUBj3Mdvv2szlp7E,679
 langchain_dev_utils/agents/middleware/model_fallback.py,sha256=pXdraahOMukLgvjX70LwhrjIoEhLYQfNEwJMQHG2WPk,1673
-langchain_dev_utils/agents/middleware/model_router.py,sha256=bq-sQ7wmvpeRM3cjFPErLQxiWfS6l5nEVBN01NNWjAU,9077
+langchain_dev_utils/agents/middleware/model_router.py,sha256=Qb_s_FoREp11yKHdmp_ZTRxB1whsFrj86awUNR0fpCk,8461
 langchain_dev_utils/agents/middleware/plan.py,sha256=saRXhzkC2pd7LNiNclSmGJelmisbTXhhTrbSUkSkf9g,16220
 langchain_dev_utils/agents/middleware/summarization.py,sha256=BtWPJcQBssGAT0nb1c0xsGEOsb8x5sAAE6xqujYjHhY,3027
 langchain_dev_utils/agents/middleware/tool_emulator.py,sha256=u9rV24yUB-dyc1uUfUe74B1wOGVI3TZRwxkE1bvGm18,2025
 langchain_dev_utils/agents/middleware/tool_selection.py,sha256=ZqdyK4Yhp2u3GM6B_D6U7Srca9vy1o7s6N_LrV24-dQ,3107
 langchain_dev_utils/chat_models/__init__.py,sha256=YSLUyHrWEEj4y4DtGFCOnDW02VIYZdfAH800m4Klgeg,224
-langchain_dev_utils/chat_models/base.py,sha256=emQs5biWgeqP9a8cEoovpOzn34w91-_SiTnytu-C5PM,12051
-langchain_dev_utils/chat_models/types.py,sha256=FM_RyiGRTb1dy59MovhDYM4Kj9cpybt2BFha0e2u0qA,468
+langchain_dev_utils/chat_models/base.py,sha256=AYRcGViGJYsquqru_www3zt8-ZCkfzPCrw-dFF6HDts,11661
+langchain_dev_utils/chat_models/types.py,sha256=M0iCGWgXmX1f1vkymH-jNGdFQlsJS5JqpmgHctUS9jw,512
 langchain_dev_utils/chat_models/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langchain_dev_utils/chat_models/adapters/openai_compatible.py,sha256=wR7Uym9rQWsxhsBt8LrE30dayWcMnbsU8AXC4kOtnyI,19719
+langchain_dev_utils/chat_models/adapters/openai_compatible.py,sha256=4Q8ySa7jS2_AFo0oxLoqeY_aQyPppvV-DAMLt2rmGoE,20192
 langchain_dev_utils/embeddings/__init__.py,sha256=zbEOaV86TUi9Zrg_dH9dpdgacWg31HMJTlTQknA9EKk,244
-langchain_dev_utils/embeddings/base.py,sha256=25ebUEaf7075h8NARgTHjAvwK6JddhHor5upiucJqu0,9686
+langchain_dev_utils/embeddings/base.py,sha256=lGZWbi6G1M0OcAO_d_k1QAFJm9z9gM0L4UAZ6xFtEoQ,8973
 langchain_dev_utils/message_convert/__init__.py,sha256=xwjaQ1oJoc80xy70oQI4uW3gAmgV5JymJd5hgnA6s3g,458
 langchain_dev_utils/message_convert/content.py,sha256=ApmQ7fUUBO3Ihjm2hYSWd4GrU_CvrjbWla-MA7DAFRc,7758
 langchain_dev_utils/message_convert/format.py,sha256=fh4GyyuZBTMrHeCEwdu9fOh5n8tdli1vDF44jK1i-tI,2373
@@ -29,7 +30,7 @@ langchain_dev_utils/pipeline/types.py,sha256=T3aROKKXeWvd0jcH5XkgMDQfEkLfPaiOhhV
 langchain_dev_utils/tool_calling/__init__.py,sha256=mu_WxKMcu6RoTf4vkTPbA1WSBSNc6YIqyBtOQ6iVQj4,322
 langchain_dev_utils/tool_calling/human_in_the_loop.py,sha256=nbaON9806pv5tpMRQUA_Ch3HJA5HBFgzZR7kQRf6PiY,9819
 langchain_dev_utils/tool_calling/utils.py,sha256=3cNv_Zx32KxdsGn8IkxjWUzxYEEwVJeJgTZTbfSg0pA,2751
-langchain_dev_utils-1.2.4.dist-info/METADATA,sha256=1bYaEqoBkx54fvr35w355lth8_OwMz4g2OS1SWnzlag,16536
-langchain_dev_utils-1.2.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-langchain_dev_utils-1.2.4.dist-info/licenses/LICENSE,sha256=AWAOzNEcsvCEzHOF0qby5OKxviVH_eT9Yce1sgJTico,1084
-langchain_dev_utils-1.2.4.dist-info/RECORD,,
+langchain_dev_utils-1.2.6.dist-info/METADATA,sha256=PhJoxRlERmnMzRumGzLW3kwU58Cg3Tt6MiFibsfIi8U,19090
+langchain_dev_utils-1.2.6.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+langchain_dev_utils-1.2.6.dist-info/licenses/LICENSE,sha256=AWAOzNEcsvCEzHOF0qby5OKxviVH_eT9Yce1sgJTico,1084
+langchain_dev_utils-1.2.6.dist-info/RECORD,,