llm-simple-router 0.1.0

package/dist/admin/retry-rules.js

@@ -0,0 +1,98 @@
+import { Type } from "@sinclair/typebox";
+import { getAllRetryRules, createRetryRule, updateRetryRule, deleteRetryRule, } from "../db/index.js";
+import { HTTP_BAD_REQUEST, HTTP_CREATED } from "./constants.js";
+const CreateRetryRuleSchema = Type.Object({
+    name: Type.String({ minLength: 1 }),
+    status_code: Type.Number({ minimum: 100, maximum: 599 }),
+    body_pattern: Type.String({ minLength: 1 }),
+    is_active: Type.Optional(Type.Number()),
+    retry_strategy: Type.Optional(Type.Union([Type.Literal("fixed"), Type.Literal("exponential")])),
+    retry_delay_ms: Type.Optional(Type.Number({ minimum: 100 })),
+    max_retries: Type.Optional(Type.Number({ minimum: 0, maximum: 100 })),
+    max_delay_ms: Type.Optional(Type.Number({ minimum: 100 })),
+});
+const UpdateRetryRuleSchema = Type.Object({
+    name: Type.Optional(Type.String({ minLength: 1 })),
+    status_code: Type.Optional(Type.Number({ minimum: 100, maximum: 599 })),
+    body_pattern: Type.Optional(Type.String({ minLength: 1 })),
+    is_active: Type.Optional(Type.Number()),
+    retry_strategy: Type.Optional(Type.Union([Type.Literal("fixed"), Type.Literal("exponential")])),
+    retry_delay_ms: Type.Optional(Type.Number({ minimum: 100 })),
+    max_retries: Type.Optional(Type.Number({ minimum: 0, maximum: 100 })),
+    max_delay_ms: Type.Optional(Type.Number({ minimum: 100 })),
+});
+function validateBodyPattern(pattern) {
+    try {
+        new RegExp(pattern);
+        return undefined;
+    }
+    catch {
+        return "Invalid body_pattern regex";
+    }
+}
+function refreshMatcher(matcher, db) {
+    if (matcher)
+        matcher.load(db);
+}
+export const adminRetryRuleRoutes = (app, options, done) => {
+    const { db, matcher } = options;
+    app.get("/admin/api/retry-rules", async (_request, reply) => {
+        const rules = getAllRetryRules(db);
+        return reply.send(rules);
+    });
+    app.post("/admin/api/retry-rules", { schema: { body: CreateRetryRuleSchema } }, async (request, reply) => {
+        const body = request.body;
+        const regexError = validateBodyPattern(body.body_pattern);
+        if (regexError) {
+            return reply.code(HTTP_BAD_REQUEST).send({ error: { message: regexError } });
+        }
+        const id = createRetryRule(db, {
+            name: body.name,
+            status_code: body.status_code,
+            body_pattern: body.body_pattern,
+            is_active: body.is_active ?? 1,
+            retry_strategy: body.retry_strategy ?? "exponential",
+            retry_delay_ms: body.retry_delay_ms ?? 5000,
+            max_retries: body.max_retries ?? 10,
+            max_delay_ms: body.max_delay_ms ?? 60000,
+        });
+        refreshMatcher(matcher, db);
+        return reply.code(HTTP_CREATED).send({ id });
+    });
+    app.put("/admin/api/retry-rules/:id", { schema: { body: UpdateRetryRuleSchema } }, async (request, reply) => {
+        const { id } = request.params;
+        const body = request.body;
+        const fields = {};
+        if (body.name !== undefined)
+            fields.name = body.name;
+        if (body.status_code !== undefined)
+            fields.status_code = body.status_code;
+        if (body.body_pattern !== undefined) {
+            const regexError = validateBodyPattern(body.body_pattern);
+            if (regexError) {
+                return reply.code(HTTP_BAD_REQUEST).send({ error: { message: regexError } });
+            }
+            fields.body_pattern = body.body_pattern;
+        }
+        if (body.is_active !== undefined)
+            fields.is_active = body.is_active;
+        if (body.retry_strategy !== undefined)
+            fields.retry_strategy = body.retry_strategy;
+        if (body.retry_delay_ms !== undefined)
+            fields.retry_delay_ms = body.retry_delay_ms;
+        if (body.max_retries !== undefined)
+            fields.max_retries = body.max_retries;
+        if (body.max_delay_ms !== undefined)
+            fields.max_delay_ms = body.max_delay_ms;
+        updateRetryRule(db, id, fields);
+        refreshMatcher(matcher, db);
+        return reply.send({ success: true });
+    });
+    app.delete("/admin/api/retry-rules/:id", async (request, reply) => {
+        const { id } = request.params;
+        deleteRetryRule(db, id);
+        refreshMatcher(matcher, db);
+        return reply.send({ success: true });
+    });
+    done();
+};

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

