llm-simple-router 0.3.7 → 0.4.1

package/README.md

@@ -1,76 +1,90 @@
 # LLM Simple Router
 
-> **Status: Active Development**
->
-> 核心代理、模型映射、自动重试、多密钥管理、请求日志、性能指标已完成。
-> 代码规范 githook 检查已集成。欢迎试用和反馈。
+LLM API 代理路由器。接收 Claude Code / Cursor 等客户端请求，通过模型映射和路由策略转发到配置的后端 Provider，支持流式（SSE）和非流式代理。
 
-## 解决的核心问题
+**解决的核心问题**：国产模型限流频繁、多供应商切换麻烦、并发控制缺失。
 
-个人使用 Claude Code 配合国产模型时的实际痛点：
+## 适合谁
 
-- **自动重试** — 国产模型限流、网络错误频繁，对可恢复错误（429/500/网络超时）自动指数退避重试
-- **多供应商模型映射** — 高峰期主模型不可用时，将 claude-opus 映射到 GLM，claude-sonnet 映射到 Kimi 等，低谷期再切回来
-- **多密钥隔离** — 为不同使用方分配独立密钥，按密钥筛选日志和性能指标
+- 用 Claude Code 配合国产模型（智谱、Moonshot、Minimax 等）的开发者
+- 希望自动重试限流错误、分时段切换模型、控制并发排队
+- 想要一个开箱即用的方案，不折腾
 
-## 功能
+## 功能一览
 
 | 功能 | 说明 |
 |------|------|
-| 模型映射 | 客户端模型名 -> 后端模型名 + 供应商，支持分组和优先级 |
-| 自动重试 | 429/500/网络错误自动重试，指数退避，可配置次数和间隔 |
-| 多供应商 | 配置多个后端供应商，按模型映射路由 |
-| 多密钥 (Router Keys) | 为不同使用方创建独立密钥，支持模型白名单 |
-| 流式代理 | 完整支持 SSE 流式和非流式请求 |
-| 供应商并发控制 | 按 Provider 维度限制并发数、队列长度和超时，防止单一供应商过载 |
-| 实时监控 | SSE 推送活跃请求、延迟热力图、Token 吞吐、运行时资源指标 |
-| 代理增强 (实验性) | 注入系统指令、会话记忆、模型锁定等增强功能 |
-| 管理后台 | Vue 3 + shadcn-vue Web UI，管理供应商、映射、密钥 |
-| 请求日志 | 结构化展示完整四阶段链路（客户端请求/上游请求/上游响应/客户端响应），适配 Claude Code 请求格式 |
-| 性能指标 | TTFT、吞吐量、Token 用量、缓存命中率，支持按模型/密钥筛选 |
+| 自动重试 | 对 429/400/网络超时自动指数退避重试，默认针对智谱模型配置 |
+| 多供应商支持 | 智谱、Moonshot、Minimax、火山引擎、阿里云、腾讯云等，Coding Plan 选择后自动填写 |
+| 模型分时段映射 | 按时间段自动切换后端模型（如高峰期切到 Kimi，低谷期切回 GLM） |
+| 并发队列等待 | 按 Provider 配置并发数上限，超限请求排队等待 |
+| Failover 故障转移 | 多 Provider 互备，失败自动切换下一个 |
+| 实时请求监控 | SSE 推送活跃请求、队列状态、流式输出实时查看 |
+| 多密钥管理 | 独立密钥 + 模型白名单，支持多用户/多项目 |
+| 请求日志 | 四阶段完整链路（客户端请求/上游请求/上游响应/客户端响应） |
+| 性能指标 | TTFT、TPS、Token 用量、缓存命中率 |
 
 > **API 兼容性：** 支持 Anthropic 兼容 API（已适配 Claude Code）。OpenAI 兼容 API（`/v1/chat/completions`）尚未充分测试。
 
-## 管理后台预览
+## 管理后台
 
