llm-simple-router 0.1.0

package/dist/db/mappings.js

@@ -0,0 +1,55 @@
+import { randomUUID } from "crypto";
+import { buildUpdateQuery, deleteById } from "./helpers.js";
+const MAPPING_FIELDS = new Set(["client_model", "backend_model", "provider_id", "is_active"]);
+const GROUP_FIELDS = new Set(["client_model", "strategy", "rule"]);
+// --- ModelMapping CRUD ---
+export function getModelMapping(db, clientModel) {
+    return db
+        .prepare("SELECT * FROM model_mappings WHERE client_model = ? AND is_active = 1")
+        .get(clientModel);
+}
+export function getAllModelMappings(db) {
+    return db.prepare("SELECT * FROM model_mappings ORDER BY created_at DESC").all();
+}
+export function createModelMapping(db, mapping) {
+    const id = randomUUID();
+    const now = new Date().toISOString();
+    db.prepare(`INSERT INTO model_mappings (id, client_model, backend_model, provider_id, is_active, created_at)
+     VALUES (?, ?, ?, ?, ?, ?)`).run(id, mapping.client_model, mapping.backend_model, mapping.provider_id, mapping.is_active ?? 1, now);
+    return id;
+}
+export function updateModelMapping(db, id, fields) {
+    buildUpdateQuery(db, "model_mappings", id, fields, MAPPING_FIELDS);
+}
+export function deleteModelMapping(db, id) {
+    deleteById(db, "model_mappings", id);
+}
+// --- MappingGroups CRUD ---
+export function getMappingGroup(db, clientModel) {
+    return db
+        .prepare("SELECT * FROM mapping_groups WHERE client_model = ?")
+        .get(clientModel);
+}
+export function getMappingGroupById(db, id) {
+    return db
+        .prepare("SELECT * FROM mapping_groups WHERE id = ?")
+        .get(id);
+}
+export function getAllMappingGroups(db) {
+    return db
+        .prepare("SELECT * FROM mapping_groups ORDER BY created_at DESC")
+        .all();
+}
+export function createMappingGroup(db, mapping) {
+    const id = randomUUID();
+    const now = new Date().toISOString();
+    db.prepare(`INSERT INTO mapping_groups (id, client_model, strategy, rule, created_at)
+     VALUES (?, ?, ?, ?, ?)`).run(id, mapping.client_model, mapping.strategy, mapping.rule, now);
+    return id;
+}
+export function updateMappingGroup(db, id, fields) {
+    buildUpdateQuery(db, "mapping_groups", id, fields, GROUP_FIELDS);
+}
+export function deleteMappingGroup(db, id) {
+    deleteById(db, "mapping_groups", id);
+}

package/dist/db/metrics.d.ts

@@ -0,0 +1,24 @@
+import Database from "better-sqlite3";
+export type MetricsPeriod = "1h" | "6h" | "24h" | "7d" | "30d";
+export type MetricsMetric = "ttft" | "tps" | "tokens" | "cache_rate" | "request_count" | "input_tokens" | "output_tokens" | "cache_hit_tokens";
+export interface MetricsSummaryRow {
+    provider_id: string;
+    provider_name: string;
+    backend_model: string;
+    request_count: number;
+    avg_ttft_ms: number | null;
+    p50_ttft_ms: null;
+    p95_ttft_ms: null;
+    avg_tps: number | null;
+    total_input_tokens: number;
+    total_output_tokens: number;
+    total_cache_hit_tokens: number;
+    cache_hit_rate: number | null;
+}
+export declare function getMetricsSummary(db: Database.Database, period: MetricsPeriod, providerId?: string, backendModel?: string, routerKeyId?: string): MetricsSummaryRow[];
+export interface MetricsTimeseriesRow {
+    time_bucket: string;
+    avg_value: number | null;
+    count: number;
+}
+export declare function getMetricsTimeseries(db: Database.Database, period: MetricsPeriod, metric: MetricsMetric, providerId?: string, backendModel?: string, routerKeyId?: string): MetricsTimeseriesRow[];

package/dist/db/metrics.js