@@ -0,0 +1,8 @@
+import { FastifyPluginCallback } from "fastify";
+import Database from "better-sqlite3";
+interface RouterKeyRoutesOptions {
+    db: Database.Database;
+    encryptionKey: string;
+}
+export declare const adminRouterKeyRoutes: FastifyPluginCallback<RouterKeyRoutesOptions>;
+export {};

package/dist/admin/router-keys.js

@@ -0,0 +1,85 @@
+import { randomBytes, createHash } from "crypto";
+import { Type } from "@sinclair/typebox";
+import { encrypt, decrypt } from "../utils/crypto.js";
+import { getAllRouterKeys, getRouterKeyById, createRouterKey, updateRouterKey, deleteRouterKey, getAvailableModels, } from "../db/index.js";
+const HTTP_CREATED = 201;
+const HTTP_NOT_FOUND = 404;
+const KEY_RANDOM_BYTES = 32;
+const KEY_PREFIX_LENGTH = 8;
+const CreateRouterKeySchema = Type.Object({
+    name: Type.String({ minLength: 1 }),
+    allowed_models: Type.Optional(Type.Union([Type.Array(Type.String()), Type.Null()])),
+});
+const UpdateRouterKeySchema = Type.Object({
+    name: Type.Optional(Type.String({ minLength: 1 })),
+    allowed_models: Type.Optional(Type.Union([Type.Array(Type.String()), Type.Null()])),
+    is_active: Type.Optional(Type.Number()),
+});
+function generateRouterKey(encryptionKey) {
+    const key = `sk-router-${randomBytes(KEY_RANDOM_BYTES).toString("hex")}`;
+    const hash = createHash("sha256").update(key).digest("hex");
+    const prefix = key.slice(0, KEY_PREFIX_LENGTH);
+    const encrypted = encrypt(key, encryptionKey);
+    return { key, hash, prefix, encrypted };
+}
+function toPublicRouterKey(rk, encryptionKey) {
+    return {
+        id: rk.id,
+        name: rk.name,
+        key_prefix: rk.key_prefix,
+        key: rk.key_encrypted ? decrypt(rk.key_encrypted, encryptionKey) : null,
+        allowed_models: rk.allowed_models ? JSON.parse(rk.allowed_models) : null,
+        is_active: rk.is_active,
+        created_at: rk.created_at,
+        updated_at: rk.updated_at,
+    };
+}
+export const adminRouterKeyRoutes = (app, options, done) => {
+    const { db, encryptionKey } = options;
+    app.get("/admin/api/router-keys", async (_request, reply) => {
+        const keys = getAllRouterKeys(db);
+        return reply.send(keys.map((rk) => toPublicRouterKey(rk, encryptionKey)));
+    });
+    app.post("/admin/api/router-keys", { schema: { body: CreateRouterKeySchema } }, async (request, reply) => {
+        const body = request.body;
+        const { key, hash, prefix, encrypted } = generateRouterKey(encryptionKey);
+        const allowedModels = body.allowed_models ? JSON.stringify(body.allowed_models) : null;
+        const id = createRouterKey(db, { name: body.name, key_hash: hash, key_prefix: prefix, key_encrypted: encrypted, allowed_models: allowedModels });
+        return reply.code(HTTP_CREATED).send({
+            id,
+            name: body.name,
+            key,
+            key_prefix: prefix,
+            allowed_models: body.allowed_models ?? null,
+            is_active: true,
+            created_at: new Date().toISOString(),
+        });
+    });
+    app.put("/admin/api/router-keys/:id", { schema: { body: UpdateRouterKeySchema } }, async (request, reply) => {
+        const { id } = request.params;
+        const existing = getRouterKeyById(db, id);
+        if (!existing) {
+            return reply.code(HTTP_NOT_FOUND).send({ error: { message: "Router key not found" } });
+        }
+        const body = request.body;
+        const fields = {};
+        if (body.name !== undefined)
+            fields.name = body.name;
+        if (body.allowed_models !== undefined)
+            fields.allowed_models = JSON.stringify(body.allowed_models);
+        if (body.is_active !== undefined)
+            fields.is_active = body.is_active;
+        updateRouterKey(db, id, fields);
+        return reply.send({ success: true });
+    });
+    app.delete("/admin/api/router-keys/:id", async (request, reply) => {
+        const { id } = request.params;
+        deleteRouterKey(db, id);
+        return reply.send({ success: true });
+    });
+    app.get("/admin/api/models/available", async (_request, reply) => {
+        const models = getAvailableModels(db);
+        return reply.send(models);
+    });
+    done();
+};

