llm-simple-router 0.1.0

package/.env.example

@@ -0,0 +1,13 @@
+# 必需配置
+ADMIN_PASSWORD=admin123
+ENCRYPTION_KEY=0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef
+JWT_SECRET=0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef
+
+# 可选配置
+PORT=3000
+DB_PATH=./data/router.db
+LOG_LEVEL=info
+TZ=Asia/Shanghai
+STREAM_TIMEOUT_MS=3000000
+RETRY_MAX_ATTEMPTS=3
+RETRY_BASE_DELAY_MS=1000

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ZzzzSsssWwww
+
+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.

package/README.md

@@ -0,0 +1,121 @@
+# LLM Simple Router
+
+> **Status: Active Development**
+>
+> 核心代理、模型映射、自动重试、多密钥管理、请求日志、性能指标已完成。
+> 代码规范 githook 检查已集成。欢迎试用和反馈。
+
+## 解决的核心问题
+
+个人使用 Claude Code 配合国产模型时的实际痛点：
+
+- **自动重试** — 国产模型限流、网络错误频繁，对可恢复错误（429/500/网络超时）自动指数退避重试
+- **多供应商模型映射** — 高峰期主模型不可用时，将 claude-opus 映射到 GLM，claude-sonnet 映射到 Kimi 等，低谷期再切回来
+- **多密钥隔离** — 为不同使用方分配独立密钥，按密钥筛选日志和性能指标
+
+## 功能
+
+| 功能 | 说明 |
+|------|------|
+| 模型映射 | 客户端模型名 -> 后端模型名 + 供应商，支持分组和优先级 |
+| 自动重试 | 429/500/网络错误自动重试，指数退避，可配置次数和间隔 |
+| 多供应商 | 配置多个后端供应商，按模型映射路由 |
+| 多密钥 (Router Keys) | 为不同使用方创建独立密钥，支持模型白名单 |
+| 流式代理 | 完整支持 SSE 流式和非流式请求 |
+| 管理后台 | Vue 3 + shadcn-vue Web UI，管理供应商、映射、密钥 |
+| 请求日志 | 结构化展示完整四阶段链路（客户端请求/上游请求/上游响应/客户端响应），适配 Claude Code 请求格式 |
+| 性能指标 | TTFT、吞吐量、Token 用量、缓存命中率，支持按模型/密钥筛选 |
+
+> **API 兼容性：** 支持 Anthropic 兼容 API（已适配 Claude Code）。OpenAI 兼容 API（`/v1/chat/completions`）尚未充分测试。
+
+## 管理后台预览
+
+| Dashboard | Provider 管理 |
+|-----------|-------------|
+| ![Dashboard](docs/screenshot/dashboard.png) | ![Provider](docs/screenshot/provider.png) |
+
+| 模型映射 | 重试规则 |
+|---------|--------|
+| ![Model Mapping](docs/screenshot/model_mapping.png) | ![Retry](docs/screenshot/retry.png) |
+
+| 请求日志 |
+|---------|
+| ![Logs](docs/screenshot/log.png) |
+
+## 工作原理
+
+```
+Claude Code -> Router (模型映射 + 自动重试) -> 智谱 GLM / Kimi / 其他供应商
+```
+
+Router 根据模型映射找到后端供应商 -> 转发请求 -> 自动重试失败请求 -> 记录日志和性能指标 -> 返回响应。
+
+## 典型使用场景
+
+### Claude Code 配置
+
+通过环境变量将 Claude Code 指向 Router：
+
+**方式一：shell alias（推荐）**
+
+```bash
+alias clodedev='ANTHROPIC_AUTH_TOKEN="<your-router-key>" ANTHROPIC_BASE_URL="http://127.0.0.1:3000" claude'
+```
+
+**方式二：~/.claude/settings.json**
+
+```json
+{
+  "env": {
+    "ANTHROPIC_AUTH_TOKEN": "sk-router-change-me",
+    "ANTHROPIC_BASE_URL": "http://127.0.0.1:3000",
+    "ANTHROPIC_MODEL": "some-model"
+  }
+}
+```
+
+将 `<your-router-key>` 替换为管理后台中创建的 Router Key。
+
+### 管理后台配置模型映射
+
+| 客户端模型 | 后端模型 | 供应商 | 时间窗口 |
+|-----------|---------|--------|---------|
+| opus | glm-5.1 | 智谱 | / |
+| sonnet | glm-5.1 | 智谱 | / |
+| sonnet | kimi-for-coding | Moonshot | 14:00-18:00 |
+| sonnet | glm-5-turbo | 智谱 | / |
+
+高峰期 GLM 3倍用量，且频繁超限时，将 sonnet 切到 Kimi；低谷期切回 GLM。
+
+## 快速开始
+
+```bash
+npm install
+cp .env.example .env
+# 编辑 .env，设置 ADMIN_PASSWORD、ENCRYPTION_KEY、JWT_SECRET
+npm run dev
+# 访问 http://localhost:3000/admin
+```
+
+生成随机密钥：`openssl rand -hex 32`
+
+## Docker 部署
+
+```bash
+docker compose up -d
+```
+
+## 环境变量
+
+| 变量 | 必需 | 默认值 | 说明 |
+|------|------|--------|------|
+| `ADMIN_PASSWORD` | Yes | -- | 管理后台密码 |
+| `ENCRYPTION_KEY` | Yes | -- | AES-256-GCM 密钥（64字符 hex） |
+| `JWT_SECRET` | Yes | -- | JWT 签名密钥（64字符 hex） |
+| `PORT` | No | `3000` | 服务端口 |
+| `DB_PATH` | No | `./data/router.db` | SQLite 数据库路径 |
+| `LOG_LEVEL` | No | `info` | 日志级别 |
+| `TZ` | No | -- | 时区设置 |
+| `STREAM_TIMEOUT_MS` | No | `3000000` | 流式代理空闲超时（ms） |
+| `RETRY_MAX_ATTEMPTS` | No | `3` | 最大重试次数 |
+| `RETRY_BASE_DELAY_MS` | No | `1000` | 重试基础延迟（ms） |

