Keep LangChain reasoning routing provider-safe

Review feedback showed that provider-based routing sent custom and other OpenAI-compatible providers through the DeepSeek LangChain integration. Restrict the DeepSeek-specific wrapper to the DeepSeek provider, preserve provider metadata from ModelService, and cover the routing boundaries in LangChain tests.

Constraint: ChatDeepSeek is provider-specific while ChatOpenAI remains the generic OpenAI-compatible path.

Rejected: Routing tongyi, zhipuai, moonshot, minimax, or custom through ChatDeepSeek | those providers are not guaranteed to follow DeepSeek integration semantics.

Confidence: high

Scope-risk: moderate

Directive: Add provider-specific LangChain wrappers only when the provider integration is explicitly supported and tested.

Tested: uv run --python 3.10 --all-extras pytest tests/unittests/integration/test_langchain.py tests/unittests/server/test_reasoning.py tests/unittests/server/test_openai_protocol.py::TestOpenAIReasoningContent tests/unittests/server/test_agui_protocol.py::TestAGUIReasoningContent

Tested: uv run --python 3.10 --all-extras make mypy-check

Tested: uv run --python 3.10 --all-extras make coverage
Signed-off-by: congxiao.wxx <congxiao.wxx@alibaba-inc.com>

Change-Id: I29d5dc26571cad77280860b8bb854bc1ad994f24

Author: congxiao-wxx

agentrun/integration/langchain/model_adapter.py

@@ -9,15 +9,7 @@
 )
 from agentrun.integration.utils.adapter import ModelAdapter
 
-# 支持 reasoning_content 的供应商列表
-_REASONING_PROVIDERS = frozenset({
-    "tongyi",
-    "custom",
-    "deepseek",
-    "zhipuai",
-    "moonshot",
-    "minimax",
-})
+_DEEPSEEK_PROVIDER = "deepseek"
 
 
 class LangChainModelAdapter(ModelAdapter):
@@ -34,15 +26,23 @@ def wrap_model(self, common_model: Any) -> Any:
         info = common_model.get_model_info()  # 确保模型可用
         provider = (info.provider or "").lower()
 
-        if provider in _REASONING_PROVIDERS:
+        if provider == _DEEPSEEK_PROVIDER:
             return self._create_reasoning_model(info)
         return self._create_openai_model(info)
 
     def _create_reasoning_model(self, info: Any) -> Any:
         """创建支持 reasoning_content 的模型（使用 ChatDeepSeek）"""
-        from langchain_deepseek import ChatDeepSeek
+        try:
+            from langchain_deepseek import ChatDeepSeek
+        except ImportError as e:
+            raise ImportError(
+                "import langchain_deepseek failed. "
+                "Install it with: pip install 'agentrun-sdk[langchain]' "
+                "or pip install 'agentrun-sdk[langgraph]'"
+            ) from e
 
         return ChatDeepSeek(
+            name=info.model,
             model=info.model,
             api_key=info.api_key,
             api_base=info.base_url,
@@ -53,7 +53,14 @@ def _create_reasoning_model(self, info: Any) -> Any:
 
     def _create_openai_model(self, info: Any) -> Any:
         """创建标准 OpenAI 兼容模型"""
-        from langchain_openai import ChatOpenAI
+        try:
+            from langchain_openai import ChatOpenAI
+        except ImportError as e:
+            raise ImportError(
+                "import langchain_openai failed. "
+                "Install it with: pip install 'agentrun-sdk[langchain]' "
+                "or pip install 'agentrun-sdk[langgraph]'"
+            ) from e
 
         return ChatOpenAI(
             name=info.model,

agentrun/model/__model_service_async_template.py

@@ -233,4 +233,5 @@ def model_info(self, config: Optional[Config] = None) -> BaseInfo:
             base_url=self.provider_settings.base_url,
             model=default_model,
             headers=cfg.get_headers(),
+            provider=self.provider,
         )

agentrun/model/model_service.py

@@ -404,4 +404,5 @@ def model_info(self, config: Optional[Config] = None) -> BaseInfo:
             base_url=self.provider_settings.base_url,
             model=default_model,
             headers=cfg.get_headers(),
+            provider=self.provider,
         )

pyproject.toml

