llm-simple-router 0.5.1 → 0.5.2

package/config/recommended-providers.json

@@ -0,0 +1,76 @@
+[
+  {
+    "group": "DeepSeek",
+    "presets": [
+      { "plan": "Anthropic", "presetName": "deepseek", "apiType": "anthropic", "baseUrl": "https://api.deepseek.com/anthropic", "models": ["deepseek-chat", "deepseek-reasoner"] },
+      { "plan": "OpenAI", "presetName": "deepseek-openai", "apiType": "openai", "baseUrl": "https://api.deepseek.com", "models": ["deepseek-chat", "deepseek-reasoner"] }
+    ]
+  },
+  {
+    "group": "百度千帆",
+    "presets": [
+      { "plan": "API", "presetName": "qianfan", "apiType": "openai", "baseUrl": "https://qianfan.baidubce.com/v2", "models": ["ernie-4.0-8k", "ernie-4.0-turbo-8k", "ernie-3.5-8k", "ernie-speed-8k", "ernie-lite-8k", "ernie-x1-32k-preview", "deepseek-v3", "deepseek-r1"] }
+    ]
+  },
+  {
+    "group": "科大讯飞",
+    "presets": [
+      { "plan": "API", "presetName": "iflytek-spark", "apiType": "openai", "baseUrl": "https://spark-api-open.xf-yun.com/v1", "models": ["4.0Ultra", "generalv3.5", "max-32k", "generalv3", "pro-128k", "lite"] }
+    ]
+  },
+  {
+    "group": "硅基流动",
+    "presets": [
+      { "plan": "API", "presetName": "siliconflow", "apiType": "openai", "baseUrl": "https://api.siliconflow.cn/v1", "models": ["deepseek-ai/DeepSeek-V3.2-Exp", "deepseek-ai/DeepSeek-R1", "Qwen/Qwen3-8B", "Qwen/Qwen2.5-72B-Instruct", "Qwen/Qwen2.5-Coder-32B-Instruct", "moonshotai/Kimi-K2-Instruct", "moonshotai/Kimi-K2.5"] }
+    ]
+  },
+  {
+    "group": "智谱",
+    "presets": [
+      { "plan": "Coding Plan", "presetName": "zhipu-coding-plan", "apiType": "anthropic", "baseUrl": "https://open.bigmodel.cn/api/anthropic", "models": ["glm-5.1", "glm-5", "glm-4.7", "glm-4.5-air"] },
+      { "plan": "API", "presetName": "zhipu", "apiType": "openai", "baseUrl": "https://open.bigmodel.cn/api/paas/v4", "models": ["glm-5.1", "glm-5", "glm-5-turbo", "glm-4.7", "glm-4.7-flash", "glm-4.6"] }
+    ]
+  },
+  {
+    "group": "KIMI",
+    "presets": [
+      { "plan": "Coding Plan", "presetName": "kimi-coding-plan", "apiType": "anthropic", "baseUrl": "https://api.kimi.com/coding", "models": ["kimi-for-coding", "kimi-k2.5"] },
+      { "plan": "API", "presetName": "kimi", "apiType": "openai", "baseUrl": "https://api.moonshot.cn", "models": ["kimi-k2.6", "kimi-k2.5", "kimi-k2-turbo-preview", "kimi-k2-thinking", "moonshot-v1-128k"] }
+    ]
+  },
+  {
+    "group": "Minimax",
+    "presets": [
+      { "plan": "Token Plan", "presetName": "minimax-token-plan", "apiType": "anthropic", "baseUrl": "https://api.minimaxi.com/anthropic", "models": ["MiniMax-M2.7"] },
+      { "plan": "API", "presetName": "minimax", "apiType": "openai", "baseUrl": "https://api.minimax.chat", "models": ["MiniMax-M2.7", "MiniMax-M2.7-highspeed", "MiniMax-M2.5", "MiniMax-M2.5-highspeed", "MiniMax-M2.1", "MiniMax-M2"] }
+    ]
+  },
+  {
+    "group": "火山引擎",
+    "presets": [
+      { "plan": "Coding Plan", "presetName": "volcengine-coding-plan", "apiType": "anthropic", "baseUrl": "https://ark.cn-beijing.volces.com/api/compatible", "models": ["ark-code-latest", "doubao-seed-2.0-code", "kimi-k2.5", "glm-4.7", "deepseek-v3.2"] },
+      { "plan": "API", "presetName": "volcengine", "apiType": "openai", "baseUrl": "https://ark.cn-beijing.volces.com/api/v3", "models": ["doubao-seed-2-0-pro-260215", "doubao-seed-1-8-251228", "doubao-seed-code-preview-251028"] }
+    ]
+  },
+  {
+    "group": "阿里云",
+    "presets": [
+      { "plan": "Coding Plan", "presetName": "aliyun-coding-plan", "apiType": "anthropic", "baseUrl": "https://coding.dashscope.aliyuncs.com/apps/anthropic", "models": ["qwen3.6-plus", "qwen3-coder-next", "qwen3-coder-plus", "kimi-k2.5", "glm-5", "MiniMax-M2.5"] },
+      { "plan": "API", "presetName": "aliyun", "apiType": "openai", "baseUrl": "https://dashscope.aliyuncs.com/compatible-mode", "models": ["qwen3.6-plus", "qwen3.5-plus", "qwen3-max", "qwen3.5-flash", "qwen3-coder-plus", "qwen3-coder-next"] }
+    ]
+  },
+  {
+    "group": "腾讯云",
+    "presets": [
+      { "plan": "Coding Plan", "presetName": "tencent-coding-plan", "apiType": "anthropic", "baseUrl": "https://api.lkeap.cloud.tencent.com/coding/anthropic", "models": ["tc-code-latest", "hunyuan-2.0-instruct", "hunyuan-2.0-thinking", "hunyuan-turbos", "hunyuan-t1", "glm-5", "kimi-k2.5"] },
+      { "plan": "API", "presetName": "tencent", "apiType": "openai", "baseUrl": "https://api.hunyuan.cloud.tencent.com", "models": ["hunyuan-2.0-thinking", "hunyuan-2.0-instruct", "hunyuan-t1-latest", "hunyuan-a13b", "hunyuan-turbos-latest"] }
+    ]
+  },
+  {
+    "group": "阶跃星辰",
+    "presets": [
+      { "plan": "Step Plan", "presetName": "stepfun-step-plan", "apiType": "anthropic", "baseUrl": "https://api.stepfun.com/step_plan", "models": ["step-3.5-flash-2603", "step-3.5-flash"] },
+      { "plan": "API", "presetName": "stepfun", "apiType": "openai", "baseUrl": "https://api.stepfun.com", "models": ["step-3.5-flash", "step-3", "step-2-mini", "step-2-16k", "step-1-8k", "step-1-32k"] }
+    ]
+  }
+]