package/dist/admin/constants.d.ts

@@ -0,0 +1,10 @@
+import type { FastifyReply } from "fastify";
+export declare const HTTP_BAD_REQUEST = 400;
+export declare const HTTP_CREATED = 201;
+export declare const HTTP_FORBIDDEN = 403;
+export declare const HTTP_NOT_FOUND = 404;
+export declare const HTTP_CONFLICT = 409;
+export declare const HTTP_INTERNAL_ERROR = 500;
+export declare const HTTP_BAD_GATEWAY = 502;
+export declare const HTTP_SERVICE_UNAVAILABLE = 503;
+export declare function sendErrorResponse(reply: FastifyReply, statusCode: number, message: string): FastifyReply<import("fastify").RouteGenericInterface, import("fastify").RawServerDefault, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, unknown, import("fastify").FastifySchema, import("fastify").FastifyTypeProviderDefault, unknown>;

package/dist/admin/constants.js

@@ -0,0 +1,11 @@
+export const HTTP_BAD_REQUEST = 400;
+export const HTTP_CREATED = 201;
+export const HTTP_FORBIDDEN = 403;
+export const HTTP_NOT_FOUND = 404;
+export const HTTP_CONFLICT = 409;
+export const HTTP_INTERNAL_ERROR = 500;
+export const HTTP_BAD_GATEWAY = 502;
+export const HTTP_SERVICE_UNAVAILABLE = 503;
+export function sendErrorResponse(reply, statusCode, message) {
+    return reply.code(statusCode).send({ error: { message } });
+}

package/dist/admin/groups.d.ts

@@ -0,0 +1,7 @@
+import { FastifyPluginCallback } from "fastify";
+import Database from "better-sqlite3";
+interface GroupRoutesOptions {
+    db: Database.Database;
+}
+export declare const adminGroupRoutes: FastifyPluginCallback<GroupRoutesOptions>;
+export {};

package/dist/admin/groups.js