-| Dashboard | Provider 管理 |
-|-----------|-------------|
-| ![Dashboard](docs/screenshot/dashboard.png) | ![Provider](docs/screenshot/provider.png) |
+| Provider 管理 + 并发控制 | 实时监控 |
+|---|---|
+| ![Provider](docs/screenshot/provider_concurrency.png) | ![Monitor](docs/screenshot/monitor.png) |
 
-| 供应商并发控制 | 实时监控 |
-|--------------|---------|
-| ![Provider Concurrency](docs/screenshot/provider_concurrency.png) | ![Monitor](docs/screenshot/monitor.png) |
+| 模型映射 | 重试规则 |
+|---|---|
+| ![Mapping](docs/screenshot/model_mapping.png) | ![Retry](docs/screenshot/retry.png) |
+
+| Dashboard | 请求日志 |
+|---|---|
+| ![Dashboard](docs/screenshot/dashboard.png) | ![Logs](docs/screenshot/log.png) |
 
 | 代理增强 (实验性) |
 |-----------------|
 | ![Proxy Enhancement](docs/screenshot/proxy_enhance.png) |
 
-| 模型映射 | 重试规则 |
-|---------|--------|
-| ![Model Mapping](docs/screenshot/model_mapping.png) | ![Retry](docs/screenshot/retry.png) |
-
-| 请求日志 |
-|---------|
-| ![Logs](docs/screenshot/log.png) |
+## 快速开始
 
-## 工作原理
+### 1. 启动 Router
 
+```bash
+npx llm-simple-router
 ```
-Claude Code -> Router (模型映射 + 自动重试) -> 智谱 GLM / Kimi / 其他供应商
-```
 
-Router 根据模型映射找到后端供应商 -> 转发请求 -> 自动重试失败请求 -> 记录日志和性能指标 -> 返回响应。
+访问 http://localhost:9981/admin ，首次进入 Setup 页面设置管理员密码。数据存储在 `~/.llm-simple-router/`。
+
+### 2. 配置 Provider
+
+管理后台 > Provider 页面 > 添加 Provider。选择 Coding Plan 后会自动填写 Base URL，只需填入 API Key。
 
-## 典型使用场景
+### 3. 配置模型映射
 
-### Claude Code 配置
+管理后台 > 模型映射页面。示例配置：
 
-通过环境变量将 Claude Code 指向 Router：
+| 客户端模型 | 后端模型 | 供应商 | 时间窗口 |
+|-----------|---------|--------|---------|
+| sonnet | glm-5.1 | 智谱 | 全天 |
+| sonnet | kimi-for-coding | Moonshot | 14:00-18:00 |
+
+客户端模型是指 Claude Code 实际请求的模型名（由 `ANTHROPIC_MODEL` 等环境变量决定）。
+
+### 4. 配置 Claude Code
+
+在管理后台创建 Router API 密钥，然后选择一种方式配置：
 
 **方式一：shell alias（推荐）**
 
 ```bash