package/config/recommended-retry-rules.json

@@ -0,0 +1,10 @@
+[
+  { "name": "429 Too Many Requests", "status_code": 429, "body_pattern": ".*", "retry_strategy": "exponential", "retry_delay_ms": 5000, "max_retries": 10, "max_delay_ms": 60000 },
+  { "name": "503 Service Unavailable", "status_code": 503, "body_pattern": ".*", "retry_strategy": "exponential", "retry_delay_ms": 5000, "max_retries": 10, "max_delay_ms": 60000 },
+  { "name": "ZAI 网络错误 (code 1234)", "status_code": 400, "body_pattern": "\"type\"\\s*:\\s*\"error\".*\"code\"\\s*:\\s*\"1234\"", "retry_strategy": "exponential", "retry_delay_ms": 5000, "max_retries": 10, "max_delay_ms": 60000 },
+  { "name": "ZAI 临时不可用", "status_code": 400, "body_pattern": "\"type\"\\s*:\\s*\"error\".*请稍后重试", "retry_strategy": "exponential", "retry_delay_ms": 5000, "max_retries": 10, "max_delay_ms": 60000 },
+  { "name": "ZAI 操作失败 (code 500)", "status_code": 400, "body_pattern": "\"type\"\\s*:\\s*\"error\".*\"code\"\\s*:\\s*\"500\"", "retry_strategy": "exponential", "retry_delay_ms": 5000, "max_retries": 10, "max_delay_ms": 60000 },
+  { "name": "ZAI 速率限制 (HTTP 200, code 1302)", "status_code": 200, "body_pattern": "\"error\".*\"code\"\\s*:\\s*\"1302\"", "retry_strategy": "exponential", "retry_delay_ms": 5000, "max_retries": 10, "max_delay_ms": 60000 },
+  { "name": "ZAI SSE 错误 (HTTP 200, code 500)", "status_code": 200, "body_pattern": "\"error\".*\"code\"\\s*:\\s*\"500\"", "retry_strategy": "exponential", "retry_delay_ms": 5000, "max_retries": 10, "max_delay_ms": 60000 },
+  { "name": "ZAI SSE 错误 (HTTP 200, code 1234)", "status_code": 200, "body_pattern": "\"error\".*\"code\"\\s*:\\s*\"1234\"", "retry_strategy": "exponential", "retry_delay_ms": 5000, "max_retries": 10, "max_delay_ms": 60000 }
+]

package/dist/admin/api-response.d.ts

