langchain-dev-utils 1.1.11__tar.gz → 1.1.13__tar.gz

{langchain_dev_utils-1.1.11 → langchain_dev_utils-1.1.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langchain-dev-utils
-Version: 1.1.11
+Version: 1.1.13
 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
@@ -61,7 +61,7 @@ Mainly consists of the following two functions:
 
 - `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`: API address of the model provider (optional, valid when `chat_model` is a string and is "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_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.
 
 `load_chat_model` parameter description:
@@ -101,7 +101,7 @@ Mainly consists of the following two functions:
 
 - `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`: API address of the model provider (optional, valid when `embeddings_model` is a string and is "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")
 
 `load_embeddings` parameter description:
 

{langchain_dev_utils-1.1.11 → langchain_dev_utils-1.1.13}/README.md

@@ -45,7 +45,7 @@ Mainly consists of the following two functions:
 
 - `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`: API address of the model provider (optional, valid when `chat_model` is a string and is "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_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.
 
 `load_chat_model` parameter description:
@@ -85,7 +85,7 @@ Mainly consists of the following two functions:
 
 - `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`: API address of the model provider (optional, valid when `embeddings_model` is a string and is "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")
 
 `load_embeddings` parameter description:
 

{langchain_dev_utils-1.1.11 → langchain_dev_utils-1.1.13}/README_cn.md

@@ -45,7 +45,7 @@ pip install -U langchain-dev-utils[standard]
 
 - `provider_name`：模型提供商名称，作为后续模型加载的标识
 - `chat_model`：对话模型，可以是 ChatModel 或字符串（目前支持 "openai-compatible"）
-- `base_url`：模型提供商的 API 地址（可选，当 `chat_model` 为字符串且是"openai-compatible"时有效）
+- `base_url`：模型提供商的 API 地址（可选，对于`chat_model`的两种类型情况都有效，但是主要用于`chat_model`为字符串且是"openai-compatible"的情况）
 - `provider_config`：模型提供商的相关配置（可选，当 `chat_model` 为字符串且是 "openai-compatible" 时有效），可以配置一些提供商的相关参数，例如是否支持 json_mode 的结构化输出方式、支持的 tool_choice 列表等
 
 `load_chat_model` 参数说明：
@@ -85,7 +85,7 @@ print(model.invoke("Hello"))
 
 - `provider_name`：嵌入模型提供商名称，作为后续模型加载的标识
 - `embeddings_model`：嵌入模型，可以是 Embeddings 或字符串（目前支持 "openai-compatible"）
-- `base_url`：模型提供商的 API 地址（可选，当 `embeddings_model` 为字符串且是"openai-compatible"时有效）
+- `base_url`：嵌入模型提供商的 API 地址（可选，对于`embeddings_model`的两种类型情况都有效，但是主要用于`embeddings_model`为字符串且是"openai-compatible"的情况）
 
 `load_embeddings` 参数说明：
 

{langchain_dev_utils-1.1.11 → langchain_dev_utils-1.1.13}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "langchain-dev-utils"
-version = "1.1.11"
+version = "1.1.13"
 description = "A practical utility library for LangChain and LangGraph development"
 readme = "README.md"
 authors = [{ name = "tiebingice", email = "tiebingice123@outlook.com" }]
@@ -32,4 +32,5 @@ tests = [
     "python-dotenv>=1.1.1",
     "langchain-tests>=1.0.0",
     "langchain-deepseek>=1.0.0",
+    "langchain-qwq>=0.3.0",
 ]

langchain_dev_utils-1.1.13/src/langchain_dev_utils/__init__.py

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

langchain_dev_utils-1.1.13/src/langchain_dev_utils/agents/middleware/plan.py

@@ -0,0 +1,372 @@
+import json
+from typing import Awaitable, Callable, Literal, Optional
+from typing import NotRequired
+
+from langchain.agents.middleware import ModelRequest, ModelResponse
+from langchain.agents.middleware.types import (
+    AgentMiddleware,
+    AgentState,
+    ModelCallResult,
+)
+from langchain.tools import BaseTool, ToolRuntime, tool
+from langchain_core.messages import ToolMessage
+from langgraph.types import Command
+from typing_extensions import TypedDict
+
+_DEFAULT_WRITE_PLAN_TOOL_DESCRIPTION = """Use this tool to create and manage a structured task list for complex or multi-step work. It helps you stay organized, track progress, and demonstrate to the user that you’re handling tasks systematically.
+
+## When to Use This Tool  
+Use this tool in the following scenarios:
+
+1. **Complex multi-step tasks** — when a task requires three or more distinct steps or actions.  
+2. **Non-trivial and complex tasks** — tasks that require careful planning or involve multiple operations.  
+3. **User explicitly requests a to-do list** — when the user directly asks you to use the to-do list feature.  
+4. **User provides multiple tasks** — when the user supplies a list of items to be done (e.g., numbered or comma-separated).  
+5. **The plan needs adjustment based on current execution** — when ongoing progress indicates the plan should be revised.
+
+## How to Use This Tool  
+1. **When starting a task** — before actually beginning work, invoke this tool with a task list (a list of strings). The first task will automatically be set to `in_progress`, and all others to `pending`.  
+2. **When updating the task list** — for example, after completing some tasks, if you find certain tasks are no longer needed, remove them; if new necessary tasks emerge, add them. However, **do not modify** tasks already marked as completed. In such cases, simply call this tool again with the updated task list.
+
+## When NOT to Use This Tool  
+Avoid using this tool in the following situations:  
+1. The task is a **single, straightforward action**.  
+2. The task is **too trivial**, and tracking it provides no benefit.  
+3. The task can be completed in **fewer than three simple steps**.  
+4. The current task list has been fully completed — in this case, use `finish_sub_plan()` to finalize.
+
+## How It Works  
+- **Input**: A parameter named `plan` containing a list of strings representing the tasks (e.g., `["Task 1", "Task 2", "Task 3"]`).  
+- **Automatic status assignment**:  
+  → First task: `in_progress`  
+  → Remaining tasks: `pending`  
+- When updating the plan, provide only the **next set of tasks to execute**. For example, if the next phase requires `["Task 4", "Task 5"]`, call this tool with `plan=["Task 4", "Task 5"]`.
+
+## Task States  
+- `pending`: Ready to start, awaiting execution  
+- `in_progress`: Currently being worked on  
+- `done`: Completed  
+
+## Best Practices  
+- Break large tasks into clear, actionable steps.  
+- Use specific and descriptive task names.  
+- Update the plan immediately if priorities shift or blockers arise.  
+- Never leave the plan empty — as long as unfinished tasks remain, at least one must be marked `in_progress`.  
+- Do not batch completions — mark each task as done immediately after finishing it.  
+- Remove irrelevant tasks entirely instead of leaving them in `pending` state.
+
+**Remember**: If a task is simple, just do it. This tool is meant to provide structure — not overhead.
+"""
+
+_DEFAULT_FINISH_SUB_PLAN_TOOL_DESCRIPTION = """This tool is used to mark the currently in-progress task in an existing task list as completed.
+
+## Functionality  
+- Marks the current task with status `in_progress` as `done`, and automatically sets the next task (previously `pending`) to `in_progress`.
+
+## When to Use  
+Use only when you have confirmed that the current task is truly finished.
+
+## Example  
+Before calling:
+```json
+[
+    {"content": "Task 1", "status": "done"},
+    {"content": "Task 2", "status": "in_progress"},
+    {"content": "Task 3", "status": "pending"}
+]
+```
+
+After calling `finish_sub_plan()`:
+```json
+[
+    {"content": "Task 1", "status": "done"},
+    {"content": "Task 2", "status": "done"},
+    {"content": "Task 3", "status": "in_progress"}
+]
+```
+
+**Note**:  
+- This tool is **only** for marking completion — do **not** use it to create or modify plans (use `write_plan` instead).  
+- Ensure the task is genuinely complete before invoking this function.  
+- No parameters are required — status updates are handled automatically.
+"""
+
+_DEFAULT_READ_PLAN_TOOL_DESCRIPTION = """
+Get all sub-plans with their current status.
+"""
+
+
+class Plan(TypedDict):
+    content: str
+    status: Literal["pending", "in_progress", "done"]
+
+
+class PlanState(AgentState):
+    plan: NotRequired[list[Plan]]
+
+
+def create_write_plan_tool(
+    description: Optional[str] = None,
+    message_key: Optional[str] = None,
+) -> BaseTool:
+    """Create a tool for writing initial plan.
+
+    This function creates a tool that allows agents to write an initial plan
+    with a list of plans. The first plan in the plan will be marked as "in_progress"
+    and the rest as "pending".
+
+    Args:
+        description: The description of the tool. Uses default description if not provided.
+        message_key: The key of the message to be updated. Defaults to "messages".
+
+    Returns:
+        BaseTool: The tool for writing initial plan.
+
+    Example:
+        Basic usage:
+        >>> from langchain_dev_utils.agents.middleware import create_write_plan_tool
+        >>> write_plan_tool = create_write_plan_tool()
+    """
+
+    @tool(
+        description=description or _DEFAULT_WRITE_PLAN_TOOL_DESCRIPTION,
+    )
+    def write_plan(plan: list[str], runtime: ToolRuntime):
+        msg_key = message_key or "messages"
+        return Command(
+            update={
+                "plan": [
+                    {
+                        "content": content,
+                        "status": "pending" if index > 0 else "in_progress",
+                    }
+                    for index, content in enumerate(plan)
+                ],
+                msg_key: [
+                    ToolMessage(
+                        content=f"Plan successfully written, please first execute the {plan[0]} sub-plan (no need to change the status to in_process)",
+                        tool_call_id=runtime.tool_call_id,
+                    )
+                ],
+            }
+        )
+
+    return write_plan
+
+
+def create_finish_sub_plan_tool(
+    description: Optional[str] = None,
+    message_key: Optional[str] = None,
+) -> BaseTool:
+    """Create a tool for finishing sub-plan tasks.
+
+    This function creates a tool that allows agents to update the status of sub-plans in a plan. Sub-plans can be marked as "done" to track progress.
+
+    Args:
+        description: The description of the tool. Uses default description if not provided.
+        message_key: The key of the message to be updated. Defaults to "messages".
+
+    Returns:
+        BaseTool: The tool for finishing sub-plan tasks.
+
+    Example:
+        Basic usage:
+        >>> from langchain_dev_utils.agents.middleware import create_finish_sub_plan_tool
+        >>> finish_sub_plan_tool = create_finish_sub_plan_tool()
+    """
+
+    @tool(
+        description=description or _DEFAULT_FINISH_SUB_PLAN_TOOL_DESCRIPTION,
+    )
+    def finish_sub_plan(
+        runtime: ToolRuntime,
+    ):
+        msg_key = message_key or "messages"
+        plan_list = runtime.state.get("plan", [])
+
+        sub_finish_plan = ""
+        sub_next_plan = ",all sub plan are done"
+        for plan in plan_list:
+            if plan["status"] == "in_progress":
+                plan["status"] = "done"
+                sub_finish_plan = f"finish sub plan:**{plan['content']}**"
+
+        for plan in plan_list:
+            if plan["status"] == "pending":
+                plan["status"] = "in_progress"
+                sub_next_plan = f",next plan:**{plan['content']}**"
+                break
+
+        return Command(
+            update={
+                "plan": plan_list,
+                msg_key: [
+                    ToolMessage(
+                        content=sub_finish_plan + sub_next_plan,
+                        tool_call_id=runtime.tool_call_id,
+                    )
+                ],
+            }
+        )
+
+    return finish_sub_plan
+
+
+def create_read_plan_tool(
+    description: Optional[str] = None,
+):
+    """Create a tool for reading all sub-plans.
+
+    This function creates a tool that allows agents to read all sub-plans
+    in the current plan with their status information.
+
+    Args:
+        description: The description of the tool. Uses default description if not provided.
+
+    Returns:
+        BaseTool: The tool for reading all sub-plans.
+
+    Example:
+        Basic usage:
+        >>> from langchain_dev_utils.agents.middleware import create_read_plan_tool
+        >>> read_plan_tool = create_read_plan_tool()
+    """
+
+    @tool(
+        description=description or _DEFAULT_READ_PLAN_TOOL_DESCRIPTION,
+    )
+    def read_plan(runtime: ToolRuntime):
+        plan_list = runtime.state.get("plan", [])
+        return json.dumps(plan_list)
+
+    return read_plan
+
+
+_PLAN_SYSTEM_PROMPT_NOT_READ_PLAN = """You can manage task plans using two simple tools:
+
+## write_plan
+- Use it to break complex tasks (3+ steps) into a clear, actionable list. Only include next steps to execute — the first becomes `"in_progress"`, the rest `"pending"`. Don’t use it for simple tasks (<3 steps).
+
+## finish_sub_plan
+- Call it **only when the current task is 100% done**. It automatically marks it `"done"` and promotes the next `"pending"` task to `"in_progress"`. No parameters needed. Never use it mid-task or if anything’s incomplete.
+Keep plans lean, update immediately, and never batch completions.
+"""
+
+_PLAN_SYSTEM_PROMPT = """You can manage task plans using three simple tools:
+
+## write_plan
+- Use it to break complex tasks (3+ steps) into a clear, actionable list. Only include next steps to execute — the first becomes `"in_progress"`, the rest `"pending"`. Don’t use it for simple tasks (<3 steps).
+
+## finish_sub_plan
+- Call it **only when the current task is 100% done**. It automatically marks it `"done"` and promotes the next `"pending"` task to `"in_progress"`. No parameters needed. Never use it mid-task or if anything’s incomplete.
+
+## read_plan
+- Retrieve the full current plan list with statuses, especially when you forget which sub-plan you're supposed to execute next.
+- No parameters required—returns a current plan list with statuses.
+"""
+
+
+class PlanMiddleware(AgentMiddleware):
+    """Middleware that provides plan management capabilities to agents.
+
+    This middleware adds a `write_plan` and `finish_sub_plan` (and `read_plan` optional) tool that allows agents to create and manage
+    structured plan lists for complex multi-step operations. It's designed to help
+    agents track progress, organize complex tasks, and provide users with visibility
+    into task completion status.
+
+    The middleware automatically injects system prompts that guide the agent on how to use the plan functionality effectively.
+
+    Args:
+        system_prompt: Custom system prompt to guide the agent on using the plan tool.
+            If not provided, uses the default `_PLAN_SYSTEM_PROMPT` or `_PLAN_SYSTEM_PROMPT_NOT_READ_PLAN` based on the `use_read_plan_tool` parameter.
+        write_plan_tool_description: Description of the `write_plan` tool.
+            If not provided, uses the default `_DEFAULT_WRITE_PLAN_TOOL_DESCRIPTION`.
+        finish_sub_plan_tool_description: Description of the `finish_sub_plan` tool.
+            If not provided, uses the default `_DEFAULT_FINISH_SUB_PLAN_TOOL_DESCRIPTION`.
+        read_plan_tool_description: Description of the `read_plan` tool.
+            If not provided, uses the default `_DEFAULT_READ_PLAN_TOOL_DESCRIPTION`.
+        use_read_plan_tool: Whether to use the `read_plan` tool.
+            If not provided, uses the default `True`.
+    Example:
+        ```python
+        from langchain_dev_utils.agents.middleware.plan import PlanMiddleware
+        from langchain_dev_utils.agents import create_agent
+
+        agent = create_agent("vllm:qwen3-4b", middleware=[PlanMiddleware()])
+
+        # Agent now has access to write_plan tool and plan state tracking
+        result = await agent.invoke({"messages": [HumanMessage("Help me refactor my codebase")]})
+
+        print(result["plan"])  # Array of plan items with status tracking
+        ```
+    """
+
+    state_schema = PlanState
+
+    def __init__(
+        self,
+        *,
+        system_prompt: Optional[str] = None,
+        write_plan_tool_description: Optional[str] = None,
+        finish_sub_plan_tool_description: Optional[str] = None,
+        read_plan_tool_description: Optional[str] = None,
+        use_read_plan_tool: bool = True,
+        message_key: Optional[str] = None,
+    ) -> None:
+        super().__init__()
+
+        write_plan_tool_description = (
+            write_plan_tool_description or _DEFAULT_WRITE_PLAN_TOOL_DESCRIPTION
+        )
+        finish_sub_plan_tool_description = (
+            finish_sub_plan_tool_description
+            or _DEFAULT_FINISH_SUB_PLAN_TOOL_DESCRIPTION
+        )
+        read_plan_tool_description = (
+            read_plan_tool_description or _DEFAULT_READ_PLAN_TOOL_DESCRIPTION
+        )
+
+        tools = [
+            create_write_plan_tool(
+                description=write_plan_tool_description, message_key=message_key
+            ),
+            create_finish_sub_plan_tool(
+                description=finish_sub_plan_tool_description, message_key=message_key
+            ),
+        ]
+
+        if use_read_plan_tool:
+            tools.append(create_read_plan_tool(description=read_plan_tool_description))
+
+        if system_prompt is None:
+            if use_read_plan_tool:
+                system_prompt = _PLAN_SYSTEM_PROMPT
+            else:
+                system_prompt = _PLAN_SYSTEM_PROMPT_NOT_READ_PLAN
+
+        self.system_prompt = system_prompt
+        self.tools = tools
+
+    def wrap_model_call(
+        self,
+        request: ModelRequest,
+        handler: Callable[[ModelRequest], ModelResponse],
+    ) -> ModelCallResult:
+        request.system_prompt = (
+            request.system_prompt + "\n\n" + self.system_prompt
+            if request.system_prompt
+            else self.system_prompt
+        )
+        return handler(request)
+
+    async def awrap_model_call(
+        self,
+        request: ModelRequest,
+        handler: Callable[[ModelRequest], Awaitable[ModelResponse]],
+    ) -> ModelCallResult:
+        request.system_prompt = (
+            request.system_prompt + "\n\n" + self.system_prompt
+            if request.system_prompt
+            else self.system_prompt
+        )
+        return await handler(request)

{langchain_dev_utils-1.1.11 → langchain_dev_utils-1.1.13}/src/langchain_dev_utils/agents/wrap.py

@@ -1,5 +1,5 @@
 import asyncio
-from typing import Any, Awaitable, Optional, Callable, cast
+from typing import Any, Awaitable, Callable, Optional, cast
 
 from langchain.tools import ToolRuntime
 from langchain_core.messages import AnyMessage, HumanMessage

{langchain_dev_utils-1.1.11 → langchain_dev_utils-1.1.13}/src/langchain_dev_utils/chat_models/adapters/openai_compatible.py

@@ -46,7 +46,7 @@ _DictOrPydantic = Union[dict, _BM]
 
 
 class _ModelProviderConfigType(BaseModel):
-    supported_tool_choice: ToolChoiceType = Field(default=[])
+    supported_tool_choice: ToolChoiceType = Field(default_factory=list)
     keep_reasoning_content: bool = Field(default=False)
     support_json_mode: bool = Field(default=False)
 
@@ -126,12 +126,15 @@ class _BaseChatOpenAICompatible(BaseChatOpenAI):
         stop: list[str] | None = None,
         **kwargs: Any,
     ) -> dict:
+        payload = {**self._default_params, **kwargs}
+
+        if self._use_responses_api(payload):
+            return super()._get_request_payload(input_, stop=stop, **kwargs)
+
         messages = self._convert_input(input_).to_messages()
         if stop is not None:
             kwargs["stop"] = stop
 
-        payload = {**self._default_params, **kwargs}
-
         payload_messages = []
 
         for m in messages:

{langchain_dev_utils-1.1.11 → langchain_dev_utils-1.1.13}/src/langchain_dev_utils/chat_models/base.py

@@ -1,10 +1,11 @@
-import os
 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 .types import ChatModelType, ToolChoiceType
+from pydantic import BaseModel
 
 _MODEL_PROVIDERS_DICT = {}
 
@@ -22,6 +23,34 @@ class ChatModelProvider(TypedDict):
     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
+
+
 def _parse_model(model: str, model_provider: Optional[str]) -> tuple[str, str]:
     """Parse model string and provider.
 
@@ -71,6 +100,11 @@ def _load_chat_model_helper(
             "provider_config"
         ):
             kwargs.update({"provider_config": provider_config})
+
+        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})
         return chat_model(model=model, **kwargs)
 
     return _init_chat_model_helper(model, model_provider=model_provider, **kwargs)
@@ -91,7 +125,7 @@ def register_model_provider(
     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: Optional base URL for API endpoints (Optional parameter;effective only when `chat_model` is a string and is "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_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
     Raises:
@@ -113,6 +147,7 @@ def register_model_provider(
         >>> 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):
         try:
             from .adapters.openai_compatible import _create_openai_compatible_model
@@ -120,8 +155,6 @@ def register_model_provider(
             raise ImportError(
                 "Please install langchain_dev_utils[standard],when chat_model is a 'openai-compatible'"
             )
-
-        base_url = base_url or os.getenv(f"{provider_name.upper()}_API_BASE")
         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"
@@ -140,11 +173,17 @@ def register_model_provider(
                 provider_name: {
                     "chat_model": chat_model,
                     "provider_config": provider_config,
+                    "base_url": base_url,
                 }
             }
         )
     else:
-        _MODEL_PROVIDERS_DICT.update({provider_name: {"chat_model": chat_model}})
+        if base_url is not None:
+            _MODEL_PROVIDERS_DICT.update(
+                {provider_name: {"chat_model": chat_model, "base_url": base_url}}
+            )
+        else:
+            _MODEL_PROVIDERS_DICT.update({provider_name: {"chat_model": chat_model}})
 
 
 def batch_register_model_provider(
@@ -159,7 +198,7 @@ def batch_register_model_provider(
         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: Optional base URL for API endpoints(Optional parameter; effective only when `chat_model` is a string and is "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_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
 
@@ -235,6 +274,10 @@ def load_chat_model(
         ... )
         >>> model.invoke("Hello, how are you?")
     """
+    if "provider_config" in kwargs:
+        raise ValueError(
+            "provider_config is not a valid parameter in load_chat_model ,you can only set it when register model provider"
+        )
     return _load_chat_model_helper(
         cast(str, model),
         model_provider=model_provider,

{langchain_dev_utils-1.1.11 → langchain_dev_utils-1.1.13}/src/langchain_dev_utils/chat_models/types.py

@@ -1,4 +1,5 @@
 from typing import Literal, Union
+
 from langchain_core.language_models.chat_models import BaseChatModel