-alias clodedev='ANTHROPIC_AUTH_TOKEN="<your-router-key>" ANTHROPIC_BASE_URL="http://127.0.0.1:9981" claude'
+alias clode='\
+export ANTHROPIC_AUTH_TOKEN="<your-router-key>" && \
+export ANTHROPIC_BASE_URL="http://127.0.0.1:9981" && \
+export ANTHROPIC_MODEL="<your-default-model>" && \
+export ANTHROPIC_DEFAULT_OPUS_MODEL="<your-opus-model>" && \
+export ANTHROPIC_DEFAULT_SONNET_MODEL="<your-sonnet-model>" && \
+export ANTHROPIC_DEFAULT_HAIKU_MODEL="<your-haiku-model>" && \
+export ANTHROPIC_SMALL_FAST_MODEL="<your-fast-model>" && \
+claude'
 ```
 
 **方式二：~/.claude/settings.json**
@@ -78,53 +92,108 @@ alias clodedev='ANTHROPIC_AUTH_TOKEN="<your-router-key>" ANTHROPIC_BASE_URL="htt
 ```json
 {
   "env": {
-    "ANTHROPIC_AUTH_TOKEN": "sk-router-change-me",
+    "ANTHROPIC_AUTH_TOKEN": "<your-router-key>",
     "ANTHROPIC_BASE_URL": "http://127.0.0.1:9981",
-    "ANTHROPIC_MODEL": "some-model"
+    "ANTHROPIC_MODEL": "<your-default-model>",
+    "ANTHROPIC_DEFAULT_OPUS_MODEL": "<your-opus-model>",
+    "ANTHROPIC_DEFAULT_SONNET_MODEL": "<your-sonnet-model>",
+    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "<your-haiku-model>",
+    "ANTHROPIC_SMALL_FAST_MODEL": "<your-fast-model>"
   }
 }
 ```
 
-将 `<your-router-key>` 替换为管理后台中创建的 Router Key。
-
-### 管理后台配置模型映射
+### 5. 使用
 
-| 客户端模型 | 后端模型 | 供应商 | 时间窗口 |
-|-----------|---------|--------|---------|
-| opus | glm-5.1 | 智谱 | / |
-| sonnet | glm-5.1 | 智谱 | / |
-| sonnet | kimi-for-coding | Moonshot | 14:00-18:00 |
-| sonnet | glm-5-turbo | 智谱 | / |
+```bash
+# 方式一用户直接用 alias
+clode
 
-高峰期 GLM 3倍用量，且频繁超限时，将 sonnet 切到 Kimi；低谷期切回 GLM。
+# 方式二用户正常启动 claude
+claude
+```
 
-## 快速开始
+## Docker 部署
 
 ```bash
-# 一行命令启动
-npx llm-simple-router
-# 访问 http://localhost:9981/admin
-# 首次访问会进入 Setup 页面设置管理员密码
+docker compose up -d
 ```
 
-无需任何环境变量。数据默认存储在 `~/.llm-simple-router/`。
+环境变量通过 Setup 页面设置，不需要 `.env` 文件。
 
-## Docker 部署
+## 工作原理
 
-```bash
-docker compose up -d
+```
+Claude Code → Router (模型映射 + 自动重试 + 并发控制) → 智谱 GLM / Kimi / 其他供应商
+```
+
+Router 根据模型映射找到后端供应商 → 转发请求 → 自动重试失败请求 → 记录日志和性能指标 → 返回响应。
+
+### 架构图
+
+**系统上下文**（[详细说明](docs/system-context.md)）：
+
+```mermaid
+graph LR
+    Clients["Claude Code / Cursor / 其他客户端"]
+    Admin["管理员"]
+    Router>"LLM Simple Router"]
+    Providers>"智谱 / Moonshot / OpenAI / Anthropic / ..."]
+
+    Clients -->|"API 请求<br/>Bearer Token"| Router
+    Admin -->|"管理后台<br/>/admin/"| Router
+    Router -->|"转发请求<br/>SSE 流式"| Providers
 ```
 
+**请求处理流水线**（[详细说明](docs/request-pipeline.md)）：
+
+```mermaid
+flowchart LR
+    A[客户端请求] --> B[认证]
+    B --> C[模型映射<br/>+ 路由策略]
+    C --> D[并发排队]
+    D --> E[调用上游<br/>失败自动重试]
+    E --> F[记录日志<br/>+ 指标]
+    F --> G[返回响应]
+
+    E -.->|失败| C
+```
+
+Router 收到请求后：认证 → 按映射规则找到后端 Provider → 排队控制并发 → 转发到上游（失败自动重试，Failover 策略下会切换 Provider）→ 记录日志和指标 → 返回响应。
+
 ## 环境变量
 