@@ -0,0 +1,27 @@
+/** 统一信封格式 */
+export interface ApiResponse<T> {
+    code: number;
+    message: string;
+    data: T | null;
+}
+/** 错误码常量 — XXYYZ 格式：前两位=HTTP 类别，后三位=业务序号 */
+export declare const API_CODE: {
+    readonly SUCCESS: 0;
+    readonly BAD_REQUEST: 40001;
+    readonly VALIDATION_FAILED: 40002;
+    readonly INVALID_REGEX: 40003;
+    readonly WRONG_PASSWORD: 40101;
+    readonly TOKEN_INVALID: 40102;
+    readonly NOT_INITIALIZED: 40103;
+    readonly NOT_FOUND: 40401;
+    readonly CONFLICT_NAME: 40901;
+    readonly CONFLICT_REFERENCED: 40902;
+    readonly ALREADY_INITIALIZED: 40903;
+    readonly INTERNAL_ERROR: 50001;
+};
+/** HTTP status → 默认 API_CODE 映射（errorHandler 兜底用） */
+export declare function statusToApiCode(status: number): number;
+/** 判断是否为 Admin API 路由（需要信封包装） */
+export declare function isAdminApiResponse(url: string, contentType?: string): boolean;
+/** 构造错误响应 */
+export declare function apiError(code: number, message: string): ApiResponse<null>;

package/dist/admin/api-response.js

@@ -0,0 +1,40 @@
+// src/admin/api-response.ts
+/** 错误码常量 — XXYYZ 格式：前两位=HTTP 类别，后三位=业务序号 */
+export const API_CODE = {
+    SUCCESS: 0,
+    BAD_REQUEST: 40001,
+    VALIDATION_FAILED: 40002,
+    INVALID_REGEX: 40003,
+    WRONG_PASSWORD: 40101,
+    TOKEN_INVALID: 40102,
+    NOT_INITIALIZED: 40103,
+    NOT_FOUND: 40401,
+    CONFLICT_NAME: 40901,
+    CONFLICT_REFERENCED: 40902,
+    ALREADY_INITIALIZED: 40903,
+    INTERNAL_ERROR: 50001,
+};
+/** HTTP status → 默认 API_CODE 映射（errorHandler 兜底用） */
+export function statusToApiCode(status) {
+    if (status === 400)
+        return API_CODE.BAD_REQUEST;
+    if (status === 401)
+        return API_CODE.TOKEN_INVALID;
+    if (status === 404)
+        return API_CODE.NOT_FOUND;
+    if (status === 409)
+        return API_CODE.CONFLICT_NAME;
+    return API_CODE.INTERNAL_ERROR;
+}
+/** 判断是否为 Admin API 路由（需要信封包装） */
+export function isAdminApiResponse(url, contentType) {
+    if (!url.startsWith('/admin/api/'))
+        return false;
+    if (contentType?.includes('text/event-stream'))
+        return false;
+    return true;
+}
+/** 构造错误响应 */
+export function apiError(code, message) {
+    return { code, message, data: null };
+}

package/dist/admin/constants.d.ts

@@ -1,3 +1 @@
-import type { FastifyReply } from "fastify";
 export { HTTP_BAD_REQUEST, HTTP_CREATED, HTTP_FORBIDDEN, HTTP_NOT_FOUND, HTTP_CONFLICT, HTTP_INTERNAL_ERROR, HTTP_BAD_GATEWAY, HTTP_SERVICE_UNAVAILABLE, } from "../constants.js";
-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

@@ -1,5 +1,2 @@
 // HTTP 状态码统一从 src/constants.ts 导入，避免重复定义
 export { HTTP_BAD_REQUEST, HTTP_CREATED, HTTP_FORBIDDEN, HTTP_NOT_FOUND, HTTP_CONFLICT, HTTP_INTERNAL_ERROR, HTTP_BAD_GATEWAY, HTTP_SERVICE_UNAVAILABLE, } from "../constants.js";
-export function sendErrorResponse(reply, statusCode, message) {
-    return reply.code(statusCode).send({ error: { message } });
-}

package/dist/admin/groups.js

@@ -1,7 +1,8 @@
 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";
+import { HTTP_BAD_REQUEST, HTTP_CREATED, HTTP_CONFLICT, HTTP_NOT_FOUND } from "./constants.js";
+import { API_CODE, apiError } from "./api-response.js";
 const MIN_FAILOVER_TARGETS = 2;
 const CreateGroupSchema = Type.Object({
     client_model: Type.String({ minLength: 1 }),
@@ -82,7 +83,7 @@ export const adminGroupRoutes = (app, options, done) => {
         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 } });
