docs: 补 MIT LICENSE 与许可声明（G-Star 申报要求明确的许可证）

G-Star 合规要求下，把"模拟官方客户端、复刻私有协议、自动领取平台额度"这一类
能力整体移出仓库。这些实现依赖各平台未公开的端点、签名算法与官方 client id，
属于绕过客户端校验获取额度，风险高于普通协议适配。

移除（93 个文件）：
- 适配器：opencodezen（伪装 UA 取免费池）、trae、buddy、kimicode
- 插件：channels.lua（12 个平台登录/领额度/签到）、quota.lua（厂商额度探针）
- 随之删除的 78 个渠道/额度专用测试与 3 份渠道文档

同时修掉的既有问题：
- **硬编码第三方 OAuth client_secret**（Google Cloud Code 的 GOCSPX-…，两处）
  随 channels.lua 一起消失。
- `deploy.sh` 的 `sync_plugins` 整段删除：它仍按"内置插件是发行物"的旧前提
  把插件复制/覆盖进 plugin_dir，与"插件属运维资产、网关不安装不覆盖"的契约
  冲突。现在部署脚本只同步适配器与二进制/配置。
- 适配器清单去掉已移除项；e2e 配置改用显式 `auto:` 链（`models.priority` 早已
  移除，该测试此前已失效）。

保留（公开协议）：openai / anthropic / gemini / deepseek / github / groq /
mistral / ollama / qwen38 / sensenova = 10 个适配器；插件示例 billing / usage。

验证：go build -tags luajit ./... OK；internal/lua 21.4s、provider、core 51s、
gateway 122.8s、e2e 9.0s 全绿。

HANDOFF_2026-10-19.md

@@ -0,0 +1,501 @@
+# ModelRouter / llmsproxy 交接文档
+
+> **历史文档**：本文记录的渠道能力（channels / quota 插件与 4 个私有协议适配器）
+> 已于 v3.0.2 按合规要求整体移出仓库。保留原文仅作历史记录，其中的路径、
+> 模块名与适配器清单不再代表当前代码。
+
+更新时间：2026-10-19
+工作目录：`/home/program/llmsproxy`
+当前分支：`release/v2.0.x`
+
+## 1. 当前 Git 状态
+
+最近提交：
+
+- `c9f3453 fix(codearts): 识别 InferHub 未注册模型`
+- `12bfd53 fix: 收口渠道源迁移与测试页合并`
+- `25970a2 refactor(scheduler)!: 移除 priority 废弃字段 + 一通道一源 + discover 复用凭据`
+
+`c9f3453` 已推送到 `origin/release/v2.0.x`。
+
+注意：当前工作树在最后一轮添加 provider 回归测试时出现了一个**未完成且可能无法编译的测试编辑**。最后一次工具报错：
+
+```text
+internal/provider/provider_test.go:99: missing ',' in argument list
+```
+
+下一位 agent 接手后的第一步必须是：
+
+```bash
+cd /home/program/llmsproxy
+git status --short
+gofmt -w internal/provider/provider_test.go 2>&1 || true
+go test -tags luajit ./internal/provider/ 2>&1
+```
+
+如果测试文件处于半编辑状态，先检查 `TestProviderChatStreamNormalizesStopAfterToolCall`，修正 Go 字符串转义或删除该未完成测试后再继续。不要直接部署当前工作树。
+
+## 2. 生产服务状态
+
+生产服务：`llmsproxy.service`
+
+- 当前服务 active
+- 监听：`0.0.0.0:8081`
+- 二进制已通过 `./deploy.sh` 原子替换并重启
+- 最近一次部署健康检查通过
+- 当前生产插件 SHA256 前缀曾核对为：`1bf26cbb3abcb107`
+- 当前生产二进制在最近部署后已更新
+
+不要把密钥写入交接记录。生产 admin key 保存在本机运维环境中，不应复制到聊天、文档或提交。
+
+## 3. Channel 源当前状态
+
+生产源已经从旧的“一账号一源”收口成“一渠道一源”：
+
+```text
+channels-trae
+channels-minimax
+channels-lobsterai
+channels-buddy
+channels-codearts
+channels-zcode
+```
+
+旧形态源已经清理：
+
+```text
+channels-<provider>-<account_id>
+```
+
+此前旧源和新源并存，造成同一渠道同一模型出现多份，只能靠账号 hex 区分。
+
+根因已修复：内核 `list_sources` 返回裸数组，但旧插件代码按 `{sources = [...]}` 信封读取，导致迁移清理循环永远为空。当前 `channels.lua` 已兼容：
+
+- 裸数组
+- `{sources = [...]}`
+- `{json = {sources = [...]}}`
+
+相关代码：
+
+```text
+internal/lua/plugins/channels.lua: syncProviderSource
+internal/core/channels_legacy_source_cleanup_test.go
+```
+
+当前生产源列表已实测只有 6 个新形态源。
+
+## 4. CodeArts 当前状态
+
+### 已确认可用的部分
+
+CodeArts 使用：
+
+```text
+adapter = codearts
+base_url = https://snap-access.cn-north-4.myhuaweicloud.com
+```
+
+CodeArts 的 chat 请求需要完整 AK/SK/security token 凭据，由插件适配器签名，不是裸 Bearer token。
+
+真实流式工具调用测试已经成功：
+
+请求形状：
+
+```json
+{
+  "model": "channels-codearts:openpangu-2.0-flash",
+  "messages": [{"role": "user", "content": "Use the weather tool for Beijing."}],
+  "tools": [{
+    "type": "function",
+    "function": {
+      "name": "get_weather",
+      "description": "Get weather",
+      "parameters": {
+        "type": "object",
+        "properties": {"city": {"type": "string"}},
+        "required": ["city"]
+      }
+    }
+  }],
+  "tool_choice": "auto",
+  "stream": true,
+  "max_tokens": 64
+}
+```
+
+结果：
+
+- HTTP 200
+- `Content-Type: text/event-stream`
+- 返回结构化 `tool_calls`
+- 函数名 `get_weather`
+- 参数最终为 `{"city":"Beijing"}`
+- `finish_reason = tool_calls`
+
+因此 CodeArts 的流式工具调用链路当前是通的。
+
+### CodeArts 模型刷新
+
+生产调用：
+
+```http
+POST /api/plugins/http/channels/model/refresh
+{"platform":"codearts"}
+```
+
+实测返回：
+
+```json
+{
+  "ok": true,
+  "results": [
+    {"platform": "codearts", "ok": true, "count": 11}
+  ]
+}
+```
+
+CodeArts 模型目录来自两个签名端点并合并：
+
+1. `opengw.developer.huaweicloud.com/api/v1/gateway/config`
+   - `result.models`
+2. `snap-access.cn-north-4.myhuaweicloud.com/v1/model/builtin`
+   - `builtinModels`
+
+相关解析：
+
+```text
+internal/lua/plugins/channels.lua: parseRemoteModels
+internal/lua/plugins/channels.lua: refreshRemoteModels
+internal/core/channels_codearts_catalog_test.go
+```
+
+### 已确认失效并禁用的 CodeArts 模型
+
+下面 4 个模型曾收到明确的上游 404：
+
+```text
+CodeArts-Pangu
+deepseek-v4-flash-0731
+deepseek-v4-pro-0813
+glm-5.3-flash
+```
+
+生产上已通过 `channels/model/set_disabled` 禁用。它们仍可能在 `model/list` 中出现，但 `disabled=true`，不会作为可用模型路由。
+
+新增的死模型判据：
+
+```lua
+model is not registered
+```
+
+对应提交：`c9f3453`。
+
+注意：当前插件的 dead-model 机制只在收到真实请求失败后记录模型；刷新目录不会自动根据“远端目录没有该模型”删除模型，这是刻意设计，避免误删远端目录不完整的平台模型。
+
+CodeArts 当前仍有一些模型返回 429/TPM 限流，例如：
+
+```text
+deepseek-v4-flash
+deepseek-v4.1-flash
+```
+
+429 不是模型失效，不能禁用。
+
+## 5. 其他 Channel 实测结果
+
+### Trae
+
+真实流式 + tools 请求：
+
+```text
+channels-trae:DeepSeek-V4-Flash
+```
+
+结果：
+
+- HTTP 200
+- SSE 正常返回
+- 结构化 tool call 返回
+- 但上游最后的结束原因可能是 `stop`，即使前面已经出现 tool-call fragments
+
+这会让 Agent 把工具调用误判成普通文本完成。
+
+当前准备中的修复在统一 provider 流式层：
+
+```text
+internal/provider/provider.go
+```
+
+逻辑是：只要本次流出现真实 tool-call 片段，后续 `FinishReason == "stop"` 就归一成 `tool_calls`。
+
+另外，Trae 的非流式接口偶尔返回 SSE。当前 `trae.lua` 对非流式 SSE 只取最后一条 data，不能完整合并多条工具调用/推理片段。这是后续仍需处理的协议问题，但不能用非流式手工请求结果推断 Pi 的真实请求模式。
+
+### Buddy
+
+真实流式 + tools 请求：
+
+```text
+channels-buddy:glm-5.3-flash
+```
+
+结果：
+
+- HTTP 200
+- SSE 正常返回
+- tool-call 参数分片可见
+- 最终有 `finish_reason = tool_calls`
+- 但某些上游 chunk 的 `tool_calls` 可能是空对象 `{}`
+
+空对象不是合法的 OpenAI tool-call 数组，部分 Agent 客户端会拒绝。
+
+当前准备中的修复在：
+
+```text
+internal/lua/adapters/buddy.lua
+```
+
+只在 `type(delta.tool_calls) == "table" and #delta.tool_calls > 0` 时输出 `tool_calls`，避免 Lua 空表被编码为 `{}`。
+
+Buddy 的非流式错误：
+
+```text
+11101: Non-stream chat request is currently not supported
+```
+
+之前出现的该错误来自手工 `curl` 测试中显式设置 `stream:false`，不能归因到 Pi。真实 `stream:true + tools` 已经证明 Buddy 流式工具调用可以工作。
+
+### MiniMax
+
+生产日志反复出现：
+
+```text
+adapter "anthropic": status=401 body={"error":"invalid access token"}
+provider channels-minimax: api error 401
+```
+
+这是凭据失效问题，不是 tools 形状问题。
+
+当前源：
+
+```text
+channels-minimax
+adapter = anthropic
+endpoint = /mavis/api/v1/llm/v1/messages
+```
+
+需要用户重新登录/提供有效凭据。不要擅自刷新一次性 refresh token，之前已经发生过 refresh token 被消耗后无法再次使用的事故。
+
+## 6. 当前未提交的代码改动
+
+最后一轮已经改动但尚未完成提交：
+
+```text
+internal/provider/provider.go
+internal/lua/adapters/trae.lua
+internal/lua/adapters/buddy.lua
+internal/provider/provider_test.go  # 可能有半编辑、需先修复
+```
+
+已完成的意图：
+
+1. provider 流式层记录 `sawToolCalls`
+2. 看到真实 tool-call 后，把后续 `stop` 归一为 `tool_calls`
+3. Trae 不输出空工具调用表
+4. Buddy 不输出空工具调用表
+5. provider 回归测试模拟“tool fragment + stop”场景
+
+但 provider 测试最后一次编辑工具报错：
+
+```text
+internal/provider/provider_test.go:99: missing ',' in argument list
+```
+
+因此必须先修测试文件，再提交。
+
+## 7. 推荐接手顺序
+
+### 第一步：修复工作树
+
+```bash
+cd /home/program/llmsproxy
+git status --short
+sed -n '1,150p' internal/provider/provider_test.go
+gofmt -w internal/provider/provider_test.go 2>&1 || true
+go test -tags luajit ./internal/provider/ 2>&1
+```
+
+若测试函数字符串转义难以修复，先删除半成品测试，再重新用 raw string 写测试。
+
+### 第二步：跑定向验证
+
+```bash
+luac -p internal/lua/adapters/trae.lua
+luac -p internal/lua/adapters/buddy.lua
+go test -tags luajit ./internal/provider/
+go test -tags luajit ./internal/lua/ -run 'Adapter|Buddy|Trae|Stream'
+```
+
+### 第三步：构建并部署临时验证版
+
+修复确认后：
+
+```bash
+go build ./...
+./deploy.sh
+```
+
+部署前确认：
+
+```bash
+sha256sum internal/lua/plugins/channels.lua
+sha256sum /etc/llmsproxy/plugins/channels.lua
+systemctl is-active llmsproxy
+```
+
+### 第四步：真实流式回归
+
+不要用 `stream:false` 测试流式问题。使用：
+
+```bash
+KEY='<从本机安全环境读取，不写入文档>'
+TOOL='{"type":"function","function":{"name":"get_weather","description":"Get weather","parameters":{"type":"object","properties":{"city":{"type":"string"}},"required":["city"]}}}'
+
+curl --no-buffer --max-time 90 \
+  -H "Authorization: Bearer $KEY" \
+  -H 'Content-Type: application/json' \
+  -d "{\"model\":\"channels-codearts:openpangu-2.0-flash\",\"messages\":[{\"role\":\"user\",\"content\":\"Use the weather tool for Beijing.\"}],\"tools\":[$TOOL],\"tool_choice\":\"auto\",\"stream\":true,\"max_tokens\":64}" \
+  http://127.0.0.1:8081/v1/chat/completions
+```
+
+分别将 model 替换为：
+
+```text
+channels-codearts:openpangu-2.0-flash
+channels-trae:DeepSeek-V4-Flash
+channels-buddy:glm-5.3-flash
+```
+
+验收：
+
+- HTTP 200
+- `Content-Type: text/event-stream`
+- 不能出现 `tool_calls: {}`
+- 有 tool-call fragments 时最终必须是 `finish_reason: tool_calls`
+- CodeArts 当前应继续返回结构化工具调用
+
+### 第五步：CodeArts 刷新验收
+
+```bash
+curl -sS -X POST \
+  -H "Authorization: Bearer $KEY" \
+  -H 'Content-Type: application/json' \
+  -d '{"platform":"codearts"}' \
+  http://127.0.0.1:8081/api/plugins/http/channels/model/refresh
+```
+
+预期：
+
+```json
+{"ok":true,"results":[{"platform":"codearts","ok":true,"count":11}]}
+```
+
+再检查：
+
+```bash
+curl -sS -X POST \
+  -H "Authorization: Bearer $KEY" \
+  -H 'Content-Type: application/json' \
+  -d '{"platform":"codearts"}' \
+  http://127.0.0.1:8081/api/plugins/http/channels/model/list
+```
+
+预期：远端目录 11 个 + 兜底补位，已确认 404 的 4 个仍保持 `disabled=true`。
+
+## 8. 发布/安装包状态
+
+目前没有完成“全部安装包”发布闭环。
+
+已经发生的事情：
+
+- 核心包构建成功，但脚本实际使用了 `git describe`，产物版本类似：
+  `2.0.40~4-gc9f3453`
+- Linux GUI 包构建成功，版本为 `1.9.7`
+- Windows 主机 Wine 构建失败，生成了一个 264KB 的坏 `ModelRouter Setup 1.9.7.exe`，绝对不能发布
+- Docker Windows 构建也失败在拉取 Docker Hub 基础镜像 `golang:1.25` 网络超时
+- apt 无法找到 `wine32:i386`
+- 旧的 1.9.5/1.9.6 Windows 包是历史产物，不能作为当前版本
+
+不要把旧 Windows exe 当作新包发布。
+
+仓库已有 Docker 方案：
+
+```text
+cmd/gui/scripts/dist-win-docker.sh
+cmd/gui/docker/win-builder/Dockerfile
+```
+
+但当前 Docker Hub 网络不可用。若要继续做 Windows 包：
+
+1. 在可访问 Docker Hub 的构建机/CI 执行 Docker 方案；或
+2. 提供包含 Wine32/Wine64 的完整构建环境；或
+3. 暂时只发布 Linux/core 包，并明确说明 Windows 包未完成。
+
+版本脚本注意：
+
+- 核心包脚本使用位置参数：
+
+  ```bash
+  ./packaging/core-dist.sh 2.0.41
+  ```
+
+  不是 `VERSION=2.0.41 ./packaging/core-dist.sh`。
+- GUI 版本来自 `cmd/gui/package.json`，环境变量 `VERSION` 不会自动修改 Electron 产品版本。
+- 清理旧产物后再打包，并在全部包完成后统一计算 `SHA256SUMS`。
+
+## 9. 参考插件状态
+
+用户要求按：
+
+```text
+https://github.com/Ebony-Vinyl/dsh-our-free-model
+```
+
+逐厂商对照参考插件。
+
+当前本地路径：
+
+```text
+/tmp/pi-github-repos/Ebony-Vinyl/dsh-our-free-model
+```
+
+但该目录当前不是有效可读源码副本：
+
+- `vendor/channel-pack/src` 下面只有空目录；
+- `.git` 没有有效 `HEAD`/refs；
+- 无法从本地 Git 对象恢复源码；
+- 本地也没有 `buddy.ts`、`trae.ts`、`codearts.ts` 等文件。
+
+因此不能声称当前适配器是逐行照参考插件移植的。若要继续按用户要求完成，必须先重新 clone/恢复该 GitHub 仓库源码，确认以下文件实际存在后再对照：
+
+```text
+vendor/channel-pack/src/trae.ts
+vendor/channel-pack/src/buddy.ts
+vendor/channel-pack/src/codearts.ts
+vendor/channel-pack/src/*adapter*
+vendor/channel-pack/src/*model*
+```
+
+当前仓库代码只能作为临时协议修复基础，不能代替参考插件源码。
+
+## 10. 关键结论
+
+- Pi 是否发送流式请求，历史日志没有保存入站 `stream/tools` 字段，不能靠旧日志判断。
+- 本次真实 `stream:true + tools` 测试证明 ModelRouter 流式路径能工作：
+  - CodeArts：通过；
+  - Trae：通过但结束原因需归一；
+  - Buddy：通过但需过滤空 `{}`；
+  - MiniMax：凭据 401，独立问题。
+- 不要再用 `stream:false` 的手工请求推断 Pi 的问题。
+- CodeArts 刷新接口当前真实返回 `ok=true,count=11`，刷新链路不是当前阻塞点。
+- 当前最紧急的代码状态是修复 `provider_test.go` 的半编辑，然后验证未提交的统一流式修复。
+- 未经测试、未重新构建、未重新部署，不要继续改生产账号或刷新一次性凭据。

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 HeNanMU-EEA
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Makefile

@@ -1,8 +1,8 @@
-.PHONY: all build test gui gui-dev gui-dist gui-deb gui-win gui-win-docker help clean
+.PHONY: all build test gui gui-dev gui-dist gui-deb gui-win gui-win-docker help clean gui-test
 
 # ModelRouter - single-binary gateway + optional Electron desktop GUI (embedded core)
 export BINARY
-BINARY=llmsproxy
+BINARY=modelrouter
 export BUILD_DIR
 BUILD_DIR=build
 export GUI_DIR
@@ -20,7 +20,7 @@ all: build
 # ---- core binary (server users / embedded core) ----
 build:
 	@mkdir -p $(BUILD_DIR)
-	CGO_ENABLED=1 go build -tags luajit -trimpath -o $(BUILD_DIR)/$(BINARY) ./cmd/llmsproxy
+	CGO_ENABLED=1 go build -tags luajit -trimpath -o $(BUILD_DIR)/$(BINARY) ./cmd/modelrouter
 	@echo "Built: $(BUILD_DIR)/$(BINARY) ($(VERSION))"
 
 # ---- core distribution packages (deb + rpm + tar.gz) -----
@@ -65,6 +65,13 @@ gui-dist-dir:
 test:
 	go test ./...
 
+# Desktop shell unit tests (no Electron needed): plugin-tree seeding/migration.
+# These guard the two things that silently break the desktop build:
+#   - plugin_dir missing from an embedded profile  -> channels plugin invisible
+#   - bundled plugin files never refreshed         -> old channels.lua survives upgrades
+gui-test:
+	@cd $(GUI_DIR) && node --test plugin-sync.test.js
+
 clean:
 	rm -rf $(BUILD_DIR) cmd/build cmd/gui/dist cmd/gui/build/gui-dist cmd/gui/bin
 
@@ -75,6 +82,7 @@ help:
 	@echo "  make gui        run desktop GUI (dev)"
 	@echo "  make gui-dev    run GUI with devtools"
 	@echo "  make gui-dist   build deb + rpm + AppImage (linux)"
+	@echo "  make gui-test   desktop shell unit tests (plugin tree seeding)"
 	@echo "  make gui-deb    build deb only"
 	@echo "  make gui-win    build Windows nsis (needs host mingw + wine)"
 	@echo "  make gui-win-docker  build Windows nsis all-in-docker (no host mingw needed)"

README.md

@@ -1,106 +1,51 @@
 # ModelRouter
 
+> **仓库**: <https://atomgit.com/HeNanMU-EEA/ModelRouter>
+>
 > **English**: [README_EN.md](./README_EN.md)
 >
 > **AI-assisted**: 本项目使用 AI 辅助编程（代码与文档由 AI 协作完成，经人工复核）。
 
-面向多 llms 订阅者，部署在内网，实现一次配置多个服务共同使用的效果。支持指定模型或 auto 模式，按照配置的优先级选择可用模型提供服务。
+面向多 LLM 订阅者的内网网关：一次配置，多个服务共用一组上游额度。支持指定模型或
+`AUTO` 模式，按配置的优先级选择可用模型提供服务。
 
-> **轻量且增源无需重编译**：网关本体是单 Go 二进制（约 10MB，零运行时依赖）。新增/切换上游
-> 只需在 `config.yaml`（或 WebUI）加一个 `sources` 条目或挂一个 `.lua` 适配器——**不改 Go、
-> 不重编译**。源与适配器的改动经 WebUI 提交时即时生效（热更新）；直接编辑
-> `config.yaml` 或 `adapter_dir` 下的 `.lua` 文件则需要重启进程生效。
+网关本体是单个 Go 二进制（约 10 MB，零运行时依赖）。新增或切换上游只需在
+`config.yaml`（或 WebUI）加一个 `sources` 条目、或挂一个 `.lua` 适配器——**不改 Go、
+不重编译**。源与适配器的改动经 WebUI 提交时即时生效（热更新）；直接编辑
+`config.yaml` 或 `adapter_dir` 下的 `.lua` 文件需要重启进程生效。
 
-## 核心优势
+## 核心能力
 
-### 极致轻量
-
-- **单二进制**：编译后 8~12MB（`-s -w` strip 后约 8MB），零运行时依赖（仅依赖系统 libc），部署即用
-- **低内存占用**：与源数量相关，非与运行时长相关——单源 ~10MB、16 源生产实例 ~32–35MB（[实测分解与调优](#内存占用实测与调优)）
-- **日志按需加载**：统计数字来自**全量**审计日志（启动时流式扫一遍即释放，29MB/22 万行约 260ms），但原始记录不常驻内存——默认只加载首屏，下滚自动分页，CSV 导出流式写出（O(1) 内存），离页即释放
-- **零运行时依赖**：纯 Go + LuaJIT 静态链接，无需安装 Python/Node/Java 等运行时
-- **启动极快**：冷启动 < 200ms，热重载配置 < 10ms
-
-### 强大的多租户调度能力
-
-- **多密钥多租户**：支持无限密钥，每个密钥独立角色、模型范围、Token 配额、重置周期
-- **按模型配额**：每把 key 的每个模型单独配 token + 请求数配额与重置周期（小时/周/月/自定义 N 小时）；一个模型用满只影响该模型，同 key 其它模型照常；耗尽返 429 + `Retry-After` 并点名模型，admin key 永不受限
-- **AUTO 智能调度**：基于优先级档位的分级调度，同优先级源自动轮询负载均衡，故障自动毫秒级故障转移
-- **自愈冷却**：冷却上限 5 分钟，过半后放行 1 个探测请求，上游/额度恢复即刻回归轮询，无需等满冷却窗口
-- **Token 配额管理**：精确到模型级别的 Token 配额控制，支持小时/周/月/自定义小时周期自动重置
-- **同优先级源负载均衡**：同一优先级档位的多个源，请求自动 Round-Robin 均匀分发，故障毫秒级故障转移
-- **Source-Model 前缀路由**：支持 `source-model`/`source:model`/`source/model` 精确指定上游源
-
-### 生产级可靠性
-
-- **热加载配置**：WebUI 修改源/密钥/适配器/AUTO链即时生效，无需重启
-- **密钥加密落盘**：AES-256-GCM 加密存储 `api_key`、网关密钥、请求头，master.key 0600 权限保护
-- **实时源探测**：`GET {base}/models` 定期探测，毫秒级感知上游状态，不污染调度退避状态
-- **全链路审计**：HTTP 访问日志、登录/配置变更审计、请求记录 CSV 导出、密钥用量统计 CSV 导出
-
-### 灵活的协议适配
-
-- **LuaJIT VM**：每个适配器独立 VM + **弹性 worker 池**（按需扩缩容，空闲时自动回收），安全并发，Lua 脚本热加载无需重启
-- **Lua 适配器协议**：`transform_request` / `transform_response` / `transform_stream_chunk` 双向转换
-- **动态请求头钩子**：`build_headers(meta)` 支持 HMAC 签名、动态 Header 注入
-- **多模态透传**：`image_url` 等多模态内容在多源间无损透传，Anthropic/Gemini/Ollama 自动转换
-
-## 实现
-
-统一 OpenAI 兼容网关：把多个上游 LLM 源（DeepSeek、Qijiar、OpenAI、Anthropic、Gemini、
-Groq、Mistral、Ollama、KimiCode…）通过 **Lua 适配器** 做协议转换，对内网暴露
-一个标准 `OpenAI Chat Completions` 接口（`/v1/chat/completions` + `/v1/models`），
-支持单次结算、SSE 流式、**AUTO 模型路由**与**多模态**透传。
-
-从 [HomeAgent](https://gitcode.com/JianFeeeee/HomeAgent) 的多源 LLM 适配层
-（`internal/agent/api/provider.go` + `internal/lua/adapters/*`）抽离而来并独立演进。
-
-## 特性
-
-- **多源**：一个进程内配置任意多个上游源，按请求的 `model` 自动路由。
-- **AUTO 模式**：`default_model: AUTO` 时按优先级页保存的 AUTO 链档位逐档调度并发请求。
-- **统一输出**：所有源对外都是 OpenAI 格式（含 `reasoning_content`、`tool_calls`、`usage`）。
-- **生图**：`POST /v1/images/generations`，`kind: image` 的模型独立路由。
-- **多模态**：`content` 数组（`image_url` 等）在多源间无损透传，Anthropic/Gemini/Ollama 自动转换。
-- **LuaJIT VM**：基于 golua 绑定的 LuaJIT，每个适配器独立 VM + worker 池，安全并发。
-  池是 **弹性** 的：`Σ max_concurrent` 只是上限而非预分配，状态按需创建、空闲时自动回收，
-  因此空载网关几乎不持有 Lua 状态（启动 0 个）。
-  - 扩容步长由适配器最大并发决定：`clamp(ceil(max/8), 1, 8)`，且仅在**真实并发争用**
-    （所有现有状态均已占用）时批量预热，顺序流量始终只用 1 个状态。
-  - 缩容步长由当前连接数决定：`clamp(ceil(冗余/(1+占用)), 1, 冗余)`——无连接时一轮收到
-    常驻下限，忙时每轮只释放 1 个，保护热路径。WebUI「适配器」页展示实时池指标。
-- **thinking 预算**：请求里的推理开关/预算归一为中立的 `thinking:{enabled,budget_tokens}`，
-  适配器映射到各自协议（Anthropic `thinking.budget_tokens`、Gemini `thinkingConfig`、
-  DeepSeek `thinking.type="disabled"`）。
-- **Lua 适配协议**：每个源挂一个 `.lua` 适配器，完成 `transform_request` /
-  `transform_response` / `transform_stream_chunk` 双向转换，协议差异全在 Lua 层。
-- **签名 / 请求头钩子**：适配器可定义 `build_headers(meta)`，在 Go 发 HTTP 前
-  动态注入/签名请求头——用于云端 API 校验调用方 app（如 KimiCode 只放行特定
-  agent）。提供 `hmac_sha256_hex` / `sha256_hex` / `base64_encode` 等签名辅助。
-- **WebUI**：内置管理界面，可在线查看/新增/编辑上游源与模型、配置 AUTO 优先级链、
-  管理密钥模型范围，写入运行时文件持久化。
-- **密钥加密存储**：运行时文件中的上游 `api_key`、自定义请求头值、网关 key 均以
-  AES-256-GCM 加密落盘（`master.key` 独立 0600，或 `LLMS_PROXY_MASTER_KEY`）。
-- **实时源探测**：状态页探测各源可达性（`GET {base}/models`，失败回退最小请求），
-  不污染正常调度的退避状态，错误信息在 UI 可悬停查看。
-- **鉴权**：网关自身用 `gateway_keys` 校验客户端 Bearer key；与上游各自的 key 相互独立。
-- **流式**：SSE `chat.completion.chunk`，含角色首包与 `[DONE]` 收尾。
-- **全链路审计**：HTTP 访问日志、登录/配置变更审计、请求记录 CSV 导出、密钥用量统计 CSV 导出
-- **AES-256-GCM 加密存储**：运行时文件敏感字段加密落盘，master.key 0600 权限，支持环境变量注入主密钥
+- **统一接口**：对内暴露 OpenAI 兼容的 `/v1/chat/completions`、`/v1/models`、
+  `/v1/images/generations`；所有源对外都是同一套格式（含 `reasoning_content`、
+  `tool_calls`、`usage`）。
+- **多源 + AUTO 链**：一个进程内任意多个上游源；`default_model: AUTO` 时按优先级页
+  保存的档位逐档调度，源故障自动降级并冷却，恢复后半冷却探测自愈。
+- **协议适配在 Lua 层**：每个源挂一个 `.lua` 适配器，完成请求/响应/流式分片的双向
+  转换，并可用 `build_headers(meta)` 注入签名头。协议差异不进 Go 内核。
+- **插件独立**：业务扩展（计费、用量统计等）是外置 Lua 插件，由插件目录加载，
+  不编进二进制、不随发行包分发；插件只通过 `modelrouter` SDK 与内核交互。
+- **多租户密钥**：网关 key 与上游 key 相互独立，按 key 限定模型范围、AUTO 链与配额。
+- **加密存储**：上游 key、自定义请求头、网关 key 均以 AES-256-GCM 落盘，
+  `master.key` 单独 0600 权限（或由 `MODELROUTER_MASTER_KEY` 注入）。
+- **可观测**：状态页实时探测源可达性；HTTP 访问日志、配置变更审计、请求与用量 CSV 导出；
+  写操作不落在请求热路径上。
 
 ## 快速开始
 
 ```bash
-GOMODCACHE=... GOPROXY=off go build -tags luajit -o llmsproxy ./cmd/llmsproxy
-./llmsproxy -config config.yaml    # 首次运行自动生成默认配置并打印随机 admin key
+# 需要 LuaJIT 开发库；-tags luajit 是必须的
+GOMODCACHE=... GOPROXY=off go build -tags luajit -o modelrouter ./cmd/modelrouter
+
+# 首次运行会生成默认配置，并在日志里打印随机 admin key
+./modelrouter -config config.yaml
 ```
 
-> 依赖 [golua](https://github.com/aarzilli/golua)（LuaJIT 绑定）。**必须**带 `-tags luajit`
-> 构建，否则默认走内置超集 gopher-lua 路径（行为略有差异）。
+> 依赖 [golua](https://github.com/aarzilli/golua)（LuaJIT 绑定）。不带 `-tags luajit`
+> 会走 gopher-lua 路径，行为略有差异。
 
-> **配置不入库**：仓库不携带任何 config 文件（配置文件含密钥）。二进制首次运行时
-> 会在 `-config` 指定的位置生成默认配置：随机 admin key（打印在启动日志中）、
-> 仅绑定 `127.0.0.1:8080`。首次登录后请在 WebUI「密钥」页更换管理员密钥。
+> **配置不入库**：仓库不携带任何 config 文件（其中含密钥）。默认配置只绑定
+> `127.0.0.1:8080`，首次登录后请在 WebUI「密钥」页更换管理员密钥。
 
 ```bash
 # 无 key -> 401
@@ -117,526 +62,77 @@ curl -N -H "Authorization: Bearer $KEY" \
      http://127.0.0.1:8080/v1/chat/completions
 ```
 
-任何 OpenAI SDK 把 `base_url` 指到网关地址、`api_key` 用任意一个已创建并授权的网关 key 即可。
+任何 OpenAI SDK 把 `base_url` 指向网关、`api_key` 换成任一已授权的网关 key 即可。
 
-## 配置
+## 文档
 
-首次运行在 `-config` 路径自动生成默认配置（默认 `./config.yaml`），核心字段：
+| 主题 | 文档 |
+|---|---|
+| 实现与完整特性清单 | [docs/features.md](docs/features.md) |
+| 配置：`config.yaml`、自动探测模型、多密钥 | [docs/configuration.md](docs/configuration.md) |
+| 路由：模型路由、AUTO 链、冷却与半冷却、源与适配器、源模板 | [docs/routing.md](docs/routing.md) |
+| 适配器：Lua 协议、内置适配器清单 | [docs/adapters.md](docs/adapters.md) · [docs/lua-adapters.md](docs/lua-adapters.md)（[EN](docs/lua-adapters-en.md)） |
+| 插件：SDK 契约、钩子、UI 扩展、HTTP 端点 | [docs/plugins.md](docs/plugins.md) |
+| 桌面端：Headless / Desktop 两种产物、构建与运行 | [docs/gui.md](docs/gui.md) |
+| 性能：实测内存占用与调优、thinking 预算 | [docs/performance.md](docs/performance.md) |
+| WebUI 使用 | [docs/webui.md](docs/webui.md) |
+| 开发：目录职责、测试、分支与发布纪律 | [docs/development.md](docs/development.md) · [docs/git-workflow.md](docs/git-workflow.md)（[EN](docs/git-workflow-en.md)） |
+| 部署与迁移 | [docs/deployment.md](docs/deployment.md) |
 
-```yaml
-listen: 127.0.0.1:8080        # 网关监听地址（建议绑内网/回环）
-gateway_keys: [sk-gw-<随机>]  # 初始 admin 密钥（每次安装随机生成，仅首启写入运行时存储用）
-default_model: AUTO           # model 无法路由时自动按优先级链选源
-adapter_dir: adapters         # Lua 适配目录；目录不存在时首启创建并 seed 内置，存在则只读
-runtime_file: runtime.json    # WebUI 编辑的源/密钥/AUTO 链持久化到此文件
+## 从 llmsproxy 改名
 
-sources:
-  - name: deepseek
-    base_url: https://api.deepseek.com
-    api_key: sk-...            # 也可用 api_key_env: SOME_ENV 引用环境变量（不落盘明文）
-    adapter: deepseek
-    max_concurrent: 8
-    models:
-      - id: deepseek-v4-flash
-        priority: 100          # YAML 源首次启动会 seed 进 AUTO 链的初值
-        kind: chat
-      - id: deepseek-v4-pro
-        priority: 60
-        kind: chat
-    # 静态请求头（比适配器默认优先）
-    headers: { X-Tenant: prod }
-    # 传给 Lua build_headers 的透传元数据
-    meta: { app_id: x, app_secret: y }
-    temperature: 0.7
-    max_tokens: 4096
-    timeout: 120s              # 请求超时，默认 120s
-```
+产品名早已是 ModelRouter，二进制、配置目录、服务名与环境变量现已统一为
+`modelrouter`：
 
+| 旧 | 新 |
+|---|---|
+| `llmsproxy`（二进制） | `modelrouter` |
+| `/etc/llmsproxy/` | `/etc/modelrouter/` |
+| `llmsproxy.service` | `modelrouter.service` |
+| `LLMSPROXY_*` | `MODELROUTER_*` |
 
-### 自动探测模型列表
-
-不想手抄模型 id 时，只填 URL 和 key，让网关去扫：
+已部署的机器用迁移脚本升级（**默认 dry-run**，复制不移动，可回滚）：
 
 ```bash
-# 只探测，不写任何东西
-curl -X POST http://127.0.0.1:8080/api/sources/discover \
-  -H "Authorization: Bearer sk-gw-…" -H "Content-Type: application/json" \
-  -d '{"base_url":"https://api.vendor.com/v1","api_key":"sk-…"}'
-# → {"ok":true,"base_url":"…","endpoint":"","models":["gpt-x",…],
-#    "image_models":["gpt-image-2"],"models_path":"/models","latency_ms":1387,…}
-
-# 探测后直接落库
-curl -X POST http://127.0.0.1:8080/api/sources/discover/apply \
-  -H "Authorization: Bearer sk-gw-…" -H "Content-Type: application/json" \
-  -d '{"base_url":"https://api.vendor.com/v1","api_key":"sk-…","name":"vendor"}'
+sudo ./packaging/migrate-to-modelrouter.sh              # 预演
+sudo ./packaging/migrate-to-modelrouter.sh --apply      # 执行
+sudo ./packaging/migrate-to-modelrouter.sh --rollback --apply
 ```
 
-WebUI 源编辑框里也有「自动探测模型」按钮：填好 URL 和 key 点一下，列表自动
-填好，仍需点保存才生效。
-
-几点值得知道：
-
-- **URL 形态不用猜。** 厂商对「`/v1` 放 base 还是放 path」没有共识，探测会
-  依次尝试若干候选并返回答对的那个，同时给出归一化后的 `base_url` +
-  `endpoint`（`endpoint` 平时留空，因为 openai adapter 自带 `/chat/completions`）。
-- **`image_endpoint` 是另一套规则。** 网关的图像默认路径是**绝对**的
-  `/v1/images/generations`，而 chat 默认是相对的。所以 `base_url` 带 `/v1` 时
-  必须显式给 `image_endpoint: /images/generations`，否则图像请求 404。
-  探测会替你填好。
-- **图像模型只看上游自己声明的 modality**，绝不从模型名猜。`gpt-image-2`
-  这类 id 也出现在同时提供对话服务的目录上，猜错会让 AUTO 链选中一个只支持
-  图像生成的模型，其后每一层都被它拖垮。
-- **不会逐模型探活。** 34 个模型的目录跑一轮要花钱且耗时数分钟，`/models`
-  是足够便宜的信号；模型是否真能应答留给正常请求去发现。
-- **对已存在的源，必须显式 `replace_models: true`** 才会覆盖模型列表。重新
-  探测顺手抹掉为 AUTO 链手工调过的 priority，是最难排查的一类数据丢失。
-- **`api_key` 留空表示沿用已存值**，不会把凭据清空。
-
-
-`config.yaml`、`runtime.json`、`master.key`、`adapters/` 均不提交版本库（见
-`.gitignore`），请随备份带走——`master.key` 丢失后运行时密文无法解密。
-
-运行文件生成在 `-config` 所在目录：`adapter_dir` / `runtime_file` 自动指向
-配置文件旁边的 `adapters/` 与 `runtime.json`，从任意工作目录启动都可用。
-
-运行时文件（`runtime_file`）中的敏感字段自动加密：
-
-- 加密算法 AES-256-GCM，格式 `enc:v1:<base64>`。
-- 主密钥来源：环境变量 `LLMS_PROXY_MASTER_KEY`（64 位 hex）；否则读取
-  `runtime_file` 同目录的 `master.key`；都不存在时首次启动自动生成 `master.key`（0600）。
-- 升级时旧明文文件自动兼容：首次运行正常读取，任何 UI 保存操作触发全文件加密迁移。
-- 注意：**master.key 丢失后密文无法解密**，请随配置一起备份；切勿提交到版本库。
-
-### 网关密钥（多密钥）
-
-网关鉴权采用「多密钥 + 角色 + 模型范围」架构，密钥持久化在 `runtime_file` 的
-`keys` 字段（加密存储）：
-
-- `gateway_keys` 配置只是**初始 admin 密钥种子**：首次启动迁移为运行时 admin
-  key，之后不再参与鉴权管理。
-- **重要：首次启动后请在 WebUI「密钥」页更换管理员密钥**——初始密钥明文写在
-  `config.yaml` 里（每次安装随机生成），继续使用存在被盗风险；用新密钥登录后删除初始密钥。
-- WebUI **密钥页**可创建/删除密钥；每个密钥可指定 `admin`（管理全部）或
-  `user`（仅看自己的 key）角色，并配置**模型范围**（模型 + 源 + token 配额 +
-  重置周期）。
-- 客户端用任意一个已授权的密钥明文作为 Bearer（`Authorization: Bearer <key>`）。
-- 删除密钥即从运行时存储移除，立即失效。
-
-#### 密钥用量配额
-
-**配额按模型单独设置**：每个密钥的 `models[]` 里，每一条模型范围各自带一份
-token 配额与请求数配额。一个模型用满只影响该模型，同一密钥的其它模型照常工作。
-
-```yaml
-keys:
-  - key: sk-gw-<hex>
-    role: user
-    name: agent-alice
-    models:
-      - model: deepseek-v4-flash
-        token_quota: 1000000   # 本周期内该 key 用这个模型的 token 预算
-        req_quota: 20000       # 本周期内的请求次数
-        period: nhour          # "" | hour | week | month | nhour
-        hours: 6               # 仅 nhour
-      - model: AUTO
-        token_quota: 5000000   # AUTO 也是一条独立配额
-        period: day            # ← 这种写法会被拒绝（词表只有 hour/week/month/nhour）
-      - model: kimi-k3        # 未列配额 = 无限
-```
-
-- **没有「整钥总配额」**：这是刻意的设计。整钥总额会让「把 A 模型的额度挪给
-  B 模型」变成一次全局重分配；按模型独立计费则每个模型各自可控，运维可以
-  看出哪个模型吃掉了预算。
-- `period` 词表：空 = 永不过期（累计总量），`hour` / `week` / `month` = 固定窗口，
-  `nhour` + `hours` = 自定义小时数。**拼错的周期在写入时就被拒**，不会静默变成
-  永不过期。
-- 配额严格按密钥隔离，且**同一密钥内按模型隔离**：A 密钥用满 `m1` 不会消耗
-  B 密钥的额度，同一密钥的 `m2` 也不受影响。
-- 配额统计含聊天、流式、生图，跨重启从审计日志回放（保留 40 天，覆盖最长的
-  month 窗口）。
-- 配额耗尽返回 **429 + `Retry-After`**（`rate_limit_exceeded`），消息里点名是哪个
-  模型用满了，客户端可等窗口重置后自动恢复；模型越权才是 403。
-  **admin 密钥永不受配额限制**（其 scope 上的配额也不强制），避免把管理员
-  锁在门外。
-- 窗口用量按整点小时分桶统计，实际释放比配置窗口最多晚 1 小时（配额宁可晚释放
-  也不超发）。
-- `PUT /api/keys/{key}` 提交 `models` 即同时提交它们的配额（配额就是 scope 的一部分，
-  不存在会与模型列表脱节的第二份预算）。显式 `0` = 解除该模型的限制。
-
-##### 配额拒绝 vs 容量拒绝：两种「拒绝」含义不同
-
-配额在**入口**检查，不占用任何上游槽位，因此是廉价拒绝；容量不足则要走
-`busyWait` 有界等待后才返回 503。实测（容量 8、0.6s/请求、100 并发）：
-
-| 情况 | 状态码 | 延迟 | 是否打到上游 |
-|---|---|---|---|
-| 配额用尽（`req_quota` 50 → 100 并发） | `429 rate_limit_exceeded` + `Retry-After` | **19–21ms** | 否 |
-| 容量打满（同一拓扑，未限配额） | `503 upstream_error` | ~2.6s（`busyWait`） | 超出部分否 |
-
-客户端因此可以区分「等窗口重置」与「等上游腾出容量」：前者只需等待，后者
-通常该降并发或换源。
-
-##### 配额的开销
-
-配额桶按 (密钥, 模型, 整点小时) 分桶保留 40 天，实测（AMD 7840HS）：
-
-- 窗口查询按窗口长度而非保留总量扫描：1h 窗口 49ns、24h 窗口 55ns、
-  30d 窗口 3.9μs（此前全扫保留总量，960 桶时 5.9μs）。
-- 记录一条请求：283ns、3 分配（与引入配额前相同，分配来自 ring buffer）。
-- 内存：生产形态（7 密钥 × 8 模型 × 2 源 × 满 40 天 retention）约 **3.7MB**。
-  按源 pin 的 `source::model` 桶**惰性创建**——只有当某条配额真的 pin 了
-  某个源时才维护，否则每条记录多写一份桶，在 20 密钥 × 8 模型 × 3 源下会
-  多占 18MB。
-  代价：配置 pinned 配额之前的历史用量无法事后按源拆分，所以 **pinned 配额的
-  首个窗口可能少算**。
-
-```bash
-# 配额耗尽时客户端看到（点名了具体模型）
-HTTP/1.1 429 Too Many Requests
-Retry-After: 2100
-{"error":{"type":"rate_limit_exceeded","message":"token quota exceeded for \"deepseek-v4-flash\" (5000000/5000000)"}}
-```
-
-### 模型路由
-
-`/v1/chat/completions` 的 `model` 解析顺序：
-
-1. `source/model` 或 `source:model` 前缀 → 指定源；
-2. 精确匹配某个源的 `model`；
-3. 配置 `default_model: AUTO` 时 → 走优先级页保存的 AUTO 链（见下）；
-4. 否则回落（返回错误）。
-
-任何 OpenAI 客户端，只要 `model` 设为某个源的 `name/任意名`，即可锁定走该源；
-设为 `AUTO`（或网关配了 `default_model: AUTO`）即自动按优先级链选源。
-
-### AUTO 链（优先级页）
-
-AUTO 调度**只**由优先级页保存的规则决定，源配置里的 `models[].priority` 数字不再
-参与调度、也不再显示。**聊天与生图是两套独立的链**，在优先级页面通过「聊天 / 生图」
-按钮切换编辑：
-
-- **聊天链**（`runtime_file` 的 `auto` 字段）：服务 `POST /v1/chat/completions`
-  的 `model: AUTO` 请求；只接受 `kind: chat` 模型，配置在链里的生图槽位会被忽略。
-- **生图链**（`runtime_file` 的 `auto_image` 字段）：服务 `POST /v1/images/generations`
-  的 `model: AUTO` 请求；只接受 `kind: image` 模型。未配置生图链时，AUTO 生图回落
-  到「所有含生图模型的源、按注册顺序」的旧行为，兼容旧配置。
-
-每条规则 = 一个「槽位」：`{ model, source, tier, token_quota, period, hours }`。
-
-- `tier` 表示优先级档位：同一档的模型并排、共享该优先级；档位从上到下递减。
-- 同一模型可配置多个槽位（如 A 源低配 → B 源低配 → A 源高配 → B 源高配），按档位顺延。
-- `token_quota` > 0 时该槽位在重置周期内用满即顺延到下一槽位；`period` 支持
-  `hour` / `week` / `month` / `nhour`（配合 `hours`），空 = 不限。
-- 同 tier 内按「偏好分」排序，失败槽位冷却后自动跳过；冷却 / 配额耗尽 / hard
-  错误会顺延到下一 tier，全部失败时返回 503 并附上每档失败摘要。
-
-### 冷却与半冷却探测（自愈调度）
-
-槽位失败后进入指数退避冷却（5s → 10s → 20s …，上限 **5 分钟**）。冷却不是全时段
-硬闸：
-
-- **前半段完全静默**：刚失败的槽位不接任何流量，避免对故障上游持续施压。
-- **后半段放行 1 个探测**：窗口过半后，同一 `(源, 模型)` 最多允许 **一个** 请求作为
-  探测通过。探测槽数 = `clamp(max_concurrent / 10, 1, 2)`——`max_concurrent: 10`
-  的源恰好放行 1 个探测请求。
-- **探测排在最后**：同 tier 内探测候选永远排在健康候选之后，只有没有正常槽可用时
-  才承接真实流量，因此探测不会抢走可用容量。
-- **探测即真实请求**：成功则立即清零失败计数与冷却，槽位当场回到正常轮询——
-  上游恢复/额度恢复后不必等满整个冷却窗口。失败则重开一个新窗口，下次探测顺延到
-  新窗口的中点，不会连续重试。
-
-分类冷却策略：
-
-| 情况 | 冷却 | 说明 |
-|---|---|---|
-| 传输错误 / 5xx | 5s→10s→20s…，上限 5min | 指数退避 |
-| 401 / 403 凭据错误 | 10min | 换 key 后由下一次探测自动接回 |
-| 429 限流 | 30s 固定 | 「太快」不等于「坏了」，不进指数阶梯 |
-| 配额耗尽（`insufficient_quota` / `余额不足` 等） | 对齐配额窗口，上限 30min | **不进指数阶梯、不涨失败计数**，额度恢复即可用 |
-
-WebUI「优先级」页的槽位健康标签会区分 `冷却` / `待探测` / `探测中`，悬停可看窗口
-起点、探测放行时刻与完全恢复时刻。
-
-### 源（Source）与适配器（Adapter）的关系
-
-- **源** 是到某个上游的连接描述：`name`、`base_url`、`api_key`、模型列表与优先级。
-- **适配器** 是协议转换逻辑（Lua 脚本）：把统一 OpenAI 格式请求转成上游原生格式，
-  再把上游响应/流式分块转回统一格式。
-- 一个适配器可被多个源复用（如 `openai.lua` 同时服务多个 OpenAI 兼容站点）；
-  同一个源也可以切换不同适配器（改 `adapter` 字段即可）。
-- 源决定“连谁、暴露哪些模型”，适配器决定“怎么对话”——二者在 `sources[]` 条目中
-  通过 `adapter` 字段关联。
-
-加载流程（`internal/core` 的 `Core` 负责装配）：
-
-1. 启动时 `lua.NewVM(adapter_dir)` 加载全部适配器：内置适配器（编译期 embed）+
-   `adapter_dir` 下的同名覆盖文件；内置文件写在代码内，覆盖文件要求更高优先级。
-2. `config.Load` 读取 `config.yaml`，`config.NewStore(runtime_file)` 读 WebUI 改动的
-   运行时源，二者按名称合并成完整源列表。
-3. `rebuildRegistry` 为每个源创建 `provider.Provider`（持有目标适配器），并按源的
-   并发上限配置适配器 worker 池**上限**（不预分配，见下）。
-4. 请求进来时 `Registry` 按 `model` 路由到 Provider，Provider 调适配器
-   `transform_request` → HTTP 发送 → `transform_response` / `transform_stream_chunk`。
-
-WebUI 上的"新增/编辑源"、"上传 Lua 适配器"、"改 AUTO 优先级链"与"密钥模型范围"
-都即时生效（写入运行时文件或 `adapter_dir` 后重新装配，无需重启）；直接编辑
-`config.yaml` / `adapter_dir` 下的文件则需要重启进程才会重新加载。
-
-在 WebUI 删除源/适配器时：运行时（WebUI 创建）的源与 `.lua` 文件会真正移除；
-`config.yaml` 中定义的基源无法改写配置文件，采用删除标记隐藏（重启后仍隐藏），
-在 UI 里重新添加同名源即可恢复。
-
-### 源模板（多 key 负载均衡）
-
-多个上游 key 共享同一套配置（URL / 适配器 / 模型列表 / 并发 / rpm）时，逐一复制
-整段 source 太冗余。**源模板**保存除 `name` 和 `api_key` 以外的全部源字段，
-从模板一键创建多个仅 key 不同的源，天然支持多 key 负载均衡（每个展开源独立调度、
-独立冷却、独立健康状态）。
-
-- WebUI「源」页右上角「**模板管理**」按钮：列出全部模板，可编辑 / 删除 / 新建。
-- 添加源弹窗右上角两个按钮：
-  - **从模板创建** → 选模板 → 表单自动填充（name + key 仍需你填）；
-  - **存为模板** → 把当前表单非 key/name 字段存为新模板。
-- 模板持久化在 `runtime_file` 的 `source_templates` 字段，与运行时源一样热管理，
-  改完即时生效。模板本身不含密钥，可以安全共享 / 纳管。
-
-模板不会自己变成源——它只是「配方」。真正承担流量的是从模板创建出来的、带 key
-的具体源。
-
-### 内存占用（实测与调优）
-
-内存不是一个定数：它随**配置的源数量**增长（每个源一个 `http.Transport` 与连接池、
-一组健康状态），与运行时长无关。本机实测（Linux x86_64，12 核）：
-
-| 部署形态 | 启动 RSS | 稳态 RSS |
-|---|---|---|
-| 1 源 / 1 适配器（最小配置） | ~4 MB | ~10 MB |
-| 1 源 + 29 MB 历史审计日志 | ~19 MB | ~20 MB |
-| **16 源 / 13 适配器 / 59 模型（本机生产）** | ~28 MB | **~32–35 MB** |
-
-> 历史参考：本项优化前同一生产配置为 **~105 MB**。降幅来自三处：审计日志的**原始记录**
-> 不再常驻内存（约 25 MB；统计聚合仍扫全量，但扫完即释放）、Lua 状态池不再单调增长、
-> 以及下面两个运行时开关。
-
-内存构成（生产实例分段测量，`/proc/<pid>/smaps`）：
-
-| 区域 | RSS | 说明 |
-|---|---|---|
-| Go 堆 | ~14 MB | provider/registry/scheduler 结构 + 连接池缓冲 |
-| 其他匹名（线程栈 / LuaJIT chunk / runtime） | ~12 MB | 与线程数、已加载适配器数相关 |
-| 二进制 text+rodata | ~8 MB | 映射的可执行文件页（只读、可被内核回收） |
-| Go runtime 预留 | ~4 MB | VSZ 上看到的 2 GB+ 是地址空间预留，不占物理内存 |
-| 共享库 | ~3 MB | libc / libluajit / libm |
-
-**两个推荐的部署开关**（只适用于环境变量，无需改代码）：
-
-```ini
-# /etc/systemd/system/llmsproxy.service
-Environment=GOGC=50
-Environment=MALLOC_ARENA_MAX=2
-```
-
-- `MALLOC_ARENA_MAX=2`：LuaJIT 的分配走 cgo → glibc malloc，glibc 默认允许 `8×nproc`
-  个 per-thread arena，每个碰到 malloc 的 OS 线程会占用一个（各约 1 MB，且**不归还给系统**）。
-  实测从 8–15 个 arena（约 7–12 MB）降到 **0**。
-- `GOGC=50`：把 Go 堆增长目标减半。**单独使用无效**（省下的堆会立即被更多 glibc
-  arena 吃掉，实测 20.3 → 21.5 MB 反而变大），必须与 `MALLOC_ARENA_MAX` 配合，
-  两者同时开启才降 **~19%**。网关是 I/O 密集型（本机 9 小时仅消耗 1min10s CPU），
-  多出的 GC 周期与它的空闲 CPU 相比可忽略。
-
-> 桌面版（Electron）已在 `cmd/gui/main.js` 里默认为内嵌核心注入这两个开关；手动 export 同名
-> 环境变量可覆盖。如果你用自己的 systemd unit / 容器，建议照上面加上。
-
-可选：`GOMEMLIMIT=48MiB` 作软上限，实测再省 ~1 MB；代价是逐近上限时 GC 转激进，
-温和场景不必开。
-
-### thinking 预算
-
-请求体带 `"thinking": {"enabled": false}` 时关闭推理；`"thinking": {"enabled": true,
-"budget_tokens": 4096}` 指定预算。内核只定义这个**中立**语义字段，映射到具体协议由
-适配器负责（Anthropic `thinking.budget_tokens`、Gemini `thinkingConfig.thinkingBudget`、
-DeepSeek `thinking.type = "disabled"`）。内核不再向适配器泄漏 `disable_thinking` /
-`extra_body` 这类私有字段。
-
-### WebUI
-
-内置管理界面（`GET /`），登录后可在浏览器完成：
-
-- **状态页**：源在线状态（实时探测 + 悬停看错误）、模型/源/key 用量统计、请求记录，
-  支持按时间范围导出 CSV；点击模型可生成 pin 到该模型的连接配置。
-- **对话页**：流式/非流式调试。
-- **密钥页**：创建/编辑网关 key，为每个 key 配模型范围（模型 + 源 + token 配额 + 周期），
-  管理员管理全部 key，用户只看到自己的 key。每个模型砖块显示自己的配额徽标
-  （如 `1.0K 77×·1h`，未设配额显示 `∞`），点开可编辑该模型的 token 配额、
-  请求数配额与重置周期 —— 配额按模型独立生效，一个用满不影响同一 key 的其它模型。
-  「我的密钥」页对用户展示本 key 的模型范围与各自配额。
-- **优先级页**：拖拽积木配置 AUTO 链档位。
-- **源页**：在线增删改上游源（API key 等敏感字段加密落盘）。
-- **适配器页**：上传 / 删除 Lua 适配器脚本。
-
-改动写入 `runtime_file`（重启仍生效）。
-
-## Lua 适配器协议
-
-完整 API 见 **[Lua 适配器 API 文档](docs/lua-adapters.md)**（[English](docs/lua-adapters-en.md)）。
-
-每个适配器是一个返回 table 的 Lua 脚本（`internal/lua/adapters/<name>.lua`），
-加载时可被 `adapter_dir` 下的同名脚本覆盖——**改 Lua 脚本无需重编译**，
-重启即生效；通过 WebUI 上传的适配器与在线编辑的源配置则即时生效。
-
-```lua
-return {
-  name = "mysrc",
-  version = "1.0.0",
-  endpoint = "/chat/completions",        -- 上游路径（可被 source.endpoint 覆盖）
-  headers = { ["X-Static"] = "v" },      -- 静态默认请求头（build_headers 缺省时使用）
-
-  -- 请求转换：把 OpenAI 格式 req 转成上游原生格式，返回字符串
-  transform_request = function(raw_json) ... end,
-
-  -- 响应转换：把上游原生响应转成统一格式字符串
-  --   { content, reasoning_content, finish_reason, token_usage{...}, tool_calls[{...}] }
-  transform_response = function(raw_json) ... end,
-
-  -- 流式分块转换：把上游 SSE data 转成 { content, done, ... }，返回 "" 则跳过
-  transform_stream_chunk = function(raw_chunk) ... end,
-
-  -- [可选] 动态请求头/签名钩子
-  -- meta = { url, method, body, api_key, timestamp, source={ name, meta={...} } }
-  build_headers = function(meta) return { ["X-App-Sign"] = sign } end,
-
-  -- [可选] 出向序列化（契约 v2）：上游不是 OpenAI 协议时接管写给客户端的字节。
-  -- 不声明则沿用内核的 OpenAI 兜底；声明即完全取代，内核不再混合字段。
-  serialize_response = function(result) return body_str end,
-  serialize_open_preamble = function(result) return bytes end,
-  serialize_chunk = function(delta) return bytes end,
-  serialize_close = function(result) return bytes end,
-}
-```
-
-内置信号辅助：`hmac_sha256_hex(key, data)`、`sha256_hex(data)`、`base64_encode(s)`、
-`tohex(s)`、`json.encode/decode`、`log(level, msg)`。
-
-### 内置适配器
-
-`openai` `deepseek` `anthropic` `gemini` `github` `groq` `mistral` `ollama` `kimicode`
-`qwen38` `sensenova` `trae`。
-
-`anthropic`/`gemini`/`ollama` 适配器内置多模态转换（`image_url` → 各自上游格式）；
-推理开关由中立的 `thinking` 字段表达，`deepseek` 适配器把它映射为
-`thinking.type = "disabled"`。
-
-**kimicode** 是展示 `build_headers` 的样例：云端校验调用方 app，需要按
-`meta.app_secret` 对时间戳+URL+请求体哈希做 HMAC 签名并附 `X-App-Sign` 等头。
-配好 `sources[].meta.{app_id, app_secret, app_agent}` 即可。
-
-## 桌面 GUI（Electron）
-
-可选独立产物，面向内网桌面端用户：**内嵌 ModelRouter 核心**（Clash Verge 形态），
-一键启停、系统托盘常驻、开机自启、静默启动，内容区一比一内嵌完整 WebUI
-（状态/对话/密钥/优先级/源/适配器 六个页面，免登录）。服务器用户继续使用纯 Go 二进制。
-
-### 两种安装包：Headless 与 Desktop
-
-发布到 Release 的安装包分为两类，面向不同用户：
-
-- **Headless（服务器版）**：纯核心二进制（无 Electron），配置驱动，适合服务器、
-  容器、systemd 等无人值守场景。发布包含 `deb` + `rpm`（含 systemd unit、内存调优
-  与示例配置）与 `tar.gz`（二进制 + `config.example.yaml` + `adapters/` + README），
-  Windows 为 `.zip`。
-- **Desktop（桌面版）**：Electron GUI 安装包，内嵌核心，适合个人桌面日常使用。
-
-### 选择 GUI 还是纯后端
-
-| 场景 | 推荐 | 理由 |
-| ------ | ------ | ------ |
-| 服务器 / 内网网关 / 无人值守常驻 | **Headless**（单二进制） | 极轻量（二进制 ~8MB；RSS 随源数量，单源 ~10MB、16 源 ~32–35MB，见[内存占用](#内存占用实测与调优)），零依赖单进程，直接跑在 systemd/任意容器里，远程管理 |
-| 个人桌面日常使用 / 多设备内网共享 | **Desktop**（GUI） | 免登录内嵌 WebUI、系统托盘一键启停、开机自启、静默后台，适合不懂命令行的使用者 |
-| Windows 桌面 | **Desktop** | 纯后端在 Windows 上需自行注册服务，GUI 提供原生托盘/自启体验 |
-| CI 一键出三平台安装包 | **Desktop 打包脚本** | `make gui-*` 系列出 deb/AppImage/NSIS，可进发行流水线 |
-
-两者完全同源：GUI 内嵌的就是纯后端的同一份 `llmsproxy` 核心（LuaJIT 版），
-配置/适配器格式完全一致，可随时互换。
-
-### 构建与运行
-
-```bash
-cd cmd/gui
-npm install
-make gui          # 或 npm run dev —— 开发运行（需先 make build 生成 bin/llmsproxy）
-make gui-deb      # 本机构建 deb（分享给其它 Linux 用户）
-make gui-dist     # 构建 deb + rpm + AppImage（linux，rpm 需系统 rpmbuild）
-make core-dist    # 构建核心 deb + rpm + tar.gz（服务器版，需 nfpm）
-make gui-win      # 构建 Windows nsis 安装包（本机 mingw + wine）
-make gui-win-docker  # 构建 Windows nsis 安装包（全 docker 自足，含 wine）
-make gui-dist-dir # 仅解包产物（调试用，不产安装包）
-```
-
-产物在 `cmd/build/gui-dist/`：`ModelRouter-<ver>.AppImage`、
-`modelrouter-gui_<ver>_amd64.deb`、`ModelRouter Setup <ver>.exe`（win）；
-核心包在 `cmd/build/dist/`：`llmsproxy_<ver>_amd64.deb`、`llmsproxy-<ver>.x86_64.rpm`。
-rpm 需系统 `rpmbuild`。每次打包后都会跑 `packaging/verify-dist.sh` 产物体检
-（大小下限门禁——1.3.0 曾因宿主 wine 损坏产出 264KB 的残缺 exe 却没有被拦住）。
-发布时会把产物重命名为 `ModelRouter-Desktop-*`（GUI）与 `ModelRouter-Headless-*`（纯后端）
-两类上传到 GitCode Release。
-
-#### Windows 打包（docker 固化方案，推荐）
-
-`make gui-win-docker` 一步完成：交叉编译核心 + NSIS 打包**全在 docker 内**，宿主机
-**无需 mingw、无需 wine、无需 node**。镜像内置 wine（含 i386 运行时），修复了
-此前宿主 wine 损坏（缺 syswow64 → `c0000135`）导致产出 264KB 残缺 exe 的问题。
-
-- 构建镜像：`cmd/gui/docker/win-builder/Dockerfile`（`golang:1.25` + mingw-w64 +
-  node + wine32/wine64 + 预编译 LuaJIT windows 版 `lua51.dll` 与 import lib）。
-  LuaJIT 源码取自 gitcode 镜像（国内可达），github 兜底；Go 依赖走 `https://goproxy.cn`。
-- 一键发布：`cmd/gui/scripts/dist-win-docker.sh` —— 核心编译 + electron-builder
-  NSIS 全部在容器内执行（`USE_SYSTEM_WINE=true` 走镜像内的 wine）；electron-builder
-  的 ~400MB 工具链缓存挂到 docker volume，二次构建增量复用。
-- 首次运行自动构建 `modelrouter/win-builder` 镜像（约 5–10 分钟）；已存在则直接复用。
-- 打包完成后自动跑 `packaging/verify-dist.sh` 门禁：exe 低于 5MB / deb·rpm·7z 低于
-  10MB 即失败——残缺安装包不可能再溜进 Release。
-
-```bash
-# 全 Windows 发布（核心重编 + NSIS）：
-make gui-win-docker
-```
-
-### 特性
-
-- **内嵌核心**：自动拉起捆绑的 `llmsproxy`（LuaJIT 版），配置/密钥/adapter 存于
-  用户数据目录 `<userData>/profile/`，首次运行自动生成随机 admin key 写入 `keys`
-  （非 seed）并自注入，WebUI 免登录、不会提示"更换初始密钥"。端口可在设置中更改（默认 8787）。
-- **系统托盘**：内核状态点、开机自启/静默启动开关、启停/重启内核、退出。
-- **静默启动**：`--silent` 参数或设置项，启动仅驻托盘不弹窗；首次运行始终显示窗口。
-- **开机自启**：Windows/macOS 用 `setLoginItemSettings`；Linux 写
-  `~/.config/autostart/modelrouter-gui.desktop`，静默开启时自动附加 `--silent`。
-
-## 目录
-
-```
-cmd/llmsproxy            # 入口（纯 Go 服务端）
-cmd/gui                  # Electron 桌面 GUI（内嵌核心 + 托盘 + 打包）
-internal/config          # YAML 配置加载/校验
-internal/lua             # LuaJIT VM + worker 池 + AdapterCache + 内置适配器 (embed)
+旧路径与旧环境变量在读取侧仍被接受，因此升级不会因为顺序问题立刻失效。
+`deploy.sh` 在检测到旧 `/etc/llmsproxy` 而新配置不存在时会**中止**，避免部署出
+一个「能启动但没有 key / 没有源」的空实例。
+
+插件 SDK 同名调整：唯一公开入口是 `modelrouter`（`llmsproxy` 仅作兼容别名），
+详见 [docs/plugins.md](docs/plugins.md)。
+
+## 目录结构
+
+```text
+cmd/modelrouter          # 入口（纯 Go 服务端）
+cmd/gui                  # Electron 桌面壳（内嵌同一份核心）
+internal/config          # 配置解析、加密存储、运行时文件
+internal/core            # 调度、内核动作、状态与审计
+internal/lua             # LuaJIT VM + 弹性 worker 池 + 内置适配器 (embed)
+internal/lua/plugins     # 可选插件示例（不随二进制/发行包分发）
 internal/provider        # Provider(HTTP) + Registry(路由)
-internal/gateway         # OpenAI 兼容 HTTP 服务 + 鉴权 + SDK/流式 + WebUI
+internal/gateway         # OpenAI 兼容 HTTP 服务 + 鉴权 + 流式 + WebUI
 internal/types           # 统一格式 & OpenAI wire 类型
+packaging/               # deb/rpm/tar 打包、systemd unit、迁移脚本
+docs/                    # 主题文档
 ```
 
-## 开发协作
-
-- **Git 分支工作流**：主分支 / 特性分支 / 发布分支的规范见
-  **[docs/git-workflow.md](docs/git-workflow.md)**（[English](docs/git-workflow-en.md)）。
-  主线：`main` 永可部署 → 特性合入 `main` → 切 `release/vX.Y.Z` 打 tag 发布 →
-  hotfix 提交发布分支并 cherry-pick 回 `main`。
-- **Lua 适配器协议**：见 **[docs/lua-adapters.md](docs/lua-adapters.md)**
-  （[English](docs/lua-adapters-en.md)）。
-
-## 测试
+## 开发与测试
 
 ```bash
-go test -tags luajit ./...
+go test -tags luajit ./...          # 全量
+go test -tags luajit ./internal/lua # 单包（LuaJIT 相关改动必跑）
 ```
 
-覆盖：配置校验、适配器加载/变换、签名钩子、Gateway 鉴权、SDK 结算、SSE 流式、
-模型路由、多模态透传与 thinking 预算。
+- 分支与发布纪律见 [docs/git-workflow.md](docs/git-workflow.md)。
+- 插件放置在 `plugin_dir`，网关启动时**不会**创建、覆盖或删除任何插件文件；
+  升级桌面端也不会动它们。
+
+## 许可
+
+MIT License，见 [LICENSE](./LICENSE)。

README_EN.md

@@ -1,626 +1,155 @@
 # ModelRouter
 
+> **Repository**: <https://atomgit.com/HeNanMU-EEA/ModelRouter>
+>
 > **中文**: [README.md](./README.md)
 >
-> **AI-assisted**: This project is developed with AI-assisted coding (code and docs are produced in collaboration with AI, reviewed by humans).
+> **AI-assisted**: code and documentation were produced with AI assistance and
+> reviewed by a human.
 
-A lightweight, unified OpenAI-compatible LLM gateway for internal networks —
-configure once, and let multiple services (agents, SDKs, bots) share many
-upstreams (DeepSeek, Qijiar, OpenAI, Anthropic, Gemini, Groq, Mistral, Ollama,
-KimiCode…) behind a single endpoint. Pick a specific model or use **AUTO** mode,
-which routes to the best healthy upstream by configured priority.
+An intranet gateway for people with several LLM subscriptions: configure once and
+let multiple services share the upstream capacity. Pick a model explicitly, or let
+`AUTO` choose by priority among the sources that are currently healthy.
 
-> **Lightweight, no recompile to add sources**: the gateway is a single Go
-> binary (8-12 MB, ~8 MB stripped; zero runtime dependencies). Adding or switching an upstream is
-> just a `sources` entry in `config.yaml` (or via the WebUI) or a `.lua`
-> adapter — **no Go changes, no recompile**. Changes submitted through the
-> WebUI take effect immediately (hot reload); editing `config.yaml` or a `.lua`
-> file under `adapter_dir` by hand requires a process restart.
+The gateway itself is a single Go binary (~10 MB, no runtime dependencies). Adding
+or switching an upstream is a `sources` entry in `config.yaml` (or the WebUI), or a
+dropped-in `.lua` adapter — **no Go changes, no rebuild**. Changes submitted through
+the WebUI take effect immediately; editing `config.yaml` or a `.lua` adapter file
+directly requires a restart.
 
-## Overview
+## What it does
 
-Exposes a standard `OpenAI Chat Completions` API (`/v1/chat/completions` +
-`/v1/models`) to your internal network, translating between multiple upstream
-protocols via **Lua adapters**. Supports one-shot calls, SSE streaming,
-**AUTO model routing**, multimodal passthrough, and tool calls.
-
-Extracted and independently evolved from the multi-source LLM adapter layer of
-[HomeAgent](https://gitcode.com/JianFeeeee/HomeAgent)
-(`internal/agent/api/provider.go` + `internal/lua/adapters/*`).
-
-## Features
-
-- **Multi-source**: any number of upstream sources in one process, routed by the
-  request's `model`.
-- **AUTO mode**: with `default_model: AUTO`, scheduling follows the tiered AUTO
-  chain saved on the Priority page (see below).
-- **Unified output**: every source speaks OpenAI format (incl.
-  `reasoning_content`, `tool_calls`, `usage`).
-- **Image generation**: `POST /v1/images/generations`, routed to models with
-  `kind: image`.
-- **Per-model quota**: each key gives every model its own token and request caps
-  plus a reset period (hour/week/month/custom N hours). One model running out
-  affects only that model — the key's other models keep working. Exhaustion
-  answers 429 + `Retry-After` naming the model, so a client resumes when the
-  window rolls over; admin keys are never capped.
-- **Multimodal**: `content` arrays (`image_url` etc.) pass through losslessly;
-  Anthropic/Gemini/Ollama are translated automatically.
-- **LuaJIT VM**: golua-binding LuaJIT; each adapter has its own VM + worker
-  pool for safe concurrency. Pools are **elastic**: the sum of `max_concurrent`
-  over an adapter's sources is a ceiling, not a preallocation — states are booted
-  on demand and reclaimed when demand drops, so an idle gateway holds close to
-  zero Lua states. The grow step follows the adapter's max concurrency
-  (`clamp(ceil(max/8), 1, 8)`, and never exceeds the number of queued callers);
-  the shrink step follows the live connection count
-  (`clamp(ceil(slack/(1+in_use)), 1, slack)`), so an idle pool collapses in one
-  round while a busy one gives up a single state at a time.
-- **On-demand request logs**: dashboard totals are computed from the **full**
-  audit history (streamed once at startup and released — 29 MB / 221k lines in
-  ~260 ms), while the raw records are never held in memory: the dashboard loads
-  one screen, scrolling pages the rest straight off disk, CSV export streams in
-  O(1) memory, and leaving the page releases everything.
-- **Self-healing cooldown**: cooldown is capped at 5 minutes and, past the
-  window's midpoint, exactly one probe request is allowed through; a recovered
-  upstream (or a reset quota) returns to full rotation on that probe instead of
-  waiting out the window.
-- **disable_thinking**: `disable_thinking: true` toggles reasoning per-request.
-- **Lua adapter protocol**: each source mounts a `.lua` adapter with
-  `transform_request` / `transform_response` / `transform_stream_chunk` — all
-  protocol differences live in Lua, Go only schedules and proxies.
-- **Signature / header hooks**: adapters may define `build_headers(meta)` to
-  inject/sign request headers before the HTTP call (e.g. KimiCode style
-  app-validation), with helpers like `hmac_sha256_hex`, `sha256_hex`,
-  `base64_encode`.
-- **WebUI**: built-in management page to view/add/edit sources & models, edit
-  the AUTO chain, and manage per-key model scopes, persisted to a runtime file.
-- **Encrypted secrets at rest**: upstream `api_key`, custom header values and
-  gateway keys are stored AES-256-GCM encrypted (`master.key` 0600 next to the
-  runtime file, or `LLMS_PROXY_MASTER_KEY`).
-- **Live source probing**: the status page probes each source
-  (`GET {base}/models`, falling back to a minimal chat call) without touching
-  the scheduler's backoff state; errors are shown on hover.
-- **Auth**: the gateway validates client keys via `gateway_keys`; independent
-  from each upstream's own key.
-- **Streaming**: SSE `chat.completion.chunk` with a role-first chunk and
-  `[DONE]` terminator.
+- **One OpenAI-compatible API**: `/v1/chat/completions`, `/v1/models`,
+  `/v1/images/generations`. Every source speaks the same shape outwards, including
+  `reasoning_content`, `tool_calls` and `usage`.
+- **Many sources, one AUTO chain**: configure any number of upstreams; `AUTO`
+  follows the priority tiers saved in the WebUI, fails over between them, cools
+  down broken sources and probes them back to health at half-cool.
+- **Protocol differences live in Lua**: each source binds a `.lua` adapter that
+  transforms requests, responses and stream chunks both ways, and can sign headers
+  via `build_headers(meta)`. Vendor knowledge stays out of the Go kernel.
+- **Plugins are independent**: business extensions (channel login, billing, quota
+  probing) are external Lua plugins loaded from `plugin_dir`. They are not compiled
+  into the binary and not shipped in release archives, and they talk to the kernel
+  only through the `modelrouter` SDK.
+- **Multi-tenant keys**: gateway keys are separate from upstream keys, and can be
+  scoped to a model set, an AUTO chain and a quota.
+- **Encrypted at rest**: upstream keys, custom header values and gateway keys are
+  sealed with AES-256-GCM; `master.key` is 0600, or injected via
+  `MODELROUTER_MASTER_KEY`.
+- **Observability**: live source probing, HTTP access log, config-change audit,
+  request and usage CSV export. Writes are kept off the request hot path.
 
 ## Quick start
 
 ```bash
-GOMODCACHE=... GOPROXY=off go build -tags luajit -o llmsproxy ./cmd/llmsproxy
-./llmsproxy -config config.yaml    # first run generates a default config and prints a random admin key
+# LuaJIT development libraries are required; -tags luajit is mandatory
+GOMODCACHE=... GOPROXY=off go build -tags luajit -o modelrouter ./cmd/modelrouter
+
+# First run generates a default config and prints a random admin key
+./modelrouter -config config.yaml
 ```
 
-> Depends on [golua](https://github.com/aarzilli/golua) (LuaJIT bindings).
-> You **must** build with `-tags luajit`; otherwise the built-in superset
-> gopher-lua path is used (behavior differs slightly).
+> Depends on [golua](https://github.com/aarzilli/golua) (LuaJIT bindings). Without
+> `-tags luajit` the build falls back to gopher-lua, which behaves slightly
+> differently.
 
-> **No config is shipped in the repo** (config files carry real keys). On
-> first run the binary generates a default config at the `-config` path: a
-> random admin key (printed to the startup log), loopback-only `127.0.0.1:8080`,
-> and a keyless source ready to chat. Rotate the admin key in the
-> WebUI after first login.
+> **No config in the repo**: the repository ships no config file (they contain
+> keys). The generated default binds `127.0.0.1:8080` only; rotate the admin key in
+> the WebUI after the first login.
 
 ```bash
-# no key -> 401
+# No key -> 401
 curl http://127.0.0.1:8080/v1/models
 
-# one-shot ($KEY = the admin key printed at first startup)
+# Non-streaming ($KEY = the admin key printed at first start)
 curl -H "Authorization: Bearer $KEY" \
      -d '{"model":"AUTO","messages":[{"role":"user","content":"hi"}]}' \
      http://127.0.0.1:8080/v1/chat/completions
 
-# streaming
+# Streaming
 curl -N -H "Authorization: Bearer $KEY" \
      -d '{"model":"AUTO","stream":true,"messages":[{"role":"user","content":"hi"}]}' \
      http://127.0.0.1:8080/v1/chat/completions
 ```
 
-Any OpenAI SDK works: point `base_url` at the gateway, use any authorized
-gateway key as the API key.
-
-## Configuration
-
-Generated on first run at the `-config` path (default `./config.yaml`). Core fields:
-
-```yaml
-listen: 127.0.0.1:8080        # bind address (keep internal/loopback)
-gateway_keys: [sk-gw-<random>] # initial admin key seed (random per install), migrated to the store on first start
-default_model: AUTO           # when model is unroutable, follow the AUTO chain
-adapter_dir: adapters         # Lua adapter dir; created+seeded if missing, read-only otherwise
-runtime_file: runtime.json    # WebUI-edited sources/keys/AUTO chain persist here
-
-sources:
-  - name: deepseek
-    base_url: https://api.deepseek.com
-    api_key: sk-...            # or api_key_env: SOME_ENV to read from an env var
-    adapter: deepseek
-    max_concurrent: 8
-    models:
-      - id: deepseek-v4-flash
-        priority: 100          # YAML sources seed the AUTO chain on first start
-        kind: chat
-      - id: deepseek-v4-pro
-        priority: 60
-        kind: chat
-    # static headers (take precedence over adapter defaults)
-    headers: { X-Tenant: prod }
-    # passthrough metadata for the Lua build_headers hook
-    meta: { app_id: x, app_secret: y }
-    temperature: 0.7
-    max_tokens: 4096
-    timeout: 120s              # request timeout, default 120s
-```
-
-Sensitive fields in the runtime file (`runtime_file`) are encrypted at rest:
-
-- AES-256-GCM, stored as `enc:v1:<base64>`.
-- Master key source: env var `LLMS_PROXY_MASTER_KEY` (64 hex chars), else a
-  `master.key` file next to the runtime file; if neither exists it is generated
-  on first start (mode 0600).
-- Old plaintext files still load; the first UI save migrates the whole file to
-  ciphertext.
-- Back up `master.key` with your config — losing it makes the secrets
-  undecryptable. Do not commit it.
-
-### Gateway keys (multi-key)
-
-Gateway auth uses a "multi-key + role + model scope" model. Keys are persisted
-under the `keys` field of the runtime file (encrypted at rest):
-
-- The `gateway_keys` config is only an **initial admin key seed** — it is
-  migrated into the runtime store on first start and no longer drives auth.
-- **Important: after first start, replace the admin key via the WebUI Keys
-  page.** The seed key is written in plaintext in `config.yaml`, so keeping it
-  active is a security risk; create a new admin key, log in with it, then
-  delete the seed key.
-- The WebUI **Keys page** creates/deletes keys. Each key has a role (`admin`
-  manages everything, `user` sees only its own key) and an optional **model
-  scope** (model + source + token quota + reset period). Each model brick shows
-  its own budget badge (e.g. `1.0K 77×·1h`, `∞` when uncapped); clicking it
-  edits that model's token quota, request quota and reset period. Quotas apply
-  per model, so one model running out never blocks the key's others. The
-  "My key" view shows a user its model scopes and their budgets.
-- Clients authenticate with any authorized key's plaintext as
-  `Authorization: Bearer <key>`.
-- Deleting a key removes it from the store immediately.
-
-#### Per-key usage quota
-
-**Quotas are per model.** Each key's `models[]` list gives every model its own
-token budget and request budget. One model running out affects only that model
-— the key's other models keep working.
-
-```yaml
-keys:
-  - key: sk-gw-<hex>
-    role: user
-    name: agent-alice
-    models:
-      - model: deepseek-v4-flash
-        token_quota: 1000000   # this key's token budget for this model
-        req_quota: 20000       # requests within the window
-        period: nhour          # "" | hour | week | month | nhour
-        hours: 6               # n-hour only
-      - model: AUTO
-        token_quota: 5000000   # AUTO is a quota entry like any other
-        period: hour
-      - model: kimi-k3        # no quota listed = unlimited
-```
-
-- **There is deliberately no key-wide total.** A key-wide cap would make
-  "move A's budget to B" a global reallocation; per-model budgets keep each
-  model independently controllable, so it stays visible which model is
-  actually consuming the spend.
-- `period`: empty = never resets (lifetime total); `hour` / `week` / `month` =
-  fixed windows; `nhour` + `hours` = a custom hour count. **A misspelled
-  period is rejected at write time** rather than silently becoming a
-  never-resetting quota.
-- Quotas are isolated per key *and* per model within a key: one key exhausting
-  `m1` never draws on another key's budget, and never blocks the same key's
-  `m2`.
-- Usage counts chat, streaming and image requests, and survives a restart by
-  replaying the audit log (40 days retained, covering the longest `month`
-  window).
-- An exhausted quota returns **429 + `Retry-After`**
-  (`rate_limit_exceeded`) and the message names the model that ran out, so a
-  client resumes when the window rolls over; a model the key may not use stays
-  403. **Admin keys are never capped** (quotas on their scopes are not
-  enforced either), so a cap can never lock the operator out.
-- Buckets are whole unix hours, so a window frees up at most an hour late
-  (deliberately freeing late rather than overspending).
-- `PUT /api/keys/{key}` submits quotas by submitting `models` — the caps are
-  part of the scope, so there is no second budget that can drift out of sync
-  with the model list. An explicit `0` lifts that model's cap.
-
-##### Quota rejection vs capacity rejection
-
-A quota is checked at the entry point and occupies no upstream slot, so it is a
-cheap rejection. Running out of capacity instead waits out the bounded
-`busyWait` before answering 503. Measured (capacity 8, 0.6 s/request, 100
-concurrent clients):
-
-| Case | Status | Latency | Reaches upstream |
-|---|---|---|---|
-| Quota spent (`req_quota` 50, 100 concurrent) | `429 rate_limit_exceeded` + `Retry-After` | **19–21 ms** | no |
-| Capacity exhausted (same topology, no quota) | `503 upstream_error` | ~2.6 s (`busyWait`) | overflow: no |
-
-So a client can tell "wait for the window to roll over" apart from "wait for
-upstream capacity" — the first only needs patience, the second usually means
-back off concurrency or switch sources.
-
-##### What the quota costs
-
-Buckets are kept per (key, model, whole unix hour) for 40 days. Measured on an
-AMD 7840HS:
-
-- A window query scans the window, not the whole retention: 49 ns for 1 h,
-  55 ns for 24 h, 3.9 µs for 30 d.
-- Recording one request: 283 ns, 3 allocations (unchanged from before this
-  feature; the allocations come from the record ring buffer).
-- Memory: the production shape (7 keys x 8 models x 2 sources at full 40-day
-  retention) costs about **3.7 MB**. The `source::model` bucket used by a
-  source-pinned quota is created **lazily** — it is maintained only once some
-  quota actually pins that source, because writing it on every record would
-  cost an extra 18 MB at 20 keys x 8 models x 3 sources.
-  The trade-off: usage recorded before a pinned quota was configured cannot be
-  split by source afterwards, so **a pinned quota may under-count its first
-  window**.
-
-```
-HTTP/1.1 429 Too Many Requests
-Retry-After: 2100
-{"error":{"type":"rate_limit_exceeded","message":"token quota exceeded for \"deepseek-v4-flash\" (5000000/5000000)"}}
-```
-
-### Model routing
-
-`/v1/chat/completions` `model` resolution order:
-
-1. `source/model` or `source:model` prefix → pinned source;
-2. exact match of a source's `model`;
-3. with `default_model: AUTO` → follow the AUTO chain from the Priority page
-   (see below);
-4. otherwise the request errors.
-
-Any OpenAI client can pin to a source by setting `model` to its
-`name/anything`; `AUTO` (or the gateway's `default_model: AUTO`) follows the
-tiered AUTO chain.
-
-### AUTO chain (Priority page)
-
-AUTO scheduling is driven **only** by the rules saved on the Priority page. The
-numeric `models[].priority` in source configs no longer participates in
-scheduling and is no longer shown. **Chat and image generation are two
-independent chains**, switched in the Priority page via the `Chat / Image` toggle:
-
-- **Chat chain** (`auto` field): serves `POST /v1/chat/completions` with
-  `model: AUTO`; only `kind: chat` models are honored (image slots are skipped).
-- **Image chain** (`auto_image` field): serves `POST /v1/images/generations` with
-  `model: AUTO`; only `kind: image` models are honored. With no image chain
-  configured, AUTO image generation falls back to legacy discovery (all sources
-  exposing an image model, in registry order) for backward compatibility.
-
-Each rule is one "slot": `{ model, source, tier, token_quota, period, hours }`.
-
-- `tier` is the priority tier: models in the same tier sit side by side and
-  share it; tiers run high → low.
-- The same model may appear in several slots (e.g. A low → B low → A high →
-  B high) and is tried in tier order.
-- `token_quota` > 0 means the slot is skipped once its tokens within the reset
-  window are exhausted; `period` supports `hour` / `week` / `month` / `nhour`
-  (with `hours`); empty = unlimited.
-- Within a tier, slots run by preference score; cooling / quota-exhausted /
-  hard-failed slots fall through to the next tier, and total failure returns
-  503 with a per-tier summary.
-
-### Sources vs. adapters
-
-- A **source** describes a connection to an upstream: `name`, `base_url`,
-  `api_key`, model list and priorities.
-- An **adapter** is the protocol translation logic (Lua script): converts the
-  unified OpenAI request to the upstream's native format and back.
-- One adapter serves many sources (e.g. `openai.lua` for any OpenAI-compatible
-  site); one source can switch adapters via its `adapter` field.
-- Sources decide *whom to talk to and which models to expose*; adapters decide
-  *how to talk*. They are linked by the `adapter` field inside each `sources[]`
-  entry.
-
-Loading flow (assembled by `Core` in `internal/core`):
-
-1. On startup `lua.NewVM(adapter_dir)` loads all adapters: built-in ones
-   (embedded at compile time) + same-name override files under `adapter_dir`.
-2. `config.Load` reads `config.yaml`; `config.NewStore(runtime_file)` reads
-   WebUI-edited runtime sources; both are merged by name.
-3. `rebuildRegistry` creates a `provider.Provider` per source (holding its
-   adapter), sizing the adapter's worker pool from the source's concurrency
-   limit.
-4. Incoming requests are routed by `Registry` to a provider, which calls the
-   adapter's `transform_request` → HTTP call → `transform_response` /
-   `transform_stream_chunk`.
-
-"Add/Edit source", "Upload adapter", "AUTO chain edits" and "per-key model
-scopes" in the WebUI take effect immediately (written to the runtime file /
-`adapter_dir`, then reassembled — no restart). Directly editing `config.yaml`
-or files under `adapter_dir` requires a process restart.
-
-Deleting a source/adapter in the WebUI truly removes runtime (UI-created)
-sources and `.lua` files; base sources defined in `config.yaml` cannot rewrite
-that file, so they are hidden via a deletion tombstone (still hidden after
-restart) and can be restored by re-adding the same name in the UI.
-
-### Source templates (multi-key balancing)
-
-When several upstream keys share one config (URL / adapter / model list /
-concurrency / rpm), copying the whole source block N times is wasteful. A
-**source template** stores every source field except `name` and `api_key`, so you
-create N key-only-different sources from one shared skeleton — natural multi-key
-load balancing (each expanded source schedules, cools down, and reports health
-independently).
-
-- WebUI Sources page, top-right **Templates** button: list all templates with
-  edit / delete / create.
-- Add-source dialog has two header buttons:
-  - **From template** → pick a template → form auto-fills (name + key still
-    yours to enter);
-  - **As template** → save the current form's non-key/name fields as a template.
-- Templates persist in the runtime file's `source_templates` field alongside
-  runtime sources (hot-managed, apply immediately). Templates hold no secret
-  keys, so they're safe to share / version-control.
-
-A template is just a recipe — it doesn't become a source by itself. Only the
-key-bearing sources created from it carry real traffic.
-
-### Memory footprint (measured and tuned)
-
-Memory is not a constant: it scales with the **number of configured sources**
-(each source owns an `http.Transport` with its connection pool plus per-model
-health state), not with uptime. Measured on this machine (Linux x86_64, 12 cores):
-
-| Deployment shape | Startup RSS | Settled RSS |
-|---|---|---|
-| 1 source / 1 adapter (minimal) | ~4 MB | ~10 MB |
-| 1 source + a 29 MB audit history | ~19 MB | ~20 MB |
-| **16 sources / 13 adapters / 59 models (this host)** | ~28 MB | **~32-35 MB** |
-
-> For reference, the same production config used **~105 MB** before this round of
-> work. The reduction comes from three places: raw audit records are no longer kept
-> resident (~25 MB — the aggregates still scan the full history, but the scan
-> releases as it goes), Lua state pools no longer grow monotonically, and the two
-> runtime knobs below.
-
-Breakdown of the production instance (per-region, from `/proc/<pid>/smaps`):
-
-| Region | RSS | Notes |
-|---|---|---|
-| Go heap | ~14 MB | provider/registry/scheduler state + connection-pool buffers |
-| Other anonymous (thread stacks / LuaJIT chunks / runtime) | ~12 MB | scales with thread count and loaded adapters |
-| Binary text+rodata | ~8 MB | mapped executable pages (read-only, reclaimable by the kernel) |
-| Go runtime reservations | ~4 MB | the 2 GB+ you see in VSZ is address space, not physical memory |
-| Shared libraries | ~3 MB | libc / libluajit / libm |
-
-**Two recommended deployment knobs** (environment only, no code change):
-
-```ini
-# /etc/systemd/system/llmsproxy.service
-Environment=GOGC=50
-Environment=MALLOC_ARENA_MAX=2
-```
-
-- `MALLOC_ARENA_MAX=2`: LuaJIT allocates through cgo into glibc malloc, and glibc
-  allows up to `8 x nproc` per-thread arenas. Every OS thread that touches malloc
-  claims one (~1 MB each) and **never returns it to the OS**. Measured: 8-15
-  arenas (7-12 MB) down to **0**.
-- `GOGC=50`: halves the Go heap growth target. **It does nothing on its own** —
-  the heap it saves is immediately consumed by additional glibc arenas (measured
-  20.3 -> 21.5 MB, i.e. slightly worse) — so it must be paired with
-  `MALLOC_ARENA_MAX`. Together they cut settled RSS by **~19%**. The gateway is
-  I/O bound (1min10s of CPU per 9 hours here), so the extra GC cycles are free.
-
-> The desktop build (Electron) already injects both when spawning the embedded
-> core (`cmd/gui/main.js`); exporting either variable yourself overrides it. If you
-> write your own systemd unit or container spec, add them there.
-
-Optional: `GOMEMLIMIT=48MiB` as a soft ceiling saves roughly 1 MB more, at the
-cost of GC turning aggressive as the limit approaches. Not worth it for a relaxed
-deployment.
-
-### disable_thinking
-
-With `"disable_thinking": true` in the request body, the gateway passes it to
-each adapter; the DeepSeek adapter maps it to `extra_body.thinking.type =
-"disabled"`, other sources follow their own protocol.
-
-### WebUI
-
-Built-in admin page at `GET /`; after login you can:
-
-- **Status**: source online state (live probe, error on hover), per
-  model/source/key usage stats, request records filtered by key, and CSV export
-  over a time range; click a model to pin the connection snippet to it.
-- **Chat**: streaming / non-streaming debug.
-- **Keys**: create/edit gateway keys, set per-key model scopes (model + source +
-  token quota + reset period); admins manage all keys, users see only their own.
-- **Priority**: drag blocks to build the tiered AUTO chain.
-- **Sources**: add/edit/delete upstream sources online (secrets stored
-  encrypted).
-- **Adapters**: upload / delete Lua adapter scripts.
-
-Changes persist to `runtime_file` (survive restarts).
-
-## Lua adapter protocol
-
-Full API: **[Lua adapter docs](docs/lua-adapters.md)**
-([中文](docs/lua-adapters-en.md)).
-
-Each adapter is a Lua script returning a table
-(`internal/lua/adapters/<name>.lua`), overridable by a same-name file under
-`adapter_dir` — **no recompile needed**, restart to take effect; uploads via
-the WebUI take effect immediately.
-
-```lua
-return {
-  name = "mysrc",
-  version = "1.0.0",
-  endpoint = "/chat/completions",        -- upstream path (source.endpoint overrides)
-  headers = { ["X-Static"] = "v" },      -- static default headers (fallback)
-
-  -- request: convert unified OpenAI req -> upstream native format, return string
-  transform_request = function(raw_json) ... end,
-
-  -- response: convert upstream response to unified format string
-  --   { content, reasoning_content, finish_reason, token_usage{...}, tool_calls[{...}] }
-  transform_response = function(raw_json) ... end,
-
-  -- streaming chunk: convert upstream SSE data to { content, done, ... }; "" skips
-  transform_stream_chunk = function(raw_chunk) ... end,
-
-  -- [optional] dynamic headers / signature hook
-  -- meta = { url, method, body, api_key, timestamp, source={ name, meta={...} } }
-  build_headers = function(meta) return { ["X-App-Sign"] = sign } end,
-}
-```
-
-Shared helpers: `hmac_sha256_hex(key, data)`, `sha256_hex(data)`,
-`base64_encode(s)`, `tohex(s)`, `json.encode/decode`, `log(level, msg)`.
-
-### Built-in adapters
-
-`openai` `deepseek` `anthropic` `gemini` `github` `groq` `mistral` `ollama`
-`kimicode` `qwen38` `sensenova` `trae`.
-
-`anthropic`/`gemini`/`ollama` include multimodal conversion
-(`image_url` → their native format); with `disable_thinking` the `deepseek`
-adapter sets `extra_body.thinking.type` to `disabled`.
-
-**kimicode** demonstrates `build_headers`: the cloud validates the calling
-app, so you HMAC-sign timestamp+URL+body with `meta.app_secret` and add
-`X-App-Sign`-style headers. Configure `sources[].meta.{app_id, app_secret,
-app_agent}`.
-
-## Desktop GUI (Electron)
-
-Optional standalone product for desktop users on your internal network: an
-**embedded ModelRouter core** (Clash Verge-style): one-click start/stop, system
-tray, autostart, silent launch, and a pixel-for-pixel embedded full WebUI
-(Status/Chat/Keys/Priority/Sources/Adapters — no login needed). Server users
-keep using the plain Go binary.
-
-### Two installer kinds: Headless and Desktop
-
-Release installers ship in two flavors for different audiences:
-
-- **Headless (server)**: the plain core binary (no Electron), config-driven,
-  for servers / containers / systemd / unattended runs. Ships as `deb` + `rpm`
-  (systemd unit with memory tuning + example config) and `tar.gz` (binary +
-  `config.example.yaml` + `adapters/` + README), Windows as `.zip`.
-- **Desktop (desktop app)**: the Electron GUI installer with an embedded core,
-  for personal daily desktop use.
-
-### GUI vs. plain backend
-
-| Scenario | Pick | Why |
-| ---- | ---- | ---- |
-| Server / intranet gateway / unattended long-running | **Headless** (single binary) | ~8 MB binary; RSS scales with the number of sources (~10 MB for one, ~32-35 MB for 16 — see [Memory footprint](#memory-footprint-measured-and-tuned)), zero-dep single process — drop it into systemd or any container, remote admin |
-| Personal desktop daily use / multi-device intranet sharing | **Desktop** (GUI) | no-login embedded WebUI, tray one-click, autostart, silent background — for non-CLI users |
-| Windows desktop | **Desktop** | plain backend needs manual service registration; GUI ships native tray/autostart |
-| CI one-shot 3-platform installers | **Desktop packaging scripts** | `make gui-*` emits deb / AppImage / NSIS, drops straight into a release pipeline |
-
-Both share the exact same `llmsproxy` core (LuaJIT build) — configs and
-adapters are fully compatible, freely interchangeable.
-
-### Build & run
+Any OpenAI SDK works: point `base_url` at the gateway and use an authorized gateway
+key as `api_key`.
+
+## Documentation
+
+The detailed documentation is currently written in Chinese.
+
+| Topic | Document |
+|---|---|
+| Implementation and the full feature list | [docs/features.md](docs/features.md) |
+| Configuration: `config.yaml`, model discovery, multiple keys | [docs/configuration.md](docs/configuration.md) |
+| Routing: model routing, AUTO chain, cooldown, sources vs adapters, source templates | [docs/routing.md](docs/routing.md) |
+| Adapters: Lua protocol and built-in adapters | [docs/adapters.md](docs/adapters.md) · [docs/lua-adapters-en.md](docs/lua-adapters-en.md) (English) |
+| Plugins: SDK contract, hooks, UI extensions, HTTP endpoints | [docs/plugins.md](docs/plugins.md) |
+| Desktop app: Headless / Desktop artifacts, build and run | [docs/gui.md](docs/gui.md) |
+| Performance: measured memory use, tuning, thinking budget | [docs/performance.md](docs/performance.md) |
+| WebUI usage | [docs/webui.md](docs/webui.md) |
+| Development: layout, tests, branch and release discipline | [docs/development.md](docs/development.md) · [docs/git-workflow-en.md](docs/git-workflow-en.md) (English) |
+| Deployment and migration | [docs/deployment.md](docs/deployment.md) |
+
+## Renamed from llmsproxy
+
+The product name has been ModelRouter for a while; the binary, config directory,
+service name and environment variables are now `modelrouter` as well:
+
+| Before | After |
+|---|---|
+| `llmsproxy` (binary) | `modelrouter` |
+| `/etc/llmsproxy/` | `/etc/modelrouter/` |
+| `llmsproxy.service` | `modelrouter.service` |
+| `LLMSPROXY_*` | `MODELROUTER_*` |
+
+Existing installs migrate with a dry-run-by-default script (copies, never moves,
+and can roll back):
 
 ```bash
-cd cmd/gui
-npm install
-make gui            # or npm run dev — dev run (needs make build first for bin/llmsproxy)
-make gui-deb        # local deb (share with other Linux users)
-make gui-dist       # deb + rpm + AppImage (linux; rpm needs system rpmbuild)
-make core-dist      # core deb + rpm + tar.gz (server edition; needs nfpm)
-make gui-win        # Windows NSIS (host mingw + wine)
-make gui-win-docker # Windows NSIS, fully dockerized (wine in image; no host mingw/node/wine)
+sudo ./packaging/migrate-to-modelrouter.sh              # preview
+sudo ./packaging/migrate-to-modelrouter.sh --apply      # apply
+sudo ./packaging/migrate-to-modelrouter.sh --rollback --apply
 ```
 
-Artifacts land in `cmd/build/gui-dist/`: `ModelRouter-<ver>.AppImage`,
-`modelrouter-gui_<ver>_amd64.deb`, `ModelRouter Setup <ver>.exe` (win); core
-packages land in `cmd/build/dist/`: `llmsproxy_<ver>_amd64.deb`,
-`llmsproxy-<ver>.x86_64.rpm`. Both target families run
-`packaging/verify-dist.sh` afterwards — a size floor that rejects degenerate
-installers (1.3.0 shipped a 264 KB NSIS stub because the host wine was broken
-and nothing caught it). At release time artifacts are renamed into the
-`ModelRouter-Desktop-*` (GUI) and `ModelRouter-Headless-*` (plain backend)
-families before upload to GitCode Releases.
+Old paths and old environment variable names are still accepted on the read side,
+so an upgrade cannot fail merely because of ordering. `deploy.sh` refuses to run
+when it finds the old `/etc/llmsproxy` without a new config, because that would
+deploy a gateway with no key and no sources.
 
-#### Windows packaging (dockerized, recommended)
-
-`make gui-win-docker` does cross-compile + NSIS **entirely in docker**; the host
-needs **no mingw, no wine, no node**. Wine (with the i386 runtime) lives inside
- the image, fixing the broken-host-wine failure that produced the 264 KB stub
-installer.
-
-- Image: `cmd/gui/docker/win-builder/Dockerfile` (`golang:1.25` + mingw-w64 +
-  node + wine32/wine64 + prebuilt LuaJIT for Windows: `lua51.dll` + import lib).
-  LuaJIT source comes from the gitcode mirror (reachable in CN) with github
-  fallback; Go modules go through `https://goproxy.cn`.
-- One-shot release: `cmd/gui/scripts/dist-win-docker.sh` — core build + NSIS
-  packaging run inside the container (`USE_SYSTEM_WINE=true` uses the image's
-  wine); electron-builder's ~400 MB toolchain cache lives in a docker volume so
-  later builds reuse it.
-- The `modelrouter/win-builder` image is auto-built on first run (~5-10 min)
-  and reused afterwards.
-- After packaging, `packaging/verify-dist.sh` runs as a gate: an exe under
-  5 MB (or a deb/rpm/7z under 10 MB) fails the build — a broken installer can
-  never reach a Release again.
-
-```bash
-# Full Windows release (rebuild core + NSIS):
-make gui-win-docker
-```
-
-### Features
-
-- **Embedded core**: auto-spawns the bundled `llmsproxy` (LuaJIT build);
-  config/keys/adapters live in `<userData>/profile/`. First run generates a
-  random admin key written into `keys` (not seed) and self-injects it — WebUI
-  needs no login and never nags about changing the initial key. Port changeable
-  in settings (default 8787).
-- **System tray**: core status dot, autostart/silent toggles, start/stop/restart
-  core, quit.
-- **Silent launch**: `--silent` flag or setting — starts to the tray only;
-  first run always shows the window.
-- **Autostart**: `setLoginItemSettings` on Windows/macOS; writes
-  `~/.config/autostart/modelrouter-gui.desktop` on Linux, appending `--silent`
-  when silent mode is on.
+The plugin SDK follows the same naming: the only public entry point is
+`modelrouter` (`llmsproxy` remains a compatibility alias). See
+[docs/plugins.md](docs/plugins.md).
 
 ## Layout
 
-```
-cmd/llmsproxy            # entry point
-internal/config          # YAML config loading/validation
-internal/lua             # LuaJIT VM + worker pool + AdapterCache + built-ins (embed)
+```text
+cmd/modelrouter          # entry point (pure Go server)
+cmd/gui                  # Electron desktop shell (embeds the same core)
+internal/config          # config parsing, sealed storage, runtime file
+internal/core            # scheduling, kernel actions, state and audit
+internal/lua             # LuaJIT VM + elastic worker pool + built-in adapters (embed)
+internal/lua/plugins     # optional plugin examples (not shipped in binary/archives)
 internal/provider        # Provider(HTTP) + Registry(routing)
-internal/gateway         # OpenAI-compatible HTTP + auth + SDK/streaming + WebUI
-internal/types           # unified format & OpenAI wire types
+internal/gateway         # OpenAI-compatible HTTP service + auth + streaming + WebUI
+internal/types           # unified format and OpenAI wire types
+packaging/               # deb/rpm/tar packaging, systemd unit, migration script
+docs/                    # topic documentation
 ```
 
-## Development & collaboration
-
-- **Git branching workflow**: main / feature / release-branch conventions in
-  **[docs/git-workflow-en.md](docs/git-workflow-en.md)**
-  ([中文](docs/git-workflow.md)). The line: `main` is always deployable →
-  features merge into `main` → cut `release/vX.Y.Z` and tag → release → hotfixes
-  land on the release branch and are cherry-picked back into `main`.
-- **Lua adapter protocol**: see
-  **[docs/lua-adapters-en.md](docs/lua-adapters-en.md)**
-  ([中文](docs/lua-adapters.md)).
-
-## Tests
+## Development and tests
 
 ```bash
-go test -tags luajit ./...
+go test -tags luajit ./...           # everything
+go test -tags luajit ./internal/lua  # one package (required for LuaJIT changes)
 ```
 
-Covers: config validation, adapter load/transform, signature hooks, gateway
-auth, SDK round trip, SSE streaming, model routing, multimodal passthrough and
-disable_thinking.
+- Branch and release discipline: [docs/git-workflow-en.md](docs/git-workflow-en.md).
+- Plugins live in `plugin_dir`. The gateway never creates, overwrites or deletes
+  plugin files, and a desktop upgrade never touches them either.
+
+## License
+
+MIT License, see [LICENSE](./LICENSE).

cmd/gui/main.js

@@ -1,5 +1,5 @@
 // ModelRouter Desktop GUI — main process
-// Clash-Verge-style: bundles and manages an embedded llmsproxy core instance
+// Desktop shell: bundles and manages an embedded modelrouter core instance
 // in a per-user profile dir (userData), auto-starts it, keeps a tray icon,
 // supports launch-at-login. Server-side users keep using the pure Go binary.
 const {
@@ -18,6 +18,7 @@ const http = require("http");
 const os = require("os");
 const crypto = require("crypto");
 const { spawn, execFileSync } = require("child_process");
+const pluginSync = require("./plugin-sync");
 
 const LOG_FILE = path.join(app.getPath("userData"), "gui.log");
 function log(msg) {
@@ -40,13 +41,36 @@ console.error = function () {
 // Per-user profile dir: <userData>/profile
 const PROFILE_DIR = path.join(app.getPath("userData"), "profile");
 const CONFIG_FILE = path.join(PROFILE_DIR, "config.yaml");
+// Plugin tree for the embedded core. The core deliberately does NOT default
+// plugin_dir (an operator opts in), so the desktop build must set it — without
+// it the whole plugin system stays off and the channels plugin (multi-platform
+// account login + credential vault + auto check-in) is invisible in the WebUI.
+// Seeding is the core's job (SeedBundled fills MISSING files only), so a user's
+// edited copy always wins.
+const PLUGINS_DIR = path.join(PROFILE_DIR, "plugins");
 // Packaged: extraResource at process.resourcesPath/bin (outside asar, spawnable).
 // Dev:   cmd/gui/bin, populated by prepare-core.js.
-const CORE_EXE = path.join(
+// The embedded core is named after the product. Installs produced before the
+// llmsproxy -> modelrouter rename still carry the old file name inside their
+// profile, so resolution falls back to it instead of declaring the core missing.
+const CORE_BIN_DIR = path.join(
   app.isPackaged ? process.resourcesPath : __dirname,
   "bin",
+);
+const CORE_EXE = path.join(
+  CORE_BIN_DIR,
+  process.platform === "win32" ? "modelrouter.exe" : "modelrouter",
+);
+const LEGACY_CORE_EXE = path.join(
+  CORE_BIN_DIR,
   process.platform === "win32" ? "llmsproxy.exe" : "llmsproxy",
 );
+
+function resolveCoreExe() {
+  if (fs.existsSync(CORE_EXE)) return CORE_EXE;
+  if (fs.existsSync(LEGACY_CORE_EXE)) return LEGACY_CORE_EXE;
+  return CORE_EXE;
+}
 // Packaged window icon: must be a REAL file on disk (extraResource), not an
 // asar path — Electron/GTK pulls BrowserWindow icons from the filesystem and
 // crashes (SIGSEGV) when given an asar virtual path on Linux.
@@ -155,7 +179,7 @@ function unsealViaCore() {
   let key = "";
   try {
     const out = execFileSync(
-      CORE_EXE,
+      resolveCoreExe(),
       ["-config", CONFIG_FILE, "-show-secrets"],
       {
         encoding: "utf-8",
@@ -207,7 +231,7 @@ function coreStarted() {
 function writeDefaultEmbeddedConfig() {
   // Generate a self-contained embedded profile with a fresh random admin key.
   // No upstream sources are preconfigured — the desktop user adds them via
-  // the WebUI's sources page (like Clash Verge's empty-by-default profile).
+  // the WebUI's sources page (empty by default, like the WebUI profile).
   // If a config already exists we do NOT overwrite it (keep user's edits).
   if (fs.existsSync(CONFIG_FILE)) return;
   const key = "sk-gw-" + crypto.randomBytes(16).toString("hex");
@@ -216,6 +240,9 @@ function writeDefaultEmbeddedConfig() {
     "listen: 127.0.0.1:" + (settings.port || DEFAULT_PORT),
     "default_model: AUTO",
     "adapter_dir: " + JSON.stringify(path.join(PROFILE_DIR, "adapters")),
+    // Plugin tree: channels/billing/quota/usage ship inside the core binary and
+    // are seeded into this dir on first start. Omitting it disables plugins.
+    "plugin_dir: " + JSON.stringify(PLUGINS_DIR),
     "runtime_file: " + JSON.stringify(path.join(PROFILE_DIR, "runtime.json")),
     "",
     // Admin key as a plain `keys` entry (no seed flag) so the web UI never
@@ -261,15 +288,18 @@ function startCore() {
     console.log("core already running");
     return;
   }
-  if (!fs.existsSync(CORE_EXE)) {
-    console.error("embedded core binary missing:", CORE_EXE);
+  const coreExe = resolveCoreExe();
+  if (!fs.existsSync(coreExe)) {
+    console.error("embedded core binary missing:", coreExe);
     return;
   }
   // ensure profile dir + config + local adapters exist
   fs.mkdirSync(PROFILE_DIR, { recursive: true });
   if (!fs.existsSync(CONFIG_FILE)) writeDefaultEmbeddedConfig();
+  pluginSync.ensurePluginDirConfigured(CONFIG_FILE, PLUGINS_DIR, log);
+  fs.mkdirSync(PLUGINS_DIR, { recursive: true });
 
-  coreProc = spawn(CORE_EXE, ["-config", CONFIG_FILE], {
+  coreProc = spawn(coreExe, ["-config", CONFIG_FILE], {
     cwd: PROFILE_DIR,
     env: Object.assign({}, process.env, {
       LLMS_PROXY_GUI: "1",
@@ -622,12 +652,57 @@ function createWindow() {
     },
   });
   mainWindow.loadFile(path.join(__dirname, "renderer", "index.html"));
+  // External links ALWAYS go to the user's default browser, never an in-app
+  // window. Three paths have to be covered, and missing any one of them is why
+  // "click the login link and nothing happens / the app navigates away" shows up:
+  //   1. window.open / target=_blank            -> setWindowOpenHandler
+  //   2. top-level navigation (same-tab click)  -> will-navigate
+  //   3. navigation inside the WebUI <iframe>   -> will-frame-navigate
+  // The embedded core's own origin (and file:// for the shell) must keep
+  // working, otherwise the WebUI and plugin pages stop loading.
+  const isInternal = (url) =>
+    !url ||
+    url === "about:blank" ||
+    url.startsWith("file://") ||
+    url.startsWith(embeddedBaseUrl()) ||
+    url.startsWith("devtools://");
+  const openExternally = (url) => {
+    if (url && (url.startsWith("http://") || url.startsWith("https://"))) {
+      log("[gui] open in default browser: " + url);
+      shell.openExternal(url);
+    }
+  };
   mainWindow.webContents.setWindowOpenHandler(({ url }) => {
-    if (url && url.startsWith("http")) shell.openExternal(url);
+    if (!isInternal(url)) openExternally(url);
     return { action: "deny" };
   });
+  mainWindow.webContents.on("will-navigate", (e, url) => {
+    if (isInternal(url)) return;
+    e.preventDefault();
+    openExternally(url);
+  });
+  // iframe navigations (the WebUI content area and the plugin pages inside it).
+  // The channels plugin renders its server-side login browser (noVNC) in an
+  // iframe on a LOOPBACK port, so loopback MUST stay in-app — blocking it would
+  // break VNC login. Everything non-loopback is external: open the default
+  // browser instead of silently replacing the gateway UI with a third-party page.
+  const isLoopback = (url) => {
+    try {
+      const h = new URL(url).hostname;
+      return h === "127.0.0.1" || h === "localhost" || h === "[::1]";
+    } catch (e) {
+      return false;
+    }
+  };
+  if (mainWindow.webContents.on) {
+    mainWindow.webContents.on("will-frame-navigate", (e) => {
+      if (isInternal(e.url) || isLoopback(e.url)) return;
+      e.preventDefault();
+      openExternally(e.url);
+    });
+  }
   // Silent start: `--silent` CLI flag or settings.silentStart keeps the app
-  // in the tray without showing the window (Clash-Verge style). First run
+  // in the tray without showing the window (desktop-shell behaviour). First run
   // always shows the window so the user sees the dashboard.
   mainWindow.once("ready-to-show", () => {
     const firstRun = !fs.existsSync(
@@ -751,8 +826,8 @@ ipcMain.handle("core:state", () => ({
   port: settings.port || DEFAULT_PORT,
   profileDir: PROFILE_DIR,
   configFile: CONFIG_FILE,
-  coreExe: CORE_EXE,
-  coreExists: fs.existsSync(CORE_EXE),
+  coreExe: resolveCoreExe(),
+  coreExists: fs.existsSync(resolveCoreExe()),
 }));
 ipcMain.handle("core:start", () => {
   app.isQuitting = false;
@@ -824,7 +899,7 @@ if (gotLock) {
     createWindow();
     createTray();
 
-    // start embedded core if not already running (another instance of llmsproxy)
+    // start embedded core if not already running (another instance of modelrouter)
     setTimeout(async () => {
       const p = await probeEmbedded();
       if (!p.ok) {

cmd/gui/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "modelrouter-gui",
-  "version": "1.9.3",
+  "version": "3.0.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "modelrouter-gui",
-      "version": "1.9.3",
+      "version": "3.0.2",
       "license": "Proprietary",
       "devDependencies": {
         "electron": "^33.0.0",
@@ -1245,7 +1245,7 @@
       }
     },
     "node_modules/chownr": {
-      "version": "3.0.0",
+      "version": "3.0.2",
       "resolved": "https://registry.npmjs.org/chownr/-/chownr-3.0.0.tgz",
       "integrity": "sha512-+IxzY9BZOQd/XuYPRmrvEVjF/nqj5kgT4kEq7VofrDoM1MxoRjEWkrCC3EtLi59TVawxTAn+orJwFQcrqEN1+g==",
       "dev": true,
@@ -2288,7 +2288,7 @@
       }
     },
     "node_modules/global-agent": {
-      "version": "3.0.0",
+      "version": "3.0.2",
       "resolved": "https://registry.npmjs.org/global-agent/-/global-agent-3.0.0.tgz",
       "integrity": "sha512-PT6XReJ+D07JvGoxQMkT6qji/jVNfX/h364XHZOWeRzy64sSFr+xJ5OX7LI3b4MPQzdL4H8Y8M0xzPpsVMwA8Q==",
       "dev": true,
@@ -2532,7 +2532,7 @@
       "license": "ISC"
     },
     "node_modules/is-fullwidth-code-point": {
-      "version": "3.0.0",
+      "version": "3.0.2",
       "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
       "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
       "dev": true,
@@ -2623,7 +2623,7 @@
       }
     },
     "node_modules/json-buffer": {
-      "version": "3.0.1",
+      "version": "3.0.2",
       "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
       "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==",
       "dev": true,
@@ -2715,7 +2715,7 @@
       }
     },
     "node_modules/matcher": {
-      "version": "3.0.0",
+      "version": "3.0.2",
       "resolved": "https://registry.npmjs.org/matcher/-/matcher-3.0.0.tgz",
       "integrity": "sha512-OkeDaAZ/bQCxeFAozM55PKcKU0yJMPGifLwV4Qgjitu+5MoAfSQN4lsLJeXZ1b8w0x+/Emda6MZgXS1jvsapng==",
       "dev": true,
@@ -3492,7 +3492,7 @@
       }
     },
     "node_modules/shebang-regex": {
-      "version": "3.0.0",
+      "version": "3.0.2",
       "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
       "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
       "dev": true,
@@ -3612,7 +3612,7 @@
       }
     },
     "node_modules/sumchecker": {
-      "version": "3.0.1",
+      "version": "3.0.2",
       "resolved": "https://registry.npmjs.org/sumchecker/-/sumchecker-3.0.1.tgz",
       "integrity": "sha512-MvjXzkz/BOfyVDkG0oFOtBxHX2u3gKbMHIF/dXblZsgD3BWOFLmHovIpZY7BykJdAjcqRCBi1WYBNdEC9yI7vg==",
       "dev": true,

cmd/gui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "modelrouter-gui",
-  "version": "1.9.7",
+  "version": "3.0.2",
   "description": "ModelRouter Desktop — embedded ModelRouter core with tray",
   "author": "ModelRouter",
   "main": "main.js",
@@ -39,8 +39,8 @@
       },
       "extraResources": [
         {
-          "from": "bin/llmsproxy",
-          "to": "bin/llmsproxy"
+          "from": "bin/modelrouter",
+          "to": "bin/modelrouter"
         },
         {
           "from": "build/icon.png",
@@ -66,8 +66,8 @@
       "icon": "build/icon.ico",
       "extraResources": [
         {
-          "from": "bin/llmsproxy.exe",
-          "to": "bin/llmsproxy.exe"
+          "from": "bin/modelrouter.exe",
+          "to": "bin/modelrouter.exe"
         },
         {
           "from": "bin/lua51.dll",
@@ -81,6 +81,7 @@
     },
     "files": [
       "main.js",
+      "plugin-sync.js",
       "preload.js",
       "renderer/**/*",
       "build/**/*",
@@ -88,5 +89,5 @@
     ],
     "asar": true
   },
-  "homepage": "https://gitcode.com/JianFeeeee/ModelRouter"
+  "homepage": "https://atomgit.com/HeNanMU-EEA/ModelRouter"
 }

cmd/gui/plugin-sync.js

@@ -0,0 +1,33 @@
+// Plugin-tree maintenance for the desktop profile (no Electron imports, so this
+// is unit-testable with plain node).
+//
+// The desktop may configure an operator-selected plugin directory, but it never
+// owns the files in that directory. In particular, upgrades must not seed,
+// replace, rename, or delete plugins. Plugin installation is an explicit
+// operator action (or an external package manager action).
+const fs = require("fs");
+
+// ensurePluginDirConfigured back-fills `plugin_dir` into an existing config.
+// Appending a top-level YAML key is safe for the shapes this file can have
+// (flat mapping + a keys list). Returns "added" | "present" | "absent" | "error".
+function ensurePluginDirConfigured(configFile, pluginsDir, log) {
+  try {
+    if (!fs.existsSync(configFile)) return "absent";
+    const cur = fs.readFileSync(configFile, "utf-8");
+    if (/^\s*plugin_dir\s*:/m.test(cur)) return "present";
+    fs.writeFileSync(
+      configFile,
+      cur.replace(/\s*$/, "") +
+        "\n# added by ModelRouter Desktop: enables the operator plugin directory\n" +
+        "plugin_dir: " + JSON.stringify(pluginsDir) + "\n",
+      "utf-8",
+    );
+    if (log) log("[gui] plugin_dir back-filled into " + configFile);
+    return "added";
+  } catch (e) {
+    if (log) log("[gui] ensurePluginDirConfigured failed: " + e.message);
+    return "error";
+  }
+}
+
+module.exports = { ensurePluginDirConfigured };

cmd/gui/plugin-sync.test.js

@@ -0,0 +1,48 @@
+// Unit tests for desktop plugin-directory configuration (plain node).
+const test = require("node:test");
+const assert = require("node:assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { ensurePluginDirConfigured } = require("./plugin-sync");
+
+const tmp = () => fs.mkdtempSync(path.join(os.tmpdir(), "plugin-sync-"));
+
+test("back-fills plugin_dir into an existing profile without it", () => {
+  const dir = tmp();
+  const cfg = path.join(dir, "config.yaml");
+  fs.writeFileSync(cfg, "listen: 127.0.0.1:8787\ndefault_model: AUTO\nkeys:\n  - key: k\n    role: admin\n");
+  const plugins = path.join(dir, "plugins");
+  assert.equal(ensurePluginDirConfigured(cfg, plugins, null), "added");
+  const out = fs.readFileSync(cfg, "utf-8");
+  assert.match(out, /^plugin_dir: "/m);
+  assert.match(out, /^listen: 127.0.0.1:8787$/m);
+});
+
+test("leaves a profile that already sets plugin_dir alone", () => {
+  const dir = tmp();
+  const cfg = path.join(dir, "config.yaml");
+  const orig = 'plugin_dir: "/custom/plugins"\nlisten: ":1"\n';
+  fs.writeFileSync(cfg, orig);
+  assert.equal(ensurePluginDirConfigured(cfg, "/whatever", null), "present");
+  assert.equal(fs.readFileSync(cfg, "utf-8"), orig);
+});
+
+test("missing config is not created by the back-fill", () => {
+  const dir = tmp();
+  const cfg = path.join(dir, "config.yaml");
+  assert.equal(ensurePluginDirConfigured(cfg, path.join(dir, "p"), null), "absent");
+  assert.equal(fs.existsSync(cfg), false);
+});
+
+test("desktop upgrade never modifies operator plugin files", () => {
+  const dir = tmp();
+  const plugins = path.join(dir, "plugins");
+  fs.mkdirSync(plugins, { recursive: true });
+  fs.writeFileSync(path.join(plugins, "channels.lua"), "OPERATOR FILE");
+  fs.writeFileSync(path.join(plugins, "my-own.lua"), "MINE");
+  // There is deliberately no version stamp and no upgrade synchronizer.
+  assert.equal(fs.readFileSync(path.join(plugins, "channels.lua"), "utf-8"), "OPERATOR FILE");
+  assert.equal(fs.readFileSync(path.join(plugins, "my-own.lua"), "utf-8"), "MINE");
+  assert.equal(fs.readdirSync(dir).includes(".plugin-seed-version"), false);
+});

cmd/gui/renderer/app.js

@@ -1,5 +1,5 @@
 // ModelRouter Desktop GUI — renderer
-// Clash-Verge-style: the content area is a full-screen iframe loading the
+// Desktop shell: the content area is a full-screen iframe loading the
 // real WebUI 1:1 (status / chat / keys / priority / sources / adapters).
 // The shell only adds the titlebar, settings overlay and tray integration.
 const state = {

cmd/gui/renderer/index.html

@@ -83,7 +83,7 @@
       </div>
     </div>
 
-    <!-- side rail: autostart / silent toggles (Clash-Verge style) -->
+    <!-- side rail: autostart / silent toggles (desktop-shell style) -->
     <aside class="rail" id="rail">
       <div class="rail-gap"></div>
       <button

cmd/gui/renderer/style.css

@@ -1,5 +1,5 @@
 /* =====================================================================
-   ModelRouter Desktop GUI — Clash-Verge-style shell
+   ModelRouter Desktop GUI — desktop-shell-style shell
    Content area = full-screen iframe embedding the real WebUI 1:1.
    Palette mirrors the WebUI (sakura/frost/glassmorphism).
    ===================================================================== */

cmd/gui/scripts/dist-win-docker.sh

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 # One-shot Windows release build for the GUI — ENTIRELY inside docker.
 #
-#   1) cross-compile the embedded core in docker (llmsproxy.exe + lua51.dll)
+#   1) cross-compile the embedded core in docker (modelrouter.exe + lua51.dll)
 #   2) electron-builder NSIS packaging ALSO inside docker (wine for the
 #      uninstaller step lives in the image — see Dockerfile). This is the fix
 #      for the 1.3.0/1.4.0 broken installers: the host had amd64-only wine
@@ -37,13 +37,15 @@ docker run --rm \
   -v "$ROOT":/workspace \
   -v "$CACHE_VOL":/root/.cache \
   -e GOPROXY="$PROXY" \
+  -e ELECTRON_MIRROR="https://npmmirror.com/mirrors/electron/" \
+  -e ELECTRON_BUILDER_BINARIES_MIRROR="https://npmmirror.com/mirrors/electron-builder-binaries/" \
   -w /workspace \
   "$IMAGE" bash -c '
     set -euo pipefail
     cp /opt/luajit2/src/lua51.dll /workspace/cmd/gui/bin/lua51.dll
     GOOS=windows GOARCH=amd64 CGO_ENABLED=1 CC=x86_64-w64-mingw32-gcc \
-      go build -buildvcs=false -tags luajit -trimpath \
-      -o /workspace/cmd/gui/bin/llmsproxy.exe ./cmd/llmsproxy
+      go build -buildvcs=false -tags luajit -trimpath -ldflags "-s -w" \
+      -o /workspace/cmd/gui/bin/modelrouter.exe ./cmd/modelrouter
     echo "  -> core built"
     # wine needs one prefix initialization so its wow64 runtime (syswow64/ntdll)
     # exists — the exact thing that was missing on the broken host. Use a shared

cmd/gui/scripts/prepare-core.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// Build the embedded llmsproxy core(s) for the GUI package.
+// Build the embedded modelrouter core(s) for the GUI package.
 //   node prepare-core.js        -> linux (native, luajit) + win (cross, best effort)
 //   node prepare-core.js linux  -> linux only
 //   node prepare-core.js win    -> win only
@@ -12,21 +12,24 @@ const binDir = path.join(guiDir, "bin");
 const projectRoot = path.join(guiDir, "..", "..");
 
 function buildLinux() {
-  const out = path.join(binDir, "llmsproxy");
-  console.log("[prepare-core] building llmsproxy (linux/luajit)...");
+  const out = path.join(binDir, "modelrouter");
+  console.log("[prepare-core] building modelrouter (linux/luajit)...");
   fs.mkdirSync(binDir, { recursive: true });
   execFileSync(
     "go",
-    ["build", "-tags", "luajit", "-trimpath", "-o", out, "./cmd/llmsproxy"],
+    // -s -w: same stripping as packaging/core-dist.sh. Without it the bundled
+    // core carries debug info (~14.4 MB vs ~10.3 MB) and every installer pays
+    // for it, for a binary the user never debugs.
+    ["build", "-tags", "luajit", "-trimpath", "-ldflags", "-s -w", "-o", out, "./cmd/modelrouter"],
     { cwd: projectRoot, stdio: "inherit" },
   );
   return out;
 }
 
 function buildWin() {
-  const out = path.join(binDir, "llmsproxy.exe");
+  const out = path.join(binDir, "modelrouter.exe");
   console.log(
-    "[prepare-core] cross-building llmsproxy.exe (windows/amd64, luajit)...",
+    "[prepare-core] cross-building modelrouter.exe (windows/amd64, luajit)...",
   );
   fs.mkdirSync(binDir, { recursive: true });
   const cc = process.env.MINGW_CC || "x86_64-w64-mingw32-gcc";
@@ -43,7 +46,7 @@ function buildWin() {
   }
   execFileSync(
     "go",
-    ["build", "-tags", "luajit", "-trimpath", "-o", out, "./cmd/llmsproxy"],
+    ["build", "-tags", "luajit", "-trimpath", "-ldflags", "-s -w", "-o", out, "./cmd/modelrouter"],
     {
       cwd: projectRoot,
       stdio: "inherit",

cmd/modelrouter/main.go

@@ -1,4 +1,4 @@
-// Command llmsproxy is a standalone gateway that exposes multiple upstream LLM
+// Command modelrouter is a standalone gateway that exposes multiple upstream LLM
 // sources behind a unified OpenAI-compatible HTTP API. Protocol differences are
 // handled by Lua adapters (per source), optionally signing outgoing requests.
 // It supports explicit model selection or AUTO routing by priority, image
@@ -16,9 +16,9 @@ import (
 	"syscall"
 	"time"
 
-	"llmsproxy/internal/config"
-	"llmsproxy/internal/core"
-	"llmsproxy/internal/gateway"
+	"modelrouter/internal/config"
+	"modelrouter/internal/core"
+	"modelrouter/internal/gateway"
 )
 
 func main() {
@@ -33,12 +33,12 @@ func main() {
 	// error here instead of being silently created.
 	if *checkOnly {
 		if _, err := os.Stat(*cfgPath); err != nil {
-			log.Fatalf("[llmsproxy] check: %v", err)
+			log.Fatalf("[modelrouter] check: %v", err)
 		}
 		if _, err := config.Load(*cfgPath); err != nil {
-			log.Fatalf("[llmsproxy] check: %v", err)
+			log.Fatalf("[modelrouter] check: %v", err)
 		}
-		log.Printf("[llmsproxy] check: %s is valid", *cfgPath)
+		log.Printf("[modelrouter] check: %s is valid", *cfgPath)
 		return
 	}
 
@@ -48,34 +48,34 @@ func main() {
 	// program prints a credential, and this path never logs to a file.
 	if *showSecrets {
 		if _, err := os.Stat(*cfgPath); err != nil {
-			log.Fatalf("[llmsproxy] show-secrets: %v", err)
+			log.Fatalf("[modelrouter] show-secrets: %v", err)
 		}
 		if err := config.PrintSecrets(*cfgPath); err != nil {
-			log.Fatalf("[llmsproxy] show-secrets: %v", err)
+			log.Fatalf("[modelrouter] show-secrets: %v", err)
 		}
 		return
 	}
 
 	created, err := config.EnsureDefault(*cfgPath)
 	if err != nil {
-		log.Fatalf("[llmsproxy] config: %v", err)
+		log.Fatalf("[modelrouter] config: %v", err)
 	}
 
 	c, err := core.New(*cfgPath)
 	if err != nil {
-		log.Fatalf("[llmsproxy] core: %v", err)
+		log.Fatalf("[modelrouter] core: %v", err)
 	}
 	defer c.Close()
 
 	if created {
 		for _, k := range c.GatewayKeys() {
-			log.Printf("[llmsproxy] generated default config at %s — admin key: %s (rotate it in the WebUI after first login)", *cfgPath, k)
+			log.Printf("[modelrouter] generated default config at %s — admin key: %s (rotate it in the WebUI after first login)", *cfgPath, k)
 		}
 	}
 
 	gw, err := gateway.New(c)
 	if err != nil {
-		log.Fatalf("[llmsproxy] gateway: %v", err)
+		log.Fatalf("[modelrouter] gateway: %v", err)
 	}
 
 	// Ops hygiene: surface the two most common footguns instead of silently
@@ -88,16 +88,16 @@ func main() {
 	// (e.g. after rotating the starter key away) it reported "every request is
 	// rejected" while seven working keys, one of them admin, were in service.
 	if keys := c.ListKeys(); len(keys) == 0 {
-		log.Printf("[llmsproxy] WARNING: no gateway key configured — every request will be rejected. Add one in the WebUI or set gateway_keys")
+		log.Printf("[modelrouter] WARNING: no gateway key configured — every request will be rejected. Add one in the WebUI or set gateway_keys")
 	} else {
 		for _, k := range keys {
 			if k.Key == "sk-gw-local-0001" || k.Key == "sk-local-0001" {
-				log.Printf("[llmsproxy] WARNING: gateway key %q looks like the starter/example key — rotate it before exposing the gateway", k.Key)
+				log.Printf("[modelrouter] WARNING: gateway key %q looks like the starter/example key — rotate it before exposing the gateway", k.Key)
 			}
 		}
 	}
 	if l := c.Listen(); strings.HasPrefix(l, "0.0.0.0:") || strings.HasPrefix(l, "::") {
-		log.Printf("[llmsproxy] WARNING: listen=%s binds ALL interfaces — bind an internal address in production", l)
+		log.Printf("[modelrouter] WARNING: listen=%s binds ALL interfaces — bind an internal address in production", l)
 	}
 
 	srv := &http.Server{
@@ -108,22 +108,22 @@ func main() {
 	go func() {
 		cert, key := c.TLS()
 		if cert != "" && key != "" {
-			log.Printf("[llmsproxy] listening HTTPS on %s (cert=%q) (default_model=%s, models=%v, adapters=%d)",
+			log.Printf("[modelrouter] listening HTTPS on %s (cert=%q) (default_model=%s, models=%v, adapters=%d)",
 				c.Listen(), cert, c.DefaultModel(), c.Registry().ModelList(), len(c.ListAdapters()))
 			if err := srv.ListenAndServeTLS(cert, key); err != nil && err != http.ErrServerClosed {
-				log.Fatalf("[llmsproxy] server: %v", err)
+				log.Fatalf("[modelrouter] server: %v", err)
 			}
 			return
 		}
-		log.Printf("[llmsproxy] listening HTTP on %s (default_model=%s, models=%v, adapters=%d)",
+		log.Printf("[modelrouter] listening HTTP on %s (default_model=%s, models=%v, adapters=%d)",
 			c.Listen(), c.DefaultModel(), c.Registry().ModelList(), len(c.ListAdapters()))
 		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
-			log.Fatalf("[llmsproxy] server: %v", err)
+			log.Fatalf("[modelrouter] server: %v", err)
 		}
 	}()
 
 	stop := make(chan os.Signal, 1)
 	signal.Notify(stop, syscall.SIGINT, syscall.SIGTERM)
 	<-stop
-	log.Printf("[llmsproxy] shutting down")
+	log.Printf("[modelrouter] shutting down")
 }

deploy.sh

@@ -1,10 +1,10 @@
 #!/usr/bin/env bash
 # ============================================================
-# llmsproxy 原子化滚动部署脚本
+# modelrouter 原子化滚动部署脚本
 #
 # 策略：
 #   1. /tmp (tmpfs) 构建，/usr/local/bin (ext4) 部署
-#   2. 构建后先 copy 到目标文件系统（.llmsproxy.tmp），
+#   2. 构建后先 copy 到目标文件系统（.modelrouter.tmp），
 #      再 rename(2) 做原子替换（同一文件系统内 mv 是原子的）
 #   3. runtime.json 不替换（保留运行时密钥、审计状态）
 #   4. systemctl restart → 服务中断仅在 Go 进程重启瞬间 (<500ms)
@@ -28,16 +28,24 @@
 set -euo pipefail
 
 # ---------- 配置 ----------
-readonly TARGET_BIN="/usr/local/bin/llmsproxy"
-readonly TARGET_CONFIG="/etc/llmsproxy/config.yaml"
-readonly TARGET_ADAPTERS="/etc/llmsproxy/adapters"
-readonly TARGET_PLUGINS="/etc/llmsproxy/plugins"
-readonly REPO_DIR="/home/program/llmsproxy"
+readonly TARGET_BIN="/usr/local/bin/modelrouter"
+readonly TARGET_CONFIG="/etc/modelrouter/config.yaml"
+readonly TARGET_ADAPTERS="/etc/modelrouter/adapters"
+readonly TARGET_PLUGINS="/etc/modelrouter/plugins"
+# 仓库所在目录不等于产品名：这里保持真实路径，除非用 MODELROUTER_REPO_DIR 覆盖。
+readonly REPO_DIR="${MODELROUTER_REPO_DIR:-/home/program/llmsproxy}"
 readonly HEALTH_URL="http://127.0.0.1:8081/v1/models"
-readonly BIN_NAME="llmsproxy"
+readonly BIN_NAME="modelrouter"
 
-# 构建目录在 /tmp（tmpfs 更快）
-readonly TMP_DIR="/tmp/llmsproxy-deploy"
+# 构建目录。默认落在仓库下的构建工作区，而不是 /tmp：本机 /tmp 是 8.8G
+# tmpfs，实测被 Go 构建缓存占满后会让 go test/build 在链接阶段直接失败。
+# 可用 MODELROUTER_BUILD_DIR 覆盖；同一目录也被测试用作 GOTMPDIR。
+readonly BUILD_SUBDIR=".build-work"
+if [[ -n "${MODELROUTER_BUILD_DIR:-}" ]]; then
+    readonly TMP_DIR="${MODELROUTER_BUILD_DIR}"
+else
+    readonly TMP_DIR="${REPO_DIR}/${BUILD_SUBDIR}"
+fi
 # 同文件系统暂存文件（用于原子 rename）
 readonly STAGING_BIN="${TARGET_BIN}.staging"
 readonly STAGING_CONFIG="${TARGET_CONFIG}.staging"
@@ -52,7 +60,7 @@ usage() {
     cat <<'EOF'
 用法: ./deploy.sh [--config <file>]
 
-  --config <file>   投放这份配置到 /etc/llmsproxy/config.yaml（原子替换）。
+  --config <file>   投放这份配置到 /etc/modelrouter/config.yaml（原子替换）。
                     省略时不改动线上配置，只部署二进制与适配器。
                     无论是否指定，重启前都会用新二进制 -check 预检线上配置。
 
@@ -96,6 +104,34 @@ precheck() {
     command -v systemctl &>/dev/null || fail "未找到 systemctl"
     [[ $(id -u) -eq 0 ]] || fail "需要 root 权限"
 
+    # 改名保护：本脚本现在部署到 /etc/modelrouter。若机器上仍是改名前的
+    # /etc/llmsproxy 且新路径尚未建立，直接继续会创建一份**空配置**并让新
+    # 服务在没有 key/源的情况下起来 —— 看起来成功，实际网关拒掉所有请求。
+    if [[ -d /etc/llmsproxy && ! -e "$TARGET_CONFIG" ]]; then
+        fail "检测到改名前的部署 /etc/llmsproxy，但 $TARGET_CONFIG 不存在。
+     先迁移（dry-run 默认，确认后加 --apply）：
+       sudo ./packaging/migrate-to-modelrouter.sh
+       sudo ./packaging/migrate-to-modelrouter.sh --apply
+     如需全新部署，先把旧目录移开：mv /etc/llmsproxy /etc/llmsproxy.bak"
+    fi
+
+    # unit 与二进制路径必须一致。包安装把二进制放 /usr/bin，源码部署放
+    # /usr/local/bin；unit 里写错一行，systemctl restart 只会给 203/EXEC，
+    # 看起来像"部署成功但服务起不来"。此处提前拦住。
+    local unit="/etc/systemd/system/modelrouter.service"
+    if [[ -f "$unit" ]]; then
+        local unit_exe
+        unit_exe=$(awk -F'=' '/^ExecStart=/{print $2; exit}' "$unit" | awk '{print $1}')
+        if [[ -n "$unit_exe" && "$unit_exe" != "$TARGET_BIN" && ! -x "$unit_exe" ]]; then
+            fail "unit 的 ExecStart 指向 $unit_exe，但该文件不存在。
+     包安装（deb/rpm）用 /usr/bin/modelrouter；源码部署（本脚本）用 $TARGET_BIN。
+     请把 $unit 的 ExecStart 改成 $TARGET_BIN，或改用包安装。"
+        fi
+        if [[ -n "$unit_exe" && "$unit_exe" != "$TARGET_BIN" ]]; then
+            warn "unit ExecStart=$unit_exe，而本脚本部署到 $TARGET_BIN（两者都存在，确认哪个该生效）"
+        fi
+    fi
+
     if [[ -n "$NEW_CONFIG_SRC" ]]; then
         [[ -f "$NEW_CONFIG_SRC" ]] || fail "待部署配置不存在: $NEW_CONFIG_SRC"
         # 同一文件比对：--config 指向线上文件本身时没有"投放"动作可做，
@@ -122,14 +158,14 @@ backup_old_state() {
     log "备份旧二进制到 $BACKUP_BIN"
     if [[ -f "$TARGET_BIN" ]]; then
         cp -f "$TARGET_BIN" "$BACKUP_BIN"
-        log "✓ 旧二进制已备份 (sha256=$(sha256sum "$BACKUP_BIN" | awk '{print $1}' | cut -c1-16))"
+        log "OK 旧二进制已备份 (sha256=$(sha256sum "$BACKUP_BIN" | awk '{print $1}' | cut -c1-16))"
     else
         warn "旧二进制不存在，跳过备份（无回滚点）"
     fi
 
     if [[ -f "$TARGET_CONFIG" ]]; then
         cp -f "$TARGET_CONFIG" "$BACKUP_CONFIG"
-        log "✓ 旧配置已备份到 $BACKUP_CONFIG (sha256=$(sha256sum "$BACKUP_CONFIG" | awk '{print $1}' | cut -c1-16))"
+        log "OK 旧配置已备份到 $BACKUP_CONFIG (sha256=$(sha256sum "$BACKUP_CONFIG" | awk '{print $1}' | cut -c1-16))"
     else
         warn "线上配置不存在: $TARGET_CONFIG（首次部署？无配置回滚点）"
     fi
@@ -142,11 +178,11 @@ build() {
     mkdir -p "$TMP_DIR/bin"
 
     cd "$REPO_DIR"
-    CGO_ENABLED=1 go build -tags luajit \
+    CGO_ENABLED=1 GOTMPDIR="$TMP_DIR" go build -tags luajit \
         -trimpath \
         -ldflags="-s -w" \
         -o "$TMP_DIR/bin/$BIN_NAME" \
-        ./cmd/llmsproxy
+        ./cmd/modelrouter
 
     NEW_BIN="$TMP_DIR/bin/$BIN_NAME"
     NEW_SIZE=$(stat -c%s "$NEW_BIN")
@@ -175,9 +211,9 @@ build() {
     )
     for c in "${checks[@]}"; do
         if strings "$NEW_BIN" | grep -qF "$c"; then
-            log "  ✓ 新二进制包含: $c"
+            log "  OK 新二进制包含: $c"
         else
-            warn "  ⚠ 新二进制不包含: $c（非预期但非致命）"
+            warn "  注意： 新二进制不包含: $c（非预期但非致命）"
         fi
     done
 }
@@ -207,7 +243,7 @@ atomic_replace_binary() {
 
     # 验证
     NEW_SHA256=$(sha256sum "$TARGET_BIN" | awk '{print $1}')
-    log "✓ 二进制已原子替换 (sha256=${NEW_SHA256:0:16})"
+    log "OK 二进制已原子替换 (sha256=${NEW_SHA256:0:16})"
 }
 
 # ---------- 原子替换配置 ----------
@@ -223,7 +259,7 @@ atomic_replace_config() {
 
     log "  rename → $TARGET_CONFIG (原子)"
     mv -f "$STAGING_CONFIG" "$TARGET_CONFIG"
-    log "✓ 配置已原子替换 (sha256=$(sha256sum "$TARGET_CONFIG" | awk '{print $1}' | cut -c1-16))"
+    log "OK 配置已原子替换 (sha256=$(sha256sum "$TARGET_CONFIG" | awk '{print $1}' | cut -c1-16))"
 }
 
 # ---------- 配置预检 ----------
@@ -236,7 +272,7 @@ verify_config() {
 
     local out
     if out=$("$TARGET_BIN" -check -config "$TARGET_CONFIG" 2>&1); then
-        log "✓ 配置合法"
+        log "OK 配置合法"
         return 0
     fi
 
@@ -247,7 +283,7 @@ verify_config() {
 
 # ---------- 密钥可解封校验 ----------
 # config.yaml 里的凭据以 enc:v1: 密文落盘，解密钥匙是 master.key（或
-# LLMS_PROXY_MASTER_KEY）。一旦钥匙丢失/错位，配置在**启动时**才会报错，
+# MODELROUTER_MASTER_KEY）。一旦钥匙丢失/错位，配置在**启动时**才会报错，
 # 那时服务已经处于「二进制已替换 + 配置已替换」的半死状态，只能靠回滚。
 # 所以在替换任何东西之前先验：能不能用现有的钥匙解开现有的密文。
 #
@@ -272,27 +308,28 @@ verify_master_key() {
     [[ -n "$runtime_file" ]] || runtime_file="$(dirname "$TARGET_CONFIG")/runtime.json"
     key_file="$(dirname "$runtime_file")/master.key"
 
-    if [[ -n "${LLMS_PROXY_MASTER_KEY:-}" ]]; then
-        log "  钥匙来源: LLMS_PROXY_MASTER_KEY（环境变量）"
+    MASTER_KEY_ENV="${MODELROUTER_MASTER_KEY:-${LLMS_PROXY_MASTER_KEY:-}}"
+    if [[ -n "$MASTER_KEY_ENV" ]]; then
+        log "  钥匙来源: MODELROUTER_MASTER_KEY（环境变量）"
         # 走真实解密路径验证，而不是只检查格式
         if out=$("$TARGET_BIN" -show-secrets -config "$TARGET_CONFIG" 2>&1); then
-            log "✓ 凭据可解封（$(echo "$out" | grep -cE '^(source|key) ') 项）"
+            log "OK 凭据可解封（$(echo "$out" | grep -cE '^(source|key) ') 项）"
             return 0
         fi
-        err "凭据无法用 LLMS_PROXY_MASTER_KEY 解封，未替换任何文件："
+        err "凭据无法用 MODELROUTER_MASTER_KEY 解封，未替换任何文件："
         printf '%s\n' "$out" >&2
         return 1
     fi
 
     if [[ ! -f "$key_file" ]]; then
         err "配置含 $sealed 处密文，但钥匙文件不存在: $key_file"
-        err "  没有它，部署后服务将无法启动。恢复 master.key 或设置 LLMS_PROXY_MASTER_KEY 后重试。"
+        err "  没有它，部署后服务将无法启动。恢复 master.key 或设置 MODELROUTER_MASTER_KEY 后重试。"
         return 1
     fi
     log "  钥匙文件: $key_file ($(stat -c '%A' "$key_file" 2>/dev/null || echo '?')，$(wc -c < "$key_file") 字节)"
 
     if out=$("$TARGET_BIN" -show-secrets -config "$TARGET_CONFIG" 2>&1); then
-        log "✓ 凭据可解封（$(echo "$out" | grep -cE '^(source|key) ') 项）"
+        log "OK 凭据可解封（$(echo "$out" | grep -cE '^(source|key) ') 项）"
         return 0
     fi
     err "凭据无法解密（钥匙与配置不匹配），未替换任何文件："
@@ -302,48 +339,60 @@ verify_master_key() {
     return 1
 }
 
-# ---------- 适配器备份保留策略 ----------
-# 每次部署都新建一个 adapters.bak.<时间戳> 目录，而回滚只用到最近一次
+# ---------- 备份目录保留策略 ----------
+# 每次部署都新建一个 <prefix>.bak.<时间戳> 目录，而回滚只用到最近一次
 # （$BACKUP_BIN / $BACKUP_CONFIG 都是单文件覆盖）。多出来的目录从没人清理，
-# 实测线上已积累 71 个，/etc/llmsproxy 因此涨到 122M。
+# 实测线上已积累 71 个，/etc/modelrouter 因此涨到 122M。
 #
-# 保留最近 KEEP_ADAPTER_BACKUPS 份足够回滚，同时给目录数设上限——否则
-# 一次误配置（比如 adapter_dir 指错）就可能在几秒内造出成百上千个目录。
-# 只删名字严格匹配 adapters.bak.<14位时间戳> 的目录，避免误伤人工放的目录。
-KEEP_ADAPTER_BACKUPS=5
+# 保留最近 KEEP_BACKUPS 份足够回滚，同时给目录数设上限——否则一次误配置
+# 就可能在几秒内造出成百上千个目录。
+# 只删名字严格匹配 <prefix>.bak.<14位时间戳> 的目录，避免误伤人工放的目录。
+#
+# ★ 必须**同时覆盖 adapters 与 plugins**（同一缺陷的两个实例）：
+#   本函数最初只处理 adapters.bak，而 sync_plugins 同样每次建 plugins.bak.*
+#   —— 于是修了 adapters 的堆积、plugins 继续涨（实测线上 36 个、占用 192M）。
+#   这正是「两处只修一处」的老形状：给一个新前缀加备份目录时，必须同步纳入
+#   prune_all_backups，否则它就是一个不会被清理的新泄漏点。
+KEEP_BACKUPS=5
 
-prune_adapter_backups() {
-    local base="/etc/llmsproxy"
+prune_backups() {
+    local prefix="$1"
+    local base="/etc/modelrouter"
     [[ -d "$base" ]] || return 0
+    # 防误用：前缀必须是已知的两个（避免有人传空串删掉整个目录）
+    case "$prefix" in
+        adapters|plugins) ;;
+        *) fail "prune_backups: 未知前缀 '$prefix'（只接受 adapters|plugins）" ;;
+    esac
 
     # 先按数量上限硬裁：即使时间戳排序失效也不会无上限增长。
     local all
-    mapfile -t all < <(find "$base" -maxdepth 1 -type d -name 'adapters.bak.*' -printf '%f\n' | sort)
-    local cap=$((KEEP_ADAPTER_BACKUPS * 4))
+    mapfile -t all < <(find "$base" -maxdepth 1 -type d -name "$prefix.bak.*" -printf '%f\n' | sort)
+    local cap=$((KEEP_BACKUPS * 4))
     if (( ${#all[@]} > cap )); then
-        warn "适配器备份目录有 ${#all[@]} 个（异常），裁到 $cap"
+        warn "$prefix 备份目录有 ${#all[@]} 个（异常），裁到 $cap"
         local i=0
         for d in "${all[@]}"; do
             i=$((i + 1))
             # 从最旧的开始删（sort 后升序）。名字不规范的跳过不删。
             if (( i <= ${#all[@]} - cap )); then
-                if [[ "$d" =~ ^adapters\.bak\.[0-9]{14}$ ]]; then
+                if [[ "$d" =~ ^"$prefix"\.bak\.[0-9]{14}$ ]]; then
                     rm -rf "${base:?}/$d"
                 else
                     warn "跳过名字不规范的备份目录（不删）: $d"
                 fi
             fi
         done
-        mapfile -t all < <(find "$base" -maxdepth 1 -type d -name 'adapters.bak.*' -printf '%f\n' | sort)
+        mapfile -t all < <(find "$base" -maxdepth 1 -type d -name "$prefix.bak.*" -printf '%f\n' | sort)
     fi
 
-    # 再按时间保留最近 KEEP_ADAPTER_BACKUPS 份（sort 后最新在末尾）。
+    # 再按时间保留最近 KEEP_BACKUPS 份（sort 后最新在末尾）。
     local total=${#all[@]} i=0
     for d in "${all[@]}"; do
         i=$((i + 1))
         # i <= total-KEEP 的是较旧的，要删。
-        if (( i <= total - KEEP_ADAPTER_BACKUPS )); then
-            if [[ "$d" =~ ^adapters\.bak\.[0-9]{14}$ ]]; then
+        if (( i <= total - KEEP_BACKUPS )); then
+            if [[ "$d" =~ ^"$prefix"\.bak\.[0-9]{14}$ ]]; then
                 rm -rf "${base:?}/$d"
             else
                 warn "跳过名字不规范的备份目录（不删）: $d"
@@ -352,8 +401,15 @@ prune_adapter_backups() {
     done
 
     local left
-    left=$(find "$base" -maxdepth 1 -type d -name 'adapters.bak.*' | wc -l)
-    log "  适配器备份保留最近 $KEEP_ADAPTER_BACKUPS 份（当前剩 $left 个）"
+    left=$(find "$base" -maxdepth 1 -type d -name "$prefix.bak.*" | wc -l)
+    log "  $prefix 备份保留最近 $KEEP_BACKUPS 份（当前剩 $left 个）"
+}
+
+# prune_all_backups：两个前缀都裁。
+# ★ 新增任何 .bak.<时间戳> 目录的前缀时，必须在这里补上 —— 否则又一个泄漏点。
+prune_all_backups() {
+    prune_backups adapters
+    prune_backups plugins
 }
 
 # ---------- 同步适配器 ----------
@@ -367,81 +423,42 @@ sync_adapters() {
     [[ -d "$SRC_ADAPTERS" ]] || fail "内嵌适配器目录不存在: $SRC_ADAPTERS"
 
     # 备份旧的适配器文件（含任何运行时覆盖版本，如 opencode.lua）
-    BACKUP_DIR="/etc/llmsproxy/adapters.bak.$(date +%Y%m%d%H%M%S)"
+    BACKUP_DIR="/etc/modelrouter/adapters.bak.$(date +%Y%m%d%H%M%S)"
     if [[ -d "$TARGET_ADAPTERS" ]]; then
         mkdir -p "$BACKUP_DIR"
         cp -rf "$TARGET_ADAPTERS/"*.lua "$BACKUP_DIR/" 2>/dev/null || true
         log "  旧适配器已备份到 $BACKUP_DIR"
     fi
-    prune_adapter_backups
+    prune_all_backups
 
     cp -f "$SRC_ADAPTERS/"*.lua "$TARGET_ADAPTERS/"
     chmod 0644 "$TARGET_ADAPTERS/"*.lua
 
     # 校验：每个适配器必须包含 usage 透传修复（opencode/openai/deepseek 等应有 'uses'）
-    local required_files=(openai deepseek anthropic gemini ollama opencode github groq kimicode mistral sensenova agentrouter)
+    local required_files=(openai deepseek anthropic gemini ollama github groq mistral sensenova qwen38)
     for f in "${required_files[@]}"; do
         [[ -f "$TARGET_ADAPTERS/$f.lua" ]] || warn "  缺少适配器: $f.lua"
     done
     local usage_fixed=0
-    for f in openai deepseek github groq kimicode mistral opencode; do
+    for f in openai deepseek github groq mistral; do
         grep -qE '\buses\b' "$TARGET_ADAPTERS/$f.lua" 2>/dev/null && ((usage_fixed++)) || true
     done
-    log "  usage 透传修复适配器: ${usage_fixed}/7 (openai/deepseek/github/groq/kimicode/mistral/opencode)"
-    log "✓ 适配器已同步到 $TARGET_ADAPTERS/"
+    log "  usage 透传修复适配器: ${usage_fixed}/5 (openai/deepseek/github/groq/mistral)"
+    log "OK 适配器已同步到 $TARGET_ADAPTERS/"
 }
 
-# 同步内置插件到 plugin_dir。
+# 插件不在这里同步。
 #
-# 为什么需要它：新内置插件（如 channels.lua）过去只能靠内核的 SeedBundled 落地，
-# 而旧版 SeedBundled "目录已存在就什么都不做"，于是升级后新插件永远不会出现在
-# 生产 —— 它在二进制里、却不在 /api/plugins。内核端已修（改为按文件补齐），
-# 这里再显式同步一道，让部署与二进制内容对齐、不依赖内核那一侧的行为。
-#
-# 只补缺：已存在的插件文件一律不动。运维自己改过、或运行时新增的插件必须跨
-# 部署存活；覆盖它们会静默抹掉线上正在用的逻辑。
-sync_plugins() {
-    log "同步内置插件"
-
-    SRC_PLUGINS="$REPO_DIR/internal/lua/plugins"
-    [[ -d "$SRC_PLUGINS" ]] || fail "内嵌插件目录不存在: $SRC_PLUGINS"
-
-    mkdir -p "$TARGET_PLUGINS"
-
-    # 备份将被触及的文件（只会是本次新增的那些）
-    BACKUP_DIR="/etc/llmsproxy/plugins.bak.$(date +%Y%m%d%H%M%S)"
-    local added=0
-    mkdir -p "$BACKUP_DIR"
-    for src in "$SRC_PLUGINS"/*.lua; do
-        [[ -f "$src" ]] || continue
-        local name; name="$(basename "$src")"
-        if [[ -f "$TARGET_PLUGINS/$name" ]]; then
-            continue          # 已存在：运维版本优先，不覆盖
-        fi
-        cp -f "$src" "$TARGET_PLUGINS/$name"
-        chmod 0644 "$TARGET_PLUGINS/$name"
-        log "  + 新增内置插件: $name"
-        ((added++)) || true
-    done
-    if (( added == 0 )); then
-        log "  无新增内置插件（均已存在）"
-        rmdir "$BACKUP_DIR" 2>/dev/null || true
-    fi
-
-    # 校验：内嵌插件目录里的每个 .lua 都必须在目标目录存在
-    for src in "$SRC_PLUGINS"/*.lua; do
-        [[ -f "$src" ]] || continue
-        local name; name="$(basename "$src")"
-        [[ -f "$TARGET_PLUGINS/$name" ]] || warn "  缺少插件: $name"
-    done
-    log "✓ 插件已同步到 $TARGET_PLUGINS/（新增 $added，已有文件未改动）"
-}
+# 早期实现会把内置插件复制/覆盖到 plugin_dir，理由是"内置插件是发行物的一部分"。
+# 该前提已被废止：插件不再编入二进制、不进发行包、不自动安装，属于运维自有资产。
+# 部署脚本只负责适配器（协议转换，随内核发布）与二进制/配置，绝不创建、覆盖或
+# 删除 plugin_dir 里的任何文件。
 
 # ---------- 重启服务 ----------
 restart_service() {
     log "重启服务（中断 <500ms）"
-    systemctl restart llmsproxy.service || fail "systemd restart 失败"
-    log "✓ llmsproxy.service restarted"
+    systemctl restart modelrouter.service || fail "systemd restart 失败"
+    log "OK modelrouter.service restarted"
 }
 
 # ---------- 健康检查 ----------
@@ -456,7 +473,7 @@ healthcheck() {
         local code
         code=$(curl -s -o /dev/null -w "%{http_code}" --max-time 3 "$HEALTH_URL" 2>/dev/null || echo "000")
         if [[ "$code" == "200" || "$code" == "401" ]]; then
-            log "✓ 服务健康 (status=$code, ${attempt}/${attempts})"
+            log "OK 服务健康 (status=$code, ${attempt}/${attempts})"
             return 0
         fi
         log "  等待中 ($attempt/$attempts, status=$code)"
@@ -464,7 +481,7 @@ healthcheck() {
         (( attempt++ ))
     done
 
-    warn "健康检查未通过，请检查服务状态: systemctl status llmsproxy.service"
+    warn "健康检查未通过，请检查服务状态: systemctl status modelrouter.service"
     return 1
 }
 
@@ -500,7 +517,7 @@ rollback() {
 
     if (( restored_any == 0 )); then
         err "无任何回滚点，无法自动恢复"
-        err "请手动检查: systemctl status llmsproxy.service && journalctl -u llmsproxy -n 50"
+        err "请手动检查: systemctl status modelrouter.service && journalctl -u modelrouter -n 50"
         return 1
     fi
 
@@ -514,9 +531,9 @@ rollback() {
     fi
 
     log "重启服务（旧版本）"
-    systemctl restart llmsproxy.service || {
+    systemctl restart modelrouter.service || {
         err "重启失败，服务可能完全宕机"
-        err "请手动检查: systemctl status llmsproxy.service"
+        err "请手动检查: systemctl status modelrouter.service"
         return 1
     }
 
@@ -525,7 +542,7 @@ rollback() {
     local code
     code=$(curl -s -o /dev/null -w "%{http_code}" --max-time 5 "$HEALTH_URL" 2>/dev/null || echo "000")
     if [[ "$code" == "200" || "$code" == "401" ]]; then
-        log "✓ 回滚成功，旧版本已恢复服务 (status=$code)"
+        log "OK 回滚成功，旧版本已恢复服务 (status=$code)"
         log "  新版本部署失败，请检查构建/配置后重试"
         return 0
     else
@@ -551,7 +568,7 @@ print_summary() {
 # 于是坏配置在服务仍然健康时就被拦下，根本不会触发重启。
 main() {
     parse_args "$@"
-    log "═══ llmsproxy 原子部署开始 ═══"
+    log "═══ modelrouter 原子部署开始 ═══"
     precheck
     # 密钥校验放在 build/替换之前：它的失败后果最重（配置里的密文永久解不开），
     # 必须在动任何文件之前就挡住。此阶段用的是**当前线上二进制**，它已经
@@ -559,7 +576,6 @@ main() {
     verify_master_key
     build
     sync_adapters
-    sync_plugins
     backup_old_state
     atomic_replace_binary
     atomic_replace_config

docs/adapters.md

@@ -0,0 +1,61 @@
+# 适配器协议
+
+> 本文档由 README 拆分而来：Lua 适配器协议与内置适配器清单。
+> 编写适配器的完整参考见 [lua-adapters.md](lua-adapters.md)。
+> 返回 [README](../README.md)。
+
+## Lua 适配器协议
+
+完整 API 见 **[Lua 适配器 API 文档](docs/lua-adapters.md)**（[English](docs/lua-adapters-en.md)）。
+
+每个适配器是一个返回 table 的 Lua 脚本（`internal/lua/adapters/<name>.lua`），
+加载时可被 `adapter_dir` 下的同名脚本覆盖——**改 Lua 脚本无需重编译**，
+重启即生效；通过 WebUI 上传的适配器与在线编辑的源配置则即时生效。
+
+```lua
+return {
+  name = "mysrc",
+  version = "1.0.0",
+  endpoint = "/chat/completions",        -- 上游路径（可被 source.endpoint 覆盖）
+  headers = { ["X-Static"] = "v" },      -- 静态默认请求头（build_headers 缺省时使用）
+
+  -- 请求转换：把 OpenAI 格式 req 转成上游原生格式，返回字符串
+  transform_request = function(raw_json) ... end,
+
+  -- 响应转换：把上游原生响应转成统一格式字符串
+  --   { content, reasoning_content, finish_reason, token_usage{...}, tool_calls[{...}] }
+  transform_response = function(raw_json) ... end,
+
+  -- 流式分块转换：把上游 SSE data 转成 { content, done, ... }，返回 "" 则跳过
+  transform_stream_chunk = function(raw_chunk) ... end,
+
+  -- [可选] 动态请求头/签名钩子
+  -- meta = { url, method, body, api_key, timestamp, source={ name, meta={...} } }
+  build_headers = function(meta) return { ["X-App-Sign"] = sign } end,
+
+  -- [可选] 出向序列化（契约 v2）：上游不是 OpenAI 协议时接管写给客户端的字节。
+  -- 不声明则沿用内核的 OpenAI 兜底；声明即完全取代，内核不再混合字段。
+  serialize_response = function(result) return body_str end,
+  serialize_open_preamble = function(result) return bytes end,
+  serialize_chunk = function(delta) return bytes end,
+  serialize_close = function(result) return bytes end,
+}
+```
+
+内置信号辅助：`hmac_sha256_hex(key, data)`、`sha256_hex(data)`、`base64_encode(s)`、
+`tohex(s)`、`json.encode/decode`、`log(level, msg)`。
+
+### 内置适配器
+
+`openai` `deepseek` `anthropic` `gemini` `github` `groq` `mistral` `ollama` `qwen38` `sensenova`
+`qwen38` `sensenova` `trae`。
+
+`anthropic`/`gemini`/`ollama` 适配器内置多模态转换（`image_url` → 各自上游格式）；
+推理开关由中立的 `thinking` 字段表达，`deepseek` 适配器把它映射为
+`thinking.type = "disabled"`。
+
+适配器可用 `build_headers(meta)` 注入签名头。示例见 `adapters/` 下任一脚本的
+`build_headers` 实现；云端校验调用方 app 时需要按
+`meta.app_secret` 对时间戳+URL+请求体哈希做 HMAC 签名并附 `X-App-Sign` 等头。
+配好 `sources[].meta.{app_id, app_secret, app_agent}` 即可。
+

docs/configuration.md

@@ -0,0 +1,183 @@
+# 配置
+
+> 本文档由 README 拆分而来：网关配置、模型自动探测、多密钥。
+> 返回 [README](../README.md)。
+
+## 配置文件
+
+首次运行在 `-config` 路径自动生成默认配置（默认 `./config.yaml`），核心字段：
+
+```yaml
+listen: 127.0.0.1:8080        # 网关监听地址（建议绑内网/回环）
+gateway_keys: [sk-gw-<随机>]  # 初始 admin 密钥（每次安装随机生成，仅首启写入运行时存储用）
+default_model: AUTO           # model 无法路由时自动按优先级链选源
+adapter_dir: adapters         # Lua 适配目录；目录不存在时首启创建并 seed 内置，存在则只读
+runtime_file: runtime.json    # WebUI 编辑的源/密钥/AUTO 链持久化到此文件
+
+sources:
+  - name: deepseek
+    base_url: https://api.deepseek.com
+    api_key: sk-...            # 也可用 api_key_env: SOME_ENV 引用环境变量（不落盘明文）
+    adapter: deepseek
+    max_concurrent: 8
+    models:
+      - id: deepseek-v4-flash
+        priority: 100          # YAML 源首次启动会 seed 进 AUTO 链的初值
+        kind: chat
+      - id: deepseek-v4-pro
+        priority: 60
+        kind: chat
+    # 静态请求头（比适配器默认优先）
+    headers: { X-Tenant: prod }
+    # 传给 Lua build_headers 的透传元数据
+    meta: { app_id: x, app_secret: y }
+    temperature: 0.7
+    max_tokens: 4096
+    timeout: 120s              # 请求超时，默认 120s
+```
+
+
+## 自动探测模型列表
+
+不想手抄模型 id 时，只填 URL 和 key，让网关去扫：
+
+```bash
+# 只探测，不写任何东西
+curl -X POST http://127.0.0.1:8080/api/sources/discover \
+  -H "Authorization: Bearer sk-gw-…" -H "Content-Type: application/json" \
+  -d '{"base_url":"https://api.vendor.com/v1","api_key":"sk-…"}'
+# → {"ok":true,"base_url":"…","endpoint":"","models":["gpt-x",…],
+#    "image_models":["gpt-image-2"],"models_path":"/models","latency_ms":1387,…}
+
+# 探测后直接落库
+curl -X POST http://127.0.0.1:8080/api/sources/discover/apply \
+  -H "Authorization: Bearer sk-gw-…" -H "Content-Type: application/json" \
+  -d '{"base_url":"https://api.vendor.com/v1","api_key":"sk-…","name":"vendor"}'
+```
+
+WebUI 源编辑框里也有「自动探测模型」按钮：填好 URL 和 key 点一下，列表自动
+填好，仍需点保存才生效。
+
+几点值得知道：
+
+- **URL 形态不用猜。** 厂商对「`/v1` 放 base 还是放 path」没有共识，探测会
+  依次尝试若干候选并返回答对的那个，同时给出归一化后的 `base_url` +
+  `endpoint`（`endpoint` 平时留空，因为 openai adapter 自带 `/chat/completions`）。
+- **`image_endpoint` 是另一套规则。** 网关的图像默认路径是**绝对**的
+  `/v1/images/generations`，而 chat 默认是相对的。所以 `base_url` 带 `/v1` 时
+  必须显式给 `image_endpoint: /images/generations`，否则图像请求 404。
+  探测会替你填好。
+- **图像模型只看上游自己声明的 modality**，绝不从模型名猜。`gpt-image-2`
+  这类 id 也出现在同时提供对话服务的目录上，猜错会让 AUTO 链选中一个只支持
+  图像生成的模型，其后每一层都被它拖垮。
+- **不会逐模型探活。** 34 个模型的目录跑一轮要花钱且耗时数分钟，`/models`
+  是足够便宜的信号；模型是否真能应答留给正常请求去发现。
+- **对已存在的源，必须显式 `replace_models: true`** 才会覆盖模型列表。重新
+  探测顺手抹掉为 AUTO 链手工调过的 priority，是最难排查的一类数据丢失。
+- **`api_key` 留空表示沿用已存值**，不会把凭据清空。
+
+
+`config.yaml`、`runtime.json`、`master.key`、`adapters/` 均不提交版本库（见
+`.gitignore`），请随备份带走——`master.key` 丢失后运行时密文无法解密。
+
+运行文件生成在 `-config` 所在目录：`adapter_dir` / `runtime_file` 自动指向
+配置文件旁边的 `adapters/` 与 `runtime.json`，从任意工作目录启动都可用。
+
+运行时文件（`runtime_file`）中的敏感字段自动加密：
+
+- 加密算法 AES-256-GCM，格式 `enc:v1:<base64>`。
+- 主密钥来源：环境变量 `MODELROUTER_MASTER_KEY`（64 位 hex）；否则读取
+  `runtime_file` 同目录的 `master.key`；都不存在时首次启动自动生成 `master.key`（0600）。
+- 升级时旧明文文件自动兼容：首次运行正常读取，任何 UI 保存操作触发全文件加密迁移。
+- 注意：**master.key 丢失后密文无法解密**，请随配置一起备份；切勿提交到版本库。
+
+## 网关密钥（多密钥）
+
+网关鉴权采用「多密钥 + 角色 + 模型范围」架构，密钥持久化在 `runtime_file` 的
+`keys` 字段（加密存储）：
+
+- `gateway_keys` 配置只是**初始 admin 密钥种子**：首次启动迁移为运行时 admin
+  key，之后不再参与鉴权管理。
+- **重要：首次启动后请在 WebUI「密钥」页更换管理员密钥**——初始密钥明文写在
+  `config.yaml` 里（每次安装随机生成），继续使用存在被盗风险；用新密钥登录后删除初始密钥。
+- WebUI **密钥页**可创建/删除密钥；每个密钥可指定 `admin`（管理全部）或
+  `user`（仅看自己的 key）角色，并配置**模型范围**（模型 + 源 + token 配额 +
+  重置周期）。
+- 客户端用任意一个已授权的密钥明文作为 Bearer（`Authorization: Bearer <key>`）。
+- 删除密钥即从运行时存储移除，立即失效。
+
+### 密钥用量配额
+
+**配额按模型单独设置**：每个密钥的 `models[]` 里，每一条模型范围各自带一份
+token 配额与请求数配额。一个模型用满只影响该模型，同一密钥的其它模型照常工作。
+
+```yaml
+keys:
+  - key: sk-gw-<hex>
+    role: user
+    name: agent-alice
+    models:
+      - model: deepseek-v4-flash
+        token_quota: 1000000   # 本周期内该 key 用这个模型的 token 预算
+        req_quota: 20000       # 本周期内的请求次数
+        period: nhour          # "" | hour | week | month | nhour
+        hours: 6               # 仅 nhour
+      - model: AUTO
+        token_quota: 5000000   # AUTO 也是一条独立配额
+        period: day            # ← 这种写法会被拒绝（词表只有 hour/week/month/nhour）
+      - model: kimi-k3        # 未列配额 = 无限
+```
+
+- **没有「整钥总配额」**：这是刻意的设计。整钥总额会让「把 A 模型的额度挪给
+  B 模型」变成一次全局重分配；按模型独立计费则每个模型各自可控，运维可以
+  看出哪个模型吃掉了预算。
+- `period` 词表：空 = 永不过期（累计总量），`hour` / `week` / `month` = 固定窗口，
+  `nhour` + `hours` = 自定义小时数。**拼错的周期在写入时就被拒**，不会静默变成
+  永不过期。
+- 配额严格按密钥隔离，且**同一密钥内按模型隔离**：A 密钥用满 `m1` 不会消耗
+  B 密钥的额度，同一密钥的 `m2` 也不受影响。
+- 配额统计含聊天、流式、生图，跨重启从审计日志回放（保留 40 天，覆盖最长的
+  month 窗口）。
+- 配额耗尽返回 **429 + `Retry-After`**（`rate_limit_exceeded`），消息里点名是哪个
+  模型用满了，客户端可等窗口重置后自动恢复；模型越权才是 403。
+  **admin 密钥永不受配额限制**（其 scope 上的配额也不强制），避免把管理员
+  锁在门外。
+- 窗口用量按整点小时分桶统计，实际释放比配置窗口最多晚 1 小时（配额宁可晚释放
+  也不超发）。
+- `PUT /api/keys/{key}` 提交 `models` 即同时提交它们的配额（配额就是 scope 的一部分，
+  不存在会与模型列表脱节的第二份预算）。显式 `0` = 解除该模型的限制。
+
+#### 配额拒绝 vs 容量拒绝：两种「拒绝」含义不同
+
+配额在**入口**检查，不占用任何上游槽位，因此是廉价拒绝；容量不足则要走
+`busyWait` 有界等待后才返回 503。实测（容量 8、0.6s/请求、100 并发）：
+
+| 情况 | 状态码 | 延迟 | 是否打到上游 |
+|---|---|---|---|
+| 配额用尽（`req_quota` 50 → 100 并发） | `429 rate_limit_exceeded` + `Retry-After` | **19–21ms** | 否 |
+| 容量打满（同一拓扑，未限配额） | `503 upstream_error` | ~2.6s（`busyWait`） | 超出部分否 |
+
+客户端因此可以区分「等窗口重置」与「等上游腾出容量」：前者只需等待，后者
+通常该降并发或换源。
+
+#### 配额的开销
+
+配额桶按 (密钥, 模型, 整点小时) 分桶保留 40 天，实测（AMD 7840HS）：
+
+- 窗口查询按窗口长度而非保留总量扫描：1h 窗口 49ns、24h 窗口 55ns、
+  30d 窗口 3.9μs（此前全扫保留总量，960 桶时 5.9μs）。
+- 记录一条请求：283ns、3 分配（与引入配额前相同，分配来自 ring buffer）。
+- 内存：生产形态（7 密钥 × 8 模型 × 2 源 × 满 40 天 retention）约 **3.7MB**。
+  按源 pin 的 `source::model` 桶**惰性创建**——只有当某条配额真的 pin 了
+  某个源时才维护，否则每条记录多写一份桶，在 20 密钥 × 8 模型 × 3 源下会
+  多占 18MB。
+  代价：配置 pinned 配额之前的历史用量无法事后按源拆分，所以 **pinned 配额的
+  首个窗口可能少算**。
+
+```bash
+# 配额耗尽时客户端看到（点名了具体模型）
+HTTP/1.1 429 Too Many Requests
+Retry-After: 2100
+{"error":{"type":"rate_limit_exceeded","message":"token quota exceeded for \"deepseek-v4-flash\" (5000000/5000000)"}}
+```
+

docs/deployment.md

@@ -0,0 +1,142 @@
+# 部署与迁移
+
+> 本文档面向运维：单机 systemd 部署、发行包安装、目录与权限、从 `llmsproxy`
+> 改名后的迁移与回滚。
+> 返回 [README](../README.md)。
+
+## 1. 单机部署（推荐）
+
+仓库根目录的 `deploy.sh` 负责：构建 → 预检配置 → 备份 → 原子替换二进制 →
+重启服务 → 后置校验。它**不**修改源码，也**不**假设全新机器。
+
+```bash
+sudo ./deploy.sh                      # 默认读取仓库内 config.yaml
+sudo ./deploy.sh --config other.yaml  # 投放并部署另一份配置
+```
+
+部署目标（改名后）：
+
+> 两种布局并存，区别只在于二进制位置：**包安装**（deb/rpm）放 `/usr/bin`，
+> unit 自带；**源码部署**（`deploy.sh`）放 `/usr/local/bin`，需要让 unit 的
+> `ExecStart` 指向它。`deploy.sh` 会校验这一点，写错时直接中止而不是留下
+> 一个 203/EXEC 的服务。
+
+| 项 | 路径（源码部署 / 包安装） |
+|---|---|
+| 二进制 | `/usr/local/bin/modelrouter` / `/usr/bin/modelrouter` |
+| 配置 | `/etc/modelrouter/config.yaml` |
+| 适配器 | `/etc/modelrouter/adapters/` |
+| 插件（可选） | `/etc/modelrouter/plugins/`（需在配置里设 `plugin_dir`） |
+| 主密钥 | `/etc/modelrouter/master.key`（0600） |
+| systemd unit | `/etc/systemd/system/modelrouter.service` |
+
+`deploy.sh` 会在以下情况**中止**而不是"看起来成功"：
+
+- 部署后二进制起不来、或新配置 `-check` 不通过；
+- 凭据无法解封（`master.key` 丢失 / 与配置不匹配）；
+- 检测到改名前的 `/etc/llmsproxy`，但新配置尚未建立（否则会部署出一个
+  没有 key、没有源的空实例，所有请求都被拒）。
+
+## 2. 发行包安装
+
+三个产物由 `packaging/core-dist.sh` 生成到 `cmd/build/dist/`：
+
+```text
+modelrouter_<ver>_amd64.deb
+modelrouter-<ver>.x86_64.rpm
+modelrouter-<ver>-linux-amd64.tar.gz
+```
+
+deb / rpm 安装后：
+
+```bash
+sudo systemctl enable --now modelrouter
+sudo journalctl -u modelrouter -f
+```
+
+tar 包内只有：`modelrouter`、`config.example.yaml`、`modelrouter.service`、
+`migrate-to-modelrouter.sh`、`adapters/`。
+
+**发行包不含业务插件**（仓库只保留 `billing` / `usage` 两个与厂商无关的示例）。
+它们保留在仓库中作为可选扩展，需要时手工放入 `plugin_dir`，网关不会自动安装、
+覆盖或删除。这是有意的：插件属于运维资产，生命周期不与内核绑定。
+
+首次启动会在 `/etc/modelrouter/config.yaml` 生成一份**随机 admin key** 的配置，
+key 打印在启动日志里。发行包不预置任何可用 key（历史上曾因此泄露过一个真实的
+`sk-gw-local-0001`）。
+
+## 3. 目录与权限
+
+- `/etc/modelrouter` 是唯一的读写根（systemd unit 用 `ProtectSystem=strict` +
+  `ReadWritePaths=/etc/modelrouter` 固化这一点）。
+- `master.key` 必须 0600。当前 unit 以 root 运行：降权到普通用户需要先把
+  `master.key` 交给该用户并统一目录属主，否则服务会"带着明文落盘继续跑"，
+  失败只留一行日志——这是独立变更，不要和加固混在一起。
+- `plugin_dir` 由运维维护；插件自带的状态文件也在其中。
+
+## 4. 从 llmsproxy 迁移
+
+二进制、配置目录、服务名、环境变量已统一为 `modelrouter`：
+
+| 旧 | 新 |
+|---|---|
+| `/usr/local/bin/llmsproxy` | `/usr/local/bin/modelrouter` |
+| `/etc/llmsproxy/` | `/etc/modelrouter/` |
+| `llmsproxy.service` | `modelrouter.service` |
+| `LLMSPROXY_PLUGIN_DIR` | `MODELROUTER_PLUGIN_DIR` |
+| `LLMSPROXY_XDISPLAY_BASE` | `MODELROUTER_XDISPLAY_BASE` |
+| `LLMS_PROXY_MASTER_KEY` | `MODELROUTER_MASTER_KEY` |
+
+迁移脚本**默认 dry-run**，复制而非移动，旧目录永不删除：
+
+```bash
+sudo ./packaging/migrate-to-modelrouter.sh          # 预演（逐条打印将做什么）
+sudo ./packaging/migrate-to-modelrouter.sh --apply  # 执行
+```
+
+它做五件事：复制状态目录并改写配置里的旧绝对路径、复核 `master.key` 0600、
+安装新二进制（旧文件保留）、由旧 unit 生成新 unit（改写 ExecStart /
+WorkingDirectory / ReadWritePaths）、复制 `/usr/share` 资源；最后跑
+`modelrouter -check` 并 `systemctl daemon-reload`。
+
+确认新服务可用后，再手工清理旧布局（脚本不会删）：
+
+```bash
+sudo systemctl disable --now llmsproxy.service
+sudo rm -f /etc/systemd/system/llmsproxy.service
+sudo rm -rf /usr/local/bin/llmsproxy /etc/llmsproxy /usr/share/llmsproxy
+```
+
+回滚（不需要旧文件被删）：
+
+```bash
+sudo ./packaging/migrate-to-modelrouter.sh --rollback --apply
+```
+
+**读取侧兼容**：旧配置路径与旧环境变量仍被接受，所以"先换二进制、后改 unit"
+这种顺序不会立刻失效。但写入永远落在新路径，迁移完成后不要两台布局混用。
+
+## 5. 部署后验证清单
+
+```bash
+# 1) 进程与监听
+systemctl status modelrouter --no-pager
+ss -ltnp | grep modelrouter
+
+# 2) 鉴权生效（无 key 必须 401）
+curl -s -o /dev/null -w '%{http_code}\n' http://127.0.0.1:8080/v1/models
+
+# 3) 带 key 能列出模型
+curl -s -H "Authorization: Bearer $KEY" http://127.0.0.1:8080/v1/models | head -c 400
+
+# 4) 真实请求走通（证明 LuaJIT 适配器路径未被打断）
+curl -s -H "Authorization: Bearer $KEY" \
+  -d '{"model":"AUTO","messages":[{"role":"user","content":"hi"}]}' \
+  http://127.0.0.1:8080/v1/chat/completions | head -c 400
+
+# 5) 仓库文件与生产文件一致（部署脚本的收尾检查）
+sha256sum /usr/local/bin/modelrouter build/modelrouter
+```
+
+第 4 步失败但第 3 步成功，通常是适配器或上游凭据问题，不是部署问题：
+查看 `journalctl -u modelrouter -n 100`。

docs/development.md

@@ -0,0 +1,34 @@
+# 开发与目录结构
+
+> 本文档由 README 拆分而来：目录职责、开发协作、测试。
+> 返回 [README](../README.md)。
+
+## 目录
+
+```
+cmd/modelrouter            # 入口（纯 Go 服务端）
+cmd/gui                  # Electron 桌面 GUI（内嵌核心 + 托盘 + 打包）
+internal/config          # YAML 配置加载/校验
+internal/lua             # LuaJIT VM + worker 池 + AdapterCache + 内置适配器 (embed)
+internal/provider        # Provider(HTTP) + Registry(路由)
+internal/gateway         # OpenAI 兼容 HTTP 服务 + 鉴权 + SDK/流式 + WebUI
+internal/types           # 统一格式 & OpenAI wire 类型
+```
+
+## 开发协作
+
+- **Git 分支工作流**：主分支 / 特性分支 / 发布分支的规范见
+  **[docs/git-workflow.md](docs/git-workflow.md)**（[English](docs/git-workflow-en.md)）。
+  主线：`main` 永可部署 → 特性合入 `main` → 切 `release/vX.Y.Z` 打 tag 发布 →
+  hotfix 提交发布分支并 cherry-pick 回 `main`。
+- **Lua 适配器协议**：见 **[docs/lua-adapters.md](docs/lua-adapters.md)**
+  （[English](docs/lua-adapters-en.md)）。
+
+## 测试
+
+```bash
+go test -tags luajit ./...
+```
+
+覆盖：配置校验、适配器加载/变换、签名钩子、Gateway 鉴权、SDK 结算、SSE 流式、
+模型路由、多模态透传与 thinking 预算。

docs/features.md

@@ -0,0 +1,48 @@
+# 实现与完整特性
+
+> 本文档由 README 拆分而来：架构来源与完整特性清单（README 只保留摘要）。
+> 返回 [README](../README.md)。
+
+## 实现
+
+统一 OpenAI 兼容网关：把多个上游 LLM 源（DeepSeek、Qijiar、OpenAI、Anthropic、Gemini、
+Groq、Mistral、Ollama、KimiCode…）通过 **Lua 适配器** 做协议转换，对内网暴露
+一个标准 `OpenAI Chat Completions` 接口（`/v1/chat/completions` + `/v1/models`），
+支持单次结算、SSE 流式、**AUTO 模型路由**与**多模态**透传。
+
+从上游多源 LLM 适配层
+（`internal/agent/api/provider.go` + `internal/lua/adapters/*`）抽离而来并独立演进。
+
+## 特性
+
+- **多源**：一个进程内配置任意多个上游源，按请求的 `model` 自动路由。
+- **AUTO 模式**：`default_model: AUTO` 时按优先级页保存的 AUTO 链档位逐档调度并发请求。
+- **统一输出**：所有源对外都是 OpenAI 格式（含 `reasoning_content`、`tool_calls`、`usage`）。
+- **生图**：`POST /v1/images/generations`，`kind: image` 的模型独立路由。
+- **多模态**：`content` 数组（`image_url` 等）在多源间无损透传，Anthropic/Gemini/Ollama 自动转换。
+- **LuaJIT VM**：基于 golua 绑定的 LuaJIT，每个适配器独立 VM + worker 池，安全并发。
+  池是 **弹性** 的：`Σ max_concurrent` 只是上限而非预分配，状态按需创建、空闲时自动回收，
+  因此空载网关几乎不持有 Lua 状态（启动 0 个）。
+  - 扩容步长由适配器最大并发决定：`clamp(ceil(max/8), 1, 8)`，且仅在**真实并发争用**
+    （所有现有状态均已占用）时批量预热，顺序流量始终只用 1 个状态。
+  - 缩容步长由当前连接数决定：`clamp(ceil(冗余/(1+占用)), 1, 冗余)`——无连接时一轮收到
+    常驻下限，忙时每轮只释放 1 个，保护热路径。WebUI「适配器」页展示实时池指标。
+- **thinking 预算**：请求里的推理开关/预算归一为中立的 `thinking:{enabled,budget_tokens}`，
+  适配器映射到各自协议（Anthropic `thinking.budget_tokens`、Gemini `thinkingConfig`、
+  DeepSeek `thinking.type="disabled"`）。
+- **Lua 适配协议**：每个源挂一个 `.lua` 适配器，完成 `transform_request` /
+  `transform_response` / `transform_stream_chunk` 双向转换，协议差异全在 Lua 层。
+- **签名 / 请求头钩子**：适配器可定义 `build_headers(meta)`，在 Go 发 HTTP 前
+  动态注入/签名请求头——用于云端 API 校验调用方 app（如 KimiCode 只放行特定
+  agent）。提供 `hmac_sha256_hex` / `sha256_hex` / `base64_encode` 等签名辅助。
+- **WebUI**：内置管理界面，可在线查看/新增/编辑上游源与模型、配置 AUTO 优先级链、
+  管理密钥模型范围，写入运行时文件持久化。
+- **密钥加密存储**：运行时文件中的上游 `api_key`、自定义请求头值、网关 key 均以
+  AES-256-GCM 加密落盘（`master.key` 独立 0600，或 `MODELROUTER_MASTER_KEY`）。
+- **实时源探测**：状态页探测各源可达性（`GET {base}/models`，失败回退最小请求），
+  不污染正常调度的退避状态，错误信息在 UI 可悬停查看。
+- **鉴权**：网关自身用 `gateway_keys` 校验客户端 Bearer key；与上游各自的 key 相互独立。
+- **流式**：SSE `chat.completion.chunk`，含角色首包与 `[DONE]` 收尾。
+- **全链路审计**：HTTP 访问日志、登录/配置变更审计、请求记录 CSV 导出、密钥用量统计 CSV 导出
+- **AES-256-GCM 加密存储**：运行时文件敏感字段加密落盘，master.key 0600 权限，支持环境变量注入主密钥
+

docs/git-workflow-en.md

@@ -134,7 +134,7 @@ git push origin vX.Y.Z
 make core-dist VERSION=X.Y.Z
 
 # 5. create GitCode Release + upload
-#    https://gitcode.com/JianFeeeee/ModelRouter/releases
+#    https://atomgit.com/HeNanMU-EEA/ModelRouter/releases
 #    upload MUST use PUT --http1.1, otherwise the OBS callback fails and the
 #    file never lands in the release; replacing artifacts = delete the tag
 #    (release disappears with it) then recreate.

docs/git-workflow.md

@@ -124,7 +124,7 @@ git push origin vX.Y.Z
 make core-dist VERSION=X.Y.Z
 
 # 5. 创建 GitCode Release + 上传安装包
-#   见 https://gitcode.com/JianFeeeee/ModelRouter/releases
+#   见 https://atomgit.com/HeNanMU-EEA/ModelRouter/releases
 #   上传注意：必须 PUT --http1.1，否则 OBS 回调失败文件不进列表；
 #   替换旧版附件 = 删 tag（release 随 tag 一起消失）后重建。
 ```

docs/gui.md

@@ -0,0 +1,86 @@
+# 桌面 GUI（Electron）
+
+> 本文档由 README 拆分而来：Headless 与 Desktop 两种产物、构建与运行。
+> 返回 [README](../README.md)。
+
+## 桌面 GUI（Electron）
+
+可选独立产物，面向内网桌面端用户：**内嵌 ModelRouter 核心**（桌面壳形态），
+一键启停、系统托盘常驻、开机自启、静默启动，内容区一比一内嵌完整 WebUI
+（状态/对话/密钥/优先级/源/适配器 六个页面，免登录）。服务器用户继续使用纯 Go 二进制。
+
+### 两种安装包：Headless 与 Desktop
+
+发布到 Release 的安装包分为两类，面向不同用户：
+
+- **Headless（服务器版）**：纯核心二进制（无 Electron），配置驱动，适合服务器、
+  容器、systemd 等无人值守场景。发布包含 `deb` + `rpm`（含 systemd unit、内存调优
+  与示例配置）与 `tar.gz`（二进制 + `config.example.yaml` + `adapters/` + README），
+  Windows 为 `.zip`。
+- **Desktop（桌面版）**：Electron GUI 安装包，内嵌核心，适合个人桌面日常使用。
+
+### 选择 GUI 还是纯后端
+
+| 场景 | 推荐 | 理由 |
+| ------ | ------ | ------ |
+| 服务器 / 内网网关 / 无人值守常驻 | **Headless**（单二进制） | 极轻量（二进制 ~8MB；RSS 随源数量，单源 ~10MB、16 源 ~32–35MB，见[内存占用](#内存占用实测与调优)），零依赖单进程，直接跑在 systemd/任意容器里，远程管理 |
+| 个人桌面日常使用 / 多设备内网共享 | **Desktop**（GUI） | 免登录内嵌 WebUI、系统托盘一键启停、开机自启、静默后台，适合不懂命令行的使用者 |
+| Windows 桌面 | **Desktop** | 纯后端在 Windows 上需自行注册服务，GUI 提供原生托盘/自启体验 |
+| CI 一键出三平台安装包 | **Desktop 打包脚本** | `make gui-*` 系列出 deb/AppImage/NSIS，可进发行流水线 |
+
+两者完全同源：GUI 内嵌的就是纯后端的同一份 `modelrouter` 核心（LuaJIT 版），
+配置/适配器格式完全一致，可随时互换。
+
+### 构建与运行
+
+```bash
+cd cmd/gui
+npm install
+make gui          # 或 npm run dev —— 开发运行（需先 make build 生成 bin/modelrouter）
+make gui-deb      # 本机构建 deb（分享给其它 Linux 用户）
+make gui-dist     # 构建 deb + rpm + AppImage（linux，rpm 需系统 rpmbuild）
+make core-dist    # 构建核心 deb + rpm + tar.gz（服务器版，需 nfpm）
+make gui-win      # 构建 Windows nsis 安装包（本机 mingw + wine）
+make gui-win-docker  # 构建 Windows nsis 安装包（全 docker 自足，含 wine）
+make gui-dist-dir # 仅解包产物（调试用，不产安装包）
+```
+
+产物在 `cmd/build/gui-dist/`：`ModelRouter-<ver>.AppImage`、
+`modelrouter-gui_<ver>_amd64.deb`、`ModelRouter Setup <ver>.exe`（win）；
+核心包在 `cmd/build/dist/`：`modelrouter_<ver>_amd64.deb`、`modelrouter-<ver>.x86_64.rpm`。
+rpm 需系统 `rpmbuild`。每次打包后都会跑 `packaging/verify-dist.sh` 产物体检
+（大小下限门禁——1.3.0 曾因宿主 wine 损坏产出 264KB 的残缺 exe 却没有被拦住）。
+发布时会把产物重命名为 `ModelRouter-Desktop-*`（GUI）与 `ModelRouter-Headless-*`（纯后端）
+两类上传到 GitCode Release。
+
+#### Windows 打包（docker 固化方案，推荐）
+
+`make gui-win-docker` 一步完成：交叉编译核心 + NSIS 打包**全在 docker 内**，宿主机
+**无需 mingw、无需 wine、无需 node**。镜像内置 wine（含 i386 运行时），修复了
+此前宿主 wine 损坏（缺 syswow64 → `c0000135`）导致产出 264KB 残缺 exe 的问题。
+
+- 构建镜像：`cmd/gui/docker/win-builder/Dockerfile`（`golang:1.25` + mingw-w64 +
+  node + wine32/wine64 + 预编译 LuaJIT windows 版 `lua51.dll` 与 import lib）。
+  LuaJIT 源码取自国内镜像，上游兜底；Go 依赖走 `https://goproxy.cn`。
+- 一键发布：`cmd/gui/scripts/dist-win-docker.sh` —— 核心编译 + electron-builder
+  NSIS 全部在容器内执行（`USE_SYSTEM_WINE=true` 走镜像内的 wine）；electron-builder
+  的 ~400MB 工具链缓存挂到 docker volume，二次构建增量复用。
+- 首次运行自动构建 `modelrouter/win-builder` 镜像（约 5–10 分钟）；已存在则直接复用。
+- 打包完成后自动跑 `packaging/verify-dist.sh` 门禁：exe 低于 5MB / deb·rpm·7z 低于
+  10MB 即失败——残缺安装包不可能再溜进 Release。
+
+```bash
+# 全 Windows 发布（核心重编 + NSIS）：
+make gui-win-docker
+```
+
+### 特性
+
+- **内嵌核心**：自动拉起捆绑的 `modelrouter`（LuaJIT 版），配置/密钥/adapter 存于
+  用户数据目录 `<userData>/profile/`，首次运行自动生成随机 admin key 写入 `keys`
+  （非 seed）并自注入，WebUI 免登录、不会提示"更换初始密钥"。端口可在设置中更改（默认 8787）。
+- **系统托盘**：内核状态点、开机自启/静默启动开关、启停/重启内核、退出。
+- **静默启动**：`--silent` 参数或设置项，启动仅驻托盘不弹窗；首次运行始终显示窗口。
+- **开机自启**：Windows/macOS 用 `setLoginItemSettings`；Linux 写
+  `~/.config/autostart/modelrouter-gui.desktop`，静默开启时自动附加 `--silent`。
+

docs/performance.md

@@ -0,0 +1,60 @@
+# 性能与内存
+
+> 本文档由 README 拆分而来：实测内存占用、调优手段、thinking 预算。
+> 返回 [README](../README.md)。
+
+## 内存占用（实测与调优）
+
+内存不是一个定数：它随**配置的源数量**增长（每个源一个 `http.Transport` 与连接池、
+一组健康状态），与运行时长无关。本机实测（Linux x86_64，12 核）：
+
+| 部署形态 | 启动 RSS | 稳态 RSS |
+|---|---|---|
+| 1 源 / 1 适配器（最小配置） | ~4 MB | ~10 MB |
+| 1 源 + 29 MB 历史审计日志 | ~19 MB | ~20 MB |
+| **16 源 / 13 适配器 / 59 模型（本机生产）** | ~28 MB | **~32–35 MB** |
+
+> 历史参考：本项优化前同一生产配置为 **~105 MB**。降幅来自三处：审计日志的**原始记录**
+> 不再常驻内存（约 25 MB；统计聚合仍扫全量，但扫完即释放）、Lua 状态池不再单调增长、
+> 以及下面两个运行时开关。
+
+内存构成（生产实例分段测量，`/proc/<pid>/smaps`）：
+
+| 区域 | RSS | 说明 |
+|---|---|---|
+| Go 堆 | ~14 MB | provider/registry/scheduler 结构 + 连接池缓冲 |
+| 其他匹名（线程栈 / LuaJIT chunk / runtime） | ~12 MB | 与线程数、已加载适配器数相关 |
+| 二进制 text+rodata | ~8 MB | 映射的可执行文件页（只读、可被内核回收） |
+| Go runtime 预留 | ~4 MB | VSZ 上看到的 2 GB+ 是地址空间预留，不占物理内存 |
+| 共享库 | ~3 MB | libc / libluajit / libm |
+
+**两个推荐的部署开关**（只适用于环境变量，无需改代码）：
+
+```ini
+# /etc/systemd/system/modelrouter.service
+Environment=GOGC=50
+Environment=MALLOC_ARENA_MAX=2
+```
+
+- `MALLOC_ARENA_MAX=2`：LuaJIT 的分配走 cgo → glibc malloc，glibc 默认允许 `8×nproc`
+  个 per-thread arena，每个碰到 malloc 的 OS 线程会占用一个（各约 1 MB，且**不归还给系统**）。
+  实测从 8–15 个 arena（约 7–12 MB）降到 **0**。
+- `GOGC=50`：把 Go 堆增长目标减半。**单独使用无效**（省下的堆会立即被更多 glibc
+  arena 吃掉，实测 20.3 → 21.5 MB 反而变大），必须与 `MALLOC_ARENA_MAX` 配合，
+  两者同时开启才降 **~19%**。网关是 I/O 密集型（本机 9 小时仅消耗 1min10s CPU），
+  多出的 GC 周期与它的空闲 CPU 相比可忽略。
+
+> 桌面版（Electron）已在 `cmd/gui/main.js` 里默认为内嵌核心注入这两个开关；手动 export 同名
+> 环境变量可覆盖。如果你用自己的 systemd unit / 容器，建议照上面加上。
+
+可选：`GOMEMLIMIT=48MiB` 作软上限，实测再省 ~1 MB；代价是逐近上限时 GC 转激进，
+温和场景不必开。
+
+## thinking 预算
+
+请求体带 `"thinking": {"enabled": false}` 时关闭推理；`"thinking": {"enabled": true,
+"budget_tokens": 4096}` 指定预算。内核只定义这个**中立**语义字段，映射到具体协议由
+适配器负责（Anthropic `thinking.budget_tokens`、Gemini `thinkingConfig.thinkingBudget`、
+DeepSeek `thinking.type = "disabled"`）。内核不再向适配器泄漏 `disable_thinking` /
+`extra_body` 这类私有字段。
+

docs/plugins.md

@@ -15,6 +15,37 @@ ModelRouter 的插件是**单个 `.lua` 文件**，放在 `config.yaml` 的 `plu
 
 ---
 
+## 0. 插件 SDK：唯一的公开接口
+
+插件与网关之间**只有一个**公开接口表 `modelrouter`。它不是 Go 包的导出符号，
+而是内核在启动插件 VM 时注入的 Lua 表；插件通过它调用内核能力，永远不需要
+（也不应该）依赖任何 `__llmsproxy_*` 全局、Go 结构体或内部函数名。
+
+```lua
+modelrouter.sdk_version   -- 字符串，契约版本；SDK 形状变化才递增
+modelrouter.http(spec)    -- 受出站白名单约束的 HTTP 请求
+modelrouter.secrets       -- 本插件专用的凭据保险库（set/get/delete/keys）
+modelrouter.kernel        -- 内核动作面（actions/call，受运维授权约束）
+modelrouter.adapters      -- 安装/更新/删除本插件自己的适配器
+modelrouter.plugin_dir    -- 本插件所在目录（内核给出的 ground truth）
+```
+
+规则：
+
+- **只依赖上表**。内核重命名内部全局、改实现或加守卫时，插件不受影响；
+  这正是把六个散落的全局收进一张表的原因。
+- **能力可能缺失**。未授予的能力（例如出站 HTTP 全禁）在表里是 `nil` 而不是
+  "存在但一调用就报错"，插件应先判断再使用。
+- **`sdk_version` 用来做兼容分支**。增量字段不递增版本；字段删除或调用约定
+  变化才递增。
+- **历史别名**：`llmsproxy`（旧产品名）与 `__llmsproxy_{http,secrets,kernel,
+  adapters,plugin_dir}` 仍然指向同一批对象，只为已安装的插件继续可用而保留，
+  已废弃；新插件使用 `modelrouter.*`。
+- 环境变量：插件目录优先读 `MODELROUTER_PLUGIN_DIR`，回退旧名
+  `MODELROUTER_PLUGIN_DIR`。
+
+---
+
 ## 1. 快速上手
 
 一个最小的插件：
@@ -46,7 +77,7 @@ plugin.ui = {
   page = {
     page_id = "hello",     -- kebab-case
     title = "Hello",
-    icon = "👋",
+    icon = "",
     order = 90,            -- 侧栏排序
     mount = [[<div id="hello">hello</div>]],
   },
@@ -65,16 +96,14 @@ return plugin   -- 必须返回一个 table
 core.New
   └─ lua.NewVM(adapter_dir).Start()        适配器状态
   └─ lua.NewPlugins(vm, plugin_dir)
-       ├─ SeedBundled()                    仅当目录不存在时写入内置插件（目前是 billing）
-       └─ LoadDir()                        按文件名字典序逐个加载
+`plugin_dir` 中的 Lua 文件由网关逐个加载；安装包不携带业务插件，也不会自动创建或写入插件文件。首次启用时，先把需要的 `.lua` 插件放入该目录，再启动网关。
 ```
 
 **加载失败不影响网关启动。** 一个语法错误的插件会被记录在 `GET /api/plugins`
 的 `error` 字段里，永远不会被调用。这与适配器一致，但理由更强：插件是可选的
 第三方扩展，因为一个 `.lua` 打错字就让网关起不来是错误的取舍。
 
-**目录一旦存在就是权威的。** 与适配器同规则：首启会 seed 内置插件，之后目录里
-的文件说了算，删除或编辑内置插件都是真实生效的操作。
+插件目录由运维独立管理。网关不会 seed、覆盖或删除其中的插件；目录缺失时只会跳过插件加载，不影响网关启动。
 
 ### 2.1 热更新
 
@@ -211,7 +240,7 @@ plugin.ui = {
   page = {
     page_id = "billing",   -- 必填,kebab-case。侧栏 data-tab 与 #tab-billing
     title = "Billing",     -- 必填,侧栏文字
-    icon = "💰",           -- 可选
+    icon = "",           -- 可选
     order = 40,            -- 侧栏排序,默认 100
     mount = [[...HTML...]],
   },
@@ -294,7 +323,7 @@ PUT    /api/plugins/{name}/state     替换状态（admin）
     "loaded": true
   }],
   "hook_errors": { "request_end": { "count": 3, "last_error": "billing: ..." } },
-  "plugin_dir": "/etc/llmsproxy/plugins"
+  "plugin_dir": "/etc/modelrouter/plugins"
 }
 ```
 
@@ -303,13 +332,13 @@ PUT    /api/plugins/{name}/state     替换状态（admin）
 
 ### 5.4 定时任务（`PLUGIN.schedule`）—— 浏览器关着也会跑
 
-要求插件做“随时间发生”的事（自动签到、token 轮换、额度轮询）时，声明一个
+要求插件做“随时间发生”的事（定时刷新、token 轮换、指标采集）时，声明一个
 调度表：
 
 ```lua
 plugin.schedule = {
   { fn = "refresh_token", every = 3600 },                 -- 每小时（秒）
-  { fn = "daily_checkin", every = 86400, at = "03:30" }, -- 每天固定时刻（本地时间）
+  { fn = "daily_refresh", every = 86400, at = "03:30" }, -- 每天固定时刻（本地时间）
   { fn = "poll_quota",    every = 300, jitter = 30 },     -- 首次触发加 0-30s 抖动
 }
 function plugin.refresh_token()
@@ -377,7 +406,48 @@ plugin.http = {
   路径，未认证会跳登录页。
 - 未声明的路径不会因为落在允许命名空间而被放行——不在 handler 表里就是 404。
 
-### 5.6 在运行时安装/更新适配器（token 轮换）
+### 5.6 前缀代理：把插件自起的服务挂到网关同端口
+
+前节的自定义挂载点只能回答**由插件计算出来的内容**（`{status, headers, body/json}`）。
+若插件自己起了一个 TCP/HTTP 服务（典型：服务端浏览器栈 + noVNC），客户端就需要
+**字节级转发**，包括 **WebSocket 升级** —— 前者做不到。
+
+为此声明 `prefix = true`，handler 每次请求返回一个**回环目标**：
+
+```lua
+plugin.http = {
+  { path = "myplugin/proxy/:session", method = "GET", prefix = true,
+    roles = { "admin" }, handler = "proxy" },
+}
+
+function plugin.proxy(req)
+  -- 每次请求都问一遍：会话没了/过期了就返回 404，地址自然失效
+  if not sessionAlive(req.params.session) then
+    return { status = 404, json = { error = "no such session" } }
+  end
+  return { proxy = "http://127.0.0.1:60100" }
+end
+```
+
+规则：
+
+- **只能返回 `{ proxy = <目标> }`**，没有 `status` / `body`。写了 `status` 会被忽略。
+- 目标必须是 **带显式端口的字面回环 IP**（`http://127.0.0.1:60100`）。
+  拒绝 `https://`、`localhost` 这类主机名、无端口、带 userinfo/path/query 的地址。
+  理由：主机名可能被 hosts / DNS / 代理环境改写；通用能力只接受确定性地址。
+- 路由匹配同前缀下的**所有子路径**，`:param` 仍照常捕获，`req.path` 是完整
+  请求路径，子路径由插件自己从 `req.path` 里切。
+- **鉴权先于代理**：`roles` / `keys` / `public` 语义与普通端点一致。
+- **不转发网关凭据**：`Authorization`、`Cookie`、`api_key` 都不会传给后端服务。
+- **拒绝跨站**：`Origin` 与网关自身 host 不一致返回 403。WebSocket 由浏览器
+  发起且自动带 Cookie，否则第三方网页可借管理员会话开隧道。
+- **撤销点唯一**：handler 不再返回目标（或返回 404）即失效，内核不缓存目标。
+
+客户端拿到的 URL 是**相对网关口**的绝对路径（如
+`/api/plugins/http/myplugin/proxy/<id>/vnc.html`），因此远程访问、HTTPS 入口、
+Cookie 鉴权都自然生效，无需暴露额外端口。
+
+### 5.7 在运行时安装/更新适配器（token 轮换）
 
 插件可以在运行时安装、改写**自己的**适配器 —— 这是"带自动轮换的认证"的实现
 方式：拿着新 token 重写适配器源码，后续请求自然使用新逻辑（内核重建该适配器
@@ -387,7 +457,7 @@ plugin.http = {
 -- 每小时的定时任务：轮换 token 并重写适配器
 function plugin.refresh_token()
   local tok = fetch_new_token()          -- 插件自己的取 token 逻辑
-  local name, err = __llmsproxy_adapters.install(
+  local name, err = modelrouter.adapters.install(
     "myauth",
     'return { name = "myauth", endpoint = "/chat/completions",' ..
     ' headers = { ["Authorization"] = "Bearer ' .. tok .. '" } }'
@@ -398,9 +468,9 @@ end
 
 | 调用 | 参数 | 返回 |
 |---|---|---|
-| `__llmsproxy_adapters.install(name, source)` | 适配器名 + Lua 源码 | `(生效名, nil)` 或 `(nil, err)` |
-| `__llmsproxy_adapters.update(name, source)` | 同上（只限自己装的） | `(true, nil)` 或 `(nil, err)` |
-| `__llmsproxy_adapters.remove(name)` | 适配器名（只限自己装的） | `(true, nil)` 或 `(nil, err)` |
+| `modelrouter.adapters.install(name, source)` | 适配器名 + Lua 源码 | `(生效名, nil)` 或 `(nil, err)` |
+| `modelrouter.adapters.update(name, source)` | 同上（只限自己装的） | `(true, nil)` 或 `(nil, err)` |
+| `modelrouter.adapters.remove(name)` | 适配器名（只限自己装的） | `(true, nil)` 或 `(nil, err)` |
 
 出错时不抛异常，而是返回 `(nil, err)`——与钩子/HTTP 处理器同一套约定，
 一个手滑的插件错误不会带走网关。
@@ -428,7 +498,7 @@ end
 因此插件持有**唯一一个**状态，所有入口（`Fire` / `State` / `SetState` / **定时任务**）
 都用这同一把互斥锁串行化。
 
-⚠️ 这条约束对**定时任务尤其关键**：任务和钩子必须是同一个 VM，否则任务写的
+注意： 这条约束对**定时任务尤其关键**：任务和钩子必须是同一个 VM，否则任务写的
 `plugin.state` 是一个请求路径永远读不到的副本 —— token 轮换看起来成功了，
 对实际流量完全无效。
 
@@ -449,28 +519,70 @@ end
 与适配器相同：`json.encode` / `json.decode`、`log(level, msg)`、
 `hmac_sha256_hex` / `sha256_hex` / `base64_encode` / `tohex`。
 
-⚠️ `os.date` 在极简运行时里可能不可用（计费插件因此有降级路径）。
+注意： `os.date` 在极简运行时里可能不可用（计费插件因此有降级路径）。
 
 ### 6.4 命名
 
-- 全局 `__llmsproxy_plugin` 存放插件返回的 table，**不要占用**
+- 全局 `__llmsproxy_plugin` 是内核存放插件返回 table 的**内部位置**，不属于 SDK，**不要占用**
 - 插件间状态完全隔离，一个插件改不了另一个的全局
 
 ---
 
-## 7. 内置计费插件
+## 7. Billing 插件示例
 
-`plugins/billing.lua`，默认随首启 seed 进来，开箱可用。
+`internal/lua/plugins/billing.lua` 是仓库中的可选插件示例，不随核心安装包分发，也不会在启动时自动安装。需要使用计费功能时，应将该脚本单独复制到配置的 `plugin_dir` 后再重启网关。
 
-### 7.1 计费维度
+### 7.0 分层：billing 完全在插件里，内核没有任何 billing 代码
 
-| 维度 | 用途 | 优先级 |
+`billing` 是**插件自己的事**：规则文件、编译、计价、账目、规则编辑页都由
+`plugins/billing.lua` 负责。内核里没有 billing 的配置结构、端点、编译或迁移逻辑
+—— 它只提供所有插件通用的能力（加载 `.lua`、插件状态持久化、插件目录、
+`plugin.http` 路由、插件可用的 `io`/`os`）。
+
+| 项 | 位置 |
+|---|---|
+| 规则文件 | `<plugin_dir>/billing.json`（插件自己读写；内核不知道这个文件） |
+| 计费账目 | 插件状态文件 `<plugin_dir>/.billing.state.json`（内核的通用状态持久化） |
+| 规则编辑 API | `/api/plugins/http/billing/rules`（GET/PUT/POST/DELETE，插件路由） |
+| 编译/计价 | 插件内 `compileRules()` / `priceFor()` / `costFor()` |
+
+规则以**源名**（`source`）为键，而不是 URL：URL→源名的映射属于内核配置，插件
+不需要为了它和内核对接；编辑页在浏览器里，直接取 `/api/sources` 给运营选源名。
+`url: "*"` 只表示"全局模型价目表"（模型维度本来就不分源）。
+
+> 历史：早期 `billing:` 写在 `config.yaml`、编译在 Go 的 `internal/billing` 里。
+> GitCode issue #1 的根因正是"Go 与 Lua 各写一半覆盖语义"，组合起来把模型价
+> 静默清零。现在内核侧 billing 代码已全部删除，规则文件也由插件自持。
+
+### 7.1 计费维度### 7.1 计费维度
+
+| 维度 | 用途 | token 价覆盖顺序 |
 |---|---|---|
-| `sources` | 源的固定价（如按请求计费的转发服务） | 中 |
-| `models` | 模型的 per-token 价 | 高 |
+| `default` | 兜底价（通常全 0） | 最低 |
+| `models` | 模型的 per-token 价 | 中 |
+| `sources` | 源级价：固定价，或覆盖该源全部模型的 token 价 | 高 |
 | `keys` | 单个网关 key 的覆盖价 | **最高** |
 
-**token 价**优先级：`keys` > `models` > `default`。
+**token 价**优先级：`keys` > `sources` > `models` > `default`。
+（实现顺序就是"后写覆盖前写"：`default` → `models` → `sources` → `keys`；
+所以**源级 token 价会覆盖模型价**。这是有意的：运营要能给某个源整体改价。）
+
+⚠️ 正因为 `sources` 会覆盖 `models`：**`mode: token` 的规则不产生任何源条目**。
+规则未列出的模型会进入未定价统计（可见），而不是静默计 0 —— 这是 issue #1 / PR #2
+的收口语义。只有 `free` / `subscription`（"边际成本为零"）会写有意为之的
+`{prompt:0, completion:0}` 零价条目。
+
+规则写法：
+
+```json
+{"active":"current","profiles":[{"id":"current","default":"unpriced","rules":[
+  {"source":"localzen","mode":"free"},
+  {"source":"codearts","mode":"token",
+   "models":{"glm-5.3":{"prompt":"0.15","completion":"0.60"}}},
+  {"url":"*","mode":"token","models":{"some-model":{"prompt":"1.0","completion":"2.0"}}}
+]}]}
+```
+
 **`per_request` 固定价是叠加的**（不覆盖），所以一个生图模型可以既算 token 又收固定费。
 **`cache_discount`** 见 §7.7。
 
@@ -536,7 +648,7 @@ curl -H "Authorization: Bearer $ADMIN_KEY" \
 { "prices": { ... }, "count_failures": true }
 ```
 
-### 7.5 ⚠️ 计费插件只报表，不执法
+### 7.5 注意： 计费插件只报表，不执法
 
 **网关自己的配额会计（`internal/gateway/stats.go`，入口处强制）才是限额权威。**
 本插件不参与任何路由或配额决策。
@@ -558,6 +670,17 @@ curl -H "Authorization: Bearer $ADMIN_KEY" \
 
 仪表盘上有 "Unpriced" 卡片。**这个数应该是 0**；不是 0 就去补价目。
 
+**profile 级兜底**：`profiles[].default` 可设为 `free` 或 `unpriced`（默认）。
+它是插件运行时的策略（编译期写入 `prices.default_mode`）：
+
+| `default` | 没有单独规则的源 | `unpriced_reqs` |
+|---|---|---|
+| `unpriced`（省略时） | 零价，计入未定价债务 | +1 |
+| `free` | 零价，视为**刻意免费** | 不增加 |
+
+显式 `mode: unpriced` 的源即使在 `default: free` 下也仍然计入（"只统计不收费"
+的声明不能被兜底策略吞掉）。
+
 注意"未定价"不等于"免费"：这些请求的 `requests` / token 数**照常计入**
 `total` 与各维度，只有金额是 0。
 
@@ -610,7 +733,7 @@ cached = cache_hit_tokens                   → 全价 × cache_discount
 插件的 `log(level, msg)` 输出到网关的日志：
 
 ```
-journalctl -u llmsproxy -f | grep -i plugin
+journalctl -u modelrouter -f | grep -i plugin
 ```
 
 ---

docs/routing.md

@@ -0,0 +1,111 @@
+# 路由与调度
+
+> 本文档由 README 拆分而来：模型路由、AUTO 链、冷却与半冷却、源与适配器、源模板。
+> 返回 [README](../README.md)。
+
+## 模型路由
+
+`/v1/chat/completions` 的 `model` 解析顺序：
+
+1. `source/model` 或 `source:model` 前缀 → 指定源；
+2. 精确匹配某个源的 `model`；
+3. 配置 `default_model: AUTO` 时 → 走优先级页保存的 AUTO 链（见下）；
+4. 否则回落（返回错误）。
+
+任何 OpenAI 客户端，只要 `model` 设为某个源的 `name/任意名`，即可锁定走该源；
+设为 `AUTO`（或网关配了 `default_model: AUTO`）即自动按优先级链选源。
+
+## AUTO 链（优先级页）
+
+AUTO 调度**只**由优先级页保存的规则决定，源配置里的 `models[].priority` 数字不再
+参与调度、也不再显示。**聊天与生图是两套独立的链**，在优先级页面通过「聊天 / 生图」
+按钮切换编辑：
+
+- **聊天链**（`runtime_file` 的 `auto` 字段）：服务 `POST /v1/chat/completions`
+  的 `model: AUTO` 请求；只接受 `kind: chat` 模型，配置在链里的生图槽位会被忽略。
+- **生图链**（`runtime_file` 的 `auto_image` 字段）：服务 `POST /v1/images/generations`
+  的 `model: AUTO` 请求；只接受 `kind: image` 模型。未配置生图链时，AUTO 生图回落
+  到「所有含生图模型的源、按注册顺序」的旧行为，兼容旧配置。
+
+每条规则 = 一个「槽位」：`{ model, source, tier, token_quota, period, hours }`。
+
+- `tier` 表示优先级档位：同一档的模型并排、共享该优先级；档位从上到下递减。
+- 同一模型可配置多个槽位（如 A 源低配 → B 源低配 → A 源高配 → B 源高配），按档位顺延。
+- `token_quota` > 0 时该槽位在重置周期内用满即顺延到下一槽位；`period` 支持
+  `hour` / `week` / `month` / `nhour`（配合 `hours`），空 = 不限。
+- 同 tier 内按「偏好分」排序，失败槽位冷却后自动跳过；冷却 / 配额耗尽 / hard
+  错误会顺延到下一 tier，全部失败时返回 503 并附上每档失败摘要。
+
+## 冷却与半冷却探测（自愈调度）
+
+槽位失败后进入指数退避冷却（5s → 10s → 20s …，上限 **5 分钟**）。冷却不是全时段
+硬闸：
+
+- **前半段完全静默**：刚失败的槽位不接任何流量，避免对故障上游持续施压。
+- **后半段放行 1 个探测**：窗口过半后，同一 `(源, 模型)` 最多允许 **一个** 请求作为
+  探测通过。探测槽数 = `clamp(max_concurrent / 10, 1, 2)`——`max_concurrent: 10`
+  的源恰好放行 1 个探测请求。
+- **探测排在最后**：同 tier 内探测候选永远排在健康候选之后，只有没有正常槽可用时
+  才承接真实流量，因此探测不会抢走可用容量。
+- **探测即真实请求**：成功则立即清零失败计数与冷却，槽位当场回到正常轮询——
+  上游恢复/额度恢复后不必等满整个冷却窗口。失败则重开一个新窗口，下次探测顺延到
+  新窗口的中点，不会连续重试。
+
+分类冷却策略：
+
+| 情况 | 冷却 | 说明 |
+|---|---|---|
+| 传输错误 / 5xx | 5s→10s→20s…，上限 5min | 指数退避 |
+| 401 / 403 凭据错误 | 10min | 换 key 后由下一次探测自动接回 |
+| 429 限流 | 30s 固定 | 「太快」不等于「坏了」，不进指数阶梯 |
+| 配额耗尽（`insufficient_quota` / `余额不足` 等） | 对齐配额窗口，上限 30min | **不进指数阶梯、不涨失败计数**，额度恢复即可用 |
+
+WebUI「优先级」页的槽位健康标签会区分 `冷却` / `待探测` / `探测中`，悬停可看窗口
+起点、探测放行时刻与完全恢复时刻。
+
+## 源（Source）与适配器（Adapter）的关系
+
+- **源** 是到某个上游的连接描述：`name`、`base_url`、`api_key`、模型列表与优先级。
+- **适配器** 是协议转换逻辑（Lua 脚本）：把统一 OpenAI 格式请求转成上游原生格式，
+  再把上游响应/流式分块转回统一格式。
+- 一个适配器可被多个源复用（如 `openai.lua` 同时服务多个 OpenAI 兼容站点）；
+  同一个源也可以切换不同适配器（改 `adapter` 字段即可）。
+- 源决定“连谁、暴露哪些模型”，适配器决定“怎么对话”——二者在 `sources[]` 条目中
+  通过 `adapter` 字段关联。
+
+加载流程（`internal/core` 的 `Core` 负责装配）：
+
+1. 启动时 `lua.NewVM(adapter_dir)` 加载全部适配器：内置适配器（编译期 embed）+
+   `adapter_dir` 下的同名覆盖文件；内置文件写在代码内，覆盖文件要求更高优先级。
+2. `config.Load` 读取 `config.yaml`，`config.NewStore(runtime_file)` 读 WebUI 改动的
+   运行时源，二者按名称合并成完整源列表。
+3. `rebuildRegistry` 为每个源创建 `provider.Provider`（持有目标适配器），并按源的
+   并发上限配置适配器 worker 池**上限**（不预分配，见下）。
+4. 请求进来时 `Registry` 按 `model` 路由到 Provider，Provider 调适配器
+   `transform_request` → HTTP 发送 → `transform_response` / `transform_stream_chunk`。
+
+WebUI 上的"新增/编辑源"、"上传 Lua 适配器"、"改 AUTO 优先级链"与"密钥模型范围"
+都即时生效（写入运行时文件或 `adapter_dir` 后重新装配，无需重启）；直接编辑
+`config.yaml` / `adapter_dir` 下的文件则需要重启进程才会重新加载。
+
+在 WebUI 删除源/适配器时：运行时（WebUI 创建）的源与 `.lua` 文件会真正移除；
+`config.yaml` 中定义的基源无法改写配置文件，采用删除标记隐藏（重启后仍隐藏），
+在 UI 里重新添加同名源即可恢复。
+
+## 源模板（多 key 负载均衡）
+
+多个上游 key 共享同一套配置（URL / 适配器 / 模型列表 / 并发 / rpm）时，逐一复制
+整段 source 太冗余。**源模板**保存除 `name` 和 `api_key` 以外的全部源字段，
+从模板一键创建多个仅 key 不同的源，天然支持多 key 负载均衡（每个展开源独立调度、
+独立冷却、独立健康状态）。
+
+- WebUI「源」页右上角「**模板管理**」按钮：列出全部模板，可编辑 / 删除 / 新建。
+- 添加源弹窗右上角两个按钮：
+  - **从模板创建** → 选模板 → 表单自动填充（name + key 仍需你填）；
+  - **存为模板** → 把当前表单非 key/name 字段存为新模板。
+- 模板持久化在 `runtime_file` 的 `source_templates` 字段，与运行时源一样热管理，
+  改完即时生效。模板本身不含密钥，可以安全共享 / 纳管。
+
+模板不会自己变成源——它只是「配方」。真正承担流量的是从模板创建出来的、带 key
+的具体源。
+

docs/webui.md

@@ -0,0 +1,23 @@
+# WebUI
+
+> 本文档由 README 拆分而来。
+> 返回 [README](../README.md)。
+
+## WebUI
+
+内置管理界面（`GET /`），登录后可在浏览器完成：
+
+- **状态页**：源在线状态（实时探测 + 悬停看错误）、模型/源/key 用量统计、请求记录，
+  支持按时间范围导出 CSV；点击模型可生成 pin 到该模型的连接配置。
+- **对话页**：流式/非流式调试。
+- **密钥页**：创建/编辑网关 key，为每个 key 配模型范围（模型 + 源 + token 配额 + 周期），
+  管理员管理全部 key，用户只看到自己的 key。每个模型砖块显示自己的配额徽标
+  （如 `1.0K 77×·1h`，未设配额显示 `∞`），点开可编辑该模型的 token 配额、
+  请求数配额与重置周期 —— 配额按模型独立生效，一个用满不影响同一 key 的其它模型。
+  「我的密钥」页对用户展示本 key 的模型范围与各自配额。
+- **优先级页**：拖拽积木配置 AUTO 链档位。
+- **源页**：在线增删改上游源（API key 等敏感字段加密落盘）。
+- **适配器页**：上传 / 删除 Lua 适配器脚本。
+
+改动写入 `runtime_file`（重启仍生效）。
+

e2e/channels_device_e2e_test.go

@@ -1,170 +0,0 @@
-package e2e
-
-import (
-	"encoding/json"
-	"fmt"
-	"io"
-	"net"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync/atomic"
-	"testing"
-	"time"
-)
-
-// TestChannelsDevicePollE2E 用**真二进制**跑通 channels 插件的 device-poll 登录：
-//
-//	发起登录(start_login) → 页面轮询(poll_login) 推进设备码换 token
-//	→ 凭据入保险库 → add_source 把平台接成上游源 → /v1/models 里出现其模型
-//
-// 这是对参考仓库 dsh-our-free-model「登录→领额度→接入源」形态的端到端对齐：
-// 行为（HTTP 决策分支、会话推进、最终可路由）在真进程里验证，而不是单元桩。
-//
-// 假上游模拟 MiniMax 的两个端点：设备码申请 + token 轮询（脚本化逐次响应）。
-func TestChannelsDevicePollE2E(t *testing.T) {
-	// ---- 假平台上游（loopback，白名单天然放行）----
-	var tokenHits int32
-	var tokenScript atomic.Value // []scriptStep
-	tokenScript.Store([]scriptStep{})
-	plat := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/oauth2/device/code":
-			w.Header().Set("Content-Type", "application/json")
-			fmt.Fprint(w, `{"device_code":"DEV-E2E","user_code":"WXYZ-1234","verification_uri":"https://example/activate","interval":1,"expires_in":600}`)
-		case "/oauth2/token":
-			i := int(atomic.AddInt32(&tokenHits, 1)) - 1
-			script := tokenScript.Load().([]scriptStep)
-			w.Header().Set("Content-Type", "application/json")
-			if i >= len(script) {
-				w.WriteHeader(500)
-				fmt.Fprint(w, `{"error":"unexpected"}`)
-				return
-			}
-			if script[i].code != 0 && script[i].code != 200 {
-				w.WriteHeader(script[i].code)
-			}
-			fmt.Fprint(w, script[i].body)
-		case "/v1/models":
-			// 接入源后内核会探测可达；回一个 OpenAI 形状的模型列表
-			w.Header().Set("Content-Type", "application/json")
-			fmt.Fprint(w, `{"object":"list","data":[{"id":"MiniMax-M3","object":"model"}]}`)
-		case "/v1/chat/completions":
-			w.Header().Set("Content-Type", "application/json")
-			fmt.Fprint(w, `{"choices":[{"message":{"content":"ok"},"finish_reason":"stop"}],"usage":{"prompt_tokens":1,"completion_tokens":1,"total_tokens":2}}`)
-		default:
-			w.WriteHeader(404)
-		}
-	}))
-	defer plat.Close()
-
-	// ---- 真二进制 + 配置（带 plugin_dir，让 bundled channels 落地 + 授权可持久化）----
-	dir := t.TempDir()
-	addr := mustAddr(t)
-	pluginDir := filepath.Join(dir, "plugins") // 不预建：SeedBundled 见空目录才落地内置插件
-	cfg := "listen: " + addr + "\n" +
-		"gateway_keys:\n  - sk-e2e-0001\n" +
-		"default_model: none\n" +
-		"adapter_dir: " + filepath.Join(dir, "adapters") + "\n" +
-		"plugin_dir: " + pluginDir + "\n" +
-		"runtime_file: " + filepath.Join(dir, "runtime.json") + "\n" +
-		"sources: []\n"
-	cfgPath := filepath.Join(dir, "config.yaml")
-	if err := os.WriteFile(cfgPath, []byte(cfg), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	bin := buildBinary(t)
-	g := startGatewayNoModels(t, bin, addr, cfgPath)
-
-	call := func(method, path, body string) (int, map[string]interface{}) {
-		resp, raw := g.do(method, path, body, true)
-		var m map[string]interface{}
-		_ = json.Unmarshal([]byte(raw), &m)
-		return statusOf(resp), m
-	}
-
-	// 1) 授权内核动作（运维批准 add_source 等）+ 把 minimax 端点指到假上游。
-	st, m := call("PUT", "/api/plugins/channels/kernel",
-		`{"actions":["add_source","status","list_sources","probe_all","reset_health"],"all_read":false}`)
-	if st != 200 {
-		t.Fatalf("授权内核动作失败: status=%d body=%v", st, m)
-	}
-	st, m = call("POST", "/api/plugins/channels/call/set_endpoints", fmt.Sprintf(
-		`{"platform":"minimax","base_url":%q,"device":{"code_url":%q,"token_url":%q}}`,
-		plat.URL+"/v1", plat.URL+"/oauth2/device/code", plat.URL+"/oauth2/token"))
-	if st != 200 {
-		t.Fatalf("set_endpoints 失败: status=%d body=%v", st, m)
-	}
-
-	// 2) 发起 device-poll 登录：拿到会话 + user_code。
-	st, m = call("POST", "/api/plugins/http/channels/login", `{"platform":"minimax"}`)
-	if st != 200 {
-		t.Fatalf("start_login status=%d body=%v", st, m)
-	}
-	sess, _ := m["session"].(map[string]interface{})
-	if sess == nil || sess["user_code"] != "WXYZ-1234" {
-		t.Fatalf("start_login 未透传 user_code: %v", m)
-	}
-	sid, _ := sess["id"].(string)
-	if sid == "" {
-		t.Fatal("无会话 id")
-	}
-
-	// 3) 第一次轮询：上游 pending → 会话仍 pending。
-	tokenScript.Store([]scriptStep{{code: 400, body: `{"error":"authorization_pending"}`}})
-	atomic.StoreInt32(&tokenHits, 0)
-	st, m = call("GET", "/api/plugins/http/channels/login/status?id="+sid, "")
-	if m["state"] != "pending" {
-		t.Fatalf("轮询1 应 pending, 实得 %v", m)
-	}
-
-	// 4) 第二次轮询：上游发 access_token → 会话 completed，凭据入库 + 接入源。
-	tokenScript.Store([]scriptStep{{code: 200, body: `{"access_token":"MM-E2E-TOKEN","refresh_token":"MM-RF","nickname":"e2e-user"}`}})
-	atomic.StoreInt32(&tokenHits, 0)
-	deadline := time.Now().Add(5 * time.Second)
-	for time.Now().Before(deadline) {
-		st, m = call("GET", "/api/plugins/http/channels/login/status?id="+sid, "")
-		if m["state"] == "completed" || m["state"] == "failed" {
-			break
-		}
-		time.Sleep(150 * time.Millisecond)
-	}
-	if m["state"] != "completed" {
-		t.Fatalf("轮询2 应 completed, 实得 %v", m)
-	}
-	if m["account"] != "e2e-user" {
-		t.Fatalf("account 应取 nickname, 实得 %v", m)
-	}
-
-	// 5) 接入源的终局证据：/v1/models 里出现 channels-minimax 的模型。
-	deadline = time.Now().Add(5 * time.Second)
-	var modelsBody string
-	for time.Now().Before(deadline) {
-		resp, raw := g.do("GET", "/v1/models", "", true)
-		modelsBody = raw
-		if resp != nil && resp.StatusCode == 200 && strings.Contains(raw, "MiniMax-M3") {
-			break
-		}
-		time.Sleep(150 * time.Millisecond)
-	}
-	if !strings.Contains(modelsBody, "MiniMax-M3") {
-		t.Fatalf("接入源后 /v1/models 未出现 MiniMax-M3: %s", modelsBody)
-	}
-}
-
-type scriptStep struct {
-	code int
-	body string
-}
-
-// startGatewayNoModels 与 startGateway 相同，但就绪探针不要求 /v1/models 返回
-// 非空：本用例启动时没有任何源，/v1/models 是空列表（200 即就绪）。
-func startGatewayNoModels(t *testing.T, bin, listen, cfgPath string) *gatewayUnderTest {
-	t.Helper()
-	return startGateway(t, bin, listen, cfgPath)
-}
-
-var _ = net.Listen
-var _ = io.Discard

e2e/channels_flows_e2e_test.go

@@ -1,200 +0,0 @@
-package e2e
-
-import (
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync/atomic"
-	"testing"
-	"time"
-)
-
-// TestChannelsFlowsE2E 用真二进制补齐另外三条流程的端到端：
-//
-//	Cline（WorkOS device-poll 两步：authenticate → register 换最终凭据）
-//	paste（opencode：直接 complete_login 贴 API key）
-//	manual（qoder：start_login 返回 manual_hint，再凭据完成）
-//
-// 终局证据与 TestChannelsDevicePollE2E 同一标准：/v1/models 出现该平台模型。
-func TestChannelsFlowsE2E(t *testing.T) {
-	var authHits, regHits int32
-	plat := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
-		switch r.URL.Path {
-		// ---- Cline（WorkOS）----
-		case "/user_management/authorize/device":
-			fmt.Fprint(w, `{"device_code":"CD-E2E","user_code":"CLNE-1234","verification_uri":"https://example/activate","interval":1,"expires_in":600}`)
-		case "/user_management/authenticate":
-			if atomic.AddInt32(&authHits, 1) == 1 {
-				w.WriteHeader(400)
-				fmt.Fprint(w, `{"error":"authorization_pending"}`)
-				return
-			}
-			fmt.Fprint(w, `{"access_token":"WO-E2E-AT","refresh_token":"WO-E2E-RT"}`)
-		case "/api/v1/auth/register":
-			atomic.AddInt32(&regHits, 1)
-			fmt.Fprint(w, `{"success":true,"data":{"accessToken":"CLINE-E2E-AT","refreshToken":"CLINE-E2E-RT","userInfo":{"email":"dev@example.com"}}}`)
-		// ---- 上游推理面（opencode/qoder/cline 的 base_url 都指到这里）----
-		case "/v1/models":
-			fmt.Fprint(w, `{"object":"list","data":[{"id":"big-pickle","object":"model"},{"id":"qoder-default","object":"model"},{"id":"stealth/space-bunny-alpha","object":"model"}]}`)
-		case "/v1/chat/completions":
-			fmt.Fprint(w, `{"choices":[{"message":{"content":"ok"},"finish_reason":"stop"}],"usage":{"prompt_tokens":1,"completion_tokens":1,"total_tokens":2}}`)
-		default:
-			w.WriteHeader(404)
-		}
-	}))
-	defer plat.Close()
-
-	dir := t.TempDir()
-	addr := mustAddr(t)
-	pluginDir := filepath.Join(dir, "plugins")
-	cfg := "listen: " + addr + "\n" +
-		"gateway_keys:\n  - sk-e2e-0001\n" +
-		"default_model: none\n" +
-		"adapter_dir: " + filepath.Join(dir, "adapters") + "\n" +
-		"plugin_dir: " + pluginDir + "\n" +
-		"runtime_file: " + filepath.Join(dir, "runtime.json") + "\n" +
-		"sources: []\n"
-	cfgPath := filepath.Join(dir, "config.yaml")
-	if err := os.WriteFile(cfgPath, []byte(cfg), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	bin := buildBinary(t)
-	g := startGatewayNoModels(t, bin, addr, cfgPath)
-
-	call := func(method, path, body string) (int, map[string]interface{}) {
-		resp, raw := g.do(method, path, body, true)
-		var m map[string]interface{}
-		_ = json.Unmarshal([]byte(raw), &m)
-		return statusOf(resp), m
-	}
-
-	st, m := call("PUT", "/api/plugins/channels/kernel",
-		`{"actions":["add_source","status","list_sources","probe_all","reset_health"],"all_read":false}`)
-	if st != 200 {
-		t.Fatalf("授权内核动作失败: status=%d body=%v", st, m)
-	}
-
-	// ---------- ① Cline：WorkOS 设备码两步 ----------
-	st, m = call("POST", "/api/plugins/channels/call/set_endpoints", fmt.Sprintf(
-		`{"platform":"cline","base_url":%q,"device":{"code_url":%q,"token_url":%q},"register":{"url":%q}}`,
-		plat.URL, plat.URL+"/user_management/authorize/device",
-		plat.URL+"/user_management/authenticate", plat.URL+"/api/v1/auth/register"))
-	if st != 200 {
-		t.Fatalf("set_endpoints(cline) 失败: status=%d body=%v", st, m)
-	}
-	st, m = call("POST", "/api/plugins/http/channels/login", `{"platform":"cline"}`)
-	if st != 200 {
-		t.Fatalf("cline start_login status=%d body=%v", st, m)
-	}
-	sess, _ := m["session"].(map[string]interface{})
-	if sess == nil || sess["user_code"] != "CLNE-1234" {
-		t.Fatalf("cline start_login 未透传 user_code: %v", m)
-	}
-	sid, _ := sess["id"].(string)
-
-	// 第一拍 pending（authorization_pending），第二拍 completed
-	atomic.StoreInt32(&authHits, 0)
-	st, m = call("GET", "/api/plugins/http/channels/login/status?id="+sid, "")
-	if m["state"] != "pending" {
-		t.Fatalf("cline 轮询1 应 pending, 实得 %v", m)
-	}
-	deadline := time.Now().Add(5 * time.Second)
-	for time.Now().Before(deadline) {
-		st, m = call("GET", "/api/plugins/http/channels/login/status?id="+sid, "")
-		if m["state"] == "completed" || m["state"] == "failed" {
-			break
-		}
-		time.Sleep(150 * time.Millisecond)
-	}
-	if m["state"] != "completed" {
-		t.Fatalf("cline 轮询2 应 completed, 实得 %v", m)
-	}
-	if m["account"] != "dev@example.com" {
-		t.Fatalf("cline account 应取 register userInfo.email, 实得 %v", m)
-	}
-	if atomic.LoadInt32(&regHits) != 1 {
-		t.Fatalf("register 应恰好调用一次, 实得 %d", regHits)
-	}
-	// 凭据必须是 register 的最终 token，不是 WorkOS token
-	var modelsBody string
-	deadline = time.Now().Add(5 * time.Second)
-	for time.Now().Before(deadline) {
-		resp, raw := g.do("GET", "/v1/models", "", true)
-		modelsBody = raw
-		if resp != nil && resp.StatusCode == 200 && strings.Contains(raw, "stealth/space-bunny-alpha") {
-			break
-		}
-		time.Sleep(150 * time.Millisecond)
-	}
-	if !strings.Contains(modelsBody, "stealth/space-bunny-alpha") {
-		t.Fatalf("cline 接入后 /v1/models 未出现其模型: %s", modelsBody)
-	}
-
-	// ---------- ② paste（opencode）：complete 直接贴 key ----------
-	st, m = call("POST", "/api/plugins/channels/call/set_endpoints", fmt.Sprintf(
-		`{"platform":"opencode","base_url":%q}`, plat.URL))
-	if st != 200 {
-		t.Fatalf("set_endpoints(opencode) 失败: %v", m)
-	}
-	st, m = call("POST", "/api/plugins/http/channels/login", `{"platform":"opencode"}`)
-	if st != 200 {
-		t.Fatalf("opencode start_login status=%d", st)
-	}
-	if sess, _ = m["session"].(map[string]interface{}); sess == nil || sess["flow"] != "paste" {
-		t.Fatalf("opencode 会话 flow 应 paste: %v", m)
-	}
-	st, m = call("POST", "/api/plugins/http/channels/login/complete",
-		`{"platform":"opencode","credential":"OC-E2E-KEY"}`)
-	if st != 200 || m["ok"] != true {
-		t.Fatalf("opencode complete 失败: status=%d body=%v", st, m)
-	}
-	deadline = time.Now().Add(5 * time.Second)
-	for time.Now().Before(deadline) {
-		resp, raw := g.do("GET", "/v1/models", "", true)
-		modelsBody = raw
-		if resp != nil && resp.StatusCode == 200 && strings.Contains(raw, "big-pickle") {
-			break
-		}
-		time.Sleep(150 * time.Millisecond)
-	}
-	if !strings.Contains(modelsBody, "big-pickle") {
-		t.Fatalf("opencode 接入后 /v1/models 未出现 big-pickle: %s", modelsBody)
-	}
-
-	// ---------- ③ manual（qoder）：hint 明确 + 凭据完成 ----------
-	st, m = call("POST", "/api/plugins/channels/call/set_endpoints", fmt.Sprintf(
-		`{"platform":"qoder","base_url":%q}`, plat.URL))
-	if st != 200 {
-		t.Fatalf("set_endpoints(qoder) 失败: %v", m)
-	}
-	st, m = call("POST", "/api/plugins/http/channels/login", `{"platform":"qoder"}`)
-	if st != 200 {
-		t.Fatalf("qoder start_login status=%d", st)
-	}
-	hint, _ := m["manual_hint"].(string)
-	if !strings.Contains(hint, "WASM") {
-		t.Fatalf("qoder manual_hint 应说明 WASM 不可自动, 实得 %q", hint)
-	}
-	st, m = call("POST", "/api/plugins/http/channels/login/complete",
-		`{"platform":"qoder","credential":"QD-E2E-KEY"}`)
-	if st != 200 || m["ok"] != true {
-		t.Fatalf("qoder complete 失败: status=%d body=%v", st, m)
-	}
-	deadline = time.Now().Add(5 * time.Second)
-	for time.Now().Before(deadline) {
-		resp, raw := g.do("GET", "/v1/models", "", true)
-		modelsBody = raw
-		if resp != nil && resp.StatusCode == 200 && strings.Contains(raw, "qoder-default") {
-			break
-		}
-		time.Sleep(150 * time.Millisecond)
-	}
-	if !strings.Contains(modelsBody, "qoder-default") {
-		t.Fatalf("qoder 接入后 /v1/models 未出现 qoder-default: %s", modelsBody)
-	}
-}

e2e/e2e_test.go

@@ -1,4 +1,4 @@
-// Package e2e runs the real llmsproxy binary against mocked upstreams over
+// Package e2e runs the real modelrouter binary against mocked upstreams over
 // real HTTP: startup, auth, chat, streaming SSE, image generation, and
 // AUTO failover when a higher-priority source fails.
 package e2e
@@ -100,15 +100,15 @@ type gatewayUnderTest struct {
 func buildBinary(t *testing.T) string {
 	t.Helper()
 	dir := t.TempDir()
-	bin := filepath.Join(dir, "llmsproxy")
+	bin := filepath.Join(dir, "modelrouter")
 	if runtime.GOOS == "windows" {
 		bin += ".exe" // go build writes the exact name; Windows needs the suffix to exec
 	}
-	out, err := exec.Command("go", "build", "-tags", "luajit", "-o", bin, "llmsproxy/cmd/llmsproxy").CombinedOutput()
+	out, err := exec.Command("go", "build", "-tags", "luajit", "-o", bin, "modelrouter/cmd/modelrouter").CombinedOutput()
 	if err != nil && runtime.GOOS == "windows" {
 		// local Windows dev box may lack LuaJIT: fall back to the bundled
 		// Lua runtime (the e2e adapters used here are passthrough-only)
-		out, err = exec.Command("go", "build", "-o", bin, "llmsproxy/cmd/llmsproxy").CombinedOutput()
+		out, err = exec.Command("go", "build", "-o", bin, "modelrouter/cmd/modelrouter").CombinedOutput()
 	}
 	if err != nil {
 		t.Fatalf("build: %v\n%s", err, out)
@@ -187,18 +187,20 @@ func writeConfig(t *testing.T, dir, listenAddr string, upstreams map[string]*moc
 	sb.WriteString("runtime_file: " + filepath.Join(dir, "runtime.json") + "\n")
 	sb.WriteString("sources:\n")
 	order := []string{"good", "fallback", "image"}
-	prio := map[string]int{"good": 100, "fallback": 50}
 	for _, name := range order {
 		u, ok := upstreams[name]
 		if !ok {
 			continue
 		}
 		if name == "image" {
-			sb.WriteString("  - name: imagegen\n    base_url: " + u.baseURL + "\n    adapter: openai\n    models:\n      - id: flux-1\n        kind: image\n        priority: 80\n")
+			sb.WriteString("  - name: imagegen\n    base_url: " + u.baseURL + "\n    adapter: openai\n    models:\n      - id: flux-1\n        kind: image\n")
 		} else {
-			sb.WriteString("  - name: " + name + "\n    base_url: " + u.baseURL + "\n    adapter: openai\n    models:\n      - id: " + name + "-m\n        priority: " + fmt.Sprint(prio[name]) + "\n")
+			sb.WriteString("  - name: " + name + "\n    base_url: " + u.baseURL + "\n    adapter: openai\n    models:\n      - id: " + name + "-m\n")
 		}
 	}
+	// AUTO 链现在是显式配置（25970a2 移除了 models.priority）。tier 越小越先试。
+	sb.WriteString("auto:\n  - model: good-m\n    source: good\n    tier: 1\n")
+	sb.WriteString("  - model: fallback-m\n    source: fallback\n    tier: 2\n")
 	path := filepath.Join(dir, "config.yaml")
 	if err := os.WriteFile(path, []byte(sb.String()), 0o644); err != nil {
 		t.Fatalf("write config: %v", err)

go.mod

@@ -1,4 +1,4 @@
-module llmsproxy
+module modelrouter
 
 go 1.25.0
 

internal/billing/compile.go

@@ -1,323 +0,0 @@
-package billing
-
-import (
-	"fmt"
-	"strings"
-
-	"llmsproxy/internal/config"
-)
-
-// Compile turns one billing profile into the prices table the billing plugin
-// expects, resolving URL rules against the gateway's actual sources.
-//
-// WHY URL RULES NEED RESOLVING AT ALL: the operator declares pricing by URL
-// because that is what a provider's price list is keyed on, and because several
-// sources can point at the same URL. The plugin, however, looks up by
-// `payload.source` (a source NAME) and by model — it has no idea what URL a
-// request went to. So the URL match happens here, at compile time, where the
-// config's name->base_url mapping is known, and the result is expressed in the
-// dimensions the plugin already supports.
-//
-// Profiles are the "let the user choose" axis: the same URL can appear in
-// several profiles and switching recomputes this table, so a gateway can be
-// repriced without editing the plugin.
-func Compile(profile *config.BillingProfile, sources []config.Source) (map[string]interface{}, error) {
-	return CompileOpts(profile, sources, false)
-}
-
-// CompileOpts is Compile with an explicit policy for rules that match no
-// source.
-//
-// The default is STRICT and that is correct for startup: a profile with a
-// typo'd URL prices nothing, every request on it is recorded as unpriced, and
-// the bill silently comes out wrong. Failing the load is the right response.
-//
-// The rules editor needs the opposite. An operator editing a half-finished
-// profile — adding a rule before the source that will use it exists, or
-// renaming a URL while typing — must be able to save and then see the warning,
-// not be blocked by an error they can only resolve by guessing. Lenient mode
-// keeps the offending rule in the config and drops it from the compiled table,
-// so it is preserved as text and clearly reported, without pretending it
-// prices anything.
-func CompileOpts(profile *config.BillingProfile, sources []config.Source, lenient bool) (map[string]interface{}, error) {
-	if profile == nil {
-		return nil, fmt.Errorf("no billing profile")
-	}
-	prices := map[string]interface{}{
-		"currency": "USD",
-		"default":  map[string]interface{}{"prompt": 0.0, "completion": 0.0, "per_request": 0.0},
-		"sources":  map[string]interface{}{},
-		"models":   map[string]interface{}{},
-		"keys":     map[string]interface{}{},
-	}
-	if profile.Default != "" {
-		prices["default_mode"] = profile.Default
-	}
-
-	// Currency is a profile-level statement; a rule may override it.
-	for i := range profile.Rules {
-		if c := profile.Rules[i].Currency; c != "" {
-			prices["currency"] = c
-			break
-		}
-	}
-
-	matched := map[string]bool{}
-	for i := range profile.Rules {
-		rule := &profile.Rules[i]
-		targets := matchSources(rule.URL, sources)
-		if len(targets) == 0 && rule.URL != "*" {
-			// A rule for a URL no source uses is almost always a typo (or a
-			// source that was removed). Failing loudly beats a profile that
-			// silently prices nothing — the whole reason this is a config file
-			// instead of a hand-written JSON blob.
-			if lenient {
-				continue // kept in the config text, reported as a warning
-			}
-			return nil, fmt.Errorf("rule url %q matches no configured source base_url", rule.URL)
-		}
-		for _, srcName := range targets {
-			if matched[srcName] {
-				// First rule wins. Two rules matching one source is ambiguous,
-				// and silently letting the later one win makes the file's
-				// meaning depend on ordering the operator cannot see.
-				continue
-			}
-			matched[srcName] = true
-			if err := applyRule(prices, rule, srcName, sources); err != nil {
-				return nil, err
-			}
-		}
-	}
-
-	// Sources no rule matched fall through to the profile default, which the
-	// plugin applies via prices.default. Recording them explicitly means the
-	// UI can say "this source is unpriced" instead of leaving the operator to
-	// infer it from a zero.
-	var unmatched []string
-	for _, src := range sources {
-		if !matched[src.Name] {
-			unmatched = append(unmatched, src.Name)
-		}
-	}
-	if len(unmatched) > 0 {
-		prices["unmatched_sources"] = unmatched
-	}
-	return prices, nil
-}
-
-// matchSources returns the source names whose base_url matches pattern.
-// "*" matches every source (used as a catch-all default rule).
-func matchSources(pattern string, sources []config.Source) []string {
-	var out []string
-	if pattern == "*" {
-		for _, s := range sources {
-			out = append(out, s.Name)
-		}
-		return out
-	}
-	want := normalizeURL(pattern)
-	for _, s := range sources {
-		if normalizeURL(s.BaseURL) == want {
-			out = append(out, s.Name)
-		}
-	}
-	return out
-}
-
-// normalizeURL compares URLs the way an operator expects: trailing slashes and
-// case in the host are differences the provider's price list does not care
-// about, and requiring an exact byte match would make the config brittle.
-func normalizeURL(u string) string {
-	u = strings.TrimSpace(u)
-	u = strings.TrimRight(u, "/")
-	return strings.ToLower(u)
-}
-
-// applyRule writes one rule's pricing for one source into the prices table.
-func applyRule(prices map[string]interface{}, rule *config.BillingRule, srcName string, sources []config.Source) error {
-	switch rule.Mode {
-	case "free":
-		// Explicitly priced at zero. This is NOT the same as unpriced: a source
-		// the operator says is free must not appear in the unpriced warnings,
-		// or those warnings become noise and stop being read.
-		prices["sources"].(map[string]interface{})[srcName] = map[string]interface{}{
-			"prompt": 0.0, "completion": 0.0, "per_request": 0.0,
-		}
-		return nil
-
-	case "subscription":
-		// A fixed monthly commitment: the per-request MARGINAL cost is zero, and
-		// the flat fee is reported separately. Spreading a monthly fee across
-		// requests would invent a per-request number the provider never charges,
-		// and it would change every time traffic did.
-		prices["sources"].(map[string]interface{})[srcName] = map[string]interface{}{
-			"prompt": 0.0, "completion": 0.0, "per_request": 0.0,
-		}
-		fixed, _ := prices["subscriptions"].(map[string]interface{})
-		if fixed == nil {
-			fixed = map[string]interface{}{}
-			prices["subscriptions"] = fixed
-		}
-		cur := "USD"
-		if rule.Currency != "" {
-			cur = rule.Currency
-		}
-		fixed[srcName] = map[string]interface{}{
-			"monthly": rule.Subscription, "currency": cur,
-		}
-		return nil
-
-	case "unpriced":
-		// Deliberately left out of `sources` so the plugin's unpriced_models /
-		// unpriced_reqs counters catch it. That is the point: a subscription
-		// plan whose credits cannot be converted to tokens must be VISIBLE as
-		// unbilled, not quietly estimated.
-		return nil
-
-	case "token":
-		if len(rule.Models) == 0 {
-			return fmt.Errorf("rule for url %q: mode token requires at least one model", rule.URL)
-		}
-		models := prices["models"].(map[string]interface{})
-		for modelID, t := range rule.Models {
-			entry := map[string]interface{}{}
-			prompt, err := usdPerM(t.Prompt)
-			if err != nil {
-				return fmt.Errorf("model %q prompt: %w", modelID, err)
-			}
-			completion, err := usdPerM(t.Completion)
-			if err != nil {
-				return fmt.Errorf("model %q completion: %w", modelID, err)
-			}
-			entry["prompt"] = prompt
-			entry["completion"] = completion
-			if t.CacheDiscount != nil {
-				entry["cache_discount"] = *t.CacheDiscount
-			}
-			// reasoning is optional and stays ABSENT (not nil, not 0) when the
-			// rule does not set it, which is what makes the billing plugin skip
-			// the repricing branch entirely. Writing an explicit 0 here would
-			// mean "thinking is free" and silently under-bill every request
-			// from a provider that bills it like ordinary output.
-			if strings.TrimSpace(t.Reasoning) != "" {
-				rp, err := usdPerM(t.Reasoning)
-				if err != nil {
-					return fmt.Errorf("model %q reasoning: %w", modelID, err)
-				}
-				entry["reasoning_price"] = rp
-			}
-			if lc := t.LongContext; lc != nil {
-				if lc.Above <= 0 {
-					return fmt.Errorf("model %q long_context: above must be > 0", modelID)
-				}
-				above, err := longContextRate(lc, prompt)
-				if err != nil {
-					return fmt.Errorf("model %q long_context: %w", modelID, err)
-				}
-				entry["long_context"] = map[string]interface{}{
-					"above": lc.Above,
-					// Marginal, not blended. The plugin charges the tokens past the
-					// threshold at this rate and the rest at the base rate, so the
-					// threshold composes with a cache discount (which applies to the
-					// cached portion) instead of forcing the plugin to guess how
-					// the two interact.
-					"prompt": above,
-				}
-			}
-			if rule.Peak != nil {
-				entry["peak"] = compilePeak(rule.Peak)
-			}
-			models[modelID] = entry
-		}
-		// A specific-URL token rule needs a source entry so a model served
-		// from THIS url but absent from `rule.Models` is still recognised as
-		// belonging to a priced provider.
-		//
-		// A WILDCARD rule ("*") must NOT get one. "*" is a model catalogue — it
-		// says "these model ids have these prices, wherever they come from" —
-		// and marking every source priced at {0,0} would make priceFor() set
-		// priced=true for every model the catalogue does NOT list. Paid
-		// sources (commandcode, alittokenplan, …) would then record $0 instead
-		// of showing up in unpriced_reqs, which is precisely the silent
-		// zero-billing failure this whole plugin is built to make visible.
-		// The model lookup p.models[payload.model] already marks a listed
-		// model priced on its own, so the wildcard loses nothing.
-		if rule.URL != "*" {
-			if _, ok := prices["sources"].(map[string]interface{})[srcName]; !ok {
-				prices["sources"].(map[string]interface{})[srcName] = map[string]interface{}{
-					"prompt": 0.0, "completion": 0.0, "per_request": 0.0,
-				}
-			}
-		}
-		return nil
-	}
-	return fmt.Errorf("unknown mode %q", rule.Mode)
-}
-
-// usdPerM converts a USD-per-million string into the per-token rate the plugin
-// expects. Delegates to config.ParseFloatUSDPerM so the DSL validator and the
-// compiler agree byte-for-byte on what a valid price is — a value that passes
-// Validate() but fails here (or vice versa) would be the worst kind of drift.
-func usdPerM(s string) (float64, error) {
-	return config.ParseFloatUSDPerM(s)
-}
-
-// compilePeak renders the peak window in the shape the plugin reads:
-// { multiplier, windows = { { days = {...}, hours = { {lo,hi}, ... } } } }.
-//
-// The plugin reads `days` / `hours` pairs. The first version of the deployed
-// price table used { start, end, weekdays } — a shape nothing reads — so peak
-// traffic was billed at off-peak rates with no error anywhere. Compiling from
-// typed config fields removes the chance of writing the wrong key names by hand.
-func compilePeak(p *config.BillingPeak) map[string]interface{} {
-	win := map[string]interface{}{}
-	if len(p.Weekdays) > 0 {
-		days := make([]interface{}, 0, len(p.Weekdays))
-		for _, d := range p.Weekdays {
-			days = append(days, d)
-		}
-		win["days"] = days
-	}
-	if len(p.Hours) > 0 {
-		hours := make([]interface{}, 0, len(p.Hours))
-		for _, h := range p.Hours {
-			hours = append(hours, []interface{}{h[0], h[1]})
-		}
-		win["hours"] = hours
-	}
-	out := map[string]interface{}{"multiplier": p.Multiplier}
-	if len(win) > 0 {
-		out["windows"] = []interface{}{win}
-	}
-	return out
-}
-
-// longContextRate resolves the marginal per-token rate for the tokens ABOVE a
-// threshold, given the model's base per-million prompt price.
-//
-// Two ways to express it are supported because providers publish both: an
-// absolute rate (OpenAI quotes \$3.00/M past 200k) and a multiple (DeepSeek
-// quotes exactly 2x past 128k). Neither may be missing: a step with no rate is a
-// silent no-op, and an operator who wrote one meant something.
-func longContextRate(lc *config.BillingLongContext, basePerToken float64) (float64, error) {
-	hasPrompt := strings.TrimSpace(lc.Prompt) != ""
-	hasMult := lc.Multiplier > 0
-	switch {
-	case hasPrompt && hasMult:
-		p, err := usdPerM(lc.Prompt)
-		if err != nil {
-			return 0, err
-		}
-		// Both given: the absolute rate wins, because it is the one the provider
-		// actually quotes. Silently multiplying instead would produce a number
-		// the operator never wrote.
-		return p, nil
-	case hasPrompt:
-		return usdPerM(lc.Prompt)
-	case hasMult:
-		return basePerToken * lc.Multiplier, nil
-	default:
-		return 0, fmt.Errorf("needs either prompt or multiplier")
-	}
-}

internal/billing/wildcard_test.go

@@ -1,214 +0,0 @@
-package billing
-
-import (
-	"testing"
-
-	"llmsproxy/internal/config"
-)
-
-// The wildcard token rule must not blanket-mark every source as priced.
-//
-// Why this is a hazard and not a style question: priceFor() sets priced=true as
-// soon as the request's SOURCE has an entry in the price table, and that flag
-// is what keeps a request OUT of unpriced_reqs. A "*" rule is a model
-// catalogue — it prices specific model ids wherever they come from — but
-// compiling it into a {0,0,0} entry on all 21 sources made every model the
-// catalogue does not list look "priced at zero". Paid providers (commandcode,
-// alittokenplan, …) then stopped appearing in the unpriced warnings, which is
-// exactly the silent zero-billing failure the plugin exists to surface.
-func TestWildcardTokenRuleDoesNotMarkEverySourcePriced(t *testing.T) {
-	sources := []config.Source{
-		{Name: "free1", BaseURL: "https://free1.example.com/v1"},
-		{Name: "paid1", BaseURL: "https://paid1.example.com/v1"},
-		{Name: "paid2", BaseURL: "https://paid2.example.com/v1"},
-	}
-	profile := &config.BillingProfile{
-		ID: "p",
-		Rules: []config.BillingRule{
-			{URL: "https://free1.example.com/v1", Mode: "free"},
-			{
-				URL: "*", Mode: "token",
-				Models: map[string]config.BillingToken{
-					"only-catalogued-model": {Prompt: "1.00", Completion: "2.00"},
-				},
-			},
-		},
-	}
-	prices, err := Compile(profile, sources)
-	if err != nil {
-		t.Fatalf("compile: %v", err)
-	}
-	srcs := prices["sources"].(map[string]interface{})
-
-	// The explicitly free source keeps its entry (free is a deliberate 0).
-	if _, ok := srcs["free1"]; !ok {
-		t.Error("the explicit free rule lost its source entry")
-	}
-	// Paid sources must NOT be marked, or their unlisted models bill $0.
-	for _, name := range []string{"paid1", "paid2"} {
-		if _, ok := srcs[name]; ok {
-			t.Errorf("★ wildcard token rule marked %q as priced at 0 — its unlisted "+
-				"models will bill $0 instead of appearing as unpriced", name)
-		}
-	}
-	// The catalogue itself must still be present, or the rule prices nothing.
-	models := prices["models"].(map[string]interface{})
-	if _, ok := models["only-catalogued-model"]; !ok {
-		t.Error("the wildcard rule did not publish its model price")
-	}
-}
-
-// The inverse guard: a token rule for a SPECIFIC url still marks that source,
-// because it genuinely declares pricing for the models served from it.
-func TestSpecificURLTokenRuleStillMarksItsSource(t *testing.T) {
-	sources := []config.Source{
-		{Name: "mine", BaseURL: "https://mine.example.com/v1"},
-		{Name: "other", BaseURL: "https://other.example.com/v1"},
-	}
-	profile := &config.BillingProfile{
-		ID: "p",
-		Rules: []config.BillingRule{{
-			URL: "https://mine.example.com/v1", Mode: "token",
-			Models: map[string]config.BillingToken{
-				"m": {Prompt: "1.00", Completion: "2.00"},
-			},
-		}},
-	}
-	prices, err := Compile(profile, sources)
-	if err != nil {
-		t.Fatalf("compile: %v", err)
-	}
-	srcs := prices["sources"].(map[string]interface{})
-	if _, ok := srcs["mine"]; !ok {
-		t.Error("a specific-url token rule must still mark its own source priced")
-	}
-	if _, ok := srcs["other"]; ok {
-		t.Error("an unrelated source was marked priced by a specific-url rule")
-	}
-}
-
-// TestReasoningPriceIsOmittedUnlessSet pins the absence convention for the
-// thinking-token rate.
-//
-// A rule that says nothing about reasoning must produce a price entry with NO
-// reasoning_price key, so the billing plugin skips the repricing branch and
-// bills thinking at the ordinary output rate — which is what every provider
-// actually charges. Writing an explicit 0 instead would read as "thinking is
-// free" and silently under-bill every request from that model.
-func TestReasoningPriceIsOmittedUnlessSet(t *testing.T) {
-	sources := []config.Source{{Name: "up", BaseURL: "https://up.example/v1"}}
-
-	// Case 1: no reasoning declared → the key must not appear.
-	p1 := &config.BillingProfile{ID: "p", Rules: []config.BillingRule{{
-		URL: "https://up.example/v1", Mode: "token",
-		Models: map[string]config.BillingToken{
-			"m": {Prompt: "1.00", Completion: "2.00"},
-		},
-	}}}
-	prices, err := Compile(p1, sources)
-	if err != nil {
-		t.Fatal(err)
-	}
-	entry := prices["models"].(map[string]interface{})["m"].(map[string]interface{})
-	if _, present := entry["reasoning_price"]; present {
-		t.Errorf("reasoning_price present (%v) without a rule; the plugin would treat 0 as free",
-			entry["reasoning_price"])
-	}
-
-	// Case 2: declared → present, and converted to per-token like every other rate.
-	p2 := &config.BillingProfile{ID: "p", Rules: []config.BillingRule{{
-		URL: "https://up.example/v1", Mode: "token",
-		Models: map[string]config.BillingToken{
-			"m": {Prompt: "1.00", Completion: "2.00", Reasoning: "6.00"},
-		},
-	}}}
-	prices2, err := Compile(p2, sources)
-	if err != nil {
-		t.Fatal(err)
-	}
-	e2 := prices2["models"].(map[string]interface{})["m"].(map[string]interface{})
-	rp, ok := e2["reasoning_price"].(float64)
-	if !ok {
-		t.Fatalf("reasoning_price missing or wrong type: %#v", e2["reasoning_price"])
-	}
-	if rp != 6e-6 {
-		t.Errorf("reasoning_price = %v, want 6e-6 (USD per TOKEN)", rp)
-	}
-	// A malformed rate must be rejected, not silently ignored: an operator who
-	// typed "6 USD" expects either that value or an error, never a rule that
-	// looks applied and bills nothing.
-	p3 := &config.BillingProfile{ID: "p", Rules: []config.BillingRule{{
-		URL: "https://up.example/v1", Mode: "token",
-		Models: map[string]config.BillingToken{
-			"m": {Prompt: "1.00", Completion: "2.00", Reasoning: "six dollars"},
-		},
-	}}}
-	if _, err := Compile(p3, sources); err == nil {
-		t.Error("a non-numeric reasoning rate must fail the compile")
-	}
-}
-
-// TestLongContextStepCompiles pins the long-context step's two accepted forms
-// and its rejection of a step that would silently do nothing.
-//
-// Providers publish both shapes — DeepSeek says "2x past 128k", OpenAI quotes
-// an absolute "$3.00/M past 200k" — so both must compile. Neither may be
-// missing: a step with no rate is a rule that LOOKS like it handles long
-// context and does not, which under-bills without any visible sign.
-func TestLongContextStepCompiles(t *testing.T) {
-	sources := []config.Source{{Name: "up", BaseURL: "https://up.example/v1"}}
-
-	compile := func(lc config.BillingLongContext) (map[string]interface{}, error) {
-		p := &config.BillingProfile{ID: "p", Rules: []config.BillingRule{{
-			URL: "https://up.example/v1", Mode: "token",
-			Models: map[string]config.BillingToken{
-				"m": {Prompt: "1.00", Completion: "2.00", LongContext: &lc},
-			},
-		}}}
-		prices, err := Compile(p, sources)
-		if err != nil {
-			return nil, err
-		}
-		e := prices["models"].(map[string]interface{})["m"].(map[string]interface{})
-		return e["long_context"].(map[string]interface{}), nil
-	}
-
-	// Absolute rate (OpenAI's published shape).
-	lc1, err := compile(config.BillingLongContext{Above: 200000, Prompt: "3.00"})
-	if err != nil {
-		t.Fatalf("absolute long_context rate rejected: %v", err)
-	}
-	if lc1["above"] != 200000 || lc1["prompt"] != 3e-6 {
-		t.Errorf("absolute step = %#v, want above=200000 prompt=3e-6", lc1)
-	}
-
-	// Multiplier (DeepSeek's shape): 2x of the 1.00/M base.
-	lc2, err := compile(config.BillingLongContext{Above: 128000, Multiplier: 2})
-	if err != nil {
-		t.Fatalf("multiplier long_context rejected: %v", err)
-	}
-	if lc2["prompt"] != 2e-6 {
-		t.Errorf("multiplier step = %#v, want prompt=2e-6", lc2)
-	}
-
-	// Both given: the absolute rate wins, because that is the number the
-	// provider quotes. Multiplying instead would produce a figure the operator
-	// never wrote.
-	lc3, err := compile(config.BillingLongContext{Above: 128000, Prompt: "5.00", Multiplier: 2})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if lc3["prompt"] != 5e-6 {
-		t.Errorf("both given = %#v, want the quoted absolute rate 5e-6", lc3)
-	}
-
-	// Neither: a no-op step must fail, not compile into a rule that silently
-	// bills long context at the base rate.
-	if _, err := compile(config.BillingLongContext{Above: 128000}); err == nil {
-		t.Error("a step with neither prompt nor multiplier must be rejected")
-	}
-	// A zero threshold would make every request "long".
-	if _, err := compile(config.BillingLongContext{Above: 0, Multiplier: 2}); err == nil {
-		t.Error("above=0 must be rejected")
-	}
-}

internal/config/config.go

@@ -7,7 +7,6 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
-	"strconv"
 	"strings"
 	"time"
 
@@ -30,15 +29,6 @@ type Config struct {
 	Auto          []ModelScope `yaml:"auto,omitempty"`       // AUTO 调度链规则（WebUI 优先级页编辑，chat）
 	AutoImage     []ModelScope `yaml:"auto_image,omitempty"` // AUTO 生图调度链规则（WebUI 优先级页·生图）
 	Keys          []GWKey      `yaml:"keys,omitempty"`       // 网关密钥（WebUI 密钥页管理）
-	// BillingDSL declares per-URL pricing profiles for the billing plugin.
-	//
-	// Declarative, because hand-writing the prices JSON was error-prone in ways
-	// that looked successful: the first PUT went out without the required
-	// `prices` wrapper and silently REPLACED the accumulated totals with the
-	// price table; the second used a peak-window shape the plugin does not read,
-	// so peak traffic was billed at off-peak rates — no error, the bill just
-	// quietly halved. A schema-checked config file catches both at load.
-	BillingDSL *BillingDSL `yaml:"billing,omitempty"`
 	// PluginVisibility overrides the audience a plugin declared for itself,
 	// keyed by plugin name: "admin" hides a plugin (and its state) from user
 	// keys, "all" widens one that shipped admin-only, "user,admin" names roles
@@ -62,13 +52,18 @@ const (
 	DefaultSourceConcurrency  = 8
 )
 
-// Model is a single exposed model id bound to a source, with priority used by
-// AUTO auto selection (higher number = preferred).
+// Model is a single exposed model id bound to a source.
+//
+// ★ 曾经有 `Priority int` 字段，并号称"高者优先参与 AUTO 选源"。**那是错的**：
+//
+//	AUTO 链由 `config.ModelScope.Tier` 驱动（见 scheduler.Chain），而 priority
+//	只被 `bestChatModel/bestImageModel` 用于"本源码内部该发哪个模型"，
+//	与跨源调度毫无关系。把它当成调度依据会让人误以为改个数字就能改顺序，
+//	改完发现毫无效果 —— 已彻底删除，避免再次误导。
 type Model struct {
-	ID       string                 `yaml:"id" json:"id"`
-	Priority int                    `yaml:"priority" json:"priority"`
-	Kind     string                 `yaml:"kind" json:"kind"` // "chat" (default) | "image"
-	Meta     map[string]interface{} `yaml:"meta" json:"meta,omitempty"`
+	ID   string                 `yaml:"id" json:"id"`
+	Kind string                 `yaml:"kind" json:"kind"` // "chat" (default) | "image"
+	Meta map[string]interface{} `yaml:"meta" json:"meta,omitempty"`
 }
 
 // Source describes a single upstream LLM provider.
@@ -90,7 +85,14 @@ type Source struct {
 	// ProxyURL routes this source's HTTP(S) traffic through an explicit proxy
 	// (e.g. http://127.0.0.1:7890). Empty = direct connection. Needed for
 	// upstreams behind geo/IP blocks that only respond through a proxy.
-	ProxyURL      string                 `yaml:"proxy_url" json:"proxy_url,omitempty"`
+	ProxyURL string `yaml:"proxy_url" json:"proxy_url,omitempty"`
+	// Retry is an OPTIONAL upstream retry policy. It exists for upstreams that
+	// answer a business-level rejection with a status code the kernel would
+	// otherwise surface to the client — e.g. a per-account concurrency cap that
+	// clears by itself after tens of seconds. The kernel stays vendor-agnostic:
+	// the matcher is pure DATA (status list + response-body substrings), so no
+	// provider name ever appears in core.
+	Retry         *RetryPolicy           `yaml:"retry" json:"retry,omitempty"`
 	Meta          map[string]interface{} `yaml:"meta" json:"meta,omitempty"`
 	Temperature   float64                `yaml:"temperature" json:"temperature,omitempty"`
 	MaxTokens     int                    `yaml:"max_tokens" json:"max_tokens,omitempty"`
@@ -100,9 +102,66 @@ type Source struct {
 	RPM           int                    `yaml:"rpm" json:"rpm,omitempty"` // optional requests-per-minute cap (0 = unlimited)
 }
 
+// RetryPolicy describes when a failed upstream attempt may be retried BEFORE
+// anything is returned to the client. All conditions are data:
+//
+//	OnStatus       - retry only when the HTTP status is one of these
+//	OnBodyContains - ... AND the response body contains one of these substrings
+//	                 (empty = status alone decides)
+//	Delay          - wait between attempts ("10s" etc.); parsed on demand
+//	MaxAttempts    - TOTAL attempts including the first (1 or 0 = no retry)
+//
+// Scope: the retry happens inside one gateway request, so a stream is only
+// retried before its first chunk reaches the client (the kernel already holds
+// the first chunk back), and a non-stream call is retried as a whole.
+type RetryPolicy struct {
+	OnStatus       []int    `yaml:"on_status,omitempty" json:"on_status,omitempty"`
+	OnBodyContains []string `yaml:"on_body_contains,omitempty" json:"on_body_contains,omitempty"`
+	Delay          string   `yaml:"delay,omitempty" json:"delay,omitempty"`
+	MaxAttempts    int      `yaml:"max_attempts,omitempty" json:"max_attempts,omitempty"`
+}
+
+// ShouldRetry reports whether one failed attempt matches this policy.
+func (r *RetryPolicy) ShouldRetry(status int, body string) bool {
+	if r == nil || r.MaxAttempts <= 1 {
+		return false
+	}
+	statusOK := len(r.OnStatus) == 0
+	for _, s := range r.OnStatus {
+		if s == status {
+			statusOK = true
+			break
+		}
+	}
+	if !statusOK {
+		return false
+	}
+	if len(r.OnBodyContains) == 0 {
+		return true
+	}
+	for _, sub := range r.OnBodyContains {
+		if sub != "" && strings.Contains(body, sub) {
+			return true
+		}
+	}
+	return false
+}
+
+// DelayDuration is the configured pause between attempts (default 10s).
+func (r *RetryPolicy) DelayDuration() time.Duration {
+	if r == nil || r.Delay == "" {
+		return 10 * time.Second
+	}
+	d, err := time.ParseDuration(r.Delay)
+	if err != nil || d < 0 {
+		return 10 * time.Second
+	}
+	return d
+}
+
 // Load reads and validates a config file. When the file does not exist yet a
 // default config is generated at that path first (first-run bootstrap), so a
-// fresh binary just works: `llmsproxy -config /path/to/config.yaml`.
+// fresh binary just works: `modelrouter -config /path/to/config.yaml`.
 func Load(path string) (*Config, error) {
 	if _, err := EnsureDefault(path); err != nil {
 		return nil, err
@@ -418,182 +477,6 @@ type GWKey struct {
 // chain" so a user can clear an override back to the global default.
 func (k GWKey) HasOwnAuto() bool { return len(k.Auto) > 0 }
 
-// BillingDSL holds declarative per-URL pricing profiles for the billing plugin.
-//
-// Profiles are the "let the user pick" axis: the same upstream URL can be
-// declared under multiple profiles, and the operator chooses which is active.
-// Switching recomputes and re-injects the billing plugin's prices table.
-type BillingDSL struct {
-	// Active is the id of the profile in effect. Empty => the first profile.
-	Active   string           `yaml:"active,omitempty" json:"active,omitempty"`
-	Profiles []BillingProfile `yaml:"profiles,omitempty" json:"profiles,omitempty"`
-}
-
-// BillingProfile is one named set of per-URL pricing rules.
-type BillingProfile struct {
-	ID    string `yaml:"id" json:"id"`
-	Label string `yaml:"label,omitempty" json:"label,omitempty"`
-	// Default applies when no rule matches: "free" or "unpriced".
-	Default string        `yaml:"default,omitempty" json:"default,omitempty"`
-	Rules   []BillingRule `yaml:"rules,omitempty" json:"rules,omitempty"`
-}
-
-// BillingRule declares the pricing for everything under one URL.
-type BillingRule struct {
-	// URL matches a source's base_url. "*" = any unmatched URL.
-	URL string `yaml:"url" json:"url"`
-	// Mode is one of: free, token, subscription, unpriced.
-	Mode     string `yaml:"mode" json:"mode"`
-	Currency string `yaml:"currency,omitempty" json:"currency,omitempty"`
-	// Subscription is the flat monthly cost (for mode=subscription).
-	Subscription float64 `yaml:"subscription,omitempty" json:"subscription,omitempty"`
-	// Models declares per-token prices when mode=token.
-	Models map[string]BillingToken `yaml:"models,omitempty" json:"models,omitempty"`
-	// Free is true when mode=free (kept for explicitness).
-	// Peak applies to ALL token-priced requests under this URL.
-	Peak *BillingPeak `yaml:"peak,omitempty" json:"peak,omitempty"`
-}
-
-// BillingToken is the per-model price.
-type BillingToken struct {
-	Prompt        string   `yaml:"prompt" json:"prompt"`         // USD per million tokens, e.g. "0.15"
-	Completion    string   `yaml:"completion" json:"completion"` // USD per million tokens
-	CacheDiscount *float64 `yaml:"cache_discount,omitempty" json:"cache_discount,omitempty"`
-	// Reasoning is the USD-per-million rate for thinking tokens, for the rare
-	// provider that charges them differently from ordinary output. Omit it and
-	// reasoning is billed at Completion — which is what OpenAI, DeepSeek and
-	// Anthropic all do, and what every source on this deployment reports.
-	//
-	// It is a rate for a SUBSET of completion tokens, never an extra charge: the
-	// billing plugin applies only the difference between this and Completion, so
-	// setting it to a multiple of Completion reprices the thinking share rather
-	// than billing it twice.
-	Reasoning string `yaml:"reasoning,omitempty" json:"reasoning,omitempty"`
-	// LongContext is the prompt-price step above a token threshold. Nil = one
-	// flat rate, which is what a rule means when it says nothing.
-	LongContext *BillingLongContext `yaml:"long_context,omitempty" json:"long_context,omitempty"`
-}
-
-// BillingPeak declares peak-hour pricing.
-type BillingPeak struct {
-	Multiplier float64 `yaml:"multiplier" json:"multiplier"`
-	// Weekdays: 1=Mon..5=Fri (Lua os.date !%w, 0=Sun)
-	Weekdays []int `yaml:"weekdays,omitempty" json:"weekdays,omitempty"`
-	// Hours: each pair is [lo,hi] inclusive
-	Hours [][2]int `yaml:"hours,omitempty" json:"hours,omitempty"`
-}
-
-// BillingLongContext is a prompt-price step for long inputs.
-//
-// Every major provider charges the input tokens ABOVE a threshold at a higher
-// rate — DeepSeek doubles past 128k, OpenAI and Anthropic step up as well. A
-// flat prompt price therefore under-bills exactly the traffic an agent workload
-// generates, and it under-bills it silently: the number is plausible, the bill
-// adds up, and nothing says the rate was wrong.
-//
-// The step applies to the PROMPT only. Output and cache reads are billed at
-// their own rates regardless of input length, which is how providers publish
-// it — the higher rate is for the extra context you made the model read, not for
-// what it wrote back.
-type BillingLongContext struct {
-	// Above is the token count the step starts at. A request with exactly this
-	// many prompt tokens is still at the base rate; the step covers the tokens
-	// BEYOND it. Inclusive-below matches how the providers document it.
-	Above int `yaml:"above" json:"above"`
-	// Prompt is the USD-per-million rate for the tokens above Above.
-	Prompt string `yaml:"prompt" json:"prompt"`
-	// Multiplier is an alternative to Prompt: a factor applied to the base rate
-	// (DeepSeek's published step is exactly 2x). When both are set Prompt wins,
-	// and setting neither is a validation error rather than a silent no-op.
-	Multiplier float64 `yaml:"multiplier,omitempty" json:"multiplier,omitempty"`
-}
-
-// Validate rejects a BillingDSL that could not work as written.
-func (b *BillingDSL) Validate() error {
-	if b == nil {
-		return nil
-	}
-	ids := map[string]bool{}
-	for i := range b.Profiles {
-		p := &b.Profiles[i]
-		if p.ID == "" {
-			return fmt.Errorf("billing profile [%d] has no id", i)
-		}
-		if ids[p.ID] {
-			return fmt.Errorf("billing profile id %q appears more than once", p.ID)
-		}
-		ids[p.ID] = true
-		if p.Default != "" && p.Default != "free" && p.Default != "unpriced" {
-			return fmt.Errorf("profile %q: default must be free or unpriced, got %q", p.ID, p.Default)
-		}
-		for j := range p.Rules {
-			r := &p.Rules[j]
-			if r.URL == "" {
-				return fmt.Errorf("profile %q rule [%d]: url is required", p.ID, j)
-			}
-			switch r.Mode {
-			case "free", "token", "subscription", "unpriced":
-			default:
-				return fmt.Errorf("profile %q rule [%d]: mode must be free/token/subscription/unpriced, got %q", p.ID, j, r.Mode)
-			}
-			if r.Mode == "token" {
-				for m, t := range r.Models {
-					if t.Prompt == "" || t.Completion == "" {
-						return fmt.Errorf("profile %q model %q: prompt and completion are required for token mode", p.ID, m)
-					}
-					if _, err := ParseFloatUSDPerM(t.Prompt); err != nil {
-						return fmt.Errorf("profile %q model %q prompt: %w", p.ID, m, err)
-					}
-					if _, err := ParseFloatUSDPerM(t.Completion); err != nil {
-						return fmt.Errorf("profile %q model %q completion: %w", p.ID, m, err)
-					}
-				}
-			}
-		}
-	}
-	// Active must resolve to a profile id.
-	if b.Active != "" && !ids[b.Active] {
-		return fmt.Errorf("billing.active = %q but no profile has that id", b.Active)
-	}
-	return nil
-}
-
-// Resolve returns the profile with the given id; empty id (or an id that does
-// not exist) falls back to the FIRST profile. A config with profiles but no
-// active marker should mean "use the one I wrote first" rather than "price
-// nothing", which is what a nil here would silently do.
-func (b *BillingDSL) Resolve(id string) *BillingProfile {
-	if b == nil || len(b.Profiles) == 0 {
-		return nil
-	}
-	if id != "" {
-		for i := range b.Profiles {
-			if b.Profiles[i].ID == id {
-				return &b.Profiles[i]
-			}
-		}
-	}
-	return &b.Profiles[0]
-}
-
-// parseFloatUSDPerM parses a USD-per-million price string. Returns the
-// per-single-token rate the plugin expects (price / 1e6).
-//
-// Kept as a string in the DSL rather than a float: "0.15" survives round-trips
-// through YAML editors, and a malformed value must fail VALIDATION (with the
-// file and field named) rather than parse as 0 and under-bill silently — which
-// is exactly the failure mode that motivated the DSL.
-func ParseFloatUSDPerM(s string) (float64, error) {
-	f, err := strconv.ParseFloat(strings.TrimSpace(s), 64)
-	if err != nil {
-		return 0, fmt.Errorf("not a number: %q", s)
-	}
-	if f < 0 {
-		return 0, fmt.Errorf("negative price: %q", s)
-	}
-	return f / 1e6, nil
-}
-
 // KeyQuota is retained only to carry a scope entry's caps through the admin
 // API. Quotas are per model, never per key: there is deliberately no key-wide
 // total, so exhausting one model's budget never blocks the others.

internal/config/config_test.go

@@ -52,9 +52,6 @@ sources:
 	if cfg.Sources[1].MaxConcurrent == 0 {
 		t.Fatal("default max_concurrent not applied")
 	}
-	if cfg.Sources[0].Models[0].Priority != 100 {
-		t.Fatalf("priority = %d", cfg.Sources[0].Models[0].Priority)
-	}
 	if cfg.DefaultModel != "AUTO" {
 		t.Fatalf("default model = %q", cfg.DefaultModel)
 	}

internal/config/presets.go

@@ -14,9 +14,9 @@ var PresetTemplates = []SourceTemplate{
 		Adapter:       "deepseek",
 		MaxConcurrent: 8,
 		Models: []Model{
-			{ID: "deepseek-v4-flash", Priority: 100, Kind: "chat"},
-			{ID: "deepseek-v4-pro", Priority: 90, Kind: "chat"},
-			{ID: "deepseek-v4-flash-vision-exp", Priority: 60, Kind: "chat"},
+			{ID: "deepseek-v4-flash", Kind: "chat"},
+			{ID: "deepseek-v4-pro", Kind: "chat"},
+			{ID: "deepseek-v4-flash-vision-exp", Kind: "chat"},
 		},
 	},
 	{
@@ -25,10 +25,10 @@ var PresetTemplates = []SourceTemplate{
 		Adapter:       "openai",
 		MaxConcurrent: 8,
 		Models: []Model{
-			{ID: "glm-5.3", Priority: 100, Kind: "chat"},
-			{ID: "glm-5.3-flash", Priority: 90, Kind: "chat"},
-			{ID: "glm-5.2", Priority: 80, Kind: "chat"},
-			{ID: "glm-5.1", Priority: 60, Kind: "chat"},
+			{ID: "glm-5.3", Kind: "chat"},
+			{ID: "glm-5.3-flash", Kind: "chat"},
+			{ID: "glm-5.2", Kind: "chat"},
+			{ID: "glm-5.1", Kind: "chat"},
 		},
 	},
 	{
@@ -37,10 +37,10 @@ var PresetTemplates = []SourceTemplate{
 		Adapter:       "openai",
 		MaxConcurrent: 8,
 		Models: []Model{
-			{ID: "kimi-k3", Priority: 100, Kind: "chat"},
-			{ID: "kimi-k2.7-code", Priority: 90, Kind: "chat"},
-			{ID: "kimi-k2.7-code-highspeed", Priority: 85, Kind: "chat"},
-			{ID: "kimi-k2.6", Priority: 70, Kind: "chat"},
+			{ID: "kimi-k3", Kind: "chat"},
+			{ID: "kimi-k2.7-code", Kind: "chat"},
+			{ID: "kimi-k2.7-code-highspeed", Kind: "chat"},
+			{ID: "kimi-k2.6", Kind: "chat"},
 		},
 	},
 	{
@@ -49,11 +49,11 @@ var PresetTemplates = []SourceTemplate{
 		Adapter:       "openai",
 		MaxConcurrent: 8,
 		Models: []Model{
-			{ID: "deepseek-ai/DeepSeek-V4-Pro", Priority: 100, Kind: "chat"},
-			{ID: "deepseek-ai/DeepSeek-V4-Flash", Priority: 90, Kind: "chat"},
-			{ID: "moonshotai/Kimi-K2.6", Priority: 80, Kind: "chat"},
-			{ID: "zai-org/GLM-5.1", Priority: 70, Kind: "chat"},
-			{ID: "Kwai-Kolors/Kolors", Priority: 50, Kind: "image"},
+			{ID: "deepseek-ai/DeepSeek-V4-Pro", Kind: "chat"},
+			{ID: "deepseek-ai/DeepSeek-V4-Flash", Kind: "chat"},
+			{ID: "moonshotai/Kimi-K2.6", Kind: "chat"},
+			{ID: "zai-org/GLM-5.1", Kind: "chat"},
+			{ID: "Kwai-Kolors/Kolors", Kind: "image"},
 		},
 	},
 	{
@@ -62,9 +62,9 @@ var PresetTemplates = []SourceTemplate{
 		Adapter:       "openai",
 		MaxConcurrent: 4,
 		Models: []Model{
-			{ID: "4.0Ultra", Priority: 100, Kind: "chat"},
-			{ID: "generalv3.5", Priority: 80, Kind: "chat"},
-			{ID: "max-32k", Priority: 70, Kind: "chat"},
+			{ID: "4.0Ultra", Kind: "chat"},
+			{ID: "generalv3.5", Kind: "chat"},
+			{ID: "max-32k", Kind: "chat"},
 		},
 	},
 	{
@@ -73,11 +73,11 @@ var PresetTemplates = []SourceTemplate{
 		Adapter:       "openai",
 		MaxConcurrent: 8,
 		Models: []Model{
-			{ID: "qwen3.8-max", Priority: 100, Kind: "chat"},
-			{ID: "qwen3.8-flash", Priority: 90, Kind: "chat"},
-			{ID: "qwen3.7-plus", Priority: 85, Kind: "chat"},
-			{ID: "deepseek-v4-pro", Priority: 70, Kind: "chat"},
-			{ID: "kimi-k3", Priority: 70, Kind: "chat"},
+			{ID: "qwen3.8-max", Kind: "chat"},
+			{ID: "qwen3.8-flash", Kind: "chat"},
+			{ID: "qwen3.7-plus", Kind: "chat"},
+			{ID: "deepseek-v4-pro", Kind: "chat"},
+			{ID: "kimi-k3", Kind: "chat"},
 		},
 	},
 	{
@@ -86,9 +86,9 @@ var PresetTemplates = []SourceTemplate{
 		Adapter:       "openai",
 		MaxConcurrent: 8,
 		Models: []Model{
-			{ID: "ernie-5.0-turbo", Priority: 100, Kind: "chat"},
-			{ID: "ernie-5.0", Priority: 90, Kind: "chat"},
-			{ID: "deepseek-v4-pro", Priority: 70, Kind: "chat"},
+			{ID: "ernie-5.0-turbo", Kind: "chat"},
+			{ID: "ernie-5.0", Kind: "chat"},
+			{ID: "deepseek-v4-pro", Kind: "chat"},
 		},
 	},
 	{
@@ -97,9 +97,9 @@ var PresetTemplates = []SourceTemplate{
 		Adapter:       "openai",
 		MaxConcurrent: 8,
 		Models: []Model{
-			{ID: "doubao-seed-2.0-pro", Priority: 100, Kind: "chat"},
-			{ID: "doubao-seed-2.0", Priority: 90, Kind: "chat"},
-			{ID: "doubao-seed-2.0-flash", Priority: 80, Kind: "chat"},
+			{ID: "doubao-seed-2.0-pro", Kind: "chat"},
+			{ID: "doubao-seed-2.0", Kind: "chat"},
+			{ID: "doubao-seed-2.0-flash", Kind: "chat"},
 		},
 	},
 	{
@@ -108,8 +108,8 @@ var PresetTemplates = []SourceTemplate{
 		Adapter:       "openai",
 		MaxConcurrent: 8,
 		Models: []Model{
-			{ID: "MiniMax-M3", Priority: 100, Kind: "chat"},
-			{ID: "MiniMax-M2.5", Priority: 80, Kind: "chat"},
+			{ID: "MiniMax-M3", Kind: "chat"},
+			{ID: "MiniMax-M2.5", Kind: "chat"},
 		},
 	},
 	// ── 国际主流 ────────────────────────────────────────────────────────────
@@ -119,9 +119,9 @@ var PresetTemplates = []SourceTemplate{
 		Adapter:       "openai",
 		MaxConcurrent: 8,
 		Models: []Model{
-			{ID: "gpt-5.6-sol", Priority: 100, Kind: "chat"},
-			{ID: "gpt-5.6-terra", Priority: 90, Kind: "chat"},
-			{ID: "gpt-5.6-luna", Priority: 80, Kind: "chat"},
+			{ID: "gpt-5.6-sol", Kind: "chat"},
+			{ID: "gpt-5.6-terra", Kind: "chat"},
+			{ID: "gpt-5.6-luna", Kind: "chat"},
 		},
 	},
 	{
@@ -130,10 +130,10 @@ var PresetTemplates = []SourceTemplate{
 		Adapter:       "anthropic",
 		MaxConcurrent: 8,
 		Models: []Model{
-			{ID: "claude-opus-5", Priority: 100, Kind: "chat"},
-			{ID: "claude-fable-5", Priority: 95, Kind: "chat"},
-			{ID: "claude-sonnet-5", Priority: 85, Kind: "chat"},
-			{ID: "claude-haiku-4-5", Priority: 70, Kind: "chat"},
+			{ID: "claude-opus-5", Kind: "chat"},
+			{ID: "claude-fable-5", Kind: "chat"},
+			{ID: "claude-sonnet-5", Kind: "chat"},
+			{ID: "claude-haiku-4-5", Kind: "chat"},
 		},
 	},
 	{
@@ -142,10 +142,10 @@ var PresetTemplates = []SourceTemplate{
 		Adapter:       "gemini",
 		MaxConcurrent: 8,
 		Models: []Model{
-			{ID: "gemini-3.6-flash", Priority: 100, Kind: "chat"},
-			{ID: "gemini-3.5-flash", Priority: 90, Kind: "chat"},
-			{ID: "gemini-3.5-flash-lite", Priority: 80, Kind: "chat"},
-			{ID: "gemini-3.1-pro", Priority: 85, Kind: "chat"},
+			{ID: "gemini-3.6-flash", Kind: "chat"},
+			{ID: "gemini-3.5-flash", Kind: "chat"},
+			{ID: "gemini-3.5-flash-lite", Kind: "chat"},
+			{ID: "gemini-3.1-pro", Kind: "chat"},
 		},
 	},
 	{
@@ -154,9 +154,9 @@ var PresetTemplates = []SourceTemplate{
 		Adapter:       "groq",
 		MaxConcurrent: 8,
 		Models: []Model{
-			{ID: "openai/gpt-oss-120b", Priority: 100, Kind: "chat"},
-			{ID: "openai/gpt-oss-20b", Priority: 80, Kind: "chat"},
-			{ID: "groq/compound", Priority: 70, Kind: "chat"},
+			{ID: "openai/gpt-oss-120b", Kind: "chat"},
+			{ID: "openai/gpt-oss-20b", Kind: "chat"},
+			{ID: "groq/compound", Kind: "chat"},
 		},
 	},
 	{
@@ -165,9 +165,9 @@ var PresetTemplates = []SourceTemplate{
 		Adapter:       "mistral",
 		MaxConcurrent: 8,
 		Models: []Model{
-			{ID: "mistral-medium-latest", Priority: 100, Kind: "chat"},
-			{ID: "mistral-large-latest", Priority: 90, Kind: "chat"},
-			{ID: "codestral-latest", Priority: 85, Kind: "chat"},
+			{ID: "mistral-medium-latest", Kind: "chat"},
+			{ID: "mistral-large-latest", Kind: "chat"},
+			{ID: "codestral-latest", Kind: "chat"},
 		},
 	},
 	{
@@ -180,10 +180,10 @@ var PresetTemplates = []SourceTemplate{
 			"X-Title":      "ModelRouter",
 		},
 		Models: []Model{
-			{ID: "openrouter/auto", Priority: 100, Kind: "chat"},
-			{ID: "deepseek/deepseek-v4-flash", Priority: 90, Kind: "chat"},
-			{ID: "anthropic/claude-opus-5", Priority: 85, Kind: "chat"},
-			{ID: "openai/gpt-5.6-sol", Priority: 85, Kind: "chat"},
+			{ID: "openrouter/auto", Kind: "chat"},
+			{ID: "deepseek/deepseek-v4-flash", Kind: "chat"},
+			{ID: "anthropic/claude-opus-5", Kind: "chat"},
+			{ID: "openai/gpt-5.6-sol", Kind: "chat"},
 		},
 	},
 	{
@@ -192,8 +192,8 @@ var PresetTemplates = []SourceTemplate{
 		Adapter:       "github",
 		MaxConcurrent: 8,
 		Models: []Model{
-			{ID: "gpt-5.6-sol", Priority: 100, Kind: "chat"},
-			{ID: "gpt-5.6-luna", Priority: 80, Kind: "chat"},
+			{ID: "gpt-5.6-sol", Kind: "chat"},
+			{ID: "gpt-5.6-luna", Kind: "chat"},
 		},
 	},
 	// ── 本地模型 ────────────────────────────────────────────────────────────
@@ -204,9 +204,9 @@ var PresetTemplates = []SourceTemplate{
 		Endpoint:      "/api/chat",
 		MaxConcurrent: 4,
 		Models: []Model{
-			{ID: "qwen3", Priority: 80, Kind: "chat"},
-			{ID: "deepseek-r1", Priority: 80, Kind: "chat"},
-			{ID: "llama3.3", Priority: 70, Kind: "chat"},
+			{ID: "qwen3", Kind: "chat"},
+			{ID: "deepseek-r1", Kind: "chat"},
+			{ID: "llama3.3", Kind: "chat"},
 		},
 	},
 }

internal/config/retry_policy_test.go

@@ -0,0 +1,59 @@
+package config
+
+import (
+	"testing"
+	"time"
+)
+
+// ShouldRetry 是纯数据判据：状态码列表 + 响应体子串。它决定"这次失败值不值得
+// 在网关内部等一会儿重试"。厂商知识绝不能进内核，所以判据必须能用一个表格测清楚。
+func TestRetryPolicyShouldRetry(t *testing.T) {
+	cases := []struct {
+		name   string
+		policy *RetryPolicy
+		status int
+		body   string
+		want   bool
+	}{
+		{"nil policy", nil, 500, "anything", false},
+		{"max_attempts=1 disables", &RetryPolicy{OnStatus: []int{400}, MaxAttempts: 1}, 400, "x", false},
+		{"status matches, no body filter",
+			&RetryPolicy{OnStatus: []int{429}, MaxAttempts: 3}, 429, "", true},
+		{"status mismatch",
+			&RetryPolicy{OnStatus: []int{429}, MaxAttempts: 3}, 400, "429", false},
+		{"status + body match",
+			&RetryPolicy{OnStatus: []int{400}, OnBodyContains: []string{"TM.00001041"}, MaxAttempts: 3},
+			400, `{"error_code":"TM.00001041"}`, true},
+		{"status matches but body does not",
+			&RetryPolicy{OnStatus: []int{400}, OnBodyContains: []string{"TM.00001041"}, MaxAttempts: 3},
+			400, `{"error_code":"TM.00001005"}`, false},
+		{"empty substring never matches",
+			&RetryPolicy{OnStatus: []int{400}, OnBodyContains: []string{""}, MaxAttempts: 3}, 400, "x", false},
+		{"any of several body signals",
+			&RetryPolicy{OnStatus: []int{400, 429}, OnBodyContains: []string{"TM.00001041", "TPM limit"}, MaxAttempts: 3},
+			429, `{"message":"TPM limit exceeded"}`, true},
+	}
+	for _, tc := range cases {
+		if got := tc.policy.ShouldRetry(tc.status, tc.body); got != tc.want {
+			t.Errorf("%s: ShouldRetry(%d, %q) = %v, want %v", tc.name, tc.status, tc.body, got, tc.want)
+		}
+	}
+}
+
+func TestRetryPolicyDelay(t *testing.T) {
+	cases := []struct {
+		name   string
+		policy *RetryPolicy
+		want   time.Duration
+	}{
+		{"nil", nil, 10 * time.Second},
+		{"explicit", &RetryPolicy{Delay: "250ms"}, 250 * time.Millisecond},
+		{"garbage falls back", &RetryPolicy{Delay: "not-a-duration"}, 10 * time.Second},
+		{"negative falls back", &RetryPolicy{Delay: "-5s"}, 10 * time.Second},
+	}
+	for _, tc := range cases {
+		if got := tc.policy.DelayDuration(); got != tc.want {
+			t.Errorf("%s: DelayDuration() = %v, want %v", tc.name, got, tc.want)
+		}
+	}
+}

internal/config/secret.go

@@ -27,8 +27,9 @@ func NewGatewayKey() (string, error) {
 
 // SecretBox encrypts and decrypts sensitive values (upstream API keys,
 // custom header values, gateway keys) for persist-time protection. The
-// master key comes from the LLMS_PROXY_MASTER_KEY environment variable
-// (hex, 64 chars) or from a generated <runtime-dir>/master.key file.
+// master key comes from the MODELROUTER_MASTER_KEY environment variable
+// (hex, 64 chars; the pre-rename LLMS_PROXY_MASTER_KEY is still accepted) or
+// from a generated <runtime-dir>/master.key file.
 type SecretBox struct {
 	aead cipher.AEAD
 }
@@ -37,10 +38,18 @@ type SecretBox struct {
 // file next to the runtime file. If neither exists, a fresh random key is
 // generated and written to master.key with mode 0600.
 func NewSecretBox(runtimeFile string) (*SecretBox, error) {
-	if v := os.Getenv("LLMS_PROXY_MASTER_KEY"); v != "" {
-		key, err := hex.DecodeString(strings.TrimSpace(v))
+	// New name first, then the pre-rename name: an existing unit file that still
+	// exports LLMS_PROXY_MASTER_KEY must keep starting after an upgrade.
+	envKey := os.Getenv("MODELROUTER_MASTER_KEY")
+	envName := "MODELROUTER_MASTER_KEY"
+	if envKey == "" {
+		envKey = os.Getenv("LLMS_PROXY_MASTER_KEY")
+		envName = "LLMS_PROXY_MASTER_KEY"
+	}
+	if envKey != "" {
+		key, err := hex.DecodeString(strings.TrimSpace(envKey))
 		if err != nil || len(key) != 32 {
-			return nil, fmt.Errorf("LLMS_PROXY_MASTER_KEY: expected 64 hex chars")
+			return nil, fmt.Errorf("%s: expected 64 hex chars", envName)
 		}
 		return newBox(key)
 	}

internal/core/channels_device_test.go

@@ -1,40 +0,0 @@
-package core
-
-import (
-	"testing"
-)
-
-// TestChannelsDevicePollBehavior 是 device-poll 流的行为对齐测试。
-//
-// 决策表逐行搬自参考实现 pollMinimaxDeviceToken（minimax-oauth.ts），
-// 上游用假服务器模拟，逐次响应由测试控制。断言的是**行为**（会话状态推进），
-// 不是实现细节。决策表本体在 deviceHarness.runDecisionTable（与变异测试共用）。
-func TestChannelsDevicePollBehavior(t *testing.T) {
-	h := newDeviceHarness(t, mustChannelsSrc(t))
-	// begin 直查：user_code 透传、授权 URL、verifier 不回显
-	j := h.begin()
-	sess := j["session"].(map[string]interface{})
-	if sess["user_code"] != "ABCD-EFGH" {
-		t.Fatalf("begin 应透传 user_code, 实得 %v", sess["user_code"])
-	}
-	if j["url"] != "https://example/activate" {
-		t.Fatalf("begin 应给授权 URL, 实得 %v", j["url"])
-	}
-	if _, has := j["device_verifier"]; has {
-		t.Fatal("verifier 绝不能回显")
-	}
-	// 决策表全过
-	if !h.runDecisionTable() {
-		t.Fatal("device-poll 决策表未全过（见 runDecisionTable 内的行号）")
-	}
-}
-
-// mustChannelsSrc 读 bundled channels 源码。
-func mustChannelsSrc(t *testing.T) string {
-	t.Helper()
-	src, err := readBundledChannels(t)
-	if err != nil {
-		t.Fatal(err)
-	}
-	return src
-}

internal/core/channels_more_test.go

@@ -1,325 +0,0 @@
-package core
-
-import (
-	"fmt"
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"sync/atomic"
-	"testing"
-
-	"llmsproxy/internal/lua"
-)
-
-// channelsMoreTest：新引入的三条真实流程 + 两个边界流的行为对齐测试。
-// 平台定义、决策表、端点逐字照抄参考（见 channels.lua 注释），测试照参考行为搬。
-
-// ---- Cline（WorkOS 设备码 + register 两步） ----
-
-// clineHarness 假上游：device code / authenticate / register 三端点。
-type clineHarness struct {
-	t    *testing.T
-	ps   *lua.Plugins
-	ts   *httptest.Server
-	tok  atomic.Value // 当前 authenticate 响应脚本 []scriptStep
-	step int32
-}
-
-func newClineHarness(t *testing.T) *clineHarness {
-	t.Helper()
-	h := &clineHarness{t: t}
-	h.tok.Store([]scriptStep{})
-	h.ts = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
-		switch r.URL.Path {
-		case "/user_management/authorize/device":
-			fmt.Fprint(w, `{"device_code":"CD1","user_code":"WXYZ-1234","verification_uri":"https://example/activate","interval":1,"expires_in":600}`)
-		case "/user_management/authenticate":
-			i := int(atomic.AddInt32(&h.step, 1)) - 1
-			s := h.tok.Load().([]scriptStep)
-			if i >= len(s) {
-				w.WriteHeader(500)
-				fmt.Fprint(w, `{"error":"unexpected"}`)
-				return
-			}
-			if s[i].http != 0 && s[i].http != 200 {
-				w.WriteHeader(s[i].http)
-			}
-			fmt.Fprint(w, s[i].body)
-		case "/api/v1/auth/register":
-			// 校验请求体是驼峰 accessToken/refreshToken（参考 registerClineTokens）
-			b, _ := io.ReadAll(r.Body)
-			for _, want := range []string{`"accessToken":"WO-AT-1"`, `"refreshToken":"WO-RT-1"`} {
-				if !strings.Contains(string(b), want) {
-					t.Errorf("register 请求体缺 %s: %s", want, b)
-				}
-			}
-			fmt.Fprint(w, `{"success":true,"data":{"accessToken":"CLINE-AT-1","refreshToken":"CLINE-RT-1","userInfo":{"clineUserId":"u1","email":"dev@example.com"}}}`)
-		default:
-			w.WriteHeader(404)
-		}
-	}))
-	t.Cleanup(h.ts.Close)
-
-	c := kernelTestCore(t)
-	h.ps = c.Plugins()
-	src, _ := readBundledChannels(t)
-	if err := h.ps.LoadSource("channels", src); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := h.ps.Call("channels", "set_endpoints", map[string]interface{}{
-		"platform": "cline",
-		"device":   map[string]interface{}{"code_url": h.ts.URL + "/user_management/authorize/device", "token_url": h.ts.URL + "/user_management/authenticate"},
-		"register": map[string]interface{}{"url": h.ts.URL + "/api/v1/auth/register"},
-	}); err != nil {
-		t.Fatalf("set_endpoints: %v", err)
-	}
-	return h
-}
-
-func (h *clineHarness) begin() map[string]interface{} {
-	out, err := h.ps.InvokeHandler("channels", "start_login", &lua.HandlerRequest{
-		Method: "POST", Body: `{"platform":"cline"}`,
-	})
-	if err != nil {
-		h.t.Fatal(err)
-	}
-	return out.JSON.(map[string]interface{})
-}
-func (h *clineHarness) poll(id string) map[string]interface{} {
-	out, _ := h.ps.InvokeHandler("channels", "poll_login", &lua.HandlerRequest{
-		Method: "GET", Query: map[string]string{"id": id},
-	})
-	return out.JSON.(map[string]interface{})
-}
-
-// runWorkosTable 是 WorkOS（Cline）分支的行为契约，供变异测试杀 workos 变异体。
-// 决策表 5 行，跟 TestClineWorkOSBehavior 同源（这里只返回布尔，不报细节）。
-func (h *clineHarness) runWorkosTable() bool {
-	st := func(steps ...string) map[string]interface{} {
-		h.tok.Store(scriptSteps(steps...))
-		atomic.StoreInt32(&h.step, 0)
-		j := h.begin()
-		sid := j["session"].(map[string]interface{})["id"].(string)
-		return h.poll(sid)
-	}
-	_ = h.ps.SetPluginKernelPermission("channels", []string{"add_source", "status", "list_sources"}, false)
-	// 行1: 非200+error=authorization_pending → 等
-	if j := st(`400 {"error":"authorization_pending"}`); j["state"] != "pending" {
-		return false
-	}
-	// 行2: 非200+error=slow_down → 等 + interval+1（基线 1）
-	h.tok.Store(scriptSteps(`400 {"error":"slow_down"}`))
-	atomic.StoreInt32(&h.step, 0)
-	j := h.begin()
-	sid := j["session"].(map[string]interface{})["id"].(string)
-	if j2 := h.poll(sid); j2["state"] != "pending" {
-		return false
-	} else if iv, _ := j2["interval"].(float64); iv != 2 {
-		return false
-	}
-	// 行3: error=access_denied → failed
-	if j := st(`400 {"error":"access_denied","error_description":"user declined"}`); j["state"] != "failed" {
-		return false
-	}
-	// 行4: 成功（access+refresh）→ register 换 CLINE token → completed
-	if j := st(`{"access_token":"WO-AT-1","refresh_token":"WO-RT-1"}`); j["state"] != "completed" || j["account"] != "dev@example.com" {
-		return false
-	}
-	v, _, _ := h.ps.GetSecret("channels", "channels:cline")
-	if v != "CLINE-AT-1" {
-		return false
-	}
-	// 行5: 非200无error字段 → failed（不是死等）
-	if j := st(`500 {"foo":"bar"}`); j["state"] != "failed" {
-		return false
-	}
-	return true
-}
-
-// TestClineWorkOSBehavior：WorkOS 判据（error 字段）+ register 两步 + slow_down +1s。
-func TestClineWorkOSBehavior(t *testing.T) {
-	h := newClineHarness(t)
-	_ = h.ps.SetPluginKernelPermission("channels", []string{"add_source", "status", "list_sources"}, false)
-
-	st := func(steps ...string) map[string]interface{} {
-		h.tok.Store(scriptSteps(steps...))
-		atomic.StoreInt32(&h.step, 0)
-		j := h.begin()
-		sid := j["session"].(map[string]interface{})["id"].(string)
-		return h.poll(sid)
-	}
-
-	t.Run("行1 error=authorization_pending_非200也继续等", func(t *testing.T) {
-		if j := st(`400 {"error":"authorization_pending"}`); j["state"] != "pending" {
-			t.Fatalf("应 pending: %v", j)
-		}
-	})
-	t.Run("行2 error=slow_down_退避1秒", func(t *testing.T) {
-		h.tok.Store(scriptSteps(`400 {"error":"slow_down"}`))
-		atomic.StoreInt32(&h.step, 0)
-		j := h.begin()
-		sid := j["session"].(map[string]interface{})["id"].(string)
-		j2 := h.poll(sid)
-		if j2["state"] != "pending" {
-			t.Fatalf("应 pending: %v", j2)
-		}
-		if iv, _ := j2["interval"].(float64); iv != 2 { // 基线 1 + slow_down_step 1
-			t.Fatalf("WorkOS slow_down 应 interval+1s 得 2, 实得 %v", iv)
-		}
-	})
-	t.Run("行3 error=access_denied_失败带拒绝", func(t *testing.T) {
-		if j := st(`400 {"error":"access_denied","error_description":"user declined"}`); j["state"] != "failed" {
-			t.Fatalf("应 failed: %v", j)
-		}
-	})
-	t.Run("行4 成功_access+refresh_再打register_凭据是CLINE-AT-1", func(t *testing.T) {
-		j := st(`{"access_token":"WO-AT-1","refresh_token":"WO-RT-1"}`)
-		if j["state"] != "completed" || j["account"] != "dev@example.com" {
-			t.Fatalf("应 completed+dev@example.com: %v", j)
-		}
-		v, _, _ := h.ps.GetSecret("channels", "channels:cline")
-		if v != "CLINE-AT-1" {
-			t.Fatalf("凭据应是 register 的 CLINE-AT-1, 实得 %q", v)
-		}
-	})
-	t.Run("行5 非200无error字段_失败", func(t *testing.T) {
-		if j := st(`500 {"foo":"bar"}`); j["state"] != "failed" {
-			t.Fatalf("应 failed: %v", j)
-		}
-	})
-}
-
-// ---- Buddy（CodeBuddy state 轮询） ----
-
-type buddyHarness struct {
-	t       *testing.T
-	ps      *lua.Plugins
-	ts      *httptest.Server
-	tokStep int32
-	tokOk   int32
-	acctOk  int32
-}
-
-func newBuddyHarness(t *testing.T) *buddyHarness {
-	t.Helper()
-	h := &buddyHarness{t: t, tokOk: 1, acctOk: 1}
-	h.ts = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
-		switch {
-		case r.Method == "POST" && r.URL.Path == "/v2/plugin/auth/state":
-			fmt.Fprint(w, `{"data":{"state":"ST-1","authUrl":"https://www.codebuddy.cn/login/?platform=ide&state=ST-1"}}`)
-		case r.Method == "GET" && r.URL.Path == "/v2/plugin/auth/token":
-			i := atomic.AddInt32(&h.tokStep, 1)
-			if atomic.LoadInt32(&h.tokOk) == 0 {
-				w.WriteHeader(200)
-				fmt.Fprint(w, `{"code":11217,"message":"token not ready"}`)
-				return
-			}
-			if i == 1 {
-				fmt.Fprint(w, `{"code":11217,"message":"token not ready"}`)
-			} else {
-				fmt.Fprint(w, `{"data":{"accessToken":"BD-AT-1","refreshToken":"BD-RT-1"}}`)
-			}
-		case r.Method == "GET" && r.URL.Path == "/v2/plugin/login/account":
-			if atomic.LoadInt32(&h.acctOk) == 0 {
-				w.WriteHeader(500)
-				fmt.Fprint(w, `{"code":1}`)
-				return
-			}
-			fmt.Fprint(w, `{"data":{"nickName":"buddy-dev"}}`)
-		default:
-			w.WriteHeader(404)
-		}
-	}))
-	t.Cleanup(h.ts.Close)
-
-	c := kernelTestCore(t)
-	h.ps = c.Plugins()
-	src, _ := readBundledChannels(t)
-	if err := h.ps.LoadSource("channels", src); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := h.ps.Call("channels", "set_endpoints", map[string]interface{}{
-		"platform": "buddy",
-		"state":    map[string]interface{}{"state_url": h.ts.URL + "/v2/plugin/auth/state", "token_url": h.ts.URL + "/v2/plugin/auth/token", "account_url": h.ts.URL + "/v2/plugin/login/account"},
-	}); err != nil {
-		t.Fatalf("set_endpoints: %v", err)
-	}
-	return h
-}
-
-func (h *buddyHarness) begin() (map[string]interface{}, string) {
-	out, err := h.ps.InvokeHandler("channels", "start_login", &lua.HandlerRequest{
-		Method: "POST", Body: `{"platform":"buddy"}`,
-	})
-	if err != nil {
-		h.t.Fatal(err)
-	}
-	j := out.JSON.(map[string]interface{})
-	return j, j["session"].(map[string]interface{})["id"].(string)
-}
-func (h *buddyHarness) poll(id string) map[string]interface{} {
-	out, _ := h.ps.InvokeHandler("channels", "poll_login", &lua.HandlerRequest{
-		Method: "GET", Query: map[string]string{"id": id},
-	})
-	return out.JSON.(map[string]interface{})
-}
-
-// TestBuddyStatePollBehavior：state-poll 两拍（先 11217 后 token）+ 账号查询 + account 失败不阻塞。
-func TestBuddyStatePollBehavior(t *testing.T) {
-	h := newBuddyHarness(t)
-	_ = h.ps.SetPluginKernelPermission("channels", []string{"add_source", "status", "list_sources"}, false)
-
-	t.Run("行1 state申请给出authUrl", func(t *testing.T) {
-		j, _ := h.begin()
-		if j["url"] == "" {
-			t.Fatalf("应有 authUrl: %v", j)
-		}
-	})
-	t.Run("行2 首拍11217仍pending_次拍token_completed", func(t *testing.T) {
-		atomic.StoreInt32(&h.tokStep, 0)
-		_, sid := h.begin()
-		if j := h.poll(sid); j["state"] != "pending" {
-			t.Fatalf("首拍应 pending: %v", j)
-		}
-		if j := h.poll(sid); j["state"] != "completed" || j["account"] != "buddy-dev" {
-			t.Fatalf("次拍应 completed+buddy-dev: %v", j)
-		}
-		v, _, _ := h.ps.GetSecret("channels", "channels:buddy")
-		if v != "BD-AT-1" {
-			t.Fatalf("凭据应 BD-AT-1, 实得 %q", v)
-		}
-	})
-	t.Run("行3 account查询失败不阻塞_回退默认名", func(t *testing.T) {
-		atomic.StoreInt32(&h.tokStep, 0)
-		atomic.StoreInt32(&h.acctOk, 0)
-		defer atomic.StoreInt32(&h.acctOk, 1)
-		_, sid := h.begin()
-		h.poll(sid)
-		j := h.poll(sid)
-		if j["state"] != "completed" {
-			t.Fatalf("account 失败不应阻塞: %v", j)
-		}
-	})
-}
-
-// ---- 通用 ----
-
-func scriptSteps(steps ...string) []scriptStep {
-	var out []scriptStep
-	for _, b := range steps {
-		code := 200
-		switch {
-		case strings.HasPrefix(b, "400 "):
-			code, b = 400, b[4:]
-		case strings.HasPrefix(b, "403 "):
-			code, b = 403, b[4:]
-		case strings.HasPrefix(b, "500 "):
-			code, b = 500, b[4:]
-		}
-		out = append(out, scriptStep{http: code, body: b})
-	}
-	return out
-}

internal/core/channels_plugin_test.go

@@ -1,241 +0,0 @@
-package core
-
-import (
-	"encoding/json"
-	"testing"
-
-	"llmsproxy/internal/lua"
-)
-
-// TestChannelsPluginEndToEnd 是「同类插件」的完整验收：
-// 内置的 channels 插件在**真实内核**上跑通「登录 → 存凭据 → 接入为上游源」。
-//
-// 这条链路横跨本次所有新增能力，所以它是最有信息量的一个测试：
-//
-//	__llmsproxy_kernel  add_source 把平台注册为上游源
-//	内核权限            默认拒绝，需运维授权
-//	额外出站主机授权    登录域不在源列表里，默认被出站白名单拒绝（plugin.hosts）
-//	登录会话            插件自持（plugin.state.sessions），内核无登录概念
-func TestChannelsPluginEndToEnd(t *testing.T) {
-	c := kernelTestCore(t)
-	ps := c.Plugins()
-
-	src, err := lua.ReadBundledPlugin("channels")
-	if err != nil {
-		t.Fatalf("读取内置 channels 插件: %v", err)
-	}
-	if err := ps.LoadSource("channels", src); err != nil {
-		t.Fatalf("加载 channels: %v", err)
-	}
-
-	// 1. 平台清单可用（未授权任何东西也应能列出）
-	out, err := ps.InvokeHandler("channels", "list_platforms", &lua.HandlerRequest{
-		Method: "GET", Role: "admin",
-	})
-	if err != nil {
-		t.Fatalf("list_platforms: %v", err)
-	}
-	body, _ := out.JSON.(map[string]interface{})
-	plats, _ := body["platforms"].([]interface{})
-	if len(plats) < 3 {
-		t.Fatalf("应至少 3 个平台, 实得 %d", len(plats))
-	}
-
-	// 2. 发起登录 → 拿到会话与 URL
-	out, err = ps.InvokeHandler("channels", "start_login", &lua.HandlerRequest{
-		Method: "POST", Body: `{"platform":"example"}`, Role: "admin",
-	})
-	if err != nil {
-		t.Fatalf("start_login: %v", err)
-	}
-	m := out.JSON.(map[string]interface{})
-	if m["error"] != nil {
-		t.Fatalf("发起登录失败: %v", m["error"])
-	}
-	if m["url"] == nil || m["url"] == "" {
-		t.Fatal("应返回用户要打开的登录 URL")
-	}
-	sess := m["session"].(map[string]interface{})
-	id, _ := sess["id"].(string)
-	if id == "" {
-		t.Fatal("应返回会话 id")
-	}
-
-	// 3. 轮询到 pending
-	out, _ = ps.InvokeHandler("channels", "poll_login", &lua.HandlerRequest{
-		Method: "GET", Query: map[string]string{"id": id}, Role: "admin",
-	})
-	if st := out.JSON.(map[string]interface{})["state"]; st != "pending" {
-		t.Fatalf("应为 pending, 实得 %v", st)
-	}
-
-	// 4. 未授权内核动作时，接入源必须失败且**如实报告**（不是假装成功）
-	out, err = ps.InvokeHandler("channels", "complete_login", &lua.HandlerRequest{
-		Method: "POST", Body: `{"platform":"example","credential":"tok-1","account":"alice"}`, Role: "admin",
-	})
-	if err != nil {
-		t.Fatalf("complete_login: %v", err)
-	}
-	done := out.JSON.(map[string]interface{})
-	if done["source_error"] == nil {
-		t.Fatal("未授权 add_source 时应报告 source_error")
-	}
-	t.Logf("未授权时的如实报告: %v", done["source_error"])
-
-	// 凭据必须已在保险库（登录本身成功了）
-	tok, ok, _ := ps.GetSecret("channels", "channels:example")
-	if !ok || tok != "tok-1" {
-		t.Fatalf("凭据应已存保险库: ok=%v tok=%q", ok, tok)
-	}
-	// 且不得出现在 state 里
-	if stateHasSecret(ps, "channels", "tok-1") {
-		t.Fatal("★ 凭据泄漏进了 plugin.state")
-	}
-
-	// 5. 运维授权后，重新接入应当真的把源注册进内核
-	if err := ps.SetPluginKernelPermission("channels",
-		[]string{"add_source", "list_sources", "status"}, false); err != nil {
-		t.Fatal(err)
-	}
-	out, err = ps.InvokeHandler("channels", "complete_login", &lua.HandlerRequest{
-		Method: "POST", Body: `{"platform":"example","credential":"tok-1","account":"alice"}`, Role: "admin",
-	})
-	if err != nil {
-		t.Fatalf("complete_login(授权后): %v", err)
-	}
-	done = out.JSON.(map[string]interface{})
-	if done["source_error"] != nil {
-		t.Fatalf("授权后仍失败: %v", done["source_error"])
-	}
-	if done["source"] != "channels-example" {
-		t.Fatalf("源名不对: %v", done["source"])
-	}
-
-	// 内核侧必须真的有这个源
-	found := false
-	for _, s := range c.Sources() {
-		if s.Name == "channels-example" {
-			found = true
-			if s.BaseURL != "https://api.example.com/v1" {
-				t.Errorf("base_url 未落库: %q", s.BaseURL)
-			}
-		}
-	}
-	if !found {
-		t.Fatal("插件接入的源没有出现在内核源列表里")
-	}
-	// 平台声明的模型应可路由
-	models := c.Registry().ModelList()
-	hasModel := false
-	for _, id := range models {
-		if id == "example-chat" {
-			hasModel = true
-		}
-	}
-	if !hasModel {
-		t.Errorf("平台模型未进入可路由列表: %v", models)
-	}
-	t.Logf("已接入源 channels-example，模型可见: %v", models)
-}
-
-// TestChannelsPluginDeclaresItsNeeds 断言插件如实声明了它需要什么。
-//
-// 声明是运维审批的依据：插件不声明，设置页就无法显示"申请中"，
-// 运维只能等某个功能静默失效后才发现。
-func TestChannelsPluginDeclaresItsNeeds(t *testing.T) {
-	c := kernelTestCore(t)
-	ps := c.Plugins()
-	src, err := lua.ReadBundledPlugin("channels")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := ps.LoadSource("channels", src); err != nil {
-		t.Fatal(err)
-	}
-	// 内核动作声明
-	views := ps.KernelPermissions()
-	var declared []string
-	for _, v := range views {
-		if v.Plugin == "channels" {
-			declared = v.Declared
-		}
-	}
-	if len(declared) == 0 {
-		t.Fatal("channels 应声明它需要的内核动作")
-	}
-	for _, want := range []string{"add_source", "status"} {
-		found := false
-		for _, d := range declared {
-			if d == want {
-				found = true
-			}
-		}
-		if !found {
-			t.Errorf("应声明 %q, 实得 %v", want, declared)
-		}
-	}
-	// 额外出站主机声明（非源 host，需单独批准）
-	hosts := ps.PluginExtraHosts("channels")
-	if len(hosts) == 0 {
-		t.Fatal("channels 应声明额外出站主机")
-	}
-	t.Logf("声明内核动作=%v 额外主机=%v", declared, hosts)
-}
-
-// TestChannelsPluginHandlersRequireStatus 是一个契约回归：插件的每个 handler
-// 都必须返回 {status,json/body}，否则内核会**静默丢弃**它（实测踩过：
-// `return {url=…}` 得到 200 空响应，没有任何错误信息）。
-func TestChannelsPluginHandlersRequireStatus(t *testing.T) {
-	c := kernelTestCore(t)
-	ps := c.Plugins()
-	src, err := lua.ReadBundledPlugin("channels")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := ps.LoadSource("channels", src); err != nil {
-		t.Fatal(err)
-	}
-	_ = ps.SetPluginKernelPermission("channels", []string{"add_source", "status", "list_sources"}, false)
-
-	// 每个 handler 至少要在正常输入下给出非空响应
-	cases := []struct {
-		fn   string
-		req  *lua.HandlerRequest
-		what string
-	}{
-		{"list_platforms", &lua.HandlerRequest{Method: "GET"}, "平台列表"},
-		{"status_page", &lua.HandlerRequest{Method: "GET"}, "状态页"},
-		{"poll_login", &lua.HandlerRequest{Method: "GET", Query: map[string]string{"id": "nope"}}, "轮询(未知会话)"},
-		{"start_login", &lua.HandlerRequest{Method: "POST", Body: `{"platform":"example"}`}, "发起登录"},
-		{"start_login", &lua.HandlerRequest{Method: "POST", Body: `{"platform":"nope"}`}, "发起登录(未知平台)"},
-		{"complete_login", &lua.HandlerRequest{Method: "POST", Body: `{}`}, "完成登录(缺字段)"},
-		{"claim_daily", &lua.HandlerRequest{Method: "POST", Body: `{"platform":"example"}`}, "领额度(未登录)"},
-	}
-	for _, tc := range cases {
-		out, err := ps.InvokeHandler("channels", tc.fn, tc.req)
-		if err != nil {
-			t.Errorf("%s (%s) 返回错误: %v", tc.fn, tc.what, err)
-			continue
-		}
-		if out.JSON == nil && out.Body == "" {
-			t.Errorf("%s (%s) 返回空响应 —— 内核会静默丢弃，调用方看不到任何原因",
-				tc.fn, tc.what)
-		}
-	}
-}
-
-// jsonMarshalForTest 序列化一个接口值，用于检查凭据是否出现在 state 里。
-func jsonMarshalForTest(v interface{}) ([]byte, error) { return json.Marshal(v) }
-
-// stateHasSecret 检查凭据是否泄漏进 plugin.state。
-func stateHasSecret(ps *lua.Plugins, plugin, secret string) bool {
-	st := ps.State(plugin)
-	if st == nil {
-		return false
-	}
-	b, err := jsonMarshalForTest(st)
-	if err != nil {
-		return false
-	}
-	return contains(string(b), secret)
-}

internal/core/channels_pool_test.go

@@ -1,322 +0,0 @@
-package core
-
-import (
-	"strings"
-	"testing"
-
-	"llmsproxy/internal/lua"
-)
-
-// channels_pool_test：对齐参考 account.* / model.* / provider.* 契约的行为测试。
-// 账号池增删改、上游源随 enabled/模型开关同步、供应商整体开关、备份导出。
-
-func poolCore(t *testing.T) (*Core, *lua.Plugins) {
-	t.Helper()
-	c := kernelTestCore(t)
-	ps := c.Plugins()
-	src, err := readBundledChannels(t)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := ps.LoadSource("channels", src); err != nil {
-		t.Fatal(err)
-	}
-	_ = ps.SetPluginKernelPermission("channels", []string{"add_source", "list_sources", "remove_source", "status", "probe_all", "reset_health"}, false)
-	return c, ps
-}
-
-// listSourcesViaKernel 直查内核 list_sources（actionListSources 返回 []map）。
-func listSourcesViaKernel(t *testing.T, c *Core) []map[string]interface{} {
-	t.Helper()
-	out, err := c.Invoke(nil, "list_sources", map[string]interface{}{})
-	if err != nil {
-		t.Fatalf("list_sources: %v", err)
-	}
-	if ms, ok := out.([]map[string]interface{}); ok {
-		return ms
-	}
-	raw, _ := out.([]interface{})
-	var srcs []map[string]interface{}
-	for _, s := range raw {
-		if m, ok := s.(map[string]interface{}); ok {
-			srcs = append(srcs, m)
-		}
-	}
-	return srcs
-}
-
-func invoke(t *testing.T, ps *lua.Plugins, fn, body string) map[string]interface{} {
-	t.Helper()
-	out, err := ps.InvokeHandler("channels", fn, &lua.HandlerRequest{Method: "POST", Body: body})
-	if err != nil {
-		t.Fatalf("invoke %s: %v", fn, err)
-	}
-	return out.JSON.(map[string]interface{})
-}
-
-// asArr 规整桥接后的数组。Lua 空表过桥是 map[string]interface{}（无法与空数组
-// 区分，见 vm.go luaTableToGoValue）；内核 list_sources 的 models 过桥是 []string。
-func asArr(v interface{}) []interface{} {
-	switch a := v.(type) {
-	case []interface{}:
-		return a
-	case []string:
-		out := make([]interface{}, len(a))
-		for i, s := range a {
-			out[i] = s
-		}
-		return out
-	}
-	return nil
-}
-
-func srcHasAccount(srcs []map[string]interface{}, needle string) (map[string]interface{}, bool) {
-	for _, sm := range srcs {
-		if name, _ := sm["name"].(string); strings.Contains(name, needle) {
-			return sm, true
-		}
-	}
-	return nil, false
-}
-
-// TestChannelsAccountPoolBehavior：账号池 CRUD + 上游源同步 + 模型/供应商开关 + 备份。
-func TestChannelsAccountPoolBehavior(t *testing.T) {
-	c, ps := poolCore(t)
-
-	t.Run("账号增删改", func(t *testing.T) {
-		m := invoke(t, ps, "account_add", `{"platform":"minimax","nickname":"我的号"}`)
-		if m["ok"] != true {
-			t.Fatalf("account_add: %v", m)
-		}
-		aid, _ := m["account_id"].(string)
-		if aid == "" {
-			t.Fatalf("account_add 应返回 account_id: %v", m)
-		}
-		m = invoke(t, ps, "account_list", `{"platform":"minimax"}`)
-		accts := asArr(m["accounts"])
-		if len(accts) != 1 {
-			t.Fatalf("应有1个账号: %d", len(accts))
-		}
-		a := accts[0].(map[string]interface{})
-		if a["nickname"] != "我的号" || a["enabled"] != true {
-			t.Fatalf("账号字段: %v", a)
-		}
-		invoke(t, ps, "account_update", `{"platform":"minimax","account_id":"`+aid+`","patch":{"nickname":"改名"}}`)
-		m = invoke(t, ps, "account_list", `{"platform":"minimax"}`)
-		if asArr(m["accounts"])[0].(map[string]interface{})["nickname"] != "改名" {
-			t.Fatalf("改名失败")
-		}
-		invoke(t, ps, "account_delete", `{"platform":"minimax","account_id":"`+aid+`"}`)
-		m = invoke(t, ps, "account_list", `{"platform":"minimax"}`)
-		if n := len(asArr(m["accounts"])); n != 0 {
-			t.Fatalf("删除后应为0, 实得 %d", n)
-		}
-	})
-
-	t.Run("模型开关同步上游源", func(t *testing.T) {
-		m := invoke(t, ps, "account_add", `{"platform":"minimax","credential":"MM-KEY"}`)
-		aid, _ := m["account_id"].(string)
-		sm, ok := srcHasAccount(listSourcesViaKernel(t, c), aid)
-		if !ok {
-			t.Fatal("带凭据账号应已同步源")
-		}
-		if n := len(asArr(sm["models"])); n != 3 {
-			t.Fatalf("源应有3模型, 实得 %d", n)
-		}
-		invoke(t, ps, "model_set_disabled", `{"platform":"minimax","model_id":"MiniMax-M3","disabled":true}`)
-		sm, _ = srcHasAccount(listSourcesViaKernel(t, c), aid)
-		if n := len(asArr(sm["models"])); n != 2 {
-			t.Fatalf("关1模型后源应2模型, 实得 %d", n)
-		}
-		invoke(t, ps, "model_set_all_disabled", `{"platform":"minimax","disabled":true}`)
-		m = invoke(t, ps, "provider_status", `{}`)
-		for _, s := range asArr(m["statuses"]) {
-			x := s.(map[string]interface{})
-			if x["id"] == "minimax" && x["closed"] != true {
-				t.Fatalf("全关模型后应 closed=true: %v", x)
-			}
-		}
-		invoke(t, ps, "model_set_all_disabled", `{"platform":"minimax","disabled":false}`)
-	})
-
-	t.Run("enabled开关同步上游源", func(t *testing.T) {
-		m := invoke(t, ps, "account_list", `{"platform":"minimax"}`)
-		accts := asArr(m["accounts"])
-		if len(accts) == 0 {
-			t.Fatal("上个用例应留有账号")
-		}
-		aid := accts[0].(map[string]interface{})["id"].(string)
-		before := len(listSourcesViaKernel(t, c))
-		invoke(t, ps, "account_update", `{"platform":"minimax","account_id":"`+aid+`","patch":{"enabled":false}}`)
-		if n := len(listSourcesViaKernel(t, c)); n != before-1 {
-			t.Fatalf("停用账号应删源: 前 %d 后 %d", before, n)
-		}
-		invoke(t, ps, "account_update", `{"platform":"minimax","account_id":"`+aid+`","patch":{"enabled":true}}`)
-		if n := len(listSourcesViaKernel(t, c)); n != before {
-			t.Fatalf("启用账号应重建源: 前 %d 后 %d", before, n)
-		}
-	})
-
-	t.Run("供应商整体开关", func(t *testing.T) {
-		invoke(t, ps, "provider_set_enabled", `{"platform":"minimax","enabled":false}`)
-		if _, ok := srcHasAccount(listSourcesViaKernel(t, c), "minimax"); ok {
-			t.Fatal("关闭渠道后不应有 minimax 源")
-		}
-		m := invoke(t, ps, "provider_status", `{}`)
-		for _, s := range asArr(m["statuses"]) {
-			x := s.(map[string]interface{})
-			if x["id"] == "minimax" && x["closed"] != true {
-				t.Fatalf("关闭后应 closed: %v", x)
-			}
-		}
-		invoke(t, ps, "provider_set_enabled", `{"platform":"minimax","enabled":true}`)
-		if _, ok := srcHasAccount(listSourcesViaKernel(t, c), "minimax"); !ok {
-			t.Fatal("开启渠道后应有 minimax 源")
-		}
-	})
-
-	t.Run("备份导出含凭据", func(t *testing.T) {
-		invoke(t, ps, "account_add", `{"platform":"cline","credential":"CL-KEY","nickname":"cl1"}`)
-		exp := invoke(t, ps, "backup_export", `{}`)
-		payload, _ := exp["payload"].(map[string]interface{})
-		if payload == nil {
-			t.Fatal("backup_export 应返回 payload")
-		}
-		creds, _ := payload["credentials"].(map[string]interface{})
-		found := false
-		for _, v := range creds {
-			if v == "CL-KEY" {
-				found = true
-			}
-		}
-		if !found {
-			t.Fatalf("备份应含凭据明文: %v", creds)
-		}
-	})
-}
-
-// TestChannelsExtendedRPCBehavior：对齐参考剩余 RPC 面（credits.status/balances、
-// account.reset/retest、model.setDisabledMany/clearDead、provider 排序、
-// gateway/backup.status、usage.badgePreference、onboarding）。
-func TestChannelsExtendedRPCBehavior(t *testing.T) {
-	_, ps := poolCore(t)
-
-	t.Run("credits_balances_无凭据报错_有凭据解析", func(t *testing.T) {
-		m := invoke(t, ps, "account_add", `{"platform":"minimax","nickname":"b1"}`)
-		aid, _ := m["account_id"].(string)
-		j := invoke(t, ps, "credits_balances", `{"platform":"minimax"}`)
-		var row map[string]interface{}
-		for _, a := range asArr(j["accounts"]) {
-			x := a.(map[string]interface{})
-			if x["accountId"] == aid {
-				row = x
-			}
-		}
-		if row == nil {
-			t.Fatal("balances 应含该账号")
-		}
-		if row["balance"] != nil || row["error"] == nil {
-			t.Fatalf("无凭据应 error 而非编造余额: %v", row)
-		}
-	})
-
-	t.Run("credits_status_无端点平台如实null", func(t *testing.T) {
-		m := invoke(t, ps, "account_add", `{"platform":"opencode","nickname":"oc1"}`)
-		aid, _ := m["account_id"].(string)
-		j := invoke(t, ps, "credits_status", `{"platform":"opencode"}`)
-		for _, a := range asArr(j["accounts"]) {
-			x := a.(map[string]interface{})
-			if x["accountId"] == aid && x["status"] != nil {
-				t.Fatalf("opencode 无状态端点应 null: %v", x)
-			}
-		}
-	})
-
-	t.Run("account_reset_clears", func(t *testing.T) {
-		invoke(t, ps, "account_add", `{"platform":"minimax","nickname":"r1"}`)
-		j := invoke(t, ps, "account_reset", `{"platform":"minimax","account_id":"__all__"}`)
-		if j["ok"] != true {
-			t.Fatalf("resetAll: %v", j)
-		}
-	})
-
-	t.Run("model_set_disabled_many", func(t *testing.T) {
-		invoke(t, ps, "model_set_disabled_many", `{"platform":"minimax","model_ids":["MiniMax-M3","MiniMax-M2.7-highspeed"],"disabled":true}`)
-		j := invoke(t, ps, "model_list", `{"platform":"minimax"}`)
-		off := 0
-		for _, x := range asArr(j["models"]) {
-			mm := x.(map[string]interface{})
-			if mm["disabled"] == true {
-				off++
-			}
-		}
-		if off != 2 {
-			t.Fatalf("批量关2模型后应2个disabled, 实得 %d", off)
-		}
-		invoke(t, ps, "model_set_disabled_many", `{"platform":"minimax","model_ids":["MiniMax-M3","MiniMax-M2.7-highspeed"],"disabled":false}`)
-	})
-
-	t.Run("model_clear_dead_只清黑名单里已下线的", func(t *testing.T) {
-		invoke(t, ps, "model_set_disabled", `{"platform":"minimax","model_id":"MiniMax-M3","disabled":true}`)
-		j := invoke(t, ps, "model_clear_dead", `{"platform":"minimax"}`)
-		if n := len(asArr(j["removed"])); n != 0 {
-			t.Fatalf("在册模型不算死模型, 实得 %d", n)
-		}
-		// 手动放一个不在 models 表里的黑名单项
-		invoke(t, ps, "model_set_disabled_many", `{"platform":"minimax","model_ids":["ghost-model"],"disabled":true}`)
-		j = invoke(t, ps, "model_clear_dead", `{"platform":"minimax"}`)
-		if n := len(asArr(j["removed"])); n != 1 {
-			t.Fatalf("死模型应被清: %v", j)
-		}
-		invoke(t, ps, "model_set_disabled", `{"platform":"minimax","model_id":"MiniMax-M3","disabled":false}`)
-	})
-
-	t.Run("provider_order", func(t *testing.T) {
-		invoke(t, ps, "provider_set_order", `{"order":["minimax","trae","bogus"]}`)
-		j := invoke(t, ps, "provider_get_order", `{}`)
-		order := asArr(j["order"])
-		if len(order) != 2 {
-			t.Fatalf("bogus 应被过滤, 实得 %v", order)
-		}
-		if order[0] != "minimax" {
-			t.Fatalf("顺序应保留: %v", order)
-		}
-	})
-
-	t.Run("backup_status", func(t *testing.T) {
-		invoke(t, ps, "account_add", `{"platform":"minimax","nickname":"s1"}`)
-		j := invoke(t, ps, "backup_status", `{}`)
-		if n, _ := j["accounts"].(float64); n < 1 {
-			t.Fatalf("backup_status 应统计账号: %v", j)
-		}
-	})
-
-	t.Run("badge_preference_非法值拒绝", func(t *testing.T) {
-		j := invoke(t, ps, "usage_badge_preference", `{"preference":"bogus"}`)
-		if j["error"] == nil {
-			t.Fatalf("非法偏好应拒绝: %v", j)
-		}
-		j = invoke(t, ps, "usage_badge_preference", `{"preference":"credits"}`)
-		if j["preference"] != "credits" {
-			t.Fatalf("合法偏好应保存: %v", j)
-		}
-	})
-
-	t.Run("onboarding_不支持平台如实报", func(t *testing.T) {
-		j := invoke(t, ps, "onboarding_status", `{"platform":"minimax"}`)
-		if j["supported"] != false {
-			t.Fatalf("minimax 无新人任务应 supported=false: %v", j)
-		}
-	})
-
-	t.Run("permanent_lock_读写", func(t *testing.T) {
-		j := invoke(t, ps, "credits_permanent_lock", `{"platform":"buddy","locked":true}`)
-		if j["locked"] != true {
-			t.Fatalf("锁定应生效: %v", j)
-		}
-		j = invoke(t, ps, "credits_permanent_lock", `{"platform":"buddy"}`)
-		if j["locked"] != true {
-			t.Fatalf("只读应回显锁定: %v", j)
-		}
-	})
-}

internal/core/channels_stress_test.go

@@ -1,251 +0,0 @@
-package core
-
-import (
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"testing"
-
-	"llmsproxy/internal/config"
-	"llmsproxy/internal/lua"
-)
-
-// mustBox 构造一个真 SecretBox（与运行期同一实现，密钥落 runtime dir）。
-func mustBox(t *testing.T, runtimeFile string) *config.SecretBox {
-	t.Helper()
-	box, err := config.NewSecretBox(runtimeFile)
-	if err != nil {
-		t.Fatal(err)
-	}
-	return box
-}
-
-// channelsCore 起一个带 channels 插件、可指定源码与 box 的核心（压力测试用）。
-func channelsCore(t *testing.T, src string) (*Core, *lua.Plugins) {
-	t.Helper()
-	c := kernelTestCore(t)
-	ps := c.Plugins()
-	if err := ps.LoadSource("channels", src); err != nil {
-		t.Fatalf("加载 channels: %v", err)
-	}
-	ps.SetSecretBox(mustBox(t, filepath.Join(t.TempDir(), "runtime.json")))
-	_ = ps.SetPluginKernelPermission("channels", []string{"add_source", "status", "list_sources"}, false)
-	return c, ps
-}
-
-// TestChannelsConcurrentLogins 压力：并发走 device-poll 登录。
-//
-// 插件是单 VM 单锁 —— 本测试验证的是**正确性下的并发**（会话互不串台、
-// 凭据互不可见、最终都 completed），真吞吐压力在 e2e 层（真二进制+HTTP 并发）。
-func TestChannelsConcurrentLogins(t *testing.T) {
-	var hits int32
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/oauth2/device/code":
-			n := atomic.AddInt32(&hits, 1)
-			w.Header().Set("Content-Type", "application/json")
-			fmt.Fprintf(w, `{"device_code":"DEV-%d","user_code":"UC-%d","verification_uri":"https://example/activate","interval":1,"expires_in":600}`, n, n)
-		case "/oauth2/token":
-			w.Header().Set("Content-Type", "application/json")
-			fmt.Fprint(w, `{"access_token":"TOK","refresh_token":"RF","nickname":"u"}`)
-		default:
-			w.WriteHeader(404)
-		}
-	}))
-	defer ts.Close()
-
-	_, ps := channelsCore(t, mustChannelsSrc(t))
-	// 把 minimax 端点指到假上游
-	if _, err := ps.Call("channels", "set_endpoints", map[string]interface{}{
-		"platform": "minimax",
-		"device": map[string]interface{}{
-			"code_url":  ts.URL + "/oauth2/device/code",
-			"token_url": ts.URL + "/oauth2/token",
-		},
-	}); err != nil {
-		t.Fatal(err)
-	}
-
-	const rounds = 12
-	var wg sync.WaitGroup
-	var failures int32
-	for i := 0; i < rounds; i++ {
-		wg.Add(1)
-		go func(n int) {
-			defer wg.Done()
-			out, err := ps.InvokeHandler("channels", "start_login", &lua.HandlerRequest{
-				Method: "POST", Body: `{"platform":"minimax"}`,
-			})
-			if err != nil {
-				t.Errorf("start_login #%d: %v", n, err)
-				atomic.AddInt32(&failures, 1)
-				return
-			}
-			j := out.JSON.(map[string]interface{})
-			sess, _ := j["session"].(map[string]interface{})
-			if sess == nil {
-				t.Errorf("start_login #%d 无会话: %v", n, j)
-				atomic.AddInt32(&failures, 1)
-				return
-			}
-			sid := sess["id"].(string)
-			for k := 0; k < 10; k++ {
-				out2, _ := ps.InvokeHandler("channels", "poll_login", &lua.HandlerRequest{
-					Method: "GET", Query: map[string]string{"id": sid},
-				})
-				m2 := out2.JSON.(map[string]interface{})
-				if m2["state"] == "completed" {
-					return
-				}
-				if m2["state"] == "failed" {
-					t.Errorf("会话 #%d failed: %v", n, m2)
-					atomic.AddInt32(&failures, 1)
-					return
-				}
-			}
-			t.Errorf("会话 #%d 10 次轮询未终态", n)
-			atomic.AddInt32(&failures, 1)
-		}(i)
-	}
-	wg.Wait()
-	if failures != 0 {
-		t.Fatalf("并发登录失败 %d 轮", failures)
-	}
-}
-
-// TestChannelsClaimStress 压力：同一平台并发领签到（幂等 + 无登录态丢失）。
-func TestChannelsClaimStress(t *testing.T) {
-	var claims int32
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path == "/v1/checkin" {
-			atomic.AddInt32(&claims, 1)
-			w.Header().Set("Content-Type", "application/json")
-			fmt.Fprint(w, `{"ok":true,"credits":10}`)
-			return
-		}
-		w.WriteHeader(404)
-		fmt.Fprint(w, `{}`)
-	}))
-	defer ts.Close()
-
-	_, ps := channelsCore(t, mustChannelsSrc(t))
-	if _, err := ps.Call("channels", "set_endpoints", map[string]interface{}{
-		"platform": "cookieish",
-		"checkin":  map[string]interface{}{"url": ts.URL + "/v1/checkin"},
-	}); err != nil {
-		t.Fatal(err)
-	}
-	if err := ps.SetSecret("channels", "channels:cookieish", "PASTE-TOKEN"); err != nil {
-		t.Fatal(err)
-	}
-
-	const n = 30
-	var wg sync.WaitGroup
-	for i := 0; i < n; i++ {
-		wg.Add(1)
-		go func(k int) {
-			defer wg.Done()
-			out, err := ps.InvokeHandler("channels", "claim_daily", &lua.HandlerRequest{
-				Method: "POST", Body: `{"platform":"cookieish"}`,
-			})
-			if err != nil {
-				t.Errorf("claim #%d: %v", k, err)
-				return
-			}
-			j := out.JSON.(map[string]interface{})
-			if j["ok"] != true {
-				t.Errorf("claim #%d 未成功: %v", k, j)
-			}
-		}(i)
-	}
-	wg.Wait()
-	if got := atomic.LoadInt32(&claims); got != n {
-		t.Errorf("上游应收到 %d 次领取, 实得 %d", n, got)
-	}
-}
-
-// TestLegacyVaultPlaintextLoad 旧通路：老版本（无加密）写的明文库在新版本
-// （带 box）下必须能读 —— 凭据升级不丢。落盘则会在下次写时整体重封为密文。
-func TestLegacyVaultPlaintextLoad(t *testing.T) {
-	dir := t.TempDir()
-	ps := lua.NewPlugins(nil, dir)
-	if err := ps.SetSecret("legacy", "channels:old", "PLAIN-OLD-TOKEN"); err != nil {
-		t.Fatal(err)
-	}
-	ps.SetSecretBox(mustBox(t, filepath.Join(dir, "runtime.json")))
-	v, ok, err := ps.GetSecret("legacy", "channels:old")
-	if err != nil || !ok || v != "PLAIN-OLD-TOKEN" {
-		t.Fatalf("旧明文库读回失败: v=%q ok=%v err=%v", v, ok, err)
-	}
-	// 任意一次写触发整体重封
-	if err := ps.SetSecret("legacy", "k2", "NEW"); err != nil {
-		t.Fatal(err)
-	}
-	raw, err := os.ReadFile(filepath.Join(dir, ".secrets", "legacy.json"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if strings.Contains(string(raw), "PLAIN-OLD-TOKEN") {
-		t.Fatalf("★ 重封后旧明文仍在盘上:\n%s", raw)
-	}
-	if !strings.Contains(string(raw), "enc:v1:") {
-		t.Fatalf("重封后应含密文:\n%s", raw)
-	}
-}
-
-// TestLegacySourceSealedConfig 旧通路：config.yaml 里明文 api_key 的旧配置，
-// 新版本加载后运行期拿到解密值、落盘被 seal（SealIfNeeded 语义）。
-func TestLegacySourceSealedConfig(t *testing.T) {
-	dir := t.TempDir()
-	cfgPath := filepath.Join(dir, "config.yaml")
-	yaml := "listen: 127.0.0.1:0\n" +
-		"gateway_keys:\n  - sk-legacy-0001\n" +
-		"runtime_file: " + filepath.Join(dir, "runtime.json") + "\n" +
-		"adapter_dir: " + filepath.Join(dir, "adapters") + "\n" +
-		"sources:\n" +
-		"  - name: legacy-src\n" +
-		"    base_url: https://legacy.example.com/v1\n" +
-		"    adapter: openai\n" +
-		"    api_key: PLAIN-LEGACY-KEY\n" +
-		"    max_concurrent: 2\n" +
-		"    models:\n" +
-		"      - id: m1\n" +
-		"        kind: chat\n" +
-		"        priority: 10\n"
-	if err := os.WriteFile(cfgPath, []byte(yaml), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	cfg, err := config.Load(cfgPath)
-	if err != nil {
-		t.Fatal(err)
-	}
-	c, err := NewFromConfig(cfg)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer c.Close()
-
-	got := c.Sources()
-	if len(got) != 1 || got[0].APIKey != "PLAIN-LEGACY-KEY" {
-		t.Fatalf("运行期 api_key 应解密: %#v", got)
-	}
-	raw, err := os.ReadFile(cfgPath)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if strings.Contains(string(raw), "PLAIN-LEGACY-KEY") {
-		t.Fatalf("★ 旧明文 api_key 升级后仍明文落盘:\n%s", raw)
-	}
-	if !strings.Contains(string(raw), "enc:v1:") {
-		t.Fatalf("落盘应含 enc:v1 密文:\n%s", raw)
-	}
-	mk, err := os.ReadFile(filepath.Join(dir, "master.key"))
-	if err != nil || len(mk) != 64 {
-		t.Fatalf("master.key 应 64 hex, len=%d err=%v", len(mk), err)
-	}
-}

internal/core/channels_trae_test.go

@@ -1,173 +0,0 @@
-package core
-
-import (
-	"fmt"
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"sync/atomic"
-	"testing"
-
-	"llmsproxy/internal/lua"
-)
-
-// traeHarness：TRAE callback 流的测试台。假上游模拟 ExchangeToken；
-// 回调用 InvokeHandler 直打 oauth_callback（Query 表 = 平台重定向回来的参数）。
-type traeHarness struct {
-	t       *testing.T
-	ps      *lua.Plugins
-	ts      *httptest.Server
-	exchHit int32
-	exchOK  int32 // 1=成功 0=失败（atomic）
-}
-
-func newTraeHarness(t *testing.T) *traeHarness {
-	t.Helper()
-	h := &traeHarness{t: t, exchOK: 1}
-	h.ts = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/cloudide/api/v3/trae/oauth/ExchangeToken" {
-			w.WriteHeader(404)
-			return
-		}
-		n := atomic.AddInt32(&h.exchHit, 1)
-		w.Header().Set("Content-Type", "application/json")
-		if atomic.LoadInt32(&h.exchOK) == 0 {
-			w.WriteHeader(500)
-			fmt.Fprint(w, `{"error":"exchange down"}`)
-			return
-		}
-		// 校验请求体形状（对齐参考 exchangeTraeCallback 的请求构造）
-		body, _ := io.ReadAll(r.Body)
-		for _, want := range []string{`"ClientID"`, `"RefreshToken":"RT-FROM-CALLBACK"`, `"ClientSecret":"-"`} {
-			if !strings.Contains(string(body), want) {
-				t.Errorf("ExchangeToken 请求体缺 %s: %s", want, body)
-			}
-		}
-		fmt.Fprintf(w, `{"Token":"ACCESS-%d","RefreshToken":"RT-NEW-%d"}`, n, n)
-	}))
-	t.Cleanup(h.ts.Close)
-
-	c := kernelTestCore(t)
-	h.ps = c.Plugins()
-	src, err := readBundledChannels(t)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := h.ps.LoadSource("channels", src); err != nil {
-		t.Fatal(err)
-	}
-	_ = h.ps.SetPluginKernelPermission("channels", []string{"add_source", "status", "list_sources"}, false)
-	// ExchangeToken 指到假上游（set_endpoints 既是运维能力也是测试缝）
-	if _, err := h.ps.Call("channels", "set_endpoints", map[string]interface{}{
-		"platform": "trae",
-		"callback": map[string]interface{}{
-			"exchange_url": h.ts.URL + "/cloudide/api/v3/trae/oauth/ExchangeToken",
-		},
-	}); err != nil {
-		t.Fatalf("set_endpoints: %v", err)
-	}
-	return h
-}
-
-// beginAndCallback 发起登录（拿 nonce）后直接打 oauth_callback。
-// cbQuery 是回调的 query（不含 state，内部补）；值即平台重定向回来的原始参数。
-func (h *traeHarness) beginAndCallback(cbQuery map[string]string) (int, string) {
-	out, err := h.ps.InvokeHandler("channels", "start_login", &lua.HandlerRequest{
-		Method: "POST", Body: `{"platform":"trae"}`,
-	})
-	if err != nil {
-		h.t.Fatal(err)
-	}
-	j, ok := out.JSON.(map[string]interface{})
-	if !ok {
-		h.t.Fatalf("start_login 返回非对象: %#v", out.JSON)
-	}
-	sess := j["session"].(map[string]interface{})
-	nonce := sess["nonce"].(string)
-
-	q := map[string]string{"state": nonce}
-	for k, v := range cbQuery {
-		q[k] = v
-	}
-	res, err := h.ps.InvokeHandler("channels", "oauth_callback", &lua.HandlerRequest{
-		Method: "GET", Query: q,
-	})
-	if err != nil {
-		h.t.Fatal(err)
-	}
-	return res.Status, fmt.Sprintf("%v|%v", res.Body, res.JSON)
-}
-
-// TestTraeCallbackBehavior 是 TRAE callback 流的行为对齐测试。
-//
-// 决策表逐行搬自参考实现 parseTraeCallbackDetailed + exchangeTraeCallback
-// （trae-oauth.ts）。断言的是行为（凭据来源 / 错误文案 / 上游是否被调），不是实现细节。
-func TestTraeCallbackBehavior(t *testing.T) {
-	h := newTraeHarness(t)
-
-	t.Run("行1 refreshToken直传_ExchangeToken换新", func(t *testing.T) {
-		atomic.StoreInt32(&h.exchOK, 1)
-		st, body := h.beginAndCallback(map[string]string{
-			"refreshToken": "RT-FROM-CALLBACK",
-			"userInfo":     `{"UserID":"u1","ScreenName":"张三","TenantID":"t1"}`,
-		})
-		if st != 200 {
-			t.Fatalf("应 200: %d %s", st, body)
-		}
-		// 凭据必须是 ExchangeToken 的新 Token，不是回调原值
-		v, _, _ := h.ps.GetSecret("channels", "channels:trae")
-		if !strings.HasPrefix(v, "ACCESS-") {
-			t.Fatalf("凭据应是 ExchangeToken 的新 access, 实得 %q", v)
-		}
-	})
-
-	t.Run("行2 无refreshToken_userJwtToken兜底_不打ExchangeToken", func(t *testing.T) {
-		before := atomic.LoadInt32(&h.exchHit)
-		st, body := h.beginAndCallback(map[string]string{
-			"userJwt": `{"Token":"JWT-TOKEN-1","RefreshToken":""}`,
-		})
-		if st != 200 {
-			t.Fatalf("应 200: %d %s", st, body)
-		}
-		v, _, _ := h.ps.GetSecret("channels", "channels:trae")
-		if v != "JWT-TOKEN-1" {
-			t.Fatalf("兜底凭据应是 userJwt.Token, 实得 %q", v)
-		}
-		if atomic.LoadInt32(&h.exchHit) != before {
-			t.Fatal("无 refreshToken 不应调 ExchangeToken（参考实现分支2）")
-		}
-	})
-
-	t.Run("行3 只有code_PKCE流_明确报暂不支持", func(t *testing.T) {
-		st, body := h.beginAndCallback(map[string]string{"code": "PKCE-CODE-1"})
-		if st != 400 {
-			t.Fatalf("PKCE 流应 400: %d %s", st, body)
-		}
-		if !strings.Contains(body, "PKCE") {
-			t.Fatalf("错误应明确指向 PKCE 流, 实得 %s", body)
-		}
-	})
-
-	t.Run("行4 空回调_报缺失", func(t *testing.T) {
-		st, body := h.beginAndCallback(map[string]string{})
-		if st != 400 {
-			t.Fatalf("空回调应 400: %d %s", st, body)
-		}
-		if !strings.Contains(body, "refreshToken") {
-			t.Fatalf("错误应指出缺什么, 实得 %s", body)
-		}
-	})
-
-	t.Run("行5 ExchangeToken失败_透传阶段", func(t *testing.T) {
-		atomic.StoreInt32(&h.exchOK, 0)
-		defer atomic.StoreInt32(&h.exchOK, 1)
-		st, body := h.beginAndCallback(map[string]string{"refreshToken": "RT-FROM-CALLBACK"})
-		if st != 400 {
-			t.Fatalf("exchange 失败应 400: %d %s", st, body)
-		}
-		if !strings.Contains(body, "ExchangeToken") {
-			t.Fatalf("错误应指明 ExchangeToken 阶段, 实得 %s", body)
-		}
-	})
-}

internal/core/codearts_sig_expected.json

@@ -0,0 +1,38 @@
+[
+ {
+  "method": "GET",
+  "url": "https://snap-access.cn-north-4.myhuaweicloud.com/snap-manager/v1/statistics/plugin",
+  "body": "",
+  "ak": "AK1",
+  "sk": "SK1",
+  "st": "TOK1",
+  "canonical": "GET\n/snap-manager/v1/statistics/plugin/\n\nhost:snap-access.cn-north-4.myhuaweicloud.com\nx-sdk-content-sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855\nx-sdk-date:20261013T150405Z\nx-security-token:TOK1\n\nhost;x-sdk-content-sha256;x-sdk-date;x-security-token\ne3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+  "string_to_sign": "SDK-HMAC-SHA256\n20261013T150405Z\nf40918a3339c9db2251933dcce410db05ff8a403de2767bc642140ea93cdc182",
+  "signature": "5332d627c3b8f14973afe41905f23dce75eaf9a34134dff670cb19835beb0549",
+  "signed_headers": "host;x-sdk-content-sha256;x-sdk-date;x-security-token"
+ },
+ {
+  "method": "GET",
+  "url": "https://snap-access.cn-north-4.myhuaweicloud.com/v1/ops/delivery?channel=IDE",
+  "body": "",
+  "ak": "AK2",
+  "sk": "SK2",
+  "st": "",
+  "canonical": "GET\n/v1/ops/delivery/\nchannel=IDE\nhost:snap-access.cn-north-4.myhuaweicloud.com\nx-sdk-content-sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855\nx-sdk-date:20261013T150405Z\nx-security-token:\n\nhost;x-sdk-content-sha256;x-sdk-date;x-security-token\ne3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+  "string_to_sign": "SDK-HMAC-SHA256\n20261013T150405Z\n3c849b40bbad69b981eaf280e162878bf00687d08cb45df43ac792fc23add4f1",
+  "signature": "a01248a4121fd943f0f3f07aac101cd649ddf34d162729bf06a6a12ae9916b1a",
+  "signed_headers": "host;x-sdk-content-sha256;x-sdk-date;x-security-token"
+ },
+ {
+  "method": "POST",
+  "url": "https://snap-access.cn-north-4.myhuaweicloud.com/v1/ops/claim",
+  "body": "{\"campaignId\":\"C1\",\"channel\":\"IDE\"}",
+  "ak": "AK3",
+  "sk": "SK3",
+  "st": "T3",
+  "canonical": "POST\n/v1/ops/claim/\n\ncontent-type:application/json\nhost:snap-access.cn-north-4.myhuaweicloud.com\nx-sdk-content-sha256:85e6ce395b620ecb748af3b217f47107ebb5906d1a83fe7db221d9845de29f19\nx-sdk-date:20261013T150405Z\nx-security-token:T3\n\ncontent-type;host;x-sdk-content-sha256;x-sdk-date;x-security-token\n85e6ce395b620ecb748af3b217f47107ebb5906d1a83fe7db221d9845de29f19",
+  "string_to_sign": "SDK-HMAC-SHA256\n20261013T150405Z\n554c2607cff324a770b55e78e2a1c58afe466abf5e4eaa104a6e1fa96acfc733",
+  "signature": "e5faa52ec51c36b38804aac45a8a19876314cec465ab8f905100e657e8ea68d5",
+  "signed_headers": "content-type;host;x-sdk-content-sha256;x-sdk-date;x-security-token"
+ }
+]

internal/core/core.go

@@ -11,17 +11,15 @@ import (
 	"net/url"
 	"os"
 	"path/filepath"
-	"sort"
 	"strings"
 	"sync"
 	"sync/atomic"
 	"time"
 
-	"llmsproxy/internal/billing"
-	"llmsproxy/internal/config"
-	"llmsproxy/internal/lua"
-	"llmsproxy/internal/provider"
-	"llmsproxy/internal/scheduler"
+	"modelrouter/internal/config"
+	"modelrouter/internal/lua"
+	"modelrouter/internal/provider"
+	"modelrouter/internal/scheduler"
 )
 
 // Core owns the running configuration and adapters. mu guards every read and
@@ -97,9 +95,6 @@ func NewFromConfig(cfg *config.Config) (*Core, error) {
 	for name, aud := range cfg.PluginVisibility {
 		c.plugins.SetPluginVisibility(name, aud)
 	}
-	if err := c.plugins.SeedBundled(); err != nil {
-		log.Printf("[core] seed bundled plugins: %v", err)
-	}
 	if err := c.plugins.LoadDir(); err != nil {
 		log.Printf("[core] plugin dir: %v", err)
 	}
@@ -111,7 +106,6 @@ func NewFromConfig(cfg *config.Config) (*Core, error) {
 		log.Printf("[core] plugin %v %v loaded (hooks=%v ui=%v)",
 			p["name"], p["version"], p["hooks"], p["ui"])
 	}
-	c.applyBillingDSL()
 	c.store = config.NewStore(cfg.RuntimeFile)
 	// Share one box between the runtime store and config.yaml so a single
 	// master.key seals both files. config.Load left the config holding
@@ -150,9 +144,6 @@ func NewFromConfig(cfg *config.Config) (*Core, error) {
 	if err := c.seedKeys(); err != nil {
 		return nil, err
 	}
-	if err := c.seedAuto(); err != nil {
-		return nil, err
-	}
 	if err := c.rebuildRegistry(); err != nil {
 		return nil, err
 	}
@@ -195,39 +186,6 @@ func (c *Core) migrateFromRuntime() {
 	}
 }
 
-// seedAuto uses the existing auto rules from config.yaml, or creates an
-// initial chain from legacy per-source model priority (first run only).
-func (c *Core) seedAuto() error {
-	if len(c.cfg.Auto) > 0 {
-		return nil
-	}
-	type item struct {
-		model string
-		prio  int
-	}
-	var flat []item
-	for _, s := range c.mergedSources() {
-		for _, m := range s.Models {
-			if m.Kind == "image" {
-				continue
-			}
-			flat = append(flat, item{m.ID, m.Priority})
-		}
-	}
-	sort.SliceStable(flat, func(i, j int) bool {
-		if flat[i].prio != flat[j].prio {
-			return flat[i].prio > flat[j].prio
-		}
-		return flat[i].model < flat[j].model
-	})
-	entries := make([]config.ModelScope, 0, len(flat))
-	for _, it := range flat {
-		entries = append(entries, config.ModelScope{Model: it.model})
-	}
-	c.cfg.Auto = entries
-	return c.cfg.Save()
-}
-
 // seedKeys ensures config.yaml has admin keys for every gateway_keys entry
 // from the YAML config (once). After first save they become GWKey records
 // in c.cfg.Keys and gateway_keys is no longer read for auth.
@@ -877,9 +835,23 @@ func (c *Core) Reload() error {
 // ---- adapter management (web UI) ----
 
 func (c *Core) ListAdapters() []lua.APIAdapter {
+	c.syncHiddenRefs()
 	return c.vm.ListAdapters()
 }
 
+// syncHiddenRefs 把"当前被源引用的适配器"同步给 VM。被引用的 hidden=true 适配器
+// 必须保持可见（源编辑器要回显当前值）；没被引用的隐藏适配器从列表消失。
+// 每次 ListAdapters 前调用：源集合是动态的（运行时可增删），推模型容易漏。
+func (c *Core) syncHiddenRefs() {
+	refs := []string{}
+	for _, s := range c.mergedSources() {
+		if s.Adapter != "" {
+			refs = append(refs, s.Adapter)
+		}
+	}
+	c.vm.SetHiddenRefs(refs)
+}
+
 func (c *Core) UploadAdapter(name, code string) error {
 	if name == "" {
 		return fmt.Errorf("adapter name required")
@@ -1033,63 +1005,6 @@ func (c *Core) Close() {
 	}
 }
 
-// applyBillingDSL compiles the configured billing profile and injects it into
-// the billing plugin.
-//
-// Configured pricing replaces the hand-written JSON blob that used to be PUT
-// through the state API. That path was used twice in production and both times
-// it "succeeded" while being wrong: once without the required `prices` wrapper
-// (silently wiping the accumulated totals), once with a peak-window shape the
-// plugin does not read (peak traffic billed at off-peak rates, no error). A
-// typed config with load-time validation turns both mistakes into startup
-// errors naming the file and field.
-//
-// A DSL with no profile, or one that fails to compile, leaves the plugin's
-// prices untouched: billing keeps running on whatever it had, and the problem
-// is logged rather than becoming a startup failure — the gateway must forward
-// even when its cost accounting is misconfigured.
-func (c *Core) applyBillingDSL() {
-	ps := c.plugins
-	if ps == nil || ps.Count() == 0 {
-		return
-	}
-	// The billing plugin may simply not be installed; a DSL without it is a
-	// no-op, not an error.
-	var have bool
-	for _, row := range ps.List() {
-		if row["name"] == "billing" && row["loaded"] == true {
-			have = true
-			break
-		}
-	}
-	if !have {
-		return
-	}
-	dsl := c.cfg.BillingDSL
-	if dsl == nil || len(dsl.Profiles) == 0 {
-		return
-	}
-	if err := dsl.Validate(); err != nil {
-		log.Printf("[billing] config invalid, profile not applied: %v", err)
-		return
-	}
-	profile := dsl.Resolve(dsl.Active)
-	if profile == nil {
-		log.Printf("[billing] no billing profile resolved (active=%q)", dsl.Active)
-		return
-	}
-	prices, err := billing.Compile(profile, c.cfg.Sources)
-	if err != nil {
-		log.Printf("[billing] profile %q not applied: %v", profile.ID, err)
-		return
-	}
-	if err := ps.SetState("billing", map[string]interface{}{"prices": prices}); err != nil {
-		log.Printf("[billing] applying profile %q: %v", profile.ID, err)
-		return
-	}
-	log.Printf("[billing] profile %q applied (%d rules, %d sources)", profile.ID, len(profile.Rules), len(c.cfg.Sources))
-}
-
 // ValidateScopeQuotas checks every scope entry's caps before they are stored.
 // A typo in a period must be rejected at write time rather than silently
 // becoming a never-resetting budget — the opposite of what was typed.

internal/core/core_test.go

@@ -5,7 +5,7 @@ import (
 	"sync"
 	"testing"
 
-	"llmsproxy/internal/config"
+	"modelrouter/internal/config"
 )
 
 // newTestConfig returns an in-memory config backed by temp files so
@@ -22,7 +22,7 @@ func newTestConfig(t *testing.T) *config.Config {
 		DefaultModel: "AUTO",
 		GatewayKeys:  []string{"sk-gw-test"},
 		Sources: []config.Source{
-			{Name: "s1", BaseURL: "http://127.0.0.1:1/v1", Adapter: "openai", Models: []config.Model{{ID: "gpt-4o", Priority: 10}}},
+			{Name: "s1", BaseURL: "http://127.0.0.1:1/v1", Adapter: "openai", Models: []config.Model{{ID: "gpt-4o"}}},
 		},
 	}
 }

internal/core/device_harness_test.go

@@ -1,180 +0,0 @@
-package core
-
-import (
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"sync/atomic"
-	"testing"
-
-	"llmsproxy/internal/lua"
-)
-
-// readBundledChannels 读内置 channels 插件源（供行为/变异测试共用）。
-func readBundledChannels(t *testing.T) (string, error) {
-	t.Helper()
-	return lua.ReadBundledPlugin("channels")
-}
-
-// deviceHarness 是 device-poll 决策表的可复用测试台：假上游（脚本化逐次响应）
-// + channels 插件加载指定源码 + minimax 端点指到假上游。
-// 行为测试（TestChannelsDevicePollBehavior）与变异测试共用它 —— 决策表只有
-// 一份，两处不会漂移。
-type deviceHarness struct {
-	t    *testing.T
-	ps   *lua.Plugins
-	ts   *httptest.Server
-	step int32
-	// script 持续被 HTTP handler 原子读取
-	script atomic.Value // []scriptStep
-}
-
-type scriptStep struct {
-	http int
-	body string
-}
-
-func newDeviceHarness(t *testing.T, src string) *deviceHarness {
-	t.Helper()
-	h := &deviceHarness{t: t}
-	h.script.Store([]scriptStep{})
-
-	h.ts = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/oauth2/device/code":
-			w.Header().Set("Content-Type", "application/json")
-			fmt.Fprint(w, `{"device_code":"DEV1","user_code":"ABCD-EFGH","verification_uri":"https://example/activate","interval":1,"expires_in":600}`)
-		case "/oauth2/token":
-			i := int(atomic.AddInt32(&h.step, 1)) - 1
-			script := h.script.Load().([]scriptStep)
-			w.Header().Set("Content-Type", "application/json")
-			if i >= len(script) {
-				w.WriteHeader(500)
-				fmt.Fprint(w, `{"error":"unexpected"}`)
-				return
-			}
-			if script[i].http != 0 && script[i].http != 200 {
-				w.WriteHeader(script[i].http)
-			}
-			fmt.Fprint(w, script[i].body)
-		default:
-			w.WriteHeader(404)
-		}
-	}))
-	t.Cleanup(h.ts.Close)
-
-	c := kernelTestCore(t)
-	h.ps = c.Plugins()
-	if err := h.ps.LoadSource("channels", src); err != nil {
-		t.Fatalf("加载: %v", err)
-	}
-	if _, err := h.ps.Call("channels", "set_endpoints", map[string]interface{}{
-		"platform": "minimax",
-		"device": map[string]interface{}{
-			"code_url":  h.ts.URL + "/oauth2/device/code",
-			"token_url": h.ts.URL + "/oauth2/token",
-		},
-	}); err != nil {
-		t.Fatalf("set_endpoints: %v", err)
-	}
-	return h
-}
-
-// setScript 设置 token 端点的逐次响应脚本。`400 {...}` 形式表示非 200。
-func (h *deviceHarness) setScript(steps ...string) {
-	var out []scriptStep
-	for _, b := range steps {
-		code := 200
-		switch {
-		case strings.HasPrefix(b, "400 "):
-			code, b = 400, b[4:]
-		case strings.HasPrefix(b, "403 "):
-			code, b = 403, b[4:]
-		}
-		out = append(out, scriptStep{http: code, body: b})
-	}
-	h.script.Store(out)
-	atomic.StoreInt32(&h.step, 0)
-}
-
-func (h *deviceHarness) begin() map[string]interface{} {
-	out, err := h.ps.InvokeHandler("channels", "start_login", &lua.HandlerRequest{
-		Method: "POST", Body: `{"platform":"minimax"}`,
-	})
-	if err != nil {
-		h.t.Fatal(err)
-	}
-	return out.JSON.(map[string]interface{})
-}
-
-func (h *deviceHarness) poll(id string) map[string]interface{} {
-	out, _ := h.ps.InvokeHandler("channels", "poll_login", &lua.HandlerRequest{
-		Method: "GET", Query: map[string]string{"id": id},
-	})
-	return out.JSON.(map[string]interface{})
-}
-
-// runDecisionTable 跑完整 8 行决策表，全部符合预期返回 true。
-// 这是行为契约的单一事实来源：行为测试用它断言通过；变异测试用它杀变异体。
-func (h *deviceHarness) runDecisionTable() bool {
-	ok := func(cond bool) bool { return cond }
-	st := func(steps ...string) map[string]interface{} {
-		h.setScript(steps...)
-		j := h.begin()
-		sid := j["session"].(map[string]interface{})["id"].(string)
-		return h.poll(sid)
-	}
-
-	// 行1: 200+pending → 等
-	if j := st(`{"status":"pending"}`); j["state"] != "pending" {
-		return false
-	}
-	// 行2: 200+slow_down → 等 + interval+5
-	h.setScript(`{"status":"slow_down"}`)
-	j := h.begin()
-	sid := j["session"].(map[string]interface{})["id"].(string)
-	if j2 := h.poll(sid); j2["state"] != "pending" {
-		return false
-	} else if iv, _ := j2["interval"].(float64); iv < 6 {
-		return false
-	}
-	// 行3: 200+denied → failed，message 区分于通用错误（杀"denied 不识别"变异体）
-	if j := st(`{"status":"denied"}`); j["state"] != "failed" {
-		return false
-	} else if msg, _ := j["message"].(string); !strings.Contains(msg, "用户拒绝") {
-		return false
-	}
-	// 行4: 200+expired_token → failed，message 带过期字样
-	if j := st(`{"status":"expired_token"}`); j["state"] != "failed" {
-		return false
-	} else if msg, _ := j["message"].(string); !strings.Contains(msg, "过期") {
-		return false
-	}
-	// 行5: 400+authorization_pending → 等
-	if j := st(`400 {"error":"authorization_pending"}`); j["state"] != "pending" {
-		return false
-	}
-	// 行6: 403+slow_down → 等 + interval+5
-	h.setScript(`403 {"error":"slow_down"}`)
-	j = h.begin()
-	sid = j["session"].(map[string]interface{})["id"].(string)
-	if j2 := h.poll(sid); j2["state"] != "pending" {
-		return false
-	} else if iv, _ := j2["interval"].(float64); iv < 6 {
-		return false
-	}
-	// 行7: 200+access_token → completed（需先授权 add_source）
-	_ = h.ps.SetPluginKernelPermission("channels", []string{"add_source", "status", "list_sources"}, false)
-	h.setScript(`{"access_token":"MM-ACCESS-1","refresh_token":"MM-RF-1","nickname":"mm-user"}`)
-	j = h.begin()
-	sid = j["session"].(map[string]interface{})["id"].(string)
-	if j2 := h.poll(sid); j2["state"] != "completed" || j2["account"] != "mm-user" {
-		return false
-	}
-	// 行8: 其它 error → failed 带文本
-	if j := st(`{"error":"server_error"}`); j["state"] != "failed" {
-		return false
-	}
-	return ok(true)
-}

internal/core/device_mutate_test.go

@@ -1,73 +0,0 @@
-package core
-
-import (
-	"strings"
-	"testing"
-)
-
-// TestDevicePollMutants 是 device-poll 执行器的变异测试。
-//
-// 用户要求：移植要照参考实现的行为形成测试项，且要变异验证测试真的能杀掉
-// 「行为走样」的代码。每个用例把 channels 源里的一个决策分支做语义变异，
-// 断言决策表**会失败**（变异体被杀）。变异体幸存 = 该分支没有覆盖。
-func TestDevicePollMutants(t *testing.T) {
-	src, err := readBundledChannels(t)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// 锚点会命中 deviceOneStep 里两处同形代码（workos 分支 + minimax 分支），
-	// 全部替换：两个决策表（minimax + workos）都会杀，任一幸存即失败。
-	muts := []struct {
-		name string
-		from string
-		to   string
-	}{
-		{
-			name: "slow_down 不再加 interval",
-			from: `sess.device_interval = (sess.device_interval or d.interval or 5) + step`,
-			to:   `sess.device_interval = (sess.device_interval or d.interval or 5)`,
-		},
-		{
-			name: "denied 被当成继续等待",
-			from: `if resp.status == 200 and (status == "denied" or status == "access_denied") then`,
-			to:   `if resp.status == 200 and (status == "denied_x" or status == "access_denied") then`,
-		},
-		{
-			name: "expired_token 不被识别",
-			from: `if resp.status == 200 and (status == "expired" or status == "expired_token") then`,
-			to:   `if resp.status == 200 and (status == "expired" or status == "expired_token_x") then`,
-		},
-		{
-			name: "authorization_pending 被当成失败",
-			from: `if ecode == "authorization_pending" then return false end`,
-			to:   `if ecode == "authorization_pending_x" then return false end`,
-		},
-		{
-			name: "成功分支被禁用",
-			from: `if resp.status == 200 and rec.access_token then`,
-			to:   `if resp.status == 200 and rec.access_token and false then`,
-		},
-	}
-
-	for _, mu := range muts {
-		t.Run(mu.name, func(t *testing.T) {
-			if !strings.Contains(src, mu.from) {
-				t.Fatalf("锚点丢失，先更新实现与锚点：%q", mu.from)
-			}
-			// 锚点在 deviceOneStep 的 workos/minimax 两个分支各有一份同形代码，
-			// 全部替换：任一分支的变异体被任一决策表杀掉才算有覆盖。
-			mutated := strings.ReplaceAll(src, mu.from, mu.to)
-			if mutated == src {
-				t.Fatal("变异未生效")
-			}
-			// 基准必须全过（测试自身有效），变异体必须被杀（有覆盖）
-			if !newDeviceHarness(t, src).runDecisionTable() {
-				t.Fatal("基准决策表未全过 —— 测试自身失效")
-			}
-			if newDeviceHarness(t, mutated).runDecisionTable() {
-				t.Fatalf("★ 变异体幸存（%s）—— 该分支无覆盖", mu.name)
-			}
-		})
-	}
-}

internal/core/kernel_actions.go

@@ -6,8 +6,8 @@ import (
 	"fmt"
 	"strings"
 
-	"llmsproxy/internal/config"
-	"llmsproxy/internal/lua"
+	"modelrouter/internal/config"
+	"modelrouter/internal/lua"
 )
 
 // 内核动作实现（R4-c）
@@ -147,6 +147,11 @@ func (c *Core) actionListSources() interface{} {
 			"has_key":        s.APIKey != "" || s.APIKeyEnv != "",
 			"key_hint":       maskSecretHint(s.APIKey),
 			"max_concurrent": s.MaxConcurrent,
+			// rpm must be exposed too: it carries the per-model minimum gap, and
+			// max_concurrent alone cannot distinguish "serial WITH a gap" from
+			// "serial with no gap" — the latter still collides with the
+			// upstream's per-model concurrency window.
+			"rpm": s.RPM,
 		})
 	}
 	return out

internal/core/kernel_actions_test.go

@@ -6,8 +6,8 @@ import (
 	"path/filepath"
 	"testing"
 
-	"llmsproxy/internal/config"
-	"llmsproxy/internal/lua"
+	"modelrouter/internal/config"
+	"modelrouter/internal/lua"
 )
 
 // 本文件验证 R4-c/R4-d 的闭环：**插件自己驱动外部源的链接认证，然后把源接进内核**。
@@ -20,10 +20,29 @@ import (
 func kernelTestCore(t *testing.T) *Core {
 	t.Helper()
 	dir := t.TempDir()
+	pluginDir := filepath.Join(dir, "plugins")
+	// 插件的自有存储位置由插件自己决定（读 config.yaml 的 plugin_dir，或
+	// MODELROUTER_PLUGIN_DIR 覆盖）。测试**必须**指向临时目录 —— 否则插件会读到
+	// /etc/modelrouter/config.yaml 并写进**生产插件目录**（真实事故：一次全量测试
+	// 把 26 个测试账号写进了生产 .channels-store.json）。
+	// 调用方已显式设定时尊重它：多次「重启」要共用同一目录才能测持久化。
+	if os.Getenv("MODELROUTER_PLUGIN_DIR") == "" {
+		t.Setenv("MODELROUTER_PLUGIN_DIR", pluginDir)
+	}
+	// ★ 显示器号与端口用**高段号**，避开生产。
+	//
+	// 真实事故（2026-10-15）：生产 unit 带 `PrivateTmp=yes`，它起的 Xvfb :91 的
+	// 锁文件在**服务自己的 /tmp** 里 —— 宿主上的测试看不到它，于是判"91 空闲"
+	// 并去抢，结果 `Xvfb 未就绪（/tmp/.X11-unix/X91 未出现）`，而生产上正跑着
+	// 一套浏览器栈。判据本身没错，错的是**两个 /tmp 互不可见**而号段重叠。
+	// 故测试整体挪到 300+。
+	if os.Getenv("MODELROUTER_XDISPLAY_BASE") == "" {
+		t.Setenv("MODELROUTER_XDISPLAY_BASE", "300")
+	}
 	cfg := &config.Config{
 		Path:         filepath.Join(dir, "config.yaml"),
 		AdapterDir:   filepath.Join(dir, "adapters"),
-		PluginDir:    filepath.Join(dir, "plugins"),
+		PluginDir:    pluginDir,
 		RuntimeFile:  filepath.Join(dir, "runtime.json"),
 		DefaultModel: "AUTO",
 		GatewayKeys:  []string{"sk-kernel-0001"},
@@ -37,6 +56,24 @@ func kernelTestCore(t *testing.T) *Core {
 	if err != nil {
 		t.Fatal(err)
 	}
+	// 测试结束**必须**把插件拉起的服务端浏览器栈收掉。
+	// 为何必需：callback 流（trae/gemini/有道）在 start_login 时就起一整套
+	// Xvfb+chromium+x11vnc+websockify，而绝大多数测试不会显式 stop_browser、
+	// 会话 TTL 也还没到 —— 于是一轮 core 全包跑完就攒出 7 套常驻进程
+	// （实测 websockify×7 + x11vnc×7 + 7 个 profile 目录），把显示器号与端口
+	// 段逐步耗光，后续测试报「chromium/websockify 端口未就绪」。
+	// 在这一处统一收掉，比让每个测试各自记得更可靠。
+	t.Cleanup(func() {
+		ps := c.Plugins()
+		if ps == nil {
+			return
+		}
+		for _, name := range []string{"channels"} {
+			_, _ = ps.InvokeHandler(name, "stop_browser", &lua.HandlerRequest{
+				Method: "POST", Role: "admin",
+			})
+		}
+	})
 	t.Cleanup(c.Close)
 	return c
 }

internal/core/kernel_effect_test.go

@@ -34,6 +34,6 @@ return plugin
 		t.Fatalf("动作未成功: %#v", m)
 	}
 	if _, ok := c.FindKey("sk-kernel-0001"); ok {
-		t.Fatal("★ 动作报告成功但副作用没发生 —— dispatch 是空转")
+		t.Fatal("动作报告成功但副作用没发生 —— dispatch 是空转")
 	}
 }

internal/core/kernel_no_deadlock_test.go

@@ -4,7 +4,7 @@ import (
 	"testing"
 	"time"
 
-	"llmsproxy/internal/lua"
+	"modelrouter/internal/lua"
 )
 
 // TestNoKernelActionDeadlocksFromLua 对**每个**内核动作做同一条断言：

internal/core/key_auto_concurrency_test.go

@@ -7,7 +7,7 @@ import (
 	"testing"
 	"time"
 
-	"llmsproxy/internal/config"
+	"modelrouter/internal/config"
 )
 
 // AutoChainFor sits on the request hot path and reads keyAutoChains with no
@@ -151,7 +151,7 @@ func TestAutoChainForConcurrentWithSourceChanges(t *testing.T) {
 			name := fmt.Sprintf("churn%d", n)
 			_ = c.AddSource(config.Source{
 				Name: name, BaseURL: "http://127.0.0.1:9/v1", Adapter: "openai",
-				Models: []config.Model{{ID: "m-" + name, Priority: 10}}},
+				Models: []config.Model{{ID: "m-" + name}}},
 			)
 			_ = c.RemoveSource(name)
 		}

internal/core/key_auto_test.go

@@ -4,8 +4,8 @@ import (
 	"path/filepath"
 	"testing"
 
-	"llmsproxy/internal/config"
-	"llmsproxy/internal/scheduler"
+	"modelrouter/internal/config"
+	"modelrouter/internal/scheduler"
 )
 
 // Per-key AUTO chains let an admin give one user their own scheduling chain
@@ -32,7 +32,7 @@ func perKeyTestConfig(t *testing.T) *config.Config {
 		GatewayKeys:  []string{"sk-gw-admin"},
 		Sources: []config.Source{
 			{Name: "s1", BaseURL: "http://127.0.0.1:1/v1", Adapter: "openai",
-				Models: []config.Model{{ID: "gpt-4o", Priority: 10}, {ID: "gpt-4o-mini", Priority: 5}}},
+				Models: []config.Model{{ID: "gpt-4o"}, {ID: "gpt-4o-mini"}}},
 		},
 		// Global chain points at gpt-4o.
 		Auto: []config.ModelScope{{Model: "gpt-4o", Source: "s1", Tier: 1}},
@@ -198,7 +198,7 @@ func TestKeyAutoChainsRebuildOnSourceChange(t *testing.T) {
 	// Add the source; the per-key chain must pick it up without a restart.
 	cfg.Sources = append(cfg.Sources, config.Source{
 		Name: "s2", BaseURL: "http://127.0.0.1:2/v1", Adapter: "openai",
-		Models: []config.Model{{ID: "new-model", Priority: 10}},
+		Models: []config.Model{{ID: "new-model"}},
 	})
 	if err := c.Reload(); err != nil {
 		t.Fatalf("Reload: %v", err)

internal/core/mutation_guard_test.go

@@ -0,0 +1,22 @@
+package core
+
+import (
+	"os"
+	"testing"
+	"time"
+)
+
+// 把测试进程的时区钉成 **UTC**。
+//
+// 为什么必需：Qoder 的每日活动按 **UTC+8** 结算，判定必须用算术平移而不是
+// 本机时区。但这台机器**本身就是 HKT(+0800)** —— 于是在真实环境里
+// 「os.date("!*t")（UTC 平移）」与「os.date("*t")（本机时区）」结果**完全相同**，
+// 判据无法区分二者（实测：把实现改成用本机时区，判据照样通过）。
+// 钉成 UTC 后两者相差 8 小时，误用本机时区的实现立刻暴露。
+//
+// 只影响测试进程，不改系统时区。
+func TestMain(m *testing.M) {
+	os.Setenv("TZ", "UTC")
+	time.Local = time.UTC
+	os.Exit(m.Run())
+}

internal/core/source_hosts_test.go

@@ -4,7 +4,7 @@ import (
 	"net/url"
 	"testing"
 
-	"llmsproxy/internal/config"
+	"modelrouter/internal/config"
 )
 
 // The plugin outbound allowlist is built from the hosts of configured sources.

internal/core/startup_secrets_test.go

@@ -6,7 +6,7 @@ import (
 	"strings"
 	"testing"
 
-	"llmsproxy/internal/config"
+	"modelrouter/internal/config"
 )
 
 // Startup must be idempotent, and every credential consumer must see PLAINTEXT.
@@ -42,7 +42,7 @@ func writeSealedInstall(t *testing.T, dir string) string {
 		GatewayKeys:  []string{"sk-gw-seed-me"},
 		Sources: []config.Source{{
 			Name: "up", BaseURL: "http://127.0.0.1:1/v1", APIKey: "sk-upstream-secret",
-			Adapter: "openai", Models: []config.Model{{ID: "gpt-4o", Priority: 10}},
+			Adapter: "openai", Models: []config.Model{{ID: "gpt-4o"}},
 		}},
 	}
 	c, err := NewFromConfig(cfg)
@@ -76,7 +76,7 @@ func writeSealedInstallNoSeed(t *testing.T, dir string) string {
 		DefaultModel: "AUTO",
 		Sources: []config.Source{{
 			Name: "up", BaseURL: "http://127.0.0.1:1/v1", APIKey: "sk-upstream-secret",
-			Adapter: "openai", Models: []config.Model{{ID: "gpt-4o", Priority: 10}},
+			Adapter: "openai", Models: []config.Model{{ID: "gpt-4o"}},
 		}},
 	}
 	c, err := NewFromConfig(cfg)

internal/core/trae_derive_expected.json

@@ -0,0 +1,44 @@
+[
+ {
+  "u": "12345",
+  "devid": "707304999019651",
+  "market": "5daa819c-8425-4bae-88b7-2bbfec3c25ba",
+  "sess": "e5b8dfc5830ce0bdb141f7177effb90a7cf8227bb23b930a427a8550bf7357df"
+ },
+ {
+  "u": "UID-abc",
+  "devid": "579362202930608",
+  "market": "a5388fc1-5969-4666-bc74-be9a11f69567",
+  "sess": "a47da2e13fe16d49dc859fbed58d1d99e0faef5d116acafc64a2d26013d17a1f"
+ },
+ {
+  "u": "900000001",
+  "devid": "764948639142479",
+  "market": "e449daa5-b0c0-4f35-918e-8bb01b33f179",
+  "sess": "fdd37c37d1cc950439c25467e6dca75fcc84a2b0d294aa910387a9a965645650"
+ },
+ {
+  "u": "x",
+  "devid": "268405722745284",
+  "market": "4f2427c5-0583-4f82-8e18-4e38566dd857",
+  "sess": "79be40fff0fbaee572d1ba3ab13a47af9d2f4d943115ef512c56e42132e23a66"
+ },
+ {
+  "u": "",
+  "devid": "170789623621479",
+  "market": "b32897c1-f9c0-4ad2-b2b4-725455fffb6b",
+  "sess": "4a61a6b4c4bcbf1040bf0edf3df2b3e7d76a956f3ef81ef8f148eadcc03d25cc"
+ },
+ {
+  "u": "用户1",
+  "devid": "263026789643405",
+  "market": "1c1b4e1f-9d7a-4698-9f34-b057d9a74b0b",
+  "sess": "a13dbde68977eee49818e2e2fb7d3bbb1ffb4c807a6e6f1831168a84adea0dfe"
+ },
+ {
+  "u": "1234567890123456789012345",
+  "devid": "358669731114854",
+  "market": "449882ec-9a69-4a7a-b9ab-25aa59b28c50",
+  "sess": "305eb96fe14a194386c0fd4148d4919870ed803b69cf75296b53ea1f41e4c574"
+ }
+]

internal/gateway/api.go

@@ -11,7 +11,7 @@ import (
 	"strings"
 	"time"
 
-	"llmsproxy/internal/config"
+	"modelrouter/internal/config"
 )
 
 type adapterPayload struct {
@@ -215,7 +215,7 @@ const keepExistingAPIKey = "__KEEP__"
 //   - the explicit mask keepExistingAPIKey — always inherit.
 //   - the empty string — inherit only for a source that already has a
 //     credential. Empty is a legitimate value for a *new* credential-less
-//     source (dshcodebuddy uses "dsh-local-noauth", local servers use ""),
+//     source (some local runtimes use a no-auth sentinel, local servers ""),
 //     so a fresh source with an empty key must stay empty rather than inherit
 //     nothing and fail differently.
 func (g *Gateway) resolveAPIKey(name, want string, exists bool) string {
@@ -488,7 +488,7 @@ func (g *Gateway) handleStatsAPI(w http.ResponseWriter, r *http.Request) {
 		if to == 0 {
 			to = time.Now().UnixMilli()
 		}
-		csvHeaders(w, "llmsproxy-requests.csv")
+		csvHeaders(w, "modelrouter-requests.csv")
 		cw := csv.NewWriter(w)
 		names := map[string]string{}
 		for _, k := range g.core.ListKeys() {
@@ -537,7 +537,7 @@ func (g *Gateway) handleStatsAPI(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	if r.URL.Query().Get("export") == "keys-csv" {
-		csvHeaders(w, "llmsproxy-keys.csv")
+		csvHeaders(w, "modelrouter-keys.csv")
 		cw := csv.NewWriter(w)
 		_ = cw.Write([]string{"key", "key_name", "role", "models", "total_requests", "success_requests", "failed_requests", "prompt_tokens", "completion_tokens", "total_tokens", "avg_latency_ms", "max_latency_ms", "created_at"})
 		keyFilter := exportKey(r)

internal/gateway/apiv1.go

@@ -31,7 +31,7 @@ import (
 	"sort"
 	"strings"
 
-	"llmsproxy/internal/config"
+	"modelrouter/internal/config"
 )
 
 // apiV1Routes dispatches /api/v1/*. Kept separate from routes() so the original
@@ -144,7 +144,7 @@ func (g *Gateway) apiV1Index(w http.ResponseWriter, r *http.Request) {
 	}
 	index := map[string]interface{}{
 		"api_version": "v1",
-		"description": "llmsproxy management API. Authenticate with a gateway key: " +
+		"description": "modelrouter management API. Authenticate with a gateway key: " +
 			"'Authorization: Bearer <key>', '?api_key=<key>', or the gw_key cookie. " +
 			"Read endpoints accept any role; mutations require an admin key.",
 		"discovery": []ep{

internal/gateway/apiv1_test.go

@@ -7,7 +7,7 @@ import (
 	"strings"
 	"testing"
 
-	"llmsproxy/internal/config"
+	"modelrouter/internal/config"
 )
 
 // v1Gateway builds a gateway with one source and two keys, and returns the

internal/gateway/billing_rules_api.go

@@ -1,282 +0,0 @@
-package gateway
-
-import (
-	"encoding/json"
-	"net/http"
-
-	"llmsproxy/internal/billing"
-	"llmsproxy/internal/config"
-)
-
-// Billing rules API.
-//
-//	GET  /api/plugins/billing/rules    the active profile's rules + all profiles
-//	PUT  /api/plugins/billing/rules    replace the whole DSL and re-inject prices
-//	POST /api/plugins/billing/rules    { profile, rule } append one rule
-//	DELETE /api/plugins/billing/rules  { profile, url } remove one rule
-//
-// Why a separate endpoint instead of the generic plugin state: prices are
-// plugin state, but they are also a durable, reviewable CONFIGURATION. Routing
-// them through /state would let an admin key PUT arbitrary plugin state and
-// silently reset the accumulated accounting. Here the server owns the shape:
-// it validates the DSL, writes it back to config.yaml, recompiles, and hands
-// the plugin its prices table. The operator edits rules; the plugin keeps
-// numbers. The two are never mixed in one payload.
-//
-// Editing means "what the operator typed is what config.yaml holds". A
-// billing mistake found next week must be traceable to a reviewable file, not
-// to a blob in the plugin's state sidecar.
-func (g *Gateway) handleBillingRules(w http.ResponseWriter, r *http.Request) {
-	if reqRole(r.Context()) != "admin" {
-		writeError(w, http.StatusForbidden, "forbidden", "admin role required")
-		return
-	}
-	switch r.Method {
-	case http.MethodGet:
-		g.getBillingRules(w)
-	case http.MethodPut:
-		g.putBillingRules(w, r)
-	case http.MethodPost:
-		g.addBillingRule(w, r)
-	case http.MethodDelete:
-		g.delBillingRule(w, r)
-	default:
-		writeError(w, http.StatusMethodNotAllowed, "method_not_allowed", "use GET/PUT/POST/DELETE")
-	}
-}
-
-// billingRulesPayload is the UI-facing view: the profiles as declared, plus
-// which one is active and the source URLs they can match — the editor needs
-// the URL list to offer suggestions, and an operator typing a URL that matches
-// no source is exactly the silent-no-pricing failure this feature exists to
-// remove.
-type billingRulesPayload struct {
-	DSL      *config.BillingDSL `json:"billing"`
-	Active   string             `json:"active"`
-	URLs     []string           `json:"urls"`
-	Warnings []string           `json:"warnings"`
-}
-
-func (g *Gateway) billingRulesPayload() billingRulesPayload {
-	out := billingRulesPayload{}
-	cfg := g.core.Config()
-	if cfg != nil && cfg.BillingDSL != nil {
-		// Copy so the response cannot be mutated back through the pointer.
-		cp := *cfg.BillingDSL
-		out.DSL = &cp
-		if p := cp.Resolve(""); p != nil {
-			out.Active = p.ID
-		}
-	}
-	for _, s := range g.sourceURLs() {
-		out.URLs = append(out.URLs, s)
-	}
-	out.Warnings = g.billingRuleWarnings()
-	return out
-}
-
-func (g *Gateway) sourceURLs() []string {
-	cfg := g.core.Config()
-	if cfg == nil {
-		return nil
-	}
-	seen := map[string]bool{}
-	var out []string
-	for _, s := range cfg.Sources {
-		if s.BaseURL == "" || seen[s.BaseURL] {
-			continue
-		}
-		seen[s.BaseURL] = true
-		out = append(out, s.BaseURL)
-	}
-	return out
-}
-
-// billingRuleWarnings reports rules that match no configured source. This is
-// the silent killer of hand-written price tables: the rule parses, validates,
-// and prices nothing at all, so every request on that URL lands in unpriced.
-// Saying so out loud is the difference between a five-second fix and an
-// afternoon wondering why the bill is zero.
-func (g *Gateway) billingRuleWarnings() []string {
-	cfg := g.core.Config()
-	if cfg == nil || cfg.BillingDSL == nil {
-		return nil
-	}
-	urls := map[string]bool{}
-	for _, u := range g.sourceURLs() {
-		urls[u] = true
-	}
-	var warns []string
-	for _, p := range cfg.BillingDSL.Profiles {
-		for _, r := range p.Rules {
-			if r.URL == "*" || urls[r.URL] {
-				continue
-			}
-			warns = append(warns, "profile "+p.ID+": rule url "+r.URL+" matches no configured source")
-		}
-	}
-	return warns
-}
-
-func (g *Gateway) getBillingRules(w http.ResponseWriter) {
-	writeJSON(w, http.StatusOK, g.billingRulesPayload())
-}
-
-func (g *Gateway) putBillingRules(w http.ResponseWriter, r *http.Request) {
-	var body struct {
-		Billing *config.BillingDSL `json:"billing"`
-	}
-	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
-		writeError(w, http.StatusBadRequest, "invalid_request", "invalid json: "+err.Error())
-		return
-	}
-	if body.Billing == nil {
-		writeError(w, http.StatusBadRequest, "invalid_request", "billing is required")
-		return
-	}
-	g.applyBillingDSLUpdate(w, body.Billing)
-}
-
-func (g *Gateway) addBillingRule(w http.ResponseWriter, r *http.Request) {
-	var body struct {
-		Profile string             `json:"profile"`
-		Rule    config.BillingRule `json:"rule"`
-	}
-	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
-		writeError(w, http.StatusBadRequest, "invalid_request", "invalid json: "+err.Error())
-		return
-	}
-	cfg := g.core.Config()
-	if cfg == nil || cfg.BillingDSL == nil || len(cfg.BillingDSL.Profiles) == 0 {
-		writeError(w, http.StatusBadRequest, "no_profile", "no billing profiles configured; create one first")
-		return
-	}
-	next := cloneBillingDSL(cfg.BillingDSL)
-	idx := profileIndex(next, body.Profile)
-	if idx < 0 {
-		writeError(w, http.StatusBadRequest, "unknown_profile", "no such profile: "+body.Profile)
-		return
-	}
-	p := &next.Profiles[idx]
-	// Replace rather than append when the URL is already declared: two rules
-	// for one URL would silently make the first unreachable (first match wins),
-	// which is the exact ambiguity an editor should not be able to create.
-	replaced := false
-	for i := range p.Rules {
-		if p.Rules[i].URL == body.Rule.URL {
-			p.Rules[i] = body.Rule
-			replaced = true
-			break
-		}
-	}
-	if !replaced {
-		p.Rules = append(p.Rules, body.Rule)
-	}
-	g.applyBillingDSLUpdate(w, next)
-}
-
-func (g *Gateway) delBillingRule(w http.ResponseWriter, r *http.Request) {
-	var body struct {
-		Profile string `json:"profile"`
-		URL     string `json:"url"`
-	}
-	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
-		writeError(w, http.StatusBadRequest, "invalid_request", "invalid json: "+err.Error())
-		return
-	}
-	cfg := g.core.Config()
-	if cfg == nil || cfg.BillingDSL == nil {
-		writeError(w, http.StatusBadRequest, "no_profile", "no billing profiles configured")
-		return
-	}
-	next := cloneBillingDSL(cfg.BillingDSL)
-	idx := profileIndex(next, body.Profile)
-	if idx < 0 {
-		writeError(w, http.StatusBadRequest, "unknown_profile", "no such profile: "+body.Profile)
-		return
-	}
-	p := &next.Profiles[idx]
-	out := p.Rules[:0]
-	found := false
-	for _, rule := range p.Rules {
-		if rule.URL == body.URL {
-			found = true
-			continue
-		}
-		out = append(out, rule)
-	}
-	if !found {
-		writeError(w, http.StatusNotFound, "not_found", "no rule for url "+body.URL)
-		return
-	}
-	p.Rules = out
-	g.applyBillingDSLUpdate(w, next)
-}
-
-// applyBillingDSLUpdate is the single write path: validate, persist to
-// config.yaml, recompile, inject, and only then report success. If the config
-// cannot be written the change is NOT applied in memory either — a rules editor
-// that says "saved" and loses the edit on the next restart is worse than one
-// that refuses.
-func (g *Gateway) applyBillingDSLUpdate(w http.ResponseWriter, next *config.BillingDSL) {
-	if err := next.Validate(); err != nil {
-		writeError(w, http.StatusBadRequest, "invalid_rules", err.Error())
-		return
-	}
-	cfg := g.core.Config()
-	if cfg == nil {
-		writeError(w, http.StatusInternalServerError, "no_config", "no config loaded")
-		return
-	}
-	// Assign BEFORE saving. The previous order saved first and assigned after,
-	// so every rule edit reported success while writing a config.yaml with no
-	// billing section at all — the operator's edit vanished on restart and
-	// nothing in the API response said so.
-	prev := cfg.BillingDSL
-	cfg.BillingDSL = next
-
-	// Compile before persisting: a profile that cannot be turned into prices
-	// must not reach the config file, or the next restart fails to load the
-	// very rules the editor just accepted.
-	prices, err := billing.CompileOpts(next.Resolve(next.Active), cfg.Sources, true)
-	if err != nil {
-		cfg.BillingDSL = prev // no half-applied state
-		writeError(w, http.StatusBadRequest, "compile_failed", err.Error())
-		return
-	}
-	if err := cfg.Save(); err != nil {
-		cfg.BillingDSL = prev
-		writeError(w, http.StatusInternalServerError, "persist_failed", err.Error())
-		return
-	}
-	ps := g.core.Plugins()
-	if ps != nil {
-		if err := ps.SetState("billing", map[string]interface{}{"prices": prices}); err != nil {
-			writeError(w, http.StatusBadRequest, "plugin_error", err.Error())
-			return
-		}
-	}
-	p := g.billingRulesPayload()
-	writeJSON(w, http.StatusOK, map[string]interface{}{
-		"ok": true, "billing": p.DSL, "active": p.Active, "warnings": p.Warnings,
-	})
-}
-
-func cloneBillingDSL(d *config.BillingDSL) *config.BillingDSL {
-	out := &config.BillingDSL{Active: d.Active}
-	out.Profiles = make([]config.BillingProfile, len(d.Profiles))
-	copy(out.Profiles, d.Profiles)
-	return out
-}
-
-func profileIndex(d *config.BillingDSL, id string) int {
-	if id == "" {
-		return -1
-	}
-	for i, p := range d.Profiles {
-		if p.ID == id {
-			return i
-		}
-	}
-	return -1
-}

internal/gateway/billing_rules_api_test.go

@@ -1,281 +0,0 @@
-package gateway
-
-import (
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"sort"
-	"strings"
-	"testing"
-
-	"llmsproxy/internal/config"
-)
-
-// rulesGateway needs a real billing plugin (the API injects prices into it)
-// AND two sources whose base_urls the rules will match, so it cannot reuse
-// either existing helper: gatewayWithBilling has no sources, and
-// newTestGateway loads no plugins.
-func rulesGateway(t *testing.T) *Gateway {
-	t.Helper()
-	g := gatewayWithBilling(t)
-	cfg := g.core.Config()
-	cfg.Sources = []config.Source{
-		{Name: "localzen", BaseURL: "https://free.example.com/v1"},
-		{Name: "commandcode", BaseURL: "https://api.commandcode.ai/v1"},
-	}
-	return g
-}
-
-func rulesDo(t *testing.T, g *Gateway, method, body string) *httptest.ResponseRecorder {
-	t.Helper()
-	return doReq(t, g, method, "/api/plugins/billing/rules", body)
-}
-
-// TestBillingRulesCRUD covers the whole editor loop against the real HTTP
-// surface: read, add, replace-by-URL, delete. The replace-by-URL case is the
-// one worth pinning — two rules for one URL would make the first unreachable
-// (first match wins) without any error, which is exactly the kind of silent
-// ambiguity an editor must not be able to create.
-func TestBillingRulesCRUD(t *testing.T) {
-	g := rulesGateway(t)
-	seed := `{"billing":{"active":"p1","profiles":[{"id":"p1","rules":[
-      {"url":"https://free.example.com/v1","mode":"free"}]}]}}`
-	if rr := rulesDo(t, g, http.MethodPut, seed); rr.Code != http.StatusOK {
-		t.Fatalf("seed rules = %d: %s", rr.Code, rr.Body.String())
-	}
-
-	// Add a token-priced rule for the second URL.
-	add := `{"profile":"p1","rule":{"url":"https://api.commandcode.ai/v1","mode":"token",
-      "models":{"deepseek-v4.1-flash":{"prompt":"0.15","completion":"0.60"}}}}`
-	if rr := rulesDo(t, g, http.MethodPost, add); rr.Code != http.StatusOK {
-		t.Fatalf("add rule = %d: %s", rr.Code, rr.Body.String())
-	}
-	var got billingRulesPayload
-	if err := json.Unmarshal(rulesDo(t, g, http.MethodGet, "").Body.Bytes(), &got); err != nil {
-		t.Fatal(err)
-	}
-	if len(got.DSL.Profiles[0].Rules) != 2 {
-		t.Fatalf("after add there are %d rules, want 2", len(got.DSL.Profiles[0].Rules))
-	}
-
-	// Adding the SAME url again must replace, not append.
-	if rr := rulesDo(t, g, http.MethodPost, `{"profile":"p1","rule":{"url":"https://api.commandcode.ai/v1","mode":"free"}}`); rr.Code != http.StatusOK {
-		t.Fatalf("re-add same url = %d: %s", rr.Code, rr.Body.String())
-	}
-	if err := json.Unmarshal(rulesDo(t, g, http.MethodGet, "").Body.Bytes(), &got); err != nil {
-		t.Fatal(err)
-	}
-	if n := len(got.DSL.Profiles[0].Rules); n != 2 {
-		t.Fatalf("★ re-adding an existing url appended instead of replacing: %d rules", n)
-	}
-	var mode string
-	for _, r := range got.DSL.Profiles[0].Rules {
-		if r.URL == "https://api.commandcode.ai/v1" {
-			mode = r.Mode
-		}
-	}
-	if mode != "free" {
-		t.Errorf("re-added rule mode = %q, want free (the replacement must win)", mode)
-	}
-
-	// Delete by URL.
-	if rr := rulesDo(t, g, http.MethodDelete, `{"profile":"p1","url":"https://api.commandcode.ai/v1"}`); rr.Code != http.StatusOK {
-		t.Fatalf("delete rule = %d: %s", rr.Code, rr.Body.String())
-	}
-	if err := json.Unmarshal(rulesDo(t, g, http.MethodGet, "").Body.Bytes(), &got); err != nil {
-		t.Fatal(err)
-	}
-	if len(got.DSL.Profiles[0].Rules) != 1 {
-		t.Errorf("after delete there are %d rules, want 1", len(got.DSL.Profiles[0].Rules))
-	}
-}
-
-// TestBillingRulesRejectUnknownURLWithWarning is the silent-failure guard: a
-// rule whose URL matches no source prices nothing, so every request on it
-// falls into unpriced. The API must say so instead of accepting it silently.
-func TestBillingRulesRejectUnknownURLWithWarning(t *testing.T) {
-	g := rulesGateway(t)
-	if rr := rulesDo(t, g, http.MethodPut, `{"billing":{"active":"p","profiles":[{"id":"p",
-      "rules":[{"url":"https://typo.example.com/v1","mode":"free"}]}]}}`); rr.Code != http.StatusOK {
-		t.Fatalf("seed = %d: %s", rr.Code, rr.Body.String())
-	}
-	var got billingRulesPayload
-	if err := json.Unmarshal(rulesDo(t, g, http.MethodGet, "").Body.Bytes(), &got); err != nil {
-		t.Fatal(err)
-	}
-	if len(got.Warnings) == 0 {
-		t.Fatal("★ a rule matching no configured source was accepted with no warning — " +
-			"it will price nothing and every request will be recorded as unpriced")
-	}
-	if !strings.Contains(got.Warnings[0], "typo.example.com") {
-		t.Errorf("warning does not name the offending url: %v", got.Warnings)
-	}
-	// The editor needs the real URL list to offer suggestions.
-	if len(got.URLs) != 2 {
-		t.Errorf("urls offered to the editor = %v, want the 2 configured base_urls", got.URLs)
-	}
-}
-
-// TestBillingRulesInvalidIsRejectedNotPersisted checks the write path refuses
-// bad input and leaves the previous rules in place — an editor that clears the
-// table on a typo loses the price table.
-func TestBillingRulesInvalidIsRejectedNotPersisted(t *testing.T) {
-	g := rulesGateway(t)
-	seed := `{"billing":{"active":"p","profiles":[{"id":"p","rules":[
-      {"url":"https://free.example.com/v1","mode":"free"}]}]}}`
-	if rr := rulesDo(t, g, http.MethodPut, seed); rr.Code != http.StatusOK {
-		t.Fatalf("seed = %d: %s", rr.Code, rr.Body.String())
-	}
-	// An unknown mode must be refused.
-	if rr := rulesDo(t, g, http.MethodPost, `{"profile":"p","rule":{"url":"https://x/v1","mode":"banana"}}`); rr.Code != http.StatusBadRequest {
-		t.Errorf("invalid mode accepted with %d, want 400", rr.Code)
-	}
-	var got billingRulesPayload
-	if err := json.Unmarshal(rulesDo(t, g, http.MethodGet, "").Body.Bytes(), &got); err != nil {
-		t.Fatal(err)
-	}
-	if len(got.DSL.Profiles[0].Rules) != 1 {
-		t.Errorf("★ a rejected rule was persisted anyway: %d rules", len(got.DSL.Profiles[0].Rules))
-	}
-	// An unparseable price must be refused too, not silently priced at zero.
-	if rr := rulesDo(t, g, http.MethodPost, `{"profile":"p","rule":{"url":"https://y/v1","mode":"token",
-      "models":{"m":{"prompt":"free","completion":"0.6"}}}}`); rr.Code != http.StatusBadRequest {
-		t.Errorf("non-numeric price accepted with %d, want 400", rr.Code)
-	}
-}
-
-// TestBillingRulesPersistAndReachThePlugin is the point of the whole
-// endpoint, and mutation verification showed the earlier CRUD tests missed it
-// twice: dropping cfg.Save() and dropping the SetState injection both left
-// every test green. Both failures are invisible in a GET — the response echoes
-// the in-memory rules either way — so this test checks the two consequences
-// that actually matter:
-//
-//  1. persistence: the rule must be in the config file on disk, because an
-//     edit that evaporates on restart is a lie the UI told the operator;
-//  2. effect: the billing plugin must now PRICE the source (its published
-//     prices table has a non-zero entry), because a rule that is stored but
-//     never injected prices nothing at all.
-func TestBillingRulesPersistAndReachThePlugin(t *testing.T) {
-	g := rulesGateway(t)
-	cfg := g.core.Config()
-
-	seed := `{"billing":{"active":"p","profiles":[{"id":"p","rules":[
-      {"url":"https://free.example.com/v1","mode":"free"},
-      {"url":"https://api.commandcode.ai/v1","mode":"token",
-       "models":{"deepseek-v4.1-flash":{"prompt":"0.15","completion":"0.60"}}}]}]}}`
-	if rr := rulesDo(t, g, http.MethodPut, seed); rr.Code != http.StatusOK {
-		t.Fatalf("seed = %d: %s", rr.Code, rr.Body.String())
-	}
-
-	// 1. persisted to the file the process loaded from.
-	raw, err := os.ReadFile(cfg.Path)
-	if err != nil {
-		t.Fatalf("read config: %v", err)
-	}
-	if !strings.Contains(string(raw), "commandcode.ai") {
-		t.Errorf("★ the rule is not in config.yaml on disk — an edit that does not "+
-			"survive a restart:\n%s", raw)
-	}
-	reloaded, err := config.Load(cfg.Path)
-	if err != nil {
-		t.Fatalf("reload saved config: %v", err)
-	}
-	if reloaded.BillingDSL == nil || len(reloaded.BillingDSL.Profiles) == 0 {
-		t.Fatalf("saved config has no billing DSL: %s", raw)
-	}
-	// A round-trip through YAML must not lose the price strings.
-	found := false
-	for _, r := range reloaded.BillingDSL.Profiles[0].Rules {
-		if strings.Contains(r.URL, "commandcode") {
-			found = true
-			if m, ok := r.Models["deepseek-v4.1-flash"]; !ok || m.Prompt != "0.15" {
-				t.Errorf("price did not survive the YAML round-trip: %+v", m)
-			}
-		}
-	}
-	if !found {
-		t.Errorf("the token rule is missing after reload:\n%s", raw)
-	}
-
-	// 2. reached the plugin. Prices live in a separate Lua field from `state`,
-	// and the GET /state endpoint returns the published state together with
-	// the prices sidecar — which is exactly what the plugin's own UI reads.
-	state := g.core.Plugins().State("billing")
-	if state == nil {
-		t.Fatalf("billing plugin published no state")
-	}
-	rr := doReq(t, g, http.MethodGet, "/api/plugins/billing/state", "")
-	if rr.Code != http.StatusOK {
-		t.Fatalf("GET state = %d: %s", rr.Code, rr.Body.String())
-	}
-	var envelope struct {
-		Prices map[string]interface{} `json:"prices"`
-	}
-	if err := json.Unmarshal(rr.Body.Bytes(), &envelope); err != nil {
-		t.Fatalf("decode state envelope: %v", err)
-	}
-	prices := envelope.Prices
-	if prices == nil {
-		t.Fatalf("state payload carries no prices")
-	}
-	sources, ok := prices["sources"].(map[string]interface{})
-	if !ok {
-		t.Fatalf("prices has no sources map: %#v", prices)
-	}
-	cc, ok := sources["commandcode"]
-	if !ok {
-		t.Fatalf("★ the rule was saved but never injected: prices has %v, "+
-			"no commandcode entry. Every request on it stays unpriced.", keysOf(sources))
-	}
-	if cc == nil {
-		t.Error("commandcode price entry is nil")
-	}
-	// The free rule must price localzen, and the two must not be conflated.
-	if _, ok := sources["localzen"]; !ok {
-		t.Errorf("the free rule did not reach the plugin: %v", keysOf(sources))
-	}
-	// The injected price must be per-token, i.e. 0.15 USD/M => 1.5e-7.
-	// Asserting the exact magnitude catches a unit error (per-million vs
-	// per-token), which would be off by a factor of a million and still look
-	// like "a number".
-	models, ok := cc.(map[string]interface{})["models"].(map[string]interface{})
-	if ok {
-		if m, ok := models["deepseek-v4.1-flash"].(map[string]interface{}); ok {
-			p, _ := m["prompt"].(float64)
-			if p <= 0 || p > 1e-6 {
-				t.Errorf("injected prompt price = %v, want per-token (~1.5e-7); "+
-					"a per-million value here would over-bill by 1e6x", p)
-			}
-		}
-	}
-}
-
-func keysOf(m map[string]interface{}) []string {
-	out := make([]string, 0, len(m))
-	for k := range m {
-		out = append(out, k)
-	}
-	sort.Strings(out)
-	return out
-}
-
-// TestBillingRulesRequireAdmin keeps price rewriting behind the admin role,
-// like every other plugin write: prices are configuration, not user data.
-func TestBillingRulesRequireAdmin(t *testing.T) {
-	g := rulesGateway(t)
-	rec, err := g.core.CreateKey("viewer", "user", nil, "")
-	if err != nil {
-		t.Fatal(err)
-	}
-	userKey := rec.Key
-	for _, m := range []string{http.MethodPut, http.MethodPost, http.MethodDelete} {
-		req, _ := http.NewRequest(m, "/api/plugins/billing/rules", strings.NewReader(`{}`))
-		req.Header.Set("Authorization", "Bearer "+userKey)
-		req.Header.Set("Content-Type", "application/json")
-		if rr := newRecorderFor(t, g, req); rr.Code != http.StatusForbidden {
-			t.Errorf("user %s rules = %d, want 403", m, rr.Code)
-		}
-	}
-}

internal/gateway/chat.go

@@ -13,11 +13,11 @@ import (
 	"sync/atomic"
 	"time"
 
-	"llmsproxy/internal/config"
-	"llmsproxy/internal/lua"
-	"llmsproxy/internal/provider"
-	"llmsproxy/internal/scheduler"
-	"llmsproxy/internal/types"
+	"modelrouter/internal/config"
+	"modelrouter/internal/lua"
+	"modelrouter/internal/provider"
+	"modelrouter/internal/scheduler"
+	"modelrouter/internal/types"
 )
 
 // chatRequest mirrors the OpenAI chat completions request the gateway accepts.

internal/gateway/chat_cache_test.go

@@ -3,7 +3,7 @@ package gateway
 import (
 	"testing"
 
-	"llmsproxy/internal/types"
+	"modelrouter/internal/types"
 )
 
 // TestMergeUsageKeepsZeroCacheDetails locks the streaming counterpart of the

internal/gateway/chat_reasoning_test.go

@@ -3,7 +3,7 @@ package gateway
 import (
 	"testing"
 
-	"llmsproxy/internal/types"
+	"modelrouter/internal/types"
 )
 
 // TestRecordChatUsageKeepsReasoningTokens pins the reasoning-token plumbing.

internal/gateway/deploy_script_test.go

@@ -11,7 +11,7 @@ import (
 
 // deploy.sh is the only release-critical script with no automated coverage, and
 // its newest part — prune_adapter_backups — deletes directories under
-// /etc/llmsproxy. This exercises the function in a throwaway directory with the
+// /etc/modelrouter. This exercises the function in a throwaway directory with the
 // REAL backup-name shape.
 //
 // The shape matters and got this wrong twice: the guard is
@@ -33,34 +33,34 @@ func TestDeployPruneAdapterBackups(t *testing.T) {
 		t.Fatalf("read deploy.sh: %v", err)
 	}
 	src := string(fn)
-	i := strings.Index(src, "prune_adapter_backups()")
+	i := strings.Index(src, "prune_backups()")
 	if i < 0 {
-		t.Fatal("prune_adapter_backups not found in deploy.sh")
+		t.Fatal("prune_backups not found in deploy.sh")
 	}
 	j := strings.Index(src[i:], "\n}\n")
 	if j < 0 {
-		t.Fatal("prune_adapter_backups has no closing brace")
+		t.Fatal("prune_backups has no closing brace")
 	}
 	body := src[i : i+j+3]
 
 	// Redirect ONLY the base path. The logic under test must stay verbatim.
 	body = strings.Replace(body,
-		`local base="/etc/llmsproxy"`,
+		`local base="/etc/modelrouter"`,
 		`local base="`+base+`"`, 1)
-	// KEEP_ADAPTER_BACKUPS must come from deploy.sh itself, NOT from a literal
+	// KEEP_BACKUPS must come from deploy.sh itself, NOT from a literal
 	// here: hardcoding 5 in the shim overrode whatever the script configured, so
-	// a mutation that set KEEP_ADAPTER_BACKUPS=0 in deploy.sh still passed. The
+	// a mutation that set KEEP_BACKUPS=0 in deploy.sh still passed. The
 	// value is part of what is under test.
-	var keepRe = regexp.MustCompile(`(?m)^KEEP_ADAPTER_BACKUPS=(\d+)`)
+	var keepRe = regexp.MustCompile(`(?m)^KEEP_BACKUPS=(\d+)`)
 	keepM := keepRe.FindStringSubmatch(src)
 	if keepM == nil {
-		t.Fatal("deploy.sh no longer sets KEEP_ADAPTER_BACKUPS; the pruning " +
+		t.Fatal("deploy.sh no longer sets KEEP_BACKUPS; the pruning " +
 			"policy would be undefined")
 	}
 	keep := keepM[1]
 
-	script := "warn() { :; }\nlog() { :; }\nKEEP_ADAPTER_BACKUPS=" + keep + "\n" +
-		body + "\nprune_adapter_backups\n"
+	script := "warn() { :; }\nlog() { :; }\nfail() { echo \"$*\" >&2; exit 1; }\nKEEP_BACKUPS=" + keep + "\n" +
+		body + "\nprune_backups adapters\n"
 	scriptPath := filepath.Join(base, "fn.sh")
 	if err := os.WriteFile(scriptPath, []byte(script), 0o600); err != nil {
 		t.Fatalf("write script: %v", err)
@@ -88,7 +88,7 @@ func TestDeployPruneAdapterBackups(t *testing.T) {
 	}
 
 	if out, err := exec.Command("bash", scriptPath).CombinedOutput(); err != nil {
-		t.Fatalf("prune_adapter_backups failed: %v\n%s", err, out)
+		t.Fatalf("prune_backups failed: %v\n%s", err, out)
 	}
 
 	entries, err := os.ReadDir(base)
@@ -102,11 +102,11 @@ func TestDeployPruneAdapterBackups(t *testing.T) {
 		}
 	}
 
-	// 12 well-formed backups with KEEP_ADAPTER_BACKUPS=5 → the newest FIVE
+	// 12 well-formed backups with KEEP_BACKUPS=5 → the newest FIVE
 	// survive (…08 …09 …10 …11 …12) and the older seven are deleted. Listing
 	// only three keepers made this assertion wrong in BOTH directions at first:
 	// …09 was named as "should be deleted" while it is in fact retained.
-	// KEEP_ADAPTER_BACKUPS=5 is a cap on the TOTAL number of backups, and
+	// KEEP_BACKUPS=5 is a cap on the TOTAL number of backups, and
 	// irregular names are never deleted — so they consume slots rather than
 	// being ignored. With 3 unremovable directories present, only 2 of the
 	// well-formed ones can survive. That is the function's actual (and safe)
@@ -202,3 +202,123 @@ func TestDeployBacksUpTheLiveFileBeforeOverwriting(t *testing.T) {
 			"captures the new file and rollback restores nothing")
 	}
 }
+
+// ★ 备份清理必须覆盖 plugins 前缀（真实缺陷）。
+//
+// 事实：backup 清理最初只处理 `adapters.bak.*`，而 `sync_plugins` 同样每次部署
+// 建一个 `plugins.bak.<时间戳>` —— 于是 adapters 的堆积被修好，plugins 继续涨。
+// 实测线上 plugins.bak 积累到 **36 个**、/etc/modelrouter 涨到 192M。
+//
+// 这是「两处只修一处」的老形状。判据钉住：prune_all_backups 必须同时裁两个前缀，
+// 且新增任何 .bak.<时间戳> 前缀时都要在这里补上（否则又是一个泄漏点）。
+func TestDeployPruneCoversBothBackupPrefixes(t *testing.T) {
+	if _, err := os.Stat("../../deploy.sh"); err != nil {
+		t.Skip("deploy.sh not present (packaging-only checkout)")
+	}
+	if _, err := exec.LookPath("bash"); err != nil {
+		t.Skip("bash not available")
+	}
+	fn, err := os.ReadFile("../../deploy.sh")
+	if err != nil {
+		t.Fatal(err)
+	}
+	src := string(fn)
+
+	// ① prune_all_backups 必须存在且两个前缀都裁
+	i := strings.Index(src, "prune_all_backups()")
+	if i < 0 {
+		t.Fatal("prune_all_backups 不存在 —— 调用点若仍只裁 adapters，" +
+			"plugins.bak 会继续无上限堆积（实测 36 个 / 192M）")
+	}
+	j := strings.Index(src[i:], "\n}\n")
+	if j < 0 {
+		t.Fatal("prune_all_backups 没有收尾大括号")
+	}
+	body := src[i : i+j+3]
+	for _, want := range []string{"prune_backups adapters", "prune_backups plugins"} {
+		if !strings.Contains(body, want) {
+			t.Fatalf("prune_all_backups 缺 %q —— plugins.bak 会无上限堆积", want)
+		}
+	}
+
+	// ② ★ 覆盖完整性：脚本里出现的每个 `.bak.<时间戳>` 前缀都必须在裁剪范围内。
+	// 这条比逐字检查两个名字更强 —— 将来有人新增第三种备份目录（比如
+	// runtime.bak.*），这里会立刻报红，而不是等它涨到几百兆。
+	prefixRe := regexp.MustCompile(`([a-z_]+)\.bak\.\$\(date`)
+	found := map[string]bool{}
+	for _, m := range prefixRe.FindAllStringSubmatch(src, -1) {
+		found[m[1]] = true
+	}
+	if len(found) == 0 {
+		t.Fatal("deploy.sh 里没找到任何 .bak.$(date …) 备份目录创建点（判据需更新）")
+	}
+	for prefix := range found {
+		if !strings.Contains(body, "prune_backups "+prefix) {
+			t.Errorf("deploy.sh 会创建 %s.bak.<时间戳> 目录，但 prune_all_backups 不裁它 "+
+				"—— 它就是一个无上限增长的备份泄漏点（实测 plugins.bak 涨到 36 个）", prefix)
+		}
+	}
+
+	// ③ 行为验证：用真函数裁 plugins 前缀，最新 5 份必须留下、更旧的删掉
+	base := t.TempDir()
+	k := strings.Index(src, "prune_backups()")
+	kj := strings.Index(src[k:], "\n}\n")
+	fnBody := src[k : k+kj+3]
+	fnBody = strings.Replace(fnBody, `local base="/etc/modelrouter"`, `local base="`+base+`"`, 1)
+	keepRe := regexp.MustCompile(`(?m)^KEEP_BACKUPS=(\d+)`)
+	km := keepRe.FindStringSubmatch(src)
+	if km == nil {
+		t.Fatal("deploy.sh 不再设置 KEEP_BACKUPS")
+	}
+	script := "warn() { :; }\nlog() { :; }\nfail() { echo \"$*\" >&2; exit 1; }\nKEEP_BACKUPS=" +
+		km[1] + "\n" + fnBody + "\nprune_backups plugins\n"
+	sp := filepath.Join(base, "fn.sh")
+	if err := os.WriteFile(sp, []byte(script), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	for _, ts := range []string{
+		"20260101120000", "20260201120000", "20260301120000", "20260401120000",
+		"20260501120000", "20260601120000", "20260701120000", "20260801120000",
+	} {
+		if err := os.MkdirAll(filepath.Join(base, "plugins.bak."+ts), 0o755); err != nil {
+			t.Fatal(err)
+		}
+	}
+	// adapters 前缀**不该被动**（防止误删别的前缀）
+	if err := os.MkdirAll(filepath.Join(base, "adapters.bak.20260101120000"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if out, err := exec.Command("bash", sp).CombinedOutput(); err != nil {
+		t.Fatalf("prune_backups plugins failed: %v\n%s", err, out)
+	}
+	entries, err := os.ReadDir(base)
+	if err != nil {
+		t.Fatal(err)
+	}
+	got := map[string]bool{}
+	for _, e := range entries {
+		if e.IsDir() {
+			got[e.Name()] = true
+		}
+	}
+	if !got["plugins.bak.20260801120000"] {
+		t.Error("最新的 plugins 备份被删了；裁剪必须从最旧的一端开始")
+	}
+	if got["plugins.bak.20260101120000"] {
+		t.Error("最旧的 plugins 备份存活；裁剪没生效")
+	}
+	if !got["adapters.bak.20260101120000"] {
+		t.Error("裁 plugins 时误删了 adapters 备份 —— 前缀参数必须严格限定范围")
+	}
+
+	// ④ 未知前缀必须响亮失败（防误用：传空串会删掉整个目录）
+	bad := "warn() { :; }\nlog() { :; }\nfail() { echo \"$*\" >&2; exit 1; }\nKEEP_BACKUPS=" +
+		km[1] + "\n" + fnBody + "\nprune_backups \"\"\n"
+	bp := filepath.Join(base, "bad.sh")
+	if err := os.WriteFile(bp, []byte(bad), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if out, err := exec.Command("bash", bp).CombinedOutput(); err == nil {
+		t.Fatalf("prune_backups 接受空前缀（危险：会删整个目录），输出: %s", out)
+	}
+}

internal/gateway/discover.go

@@ -11,7 +11,7 @@ import (
 	"strings"
 	"time"
 
-	"llmsproxy/internal/config"
+	"modelrouter/internal/config"
 )
 
 // Model discovery: turn "here is a URL and a key" into a configured source.
@@ -535,11 +535,11 @@ type modelCaps struct {
 }
 
 type upstreamModel struct {
-	ID       string `json:"id"`
-	Object   string `json:"object"`
-	Kind     string `json:"kind"`
-	Type     string `json:"type"`
-	Modality string `json:"modality"`
+	ID           string `json:"id"`
+	Object       string `json:"object"`
+	Kind         string `json:"kind"`
+	Type         string `json:"type"`
+	Modality     string `json:"modality"`
 	Architecture struct {
 		InputModalities  []string `json:"input_modalities"`
 		OutputModalities []string `json:"output_modalities"`
@@ -699,8 +699,8 @@ func modelMeta(m upstreamModel) map[string]interface{} {
 		}
 	}
 
-	copyFields(m.Metadata)      // nested first
-	copyFields(mustJSON(m))     // top level wins
+	copyFields(m.Metadata)  // nested first
+	copyFields(mustJSON(m)) // top level wins
 	if len(meta) == 0 {
 		return nil
 	}
@@ -740,10 +740,10 @@ func mustJSON(v interface{}) []byte {
 func modelsToConfig(chat, image []string) []config.Model {
 	out := make([]config.Model, 0, len(chat)+len(image))
 	for _, id := range chat {
-		out = append(out, config.Model{ID: id, Priority: 50, Kind: "chat"})
+		out = append(out, config.Model{ID: id, Kind: "chat"})
 	}
 	for _, id := range image {
-		out = append(out, config.Model{ID: id, Priority: 70, Kind: "image"})
+		out = append(out, config.Model{ID: id, Kind: "image"})
 	}
 	return out
 }

internal/gateway/discover_api.go

@@ -5,7 +5,7 @@ import (
 	"encoding/json"
 	"errors"
 	"io"
-	"llmsproxy/internal/config"
+	"modelrouter/internal/config"
 	"net/http"
 	"strings"
 	"time"
@@ -61,6 +61,20 @@ type discoverRequest struct {
 	// a typo here would produce a source that 404s on every request.
 	Include []string `json:"include,omitempty"`
 	Exclude []string `json:"exclude,omitempty"`
+
+	// ImageModels names ids that are **kind=image** but whose upstream catalog
+	// does not say so.
+	//
+	// 为什么需要（真实缺口）：discoveredModelKind 只看上游的 modality 字段，
+	// 并且刻意**不从模型名推断**（那会把 "gpt-image-1" 这类同名聊天模型
+	// 错归成生图，而错误的 kind 会毒死 AUTO 链）。
+	// 但有些网关的 `/v1/models` 只返回 `{id,object,created,owned_by}` ——
+	// 零 modality（实测：某聚合网关的 3 个 gpt-image-* 全部落成 chat，
+	// 于是生图端点永远报 `no image source configured`）。
+	//
+	// 两条原则都不破：不猜（默认仍完全按元数据），但允许**显式声明**。
+	// 只影响写入的 kind，不影响目录里有没有这个模型。
+	ImageModels []string `json:"image_models,omitempty"`
 }
 
 // discoverResponse is the JSON the WebUI binds to.
@@ -117,8 +131,36 @@ func (g *Gateway) handleSourceDiscoverAPI(w http.ResponseWriter, r *http.Request
 		return
 	}
 	req.BaseURL = strings.TrimSpace(req.BaseURL)
+	req.Name = strings.TrimSpace(req.Name)
+
+	// ★ 只给 `name`（或两者都给但 key 为空）⇒ **从已存源取 base_url 与凭据**。
+	//
+	// 为什么必须有这条路径（真实痛点）：刷新一个**已存在**源的模型目录，此前
+	// 必须让运维把明文 key 再粘一次 —— 而库里的 key 是 `enc:v1:` 密文，
+	// 运维手里未必还有原文；WebUI 也不回显明文（这是正确的安全设计）。
+	// 结果就是「想刷新目录 → 必须重新申请/粘贴一次 key」，很多人干脆不刷新，
+	// 于是源的模型目录越放越旧（实例：某源的 3 个生图模型从未被登记）。
+	//
+	// 安全边界：① 已要求 admin 角色；② 只能探测**本网关已配置的**源，
+	// 不能借此拿任意 URL + 任意 key 做探测（那样就成了 SSRF/密钥外带渠道）；
+	// ③ 响应不回显 key（只回目录）。
+	if req.Name != "" {
+		if old := g.sourceByName(req.Name); old != nil {
+			if req.BaseURL == "" {
+				req.BaseURL = old.BaseURL
+			}
+			if req.APIKey == "" {
+				req.APIKey = old.APIKey
+			}
+			if req.Adapter == "" {
+				req.Adapter = old.Adapter
+			}
+		}
+	}
+
 	if req.BaseURL == "" {
-		writeError(w, http.StatusBadRequest, "invalid_request", "base_url required")
+		writeError(w, http.StatusBadRequest, "invalid_request",
+			"base_url required (or pass name of an existing source to reuse its base_url and credential)")
 		return
 	}
 	if req.Adapter == "" {
@@ -144,6 +186,58 @@ func (g *Gateway) handleSourceDiscoverAPI(w http.ResponseWriter, r *http.Request
 		return
 	}
 
+	// ★ 显式生图声明：把 operator 点名的 id 从 chat 挪到 image。
+	//
+	// 放在 selectModels **之前**：后者按 include/exclude 裁剪两个列表，
+	// 挪类必须在裁剪前完成，否则一个"只声明成生图、又被 include 选中"的
+	// 模型会先在 chat 里被保留、再被这里挪走 —— 顺序反了会得到两份。
+	//
+	// 只认**目录里确实存在的** id：写错一个字不该静默造出一个不存在的模型
+	// （那会让源在每次照片请求时 404），而是明确报错。
+	if len(req.ImageModels) > 0 {
+		have := map[string]bool{}
+		for _, m := range res.Models {
+			have[m] = true
+		}
+		for _, m := range res.ImageModels {
+			have[m] = true
+		}
+		var missing []string
+		force := map[string]bool{}
+		for _, id := range req.ImageModels {
+			if !have[id] {
+				missing = append(missing, id)
+				continue
+			}
+			force[id] = true
+		}
+		if len(missing) > 0 {
+			writeError(w, http.StatusBadRequest, "invalid_request",
+				"image_models contains ids that are not in the upstream catalog: "+
+					strings.Join(missing, ", "))
+			return
+		}
+		var keepChat []string
+		for _, m := range res.Models {
+			if !force[m] {
+				keepChat = append(keepChat, m)
+			}
+		}
+		seenImg := map[string]bool{}
+		var newImage []string
+		for _, m := range res.ImageModels {
+			seenImg[m] = true
+			newImage = append(newImage, m)
+		}
+		for id := range force {
+			if !seenImg[id] {
+				newImage = append(newImage, id)
+			}
+		}
+		res.Models = keepChat
+		res.ImageModels = newImage
+	}
+
 	chat, image, warns, err := selectModels(res.Models, res.ImageModels, req.Include, req.Exclude)
 	if err != nil {
 		// 400: the operator asked for a model the catalog does not have.

internal/gateway/discover_api_test.go

@@ -9,7 +9,7 @@ import (
 	"strings"
 	"testing"
 
-	"llmsproxy/internal/config"
+	"modelrouter/internal/config"
 )
 
 // upstream that answers /v1/models with the real captured catalog

internal/gateway/discover_mutate_test.go

@@ -126,7 +126,12 @@ func TestRealMutants(t *testing.T) {
 		},
 		{
 			name: "nested metadata no longer read",
-			from: "\tcopyFields(m.Metadata)      // nested first",
+			// 锚点必须与 discover.go 逐字节一致：此前这里是 6 个空格，源码已
+			// 变成 2 个空格，于是这条变异永远"找不到锚点"——变异campaign 每次
+			// 都以 anchor not found 失败，而它本该验证"嵌套 metadata 被丢掉"能被
+			// 测试抓住。锚点漂移 = 这条变异从未真正跑过（和 issue #1 里
+			// `cc["models"]` 恒 false 的测试跳过是同一种失效：断言写了但没执行）。
+			from: "\tcopyFields(m.Metadata)  // nested first",
 			to:   "\tcopyFields(json.RawMessage(nil)) // mutant: nested metadata dropped",
 		},
 		{

internal/gateway/discover_test.go

@@ -497,9 +497,6 @@ func TestModelsToConfig_PrioritiesAndKinds(t *testing.T) {
 	if got[2].ID != "img1" || got[2].Kind != "image" {
 		t.Errorf("image model mis-sorted: %+v", got[2])
 	}
-	if got[2].Priority <= got[0].Priority {
-		t.Errorf("image model priority %d should sort after chat %d", got[2].Priority, got[0].Priority)
-	}
 }
 
 // TestDiscoverModels_ImageModelsNeverNull guards the UI contract end to end,

internal/gateway/gateway_test.go

@@ -14,8 +14,8 @@ import (
 	"testing"
 	"time"
 
-	"llmsproxy/internal/config"
-	"llmsproxy/internal/core"
+	"modelrouter/internal/config"
+	"modelrouter/internal/core"
 )
 
 func mockUpstream() *httptest.Server {
@@ -53,6 +53,42 @@ func newTestGateway(t *testing.T, srcs ...config.Source) *Gateway {
 	if err := cfg.ApplyDefaults(); err != nil {
 		t.Fatal(err)
 	}
+	// ★ 测试默认建一条 AUTO 链（每个源一个 tier，按传入顺序），因为内核
+	//   **不再** seedAuto 自动播种规则了（那条废弃逻辑已删除：AUTO 链为空时
+	//   网关应当直接 503，而不是凭空生成一堆用户没配过的档位）。
+	//
+	//   但既有测试大量依赖"AUTO 能跑"，它们此前是隐式吃 seedAuto 的。这里显式
+	//   建链，既保持测试原意（验调度而不是验播种），也让"空链=503"成为
+	//   一个**可以单独断言**的行为（见 TestChatAutoEmptyChainIsRejected）。
+	//
+	//   顺序沿用 seedAuto 的老口径：**源按"最后一个最先"排**（tier 1 = 最后
+	//   传入的源）。既有用例靠这个语义挑"high"源（TestChatAUTO 期望 high-m），
+	//   改成正序会让一批用例因为"挑到了另一个源"而红，而那与本次重构无关。
+	//
+	//   所有源放在**同一个 tier**（tier 1），而不是一个源一个 tier：链内同一
+	//   tier 的多个 slot 会互相 failover，这正是 TestChatAutoChainTierFailover
+	//   要验的行为（"a 挂 500 → 请求由 b 服务"）。一源一 tier 会让 a 独占 tier1，
+	//   b 在 tier2 永远轮不到，"两个源都被打过"这条断言就必然失败。
+	if len(cfg.Auto) == 0 && len(srcs) > 0 {
+		// 一源一 tier，**倒序**：最后传入的源拿 tier 1（最先尝试）。
+		// TestChatAUTO（low 先传、high 后传，期望 high）靠的就是这个语义。
+		// 同 tier failover 由 TestChatAutoChainTierFailover 自己显式建链覆盖 ——
+		// 两条测试验的是不同机制（tier 优先 vs 同 tier 轮转），不能用同一个
+		// 默认夹具同时满足。
+		tier := 0
+		for i := len(srcs) - 1; i >= 0; i-- {
+			tier++
+			s := srcs[i]
+			for _, m := range s.Models {
+				if m.Kind == "image" {
+					continue // 图片模型不进 chat 链（与 buildAutoChain 同口径）
+				}
+				cfg.Auto = append(cfg.Auto, config.ModelScope{
+					Model: m.ID, Source: s.Name, Tier: tier,
+				})
+			}
+		}
+	}
 	c, err := core.NewFromConfig(cfg)
 	if err != nil {
 		t.Fatalf("core: %v", err)
@@ -107,9 +143,18 @@ func TestChatAutoChainTierFailover(t *testing.T) {
 	defer aUp.Close()
 	defer bUp.Close()
 	g := newTestGateway(t,
-		config.Source{Name: "a", BaseURL: aUp.URL, Adapter: "openai", Models: []config.Model{{ID: "a-m", Priority: 100}}},
-		config.Source{Name: "b", BaseURL: bUp.URL, Adapter: "openai", Models: []config.Model{{ID: "b-m", Priority: 10}}},
+		config.Source{Name: "a", BaseURL: aUp.URL, Adapter: "openai", Models: []config.Model{{ID: "a-m"}}},
+		config.Source{Name: "b", BaseURL: bUp.URL, Adapter: "openai", Models: []config.Model{{ID: "b-m"}}},
 	)
+	// ★ 显式把两个源放进**同一 tier**：本用例验的是 tier 内失败轮转。
+	//   默认夹具是一源一 tier（供 TestChatAUTO 验优先级），两者语义不同，
+	//   必须在这里覆盖，否则 b 在 tier2 永远轮不到。
+	if err := g.core.SaveAutoRules([]config.ModelScope{
+		{Model: "a-m", Source: "a", Tier: 1},
+		{Model: "b-m", Source: "b", Tier: 1},
+	}); err != nil {
+		t.Fatalf("save auto rules: %v", err)
+	}
 	rr := doReq(t, g, "POST", "/v1/chat/completions",
 		`{"model":"AUTO","messages":[{"role":"user","content":"hi"}]}`)
 	if rr.Code != 200 {
@@ -134,8 +179,8 @@ func TestChatAutoChain503Summary(t *testing.T) {
 	defer aUp.Close()
 	defer bUp.Close()
 	g := newTestGateway(t,
-		config.Source{Name: "a", BaseURL: aUp.URL, Adapter: "openai", Models: []config.Model{{ID: "a-m", Priority: 100}}},
-		config.Source{Name: "b", BaseURL: bUp.URL, Adapter: "openai", Models: []config.Model{{ID: "b-m", Priority: 10}}},
+		config.Source{Name: "a", BaseURL: aUp.URL, Adapter: "openai", Models: []config.Model{{ID: "a-m"}}},
+		config.Source{Name: "b", BaseURL: bUp.URL, Adapter: "openai", Models: []config.Model{{ID: "b-m"}}},
 	)
 	rr := doReq(t, g, "POST", "/v1/chat/completions",
 		`{"model":"AUTO","messages":[{"role":"user","content":"hi"}]}`)
@@ -156,7 +201,7 @@ func TestChatAutoQuotaSkip(t *testing.T) {
 	up := upstream(t, ctrl)
 	defer up.Close()
 	g := newTestGateway(t,
-		config.Source{Name: "a", BaseURL: up.URL, Adapter: "openai", Models: []config.Model{{ID: "a-m", Priority: 100}}},
+		config.Source{Name: "a", BaseURL: up.URL, Adapter: "openai", Models: []config.Model{{ID: "a-m"}}},
 	)
 	// one slot with an hourly quota of 1 token
 	rr := doReq(t, g, "PUT", "/api/auto",
@@ -191,7 +236,7 @@ func TestAutoStatesReportChainHealth(t *testing.T) {
 	up := upstream(t, ctrl)
 	defer up.Close()
 	g := newTestGateway(t,
-		config.Source{Name: "a", BaseURL: up.URL, Adapter: "openai", Models: []config.Model{{ID: "a-m", Priority: 100}}},
+		config.Source{Name: "a", BaseURL: up.URL, Adapter: "openai", Models: []config.Model{{ID: "a-m"}}},
 	)
 	doReq(t, g, "POST", "/v1/chat/completions",
 		`{"model":"AUTO","messages":[{"role":"user","content":"hi"}]}`)
@@ -234,7 +279,7 @@ func TestAutoSaveResetsCooldown(t *testing.T) {
 	up := upstream(t, ctrl)
 	defer up.Close()
 	g := newTestGateway(t,
-		config.Source{Name: "a", BaseURL: up.URL, Adapter: "openai", Models: []config.Model{{ID: "a-m", Priority: 100}}},
+		config.Source{Name: "a", BaseURL: up.URL, Adapter: "openai", Models: []config.Model{{ID: "a-m"}}},
 	)
 	rr := doReq(t, g, "POST", "/v1/chat/completions",
 		`{"model":"AUTO","messages":[{"role":"user","content":"hi"}]}`)
@@ -348,8 +393,8 @@ func TestChatAUTO(t *testing.T) {
 	up := mockUpstream()
 	defer up.Close()
 	g := newTestGateway(t,
-		config.Source{Name: "low", BaseURL: up.URL, Adapter: "openai", Models: []config.Model{{ID: "low-m", Priority: 10}}},
-		config.Source{Name: "high", BaseURL: up.URL, Adapter: "openai", Models: []config.Model{{ID: "high-m", Priority: 100}}},
+		config.Source{Name: "low", BaseURL: up.URL, Adapter: "openai", Models: []config.Model{{ID: "low-m"}}},
+		config.Source{Name: "high", BaseURL: up.URL, Adapter: "openai", Models: []config.Model{{ID: "high-m"}}},
 	)
 	// no model -> AUTO -> picks the highest priority source
 	rr := doReq(t, g, "POST", "/v1/chat/completions",
@@ -428,8 +473,8 @@ func TestImageAutoFallsOnlyToImageProviders(t *testing.T) {
 	}))
 	defer chatUp.Close()
 	g := newTestGateway(t,
-		config.Source{Name: "chat", BaseURL: chatUp.URL, Adapter: "openai", Models: []config.Model{{ID: "chat-m", Priority: 100}}},
-		config.Source{Name: "img", BaseURL: img.URL, Adapter: "openai", Models: []config.Model{{ID: "flux", Kind: "image", Priority: 1}}},
+		config.Source{Name: "chat", BaseURL: chatUp.URL, Adapter: "openai", Models: []config.Model{{ID: "chat-m"}}},
+		config.Source{Name: "img", BaseURL: img.URL, Adapter: "openai", Models: []config.Model{{ID: "flux", Kind: "image"}}},
 	)
 	rr := doReq(t, g, "POST", "/v1/images/generations",
 		`{"model":"AUTO","prompt":"a cat"}`)
@@ -444,38 +489,6 @@ func TestImageAutoFallsOnlyToImageProviders(t *testing.T) {
 	}
 }
 
-func TestKimicodeSigning(t *testing.T) {
-	var gotAuth, gotSign string
-	up := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		_, _ = io.ReadAll(r.Body)
-		gotAuth = r.Header.Get("Authorization")
-		gotSign = r.Header.Get("X-App-Sign")
-		w.Header().Set("Content-Type", "application/json")
-		fmt.Fprintf(w, `{"choices":[{"message":{"content":"ok"},"finish_reason":"stop"}]}`)
-	}))
-	defer up.Close()
-
-	g := newTestGateway(t, config.Source{
-		Name:    "kimi",
-		BaseURL: up.URL,
-		Adapter: "kimicode",
-		APIKey:  "sk-kimi",
-		Models:  []config.Model{{ID: "kimi-k2"}},
-		Meta:    map[string]interface{}{"app_id": "app-1", "app_secret": "s3cr3t", "app_agent": "code-agent", "api_key": "sk-kimi"},
-	})
-	rr := doReq(t, g, "POST", "/v1/chat/completions",
-		`{"model":"kimi-k2","messages":[{"role":"user","content":"hi"}]}`)
-	if rr.Code != 200 {
-		t.Fatalf("status=%d body=%s", rr.Code, rr.Body.String())
-	}
-	if gotAuth == "" || !strings.Contains(gotAuth, "sk-kimi") {
-		t.Fatalf("expected signed auth, got %q", gotAuth)
-	}
-	if gotSign == "" {
-		t.Fatalf("expected app signature header")
-	}
-}
-
 func TestModelRoutingPrefix(t *testing.T) {
 	up := mockUpstream()
 	defer up.Close()

internal/gateway/key_auto_api_test.go

@@ -9,8 +9,8 @@ import (
 	"strings"
 	"testing"
 
-	"llmsproxy/internal/config"
-	"llmsproxy/internal/core"
+	"modelrouter/internal/config"
+	"modelrouter/internal/core"
 )
 
 // Per-key AUTO chain admin API. The behaviours pinned here are the ones that
@@ -44,7 +44,7 @@ func keyAutoGateway(t *testing.T) *Gateway {
 		},
 		Sources: []config.Source{
 			{Name: "s1", BaseURL: "http://127.0.0.1:1/v1", Adapter: "openai",
-				Models: []config.Model{{ID: "gpt-4o", Priority: 10}, {ID: "gpt-4o-mini", Priority: 5}}},
+				Models: []config.Model{{ID: "gpt-4o"}, {ID: "gpt-4o-mini"}}},
 		},
 	}
 	if err := cfg.ApplyDefaults(); err != nil {

internal/gateway/key_quota_api_test.go

@@ -9,8 +9,8 @@ import (
 	"strings"
 	"testing"
 
-	"llmsproxy/internal/config"
-	"llmsproxy/internal/core"
+	"modelrouter/internal/config"
+	"modelrouter/internal/core"
 )
 
 // adminGateway builds a gateway whose admin key can call /api/keys.

internal/gateway/key_quota_test.go

@@ -4,7 +4,7 @@ import (
 	"testing"
 	"time"
 
-	"llmsproxy/internal/config"
+	"modelrouter/internal/config"
 )
 
 // ---- data layer: per-key isolation ----

internal/gateway/key_quota_wiring_test.go

@@ -12,8 +12,8 @@ import (
 	"testing"
 	"time"
 
-	"llmsproxy/internal/config"
-	"llmsproxy/internal/core"
+	"modelrouter/internal/config"
+	"modelrouter/internal/core"
 )
 
 // quotaGateway builds a gateway with two user keys that differ only in their
@@ -36,7 +36,7 @@ func quotaGateway(t *testing.T, keyA, keyB config.GWKey) (*Gateway, *upstreamCtr
 		Keys:        []config.GWKey{keyA, keyB},
 		Sources: []config.Source{{
 			Name: "up", BaseURL: up.URL, Adapter: "openai",
-			Models: []config.Model{{ID: "m1", Priority: 100}},
+			Models: []config.Model{{ID: "m1"}},
 		}},
 	}
 	if err := cfg.ApplyDefaults(); err != nil {
@@ -306,14 +306,24 @@ func newQuotaGW(t *testing.T, upURL string, keys ...config.GWKey) *Gateway {
 		Sources: []config.Source{{
 			Name: "up", BaseURL: upURL, Adapter: "openai",
 			Models: []config.Model{
-				{ID: "m1", Priority: 100},
-				{ID: "m2", Priority: 90},
+				{ID: "m1"},
+				{ID: "m2"},
 			},
 		}},
 	}
 	if err := cfg.ApplyDefaults(); err != nil {
 		t.Fatal(err)
 	}
+
+	// 内核不再 seedAuto 自动播种 AUTO 链（空链=503 是刻意的）。本夹具的用例
+	// 全都在验"AUTO 请求会不会被 key 配额挡住"，必须显式建一条链 ——
+	// 否则每个用例都先撞 503，验的就不是配额了。
+	if len(cfg.Auto) == 0 {
+		cfg.Auto = []config.ModelScope{
+			{Model: "m1", Source: "up", Tier: 1},
+			{Model: "m2", Source: "up", Tier: 2},
+		}
+	}
 	c, err := core.NewFromConfig(cfg)
 	if err != nil {
 		t.Fatalf("core: %v", err)
@@ -355,8 +365,8 @@ func TestOneModelsQuotaDoesNotBlockAnother(t *testing.T) {
 		Sources: []config.Source{{
 			Name: "up", BaseURL: up.URL, Adapter: "openai",
 			Models: []config.Model{
-				{ID: "m1", Priority: 100},
-				{ID: "m2", Priority: 90},
+				{ID: "m1"},
+				{ID: "m2"},
 			},
 		}},
 	}

internal/gateway/keys.go

@@ -6,8 +6,8 @@ import (
 	"net/http"
 	"strings"
 
-	"llmsproxy/internal/config"
-	"llmsproxy/internal/scheduler"
+	"modelrouter/internal/config"
+	"modelrouter/internal/scheduler"
 )
 
 // handleKeysAPI manages gateway keys: GET /api/keys (admin: all keys),

internal/gateway/messages.go

@@ -10,9 +10,9 @@ import (
 	"strings"
 	"time"
 
-	"llmsproxy/internal/provider"
-	"llmsproxy/internal/scheduler"
-	"llmsproxy/internal/types"
+	"modelrouter/internal/provider"
+	"modelrouter/internal/scheduler"
+	"modelrouter/internal/types"
 )
 
 // handleMessages serves the Anthropic Messages protocol (POST /v1/messages).

internal/gateway/messages_test.go

@@ -11,8 +11,8 @@ import (
 	"strings"
 	"testing"
 
-	"llmsproxy/internal/config"
-	"llmsproxy/internal/core"
+	"modelrouter/internal/config"
+	"modelrouter/internal/core"
 )
 
 // 本文件端到端验证 Phase 2 的核心主张：**对外协议由适配器决定，内核只调度**。
@@ -106,7 +106,7 @@ func messagesGateway(t *testing.T) (*httptest.Server, string) {
 		Sources: []config.Source{{
 			Name: "anth", BaseURL: up.URL, Adapter: "anthropic",
 			APIKey: "k", MaxConcurrent: 4,
-			Models: []config.Model{{ID: "claude-test", Kind: "chat", Priority: 100}},
+			Models: []config.Model{{ID: "claude-test", Kind: "chat"}},
 		}},
 	}
 

internal/gateway/mount.go

@@ -21,7 +21,7 @@ import (
 	"sort"
 	"strings"
 
-	"llmsproxy/internal/lua"
+	"modelrouter/internal/lua"
 )
 
 // allowedMountPrefixes are the only namespaces a plugin/adapters may claim.

internal/gateway/mount_test.go

@@ -10,8 +10,8 @@ import (
 	"strings"
 	"testing"
 
-	"llmsproxy/internal/config"
-	"llmsproxy/internal/core"
+	"modelrouter/internal/config"
+	"modelrouter/internal/core"
 )
 
 // 本文件锁定 R3 的两条不变量：

internal/gateway/mutation_guard_test.go

@@ -0,0 +1,71 @@
+package gateway
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// 变异测试会**改写生产源码** `discover.go`（discover_mutate_test.go），
+// 靠 defer 把原文件写回。这在进程被强杀时不成立：
+//
+//   - `go test -timeout` 超时 → 测试进程被杀
+//   - Ctrl-C / 后台任务被 kill
+//   - 跑测试的 shell 被误杀（本仓真实踩过：`pkill -f` 匹配到执行它的那条命令行）
+//
+// 后果不是"这次测试没跑完"，而是**变异体被留在工作区里**：下一次运行会把
+// 它当成"原始源码"捕获，于是基线本身就是变异体，所有裁决静默失效；更糟的是
+// 开发者可能把它当成自己的改动提交上去（真实踩过两次：`b == b && b != b`
+// 这种恒假的变异体出现在 `git status` 里）。
+//
+// 兜底：每次进入本包的测试都先把已知变异体的痕迹清掉（回滚到提交版本），
+// 这样即使上一次被强杀，本次运行也不会建立在污染之上。TestRealMutants 自己
+// 也会在脏树上拒绝运行，但那是"拒绝"，这里是"自愈"。
+func TestMain(m *testing.M) {
+	restoreLeakedMutants()
+	os.Exit(m.Run())
+}
+
+// leakedMutants 列出「变异体特征 → 它对应的正确原文」。
+// 只处理能**确定判定**的形态：出现特征即说明上一次没回滚干净。
+var leakedMutants = []struct {
+	file string
+	bad  string
+	good string
+}{
+	{
+		file: "discover.go",
+		bad:  "\tif b := trimVersionSuffix(persistedBase); b == b && b != b {",
+		good: "\tif b := trimVersionSuffix(persistedBase); b != persistedBase {",
+	},
+	{
+		file: "discover.go",
+		bad:  "\t\tif len(pair) > 0 && (seenPair[pair] || seenURL[base+path]) && false {",
+		good: "\t\tif seenPair[pair] || seenURL[base+path] {",
+	},
+}
+
+func restoreLeakedMutants() {
+	wd, err := os.Getwd()
+	if err != nil {
+		return
+	}
+	for _, m := range leakedMutants {
+		p := filepath.Join(wd, m.file)
+		b, err := os.ReadFile(p)
+		if err != nil {
+			continue
+		}
+		s := string(b)
+		if !strings.Contains(s, m.bad) {
+			continue
+		}
+		// 只替换回原文，不猜别的差异 —— 保守，避免把开发中的改动一起冲掉。
+		fixed := strings.Replace(s, m.bad, m.good, 1)
+		if fixed == s {
+			continue
+		}
+		_ = os.WriteFile(p, []byte(fixed), 0o644)
+	}
+}

internal/gateway/overflow_err_test.go

@@ -6,8 +6,8 @@ import (
 	"strings"
 	"testing"
 
-	"llmsproxy/internal/scheduler"
-	"llmsproxy/internal/types"
+	"modelrouter/internal/scheduler"
+	"modelrouter/internal/types"
 )
 
 // piOverflowRe 是 @earendil-works/pi-ai 的 OVERFLOW_PATTERNS 中对应的一条。

internal/gateway/plugin_call_api_test.go

@@ -17,8 +17,8 @@ import (
 	"strings"
 	"testing"
 
-	"llmsproxy/internal/config"
-	"llmsproxy/internal/core"
+	"modelrouter/internal/config"
+	"modelrouter/internal/core"
 )
 
 // callPlugin exposes exactly one export plus a function that is NOT exported.

internal/gateway/plugin_http_routes.go

@@ -21,7 +21,7 @@ import (
 	"strconv"
 	"strings"
 
-	"llmsproxy/internal/lua"
+	"modelrouter/internal/lua"
 )
 
 // pluginHTTPPrefix is the mount point. It is deliberately narrow: a plugin's
@@ -55,6 +55,15 @@ func (g *Gateway) handlePluginHTTP(w http.ResponseWriter, r *http.Request) {
 	for i := range matches {
 		h := matches[i]
 		p, ok := matchHandlerPath(h.Path, rest)
+		if h.Prefix {
+			pattern := strings.Trim(h.Path, "/")
+			parts := strings.Split(strings.Trim(rest, "/"), "/")
+			n := len(strings.Split(pattern, "/"))
+			ok = len(parts) >= n
+			if ok {
+				p, ok = matchHandlerPath(pattern, strings.Join(parts[:n], "/"))
+			}
+		}
 		if !ok {
 			continue
 		}
@@ -116,6 +125,16 @@ func (g *Gateway) handlePluginHTTP(w http.ResponseWriter, r *http.Request) {
 		writeError(w, http.StatusBadGateway, "plugin_error", err.Error())
 		return
 	}
+	if resp.Proxy != "" {
+		if !chosen.Prefix {
+			writeError(w, http.StatusBadGateway, "plugin_error", "proxy response requires prefix=true")
+			return
+		}
+		parts := strings.Split(strings.Trim(rest, "/"), "/")
+		n := len(strings.Split(strings.Trim(chosen.Path, "/"), "/"))
+		g.servePluginProxy(w, r, resp.Proxy, pluginHTTPPrefix+strings.Join(parts[:n], "/"))
+		return
+	}
 	lua.WriteHandlerResponse(w, resp)
 }
 

internal/gateway/plugin_proxy.go

@@ -0,0 +1,54 @@
+package gateway
+
+import (
+	"net"
+	"net/http"
+	"net/http/httputil"
+	"net/url"
+	"strings"
+)
+
+// servePluginProxy forwards a plugin-owned prefix to an explicit loopback
+// origin. No destination or path may be supplied by the client. Authentication
+// and endpoint authorization have already completed before this is called.
+func (g *Gateway) servePluginProxy(w http.ResponseWriter, r *http.Request, target, prefix string) {
+	u, err := url.Parse(target)
+	if err != nil || u.Scheme != "http" || u.User != nil || u.RawQuery != "" || u.Fragment != "" || (u.Path != "" && u.Path != "/") {
+		writeError(w, http.StatusBadGateway, "plugin_proxy", "proxy must name a loopback HTTP origin")
+		return
+	}
+	ip := net.ParseIP(u.Hostname())
+	if ip == nil || !ip.IsLoopback() || u.Port() == "" {
+		writeError(w, http.StatusBadGateway, "plugin_proxy", "proxy requires a literal loopback address and port")
+		return
+	}
+	// WebSocket requests are browser-initiated and carry ambient cookies. Do not
+	// allow a foreign website to use an administrator's session to open a tunnel.
+	if origin := r.Header.Get("Origin"); origin != "" {
+		o, e := url.Parse(origin)
+		if e != nil || !strings.EqualFold(o.Host, r.Host) {
+			writeError(w, http.StatusForbidden, "forbidden", "cross-origin proxy request refused")
+			return
+		}
+	}
+	proxy := httputil.NewSingleHostReverseProxy(u)
+	director := proxy.Director
+	proxy.Director = func(out *http.Request) {
+		director(out)
+		out.URL.Path = strings.TrimPrefix(r.URL.Path, prefix)
+		if out.URL.Path == "" {
+			out.URL.Path = "/"
+		}
+		out.URL.RawPath = ""
+		out.Host = u.Host
+		out.Header.Del("Authorization")
+		out.Header.Del("Cookie")
+		q := out.URL.Query()
+		q.Del("api_key")
+		out.URL.RawQuery = q.Encode()
+	}
+	proxy.ErrorHandler = func(w http.ResponseWriter, r *http.Request, err error) {
+		writeError(w, http.StatusBadGateway, "plugin_proxy", "plugin service unavailable")
+	}
+	proxy.ServeHTTP(w, r)
+}

internal/gateway/plugin_proxy_security_test.go

@@ -0,0 +1,66 @@
+package gateway
+
+import (
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+)
+
+func TestPluginProxyRejectsUnsafeTargetsAndOrigin(t *testing.T) {
+	g, _ := gatewayWithSpy(t)
+	for _, target := range []string{"http://example.com:80", "http://localhost:80", "https://127.0.0.1:80", "http://127.0.0.1", "http://u:p@127.0.0.1:80", "http://127.0.0.1:80/path", "http://127.0.0.1:80/?x=1"} {
+		rr := httptest.NewRecorder()
+		g.servePluginProxy(rr, httptest.NewRequest("GET", "http://gateway/api/plugins/http/relay/s/live.js", nil), target, "/api/plugins/http/relay/s")
+		if rr.Code != 502 {
+			t.Errorf("unsafe target %q accepted: %d", target, rr.Code)
+		}
+	}
+	rr := httptest.NewRecorder()
+	req := httptest.NewRequest("GET", "http://gateway/api/plugins/http/relay/s/websockify", nil)
+	req.Header.Set("Origin", "https://evil.example")
+	g.servePluginProxy(rr, req, "http://127.0.0.1:12345", "/api/plugins/http/relay/s")
+	if rr.Code != 403 {
+		t.Fatalf("foreign origin accepted: %d", rr.Code)
+	}
+}
+
+func TestPluginPrefixProxyAuthorizationAndRevocation(t *testing.T) {
+	backend := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { t.Error("denied request reached backend") }))
+	defer backend.Close()
+	g, _ := gatewayWithSpy(t)
+	src := `local p={name="relaydeny",http={{path="relaydeny/:session",prefix=true,roles={"admin"},handler="proxy"}}}
+ function p.proxy(req) return {status=404,body="expired session"} end
+ return p`
+	if err := g.core.Plugins().LoadSource("relaydeny", src); err != nil {
+		t.Fatal(err)
+	}
+	server := httptest.NewServer(g.Handler())
+	defer server.Close()
+	for _, tc := range []struct {
+		path, key string
+		status    int
+	}{
+		{"/api/plugins/http/relaydeny/expired/vnc.html", "", 401},
+		{"/api/plugins/http/relaydeny/expired/vnc.html", "sk-test", 404},
+		{"/api/plugins/http/relaydeny-not-a-child/expired/vnc.html", "sk-test", 404},
+	} {
+		req, _ := http.NewRequest("GET", server.URL+tc.path, nil)
+		if tc.key != "" {
+			req.Header.Set("Authorization", "Bearer "+tc.key)
+		}
+		resp, err := http.DefaultClient.Do(req)
+		if err != nil {
+			t.Fatal(err)
+		}
+		b, _ := io.ReadAll(resp.Body)
+		resp.Body.Close()
+		if resp.StatusCode != tc.status {
+			t.Fatalf("%s got %d %s", tc.path, resp.StatusCode, b)
+		}
+		if tc.key != "" && strings.Contains(tc.path, "/expired/") && strings.Contains(tc.path, "/relaydeny/") && string(b) != "expired session" {
+			t.Fatalf("revocation response=%s", b)
+		}
+	}
+}

internal/gateway/plugin_proxy_test.go

@@ -0,0 +1,82 @@
+package gateway
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+)
+
+// Drive the real authenticated plugin route, including the access-log wrapper.
+// A successful static request alone does not prove WebSocket can upgrade.
+func TestPluginPrefixProxyHTTPAndUpgrade(t *testing.T) {
+	backend := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Header.Get("Authorization") != "" || r.Header.Get("Cookie") != "" || r.URL.Query().Get("api_key") != "" {
+			t.Error("gateway credentials leaked to plugin backend")
+		}
+		if r.URL.Path == "/websockify" {
+			c, b, err := w.(http.Hijacker).Hijack()
+			if err != nil {
+				t.Error(err)
+				return
+			}
+			defer c.Close()
+			fmt.Fprint(b, "HTTP/1.1 101 Switching Protocols\r\nConnection: Upgrade\r\nUpgrade: websocket\r\n\r\n")
+			b.Flush()
+			io.Copy(c, c)
+			return
+		}
+		fmt.Fprint(w, r.URL.Path+"?"+r.URL.RawQuery)
+	}))
+	defer backend.Close()
+	g, _ := gatewayWithSpy(t)
+	src := fmt.Sprintf(`local p={name="relay",http={{path="relay/:session",prefix=true,method="GET",roles={"admin"},handler="proxy"}}}
+ function p.proxy(req)
+ if req.params.session ~= "live" then return {status=404,body="expired"} end
+ return {proxy=%q}
+ end
+ return p`, backend.URL)
+	if err := g.core.Plugins().LoadSource("relay", src); err != nil {
+		t.Fatal(err)
+	}
+	server := httptest.NewServer(g.Handler())
+	defer server.Close()
+	req, _ := http.NewRequest("GET", server.URL+"/api/plugins/http/relay/live/app/main.js?x=1&api_key=sk-test", nil)
+	req.Header.Set("Authorization", "Bearer sk-test")
+	req.AddCookie(&http.Cookie{Name: "gw_key", Value: "sk-test"})
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	body, _ := io.ReadAll(resp.Body)
+	resp.Body.Close()
+	if resp.StatusCode != 200 || string(body) != "/app/main.js?x=1" {
+		t.Fatalf("HTTP proxy: %d %s", resp.StatusCode, body)
+	}
+	c, err := net.Dial("tcp", strings.TrimPrefix(server.URL, "http://"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer c.Close()
+	fmt.Fprintf(c, "GET /api/plugins/http/relay/live/websockify HTTP/1.1\r\nHost: %s\r\nAuthorization: Bearer sk-test\r\nConnection: Upgrade\r\nUpgrade: websocket\r\n\r\n", strings.TrimPrefix(server.URL, "http://"))
+	b := bufio.NewReader(c)
+	reply, err := http.ReadResponse(b, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if reply.StatusCode != 101 {
+		t.Fatalf("upgrade failed: %s", reply.Status)
+	}
+	c.Write([]byte("ping"))
+	got := make([]byte, 4)
+	if _, err = io.ReadFull(b, got); err != nil {
+		t.Fatal(err)
+	}
+	if string(got) != "ping" {
+		t.Fatalf("tunnel payload=%q", got)
+	}
+}

internal/gateway/plugin_wiring_test.go

@@ -9,8 +9,8 @@ import (
 	"strings"
 	"testing"
 
-	"llmsproxy/internal/config"
-	"llmsproxy/internal/core"
+	"modelrouter/internal/config"
+	"modelrouter/internal/core"
 )
 
 // newFailingServer serves handler and returns its test server.

internal/gateway/plugins_api.go

@@ -9,7 +9,7 @@ import (
 	"path/filepath"
 	"strings"
 
-	"llmsproxy/internal/lua"
+	"modelrouter/internal/lua"
 )
 
 var (
@@ -169,7 +169,7 @@ func (g *Gateway) handlePluginsAPI(w http.ResponseWriter, r *http.Request) {
 	}
 
 	// /api/plugins/{name}/login — REMOVED. Login sessions are plugin domain:
-	// channels.lua owns its own session state and serves it through its own
+	// A plugin owns its own session state and serves it through its own
 	// mount. The kernel has no login concept.
 
 	// /api/plugins/{name}/call/{fn}

internal/gateway/plugins_api_test.go

@@ -9,9 +9,9 @@ import (
 	"strings"
 	"testing"
 
-	"llmsproxy/internal/config"
-	"llmsproxy/internal/core"
-	"llmsproxy/internal/lua"
+	"modelrouter/internal/config"
+	"modelrouter/internal/core"
+	"modelrouter/internal/lua"
 )
 
 // gatewayWithBilling boots a gateway with the bundled billing plugin loaded, so

internal/gateway/serializer.go

@@ -29,9 +29,9 @@ import (
 	"sync/atomic"
 	"time"
 
-	"llmsproxy/internal/lua"
-	"llmsproxy/internal/provider"
-	"llmsproxy/internal/types"
+	"modelrouter/internal/lua"
+	"modelrouter/internal/provider"
+	"modelrouter/internal/types"
 )
 
 // StreamState 是一个流会话在序列化侧的累积状态（角色前导是否已发、已见

internal/gateway/serializer_test.go

@@ -8,8 +8,8 @@ import (
 	"sync"
 	"testing"
 
-	"llmsproxy/internal/lua"
-	"llmsproxy/internal/types"
+	"modelrouter/internal/lua"
+	"modelrouter/internal/types"
 )
 
 // 本文件锁定对外序列化的**优先级契约**：

internal/gateway/server.go

@@ -18,8 +18,8 @@ import (
 	"sync"
 	"time"
 
-	"llmsproxy/internal/config"
-	"llmsproxy/internal/core"
+	"modelrouter/internal/config"
+	"modelrouter/internal/core"
 )
 
 //go:embed ui/*
@@ -187,6 +187,10 @@ type statusRecorder struct {
 	code int
 }
 
+// Unwrap preserves optional writer capabilities (notably Hijack for WebSocket)
+// through the access-log middleware via http.ResponseController.
+func (s *statusRecorder) Unwrap() http.ResponseWriter { return s.ResponseWriter }
+
 func (s *statusRecorder) WriteHeader(code int) {
 	if s.code == 0 {
 		s.code = code
@@ -243,11 +247,6 @@ func (g *Gateway) routes(w http.ResponseWriter, r *http.Request) {
 		g.handleSourceTemplatesAPI(w, r)
 	case r.URL.Path == "/api/ui-inject" || strings.HasPrefix(r.URL.Path, "/api/ui-inject/"):
 		g.handlePluginUI(w, r)
-	case r.URL.Path == "/api/plugins/billing/rules":
-		// Checked BEFORE the generic /api/plugins/ prefix: the plugin router
-		// treats anything after the name as a plugin sub-resource and would
-		// 404 on "rules" instead of reaching the billing editor.
-		g.handleBillingRules(w, r)
 	case strings.HasPrefix(r.URL.Path, pluginHTTPPrefix):
 		// Before the generic plugin router: these paths belong to a PLUGIN, not to
 		// the plugin manager, and "http" is a valid sub-resource name otherwise.

internal/gateway/source_fields_test.go

@@ -9,8 +9,8 @@ import (
 	"testing"
 	"time"
 
-	"llmsproxy/internal/config"
-	"llmsproxy/internal/core"
+	"modelrouter/internal/config"
+	"modelrouter/internal/core"
 )
 
 // This file covers the second round of the same class of defect bf0657b fixed.

internal/gateway/sources_api_test.go

@@ -9,7 +9,7 @@ import (
 	"strings"
 	"testing"
 
-	"llmsproxy/internal/config"
+	"modelrouter/internal/config"
 )
 
 // These cover the two write-path defects found while adding a model to a live
@@ -71,11 +71,6 @@ func TestSourcePutUpdatesSource(t *testing.T) {
 			continue
 		}
 		found = true
-		for _, m := range s.Models {
-			if m.ID == "m-one" && m.Priority != 42 {
-				t.Fatalf("priority not applied: %+v", s.Models)
-			}
-		}
 	}
 	if !found {
 		t.Fatal("source vanished after PUT")