package/dist/admin/routes.d.ts

@@ -0,0 +1,12 @@
+import { FastifyPluginCallback } from "fastify";
+import Database from "better-sqlite3";
+import { RetryRuleMatcher } from "../proxy/retry-rules.js";
+interface AdminRoutesOptions {
+    db: Database.Database;
+    adminPassword: string;
+    jwtSecret: string;
+    encryptionKey: string;
+    matcher: RetryRuleMatcher | null;
+}
+export declare const adminRoutes: FastifyPluginCallback<AdminRoutesOptions>;
+export {};

package/dist/admin/routes.js

@@ -0,0 +1,22 @@
+import { adminAuthPlugin, adminLoginRoutes } from "../middleware/admin-auth.js";
+import { adminProviderRoutes } from "./providers.js";
+import { adminMappingRoutes } from "./mappings.js";
+import { adminGroupRoutes } from "./groups.js";
+import { adminRetryRuleRoutes } from "./retry-rules.js";
+import { adminLogRoutes } from "./logs.js";
+import { adminStatsRoutes } from "./stats.js";
+import { adminMetricsRoutes } from "./metrics.js";
+import { adminRouterKeyRoutes } from "./router-keys.js";
+export const adminRoutes = (app, options, done) => {
+    app.register(adminAuthPlugin, { adminPassword: options.adminPassword, jwtSecret: options.jwtSecret });
+    app.register(adminLoginRoutes, { adminPassword: options.adminPassword, jwtSecret: options.jwtSecret });
+    app.register(adminProviderRoutes, { db: options.db, encryptionKey: options.encryptionKey });
+    app.register(adminMappingRoutes, { db: options.db });
+    app.register(adminGroupRoutes, { db: options.db });
+    app.register(adminRetryRuleRoutes, { db: options.db, matcher: options.matcher });
+    app.register(adminLogRoutes, { db: options.db });
+    app.register(adminRouterKeyRoutes, { db: options.db, encryptionKey: options.encryptionKey });
+    app.register(adminStatsRoutes, { db: options.db });
+    app.register(adminMetricsRoutes, { db: options.db });
+    done();
+};

package/dist/admin/services.d.ts

@@ -0,0 +1,7 @@
+import { FastifyPluginCallback } from "fastify";
+interface ServiceRoutesOptions {
+    db: any;
+    encryptionKey: string;
+}
+export declare const adminServiceRoutes: FastifyPluginCallback<ServiceRoutesOptions>;
+export {};

package/dist/admin/services.js

