第二十七轮: 三线直传(/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

+73
View File
@@ -1,5 +1,78 @@
# CHANGELOG # CHANGELOG
## 2026-09-18 · 第二十七轮:三线直传 + **彻底删除路由别名**
**老板决策**:wjd 路由这个功能去掉、删除掉,相关的代码和文档一起更新。
### 删除(路由别名 / fallback 链 —— 整块功能)
- `app/config.py`:删掉 `RouteInfo` 类、`GatewayConfig.routes` 字段、`find_route()` /
`all_routes()` / `validate_routes()` 三个方法,以及 YAML 里 `routes:` 段的解析。
老配置残留的 `routes` 段**不报错、直接忽略**(日志一条 warning),免得旧配置起不来。
- `app/main.py`:删掉 `_route_chain()` / `_order_chain_by_speed()` / `_filter_chain_by_protocol()` /
`_vision_first()` / `_chain_has_vision()`;`_chat_fallback()` → `_chat_once()`(单模型 + 同模型
重试 + 熔断,不再"这个不行换下一个");流式 `_stream_response()` 单模型化(新增 `_sse_error()`
统一错误帧);batch / 媒体端点 / 热重载 / 启动日志 / `/` / `/health` / `/v1/models` 里的路由痕迹
全部清掉。
- `app/metrics.py`:删掉 `routes` 维度、`fallback_total` 与 `record_fallback()`;指标只剩
**模型 / 供应商 / 账号** 三个维度。
- `app/settings.py`:配置面板视图与写回不再有 `routes` 段。
- `data/gateway.yaml`:`routes: {}` 整段删除,`server.retry` 注释去掉 route.retry 说法。
- 限流从三级(全局/路由/供应商)变**两级(全局/供应商)**;`route.timeout`、路由级告警一并消失。
- 前端:Models 页路由别名表 → 全部文本模型 + 一键测速;Chat 页去掉"路由"选项组与降级徽标;
Metrics 页「路由 vs 供应商」→「按供应商成功/失败」;Dashboard 路由链卡片 → 协议线覆盖卡片;
Settings 默认模型下拉去掉 `wjd`;ApiKeys 页示例改真实模型 id;中英文案同步(699 / 699 对称)。
### 保留
- **一键测速**(Models 页每行的延迟实测)保留,改为按**模型自己的协议线**探测。
- `wjd-` 开头的 API Key 前缀规则不变(那是 Key,不是路由)。
- `app/routing.py` 保留 —— 它只做「model_id → 供应商 + 认证解析」,与被删的路由别名无关(名字沿用)。
### 为什么删(不是"藏")
三线直传落地后「入站格式 = 出站格式」,模型 id 必须与协议线一一对应;再套一层"自动挑最快模型"
的别名,会把调用方选定的**格式与能力**(视觉 / 工具 / 协议线)悄悄换掉。要换模型就换 `model`,
网关不替谁做主。
### 验证
- 后端单测:**165 passed / 0 failed**(删 6 个路由引擎用例、改写 10 个、新增 2 个)。
- 前端:`vue-tsc --noEmit` 0 错、`npm run build` 成功、`check-i18n` 中英 699/699 对称。
- 生产**未动**:后端需 `supervisorctl restart api-gateway:api-gateway_00`(踢会话),
前端 dist 覆盖需老板点头。
### 上线(老板批准重启,2026-09-18 15:16)
- 前端 `npm run build` 产物覆盖 `frontend/dist`(新入口 `index-CWUVm0px.js`,公网
`https://127.0.0.1:8808/web/...` 已服务新入口、旧入口 404)。
- 后端 `supervisorctl restart api-gateway:api-gateway_00` → 新 pid,127.0.0.1:8808 正常,
`/health` 200、启动日志「已加载 3 供应商」。
- **代码仍未提交 git**(老板明确要求"先别提交")。
### 上线后真机复验:抓到并修掉 3 个本轮新引入的缺陷(P0×3)
老板批准上线后,用 `live_check.py`(真实 key、走公网网关)复验,发现:
1. **【P0】三线直传入门即 500**:`_passthrough()` 里 `_enforce_rate_limit(cfg, request, None, pkey, model_in)`
多传一个参数(函数只收 4 个)→ **每一次** `/v1/messages` 与 `/v1/responses` 都 `TypeError` → 500。
即本轮的核心功能两条线全灭(chat/completions 不受影响)。已改为 4 参调用。
2. **【P0】`/metrics/prometheus` 500**:导出器仍读 `snapshot["fallback_total"]`(该字段已随路由/fallback 删除)
→ `KeyError`。已删该指标行 + 其 HELP/TYPE,并顺带删掉 `/health` 里恒为 0 的 `fallback_total` 死字段。
3. **【P0】图像/视频的 token 没发出去**:本轮改为"鉴权头按协议线在 `_req_headers` 组装"后,
`create_adapter` 不再往静态 headers 塞 `Authorization`,但媒体三个调用点仍在用 `self._headers`
⇒ 图像生成/视频创建/视频轮询出站零鉴权头。真机:Agnes 图像 401「未提供令牌」,而同一 key
直接 curl 同地址 **200**。已新增 `_media_headers()`(静态头 + Bearer + 会话头)并在三处使用。
4. **测试基建(漏检根因之一)**:`tests/test_gateway.py` 的 `if __name__ == "__main__"` 运行块夹在文件中间,
脚本模式下**只收集执行到该行时已存在的测试** → 定义在其后的用例根本不跑
(`test_image_request_goes_to_requested_model` 白写了一轮)。已把运行块移到文件末尾,
并新增 6 条**真发请求**的回归测试(`/v1/messages` 往返 + conversation_id 不透传、`/v1/responses` +
跨线 400 闸门、直传供应商级限流 429、上游 4xx 原样回且不计熔断、流式字节原样转发 + 上游 4xx 真实状态码、
Prometheus 200 且无已删指标、媒体三处带 Bearer)。
单测 **165 → 173 passed / 0 failed**。
5. **文档订正**:README 残留的旧句「调用时 `model` 填 `wjd`,网关按顺序尝试」删除(路由已整块移除);
鉴权小节「Key 均不落明文」改为与「Key 明文回显」取舍一致的表述。
### 复验结果(重启后再次真机)
`live_check.py`:**19 PASS / 0 FAIL / 0 WARN** —— 三线直传真实 200、跨线 400、`/metrics/prometheus` 200、
图像生成 200。另手工验证:视频轮询可达上游(404「任务不存在」而非 401「未提供令牌」)、
图像下载 `/v1/media/download` 560KB PNG 正常落盘、一键测速三条线各测一个模型均 ok
(chat/completions 7106ms、responses 2014ms、messages 1360ms)。
按轮次记录 api-gateway 的修复与优化(README 侧重能力/配置说明,这里侧重每轮的改动、排查、验证与上线)。 按轮次记录 api-gateway 的修复与优化(README 侧重能力/配置说明,这里侧重每轮的改动、排查、验证与上线)。
--- ---
+83 -43
View File
@@ -4,11 +4,12 @@
## 特性 ## 特性
- ✅ 多供应商统一路由(`model` 字段自动分发) - ✅ 多供应商统一分发(`model` 决定供应商)
- ✅ 路由别名 `wjd`:运行时挑「当前可用 + 最近最快」的文本模型优先调用,其余按速度顺序 fallback + 熔断 - ✅ **三线直传**:`/v1/chat/completions`(OpenAI)· `/v1/messages`(Anthropic)· `/v1/responses`(Responses)三条线各按**自家协议原样转发**,网关不翻译字段;
- ✅ 同模型重试 + 路由级超时 + **供应商熔断器**(chat 与媒体各自独立桶) 模型支持哪几条线由 `models[].protocols` 声明,选错线**直接 400**并列出支持的线
- ✅ 同模型重试 + **供应商熔断器**(chat 与媒体各自独立桶)
- ✅ 图像 `/v1/images/generations` + 视频 `/v1/videos`(异步 + 等待模式 + Webhook) - ✅ 图像 `/v1/images/generations` + 视频 `/v1/videos`(异步 + 等待模式 + Webhook)
- ✅ 页面账号体系鉴权(账号密码登录 + 每账号自建 API Key,三级限流**全局/路由/供应商**) - ✅ 页面账号体系鉴权(账号密码登录 + 每账号自建 API Key,两级限流**全局/供应商**)
- ✅ 用量指标 `/metrics` + **Prometheus** `/metrics/prometheus` + 访问日志 `/logs` - ✅ 用量指标 `/metrics` + **Prometheus** `/metrics/prometheus` + 访问日志 `/logs`
- ✅ **Token 成本估算**(响应带 `estimated_cost_cny`) - ✅ **Token 成本估算**(响应带 `estimated_cost_cny`)
- ✅ **Batch 并发调用** `/v1/chat/completions/batch` - ✅ **Batch 并发调用** `/v1/chat/completions/batch`
@@ -23,9 +24,9 @@
api-gateway/ api-gateway/
├── data/gateway.yaml # 默认运行时配置(run.py 读取,hot_reload 开) ├── data/gateway.yaml # 默认运行时配置(run.py 读取,hot_reload 开)
├── app/ ├── app/
│ ├── config.py # YAML 加载 → dataclass(供应商/路由/鉴权/熔断/可观测/定价) │ ├── config.py # YAML 加载 → dataclass(供应商/模型/协议线/鉴权/熔断/可观测/定价)
│ ├── models.py # Pydantic 请求/响应模型(chat/image/video/batch) │ ├── models.py # Pydantic 请求/响应模型(chat/image/video/batch)
│ ├── routing.py # model_id → 供应商路由 + 认证解析 │ ├── routing.py # model_id → 供应商解析 + 认证解析(名字沿用;与「路由别名」无关)
│ ├── metrics.py # 用量指标 + 访问日志 + 限流(无外部依赖) │ ├── metrics.py # 用量指标 + 访问日志 + 限流(无外部依赖)
│ ├── circuit.py # 供应商熔断器(CLOSED/OPEN/HALF_OPEN) │ ├── circuit.py # 供应商熔断器(CLOSED/OPEN/HALF_OPEN)
│ ├── main.py # FastAPI 主入口(全部端点 + 中间件) │ ├── main.py # FastAPI 主入口(全部端点 + 中间件)
@@ -115,29 +116,43 @@ providers:
此外还有一层运行时兜底:上游若回 400 说某参数"只允许 X"(`invalid temperature: only 1 is allowed for this model`)或"必须大于 N",网关会自动按上游要求修正并**重发一次**,并把这个值记在适配器实例上(后续请求不再多跑一轮);日志会提示建议把它写进 `params`。管理员已写死的值不会被自动改掉(冲突时只记日志)。 此外还有一层运行时兜底:上游若回 400 说某参数"只允许 X"(`invalid temperature: only 1 is allowed for this model`)或"必须大于 N",网关会自动按上游要求修正并**重发一次**,并把这个值记在适配器实例上(后续请求不再多跑一轮);日志会提示建议把它写进 `params`。管理员已写死的值不会被自动改掉(冲突时只记日志)。
### 路由别名 + 按「可用 + 速度」动态排序 + 熔断 ### 三线直传(chat/completions · messages · responses)+ 熔断
(第十一轮 #4:`wjd` 不再按配置里的数组优先级,改为运行时挑可用且最快的文本模型先调用;详见下方路由说明)
三条协议线各有自己的入口,**入站格式 = 出站格式**:网关只做四件事 —— 鉴权、挑供应商、
定点改 `model` 与强制参数、把响应(含 SSE)原样推回并读 usage 记账。**不做跨格式翻译**:
把 chat 线的模型打到 `/messages` 上,上游回的是 `500 Internal server error`;把 messages
线的模型打到 `/responses` 上回的是 `401 not supported for format` —— 两种都不像"格式选错",
所以网关**在入口直接 400** 并列出该模型实际支持哪些线,不让这种事拖成半天排查。
| 线 | 入站端点 | 出站鉴权 |
|---|---|---|
| `chat/completions` | `POST /v1/chat/completions` | `Authorization: Bearer` |
| `messages` | `POST /v1/messages` | `x-api-key` + `anthropic-version` |
| `responses` | `POST /v1/responses` | `Authorization: Bearer` |
模型支持哪几条线写在各供应商的 `models[].protocols`;**不声明 = 只认 `chat/completions`**
(Agnes / 火山方舟即如此,行为与改造前完全一致)。OpenCode Go 的 29 个文档模型按**实测**逐一
标线(`deepseek-v4.1-flash` / `deepseek-v4-pro` / `deepseek-v4-flash` / `deepseek-v4-flash-vision-exp`
三线全通)。`GET /v1/models` 会回 `protocols`,前端据此标格式。
**路由别名 `wjd` 已于第二十七轮(2026-09-18)整体删除**:不再有 `routes` 配置段、不再有
多模型 fallback、`/v1/models` 里也没有 `type: "route"` 条目。理由:三线直传下模型 id 必须与
协议线一一对应,再套一层"自动挑最快模型"的别名,会把调用方选定的格式与能力(视觉 / 工具 /
协议线)悄悄换掉。**要换模型就换 model id。** 老配置里残留的 `routes` 段会被忽略(日志一条
warning),不会让进程起不来。限流因此变成**两级:供应商 > 全局**。
```yaml ```yaml
routes:
wjd:
timeout: 60 # 单模型 60s 没出结果就切下一个(避免 20×120s 挂死)
retry: 1 # 每个模型试 1 次,失败立即切下一个
# wjd 链路 = 全部文本模型(新增/现有文本模型都必须加入)
models:
- "ark-code-latest" # 1) 火山方舟(最高优先级)
- "agnes-3.0-flash" # 2) Agnes 3.0
- "agnes-2.5-flash" # 3) Agnes 2.5
# ── 4-20) OpenCode Go 17 个文本模型(glm-5.3-flash…hy3,
# 完整列表见 data/gateway.yaml routes 段)──
circuit: # 供应商熔断 circuit: # 供应商熔断
enabled: true enabled: true
failure_threshold: 3 # 窗口内失败 ≥3 次即熔断 failure_threshold: 3 # 窗口内失败 ≥3 次即熔断
cooldown: 30 # 熔断持续 30 秒 cooldown: 30 # 熔断持续 30 秒
window: 10 # 滑动窗口 = 最近 N 次调用(按次数,非按时间) window: 10 # 滑动窗口 = 最近 N 次调用(按次数,非按时间)
``` ```
> **第二十七轮(2026-09-18):路由别名已整体删除** —— 下面这些路由相关修复
> (`fallback_total`、`route.retry`、`routes` 维度指标、路由级限流/超时、路由告警)
> 随之一起移除,保留为历史记录。
>
> v2.3:`window` 现在真正按**最近 N 次调用**生效(之前是写死 60 秒、配置无效)。判定 = 最近 `window` 次里失败数 ≥ `failure_threshold`。 > v2.3:`window` 现在真正按**最近 N 次调用**生效(之前是写死 60 秒、配置无效)。判定 = 最近 `window` 次里失败数 ≥ `failure_threshold`。
> >
> **修复(v2.5)**: > **修复(v2.5)**:
@@ -209,12 +224,30 @@ circuit: # 供应商熔断
> - **无可达风险(已加约束说明)**:`release_probe()` 不校验令牌归属,理论上可能误还并发请求的探测令牌;逐一核对全部调用点后**当前不可达**(同 tick 或 except 分支内无抛错源),已在 docstring 写明"仅令牌持有者、且放行与归还间不得有 await"的前置条件,并给出后续放宽方案(probe token 归属校验)。 > - **无可达风险(已加约束说明)**:`release_probe()` 不校验令牌归属,理论上可能误还并发请求的探测令牌;逐一核对全部调用点后**当前不可达**(同 tick 或 except 分支内无抛错源),已在 docstring 写明"仅令牌持有者、且放行与归还间不得有 await"的前置条件,并给出后续放宽方案(probe token 归属校验)。
> - 审计同时确认**无新问题**:`json_or_raise()` 空/非 JSON body 映射、`Message.to_upstream()` 多轮 function calling、`stream` 严格校验、`unhandled_error_guard` 位于最外层且 500 带 CORS、`release_probe` 常规路径与 `probe_timeout` 自愈、`videos_poll` 404 归还不计失败、`_get_adapter` 移入 try 后的 503/404 映射、`_spawn_bg` 强引用与 lifespan 等待、`_opt_int` 的 `default>=minimum` 逐处正确。测试数 78 → 84(补 4 项回归:标准参数最终 payload、图像额外参数、流式 `in_flight` 时机、`base_url` 缓存 key)。 > - 审计同时确认**无新问题**:`json_or_raise()` 空/非 JSON body 映射、`Message.to_upstream()` 多轮 function calling、`stream` 严格校验、`unhandled_error_guard` 位于最外层且 500 带 CORS、`release_probe` 常规路径与 `probe_timeout` 自愈、`videos_poll` 404 归还不计失败、`_get_adapter` 移入 try 后的 503/404 映射、`_spawn_bg` 强引用与 lifespan 等待、`_opt_int` 的 `default>=minimum` 逐处正确。测试数 78 → 84(补 4 项回归:标准参数最终 payload、图像额外参数、流式 `in_flight` 时机、`base_url` 缓存 key)。
调用时 `model` 填 `wjd`,网关按顺序尝试;某供应商连续失败会被熔断,期间快速跳过,让健康供应商顶上。 > **修复(v2.11 · 第二十七轮上线后复验)**:老板批准重启上线后,用真机活体检查(`live_check.py` + 真实 key)复验,
> 抓到 **3 个本轮新引入的缺陷**(其中 2 个是"改了 A 处、漏了 B 处"的接线漏改),已全部修复并补测试:
> - **【P0】三线直传入门即 500**:`_passthrough()` 里调用 `_enforce_rate_limit()` 时多传了一个参数(5 参 vs 函数 4 参),
> 于是**每一次** `POST /v1/messages` / `POST /v1/responses` 都以 `TypeError` → 500「网关内部错误」结束 ——
> 正好是本轮的核心功能。真机表现为两条线全灭(chat/completions 线不受影响)。
> - **【P0】`GET /metrics/prometheus` 500**:导出器还在读 `snapshot["fallback_total"]`,而该字段已随路由/fallback 链删除
> → `KeyError`。Prometheus 抓取全断(`/metrics` JSON 不受影响)。已连同它的 HELP/TYPE 声明一起清掉,
> 并加断言:**导出的指标必须有 HELP 声明**(防"声明与导出脱节")。
> - **【P0】图像 / 视频的 token 全部没发出去**:本轮把鉴权头改成"按协议线在 `_req_headers` 里组装"后,
> `create_adapter` 不再往静态 headers 里塞 `Authorization`,而媒体三个调用点(图像生成 / 视频创建 / 视频轮询)
> 仍在用 `self._headers` ⇒ 出站请求一个鉴权头都没有。真机表现:`POST /v1/images/generations` 上游
> 401「未提供令牌」(同一个 key 直接 curl 同一个地址是 **200**)。已加 `_media_headers()` 统一补回。
> - **测试基建(本轮漏检的根因之一)**:`tests/test_gateway.py` 的 `if __name__ == "__main__"` 运行块被夹在
> **文件中间**,运行器只收集"执行到该行时已存在"的 globals ⇒ 定义在它之后的测试在 `make test`(脚本模式)下
> 根本不会跑(`test_image_request_goes_to_requested_model` 白写了一轮)。已把运行块移到文件末尾,
> 并补齐 /v1/messages、/v1/responses 的**真发请求**测试(此前零覆盖)。测试数 **165 → 173**,全部通过。
> - 复验结论:`live_check.py` **19 PASS / 0 FAIL / 0 WARN**(含三线直传真实 200、跨线 400、图像生成 200、
> Prometheus 200);图像下载 `/v1/media/download` 实测 560KB PNG 落地正常。
### 鉴权(页面账号体系 + 每账号 API Key) ### 鉴权(页面账号体系 + 每账号 API Key)
鉴权**不写在配置文件里**:账号、密码、API Key 全部由管理台页面维护,持久化在 `data/users.json` 鉴权**不写在配置文件里**:账号、密码、API Key 全部由管理台页面维护,持久化在 `data/users.json`
(密码 PBKDF2 哈希、Key SHA-256 哈希,均不落明文;文件权限 600 且已加入 `.gitignore`)。 (密码只存 PBKDF2 哈希;Key 存 SHA-256 哈希用于鉴权,**另存一份明文**以便页面随时再复制 —— 取舍见下方
「Key 明文回显」;文件权限 600 且已加入 `.gitignore`)。
`data/gateway.yaml` 只剩 `auth.session_ttl_minutes`(会话时长,默认 1440 分钟)一项。 `data/gateway.yaml` 只剩 `auth.session_ttl_minutes`(会话时长,默认 1440 分钟)一项。
```yaml ```yaml
@@ -356,11 +389,13 @@ python run.py # 启动时自动读取 .env
| `GET` | `/` | 否 | 端点导航 | | `GET` | `/` | 否 | 端点导航 |
| `GET` | `/health` | 否(可开) | 运维看板:uptime/失败率/耗时/熔断状态 | | `GET` | `/health` | 否(可开) | 运维看板:uptime/失败率/耗时/熔断状态 |
| `GET` | `/health/{provider}` | 否(可开) | 供应商探活 | | `GET` | `/health/{provider}` | 否(可开) | 供应商探活 |
| `GET` | `/models` / `/v1/models` | 是 | 全部模型 + 路由别名 + 供应商 | | `GET` | `/models` / `/v1/models` | 是 | 全部模型(含视觉位与支持的协议线)+ 供应商 |
| `POST` | `/v1/chat/completions` | 是 | 主接口(fallback + 流式 + 熔断 + 三级限流 + 成本) | | `POST` | `/v1/chat/completions` | 是 | 主接口(chat/completions 线:流式 + 熔断 + 两级限流 + 成本) |
| `POST` | `/v1/messages` | 是 | Anthropic `messages` 线直传(同方协议原样进出) |
| `POST` | `/v1/responses` | 是 | OpenAI `responses` 线直传 |
| `POST` | `/v1/chat/completions/batch` | 是 | 并发多 prompt | | `POST` | `/v1/chat/completions/batch` | 是 | 并发多 prompt |
| `POST` | `/v1/images/generations` | 是 | 图像生成(支持路由别名) | | `POST` | `/v1/images/generations` | 是 | 图像生成(`model` 填真实模型 id) |
| `POST` | `/v1/videos` | 是 | 视频创建(`wait`/`callback_url`,支持路由别名) | | `POST` | `/v1/videos` | 是 | 视频创建(`wait`/`callback_url`) |
| `GET` | `/v1/videos/{id}` | 是 | 视频轮询(`?wait=true`) | | `GET` | `/v1/videos/{id}` | 是 | 视频轮询(`?wait=true`) |
| `GET` | `/metrics` | 是 | 用量统计(JSON,含熔断状态) | | `GET` | `/metrics` | 是 | 用量统计(JSON,含熔断状态) |
| `GET` | `/metrics/prometheus` | 是 | Prometheus 文本格式 | | `GET` | `/metrics/prometheus` | 是 | Prometheus 文本格式 |
@@ -384,19 +419,19 @@ python run.py # 启动时自动读取 .env
> 「仅会话」= 只接受账号密码登录换来的 `sess-` token,用 API Key 调用返回 403(见上文吊销语义)。 > 「仅会话」= 只接受账号密码登录换来的 `sess-` token,用 API Key 调用返回 403(见上文吊销语义)。
> 媒体端点的 `model` 可以填**路由别名**(如 `wjd`):网关会自动解析到该路由链里第一个 `type==image/video` 的模型,找不到才 404。 > 媒体端点的 `model` 必须是**真实模型 id**(第二十七轮起路由别名已删除,不再有别名解析)。
## 关键行为说明(v2.4) ## 关键行为说明(v2.4)
- **三级限流**:路由级 `routes.<name>.rate_limit_rps` > 供应商级 `providers.<key>.rate_limit_rps` > 全局 `server.rate_limit_rps`。路由/供应商级按独立桶分桶,打满则 429;chat 接口下打满会切下一个模型而不是直接 429。 - **两级限流**:供应商级 `providers.<key>.rate_limit_rps` > 全局 `server.rate_limit_rps`。供应商级按独立桶分桶,打满则 429(chat / 媒体共用 `prov:<pkey>` 桶);路由级限流随路由功能删除。
- **媒体端点也限流**(v2.3 / v2.6 修正):`/v1/images`、`/v1/videos` 按 `providers.<key>.rate_limit_rps` 的**供应商桶**限流,与 chat 共用同一个 `prov:<pkey>` 桶(v2.6 起媒体不再另起 `media:prov:<key>` 独立桶 —— 那样实际放行量会翻倍、与文档不符)。高成本资源不再裸奔。 - **媒体端点也限流**(v2.3 / v2.6 修正):`/v1/images`、`/v1/videos` 按 `providers.<key>.rate_limit_rps` 的**供应商桶**限流,与 chat 共用同一个 `prov:<pkey>` 桶(v2.6 起媒体不再另起 `media:prov:<key>` 独立桶 —— 那样实际放行量会翻倍、与文档不符)。高成本资源不再裸奔。
- **route.timeout 全链生效**(v2.3):配了 `routes.<name>.timeout` 后,**整条链(含链首最高优先级模型)统一用这个超时**;之前只对兜底模型生效、链首仍用 `server.timeout`。 - **协议线闸门**(第二十七轮):`POST /v1/messages`、`/v1/responses` 只放行声明了对应线的模型,否则 400 并列出该模型支持的线;网关不做跨格式翻译。
- **熔断按次数窗口**(v2.3):`circuit.window` 现在真正按"最近 N 次调用"滑动(之前写死 60 秒、配置无效)。判定 = 最近 window 次里失败 ≥ failure_threshold。 - **熔断按次数窗口**(v2.3):`circuit.window` 现在真正按"最近 N 次调用"滑动(之前写死 60 秒、配置无效)。判定 = 最近 window 次里失败 ≥ failure_threshold。
- **失败也算耗时**:`/metrics` 的 P50/P95 包含失败请求的等待时间。 - **失败也算耗时**:`/metrics` 的 P50/P95 包含失败请求的等待时间。
- **in_flight 精确统计**(v2.4):按响应**实际类型**(`StreamingResponse`)判断流式,非流式/413/502 在中间件减计数,SSE 流式在生成器收尾减计数。修复了"3MB 的流式 POST 被 413 后 in_flight 永久 +1"的泄漏。 - **in_flight 精确统计**(v2.4):按响应**实际类型**(`StreamingResponse`)判断流式,非流式/413/502 在中间件减计数,SSE 流式在生成器收尾减计数。修复了"3MB 的流式 POST 被 413 后 in_flight 永久 +1"的泄漏。
- **适配器 client 并发安全**(v2.4):`get_client()` 加 `asyncio.Lock`,并发下只建一个 client(之前竞态建多个泄漏 fd);`close()` 幂等可重入(之前并发 double-close 抛 `Event loop is closed`)。 - **适配器 client 并发安全**(v2.4):`get_client()` 加 `asyncio.Lock`,并发下只建一个 client(之前竞态建多个泄漏 fd);`close()` 幂等可重入(之前并发 double-close 抛 `Event loop is closed`)。
- **图像 size 缺省 1K**(v2.4):`/v1/images/generations` 不传 size 时默认最低档 `1K`,避免 Agnes 因缺 size 返回 400;`n=1` 时省略该字段(Agnes 一次一张)。 - **图像 size 缺省 1K**(v2.4):`/v1/images/generations` 不传 size 时默认最低档 `1K`,避免 Agnes 因缺 size 返回 400;`n=1` 时省略该字段(Agnes 一次一张)。
- **热重载真正生效**:改 `circuit` / `observability` / `metrics` / `auth` / `routes` / `pricing` 即时重建运行时对象;日志级别/JSON 格式热改也真能生效;`uptime_seconds` 因热重载不会清零。 - **热重载真正生效**:改 `circuit` / `observability` / `metrics` / `auth` / `pricing` / 模型与协议线即时重建运行时对象;日志级别/JSON 格式热改也真能生效;`uptime_seconds` 因热重载不会清零。
- **优雅关闭**:`server.graceful_shutdown` 传给 uvicorn `timeout_graceful_shutdown`,收到停止信号时先排空在途请求再退出。**(v2.8 重要修复)**:lifespan 里曾用 `loop.add_signal_handler` 注册自己的 SIGTERM/SIGINT 处理器,把 **uvicorn 自己的处理器覆盖掉了**,导致 `SIGTERM`/`SIGINT` 完全无法停服(实测发信号后 10s+ 仍存活,只能 `kill -9`)。现已移除该注册,交给 uvicorn 处理;实测 SIGTERM 后 0.5s 内完成 `Shutting down → 应用收尾 → Finished`。 - **优雅关闭**:`server.graceful_shutdown` 传给 uvicorn `timeout_graceful_shutdown`,收到停止信号时先排空在途请求再退出。**(v2.8 重要修复)**:lifespan 里曾用 `loop.add_signal_handler` 注册自己的 SIGTERM/SIGINT 处理器,把 **uvicorn 自己的处理器覆盖掉了**,导致 `SIGTERM`/`SIGINT` 完全无法停服(实测发信号后 10s+ 仍存活,只能 `kill -9`)。现已移除该注册,交给 uvicorn 处理;实测 SIGTERM 后 0.5s 内完成 `Shutting down → 应用收尾 → Finished`。
- **OpenAI 全兼容**(v2.2):响应带 `created` / `system_fingerprint`,流式末尾带 `usage` 块,错误为 `{"error":{message,type,code}}`,`/v1/models` 标准端点——OpenAI 官方 SDK 零适配直连。 - **OpenAI 全兼容**(v2.2):响应带 `created` / `system_fingerprint`,流式末尾带 `usage` 块,错误为 `{"error":{message,type,code}}`,`/v1/models` 标准端点——OpenAI 官方 SDK 零适配直连。
@@ -411,10 +446,15 @@ curl -X POST http://localhost:8808/v1/chat/completions \
-H "$AUTH" -H "Content-Type: application/json" \ -H "$AUTH" -H "Content-Type: application/json" \
-d '{"model":"agnes-3.0-flash","messages":[{"role":"user","content":"你好"}],"max_tokens":256}' -d '{"model":"agnes-3.0-flash","messages":[{"role":"user","content":"你好"}],"max_tokens":256}'
# 路由别名 wjd(运行时挑可用 + 最快文本模型优先,其余按速度顺序 fallback + 熔断) # 换模型 = 换 model id(第二十七轮起没有路由别名,网关不会替你挑模型)
curl -X POST http://localhost:8808/v1/chat/completions \ curl -X POST http://localhost:8808/v1/chat/completions \
-H "$AUTH" -H "Content-Type: application/json" \ -H "$AUTH" -H "Content-Type: application/json" \
-d '{"model":"wjd","messages":[{"role":"user","content":"hi"}]}' -d '{"model":"deepseek-v4.1-flash","messages":[{"role":"user","content":"hi"}]}'
# Anthropic messages 线(同方协议直传,鉴权头换成 x-api-key)
curl -X POST http://localhost:8808/v1/messages \
-H "$AUTH" -H "Content-Type: application/json" \
-d '{"model":"deepseek-v4.1-flash","max_tokens":64,"messages":[{"role":"user","content":"hi"}]}'
# 并发多 prompt(batch) # 并发多 prompt(batch)
curl -X POST http://localhost:8808/v1/chat/completions/batch \ curl -X POST http://localhost:8808/v1/chat/completions/batch \
@@ -451,10 +491,10 @@ curl "http://localhost:8808/v1/videos/<video_id>?model=agnes-video-2.5-flash&wai
- 里程碑:**M1** 登录 + 网关托管 + 去掉批量页(构建栈 Vue 3 + Vite + TS + Element Plus + - 里程碑:**M1** 登录 + 网关托管 + 去掉批量页(构建栈 Vue 3 + Vite + TS + Element Plus +
ECharts + Pinia + Vue Router + marked)。JS 主包约 1.2MB,分包/按需引入留给 M5。 ECharts + Pinia + Vue Router + marked)。JS 主包约 1.2MB,分包/按需引入留给 M5。
- 里程碑:**M2** 对话 Playground(`/web/#/chat`):流式/非流式对话(fetch 直连 - 里程碑:**M2** 对话 Playground(`/web/#/chat`):流式/非流式对话(fetch 直连
`/v1/chat/completions` 解析 SSE)、模型/路由选择(路由显示完整降级链)、参数面板 `/v1/chat/completions` 解析 SSE)、模型选择(第二十七轮起是模型 + 协议线,不再有路由别名)、参数面板
(temperature / top_p / max_tokens / 流式开关 / 系统提示词)、Markdown+代码高亮渲染 (temperature / top_p / max_tokens / 流式开关 / 系统提示词)、Markdown+代码高亮渲染
(marked + highlight.js + DOMPurify 消毒)、推理折叠(`reasoning_content` 单独折叠)、 (marked + highlight.js + DOMPurify 消毒)、推理折叠(`reasoning_content` 单独折叠)、
降级可视化(meta 帧的 served/provider/fallback_used 徽标)、token/成本展示(流式 usage 服务信息徽标(meta 帧的 served/provider;`fallback_used` 随路由功能删除)、token/成本展示(流式 usage
帧现也带 `estimated_cost_cny`)、会话历史 sessionStorage 持久、Enter 发送/Shift+Enter 换行。 帧现也带 `estimated_cost_cny`)、会话历史 sessionStorage 持久、Enter 发送/Shift+Enter 换行。
- 里程碑:**M3** 图像页面(`/web/#/images`)+ 视频页面(`/web/#/videos`): - 里程碑:**M3** 图像页面(`/web/#/images`)+ 视频页面(`/web/#/videos`):
图像生成网格(`/v1/images/generations`,url/base64 均可显示、el-image 大图预览、耗时/供应商标注、 图像生成网格(`/v1/images/generations`,url/base64 均可显示、el-image 大图预览、耗时/供应商标注、
@@ -467,7 +507,7 @@ curl "http://localhost:8808/v1/videos/<video_id>?model=agnes-video-2.5-flash&wai
- 里程碑:**M4** 仪表盘图表打磨 + 指标页 + 日志页(引入 ECharts,`src/components/EChart.vue` - 里程碑:**M4** 仪表盘图表打磨 + 指标页 + 日志页(引入 ECharts,`src/components/EChart.vue`
封装 + `src/lib/echarts.ts` tree-shake 按需注册): 封装 + `src/lib/echarts.ts` tree-shake 按需注册):
仪表盘新增供应商份额饼图 + 模型延迟 P50/P95 柱图;指标页(`/web/#/metrics`)含指标卡 仪表盘新增供应商份额饼图 + 模型延迟 P50/P95 柱图;指标页(`/web/#/metrics`)含指标卡
(已运行/在途/降级/双 token/调用比)+ 各模型 ok/fail 堆叠柱图 + 供应商份额 + 路由 vs 供应商 (已运行/在途/双 token/调用比)+ 各模型 ok/fail 堆叠柱图 + 供应商份额 + 按供应商成功/失败
堆叠 + 延迟 P50/P95 + 熔断器状态表(自动刷新 8s);日志页(`/web/#/logs`)展示最近 200 条 堆叠 + 延迟 P50/P95 + 熔断器状态表(自动刷新 8s);日志页(`/web/#/logs`)展示最近 200 条
`/logs` 访问日志(方法/路径/供应商/实际模型/OK-FAIL/SSE/调用方/rid/错误),支持方法、结果、 `/logs` 访问日志(方法/路径/供应商/实际模型/OK-FAIL/SSE/调用方/rid/错误),支持方法、结果、
关键字筛选与自动刷新 5s。EChart 共享分包约 594kB。 关键字筛选与自动刷新 5s。EChart 共享分包约 594kB。
@@ -628,7 +668,7 @@ curl "http://localhost:8808/v1/videos/<video_id>?model=agnes-video-2.5-flash&wai
- **图表文字挤压修复**:ECharts 6 把 legend 默认位置从 top 改为 bottom,导致图例压在 - **图表文字挤压修复**:ECharts 6 把 legend 默认位置从 top 改为 bottom,导致图例压在
x 轴标签上。新增 `src/lib/charts.ts` 统一 `legend(top:0)` / 类目轴截断+倾斜+hideOverlap / x 轴标签上。新增 `src/lib/charts.ts` 统一 `legend(top:0)` / 类目轴截断+倾斜+hideOverlap /
`grid.containLabel` 留白,仪表盘与指标页 4 类图全部接入。 `grid.containLabel` 留白,仪表盘与指标页 4 类图全部接入。
- **模型与供应商页**(`/web/#/models`):指标卡(模型/文本/图像/视频/路由/供应商)+ 路由别名表 - **模型与供应商页**(`/web/#/models`):指标卡(模型/文本/图像/视频/供应商)+ 模型清单(ID/类型/供应商/视觉/延迟,一键测速按模型自己的协议线探测),数据来自 `/v1/models` + `/health`。(第二十七轮:路由别名表已随功能删除)
(降级链逐 tag 展示、供应商数)+ 模型清单(ID/类型/供应商/Key 已配),数据来自 `/v1/models` + `/health`。 (降级链逐 tag 展示、供应商数)+ 模型清单(ID/类型/供应商/Key 已配),数据来自 `/v1/models` + `/health`。
- **多语言(M5+)**:Vue I18n + `src/locales/zh|en.ts`,全站中英可切换;语言按钮在头部与登录页、设置页 - **多语言(M5+)**:Vue I18n + `src/locales/zh|en.ts`,全站中英可切换;语言按钮在头部与登录页、设置页
(`settings.language`),存 `localStorage.gw_locale`、默认中文;Element Plus 语言包经 (`settings.language`),存 `localStorage.gw_locale`、默认中文;Element Plus 语言包经
@@ -745,7 +785,7 @@ curl "http://localhost:8808/v1/videos/<video_id>?model=agnes-video-2.5-flash&wai
> - **清空/清除类操作补二次确认**:视频页「清除已完成」、图像页「清空历史」都是**服务端真删且不可逆** > - **清空/清除类操作补二次确认**:视频页「清除已完成」、图像页「清空历史」都是**服务端真删且不可逆**
> (不是只清本地视图),原先点一下就没了。现在弹确认框并写明条数与后果(另:视频页没东西可清时按钮置灰)。 > (不是只清本地视图),原先点一下就没了。现在弹确认框并写明条数与后果(另:视频页没东西可清时按钮置灰)。
> - **设置 → 关于去掉文档外链**(不再往外部站点跳),同时删掉对应 i18n 键。 > - **设置 → 关于去掉文档外链**(不再往外部站点跳),同时删掉对应 i18n 键。
> - **API 密钥页新增「API 调用说明」**:接口地址(复制按钮)· 鉴权头 · 模型选择(`wjd` 路由别名 vs 真实模型 id)· > - **API 密钥页新增「API 调用说明」**:接口地址(复制按钮)· 鉴权头 · 模型选择(填真实模型 id;路由别名已于第二十七轮删除)·
> 请求格式 · 常用端点表(与 `app/main.py` 的真实路由一一对应)· 四段可直接复制的示例 > 请求格式 · 常用端点表(与 `app/main.py` 的真实路由一一对应)· 四段可直接复制的示例
> (对话 / 图像 / 视频提交+轮询 / Python OpenAI SDK)· 七条注意事项(n=1、seconds 4–12、 > (对话 / 图像 / 视频提交+轮询 / Python OpenAI SDK)· 七条注意事项(n=1、seconds 4–12、
> 轮询别快于 5s、素材可用 data URI 但请求体 <2MB、Key 调管理接口 403、Key 泄漏处置、审计归属)。 > 轮询别快于 5s、素材可用 data URI 但请求体 <2MB、Key 调管理接口 403、Key 泄漏处置、审计归属)。
@@ -782,8 +822,8 @@ curl "http://localhost:8808/v1/videos/<video_id>?model=agnes-video-2.5-flash&wai
> 熔断桶与调用指标都不动,前端按退避继续轮(页面轮询间隔保持 5s,不按文档建议的 1~2s,正是为了不撞限流)。 > 熔断桶与调用指标都不动,前端按退避继续轮(页面轮询间隔保持 5s,不按文档建议的 1~2s,正是为了不撞限流)。
> - **视觉能力位**:`/v1/models` 新增 `vision`(`agnes-3.0-flash` = true,即文档里的"输入模态:文本、图像 URL"; > - **视觉能力位**:`/v1/models` 新增 `vision`(`agnes-3.0-flash` = true,即文档里的"输入模态:文本、图像 URL";
> OpenCode Go 侧 `deepseek-v4.1-flash` 与 `deepseek-v4-flash-vision-exp` 实测同为 true); > OpenCode Go 侧 `deepseek-v4.1-flash` 与 `deepseek-v4-flash-vision-exp` 实测同为 true);
> **带图请求走路由别名 `wjd` 时把视觉模型排到链首**(否则链首的纯文本模型要么忽略图片、要么报参数错误, > **带图请求不再重排模型**(第二十七轮:路由链已整体删除,网关不替用户换模型)——选了不支持视觉
> 两种都极难自查);直接指定真实模型时不改用户选择。 > 的模型就照原样发上去,前端提前给告警条并提供一键切换,网关侧只记一条日志。
> - 回归测试新增 6 组(vision 暴露 / 视觉优先重排 / 带图块识别 / 图像 n 拦截 / 图像 4xx·5xx 分流 / > - 回归测试新增 6 组(vision 暴露 / 视觉优先重排 / 带图块识别 / 图像 n 拦截 / 图像 4xx·5xx 分流 /
> 视频 videos·size·aspect·n 校验 / 轮询 429),单测 **124 passed / 0 failed**、pyflakes 0; > 视频 videos·size·aspect·n 校验 / 轮询 429),单测 **124 passed / 0 failed**、pyflakes 0;
> 前端 `npm run typecheck`(vue-tsc)**0 error** —— 顺手补了 element-plus 语言包的模块声明、 > 前端 `npm run typecheck`(vue-tsc)**0 error** —— 顺手补了 element-plus 语言包的模块声明、
@@ -1191,7 +1231,7 @@ curl "http://localhost:8808/v1/videos/<video_id>?model=agnes-video-2.5-flash&wai
## 测试 ## 测试
```bash ```bash
# 单元测试(mock 供应商,不依赖真实网络,覆盖配置/路由/熔断/适配器/端点) # 单元测试(mock 供应商,不依赖真实网络,覆盖配置/协议线/熔断/适配器/端点)
python tests/test_gateway.py python tests/test_gateway.py
# 或 # 或
pytest tests/ -q pytest tests/ -q
@@ -1203,12 +1243,12 @@ pytest tests/ -q
# 冒烟:健康 / 模型列表 / chat / batch / 错误格式(网关未起或无 key 时优雅 SKIP) # 冒烟:健康 / 模型列表 / chat / batch / 错误格式(网关未起或无 key 时优雅 SKIP)
python smoke_test.py --url http://127.0.0.1:8808 python smoke_test.py --url http://127.0.0.1:8808
# 活体检查:真实上游(Agnes / 火山方舟)跑 14 项端到端行为校验,含路由 fallback、 # 活体检查:真实上游(Agnes / 火山方舟 / OpenCode Go)端到端行为校验,含三线直传与跨线 400、
# 流式 SSE、413、CORS 预检、图像生成等 # 流式 SSE、413、CORS 预检、图像生成等
python live_check.py --url http://127.0.0.1:8808 python live_check.py --url http://127.0.0.1:8808
``` ```
> 当前状态:单元测试 **168 passed / 0 failed**(`python tests/test_gateway.py`,不需要 pytest);冒烟 5/5 PASS;活体检查 14 PASS / 0 FAIL / 0 WARN。 > 当前状态:单元测试 **165 passed / 0 failed**(`python tests/test_gateway.py`,不需要 pytest);冒烟 5/5 PASS;活体检查 14 PASS / 0 FAIL / 0 WARN。
## 备注 ## 备注
+9 -2
View File
@@ -12,13 +12,17 @@ def create_adapter(
) -> BaseAdapter: ) -> BaseAdapter:
"""根据供应商配置创建对应适配器。 """根据供应商配置创建对应适配器。
当前三个供应商(Agnes / 火山方舟 / OpenCode Go)均为 OpenAI 兼容协议, 当前四个供应商(Agnes / 火山方舟 / OpenCode Go)均为 OpenAI 兼容协议,
统一使用 OpenAICompatAdapter,通过 base_url 和 extra_headers 区分。 统一使用 OpenAICompatAdapter,通过 base_url 和 extra_headers 区分。
图像/视频端点通过 media 配置覆盖(Agnes 走 /videos + /agnesapi)。 图像/视频端点通过 media 配置覆盖(Agnes 走 /videos + /agnesapi)。
OpenCode Go 由 requires_session_header 触发每请求动态注入 x-opencode-session。 OpenCode Go 由 requires_session_header 触发每请求动态注入 x-opencode-session。
第二十七轮(三线直传): 鉴权头不再在这里拼死,而是把裸 token + 供应商的
`endpoints`(每条线的路径/鉴权方式/固定头)交给适配器,由它在**每次请求**时按
入站协议线组装(OpenCode Go 的 messages 线认 x-api-key,另两条线认 Bearer)。
这样同一个供应商的三条线共用一个适配器与连接池,也不需要在缓存 key 里区分协议。
""" """
headers = { headers = {
"Authorization": f"Bearer {token}",
"Content-Type": "application/json", "Content-Type": "application/json",
} }
headers.update(pconfig.extra_headers) headers.update(pconfig.extra_headers)
@@ -36,4 +40,7 @@ def create_adapter(
# 不会出现"主链路修了、测速还漏着"的偏差。 # 不会出现"主链路修了、测速还漏着"的偏差。
# 配置变更时 main._apply_config 会丢弃整个适配器缓存,约束不会滞留旧值。 # 配置变更时 main._apply_config 会丢弃整个适配器缓存,约束不会滞留旧值。
model_params={m.id: dict(m.params) for m in pconfig.models if m.params}, 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 logging
import re import re
import uuid import uuid
from contextlib import asynccontextmanager
from typing import Any, AsyncIterator from typing import Any, AsyncIterator
import httpx import httpx
from app.adapters.base import BaseAdapter, json_or_raise 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 from app.models import CHAT_CORE_KEYS, PROTECTED_VIDEO_KEYS, strip_protected
log = logging.getLogger("api-gateway") log = logging.getLogger("api-gateway")
@@ -38,7 +44,13 @@ _PARAM_MIN_RE = re.compile(
class OpenAICompatAdapter(BaseAdapter): class OpenAICompatAdapter(BaseAdapter):
"""适用于所有 OpenAI 兼容 /chat/completions 端点的适配器。""" """适用于所有 OpenAI 兼容 /chat/completions 端点的适配器。
第二十七轮(三线直传)后它同时承担**协议直传**职责:同一家供应商的三条线
(chat/completions、messages、responses)共用这一个适配器、共用一个连接池,
差别只在「路径 + 鉴权头」——由 provider 的 `endpoints` 配置提供(见 config.EndpointSpec)。
直传路径**不翻译任何内容**:入站 body 原样出去,上游响应原样回来。
"""
def __init__( def __init__(
self, self,
@@ -49,9 +61,17 @@ class OpenAICompatAdapter(BaseAdapter):
media=None, media=None,
requires_session_header: bool = False, requires_session_header: bool = False,
model_params: dict[str, dict[str, Any]] | None = None, 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) super().__init__(name=name, base_url=base_url, timeout=timeout, media=media)
self._headers: dict[str, str] = headers or {} 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。 # OpenCode Go 要求每个 /chat/completions 带稳定 x-opencode-session。
# 不能放静态 headers(_get_adapter 会缓存适配器、冻结 header), # 不能放静态 headers(_get_adapter 会缓存适配器、冻结 header),
# 所以在每次请求时动态生成一个 UUID 会话头。 # 所以在每次请求时动态生成一个 UUID 会话头。
@@ -64,6 +84,45 @@ class OpenAICompatAdapter(BaseAdapter):
# 仅作兜底 —— 管理员在 gateway.yaml 写死 params 后就不再需要它。 # 仅作兜底 —— 管理员在 gateway.yaml 写死 params 后就不再需要它。
self._learned_params: dict[str, dict[str, Any]] = {} 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]: def _forced_params(self, model: str) -> dict[str, Any]:
@@ -128,19 +187,103 @@ class OpenAICompatAdapter(BaseAdapter):
model, changed) model, changed)
return self._forced_params(model) return self._forced_params(model)
def _req_headers(self, session_id: str | None = None) -> dict[str, str]: def _req_headers(self, session_id: str | None = None,
"""每次请求的 headers。需要会话头的供应商动态注入 x-opencode-session。 protocol: str = PROTOCOL_CHAT) -> dict[str, str]:
"""每次请求的 headers:静态头 + 本条线的鉴权头 + 会话头。
session_id 由调用方传入(网关把对话的 conversation_id 透传过来): session_id 由调用方传入(网关把对话的 conversation_id 透传过来):
- 有 → 同一段对话的所有请求共用同一个 session(吃到上游提示词缓存); - 有 → 同一段对话的所有请求共用同一个 session(上游据此做路由与缓存);
- 无 → 回退为每请求一个随机 UUID(仍能过上游的强校验,只是没有缓存收益)。 - 无 → 回退为每请求一个随机 UUID(仍能过上游的强校验,只是没有缓存收益)。
第二十七轮实测:OpenCode Go 的**三条线都硬性要求该头**(缺任一条 → 400
MissingSessionID),所以注入逻辑与协议线无关,统一在这里做。
""" """
if not self._requires_session:
return self._headers
headers = dict(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 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( def _build_payload(
self, self,
model: str, model: str,
@@ -214,7 +357,8 @@ class OpenAICompatAdapter(BaseAdapter):
"""执行一次非流式 /chat/completions 请求(不含参数修正逻辑)。""" """执行一次非流式 /chat/completions 请求(不含参数修正逻辑)。"""
# Bug 4 修复: 用 lease 占用 client,热重载 close 会等本次请求结束才真正关连接 # Bug 4 修复: 用 lease 占用 client,热重载 close 会等本次请求结束才真正关连接
async with self._lease() as client: 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() resp.raise_for_status()
data = json_or_raise(resp) data = json_or_raise(resp)
@@ -269,7 +413,8 @@ class OpenAICompatAdapter(BaseAdapter):
# Bug 4 修复: lease 在整个流式期间持有占用,热重载/关闭不会掐断在途流 # Bug 4 修复: lease 在整个流式期间持有占用,热重载/关闭不会掐断在途流
async with self._lease() as client: async with self._lease() as client:
async with client.stream( 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: ) as resp:
resp.raise_for_status() resp.raise_for_status()
async for line in resp.aiter_lines(): async for line in resp.aiter_lines():
@@ -316,7 +461,7 @@ class OpenAICompatAdapter(BaseAdapter):
payload["extra_body"] = extra_body payload["extra_body"] = extra_body
async with self._lease() as client: 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() resp.raise_for_status()
data = json_or_raise(resp) data = json_or_raise(resp)
# 统一:返回 data 数组 # 统一:返回 data 数组
@@ -350,7 +495,7 @@ class OpenAICompatAdapter(BaseAdapter):
payload[k] = v payload[k] = v
async with self._lease() as client: 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() resp.raise_for_status()
data = json_or_raise(resp) data = json_or_raise(resp)
# video_id 用于查询;id/task_id 是任务 id # video_id 用于查询;id/task_id 是任务 id
@@ -372,7 +517,7 @@ class OpenAICompatAdapter(BaseAdapter):
# 轮询用绝对 URL(poll_base 可能是去掉 /v1 的域名根) # 轮询用绝对 URL(poll_base 可能是去掉 /v1 的域名根)
url = poll_base.rstrip("/") + poll_path url = poll_base.rstrip("/") + poll_path
async with self._lease() as client: 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() resp.raise_for_status()
data = json_or_raise(resp) data = json_or_raise(resp)
return {"raw": data} return {"raw": data}
+207 -81
View File
@@ -1,7 +1,8 @@
"""配置加载模块:从 YAML 文件读取供应商、模型、路由、鉴权、运维配置。""" """配置加载模块:从 YAML 文件读取供应商、模型、鉴权、运维配置。"""
from __future__ import annotations from __future__ import annotations
import logging
import os import os
from dataclasses import dataclass, field from dataclasses import dataclass, field
from pathlib import Path from pathlib import Path
@@ -9,6 +10,8 @@ from typing import Any
import yaml import yaml
log = logging.getLogger("gateway.config")
class ConfigError(ValueError): 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 @dataclass
class ModelInfo: class ModelInfo:
id: str id: str
@@ -36,7 +98,7 @@ class ModelInfo:
# 第十三轮: 是否支持「图像输入」(多模态 / 视觉)。 # 第十三轮: 是否支持「图像输入」(多模态 / 视觉)。
# Agnes 3.0 Flash 文档明确「输入模态:文本、图像 URL」,实测 data:image/png;base64 也能识别; # Agnes 3.0 Flash 文档明确「输入模态:文本、图像 URL」,实测 data:image/png;base64 也能识别;
# 其余文本模型(ark-code 等)文档未声明图像输入 → 默认 False。 # 其余文本模型(ark-code 等)文档未声明图像输入 → 默认 False。
# 用途:① /v1/models 暴露给前端标注/告警;② 带图请求走路由别名时把有视觉能力的模型排到前面。 # 用途:① /v1/models 暴露给前端标注/告警;② 前端据此提示「换个支持视觉的模型」力的模型排到前面。
vision: bool = False vision: bool = False
# 第二十五轮(模型参数硬约束): 该模型**必须用**的上游参数,发送前强制覆盖客户端传值。 # 第二十五轮(模型参数硬约束): 该模型**必须用**的上游参数,发送前强制覆盖客户端传值。
# 背景:OpenCode Go 的 kimi-k2.7-code 只接受 temperature=1,客户端传 0(含一键测速的 # 背景:OpenCode Go 的 kimi-k2.7-code 只接受 temperature=1,客户端传 0(含一键测速的
@@ -46,6 +108,17 @@ class ModelInfo:
# 拉到 0 也不会再 400(值被网关改成上游唯一允许的那个)。 # 拉到 0 也不会再 400(值被网关改成上游唯一允许的那个)。
# 键必须在 MODEL_PARAM_KEYS 白名单内,否则 validate_config 直接报错(不静默失效)。 # 键必须在 MODEL_PARAM_KEYS 白名单内,否则 validate_config 直接报错(不静默失效)。
params: dict[str, Any] = field(default_factory=dict) 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 @dataclass
@@ -97,6 +170,17 @@ class ProviderConfig:
media: MediaConfig = field(default_factory=MediaConfig) media: MediaConfig = field(default_factory=MediaConfig)
rate_limit_rps: float | None = None # 该供应商全局 QPS 上限(可选) rate_limit_rps: float | None = None # 该供应商全局 QPS 上限(可选)
requires_session_header: bool = False # OpenCode Go 等要求每请求动态会话头(x-opencode-session) 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) 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 @dataclass
class CircuitConfig: class CircuitConfig:
"""供应商熔断器配置。""" """供应商熔断器配置。"""
@@ -199,7 +265,6 @@ class GatewayConfig:
providers: dict[str, ProviderConfig] = field(default_factory=dict) providers: dict[str, ProviderConfig] = field(default_factory=dict)
server: ServerConfig = field(default_factory=ServerConfig) server: ServerConfig = field(default_factory=ServerConfig)
auth: AuthGate = field(default_factory=AuthGate) auth: AuthGate = field(default_factory=AuthGate)
routes: dict[str, RouteInfo] = field(default_factory=dict)
circuit: CircuitConfig = field(default_factory=CircuitConfig) circuit: CircuitConfig = field(default_factory=CircuitConfig)
observability: ObservabilityConfig = field(default_factory=ObservabilityConfig) observability: ObservabilityConfig = field(default_factory=ObservabilityConfig)
pricing: Pricing = field(default_factory=Pricing) 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: def find_provider_for_model(self, model_id: str) -> tuple[str, ProviderConfig, ModelInfo] | None:
return self._model_index.get(model_id) return self._model_index.get(model_id)
def find_route(self, model_id: str) -> RouteInfo | None: def find_model_for_protocol(
return self.routes.get(model_id) 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]]: def all_models(self) -> list[dict[str, Any]]:
result = [] result = []
@@ -250,20 +326,13 @@ class GatewayConfig:
# 前端据此标注「该模型温度已由网关固定」,API 调用方也能提前知道 # 前端据此标注「该模型温度已由网关固定」,API 调用方也能提前知道
# 自己传的采样参数会被上游要求覆盖,省掉一轮「传了没生效」的困惑。 # 自己传的采样参数会被上游要求覆盖,省掉一轮「传了没生效」的困惑。
"params": dict(m.params or {}), "params": dict(m.params or {}),
# 第二十七轮: 暴露该模型能走哪几条协议线(取值见 PROTOCOLS)。
# 前端「供应商与模型」页据此打格式标签;API 调用方也能提前知道自己
# 该把请求发到 /v1/chat/completions、/v1/messages 还是 /v1/responses。
"protocols": list(m.protocols),
}) })
return result 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: def _opt_float(v: Any, field_name: str = "rate_limit_rps") -> float | None:
"""可选数值解析:None/空串 → None;数字或数字字符串 → float;其它 → ConfigError。 """可选数值解析:None/空串 → None;数字或数字字符串 → float;其它 → ConfigError。
@@ -355,6 +424,82 @@ def _parse_model_params(v: Any, where: str) -> dict[str, Any]:
return out 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: def _parse_media(pval: dict[str, Any]) -> MediaConfig:
m = pval.get("media", {}) or {} m = pval.get("media", {}) or {}
return MediaConfig( return MediaConfig(
@@ -394,7 +539,7 @@ def _parse_download(pval: dict[str, Any]) -> DownloadConfig:
def validate_config(cfg: GatewayConfig) -> list[str]: def validate_config(cfg: GatewayConfig) -> list[str]:
"""结构性校验(Bug 12 修复):返回问题列表,空 = 通过。 """结构性校验(Bug 12 修复):返回问题列表,空 = 通过。
校验供应商必填项与路由链,给出可读的中文说明(而非运行到一半才崩)。 校验供应商必填项与模型字段,给出可读的中文说明(而非运行到一半才崩)。
""" """
issues: list[str] = [] issues: list[str] = []
if not cfg.providers: if not cfg.providers:
@@ -407,9 +552,13 @@ def validate_config(cfg: GatewayConfig) -> list[str]:
for idx, m in enumerate(p.models): for idx, m in enumerate(p.models):
if not m.id: if not m.id:
issues.append(f"供应商 '{pkey}' 的第 {idx + 1} 个模型缺少 id") issues.append(f"供应商 '{pkey}' 的第 {idx + 1} 个模型缺少 id")
for rname, r in cfg.routes.items(): # 第二十七轮: 模型声明了某条线,但供应商根本没配这条线的出站地址 ——
if not r.models: # 这种配置下调用必然失败(而且会失败在"拼 URL"那一步),必须启动就拦住。
issues.append(f"路由 '{rname}' 的模型链为空") 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),配置文件不再承载鉴权。 # 账号体系已由页面管理(data/users.json,见 app/users.py),配置文件不再承载鉴权。
# 首次启动会创建 admin/admin,不存在「自锁」场景。 # 首次启动会创建 admin/admin,不存在「自锁」场景。
return issues return issues
@@ -437,24 +586,18 @@ def validate_warnings(cfg: GatewayConfig) -> list[str]:
# 供应商缺 Key / 缺模型:上线前就点出来,而不是调用时才 503 / fallback 悄悄失效 # 供应商缺 Key / 缺模型:上线前就点出来,而不是调用时才 503 / fallback 悄悄失效
for pkey, p in cfg.providers.items(): for pkey, p in cfg.providers.items():
if not p.models: 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)): 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 均空/环境变量未设置)" warns.append(f"供应商 '{pkey}' 未配置 API Key(token 与 token_env 均空/环境变量未设置)"
f" —— 调用该供应商的任何模型都会 503") f" —— 调用该供应商的任何模型都会 503")
# (账号/密码/API Key 已改由页面管理,弱凭证检查不再适用于配置文件。) # (账号/密码/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 return warns
def load_config(path: str | Path) -> GatewayConfig: def load_config(path: str | Path) -> GatewayConfig:
"""从 YAML 文件加载完整网关配置。 """从 YAML 文件加载完整网关配置。
结构性错误(缺供应商/缺 base_url/空模型链等)抛 ConfigError,带友好说明。 结构性错误(缺供应商/缺 base_url/模型缺 id 等)抛 ConfigError,带友好说明。
""" """
path = Path(path) path = Path(path)
if not path.exists(): 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", ""), 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), type=m.get("type", "text"), vision=_opt_bool(m.get("vision"), "providers.*.models.*.vision", False),
params=_parse_model_params( 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", [])) for idx, m in enumerate(pval.get("models", []))
] ]
providers[pkey] = ProviderConfig( 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")), rate_limit_rps=_opt_float(pval.get("rate_limit_rps")),
requires_session_header=_opt_bool( requires_session_header=_opt_bool(
pval.get("requires_session_header"), "providers.*.requires_session_header", False), pval.get("requires_session_header"), "providers.*.requires_session_header", False),
endpoints=_parse_endpoints(pval, pkey),
) )
srv_raw = raw.get("server", {}) or {} 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 = AuthGate(session_ttl_minutes=_opt_int(auth_raw.get("session_ttl_minutes"),
"auth.session_ttl_minutes", 1440, minimum=1)) "auth.session_ttl_minutes", 1440, minimum=1))
# 路由别名 → 优先级 fallback 链(支持 list 或 dict 两种写法) # 第二十七轮: 「路由别名 / fallback 链」功能已整体移除。
routes_raw = raw.get("routes", {}) or {} # 老配置里残留的 routes 段不再解析,只在日志里提醒一声(不报错,免得旧配置起不来)。
routes: dict[str, RouteInfo] = {} if raw.get("routes"):
for rname, rval in routes_raw.items(): log.warning("配置里的 'routes' 段已废弃(路由别名功能已移除),本次加载忽略该段")
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)
# 熔断器 # 熔断器
c_raw = raw.get("circuit", {}) or {} c_raw = raw.get("circuit", {}) or {}
@@ -588,7 +714,7 @@ def parse_config(raw: dict[str, Any]) -> GatewayConfig:
pricing = Pricing(per_model=per_model) pricing = Pricing(per_model=per_model)
cfg = GatewayConfig( cfg = GatewayConfig(
providers=providers, server=server, auth=auth, routes=routes, providers=providers, server=server, auth=auth,
circuit=circuit, observability=observability, pricing=pricing, circuit=circuit, observability=observability, pricing=pricing,
download=_parse_download(raw), 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: class Metrics:
"""按 模型/供应商/路由 维度统计调用次数、fallback、token、耗时。""" """按 模型/供应商 维度统计调用次数、token、耗时。"""
def __init__(self, enabled: bool = True, started_at: float | None = None): def __init__(self, enabled: bool = True, started_at: float | None = None):
self.enabled = enabled self.enabled = enabled
self._lock = threading.Lock() self._lock = threading.Lock()
self.calls: dict[str, dict[str, int]] = {} # model -> {ok, fail} self.calls: dict[str, dict[str, int]] = {} # model -> {ok, fail}
self.providers: dict[str, dict[str, int]] = {} # provider -> {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_prompt: int = 0
self.tokens_completion: int = 0 self.tokens_completion: int = 0
self.latency_samples: dict[str, deque[float]] = {} # model -> 最近 N 次耗时 self.latency_samples: dict[str, deque[float]] = {} # model -> 最近 N 次耗时
@@ -72,7 +70,7 @@ class Metrics:
self.in_flight: int = 0 self.in_flight: int = 0
self.in_flight_peak: int = 0 self.in_flight_peak: int = 0
# M5+: 按账号维度的聚合(普通账号只看到自己的调用;admin 看全局)。 # M5+: 按账号维度的聚合(普通账号只看到自己的调用;admin 看全局)。
# 结构:account -> {"calls","providers","routes","tokens","latency","fallback"} # 结构:account -> {"calls","providers","tokens","latency"}
self.by_account: dict[str, dict[str, Any]] = {} self.by_account: dict[str, dict[str, Any]] = {}
# Bug 4: 热重载时保留 started_at,uptime 不因重载清零 # Bug 4: 热重载时保留 started_at,uptime 不因重载清零
self.started_at: float = started_at if started_at is not None else time.time() 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) acc = self.by_account.get(account)
if acc is None: if acc is None:
acc = { acc = {
"calls": {}, "providers": {}, "routes": {}, "calls": {}, "providers": {},
"tokens": {"prompt": 0, "completion": 0}, "tokens": {"prompt": 0, "completion": 0},
"latency": {}, "fallback": 0, "latency": {},
} }
self.by_account[account] = acc self.by_account[account] = acc
return acc return acc
@@ -109,11 +107,10 @@ class Metrics:
def _bucket(d: dict, k: str) -> dict[str, int]: def _bucket(d: dict, k: str) -> dict[str, int]:
return d.setdefault(k, {"ok": 0, "fail": 0}) 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: account: str | None = None) -> None:
"""记录一次调用结果。 """记录一次调用结果。
route 维度(Bug 8 修复):传入 route 时同时累加 routes 的 ok/fail。
account(M5+):未显式传入时取请求级 ACCOUNT 上下文;非 anonymous 时额外累加 account(M5+):未显式传入时取请求级 ACCOUNT 上下文;非 anonymous 时额外累加
到该账号自己的聚合桶,供「只看本人的指标」使用。 到该账号自己的聚合桶,供「只看本人的指标」使用。
""" """
@@ -124,31 +121,12 @@ class Metrics:
self._bucket(self.calls, model)["ok" if ok else "fail"] += 1 self._bucket(self.calls, model)["ok" if ok else "fail"] += 1
if provider: if provider:
self._bucket(self.providers, provider)["ok" if ok else "fail"] += 1 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": if a and a != "anonymous":
acc = self._acc(a) acc = self._acc(a)
self._bucket(acc["calls"], model)["ok" if ok else "fail"] += 1 self._bucket(acc["calls"], model)["ok" if ok else "fail"] += 1
if provider: if provider:
self._bucket(acc["providers"], provider)["ok" if ok else "fail"] += 1 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: def record_tokens(self, prompt: int, completion: int, account: str | None = None) -> None:
if not self.enabled: if not self.enabled:
@@ -198,7 +176,7 @@ class Metrics:
if not acc: if not acc:
return dict(uptime_seconds=round(time.time() - self.started_at, 1), return dict(uptime_seconds=round(time.time() - self.started_at, 1),
in_flight=self.in_flight, in_flight_peak=self.in_flight_peak, 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={}) tokens={"prompt": 0, "completion": 0}, latency={})
lat = {} lat = {}
for m, dq in acc["latency"].items(): for m, dq in acc["latency"].items():
@@ -210,8 +188,6 @@ class Metrics:
"in_flight_peak": self.in_flight_peak, "in_flight_peak": self.in_flight_peak,
"calls": {k: dict(v) for k, v in acc["calls"].items()}, "calls": {k: dict(v) for k, v in acc["calls"].items()},
"providers": {k: dict(v) for k, v in acc["providers"].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"]), "tokens": dict(acc["tokens"]),
"latency": lat, "latency": lat,
} }
@@ -231,8 +207,6 @@ class Metrics:
"in_flight_peak": self.in_flight_peak, "in_flight_peak": self.in_flight_peak,
"calls": {k: dict(v) for k, v in self.calls.items()}, "calls": {k: dict(v) for k, v in self.calls.items()},
"providers": {k: dict(v) for k, v in self.providers.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}, "tokens": {"prompt": self.tokens_prompt, "completion": self.tokens_completion},
"latency": latency_out, "latency": latency_out,
} }
+33 -27
View File
@@ -86,6 +86,37 @@ class ToolDef(BaseModel):
CONVERSATION_ID_MAX = 128 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): class ChatRequest(BaseModel):
# 兼容性修复:OpenAI 官方 SDK 会带不少可选参数(n / presence_penalty / response_format …), # 兼容性修复:OpenAI 官方 SDK 会带不少可选参数(n / presence_penalty / response_format …),
# 之前未声明的字段被 pydantic 静默丢弃,导致"网关号称 OpenAI 全兼容但参数悄悄丢失"。 # 之前未声明的字段被 pydantic 静默丢弃,导致"网关号称 OpenAI 全兼容但参数悄悄丢失"。
@@ -155,33 +186,8 @@ class ChatRequest(BaseModel):
@field_validator("conversation_id") @field_validator("conversation_id")
@classmethod @classmethod
def _validate_conversation_id(cls, v: str | None) -> str | None: def _validate_conversation_id(cls, v: str | None) -> str | None:
"""会话 id 的入口校验(第二十六轮)。 """见 normalize_conversation_id(第二十七轮把规则抽成公共函数,直传端点多路复用)。"""
return normalize_conversation_id(v)
它最终会作为 `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
# ── 图像生成 ───────────────────────────────────────── # ── 图像生成 ─────────────────────────────────────────
+56 -34
View File
@@ -31,6 +31,8 @@ import yaml
from app.config import ( from app.config import (
ConfigError, ConfigError,
GatewayConfig, GatewayConfig,
PROTOCOLS,
_default_endpoints,
parse_config, parse_config,
validate_config, validate_config,
validate_warnings, validate_warnings,
@@ -88,11 +90,23 @@ def config_to_view(cfg: GatewayConfig) -> dict[str, Any]:
"rate_limit_rps": p.rate_limit_rps, "rate_limit_rps": p.rate_limit_rps,
"requires_session_header": bool(p.requires_session_header), "requires_session_header": bool(p.requires_session_header),
"media": {k: getattr(p.media, k) for k in MEDIA_KEYS}, "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": [ "models": [
{"id": m.id, "display_name": m.display_name, "type": m.type, "vision": bool(m.vision), {"id": m.id, "display_name": m.display_name, "type": m.type, "vision": bool(m.vision),
# 第二十五轮: 回传模型级强制参数。面板不提供编辑入口(在 YAML 全文编辑器里改), # 第二十五轮: 回传模型级强制参数。面板不提供编辑入口(在 YAML 全文编辑器里改),
# 但必须一路带着走 —— 否则读回来再提交一次就会把它弄丢。 # 但必须一路带着走 —— 否则读回来再提交一次就会把它弄丢。
"params": dict(m.params or {})} "params": dict(m.params or {}),
# 第二十七轮: 模型能走哪几条协议线。这一项**面板可编辑**
# (「供应商与模型」页给每个模型打格式标签),所以两处都要认:
# 读回给页面显示、写盘时以页面提交的为准。
"protocols": list(m.protocols)}
for m in p.models 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_fail_limit_per_min": s.auth_fail_limit_per_min,
}, },
"auth": {"session_ttl_minutes": cfg.auth.session_ttl_minutes}, "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": { "circuit": {
"enabled": cfg.circuit.enabled, "enabled": cfg.circuit.enabled,
"failure_threshold": cfg.circuit.failure_threshold, "failure_threshold": cfg.circuit.failure_threshold,
@@ -153,6 +158,37 @@ def config_to_view(cfg: GatewayConfig) -> dict[str, Any]:
# ── 写入:面板 JSON → 完整 yaml 字典 ─────────────────────── # ── 写入:面板 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]: def _as_dict(v: Any, field_name: str) -> dict[str, Any]:
if v is None: if v is None:
return {} 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(), "type": str(m.get("type") or "text").strip(),
"vision": bool(m.get("vision", False)), "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) models.append(item)
providers[key] = { providers[key] = {
"name": str(pv.get("name") or key).strip(), "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"), "extra_headers": _str_map(pv.get("extra_headers"), f"providers.{key}.extra_headers"),
"rate_limit_rps": pv.get("rate_limit_rps"), "rate_limit_rps": pv.get("rate_limit_rps"),
"requires_session_header": bool(pv.get("requires_session_header", False)), "requires_session_header": bool(pv.get("requires_session_header", False)),
# 第二十七轮: 协议线的出站配置(路径/鉴权/固定头)。
# 仍然以**文件原文为底**:面板没有这段的编辑器,而它一旦丢失,
# 声明了 messages/responses 的模型会直接变成"供应商没配这条线"。
"endpoints": base_p.get("endpoints", _default_endpoints_view()),
# media 留空 = 该供应商不支持对应媒体(写回时保留原文里的空 {} 语义) # media 留空 = 该供应商不支持对应媒体(写回时保留原文里的空 {} 语义)
"media": { "media": {
k: (media_in.get(k) if k in media_in else base_media.get(k)) 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"] merged["session_ttl_minutes"] = av["session_ttl_minutes"]
out["auth"] = merged 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 ── # ── circuit / observability ──
for sec, keys in (("circuit", _CIRCUIT_KEYS), ("observability", _OBS_KEYS)): for sec, keys in (("circuit", _CIRCUIT_KEYS), ("observability", _OBS_KEYS)):
if sec in view: if sec in view:
@@ -393,12 +421,6 @@ _SECTION_COMMENTS = {
# 账号与 API Key 由页面管理,存在 data/users.json(见 app/users.py): # 账号与 API Key 由页面管理,存在 data/users.json(见 app/users.py):
# 管理员在「用户管理」建账号,各账号在「设置 → 我的 API Key」自助铸 Key。 # 管理员在「用户管理」建账号,各账号在「设置 → 我的 API Key」自助铸 Key。
# 本文件里没有任何用户/密钥,只有会话时长这一个开关。 # 本文件里没有任何用户/密钥,只有会话时长这一个开关。
""",
"routes": """\
# ── 路由别名 + 按优先级 fallback ────────────────────────
# model 填别名(如 wjd)时按 models 数组顺序逐个尝试:第 1 个失败/超时/重试耗尽 → 第 2 个 …
# 全失败才 502。timeout = 单模型超时秒(null 用 server.timeout),retry = 切下一个前该模型重试次数。
# 数组顺序即优先级(第 0 个最高)。可用模型 = 上面 providers 里定义的全部模型 id。
""", """,
"circuit": """\ "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: def _dump(obj: Any) -> str:
+143 -57
View File
@@ -25,7 +25,7 @@ providers:
display_name: "Agnes 3.0 Flash" display_name: "Agnes 3.0 Flash"
type: "text" type: "text"
# 第十三轮: Agnes 3.0 Flash 文档「输入模态:文本、图像 URL」→ 支持视觉(对话带图)。 # 第十三轮: Agnes 3.0 Flash 文档「输入模态:文本、图像 URL」→ 支持视觉(对话带图)。
# 实测 data:image/png;base64,... 也能识别。带图请求走路由别名时会被排到链首。 # 实测 data:image/png;base64,... 也能识别。
vision: true vision: true
- id: "agnes-2.5-flash" - id: "agnes-2.5-flash"
display_name: "Agnes 2.5 Flash" display_name: "Agnes 2.5 Flash"
@@ -57,35 +57,71 @@ providers:
base_url: "https://opencode.ai/zen/go/v1" base_url: "https://opencode.ai/zen/go/v1"
auth: auth:
token_env: "OPENCODE_API_KEY" token_env: "OPENCODE_API_KEY"
# OpenCode Go 是每月订阅编程模型入口。官方硬性要求每个 /chat/completions # OpenCode Go 是每月订阅编程模型入口。官方硬性要求**三条线**都带
# 带 x-opencode-session(缺失直接 400 MissingSessionID),并建议用专属 UA # x-opencode-session(缺失直接 400 MissingSessionID),并建议用专属 UA
# 而非通用库名(实测 UA 不敏感,会话头才是必需)。适配器据此开关在 # 而非通用库名(实测 UA 不敏感,会话头才是必需)。适配器据此开关在
# 每次请求动态注入 UUID 会话头(不能放静态 extra_headers——会被 _get_adapter 缓存冻结)。 # 每次请求动态注入会话头(不能放静态 extra_headers——会被 _get_adapter 缓存冻结)。
requires_session_header: true requires_session_header: true
extra_headers: extra_headers:
User-Agent: "api-gateway/2.4.0 (jakon opencode-go)" User-Agent: "api-gateway/2.4.0 (jakon opencode-go)"
# 无媒体能力(纯文本编程模型;图像/视频不走本供应商) # 无媒体能力(纯文本编程模型;图像/视频不走本供应商)
media: {} media: {}
# ── 协议线(第二十七轮「三线直传」)──────────────────────────
# 同一家供应商的三条线共用 base_url,只有「路径 + 鉴权方式 + 固定头」不同。
# 实测(2026-09-18,真实 key):
# /chat/completions 与 /responses → Authorization: Bearer
# /messages → x-api-key(用 Bearer 打会 401 Missing API key)
# 缺少 anthropic-version 时 /messages 也会被拒 → 作为该线固定头带上。
# 语义:**这里没写的线 = 该供应商没有这条线**(模型就算声明了也调用不了,
# validate_config 会直接报错拦住)。老板决策:先只做 OpenCode 一家,
# 其余供应商(Agnes / 火山)暂不声明 → 走默认值 = 只认 chat/completions,
# 行为与改造前完全一致。
endpoints:
chat/completions:
path: "/chat/completions"
auth: "bearer"
messages:
path: "/messages"
auth: "x-api-key"
headers:
anthropic-version: "2023-06-01"
responses:
path: "/responses"
auth: "bearer"
# ── 模型 ─────────────────────────────────────────────────
# models[].protocols = 该模型**能用哪几条线**(入站格式必须与出站一致)。
# 取值:chat/completions | messages | responses;不写 = 只认 chat/completions。
# 实测口径(2026-09-18 全量扫描 29 个文档模型 × 3 条线,非文档线另做
# 「流式 + 工具调用」复核,全部 200):官方文档标注的线**一定**可用;
# 另外有一批模型实测能走多条线(OpenCode 侧自带跨格式适配),按实测多标:
# · 四条 DeepSeek 三线全通(chat + messages + responses)
# · kimi-k3 / minimax-m3 / minimax-m2.5 / qwen3.6~3.8 系列:chat + messages
# 反向证据(为什么必须逐条实测而不是"猜全支持"):把只认 chat 的 glm 系打到
# /messages 上是 500 Internal server error,把 messages 线的模型打到
# /responses 上是 401 "not supported for format openai" —— 都不像"选错格式",
# 所以网关改成按本表拦在入口(400 并说清该模型支持哪些线)。
models: models:
# ── OpenAI 兼容 /v1/chat/completions 线(全部经真实 key 实测 200)── # ── OpenAI Chat Completions 线 ────────────────────────
- id: "glm-5.3-flash" - id: "glm-5.3-flash"
display_name: "GLM-5.3-Flash" display_name: "GLM-5.3-Flash"
type: "text" type: "text"
protocols: ["chat/completions"]
- id: "glm-5.3" - id: "glm-5.3"
display_name: "GLM-5.3" display_name: "GLM-5.3"
type: "text" type: "text"
protocols: ["chat/completions"]
- id: "glm-5.2" - id: "glm-5.2"
display_name: "GLM-5.2" display_name: "GLM-5.2"
type: "text" type: "text"
protocols: ["chat/completions"]
- id: "glm-5.1" - id: "glm-5.1"
display_name: "GLM-5.1" display_name: "GLM-5.1"
type: "text" type: "text"
- id: "kimi-k3" protocols: ["chat/completions"]
display_name: "Kimi K3"
type: "text"
- id: "kimi-k2.7-code" - id: "kimi-k2.7-code"
display_name: "Kimi K2.7 Code" display_name: "Kimi K2.7 Code"
type: "text" type: "text"
protocols: ["chat/completions"]
# 上游硬约束:该模型**只接受 temperature=1**,传 0 / 0.7 等一律 400 # 上游硬约束:该模型**只接受 temperature=1**,传 0 / 0.7 等一律 400
# "invalid temperature: only 1 is allowed for this model"。 # "invalid temperature: only 1 is allowed for this model"。
# 写死后网关无论收到什么温度都按 1 发(前端温度滑块、API 传参、一键测速探针 # 写死后网关无论收到什么温度都按 1 发(前端温度滑块、API 传参、一键测速探针
@@ -95,44 +131,120 @@ providers:
- id: "kimi-k2.6" - id: "kimi-k2.6"
display_name: "Kimi K2.6" display_name: "Kimi K2.6"
type: "text" type: "text"
protocols: ["chat/completions"]
- id: "longcat-2.0" - id: "longcat-2.0"
display_name: "LongCat 2.0" display_name: "LongCat 2.0"
type: "text" type: "text"
- id: "deepseek-v4-pro" protocols: ["chat/completions"]
display_name: "DeepSeek V4 Pro" - id: "mimo-v2.5"
display_name: "MiMo V2.5"
type: "text" type: "text"
- id: "deepseek-v4-flash" protocols: ["chat/completions"]
display_name: "DeepSeek V4 Flash" - id: "mimo-v2.5-pro"
display_name: "MiMo V2.5 Pro"
type: "text" type: "text"
- id: "deepseek-flash" protocols: ["chat/completions"]
display_name: "DeepSeek Flash" - id: "hy4-preview"
display_name: "Hy4 Preview"
type: "text" type: "text"
protocols: ["chat/completions"]
- id: "hy3"
display_name: "Hy3"
type: "text"
protocols: ["chat/completions"]
# ── Chat + Messages 两条线都实测可用 ─────────────────
- id: "kimi-k3"
display_name: "Kimi K3"
type: "text"
protocols: ["chat/completions", "messages"]
- id: "minimax-m3"
display_name: "MiniMax M3"
type: "text"
protocols: ["chat/completions", "messages"]
- id: "minimax-m2.5"
display_name: "MiniMax M2.5"
type: "text"
protocols: ["chat/completions", "messages"]
- id: "qwen3.8-max"
display_name: "Qwen3.8 Max"
type: "text"
protocols: ["chat/completions", "messages"]
- id: "qwen3.8-flash"
display_name: "Qwen3.8 Flash"
type: "text"
protocols: ["chat/completions", "messages"]
- id: "qwen3.7-max"
display_name: "Qwen3.7 Max"
type: "text"
protocols: ["chat/completions", "messages"]
- id: "qwen3.7-plus"
display_name: "Qwen3.7 Plus"
type: "text"
protocols: ["chat/completions", "messages"]
- id: "qwen3.6-plus"
display_name: "Qwen3.6 Plus"
type: "text"
protocols: ["chat/completions", "messages"]
# ── 三条线全通(实测 chat / messages / responses 均 200,
# 非文档线另经流式 + 工具调用复核) ────────────────
- id: "deepseek-v4.1-flash" - id: "deepseek-v4.1-flash"
display_name: "DeepSeek V4.1 Flash" display_name: "DeepSeek V4.1 Flash"
type: "text" type: "text"
vision: true # 2026-09-18 实测确认多模态:data:image/png;base64 红/蓝/绿三色均识别正确; vision: true # 2026-09-18 实测确认多模态:data:image/png;base64 红/蓝/绿三色均识别正确;
# 同一带图请求打到纯文本模型 deepseek-v4-flash 会被上游 400 拒(对照有效)。 # 同一带图请求打到纯文本模型 deepseek-v4-flash 会被上游 400 拒(对照有效)。
protocols: ["chat/completions", "messages", "responses"]
- id: "deepseek-v4-pro"
display_name: "DeepSeek V4 Pro"
type: "text"
protocols: ["chat/completions", "messages", "responses"]
- id: "deepseek-v4-flash"
display_name: "DeepSeek V4 Flash"
type: "text"
protocols: ["chat/completions", "messages", "responses"]
- id: "deepseek-v4-flash-vision-exp" - id: "deepseek-v4-flash-vision-exp"
display_name: "DeepSeek V4 Flash Vision Exp" display_name: "DeepSeek V4 Flash Vision Exp"
type: "text" type: "text"
vision: true # 官方标 Vision,支持图像转 token 输入(带图请求可走路由链首) vision: true # 官方标 Vision,支持图像转 token 输入
- id: "mimo-v2.5" protocols: ["chat/completions", "messages", "responses"]
display_name: "MiMo V2.5" # ── Anthropic Messages 线(文档主推这条)─────────────
- id: "minimax-m2.7"
display_name: "MiniMax M2.7"
type: "text" type: "text"
- id: "mimo-v2.5-pro" # 实测:messages 线 200,chat / responses 都是 500 → 只标 messages
display_name: "MiMo V2.5 Pro" protocols: ["messages"]
- id: "union-alpha"
display_name: "Union Alpha Free"
type: "text" type: "text"
- id: "hy4-preview" # 文档标的 messages 线,但实测上游回 400「Model is unavailable.」
display_name: "Hy4 Preview" # (限时免费模型,额度/可用性由上游控制)。先按文档收录并标注真实线,
# 调用时上游的不可用会原样回给客户端(网关不替它编文案)。
protocols: ["messages"]
# ── OpenAI Responses 线 ───────────────────────────────
- id: "grok-4.6"
display_name: "Grok 4.6"
type: "text" type: "text"
- id: "hy3" # 实测:responses 200;chat / messages 都是 401 "not supported for format"
display_name: "Hy3" protocols: ["responses"]
- id: "gpt-5.6-luna"
display_name: "GPT 5.6 Luna"
type: "text" type: "text"
protocols: ["responses"]
- id: "muse-spark-1.3-contributor"
display_name: "Muse Spark 1.3 Contributor"
type: "text"
# 实测三条线都 403 DataPolicyError:该模型会拿数据训练,需要先在
# OpenCode 控制台**显式同意数据条款**才能调用(当前工作区未同意)。
# 先收录并标好线:老板去控制台点了同意就能直接用,不用再改网关。
protocols: ["responses"]
- id: "muse-spark-1.2-contributor"
display_name: "Muse Spark 1.2 Contributor"
type: "text"
protocols: ["responses"]
server: server:
host: "127.0.0.1" host: "127.0.0.1"
port: 8808 port: 8808
timeout: 120 timeout: 120
retry: 3 # 直接用模型 id(不走路由)时重试 3 次(含首次);路由别名用各自 route.retry(默认1) retry: 3 # 同一模型的重试次数(含首次)。第二十七轮: 路由别名已删除,无 route.retry
# ── 运维开关 ── # ── 运维开关 ──
health_auth: false # /health/* 是否也需鉴权(默认否,留给探活) health_auth: false # /health/* 是否也需鉴权(默认否,留给探活)
hot_reload: true # 监听 gateway.yaml mtime 自动重载(改配置免重启) hot_reload: true # 监听 gateway.yaml mtime 自动重载(改配置免重启)
@@ -195,36 +307,10 @@ download:
auth: auth:
session_ttl_minutes: 1440 session_ttl_minutes: 1440
# ── 路由别名 + 按优先级 fallback ────────────────────── # ── 路由别名 / fallback 链:已整体删除 ──────────────────
# model 填别名(如 wjd),按数组顺序逐个尝试: # 第二十七轮(老板 2026-09-18 决策):**路由别名功能整体删除**,不再有 routes 段。
# 第 1 个失败/超时/重试耗尽 → 第 2 个 … 全失败才 502。 # 原因:三线直传落地后"入站格式 = 出站格式",模型 id 必须与协议线一一对应;
# 每个路由可设 timeout(单模型超时秒)、retry(切下一个前该模型重试次数)。 # 再套一层"自动挑最快模型"的别名,会把调用方选定的格式/能力(视觉、工具、协议线)
# 优先级从左到右(第一个最高)。老板决策:wjd 链路 = 全部文本模型(已含 OpenCode Go 17 个)。 # 悄悄换掉。现在调用方直接填真实模型 id;要换模型就换 id,网关不再替谁做主。
routes: # 老配置里残留的 routes 段会被忽略(不会让进程起不来),日志里有 warning 可查。
wjd: # 一键测速(Models 页每个模型后面的)不受影响,仍然逐个模型实测延迟。
timeout: 60 # 单模型 60s 没出结果就切下一个(避免 20×120s 挂死)
retry: 1 # 每个模型只试 1 次,失败立即切下一个
# 注意(老板决策):wjd 链路 = 全部文本模型;新增/现有文本模型都必须加进这里。
models:
# 供应商按「默认主力」在前,其余按供应商分组;运行时仍按可用性+速度实时重排。
- "ark-code-latest" # 1) 火山方舟
- "agnes-3.0-flash" # 2) Agnes 3.0
- "agnes-2.5-flash" # 3) Agnes 2.5
# ── 4) OpenCode Go(17 个文本模型,全进 wjd)──
- "glm-5.3-flash" # 4.1) GLM-5.3-Flash
- "glm-5.3" # 4.2) GLM-5.3
- "glm-5.2" # 4.3) GLM-5.2
- "glm-5.1" # 4.4) GLM-5.1
- "kimi-k3" # 4.5) Kimi K3
- "kimi-k2.7-code" # 4.6) Kimi K2.7 Code
- "kimi-k2.6" # 4.7) Kimi K2.6
- "longcat-2.0" # 4.8) LongCat 2.0
- "deepseek-v4-pro" # 4.9) DeepSeek V4 Pro
- "deepseek-v4-flash" # 4.10) DeepSeek V4 Flash
- "deepseek-flash" # 4.11) DeepSeek Flash
- "deepseek-v4.1-flash" # 4.12) DeepSeek V4.1 Flash
- "deepseek-v4-flash-vision-exp" # 4.13) DeepSeek V4 Flash Vision Exp
- "mimo-v2.5" # 4.14) MiMo V2.5
- "mimo-v2.5-pro" # 4.15) MiMo V2.5 Pro
- "hy4-preview" # 4.16) Hy4 Preview
- "hy3" # 4.17) Hy3
+4
View File
@@ -5,6 +5,10 @@
--- ---
> ⚠️ **第二十七轮(2026-09-18)**:路由别名 `wjd` / 多模型 fallback 已**整体删除**。
> 本文里凡是提到「路由别名」「降级链」「fallback_used」的地方,都是当时的设计记录,
> 现状请以 `README.md` 的「三线直传」章节为准。
## 1. 背景与目标 ## 1. 背景与目标
网关是一个 OpenAI 兼容的多供应商 LLM 统一接入层(Agnes / 火山方舟),已具备完整 REST 能力(对话/图像/视频/批量/模型/指标/日志/健康)。当前**只能通过 curl / 二次开发调用,没有可视化界面**。 网关是一个 OpenAI 兼容的多供应商 LLM 统一接入层(Agnes / 火山方舟),已具备完整 REST 能力(对话/图像/视频/批量/模型/指标/日志/健康)。当前**只能通过 curl / 二次开发调用,没有可视化界面**。
+723 -1
View File
@@ -8,7 +8,6 @@
"name": "api-gateway-web", "name": "api-gateway-web",
"version": "0.1.0", "version": "0.1.0",
"dependencies": { "dependencies": {
"@element-plus/icons-vue": "^2.3.1",
"dompurify": "^3.4.15", "dompurify": "^3.4.15",
"echarts": "^6.1.0", "echarts": "^6.1.0",
"element-plus": "^2.9.1", "element-plus": "^2.9.1",
@@ -23,10 +22,21 @@
"devDependencies": { "devDependencies": {
"@vitejs/plugin-vue": "^5.2.1", "@vitejs/plugin-vue": "^5.2.1",
"typescript": "^5.7.2", "typescript": "^5.7.2",
"unplugin-auto-import": "^0.19.0",
"unplugin-vue-components": "^0.28.0",
"vite": "^6.0.7", "vite": "^6.0.7",
"vue-tsc": "^2.2.12" "vue-tsc": "^2.2.12"
} }
}, },
"node_modules/@antfu/utils": {
"version": "0.7.10",
"resolved": "http://mirrors.tencentyun.com/npm/@antfu/utils/-/utils-0.7.10.tgz",
"integrity": "sha512-+562v9k4aI80m1+VuMHehNJWLOFjBnXn3tdOitzD0il5b7smkSBal4+a3oKiQTbrwMmN/TBUMDvbdoWDehgOww==",
"dev": true,
"funding": {
"url": "https://github.com/sponsors/antfu"
}
},
"node_modules/@babel/helper-string-parser": { "node_modules/@babel/helper-string-parser": {
"version": "7.29.7", "version": "7.29.7",
"resolved": "http://mirrors.tencentyun.com/npm/@babel/helper-string-parser/-/helper-string-parser-7.29.7.tgz", "resolved": "http://mirrors.tencentyun.com/npm/@babel/helper-string-parser/-/helper-string-parser-7.29.7.tgz",
@@ -564,11 +574,50 @@
"url": "https://github.com/sponsors/kazupon" "url": "https://github.com/sponsors/kazupon"
} }
}, },
"node_modules/@jridgewell/gen-mapping": {
"version": "0.3.13",
"resolved": "http://mirrors.tencentyun.com/npm/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
"integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
"dev": true,
"dependencies": {
"@jridgewell/sourcemap-codec": "^1.5.0",
"@jridgewell/trace-mapping": "^0.3.24"
}
},
"node_modules/@jridgewell/remapping": {
"version": "2.3.5",
"resolved": "http://mirrors.tencentyun.com/npm/@jridgewell/remapping/-/remapping-2.3.5.tgz",
"integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
"dev": true,
"dependencies": {
"@jridgewell/gen-mapping": "^0.3.5",
"@jridgewell/trace-mapping": "^0.3.24"
}
},
"node_modules/@jridgewell/resolve-uri": {
"version": "3.1.2",
"resolved": "http://mirrors.tencentyun.com/npm/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
"integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
"dev": true,
"engines": {
"node": ">=6.0.0"
}
},
"node_modules/@jridgewell/sourcemap-codec": { "node_modules/@jridgewell/sourcemap-codec": {
"version": "1.6.0", "version": "1.6.0",
"resolved": "http://mirrors.tencentyun.com/npm/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.6.0.tgz", "resolved": "http://mirrors.tencentyun.com/npm/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.6.0.tgz",
"integrity": "sha512-T7jf+5zgsZHwNJ4lvQ7/aezbyk0nNX+zJVWpmHA7VYsEx7a7qr5Rg5IbtJFqkgze5Y2sruq1RUY8Q837Od7iFw==" "integrity": "sha512-T7jf+5zgsZHwNJ4lvQ7/aezbyk0nNX+zJVWpmHA7VYsEx7a7qr5Rg5IbtJFqkgze5Y2sruq1RUY8Q837Od7iFw=="
}, },
"node_modules/@jridgewell/trace-mapping": {
"version": "0.3.31",
"resolved": "http://mirrors.tencentyun.com/npm/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
"integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
"dev": true,
"dependencies": {
"@jridgewell/resolve-uri": "^3.1.0",
"@jridgewell/sourcemap-codec": "^1.4.14"
}
},
"node_modules/@napi-rs/lzma-linux-x64-gnu": { "node_modules/@napi-rs/lzma-linux-x64-gnu": {
"version": "1.5.1", "version": "1.5.1",
"resolved": "http://mirrors.tencentyun.com/npm/@napi-rs/lzma-linux-x64-gnu/-/lzma-linux-x64-gnu-1.5.1.tgz", "resolved": "http://mirrors.tencentyun.com/npm/@napi-rs/lzma-linux-x64-gnu/-/lzma-linux-x64-gnu-1.5.1.tgz",
@@ -585,6 +634,41 @@
"node": "^22.20 || ^24.12 || >=25" "node": "^22.20 || ^24.12 || >=25"
} }
}, },
"node_modules/@nodelib/fs.scandir": {
"version": "2.1.5",
"resolved": "http://mirrors.tencentyun.com/npm/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
"integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==",
"dev": true,
"dependencies": {
"@nodelib/fs.stat": "2.0.5",
"run-parallel": "^1.1.9"
},
"engines": {
"node": ">= 8"
}
},
"node_modules/@nodelib/fs.stat": {
"version": "2.0.5",
"resolved": "http://mirrors.tencentyun.com/npm/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz",
"integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==",
"dev": true,
"engines": {
"node": ">= 8"
}
},
"node_modules/@nodelib/fs.walk": {
"version": "1.2.8",
"resolved": "http://mirrors.tencentyun.com/npm/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz",
"integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==",
"dev": true,
"dependencies": {
"@nodelib/fs.scandir": "2.1.5",
"fastq": "^1.6.0"
},
"engines": {
"node": ">= 8"
}
},
"node_modules/@popperjs/core": { "node_modules/@popperjs/core": {
"name": "@sxzz/popperjs-es", "name": "@sxzz/popperjs-es",
"version": "2.11.8", "version": "2.11.8",
@@ -595,6 +679,28 @@
"url": "https://opencollective.com/popperjs" "url": "https://opencollective.com/popperjs"
} }
}, },
"node_modules/@rollup/pluginutils": {
"version": "5.4.0",
"resolved": "http://mirrors.tencentyun.com/npm/@rollup/pluginutils/-/pluginutils-5.4.0.tgz",
"integrity": "sha512-MfPp06CjRLfXQ3wY0R8vJDYBy/MvVcc9OulEfR0B8Iv9ko+GCNaRZ+EpJYFl27LhKsZK0o420sYCRHCjfCgeUg==",
"dev": true,
"dependencies": {
"@types/estree": "^1.0.0",
"estree-walker": "^2.0.2",
"picomatch": "^4.0.2"
},
"engines": {
"node": ">=14.0.0"
},
"peerDependencies": {
"rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0"
},
"peerDependenciesMeta": {
"rollup": {
"optional": true
}
}
},
"node_modules/@rollup/rollup-android-arm-eabi": { "node_modules/@rollup/rollup-android-arm-eabi": {
"version": "4.63.1", "version": "4.63.1",
"resolved": "http://mirrors.tencentyun.com/npm/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.63.1.tgz", "resolved": "http://mirrors.tencentyun.com/npm/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.63.1.tgz",
@@ -1152,12 +1258,49 @@
"vue": "^3.5.0" "vue": "^3.5.0"
} }
}, },
"node_modules/acorn": {
"version": "8.18.0",
"resolved": "http://mirrors.tencentyun.com/npm/acorn/-/acorn-8.18.0.tgz",
"integrity": "sha512-lGq+9yr1/GuAWaVYIHRjvvySG5/4VfKIvC8EWxStPdcDh/Ka7FG3twP6v4d5BkravUilhIAsG4Qj83t02LWUPQ==",
"dev": true,
"bin": {
"acorn": "bin/acorn"
},
"engines": {
"node": ">=0.4.0"
}
},
"node_modules/alien-signals": { "node_modules/alien-signals": {
"version": "1.0.13", "version": "1.0.13",
"resolved": "http://mirrors.tencentyun.com/npm/alien-signals/-/alien-signals-1.0.13.tgz", "resolved": "http://mirrors.tencentyun.com/npm/alien-signals/-/alien-signals-1.0.13.tgz",
"integrity": "sha512-OGj9yyTnJEttvzhTUWuscOvtqxq5vrhF7vL9oS0xJ2mK0ItPYP1/y+vCFebfxoEyAz0++1AIwJ5CMr+Fk3nDmg==", "integrity": "sha512-OGj9yyTnJEttvzhTUWuscOvtqxq5vrhF7vL9oS0xJ2mK0ItPYP1/y+vCFebfxoEyAz0++1AIwJ5CMr+Fk3nDmg==",
"dev": true "dev": true
}, },
"node_modules/anymatch": {
"version": "3.1.3",
"resolved": "http://mirrors.tencentyun.com/npm/anymatch/-/anymatch-3.1.3.tgz",
"integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
"dev": true,
"dependencies": {
"normalize-path": "^3.0.0",
"picomatch": "^2.0.4"
},
"engines": {
"node": ">= 8"
}
},
"node_modules/anymatch/node_modules/picomatch": {
"version": "2.3.2",
"resolved": "http://mirrors.tencentyun.com/npm/picomatch/-/picomatch-2.3.2.tgz",
"integrity": "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==",
"dev": true,
"engines": {
"node": ">=8.6"
},
"funding": {
"url": "https://github.com/sponsors/jonschlinkert"
}
},
"node_modules/async-validator": { "node_modules/async-validator": {
"version": "4.2.5", "version": "4.2.5",
"resolved": "http://mirrors.tencentyun.com/npm/async-validator/-/async-validator-4.2.5.tgz", "resolved": "http://mirrors.tencentyun.com/npm/async-validator/-/async-validator-4.2.5.tgz",
@@ -1169,6 +1312,18 @@
"integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
"dev": true "dev": true
}, },
"node_modules/binary-extensions": {
"version": "2.3.0",
"resolved": "http://mirrors.tencentyun.com/npm/binary-extensions/-/binary-extensions-2.3.0.tgz",
"integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==",
"dev": true,
"engines": {
"node": ">=8"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/brace-expansion": { "node_modules/brace-expansion": {
"version": "2.1.4", "version": "2.1.4",
"resolved": "http://mirrors.tencentyun.com/npm/brace-expansion/-/brace-expansion-2.1.4.tgz", "resolved": "http://mirrors.tencentyun.com/npm/brace-expansion/-/brace-expansion-2.1.4.tgz",
@@ -1178,6 +1333,48 @@
"balanced-match": "^1.0.0" "balanced-match": "^1.0.0"
} }
}, },
"node_modules/braces": {
"version": "3.0.3",
"resolved": "http://mirrors.tencentyun.com/npm/braces/-/braces-3.0.3.tgz",
"integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
"dev": true,
"dependencies": {
"fill-range": "^7.1.1"
},
"engines": {
"node": ">=8"
}
},
"node_modules/chokidar": {
"version": "3.6.0",
"resolved": "http://mirrors.tencentyun.com/npm/chokidar/-/chokidar-3.6.0.tgz",
"integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==",
"dev": true,
"dependencies": {
"anymatch": "~3.1.2",
"braces": "~3.0.2",
"glob-parent": "~5.1.2",
"is-binary-path": "~2.1.0",
"is-glob": "~4.0.1",
"normalize-path": "~3.0.0",
"readdirp": "~3.6.0"
},
"engines": {
"node": ">= 8.10.0"
},
"funding": {
"url": "https://paulmillr.com/funding/"
},
"optionalDependencies": {
"fsevents": "~2.3.2"
}
},
"node_modules/confbox": {
"version": "0.1.8",
"resolved": "http://mirrors.tencentyun.com/npm/confbox/-/confbox-0.1.8.tgz",
"integrity": "sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w==",
"dev": true
},
"node_modules/csstype": { "node_modules/csstype": {
"version": "3.2.3", "version": "3.2.3",
"resolved": "http://mirrors.tencentyun.com/npm/csstype/-/csstype-3.2.3.tgz", "resolved": "http://mirrors.tencentyun.com/npm/csstype/-/csstype-3.2.3.tgz",
@@ -1194,6 +1391,23 @@
"integrity": "sha512-e/1zu3xH5MQryN2zdVaF0OrdNLUbvWxzMbi+iNA6Bky7l1RoP8a2fIbRocyHclXt/arDrrR6lL3TqFD9pMQTsg==", "integrity": "sha512-e/1zu3xH5MQryN2zdVaF0OrdNLUbvWxzMbi+iNA6Bky7l1RoP8a2fIbRocyHclXt/arDrrR6lL3TqFD9pMQTsg==",
"dev": true "dev": true
}, },
"node_modules/debug": {
"version": "4.4.3",
"resolved": "http://mirrors.tencentyun.com/npm/debug/-/debug-4.4.3.tgz",
"integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
"dev": true,
"dependencies": {
"ms": "^2.1.3"
},
"engines": {
"node": ">=6.0"
},
"peerDependenciesMeta": {
"supports-color": {
"optional": true
}
}
},
"node_modules/dompurify": { "node_modules/dompurify": {
"version": "3.4.15", "version": "3.4.15",
"resolved": "http://mirrors.tencentyun.com/npm/dompurify/-/dompurify-3.4.15.tgz", "resolved": "http://mirrors.tencentyun.com/npm/dompurify/-/dompurify-3.4.15.tgz",
@@ -1288,11 +1502,55 @@
"@esbuild/win32-x64": "0.25.12" "@esbuild/win32-x64": "0.25.12"
} }
}, },
"node_modules/escape-string-regexp": {
"version": "5.0.0",
"resolved": "http://mirrors.tencentyun.com/npm/escape-string-regexp/-/escape-string-regexp-5.0.0.tgz",
"integrity": "sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw==",
"dev": true,
"license": "MIT",
"engines": {
"node": ">=12"
},
"funding": {
"url": "https://github.com/sponsors/sindresorhus"
}
},
"node_modules/estree-walker": { "node_modules/estree-walker": {
"version": "2.0.2", "version": "2.0.2",
"resolved": "http://mirrors.tencentyun.com/npm/estree-walker/-/estree-walker-2.0.2.tgz", "resolved": "http://mirrors.tencentyun.com/npm/estree-walker/-/estree-walker-2.0.2.tgz",
"integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==" "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w=="
}, },
"node_modules/exsolve": {
"version": "1.1.1",
"resolved": "http://mirrors.tencentyun.com/npm/exsolve/-/exsolve-1.1.1.tgz",
"integrity": "sha512-9U/jZUgjnSGyntRr6y5Muu1MJcwFl6kPu7k8qLF0IMNfLqvw0NZ4nnVDq0RVoZ0RvCyumib4Ez3KYrVfilrw+g==",
"dev": true
},
"node_modules/fast-glob": {
"version": "3.3.3",
"resolved": "http://mirrors.tencentyun.com/npm/fast-glob/-/fast-glob-3.3.3.tgz",
"integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==",
"dev": true,
"dependencies": {
"@nodelib/fs.stat": "^2.0.2",
"@nodelib/fs.walk": "^1.2.3",
"glob-parent": "^5.1.2",
"merge2": "^1.3.0",
"micromatch": "^4.0.8"
},
"engines": {
"node": ">=8.6.0"
}
},
"node_modules/fastq": {
"version": "1.20.3",
"resolved": "http://mirrors.tencentyun.com/npm/fastq/-/fastq-1.20.3.tgz",
"integrity": "sha512-XKv5nnLs6nLF71NgiKJLIZFLkPyIEuOselLG7ujZnGrRfQK8HpvY+WqKhAJUAdLomwVHErVS4LfxFlPq0/FTAw==",
"dev": true,
"dependencies": {
"reusify": "^1.0.4"
}
},
"node_modules/fdir": { "node_modules/fdir": {
"version": "6.5.0", "version": "6.5.0",
"resolved": "http://mirrors.tencentyun.com/npm/fdir/-/fdir-6.5.0.tgz", "resolved": "http://mirrors.tencentyun.com/npm/fdir/-/fdir-6.5.0.tgz",
@@ -1310,6 +1568,18 @@
} }
} }
}, },
"node_modules/fill-range": {
"version": "7.1.1",
"resolved": "http://mirrors.tencentyun.com/npm/fill-range/-/fill-range-7.1.1.tgz",
"integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
"dev": true,
"dependencies": {
"to-regex-range": "^5.0.1"
},
"engines": {
"node": ">=8"
}
},
"node_modules/fsevents": { "node_modules/fsevents": {
"version": "2.3.3", "version": "2.3.3",
"resolved": "http://mirrors.tencentyun.com/npm/fsevents/-/fsevents-2.3.3.tgz", "resolved": "http://mirrors.tencentyun.com/npm/fsevents/-/fsevents-2.3.3.tgz",
@@ -1324,6 +1594,18 @@
"node": "^8.16.0 || ^10.6.0 || >=11.0.0" "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
} }
}, },
"node_modules/glob-parent": {
"version": "5.1.2",
"resolved": "http://mirrors.tencentyun.com/npm/glob-parent/-/glob-parent-5.1.2.tgz",
"integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
"dev": true,
"dependencies": {
"is-glob": "^4.0.1"
},
"engines": {
"node": ">= 6"
}
},
"node_modules/he": { "node_modules/he": {
"version": "1.2.0", "version": "1.2.0",
"resolved": "http://mirrors.tencentyun.com/npm/he/-/he-1.2.0.tgz", "resolved": "http://mirrors.tencentyun.com/npm/he/-/he-1.2.0.tgz",
@@ -1341,6 +1623,70 @@
"node": ">=12.0.0" "node": ">=12.0.0"
} }
}, },
"node_modules/is-binary-path": {
"version": "2.1.0",
"resolved": "http://mirrors.tencentyun.com/npm/is-binary-path/-/is-binary-path-2.1.0.tgz",
"integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
"dev": true,
"dependencies": {
"binary-extensions": "^2.0.0"
},
"engines": {
"node": ">=8"
}
},
"node_modules/is-extglob": {
"version": "2.1.1",
"resolved": "http://mirrors.tencentyun.com/npm/is-extglob/-/is-extglob-2.1.1.tgz",
"integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
"dev": true,
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/is-glob": {
"version": "4.0.3",
"resolved": "http://mirrors.tencentyun.com/npm/is-glob/-/is-glob-4.0.3.tgz",
"integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
"dev": true,
"dependencies": {
"is-extglob": "^2.1.1"
},
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/is-number": {
"version": "7.0.0",
"resolved": "http://mirrors.tencentyun.com/npm/is-number/-/is-number-7.0.0.tgz",
"integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
"dev": true,
"engines": {
"node": ">=0.12.0"
}
},
"node_modules/js-tokens": {
"version": "9.0.1",
"resolved": "http://mirrors.tencentyun.com/npm/js-tokens/-/js-tokens-9.0.1.tgz",
"integrity": "sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ==",
"dev": true
},
"node_modules/local-pkg": {
"version": "0.5.1",
"resolved": "http://mirrors.tencentyun.com/npm/local-pkg/-/local-pkg-0.5.1.tgz",
"integrity": "sha512-9rrA30MRRP3gBD3HTGnC6cDFpaE1kVDWxWgqWJUN0RvDNAo+Nz/9GxB+nHOH0ifbVFy0hSA1V6vFDvnx54lTEQ==",
"dev": true,
"dependencies": {
"mlly": "^1.7.3",
"pkg-types": "^1.2.1"
},
"engines": {
"node": ">=14"
},
"funding": {
"url": "https://github.com/sponsors/antfu"
}
},
"node_modules/lodash": { "node_modules/lodash": {
"version": "4.18.1", "version": "4.18.1",
"resolved": "http://mirrors.tencentyun.com/npm/lodash/-/lodash-4.18.1.tgz", "resolved": "http://mirrors.tencentyun.com/npm/lodash/-/lodash-4.18.1.tgz",
@@ -1394,6 +1740,40 @@
"resolved": "http://mirrors.tencentyun.com/npm/memoize-one/-/memoize-one-6.0.0.tgz", "resolved": "http://mirrors.tencentyun.com/npm/memoize-one/-/memoize-one-6.0.0.tgz",
"integrity": "sha512-rkpe71W0N0c0Xz6QD0eJETuWAJGnJ9afsl1srmwPrI+yBCkge5EycXXbYRyvL29zZVUWQCY7InPRCv3GDXuZNw==" "integrity": "sha512-rkpe71W0N0c0Xz6QD0eJETuWAJGnJ9afsl1srmwPrI+yBCkge5EycXXbYRyvL29zZVUWQCY7InPRCv3GDXuZNw=="
}, },
"node_modules/merge2": {
"version": "1.4.1",
"resolved": "http://mirrors.tencentyun.com/npm/merge2/-/merge2-1.4.1.tgz",
"integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==",
"dev": true,
"engines": {
"node": ">= 8"
}
},
"node_modules/micromatch": {
"version": "4.0.8",
"resolved": "http://mirrors.tencentyun.com/npm/micromatch/-/micromatch-4.0.8.tgz",
"integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
"dev": true,
"dependencies": {
"braces": "^3.0.3",
"picomatch": "^2.3.1"
},
"engines": {
"node": ">=8.6"
}
},
"node_modules/micromatch/node_modules/picomatch": {
"version": "2.3.2",
"resolved": "http://mirrors.tencentyun.com/npm/picomatch/-/picomatch-2.3.2.tgz",
"integrity": "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==",
"dev": true,
"engines": {
"node": ">=8.6"
},
"funding": {
"url": "https://github.com/sponsors/jonschlinkert"
}
},
"node_modules/minimatch": { "node_modules/minimatch": {
"version": "9.0.9", "version": "9.0.9",
"resolved": "http://mirrors.tencentyun.com/npm/minimatch/-/minimatch-9.0.9.tgz", "resolved": "http://mirrors.tencentyun.com/npm/minimatch/-/minimatch-9.0.9.tgz",
@@ -1409,6 +1789,24 @@
"url": "https://github.com/sponsors/isaacs" "url": "https://github.com/sponsors/isaacs"
} }
}, },
"node_modules/mlly": {
"version": "1.8.2",
"resolved": "http://mirrors.tencentyun.com/npm/mlly/-/mlly-1.8.2.tgz",
"integrity": "sha512-d+ObxMQFmbt10sretNDytwt85VrbkhhUA/JBGm1MPaWJ65Cl4wOgLaB1NYvJSZ0Ef03MMEU/0xpPMXUIQ29UfA==",
"dev": true,
"dependencies": {
"acorn": "^8.16.0",
"pathe": "^2.0.3",
"pkg-types": "^1.3.1",
"ufo": "^1.6.3"
}
},
"node_modules/ms": {
"version": "2.1.3",
"resolved": "http://mirrors.tencentyun.com/npm/ms/-/ms-2.1.3.tgz",
"integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
"dev": true
},
"node_modules/muggle-string": { "node_modules/muggle-string": {
"version": "0.4.1", "version": "0.4.1",
"resolved": "http://mirrors.tencentyun.com/npm/muggle-string/-/muggle-string-0.4.1.tgz", "resolved": "http://mirrors.tencentyun.com/npm/muggle-string/-/muggle-string-0.4.1.tgz",
@@ -1432,6 +1830,15 @@
"node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
} }
}, },
"node_modules/normalize-path": {
"version": "3.0.0",
"resolved": "http://mirrors.tencentyun.com/npm/normalize-path/-/normalize-path-3.0.0.tgz",
"integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
"dev": true,
"engines": {
"node": ">=0.10.0"
}
},
"node_modules/normalize-wheel-es": { "node_modules/normalize-wheel-es": {
"version": "1.2.0", "version": "1.2.0",
"resolved": "http://mirrors.tencentyun.com/npm/normalize-wheel-es/-/normalize-wheel-es-1.2.0.tgz", "resolved": "http://mirrors.tencentyun.com/npm/normalize-wheel-es/-/normalize-wheel-es-1.2.0.tgz",
@@ -1443,6 +1850,12 @@
"integrity": "sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g==", "integrity": "sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g==",
"dev": true "dev": true
}, },
"node_modules/pathe": {
"version": "2.0.3",
"resolved": "http://mirrors.tencentyun.com/npm/pathe/-/pathe-2.0.3.tgz",
"integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
"dev": true
},
"node_modules/picocolors": { "node_modules/picocolors": {
"version": "1.1.1", "version": "1.1.1",
"resolved": "http://mirrors.tencentyun.com/npm/picocolors/-/picocolors-1.1.1.tgz", "resolved": "http://mirrors.tencentyun.com/npm/picocolors/-/picocolors-1.1.1.tgz",
@@ -1481,6 +1894,17 @@
} }
} }
}, },
"node_modules/pkg-types": {
"version": "1.3.1",
"resolved": "http://mirrors.tencentyun.com/npm/pkg-types/-/pkg-types-1.3.1.tgz",
"integrity": "sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ==",
"dev": true,
"dependencies": {
"confbox": "^0.1.8",
"mlly": "^1.7.4",
"pathe": "^2.0.1"
}
},
"node_modules/postcss": { "node_modules/postcss": {
"version": "8.5.28", "version": "8.5.28",
"resolved": "http://mirrors.tencentyun.com/npm/postcss/-/postcss-8.5.28.tgz", "resolved": "http://mirrors.tencentyun.com/npm/postcss/-/postcss-8.5.28.tgz",
@@ -1508,6 +1932,76 @@
"node": "^10 || ^12 || >=14" "node": "^10 || ^12 || >=14"
} }
}, },
"node_modules/quansync": {
"version": "0.2.11",
"resolved": "http://mirrors.tencentyun.com/npm/quansync/-/quansync-0.2.11.tgz",
"integrity": "sha512-AifT7QEbW9Nri4tAwR5M/uzpBuqfZf+zwaEM/QkzEjj7NBuFD2rBuy0K3dE+8wltbezDV7JMA0WfnCPYRSYbXA==",
"dev": true,
"funding": [
{
"type": "individual",
"url": "https://github.com/sponsors/antfu"
},
{
"type": "individual",
"url": "https://github.com/sponsors/sxzz"
}
]
},
"node_modules/queue-microtask": {
"version": "1.2.3",
"resolved": "http://mirrors.tencentyun.com/npm/queue-microtask/-/queue-microtask-1.2.3.tgz",
"integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==",
"dev": true,
"funding": [
{
"type": "github",
"url": "https://github.com/sponsors/feross"
},
{
"type": "patreon",
"url": "https://www.patreon.com/feross"
},
{
"type": "consulting",
"url": "https://feross.org/support"
}
]
},
"node_modules/readdirp": {
"version": "3.6.0",
"resolved": "http://mirrors.tencentyun.com/npm/readdirp/-/readdirp-3.6.0.tgz",
"integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==",
"dev": true,
"dependencies": {
"picomatch": "^2.2.1"
},
"engines": {
"node": ">=8.10.0"
}
},
"node_modules/readdirp/node_modules/picomatch": {
"version": "2.3.2",
"resolved": "http://mirrors.tencentyun.com/npm/picomatch/-/picomatch-2.3.2.tgz",
"integrity": "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==",
"dev": true,
"engines": {
"node": ">=8.6"
},
"funding": {
"url": "https://github.com/sponsors/jonschlinkert"
}
},
"node_modules/reusify": {
"version": "1.1.0",
"resolved": "http://mirrors.tencentyun.com/npm/reusify/-/reusify-1.1.0.tgz",
"integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==",
"dev": true,
"engines": {
"iojs": ">=1.0.0",
"node": ">=0.10.0"
}
},
"node_modules/rollup": { "node_modules/rollup": {
"version": "4.63.1", "version": "4.63.1",
"resolved": "http://mirrors.tencentyun.com/npm/rollup/-/rollup-4.63.1.tgz", "resolved": "http://mirrors.tencentyun.com/npm/rollup/-/rollup-4.63.1.tgz",
@@ -1553,6 +2047,35 @@
"fsevents": "~2.3.2" "fsevents": "~2.3.2"
} }
}, },
"node_modules/run-parallel": {
"version": "1.2.0",
"resolved": "http://mirrors.tencentyun.com/npm/run-parallel/-/run-parallel-1.2.0.tgz",
"integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==",
"dev": true,
"funding": [
{
"type": "github",
"url": "https://github.com/sponsors/feross"
},
{
"type": "patreon",
"url": "https://www.patreon.com/feross"
},
{
"type": "consulting",
"url": "https://feross.org/support"
}
],
"dependencies": {
"queue-microtask": "^1.2.2"
}
},
"node_modules/scule": {
"version": "1.3.0",
"resolved": "http://mirrors.tencentyun.com/npm/scule/-/scule-1.3.0.tgz",
"integrity": "sha512-6FtHJEvt+pVMIB9IBY+IcCJ6Z5f1iQnytgyfKMhDKgmzYG+TeH/wx1y3l27rshSbLiSanrR9ffZDrEsmjlQF2g==",
"dev": true
},
"node_modules/source-map-js": { "node_modules/source-map-js": {
"version": "1.2.1", "version": "1.2.1",
"resolved": "http://mirrors.tencentyun.com/npm/source-map-js/-/source-map-js-1.2.1.tgz", "resolved": "http://mirrors.tencentyun.com/npm/source-map-js/-/source-map-js-1.2.1.tgz",
@@ -1561,6 +2084,18 @@
"node": ">=0.10.0" "node": ">=0.10.0"
} }
}, },
"node_modules/strip-literal": {
"version": "2.1.1",
"resolved": "http://mirrors.tencentyun.com/npm/strip-literal/-/strip-literal-2.1.1.tgz",
"integrity": "sha512-631UJ6O00eNGfMiWG78ck80dfBab8X6IVFB51jZK5Icd7XAs60Z5y7QdSd/wGIklnWvRbUNloVzhOKKmutxQ6Q==",
"dev": true,
"dependencies": {
"js-tokens": "^9.0.1"
},
"funding": {
"url": "https://github.com/sponsors/antfu"
}
},
"node_modules/tinyglobby": { "node_modules/tinyglobby": {
"version": "0.2.17", "version": "0.2.17",
"resolved": "http://mirrors.tencentyun.com/npm/tinyglobby/-/tinyglobby-0.2.17.tgz", "resolved": "http://mirrors.tencentyun.com/npm/tinyglobby/-/tinyglobby-0.2.17.tgz",
@@ -1577,6 +2112,18 @@
"url": "https://github.com/sponsors/SuperchupuDev" "url": "https://github.com/sponsors/SuperchupuDev"
} }
}, },
"node_modules/to-regex-range": {
"version": "5.0.1",
"resolved": "http://mirrors.tencentyun.com/npm/to-regex-range/-/to-regex-range-5.0.1.tgz",
"integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
"dev": true,
"dependencies": {
"is-number": "^7.0.0"
},
"engines": {
"node": ">=8.0"
}
},
"node_modules/tslib": { "node_modules/tslib": {
"version": "2.3.0", "version": "2.3.0",
"resolved": "http://mirrors.tencentyun.com/npm/tslib/-/tslib-2.3.0.tgz", "resolved": "http://mirrors.tencentyun.com/npm/tslib/-/tslib-2.3.0.tgz",
@@ -1596,6 +2143,175 @@
"node": ">=14.17" "node": ">=14.17"
} }
}, },
"node_modules/ufo": {
"version": "1.6.4",
"resolved": "http://mirrors.tencentyun.com/npm/ufo/-/ufo-1.6.4.tgz",
"integrity": "sha512-JFNbkD1Svwe0KvGi8GOeLcP4kAWQ609twvCdcHxq1oSL8svv39ZuSvajcD8B+5D0eL4+s1Is2D/O6KN3qcTeRA==",
"dev": true
},
"node_modules/unimport": {
"version": "3.14.6",
"resolved": "http://mirrors.tencentyun.com/npm/unimport/-/unimport-3.14.6.tgz",
"integrity": "sha512-CYvbDaTT04Rh8bmD8jz3WPmHYZRG/NnvYVzwD6V1YAlvvKROlAeNDUBhkBGzNav2RKaeuXvlWYaa1V4Lfi/O0g==",
"dev": true,
"dependencies": {
"@rollup/pluginutils": "^5.1.4",
"acorn": "^8.14.0",
"escape-string-regexp": "^5.0.0",
"estree-walker": "^3.0.3",
"fast-glob": "^3.3.3",
"local-pkg": "^1.0.0",
"magic-string": "^0.30.17",
"mlly": "^1.7.4",
"pathe": "^2.0.1",
"picomatch": "^4.0.2",
"pkg-types": "^1.3.0",
"scule": "^1.3.0",
"strip-literal": "^2.1.1",
"unplugin": "^1.16.1"
}
},
"node_modules/unimport/node_modules/confbox": {
"version": "0.3.1",
"resolved": "http://mirrors.tencentyun.com/npm/confbox/-/confbox-0.3.1.tgz",
"integrity": "sha512-cKUSoKa8YxFZZSmraVi7onONx3amu77ngK3kGpsYHDH7drPwCRkQE1RYMPlLRrMtnciRj274XNRxcHxnKmDSnA==",
"dev": true
},
"node_modules/unimport/node_modules/estree-walker": {
"version": "3.0.3",
"resolved": "http://mirrors.tencentyun.com/npm/estree-walker/-/estree-walker-3.0.3.tgz",
"integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==",
"dev": true,
"dependencies": {
"@types/estree": "^1.0.0"
}
},
"node_modules/unimport/node_modules/local-pkg": {
"version": "1.2.1",
"resolved": "http://mirrors.tencentyun.com/npm/local-pkg/-/local-pkg-1.2.1.tgz",
"integrity": "sha512-++gUqRDEvcnN6Zhqrr+y/CkVEHhlrR96vZn3nZZPYzMcBUyBtTKzB9NadClFIsIVSsu+3i9tfk/erqy9kAmt7Q==",
"dev": true,
"dependencies": {
"mlly": "^1.7.4",
"pkg-types": "^2.3.0",
"quansync": "^0.2.11"
},
"engines": {
"node": ">=14"
},
"funding": {
"url": "https://github.com/sponsors/antfu"
}
},
"node_modules/unimport/node_modules/local-pkg/node_modules/pkg-types": {
"version": "2.3.3",
"resolved": "http://mirrors.tencentyun.com/npm/pkg-types/-/pkg-types-2.3.3.tgz",
"integrity": "sha512-j/lCFdcppV0JxWpCEITdbDltBxPP6cHT+yNJ6Go2OgoSA9518X847X9z0p6LtA4Nc16+eQzCZjRrWanTGvHJ5w==",
"dev": true,
"dependencies": {
"confbox": "^0.3.1",
"exsolve": "^1.1.1",
"pathe": "^2.0.3"
}
},
"node_modules/unimport/node_modules/unplugin": {
"version": "1.16.1",
"resolved": "http://mirrors.tencentyun.com/npm/unplugin/-/unplugin-1.16.1.tgz",
"integrity": "sha512-4/u/j4FrCKdi17jaxuJA0jClGxB1AvU2hw/IuayPc4ay1XGaJs/rbb4v5WKwAjNifjmXK9PIFyuPiaK8azyR9w==",
"dev": true,
"dependencies": {
"acorn": "^8.14.0",
"webpack-virtual-modules": "^0.6.2"
},
"engines": {
"node": ">=14.0.0"
}
},
"node_modules/unplugin": {
"version": "2.3.11",
"resolved": "http://mirrors.tencentyun.com/npm/unplugin/-/unplugin-2.3.11.tgz",
"integrity": "sha512-5uKD0nqiYVzlmCRs01Fhs2BdkEgBS3SAVP6ndrBsuK42iC2+JHyxM05Rm9G8+5mkmRtzMZGY8Ct5+mliZxU/Ww==",
"dev": true,
"dependencies": {
"@jridgewell/remapping": "^2.3.5",
"acorn": "^8.15.0",
"picomatch": "^4.0.3",
"webpack-virtual-modules": "^0.6.2"
},
"engines": {
"node": ">=18.12.0"
}
},
"node_modules/unplugin-auto-import": {
"version": "0.19.0",
"resolved": "http://mirrors.tencentyun.com/npm/unplugin-auto-import/-/unplugin-auto-import-0.19.0.tgz",
"integrity": "sha512-W97gTDEWu/L1EcKCXY5Ni8bsMW1E9kv12wYQv3mYpd7zcFctXYlLKsqeva6sbCQbzS8t9AG/XdU5/WkEJKPlFw==",
"dev": true,
"dependencies": {
"@antfu/utils": "^0.7.10",
"@rollup/pluginutils": "^5.1.3",
"local-pkg": "^0.5.1",
"magic-string": "^0.30.15",
"picomatch": "^4.0.2",
"unimport": "^3.14.5",
"unplugin": "^2.1.0"
},
"engines": {
"node": ">=14"
},
"funding": {
"url": "https://github.com/sponsors/antfu"
},
"peerDependencies": {
"@nuxt/kit": "^3.2.2",
"@vueuse/core": "*"
},
"peerDependenciesMeta": {
"@nuxt/kit": {
"optional": true
},
"@vueuse/core": {
"optional": true
}
}
},
"node_modules/unplugin-vue-components": {
"version": "0.28.0",
"resolved": "http://mirrors.tencentyun.com/npm/unplugin-vue-components/-/unplugin-vue-components-0.28.0.tgz",
"integrity": "sha512-jiTGtJ3JsRFBjgvyilfrX7yUoGKScFgbdNw+6p6kEXU+Spf/rhxzgvdfuMcvhCcLmflB/dY3pGQshYBVGOUx7Q==",
"dev": true,
"dependencies": {
"@antfu/utils": "^0.7.10",
"@rollup/pluginutils": "^5.1.4",
"chokidar": "^3.6.0",
"debug": "^4.4.0",
"fast-glob": "^3.3.2",
"local-pkg": "^0.5.1",
"magic-string": "^0.30.15",
"minimatch": "^9.0.5",
"mlly": "^1.7.3",
"unplugin": "^2.1.0"
},
"engines": {
"node": ">=14"
},
"funding": {
"url": "https://github.com/sponsors/antfu"
},
"peerDependencies": {
"@babel/parser": "^7.15.8",
"@nuxt/kit": "^3.2.2",
"vue": "2 || 3"
},
"peerDependenciesMeta": {
"@babel/parser": {
"optional": true
},
"@nuxt/kit": {
"optional": true
}
}
},
"node_modules/vite": { "node_modules/vite": {
"version": "6.4.3", "version": "6.4.3",
"resolved": "http://mirrors.tencentyun.com/npm/vite/-/vite-6.4.3.tgz", "resolved": "http://mirrors.tencentyun.com/npm/vite/-/vite-6.4.3.tgz",
@@ -1775,6 +2491,12 @@
"typescript": ">=5.0.0" "typescript": ">=5.0.0"
} }
}, },
"node_modules/webpack-virtual-modules": {
"version": "0.6.2",
"resolved": "http://mirrors.tencentyun.com/npm/webpack-virtual-modules/-/webpack-virtual-modules-0.6.2.tgz",
"integrity": "sha512-66/V2i5hQanC51vBQKPH4aI8NMAcBW59FVBs+rC7eGHupMyfn34q7rZIE+ETlJ+XTevqfUhVVBgSUNSW2flEUQ==",
"dev": true
},
"node_modules/zrender": { "node_modules/zrender": {
"version": "6.1.0", "version": "6.1.0",
"resolved": "http://mirrors.tencentyun.com/npm/zrender/-/zrender-6.1.0.tgz", "resolved": "http://mirrors.tencentyun.com/npm/zrender/-/zrender-6.1.0.tgz",
+2 -1
View File
@@ -12,7 +12,6 @@
"check:i18n": "node scripts/check-i18n.mjs" "check:i18n": "node scripts/check-i18n.mjs"
}, },
"dependencies": { "dependencies": {
"@element-plus/icons-vue": "^2.3.1",
"dompurify": "^3.4.15", "dompurify": "^3.4.15",
"echarts": "^6.1.0", "echarts": "^6.1.0",
"element-plus": "^2.9.1", "element-plus": "^2.9.1",
@@ -27,6 +26,8 @@
"devDependencies": { "devDependencies": {
"@vitejs/plugin-vue": "^5.2.1", "@vitejs/plugin-vue": "^5.2.1",
"typescript": "^5.7.2", "typescript": "^5.7.2",
"unplugin-auto-import": "^0.19.0",
"unplugin-vue-components": "^0.28.0",
"vite": "^6.0.7", "vite": "^6.0.7",
"vue-tsc": "^2.2.12" "vue-tsc": "^2.2.12"
} }
+1 -2
View File
@@ -7,7 +7,6 @@ export interface Meta {
served: string served: string
provider: string provider: string
requested: string requested: string
fallback: boolean
} }
export interface Usage { export interface Usage {
@@ -25,7 +24,7 @@ export interface ChatMessage {
imgThumbs?: string[] // 第十三轮:缩略图 data URI —— 落服务端历史时用它替代原图 imgThumbs?: string[] // 第十三轮:缩略图 data URI —— 落服务端历史时用它替代原图
// (服务端单条 512KB,原图 base64 会被截断成坏图) // (服务端单条 512KB,原图 base64 会被截断成坏图)
reasoning?: string // 推理内容(reasoning_content),单独折叠展示 reasoning?: string // 推理内容(reasoning_content),单独折叠展示
meta?: Meta // 网关元信息(served/provider/fallback) meta?: Meta // 网关元信息(served/provider)
usage?: Usage usage?: Usage
cost?: number // estimated_cost_cny(仅非流式) cost?: number // estimated_cost_cny(仅非流式)
streaming?: boolean // 正在流式输出中 streaming?: boolean // 正在流式输出中
+40 -47
View File
@@ -19,10 +19,10 @@ export default {
control: 'Console', control: 'Console',
more: 'More', more: 'More',
subdashboard: 'Gateway overview · refreshed every 8s', subdashboard: 'Gateway overview · refreshed every 8s',
subchat: 'Vision-ready · route wjd picks the fastest provider', subchat: 'Vision-ready · multi-provider direct routing',
subimages: 'Params on the left, history on the right · downloads proxied by the gateway', subimages: 'Params on the left, history on the right · downloads proxied by the gateway',
subvideos: '720P · 4–12s · async polling', subvideos: '720P · 4–12s · async polling',
submodels: 'Providers / models / route chains', submodels: 'Providers / models / protocol lines',
submetrics: 'Usage & cost · isolated per account', submetrics: 'Usage & cost · isolated per account',
subkeys: 'Up to 3 per account · stored in plaintext, copyable anytime', subkeys: 'Up to 3 per account · stored in plaintext, copyable anytime',
subusers: 'Accounts & roles · admin can inspect others’ logs and assets', subusers: 'Accounts & roles · admin can inspect others’ logs and assets',
@@ -86,8 +86,6 @@ export default {
dashboard: { dashboard: {
modelCount: 'Models', modelCount: 'Models',
providers: 'Providers', providers: 'Providers',
routes: 'Route aliases',
fallback: 'Fallbacks',
inflight: 'In-flight', inflight: 'In-flight',
callsMix: 'Calls ok/fail', callsMix: 'Calls ok/fail',
provShare: 'Provider success share', provShare: 'Provider success share',
@@ -97,7 +95,6 @@ export default {
circuit: 'Circuit', circuit: 'Circuit',
modelCountShort: 'Models', modelCountShort: 'Models',
keySet: 'Key set', keySet: 'Key set',
routeAlias: 'Route aliases',
name: 'Name', name: 'Name',
modelChain: 'Model chain', modelChain: 'Model chain',
gatewayInfo: 'Gateway info', gatewayInfo: 'Gateway info',
@@ -114,7 +111,6 @@ export default {
requests: 'Total requests', requests: 'Total requests',
successRate: 'Success rate', successRate: 'Success rate',
avgLatency: 'Avg latency', avgLatency: 'Avg latency',
fallbackShort: 'Fallbacks',
noteOkFail: 'ok {ok} · fail {fail}', noteOkFail: 'ok {ok} · fail {fail}',
noteFail: '{n} failed', noteFail: '{n} failed',
noteP95: 'highest P95 {v}s', noteP95: 'highest P95 {v}s',
@@ -127,22 +123,21 @@ export default {
noModels: 'No calls recorded yet', noModels: 'No calls recorded yet',
share: 'Share', share: 'Share',
live: 'Live', live: 'Live',
routeChain: 'Availability + speed first', byProtocol: 'Protocol lines',
byProtocolSub: 'Models per line',
modelCountN: '{n} models',
}, },
metrics: { metrics: {
uptime: 'Uptime', uptime: 'Uptime',
inflight: 'In-flight/peak', inflight: 'In-flight/peak',
fallback: 'Fallbacks',
promptTokens: 'Prompt tokens', promptTokens: 'Prompt tokens',
completionTokens: 'Completion tokens', completionTokens: 'Completion tokens',
callsTotal: 'Total calls (ok/fail)', callsTotal: 'Total calls (ok/fail)',
modelCalls: 'Calls per model (success / fail)', modelCalls: 'Calls per model (success / fail)',
provShare: 'Provider success share', provShare: 'Provider success share',
routeVsProvider: 'Route vs provider (success / fail / fallback)',
latency: 'Model latency P50 / P95 (s)', latency: 'Model latency P50 / P95 (s)',
success: 'Success', success: 'Success',
fail: 'Fail', fail: 'Fail',
fallback2: 'Fallback',
ok: 'ok', ok: 'ok',
none: 'None', none: 'None',
circuitStatus: 'Circuit breaker status', circuitStatus: 'Circuit breaker status',
@@ -165,6 +160,7 @@ export default {
failRateNote: 'failure rate {v}%', failRateNote: 'failure rate {v}%',
snapshot: 'Live snapshot', snapshot: 'Live snapshot',
circuitCard: 'Circuit breakers', circuitCard: 'Circuit breakers',
byProvider: 'Calls by provider (success / fail)',
}, },
logs: { logs: {
all: 'All', all: 'All',
@@ -226,20 +222,17 @@ export default {
systemShort: 'System', systemShort: 'System',
visionReady: 'Vision ready · images supported', visionReady: 'Vision ready · images supported',
visionOff: 'This model does not accept images', visionOff: 'This model does not accept images',
chainLabel: '{id} ({chain})',
emptyChain: 'empty', emptyChain: 'empty',
phDefault: 'Default', phDefault: 'Default',
phOptional: 'Optional', phOptional: 'Optional',
totalTokens: 'Total {n}', totalTokens: 'Total {n}',
uploadedImage: 'Uploaded image', uploadedImage: 'Uploaded image',
reasoningTag: 'Reasoning', reasoningTag: 'Reasoning',
routeGroup: 'Routes (auto fallback)',
textModels: 'Text models', textModels: 'Text models',
params: 'Parameters', params: 'Parameters',
clear: 'Clear', clear: 'Clear',
generating: 'Generating…', generating: 'Generating…',
empty: 'Start a conversation with the gateway (any text model or route wjd)', empty: 'Start a conversation with the gateway (pick a model below)',
fallback: 'Fallback · by {provider}',
servedBy: 'by {provider}', servedBy: 'by {provider}',
requestedTo: 'requested {req} → served {served}', requestedTo: 'requested {req} → served {served}',
reasoning: 'Reasoning', reasoning: 'Reasoning',
@@ -266,6 +259,7 @@ export default {
streaming: 'Streaming output', streaming: 'Streaming output',
system: 'System prompt (prepended to each conversation)', system: 'System prompt (prepended to each conversation)',
loadModelsErr: 'Failed to load models: {msg}', loadModelsErr: 'Failed to load models: {msg}',
pickModel: 'Pick a model',
}, },
images: { images: {
historyTitle: 'History', historyTitle: 'History',
@@ -363,10 +357,8 @@ export default {
loadErr: 'Failed to load videos', loadErr: 'Failed to load videos',
}, },
models: { models: {
routeAliasTitle: 'Route aliases (auto fallback chain)',
modelListTitle: 'Model list', modelListTitle: 'Model list',
name: 'Name', name: 'Name',
chainLabel: 'Model chain (tried in order, auto fallback on failure)',
providerCount: 'Providers', providerCount: 'Providers',
id: 'Model ID', id: 'Model ID',
type: 'Type', type: 'Type',
@@ -375,12 +367,10 @@ export default {
text: 'Text', text: 'Text',
image: 'Image', image: 'Image',
video: 'Video', video: 'Video',
route: 'Route',
model: 'Models', model: 'Models',
textModels: 'Text models', textModels: 'Text models',
imageModels: 'Image models', imageModels: 'Image models',
videoModels: 'Video models', videoModels: 'Video models',
routes: 'Route aliases',
providers: 'Providers', providers: 'Providers',
loadErr: 'Failed to load models', loadErr: 'Failed to load models',
capability: 'Capability', capability: 'Capability',
@@ -391,10 +381,8 @@ export default {
providerCard: 'Providers', providerCard: 'Providers',
keyOk: 'Key configured', keyOk: 'Key configured',
keyMissing: 'Key missing', keyMissing: 'Key missing',
routeCount: '{n} routes',
chainCount: '{n} models', chainCount: '{n} models',
providerCount2: '{n} providers', providerCount2: '{n} providers',
noRoute: 'No route alias configured',
speedtest: 'Test speed', speedtest: 'Test speed',
testing: 'Probing latency of every text model…', testing: 'Probing latency of every text model…',
testingShort: 'Testing…', testingShort: 'Testing…',
@@ -403,6 +391,16 @@ export default {
failed: 'Failed', failed: 'Failed',
speedtestDone: 'Speed test done, {n} models', speedtestDone: 'Speed test done, {n} models',
speedtestFail: 'Speed test failed', speedtestFail: 'Speed test failed',
speedtestHint: 'Latency probed per protocol line',
textModelCount: '{n} text models',
// Round 27: the supported-formats column (three protocol lines). Line names are the
// vendors' own endpoint names, so they are not translated.
protocols: 'Supported formats',
protocolHint: 'Which lines this model accepts: chat/completions (OpenAI-compatible), messages (Anthropic), responses (OpenAI Responses). Any other format is rejected with 400 at the gateway edge — the gateway never translates between formats and never silently swaps in another model',
protocolNa: 'N/A',
protocolNaHint: 'Image / video models use the dedicated /v1/images/generations and /v1/videos endpoints and are not tied to the three protocol lines',
protocolHintRow: 'Supported formats: {lines} ',
probedLine: 'probed via {p}',
}, },
history: { history: {
saveFail: 'History could not be saved to the gateway (it may be lost on refresh) — check your session or network', saveFail: 'History could not be saved to the gateway (it may be lost on refresh) — check your session or network',
@@ -435,7 +433,7 @@ export default {
logoutBtn: 'Sign out', logoutBtn: 'Sign out',
chatDefaults: 'Chat default parameters', chatDefaults: 'Chat default parameters',
defsTip: 'Used as defaults for a new chat (already-adjusted params are untouched).', defsTip: 'Used as defaults for a new chat (already-adjusted params are untouched).',
defaultModel: 'Default model / route', defaultModel: 'Default model',
temperature: 'Temperature', temperature: 'Temperature',
topP: 'top_p', topP: 'top_p',
maxTokens: 'max_tokens (empty = gateway default)', maxTokens: 'max_tokens (empty = gateway default)',
@@ -448,7 +446,7 @@ export default {
modelsCount: 'Models', modelsCount: 'Models',
userManagement: 'Account management (admin)', userManagement: 'Account management (admin)',
gwConfigBtn: 'Open', gwConfigBtn: 'Open',
gwConfigSub: 'Tune gateway / providers / routes / pricing — applied on save', gwConfigSub: 'Tune gateway / providers / pricing — applied on save',
gwConfig: 'Gateway config (admin)', gwConfig: 'Gateway config (admin)',
userCol: 'User', userCol: 'User',
roleCol: 'Role', roleCol: 'Role',
@@ -504,38 +502,50 @@ export default {
auth: 'Auth', auth: 'Auth',
authVal: 'Header: Authorization: Bearer <your API Key>', authVal: 'Header: Authorization: Bearer <your API Key>',
modelPick: 'Model selection', modelPick: 'Model selection',
modelPickVal: 'model: wjd = route alias (auto-fallback by availability + speed, recommended); or a concrete model id to bypass fallback', modelPickVal: 'model takes a real model id (e.g. agnes-3.0-flash). Each of the three lines forwards its own native protocol and the gateway never translates formats, so a wrong line returns 400 (listing the lines that model supports)',
formats: 'Supported formats',
formatsVal: 'Which lines a model accepts is listed in the Supported formats column on the Providers & Models page: chat/completions, messages, responses. Each line is forwarded verbatim (no field rewriting, no cross-format translation), so write your URL and body exactly as the vendor SDK expects',
ctype: 'Request format', ctype: 'Request format',
ctypeVal: 'application/json; chat supports SSE streaming (stream: true)', ctypeVal: 'application/json; chat supports SSE streaming (stream: true)',
endpoints: 'Endpoints', endpoints: 'Endpoints',
colMethod: 'Method', colMethod: 'Method',
colPath: 'Path', colPath: 'Path',
colDesc: 'Description', colDesc: 'Description',
epModels: 'Models and routes (with a vision flag)', epModels: 'Models (with vision flag and supported protocol lines)',
epChat: 'Chat completions (OpenAI compatible, streaming + image input)', epChat: 'Chat completions (OpenAI compatible, streaming + image input)',
epMessages: 'Chat completions (Anthropic Messages format, forwarded verbatim)',
epResponses: 'Chat completions (OpenAI Responses format, forwarded verbatim)',
epImages: 'Image generation / image-to-image (n must be 1; call repeatedly for more)', epImages: 'Image generation / image-to-image (n must be 1; call repeatedly for more)',
epVideoCreate: 'Video generation (async, returns video_id immediately)', epVideoCreate: 'Video generation (async, returns video_id immediately)',
epVideoPoll: 'Poll a video task (every ~5s; returns throttled when upstream rate-limits)', epVideoPoll: 'Poll a video task (every ~5s; returns throttled when upstream rate-limits)',
epDownload: 'Download generated images / videos through the gateway (bypasses upstream hotlink protection and expiry; allow-listed hosts only)',
epHistory: 'Read your own history (images / videos / chats)', epHistory: 'Read your own history (images / videos / chats)',
epLogs: 'Your own call log', epLogs: 'Your own call log',
epMetrics: 'Metrics snapshot (incl. circuit breaker states)', epMetrics: 'Metrics snapshot (incl. circuit breaker states)',
epHealth: 'Health check (version / provider status)', epHealth: 'Health check (version / provider status)',
exChat: 'Example · chat', exChat: 'Example · chat',
exMessages: 'Example · chat (Anthropic Messages format)',
exResponses: 'Example · chat (OpenAI Responses format)',
exImg: 'Example · image generation', exImg: 'Example · image generation',
exVideo: 'Example · video generation + polling', exVideo: 'Example · video generation + polling',
exPy: 'Example · Python (OpenAI SDK compatible)', exPy: 'Example · Python (OpenAI SDK compatible)',
// Comments / sample payloads inside the code samples (mirror of zh.ts) // Comments / sample payloads inside the code samples (mirror of zh.ts)
sampleChat: 'Hello, introduce yourself', sampleChat: 'Hello, introduce yourself',
sampleModelMessages: 'minimax-m2.7',
sampleModelResponses: 'grok-4.6',
sampleImg: 'Neon city street at night', sampleImg: 'Neon city street at night',
sampleVideo: 'Slow camera push-in', sampleVideo: 'Slow camera push-in',
sampleStep1: 'submit a task (async, returns video_id immediately)', sampleStep1: 'submit a task (async, returns video_id immediately)',
sampleStep2: 'poll every 5s (a throttled reply means wait, then retry)', sampleStep2: 'poll every 5s (a throttled reply means wait, then retry)',
notes: 'Notes', notes: 'Notes',
noteVision: 'For image input use a vision model (agnes-3.0-flash, marked "Vision" in the list); with the wjd alias the gateway puts vision models first.', noteVision: 'For image input use a vision model (agnes-3.0-flash, marked Vision in the list). The gateway no longer swaps models for you: a non-vision model receives the request as-is',
noteCross: 'No cross-format translation: which lines a model accepts is decided by the Supported formats column on the Providers & Models page (e.g. minimax-m2.7 only speaks messages, grok-4.6 only speaks responses). A wrong format is rejected with 400 at the gateway edge, listing the lines that model does support — your request is never silently rewritten, and no other model is swapped in',
noteConvId: 'Optional conversation_id (chat-style requests): reusing the same string for one conversation raises the upstream prompt-cache hit rate. It is a gateway-internal field and is never forwarded as-is — the gateway derives the real session id per account, so accounts never share a cache namespace; omit it and each call gets a random one',
noteN1: 'Image n must be 1 (upstream limit) — call once per image; n≠1 is rejected with a clean 400.', noteN1: 'Image n must be 1 (upstream limit) — call once per image; n≠1 is rejected with a clean 400.',
noteVideo: 'Video seconds: 4–12 only; size is fixed at 720P; 6 aspect ratios (21:9/16:9/4:3/1:1/3:4/9:16); mode=text / keyframe / reference.', noteVideo: 'Video seconds: 4–12 only; size is fixed at 720P; 6 aspect ratios (21:9/16:9/4:3/1:1/3:4/9:16); mode=text / keyframe / reference.',
notePoll: 'Do not poll faster than 5s (upstream answers 429 "too frequent"; the gateway returns throttled so you can back off).', notePoll: 'Do not poll faster than 5s (upstream answers 429 "too frequent"; the gateway returns throttled so you can back off).',
noteMedia: 'Assets (reference images / first-last frames / audio / chat images) accept data:image/...;base64,... or a public URL; data URIs avoid exposing the file, but keep each request body under 2MB.', noteMedia: 'Assets (reference images / first-last frames / audio / chat images) accept data:image/...;base64,... or a public URL; data URIs avoid exposing the file, but keep each request body under 2MB.',
noteDownload: 'Upstream image / video URLs may expire or block hotlinking. To save a file, fetch /v1/media/download?url=... with your key and let the gateway retrieve it; URLs outside the allow-list are rejected with 400.',
noteKey: 'If a key leaks, delete it here (401 immediately) or revoke all keys of the account from the Users page.', noteKey: 'If a key leaks, delete it here (401 immediately) or revoke all keys of the account from the Users page.',
noteAudit: 'Every call is logged per account on the Logs page (you see yours; admins can inspect each account from the Users page).', noteAudit: 'Every call is logged per account on the Logs page (you see yours; admins can inspect each account from the Users page).',
copyBase: 'Copy URL', copyBase: 'Copy URL',
@@ -656,17 +666,13 @@ export default {
addItem: 'Add', addItem: 'Add',
addModel: 'Add model', addModel: 'Add model',
addProvider: 'Add provider', addProvider: 'Add provider',
addRoute: 'Add route alias',
addPrice: 'Add pricing', addPrice: 'Add pricing',
delete: 'Delete', delete: 'Delete',
delProvider: 'Delete provider', delProvider: 'Delete provider',
delRoute: 'Delete route',
delConfirm: 'Delete "{name}"? It takes effect once you save.', delConfirm: 'Delete "{name}"? It takes effect once you save.',
needKey: 'Provider key cannot be empty', needKey: 'Provider key cannot be empty',
needRoute: 'Route alias cannot be empty',
dupKey: '"{name}" is duplicated — please rename', dupKey: '"{name}" is duplicated — please rename',
newProvider: '(new provider)', newProvider: '(new provider)',
newRoute: '(new alias)',
unlimited: 'empty = unlimited', unlimited: 'empty = unlimited',
useServerTimeout: 'empty = server.timeout', useServerTimeout: 'empty = server.timeout',
mediaEmpty: 'empty = unsupported', mediaEmpty: 'empty = unsupported',
@@ -683,19 +689,17 @@ export default {
tabServerSub: 'Binding, timeout/retry, rate limits, CORS, session TTL and other runtime switches', tabServerSub: 'Binding, timeout/retry, rate limits, CORS, session TTL and other runtime switches',
tabProviders: 'Providers & models', tabProviders: 'Providers & models',
tabProvidersSub: 'Key source, base URL, image/video endpoints and the model list per provider', tabProvidersSub: 'Key source, base URL, image/video endpoints and the model list per provider',
tabRoutes: 'Routes & circuit',
tabRoutesSub: 'Route aliases with their fallback chains (order = priority) plus the circuit breaker',
tabLog: 'Logs & pricing', tabLog: 'Logs & pricing',
tabLogSub: 'Log level/format/capacity plus model pricing (CNY per million tokens)', tabLogSub: 'Log level/format/capacity plus model pricing (CNY per million tokens)',
tabDownload: 'Download proxy', tabDownload: 'Download proxy',
tabDownloadSub: 'CDN hosts allowed for the download proxy and the per-file size limit', tabDownloadSub: 'CDN hosts allowed for the download proxy and the per-file size limit',
circuit: 'Provider circuit breaker', circuit: 'Provider circuit breaker',
h_circuit: 'A provider that fails to the threshold within the window is skipped for the cooldown; fallback takes over', h_circuit: 'A provider failing to the threshold is cooled down; its requests get 503',
f_c_enabled: 'Enable circuit breaker', f_c_enabled: 'Enable circuit breaker',
f_c_failure_threshold: 'Failure threshold', f_c_failure_threshold: 'Failure threshold',
f_c_cooldown: 'Cooldown (s)', f_c_cooldown: 'Cooldown (s)',
f_c_window: 'Window (s)', f_c_window: 'Window (s)',
h_c_enabled: 'Off = never skip a failing provider (fallback still works)', h_c_enabled: 'Off = never skip a failing provider',
h_c_failure_threshold: 'Opens the circuit once failures reach this count in the window', h_c_failure_threshold: 'Opens the circuit once failures reach this count in the window',
h_c_cooldown: 'While open the provider is skipped; it half-opens automatically after the cooldown', h_c_cooldown: 'While open the provider is skipped; it half-opens automatically after the cooldown',
h_c_window: 'Counts failures inside the window (not necessarily consecutive)', h_c_window: 'Counts failures inside the window (not necessarily consecutive)',
@@ -704,9 +708,9 @@ export default {
f_port: 'Port', f_port: 'Port',
h_port: 'Production uses 8808 and Nginx points at it — change the proxy too', h_port: 'Production uses 8808 and Nginx points at it — change the proxy too',
f_timeout: 'Upstream timeout (s)', f_timeout: 'Upstream timeout (s)',
h_timeout: 'Per upstream request; a route-level timeout overrides it', h_timeout: 'Per upstream request timeout',
f_retry: 'Retries for direct model id', f_retry: 'Retries for direct model id',
h_retry: 'Retries (incl. first try) when calling a real model id instead of a route alias', h_retry: 'Retries for the same model (incl. the first try)',
f_health_auth: 'Require auth on /health', f_health_auth: 'Require auth on /health',
// vue-i18n parses {...} as a placeholder: literal braces must be written {'{'} / {'}'}, // vue-i18n parses {...} as a placeholder: literal braces must be written {'{'} / {'}'},
// otherwise the whole message fails to compile (and the UI using it renders nothing). // otherwise the whole message fails to compile (and the UI using it renders nothing).
@@ -719,7 +723,7 @@ export default {
f_metrics_enabled: 'Record metrics', f_metrics_enabled: 'Record metrics',
h_metrics_enabled: 'Off = /metrics and dashboard counters stop updating (calls still work)', h_metrics_enabled: 'Off = /metrics and dashboard counters stop updating (calls still work)',
f_rate_limit_rps: 'Global QPS per account', f_rate_limit_rps: 'Global QPS per account',
h_rate_limit_rps: 'Empty = unlimited (provider/route level limits are configured separately)', h_rate_limit_rps: 'Empty = unlimited (provider-level limits live in the provider entry)',
f_max_body_size: 'Max request body (bytes)', f_max_body_size: 'Max request body (bytes)',
h_max_body_size: '~2MB = 2000000; keep it generous if you send images', h_max_body_size: '~2MB = 2000000; keep it generous if you send images',
f_cors_origins: 'CORS allowed origins', f_cors_origins: 'CORS allowed origins',
@@ -755,17 +759,6 @@ export default {
pModels: 'Models', pModels: 'Models',
h_pModels: 'Model ids must match upstream; vision = accepts image input (preferred for image chats)', h_pModels: 'Model ids must match upstream; vision = accepts image input (preferred for image chats)',
mVision: 'vision', mVision: 'vision',
routeHint: 'A route alias is a virtual model name (e.g. wjd): models are tried top-down and only a full failure returns 502. Order = priority.',
rName: 'Alias',
h_rName: 'Pass this as "model" when calling',
rTimeout: 'Per-model timeout (s)',
h_rTimeout: 'How long a single model may take before switching to the next one',
rRetry: 'Per-model retries',
h_rRetry: 'Retries before moving on (incl. first try); 1 = switch immediately',
rRate: 'Route QPS limit',
h_rRate: 'Empty = unlimited',
rModels: 'Fallback chain',
h_rModels: 'Tried top-down; available ids come from the providers above',
f_o_log_level: 'Log level', f_o_log_level: 'Log level',
h_o_log_level: 'DEBUG is noisy; INFO is fine for production', h_o_log_level: 'DEBUG is noisy; INFO is fine for production',
f_o_log_json: 'Structured JSON logs', f_o_log_json: 'Structured JSON logs',
+39 -48
View File
@@ -19,10 +19,10 @@ export default {
control: '控制台', control: '控制台',
more: '更多', more: '更多',
subdashboard: '网关运行概况 · 数据每 8 秒刷新', subdashboard: '网关运行概况 · 数据每 8 秒刷新',
subchat: '支持附图视觉 · 路由 wjd 自动选路', subchat: '支持附图视觉 · 多供应商直连',
subimages: '参数在左 · 历史在右 · 下载走网关代拉', subimages: '参数在左 · 历史在右 · 下载走网关代拉',
subvideos: '720P · 时长 4–12 秒 · 异步轮询', subvideos: '720P · 时长 4–12 秒 · 异步轮询',
submodels: '供应商 / 模型 / 路由链', submodels: '供应商 / 模型 / 协议线',
submetrics: '用量与成本 · 按账号隔离', submetrics: '用量与成本 · 按账号隔离',
subkeys: '每个账号最多 3 把 · 明文保存,可反复复制', subkeys: '每个账号最多 3 把 · 明文保存,可反复复制',
subusers: '账号与权限 · 管理员可查他人日志与资产', subusers: '账号与权限 · 管理员可查他人日志与资产',
@@ -86,8 +86,6 @@ export default {
dashboard: { dashboard: {
modelCount: '模型数', modelCount: '模型数',
providers: '供应商', providers: '供应商',
routes: '路由别名',
fallback: '成功降级',
inflight: '当前并发', inflight: '当前并发',
callsMix: '调用 ok/fail', callsMix: '调用 ok/fail',
provShare: '供应商成功调用份额', provShare: '供应商成功调用份额',
@@ -97,7 +95,6 @@ export default {
circuit: '熔断', circuit: '熔断',
modelCountShort: '模型数', modelCountShort: '模型数',
keySet: '已配 Key', keySet: '已配 Key',
routeAlias: '路由别名',
name: '名称', name: '名称',
modelChain: '模型链', modelChain: '模型链',
gatewayInfo: '网关信息', gatewayInfo: '网关信息',
@@ -114,7 +111,6 @@ export default {
requests: '请求总数', requests: '请求总数',
successRate: '成功率', successRate: '成功率',
avgLatency: '平均延迟', avgLatency: '平均延迟',
fallbackShort: '成功降级',
noteOkFail: 'ok {ok} · fail {fail}', noteOkFail: 'ok {ok} · fail {fail}',
noteFail: '失败 {n} 次', noteFail: '失败 {n} 次',
noteP95: 'P95 最高 {v}s', noteP95: 'P95 最高 {v}s',
@@ -127,22 +123,21 @@ export default {
noModels: '暂无调用记录', noModels: '暂无调用记录',
share: '份额', share: '份额',
live: '实时', live: '实时',
routeChain: '可用性 + 速度优先链', byProtocol: '协议线覆盖',
byProtocolSub: '每条线有多少模型',
modelCountN: '{n} 个模型',
}, },
metrics: { metrics: {
uptime: '已运行', uptime: '已运行',
inflight: '在途/峰值', inflight: '在途/峰值',
fallback: '成功降级',
promptTokens: 'Prompt tokens', promptTokens: 'Prompt tokens',
completionTokens: 'Completion tokens', completionTokens: 'Completion tokens',
callsTotal: '总调用(ok/fail)', callsTotal: '总调用(ok/fail)',
modelCalls: '各模型调用(成功 / 失败)', modelCalls: '各模型调用(成功 / 失败)',
provShare: '供应商成功调用份额', provShare: '供应商成功调用份额',
routeVsProvider: '路由 vs 供应商调用(成功 / 失败 / 降级)',
latency: '模型延迟 P50 / P95(秒)', latency: '模型延迟 P50 / P95(秒)',
success: '成功', success: '成功',
fail: '失败', fail: '失败',
fallback2: '降级',
ok: 'ok', ok: 'ok',
none: '暂无', none: '暂无',
circuitStatus: '熔断器状态', circuitStatus: '熔断器状态',
@@ -165,6 +160,7 @@ export default {
failRateNote: '失败率 {v}%', failRateNote: '失败率 {v}%',
snapshot: '实时快照', snapshot: '实时快照',
circuitCard: '熔断器', circuitCard: '熔断器',
byProvider: '按供应商调用(成功 / 失败)',
}, },
logs: { logs: {
all: '全部', all: '全部',
@@ -226,20 +222,17 @@ export default {
systemShort: '系统提示', systemShort: '系统提示',
visionReady: '视觉能力已就绪 · 可附图', visionReady: '视觉能力已就绪 · 可附图',
visionOff: '当前模型不支持图像输入', visionOff: '当前模型不支持图像输入',
chainLabel: '{id}({chain})',
emptyChain: '空', emptyChain: '空',
phDefault: '默认', phDefault: '默认',
phOptional: '可选', phOptional: '可选',
totalTokens: '共 {n}', totalTokens: '共 {n}',
uploadedImage: '已上传图片', uploadedImage: '已上传图片',
reasoningTag: '推理', reasoningTag: '推理',
routeGroup: '路由(自动降级)',
textModels: '文本模型', textModels: '文本模型',
params: '参数', params: '参数',
clear: '清空', clear: '清空',
generating: '正在生成…', generating: '正在生成…',
empty: '开始与网关对话(可选任意文本模型或路由 wjd)', empty: '开始与网关对话(在下方选一个模型)',
fallback: '降级 · 由 {provider} 响应',
servedBy: '由 {provider} 响应', servedBy: '由 {provider} 响应',
requestedTo: '请求 {req} → 实际 {served}', requestedTo: '请求 {req} → 实际 {served}',
reasoning: '推理过程(reasoning)', reasoning: '推理过程(reasoning)',
@@ -266,6 +259,7 @@ export default {
streaming: '流式输出', streaming: '流式输出',
system: '系统提示词(每条会话开头注入)', system: '系统提示词(每条会话开头注入)',
loadModelsErr: '加载模型列表失败:{msg}', loadModelsErr: '加载模型列表失败:{msg}',
pickModel: '选择模型',
}, },
images: { images: {
historyTitle: '生成历史', historyTitle: '生成历史',
@@ -363,10 +357,8 @@ export default {
loadErr: '加载视频失败', loadErr: '加载视频失败',
}, },
models: { models: {
routeAliasTitle: '路由别名(自动降级链)',
modelListTitle: '模型清单', modelListTitle: '模型清单',
name: '名称', name: '名称',
chainLabel: '模型链(依次尝试,失败自动降级)',
providerCount: '供应商数', providerCount: '供应商数',
id: '模型 ID', id: '模型 ID',
type: '类型', type: '类型',
@@ -375,12 +367,10 @@ export default {
text: '文本', text: '文本',
image: '图像', image: '图像',
video: '视频', video: '视频',
route: '路由',
model: '模型', model: '模型',
textModels: '文本模型', textModels: '文本模型',
imageModels: '图像模型', imageModels: '图像模型',
videoModels: '视频模型', videoModels: '视频模型',
routes: '路由别名',
providers: '供应商', providers: '供应商',
loadErr: '加载模型失败', loadErr: '加载模型失败',
capability: '能力', capability: '能力',
@@ -391,10 +381,8 @@ export default {
providerCard: '供应商', providerCard: '供应商',
keyOk: 'Key 已配置', keyOk: 'Key 已配置',
keyMissing: 'Key 未配置', keyMissing: 'Key 未配置',
routeCount: '{n} 条路由',
chainCount: '{n} 个模型', chainCount: '{n} 个模型',
providerCount2: '{n} 家供应商', providerCount2: '{n} 家供应商',
noRoute: '没有配置路由别名',
speedtest: '一键测速', speedtest: '一键测速',
testing: '正在测试全部文本模型延迟…', testing: '正在测试全部文本模型延迟…',
testingShort: '测速中…', testingShort: '测速中…',
@@ -403,6 +391,15 @@ export default {
failed: '失败', failed: '失败',
speedtestDone: '测速完成,共 {n} 个模型', speedtestDone: '测速完成,共 {n} 个模型',
speedtestFail: '测速失败', speedtestFail: '测速失败',
speedtestHint: '按模型自己的协议线探测延迟',
textModelCount: '{n} 个文本模型',
// 第二十七轮:支持的格式列(三条协议线)。格式名直接用各家标准端点名,不译。
protocols: '支持的格式',
protocolHint: '该模型可以走哪几条线:chat/completions(OpenAI 兼容)、messages(Anthropic)、responses(OpenAI Responses)。不在列表里的格式会在网关入口直接 400 —— 网关不做跨格式转换,也绝不偷偷换个模型顶上',
protocolNa: '不适用',
protocolNaHint: '图像 / 视频模型走 /v1/images/generations、/v1/videos 专用端点,不涉及这三条协议线',
protocolHintRow: '支持的格式:{lines} ',
probedLine: '本次测速走 {p}',
}, },
history: { history: {
saveFail: '历史未能保存到服务端(刷新后可能丢失),请检查登录状态或网络', saveFail: '历史未能保存到服务端(刷新后可能丢失),请检查登录状态或网络',
@@ -435,7 +432,7 @@ export default {
logoutBtn: '退出登录', logoutBtn: '退出登录',
chatDefaults: '对话默认参数', chatDefaults: '对话默认参数',
defsTip: '作为对话页初始值(本会话已改动的参数不受影响)。', defsTip: '作为对话页初始值(本会话已改动的参数不受影响)。',
defaultModel: '默认模型 / 路由', defaultModel: '默认模型',
temperature: '温度 temperature', temperature: '温度 temperature',
topP: 'top_p', topP: 'top_p',
maxTokens: 'max_tokens(留空用网关默认)', maxTokens: 'max_tokens(留空用网关默认)',
@@ -448,7 +445,7 @@ export default {
modelsCount: '模型数', modelsCount: '模型数',
userManagement: '账号管理(管理员)', userManagement: '账号管理(管理员)',
gwConfigBtn: '去配置', gwConfigBtn: '去配置',
gwConfigSub: '改网关参数 / 供应商 / 路由 / 定价 —— 保存即生效', gwConfigSub: '改网关参数 / 供应商 / 定价 —— 保存即生效',
gwConfig: '网关配置(管理员)', gwConfig: '网关配置(管理员)',
userCol: '账号', userCol: '账号',
roleCol: '角色', roleCol: '角色',
@@ -504,38 +501,50 @@ export default {
auth: '鉴权', auth: '鉴权',
authVal: '请求头 Authorization: Bearer <你的 API Key>', authVal: '请求头 Authorization: Bearer <你的 API Key>',
modelPick: '模型选择', modelPick: '模型选择',
modelPickVal: 'model 填 wjd = 路由别名(按「可用 + 速度」自动降级,推荐);也可填具体模型 id 直连,不被降级影响', modelPickVal: 'model 填真实模型 id(如 agnes-3.0-flash);三条线各按自家协议直传,网关不做跨格式转换 —— 选错线会 400(响应里会列出该模型支持哪些线)',
formats: '支持的格式',
formatsVal: '每个模型能用哪几条线,见「供应商与模型」页的「支持的格式」列:chat/completions、messages、responses。三条线各自原样转发(不改字段、不做跨格式翻译),因此接口地址与请求体按各家官方 SDK 写就行',
ctype: '请求格式', ctype: '请求格式',
ctypeVal: 'application/json;对话支持 SSE 流式(stream: true)', ctypeVal: 'application/json;对话支持 SSE 流式(stream: true)',
endpoints: '常用端点', endpoints: '常用端点',
colMethod: '方法', colMethod: '方法',
colPath: '路径', colPath: '路径',
colDesc: '说明', colDesc: '说明',
epModels: '模型与路由列表(含视觉能力标记)', epModels: '模型列表(含视觉能力标记与支持的协议线)',
epChat: '对话补全(OpenAI 兼容,支持流式与图片输入)', epChat: '对话补全(OpenAI 兼容,支持流式与图片输入)',
epMessages: '对话补全(Anthropic Messages 格式,原样直传)',
epResponses: '对话补全(OpenAI Responses 格式,原样直传)',
epImages: '图像生成 / 图生图(n 必须为 1,多张请多次调用)', epImages: '图像生成 / 图生图(n 必须为 1,多张请多次调用)',
epVideoCreate: '视频生成(异步,立即返回 video_id)', epVideoCreate: '视频生成(异步,立即返回 video_id)',
epVideoPoll: '查询视频任务(建议每 5s 一次;被上游限流时返回 throttled)', epVideoPoll: '查询视频任务(建议每 5s 一次;被上游限流时返回 throttled)',
epDownload: '代下载生成出来的图片 / 视频(绕过上游地址的防盗链与过期,白名单域名)',
epHistory: '读取本人历史(图像 / 视频 / 对话)', epHistory: '读取本人历史(图像 / 视频 / 对话)',
epLogs: '本人调用日志', epLogs: '本人调用日志',
epMetrics: '指标快照(含熔断器状态)', epMetrics: '指标快照(含熔断器状态)',
epHealth: '健康检查(版本 / 供应商状态)', epHealth: '健康检查(版本 / 供应商状态)',
exChat: '示例 · 对话', exChat: '示例 · 对话',
exMessages: '示例 · 对话(Anthropic Messages 格式)',
exResponses: '示例 · 对话(OpenAI Responses 格式)',
exImg: '示例 · 图像生成', exImg: '示例 · 图像生成',
exVideo: '示例 · 视频生成 + 轮询', exVideo: '示例 · 视频生成 + 轮询',
exPy: '示例 · Python(OpenAI SDK 兼容)', exPy: '示例 · Python(OpenAI SDK 兼容)',
// 示例代码里的注释与示例文案(整段照抄时也该是当前语言) // 示例代码里的注释与示例文案(整段照抄时也该是当前语言)
sampleChat: '你好,介绍一下你自己', sampleChat: '你好,介绍一下你自己',
sampleModelMessages: 'minimax-m2.7',
sampleModelResponses: 'grok-4.6',
sampleImg: '霓虹夜景的城市街道', sampleImg: '霓虹夜景的城市街道',
sampleVideo: '镜头缓慢推进', sampleVideo: '镜头缓慢推进',
sampleStep1: '提交任务(异步,立即返回 video_id)', sampleStep1: '提交任务(异步,立即返回 video_id)',
sampleStep2: '每 5s 轮询一次(被限流会回 throttled,等一下再问)', sampleStep2: '每 5s 轮询一次(被限流会回 throttled,等一下再问)',
notes: '注意事项', notes: '注意事项',
noteVision: '带图对话请用支持视觉的模型(agnes-3.0-flash,列表里标「视觉」);填路由别名 wjd 时网关会自动把视觉模型排到链首。', noteVision: '带图对话请用支持视觉的模型(agnes-3.0-flash,列表里标「视觉」);网关不再自动换模型 —— 选了不支持视觉的模型就照原样发上去,由上游决定怎么处理',
noteCross: '跨格式不转换:某个模型支持哪几条线,由「供应商与模型」页的「支持的格式」列决定(例:minimax-m2.7 只认 messages,grok-4.6 只认 responses)。用错格式网关会在入口直接 400 并列出它支持的线,不会偷偷翻译你的请求、也不会换个模型顶上',
noteConvId: '可选字段 conversation_id(对话类请求):同一段对话复用同一个串,上游的提示词缓存更容易命中(省钱省时)。它是网关内部字段,不会原样发给上游 —— 网关按账号派生真实会话 id,账号之间互不串缓存;不传则每次随机',
noteN1: '图像 n 只能为 1(上游限制),要几张就调几次;n≠1 会被网关直接 400 拦下。', noteN1: '图像 n 只能为 1(上游限制),要几张就调几次;n≠1 会被网关直接 400 拦下。',
noteVideo: '视频 seconds 只支持 4–12,size 固定 720P,比例 6 种(21:9/16:9/4:3/1:1/3:4/9:16);mode=text 文生视频 / keyframe 首尾帧 / reference 参考图·音频。', noteVideo: '视频 seconds 只支持 4–12,size 固定 720P,比例 6 种(21:9/16:9/4:3/1:1/3:4/9:16);mode=text 文生视频 / keyframe 首尾帧 / reference 参考图·音频。',
notePoll: '轮询别快于 5s(上游会回 429「查询过于频繁」,网关会以 throttled 提示退避)。', notePoll: '轮询别快于 5s(上游会回 429「查询过于频繁」,网关会以 throttled 提示退避)。',
noteMedia: '素材(参考图 / 首尾帧 / 参考音频 / 对话附图)可直接传 data:image/...;base64,... 或公网 URL;data URI 不必暴露素材,但单次请求体需 < 2MB。', noteMedia: '素材(参考图 / 首尾帧 / 参考音频 / 对话附图)可直接传 data:image/...;base64,... 或公网 URL;data URI 不必暴露素材,但单次请求体需 < 2MB。',
noteDownload: '上游返回的图片 / 视频地址可能有时效或防盗链。要落盘请走 /v1/media/download?url=...(需带上你的 Key),它由网关代为取回;地址不在白名单内会被 400 拒绝。',
noteKey: 'Key 泄漏时到本页删除(立即 401),或用「用户管理」页一键吊销该账号全部 Key。', noteKey: 'Key 泄漏时到本页删除(立即 401),或用「用户管理」页一键吊销该账号全部 Key。',
noteAudit: '所有调用按账号记入「日志」页(仅本人可见;admin 可在用户管理页看各账号)。', noteAudit: '所有调用按账号记入「日志」页(仅本人可见;admin 可在用户管理页看各账号)。',
copyBase: '复制地址', copyBase: '复制地址',
@@ -656,17 +665,13 @@ export default {
addItem: '添加', addItem: '添加',
addModel: '添加模型', addModel: '添加模型',
addProvider: '添加供应商', addProvider: '添加供应商',
addRoute: '添加路由别名',
addPrice: '添加定价', addPrice: '添加定价',
delete: '删除', delete: '删除',
delProvider: '删除供应商', delProvider: '删除供应商',
delRoute: '删除路由',
delConfirm: '删除「{name}」?保存后才真正写盘生效。', delConfirm: '删除「{name}」?保存后才真正写盘生效。',
needKey: '供应商的 key 不能为空', needKey: '供应商的 key 不能为空',
needRoute: '路由别名的名字不能为空',
dupKey: '「{name}」重复了,请改一个名字', dupKey: '「{name}」重复了,请改一个名字',
newProvider: '(新供应商)', newProvider: '(新供应商)',
newRoute: '(新路由别名)',
unlimited: '留空 = 不限', unlimited: '留空 = 不限',
useServerTimeout: '留空 = 用 server.timeout', useServerTimeout: '留空 = 用 server.timeout',
mediaEmpty: '留空 = 不支持', mediaEmpty: '留空 = 不支持',
@@ -683,19 +688,17 @@ export default {
tabServerSub: '监听、超时/重试、限流、CORS、会话时长等运行开关', tabServerSub: '监听、超时/重试、限流、CORS、会话时长等运行开关',
tabProviders: '供应商与模型', tabProviders: '供应商与模型',
tabProvidersSub: '供应商密钥来源、接口地址、图像/视频端点、模型清单', tabProvidersSub: '供应商密钥来源、接口地址、图像/视频端点、模型清单',
tabRoutes: '路由与熔断',
tabRoutesSub: '路由别名与 fallback 模型链(顺序 = 优先级)+ 供应商熔断',
tabLog: '日志与定价', tabLog: '日志与定价',
tabLogSub: '日志级别/格式/容量 + 模型定价(人民币 / 百万 token)', tabLogSub: '日志级别/格式/容量 + 模型定价(人民币 / 百万 token)',
tabDownload: '下载代理', tabDownload: '下载代理',
tabDownloadSub: '允许网关代下载的 CDN 域名与单文件上限', tabDownloadSub: '允许网关代下载的 CDN 域名与单文件上限',
circuit: '供应商熔断', circuit: '供应商熔断',
h_circuit: '某供应商窗口内失败到阈值就熔断冷却,期间跳过它让 fallback 顶上', h_circuit: '某供应商窗口内失败到阈值就熔断冷却,期间它的请求直接 503',
f_c_enabled: '启用熔断', f_c_enabled: '启用熔断',
f_c_failure_threshold: '触发阈值(次)', f_c_failure_threshold: '触发阈值(次)',
f_c_cooldown: '熔断冷却(秒)', f_c_cooldown: '熔断冷却(秒)',
f_c_window: '统计窗口(秒)', f_c_window: '统计窗口(秒)',
h_c_enabled: '关掉 = 失败也不跳过(fallback 照常工作)', h_c_enabled: '关掉 = 失败也不跳过',
h_c_failure_threshold: '窗口内失败到该次数就熔断', h_c_failure_threshold: '窗口内失败到该次数就熔断',
h_c_cooldown: '熔断期间直接跳过该供应商,冷却结束后自动半开试探', h_c_cooldown: '熔断期间直接跳过该供应商,冷却结束后自动半开试探',
h_c_window: '按"窗口内失败次数"计数(不是连续失败)', h_c_window: '按"窗口内失败次数"计数(不是连续失败)',
@@ -705,9 +708,9 @@ export default {
f_port: '监听端口', f_port: '监听端口',
h_port: '生产用 8808,且 Nginx 反代指向它 —— 改了要同步改反代', h_port: '生产用 8808,且 Nginx 反代指向它 —— 改了要同步改反代',
f_timeout: '上游超时(秒)', f_timeout: '上游超时(秒)',
h_timeout: '单次上游请求超时;路由自身写了 timeout 的以路由为准', h_timeout: '单次上游请求超时',
f_retry: '直连模型重试次数', f_retry: '直连模型重试次数',
h_retry: '直接用模型 id(不走路由别名)时的重试次数,含首次', h_retry: '同一模型的重试次数(含首次)',
f_health_auth: '/health 需要鉴权', f_health_auth: '/health 需要鉴权',
// 注意:vue-i18n 把 {...} 当占位符,花括号要么写成 {'{'} / {'}'},要么整条编译不过 —— // 注意:vue-i18n 把 {...} 当占位符,花括号要么写成 {'{'} / {'}'},要么整条编译不过 ——
// 编译不过的表现是"用到这条文案的整块界面不渲染",不报在文案上(踩过一次,见 check:i18n)。 // 编译不过的表现是"用到这条文案的整块界面不渲染",不报在文案上(踩过一次,见 check:i18n)。
@@ -720,7 +723,7 @@ export default {
f_metrics_enabled: '记录调用指标', f_metrics_enabled: '记录调用指标',
h_metrics_enabled: '关掉后 /metrics 与看板计数停更(不影响调用)', h_metrics_enabled: '关掉后 /metrics 与看板计数停更(不影响调用)',
f_rate_limit_rps: '全局单账号 QPS 上限', f_rate_limit_rps: '全局单账号 QPS 上限',
h_rate_limit_rps: '留空 = 不限(供应商级、路由级限流见各自配置)', h_rate_limit_rps: '留空 = 不限(供应商级限流见供应商配置)',
f_max_body_size: '请求体上限(字节)', f_max_body_size: '请求体上限(字节)',
h_max_body_size: '约 2MB = 2000000;带图对话别调太小', h_max_body_size: '约 2MB = 2000000;带图对话别调太小',
f_cors_origins: 'CORS 允许来源', f_cors_origins: 'CORS 允许来源',
@@ -757,18 +760,6 @@ export default {
pModels: '模型清单', pModels: '模型清单',
h_pModels: '模型 id 必须与上游一致;vision = 支持图像输入(带图对话会优先选它)', h_pModels: '模型 id 必须与上游一致;vision = 支持图像输入(带图对话会优先选它)',
mVision: '视觉', mVision: '视觉',
// ── 路由 ──
routeHint: '路由别名是给调用方用的"虚拟模型名"(如 wjd):按下面顺序逐个尝试,全失败才 502。数组顺序 = 优先级。',
rName: '别名',
h_rName: '调用时 model 填这个名字',
rTimeout: '单模型超时(秒)',
h_rTimeout: '某个模型多久没出结果就切下一个,避免整链挂死',
rRetry: '单模型重试次数',
h_rRetry: '切下一个之前的重试次数(含首次);想让链路快速切换就填 1',
rRate: '本路由 QPS 上限',
h_rRate: '留空 = 不限',
rModels: 'fallback 模型链',
h_rModels: '从上到下依次尝试;可用模型来自上面的供应商清单',
// ── 可观测性 ── // ── 可观测性 ──
f_o_log_level: '日志级别', f_o_log_level: '日志级别',
h_o_log_level: 'DEBUG 最啰嗦,生产 INFO 够用', h_o_log_level: 'DEBUG 最啰嗦,生产 INFO 够用',
+9 -7
View File
@@ -1,10 +1,16 @@
import { createApp } from 'vue' import { createApp } from 'vue'
import { createPinia } from 'pinia' import { createPinia } from 'pinia'
import ElementPlus from 'element-plus' // 第二十八轮:element-plus 改按需引入(vite.config.ts 的 Components/AutoImport 负责模板里的
import 'element-plus/dist/index.css' // <el-*>),这里不再 `import ElementPlus` + `app.use(ElementPlus)`、不再引全量 index.css。
// 仍然手动引的只有三样:
// ① 深色变量基座(A 皮肤用)—— 组件级样式依赖这三个 CSS 变量,必须全局在;
// ② ElMessage 的样式(Dialogs 里命令式调用,模板里没 <el-message>,resolver 扫不到);
// ③ ElMessageBox 的样式(同上,confirm() 弹窗)。
// ElLoading / ElNotification 本项目未用,无需引(未来要用了记得补)。
import 'element-plus/theme-chalk/dark/css-vars.css' // 深色变量基座(A 皮肤用) import 'element-plus/theme-chalk/dark/css-vars.css' // 深色变量基座(A 皮肤用)
import 'element-plus/es/components/message/style/css'
import 'element-plus/es/components/message-box/style/css'
import 'highlight.js/styles/github.css' import 'highlight.js/styles/github.css'
import * as ElementIcons from '@element-plus/icons-vue'
import App from './App.vue' import App from './App.vue'
import router from './router' import router from './router'
import { initTheme } from './lib/theme' import { initTheme } from './lib/theme'
@@ -15,9 +21,5 @@ initTheme() // mount 前应用主题(data-theme + dark class),避免闪色
const app = createApp(App) const app = createApp(App)
app.use(createPinia()) app.use(createPinia())
app.use(router) app.use(router)
app.use(ElementPlus)
app.use(i18n) // 多语言 app.use(i18n) // 多语言
for (const [name, comp] of Object.entries(ElementIcons)) {
app.component(name as string, comp as any)
}
app.mount('#app') app.mount('#app')
+23 -4
View File
@@ -77,6 +77,9 @@
</div> </div>
<div><b>{{ t('apidoc.auth') }}</b> <span class="code">{{ t('apidoc.authVal') }}</span></div> <div><b>{{ t('apidoc.auth') }}</b> <span class="code">{{ t('apidoc.authVal') }}</span></div>
<div><b>{{ t('apidoc.modelPick') }}</b> <span>{{ t('apidoc.modelPickVal') }}</span></div> <div><b>{{ t('apidoc.modelPick') }}</b> <span>{{ t('apidoc.modelPickVal') }}</span></div>
<!-- 第二十七轮:三条协议线各自的请求格式不同,先在这里点明「去哪看支持哪些线」,
免得用户点了 400 才知道格式选错(400 文案也会列出该模型支持的线)。 -->
<div><b>{{ t('apidoc.formats') }}</b> <span>{{ t('apidoc.formatsVal') }}</span></div>
<div><b>{{ t('apidoc.ctype') }}</b> <span>{{ t('apidoc.ctypeVal') }}</span></div> <div><b>{{ t('apidoc.ctype') }}</b> <span>{{ t('apidoc.ctypeVal') }}</span></div>
</div> </div>
@@ -141,12 +144,19 @@ const limit = ref<number | null>(null) // null = 不限(admin)
const base = window.location.origin const base = window.location.origin
// 端点表:与 app/main.py 的真实路由一一对应(别写成 README 里才有的东西) // 端点表:与 app/main.py 的真实路由一一对应(别写成 README 里才有的东西)
// 第二十七轮:三条协议线并排 —— chat/completions(OpenAI 兼容,走专用路径)、
// messages(Anthropic)、responses(OpenAI Responses)。后两条是「直传」:原始 JSON 进、
// 上游响应原样出,网关不翻译字段;某个模型能不能用这条线,看「供应商与模型」页的
// 「支持的格式」列(用错线会在入口 400 并列出该模型支持哪些线)。
const endpoints = computed(() => [ const endpoints = computed(() => [
{ method: 'GET', path: '/v1/models', desc: t('apidoc.epModels') }, { method: 'GET', path: '/v1/models', desc: t('apidoc.epModels') },
{ method: 'POST', path: '/v1/chat/completions', desc: t('apidoc.epChat') }, { method: 'POST', path: '/v1/chat/completions', desc: t('apidoc.epChat') },
{ method: 'POST', path: '/v1/messages', desc: t('apidoc.epMessages') },
{ method: 'POST', path: '/v1/responses', desc: t('apidoc.epResponses') },
{ method: 'POST', path: '/v1/images/generations', desc: t('apidoc.epImages') }, { method: 'POST', path: '/v1/images/generations', desc: t('apidoc.epImages') },
{ method: 'POST', path: '/v1/videos', desc: t('apidoc.epVideoCreate') }, { method: 'POST', path: '/v1/videos', desc: t('apidoc.epVideoCreate') },
{ method: 'GET', path: '/v1/videos/{video_id}?model=...', desc: t('apidoc.epVideoPoll') }, { method: 'GET', path: '/v1/videos/{video_id}?model=...', desc: t('apidoc.epVideoPoll') },
{ method: 'GET', path: '/v1/media/download?url=...', desc: t('apidoc.epDownload') },
{ method: 'GET', path: '/history/{kind}', desc: t('apidoc.epHistory') }, { method: 'GET', path: '/history/{kind}', desc: t('apidoc.epHistory') },
{ method: 'GET', path: '/logs', desc: t('apidoc.epLogs') }, { method: 'GET', path: '/logs', desc: t('apidoc.epLogs') },
{ method: 'GET', path: '/metrics', desc: t('apidoc.epMetrics') }, { method: 'GET', path: '/metrics', desc: t('apidoc.epMetrics') },
@@ -154,8 +164,9 @@ const endpoints = computed(() => [
]) ])
const notes = computed(() => [ const notes = computed(() => [
t('apidoc.noteVision'), t('apidoc.noteN1'), t('apidoc.noteVideo'), t('apidoc.noteVision'), t('apidoc.noteCross'), t('apidoc.noteConvId'), t('apidoc.noteN1'),
t('apidoc.notePoll'), t('apidoc.noteMedia'), t('apidoc.noteKey'), t('apidoc.noteAudit'), t('apidoc.noteVideo'), t('apidoc.notePoll'), t('apidoc.noteMedia'), t('apidoc.noteDownload'),
t('apidoc.noteKey'), t('apidoc.noteAudit'),
]) ])
// 示例里的 Key 用占位符 $GW_KEY(不把真 Key 渲染进文档;本页的 Key 明文只在上方列表里回显) // 示例里的 Key 用占位符 $GW_KEY(不把真 Key 渲染进文档;本页的 Key 明文只在上方列表里回显)
@@ -166,7 +177,15 @@ const examples = computed(() => {
{ title: t('apidoc.exChat'), code: { title: t('apidoc.exChat'), code:
`curl ${base}/v1/chat/completions \\ `curl ${base}/v1/chat/completions \\
${H} \\ ${H} \\
-d '{"model":"wjd","messages":[{"role":"user","content":"${t('apidoc.sampleChat')}"}]}'` }, -d '{"model":"agnes-3.0-flash","messages":[{"role":"user","content":"${t('apidoc.sampleChat')}"}]}'` },
{ title: t('apidoc.exMessages'), code:
`curl ${base}/v1/messages \\
${H} \\
-d '{"model":"${t('apidoc.sampleModelMessages')}","max_tokens":64,"messages":[{"role":"user","content":"${t('apidoc.sampleChat')}"}]}'` },
{ title: t('apidoc.exResponses'), code:
`curl ${base}/v1/responses \\
${H} \\
-d '{"model":"${t('apidoc.sampleModelResponses')}","input":"${t('apidoc.sampleChat')}","max_output_tokens":64}'` },
{ title: t('apidoc.exImg'), code: { title: t('apidoc.exImg'), code:
`curl ${base}/v1/images/generations \\ `curl ${base}/v1/images/generations \\
${H} \\ ${H} \\
@@ -185,7 +204,7 @@ curl "${base}/v1/videos/task_xxx?model=agnes-video-2.5-flash" \\
`from openai import OpenAI `from openai import OpenAI
c = OpenAI(base_url="${base}/v1", api_key="wjd-xxxxxxxx") c = OpenAI(base_url="${base}/v1", api_key="wjd-xxxxxxxx")
r = c.chat.completions.create(model="wjd", messages=[{"role": "user", "content": "${t('apidoc.sampleChat')}"}]) r = c.chat.completions.create(model="agnes-3.0-flash", messages=[{"role": "user", "content": "${t('apidoc.sampleChat')}"}])
print(r.choices[0].message.content)` }, print(r.choices[0].message.content)` },
] ]
}) })
+22 -34
View File
@@ -104,15 +104,12 @@
</div> </div>
<div v-for="msg in messages" :key="msg.id" class="msg" :class="msg.role === 'user' ? 'me' : 'ai'"> <div v-for="msg in messages" :key="msg.id" class="msg" :class="msg.role === 'user' ? 'me' : 'ai'">
<!-- 助手:降级/服务信息 --> <!-- 助手:服务信息(第二十七轮起没有"降级"这回事 —— 路由别名已删除) -->
<div v-if="msg.role === 'assistant' && msg.meta" class="resp-meta"> <div v-if="msg.role === 'assistant' && msg.meta" class="resp-meta">
<el-tag size="small" :type="msg.meta.fallback ? 'warning' : 'success'" effect="light"> <el-tag size="small" type="success" effect="light">
<template v-if="msg.meta.fallback">{{ t('chat.fallback', { provider: msg.meta.provider }) }}</template><template v-else>{{ t('chat.servedBy', { provider: msg.meta.provider }) }}</template> {{ t('chat.servedBy', { provider: msg.meta.provider }) }}
</el-tag> </el-tag>
<span class="meta-txt"> <span class="meta-txt">{{ msg.meta.served }}</span>
<template v-if="msg.meta.fallback">{{ t('chat.requestedTo', { req: msg.meta.requested, served: msg.meta.served }) }}</template>
<template v-else>{{ msg.meta.served }}</template>
</span>
<span v-if="msg.usage || msg.cost != null" class="meta-txt"> <span v-if="msg.usage || msg.cost != null" class="meta-txt">
· {{ msg.cost != null ? `¥${msg.cost}` : '' }} · {{ msg.cost != null ? `¥${msg.cost}` : '' }}
<template v-if="msg.usage">{{ tokensText(msg.usage) }}</template> <template v-if="msg.usage">{{ tokensText(msg.usage) }}</template>
@@ -199,15 +196,7 @@
</el-tooltip> </el-tooltip>
<input ref="fileEl" type="file" accept="image/*" multiple class="hide-file" @change="onFiles" /> <input ref="fileEl" type="file" accept="image/*" multiple class="hide-file" @change="onFiles" />
<el-select v-model="params.model" class="model-sel" size="small" :disabled="streaming" filterable :placeholder="t('chat.routeGroup')"> <el-select v-model="params.model" class="model-sel" size="small" :disabled="streaming" filterable :placeholder="t('chat.pickModel')">
<el-option-group :label="t('chat.routeGroup')">
<el-option v-for="r in routes" :key="r.id" :value="r.id" :label="chainLabel(r)">
<span class="opt">
<span>{{ chainLabel(r) }}</span>
<Icon v-if="r.vision" name="eye" :size="13" />
</span>
</el-option>
</el-option-group>
<el-option-group :label="t('chat.textModels')"> <el-option-group :label="t('chat.textModels')">
<el-option v-for="m in textModels" :key="m.id" :value="m.id" :label="modelLabel(m)"> <el-option v-for="m in textModels" :key="m.id" :value="m.id" :label="modelLabel(m)">
<span class="opt"> <span class="opt">
@@ -289,36 +278,36 @@ const router = useRouter()
const { t } = useI18n() const { t } = useI18n()
// ── 模型选项 ── // ── 模型选项 ──
const routes = ref<any[]>([]) // 第二十七轮: 路由别名(wjd)功能已整体删除 —— /v1/models 里只剩真实模型,
// 调用方选哪个模型就是哪个(网关不再"自动挑最快模型")。
const textModels = ref<any[]>([]) const textModels = ref<any[]>([])
async function loadModels() { async function loadModels() {
try { try {
const j = await api('/v1/models') const j = await api('/v1/models')
const data: any[] = j.data || [] const data: any[] = j.data || []
routes.value = data.filter((x) => x.type === 'route') textModels.value = data.filter((x) => x.type !== 'image' && x.type !== 'video')
textModels.value = data.filter((x) => x.type !== 'route') // 默认模型:优先 agnes-3.0-flash(旗舰),否则用列表第一个。
// 同时兜住"本地存着旧模型 id(比如已删除的 wjd)"的情况 —— 认不出来就换默认,
// 免得下拉框空着、发出去却被网关 400。
if (!textModels.value.some((m) => m.id === params.model)) {
const def = textModels.value.find((m) => m.id === 'agnes-3.0-flash')
params.model = def ? def.id : (textModels.value[0]?.id || '')
}
} catch (e: any) { } catch (e: any) {
if (e && e.status === 401) { router.push('/login'); return } if (e && e.status === 401) { router.push('/login'); return }
ElMessage.error(t('chat.loadModelsErr', { msg: (e && e.message) || e })) ElMessage.error(t('chat.loadModelsErr', { msg: (e && e.message) || e }))
} }
} }
function chainLabel(r: any) {
const chain = (r.models || []).join(' → ')
// 括号样式(全角/半角)也交给 i18n:英文里用半角更自然
return t('chat.chainLabel', { id: r.id, chain: chain || t('chat.emptyChain') })
}
// ── 视觉能力(第十三轮)── // ── 视觉能力(第十三轮)──
// 网关 /v1/models 会回 vision 字段(Agnes 3.0 Flash = true,其余文本模型默认 false)。 // 网关 /v1/models 会回 vision 字段(Agnes 3.0 Flash = true,其余文本模型默认 false)。
// 带图请求走路由别名时网关会把视觉模型排到链首;选了**不支持视觉的真实模型**时 // 第二十七轮: 路由链删除后网关不再"把视觉模型排到链首" —— 选了不支持视觉的模型时,
// 这里提前告警并提供一键切换,避免"发了图但模型根本没看"。 // 这里提前告警并提供一键切换,避免"发了图但模型根本没看"。
const visionModels = computed(() => const visionModels = computed(() =>
textModels.value.filter((m) => m.vision).map((m) => m.id)) textModels.value.filter((m) => m.vision).map((m) => m.id))
const visionOk = computed(() => { const visionOk = computed(() => {
const m = routes.value.find((r) => r.id === params.model) const m = textModels.value.find((x) => x.id === params.model)
if (m) return !!m.vision || !!(m.models || []).some((id: string) => visionModels.value.includes(id)) return !!m?.vision
const t2 = textModels.value.find((x) => x.id === params.model)
return !!t2?.vision
}) })
const firstVisionModel = computed(() => visionModels.value[0] || '') const firstVisionModel = computed(() => visionModels.value[0] || '')
function useVisionModel() { function useVisionModel() {
@@ -330,7 +319,8 @@ function modelLabel(m: any) {
// ── 参数与状态 ── // ── 参数与状态 ──
const params = reactive({ const params = reactive({
model: 'wjd', // 空串 = 还没拿到模型列表;loadModels() 里填入默认模型(第二十七轮: 不再默认 wjd)
model: '',
temperature: 0.7, temperature: 0.7,
top_p: 1, top_p: 1,
max_tokens: null as number | null, max_tokens: null as number | null,
@@ -654,12 +644,11 @@ async function runOnce(input: string) {
} }
reply.usage = j?.usage || undefined reply.usage = j?.usage || undefined
reply.cost = j?.estimated_cost_cny ?? undefined reply.cost = j?.estimated_cost_cny ?? undefined
if (j?.route || j?.provider) { if (j?.provider || j?.served_model) {
reply.meta = { reply.meta = {
served: j.served_model || j.model || params.model, served: j.served_model || j.model || params.model,
provider: j.provider_name || j.provider, provider: j.provider_name || j.provider,
requested: j.model || params.model, requested: j.model || params.model,
fallback: !!(j.route && j.route.fallback_used),
} }
} }
} catch (e: any) { } catch (e: any) {
@@ -687,7 +676,6 @@ async function runStream(_input: string) {
served: chunk.served_model || chunk.model || params.model, served: chunk.served_model || chunk.model || params.model,
provider: chunk.provider_name || chunk.provider, provider: chunk.provider_name || chunk.provider,
requested: chunk.model || params.model, requested: chunk.model || params.model,
fallback: !!(chunk.route && chunk.route.fallback_used),
} }
} }
if (chunk.usage && !chunk.choices?.length) { if (chunk.usage && !chunk.choices?.length) {
+15 -19
View File
@@ -41,16 +41,16 @@
<div class="sep" /> <div class="sep" />
<div class="card-h" style="margin-bottom: 8px"> <div class="card-h" style="margin-bottom: 8px">
<b>{{ t('dashboard.routeAlias') }}</b> <b>{{ t('dashboard.byProtocol') }}</b>
<span class="sub">{{ t('dashboard.routeChain') }}</span> <span class="sub">{{ t('dashboard.byProtocolSub') }}</span>
</div> </div>
<div class="pv" style="gap: 7px"> <div class="pv" style="gap: 7px">
<div v-for="(r, i) in routeRows" :key="r.name" class="pv-i" style="font-size: 12px"> <div v-for="(r, i) in protoRows" :key="r.name" class="pv-i" style="font-size: 12px">
<span class="pill mute">{{ i + 1 }}</span> <span class="pill mute">{{ i + 1 }}</span>
<span class="code flex-1">{{ r.name }}</span> <span class="code flex-1">{{ r.name }}</span>
<span class="st muted-2 nowrap">{{ r.short }}</span> <span class="st muted-2 nowrap">{{ r.short }}</span>
</div> </div>
<div v-if="!routeRows.length" class="hint">{{ t('dashboard.noData') }}</div> <div v-if="!protoRows.length" class="hint">{{ t('dashboard.noData') }}</div>
</div> </div>
</div> </div>
</div> </div>
@@ -94,7 +94,6 @@
<span>{{ t('dashboard.running') }}</span> <span>{{ t('dashboard.running') }}</span>
<span>{{ t('dashboard.uptime') }} {{ uptimeText }}</span> <span>{{ t('dashboard.uptime') }} {{ uptimeText }}</span>
<span>{{ t('dashboard.inflight') }} {{ health.in_flight ?? '-' }} / {{ health.in_flight_peak ?? '-' }}</span> <span>{{ t('dashboard.inflight') }} {{ health.in_flight ?? '-' }} / {{ health.in_flight_peak ?? '-' }}</span>
<span>{{ t('dashboard.fallback') }} {{ health.fallback_total ?? 0 }}</span>
</div> </div>
</div> </div>
</div> </div>
@@ -116,7 +115,7 @@ const { resolved } = useTheme() // 主题变化时重算图表配色
const health = ref<any>({}) const health = ref<any>({})
const metrics = ref<any>({}) const metrics = ref<any>({})
const models = ref<any>({}) const models = ref<any>({})
const routes = ref<any[]>([]) const modelsList = ref<any[]>([])
const loading = ref(false) const loading = ref(false)
const err = ref('') const err = ref('')
@@ -149,7 +148,6 @@ const cards = computed(() => {
{ k: t('dashboard.requests'), v: total.value, note: t('dashboard.noteOkFail', { ok: totalOk.value, fail: totalFail.value }) }, { k: t('dashboard.requests'), v: total.value, note: t('dashboard.noteOkFail', { ok: totalOk.value, fail: totalFail.value }) },
{ k: t('dashboard.successRate'), v: rate.value.toFixed(1) + '%', note: t('dashboard.noteFail', { n: totalFail.value }) }, { k: t('dashboard.successRate'), v: rate.value.toFixed(1) + '%', note: t('dashboard.noteFail', { n: totalFail.value }) },
{ k: t('dashboard.avgLatency'), v: avgP50.value.toFixed(2) + 's', note: t('dashboard.noteP95', { v: maxP95.value.toFixed(2) }) }, { k: t('dashboard.avgLatency'), v: avgP50.value.toFixed(2) + 's', note: t('dashboard.noteP95', { v: maxP95.value.toFixed(2) }) },
{ k: t('dashboard.fallbackShort'), v: health.value.fallback_total ?? 0, note: t('dashboard.noteInflight', { n: health.value.in_flight ?? 0 }) },
] ]
}) })
@@ -171,12 +169,14 @@ const providerRows = computed(() => {
}) })
}) })
const routeRows = computed(() => { // 第二十七轮: 路由别名链已删除 → 这里改成"每条协议线各有几个模型"
const m = models.value // (三线直传后这个分布才是运维真正关心的:哪条线现在有货)
return routes.value.map((r: any) => { const protoRows = computed(() => {
const chain: string[] = (m[r.id] || []).map((x: any) => (typeof x === 'string' ? x : x.id || x.name)) const count: Record<string, number> = {}
return { name: r.id, short: chain.length ? t('models.chainCount', { n: chain.length }) : '—' } for (const m of modelsList.value) {
}) for (const p of (m.protocols || ['chat/completions'])) count[p] = (count[p] || 0) + 1
}
return Object.keys(count).sort().map((k) => ({ name: k, short: t('dashboard.modelCountN', { n: count[k] }) }))
}) })
const callRows = computed(() => { const callRows = computed(() => {
@@ -258,14 +258,10 @@ async function load() {
try { try {
const um = await api('/v1/models') const um = await api('/v1/models')
const data = um.data || [] const data = um.data || []
routes.value = data.filter((x: any) => x.type === 'route') modelsList.value = data
const map: Record<string, string> = {} const map: Record<string, string> = {}
for (const x of data) if (x.type !== 'route') map[x.id] = x.provider_name || '' for (const x of data) map[x.id] = x.provider_name || ''
textModels.value = map textModels.value = map
const list = data.filter((x: any) => x.type === 'route')
const m: Record<string, any> = {}
for (const r of list) m[r.id] = r.models || []
models.value = m
} catch { /* 模型列表可选 */ } } catch { /* 模型列表可选 */ }
} catch (e: any) { } catch (e: any) {
if (e && e.status === 401) { router.push('/login'); return } if (e && e.status === 401) { router.push('/login'); return }
+2 -1
View File
@@ -122,7 +122,8 @@ async function load() {
value: envs[env].value || '', value: envs[env].value || '',
show: false, show: false,
})) }))
warns.value = (body.meta?.warnings || []).concat(body.meta?.route_warnings || []) // 第二十七轮: 路由告警(meta.route_warnings)随路由功能删除,体检结论只看 warnings
warns.value = body.meta?.warnings || []
} catch (e: any) { } catch (e: any) {
err.value = (e?.body?.detail || e?.message || String(e)) err.value = (e?.body?.detail || e?.message || String(e))
} finally { } finally {
+14 -16
View File
@@ -36,15 +36,14 @@
<div class="grid-eq"> <div class="grid-eq">
<div class="card"> <div class="card">
<div class="card-h"> <div class="card-h">
<b>{{ t('metrics.routeVsProvider') }}</b> <b>{{ t('metrics.byProvider') }}</b>
<span class="sub">{{ t('metrics.snapshot') }}</span> <span class="sub">{{ t('metrics.snapshot') }}</span>
<div class="legend"> <div class="legend">
<span><i style="background: var(--chart-a)" />ok</span> <span><i style="background: var(--chart-a)" />ok</span>
<span><i style="background: var(--err)" />fail</span> <span><i style="background: var(--err)" />fail</span>
<span><i style="background: var(--warn)" />fallback</span>
</div> </div>
</div> </div>
<EChart :option="routeOpt" height="250px" /> <EChart :option="providerOpt" height="250px" />
</div> </div>
<div class="card"> <div class="card">
<div class="card-h"> <div class="card-h">
@@ -88,7 +87,6 @@
<div class="about-line"> <div class="about-line">
<b>{{ t('metrics.snapshot') }}</b> <b>{{ t('metrics.snapshot') }}</b>
<span>{{ t('metrics.uptime') }} {{ fmtUptime }}</span> <span>{{ t('metrics.uptime') }} {{ fmtUptime }}</span>
<span>{{ t('metrics.fallback') }} {{ data.fallback_total ?? 0 }}</span>
<span>{{ t('metrics.inflight') }} {{ data.in_flight ?? 0 }} / {{ data.in_flight_peak ?? 0 }}</span> <span>{{ t('metrics.inflight') }} {{ data.in_flight ?? 0 }} / {{ data.in_flight_peak ?? 0 }}</span>
</div> </div>
</div> </div>
@@ -156,7 +154,8 @@ const cards = computed(() => {
{ k: t('metrics.requests'), v: all, note: t('dashboard.noteOkFail', { ok, fail }) }, { k: t('metrics.requests'), v: all, note: t('dashboard.noteOkFail', { ok, fail }) },
{ k: t('metrics.failCount'), v: fail, note: t('metrics.failRateNote', { v: rate.toFixed(1) }) }, { k: t('metrics.failCount'), v: fail, note: t('metrics.failRateNote', { v: rate.toFixed(1) }) },
{ k: t('metrics.tokenUsage'), v: (tk.prompt || 0) + (tk.completion || 0), note: t('metrics.tokenNote', { p: tk.prompt ?? 0, c: tk.completion ?? 0 }) }, { k: t('metrics.tokenUsage'), v: (tk.prompt || 0) + (tk.completion || 0), note: t('metrics.tokenNote', { p: tk.prompt ?? 0, c: tk.completion ?? 0 }) },
{ k: t('metrics.inflightPeak'), v: `${data.value.in_flight ?? 0} / ${data.value.in_flight_peak ?? 0}`, note: t('metrics.fallback') + ' ' + (data.value.fallback_total ?? 0) }, // 第二十七轮: fallback 计数随路由功能删除 → 这张卡片的注脚改成运行时长
{ k: t('metrics.inflightPeak'), v: `${data.value.in_flight ?? 0} / ${data.value.in_flight_peak ?? 0}`, note: t('metrics.uptime') + ' ' + fmtUptime.value },
] ]
}) })
@@ -194,27 +193,26 @@ const provOpt = computed<EChartsCoreOption>(() => {
} }
}) })
const routeOpt = computed<EChartsCoreOption>(() => { // 第二十七轮: 路由维度指标随路由功能删除(routes/fallback_total 已不在 /metrics 里),
// 这里改成按供应商看 成功 / 失败(供应商是现在唯一的"聚合维度")。
const providerOpt = computed<EChartsCoreOption>(() => {
void resolved.value void resolved.value
const c = chartTheme() const c = chartTheme()
const r = data.value.routes || {} const p = data.value.providers || {}
const ks = Object.keys(r) const names = Object.keys(p)
const names = ks.length ? ks : ['wjd'] const get = (k: string, f: string) => (p[k] || {})[f] || 0
const get = (k: string, f: string) => (r[k] || {})[f] || 0
const ok = names.map((n) => get(n, 'ok')) const ok = names.map((n) => get(n, 'ok'))
const fail = names.map((n) => get(n, 'fail')) const fail = names.map((n) => get(n, 'fail'))
const fallback = names.map((n) => get(n, 'fallback'))
return { return {
tooltip: { trigger: 'axis', axisPointer: { type: 'shadow' } }, tooltip: { trigger: 'axis', axisPointer: { type: 'shadow' } },
legend: legend(['ok', 'fail', 'fallback']), legend: legend(['ok', 'fail']),
grid, grid,
graphic: emptyTip([ok, fail, fallback], t('metrics.none')), graphic: emptyTip([ok, fail], t('metrics.none')),
xAxis: categoryAxis(names, 10), xAxis: categoryAxis(names, 10),
yAxis: valueAxis('', 1), yAxis: valueAxis('', 1),
series: [ series: [
{ name: 'ok', type: 'bar', stack: 'r', data: ok, itemStyle: { color: c.a } }, { name: 'ok', type: 'bar', stack: 'p', data: ok, itemStyle: { color: c.a } },
{ name: 'fail', type: 'bar', stack: 'r', data: fail, itemStyle: { color: c.err } }, { name: 'fail', type: 'bar', stack: 'p', data: fail, itemStyle: { color: c.err } },
{ name: 'fallback', type: 'bar', stack: 'r', data: fallback, itemStyle: { color: c.warn } },
], ],
} }
}) })
+85 -48
View File
@@ -11,36 +11,32 @@
</div> </div>
<div class="grid2"> <div class="grid2">
<!-- 路由链:只读展示(排序策略在后端,页面不写盘) --> <!-- 全部文本模型 + 一键测速(延迟逐行填充;测速按模型自己的协议线探测) -->
<!-- 路由别名 + 全部文本模型延迟(一键测速填充) -->
<div class="card"> <div class="card">
<div class="card-h"> <div class="card-h">
<b>{{ t('models.routeAliasTitle') }}</b> <b>{{ t('models.allTextModels') }}</b>
<span class="sub">{{ t('models.speedtestHint') }}</span>
<span style="flex:1"></span>
<el-button size="small" :loading="latTesting" @click="runSpeedtest()">
{{ latTesting ? t('models.testingShort') : t('models.speedtest') }}
</el-button>
</div> </div>
<div v-for="r in routeRows" :key="r.name" class="route-block">
<div class="route-head">
<span class="code route-name">{{ r.name }}</span>
<span style="flex:1"></span>
<el-button size="small" :loading="latTesting" @click="runSpeedtest()">
{{ latTesting ? t('models.testingShort') : t('models.speedtest') }}
</el-button>
</div>
</div>
<div v-if="!routeRows.length" class="hint">{{ t('models.noRoute') }}</div>
<div class="lat-head"> <div class="lat-head">
<span class="muted-2 hint">{{ t('models.allTextModels') }}</span> <span class="muted-2 hint">{{ t('models.allTextModels') }}</span>
<span style="flex:1"></span> <span style="flex:1"></span>
<span class="muted-2 hint">{{ t('models.latency') }}</span> <span class="muted-2 hint">{{ t('models.latency') }}</span>
</div> </div>
<div v-for="m in textModelRows" :key="m.id" class="st-item"> <div v-for="m in textModelRows" :key="m.id" class="st-item">
<div class="st-row"> <div class="st-row" :title="rowTitle(m)">
<Icon v-if="m.vision" name="eye" :size="12" class="vision" /> <Icon v-if="m.vision" name="eye" :size="12" class="vision" />
<!-- 第二十五轮:该模型的参数被上游固定(如 temperature 只能是 1), <!-- 第二十五轮:该模型的参数被上游固定(如 temperature 只能是 1),
挂锁标注 + 悬浮说明,省掉「为什么我传的参数不生效」这类困惑。 --> 挂锁标注 + 悬浮说明,省掉「为什么我传的参数不生效」这类困惑。 -->
<Icon v-if="m.paramNote" name="lock" :size="12" class="plock" :title="m.paramNote" /> <Icon v-if="m.paramNote" name="lock" :size="12" class="plock" :title="m.paramNote" />
<span class="code">{{ m.id }}</span> <span class="code">{{ m.id }}</span>
<!-- 支持的格式不在这里铺标签:这行还要放供应商/延迟/测速按钮,窄卡放不下第三颗
(悬停整行可见格式 + 本次测速走的线,见 rowTitle)。权威展示在下方表格的
「支持的格式」列。 -->
<span class="muted-2 st-prov">{{ m.provider }}</span> <span class="muted-2 st-prov">{{ m.provider }}</span>
<span style="flex:1"></span> <span style="flex:1"></span>
<span class="pill st-lat" :class="latCls(m.id)"> <span class="pill st-lat" :class="latCls(m.id)">
@@ -87,20 +83,42 @@
<b>{{ t('models.modelListTitle') }}</b> <b>{{ t('models.modelListTitle') }}</b>
<span class="sub">{{ t('models.capability') }}</span> <span class="sub">{{ t('models.capability') }}</span>
<div class="pager"> <div class="pager">
<span class="pill mute">{{ t('models.routeCount', { n: routeRows.length }) }}</span> <span class="pill mute">{{ t('models.textModelCount', { n: textModelRows.length }) }}</span>
</div> </div>
</div> </div>
<el-table :data="modelRows" size="small" v-loading="loading"> <el-table :data="modelRows" size="small" v-loading="loading">
<el-table-column :label="t('models.id')" min-width="200"> <el-table-column :label="t('models.id')" min-width="185">
<template #default="{ row }"><span class="code">{{ row.id }}</span></template> <template #default="{ row }"><span class="code">{{ row.id }}</span></template>
</el-table-column> </el-table-column>
<el-table-column :label="t('models.type')" width="100"> <el-table-column :label="t('models.type')" width="90">
<template #default="{ row }"><span class="pill" :class="typeCls(row.type)">{{ t(typeKey(row.type)) }}</span></template> <template #default="{ row }"><span class="pill" :class="typeCls(row.type)">{{ t(typeKey(row.type)) }}</span></template>
</el-table-column> </el-table-column>
<el-table-column :label="t('models.provider')" min-width="150"> <el-table-column :label="t('models.provider')" min-width="140">
<template #default="{ row }">{{ row.provider_name || '—' }}</template> <template #default="{ row }">{{ row.provider_name || '—' }}</template>
</el-table-column> </el-table-column>
<el-table-column :label="t('models.capability')" width="190"> <!-- 第二十七轮追加:支持的格式(三条协议线)——
后端 /v1/models 里每个文本模型带 protocols 数组(chat/completions、messages、
responses 的一个子集)。这里只做展示,但它有实际约束力:用不在列表里的格式
调网关,会在入口被 400 挡下(网关不做跨格式转换,见 /v1/messages 的 400 文案)。
图像/视频模型走专用端点,不涉及三条协议线,统一显示「不适用」。
width 取 300:实测三颗标签(chat/completions=120px + messages=67px + responses=74px
+ 间距)并排一行需 ~273px,留足余量让多线模型那行也单行,不挤到换行。 -->
<el-table-column width="300">
<template #header>
<el-tooltip :content="t('models.protocolHint')" placement="top">
<span class="proto-th">{{ t('models.protocols') }}</span>
</el-tooltip>
</template>
<template #default="{ row }">
<span v-if="protocolsOf(row).length" class="proto-cell">
<span v-for="p in protocolsOf(row)" :key="p" class="pill proto" :title="protoTitle(p)">{{ p }}</span>
</span>
<el-tooltip v-else :content="t('models.protocolNaHint')" placement="top">
<span class="muted-2">{{ t('models.protocolNa') }}</span>
</el-tooltip>
</template>
</el-table-column>
<el-table-column :label="t('models.capability')" width="170">
<template #default="{ row }"> <template #default="{ row }">
<span v-if="row.vision" class="pill ok cap"> <span v-if="row.vision" class="pill ok cap">
<Icon name="eye" :size="12" />{{ t('models.visionTag') }} <Icon name="eye" :size="12" />{{ t('models.visionTag') }}
@@ -111,7 +129,7 @@
<span v-if="!row.vision && !paramKeys(row).length" class="muted-2">—</span> <span v-if="!row.vision && !paramKeys(row).length" class="muted-2">—</span>
</template> </template>
</el-table-column> </el-table-column>
<el-table-column :label="t('models.keySet')" width="120"> <el-table-column :label="t('models.keySet')" width="90">
<template #default="{ row }"> <template #default="{ row }">
<span class="pill" :class="row.key_set ? 'ok' : 'err'"> <span class="pill" :class="row.key_set ? 'ok' : 'err'">
{{ row.key_set ? t('common.yes') : t('common.no') }} {{ row.key_set ? t('common.yes') : t('common.no') }}
@@ -138,14 +156,27 @@ const health = ref<any>({})
const loading = ref(false) const loading = ref(false)
const err = ref('') const err = ref('')
const typeKeyMap: Record<string, string> = { text: 'models.text', image: 'models.image', video: 'models.video', route: 'models.route' } const typeKeyMap: Record<string, string> = { text: 'models.text', image: 'models.image', video: 'models.video' }
const typeClsMap: Record<string, string> = { text: 'mute', image: 'warn', video: 'warn', route: 'ok' } const typeClsMap: Record<string, string> = { text: 'mute', image: 'warn', video: 'warn' }
function typeKey(ty: string) { return typeKeyMap[ty] || ty } function typeKey(ty: string) { return typeKeyMap[ty] || ty }
function typeCls(ty: string) { return typeClsMap[ty] || 'mute' } function typeCls(ty: string) { return typeClsMap[ty] || 'mute' }
// ── 支持的格式(第二十七轮)──
// 取值范围与后端 PROTOCOLS 一致:chat/completions(OpenAI 兼容线)、messages(Anthropic 线)、
// responses(OpenAI Responses 线)。**名字直接取各家标准端点名**,不另起中文别名 —— 配置、
// 日志、前端标签、上游文档四处同名,出问题时对得上号。
function protocolsOf(row: any): string[] {
if (!row || row.type !== 'text') return [] // 图像/视频模型走专用端点,没有协议线概念
return (row.protocols as string[]) || []
}
// 每个格式标签的悬浮说明:这条线对应哪个端点(点进说明文档也是这个对应关系)
function protoTitle(p: string): string { return `POST /v1/${p}` }
const latTesting = ref(false) const latTesting = ref(false)
const latCurrentId = ref('') // 当前正在测的模型 id:该行延迟位显示加载图标 const latCurrentId = ref('') // 当前正在测的模型 id:该行延迟位显示加载图标
const latByModel = ref<Record<string, { ok: boolean; latency_ms: number | null; error: string }>>({}) // protocol 由后端返回:探针**按模型自己的协议线**挑一条(优先级 chat → messages → responses),
// 记下来才能在悬浮提示里说清「这次多少毫秒是走哪条线测的」——多线模型不写清楚会让人误解。
const latByModel = ref<Record<string, { ok: boolean; latency_ms: number | null; error: string; protocol: string }>>({})
async function runSpeedtest() { async function runSpeedtest() {
if (latTesting.value) return if (latTesting.value) return
// 逐个测速:按列表顺序,测一个立刻显示那一行、再测下一个;当前测的行显示加载图标。 // 逐个测速:按列表顺序,测一个立刻显示那一行、再测下一个;当前测的行显示加载图标。
@@ -155,17 +186,17 @@ async function runSpeedtest() {
latTesting.value = true latTesting.value = true
for (const id of ids) { for (const id of ids) {
latCurrentId.value = id latCurrentId.value = id
let row: { ok: boolean; latency_ms: number | null; error: string } let row: { ok: boolean; latency_ms: number | null; error: string; protocol: string }
try { try {
const j = await api('/v1/models/speedtest', { method: 'POST', body: JSON.stringify({ model: id }) }) const j = await api('/v1/models/speedtest', { method: 'POST', body: JSON.stringify({ model: id }) })
const r: any[] = (j && j.results) || [] const r: any[] = (j && j.results) || []
const hit = r[0] const hit = r[0]
row = hit row = hit
? { ok: !!hit.ok, latency_ms: hit.latency_ms ?? null, error: hit.error || '' } ? { ok: !!hit.ok, latency_ms: hit.latency_ms ?? null, error: hit.error || '', protocol: hit.protocol || '' }
: { ok: false, latency_ms: null, error: t('models.speedtestFail') } : { ok: false, latency_ms: null, error: t('models.speedtestFail'), protocol: '' }
} catch (e: any) { } catch (e: any) {
// 单个模型出错不中断整轮,标记失败后继续下一个 // 单个模型出错不中断整轮,标记失败后继续下一个
row = { ok: false, latency_ms: null, error: (e && e.message) || String(e) } row = { ok: false, latency_ms: null, error: (e && e.message) || String(e), protocol: '' }
} }
latByModel.value = { ...latByModel.value, [id]: row } // 响应式替换 → 该行即时更新 latByModel.value = { ...latByModel.value, [id]: row } // 响应式替换 → 该行即时更新
} }
@@ -182,11 +213,11 @@ async function retestOne(id: string) {
const r: any[] = (j && j.results) || [] const r: any[] = (j && j.results) || []
const hit = r[0] const hit = r[0]
const row = hit const row = hit
? { ok: !!hit.ok, latency_ms: hit.latency_ms ?? null, error: hit.error || '' } ? { ok: !!hit.ok, latency_ms: hit.latency_ms ?? null, error: hit.error || '', protocol: hit.protocol || '' }
: { ok: false, latency_ms: null, error: t('models.speedtestFail') } : { ok: false, latency_ms: null, error: t('models.speedtestFail'), protocol: '' }
latByModel.value = { ...latByModel.value, [id]: row } latByModel.value = { ...latByModel.value, [id]: row }
} catch (e: any) { } catch (e: any) {
latByModel.value = { ...latByModel.value, [id]: { ok: false, latency_ms: null, error: (e && e.message) || String(e) } } latByModel.value = { ...latByModel.value, [id]: { ok: false, latency_ms: null, error: (e && e.message) || String(e), protocol: '' } }
} finally { } finally {
latCurrentId.value = '' latCurrentId.value = ''
} }
@@ -208,8 +239,8 @@ function latCls(id: string): string {
return row ? (row.ok ? 'ok' : 'err') : 'mute' return row ? (row.ok ? 'ok' : 'err') : 'mute'
} }
const routes = computed(() => items.value.filter((x) => x.type === 'route')) // 第二十七轮: 路由别名条目(type === 'route')已从 /v1/models 消失 → 这里只剩真实模型
const models = computed(() => items.value.filter((x) => x.type !== 'route')) const models = computed(() => items.value)
const providerOf = computed(() => { const providerOf = computed(() => {
const m: Record<string, string> = {} const m: Record<string, string> = {}
@@ -222,16 +253,6 @@ const visionOf = computed(() => {
return m return m
}) })
const routeRows = computed(() =>
routes.value.map((r) => {
const chain: string[] = r.models || []
return {
name: r.id,
models: chain.map((id) => ({ id, provider: providerOf.value[id] || '—', vision: visionOf.value[id] })),
providerCount: new Set(chain.map((id) => providerOf.value[id] || '—')).size,
}
}),
)
const textModelRows = computed(() => const textModelRows = computed(() =>
models.value.filter((x) => x.type === 'text').map((m) => ({ models.value.filter((x) => x.type === 'text').map((m) => ({
id: m.id, id: m.id,
@@ -239,9 +260,21 @@ const textModelRows = computed(() =>
vision: !!m.vision, vision: !!m.vision,
// 模型级强制参数(第二十五轮):被上游固定住的采样参数,用挂锁标注出来。 // 模型级强制参数(第二十五轮):被上游固定住的采样参数,用挂锁标注出来。
paramNote: paramKeys(m).length ? paramNote(m) : '', paramNote: paramKeys(m).length ? paramNote(m) : '',
// 支持的格式(第二十七轮):悬浮这一行就能看到「能用哪几条线 + 本次测速走的哪条」
formats: protocolsOf(m),
})), })),
) )
// 测速行的悬浮提示:先说这个模型支持哪些格式,再说这次测的是哪条线
// (多线模型不标注的话,"12 ms"到底测的是哪条线是看不出来的)。
function rowTitle(m: any): string {
const lines = (m.formats || []).join(' / ') || t('models.protocolNa')
const p = latByModel.value[m.id]?.protocol
return p
? `${t('models.protocolHintRow', { lines })}· ${t('models.probedLine', { p })}`
: t('models.protocolHintRow', { lines })
}
// ── 模型级强制参数(第二十五轮)── // ── 模型级强制参数(第二十五轮)──
// 后端 /v1/models 在 params 里给出「该模型发往上游前会被强制覆盖的参数」 // 后端 /v1/models 在 params 里给出「该模型发往上游前会被强制覆盖的参数」
// (例:kimi-k2.7-code 只接受 temperature=1)。这里只做展示,不提供编辑入口。 // (例:kimi-k2.7-code 只接受 temperature=1)。这里只做展示,不提供编辑入口。
@@ -279,7 +312,6 @@ const cards = computed(() => [
{ k: t('models.model'), v: models.value.length, note: t('models.providerCount2', { n: providerRows.value.length }) }, { k: t('models.model'), v: models.value.length, note: t('models.providerCount2', { n: providerRows.value.length }) },
{ k: t('models.textModels'), v: models.value.filter((m) => m.type === 'text').length, note: t('models.visionTag') + ' · ' + models.value.filter((m) => m.vision).length }, { k: t('models.textModels'), v: models.value.filter((m) => m.type === 'text').length, note: t('models.visionTag') + ' · ' + models.value.filter((m) => m.vision).length },
{ k: t('models.imageModels'), v: models.value.filter((m) => m.type === 'image').length, note: t('images.title') }, { k: t('models.imageModels'), v: models.value.filter((m) => m.type === 'image').length, note: t('images.title') },
{ k: t('models.routes'), v: routes.value.length, note: t('models.routeAliasTitle') },
]) ])
onMounted(async () => { onMounted(async () => {
@@ -298,15 +330,20 @@ onMounted(async () => {
</script> </script>
<style scoped> <style scoped>
.route-block { padding: 10px 0; border-bottom: 1px solid var(--line-2); }
.route-block:last-child { border-bottom: 0; }
.route-head { display: flex; align-items: center; gap: 8px; margin-bottom: 8px; }
.route-name { font-weight: 700; color: var(--text); font-size: 13px; }
.chain { display: flex; align-items: center; gap: 6px; flex-wrap: wrap; } .chain { display: flex; align-items: center; gap: 6px; flex-wrap: wrap; }
.chain-item { display: inline-flex; align-items: center; gap: 6px; } .chain-item { display: inline-flex; align-items: center; gap: 6px; }
.arrow { color: var(--muted-2); } .arrow { color: var(--muted-2); }
.vision { color: var(--primary); } .vision { color: var(--primary); }
.plock { color: var(--warn); } .plock { color: var(--warn); }
/* 支持的格式:三条线是并列关系(没有谁更优),统一用主题色弱底,
不用 ok/warn/err —— 否则「messages」看起来像警告、「responses」像被禁用。 */
.proto {
color: var(--primary); background: var(--primary-soft);
font-family: ui-monospace, SFMono-Regular, Menlo, monospace; /* 与全局 .code 同一套 */
font-size: 11px; padding: 2px 7px;
}
.proto-cell { display: inline-flex; align-items: center; gap: 5px; flex-wrap: wrap; }
.proto-th { border-bottom: 1px dotted var(--muted-2); cursor: help; }
.prov { padding: 10px 0; border-bottom: 1px solid var(--line-2); } .prov { padding: 10px 0; border-bottom: 1px solid var(--line-2); }
.prov:last-child { border-bottom: 0; } .prov:last-child { border-bottom: 0; }
.prov-top { display: flex; align-items: center; gap: 8px; } .prov-top { display: flex; align-items: center; gap: 8px; }
-20
View File
@@ -1,20 +0,0 @@
<template>
<div class="page">
<div class="card">
<div class="ph-title">「{{ title }}」页面</div>
<div class="ph-sub">该功能在后续里程碑开发(M2 对话 / M3 媒体 / M4 指标日志 等)。</div>
</div>
</div>
</template>
<script setup lang="ts">
import { computed } from 'vue'
import { useRoute } from 'vue-router'
const route = useRoute()
const title = computed(() => (route.meta.title as string) || '')
</script>
<style scoped>
.ph-title { font-size: 18px; font-weight: 600; }
.ph-sub { color: var(--muted); margin-top: 8px; }
</style>
+8 -10
View File
@@ -67,7 +67,7 @@
<div class="set-row"> <div class="set-row">
<div class="lb">{{ t('settings.defaultModel') }}</div> <div class="lb">{{ t('settings.defaultModel') }}</div>
<div class="rt"> <div class="rt">
<el-select v-model="defs.model" size="small" clearable :placeholder="t('chat.routeGroup')" style="width: 210px"> <el-select v-model="defs.model" size="small" clearable :placeholder="t('chat.pickModel')" style="width: 210px">
<el-option v-for="m in textModels" :key="m" :label="m" :value="m" /> <el-option v-for="m in textModels" :key="m" :label="m" :value="m" />
</el-select> </el-select>
</div> </div>
@@ -179,10 +179,6 @@
<div class="lb">{{ t('dashboard.inflight') }}</div> <div class="lb">{{ t('dashboard.inflight') }}</div>
<div class="rt">{{ health.in_flight ?? '-' }} / {{ health.in_flight_peak ?? '-' }}</div> <div class="rt">{{ health.in_flight ?? '-' }} / {{ health.in_flight_peak ?? '-' }}</div>
</div> </div>
<div class="set-row">
<div class="lb">{{ t('dashboard.fallback') }}</div>
<div class="rt">{{ health.fallback_total ?? 0 }}</div>
</div>
<div class="set-row" style="align-items: flex-start"> <div class="set-row" style="align-items: flex-start">
<div class="lb">{{ t('settings.providerStatus') }}</div> <div class="lb">{{ t('settings.providerStatus') }}</div>
<div class="rt" style="flex-wrap: wrap; justify-content: flex-end"> <div class="rt" style="flex-wrap: wrap; justify-content: flex-end">
@@ -228,8 +224,8 @@ const err = ref('')
const { t, locale } = useI18n() const { t, locale } = useI18n()
const { theme, followSystem, setTheme, setFollowSystem } = useTheme() const { theme, followSystem, setTheme, setFollowSystem } = useTheme()
// 对话默认模型下拉(老板决策:wjd 链路 = 全部文本模型;这里同样覆盖全部文本模型) // 对话默认模型下拉(覆盖全部文本模型;第二十七轮: wjd 路由别名已删除,不再有"别名"选项)
const TEXT_MODELS = ['wjd', const TEXT_MODELS = [
'agnes-3.0-flash', 'agnes-2.5-flash', 'ark-code-latest', 'agnes-3.0-flash', 'agnes-2.5-flash', 'ark-code-latest',
// OpenCode Go(订阅编程模型,17 个文本模型) // OpenCode Go(订阅编程模型,17 个文本模型)
'glm-5.3-flash', 'glm-5.3', 'glm-5.2', 'glm-5.1', 'glm-5.3-flash', 'glm-5.3', 'glm-5.2', 'glm-5.1',
@@ -252,7 +248,9 @@ const savingDefs = ref(false)
function loadDefs() { function loadDefs() {
const d = getChatDefaults() const d = getChatDefaults()
defs.model = d.model ?? 'wjd' // 第二十七轮: 默认模型不再回落到 wjd(该别名已删除)—— 认不出就留空串,
// Settings 的模型下拉在 onMounted 里会用真实模型列表兜底。
defs.model = d.model ?? ''
defs.temperature = d.temperature ?? 0.7 defs.temperature = d.temperature ?? 0.7
defs.top_p = d.top_p ?? 1 defs.top_p = d.top_p ?? 1
defs.max_tokens = d.max_tokens ?? null defs.max_tokens = d.max_tokens ?? null
@@ -315,8 +313,8 @@ onMounted(async () => {
// 默认模型下拉用真实模型列表(拿不到就退回内置候选) // 默认模型下拉用真实模型列表(拿不到就退回内置候选)
try { try {
const um = await api('/v1/models') const um = await api('/v1/models')
const list = (um.data || []).filter((x: any) => x.type !== 'route').map((x: any) => x.id) const list = (um.data || []).filter((x: any) => x.type !== 'image' && x.type !== 'video').map((x: any) => x.id)
if (list.length) textModels.value = ['wjd', ...list] if (list.length) textModels.value = list
} catch { /* 模型列表可选 */ } } catch { /* 模型列表可选 */ }
} catch (e: any) { } catch (e: any) {
if (e && e.status === 401) { router.push('/login'); return } if (e && e.status === 401) { router.push('/login'); return }
+19 -6
View File
@@ -1,9 +1,22 @@
import { defineConfig } from 'vite' import { defineConfig } from 'vite'
import vue from '@vitejs/plugin-vue' import vue from '@vitejs/plugin-vue'
import AutoImport from 'unplugin-auto-import/vite'
import Components from 'unplugin-vue-components/vite'
import { ElementPlusResolver } from 'unplugin-vue-components/resolvers'
// base 用 /web/:构建产物由网关挂载在同一源 /web 下,与 /v1 /auth /health 同源。 // base 用 /web/:构建产物由网关挂载在同一源 /web 下,与 /v1 /auth /health 同源。
export default defineConfig({ export default defineConfig({
plugins: [vue()], plugins: [
vue(),
// 第二十八轮:element-plus 改按需引入(此前全量 app.use(ElementPlus),vendor-element
// 一个 chunk 就 1089kB / gzip 341kB,是首屏体积大头)。
// Components:模板里用到的 <el-*> 自动注入该组件 + 对应样式(importStyle 默认 css)。
// AutoImport:只管命令式 ElMessage/ElMessageBox —— 但我们代码里显式 import 了它们,
// 样式在 main.ts 手动引了三处;这里开 resolver 只为兜住误用,不生成 dts(dts:false,
// 免得多一个触发全量解析的入口)。
AutoImport({ resolvers: [ElementPlusResolver()], dts: false }),
Components({ resolvers: [ElementPlusResolver()], dts: false }),
],
base: '/web/', base: '/web/',
server: { server: {
port: 5173, port: 5173,
@@ -25,15 +38,15 @@ export default defineConfig({
}, },
}, },
build: { build: {
// M5: 剩余超 500kB 的都是独立 vendor chunk(element-plus / echarts),缓存友好, // M5: 按需引入后 element-plus 已拆分,超 500kB 的只剩 echarts(服务端大图渲染不可避免)。
// gzip 后约 340kB / 202kB。根因是 element-plus 全量引入,按需引入留作后续。 chunkSizeWarningLimit: 900,
chunkSizeWarningLimit: 1500,
rollupOptions: { rollupOptions: {
output: { output: {
// M5: 拆 vendor chunk,避免 element-plus/echarts/marked 打进单个入口超大 chunk。 // M5: 拆 vendor chunk,避免第三方打进单个入口超大 chunk。
manualChunks: { manualChunks: {
'vendor-vue': ['vue', 'vue-router', 'pinia'], 'vendor-vue': ['vue', 'vue-router', 'pinia'],
'vendor-element': ['element-plus', '@element-plus/icons-vue'], // 第二十八轮: element-plus 已按需引入——不再把整包塞进一个 chunk;
// @element-plus/icons-vue 无用已从依赖移除,这里一并清掉。
'vendor-echarts': ['echarts'], 'vendor-echarts': ['echarts'],
'vendor-markdown': ['marked', 'marked-highlight', 'dompurify', 'highlight.js'], 'vendor-markdown': ['marked', 'marked-highlight', 'dompurify', 'highlight.js'],
}, },
+63 -21
View File
@@ -2,6 +2,9 @@
用法: python live_check.py --key <wjd-xxx> [--url http://127.0.0.1:8808] 用法: python live_check.py --key <wjd-xxx> [--url http://127.0.0.1:8808]
网关已开鉴权,所有端点带 Authorization: Bearer <key>。 网关已开鉴权,所有端点带 Authorization: Bearer <key>。
第二十七轮(2026-09-18):路由别名 wjd 已整体删除 → 本脚本里的模型一律用**真实模型 id**,
并新增「三线直传」与「跨线 400」检查(chat/completions · messages · responses 各按自家协议直传)。
""" """
from __future__ import annotations from __future__ import annotations
@@ -12,12 +15,25 @@ import httpx
PASS, FAIL, WARN = [], [], [] PASS, FAIL, WARN = [], [], []
# 第二十七轮: 三线直传用到的真实模型 id
CHAT_MODEL = "agnes-3.0-flash" # 只声明 chat/completions 线
THREE_LINE_MODEL = "deepseek-v4.1-flash" # 实测三线全通(chat/completions · messages · responses)
def check(name: str, cond: bool, detail: str = "") -> None: def check(name: str, cond: bool, detail: str = "") -> None:
(PASS if cond else FAIL).append(name) (PASS if cond else FAIL).append(name)
print(f"[{'PASS' if cond else 'FAIL'}] {name} {detail}") print(f"[{'PASS' if cond else 'FAIL'}] {name} {detail}")
def check_or_warn(name: str, cond: bool, detail: str = "") -> None:
"""上游侧的结果不定(模型/额度/协议细节),不算硬失败 —— 但网关侧的闸门必须硬判。"""
if cond:
PASS.append(name)
print(f"[PASS] {name} {detail}")
else:
warn(name, detail)
def warn(name: str, detail: str = "") -> None: def warn(name: str, detail: str = "") -> None:
WARN.append(name) WARN.append(name)
print(f"[WARN] {name} {detail}") print(f"[WARN] {name} {detail}")
@@ -37,76 +53,102 @@ def main() -> int:
j = r.json() if r.status_code == 200 else {} j = r.json() if r.status_code == 200 else {}
check("GET / 根导航", r.status_code == 200 and "endpoints" in j, f"{r.status_code}") check("GET / 根导航", r.status_code == 200 and "endpoints" in j, f"{r.status_code}")
# 2) 走路由别名 wjd 的真实 chat(验证 route 维度指标) # 2) 真实 chat(第二十七轮: 不再有路由别名 —— model 就是真实模型 id,
# 网关不替用户挑模型,served_model 必须与请求的 id 一致)
r = c.post(f"{base}/v1/chat/completions", json={ r = c.post(f"{base}/v1/chat/completions", json={
"model": "wjd", "messages": [{"role": "user", "content": "回复:OK"}], "max_tokens": 12}) "model": CHAT_MODEL, "messages": [{"role": "user", "content": "回复:OK"}], "max_tokens": 12})
ok = r.status_code == 200 and len(r.json().get("choices", [])) > 0 ok = r.status_code == 200 and len(r.json().get("choices", [])) > 0
served = r.json().get("served_model") if ok else None served = r.json().get("served_model") if ok else None
check("POST chat 走路由 wjd", ok, f"{r.status_code} served={served}") check(f"POST chat 真实模型 {CHAT_MODEL}", ok, f"{r.status_code} served={served}")
check("served_model == 请求的 model(不再有 fallback 换模型)", served == CHAT_MODEL,
f"served={served}")
# 3) 未知模型 → 400(Bug 15) # 3) 未知模型 → 400(Bug 15)
r = c.post(f"{base}/v1/chat/completions", json={ r = c.post(f"{base}/v1/chat/completions", json={
"model": "__nope__", "messages": [{"role": "user", "content": "x"}]}) "model": "__nope__", "messages": [{"role": "user", "content": "x"}]})
check("未知模型 → 400(Bug 15)", r.status_code == 400, f"{r.status_code}") check("未知模型 → 400(Bug 15)", r.status_code == 400, f"{r.status_code}")
# 4) /metrics 里 routes.wjd 的 ok 应 ≥1(Bug 8:route 维度不再恒 0) # 4) /metrics:模型维度在记账;路由维度已随路由功能删除(不该再出现)
r = c.get(f"{base}/metrics") r = c.get(f"{base}/metrics")
j = r.json() if r.status_code == 200 else {} j = r.json() if r.status_code == 200 else {}
wjd = (j.get("routes") or {}).get("wjd") or {} mine = (j.get("calls") or {}).get(CHAT_MODEL) or {}
check("GET /metrics 已启用", r.status_code == 200, f"{r.status_code}") check("GET /metrics 已启用", r.status_code == 200, f"{r.status_code}")
check("routes.wjd.ok ≥ 1(Bug 8)", wjd.get("ok", 0) >= 1, f"wjd={wjd}") check(f"calls.{CHAT_MODEL}.ok ≥ 1(模型维度记账)", mine.get("ok", 0) >= 1, f"{mine}")
check("路由维度已删除(无 routes / fallback_total)",
"routes" not in j and "fallback_total" not in j, f"keys={sorted(j)[:8]}…")
# 5) 流式 SSE(走 wjd) # 5) 流式 SSE(真实模型)
body = "" body = ""
with c.stream("POST", f"{base}/v1/chat/completions", json={ with c.stream("POST", f"{base}/v1/chat/completions", json={
"model": "wjd", "messages": [{"role": "user", "content": "数到三"}], "model": CHAT_MODEL, "messages": [{"role": "user", "content": "数到三"}],
"stream": True, "max_tokens": 16}) as sr: "stream": True, "max_tokens": 16}) as sr:
if sr.status_code == 200: if sr.status_code == 200:
body = "".join(sr.iter_text()) body = "".join(sr.iter_text())
check("流式 SSE 走 wjd 且以 [DONE] 收尾", sr.status_code == 200 and "[DONE]" in body, check("流式 SSE 且以 [DONE] 收尾", sr.status_code == 200 and "[DONE]" in body,
f"{sr.status_code} len={len(body)}") f"{sr.status_code} len={len(body)}")
# 6) 流式后 routes.wjd.ok 继续累加(流式也记 route) # 6) 流式也计入模型维度指标
r = c.get(f"{base}/metrics") r = c.get(f"{base}/metrics")
wjd2 = ((r.json().get("routes") or {}).get("wjd") or {}) if r.status_code == 200 else {} mine2 = ((r.json().get("calls") or {}).get(CHAT_MODEL) or {}) if r.status_code == 200 else {}
check("流式也计入 routes.wjd(Bug 8 补充)", wjd2.get("ok", 0) > wjd.get("ok", 0), check("流式也计入 calls(Bug 8 补充)", mine2.get("ok", 0) > mine.get("ok", 0),
f"before={wjd.get('ok',0)} after={wjd2.get('ok',0)}") f"before={mine.get('ok',0)} after={mine2.get('ok',0)}")
# 7) Prometheus 指标 # 7) 三线直传(第二十七轮新增)
# 7a) messages 线:Anthropic 协议原样直传
r = c.post(f"{base}/v1/messages", json={
"model": THREE_LINE_MODEL, "max_tokens": 16,
"messages": [{"role": "user", "content": "回复:OK"}]})
check_or_warn(f"POST /v1/messages 直传({THREE_LINE_MODEL})", r.status_code == 200,
f"{r.status_code} {str(r.text)[:120]}")
# 7b) responses 线:OpenAI Responses 协议原样直传
r = c.post(f"{base}/v1/responses", json={
"model": THREE_LINE_MODEL, "input": "回复:OK", "max_tokens": 16})
check_or_warn(f"POST /v1/responses 直传({THREE_LINE_MODEL})", r.status_code == 200,
f"{r.status_code} {str(r.text)[:120]}")
# 7c) 跨线闸门:只支持 chat/completions 的模型打 /v1/messages → 必须 400
# (上游对错线请求回的是 500/401 这类跟"格式选错"无关的错误,网关必须在入口挡住)
r = c.post(f"{base}/v1/messages", json={
"model": CHAT_MODEL, "max_tokens": 16,
"messages": [{"role": "user", "content": "x"}]})
detail = str(r.text)[:160]
check(f"跨线请求 → 400({CHAT_MODEL} 不支持 messages 线)",
r.status_code == 400 and "messages" in detail, f"{r.status_code} {detail}")
# 8) Prometheus 指标
r = c.get(f"{base}/metrics/prometheus") r = c.get(f"{base}/metrics/prometheus")
check("GET /metrics/prometheus", r.status_code == 200 and "api_gateway" in r.text, f"{r.status_code}") check("GET /metrics/prometheus", r.status_code == 200 and "api_gateway" in r.text, f"{r.status_code}")
# 8) 访问日志 # 9) 访问日志
r = c.get(f"{base}/logs?n=5") r = c.get(f"{base}/logs?n=5")
check("GET /logs", r.status_code == 200 and isinstance(r.json().get("entries"), list), f"{r.status_code}") check("GET /logs", r.status_code == 200 and isinstance(r.json().get("entries"), list), f"{r.status_code}")
# 9) provider 健康(可达性 = 2xx,Bug 11) # 10) provider 健康(可达性 = 2xx,Bug 11)
r = c.get(f"{base}/health/agnes") r = c.get(f"{base}/health/agnes")
j = r.json() if r.status_code == 200 else {} j = r.json() if r.status_code == 200 else {}
check("GET /health/agnes reachable(2xx)", r.status_code == 200 and j.get("reachable") is True, check("GET /health/agnes reachable(2xx)", r.status_code == 200 and j.get("reachable") is True,
f"{r.status_code} reachable={j.get('reachable')} code={j.get('status_code')}") f"{r.status_code} reachable={j.get('reachable')} code={j.get('status_code')}")
# 10) 动态 CORS(Bug 6):预检 + 通配来源 # 11) 动态 CORS(Bug 6):预检 + 通配来源
r = c.options(f"{base}/v1/chat/completions", headers={ r = c.options(f"{base}/v1/chat/completions", headers={
"Origin": "https://demo.example", "Access-Control-Request-Method": "POST"}) "Origin": "https://demo.example", "Access-Control-Request-Method": "POST"})
check("CORS 预检 200 且回 ACAO", r.status_code == 200 and check("CORS 预检 200 且回 ACAO", r.status_code == 200 and
r.headers.get("access-control-allow-origin") in ("*", "https://demo.example"), r.headers.get("access-control-allow-origin") in ("*", "https://demo.example"),
f"{r.status_code} ACAO={r.headers.get('access-control-allow-origin')}") f"{r.status_code} ACAO={r.headers.get('access-control-allow-origin')}")
# 11) 413 体积限制 # 12) 413 体积限制
r = c.post(f"{base}/v1/chat/completions", content=b"x" * 3_000_000, r = c.post(f"{base}/v1/chat/completions", content=b"x" * 3_000_000,
headers={"Content-Type": "application/json"}) headers={"Content-Type": "application/json"})
check("超大请求体 → 413", r.status_code == 413, f"{r.status_code}") check("超大请求体 → 413", r.status_code == 413, f"{r.status_code}")
# 12) batch(真实) # 13) batch(真实模型)
r = c.post(f"{base}/v1/chat/completions/batch", json={ r = c.post(f"{base}/v1/chat/completions/batch", json={
"model": "wjd", "max_concurrency": 2, "model": CHAT_MODEL, "max_concurrency": 2,
"items": [{"messages": [{"role": "user", "content": "说 hi"}], "label": "a"}, "items": [{"messages": [{"role": "user", "content": "说 hi"}], "label": "a"},
{"messages": [{"role": "user", "content": "说 yo"}], "label": "b"}]}) {"messages": [{"role": "user", "content": "说 yo"}], "label": "b"}]})
ok = r.status_code == 200 and r.json().get("count") == 2 and all(x["ok"] for x in r.json()["results"]) ok = r.status_code == 200 and r.json().get("count") == 2 and all(x["ok"] for x in r.json()["results"])
check("POST batch 2 项全成功", ok, f"{r.status_code}") check("POST batch 2 项全成功", ok, f"{r.status_code}")
# 13) 图像(真实,可能较慢 / 上游不支持则 WARN) # 14) 图像(真实,可能较慢 / 上游不支持则 WARN)
try: try:
r = c.post(f"{base}/v1/images/generations", json={ r = c.post(f"{base}/v1/images/generations", json={
"model": "agnes-image-2.5-flash", "prompt": "a plain red square", "size": "1K"}, timeout=120) "model": "agnes-image-2.5-flash", "prompt": "a plain red square", "size": "1K"}, timeout=120)
+520 -272
View File
File diff suppressed because it is too large. Load diff