Files
AgentLab/backend/app/providers/factory.py
T
ThearchyHelios f43f56abb7 把 Copilot 的思考显示出来:模型一直在想,只是被丢掉了
用户问能不能看到"正在理解需求、规划步骤"里面发生了什么。查下来是这样:
模型确实在想,reasoning 花了实打实的 token,但一路上被丢了三次。

1. langchain 的 ChatOpenAI **故意**不保留第三方的 reasoning_content——它的
   文档原话是 "Non-standard response fields added by third-party providers
   are not extracted or preserved",建议换 ChatDeepSeek 之类的专用包。可
   "用哪个供应商"在这个产品里是用户在设置页配的(DeepSeek / Qianfan /
   vLLM / OpenRouter 都可能),为每种装一个专用包不现实。在 factory 里
   子类化捞回 additional_kwargs,只加字段,不动 langchain 对正文的处理。

2. thinking_text 只认 Anthropic 的 thinking 块。补上兼容端点那一种。

3. 前端把一段思考的标题固定成开头 60 个字。思考是流式的,开头往往是
   "用户想要一个……"这类复述,之后几十秒里它一直在推进——固定显示开头
   等于把一段活的叙述冻在起点上,看着就像卡住了。改成:还在想的时候显示
   最新一句,想完了换回开头那句(那时它是一条历史记录)。

