langchain-dev-utils 1.1.11__py3-none-any.whl → 1.1.13__py3-none-any.whl

langchain_dev_utils/__init__.py

@@ -1 +1 @@
-__version__ = "1.1.11"
+__version__ = "1.1.13"

langchain_dev_utils/agents/middleware/plan.py

@@ -13,138 +13,82 @@ from langchain_core.messages import ToolMessage
 from langgraph.types import Command
 from typing_extensions import TypedDict
 
-_DEFAULT_WRITE_PLAN_TOOL_DESCRIPTION = """
-This tool is used to **create a new plan list ** or **modify an existing plan**.
-
-Parameters:
-`plan`: A list of strings representing the plans to be executed. The first plan in the list will automatically be set to the "in_progress" status, and all remaining plans will be set to the "pending" status. Internally, each string is converted into a dictionary containing "content" and "status" keys, where "content" corresponds to each string value in the list, and the "status" is assigned according to the rule: the first plan is "in_progress", and all others are "pending".
-When modifying a plan, only provide the plans that need to be executed next. For example, if the current plan is ['Plan 1', 'Plan 2', 'Plan 3'], and Plan 1 is completed, but you determine that Plan 2 and Plan 3 are no longer suitable and should be replaced with ['Plan 4', 'Plan 5'], then only pass ['Plan 4', 'Plan 5'].
-
-## Tool Functionality
-
-This tool is used to **create a new plan list** or **modify an existing plan list**.
-
-- **Primary Use**: Create a new plan list.
-- **Secondary Use**: Modify the plan when problems are identified with the existing one.
-- **Not For**: Marking plans as completed.
-
-## Plan Statuses
-
-Use the following statuses to track progress:
-
-- `pending`: Plan has not yet started.
-- `in_progress`: Currently being worked on.
-- `done`: Plan has been completed.
-
-## Usage Guidelines
-
-### Creating a Plan (Primary Use)
-
-Call this tool to create a structured plan when dealing with complex tasks:
-
-- Complex multi-step tasks (≥3 steps).
-- Non-trivial tasks requiring careful planning.
-- The user explicitly requests a plan list.
-
-### Modifying a Plan (Special Cases)
-
-Modify an existing plan only under the following circumstances:
-
-- The current plan structure is found to be problematic.
-- The plan structure or content needs adjustment.
-- The existing plan cannot be executed effectively.
-
-**Important Update Behavior**: When updating a plan, only pass the list of plans that need to be executed next. The tool automatically handles status assignment – the first plan is set to `in_progress`, and the rest are set to `pending`.
-
-### Plan Completion
-
-**Important Note**: When completing a plan, call the `finish_sub_plan()` function to update the plan status. **Do not use this tool**.
-
-## When to Use
-
-**Appropriate Scenarios**:
-
-- When starting a new complex work session.
-- When needing to reorganize the plan structure.
-- When the current plan needs revision based on new information.
-
-**Scenarios to Avoid**:
-
-- Simple tasks (<3 steps).
-- When only needing to mark a plan as complete.
-- Purely informational queries or conversation.
-- Trivial tasks that can be completed directly.
-
-## Best Practices
-
-1. When creating a plan, the first plan is automatically set to `in_progress`.
-2. Ensure sub-plans within the plan are specific and actionable.
-3. Break down complex sub-plans into smaller steps.
-4. Always keep at least one plan in the `in_progress` status unless all plans are completed.
-5. When modifying a plan, only provide the sub-plans that need to be executed next.
-6. Use clear, descriptive names for sub-plans.
-
-## Internal Processing Logic
-
-The tool automatically converts the input strings into a structured format:
-
-- Input: `["Sub-plan 1", "Sub-plan 2", "Sub-plan 3"]`
-- Internal Representation:
-```json
-  [
-  {"content": "Sub-plan 1", "status": "in_progress"},
-  {"content": "Sub-plan 2", "status": "pending"},
-  {"content": "Sub-plan 3", "status": "pending"}
-  ]
-```
-
-Please remember:
-
-- For simple plans, execute them directly; there is no need to call this tool.
-- Use the `finish_sub_plan()` function to mark sub-plans as completed.
-- When modifying a plan, only provide the sub-plans that need to be executed next.
+_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 completion status of a sub-plan in an existing plan.
-
-Functionality:
-- Marks the sub-plan with status 'in_progress' as 'done'
-- Sets the first sub-plan with status 'pending' to 'in_progress' (if one exists)
+_DEFAULT_FINISH_SUB_PLAN_TOOL_DESCRIPTION = """This tool is used to mark the currently in-progress task in an existing task list as completed.
 