-所有密钥（管理员密码、加密密钥、JWT 密钥）通过首次启动的 Setup 页面设置，无需环境变量。
-
-| 变量 | 必需 | 默认值 | 说明 |
-|------|------|--------|------|
-| `PORT` | No | `9981` | 服务端口 |
-| `DB_PATH` | No | `~/.llm-simple-router/router.db` | SQLite 数据库路径 |
-| `LOG_LEVEL` | No | `info` | 日志级别 |
-| `TZ` | No | `Asia/Shanghai` | 时区设置 |
-| `STREAM_TIMEOUT_MS` | No | `3000000` | 流式代理空闲超时（ms） |
-| `RETRY_MAX_ATTEMPTS` | No | `3` | 最大重试次数 |
-| `RETRY_BASE_DELAY_MS` | No | `1000` | 重试基础延迟（ms） |
+所有密钥通过 Setup 页面设置，以下为可选配置：
+
+| 变量 | 默认值 | 说明 |
+|------|--------|------|
+| `PORT` | `9981` | 服务端口 |
+| `DB_PATH` | `~/.llm-simple-router/router.db` | SQLite 数据库路径 |
+| `LOG_LEVEL` | `info` | 日志级别 |
+| `TZ` | `Asia/Shanghai` | 时区设置 |
+| `STREAM_TIMEOUT_MS` | `3000000` | 流式代理空闲超时（ms） |
+| `RETRY_MAX_ATTEMPTS` | `3` | 最大重试次数 |
+| `RETRY_BASE_DELAY_MS` | `1000` | 重试基础延迟（ms） |
+
+## 开发
+
+```bash
+# 后端（热重载）
+npm run dev
+
+# 前端（热重载，代理 API 到后端 :9980）
+cd frontend && npm run dev
+
+# 构建
+npm run build:full
+
+# 测试
+npm test
+
+# Lint
+npm run lint
+```
+
+## License
+
+MIT

package/dist/admin/constants.d.ts

@@ -1,10 +1,3 @@
 import type { FastifyReply } from "fastify";