@@ -0,0 +1,63 @@
+import { getAllBackendServices, getBackendServiceById, createBackendService, updateBackendService, deleteBackendService } from "../db/index.js";
+import { decrypt, encrypt } from "../utils/crypto.js";
+function maskApiKey(encrypted, key) {
+    const decrypted = decrypt(encrypted, key);
+    if (decrypted.length <= 8)
+        return "****";
+    return `${decrypted.slice(0, 4)}...${decrypted.slice(-4)}`;
+}
+export const adminServiceRoutes = (app, options, done) => {
+    const { db, encryptionKey } = options;
+    app.get("/admin/api/services", async (_request, reply) => {
+        const services = getAllBackendServices(db);
+        return reply.send(services.map((s) => ({
+            ...s,
+            api_key: maskApiKey(s.api_key, encryptionKey),
+        })));
+    });
+    app.post("/admin/api/services", async (request, reply) => {
+        const body = request.body;
+        if (!body.name || !body.api_type || !body.base_url || !body.api_key) {
+            return reply.code(400).send({ error: { message: "Missing required fields: name, api_type, base_url, api_key" } });
+        }
+        if (!["openai", "anthropic"].includes(body.api_type)) {
+            return reply.code(400).send({ error: { message: "api_type must be 'openai' or 'anthropic'" } });
+        }
+        const encryptedKey = encrypt(body.api_key, encryptionKey);
+        const id = createBackendService(db, {
+            name: body.name,
+            api_type: body.api_type,
+            base_url: body.base_url,
+            api_key: encryptedKey,
+            is_active: body.is_active ?? 1,
+        });
+        return reply.code(201).send({ id });
+    });
+    app.put("/admin/api/services/:id", async (request, reply) => {
+        const { id } = request.params;
+        const existing = getBackendServiceById(db, id);
+        if (!existing) {
+            return reply.code(404).send({ error: { message: "Service not found" } });
+        }
+        const body = request.body;
+        const fields = {};
+        if (body.name !== undefined)
+            fields.name = body.name;
+        if (body.api_type !== undefined)
+            fields.api_type = body.api_type;
+        if (body.base_url !== undefined)
+            fields.base_url = body.base_url;
+        if (body.is_active !== undefined)
+            fields.is_active = body.is_active;
+        if (body.api_key)
+            fields.api_key = encrypt(body.api_key, encryptionKey);
+        updateBackendService(db, id, fields);
+        return reply.send({ success: true });
+    });
+    app.delete("/admin/api/services/:id", async (request, reply) => {
+        const { id } = request.params;
+        deleteBackendService(db, id);
+        return reply.send({ success: true });
+    });
+    done();
+};

package/dist/admin/stats.d.ts

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

package/dist/admin/stats.js

@@ -0,0 +1,15 @@
+import { Type } from "@sinclair/typebox";
+import { getStats } from "../db/index.js";
+const StatsQuerySchema = Type.Object({
+    period: Type.Optional(Type.String()),
+    router_key_id: Type.Optional(Type.String()),
+});
+export const adminStatsRoutes = (app, options, done) => {
+    app.get("/admin/api/stats", { schema: { querystring: StatsQuerySchema } }, async (request, reply) => {
+        const query = request.query;
+        const period = (query.period || "24h");
+        const stats = getStats(options.db, period, query.router_key_id);
+        return reply.send(stats);
+    });
+    done();
+};

package/dist/config.d.ts

@@ -0,0 +1,15 @@
+import "dotenv/config";
+export interface Config {
+    ADMIN_PASSWORD: string;
+    ENCRYPTION_KEY: string;
+    JWT_SECRET: string;
+    PORT: number;
+    DB_PATH: string;
+    LOG_LEVEL: string;
+    TZ: string;
+    STREAM_TIMEOUT_MS: number;
+    RETRY_MAX_ATTEMPTS: number;
+    RETRY_BASE_DELAY_MS: number;
+}
+export declare function resetConfig(): void;
+export declare function getConfig(): Config;

package/dist/config.js

@@ -0,0 +1,28 @@
+import "dotenv/config";
+let cachedConfig = null;
+export function resetConfig() {
+    cachedConfig = null;
+}
+export function getConfig() {
+    if (cachedConfig)
+        return cachedConfig;
+    const requiredVars = ["ADMIN_PASSWORD", "ENCRYPTION_KEY", "JWT_SECRET"];
+    for (const name of requiredVars) {
+        if (!process.env[name]) {
+            throw new Error(`Missing required environment variable: ${name}`);
+        }
+    }
+    cachedConfig = {
+        ADMIN_PASSWORD: process.env.ADMIN_PASSWORD,
+        ENCRYPTION_KEY: process.env.ENCRYPTION_KEY,
+        JWT_SECRET: process.env.JWT_SECRET,
+        PORT: parseInt(process.env.PORT || "3000", 10),
+        DB_PATH: process.env.DB_PATH || "./data/router.db",
+        LOG_LEVEL: process.env.LOG_LEVEL || "info",
+        TZ: process.env.TZ || "Asia/Shanghai",
+        STREAM_TIMEOUT_MS: parseInt(process.env.STREAM_TIMEOUT_MS || "3000000", 10),
+        RETRY_MAX_ATTEMPTS: parseInt(process.env.RETRY_MAX_ATTEMPTS || "3", 10),
+        RETRY_BASE_DELAY_MS: parseInt(process.env.RETRY_BASE_DELAY_MS || "1000", 10),
+    };
+    return cachedConfig;
+}