@@ -73,6 +73,8 @@ tablestore = [
 langgraph = [
     "langgraph>=0.2.0; python_version >= '3.10'",
     "langchain-core>=0.3.0; python_version >= '3.10'",
+    "langchain-openai>=1.0.0; python_version >= '3.10'",
+    "langchain-deepseek>=1.0.1; python_version >= '3.10'",
 ]
 
 [dependency-groups]

scripts/smoke_reasoning_protocol.py

@@ -6,17 +6,12 @@
 import os
 from typing import Any, Dict, Iterable, List, Optional
 
-import httpx
 from dotenv import load_dotenv
+import httpx
 
 from agentrun.model import BackendType, ModelClient
 from agentrun.model.api.data import ModelDataAPI
-from agentrun.server import (
-    AgentEvent,
-    AgentRequest,
-    AgentRunServer,
-    EventType,
-)
+from agentrun.server import AgentEvent, AgentRequest, AgentRunServer, EventType
 from agentrun.server.agui_protocol import AGUIProtocolHandler
 from agentrun.server.openai_protocol import OpenAIProtocolHandler
 from agentrun.utils.reasoning import (
@@ -236,8 +231,7 @@ async def call_real_model(
 
     if response.is_error:
         raise RuntimeError(
-            f"real model request failed: {response.status_code} "
-            f"{response.text}"
+            f"real model request failed: {response.status_code} {response.text}"
         )
 
     if not stream:
@@ -257,13 +251,16 @@ def resolve_model_endpoint(
             raise RuntimeError(
                 f"model service {model_resource} has no provider settings"
             )
+        default_model = (
+            settings.model_names[0] if settings.model_names else None
+        )
         return (
             settings.base_url,
             {
                 "authorization": f"Bearer {settings.api_key}",
                 "content-type": "application/json",
             },
-            (settings.model_names or [None])[0],
+            default_model,
         )
 
     data_api = ModelDataAPI(model_resource)
@@ -398,12 +395,18 @@ async def main() -> None:
             validate_result("agui", content, reasoning, args)
             results["agui"] = summarize(content, reasoning, raw)
 
-    print(json.dumps({
-        "thinkingEnabled": is_thinking_enabled_from_env(),
-        "protocol": args.protocol,
-        "responseMode": args.response_mode,
-        "results": results,
-    }, ensure_ascii=False, indent=2))
+    print(
+        json.dumps(
+            {
+                "thinkingEnabled": is_thinking_enabled_from_env(),
+                "protocol": args.protocol,
+                "responseMode": args.response_mode,
+                "results": results,
+            },
+            ensure_ascii=False,
+            indent=2,
+        )
+    )
 
 
 def summarize(content: str, reasoning: str, raw: Any) -> Dict[str, Any]:

tests/unittests/integration/test_langchain.py

@@ -15,7 +15,9 @@
 
 from agentrun.integration.builtin.model import CommonModel
 from agentrun.integration.utils.tool import CommonToolSet, tool
+from agentrun.model import ModelService, ProviderSettings
 from agentrun.model.model_proxy import ModelProxy
+from agentrun.utils.config import Config
 
 from .base import IntegrationTestBase, IntegrationTestResult, ToolCallInfo
 from .mock_llm_server import MockLLMServer
@@ -173,6 +175,20 @@ def _msg_to_dict(self, msg: Any) -> dict:
 class TestLangChainIntegration(LangChainTestMixin):
     """LangChain Integration 测试类"""
 
+    def _model_service_model(self, provider: Optional[str]) -> CommonModel:
+        return CommonModel(
+            ModelService(
+                model_service_name=f"{provider or 'default'}-service",
+                provider=provider,
+                provider_settings=ProviderSettings(
+                    api_key="sk-test",
+                    base_url="https://model.example/v1",
+                    model_names=["test-model"],
+                ),
+            ),
+            config=Config(headers={"x-test-header": "yes"}),
+        )
+
     @pytest.fixture
     def mock_server(self, monkeypatch: Any, respx_mock: Any) -> MockLLMServer:
         """创建并安装 Mock LLM Server
@@ -320,6 +336,49 @@ def test_stream_options_in_requests(
         assert llm.stream_usage is True
         assert llm.streaming is True
 
+    def test_model_service_model_info_exposes_provider(self):
+        model = self._model_service_model("deepseek")
+
+        assert model.get_model_info().provider == "deepseek"
+
+    def test_deepseek_provider_uses_chat_deepseek(self):
+        from langchain_deepseek import ChatDeepSeek
+
+        model = self._model_service_model("deepseek")
+
+        llm = model.to_langchain()
+
+        assert isinstance(llm, ChatDeepSeek)
+        assert llm.name == "test-model"
+        assert llm.model_name == "test-model"
+        assert llm.api_base == "https://model.example/v1"
+        assert llm.default_headers == {"x-test-header": "yes"}
+        assert llm.openai_api_key.get_secret_value() == "sk-test"
+        assert llm.stream_usage is True
+        assert llm.streaming is True
+
+    @pytest.mark.parametrize(
+        "provider",
+        [None, "custom", "tongyi", "zhipuai", "moonshot", "minimax", "unknown"],
+    )
+    def test_non_deepseek_providers_use_chat_openai(
+        self, provider: Optional[str]
+    ):
+        from langchain_openai import ChatOpenAI
+
+        model = self._model_service_model(provider)
+
+        llm = model.to_langchain()
+
+        assert isinstance(llm, ChatOpenAI)
+        assert llm.name == "test-model"
+        assert llm.model_name == "test-model"
+        assert llm.openai_api_base == "https://model.example/v1"
+        assert llm.default_headers == {"x-test-header": "yes"}
+        assert llm.openai_api_key.get_secret_value() == "sk-test"
+        assert llm.stream_usage is True
+        assert llm.streaming is True
+
     def test_stream_options_validation(
         self,
         mock_server: MockLLMServer,