@@ -0,0 +1,119 @@
+const PERIOD_OFFSET = {
+    "1h": "-1 hours",
+    "6h": "-6 hours",
+    "24h": "-1 day",
+    "7d": "-7 days",
+    "30d": "-30 days",
+};
+const BUCKET_SECONDS = {
+    "1h": 60,
+    "6h": 300,
+    "24h": 900,
+    "7d": 3600,
+    "30d": 14400,
+};
+// unix epoch 秒转毫秒的乘数
+const MS_PER_SEC = 1000;
+export function getMetricsSummary(db, period, providerId, backendModel, routerKeyId) {
+    const offset = PERIOD_OFFSET[period];
+    const conditions = ["rm.is_complete = 1", "rm.created_at >= datetime('now', ?)"];
+    const params = [offset];
+    if (providerId) {
+        conditions.push("rm.provider_id = ?");
+        params.push(providerId);
+    }
+    if (backendModel) {
+        conditions.push("rm.backend_model = ?");
+        params.push(backendModel);
+    }
+    const joins = "LEFT JOIN providers p ON p.id = rm.provider_id";
+    if (routerKeyId) {
+        conditions.push("rl.router_key_id = ?");
+        params.push(routerKeyId);
+        return db.prepare(`
+      SELECT
+        rm.provider_id, COALESCE(p.name, rm.provider_id) AS provider_name, rm.backend_model,
+        COUNT(*) AS request_count, AVG(rm.ttft_ms) AS avg_ttft_ms, NULL AS p50_ttft_ms, NULL AS p95_ttft_ms,
+        AVG(rm.tokens_per_second) AS avg_tps,
+        COALESCE(SUM(rm.input_tokens), 0) AS total_input_tokens, COALESCE(SUM(rm.output_tokens), 0) AS total_output_tokens,
+        COALESCE(SUM(rm.cache_read_tokens), 0) AS total_cache_hit_tokens,
+        CASE WHEN SUM(rm.input_tokens) > 0 THEN SUM(rm.cache_read_tokens) * 1.0 / SUM(rm.input_tokens) ELSE NULL END AS cache_hit_rate
+      FROM request_metrics rm
+      LEFT JOIN providers p ON p.id = rm.provider_id
+      LEFT JOIN request_logs rl ON rl.id = rm.request_log_id
+      WHERE ${conditions.join(" AND ")}
+      GROUP BY rm.provider_id, rm.backend_model ORDER BY request_count DESC
+    `).all(...params);
+    }
+    const where = conditions.join(" AND ");
+    return db.prepare(`
+    SELECT
+      rm.provider_id,
+      COALESCE(p.name, rm.provider_id) AS provider_name,
+      rm.backend_model,
+      COUNT(*) AS request_count,
+      AVG(rm.ttft_ms) AS avg_ttft_ms,
+      NULL AS p50_ttft_ms,
+      NULL AS p95_ttft_ms,
+      AVG(rm.tokens_per_second) AS avg_tps,
+      COALESCE(SUM(rm.input_tokens), 0) AS total_input_tokens,
+      COALESCE(SUM(rm.output_tokens), 0) AS total_output_tokens,
+      COALESCE(SUM(rm.cache_read_tokens), 0) AS total_cache_hit_tokens,
+      CASE WHEN SUM(rm.input_tokens) > 0
+        THEN SUM(rm.cache_read_tokens) * 1.0 / SUM(rm.input_tokens)
+        ELSE NULL
+      END AS cache_hit_rate
+    FROM request_metrics rm
+    ${joins}
+    WHERE ${where}
+    GROUP BY rm.provider_id, rm.backend_model
+    ORDER BY request_count DESC
+  `).all(...params);
+}
+const METRIC_EXPR = {
+    ttft: "AVG(rm.ttft_ms)",
+    tps: "AVG(rm.tokens_per_second)",
+    tokens: "SUM(rm.output_tokens)",
+    cache_rate: "CASE WHEN SUM(rm.input_tokens) > 0 THEN SUM(rm.cache_read_tokens) * 1.0 / SUM(rm.input_tokens) ELSE NULL END",
+    request_count: "COUNT(*)",
+    input_tokens: "SUM(rm.input_tokens)",
+    output_tokens: "SUM(rm.output_tokens)",
+    cache_hit_tokens: "SUM(rm.cache_read_tokens)",
+};
+export function getMetricsTimeseries(db, period, metric, providerId, backendModel, routerKeyId) {
+    const offset = PERIOD_OFFSET[period];
+    const bucketSec = BUCKET_SECONDS[period];
+    const conditions = ["rm.is_complete = 1", "rm.created_at >= datetime('now', ?)"];
+    const params = [offset];
+    if (providerId) {
+        conditions.push("rm.provider_id = ?");
+        params.push(providerId);
+    }
+    if (backendModel) {
+        conditions.push("rm.backend_model = ?");
+        params.push(backendModel);
+    }
+    if (routerKeyId) {
+        conditions.push("rl.router_key_id = ?");
+        params.push(routerKeyId);
+    }
+    const where = conditions.join(" AND ");
+    const expr = METRIC_EXPR[metric];
+    const joinClause = routerKeyId ? "LEFT JOIN request_logs rl ON rl.id = rm.request_log_id" : "";
+    const rows = db.prepare(`
+    SELECT
+      (unixepoch(rm.created_at) / ?) * ? AS bucket_key,
+      ${expr} AS avg_value,
+      COUNT(*) AS count
+    FROM request_metrics rm
+    ${joinClause}
+    WHERE ${where}
+    GROUP BY bucket_key
+    ORDER BY bucket_key ASC
+  `).all(bucketSec, bucketSec, ...params);
+    return rows.map((r) => ({
+        time_bucket: new Date(r.bucket_key * MS_PER_SEC).toISOString(),
+        avg_value: r.avg_value,
+        count: r.count,
+    }));
+}