实测一次真实生成,60 秒里侧栏逐句变化:

    3s  可用数据源 bi
    9s  人工节点 approve 模式,审核
   18s  我们可以用 db_query__sales 执行 SELECT COUNT(*) FROM orders 等
   36s  更合理:rejected -> query_agent(重新
   45s  对于 bi 有 53 个对象,靠
   57s  (plan 到达,思考收尾,换回开头那句)

顺带运行期的 LLM 节点也跟着有了思考——走的是同一个 thinking_text,之前
同样只有 Anthropic 系才有。已验证流式合并后思考连成完整一段,不是只剩
最后一片。

tests/test_thinking.py 守两种形态、合并、以及"不产思考的模型不硬凑"。
check-decode 补 5 条守"还在想显示最新一句、想完了换开头"。
2026-09-18 09:55:42 +08:00

242 lines
9.8 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
from __future__ import annotations
import os
from typing import Any
from langchain_core.language_models.chat_models import BaseChatModel
from pydantic import BaseModel, Field
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from app.core.crypto import decrypt
from app.db.models import Provider
from app.providers import catalog
from app.providers.mock_model import MockChatModel
class ModelSpec(BaseModel):
"""节点上对模型的请求。省略的字段会回退到 provider 默认值。"""
provider: str | None = None # provider 的 name 或 id
model: str | None = None
temperature: float | None = None
max_tokens: int | None = Field(default=None)
thinking: str | None = None # off | adaptive
effort: str | None = None # low | medium | high | xhigh | max
timeout: int | None = None
extra: dict[str, Any] = Field(default_factory=dict)
class ProviderNotConfigured(RuntimeError):
pass
async def list_providers(session: AsyncSession) -> list[Provider]:
rows = await session.execute(select(Provider).order_by(Provider.created_at))
return list(rows.scalars())
async def resolve_provider(
session: AsyncSession, ref: str | None, model: str | None = None
) -> Provider | None:
"""找出该用哪个 provider。
顺序很关键:显式指定的 ref 最优先;其次按模型名反查 —— 节点上通常只选了
模型(比如 mock-fast),没选 provider,这时必须找到真正提供该模型的那一个,
否则会拿着 A 家的模型名去调 B 家的接口。最后才回退到默认 provider。
"""
providers = await list_providers(session)
enabled = [p for p in providers if p.enabled]
if ref:
for p in providers:
if p.name == ref or p.id == ref:
return p
return None
if model:
for p in enabled:
if any((m or {}).get("id") == model for m in (p.models or [])):
return p
for p in enabled:
if p.default_model == model:
return p
# 模型认得出来,但它所属的 provider 被停用了。这时候不能默默换一家 ——
# 拿着 A 家的模型名去调 B 家,必然 404,而且报错完全指不到真正的原因。
for p in providers:
if not p.enabled and (
any((m or {}).get("id") == model for m in (p.models or []))
or p.default_model == model
):
raise ProviderNotConfigured(
f"模型 {model!r} 属于 provider {p.name!r},但它已被停用。"
f"请在设置里启用它,或给节点换一个模型。"
)
# 认不出来的模型名就放行:用户可能手填了一个目录里还没有的新模型
real = [p for p in enabled if p.kind != "mock"]
return (real or enabled or [None])[0]
def _resolve_key(provider: Provider) -> str | None:
"""明文 key。没配就退回环境变量 —— 本地实验时最省事。"""
key = decrypt(provider.api_key)
if key:
return key
env_names = {
"anthropic": ("ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN"),
"openai": ("OPENAI_API_KEY",),
}.get(provider.kind, ())
for name in env_names:
if os.environ.get(name):
return os.environ[name]
return None
def build_chat_model(provider: Provider, spec: ModelSpec) -> BaseChatModel:
"""把一条 provider 记录 + 节点配置变成可调用的 LangChain 模型。
这里最要紧的是按模型能力裁剪参数:Claude 4.6 之后的模型收到 temperature
会直接 400,所以不能无脑透传节点上的滑块值。
"""
model = spec.model or provider.default_model or ""
if not model:
raise ProviderNotConfigured(f"provider {provider.name!r} 没有可用的模型")
kwargs: dict[str, Any] = {"model": model}
if spec.max_tokens:
kwargs["max_tokens"] = spec.max_tokens
if spec.timeout:
kwargs["timeout"] = spec.timeout
# 采样参数:能力允许才传
if spec.temperature is not None and catalog.supports_sampling(model):
kwargs["temperature"] = spec.temperature
if provider.kind == "mock":
return MockChatModel(model_name=model)
api_key = _resolve_key(provider)
base_url = provider.base_url or None
extra = dict(provider.extra or {})
if provider.kind == "anthropic":
from langchain_anthropic import ChatAnthropic
base_url = base_url or os.environ.get("ANTHROPIC_BASE_URL") or None
if not api_key:
raise ProviderNotConfigured(f"provider {provider.name!r} 缺少 API Key")
bearer = extra.get("auth_style") == "bearer"
kwargs["api_key"] = "placeholder-replaced-below" if bearer else api_key
if base_url:
kwargs["base_url"] = base_url
if extra.get("headers"):
kwargs["default_headers"] = dict(extra["headers"])
# thinking 这类模型会先花 token 思考再输出正文;给太小的 max_tokens
# 会出现"思考完就没额度写答案",返回一条空正文。
kwargs.setdefault("max_tokens", 8192)
model_kwargs: dict[str, Any] = {}
if catalog.supports_adaptive_thinking(model):
mode = spec.thinking or "summarized"
if mode in ("adaptive", "summarized"):
# summarized 会把思考摘要一起返回,画布上就能展示"它在想什么"
kwargs["thinking"] = {
"type": "adaptive",
"display": "summarized" if mode == "summarized" else "omitted",
}
elif mode == "off":
kwargs["thinking"] = {"type": "disabled"}
if spec.effort and catalog.supports_effort(model):
model_kwargs["output_config"] = {"effort": spec.effort}
if model_kwargs:
kwargs["model_kwargs"] = model_kwargs
chat = ChatAnthropic(**kwargs)
if bearer:
# 网关只认 Authorization: Bearer,且多带一个 x-api-key 就会 401。
# ChatAnthropic 的 default_headers 是 dict[str,str],塞不进 SDK 的 Omit 哨兵,
# 所以直接换掉底层 client —— anthropic SDK 原生支持 auth_token,
# 且 api_key=None 时不会发出 x-api-key。
import anthropic
client_args = {"base_url": base_url, "api_key": None, "auth_token": api_key}
chat._client = anthropic.Anthropic(**client_args)
chat._async_client = anthropic.AsyncAnthropic(**client_args)
return chat
# openai 与 openai 兼容走同一个类,区别只在 base_url
if provider.kind == "openai_compatible" and not base_url:
raise ProviderNotConfigured(f"provider {provider.name!r} 需要填 base_url")
# 很多本地服务(Ollama、vLLM)不校验 key,但 SDK 要求非空
kwargs["api_key"] = api_key or "not-needed"
if base_url:
kwargs["base_url"] = base_url
if extra.get("headers"):
kwargs["default_headers"] = extra["headers"]
return _ReasoningAwareChatOpenAI(**kwargs)
def _reasoning_aware_openai() -> type:
"""ChatOpenAI 的子类,保留供应商的思考内容。
langchain 的 ChatOpenAI 只认官方 OpenAI 规范,第三方加的 reasoning_content
是**明确丢弃**的(它的文档原话:"Non-standard response fields added by
third-party providers are not extracted or preserved"),建议换用
ChatDeepSeek 之类的专用包。
但"用哪个供应商"在这个产品里是用户在设置页配的,可能是 DeepSeek、
Qianfan、vLLM、OpenRouter 里任何一个——为每种装一个专用包不现实。而这
段内容正是界面上"它大致在想什么"的唯一真实来源:实测 deepseek-v4-pro
一次调用花 160 个 token 在推理上,全被丢掉了,于是编排期那 50 秒里
界面上只有一行不动的"正在理解需求"。
所以在这里把它捞回 additional_kwargs,thinking_text 再统一读出来。
只加字段,不改 langchain 对正文的任何处理。
"""
from langchain_openai import ChatOpenAI
class ReasoningAwareChatOpenAI(ChatOpenAI): # type: ignore[misc]
def _convert_chunk_to_generation_chunk(
self, chunk: dict, default_chunk_class: type, base_generation_info: dict | None
):
gen = super()._convert_chunk_to_generation_chunk(
chunk, default_chunk_class, base_generation_info
)
if gen is None:
return gen
choices = chunk.get("choices") or chunk.get("chunk", {}).get("choices") or []
delta = (choices[0] or {}).get("delta") or {} if choices else {}
# 不同网关的叫法不统一,见到哪个用哪个
text = delta.get("reasoning_content") or delta.get("reasoning")
if isinstance(text, str) and text:
gen.message.additional_kwargs["reasoning_content"] = text
return gen
return ReasoningAwareChatOpenAI
class _LazyReasoningChatOpenAI:
"""延迟导入 langchain_openai:它加载得慢,而 mock/anthropic 路径用不上。"""
def __call__(self, **kwargs: Any) -> Any:
return _reasoning_aware_openai()(**kwargs)
_ReasoningAwareChatOpenAI = _LazyReasoningChatOpenAI()
async def get_chat_model(session: AsyncSession, spec: ModelSpec) -> tuple[BaseChatModel, str]:
"""返回 (模型, 实际使用的模型 id)。找不到任何 provider 时回退到 mock,
保证一张图在没配 key 的机器上也能跑完。"""
provider = await resolve_provider(session, spec.provider, spec.model)
if provider is None:
return MockChatModel(model_name="mock-fast"), "mock-fast"
try:
model = build_chat_model(provider, spec)
except ProviderNotConfigured:
raise
return model, (spec.model or provider.default_model or "")