-## Tool Purpose
-Specifically designed to **mark the current sub-plan as completed** in an existing plan.
+## 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 the current sub-plan is confirmed complete.
+## When to Use  
+Use only when you have confirmed that the current task is truly finished.
 
-### Automatic Status Management
-- `in_progress` → `done`
-- First `pending` → `in_progress` (if any)
-
-## Usage Example
-Current plan status:
+## Example  
+Before calling:
 ```json
 [
-    {"content": "Research market trends", "status": "done"},
-    {"content": "Analyze competitor data", "status": "in_progress"},
-    {"content": "Prepare summary report", "status": "pending"}
+    {"content": "Task 1", "status": "done"},
+    {"content": "Task 2", "status": "in_progress"},
+    {"content": "Task 3", "status": "pending"}
 ]
 ```
 
-After calling finish_sub_plan():
+After calling `finish_sub_plan()`:
 ```json
 [
-    {"content": "Research market trends", "status": "done"},
-    {"content": "Analyze competitor data", "status": "done"},
-    {"content": "Prepare summary report", "status": "in_progress"}
+    {"content": "Task 1", "status": "done"},
+    {"content": "Task 2", "status": "done"},
+    {"content": "Task 3", "status": "in_progress"}
 ]
 ```
 
-Remember:
-- Only for marking completion—do not use to create or modify plans (use write_plan instead)
-- Ensure the sub-plan is truly complete before calling
-- No parameters needed; status transitions are handled automatically
+**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 = """
@@ -298,67 +242,27 @@ def create_read_plan_tool(
     return read_plan
 
 
-_READ_PLAN_SYSTEM_PROMPT = """### 3. read_plan: View Current Plan
-- **Purpose**: 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 complete snapshot of the active 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_MIDDLEWARE_SYSTEM_PROMPT = """
-You can manage task plans using the following {num} tools:
-
-## 1. write_plan: Create or Replace a Plan
-- **Primary Purpose**: Generate a structured execution framework for complex tasks, or completely replace the remaining plan sequence when the current plan is no longer valid.
-- **When to Use**:
-  - The task requires 3 or more distinct, actionable steps
-  - The user explicitly requests a plan list or "to-do plan"
-  - The user provides multiple plans (e.g., numbered list, comma-separated items)
-  - Execution reveals fundamental flaws in the current plan, requiring a new direction
-- **Input Format**: A list of plan description strings, e.g., ["Analyze user needs", "Design system architecture", "Implement core module"]
-- **Automatic Status Assignment**:
-  - First plan → `"in_progress"`
-  - All subsequent plans → `"pending"`
-- **Plan Replacement Rule**: Provide **only the new plans that should be executed next**. Do not include completed, obsolete, or irrelevant plans.
-- **Plan Quality Requirements**:
-  - Plans must be specific, actionable, and verifiable
-  - Break work into logical phases (chronological or dependency-based)
-  - Define clear milestones and deliverable standards
-  - Avoid vague, ambiguous, or non-executable descriptions
-- **Do NOT Use When**:
-  - The task is simple (<3 steps)
-  - The request is conversational, informational, or a one-off query
-  - You only need to mark a plan as complete (use `finish_sub_plan` instead)
-
-## 2. finish_sub_plan: Mark Current Plan as Complete
-- **Primary Purpose**: Confirm the current `"in_progress"` plan is fully done, mark it as `"done"`, and automatically promote the first `"pending"` plan to `"in_progress"`.
-- **Call Only If ALL Conditions Are Met**:
-  - The sub-plan has been **fully executed**
-  - All specified requirements have been satisfied
-  - There are no unresolved errors, omissions, or blockers
-  - The output meets quality standards and has been verified
-- **Automatic Behavior**:
-  - No parameters needed—status transitions are handled internally
-  - If no `"pending"` plans remain, the plan ends naturally
-- **Never Call If**:
-  - The plan is partially complete
-  - Known issues or defects remain
-  - Execution was blocked due to missing resources or dependencies
-  - The result fails to meet expected quality
-
-{read_plan_system_prompt}
-
-## Plan Status Rules (Only These Three Are Valid)
-- **`"pending"`**: Plan not yet started
-- **`"in_progress"`**: Currently being executed (exactly one allowed at any time)
-- **`"done"`**: Fully completed and verified  
-> ⚠️ No other status values (e.g., "completed", "failed", "blocked") are permitted.
-
-## General Usage Principles
-1. **Execute simple plans directly**: If a request can be fulfilled in 1–2 steps, do not create a plan—just complete it.
-2. **Decompose thoughtfully**: Break complex work into clear, independent, trackable sub-plans.
-3. **Manage status rigorously**:
-   - Always maintain exactly one `"in_progress"` plan while work is ongoing
-   - Call `finish_sub_plan` immediately after plan completion—never delay
-4. **Plan modification = full replacement**: Never edit individual plans. To adjust the plan, use `write_plan` with a new list of remaining plans.
-5. **Respect user intent**: If the user explicitly asks for a plan—even for a simpler task—honor the request and create one.
+
+_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.
 """
 
 