package/dist/db/helpers.d.ts

@@ -0,0 +1,12 @@
+import Database from "better-sqlite3";
+/**
+ * 通用 UPDATE 构建器。
+ * 用白名单过滤安全字段，拼接 SET 子句。
+ *
+ * table 参数来自代码中的字符串常量（非用户输入），不存在 SQL 注入风险。
+ */
+export declare function buildUpdateQuery(db: Database.Database, table: string, id: string, fields: Record<string, unknown>, allowedKeys: Set<string>, options?: {
+    updatedAt?: boolean;
+}): void;
+/** 通用 DELETE by ID */
+export declare function deleteById(db: Database.Database, table: string, id: string): void;

package/dist/db/helpers.js

@@ -0,0 +1,28 @@
+/**
+ * 通用 UPDATE 构建器。
+ * 用白名单过滤安全字段，拼接 SET 子句。
+ *
+ * table 参数来自代码中的字符串常量（非用户输入），不存在 SQL 注入风险。
+ */
+export function buildUpdateQuery(db, table, id, fields, allowedKeys, options) {
+    const sets = [];
+    const values = [];
+    for (const [key, value] of Object.entries(fields)) {
+        if (allowedKeys.has(key)) {
+            sets.push(`${key} = ?`);
+            values.push(value);
+        }
+    }
+    if (sets.length === 0)
+        return;
+    if (options?.updatedAt) {
+        sets.push("updated_at = ?");
+        values.push(new Date().toISOString());
+    }
+    values.push(id);
+    db.prepare(`UPDATE ${table} SET ${sets.join(", ")} WHERE id = ?`).run(...values);
+}
+/** 通用 DELETE by ID */
+export function deleteById(db, table, id) {
+    db.prepare(`DELETE FROM ${table} WHERE id = ?`).run(id);
+}

package/dist/db/index.d.ts