package/dist/db/migrations/001_init.sql

@@ -0,0 +1,37 @@
+CREATE TABLE IF NOT EXISTS migrations (
+  name TEXT PRIMARY KEY,
+  applied_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS backend_services (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  api_type TEXT NOT NULL CHECK(api_type IN ('openai', 'anthropic')),
+  base_url TEXT NOT NULL,
+  api_key TEXT NOT NULL,
+  is_active INTEGER NOT NULL DEFAULT 1,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS model_mappings (
+  id TEXT PRIMARY KEY,
+  client_model TEXT NOT NULL UNIQUE,
+  backend_model TEXT NOT NULL,
+  backend_service_id TEXT NOT NULL,
+  is_active INTEGER NOT NULL DEFAULT 1,
+  created_at TEXT NOT NULL,
+  FOREIGN KEY (backend_service_id) REFERENCES backend_services(id)
+);
+
+CREATE TABLE IF NOT EXISTS request_logs (
+  id TEXT PRIMARY KEY,
+  api_type TEXT NOT NULL,
+  model TEXT,
+  backend_service_id TEXT,
+  status_code INTEGER,
+  latency_ms INTEGER,
+  is_stream INTEGER,
+  error_message TEXT,
+  created_at TEXT NOT NULL
+);

package/dist/db/migrations/002_add_request_response_body.sql

@@ -0,0 +1,2 @@
+ALTER TABLE request_logs ADD COLUMN request_body TEXT;
+ALTER TABLE request_logs ADD COLUMN response_body TEXT;

package/dist/db/migrations/003_add_full_request_chain_log.sql

@@ -0,0 +1,4 @@
+ALTER TABLE request_logs ADD COLUMN client_request TEXT;
+ALTER TABLE request_logs ADD COLUMN upstream_request TEXT;
+ALTER TABLE request_logs ADD COLUMN upstream_response TEXT;
+ALTER TABLE request_logs ADD COLUMN client_response TEXT;

package/dist/db/migrations/004_rename_to_providers.sql

@@ -0,0 +1,9 @@
+-- backend_services → providers
+-- model_mappings.backend_service_id → provider_id
+-- request_logs.backend_service_id → provider_id
+
+ALTER TABLE backend_services RENAME TO providers;
+
+ALTER TABLE model_mappings RENAME COLUMN backend_service_id TO provider_id;
+
+ALTER TABLE request_logs RENAME COLUMN backend_service_id TO provider_id;

package/dist/db/migrations/005_add_api_key_preview.sql

@@ -0,0 +1 @@
+ALTER TABLE providers ADD COLUMN api_key_preview TEXT;

package/dist/db/migrations/006_create_request_metrics.sql

@@ -0,0 +1,20 @@
+CREATE TABLE request_metrics (
+  id TEXT PRIMARY KEY,
+  request_log_id TEXT NOT NULL UNIQUE REFERENCES request_logs(id) ON DELETE CASCADE,
+  provider_id TEXT NOT NULL,
+  backend_model TEXT NOT NULL,
+  api_type TEXT NOT NULL,
+  input_tokens INTEGER,
+  output_tokens INTEGER,
+  cache_creation_tokens INTEGER,
+  cache_read_tokens INTEGER,
+  ttft_ms INTEGER,
+  total_duration_ms INTEGER,
+  tokens_per_second REAL,
+  stop_reason TEXT,
+  is_complete INTEGER NOT NULL DEFAULT 1,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX idx_metrics_time_provider_model ON request_metrics(created_at, provider_id, backend_model);
+CREATE INDEX idx_metrics_api_type_created_at ON request_metrics(api_type, created_at);

package/dist/db/migrations/007_add_retry_fields.sql

@@ -0,0 +1,2 @@
+ALTER TABLE request_logs ADD COLUMN is_retry INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE request_logs ADD COLUMN original_request_id TEXT;

package/dist/db/migrations/008_create_router_keys.sql

@@ -0,0 +1,17 @@
+CREATE TABLE IF NOT EXISTS router_keys (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  key_hash TEXT NOT NULL UNIQUE,
+  key_prefix TEXT NOT NULL,
+  allowed_models TEXT,
+  is_active INTEGER NOT NULL DEFAULT 1,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_router_keys_hash ON router_keys(key_hash);
+CREATE INDEX IF NOT EXISTS idx_router_keys_active ON router_keys(is_active);
+
+ALTER TABLE request_logs ADD COLUMN router_key_id TEXT;
+
+CREATE INDEX IF NOT EXISTS idx_request_logs_router_key ON request_logs(router_key_id);

package/dist/db/migrations/009_add_request_logs_indexes.sql

@@ -0,0 +1,2 @@
+CREATE INDEX IF NOT EXISTS idx_request_logs_created_at ON request_logs(created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_request_logs_api_type ON request_logs(api_type);

package/dist/db/migrations/010_add_key_encrypted.sql

@@ -0,0 +1 @@
+ALTER TABLE router_keys ADD COLUMN key_encrypted TEXT;

package/dist/db/migrations/011_create_mapping_groups.sql

@@ -0,0 +1,33 @@
+CREATE TABLE IF NOT EXISTS mapping_groups (
+  id TEXT PRIMARY KEY,
+  client_model TEXT NOT NULL UNIQUE,
+  strategy TEXT NOT NULL DEFAULT 'scheduled',
+  rule TEXT NOT NULL,
+  created_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS retry_rules (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  status_code INTEGER NOT NULL,
+  body_pattern TEXT NOT NULL,
+  is_active INTEGER NOT NULL DEFAULT 1,
+  created_at TEXT NOT NULL
+);
+
+-- 从现有 model_mappings 迁移数据：
+-- 每条旧映射转为 scheduled 策略，default 指向原后端，windows 为空数组
+INSERT INTO mapping_groups (id, client_model, strategy, rule, created_at)
+SELECT
+  lower(hex(randomblob(16))) AS id,
+  client_model,
+  'scheduled' AS strategy,
+  json_object(
+    'default', json_object('provider_id', provider_id, 'backend_model', backend_model),
+    'windows', json_array()
+  ) AS rule,
+  created_at
+FROM model_mappings
+WHERE is_active = 1;
+
+-- 默认重试规则在首次启动时通过 seedDefaultRules() 自动插入，不在此处硬编码

package/dist/db/migrations/012_add_provider_models.sql

@@ -0,0 +1,2 @@
+-- 为供应商增加可用模型列表，存储 JSON 数组
+ALTER TABLE providers ADD COLUMN models TEXT NOT NULL DEFAULT '[]';

package/dist/db/migrations/013_add_retry_strategy.sql

@@ -0,0 +1,4 @@
+ALTER TABLE retry_rules ADD COLUMN retry_strategy TEXT NOT NULL DEFAULT 'exponential';
+ALTER TABLE retry_rules ADD COLUMN retry_delay_ms INTEGER NOT NULL DEFAULT 5000;
+ALTER TABLE retry_rules ADD COLUMN max_retries INTEGER NOT NULL DEFAULT 10;
+ALTER TABLE retry_rules ADD COLUMN max_delay_ms INTEGER NOT NULL DEFAULT 60000;

package/dist/db/providers.d.ts

@@ -0,0 +1,27 @@
+import Database from "better-sqlite3";
+export interface Provider {
+    id: string;
+    name: string;
+    api_type: "openai" | "anthropic";
+    base_url: string;
+    api_key: string;
+    api_key_preview?: string;
+    models: string;
+    is_active: number;
+    created_at: string;
+    updated_at: string;
+}
+export declare function getActiveProviders(db: Database.Database, apiType: "openai" | "anthropic"): Provider[];
+export declare function getAllProviders(db: Database.Database): Provider[];
+export declare function getProviderById(db: Database.Database, id: string): Provider | undefined;
+export declare function createProvider(db: Database.Database, provider: {
+    name: string;
+    api_type: "openai" | "anthropic";
+    base_url: string;
+    api_key: string;
+    api_key_preview?: string;
+    models?: string;
+    is_active?: number;
+}): string;
+export declare function updateProvider(db: Database.Database, id: string, fields: Partial<Pick<Provider, "name" | "api_type" | "base_url" | "api_key" | "api_key_preview" | "is_active">>): void;
+export declare function deleteProvider(db: Database.Database, id: string): void;

package/dist/db/providers.js

@@ -0,0 +1,29 @@
+import { randomUUID } from "crypto";
+import { buildUpdateQuery, deleteById } from "./helpers.js";
+const PROVIDER_FIELDS = new Set([
+    "name", "api_type", "base_url", "api_key", "api_key_preview", "models", "is_active",
+]);
+export function getActiveProviders(db, apiType) {
+    return db
+        .prepare("SELECT * FROM providers WHERE api_type = ? AND is_active = 1")
+        .all(apiType);
+}
+export function getAllProviders(db) {
+    return db.prepare("SELECT * FROM providers ORDER BY created_at DESC").all();
+}
+export function getProviderById(db, id) {
+    return db.prepare("SELECT * FROM providers WHERE id = ?").get(id);
+}
+export function createProvider(db, provider) {
+    const id = randomUUID();
+    const now = new Date().toISOString();
+    db.prepare(`INSERT INTO providers (id, name, api_type, base_url, api_key, api_key_preview, models, is_active, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, provider.name, provider.api_type, provider.base_url, provider.api_key, provider.api_key_preview ?? null, provider.models ?? "[]", provider.is_active ?? 1, now, now);
+    return id;
+}
+export function updateProvider(db, id, fields) {
+    buildUpdateQuery(db, "providers", id, fields, PROVIDER_FIELDS, { updatedAt: true });
+}
+export function deleteProvider(db, id) {
+    deleteById(db, "providers", id);
+}

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

@@ -0,0 +1,32 @@
+import Database from "better-sqlite3";
+export interface RetryRule {
+    id: string;
+    name: string;
+    status_code: number;
+    body_pattern: string;
+    is_active: number;
+    created_at: string;
+    retry_strategy: "fixed" | "exponential";
+    retry_delay_ms: number;
+    max_retries: number;
+    max_delay_ms: number;
+}
+export declare function getActiveRetryRules(db: Database.Database): RetryRule[];
+export declare function getAllRetryRules(db: Database.Database): RetryRule[];
+export declare function createRetryRule(db: Database.Database, rule: {
+    name: string;
+    status_code: number;
+    body_pattern: string;
+    is_active?: number;
+    retry_strategy?: string;
+    retry_delay_ms?: number;
+    max_retries?: number;
+    max_delay_ms?: number;
+}): string;
+export declare function updateRetryRule(db: Database.Database, id: string, fields: Partial<Pick<RetryRule, "name" | "status_code" | "body_pattern" | "is_active" | "retry_strategy" | "retry_delay_ms" | "max_retries" | "max_delay_ms">>): void;
+export declare function deleteRetryRule(db: Database.Database, id: string): void;
+/**
+ * 首次启动时（表为空）插入默认重试规则。
+ * 429/503 为通用 HTTP 重试；其余为 ZAI middleware 特定 400 响应。
+ */
+export declare function seedDefaultRules(db: Database.Database): void;

package/dist/db/retry-rules.js

@@ -0,0 +1,49 @@
+import { randomUUID } from "crypto";
+import { buildUpdateQuery, deleteById } from "./helpers.js";
+const RETRY_FIELDS = new Set(["name", "status_code", "body_pattern", "is_active", "retry_strategy", "retry_delay_ms", "max_retries", "max_delay_ms"]);
+export function getActiveRetryRules(db) {
+    return db
+        .prepare("SELECT * FROM retry_rules WHERE is_active = 1 ORDER BY created_at DESC")
+        .all();
+}
+export function getAllRetryRules(db) {
+    return db
+        .prepare("SELECT * FROM retry_rules ORDER BY created_at DESC")
+        .all();
+}
+export function createRetryRule(db, rule) {
+    const id = randomUUID();
+    const now = new Date().toISOString();
+    db.prepare(`INSERT INTO retry_rules (id, name, status_code, body_pattern, is_active, created_at, retry_strategy, retry_delay_ms, max_retries, max_delay_ms)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, rule.name, rule.status_code, rule.body_pattern, rule.is_active ?? 1, now, rule.retry_strategy ?? "exponential", rule.retry_delay_ms ?? 5000, rule.max_retries ?? 10, rule.max_delay_ms ?? 60000);
+    return id;
+}
+export function updateRetryRule(db, id, fields) {
+    buildUpdateQuery(db, "retry_rules", id, fields, RETRY_FIELDS);
+}
+export function deleteRetryRule(db, id) {
+    deleteById(db, "retry_rules", id);
+}
+// ---------- Default seed rules ----------
+const DEFAULT_RULES = [
+    { name: "429 Too Many Requests", status_code: 429, body_pattern: ".*", is_active: 1, retry_strategy: "exponential", retry_delay_ms: 5000, max_retries: 10, max_delay_ms: 60000 },
+    { name: "503 Service Unavailable", status_code: 503, body_pattern: ".*", is_active: 1, retry_strategy: "exponential", retry_delay_ms: 5000, max_retries: 10, max_delay_ms: 60000 },
+    { name: 'ZAI 网络错误 (code 1234)', status_code: 400, body_pattern: '"type"\\s*:\\s*"error".*"code"\\s*:\\s*"1234"', is_active: 1, retry_strategy: "exponential", retry_delay_ms: 5000, max_retries: 10, max_delay_ms: 60000 },
+    { name: 'ZAI 临时不可用', status_code: 400, body_pattern: '"type"\\s*:\\s*"error".*请稍后重试', is_active: 1, retry_strategy: "exponential", retry_delay_ms: 5000, max_retries: 10, max_delay_ms: 60000 },
+    { name: 'ZAI 操作失败 (code 500)', status_code: 400, body_pattern: '"type"\\s*:\\s*"error".*"code"\\s*:\\s*"500"', is_active: 1, retry_strategy: "exponential", retry_delay_ms: 5000, max_retries: 10, max_delay_ms: 60000 },
+];
+/**
+ * 首次启动时（表为空）插入默认重试规则。
+ * 429/503 为通用 HTTP 重试；其余为 ZAI middleware 特定 400 响应。
+ */
+export function seedDefaultRules(db) {
+    const count = db.prepare("SELECT COUNT(*) as c FROM retry_rules").get().c;
+    if (count > 0)
+        return;
+    const now = new Date().toISOString();
+    const insert = db.prepare(`INSERT INTO retry_rules (id, name, status_code, body_pattern, is_active, created_at, retry_strategy, retry_delay_ms, max_retries, max_delay_ms)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+    for (const rule of DEFAULT_RULES) {
+        insert.run(randomUUID(), rule.name, rule.status_code, rule.body_pattern, rule.is_active, now, rule.retry_strategy, rule.retry_delay_ms, rule.max_retries, rule.max_delay_ms);
+    }
+}

package/dist/db/router-keys.d.ts

@@ -0,0 +1,29 @@
+import Database from "better-sqlite3";
+export interface RouterKey {
+    id: string;
+    name: string;
+    key_hash: string;
+    key_prefix: string;
+    key_encrypted: string | null;
+    allowed_models: string | null;
+    is_active: number;
+    created_at: string;
+    updated_at: string;
+}
+export declare function getRouterKeyByHash(db: Database.Database, hash: string): {
+    id: string;
+    name: string;
+    allowed_models: string | null;
+} | undefined;
+export declare function getAllRouterKeys(db: Database.Database): RouterKey[];
+export declare function getRouterKeyById(db: Database.Database, id: string): RouterKey | undefined;
+export declare function createRouterKey(db: Database.Database, key: {
+    name: string;
+    key_hash: string;
+    key_prefix: string;
+    key_encrypted: string;
+    allowed_models?: string | null;
+}): string;
+export declare function updateRouterKey(db: Database.Database, id: string, fields: Partial<Pick<RouterKey, "name" | "allowed_models" | "is_active">>): void;
+export declare function deleteRouterKey(db: Database.Database, id: string): void;
+export declare function getAvailableModels(db: Database.Database): string[];

package/dist/db/router-keys.js

@@ -0,0 +1,36 @@
+import { randomUUID } from "crypto";
+import { buildUpdateQuery, deleteById } from "./helpers.js";
+export function getRouterKeyByHash(db, hash) {
+    return db.prepare("SELECT id, name, allowed_models FROM router_keys WHERE key_hash = ? AND is_active = 1").get(hash);
+}
+export function getAllRouterKeys(db) {
+    return db.prepare("SELECT * FROM router_keys ORDER BY created_at DESC").all();
+}
+export function getRouterKeyById(db, id) {
+    return db.prepare("SELECT * FROM router_keys WHERE id = ?").get(id);
+}
+export function createRouterKey(db, key) {
+    const id = randomUUID();
+    const now = new Date().toISOString();
+    db.prepare(`INSERT INTO router_keys (id, name, key_hash, key_prefix, key_encrypted, allowed_models, is_active, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?)`).run(id, key.name, key.key_hash, key.key_prefix, key.key_encrypted, key.allowed_models ?? null, now, now);
+    return id;
+}
+const ROUTER_KEY_FIELDS = new Set(["name", "allowed_models", "is_active"]);
+export function updateRouterKey(db, id, fields) {
+    buildUpdateQuery(db, "router_keys", id, fields, ROUTER_KEY_FIELDS, { updatedAt: true });
+}
+export function deleteRouterKey(db, id) {
+    deleteById(db, "router_keys", id);
+}
+export function getAvailableModels(db) {
+    const rows = db.prepare("SELECT models FROM providers WHERE is_active = 1").all();
+    const set = new Set();
+    for (const r of rows) {
+        try {
+            JSON.parse(r.models || "[]").forEach((m) => set.add(m));
+        }
+        catch { /* skip invalid JSON */ }
+    }
+    return [...set].sort();
+}

package/dist/db/stats.d.ts

@@ -0,0 +1,9 @@
+import Database from "better-sqlite3";
+export type StatsPeriod = "1h" | "6h" | "24h" | "7d" | "30d";
+export interface Stats {
+    totalRequests: number;
+    successRate: number;
+    avgTps: number;
+    totalTokens: number;
+}
+export declare function getStats(db: Database.Database, period: StatsPeriod, routerKeyId?: string): Stats;

package/dist/db/stats.js

@@ -0,0 +1,34 @@
+const PERIOD_OFFSET = {
+    "1h": "-1 hours",
+    "6h": "-6 hours",
+    "24h": "-1 day",
+    "7d": "-7 days",
+    "30d": "-30 days",
+};
+export function getStats(db, period, routerKeyId) {
+    const offset = PERIOD_OFFSET[period];
+    const conditions = ["rm.is_complete = 1", "rm.created_at >= datetime('now', ?)"];
+    const params = [offset];
+    if (routerKeyId) {
+        conditions.push("rl.router_key_id = ?");
+        params.push(routerKeyId);
+    }
+    const where = conditions.join(" AND ");
+    const row = db.prepare(`
+    SELECT
+      COUNT(*) AS total_requests,
+      SUM(CASE WHEN rl.status_code >= 200 AND rl.status_code < 300 THEN 1 ELSE 0 END) AS success_count,
+      AVG(rm.tokens_per_second) AS avg_tps,
+      COALESCE(SUM(rm.input_tokens), 0) + COALESCE(SUM(rm.output_tokens), 0) AS total_tokens
+    FROM request_metrics rm
+    JOIN request_logs rl ON rl.id = rm.request_log_id
+    WHERE ${where}
+  `).get(...params);
+    const total = row?.total_requests ?? 0;
+    return {
+        totalRequests: total,
+        successRate: total > 0 ? (row?.success_count ?? 0) / total : 0,
+        avgTps: row?.avg_tps ?? 0,
+        totalTokens: row?.total_tokens ?? 0,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { FastifyInstance } from "fastify";
+import { Config } from "./config.js";
+import Database from "better-sqlite3";
+export interface AppOptions {
+    config?: Config;
+    db?: Database.Database;
+}
+export declare function buildApp(options?: AppOptions): Promise<{
+    app: FastifyInstance;
+    db: Database.Database;
+    close: () => Promise<void>;
+}>;