@@ -374,9 +278,15 @@ class PlanMiddleware(AgentMiddleware):
 
     Args:
         system_prompt: Custom system prompt to guide the agent on using the plan tool.
-            If not provided, uses the default `_PLAN_MIDDLEWARE_SYSTEM_PROMPT`.
-        tools: List of tools to be added to the agent. The tools must be created by `create_write_plan_tool`, `create_finish_sub_plan_tool`, and `create_read_plan_tool`(optional).
-
+            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
@@ -397,41 +307,45 @@ class PlanMiddleware(AgentMiddleware):
         self,
         *,
         system_prompt: Optional[str] = None,
-        tools: Optional[list[BaseTool]] = 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__()
 
-        if tools is None:
-            tools = [
-                create_write_plan_tool(),
-                create_finish_sub_plan_tool(),
-                create_read_plan_tool(),
-            ]
-
-        # Check if required tools exist
-        has_write_plan = any(tool_obj.name == "write_plan" for tool_obj in tools)
-        has_finish_sub_plan = any(
-            tool_obj.name == "finish_sub_plan" for tool_obj in tools
+        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
         )
 
-        if not (has_write_plan and has_finish_sub_plan):
-            raise ValueError(
-                "PlanMiddleware requires exactly two tools: write_plan and finish_sub_plan."
-            )
+        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
+            ),
+        ]
 
-        self.tools = tools
+        if use_read_plan_tool:
+            tools.append(create_read_plan_tool(description=read_plan_tool_description))
 
         if system_prompt is None:
-            num = len(self.tools)
-            read_plan_system = (
-                _READ_PLAN_SYSTEM_PROMPT if num == 3 else ""
-            )  # if read_plan tool is not provided, do not include it in the system prompt
-
-            system_prompt = _PLAN_MIDDLEWARE_SYSTEM_PROMPT.format(
-                num=num, read_plan_system_prompt=read_plan_system
-            )
+            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,

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/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/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/chat_models/types.py

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

langchain_dev_utils/embeddings/base.py

@@ -1,7 +1,8 @@
-import os
 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
 
 _EMBEDDINGS_PROVIDERS_DICT = {}
 
@@ -14,6 +15,34 @@ 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.
 
