376 lines
14 KiB
Python
376 lines
14 KiB
Python
"""
|
||
聊天所用大模型的「逻辑 id ↔ 各家 API 模型名」映射，以及统一的模型构造工厂。
|
||
|
||
统一构造入口：`build_chat_model(...)` / `build_chat_model_for_completion(...)` 返回
|
||
`langchain_core.language_models.chat_models.BaseChatModel`（通常为 ``ChatOpenAI`` 或通义原生 ``ChatTongyi``）。
|
||
|
||
- **通义（默认）**：``USE_ORIGIN_MODEL=False`` 时走 ``ChatOpenAI`` + ``DASHSCOPE_API_BASE``（OpenAI 兼容网关）；
|
||
``USE_ORIGIN_MODEL=True`` 时走 ``langchain_community.chat_models.ChatTongyi``（DashScope 原生 ``Generation`` 协议，不读兼容 base_url）。
|
||
- **DeepSeek**：仍用 ``ChatOpenAI`` + 各 ``DEEPSEEK_*`` base；聊天主入口另有 ``ChatDeepSeek``（见 ``build_chatdeepseek_model``）。
|
||
- 深度思考：兼容模式下 ``extra_body={"enable_thinking": True}``；通义原生模式下写入 ``ChatTongyi.model_kwargs["enable_thinking"]``。
|
||
|
||
逻辑 id 与 GET /api/chat/llm-options 返回的 models[].id 一致；ChatRequest.llm_model 使用相同 id。
|
||
"""
|
||
from __future__ import annotations
|
||
|
||
import os
|
||
from dataclasses import dataclass
|
||
from typing import Any, Dict, List, Optional, Tuple
|
||
|
||
from langchain_community.chat_models.tongyi import ChatTongyi
|
||
from langchain_core.language_models.chat_models import BaseChatModel
|
||
from langchain_deepseek.chat_models import ChatDeepSeek
|
||
from langchain_openai import ChatOpenAI
|
||
|
||
from core import llm_env
|
||
from core.config import get_settings
|
||
from logger.logging import get_logger
|
||
|
||
logger = get_logger(__name__)
|
||
|
||
# ---------- 数据定义 ----------
|
||
|
||
|
||
@dataclass(frozen=True)
|
||
class _ModelRow:
|
||
id: str
|
||
label: str
|
||
api_model: str
|
||
description: str = ""
|
||
|
||
|
||
@dataclass(frozen=True)
|
||
class _ProviderRow:
|
||
id: str
|
||
label: str
|
||
models: Tuple[_ModelRow, ...]
|
||
|
||
|
||
_TONGYI_MODELS: Tuple[_ModelRow, ...] = (
|
||
_ModelRow("qwen3-max", "Qwen3-Max", "qwen3-max", "通义千问 Max"),
|
||
)
|
||
|
||
_DEEPSEEK_MODELS: Tuple[_ModelRow, ...] = (
|
||
_ModelRow("deepseek-chat", "DeepSeek Chat", "deepseek-chat", "通用对话"),
|
||
_ModelRow(
|
||
"deepseek-reasoner",
|
||
"DeepSeek Reasoner",
|
||
"deepseek-reasoner",
|
||
"深度推理模型",
|
||
),
|
||
)
|
||
|
||
_PROVIDERS: Tuple[_ProviderRow, ...] = (
|
||
_ProviderRow("tongyi", "通义千问", _TONGYI_MODELS),
|
||
_ProviderRow("deepseek", "DeepSeek", _DEEPSEEK_MODELS),
|
||
)
|
||
|
||
_DEFAULT_MODEL_BY_PROVIDER: Dict[str, str] = {
|
||
"tongyi": "qwen3-max",
|
||
"deepseek": "deepseek-chat",
|
||
}
|
||
|
||
|
||
# 旧版前端 logical id → 新版 id（仅存根兼容，不参与 llm-options 展示）
|
||
_LEGACY_DEEPSEEK_LOGICAL_ID: Dict[str, str] = {
|
||
"deepseek-v3": "deepseek-chat",
|
||
"deepseek-v2": "deepseek-chat",
|
||
}
|
||
|
||
_LEGACY_TONGYI_LOGICAL_ID: Dict[str, str] = {
|
||
"qwen3.5-plus": "qwen3-max",
|
||
"qwen3.6-plus": "qwen3-max",
|
||
}
|
||
|
||
# 聊天主入口：DeepSeek 实际调用的 API 名仅由深度思考开关决定（与请求里的 llm_model 无关）
|
||
_DEEPSEEK_API_CHAT = "deepseek-chat"
|
||
_DEEPSEEK_API_REASONER = "deepseek-reasoner"
|
||
|
||
|
||
def deepseek_api_model_by_reasoner_setting(*, user_is_reasoner: bool) -> str:
|
||
"""用户开启深度思考则用 ``deepseek-reasoner``，否则 ``deepseek-chat``。"""
|
||
return _DEEPSEEK_API_REASONER if user_is_reasoner else _DEEPSEEK_API_CHAT
|
||
|
||
|
||
_LOGICAL_TO_API: Dict[Tuple[str, str], str] = {}
|
||
for _p in _PROVIDERS:
|
||
for _m in _p.models:
|
||
_LOGICAL_TO_API[(_p.id, _m.id)] = _m.api_model
|
||
|
||
|
||
# ---------- 提供方与模型 id 工具 ----------
|
||
|
||
|
||
def normalize_provider(raw: Optional[str]) -> str:
|
||
if not raw or not str(raw).strip():
|
||
return "tongyi"
|
||
s = str(raw).strip().lower()
|
||
if s in ("dashscope", "qwen", "tongyi", "通义", "通义千问"):
|
||
return "tongyi"
|
||
if s in ("deepseek", "ds"):
|
||
return "deepseek"
|
||
return "tongyi"
|
||
|
||
|
||
def coerce_model_id(provider: str, model: Optional[str]) -> str:
|
||
prov = normalize_provider(provider)
|
||
if model and str(model).strip():
|
||
return str(model).strip()
|
||
return _DEFAULT_MODEL_BY_PROVIDER.get(prov, _DEFAULT_MODEL_BY_PROVIDER["tongyi"])
|
||
|
||
|
||
def validate_request_can_use_provider(provider: str) -> Optional[str]:
|
||
"""若配置不允许使用该校验的提供方，返回中文错误说明，否则返回 None。"""
|
||
settings = get_settings()
|
||
p = normalize_provider(provider)
|
||
if p == "tongyi":
|
||
if not settings.dashscope_api_key:
|
||
return "未配置通义千问 API Key（DASHSCOPE_API_KEY）"
|
||
elif p == "deepseek":
|
||
if not settings.deepseek_api_key:
|
||
return "未配置 DeepSeek API Key（DEEPSEEK_API_KEY）"
|
||
else:
|
||
return f"不支持的模型提供方: {provider}"
|
||
return None
|
||
|
||
|
||
def resolve_to_api_model(provider: str, logical_id: str) -> str:
|
||
p = normalize_provider(provider)
|
||
lid = logical_id
|
||
if p == "deepseek" and lid in _LEGACY_DEEPSEEK_LOGICAL_ID:
|
||
lid = _LEGACY_DEEPSEEK_LOGICAL_ID[lid]
|
||
if p == "tongyi" and lid in _LEGACY_TONGYI_LOGICAL_ID:
|
||
lid = _LEGACY_TONGYI_LOGICAL_ID[lid]
|
||
key = (p, lid)
|
||
if key not in _LOGICAL_TO_API:
|
||
# 兼容上层直接传 api_model（比如 "qwen-plus-latest"、"deepseek-chat"）：
|
||
# 找不到逻辑 id 时，原样作为 api_model 透传，而不是抛错。
|
||
return lid
|
||
return _LOGICAL_TO_API[key]
|
||
|
||
|
||
def list_llm_options_payload() -> Dict[str, Any]:
|
||
"""供 GET /api/chat/llm-options 使用：只返回当前环境**已配置密钥**的提供方及其模型。"""
|
||
settings = get_settings()
|
||
out_providers: List[Dict[str, Any]] = []
|
||
|
||
for prov in _PROVIDERS:
|
||
if prov.id == "tongyi" and not settings.dashscope_api_key:
|
||
continue
|
||
if prov.id == "deepseek" and not settings.deepseek_api_key:
|
||
continue
|
||
out_providers.append(
|
||
{
|
||
"id": prov.id,
|
||
"label": prov.label,
|
||
"models": [
|
||
{
|
||
"id": m.id,
|
||
"label": m.label,
|
||
**({"description": m.description} if m.description else {}),
|
||
}
|
||
for m in prov.models
|
||
],
|
||
}
|
||
)
|
||
|
||
default_provider = "tongyi"
|
||
if not any(p["id"] == default_provider for p in out_providers) and out_providers:
|
||
default_provider = out_providers[0]["id"]
|
||
|
||
default_model_by_provider = {
|
||
p["id"]: _DEFAULT_MODEL_BY_PROVIDER[p["id"]]
|
||
for p in out_providers
|
||
if p["id"] in _DEFAULT_MODEL_BY_PROVIDER
|
||
}
|
||
|
||
return {
|
||
"default_provider": default_provider,
|
||
"default_model_by_provider": default_model_by_provider,
|
||
"providers": out_providers,
|
||
}
|
||
|
||
|
||
# ---------- 统一构造工厂 ----------
|
||
|
||
|
||
def _tongyi_model_kwargs_from_chatopenai_extras(
|
||
temperature: float, extra_kwargs: Dict[str, Any]
|
||
) -> Dict[str, Any]:
|
||
"""将常见的 ChatOpenAI 风格参数映射为 ChatTongyi 的 ``model_kwargs``（传入 DashScope Generation）。"""
|
||
mk: Dict[str, Any] = {"temperature": temperature}
|
||
nested = extra_kwargs.get("model_kwargs")
|
||
if isinstance(nested, dict):
|
||
mk.update(nested)
|
||
if "max_tokens" in extra_kwargs:
|
||
mk["max_tokens"] = extra_kwargs["max_tokens"]
|
||
eb = extra_kwargs.get("extra_body")
|
||
if isinstance(eb, dict) and eb.get("enable_thinking"):
|
||
mk["enable_thinking"] = True
|
||
return mk
|
||
|
||
|
||
def _tongyi_chattongyi_must_use_openai_compatible(api_model: str) -> bool:
|
||
"""百炼：部分模型与 ``Generation.call``（text-generation）不匹配，``ChatTongyi`` 仍会走该端点会报 ``url error``；须改用 OpenAI 兼容接口。"""
|
||
m = (api_model or "").strip().lower()
|
||
if any(x in m for x in ("-vl-", "vl-plus", "vl-max", "omni")):
|
||
return True
|
||
if m.startswith("qwen3.5") or m.startswith("qwen3.6"):
|
||
return True
|
||
if m.startswith("qwen2.5-vl") or m.startswith("qwen-vl"):
|
||
return True
|
||
return False
|
||
|
||
|
||
def build_chat_model(
|
||
provider: str,
|
||
api_model: str,
|
||
*,
|
||
streaming: bool = False,
|
||
temperature: float = 0.7,
|
||
**extra_kwargs: Any,
|
||
) -> BaseChatModel:
|
||
"""
|
||
统一构造聊天模型。
|
||
|
||
- ``provider=deepseek``：始终 ``ChatOpenAI``（OpenAI 兼容）。
|
||
- ``provider=tongyi``：由 ``USE_ORIGIN_MODEL`` 决定 ``ChatTongyi``（原生）或 ``ChatOpenAI``（兼容网关）。
|
||
|
||
``extra_kwargs`` 在通义原生路径下仅识别 ``model_kwargs``、``max_tokens``、``extra_body.enable_thinking``；
|
||
其余键仅适用于 ``ChatOpenAI`` 分支。
|
||
|
||
部分通义模型与 ``ChatTongyi`` 内部使用的 ``Generation`` 端点不兼容（百炼 ``url error``），此时即使开启 ``USE_ORIGIN_MODEL`` 也会自动回退 ``ChatOpenAI`` + ``DASHSCOPE_API_BASE``。
|
||
"""
|
||
p = normalize_provider(provider)
|
||
if p == "tongyi":
|
||
api_key = (os.getenv("DASHSCOPE_API_KEY") or "").strip()
|
||
if not api_key:
|
||
raise ValueError("缺少 DASHSCOPE_API_KEY")
|
||
base_url = llm_env.tongyi_openai_compatible_base_url().strip().rstrip("/")
|
||
use_native = get_settings().use_origin_model
|
||
if use_native and _tongyi_chattongyi_must_use_openai_compatible(api_model):
|
||
logger.info(
|
||
"通义模型 {} 与 ChatTongyi(Generation) 端点不兼容，改用 ChatOpenAI + 兼容网关",
|
||
api_model,
|
||
)
|
||
use_native = False
|
||
if use_native:
|
||
mk = _tongyi_model_kwargs_from_chatopenai_extras(temperature, extra_kwargs)
|
||
import dashscope
|
||
|
||
native_base = llm_env.dashscope_native_http_api_base().strip().rstrip("/")
|
||
dashscope.base_http_api_url = native_base
|
||
logger.debug(
|
||
"通义使用 ChatTongyi（USE_ORIGIN_MODEL=true），dashscope.base_http_api_url={}",
|
||
native_base,
|
||
)
|
||
return ChatTongyi(
|
||
model=api_model,
|
||
api_key=api_key,
|
||
streaming=streaming,
|
||
model_kwargs=mk,
|
||
)
|
||
# 未走 ChatTongyi 时，与同提供方 OpenAI 兼容路径共用密钥与 base_url
|
||
elif p == "deepseek":
|
||
api_key = (os.getenv("DEEPSEEK_API_KEY") or "").strip()
|
||
if not api_key:
|
||
raise ValueError("缺少 DEEPSEEK_API_KEY")
|
||
base_url = llm_env.resolved_deepseek_chat_base_url().strip().rstrip("/")
|
||
else:
|
||
raise ValueError(f"未知提供方: {provider}")
|
||
return ChatOpenAI(
|
||
model=api_model,
|
||
api_key=api_key,
|
||
base_url=base_url,
|
||
streaming=streaming,
|
||
temperature=temperature,
|
||
**extra_kwargs,
|
||
)
|
||
|
||
|
||
# ---------- 兼容旧接口（保留命名，内部统一走 build_chat_model） ----------
|
||
|
||
|
||
def build_streaming_chat_model(provider: str, api_model: str) -> BaseChatModel:
|
||
"""聊天主入口使用的流式模型。"""
|
||
return build_chat_model(provider, api_model, streaming=True, temperature=0.7)
|
||
|
||
|
||
def build_deepseek_reasoner_model() -> BaseChatModel:
|
||
"""DeepSeek 深度思考模型（Reasoner）。"""
|
||
return build_chat_model(
|
||
"deepseek", "deepseek-reasoner", streaming=True, temperature=0.6
|
||
)
|
||
|
||
|
||
def _tongyi_openai_extra_url_for_thinking(*, enable_thinking: bool) -> Dict[str, Any]:
|
||
"""通义经 ChatOpenAI（兼容网关）：是否附加 thinking。"""
|
||
if not enable_thinking:
|
||
return {}
|
||
return {"extra_body": {"enable_thinking": True}}
|
||
|
||
|
||
def build_tongyi_reasoning_model(api_model: str) -> BaseChatModel:
|
||
"""
|
||
通义深度思考：沿用当前选用的对话模型并开启思考输出。
|
||
|
||
- ``USE_ORIGIN_MODEL=False``：``extra_body={"enable_thinking": True}``（OpenAI 兼容）。
|
||
- ``USE_ORIGIN_MODEL=True``：``ChatTongyi.model_kwargs`` 中 ``enable_thinking=True``（DashScope 原生）。
|
||
"""
|
||
extra = _tongyi_openai_extra_url_for_thinking(enable_thinking=True)
|
||
return build_chat_model(
|
||
"tongyi", api_model, streaming=True, temperature=0.6, **extra
|
||
)
|
||
|
||
|
||
def build_chatdeepseek_model(api_model: str, *, enable_thinking: bool) -> ChatDeepSeek:
|
||
"""使用 LangChain ``langchain_deepseek.ChatDeepSeek`` 构造客户端（不在本仓库继承/改写）。"""
|
||
api_key = (os.getenv("DEEPSEEK_API_KEY") or "").strip()
|
||
if not api_key:
|
||
raise ValueError("缺少 DEEPSEEK_API_KEY")
|
||
base_url = llm_env.resolved_deepseek_chat_base_url().strip().rstrip("/")
|
||
logger.debug(
|
||
"DeepSeek 模型: api_model={} enable_thinking={} base_url={}",
|
||
api_model,
|
||
enable_thinking,
|
||
base_url,
|
||
)
|
||
kwargs: Dict[str, Any] = {
|
||
"model": api_model,
|
||
"api_key": api_key,
|
||
"base_url": base_url,
|
||
"streaming": True,
|
||
}
|
||
# ``deepseek-reasoner`` 为专用推理模型，勿再加 ``thinking`` 扩展体；仅 ``deepseek-chat`` 在用户开启深度思考时使用
|
||
if enable_thinking and api_model == "deepseek-chat":
|
||
kwargs["extra_body"] = {"thinking": {"type": "enabled"}}
|
||
return ChatDeepSeek(**kwargs)
|
||
|
||
|
||
def build_chat_model_for_completion(
|
||
provider: str,
|
||
api_model: str,
|
||
*,
|
||
enable_thinking: bool,
|
||
logical_llm_id: Optional[str] = None,
|
||
) -> BaseChatModel:
|
||
"""聊天主入口按提供方构造模型（DeepSeek：`ChatDeepSeek`；通义：由 ``USE_ORIGIN_MODEL`` 决定 ``ChatTongyi`` 或 ``ChatOpenAI``）。
|
||
|
||
深度思考：``enable_thinking=True`` 时，兼容模式用 ``extra_body``；通义原生模式写入 ``model_kwargs.enable_thinking``。
|
||
|
||
``logical_llm_id`` 主要来自 ``ChatRequest.llm_model``（通义等仍按该 id 解析）。
|
||
|
||
**DeepSeek**：聊天路由在读取 ``user_list.is_reasoner`` 后，会无视请求中的模型选择，
|
||
直接按 ``deepseek_api_model_by_reasoner_setting`` 选用 ``deepseek-chat`` 或
|
||
``deepseek-reasoner``；本函数收到的 ``api_model`` 应为该结果。
|
||
"""
|
||
p = normalize_provider(provider)
|
||
if p == "deepseek":
|
||
return build_chatdeepseek_model(api_model, enable_thinking=enable_thinking)
|
||
if p == "tongyi":
|
||
extra = _tongyi_openai_extra_url_for_thinking(enable_thinking=enable_thinking)
|
||
return build_chat_model(
|
||
"tongyi", api_model, streaming=True, temperature=0.7, **extra
|
||
)
|
||
raise ValueError(f"不支持的模型提供方: {provider}")
|