@@ -0,0 +1,118 @@
+import { Type } from "@sinclair/typebox";
+import { getAllMappingGroups, createMappingGroup, updateMappingGroup, deleteMappingGroup, getProviderById, getMappingGroupById, } from "../db/index.js";
+import { STRATEGY_NAMES } from "../proxy/strategy/types.js";
+import { HTTP_BAD_REQUEST, HTTP_CREATED, HTTP_CONFLICT } from "./constants.js";
+const CreateGroupSchema = Type.Object({
+    client_model: Type.String({ minLength: 1 }),
+    strategy: Type.String({ minLength: 1 }),
+    rule: Type.String(),
+});
+const UpdateGroupSchema = Type.Object({
+    client_model: Type.Optional(Type.String({ minLength: 1 })),
+    strategy: Type.Optional(Type.String({ minLength: 1 })),
+    rule: Type.Optional(Type.String()),
+});
+async function validateRule(db, strategy, ruleJson) {
+    let rule;
+    try {
+        rule = JSON.parse(ruleJson);
+    }
+    catch {
+        return "Invalid rule JSON";
+    }
+    if (strategy === STRATEGY_NAMES.SCHEDULED) {
+        const r = rule;
+        if (!r.default || !r.default.backend_model || !r.default.provider_id) {
+            return "rule.default.backend_model and rule.default.provider_id are required";
+        }
+        const defaultProvider = getProviderById(db, r.default.provider_id);
+        if (!defaultProvider) {
+            return `provider_id '${r.default.provider_id}' not found`;
+        }
+        if (r.windows !== undefined && !Array.isArray(r.windows)) {
+            return "rule.windows must be an array";
+        }
+        if (Array.isArray(r.windows)) {
+            for (let i = 0; i < r.windows.length; i++) {
+                const w = r.windows[i];
+                if (!w.start || !w.end || !w.target || !w.target.backend_model || !w.target.provider_id) {
+                    return `window[${i}] missing start/end/target.backend_model/target.provider_id`;
+                }
+                const p = getProviderById(db, w.target.provider_id);
+                if (!p) {
+                    return `window[${i}] provider_id '${w.target.provider_id}' not found`;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+export const adminGroupRoutes = (app, options, done) => {
+    const { db } = options;
+    app.get("/admin/api/mapping-groups", async (_request, reply) => {
+        const groups = getAllMappingGroups(db);
+        return reply.send(groups);
+    });
+    app.post("/admin/api/mapping-groups", { schema: { body: CreateGroupSchema } }, async (request, reply) => {
+        const body = request.body;
+        const validationError = await validateRule(db, body.strategy, body.rule);
+        if (validationError) {
+            return reply.code(HTTP_BAD_REQUEST).send({ error: { message: validationError } });
+        }
+        try {
+            const id = createMappingGroup(db, {
+                client_model: body.client_model,
+                strategy: body.strategy,
+                rule: body.rule,
+            });
+            return reply.code(HTTP_CREATED).send({ id });
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.includes("UNIQUE constraint")) {
+                return reply.code(HTTP_CONFLICT).send({ error: { message: "client_model already exists" } });
+            }
+            throw err;
+        }
+    });
+    app.put("/admin/api/mapping-groups/:id", { schema: { body: UpdateGroupSchema } }, async (request, reply) => {
+        const { id } = request.params;
+        const body = request.body;
+        const fields = {};
+        if (body.client_model !== undefined)
+            fields.client_model = body.client_model;
+        if (body.strategy !== undefined)
+            fields.strategy = body.strategy;
+        if (body.rule !== undefined)
+            fields.rule = body.rule;
+        const strategy = body.strategy ?? findGroupStrategy(db, id);
+        const ruleJson = body.rule ?? findGroupRule(db, id);
+        const validationError = await validateRule(db, strategy, ruleJson);
+        if (validationError) {
+            return reply.code(HTTP_BAD_REQUEST).send({ error: { message: validationError } });
+        }
+        try {
+            updateMappingGroup(db, id, fields);
+            return reply.send({ success: true });
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.includes("UNIQUE constraint")) {
+                return reply.code(HTTP_CONFLICT).send({ error: { message: "client_model already exists" } });
+            }
+            throw err;
+        }
+    });
+    app.delete("/admin/api/mapping-groups/:id", async (request, reply) => {
+        const { id } = request.params;
+        deleteMappingGroup(db, id);
+        return reply.send({ success: true });
+    });
+    done();
+};
+function findGroupStrategy(db, id) {
+    const g = getMappingGroupById(db, id);
+    return g?.strategy ?? STRATEGY_NAMES.SCHEDULED;
+}
+function findGroupRule(db, id) {
+    const g = getMappingGroupById(db, id);
+    return g?.rule ?? "{}";
+}

package/dist/admin/logs.d.ts

@@ -0,0 +1,7 @@
+import { FastifyPluginCallback } from "fastify";
+import Database from "better-sqlite3";
+interface LogRoutesOptions {
+    db: Database.Database;
+}
+export declare const adminLogRoutes: FastifyPluginCallback<LogRoutesOptions>;
+export {};

package/dist/admin/logs.js

@@ -0,0 +1,43 @@
+import { Type } from "@sinclair/typebox";
+import { getRequestLogs, getRequestLogById, deleteLogsBefore } from "../db/index.js";
+import { HTTP_NOT_FOUND } from "./constants.js";
+const LogQuerySchema = Type.Object({
+    page: Type.Optional(Type.String()),
+    limit: Type.Optional(Type.String()),
+    api_type: Type.Optional(Type.String()),
+    model: Type.Optional(Type.String()),
+    router_key_id: Type.Optional(Type.String()),
+});
+const DeleteLogsBeforeSchema = Type.Object({
+    before: Type.String({ minLength: 1 }),
+});
+export const adminLogRoutes = (app, options, done) => {
+    const { db } = options;
+    app.get("/admin/api/logs", { schema: { querystring: LogQuerySchema } }, async (request, reply) => {
+        const query = request.query;
+        const page = parseInt(query.page || "1", 10);
+        const limit = parseInt(query.limit || "20", 10);
+        const result = getRequestLogs(db, {
+            page,
+            limit,
+            api_type: query.api_type || undefined,
+            model: query.model || undefined,
+            router_key_id: query.router_key_id || undefined,
+        });
+        return reply.send({ ...result, page, limit });
+    });
+    app.get("/admin/api/logs/:id", async (request, reply) => {
+        const params = request.params;
+        const log = getRequestLogById(db, params.id);
+        if (!log) {
+            return reply.code(HTTP_NOT_FOUND).send({ error: { message: "Log not found" } });
+        }
+        return reply.send(log);
+    });
+    app.delete("/admin/api/logs/before", { schema: { body: DeleteLogsBeforeSchema } }, async (request, reply) => {
+        const body = request.body;
+        const deleted = deleteLogsBefore(db, body.before);
+        return reply.send({ deleted });
+    });
+    done();
+};

package/dist/admin/mappings.d.ts

@@ -0,0 +1,7 @@
+import { FastifyPluginCallback } from "fastify";
+import Database from "better-sqlite3";
+interface MappingRoutesOptions {
+    db: Database.Database;
+}
+export declare const adminMappingRoutes: FastifyPluginCallback<MappingRoutesOptions>;
+export {};

package/dist/admin/mappings.js

@@ -0,0 +1,120 @@
+import { Type } from "@sinclair/typebox";
+import { getAllMappingGroups, createMappingGroup, updateMappingGroup, deleteMappingGroup, getProviderById, getMappingGroupById, getMappingGroup, } from "../db/index.js";
+import { STRATEGY_NAMES } from "../proxy/strategy/types.js";
+import { HTTP_BAD_REQUEST, HTTP_CREATED, HTTP_NOT_FOUND, HTTP_CONFLICT } from "./constants.js";
+const CreateMappingSchema = Type.Object({
+    client_model: Type.String({ minLength: 1 }),
+    backend_model: Type.String({ minLength: 1 }),
+    provider_id: Type.String({ minLength: 1 }),
+});
+const UpdateMappingSchema = Type.Object({
+    client_model: Type.Optional(Type.String({ minLength: 1 })),
+    backend_model: Type.Optional(Type.String({ minLength: 1 })),
+    provider_id: Type.Optional(Type.String({ minLength: 1 })),
+});
+function toLegacy(group) {
+    let rule;
+    try {
+        rule = JSON.parse(group.rule);
+    }
+    catch {
+        return null;
+    }
+    const defaultTarget = rule?.default;
+    if (!defaultTarget)
+        return null;
+    return {
+        id: group.id,
+        client_model: group.client_model,
+        backend_model: defaultTarget.backend_model ?? "",
+        provider_id: defaultTarget.provider_id ?? "",
+        is_active: 1,
+        created_at: group.created_at,
+    };
+}
+function findGroupByIdOrClientModel(db, id) {
+    return getMappingGroupById(db, id) ?? getMappingGroup(db, id);
+}
+export const adminMappingRoutes = (app, options, done) => {
+    const { db } = options;
+    app.get("/admin/api/mappings", async (_request, reply) => {
+        const groups = getAllMappingGroups(db);
+        const legacy = groups.map(toLegacy).filter((m) => m !== null);
+        return reply.send(legacy);
+    });
+    app.post("/admin/api/mappings", { schema: { body: CreateMappingSchema } }, async (request, reply) => {
+        const body = request.body;
+        const provider = getProviderById(db, body.provider_id);
+        if (!provider) {
+            return reply.code(HTTP_BAD_REQUEST).send({ error: { message: "provider_id not found" } });
+        }
+        try {
+            const id = createMappingGroup(db, {
+                client_model: body.client_model,
+                strategy: STRATEGY_NAMES.SCHEDULED,
+                rule: JSON.stringify({
+                    default: { backend_model: body.backend_model, provider_id: body.provider_id },
+                    windows: [],
+                }),
+            });
+            return reply.code(HTTP_CREATED).send({ id });
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.includes("UNIQUE constraint")) {
+                return reply.code(HTTP_CONFLICT).send({ error: { message: "client_model already exists" } });
+            }
+            throw err;
+        }
+    });
+    app.put("/admin/api/mappings/:id", { schema: { body: UpdateMappingSchema } }, async (request, reply) => {
+        const { id } = request.params;
+        const group = findGroupByIdOrClientModel(db, id);
+        if (!group) {
+            return reply.code(HTTP_NOT_FOUND).send({ error: { message: "Mapping not found" } });
+        }
+        const body = request.body;
+        let rule;
+        try {
+            rule = JSON.parse(group.rule);
+        }
+        catch {
+            rule = { default: {}, windows: [] };
+        }
+        const defaultTarget = { ...(rule.default || {}) };
+        if (body.backend_model !== undefined)
+            defaultTarget.backend_model = body.backend_model;
+        if (body.provider_id !== undefined) {
+            const provider = getProviderById(db, body.provider_id);
+            if (!provider) {
+                return reply.code(HTTP_BAD_REQUEST).send({ error: { message: "provider_id not found" } });
+            }
+            defaultTarget.provider_id = body.provider_id;
+        }
+        rule.default = defaultTarget;
+        const fields = {
+            rule: JSON.stringify(rule),
+        };
+        if (body.client_model !== undefined)
+            fields.client_model = body.client_model;
+        try {
+            updateMappingGroup(db, group.id, fields);
+            return reply.send({ success: true });
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.includes("UNIQUE constraint")) {
+                return reply.code(HTTP_CONFLICT).send({ error: { message: "client_model already exists" } });
+            }
+            throw err;
+        }
+    });
+    app.delete("/admin/api/mappings/:id", async (request, reply) => {
+        const { id } = request.params;
+        const group = findGroupByIdOrClientModel(db, id);
+        if (!group) {
+            return reply.code(HTTP_NOT_FOUND).send({ error: { message: "Mapping not found" } });
+        }
+        deleteMappingGroup(db, group.id);
+        return reply.send({ success: true });
+    });
+    done();
+};

package/dist/admin/metrics.d.ts

@@ -0,0 +1,7 @@
+import { FastifyPluginCallback } from "fastify";
+import Database from "better-sqlite3";
+interface MetricsRoutesOptions {
+    db: Database.Database;
+}
+export declare const adminMetricsRoutes: FastifyPluginCallback<MetricsRoutesOptions>;
+export {};

package/dist/admin/metrics.js

@@ -0,0 +1,41 @@
+import { Type } from "@sinclair/typebox";
+import { getMetricsSummary, getMetricsTimeseries } from "../db/index.js";
+const PeriodEnum = Type.Union([
+    Type.Literal("1h"), Type.Literal("6h"), Type.Literal("24h"),
+    Type.Literal("7d"), Type.Literal("30d"),
+]);
+const MetricEnum = Type.Union([
+    Type.Literal("ttft"), Type.Literal("tps"), Type.Literal("tokens"),
+    Type.Literal("cache_rate"), Type.Literal("request_count"),
+    Type.Literal("input_tokens"), Type.Literal("output_tokens"),
+    Type.Literal("cache_hit_tokens"),
+]);
+const SummaryQuerySchema = Type.Object({
+    period: Type.Optional(PeriodEnum),
+    provider_id: Type.Optional(Type.String()),
+    backend_model: Type.Optional(Type.String()),
+    router_key_id: Type.Optional(Type.String()),
+});
+const TimeseriesQuerySchema = Type.Object({
+    period: Type.Optional(PeriodEnum),
+    metric: MetricEnum,
+    provider_id: Type.Optional(Type.String()),
+    backend_model: Type.Optional(Type.String()),
+    router_key_id: Type.Optional(Type.String()),
+});
+export const adminMetricsRoutes = (app, options, done) => {
+    app.get("/admin/api/metrics/summary", { schema: { querystring: SummaryQuerySchema } }, async (request, reply) => {
+        const query = request.query;
+        const period = (query.period ?? "24h");
+        const summary = getMetricsSummary(options.db, period, query.provider_id, query.backend_model, query.router_key_id);
+        return reply.send(summary);
+    });
+    app.get("/admin/api/metrics/timeseries", { schema: { querystring: TimeseriesQuerySchema } }, async (request, reply) => {
+        const query = request.query;
+        const period = (query.period ?? "24h");
+        const metric = query.metric;
+        const timeseries = getMetricsTimeseries(options.db, period, metric, query.provider_id, query.backend_model, query.router_key_id);
+        return reply.send(timeseries);
+    });
+    done();
+};

package/dist/admin/providers.d.ts

@@ -0,0 +1,8 @@
+import { FastifyPluginCallback } from "fastify";
+import Database from "better-sqlite3";
+interface ProviderRoutesOptions {
+    db: Database.Database;
+    encryptionKey: string;
+}
+export declare const adminProviderRoutes: FastifyPluginCallback<ProviderRoutesOptions>;
+export {};

package/dist/admin/providers.js

@@ -0,0 +1,101 @@
+import { Type } from "@sinclair/typebox";
+import { getAllProviders, getProviderById, createProvider, updateProvider, deleteProvider, getAllMappingGroups } from "../db/index.js";
+import { encrypt } from "../utils/crypto.js";
+import { HTTP_CREATED, HTTP_NOT_FOUND, HTTP_CONFLICT } from "./constants.js";
+const API_KEY_PREVIEW_MIN_LEN = 8;
+const API_KEY_PREVIEW_PREFIX_LEN = 4;
+const CreateProviderSchema = Type.Object({
+    name: Type.String({ minLength: 1 }),
+    api_type: Type.Union([Type.Literal("openai"), Type.Literal("anthropic")]),
+    base_url: Type.String({ minLength: 1 }),
+    api_key: Type.String({ minLength: 1 }),
+    models: Type.Optional(Type.Array(Type.String())),
+    is_active: Type.Optional(Type.Number()),
+});
+const UpdateProviderSchema = Type.Object({
+    name: Type.Optional(Type.String({ minLength: 1 })),
+    api_type: Type.Optional(Type.Union([Type.Literal("openai"), Type.Literal("anthropic")])),
+    base_url: Type.Optional(Type.String({ minLength: 1 })),
+    api_key: Type.Optional(Type.String({ minLength: 1 })),
+    models: Type.Optional(Type.Array(Type.String())),
+    is_active: Type.Optional(Type.Number()),
+});
+function computeApiKeyPreview(apiKey) {
+    if (apiKey.length <= API_KEY_PREVIEW_MIN_LEN)
+        return "****";
+    return `${apiKey.slice(0, API_KEY_PREVIEW_PREFIX_LEN)}...${apiKey.slice(-API_KEY_PREVIEW_PREFIX_LEN)}`;
+}
+export const adminProviderRoutes = (app, options, done) => {
+    const { db, encryptionKey } = options;
+    app.get("/admin/api/providers", async (_request, reply) => {
+        const providers = getAllProviders(db);
+        return reply.send(providers.map((s) => ({
+            id: s.id,
+            name: s.name,
+            api_type: s.api_type,
+            base_url: s.base_url,
+            api_key_preview: s.api_key_preview || "****",
+            models: JSON.parse(s.models || "[]"),
+            is_active: s.is_active,
+            created_at: s.created_at,
+            updated_at: s.updated_at,
+        })));
+    });
+    app.post("/admin/api/providers", { schema: { body: CreateProviderSchema } }, async (request, reply) => {
+        const body = request.body;
+        const encryptedKey = encrypt(body.api_key, encryptionKey);
+        const apiKeyPreview = computeApiKeyPreview(body.api_key);
+        const id = createProvider(db, {
+            name: body.name,
+            api_type: body.api_type,
+            base_url: body.base_url,
+            api_key: encryptedKey,
+            api_key_preview: apiKeyPreview,
+            models: JSON.stringify(body.models ?? []),
+            is_active: body.is_active ?? 1,
+        });
+        return reply.code(HTTP_CREATED).send({ id });
+    });
+    app.put("/admin/api/providers/:id", { schema: { body: UpdateProviderSchema } }, async (request, reply) => {
+        const { id } = request.params;
+        const existing = getProviderById(db, id);
+        if (!existing) {
+            return reply.code(HTTP_NOT_FOUND).send({ error: { message: "Provider not found" } });
+        }
+        const body = request.body;
+        const fields = {};
+        if (body.name !== undefined)
+            fields.name = body.name;
+        if (body.api_type !== undefined)
+            fields.api_type = body.api_type;
+        if (body.base_url !== undefined)
+            fields.base_url = body.base_url;
+        if (body.is_active !== undefined)
+            fields.is_active = body.is_active;
+        if (body.models !== undefined)
+            fields.models = JSON.stringify(body.models);
+        if (body.api_key) {
+            fields.api_key = encrypt(body.api_key, encryptionKey);
+            fields.api_key_preview = computeApiKeyPreview(body.api_key);
+        }
+        updateProvider(db, id, fields);
+        return reply.send({ success: true });
+    });
+    app.delete("/admin/api/providers/:id", async (request, reply) => {
+        const { id } = request.params;
+        const groups = getAllMappingGroups(db);
+        for (const g of groups) {
+            try {
+                const rule = JSON.parse(g.rule);
+                const targets = [rule.default, ...(rule.windows || [])].filter(Boolean);
+                if (targets.some((t) => t.provider_id === id)) {
+                    return reply.code(HTTP_CONFLICT).send({ error: { message: `Provider is referenced by mapping group '${g.client_model}'` } });
+                }
+            }
+            catch { /* rule format invalid, skip */ }
+        }
+        deleteProvider(db, id);
+        return reply.send({ success: true });
+    });
+    done();
+};

package/dist/admin/retry-rules.d.ts

@@ -0,0 +1,9 @@
+import { FastifyPluginCallback } from "fastify";
+import Database from "better-sqlite3";
+import { RetryRuleMatcher } from "../proxy/retry-rules.js";
+interface RetryRuleRoutesOptions {
+    db: Database.Database;
+    matcher: RetryRuleMatcher | null;
+}
+export declare const adminRetryRuleRoutes: FastifyPluginCallback<RetryRuleRoutesOptions>;
+export {};