+            return reply.code(HTTP_BAD_REQUEST).send(apiError(API_CODE.BAD_REQUEST, validationError));
         }
         try {
             const id = createMappingGroup(db, {
@@ -94,7 +95,7 @@ export const adminGroupRoutes = (app, options, done) => {
         }
         catch (err) {
             if (err instanceof Error && err.message.includes("UNIQUE constraint")) {
-                return reply.code(HTTP_CONFLICT).send({ error: { message: "client_model already exists" } });
+                return reply.code(HTTP_CONFLICT).send(apiError(API_CODE.CONFLICT_NAME, "client_model already exists"));
             }
             throw err;
         }
@@ -113,7 +114,7 @@ export const adminGroupRoutes = (app, options, done) => {
         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 } });
+            return reply.code(HTTP_BAD_REQUEST).send(apiError(API_CODE.BAD_REQUEST, validationError));
         }
         try {
             updateMappingGroup(db, id, fields);
@@ -121,13 +122,16 @@ export const adminGroupRoutes = (app, options, done) => {
         }
         catch (err) {
             if (err instanceof Error && err.message.includes("UNIQUE constraint")) {
-                return reply.code(HTTP_CONFLICT).send({ error: { message: "client_model already exists" } });
+                return reply.code(HTTP_CONFLICT).send(apiError(API_CODE.CONFLICT_NAME, "client_model already exists"));
             }
             throw err;
         }
     });
     app.delete("/admin/api/mapping-groups/:id", async (request, reply) => {
         const { id } = request.params;
+        const existing = getMappingGroupById(db, id);
+        if (!existing)
+            return reply.code(HTTP_NOT_FOUND).send(apiError(API_CODE.NOT_FOUND, "Mapping group not found"));
         deleteMappingGroup(db, id);
         return reply.send({ success: true });
     });

package/dist/admin/logs.js

@@ -1,6 +1,7 @@
 import { Type } from "@sinclair/typebox";
 import { getRequestLogs, getRequestLogsGrouped, getRequestLogById, getRequestLogChildren, deleteLogsBefore } from "../db/index.js";
 import { HTTP_NOT_FOUND } from "./constants.js";
+import { API_CODE, apiError } from "./api-response.js";
 const LogQuerySchema = Type.Object({
     page: Type.Optional(Type.String()),
     limit: Type.Optional(Type.String()),
@@ -42,7 +43,7 @@ export const adminLogRoutes = (app, options, done) => {
         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.code(HTTP_NOT_FOUND).send(apiError(API_CODE.NOT_FOUND, "Log not found"));
         }
         return reply.send(log);
     });
@@ -50,7 +51,7 @@ export const adminLogRoutes = (app, options, done) => {
         const params = request.params;
         const parent = getRequestLogById(db, params.id);
         if (!parent) {
-            return reply.code(HTTP_NOT_FOUND).send({ error: { message: "Log not found" } });
+            return reply.code(HTTP_NOT_FOUND).send(apiError(API_CODE.NOT_FOUND, "Log not found"));
         }
         const rows = getRequestLogChildren(db, params.id);
         return reply.send(rows);

package/dist/admin/mappings.js

@@ -2,6 +2,7 @@ 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";
+import { API_CODE, apiError } from "./api-response.js";
 const CreateMappingSchema = Type.Object({
     client_model: Type.String({ minLength: 1 }),
     backend_model: Type.String({ minLength: 1 }),
@@ -46,7 +47,7 @@ export const adminMappingRoutes = (app, options, done) => {
         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" } });
+            return reply.code(HTTP_BAD_REQUEST).send(apiError(API_CODE.NOT_FOUND, "provider_id not found"));
         }
         try {
             const id = createMappingGroup(db, {
@@ -61,7 +62,7 @@ export const adminMappingRoutes = (app, options, done) => {
         }
         catch (err) {
             if (err instanceof Error && err.message.includes("UNIQUE constraint")) {
-                return reply.code(HTTP_CONFLICT).send({ error: { message: "client_model already exists" } });
+                return reply.code(HTTP_CONFLICT).send(apiError(API_CODE.CONFLICT_NAME, "client_model already exists"));
             }
             throw err;
         }
@@ -70,7 +71,7 @@ export const adminMappingRoutes = (app, options, done) => {
         const { id } = request.params;
         const group = findGroupByIdOrClientModel(db, id);
         if (!group) {
-            return reply.code(HTTP_NOT_FOUND).send({ error: { message: "Mapping not found" } });
+            return reply.code(HTTP_NOT_FOUND).send(apiError(API_CODE.NOT_FOUND, "Mapping not found"));
         }
         const body = request.body;
         let rule;
@@ -86,7 +87,7 @@ export const adminMappingRoutes = (app, options, done) => {
         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" } });
+                return reply.code(HTTP_BAD_REQUEST).send(apiError(API_CODE.NOT_FOUND, "provider_id not found"));
             }
             defaultTarget.provider_id = body.provider_id;
         }
@@ -102,7 +103,7 @@ export const adminMappingRoutes = (app, options, done) => {
         }
         catch (err) {
             if (err instanceof Error && err.message.includes("UNIQUE constraint")) {
-                return reply.code(HTTP_CONFLICT).send({ error: { message: "client_model already exists" } });
+                return reply.code(HTTP_CONFLICT).send(apiError(API_CODE.CONFLICT_NAME, "client_model already exists"));
             }
             throw err;
         }
@@ -111,7 +112,7 @@ export const adminMappingRoutes = (app, options, done) => {
         const { id } = request.params;
         const group = findGroupByIdOrClientModel(db, id);
         if (!group) {
-            return reply.code(HTTP_NOT_FOUND).send({ error: { message: "Mapping not found" } });
+            return reply.code(HTTP_NOT_FOUND).send(apiError(API_CODE.NOT_FOUND, "Mapping not found"));
         }
         deleteMappingGroup(db, group.id);
         return reply.send({ success: true });

package/dist/admin/metrics.js

@@ -1,9 +1,14 @@
 import { Type } from "@sinclair/typebox";
 import { getMetricsSummary, getMetricsTimeseries } from "../db/index.js";
-const PeriodEnum = Type.Union([
+import { resolveTimeRange } from "../utils/time-range.js";
+const LegacyPeriodEnum = Type.Union([
     Type.Literal("1h"), Type.Literal("5h"), Type.Literal("6h"), Type.Literal("24h"),
     Type.Literal("7d"), Type.Literal("30d"),
 ]);
+const DashboardPeriodEnum = Type.Union([
+    Type.Literal("window"), Type.Literal("weekly"), Type.Literal("monthly"),
+]);
+const PeriodEnum = Type.Union([LegacyPeriodEnum, DashboardPeriodEnum]);
 const MetricEnum = Type.Union([
     Type.Literal("ttft"), Type.Literal("tps"), Type.Literal("tokens"),
     Type.Literal("cache_rate"), Type.Literal("request_count"),
@@ -27,18 +32,31 @@ const TimeseriesQuerySchema = Type.Object({
     start_time: Type.Optional(Type.String()),
     end_time: Type.Optional(Type.String()),
 });
+const DASHBOARD_PERIODS = new Set(["window", "weekly", "monthly"]);
+function resolveMetricsTime(query, db, routerKeyId) {
+    if (query.start_time && query.end_time) {
+        return { startTime: query.start_time, endTime: query.end_time, legacyPeriod: "30d" };
+    }
+    const period = query.period ?? "weekly";
+    if (DASHBOARD_PERIODS.has(period)) {
+        const range = resolveTimeRange(period, db, routerKeyId);
+        return { startTime: range.startTime, endTime: range.endTime, legacyPeriod: "5h" };
+    }
+    return { legacyPeriod: period };
+}
 export const adminMetricsRoutes = (app, options, done) => {
+    const { db } = options;
     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, query.start_time, query.end_time);
+        const { startTime, endTime, legacyPeriod } = resolveMetricsTime(query, db, query.router_key_id);
+        const summary = getMetricsSummary(db, legacyPeriod, query.provider_id, query.backend_model, query.router_key_id, startTime, endTime);
         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, query.start_time, query.end_time);
+        const { startTime, endTime, legacyPeriod } = resolveMetricsTime(query, db, query.router_key_id);
+        const timeseries = getMetricsTimeseries(db, legacyPeriod, metric, query.provider_id, query.backend_model, query.router_key_id, startTime, endTime);
         return reply.send(timeseries);
     });
     done();

package/dist/admin/monitor.js

@@ -1,4 +1,5 @@
 import { HTTP_NOT_FOUND } from "./constants.js";
+import { API_CODE, apiError } from "./api-response.js";
 const HTTP_OK = 200;
 export const adminMonitorRoutes = (app, options, done) => {
     const { tracker } = options;
@@ -26,7 +27,7 @@ export const adminMonitorRoutes = (app, options, done) => {
         const { id } = request.params;
         const req = tracker.getRequestById(id);
         if (!req)
-            return reply.status(HTTP_NOT_FOUND).send({ error: "Not found" });
+            return reply.code(HTTP_NOT_FOUND).send(apiError(API_CODE.NOT_FOUND, "Not found"));
         return req;
     });
     done();

package/dist/admin/providers.js

@@ -3,6 +3,7 @@ import { getAllProviders, getProviderById, createProvider, updateProvider, delet
 import { encrypt, decrypt } from "../utils/crypto.js";
 import { getSetting } from "../db/settings.js";
 import { HTTP_CREATED, HTTP_NOT_FOUND, HTTP_CONFLICT, HTTP_BAD_REQUEST } from "./constants.js";
+import { API_CODE, apiError } from "./api-response.js";
 const API_KEY_PREVIEW_MIN_LENGTH = 8;
 const API_KEY_PREVIEW_PREFIX_LEN = 4;
 const PROVIDER_NAME_RE = /^[a-zA-Z0-9_-]+$/;
@@ -52,7 +53,11 @@ export const adminProviderRoutes = (app, options, done) => {
     app.post("/admin/api/providers", { schema: { body: CreateProviderSchema } }, async (request, reply) => {
         const body = request.body;
         if (!PROVIDER_NAME_RE.test(body.name)) {
-            return reply.status(HTTP_BAD_REQUEST).send({ error: { message: "Provider 名称仅允许英文大小写字母、数字、横线和下划线" } });
+            return reply.code(HTTP_BAD_REQUEST).send(apiError(API_CODE.VALIDATION_FAILED, "Provider 名称仅允许英文大小写字母、数字、横线和下划线"));
+        }
+        const existing = db.prepare("SELECT id FROM providers WHERE name = ?").get(body.name);
+        if (existing) {
+            return reply.code(HTTP_CONFLICT).send(apiError(API_CODE.CONFLICT_NAME, `Provider 名称 '${body.name}' 已存在`));
         }
         const encryptedKey = encrypt(body.api_key, getSetting(db, "encryption_key"));
         const id = createProvider(db, {
@@ -84,11 +89,11 @@ export const adminProviderRoutes = (app, options, done) => {
         const { id } = request.params;
         const existing = getProviderById(db, id);
         if (!existing) {
-            return reply.code(HTTP_NOT_FOUND).send({ error: { message: "Provider not found" } });
+            return reply.code(HTTP_NOT_FOUND).send(apiError(API_CODE.NOT_FOUND, "Provider not found"));
         }
         const body = request.body;
         if (body.name !== undefined && !PROVIDER_NAME_RE.test(body.name)) {
-            return reply.status(HTTP_BAD_REQUEST).send({ error: { message: "Provider 名称仅允许英文大小写字母、数字、横线和下划线" } });
+            return reply.code(HTTP_BAD_REQUEST).send(apiError(API_CODE.VALIDATION_FAILED, "Provider 名称仅允许英文大小写字母、数字、横线和下划线"));
         }
         const fields = {};
         if (body.name !== undefined)
@@ -130,13 +135,17 @@ export const adminProviderRoutes = (app, options, done) => {
     });
     app.delete("/admin/api/providers/:id", async (request, reply) => {
         const { id } = request.params;
+        const existing = getProviderById(db, id);
+        if (!existing) {
+            return reply.code(HTTP_NOT_FOUND).send(apiError(API_CODE.NOT_FOUND, "Provider not found"));
+        }
         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}'` } });
+                    return reply.code(HTTP_CONFLICT).send(apiError(API_CODE.CONFLICT_REFERENCED, `Provider is referenced by mapping group '${g.client_model}'`));
                 }
             }
             catch {

package/dist/admin/proxy-enhancement.js

@@ -1,4 +1,12 @@
+import { Type } from "@sinclair/typebox";
 import { getSetting, setSetting } from "../db/settings.js";
+const UpdateProxyEnhancementSchema = Type.Object({
+    claude_code_enabled: Type.Boolean(),
+});
+const SessionParamsSchema = Type.Object({
+    keyId: Type.String(),
+    sessionId: Type.String(),
+});
 import { getSessionStates, getSessionHistory, } from "../db/session-states.js";
 import { modelState } from "../proxy/model-state.js";
 export const adminProxyEnhancementRoutes = (app, options, done) => {
@@ -10,11 +18,8 @@ export const adminProxyEnhancementRoutes = (app, options, done) => {
             : { claude_code_enabled: false };
         return reply.send(config);
     });
-    app.put("/admin/api/proxy-enhancement", async (req, reply) => {
+    app.put("/admin/api/proxy-enhancement", { schema: { body: UpdateProxyEnhancementSchema } }, async (req, reply) => {
         const body = req.body;
-        if (typeof body.claude_code_enabled !== "boolean") {
-            return reply.status(400).send({ error: "claude_code_enabled must be a boolean" }); // eslint-disable-line no-magic-numbers
-        }
         const config = {
             claude_code_enabled: body.claude_code_enabled,
         };
@@ -25,12 +30,12 @@ export const adminProxyEnhancementRoutes = (app, options, done) => {
         const states = getSessionStates(db);
         return reply.send(states);
     });
-    app.get("/admin/api/session-states/:keyId/:sessionId/history", async (req, reply) => {
+    app.get("/admin/api/session-states/:keyId/:sessionId/history", { schema: { params: SessionParamsSchema } }, async (req, reply) => {
         const { keyId, sessionId } = req.params;
         const history = getSessionHistory(db, keyId, sessionId);
         return reply.send(history);
     });
-    app.delete("/admin/api/session-states/:keyId/:sessionId", async (req, reply) => {
+    app.delete("/admin/api/session-states/:keyId/:sessionId", { schema: { params: SessionParamsSchema } }, async (req, reply) => {
         const { keyId, sessionId } = req.params;
         modelState.delete(keyId, sessionId);
         return reply.send({ success: true });

package/dist/admin/recommended.js

@@ -2,15 +2,7 @@ import { getRecommendedProviders, getRecommendedRetryRules, reloadConfig } from
 export const adminRecommendedRoutes = (app, options, done) => {
     const { db } = options;
     app.get("/admin/api/recommended/providers", async (_req, reply) => {
-        const groups = getRecommendedProviders();
-        const existing = new Set(db.prepare("SELECT name FROM providers").all().map((r) => r.name));
-        const filtered = groups
-            .map((g) => ({
-            ...g,
-            presets: g.presets.filter((p) => !existing.has(p.presetName)),
-        }))
-            .filter((g) => g.presets.length > 0);
-        return reply.send(filtered);
+        return reply.send(getRecommendedProviders());
     });
     app.get("/admin/api/recommended/retry-rules", async (_req, reply) => {
         const rules = getRecommendedRetryRules();

package/dist/admin/retry-rules.js

@@ -1,6 +1,7 @@
 import { Type } from "@sinclair/typebox";
-import { getAllRetryRules, createRetryRule, updateRetryRule, deleteRetryRule, } from "../db/index.js";
-import { HTTP_BAD_REQUEST, HTTP_CREATED } from "./constants.js";
+import { getAllRetryRules, getRetryRuleById, createRetryRule, updateRetryRule, deleteRetryRule, } from "../db/index.js";
+import { HTTP_BAD_REQUEST, HTTP_CREATED, HTTP_NOT_FOUND } from "./constants.js";
+import { API_CODE, apiError } from "./api-response.js";
 const DEFAULT_RETRY_DELAY_MS = 5000;
 const DEFAULT_MAX_RETRIES = 10;
 const DEFAULT_MAX_DELAY_MS = 60000;
@@ -47,7 +48,7 @@ export const adminRetryRuleRoutes = (app, options, done) => {
         const body = request.body;
         const regexError = validateBodyPattern(body.body_pattern);
         if (regexError) {
-            return reply.code(HTTP_BAD_REQUEST).send({ error: { message: regexError } });
+            return reply.code(HTTP_BAD_REQUEST).send(apiError(API_CODE.INVALID_REGEX, regexError));
         }
         const id = createRetryRule(db, {
             name: body.name,
@@ -73,7 +74,7 @@ export const adminRetryRuleRoutes = (app, options, done) => {
         if (body.body_pattern !== undefined) {
             const regexError = validateBodyPattern(body.body_pattern);
             if (regexError) {
-                return reply.code(HTTP_BAD_REQUEST).send({ error: { message: regexError } });
+                return reply.code(HTTP_BAD_REQUEST).send(apiError(API_CODE.INVALID_REGEX, regexError));
             }
             fields.body_pattern = body.body_pattern;
         }
@@ -93,6 +94,9 @@ export const adminRetryRuleRoutes = (app, options, done) => {
     });
     app.delete("/admin/api/retry-rules/:id", async (request, reply) => {
         const { id } = request.params;
+        const existing = getRetryRuleById(db, id);
+        if (!existing)
+            return reply.code(HTTP_NOT_FOUND).send(apiError(API_CODE.NOT_FOUND, "Retry rule not found"));
         deleteRetryRule(db, id);
         refreshMatcher(matcher, db);
         return reply.send({ success: true });

package/dist/admin/router-keys.js

@@ -4,6 +4,7 @@ import { encrypt, decrypt } from "../utils/crypto.js";
 import { getAllRouterKeys, getRouterKeyById, createRouterKey, updateRouterKey, deleteRouterKey, getAvailableModels, } from "../db/index.js";
 import { getSetting } from "../db/settings.js";
 import { HTTP_CREATED, HTTP_NOT_FOUND } from "./constants.js";
+import { API_CODE, apiError } from "./api-response.js";
 const KEY_RANDOM_BYTES = 32;
 const KEY_PREFIX_LENGTH = 8;
 /** 归一化 allowed_models：null/空数组/仅含空字符串 → null（允许所有模型） */
@@ -67,7 +68,7 @@ export const adminRouterKeyRoutes = (app, options, done) => {
         const { id } = request.params;
         const existing = getRouterKeyById(db, id);
         if (!existing) {
-            return reply.code(HTTP_NOT_FOUND).send({ error: { message: "Router key not found" } });
+            return reply.code(HTTP_NOT_FOUND).send(apiError(API_CODE.NOT_FOUND, "Router key not found"));
         }
         const body = request.body;
         const fields = {};
@@ -82,6 +83,9 @@ export const adminRouterKeyRoutes = (app, options, done) => {
     });
     app.delete("/admin/api/router-keys/:id", async (request, reply) => {
         const { id } = request.params;
+        const existing = getRouterKeyById(db, id);
+        if (!existing)
+            return reply.code(HTTP_NOT_FOUND).send(apiError(API_CODE.NOT_FOUND, "Router key not found"));
         deleteRouterKey(db, id);
         return reply.send({ success: true });
     });

package/dist/admin/settings-import-export.js

@@ -3,6 +3,7 @@ import { getAllProviders, PROVIDER_CONCURRENCY_DEFAULTS } from "../db/index.js";
 import { encrypt, decrypt } from "../utils/crypto.js";
 import { getSetting } from "../db/settings.js";
 import { modelState } from "../proxy/model-state.js";
+import { API_CODE, apiError } from "./api-response.js";
 const CONFIG_TABLES = [
     "providers",
     "mapping_groups",
@@ -58,10 +59,10 @@ export const adminImportExportRoutes = (app, options, done) => {
     app.post("/admin/api/settings/import", async (request, reply) => {
         const body = request.body;
         if (typeof body.version !== "number" || body.version !== EXPORT_VERSION) {
-            return reply.code(BAD_REQUEST).send({ error: { message: `Unsupported version. Expected ${EXPORT_VERSION}.` } });
+            return reply.code(BAD_REQUEST).send(apiError(API_CODE.BAD_REQUEST, `Unsupported version. Expected ${EXPORT_VERSION}.`));
         }
         if (!body.data || typeof body.data !== "object") {
-            return reply.code(BAD_REQUEST).send({ error: { message: "Missing or invalid data field" } });
+            return reply.code(BAD_REQUEST).send(apiError(API_CODE.BAD_REQUEST, "Missing or invalid data field"));
         }
         const counts = {};
         const importData = body.data;

package/dist/admin/settings.js

@@ -1,14 +1,16 @@
 import { getLogRetentionDays, setLogRetentionDays, getDbMaxSizeMb, setDbMaxSizeMb, getLogTableMaxSizeMb, setLogTableMaxSizeMb, getSetting, } from "../db/settings.js";
+import { HTTP_BAD_REQUEST } from "./constants.js";
+import { API_CODE, apiError } from "./api-response.js";
 export const adminSettingsRoutes = (app, options, done) => {
     const { db } = options;
     app.get("/admin/api/settings/log-retention", async () => {
         return { days: getLogRetentionDays(db) };
     });
-    app.put("/admin/api/settings/log-retention", async (request) => {
+    app.put("/admin/api/settings/log-retention", async (request, reply) => {
         const { days } = request.body;
         const MAX_LOG_RETENTION_DAYS = 90;
         if (!Number.isInteger(days) || days < 0 || days > MAX_LOG_RETENTION_DAYS) {
-            throw { statusCode: 400, message: "days must be integer 0-90" };
+            return reply.code(HTTP_BAD_REQUEST).send(apiError(API_CODE.BAD_REQUEST, "days must be integer 0-90"));
         }
         setLogRetentionDays(db, days);
         return { days };
@@ -31,17 +33,17 @@ export const adminSettingsRoutes = (app, options, done) => {
             },
         };
     });
-    app.put("/admin/api/settings/db-size-thresholds", async (request) => {
+    app.put("/admin/api/settings/db-size-thresholds", async (request, reply) => {
         const body = request.body;
         if (body.dbMaxSizeMb !== undefined) {
             if (!Number.isFinite(body.dbMaxSizeMb) || body.dbMaxSizeMb < 1) {
-                throw { statusCode: 400, message: "dbMaxSizeMb must be a positive number" };
+                return reply.code(HTTP_BAD_REQUEST).send(apiError(API_CODE.BAD_REQUEST, "dbMaxSizeMb must be a positive number"));
             }
             setDbMaxSizeMb(db, Math.round(body.dbMaxSizeMb));
         }
         if (body.logTableMaxSizeMb !== undefined) {
             if (!Number.isFinite(body.logTableMaxSizeMb) || body.logTableMaxSizeMb < 1) {
-                throw { statusCode: 400, message: "logTableMaxSizeMb must be a positive number" };
+                return reply.code(HTTP_BAD_REQUEST).send(apiError(API_CODE.BAD_REQUEST, "logTableMaxSizeMb must be a positive number"));
             }
             setLogTableMaxSizeMb(db, Math.round(body.logTableMaxSizeMb));
         }