@@ -56,7 +85,7 @@ def register_embeddings_provider(
     Args:
         provider_name: Name of the provider to register
         embeddings_model: Either an Embeddings class or a string identifier for a supported provider
-        base_url: Optional base URL for API endpoints (required when embeddings_model is a string)
+        base_url: The API address of the Embedding model provider (optional, valid for both types of `embeddings_model`, but mainly used when `embeddings_model` is a string and is "openai-compatible")
 
     Raises:
         ValueError: If base_url is not provided when embeddings_model is a string
@@ -77,8 +106,9 @@ def register_embeddings_provider(
         >>> embeddings = load_embeddings("vllm:qwen3-embedding-4b")
         >>> embeddings.embed_query("hello world")
     """
+
+    base_url = base_url or from_env(f"{provider_name.upper()}_API_BASE", default=None)()
     if isinstance(embeddings_model, str):
-        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 embeddings_model is a string"
@@ -98,9 +128,19 @@ def register_embeddings_provider(
             }
         )
     else:
-        _EMBEDDINGS_PROVIDERS_DICT.update(
-            {provider_name: {"embeddings_model": embeddings_model}}
-        )
+        if base_url is not None:
+            _EMBEDDINGS_PROVIDERS_DICT.update(
+                {
+                    provider_name: {
+                        "embeddings_model": embeddings_model,
+                        "base_url": base_url,
+                    }
+                }
+            )
+        else:
+            _EMBEDDINGS_PROVIDERS_DICT.update(
+                {provider_name: {"embeddings_model": embeddings_model}}
+            )
 
 
 def batch_register_embeddings_provider(
@@ -115,7 +155,7 @@ def batch_register_embeddings_provider(
         providers: List of EmbeddingProvider dictionaries, each containing:
             - provider_name: str - Provider name
             - embeddings_model: Union[Type[Embeddings], str] - Model class or provider string
-            - base_url: Optional[str] - Base URL for API endpoints
+            - base_url: The API address of the Embedding model provider (optional, valid for both types of `embeddings_model`, but mainly used when `embeddings_model` is a string and is "openai-compatible")
 
     Raises:
         ValueError: If any of the providers are invalid
@@ -186,7 +226,7 @@ def load_embeddings(
     embeddings = _EMBEDDINGS_PROVIDERS_DICT[provider]["embeddings_model"]
     if isinstance(embeddings, str):
         if not (api_key := kwargs.get("api_key")):
-            api_key = os.getenv(f"{provider.upper()}_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."
@@ -203,4 +243,8 @@ def load_embeddings(
             **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)

{langchain_dev_utils-1.1.11.dist-info → langchain_dev_utils-1.1.13.dist-info}/METADATA

@@ -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.dist-info → langchain_dev_utils-1.1.13.dist-info}/RECORD

@@ -1,24 +1,24 @@
-langchain_dev_utils/__init__.py,sha256=onvMxIPKVCA4yl5UqyZ5erfVCfX2V2Tl84vB4lkYg0M,23
+langchain_dev_utils/__init__.py,sha256=fHD3CDKZLpB_vekISdHB54mQUzaieloAPZEREmkbiRQ,23
 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=pQeqz_ZlU43Os5gKlRu5-iCLTslPWEqWJzuGxpKhcRo,3904
 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=eOUDybZZFpp2zQWF-alta2MPL1M24iUgoYJZZPYbJvU,5165
+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=cvTj_sOw3r4B4ErMAVdsrniMImWnUpLMECmQErxdsUU,1688
 langchain_dev_utils/agents/middleware/model_router.py,sha256=YkaPpYmIZaGj--YlUjm7dVcNzRt3Au317eor4SDYsQs,8799
-langchain_dev_utils/agents/middleware/plan.py,sha256=Wz340HQYhw_jNrhbHWsL-UqpyeSSc9peOz6UiWIjx6Y,17846
+langchain_dev_utils/agents/middleware/plan.py,sha256=pVABuihOo-TGuPwJA_AdpBa6eodbdZalXozl_YcMsHc,15198
 langchain_dev_utils/agents/middleware/summarization.py,sha256=Ws-_cxSQQfa5rn5Spq1gSLpgIleUCno3QmWRvN4-u9E,2213
 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=jeG4hSxqxMQenhx9Ow4Q8dAOtv5WZO_eVOgX6ugpSiQ,9602
-langchain_dev_utils/chat_models/types.py,sha256=gDlV5iidIIMSpY-vdUkmpNAWaDWe9IcQ5_5LhdCHJ-M,259
+langchain_dev_utils/chat_models/base.py,sha256=BagUNjqWwTZ2vJ-uHPQ0vyC6nYXOdFJidV_73jlPFG8,11232
+langchain_dev_utils/chat_models/types.py,sha256=oPXFsfho9amnwek5v3ey8LcnsfKVzecWSJcKVBG4ETc,261
 langchain_dev_utils/chat_models/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langchain_dev_utils/chat_models/adapters/openai_compatible.py,sha256=1HMIimg6Y_OFAz7eOhPzkoKXpl8dvL5sWBD_draSNj0,18276
+langchain_dev_utils/chat_models/adapters/openai_compatible.py,sha256=6ZTRCFqgW8fk8nbZs0OarmuHP5M6wr-0mbFogZuLTWY,18409
 langchain_dev_utils/embeddings/__init__.py,sha256=zbEOaV86TUi9Zrg_dH9dpdgacWg31HMJTlTQknA9EKk,244
-langchain_dev_utils/embeddings/base.py,sha256=pLFfhgBM3A1uKfvF8eghl-oiVH5W8JiAiALRTPBvC90,7816
+langchain_dev_utils/embeddings/base.py,sha256=OFXgaLO6DsadSITUmtrDvJg_-042lrrDwY5vnS9_do8,9574
 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 +29,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.1.11.dist-info/METADATA,sha256=xg-HQelvUlQkbnBI-_use7IJ-xYnGMVGsVGzy1hHJ9A,16144
-langchain_dev_utils-1.1.11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-langchain_dev_utils-1.1.11.dist-info/licenses/LICENSE,sha256=AWAOzNEcsvCEzHOF0qby5OKxviVH_eT9Yce1sgJTico,1084
-langchain_dev_utils-1.1.11.dist-info/RECORD,,
+langchain_dev_utils-1.1.13.dist-info/METADATA,sha256=m205M6P2wNSDHHHNCVuSE-1SBMD1oyiMHRYYwHbJyEA,16264
+langchain_dev_utils-1.1.13.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+langchain_dev_utils-1.1.13.dist-info/licenses/LICENSE,sha256=AWAOzNEcsvCEzHOF0qby5OKxviVH_eT9Yce1sgJTico,1084
+langchain_dev_utils-1.1.13.dist-info/RECORD,,