第二十七轮: 三线直传(/v1/messages,/v1/responses)+删除路由别名;第二十八轮: element-plus 按需引入+死代码清理+前端支持格式列/API Key 文档

This commit is contained in:
api-gateway committed 2026-09-18 16:33:33 +08:00
1 parent bad8b43b22
commit aad3f28589
28 files changed
+3016 -1263

No files matched your search

+9 -2
View File
@@ -12,13 +12,17 @@ def create_adapter(
) -> BaseAdapter:
"""根据供应商配置创建对应适配器。
当前三个供应商(Agnes / 火山方舟 / OpenCode Go)均为 OpenAI 兼容协议,
当前四个供应商(Agnes / 火山方舟 / OpenCode Go)均为 OpenAI 兼容协议,
统一使用 OpenAICompatAdapter,通过 base_url 和 extra_headers 区分。
图像/视频端点通过 media 配置覆盖(Agnes 走 /videos + /agnesapi)。
OpenCode Go 由 requires_session_header 触发每请求动态注入 x-opencode-session。
第二十七轮(三线直传): 鉴权头不再在这里拼死,而是把裸 token + 供应商的
`endpoints`(每条线的路径/鉴权方式/固定头)交给适配器,由它在**每次请求**时按
入站协议线组装(OpenCode Go 的 messages 线认 x-api-key,另两条线认 Bearer)。
这样同一个供应商的三条线共用一个适配器与连接池,也不需要在缓存 key 里区分协议。
"""
headers = {
"Authorization": f"Bearer {token}",
"Content-Type": "application/json",
}
headers.update(pconfig.extra_headers)
@@ -36,4 +40,7 @@ def create_adapter(
# 不会出现"主链路修了、测速还漏着"的偏差。
# 配置变更时 main._apply_config 会丢弃整个适配器缓存,约束不会滞留旧值。
model_params={m.id: dict(m.params) for m in pconfig.models if m.params},
# 第二十七轮: 三条线的出站地址与鉴权方式(直传与常规调用共用)
token=token,
endpoints=pconfig.endpoints,
)
+158 -13
View File
@@ -14,12 +14,18 @@ import json
import logging
import re
import uuid
from contextlib import asynccontextmanager
from typing import Any, AsyncIterator
import httpx
from app.adapters.base import BaseAdapter, json_or_raise
from app.config import MODEL_PARAM_KEYS
from app.config import (
PROTOCOL_CHAT,
EndpointSpec,
MODEL_PARAM_KEYS,
_default_endpoints,
)
from app.models import CHAT_CORE_KEYS, PROTECTED_VIDEO_KEYS, strip_protected
log = logging.getLogger("api-gateway")
@@ -38,7 +44,13 @@ _PARAM_MIN_RE = re.compile(
class OpenAICompatAdapter(BaseAdapter):
"""适用于所有 OpenAI 兼容 /chat/completions 端点的适配器。"""
"""适用于所有 OpenAI 兼容 /chat/completions 端点的适配器。
第二十七轮(三线直传)后它同时承担**协议直传**职责:同一家供应商的三条线
(chat/completions、messages、responses)共用这一个适配器、共用一个连接池,
差别只在「路径 + 鉴权头」——由 provider 的 `endpoints` 配置提供(见 config.EndpointSpec)。
直传路径**不翻译任何内容**:入站 body 原样出去,上游响应原样回来。
"""
def __init__(
self,
@@ -49,9 +61,17 @@ class OpenAICompatAdapter(BaseAdapter):
media=None,
requires_session_header: bool = False,
model_params: dict[str, dict[str, Any]] | None = None,
token: str = "",
endpoints: dict[str, EndpointSpec] | None = None,
):
super().__init__(name=name, base_url=base_url, timeout=timeout, media=media)
self._headers: dict[str, str] = headers or {}
# 第二十七轮: 每条协议线的出站配置(路径 / 鉴权方式 / 该线固定头)。
# 不传 = 三条标准线的默认值,所以旧调用点(含单测直接 new)行为不变。
self._endpoints: dict[str, EndpointSpec] = dict(endpoints or _default_endpoints())
# 裸 token:每条线要发的鉴权头不同(Bearer / x-api-key),所以不能在构造时就把
# header 拼死。没显式传就回头从静态 headers 里解析(兼容直接 new 的调用方)。
self._token = token or self._token_from_headers(self._headers)
# OpenCode Go 要求每个 /chat/completions 带稳定 x-opencode-session。
# 不能放静态 headers(_get_adapter 会缓存适配器、冻结 header),
# 所以在每次请求时动态生成一个 UUID 会话头。
@@ -64,6 +84,45 @@ class OpenAICompatAdapter(BaseAdapter):
# 仅作兜底 —— 管理员在 gateway.yaml 写死 params 后就不再需要它。
self._learned_params: dict[str, dict[str, Any]] = {}
@staticmethod
def _token_from_headers(headers: dict[str, str]) -> str:
"""从静态 headers 里反解 token(兼容历史调用方式:构造时就带 Authorization)。"""
auth = headers.get("Authorization") or headers.get("authorization") or ""
if auth.lower().startswith("bearer "):
return auth[7:].strip()
return headers.get("x-api-key") or ""
# ── 协议线(第二十七轮) ─────────────────────────
def endpoint(self, protocol: str) -> EndpointSpec | None:
"""取某条线的出站配置(None = 该供应商没有这条线)。"""
return self._endpoints.get(protocol)
def _path(self, protocol: str) -> str:
ep = self._endpoints.get(protocol)
if ep is None:
# 走到这里说明配置校验漏了(validate_config 会拦「模型声明了但供应商没配」),
# 抛清晰错误而不是退化成默认路径 —— 猜出来的地址只会收到 404,更难查。
raise ValueError(f"供应商 {self.name} 未配置协议线 {protocol}")
return ep.path
def auth_headers(self, protocol: str) -> dict[str, str]:
"""按该线的鉴权方式组装鉴权头(Bearer / x-api-key / 无)。
这是三线直传里"唯一必须做的 glue":同一个供应商的三条线鉴权方式可能不同
(实测 OpenCode Go:chat/completions 与 responses 认 `Authorization: Bearer`,
messages 认 `x-api-key`;用 Bearer 打 /messages 会 401 Missing API key)。
"""
ep = self._endpoints.get(protocol)
style = (ep.auth if ep else "bearer")
out: dict[str, str] = {}
if style == "bearer" and self._token:
out["Authorization"] = f"Bearer {self._token}"
elif style == "x-api-key" and self._token:
out["x-api-key"] = self._token
if ep:
out.update(ep.headers or {}) # 如 anthropic-version
return out
# ── 模型级强制参数 / 上游参数约束自学习(第二十五轮) ──
def _forced_params(self, model: str) -> dict[str, Any]:
@@ -128,19 +187,103 @@ class OpenAICompatAdapter(BaseAdapter):
model, changed)
return self._forced_params(model)
def _req_headers(self, session_id: str | None = None) -> dict[str, str]:
"""每次请求的 headers。需要会话头的供应商动态注入 x-opencode-session。
def _req_headers(self, session_id: str | None = None,
protocol: str = PROTOCOL_CHAT) -> dict[str, str]:
"""每次请求的 headers:静态头 + 本条线的鉴权头 + 会话头。
session_id 由调用方传入(网关把对话的 conversation_id 透传过来):
- 有 → 同一段对话的所有请求共用同一个 session(吃到上游提示词缓存);
- 有 → 同一段对话的所有请求共用同一个 session(上游据此做路由与缓存);
- 无 → 回退为每请求一个随机 UUID(仍能过上游的强校验,只是没有缓存收益)。
第二十七轮实测:OpenCode Go 的**三条线都硬性要求该头**(缺任一条 → 400
MissingSessionID),所以注入逻辑与协议线无关,统一在这里做。
"""
if not self._requires_session:
return self._headers
headers = dict(self._headers)
headers["x-opencode-session"] = session_id or uuid.uuid4().hex
# 鉴权头按线走:先清掉静态头里可能残留的鉴权(历史写法:create_adapter 曾把
# Authorization 塞进静态 headers),再由 auth_headers 按该线的方式补上。
headers.pop("Authorization", None)
headers.pop("authorization", None)
headers.pop("x-api-key", None)
headers.update(self.auth_headers(protocol))
if self._requires_session:
headers["x-opencode-session"] = session_id or uuid.uuid4().hex
return headers
def _media_headers(self) -> dict[str, str]:
"""媒体端点(图像生成 / 视频创建 / 视频轮询)的 headers。
媒体端点不属于「三条协议线」,所以不走 `_req_headers` —— 历史口径是固定用 Bearer。
第二十七轮把鉴权头改成「按协议线在 `_req_headers` 里组装」之后,这三个调用点却还在
用静态 `self._headers`,而 `create_adapter` 已经不再往静态头里塞 Authorization
⇒ **token 一个都没带出去**。真机表现:`POST /v1/images/generations` 上游 401
「未提供令牌」(同一个 key 直接 curl 同一个地址是 200)。
这里统一补回来:静态头 + Bearer(有 token 时)+ 会话头(供应商要求时)。
"""
headers = dict(self._headers)
if self._token:
headers["Authorization"] = f"Bearer {self._token}"
if self._requires_session:
headers["x-opencode-session"] = uuid.uuid4().hex
return headers
# ── 协议直传(第二十七轮)────────────────────────
# 「入站是什么格式,出站就是什么格式」:这两个原语把入站 body **原样**发到该线的上游
# 地址,**不翻译任何字段**。网关只做三件事:① 挑对供应商与线;② 把 model 改成真实
# id 并盖上模型级强制参数;③ 原样把响应(含 SSE)交回客户端。
# 中间不做 has_images 之类的语义判断,也不解析 body 结构。
def prepare_payload(self, model: str, payload: dict[str, Any]) -> dict[str, Any]:
"""直传前的定点改写:model 换成真实 id + 盖模型级强制参数(其余一律不动)。
- model:入站就是真实模型 id(第二十七轮起路由别名已删除,不再有别名解析,
网关也不会替你换模型)—— 这里仍保留"定点改写 model"的能力:调用方写的 id
必须落到某条线能认的 id 上;
- 强制参数:`models[].params`(如 kimi-k2.7-code 只接受 temperature=1)在直传里
同样必须生效,否则"直传"就成了"漏掉网关的硬约束"。
这两处是**唯一**允许改写入站 body 的地方(改的都是"发给谁/必须用什么参数",
不是协议语义),其余字段一律原样。
"""
out = dict(payload)
out["model"] = model
forced = self._forced_params(model)
if forced:
out.update(forced)
return out
async def raw_json(self, protocol: str, payload: dict[str, Any],
session_id: str | None = None) -> tuple[int, Any]:
"""非流式直传:返回 (上游状态码, 上游 JSON/文本)。
刻意**不 raise_for_status**:直传口径下上游的错误体要原样交回客户端
(老板决策:"其他都不转" —— 错误文案也不转)。熔断/指标由调用方按状态码记。
"""
async with self._lease() as client:
resp = await client.post(self._path(protocol), json=payload,
headers=self._req_headers(session_id, protocol))
body = resp.content
ctype = resp.headers.get("content-type", "")
if "application/json" in ctype:
try:
return resp.status_code, json.loads(body)
except (ValueError, json.JSONDecodeError):
pass
# 非 JSON(或声明 JSON 但解析失败):把原始文本交回,别在这里编造结构
return resp.status_code, body.decode("utf-8", "replace")
@asynccontextmanager
async def raw_stream(self, protocol: str, payload: dict[str, Any],
session_id: str | None = None):
"""流式直传:上下文内可直接读 `resp`(状态码 + 字节流)。
为什么用 asynccontextmanager 而不是普通 async generator:调用方需要**先看到
状态码**再决定返回 SSE(200)还是上游的 JSON 错误(4xx/5xx)。同时 lease 必须在
整个流式期间持有(热重载/关闭不会掐断在途流,与 _stream_once 同一处理)。
"""
async with self._lease() as client:
async with client.stream("POST", self._path(protocol), json=payload,
headers=self._req_headers(session_id, protocol)) as resp:
yield resp
def _build_payload(
self,
model: str,
@@ -214,7 +357,8 @@ class OpenAICompatAdapter(BaseAdapter):
"""执行一次非流式 /chat/completions 请求(不含参数修正逻辑)。"""
# Bug 4 修复: 用 lease 占用 client,热重载 close 会等本次请求结束才真正关连接
async with self._lease() as client:
resp = await client.post("/chat/completions", json=payload, headers=self._req_headers(session_id))
resp = await client.post(self._path(PROTOCOL_CHAT), json=payload,
headers=self._req_headers(session_id, PROTOCOL_CHAT))
resp.raise_for_status()
data = json_or_raise(resp)
@@ -269,7 +413,8 @@ class OpenAICompatAdapter(BaseAdapter):
# Bug 4 修复: lease 在整个流式期间持有占用,热重载/关闭不会掐断在途流
async with self._lease() as client:
async with client.stream(
"POST", "/chat/completions", json=payload, headers=self._req_headers(session_id)
"POST", self._path(PROTOCOL_CHAT), json=payload,
headers=self._req_headers(session_id, PROTOCOL_CHAT)
) as resp:
resp.raise_for_status()
async for line in resp.aiter_lines():
@@ -316,7 +461,7 @@ class OpenAICompatAdapter(BaseAdapter):
payload["extra_body"] = extra_body
async with self._lease() as client:
resp = await client.post(endpoint, json=payload, headers=self._headers)
resp = await client.post(endpoint, json=payload, headers=self._media_headers())
resp.raise_for_status()
data = json_or_raise(resp)
# 统一:返回 data 数组
@@ -350,7 +495,7 @@ class OpenAICompatAdapter(BaseAdapter):
payload[k] = v
async with self._lease() as client:
resp = await client.post(endpoint, json=payload, headers=self._headers)
resp = await client.post(endpoint, json=payload, headers=self._media_headers())
resp.raise_for_status()
data = json_or_raise(resp)
# video_id 用于查询;id/task_id 是任务 id
@@ -372,7 +517,7 @@ class OpenAICompatAdapter(BaseAdapter):
# 轮询用绝对 URL(poll_base 可能是去掉 /v1 的域名根)
url = poll_base.rstrip("/") + poll_path
async with self._lease() as client:
resp = await client.get(url, params=params, headers=self._headers)
resp = await client.get(url, params=params, headers=self._media_headers())
resp.raise_for_status()
data = json_or_raise(resp)
return {"raw": data}
+207 -81
View File
@@ -1,7 +1,8 @@
"""配置加载模块:从 YAML 文件读取供应商、模型、路由、鉴权、运维配置。"""
"""配置加载模块:从 YAML 文件读取供应商、模型、鉴权、运维配置。"""
from __future__ import annotations
import logging
import os
from dataclasses import dataclass, field
from pathlib import Path
@@ -9,6 +10,8 @@ from typing import Any
import yaml
log = logging.getLogger("gateway.config")
class ConfigError(ValueError):
"""配置结构性错误(缺必填项等)。启动/热重载时抛出,附友好说明。"""
@@ -28,6 +31,65 @@ MODEL_PARAM_KEYS: frozenset[str] = frozenset({
})
# ── 协议线(方言)标准名(第二十七轮「三线直传」) ──────────────
# 老板决策:**入站是什么格式,出站就是什么格式**;网关不做任何跨格式翻译,
# 只在「供应商与模型」里声明每个模型能用哪几条线。
#
# 这里直接用各家文档 / SDK 里的**端点名**当协议名("标准的来"):
# chat/completions —— OpenAI Chat Completions(POST {base}/chat/completions)
# messages —— Anthropic Messages(POST {base}/messages,认 x-api-key)
# responses —— OpenAI Responses(POST {base}/responses,认 Bearer)
# 好处:配置、日志、前端标签、上游文档四处用的是同一个词,不用查对照表。
#
# 纯透传的边界:
# - 同一格(入站 = 出站)→ 原样转发,只定点改写 model + 盖模型级强制参数;
# - 不同格(如用 messages 打一个只支持 chat/completions 的模型)→ 入站直接 400
# 报「该模型不支持 messages 线」,**绝不偷偷翻译**(翻译出来的东西一定有损,
# 而且失败现场离用户十万八千里)。
PROTOCOL_CHAT = "chat/completions"
PROTOCOL_MESSAGES = "messages"
PROTOCOL_RESPONSES = "responses"
PROTOCOLS: tuple[str, ...] = (PROTOCOL_CHAT, PROTOCOL_MESSAGES, PROTOCOL_RESPONSES)
# 模型没写 protocols 时的默认值:只认 chat/completions。
# 为什么要默认而不是"全支持":老配置(Agnes / 火山)从未声明过协议,
# 默认全支持等于把「没实测过的线」当成可用,用户打过去只会收到上游 500。
DEFAULT_PROTOCOLS: tuple[str, ...] = (PROTOCOL_CHAT,)
# 出站鉴权方式:bearer(Authorization: Bearer xxx)/ x-api-key(Anthropic 系)/ none
AUTH_STYLES: frozenset[str] = frozenset({"bearer", "x-api-key", "none"})
@dataclass
class EndpointSpec:
"""某供应商在**一条协议线**上的出站配置(providers.<key>.endpoints.<protocol>)。
为什么放在供应商级而不是模型级:同一条线在同一个供应商下永远是同一个地址与同一套
鉴权头(OpenCode Go 三条线共用 https://opencode.ai/zen/go/v1,只是路径和鉴权头不同),
模型之间只有"能不能走"的差别 —— 那是 models[].protocols 的事。
"""
path: str = "" # 相对 base_url 的路径,如 /chat/completions
auth: str = "bearer" # bearer | x-api-key | none
headers: dict[str, str] = field(default_factory=dict) # 该线固定附加头(如 anthropic-version)
def _default_endpoints() -> dict[str, EndpointSpec]:
"""三条标准线的默认出站配置(未写 providers.*.endpoints 时用)。
默认值就是三家协议的标准形态,写出来只是为了让"默认"可见:
chat/completions → /chat/completions + Bearer
messages → /messages + x-api-key + anthropic-version
responses → /responses + Bearer
"""
return {
PROTOCOL_CHAT: EndpointSpec(path="/chat/completions", auth="bearer"),
PROTOCOL_MESSAGES: EndpointSpec(
path="/messages", auth="x-api-key",
headers={"anthropic-version": "2023-06-01"}),
PROTOCOL_RESPONSES: EndpointSpec(path="/responses", auth="bearer"),
}
@dataclass
class ModelInfo:
id: str
@@ -36,7 +98,7 @@ class ModelInfo:
# 第十三轮: 是否支持「图像输入」(多模态 / 视觉)。
# Agnes 3.0 Flash 文档明确「输入模态:文本、图像 URL」,实测 data:image/png;base64 也能识别;
# 其余文本模型(ark-code 等)文档未声明图像输入 → 默认 False。
# 用途:① /v1/models 暴露给前端标注/告警;② 带图请求走路由别名时把有视觉能力的模型排到前面。
# 用途:① /v1/models 暴露给前端标注/告警;② 前端据此提示「换个支持视觉的模型」力的模型排到前面。
vision: bool = False
# 第二十五轮(模型参数硬约束): 该模型**必须用**的上游参数,发送前强制覆盖客户端传值。
# 背景:OpenCode Go 的 kimi-k2.7-code 只接受 temperature=1,客户端传 0(含一键测速的
@@ -46,6 +108,17 @@ class ModelInfo:
# 拉到 0 也不会再 400(值被网关改成上游唯一允许的那个)。
# 键必须在 MODEL_PARAM_KEYS 白名单内,否则 validate_config 直接报错(不静默失效)。
params: dict[str, Any] = field(default_factory=dict)
# 第二十七轮(三线直传): 该模型**能用哪几条协议线**(取值见 PROTOCOLS)。
# 语义是「入站也用这条线」—— 入站 /v1/messages 打到只声明了 chat/completions 的模型
# 时,网关直接 400,不替用户翻译(详见 PROTOCOLS 的说明)。
# 不写 = 默认 ["chat/completions"](老配置行为完全不变)。
# 实测口径(OpenCode Go 2026-09-18):**文档标注的线一定可用;有些模型实测能走多条线**
# (如 kimi-k3 / qwen 系列 chat + messages 都 200,deepseek 四个模型三线全通),
# 这类按实测把两条线都写上 —— 但只写实测 200 过的,猜测的线不写。
protocols: list[str] = field(default_factory=lambda: list(DEFAULT_PROTOCOLS))
def supports(self, protocol: str) -> bool:
return protocol in self.protocols
@dataclass
@@ -97,6 +170,17 @@ class ProviderConfig:
media: MediaConfig = field(default_factory=MediaConfig)
rate_limit_rps: float | None = None # 该供应商全局 QPS 上限(可选)
requires_session_header: bool = False # OpenCode Go 等要求每请求动态会话头(x-opencode-session)
# 第二十七轮(三线直传): 该供应商**每条协议线**的出站地址与鉴权头。
# 未配置时用 _default_endpoints()(三条标准线 + 标准鉴权)—— 所以 Agnes / 火山这类
# 只走 chat/completions 的供应商一个字段都不用加,行为与以前完全一致。
endpoints: dict[str, EndpointSpec] = field(default_factory=_default_endpoints)
def endpoint(self, protocol: str) -> EndpointSpec | None:
"""取某条线的出站配置(没有该线 → None,调用方按"供应商不支持这条线"处理)。"""
return self.endpoints.get(protocol)
def supports_protocol(self, protocol: str) -> bool:
return protocol in self.endpoints
# ── 网关入口鉴权 ──
@@ -107,24 +191,6 @@ class AuthGate:
session_ttl_minutes: int = 1440 # 前端 /auth/login 签发的 session 有效时长(分钟,默认 24h)
# ── 路由别名 + 优先级 fallback ──
@dataclass
class RouteInfo:
"""路由别名 → 按优先级排列的 fallback 模型链。
models: 第 0 个为最高优先级,调用失败/超时依次切换。
timeout: 单个模型尝试的超时(秒),None 用 server.timeout。
retry: 切到下一个模型前,同一模型的重试次数(含首次)。
rate_limit_rps: 该路由别名整体 QPS 上限(None=不限)。
"""
name: str
models: list[str] = field(default_factory=list)
timeout: int | None = None
retry: int = 1
rate_limit_rps: float | None = None
@dataclass
class CircuitConfig:
"""供应商熔断器配置。"""
@@ -199,7 +265,6 @@ class GatewayConfig:
providers: dict[str, ProviderConfig] = field(default_factory=dict)
server: ServerConfig = field(default_factory=ServerConfig)
auth: AuthGate = field(default_factory=AuthGate)
routes: dict[str, RouteInfo] = field(default_factory=dict)
circuit: CircuitConfig = field(default_factory=CircuitConfig)
observability: ObservabilityConfig = field(default_factory=ObservabilityConfig)
pricing: Pricing = field(default_factory=Pricing)
@@ -222,18 +287,29 @@ class GatewayConfig:
def find_provider_for_model(self, model_id: str) -> tuple[str, ProviderConfig, ModelInfo] | None:
return self._model_index.get(model_id)
def find_route(self, model_id: str) -> RouteInfo | None:
return self.routes.get(model_id)
def find_model_for_protocol(
self, model_id: str, protocol: str
) -> tuple[str, ProviderConfig, ModelInfo] | None:
"""按「模型 + 入站协议线」查供应商;模型不存在或该线不支持 → None。
三线直传的核心闸门:入站是哪条线,就必须在这条线上找到模型,否则 400 ——
**不做任何跨线翻译**(老板决策)。返回 None 的两种情况(未知模型 / 不支持该线)
由调用方分别给不同文案,别混成一句"模型不存在"。
"""
found = self._model_index.get(model_id)
if found is None:
return None
pkey, pconfig, minfo = found
if not minfo.supports(protocol):
return None
if not pconfig.supports_protocol(protocol):
return None
return found
def models_with_protocol(self, protocol: str) -> list[ModelInfo]:
"""能走某条线的全部模型(/v1/models 与前端标签用)。"""
return [m for p in self.providers.values() for m in p.models if m.supports(protocol)]
def validate_routes(self) -> list[str]:
"""启动校验:路由里的 model ID 是否都存在。返回告警列表(空=全合法)。"""
known = {m["id"] for m in self.all_models()}
warnings: list[str] = []
for rname, route in self.routes.items():
for mid in route.models:
if mid not in known:
warnings.append(f"路由 {rname} 引用了未知模型 '{mid}'")
return warnings
def all_models(self) -> list[dict[str, Any]]:
result = []
@@ -250,20 +326,13 @@ class GatewayConfig:
# 前端据此标注「该模型温度已由网关固定」,API 调用方也能提前知道
# 自己传的采样参数会被上游要求覆盖,省掉一轮「传了没生效」的困惑。
"params": dict(m.params or {}),
# 第二十七轮: 暴露该模型能走哪几条协议线(取值见 PROTOCOLS)。
# 前端「供应商与模型」页据此打格式标签;API 调用方也能提前知道自己
# 该把请求发到 /v1/chat/completions、/v1/messages 还是 /v1/responses。
"protocols": list(m.protocols),
})
return result
def all_routes(self) -> list[dict[str, Any]]:
out = []
for rname, r in self.routes.items():
out.append({
"name": rname,
"models": r.models,
"timeout": r.timeout,
"retry": r.retry,
})
return out
def _opt_float(v: Any, field_name: str = "rate_limit_rps") -> float | None:
"""可选数值解析:None/空串 → None;数字或数字字符串 → float;其它 → ConfigError。
@@ -355,6 +424,82 @@ def _parse_model_params(v: Any, where: str) -> dict[str, Any]:
return out
def _parse_protocols(v: Any, where: str) -> list[str]:
"""解析模型级 `protocols`(第二十七轮三线直传)。
容错口径(宁可报错,不可静默失效 —— 写错协议名是最容易发生的配置失误,
而它的表现是"调用该模型永远 400",静默接受等于让用户自己 debug 配置):
- 缺失 / None → 默认 ["chat/completions"](老配置行为不变);
- 字符串 → 当作单元素列表(写 `protocols: messages` 也认);
- 列表 → 逐项校验,必须是 PROTOCOLS 里的标准名;
- 去重保序;空列表 → ConfigError("一个模型一条线都不支持"多半是手滑)。
"""
if v is None:
return list(DEFAULT_PROTOCOLS)
if isinstance(v, str):
raw_items: list[Any] = [v]
elif isinstance(v, (list, tuple)):
raw_items = list(v)
else:
raise ConfigError(
f"{where} 必须是字符串或列表(可选值:{', '.join(PROTOCOLS)}),得到 {type(v).__name__}: {v!r}")
out: list[str] = []
for item in raw_items:
name = str(item or "").strip()
if not name:
raise ConfigError(f"{where} 出现空的协议名")
if name not in PROTOCOLS:
raise ConfigError(
f"{where} 里的 '{name}' 不是标准协议名(允许:{', '.join(PROTOCOLS)})")
if name not in out:
out.append(name)
if not out:
raise ConfigError(f"{where} 为空列表 —— 每个模型至少要声明一条协议线")
return out
def _parse_endpoints(pval: dict[str, Any], pkey: str) -> dict[str, EndpointSpec]:
"""解析供应商级 `endpoints`(每条协议线的出站路径 / 鉴权 / 固定头)。
未配置 → 三条标准线的默认值(见 _default_endpoints)。配置了就**只认配的那些线**:
"没写这条线" 有语义 —— 该供应商没有这条线,模型声明了也没用(调用会明确报错,
而不是发到一个猜出来的地址上收 404)。
形如:
endpoints:
messages:
path: "/messages"
auth: "x-api-key"
headers: {anthropic-version: "2023-06-01"}
"""
raw = pval.get("endpoints")
if raw is None:
return _default_endpoints()
if not isinstance(raw, dict):
raise ConfigError(f"providers.{pkey}.endpoints 必须是映射,得到 {type(raw).__name__}")
out: dict[str, EndpointSpec] = {}
for pname, spec in raw.items():
name = str(pname or "").strip()
where = f"providers.{pkey}.endpoints.{name}"
if name not in PROTOCOLS:
raise ConfigError(f"{where} 不是标准协议名(允许:{', '.join(PROTOCOLS)})")
if not isinstance(spec, dict):
raise ConfigError(f"{where} 必须是映射(path/auth/headers),得到 {type(spec).__name__}")
path = str(spec.get("path") or "").strip()
if not path:
raise ConfigError(f"{where}.path 不能为空(相对 base_url 的路径,如 /messages)")
auth = str(spec.get("auth") or "bearer").strip()
if auth not in AUTH_STYLES:
raise ConfigError(
f"{where}.auth 只能是 {'/'.join(sorted(AUTH_STYLES))},得到 {auth!r}")
headers = spec.get("headers") or {}
if not isinstance(headers, dict):
raise ConfigError(f"{where}.headers 必须是映射(如 anthropic-version)")
out[name] = EndpointSpec(path=path, auth=auth,
headers={str(k): str(v) for k, v in headers.items()})
return out
def _parse_media(pval: dict[str, Any]) -> MediaConfig:
m = pval.get("media", {}) or {}
return MediaConfig(
@@ -394,7 +539,7 @@ def _parse_download(pval: dict[str, Any]) -> DownloadConfig:
def validate_config(cfg: GatewayConfig) -> list[str]:
"""结构性校验(Bug 12 修复):返回问题列表,空 = 通过。
校验供应商必填项与路由链,给出可读的中文说明(而非运行到一半才崩)。
校验供应商必填项与模型字段,给出可读的中文说明(而非运行到一半才崩)。
"""
issues: list[str] = []
if not cfg.providers:
@@ -407,9 +552,13 @@ def validate_config(cfg: GatewayConfig) -> list[str]:
for idx, m in enumerate(p.models):
if not m.id:
issues.append(f"供应商 '{pkey}' 的第 {idx + 1} 个模型缺少 id")
for rname, r in cfg.routes.items():
if not r.models:
issues.append(f"路由 '{rname}' 的模型链为空")
# 第二十七轮: 模型声明了某条线,但供应商根本没配这条线的出站地址 ——
# 这种配置下调用必然失败(而且会失败在"拼 URL"那一步),必须启动就拦住。
for proto in m.protocols:
if not p.supports_protocol(proto):
issues.append(
f"供应商 '{pkey}' 的模型 '{m.id}' 声明了协议线 '{proto}',"
f"但该供应商的 endpoints 里没有这条线")
# 账号体系已由页面管理(data/users.json,见 app/users.py),配置文件不再承载鉴权。
# 首次启动会创建 admin/admin,不存在「自锁」场景。
return issues
@@ -437,24 +586,18 @@ def validate_warnings(cfg: GatewayConfig) -> list[str]:
# 供应商缺 Key / 缺模型:上线前就点出来,而不是调用时才 503 / fallback 悄悄失效
for pkey, p in cfg.providers.items():
if not p.models:
warns.append(f"供应商 '{pkey}' 没有任何模型 —— 路由链里指向它的 fallback 项永远不可用")
warns.append(f"供应商 '{pkey}' 没有任何模型 —— 它不会出现在任何一条协议线上,永远不可用")
if not p.auth.token and not (p.auth.token_env and os.environ.get(p.auth.token_env)):
warns.append(f"供应商 '{pkey}' 未配置 API Key(token 与 token_env 均空/环境变量未设置)"
f" —— 调用该供应商的任何模型都会 503")
# (账号/密码/API Key 已改由页面管理,弱凭证检查不再适用于配置文件。)
# 路由引用了不存在的模型 id → 该 fallback 项永远不可用(多半是打错字)
known = {m["id"] for m in cfg.all_models()}
for r in cfg.all_routes():
miss = [mid for mid in r["models"] if mid not in known]
if miss:
warns.append(f"路由 '{r['name']}' 引用了未定义的模型 {miss} —— 这些 fallback 项永远不可用")
return warns
def load_config(path: str | Path) -> GatewayConfig:
"""从 YAML 文件加载完整网关配置。
结构性错误(缺供应商/缺 base_url/空模型链等)抛 ConfigError,带友好说明。
结构性错误(缺供应商/缺 base_url/模型缺 id 等)抛 ConfigError,带友好说明。
"""
path = Path(path)
if not path.exists():
@@ -484,7 +627,9 @@ def parse_config(raw: dict[str, Any]) -> GatewayConfig:
ModelInfo(id=m.get("id", ""), display_name=m.get("display_name", ""),
type=m.get("type", "text"), vision=_opt_bool(m.get("vision"), "providers.*.models.*.vision", False),
params=_parse_model_params(
m.get("params"), f"providers.{pkey}.models[{idx}].params"))
m.get("params"), f"providers.{pkey}.models[{idx}].params"),
protocols=_parse_protocols(
m.get("protocols"), f"providers.{pkey}.models[{idx}].protocols"))
for idx, m in enumerate(pval.get("models", []))
]
providers[pkey] = ProviderConfig(
@@ -498,6 +643,7 @@ def parse_config(raw: dict[str, Any]) -> GatewayConfig:
rate_limit_rps=_opt_float(pval.get("rate_limit_rps")),
requires_session_header=_opt_bool(
pval.get("requires_session_header"), "providers.*.requires_session_header", False),
endpoints=_parse_endpoints(pval, pkey),
)
srv_raw = raw.get("server", {}) or {}
@@ -535,30 +681,10 @@ def parse_config(raw: dict[str, Any]) -> GatewayConfig:
auth = AuthGate(session_ttl_minutes=_opt_int(auth_raw.get("session_ttl_minutes"),
"auth.session_ttl_minutes", 1440, minimum=1))
# 路由别名 → 优先级 fallback 链(支持 list 或 dict 两种写法)
routes_raw = raw.get("routes", {}) or {}
routes: dict[str, RouteInfo] = {}
for rname, rval in routes_raw.items():
if isinstance(rval, dict):
chain: list[str] = []
for item in (rval.get("models", []) or []):
if isinstance(item, str):
chain.append(item)
elif isinstance(item, dict) and item.get("model"):
chain.append(item["model"])
routes[rname] = RouteInfo(
name=rname,
models=chain,
# 注意 minimum=0:缺省值是 0(=未设置,下面 `or None` 转 None)。
# 若写 minimum=1,会让"路由没写 timeout"的配置直接报 ConfigError —— 这正是
# 第七轮自查抓到的一个自伤 bug(之前只有在配置恰好写了 timeout 时才不炸)。
timeout=(_opt_int(rval.get("timeout"), f"routes.{rname}.timeout", 0, minimum=0) or None),
retry=_opt_int(rval.get("retry"), f"routes.{rname}.retry", 1, minimum=1),
rate_limit_rps=_opt_float(rval.get("rate_limit_rps")),
)
else:
chain = [x for x in (rval or []) if isinstance(x, str)]
routes[rname] = RouteInfo(name=rname, models=chain)
# 第二十七轮: 「路由别名 / fallback 链」功能已整体移除。
# 老配置里残留的 routes 段不再解析,只在日志里提醒一声(不报错,免得旧配置起不来)。
if raw.get("routes"):
log.warning("配置里的 'routes' 段已废弃(路由别名功能已移除),本次加载忽略该段")
# 熔断器
c_raw = raw.get("circuit", {}) or {}
@@ -588,7 +714,7 @@ def parse_config(raw: dict[str, Any]) -> GatewayConfig:
pricing = Pricing(per_model=per_model)
cfg = GatewayConfig(
providers=providers, server=server, auth=auth, routes=routes,
providers=providers, server=server, auth=auth,
circuit=circuit, observability=observability, pricing=pricing,
download=_parse_download(raw),
)
+659 -417
View File
File diff suppressed because it is too large. Load diff
+6 -32
View File
@@ -56,15 +56,13 @@ _BODY_MAX = 2000
# ── 用量指标 ──────────────────────────────────────────
class Metrics:
"""按 模型/供应商/路由 维度统计调用次数、fallback、token、耗时。"""
"""按 模型/供应商 维度统计调用次数、token、耗时。"""
def __init__(self, enabled: bool = True, started_at: float | None = None):
self.enabled = enabled
self._lock = threading.Lock()
self.calls: dict[str, dict[str, int]] = {} # model -> {ok, fail}
self.providers: dict[str, dict[str, int]] = {} # provider -> {ok, fail}
self.routes: dict[str, dict[str, int]] = {} # route -> {ok, fallback}
self.fallback_total: int = 0
self.tokens_prompt: int = 0
self.tokens_completion: int = 0
self.latency_samples: dict[str, deque[float]] = {} # model -> 最近 N 次耗时
@@ -72,7 +70,7 @@ class Metrics:
self.in_flight: int = 0
self.in_flight_peak: int = 0
# M5+: 按账号维度的聚合(普通账号只看到自己的调用;admin 看全局)。
# 结构:account -> {"calls","providers","routes","tokens","latency","fallback"}
# 结构:account -> {"calls","providers","tokens","latency"}
self.by_account: dict[str, dict[str, Any]] = {}
# Bug 4: 热重载时保留 started_at,uptime 不因重载清零
self.started_at: float = started_at if started_at is not None else time.time()
@@ -82,9 +80,9 @@ class Metrics:
acc = self.by_account.get(account)
if acc is None:
acc = {
"calls": {}, "providers": {}, "routes": {},
"calls": {}, "providers": {},
"tokens": {"prompt": 0, "completion": 0},
"latency": {}, "fallback": 0,
"latency": {},
}
self.by_account[account] = acc
return acc
@@ -109,11 +107,10 @@ class Metrics:
def _bucket(d: dict, k: str) -> dict[str, int]:
return d.setdefault(k, {"ok": 0, "fail": 0})
def record_call(self, model: str, provider: str | None, ok: bool, route: str | None = None,
def record_call(self, model: str, provider: str | None, ok: bool,
account: str | None = None) -> None:
"""记录一次调用结果。
route 维度(Bug 8 修复):传入 route 时同时累加 routes 的 ok/fail。
account(M5+):未显式传入时取请求级 ACCOUNT 上下文;非 anonymous 时额外累加
到该账号自己的聚合桶,供「只看本人的指标」使用。
"""
@@ -124,31 +121,12 @@ class Metrics:
self._bucket(self.calls, model)["ok" if ok else "fail"] += 1
if provider:
self._bucket(self.providers, provider)["ok" if ok else "fail"] += 1
if route:
self._bucket(self.routes, route)["ok" if ok else "fail"] += 1
if a and a != "anonymous":
acc = self._acc(a)
self._bucket(acc["calls"], model)["ok" if ok else "fail"] += 1
if provider:
self._bucket(acc["providers"], provider)["ok" if ok else "fail"] += 1
if route:
self._bucket(acc["routes"], route)["ok" if ok else "fail"] += 1
def record_fallback(self, route: str | None, account: str | None = None) -> None:
if not self.enabled:
return
a = account or ACCOUNT.get()
with self._lock:
self.fallback_total += 1
if route:
self._bucket(self.routes, route).setdefault("fallback", 0)
self.routes[route]["fallback"] += 1
if a and a != "anonymous":
acc = self._acc(a)
acc["fallback"] += 1
if route:
b = self._bucket(acc["routes"], route)
b["fallback"] = b.get("fallback", 0) + 1
def record_tokens(self, prompt: int, completion: int, account: str | None = None) -> None:
if not self.enabled:
@@ -198,7 +176,7 @@ class Metrics:
if not acc:
return dict(uptime_seconds=round(time.time() - self.started_at, 1),
in_flight=self.in_flight, in_flight_peak=self.in_flight_peak,
calls={}, providers={}, routes={}, fallback_total=0,
calls={}, providers={},
tokens={"prompt": 0, "completion": 0}, latency={})
lat = {}
for m, dq in acc["latency"].items():
@@ -210,8 +188,6 @@ class Metrics:
"in_flight_peak": self.in_flight_peak,
"calls": {k: dict(v) for k, v in acc["calls"].items()},
"providers": {k: dict(v) for k, v in acc["providers"].items()},
"routes": {k: dict(v) for k, v in acc["routes"].items()},
"fallback_total": acc["fallback"],
"tokens": dict(acc["tokens"]),
"latency": lat,
}
@@ -231,8 +207,6 @@ class Metrics:
"in_flight_peak": self.in_flight_peak,
"calls": {k: dict(v) for k, v in self.calls.items()},
"providers": {k: dict(v) for k, v in self.providers.items()},
"routes": {k: dict(v) for k, v in self.routes.items()},
"fallback_total": self.fallback_total,
"tokens": {"prompt": self.tokens_prompt, "completion": self.tokens_completion},
"latency": latency_out,
}
+33 -27
View File
@@ -86,6 +86,37 @@ class ToolDef(BaseModel):
CONVERSATION_ID_MAX = 128
def normalize_conversation_id(v: Any) -> str | None:
"""会话 id 的入口校验(第二十六轮,第二十七轮抽成函数给直传端点多路复用)。
它最终会作为 `x-opencode-session` **HTTP header** 发往上游,所以必须在入站拦掉
两类值——否则失败发生在组 header 的那一刻,会被误报成"上游挂了":
① **非 ASCII**(中文、全角符号等):httpx 组 header 抛 `UnicodeEncodeError`
(实测 `'ascii' codec can't encode characters`),网关把它当成上游失败
**重试 3 次**(3 次必然都失败)→ 最终回 502「路由 x 全部模型调用失败」+
记一次熔断。真实原因是客户端传错了值,却被伪装成上游故障,排查成本极高。
② **过长**:header 超限同样会失败,且一行 header 塞几百 KB 毫无意义。
空白串按"未传"处理(返回 None → 上游每次随机会话),与旧行为保持一致。
校验失败抛 ValueError,由调用方转成 400(pydantic 校验器与直传端点共用同一份规则)。
"""
if v is None:
return None
if not isinstance(v, str):
raise ValueError(f"类型必须是字符串,得到 {type(v).__name__}")
v = v.strip()
if not v:
return None
if len(v) > CONVERSATION_ID_MAX:
raise ValueError(f"过长:最多 {CONVERSATION_ID_MAX} 个字符(收到 {len(v)} 个)")
try:
v.encode("ascii")
except UnicodeEncodeError:
raise ValueError("只能包含 ASCII 字符(不能有中文/全角符号/emoji);建议用 uuid4().hex")
return v
class ChatRequest(BaseModel):
# 兼容性修复:OpenAI 官方 SDK 会带不少可选参数(n / presence_penalty / response_format …),
# 之前未声明的字段被 pydantic 静默丢弃,导致"网关号称 OpenAI 全兼容但参数悄悄丢失"。
@@ -155,33 +186,8 @@ class ChatRequest(BaseModel):
@field_validator("conversation_id")
@classmethod
def _validate_conversation_id(cls, v: str | None) -> str | None:
"""会话 id 的入口校验(第二十六轮)。
它最终会作为 `x-opencode-session` **HTTP header** 发往上游,所以必须在入站拦掉
两类值——否则失败发生在组 header 的那一刻,会被误报成"上游挂了":
① **非 ASCII**(中文、全角符号等):httpx 组 header 抛 `UnicodeEncodeError`
(实测 `'ascii' codec can't encode characters`),网关把它当成上游失败
**重试 3 次**(3 次必然都失败)→ 最终回 502「路由 x 全部模型调用失败」+
记一次熔断。真实原因是客户端传错了值,却被伪装成上游故障,排查成本极高。
② **过长**:header 超限同样会失败,且一行 header 塞几百 KB 毫无意义。
空白串按"未传"处理(返回 None → 上游每次随机会话),与旧行为保持一致。
"""
if v is None:
return None
v = v.strip()
if not v:
return None
if len(v) > CONVERSATION_ID_MAX:
raise ValueError(
f"过长:最多 {CONVERSATION_ID_MAX} 个字符(收到 {len(v)} 个)")
try:
v.encode("ascii")
except UnicodeEncodeError:
raise ValueError(
"只能包含 ASCII 字符(不能有中文/全角符号/emoji);建议用 uuid4().hex")
return v
"""见 normalize_conversation_id(第二十七轮把规则抽成公共函数,直传端点多路复用)。"""
return normalize_conversation_id(v)
# ── 图像生成 ─────────────────────────────────────────
+56 -34
View File
@@ -31,6 +31,8 @@ import yaml
from app.config import (
ConfigError,
GatewayConfig,
PROTOCOLS,
_default_endpoints,
parse_config,
validate_config,
validate_warnings,
@@ -88,11 +90,23 @@ def config_to_view(cfg: GatewayConfig) -> dict[str, Any]:
"rate_limit_rps": p.rate_limit_rps,
"requires_session_header": bool(p.requires_session_header),
"media": {k: getattr(p.media, k) for k in MEDIA_KEYS},
# 第二十七轮(三线直传): 每条协议线的出站路径/鉴权/固定头。
# 面板不提供编辑器(在 YAML 全文编辑器里改),但**必须一路带着走**:
# view_to_raw 是按固定键集重建 providers 的,少带这一段 = 管理员在页面上
# 随手保存一次,OpenCode 的三条线配置就被静默清掉(模型全变"不支持该线")。
"endpoints": {
name: {"path": ep.path, "auth": ep.auth, "headers": dict(ep.headers or {})}
for name, ep in (p.endpoints or {}).items()
},
"models": [
{"id": m.id, "display_name": m.display_name, "type": m.type, "vision": bool(m.vision),
# 第二十五轮: 回传模型级强制参数。面板不提供编辑入口(在 YAML 全文编辑器里改),
# 但必须一路带着走 —— 否则读回来再提交一次就会把它弄丢。
"params": dict(m.params or {})}
"params": dict(m.params or {}),
# 第二十七轮: 模型能走哪几条协议线。这一项**面板可编辑**
# (「供应商与模型」页给每个模型打格式标签),所以两处都要认:
# 读回给页面显示、写盘时以页面提交的为准。
"protocols": list(m.protocols)}
for m in p.models
],
}
@@ -119,15 +133,6 @@ def config_to_view(cfg: GatewayConfig) -> dict[str, Any]:
"auth_fail_limit_per_min": s.auth_fail_limit_per_min,
},
"auth": {"session_ttl_minutes": cfg.auth.session_ttl_minutes},
"routes": {
rname: {
"models": list(r.models or []),
"timeout": r.timeout,
"retry": r.retry,
"rate_limit_rps": r.rate_limit_rps,
}
for rname, r in cfg.routes.items()
},
"circuit": {
"enabled": cfg.circuit.enabled,
"failure_threshold": cfg.circuit.failure_threshold,
@@ -153,6 +158,37 @@ def config_to_view(cfg: GatewayConfig) -> dict[str, Any]:
# ── 写入:面板 JSON → 完整 yaml 字典 ───────────────────────
def _parse_protocols_view(v: Any, where: str) -> list[str]:
"""面板提交的模型协议线(第二十七轮三线直传)→ 写盘用的标准名列表。
页面上的格式标签就是这几个标准名(chat/completions | messages | responses),
写错名字在写盘前就报错(不能等运行时才发现"这个模型永远 400")。
列表去重保序;空列表报错(一个模型一条线都不支持多半是手滑)。
"""
if isinstance(v, str):
raw_items: list[Any] = [v]
elif isinstance(v, (list, tuple)):
raw_items = list(v)
else:
raise ConfigError(f"{where} 必须是列表(可选:{'/'.join(PROTOCOLS)})")
out: list[str] = []
for item in raw_items:
name = str(item or "").strip()
if name not in PROTOCOLS:
raise ConfigError(f"{where} 里的 {name!r} 不是标准协议名(可选:{'/'.join(PROTOCOLS)})")
if name not in out:
out.append(name)
if not out:
raise ConfigError(f"{where} 不能为空 —— 每个模型至少要声明一条协议线")
return out
def _default_endpoints_view() -> dict[str, Any]:
"""供应商没在文件里写 endpoints 时,面板/写盘要用的默认三条线。"""
return {name: {"path": ep.path, "auth": ep.auth, "headers": dict(ep.headers or {})}
for name, ep in _default_endpoints().items()}
def _as_dict(v: Any, field_name: str) -> dict[str, Any]:
if v is None:
return {}
@@ -242,6 +278,11 @@ def view_to_raw(cfg: GatewayConfig, raw: dict[str, Any], view: dict[str, Any]) -
"type": str(m.get("type") or "text").strip(),
"vision": bool(m.get("vision", False)),
})
# 第二十七轮: 协议线由面板管理(每个模型的格式标签),提交了就以此为准;
# 没提交则沿用文件原文里的值(避免旧前端/脚本提交时把 protocols 清空)。
if m.get("protocols"):
item["protocols"] = _parse_protocols_view(
m.get("protocols"), f"providers.{key}.models[{i}].protocols")
models.append(item)
providers[key] = {
"name": str(pv.get("name") or key).strip(),
@@ -253,6 +294,10 @@ def view_to_raw(cfg: GatewayConfig, raw: dict[str, Any], view: dict[str, Any]) -
"extra_headers": _str_map(pv.get("extra_headers"), f"providers.{key}.extra_headers"),
"rate_limit_rps": pv.get("rate_limit_rps"),
"requires_session_header": bool(pv.get("requires_session_header", False)),
# 第二十七轮: 协议线的出站配置(路径/鉴权/固定头)。
# 仍然以**文件原文为底**:面板没有这段的编辑器,而它一旦丢失,
# 声明了 messages/responses 的模型会直接变成"供应商没配这条线"。
"endpoints": base_p.get("endpoints", _default_endpoints_view()),
# media 留空 = 该供应商不支持对应媒体(写回时保留原文里的空 {} 语义)
"media": {
k: (media_in.get(k) if k in media_in else base_media.get(k))
@@ -277,23 +322,6 @@ def view_to_raw(cfg: GatewayConfig, raw: dict[str, Any], view: dict[str, Any]) -
merged["session_ttl_minutes"] = av["session_ttl_minutes"]
out["auth"] = merged
# ── routes(整段以面板为准:删掉的路由别名就是删掉)──
if "routes" in view:
rv = _as_dict(view.get("routes"), "routes")
routes: dict[str, Any] = {}
for rname, rv1 in rv.items():
name = str(rname).strip()
if not name:
raise ConfigError("路由别名的名字不能为空")
rv1 = _as_dict(rv1, f"routes.{name}")
routes[name] = {
"models": _str_list(rv1.get("models"), f"routes.{name}.models"),
"timeout": rv1.get("timeout"),
"retry": rv1.get("retry"),
"rate_limit_rps": rv1.get("rate_limit_rps"),
}
out["routes"] = routes
# ── circuit / observability ──
for sec, keys in (("circuit", _CIRCUIT_KEYS), ("observability", _OBS_KEYS)):
if sec in view:
@@ -393,12 +421,6 @@ _SECTION_COMMENTS = {
# 账号与 API Key 由页面管理,存在 data/users.json(见 app/users.py):
# 管理员在「用户管理」建账号,各账号在「设置 → 我的 API Key」自助铸 Key。
# 本文件里没有任何用户/密钥,只有会话时长这一个开关。
""",
"routes": """\
# ── 路由别名 + 按优先级 fallback ────────────────────────
# model 填别名(如 wjd)时按 models 数组顺序逐个尝试:第 1 个失败/超时/重试耗尽 → 第 2 个 …
# 全失败才 502。timeout = 单模型超时秒(null 用 server.timeout),retry = 切下一个前该模型重试次数。
# 数组顺序即优先级(第 0 个最高)。可用模型 = 上面 providers 里定义的全部模型 id。
""",
"circuit": """\
# ── 供应商熔断 ──────────────────────────────────────────
@@ -424,7 +446,7 @@ _SECTION_COMMENTS = {
""",
}
_SECTION_ORDER = ("providers", "server", "circuit", "observability", "pricing", "download", "auth", "routes")
_SECTION_ORDER = ("providers", "server", "circuit", "observability", "pricing", "download", "auth")
def _dump(obj: Any) -> str: