llm-simple-router 0.5.5 → 0.6.0

package/dist/admin/groups.js

@@ -1,17 +1,13 @@
 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, 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 }),
-    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()),
 });
 function validateOverflow(db, target, label) {
@@ -31,11 +27,7 @@ function validateOverflow(db, target, label) {
     }
     return undefined;
 }
-async function validateRule(db, strategy, ruleJson) {
-    const VALID_STRATEGIES = new Set(Object.values(STRATEGY_NAMES));
-    if (!VALID_STRATEGIES.has(strategy)) {
-        return `Unknown strategy '${strategy}'. Valid: ${[...VALID_STRATEGIES].join(", ")}`;
-    }
+function validateRule(db, ruleJson) {
     let rule;
     try {
         rule = JSON.parse(ruleJson);
@@ -43,59 +35,24 @@ async function validateRule(db, strategy, 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";
+    if (typeof rule !== "object" || rule === null)
+        return "Invalid rule";
+    const r = rule;
+    if (!Array.isArray(r.targets) || r.targets.length === 0) {
+        return "rule.targets must be a non-empty array";
+    }
+    for (let i = 0; i < r.targets.length; i++) {
+        const t = r.targets[i];
+        if (!t.backend_model || !t.provider_id) {
+            return `targets[${i}] missing backend_model or provider_id`;
         }
-        const defaultProvider = getProviderById(db, r.default.provider_id);
-        if (!defaultProvider) {
-            return `provider_id '${r.default.provider_id}' not found`;
+        const p = getProviderById(db, t.provider_id);
+        if (!p) {
+            return `targets[${i}] provider_id '${t.provider_id}' not found`;
         }
-        const overflowErr = validateOverflow(db, r.default, "rule.default");
+        const overflowErr = validateOverflow(db, t, `targets[${i}]`);
         if (overflowErr)
             return overflowErr;
-        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`;
-                }
-                const wOverflowErr = validateOverflow(db, w.target, `window[${i}]`);
-                if (wOverflowErr)
-                    return wOverflowErr;
-            }
-        }
-    }
-    if (strategy === STRATEGY_NAMES.ROUND_ROBIN || strategy === STRATEGY_NAMES.RANDOM || strategy === STRATEGY_NAMES.FAILOVER) {
-        const r = rule;
-        if (!Array.isArray(r.targets) || r.targets.length === 0) {
-            return "rule.targets must be a non-empty array";
-        }
-        const minTargets = strategy === STRATEGY_NAMES.FAILOVER ? MIN_FAILOVER_TARGETS : 1;
-        if (r.targets.length < minTargets) {
-            return `strategy '${strategy}' requires at least ${minTargets} target(s)`;
-        }
-        for (let i = 0; i < r.targets.length; i++) {
-            const t = r.targets[i];
-            if (!t.backend_model || !t.provider_id) {
-                return `targets[${i}] missing backend_model or provider_id`;
-            }
-            const p = getProviderById(db, t.provider_id);
-            if (!p) {
-                return `targets[${i}] provider_id '${t.provider_id}' not found`;
-            }
-            const overflowErr = validateOverflow(db, t, `targets[${i}]`);
-            if (overflowErr)
-                return overflowErr;
-        }
     }
     return undefined;
 }
@@ -107,14 +64,13 @@ export const adminGroupRoutes = (app, options, done) => {
     });
     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);
+        const validationError = validateRule(db, body.rule);
         if (validationError) {
             return reply.code(HTTP_BAD_REQUEST).send(apiError(API_CODE.BAD_REQUEST, validationError));
         }
         try {
             const id = createMappingGroup(db, {
                 client_model: body.client_model,
-                strategy: body.strategy,
                 rule: body.rule,
             });
             return reply.code(HTTP_CREATED).send({ id });
@@ -132,13 +88,10 @@ export const adminGroupRoutes = (app, options, done) => {
         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);
+        const validationError = validateRule(db, ruleJson);
         if (validationError) {
             return reply.code(HTTP_BAD_REQUEST).send(apiError(API_CODE.BAD_REQUEST, validationError));
         }
@@ -172,10 +125,6 @@ export const adminGroupRoutes = (app, options, done) => {
     });
     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.js

@@ -11,6 +11,7 @@ const LogQuerySchema = Type.Object({
     provider_id: Type.Optional(Type.String()),
     start_time: Type.Optional(Type.String()),
     end_time: Type.Optional(Type.String()),
+    status_code: Type.Optional(Type.String()),
     view: Type.Optional(Type.Literal("grouped")),
 });
 const DeleteLogsBeforeSchema = Type.Object({
@@ -33,6 +34,7 @@ export const adminLogRoutes = (app, options, done) => {
             provider_id: query.provider_id || undefined,
             start_time: query.start_time || undefined,
             end_time: query.end_time || undefined,
+            status_code: query.status_code || undefined,
         };
         const result = view === "grouped"
             ? getRequestLogsGrouped(db, listOptions)

package/dist/admin/mappings.js

@@ -1,6 +1,5 @@
 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({
@@ -21,14 +20,14 @@ function toLegacy(group) {
     catch {
         return null;
     }
-    const defaultTarget = rule?.default;
-    if (!defaultTarget)
+    const targets = rule?.targets;
+    if (!targets || targets.length === 0)
         return null;
     return {
         id: group.id,
         client_model: group.client_model,
-        backend_model: defaultTarget.backend_model ?? "",
-        provider_id: defaultTarget.provider_id ?? "",
+        backend_model: targets[0].backend_model ?? "",
+        provider_id: targets[0].provider_id ?? "",
         is_active: 1,
         created_at: group.created_at,
     };
@@ -52,10 +51,8 @@ export const adminMappingRoutes = (app, options, done) => {
         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: [],
+                    targets: [{ backend_model: body.backend_model, provider_id: body.provider_id }],
                 }),
             });
             return reply.code(HTTP_CREATED).send({ id });
@@ -79,19 +76,26 @@ export const adminMappingRoutes = (app, options, done) => {
             rule = JSON.parse(group.rule);
         }
         catch {
-            rule = { default: {}, windows: [] };
+            rule = { targets: [{}] };
         }
-        const defaultTarget = { ...(rule.default || {}) };
+        const targets = rule.targets || [];
+        const firstTarget = { ...(targets[0] || {}) };
         if (body.backend_model !== undefined)
-            defaultTarget.backend_model = body.backend_model;
+            firstTarget.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(apiError(API_CODE.NOT_FOUND, "provider_id not found"));
             }
-            defaultTarget.provider_id = body.provider_id;
+            firstTarget.provider_id = body.provider_id;
         }
-        rule.default = defaultTarget;
+        if (targets.length > 0) {
+            targets[0] = firstTarget;
+        }
+        else {
+            targets.push(firstTarget);
+        }
+        rule.targets = targets;
         const fields = {
             rule: JSON.stringify(rule),
         };

package/dist/admin/metrics.js

@@ -10,8 +10,9 @@ const DashboardPeriodEnum = Type.Union([
 ]);
 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"),
+    Type.Literal("ttft"), Type.Literal("tps"), Type.Literal("text_tps"),
+    Type.Literal("thinking_tps"), Type.Literal("tool_use_tps"), Type.Literal("total_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"),
 ]);
@@ -33,13 +34,13 @@ const TimeseriesQuerySchema = Type.Object({
     end_time: Type.Optional(Type.String()),
 });
 const DASHBOARD_PERIODS = new Set(["window", "weekly", "monthly"]);
-function resolveMetricsTime(query, db, routerKeyId) {
+function resolveMetricsTime(query, db, routerKeyId, providerId) {
     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);
+        const range = resolveTimeRange(period, db, routerKeyId, providerId);
         return { startTime: range.startTime, endTime: range.endTime, legacyPeriod: "5h" };
     }
     return { legacyPeriod: period };
@@ -48,14 +49,14 @@ 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 { startTime, endTime, legacyPeriod } = resolveMetricsTime(query, db, query.router_key_id);
+        const { startTime, endTime, legacyPeriod } = resolveMetricsTime(query, db, query.router_key_id, query.provider_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 metric = query.metric;
-        const { startTime, endTime, legacyPeriod } = resolveMetricsTime(query, db, query.router_key_id);
+        const { startTime, endTime, legacyPeriod } = resolveMetricsTime(query, db, query.router_key_id, query.provider_id);
         const timeseries = getMetricsTimeseries(db, legacyPeriod, metric, query.provider_id, query.backend_model, query.router_key_id, startTime, endTime);
         return reply.send(timeseries);
     });

package/dist/admin/providers.js

@@ -1,5 +1,5 @@
 import { Type } from "@sinclair/typebox";
-import { getAllProviders, getProviderById, createProvider, updateProvider, deleteProvider, getAllMappingGroups, getAllModelMappings, updateMappingGroup, PROVIDER_CONCURRENCY_DEFAULTS } from "../db/index.js";
+import { getAllProviders, getProviderById, createProvider, updateProvider, deleteProvider, getAllMappingGroups, updateMappingGroup, PROVIDER_CONCURRENCY_DEFAULTS } from "../db/index.js";
 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";
@@ -22,55 +22,29 @@ function cascadeProviderDisable(db, providerId) {
         }
         let modified = false;
         let shouldDisable = false;
-        if (g.strategy === "scheduled") {
-            const def = rule.default;
-            if (def) {
-                if (def.provider_id === providerId) {
-                    shouldDisable = true;
+        // 归一化旧格式 { default, windows } → { targets }（向后兼容 migration 026 前数据）
+        // eslint-disable-next-line taste/no-deprecated-rule-format
+        if (!Array.isArray(rule.targets) && typeof rule.default === "object" && rule.default !== null) {
+            // eslint-disable-next-line taste/no-deprecated-rule-format
+            rule.targets = [rule.default];
+        }
+        const targets = rule.targets;
+        if (Array.isArray(targets)) {
+            const filtered = targets.filter((t) => {
+                if (t.provider_id === providerId) {
                     modified = true;
+                    return false;
                 }
-                if (def.overflow_provider_id === providerId) {
-                    delete def.overflow_provider_id;
-                    delete def.overflow_model;
+                if (t.overflow_provider_id === providerId) {
+                    delete t.overflow_provider_id;
+                    delete t.overflow_model;
                     modified = true;
                 }
-            }
-            const windows = rule.windows;
-            if (Array.isArray(windows)) {
-                const filtered = windows.filter((w) => {
-                    if (w.target?.provider_id === providerId) {
-                        modified = true;
-                        return false;
-                    }
-                    if (w.target?.overflow_provider_id === providerId) {
-                        delete w.target.overflow_provider_id;
-                        delete w.target.overflow_model;
-                        modified = true;
-                    }
-                    return true;
-                });
-                rule.windows = filtered;
-            }
-        }
-        else {
-            const targets = rule.targets;
-            if (Array.isArray(targets)) {
-                const filtered = targets.filter((t) => {
-                    if (t.provider_id === providerId) {
-                        modified = true;
-                        return false;
-                    }
-                    if (t.overflow_provider_id === providerId) {
-                        delete t.overflow_provider_id;
-                        delete t.overflow_model;
-                        modified = true;
-                    }
-                    return true;
-                });
-                rule.targets = filtered;
-                if (filtered.length === 0 && modified) {
-                    shouldDisable = true;
-                }
+                return true;
+            });
+            rule.targets = filtered;
+            if (filtered.length === 0 && modified) {
+                shouldDisable = true;
             }
         }
         if (modified) {
@@ -256,22 +230,6 @@ export const adminProviderRoutes = (app, options, done) => {
             const refs = [];
             try {
                 const rule = JSON.parse(g.rule);
-                if (rule.default?.provider_id === id) {
-                    refs.push(`默认模型 (${rule.default.backend_model})`);
-                }
-                if (rule.default?.overflow_provider_id === id) {
-                    refs.push(`默认溢出模型 (${rule.default.overflow_model || "-"})`);
-                }
-                if (Array.isArray(rule.windows)) {
-                    for (const w of rule.windows) {
-                        if (w.target?.provider_id === id) {
-                            refs.push(`时间窗口 ${w.start}-${w.end} (${w.target.backend_model})`);
-                        }
-                        if (w.target?.overflow_provider_id === id) {
-                            refs.push(`时间窗口 ${w.start}-${w.end} 溢出 (${w.target.overflow_model || "-"})`);
-                        }
-                    }
-                }
                 if (Array.isArray(rule.targets)) {
                     for (let i = 0; i < rule.targets.length; i++) {
                         const t = rule.targets[i];
@@ -291,12 +249,6 @@ export const adminProviderRoutes = (app, options, done) => {
                 references.push(`映射分组「${g.client_model}」: ${ref}`);
             }
         }
-        const mappings = getAllModelMappings(db);
-        for (const m of mappings) {
-            if (m.provider_id === id) {
-                references.push(`旧版映射「${m.client_model}」→ ${m.backend_model}`);
-            }
-        }
         return reply.send({ references });
     });
     app.delete("/admin/api/providers/:id", async (request, reply) => {
@@ -309,8 +261,8 @@ export const adminProviderRoutes = (app, options, done) => {
         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)) {
+                const targets = Array.isArray(rule.targets) ? rule.targets : [];
+                if (targets.some((t) => t?.provider_id === id)) {
                     return reply.code(HTTP_CONFLICT).send(apiError(API_CODE.CONFLICT_REFERENCED, `Provider is referenced by mapping group '${g.client_model}'`));
                 }
             }

package/dist/admin/routes.js

@@ -15,6 +15,7 @@ import { adminRecommendedRoutes } from "./recommended.js";
 import { adminUsageRoutes } from "./usage.js";
 import { adminUpgradeRoutes } from "./upgrade.js";
 import { adminImportExportRoutes } from "./settings-import-export.js";
+import { adminScheduleRoutes } from "./schedules.js";
 export const adminRoutes = (app, options, done) => {
     // Setup 路由不需要 auth
     app.register(adminSetupRoutes, { db: options.db });
@@ -23,6 +24,7 @@ export const adminRoutes = (app, options, done) => {
     app.register(adminProviderRoutes, { db: options.db, semaphoreManager: options.semaphoreManager, tracker: options.tracker });
     app.register(adminMappingRoutes, { db: options.db });
     app.register(adminGroupRoutes, { db: options.db });
+    app.register(adminScheduleRoutes, { db: options.db });
     app.register(adminRetryRuleRoutes, { db: options.db, matcher: options.matcher });
     app.register(adminLogRoutes, { db: options.db });
     app.register(adminRouterKeyRoutes, { db: options.db });

package/dist/admin/schedules.d.ts

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

package/dist/admin/schedules.js

@@ -0,0 +1,210 @@
+import { Type } from "@sinclair/typebox";
+import { getSchedulesByGroup, getAllSchedules, getScheduleById, createSchedule, updateSchedule, deleteSchedule, } from "../db/index.js";
+import { getMappingGroupById, getProviderById } 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 CreateScheduleSchema = Type.Object({
+    mapping_group_id: Type.String({ minLength: 1 }),
+    name: Type.String({ minLength: 1 }),
+    week: Type.String(),
+    start_hour: Type.Number({ minimum: 0, maximum: 23 }),
+    end_hour: Type.Number({ minimum: 1, maximum: 24 }),
+    mapping_rule: Type.String(),
+    concurrency_rule: Type.Optional(Type.String()),
+});
+const UpdateScheduleSchema = Type.Object({
+    name: Type.Optional(Type.String({ minLength: 1 })),
+    enabled: Type.Optional(Type.Number()),
+    week: Type.Optional(Type.String()),
+    start_hour: Type.Optional(Type.Number({ minimum: 0, maximum: 23 })),
+    end_hour: Type.Optional(Type.Number({ minimum: 1, maximum: 24 })),
+    mapping_rule: Type.Optional(Type.String()),
+    concurrency_rule: Type.Optional(Type.String()),
+});
+function validateMappingRule(db, ruleJson) {
+    let rule;
+    try {
+        rule = JSON.parse(ruleJson);
+    }
+    catch {
+        return "Invalid mapping_rule JSON";
+    }
+    if (typeof rule !== "object" || rule === null)
+        return "Invalid mapping_rule";
+    const r = rule;
+    if (!Array.isArray(r.targets) || r.targets.length === 0) {
+        return "mapping_rule.targets must be a non-empty array";
+    }
+    for (let i = 0; i < r.targets.length; i++) {
+        const t = r.targets[i];
+        if (!t.backend_model || !t.provider_id) {
+            return `targets[${i}] missing backend_model or provider_id`;
+        }
+        const p = getProviderById(db, t.provider_id);
+        if (!p)
+            return `targets[${i}] provider_id '${t.provider_id}' not found`;
+        const hasOverflowProvider = !!t.overflow_provider_id;
+        const hasOverflowModel = !!t.overflow_model;
+        if (hasOverflowProvider && !hasOverflowModel) {
+            return `targets[${i}]: overflow_provider_id requires overflow_model`;
+        }
+        if (hasOverflowModel && !hasOverflowProvider) {
+            return `targets[${i}]: overflow_model requires overflow_provider_id`;
+        }
+        if (hasOverflowProvider) {
+            const op = getProviderById(db, t.overflow_provider_id);
+            if (!op)
+                return `targets[${i}]: overflow_provider_id '${t.overflow_provider_id}' not found`;
+        }
+    }
+    return undefined;
+}
+/** 解析 week JSON 为数字数组，失败返回 null */
+function parseWeekSafe(weekJson) {
+    try {
+        const arr = JSON.parse(weekJson);
+        if (!Array.isArray(arr) || !arr.every((d) => typeof d === "number" && d >= 0 && d <= 6))
+            return null;
+        return arr;
+    }
+    catch {
+        return null;
+    }
+}
+/** 检查同组 schedules 是否与 [startHour, endHour) 时段重叠（按星期交集判断） */
+function checkOverlap(db, groupId, excludeId, weekDays, startHour, endHour) {
+    const existing = getSchedulesByGroup(db, groupId);
+    for (const s of existing) {
+        if (excludeId && s.id === excludeId)
+            continue;
+        const sWeek = parseWeekSafe(s.week);
+        if (!sWeek)
+            continue;
+        // 星期有交集 AND 时段有交集 才算重叠
+        const weekOverlap = weekDays.some(d => sWeek.includes(d));
+        const timeOverlap = startHour < s.end_hour && endHour > s.start_hour;
+        if (weekOverlap && timeOverlap) {
+            const days = weekDays.map(d => ["周日", "周一", "周二", "周三", "周四", "周五", "周六"][d]).join("、");
+            return `时段与「${s.name}」重叠 (${days} ${formatHour(startHour)}-${formatHour(endHour)} vs ${formatHour(s.start_hour)}-${formatHour(s.end_hour)})`;
+        }
+    }
+    return undefined;
+}
+function formatHour(h) {
+    return String(h).padStart(2, "0") + ":00";
+}
+export const adminScheduleRoutes = (app, options, done) => {
+    const { db } = options;
+    app.get("/admin/api/schedules", async (_request, reply) => {
+        const schedules = getAllSchedules(db);
+        return reply.send(schedules);
+    });
+    app.get("/admin/api/schedules/group/:groupId", async (request, reply) => {
+        const { groupId } = request.params;
+        const group = getMappingGroupById(db, groupId);
+        if (!group)
+            return reply.code(HTTP_NOT_FOUND).send(apiError(API_CODE.NOT_FOUND, "Mapping group not found"));
+        const schedules = getSchedulesByGroup(db, groupId);
+        return reply.send(schedules);
+    });
+    app.post("/admin/api/schedules", { schema: { body: CreateScheduleSchema } }, async (request, reply) => {
+        const body = request.body;
+        const group = getMappingGroupById(db, body.mapping_group_id);
+        if (!group)
+            return reply.code(HTTP_BAD_REQUEST).send(apiError(API_CODE.BAD_REQUEST, "mapping_group_id not found"));
+        const ruleErr = validateMappingRule(db, body.mapping_rule);
+        if (ruleErr)
+            return reply.code(HTTP_BAD_REQUEST).send(apiError(API_CODE.BAD_REQUEST, ruleErr));
+        if (body.concurrency_rule) {
+            try {
+                JSON.parse(body.concurrency_rule);
+            }
+            catch {
+                return reply.code(HTTP_BAD_REQUEST).send(apiError(API_CODE.BAD_REQUEST, "Invalid concurrency_rule JSON"));
+            }
+        }
+        if (body.start_hour >= body.end_hour) {
+            return reply.code(HTTP_BAD_REQUEST).send(apiError(API_CODE.BAD_REQUEST, "start_hour must be < end_hour"));
+        }
+        const weekDays = parseWeekSafe(body.week);
+        if (!weekDays) {
+            return reply.code(HTTP_BAD_REQUEST).send(apiError(API_CODE.BAD_REQUEST, "week must be array of 0-6"));
+        }
+        const overlapErr = checkOverlap(db, body.mapping_group_id, undefined, weekDays, body.start_hour, body.end_hour);
+        if (overlapErr) {
+            return reply.code(HTTP_BAD_REQUEST).send(apiError(API_CODE.BAD_REQUEST, overlapErr));
+        }
+        const id = createSchedule(db, {
+            mapping_group_id: body.mapping_group_id,
+            name: body.name,
+            week: body.week,
+            start_hour: body.start_hour,
+            end_hour: body.end_hour,
+            mapping_rule: body.mapping_rule,
+            concurrency_rule: body.concurrency_rule,
+        });
+        return reply.code(HTTP_CREATED).send({ id });
+    });
+    app.put("/admin/api/schedules/:id", { schema: { body: UpdateScheduleSchema } }, async (request, reply) => {
+        const { id } = request.params;
+        const body = request.body;
+        const existing = getScheduleById(db, id);
+        if (!existing)
+            return reply.code(HTTP_NOT_FOUND).send(apiError(API_CODE.NOT_FOUND, "Schedule not found"));
+        const mappingRule = body.mapping_rule ?? existing.mapping_rule;
+        const ruleErr = validateMappingRule(db, mappingRule);
+        if (ruleErr)
+            return reply.code(HTTP_BAD_REQUEST).send(apiError(API_CODE.BAD_REQUEST, ruleErr));
+        if (body.concurrency_rule) {
+            try {
+                JSON.parse(body.concurrency_rule);
+            }
+            catch {
+                return reply.code(HTTP_BAD_REQUEST).send(apiError(API_CODE.BAD_REQUEST, "Invalid concurrency_rule JSON"));
+            }
+        }
+        const startH = body.start_hour ?? existing.start_hour;
+        const endH = body.end_hour ?? existing.end_hour;
+        if (startH >= endH) {
+            return reply.code(HTTP_BAD_REQUEST).send(apiError(API_CODE.BAD_REQUEST, "start_hour must be < end_hour"));
+        }
+        // 时段重叠校验（仅在 week 或 start/end 有变更时）
+        if (body.week !== undefined || body.start_hour !== undefined || body.end_hour !== undefined) {
+            const weekDays = parseWeekSafe(body.week ?? existing.week);
+            if (!weekDays) {
+                return reply.code(HTTP_BAD_REQUEST).send(apiError(API_CODE.BAD_REQUEST, "week must be array of 0-6"));
+            }
+            const overlapErr = checkOverlap(db, existing.mapping_group_id, id, weekDays, startH, endH);
+            if (overlapErr) {
+                return reply.code(HTTP_BAD_REQUEST).send(apiError(API_CODE.BAD_REQUEST, overlapErr));
+            }
+        }
+        const fields = {};
+        const UPDATE_FIELDS = ["name", "enabled", "week", "start_hour", "end_hour", "mapping_rule", "concurrency_rule"];
+        const bodyObj = body;
+        for (const key of UPDATE_FIELDS) {
+            if (bodyObj[key] !== undefined)
+                fields[key] = bodyObj[key];
+        }
+        updateSchedule(db, id, fields);
+        return reply.send({ success: true });
+    });
+    app.delete("/admin/api/schedules/:id", async (request, reply) => {
+        const { id } = request.params;
+        const existing = getScheduleById(db, id);
+        if (!existing)
+            return reply.code(HTTP_NOT_FOUND).send(apiError(API_CODE.NOT_FOUND, "Schedule not found"));
+        deleteSchedule(db, id);
+        return reply.send({ success: true });
+    });
+    app.post("/admin/api/schedules/:id/toggle", async (request, reply) => {
+        const { id } = request.params;
+        const existing = getScheduleById(db, id);
+        if (!existing)
+            return reply.code(HTTP_NOT_FOUND).send(apiError(API_CODE.NOT_FOUND, "Schedule not found"));
+        const newEnabled = existing.enabled ? 0 : 1;
+        updateSchedule(db, id, { enabled: newEnabled });
+        return reply.send({ success: true, enabled: newEnabled });
+    });
+    done();
+};

package/dist/admin/stats.js

@@ -10,6 +10,8 @@ const StatsQuerySchema = Type.Object({
     start_time: Type.Optional(Type.String()),
     end_time: Type.Optional(Type.String()),
     router_key_id: Type.Optional(Type.String()),
+    provider_id: Type.Optional(Type.String()),
+    backend_model: Type.Optional(Type.String()),
 });
 export const adminStatsRoutes = (app, options, done) => {
     app.get("/admin/api/stats", { schema: { querystring: StatsQuerySchema } }, async (request, reply) => {
@@ -21,12 +23,12 @@ export const adminStatsRoutes = (app, options, done) => {
             endTime = query.end_time;
         }
         else {
-            const range = resolveTimeRange((query.period ?? "weekly"), options.db, query.router_key_id);
+            const range = resolveTimeRange((query.period ?? "weekly"), options.db, query.router_key_id, query.provider_id);
             startTime = range.startTime;
             endTime = range.endTime;
         }
-        const stats = getStats(options.db, startTime, endTime, query.router_key_id);
-        return reply.send(stats);
+        const stats = getStats(options.db, startTime, endTime, query.router_key_id, query.provider_id, query.backend_model);
+        return reply.send({ ...stats, startTime, endTime });
     });
     done();
 };