-export declare const HTTP_BAD_REQUEST = 400;
-export declare const HTTP_CREATED = 201;
-export declare const HTTP_FORBIDDEN = 403;
-export declare const HTTP_NOT_FOUND = 404;
-export declare const HTTP_CONFLICT = 409;
-export declare const HTTP_INTERNAL_ERROR = 500;
-export declare const HTTP_BAD_GATEWAY = 502;
-export declare const HTTP_SERVICE_UNAVAILABLE = 503;
+export { 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,11 +1,5 @@
-export const HTTP_BAD_REQUEST = 400;
-export const HTTP_CREATED = 201;
-export const HTTP_FORBIDDEN = 403;
-export const HTTP_NOT_FOUND = 404;
-export const HTTP_CONFLICT = 409;
-export const HTTP_INTERNAL_ERROR = 500;
-export const HTTP_BAD_GATEWAY = 502;
-export const HTTP_SERVICE_UNAVAILABLE = 503;
+// 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/logs.js

@@ -1,5 +1,5 @@
 import { Type } from "@sinclair/typebox";
-import { getRequestLogs, getRequestLogById, deleteLogsBefore } from "../db/index.js";
+import { getRequestLogs, getRequestLogsGrouped, getRequestLogById, getRequestLogChildren, deleteLogsBefore } from "../db/index.js";
 import { HTTP_NOT_FOUND } from "./constants.js";
 const LogQuerySchema = Type.Object({
     page: Type.Optional(Type.String()),
@@ -7,23 +7,35 @@ const LogQuerySchema = Type.Object({
     api_type: Type.Optional(Type.String()),
     model: Type.Optional(Type.String()),
     router_key_id: Type.Optional(Type.String()),
+    provider_id: Type.Optional(Type.String()),
+    start_time: Type.Optional(Type.String()),
+    end_time: Type.Optional(Type.String()),
+    view: Type.Optional(Type.Literal("grouped")),
 });
 const DeleteLogsBeforeSchema = Type.Object({
     before: Type.String({ minLength: 1 }),
 });
+const DEFAULT_LOG_VIEW = "flat";
 export const adminLogRoutes = (app, options, done) => {
     const { db } = options;
     app.get("/admin/api/logs", { schema: { querystring: LogQuerySchema } }, async (request, reply) => {
         const query = request.query;
         const page = parseInt(query.page || "1", 10);
         const limit = parseInt(query.limit || "20", 10);
-        const result = getRequestLogs(db, {
+        const view = query.view || DEFAULT_LOG_VIEW;
+        const listOptions = {
             page,
             limit,
             api_type: query.api_type || undefined,
             model: query.model || undefined,
             router_key_id: query.router_key_id || undefined,
-        });
+            provider_id: query.provider_id || undefined,
+            start_time: query.start_time || undefined,
+            end_time: query.end_time || undefined,
+        };
+        const result = view === "grouped"
+            ? getRequestLogsGrouped(db, listOptions)
+            : getRequestLogs(db, listOptions);
         return reply.send({ ...result, page, limit });
     });
     app.get("/admin/api/logs/:id", async (request, reply) => {
@@ -32,7 +44,16 @@ export const adminLogRoutes = (app, options, done) => {
         if (!log) {
             return reply.code(HTTP_NOT_FOUND).send({ error: { message: "Log not found" } });
         }
-        return reply.send(log);
+        return reply.send({ data: log });
+    });
+    app.get("/admin/api/logs/:id/children", async (request, reply) => {
+        const params = request.params;
+        const parent = getRequestLogById(db, params.id);
+        if (!parent) {
+            return reply.code(HTTP_NOT_FOUND).send({ error: { message: "Log not found" } });
+        }
+        const rows = getRequestLogChildren(db, params.id);
+        return reply.send({ data: rows });
     });
     app.delete("/admin/api/logs/before", { schema: { body: DeleteLogsBeforeSchema } }, async (request, reply) => {
         const body = request.body;

package/dist/admin/metrics.js

@@ -1,7 +1,7 @@
 import { Type } from "@sinclair/typebox";
 import { getMetricsSummary, getMetricsTimeseries } from "../db/index.js";
 const PeriodEnum = Type.Union([
-    Type.Literal("1h"), Type.Literal("6h"), Type.Literal("24h"),
+    Type.Literal("1h"), Type.Literal("5h"), Type.Literal("6h"), Type.Literal("24h"),
     Type.Literal("7d"), Type.Literal("30d"),
 ]);
 const MetricEnum = Type.Union([
@@ -15,6 +15,8 @@ const SummaryQuerySchema = Type.Object({
     provider_id: Type.Optional(Type.String()),
     backend_model: Type.Optional(Type.String()),
     router_key_id: Type.Optional(Type.String()),
+    start_time: Type.Optional(Type.String()),
+    end_time: Type.Optional(Type.String()),
 });
 const TimeseriesQuerySchema = Type.Object({
     period: Type.Optional(PeriodEnum),
@@ -22,19 +24,21 @@ const TimeseriesQuerySchema = Type.Object({
     provider_id: Type.Optional(Type.String()),
     backend_model: Type.Optional(Type.String()),
     router_key_id: Type.Optional(Type.String()),
+    start_time: Type.Optional(Type.String()),
+    end_time: Type.Optional(Type.String()),
 });
 export const adminMetricsRoutes = (app, options, done) => {
     app.get("/admin/api/metrics/summary", { schema: { querystring: SummaryQuerySchema } }, async (request, reply) => {
         const query = request.query;
         const period = (query.period ?? "24h");
-        const summary = getMetricsSummary(options.db, period, query.provider_id, query.backend_model, query.router_key_id);
+        const summary = getMetricsSummary(options.db, period, query.provider_id, query.backend_model, query.router_key_id, query.start_time, query.end_time);
         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);
+        const timeseries = getMetricsTimeseries(options.db, period, metric, query.provider_id, query.backend_model, query.router_key_id, query.start_time, query.end_time);
         return reply.send(timeseries);
     });
     done();

package/dist/admin/recommended.d.ts

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

package/dist/admin/recommended.js

@@ -0,0 +1,25 @@
+import { getRecommendedProviders, getRecommendedRetryRules, reloadConfig } from "../config/recommended.js";
+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);
+    });
+    app.get("/admin/api/recommended/retry-rules", async (_req, reply) => {
+        const rules = getRecommendedRetryRules();
+        const existing = new Set(db.prepare("SELECT name FROM retry_rules").all().map((r) => r.name));
+        return reply.send(rules.filter((r) => !existing.has(r.name)));
+    });
+    app.post("/admin/api/recommended/reload", async (_req, reply) => {
+        reloadConfig();
+        return reply.send({ ok: true });
+    });
+    done();
+};

package/dist/admin/router-keys.js

@@ -3,8 +3,7 @@ import { Type } from "@sinclair/typebox";
 import { encrypt, decrypt } from "../utils/crypto.js";
 import { getAllRouterKeys, getRouterKeyById, createRouterKey, updateRouterKey, deleteRouterKey, getAvailableModels, } from "../db/index.js";
 import { getSetting } from "../db/settings.js";
-const HTTP_CREATED = 201;
-const HTTP_NOT_FOUND = 404;
+import { HTTP_CREATED, HTTP_NOT_FOUND } from "./constants.js";
 const KEY_RANDOM_BYTES = 32;
 const KEY_PREFIX_LENGTH = 8;
 /** 归一化 allowed_models：null/空数组/仅含空字符串 → null（允许所有模型） */

package/dist/admin/routes.js

@@ -10,6 +10,8 @@ import { adminProxyEnhancementRoutes } from "./proxy-enhancement.js";
 import { adminRouterKeyRoutes } from "./router-keys.js";
 import { adminSetupRoutes } from "./setup.js";
 import { adminMonitorRoutes } from "./monitor.js";
+import { adminRecommendedRoutes } from "./recommended.js";
+import { adminUsageRoutes } from "./usage.js";
 export const adminRoutes = (app, options, done) => {
     // Setup 路由不需要 auth
     app.register(adminSetupRoutes, { db: options.db });
@@ -25,5 +27,7 @@ export const adminRoutes = (app, options, done) => {
     app.register(adminMetricsRoutes, { db: options.db });
     app.register(adminProxyEnhancementRoutes, { db: options.db });
     app.register(adminMonitorRoutes, { tracker: options.tracker });
+    app.register(adminRecommendedRoutes, { db: options.db });
+    app.register(adminUsageRoutes, { db: options.db });
     done();
 };

package/dist/admin/usage.d.ts

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

package/dist/admin/usage.js

@@ -0,0 +1,66 @@
+import { Type } from "@sinclair/typebox";
+import { getWindowsInRange, getWindowUsage } from "../db/usage-windows.js";
+import { toSqliteDatetime } from "../utils/datetime.js";
+const UsageQuerySchema = Type.Object({
+    router_key_id: Type.Optional(Type.String()),
+});
+function getMonday(date) {
+    const d = new Date(date);
+    const day = d.getDay();
+    // 周日 getDay()=0，需要回退到上周一；其余日期减到周一
+    const diff = d.getDate() - day + (day === 0 ? -6 : 1); // eslint-disable-line no-magic-numbers
+    d.setDate(diff);
+    return d;
+}
+function getDailyUsage(db, start, end, routerKeyId) {
+    const routerKeyFilter = routerKeyId
+        ? " AND rl.router_key_id = ?"
+        : "";
+    const params = routerKeyId
+        ? [toSqliteDatetime(start), toSqliteDatetime(end), routerKeyId]
+        : [toSqliteDatetime(start), toSqliteDatetime(end)];
+    return db.prepare(`
+    SELECT
+      date(rm.created_at) AS date,
+      COUNT(*) AS request_count,
+      COALESCE(SUM(rm.input_tokens), 0) AS total_input_tokens,
+      COALESCE(SUM(rm.output_tokens), 0) AS total_output_tokens
+    FROM request_metrics rm
+    JOIN request_logs rl ON rl.id = rm.request_log_id
+    WHERE rm.is_complete = 1
+      AND rm.created_at >= datetime(?)
+      AND rm.created_at < datetime(?)
+      ${routerKeyFilter}
+    GROUP BY date(rm.created_at)
+    ORDER BY date ASC
+  `).all(...params);
+}
+export const adminUsageRoutes = (app, options, done) => {
+    const { db } = options;
+    app.get("/admin/api/usage/windows", { schema: { querystring: UsageQuerySchema } }, async (request) => {
+        const query = request.query;
+        const today = new Date();
+        today.setHours(0, 0, 0, 0);
+        const tomorrow = new Date(today);
+        tomorrow.setDate(tomorrow.getDate() + 1);
+        const windows = getWindowsInRange(db, toSqliteDatetime(today), toSqliteDatetime(tomorrow), query.router_key_id);
+        return windows.map(w => ({
+            window: w,
+            usage: getWindowUsage(db, w.start_time, w.end_time, query.router_key_id),
+        }));
+    });
+    app.get("/admin/api/usage/weekly", { schema: { querystring: UsageQuerySchema } }, async (request) => {
+        const query = request.query;
+        const now = new Date();
+        const monday = getMonday(now);
+        monday.setHours(0, 0, 0, 0);
+        return getDailyUsage(db, monday, now, query.router_key_id);
+    });
+    app.get("/admin/api/usage/monthly", { schema: { querystring: UsageQuerySchema } }, async (request) => {
+        const query = request.query;
+        const now = new Date();
+        const firstOfMonth = new Date(now.getFullYear(), now.getMonth(), 1);
+        return getDailyUsage(db, firstOfMonth, now, query.router_key_id);
+    });
+    done();
+};

package/dist/config/recommended.d.ts

@@ -0,0 +1,24 @@
+export interface ProviderPreset {
+    plan: string;
+    presetName: string;
+    apiType: 'openai' | 'anthropic';
+    baseUrl: string;
+    models: string[];
+}
+export interface ProviderGroup {
+    group: string;
+    presets: ProviderPreset[];
+}
+export interface RecommendedRetryRule {
+    name: string;
+    status_code: number;
+    body_pattern: string;
+    retry_strategy: 'fixed' | 'exponential';
+    retry_delay_ms: number;
+    max_retries: number;
+    max_delay_ms: number;
+}
+export declare function loadRecommendedConfig(dir?: string): void;
+export declare function getRecommendedProviders(): ProviderGroup[];
+export declare function getRecommendedRetryRules(): RecommendedRetryRule[];
+export declare function reloadConfig(): void;

package/dist/config/recommended.js

@@ -0,0 +1,30 @@
+import fs from 'fs';
+import path from 'path';
+let cachedProviders = [];
+let cachedRetryRules = [];
+let configDir = '';
+export function loadRecommendedConfig(dir) {
+    configDir = dir ?? path.resolve(process.cwd(), 'config');
+    cachedProviders = loadJson('recommended-providers.json');
+    cachedRetryRules = loadJson('recommended-retry-rules.json');
+}
+export function getRecommendedProviders() {
+    return cachedProviders;
+}
+export function getRecommendedRetryRules() {
+    return cachedRetryRules;
+}
+export function reloadConfig() {
+    loadRecommendedConfig(configDir);
+}
+function loadJson(filename) {
+    const filePath = path.join(configDir, filename);
+    try {
+        if (!fs.existsSync(filePath))
+            return [];
+        return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    }
+    catch {
+        return [];
+    }
+}

package/dist/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const HTTP_BAD_REQUEST = 400;
+export declare const HTTP_CREATED = 201;
+export declare const HTTP_FORBIDDEN = 403;
+export declare const HTTP_NOT_FOUND = 404;
+export declare const HTTP_CONFLICT = 409;
+export declare const HTTP_INTERNAL_ERROR = 500;
+export declare const HTTP_BAD_GATEWAY = 502;
+export declare const HTTP_SERVICE_UNAVAILABLE = 503;

package/dist/constants.js

@@ -0,0 +1,9 @@
+// HTTP 状态码常量 — 全局唯一来源
+export const HTTP_BAD_REQUEST = 400;
+export const HTTP_CREATED = 201;
+export const HTTP_FORBIDDEN = 403;
+export const HTTP_NOT_FOUND = 404;
+export const HTTP_CONFLICT = 409;
+export const HTTP_INTERNAL_ERROR = 500;
+export const HTTP_BAD_GATEWAY = 502;
+export const HTTP_SERVICE_UNAVAILABLE = 503;

package/dist/db/index.d.ts

@@ -4,16 +4,18 @@ export { getActiveProviders, getAllProviders, getProviderById, createProvider, u
 export type { Provider } from "./providers.js";
 export { getModelMapping, getAllModelMappings, createModelMapping, updateModelMapping, deleteModelMapping, getMappingGroup, getMappingGroupById, getAllMappingGroups, createMappingGroup, updateMappingGroup, deleteMappingGroup, getActiveProviderModels, resolveByProviderModel, } from "./mappings.js";
 export type { ModelMapping, MappingGroup, ProviderModelEntry } from "./mappings.js";
-export { getActiveRetryRules, getAllRetryRules, createRetryRule, updateRetryRule, deleteRetryRule, seedDefaultRules, } from "./retry-rules.js";
+export { getActiveRetryRules, getAllRetryRules, createRetryRule, updateRetryRule, deleteRetryRule, } from "./retry-rules.js";
 export type { RetryRule } from "./retry-rules.js";
-export { insertRequestLog, getRequestLogs, getRequestLogById, deleteLogsBefore, insertMetrics, } from "./logs.js";
-export type { RequestLog, MetricsRow, MetricsInsert } from "./logs.js";
+export { insertRequestLog, getRequestLogs, getRequestLogById, deleteLogsBefore, getRequestLogChildren, getRequestLogsGrouped, } from "./logs.js";
+export type { RequestLog, RequestLogGroupedRow, RequestLogListRow } from "./logs.js";
 export { getRouterKeyByHash, getAllRouterKeys, getRouterKeyById, createRouterKey, updateRouterKey, deleteRouterKey, getAvailableModels, } from "./router-keys.js";
 export type { RouterKey } from "./router-keys.js";
-export { getMetricsSummary, getMetricsTimeseries } from "./metrics.js";
-export type { MetricsSummaryRow, MetricsTimeseriesRow, MetricsPeriod, MetricsMetric } from "./metrics.js";
+export { getMetricsSummary, getMetricsTimeseries, insertMetrics } from "./metrics.js";
+export type { MetricsSummaryRow, MetricsTimeseriesRow, MetricsPeriod, MetricsMetric, MetricsRow, MetricsInsert } from "./metrics.js";
 export { getStats } from "./stats.js";
 export type { Stats, StatsPeriod } from "./stats.js";
 export { getSetting, setSetting, isInitialized } from "./settings.js";
 export { getSessionStates, getSessionState, getSessionHistory, upsertSessionState, insertSessionHistory, deleteSessionState, } from "./session-states.js";
 export type { SessionModelState, SessionModelHistory, UpsertSessionStateInput, InsertSessionHistoryInput } from "./session-states.js";
+export { insertWindow, getLatestWindow, getWindowsInRange, getWindowUsage, } from "./usage-windows.js";
+export type { UsageWindow, WindowUsage } from "./usage-windows.js";