llm-simple-router 1.0.11 → 1.0.13

package/dist/admin/dashboard.d.ts

@@ -1,7 +1,9 @@
 import { FastifyPluginCallback } from "fastify";
 import Database from "better-sqlite3";
+import type { StateRegistry } from "../core/registry.js";
 interface DashboardRoutesOptions {
     db: Database.Database;
+    stateRegistry?: StateRegistry;
 }
 export declare const adminDashboardRoutes: FastifyPluginCallback<DashboardRoutesOptions>;
 export {};

package/dist/admin/dashboard.js

@@ -1,5 +1,7 @@
 import { Type } from "@sinclair/typebox";
-import { getStats, getMetricsSummary, getMetricsTimeseries, getClientTypeBreakdown } from "../db/index.js";
+import { getStats, getMetricsSummary, getMetricsTimeseries, getClientTypeBreakdown, getAllProviders, getAllRouterKeys, computeBucketBoundary } from "../db/index.js";
+import { getSetting } from "../db/settings.js";
+import { serializeProviders } from "./providers.js";
 const OverviewQuerySchema = Type.Object({
     provider_id: Type.Optional(Type.String()),
     backend_model: Type.Optional(Type.String()),
@@ -10,84 +12,124 @@ const OverviewQuerySchema = Type.Object({
 });
 const PERCENT_MULTIPLIER = 100;
 const PCT_ROUND_DIGITS = 10;
-const PROVIDER_TOKEN_LOOKBACK_DAYS = 30;
+/** Compute overview stats (reused by both /overview and /init) */
+async function computeOverview(db, query) {
+    const startTime = query.start_time;
+    const endTime = query.end_time;
+    const providerId = query.provider_id || undefined;
+    const backendModel = query.backend_model || undefined;
+    const routerKeyId = query.router_key_id || undefined;
+    const clientType = query.client_type || undefined;
+    // 1. Current period stats
+    const stats = getStats(db, startTime, endTime, routerKeyId, providerId, backendModel, clientType);
+    // 2. Previous period stats (same duration, immediately before current window)
+    const durationMs = new Date(endTime).getTime() - new Date(startTime).getTime();
+    const prevEnd = startTime;
+    const prevStart = new Date(new Date(startTime).getTime() - durationMs).toISOString();
+    const prevStats = durationMs > 0
+        ? getStats(db, prevStart, prevEnd, routerKeyId, providerId, backendModel, clientType)
+        : null;
+    // 3. Timeseries (tps, input_tokens, output_tokens)
+    const legacyPeriod = "30d";
+    const [tpsRes, inputRes, outputRes] = await Promise.allSettled([
+        getMetricsTimeseries(db, legacyPeriod, "total_tps", providerId, backendModel, routerKeyId, startTime, endTime, clientType),
+        getMetricsTimeseries(db, legacyPeriod, "input_tokens", providerId, backendModel, routerKeyId, startTime, endTime, clientType),
+        getMetricsTimeseries(db, legacyPeriod, "output_tokens", providerId, backendModel, routerKeyId, startTime, endTime, clientType),
+    ]);
+    const tpsRes_ = tpsRes.status === "fulfilled" ? tpsRes.value : [];
+    const inputRes_ = inputRes.status === "fulfilled" ? inputRes.value : [];
+    const outputRes_ = outputRes.status === "fulfilled" ? outputRes.value : [];
+    // 4. Cache hit rate + client type breakdown
+    const summary = getMetricsSummary(db, legacyPeriod, providerId, backendModel, routerKeyId, startTime, endTime, clientType);
+    const totalInputTokens = summary.reduce((sum, r) => sum + r.total_input_tokens, 0);
+    const totalCacheHitTokens = summary.reduce((sum, r) => sum + r.total_cache_hit_tokens, 0);
+    const cacheHitRate = totalInputTokens > 0
+        ? Math.round(totalCacheHitTokens * PERCENT_MULTIPLIER / totalInputTokens * PCT_ROUND_DIGITS) / PCT_ROUND_DIGITS
+        : 0;
+    const breakdown = getClientTypeBreakdown(db, legacyPeriod, providerId, backendModel, routerKeyId, startTime, endTime);
+    // 5. Provider token summary (same time range as overview)
+    const providerTokenSummary = getProviderTokenSummary(db, startTime, endTime);
+    return {
+        stats: {
+            totalRequests: stats.totalRequests,
+            successRate: stats.successRate,
+            avgTps: stats.avgTps,
+            totalInputTokens: stats.totalInputTokens,
+            totalOutputTokens: stats.totalOutputTokens,
+            startTime,
+            endTime,
+        },
+        prev_stats: prevStats ? {
+            totalRequests: prevStats.totalRequests,
+            successRate: prevStats.successRate,
+            avgTps: prevStats.avgTps,
+            totalInputTokens: prevStats.totalInputTokens,
+            totalOutputTokens: prevStats.totalOutputTokens,
+        } : null,
+        cache_hit_rate: cacheHitRate,
+        client_type_breakdown: breakdown,
+        timeseries: {
+            tps: tpsRes_,
+            input_tokens: inputRes_,
+            output_tokens: outputRes_,
+        },
+        provider_token_summary: providerTokenSummary,
+    };
+}
 export const adminDashboardRoutes = (app, options, done) => {
-    const { db } = options;
-    app.get("/admin/api/dashboard/overview", { schema: { querystring: OverviewQuerySchema } }, async (request, reply) => {
+    const { db, stateRegistry } = options;
+    app.get("/admin/api/dashboard/init", { schema: { querystring: OverviewQuerySchema } }, async (request, reply) => {
         const query = request.query;
-        const startTime = query.start_time;
-        const endTime = query.end_time;
-        const providerId = query.provider_id || undefined;
-        const backendModel = query.backend_model || undefined;
-        const routerKeyId = query.router_key_id || undefined;
-        const clientType = query.client_type || undefined;
-        // 1. Current period stats
-        const stats = getStats(db, startTime, endTime, routerKeyId, providerId, backendModel, clientType);
-        // 2. Previous period stats (same duration, immediately before current window)
-        const durationMs = new Date(endTime).getTime() - new Date(startTime).getTime();
-        const prevEnd = startTime;
-        const prevStart = new Date(new Date(startTime).getTime() - durationMs).toISOString();
-        const prevStats = durationMs > 0
-            ? getStats(db, prevStart, prevEnd, routerKeyId, providerId, backendModel, clientType)
-            : null;
-        // 3. Timeseries (tps, input_tokens, output_tokens)
-        const legacyPeriod = "30d";
-        const [tpsRes, inputRes, outputRes] = await Promise.allSettled([
-            getMetricsTimeseries(db, legacyPeriod, "total_tps", providerId, backendModel, routerKeyId, startTime, endTime, clientType),
-            getMetricsTimeseries(db, legacyPeriod, "input_tokens", providerId, backendModel, routerKeyId, startTime, endTime, clientType),
-            getMetricsTimeseries(db, legacyPeriod, "output_tokens", providerId, backendModel, routerKeyId, startTime, endTime, clientType),
+        const [providersResult, routerKeysResult, overviewResult] = await Promise.allSettled([
+            (async () => {
+                const encryptionKey = getSetting(db, "encryption_key");
+                const providers = getAllProviders(db);
+                return serializeProviders(db, providers, encryptionKey, (id) => stateRegistry?.getProviderStatus(id) ?? { active: 0, queued: 0 });
+            })(),
+            Promise.resolve(getAllRouterKeys(db).map(rk => ({ id: rk.id, name: rk.name }))),
+            (async () => computeOverview(db, query))(),
         ]);
-        const tpsRes_ = tpsRes.status === "fulfilled" ? tpsRes.value : [];
-        const inputRes_ = inputRes.status === "fulfilled" ? inputRes.value : [];
-        const outputRes_ = outputRes.status === "fulfilled" ? outputRes.value : [];
-        // 4. Cache hit rate + client type breakdown
-        const summary = getMetricsSummary(db, legacyPeriod, providerId, backendModel, routerKeyId, startTime, endTime, clientType);
-        const totalInputTokens = summary.reduce((sum, r) => sum + r.total_input_tokens, 0);
-        const totalCacheHitTokens = summary.reduce((sum, r) => sum + r.total_cache_hit_tokens, 0);
-        const cacheHitRate = totalInputTokens > 0
-            ? Math.round(totalCacheHitTokens * PERCENT_MULTIPLIER / totalInputTokens * PCT_ROUND_DIGITS) / PCT_ROUND_DIGITS
-            : 0;
-        const breakdown = getClientTypeBreakdown(db, legacyPeriod, providerId, backendModel, routerKeyId, startTime, endTime);
-        // 5. Provider token summary (for provider sorting/labels in frontend)
-        const providerTokenSummary = getProviderTokenSummary(db);
         return reply.send({
-            stats: {
-                totalRequests: stats.totalRequests,
-                successRate: stats.successRate,
-                avgTps: stats.avgTps,
-                totalInputTokens: stats.totalInputTokens,
-                totalOutputTokens: stats.totalOutputTokens,
-                startTime,
-                endTime,
-            },
-            prev_stats: prevStats ? {
-                totalRequests: prevStats.totalRequests,
-                successRate: prevStats.successRate,
-                avgTps: prevStats.avgTps,
-                totalInputTokens: prevStats.totalInputTokens,
-                totalOutputTokens: prevStats.totalOutputTokens,
-            } : null,
-            cache_hit_rate: cacheHitRate,
-            client_type_breakdown: breakdown,
-            timeseries: {
-                tps: tpsRes_,
-                input_tokens: inputRes_,
-                output_tokens: outputRes_,
-            },
-            provider_token_summary: providerTokenSummary,
+            providers: providersResult.status === "fulfilled" ? providersResult.value : null,
+            router_keys: routerKeysResult.status === "fulfilled" ? routerKeysResult.value : null,
+            ...(overviewResult.status === "fulfilled" ? overviewResult.value : {
+                stats: null, prev_stats: null, cache_hit_rate: null,
+                client_type_breakdown: null, timeseries: null, provider_token_summary: null,
+            }),
         });
     });
+    app.get("/admin/api/dashboard/overview", { schema: { querystring: OverviewQuerySchema } }, async (request, reply) => {
+        const query = request.query;
+        return reply.send(await computeOverview(db, query));
+    });
     done();
 };
-/** Get per-provider total input tokens for last 30 days (for sorting/labels) */
-function getProviderTokenSummary(db) {
-    const rows = db.prepare(`SELECT provider_id, COALESCE(SUM(sum_input_tokens), 0) AS total_input_tokens
-     FROM metrics_10min
-     WHERE bucket_time >= datetime('now', '-' || ? || ' days')
-     GROUP BY provider_id`).all(PROVIDER_TOKEN_LOOKBACK_DAYS);
+/** Get per-provider total input tokens for the given time range (for sorting/labels).
+ *  Uses the same cross-boundary merge as getStats(): metrics_10min (settled) + request_metrics (current bucket).
+ */
+function getProviderTokenSummary(db, startTime, endTime) {
     const result = {};
-    for (const r of rows) {
-        result[r.provider_id] = r.total_input_tokens;
+    const boundary = computeBucketBoundary();
+    // 1. Aggregated data from metrics_10min (everything before the current bucket)
+    const aggEnd = endTime <= boundary ? endTime : boundary;
+    if (startTime < aggEnd) {
+        const rows = db.prepare(`SELECT provider_id, COALESCE(SUM(sum_input_tokens), 0) AS total_input_tokens
+       FROM metrics_10min
+       WHERE bucket_time >= datetime(?) AND bucket_time < datetime(?)
+       GROUP BY provider_id`).all(startTime, aggEnd);
+        for (const r of rows) {
+            result[r.provider_id] = (result[r.provider_id] ?? 0) + r.total_input_tokens;
+        }
+    }
+    // 2. Real-time data from request_metrics (current bucket to now)
+    if (endTime > boundary && boundary > startTime) {
+        const detailRows = db.prepare(`SELECT provider_id, COALESCE(SUM(input_tokens), 0) AS total_input_tokens
+       FROM request_metrics
+       WHERE created_at >= datetime(?) AND created_at < datetime(?)
+       GROUP BY provider_id`).all(boundary, endTime);
+        for (const r of detailRows) {
+            result[r.provider_id] = (result[r.provider_id] ?? 0) + r.total_input_tokens;
+        }
     }
     return result;
 }

package/dist/admin/groups.js

@@ -1,5 +1,7 @@
 import { Type } from "@sinclair/typebox";
-import { getAllMappingGroups, createMappingGroup, updateMappingGroup, deleteMappingGroup, getProviderById, getMappingGroupById, } from "../db/index.js";
+import { getAllMappingGroups, createMappingGroup, updateMappingGroup, deleteMappingGroup, getProviderById, getMappingGroupById, getAllProviders, } from "../db/index.js";
+import { getSetting } from "../db/settings.js";
+import { serializeProviders } from "./providers.js";
 import { HTTP_BAD_REQUEST, HTTP_CREATED, HTTP_CONFLICT, HTTP_NOT_FOUND } from "./constants.js";
 import { parseModels } from "../config/model-context.js";
 import { API_CODE, apiError } from "./api-response.js";
@@ -87,6 +89,13 @@ export const adminGroupRoutes = (app, options, done) => {
         const groups = getAllMappingGroups(db);
         return reply.send(groups);
     });
+    app.get("/admin/api/mapping-groups/init", async (_request, reply) => {
+        const groups = getAllMappingGroups(db);
+        const encryptionKey = getSetting(db, "encryption_key");
+        const providers = getAllProviders(db);
+        const serialized = serializeProviders(db, providers, encryptionKey);
+        return reply.send({ groups, providers: serialized });
+    });
     app.post("/admin/api/mapping-groups", { schema: { body: CreateGroupSchema } }, async (request, reply) => {
         const body = request.body;
         const validationError = validateRule(db, body.rule);

package/dist/admin/logs.js

@@ -1,5 +1,6 @@
 import { Type } from "@sinclair/typebox";
-import { getRequestLogs, getRequestLogsGrouped, getRequestLogById, getRequestLogChildren, deleteLogsBefore, extractThinkingLevel } from "../db/index.js";
+import { getRequestLogs, getRequestLogsGrouped, getRequestLogById, getRequestLogChildren, deleteLogsBefore, extractThinkingLevel, getAllProviders, getAllRouterKeys, getAllMappingGroups } from "../db/index.js";
+import { getLogRetentionDays } from "../db/settings.js";
 import { HTTP_NOT_FOUND } from "./constants.js";
 import { API_CODE, apiError } from "./api-response.js";
 const LogQuerySchema = Type.Object({
@@ -22,6 +23,34 @@ const DeleteLogsBeforeSchema = Type.Object({
 const DEFAULT_LOG_VIEW = "flat";
 export const adminLogRoutes = (app, options, done) => {
     const { db, logFileWriter } = options;
+    app.get("/admin/api/logs/init", async () => {
+        const [providersResult, routerKeysResult, groupsResult, retentionResult] = await Promise.allSettled([
+            Promise.resolve(getAllProviders(db).map(p => ({ id: p.id, name: p.name }))),
+            Promise.resolve(getAllRouterKeys(db).map(rk => ({ id: rk.id, name: rk.name }))),
+            (async () => {
+                const groups = getAllMappingGroups(db);
+                const clientModels = [...new Set(groups.filter(g => g.is_active).map(g => g.client_model))].sort();
+                const backendModels = [...new Set(groups.flatMap(g => {
+                        try {
+                            const rule = JSON.parse(g.rule);
+                            return (Array.isArray(rule.targets) ? rule.targets : []).map((t) => t.backend_model);
+                        }
+                        catch {
+                            return [];
+                        }
+                    }).filter(Boolean))].sort();
+                return { client_models: clientModels, backend_models: backendModels };
+            })(),
+            Promise.resolve(getLogRetentionDays(db)),
+        ]);
+        return {
+            providers: providersResult.status === "fulfilled" ? providersResult.value : null,
+            router_keys: routerKeysResult.status === "fulfilled" ? routerKeysResult.value : null,
+            client_models: groupsResult.status === "fulfilled" ? groupsResult.value.client_models : null,
+            backend_models: groupsResult.status === "fulfilled" ? groupsResult.value.backend_models : null,
+            log_retention_days: retentionResult.status === "fulfilled" ? retentionResult.value : null,
+        };
+    });
     app.get("/admin/api/logs", { schema: { querystring: LogQuerySchema } }, async (request, reply) => {
         const query = request.query;
         const page = parseInt(query.page || "1", 10);

package/dist/admin/monitor.js

@@ -8,6 +8,22 @@ export const adminMonitorRoutes = (app, options, done) => {
         done();
         return;
     }
+    app.get("/admin/api/monitor/init", async () => {
+        const [activeResult, recentResult, statsResult, concurrencyResult, runtimeResult] = await Promise.allSettled([
+            tracker.getActive(),
+            tracker.getRecent(),
+            tracker.getStats(),
+            tracker.getConcurrency(),
+            tracker.getRuntime(),
+        ]);
+        return {
+            active: activeResult.status === "fulfilled" ? activeResult.value : null,
+            recent: recentResult.status === "fulfilled" ? recentResult.value : null,
+            stats: statsResult.status === "fulfilled" ? statsResult.value : null,
+            concurrency: concurrencyResult.status === "fulfilled" ? concurrencyResult.value : null,
+            runtime: runtimeResult.status === "fulfilled" ? runtimeResult.value : null,
+        };
+    });
     app.get("/admin/api/monitor/active", async () => tracker.getActive());
     app.get("/admin/api/monitor/recent", async () => tracker.getRecent());
     app.get("/admin/api/monitor/stats", async () => tracker.getStats());

package/dist/admin/providers.d.ts

@@ -1,5 +1,6 @@
 import { FastifyPluginCallback } from "fastify";
 import Database from "better-sqlite3";
+import type { Provider } from "../db/index.js";
 import type { StateRegistry } from "../core/registry.js";
 import type { AdaptiveController } from "../core/concurrency/index.js";
 import type { RequestTracker } from "../core/monitor/index.js";
@@ -11,5 +12,39 @@ interface ProviderRoutesOptions {
     adaptiveController?: AdaptiveController;
     proxyAgentFactory?: ProxyAgentFactory;
 }
+/** 序列化 provider 列表，解密敏感字段、展开 models/endpoints。供多个端点复用 */
+export declare function serializeProviders(db: Database.Database, providers: Provider[], encryptionKey: string, concurrencyStatus?: (id: string) => {
+    active: number;
+    queued: number;
+}): {
+    id: string;
+    name: string;
+    api_type: "anthropic" | "openai" | "openai-responses";
+    base_url: string;
+    upstream_path: string | null;
+    api_key: string;
+    models: import("../config/model-context.js").ModelInfo[];
+    is_active: number;
+    max_concurrency: number;
+    queue_timeout_ms: number;
+    max_queue_size: number;
+    adaptive_enabled: number;
+    proxy_type: string | null;
+    proxy_url: string | null;
+    proxy_username: string | null;
+    proxy_password: string | null;
+    endpoints: {
+        api_type: import("../core/types.js").ApiType;
+        base_url: string;
+        upstream_path: string | null;
+        api_key: string;
+    }[];
+    concurrency_status: {
+        active: number;
+        queued: number;
+    };
+    created_at: string;
+    updated_at: string;
+}[];
 export declare const adminProviderRoutes: FastifyPluginCallback<ProviderRoutesOptions>;
 export {};

package/dist/admin/providers.js

@@ -1,11 +1,12 @@
 import { Type } from "@sinclair/typebox";
 import { getAllProviders, getProviderById, createProvider, updateProvider, deleteProvider, getAllMappingGroups, updateMappingGroup, PROVIDER_CONCURRENCY_DEFAULTS } from "../db/index.js";
 import { parseEndpoints, serializeEndpoints } from "../db/providers.js";
+import { getRecommendedProviders } from "../config/recommended.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, HTTP_OK } from "./constants.js";
 import { API_CODE, apiError } from "./api-response.js";
-import { parseModels, buildModelInfoList, normalizePatchName } from "../config/model-context.js";
+import { parseModels, buildModelInfoList, normalizePatchName, lookupCapabilities } from "../config/model-context.js";
 import { getModelInfoForProvider, setModelInfoForProvider, deleteAllModelInfoForProvider } from "../db/model-info.js";
 import { buildUpstreamHeaders } from "../proxy/proxy-core.js";
 import { callGet } from "../proxy/transport/http.js";
@@ -268,42 +269,62 @@ async function handleCreateProvider(body, reply, deps) {
     });
     return reply.code(HTTP_CREATED).send({ id });
 }
+/** 序列化 provider 列表，解密敏感字段、展开 models/endpoints。供多个端点复用 */
+export function serializeProviders(db, providers, encryptionKey, concurrencyStatus) {
+    return providers.map((s) => {
+        const modelEntries = parseModels(s.models || "[]");
+        const overrides = new Map(getModelInfoForProvider(db, s.id).map(m => [m.model_name, m.context_window]));
+        return {
+            id: s.id,
+            name: s.name,
+            api_type: s.api_type,
+            base_url: s.base_url,
+            upstream_path: s.upstream_path,
+            api_key: s.api_key ? decrypt(s.api_key, encryptionKey) : "",
+            models: buildModelInfoList(modelEntries, overrides),
+            is_active: s.is_active,
+            max_concurrency: s.max_concurrency,
+            queue_timeout_ms: s.queue_timeout_ms,
+            max_queue_size: s.max_queue_size,
+            adaptive_enabled: s.adaptive_enabled,
+            proxy_type: s.proxy_type,
+            proxy_url: s.proxy_url,
+            proxy_username: s.proxy_username ? decrypt(s.proxy_username, encryptionKey) : null,
+            proxy_password: s.proxy_password ? decrypt(s.proxy_password, encryptionKey) : null,
+            endpoints: parseEndpoints(s.endpoints).map(ep => ({
+                api_type: ep.api_type,
+                base_url: ep.base_url,
+                upstream_path: ep.upstream_path ?? null,
+                api_key: ep.api_key ? decrypt(ep.api_key, encryptionKey) : "",
+            })),
+            concurrency_status: concurrencyStatus?.(s.id) ?? { active: 0, queued: 0 },
+            created_at: s.created_at,
+            updated_at: s.updated_at,
+        };
+    });
+}
 export const adminProviderRoutes = (app, options, done) => {
     const { db, stateRegistry, tracker, adaptiveController, proxyAgentFactory } = options;
     app.get("/admin/api/providers", async (_request, reply) => {
         const encryptionKey = getSetting(db, "encryption_key");
         const providers = getAllProviders(db);
-        return reply.send(providers.map((s) => {
-            const modelEntries = parseModels(s.models || "[]");
-            const overrides = new Map(getModelInfoForProvider(db, s.id).map(m => [m.model_name, m.context_window]));
-            return {
-                id: s.id,
-                name: s.name,
-                api_type: s.api_type,
-                base_url: s.base_url,
-                upstream_path: s.upstream_path,
-                api_key: s.api_key ? decrypt(s.api_key, encryptionKey) : "",
-                models: buildModelInfoList(modelEntries, overrides),
-                is_active: s.is_active,
-                max_concurrency: s.max_concurrency,
-                queue_timeout_ms: s.queue_timeout_ms,
-                max_queue_size: s.max_queue_size,
-                adaptive_enabled: s.adaptive_enabled,
-                proxy_type: s.proxy_type,
-                proxy_url: s.proxy_url,
-                proxy_username: s.proxy_username ? decrypt(s.proxy_username, encryptionKey) : null,
-                proxy_password: s.proxy_password ? decrypt(s.proxy_password, encryptionKey) : null,
-                endpoints: parseEndpoints(s.endpoints).map(ep => ({
-                    api_type: ep.api_type,
-                    base_url: ep.base_url,
-                    upstream_path: ep.upstream_path ?? null,
-                    api_key: ep.api_key ? decrypt(ep.api_key, encryptionKey) : "",
-                })),
-                concurrency_status: stateRegistry?.getProviderStatus(s.id) ?? { active: 0, queued: 0 },
-                created_at: s.created_at,
-                updated_at: s.updated_at,
-            };
-        }));
+        return reply.send(serializeProviders(db, providers, encryptionKey, (id) => stateRegistry?.getProviderStatus(id) ?? { active: 0, queued: 0 }));
+    });
+    app.get("/admin/api/providers/init", async (_request, reply) => {
+        const encryptionKey = getSetting(db, "encryption_key");
+        const providers = getAllProviders(db);
+        const serialized = serializeProviders(db, providers, encryptionKey, (id) => stateRegistry?.getProviderStatus(id) ?? { active: 0, queued: 0 });
+        const recommended = getRecommendedProviders();
+        for (const group of recommended) {
+            for (const preset of group.presets) {
+                const capMap = {};
+                for (const m of preset.models) {
+                    capMap[m] = lookupCapabilities(m);
+                }
+                preset.modelCapabilities = capMap;
+            }
+        }
+        return reply.send({ providers: serialized, recommended });
     });
     app.post("/admin/api/providers", { schema: { body: CreateProviderSchema } }, async (request, reply) => {
         return handleCreateProvider(request.body, reply, { db, stateRegistry, tracker, adaptiveController });

package/dist/admin/proxy-enhancement.js

@@ -1,6 +1,8 @@
 import { Type } from "@sinclair/typebox";
 import { getSetting, setSetting } from "../db/settings.js";
 import { clearEnhancementConfigCache } from "../proxy/routing/enhancement-config.js";
+import { getAllProviders } from "../db/index.js";
+import { serializeProviders } from "./providers.js";
 const UpdateProxyEnhancementSchema = Type.Object({
     tool_call_loop_enabled: Type.Boolean(),
     stream_loop_enabled: Type.Boolean(),
@@ -59,5 +61,40 @@ export const adminProxyEnhancementRoutes = (app, options, done) => {
         }
         return reply.send({ success: true });
     });
+    app.get("/admin/api/proxy-enhancement/init", async (_request, reply) => {
+        // config
+        const raw = getSetting(db, "proxy_enhancement");
+        const defaults = { tool_call_loop_enabled: false, stream_loop_enabled: false, tool_round_limit_enabled: true, tool_error_logging_enabled: false };
+        let config = defaults;
+        if (raw) {
+            try {
+                const parsed = JSON.parse(raw);
+                config = {
+                    tool_call_loop_enabled: parsed.tool_call_loop_enabled ?? false,
+                    stream_loop_enabled: parsed.stream_loop_enabled ?? false,
+                    tool_round_limit_enabled: parsed.tool_round_limit_enabled ?? true,
+                    tool_error_logging_enabled: parsed.tool_error_logging_enabled ?? false,
+                };
+            }
+            catch { /* eslint-disable-line taste/no-silent-catch -- 损坏的 JSON，回退默认 */ }
+        }
+        const aiConfigRaw = getSetting(db, "ai_retry_config");
+        let aiRetryConfig = null;
+        if (aiConfigRaw) {
+            try {
+                aiRetryConfig = JSON.parse(aiConfigRaw);
+            }
+            catch (e) {
+                console.error('proxyEnhancementInit.parseAiConfig:', e);
+                aiRetryConfig = null;
+            }
+        }
+        const fullConfig = { ...config, ai_retry_config: aiRetryConfig };
+        // providers — simplified list with id, name, models for AI Retry selection
+        const encryptionKey = getSetting(db, "encryption_key");
+        const providers = getAllProviders(db);
+        const serializedProviders = serializeProviders(db, providers, encryptionKey);
+        return reply.send({ config: fullConfig, providers: serializedProviders });
+    });
     done();
 };

package/dist/admin/quick-setup.js

@@ -7,6 +7,10 @@ import { createRetryRule } from "../db/retry-rules.js";
 import { upsertTransformRule } from "../db/transform-rules.js";
 import { encrypt } from "../utils/crypto.js";
 import { getSetting } from "../db/settings.js";
+import { getRecommendedProviders, getRecommendedRetryRules } from "../config/recommended.js";
+import { lookupCapabilities } from "../config/model-context.js";
+import { getAllMappingGroups, getAllProviders } from "../db/index.js";
+import { serializeProviders } from "./providers.js";
 import { HTTP_CREATED, HTTP_BAD_REQUEST, HTTP_BAD_GATEWAY, HTTP_CONFLICT } from "./constants.js";
 import { API_CODE, apiError } from "./api-response.js";
 const PROVIDER_NAME_RE = /^[a-zA-Z0-9_-]+$/;
@@ -224,6 +228,35 @@ export const adminQuickSetupRoutes = (app, options, done) => {
         });
         return reply.code(HTTP_CREATED).send({ success: true, provider_id: providerId });
     });
+    app.get("/admin/api/quick-setup/init", async (_request, reply) => {
+        // provider_groups (recommended providers with capabilities)
+        const groups = getRecommendedProviders();
+        for (const group of groups) {
+            for (const preset of group.presets) {
+                const capMap = {};
+                for (const m of preset.models) {
+                    capMap[m] = lookupCapabilities(m);
+                }
+                preset.modelCapabilities = capMap;
+            }
+        }
+        // recommended_rules (with exists flag)
+        const rules = getRecommendedRetryRules();
+        const existing = new Set(db.prepare("SELECT name FROM retry_rules").all().map((r) => r.name));
+        const recommendedRules = rules.map(r => ({ ...r, exists: existing.has(r.name) }));
+        // existing_mappings
+        const existingMappings = getAllMappingGroups(db);
+        // existing_providers
+        const encryptionKey = getSetting(db, "encryption_key");
+        const providers = getAllProviders(db);
+        const serializedProviders = serializeProviders(db, providers, encryptionKey);
+        return reply.send({
+            provider_groups: groups,
+            recommended_rules: recommendedRules,
+            existing_mappings: existingMappings,
+            existing_providers: serializedProviders,
+        });
+    });
     // ---------- Test Connection ----------
     const TestConnectionSchema = Type.Object({
         api_type: Type.Union([Type.Literal("openai"), Type.Literal("openai-responses"), Type.Literal("anthropic")]),

package/dist/admin/retry-rules.js

@@ -1,5 +1,6 @@
 import { Type } from "@sinclair/typebox";
-import { getAllRetryRules, getRetryRuleById, createRetryRule, updateRetryRule, deleteRetryRule, } from "../db/index.js";
+import { getAllRetryRules, getRetryRuleById, createRetryRule, updateRetryRule, deleteRetryRule, getAllProviders, } from "../db/index.js";
+import { getRecommendedRetryRules } from "../config/recommended.js";
 import { callLLM } from "../utils/llm-client.js";
 import { getActiveRetryRules } from "../db/retry-rules.js";
 import { getRequestLogById } from "../db/logs.js";
@@ -270,6 +271,17 @@ export const adminRetryRuleRoutes = (app, options, done) => {
         const rules = getAllRetryRules(db);
         return reply.send(rules);
     });
+    app.get("/admin/api/retry-rules/init", async (_request, reply) => {
+        const rules = getAllRetryRules(db);
+        const providers = getAllProviders(db).map(p => ({ id: p.id, name: p.name }));
+        const recommendedRaw = getRecommendedRetryRules();
+        const existing = new Set(db.prepare("SELECT name FROM retry_rules").all().map(r => r.name));
+        const recommended_rules = recommendedRaw.map(r => ({
+            ...r,
+            exists: existing.has(r.name),
+        }));
+        return reply.send({ rules, providers, recommended_rules });
+    });
     app.post("/admin/api/retry-rules", { schema: { body: CreateRetryRuleSchema } }, async (request, reply) => {
         const body = request.body;
         const regexError = validateBodyPattern(body.body_pattern);

package/dist/admin/router-keys.js

@@ -89,6 +89,12 @@ export const adminRouterKeyRoutes = (app, options, done) => {
         deleteRouterKey(db, id);
         return reply.send({ success: true });
     });
+    app.get("/admin/api/router-keys/init", async (_request, reply) => {
+        const keys = getAllRouterKeys(db);
+        const serialized = keys.map((rk) => toPublicRouterKey(rk, db));
+        const availableModels = getAvailableModels(db);
+        return reply.send({ keys: serialized, available_models: availableModels });
+    });
     app.get("/admin/api/models/available", async (_request, reply) => {
         const models = getAvailableModels(db);
         return reply.send(models);

package/dist/admin/routes.js

@@ -42,7 +42,7 @@ export const adminRoutes = (app, options, done) => {
     app.register(adminUsageRoutes, { db: options.db });
     app.register(adminQuickSetupRoutes, { db: options.db, stateRegistry: options.stateRegistry, tracker: options.tracker, adaptiveController: options.adaptiveController });
     app.register(adminUpgradeRoutes, { db: options.db, closeFn: options.closeFn ?? (async () => { }) });
-    app.register(adminDashboardRoutes, { db: options.db });
+    app.register(adminDashboardRoutes, { db: options.db, stateRegistry: options.stateRegistry });
     app.register(adminTransformRuleRoutes, { db: options.db, pluginRegistry: options.pluginRegistry });
     // Pipeline hooks 查询
     app.get("/admin/api/pipeline/hooks", async () => {

package/dist/admin/schedules.js

@@ -1,6 +1,8 @@
 import { Type } from "@sinclair/typebox";
-import { getSchedulesByGroup, getAllSchedules, getScheduleById, createSchedule, updateSchedule, deleteSchedule, } from "../db/index.js";
+import { getSchedulesByGroup, getAllSchedules, getScheduleById, createSchedule, updateSchedule, deleteSchedule, getAllMappingGroups, getAllProviders, } from "../db/index.js";
 import { getMappingGroupById, getProviderById } from "../db/index.js";
+import { serializeProviders } from "./providers.js";
+import { getSetting } from "../db/settings.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({
@@ -227,5 +229,13 @@ export const adminScheduleRoutes = (app, options, done) => {
         updateSchedule(db, id, { enabled: newEnabled });
         return reply.send({ success: true, enabled: newEnabled });
     });
+    app.get("/admin/api/schedules/init", async (_request, reply) => {
+        const schedules = getAllSchedules(db);
+        const mappingGroups = getAllMappingGroups(db);
+        const encryptionKey = getSetting(db, "encryption_key");
+        const providers = getAllProviders(db);
+        const serializedProviders = serializeProviders(db, providers, encryptionKey);
+        return reply.send({ schedules, mapping_groups: mappingGroups, providers: serializedProviders });
+    });
     done();
 };