@@ -0,0 +1,16 @@
+import Database from "better-sqlite3";
+export declare function initDatabase(dbPath: string): Database.Database;
+export { getActiveProviders, getAllProviders, getProviderById, createProvider, updateProvider, deleteProvider, } from "./providers.js";
+export type { Provider } from "./providers.js";
+export { getModelMapping, getAllModelMappings, createModelMapping, updateModelMapping, deleteModelMapping, getMappingGroup, getMappingGroupById, getAllMappingGroups, createMappingGroup, updateMappingGroup, deleteMappingGroup, } from "./mappings.js";
+export type { ModelMapping, MappingGroup } from "./mappings.js";
+export { getActiveRetryRules, getAllRetryRules, createRetryRule, updateRetryRule, deleteRetryRule, seedDefaultRules, } 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 { 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 { getStats } from "./stats.js";
+export type { Stats, StatsPeriod } from "./stats.js";

package/dist/db/index.js

@@ -0,0 +1,45 @@
+import Database from "better-sqlite3";
+import { readFileSync, readdirSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const MIGRATIONS_DIR = join(__dirname, "migrations");
+export function initDatabase(dbPath) {
+    if (dbPath !== ":memory:") {
+        mkdirSync(dirname(dbPath), { recursive: true });
+    }
+    const db = new Database(dbPath);
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS migrations (
+      name TEXT PRIMARY KEY,
+      applied_at TEXT NOT NULL
+    );
+  `);
+    const applied = new Set(db.prepare("SELECT name FROM migrations").all().map((r) => r.name));
+    const files = readdirSync(MIGRATIONS_DIR)
+        .filter((f) => f.endsWith(".sql"))
+        .sort();
+    for (const file of files) {
+        if (applied.has(file))
+            continue;
+        try {
+            const sql = readFileSync(join(MIGRATIONS_DIR, file), "utf-8");
+            db.exec(sql);
+        }
+        catch (err) {
+            console.error(`Failed to apply migration ${file}:`, err);
+            throw err;
+        }
+        db.prepare("INSERT INTO migrations (name, applied_at) VALUES (?, ?)").run(file, new Date().toISOString());
+    }
+    return db;
+}
+// --- Re-export from per-table modules ---
+export { getActiveProviders, getAllProviders, getProviderById, createProvider, updateProvider, deleteProvider, } from "./providers.js";
+export { getModelMapping, getAllModelMappings, createModelMapping, updateModelMapping, deleteModelMapping, getMappingGroup, getMappingGroupById, getAllMappingGroups, createMappingGroup, updateMappingGroup, deleteMappingGroup, } from "./mappings.js";
+export { getActiveRetryRules, getAllRetryRules, createRetryRule, updateRetryRule, deleteRetryRule, seedDefaultRules, } from "./retry-rules.js";
+export { insertRequestLog, getRequestLogs, getRequestLogById, deleteLogsBefore, insertMetrics, } from "./logs.js";
+export { getRouterKeyByHash, getAllRouterKeys, getRouterKeyById, createRouterKey, updateRouterKey, deleteRouterKey, getAvailableModels, } from "./router-keys.js";
+export { getMetricsSummary, getMetricsTimeseries } from "./metrics.js";
+export { getStats } from "./stats.js";

package/dist/db/logs.d.ts

@@ -0,0 +1,90 @@
+import Database from "better-sqlite3";
+export interface RequestLog {
+    id: string;
+    api_type: string;
+    model: string | null;
+    provider_id: string | null;
+    status_code: number | null;
+    latency_ms: number | null;
+    is_stream: number;
+    error_message: string | null;
+    created_at: string;
+    request_body: string | null;
+    response_body: string | null;
+    client_request: string | null;
+    upstream_request: string | null;
+    upstream_response: string | null;
+    client_response: string | null;
+    is_retry: number;
+    original_request_id: string | null;
+}
+/** 列表查询扩展字段：JOIN request_metrics + providers 获得 */
+export interface RequestLogListRow extends RequestLog {
+    backend_model: string | null;
+    provider_name: string | null;
+}
+export interface MetricsRow {
+    id: string;
+    request_log_id: string;
+    provider_id: string;
+    backend_model: string;
+    api_type: string;
+    input_tokens: number | null;
+    output_tokens: number | null;
+    cache_creation_tokens: number | null;
+    cache_read_tokens: number | null;
+    ttft_ms: number | null;
+    total_duration_ms: number | null;
+    tokens_per_second: number | null;
+    stop_reason: string | null;
+    is_complete: number;
+    created_at: string;
+}
+export type MetricsInsert = {
+    request_log_id: string;
+    provider_id: string;
+    backend_model: string;
+    api_type: string;
+    input_tokens?: number | null;
+    output_tokens?: number | null;
+    cache_creation_tokens?: number | null;
+    cache_read_tokens?: number | null;
+    ttft_ms?: number | null;
+    total_duration_ms?: number | null;
+    tokens_per_second?: number | null;
+    stop_reason?: string | null;
+    is_complete?: number;
+};
+export declare function insertRequestLog(db: Database.Database, log: {
+    id: string;
+    api_type: string;
+    model: string | null;
+    provider_id: string | null;
+    status_code: number | null;
+    latency_ms: number | null;
+    is_stream: number;
+    error_message: string | null;
+    created_at: string;
+    request_body?: string | null;
+    response_body?: string | null;
+    client_request?: string | null;
+    upstream_request?: string | null;
+    upstream_response?: string | null;
+    client_response?: string | null;
+    is_retry?: number;
+    original_request_id?: string | null;
+    router_key_id?: string | null;
+}): void;
+export declare function getRequestLogs(db: Database.Database, options: {
+    page: number;
+    limit: number;
+    api_type?: string;
+    model?: string;
+    router_key_id?: string;
+}): {
+    data: RequestLogListRow[];
+    total: number;
+};
+export declare function getRequestLogById(db: Database.Database, id: string): RequestLog | undefined;
+export declare function deleteLogsBefore(db: Database.Database, beforeDate: string): number;
+export declare function insertMetrics(db: Database.Database, m: MetricsInsert): string;

package/dist/db/logs.js

@@ -0,0 +1,47 @@
+import { randomUUID } from "crypto";
+// --- request_logs ---
+export function insertRequestLog(db, log) {
+    db.prepare(`INSERT INTO request_logs (id, api_type, model, provider_id, status_code, latency_ms, is_stream, error_message, created_at, request_body, response_body, client_request, upstream_request, upstream_response, client_response, is_retry, original_request_id, router_key_id)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(log.id, log.api_type, log.model, log.provider_id, log.status_code, log.latency_ms, log.is_stream, log.error_message, log.created_at, log.request_body ?? null, log.response_body ?? null, log.client_request ?? null, log.upstream_request ?? null, log.upstream_response ?? null, log.client_response ?? null, log.is_retry ?? 0, log.original_request_id ?? null, log.router_key_id ?? null);
+}
+export function getRequestLogs(db, options) {
+    let where = "1=1";
+    const params = [];
+    if (options.api_type) {
+        where += " AND rl.api_type = ?";
+        params.push(options.api_type);
+    }
+    if (options.model) {
+        where += " AND rl.model LIKE ?";
+        params.push(`%${options.model}%`);
+    }
+    if (options.router_key_id) {
+        where += " AND rl.router_key_id = ?";
+        params.push(options.router_key_id);
+    }
+    const total = db.prepare(`SELECT COUNT(*) as count FROM request_logs rl WHERE ${where}`).get(...params).count;
+    const offset = (options.page - 1) * options.limit;
+    const data = db
+        .prepare(`SELECT rl.id, rl.api_type, rl.model, rl.provider_id, rl.status_code, rl.latency_ms,
+              rl.is_stream, rl.error_message, rl.created_at, rl.is_retry, rl.original_request_id,
+              rm.backend_model, COALESCE(p.name, rl.provider_id) AS provider_name
+       FROM request_logs rl
+       LEFT JOIN request_metrics rm ON rm.request_log_id = rl.id
+       LEFT JOIN providers p ON p.id = rl.provider_id
+       WHERE ${where} ORDER BY rl.created_at DESC LIMIT ? OFFSET ?`)
+        .all(...params, options.limit, offset);
+    return { data, total };
+}
+export function getRequestLogById(db, id) {
+    return db.prepare("SELECT * FROM request_logs WHERE id = ?").get(id);
+}
+export function deleteLogsBefore(db, beforeDate) {
+    return db.prepare("DELETE FROM request_logs WHERE created_at < ?").run(beforeDate).changes;
+}
+// --- request_metrics ---
+export function insertMetrics(db, m) {
+    const id = randomUUID();
+    db.prepare(`INSERT INTO request_metrics (id, request_log_id, provider_id, backend_model, api_type, input_tokens, output_tokens, cache_creation_tokens, cache_read_tokens, ttft_ms, total_duration_ms, tokens_per_second, stop_reason, is_complete)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, m.request_log_id, m.provider_id, m.backend_model, m.api_type, m.input_tokens ?? null, m.output_tokens ?? null, m.cache_creation_tokens ?? null, m.cache_read_tokens ?? null, m.ttft_ms ?? null, m.total_duration_ms ?? null, m.tokens_per_second ?? null, m.stop_reason ?? null, m.is_complete ?? 1);
+    return id;
+}

package/dist/db/mappings.d.ts

@@ -0,0 +1,36 @@
+import Database from "better-sqlite3";
+export interface ModelMapping {
+    id: string;
+    client_model: string;
+    backend_model: string;
+    provider_id: string;
+    is_active: number;
+    created_at: string;
+}
+export interface MappingGroup {
+    id: string;
+    client_model: string;
+    strategy: string;
+    rule: string;
+    created_at: string;
+}
+export declare function getModelMapping(db: Database.Database, clientModel: string): ModelMapping | undefined;
+export declare function getAllModelMappings(db: Database.Database): ModelMapping[];
+export declare function createModelMapping(db: Database.Database, mapping: {
+    client_model: string;
+    backend_model: string;
+    provider_id: string;
+    is_active?: number;
+}): string;
+export declare function updateModelMapping(db: Database.Database, id: string, fields: Partial<Pick<ModelMapping, "client_model" | "backend_model" | "provider_id" | "is_active">>): void;
+export declare function deleteModelMapping(db: Database.Database, id: string): void;
+export declare function getMappingGroup(db: Database.Database, clientModel: string): MappingGroup | undefined;
+export declare function getMappingGroupById(db: Database.Database, id: string): MappingGroup | undefined;
+export declare function getAllMappingGroups(db: Database.Database): MappingGroup[];
+export declare function createMappingGroup(db: Database.Database, mapping: {
+    client_model: string;
+    strategy: string;
+    rule: string;
+}): string;
+export declare function updateMappingGroup(db: Database.Database, id: string, fields: Partial<Pick<MappingGroup, "client_model" | "strategy" | "rule">>): void;
+export declare function deleteMappingGroup(db: Database.Database, id: string): void;