llm-simple-router 0.8.2 → 0.9.4

package/dist/admin/quick-setup.js

@@ -0,0 +1,169 @@
+import { Type } from "@sinclair/typebox";
+import { createProvider } from "../db/providers.js";
+import { createMappingGroup, updateMappingGroup } from "../db/mappings.js";
+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 { HTTP_CREATED, HTTP_BAD_REQUEST, HTTP_CONFLICT } from "./constants.js";
+import { API_CODE, apiError } from "./api-response.js";
+import { PROVIDER_CONCURRENCY_DEFAULTS } from "../db/providers.js";
+const PROVIDER_NAME_RE = /^[a-zA-Z0-9_-]+$/;
+const API_KEY_PREVIEW_MIN_LENGTH = 8;
+const API_KEY_PREVIEW_PREFIX_LEN = 4;
+const QuickSetupProviderSchema = Type.Object({
+    name: Type.String({ minLength: 1 }),
+    api_type: Type.Union([Type.Literal("openai"), Type.Literal("openai-responses"), Type.Literal("anthropic")]),
+    base_url: Type.String({ minLength: 1 }),
+    api_key: Type.String({ minLength: 1 }),
+    models: Type.Array(Type.Object({
+        name: Type.String(),
+        context_window: Type.Optional(Type.Number()),
+        patches: Type.Optional(Type.Array(Type.String())),
+    })),
+    concurrency_mode: Type.Optional(Type.Union([Type.Literal("auto"), Type.Literal("manual"), Type.Literal("none")])),
+    max_concurrency: Type.Optional(Type.Number()),
+    queue_timeout_ms: Type.Optional(Type.Number()),
+    max_queue_size: Type.Optional(Type.Number()),
+});
+const QuickSetupMappingSchema = Type.Object({
+    client_model: Type.String({ minLength: 1 }),
+    backend_model: Type.String({ minLength: 1 }),
+});
+const QuickSetupRetryRuleSchema = Type.Object({
+    name: Type.String({ minLength: 1 }),
+    status_code: Type.Number({ minimum: 100, maximum: 599 }),
+    body_pattern: Type.String({ minLength: 1 }),
+    retry_strategy: Type.Union([Type.Literal("fixed"), Type.Literal("exponential")]),
+    retry_delay_ms: Type.Number({ minimum: 100 }),
+    max_retries: Type.Number({ minimum: 0, maximum: 100 }),
+    max_delay_ms: Type.Number({ minimum: 100 }),
+});
+const QuickSetupTransformSchema = Type.Object({
+    inject_headers: Type.Optional(Type.Record(Type.String(), Type.String())),
+    request_defaults: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+    drop_fields: Type.Optional(Type.Array(Type.String())),
+});
+const QuickSetupSchema = Type.Object({
+    provider: QuickSetupProviderSchema,
+    mappings: Type.Array(QuickSetupMappingSchema),
+    retry_rules: Type.Array(QuickSetupRetryRuleSchema),
+    transform_rules: Type.Optional(QuickSetupTransformSchema),
+});
+export const adminQuickSetupRoutes = (app, options, done) => {
+    const { db, stateRegistry, tracker, adaptiveController } = options;
+    app.post("/admin/api/quick-setup", { schema: { body: QuickSetupSchema } }, async (request, reply) => {
+        const body = request.body;
+        // 1. Validate provider name
+        if (!PROVIDER_NAME_RE.test(body.provider.name)) {
+            return reply.code(HTTP_BAD_REQUEST).send(apiError(API_CODE.VALIDATION_FAILED, "Provider 名称仅允许英文大小写字母、数字、横线和下划线"));
+        }
+        // 2. Check no duplicate provider name
+        const existing = db.prepare("SELECT id FROM providers WHERE name = ?").get(body.provider.name);
+        if (existing) {
+            return reply.code(HTTP_CONFLICT).send(apiError(API_CODE.CONFLICT_NAME, `Provider 名称 '${body.provider.name}' 已存在`));
+        }
+        // 3. Validate retry rule body_pattern regex
+        for (const rule of body.retry_rules) {
+            try {
+                new RegExp(rule.body_pattern);
+            }
+            catch {
+                return reply.code(HTTP_BAD_REQUEST).send(apiError(API_CODE.INVALID_REGEX, `重试规则「${rule.name}」的 body_pattern 不是有效的正则表达式`));
+            }
+        }
+        // 4. Start transaction
+        const encryptionKey = getSetting(db, "encryption_key");
+        const createAll = db.transaction(() => {
+            // 5. Create provider with models JSON
+            const encryptedKey = encrypt(body.provider.api_key, encryptionKey);
+            const modelEntries = body.provider.models.map(m => ({
+                name: m.name,
+                ...(m.context_window != null ? { context_window: m.context_window } : {}),
+                ...(m.patches && m.patches.length > 0 ? { patches: m.patches } : {}),
+            }));
+            const adaptiveEnabled = body.provider.concurrency_mode === 'auto' ? 1 : 0;
+            const maxConcurrency = body.provider.max_concurrency ?? PROVIDER_CONCURRENCY_DEFAULTS.max_concurrency;
+            const queueTimeoutMs = body.provider.queue_timeout_ms ?? PROVIDER_CONCURRENCY_DEFAULTS.queue_timeout_ms;
+            const maxQueueSize = body.provider.max_queue_size ?? PROVIDER_CONCURRENCY_DEFAULTS.max_queue_size;
+            const providerId = createProvider(db, {
+                name: body.provider.name,
+                api_type: body.provider.api_type,
+                base_url: body.provider.base_url,
+                api_key: encryptedKey,
+                api_key_preview: body.provider.api_key.length > API_KEY_PREVIEW_MIN_LENGTH
+                    ? `${body.provider.api_key.slice(0, API_KEY_PREVIEW_PREFIX_LEN)}...${body.provider.api_key.slice(-API_KEY_PREVIEW_PREFIX_LEN)}`
+                    : "****",
+                models: JSON.stringify(modelEntries),
+                is_active: 1,
+                max_concurrency: maxConcurrency,
+                queue_timeout_ms: queueTimeoutMs,
+                max_queue_size: maxQueueSize,
+                adaptive_enabled: adaptiveEnabled,
+            });
+            // 6. Upsert mapping groups
+            for (const m of body.mappings) {
+                const existing = db.prepare('SELECT id FROM mapping_groups WHERE client_model = ?').get(m.client_model);
+                const ruleJson = JSON.stringify({
+                    targets: [{ backend_model: m.backend_model, provider_id: providerId }],
+                });
+                if (existing) {
+                    updateMappingGroup(db, existing.id, {
+                        client_model: m.client_model,
+                        rule: ruleJson,
+                    });
+                }
+                else {
+                    createMappingGroup(db, {
+                        client_model: m.client_model,
+                        rule: ruleJson,
+                    });
+                }
+            }
+            // 7. Create retry rules
+            for (const r of body.retry_rules) {
+                createRetryRule(db, {
+                    name: r.name,
+                    status_code: r.status_code,
+                    body_pattern: r.body_pattern,
+                    is_active: 1,
+                    retry_strategy: r.retry_strategy,
+                    retry_delay_ms: r.retry_delay_ms,
+                    max_retries: r.max_retries,
+                    max_delay_ms: r.max_delay_ms,
+                });
+            }
+            // 8. Create transform rules
+            if (body.transform_rules) {
+                upsertTransformRule(db, providerId, {
+                    inject_headers: body.transform_rules.inject_headers ?? null,
+                    request_defaults: body.transform_rules.request_defaults ?? null,
+                    drop_fields: body.transform_rules.drop_fields ?? null,
+                    is_active: 1,
+                });
+            }
+            return providerId;
+        });
+        // 8. Execute transaction
+        const providerId = createAll();
+        // 9. Sync concurrency state
+        const finalAdaptiveEnabled = body.provider.concurrency_mode === 'auto' ? 1 : 0;
+        const finalMaxConcurrency = body.provider.max_concurrency ?? PROVIDER_CONCURRENCY_DEFAULTS.max_concurrency;
+        const finalQueueTimeoutMs = body.provider.queue_timeout_ms ?? PROVIDER_CONCURRENCY_DEFAULTS.queue_timeout_ms;
+        const finalMaxQueueSize = body.provider.max_queue_size ?? PROVIDER_CONCURRENCY_DEFAULTS.max_queue_size;
+        adaptiveController?.syncProvider(providerId, {
+            adaptive_enabled: finalAdaptiveEnabled,
+            max_concurrency: finalMaxConcurrency,
+            queue_timeout_ms: finalQueueTimeoutMs,
+            max_queue_size: finalMaxQueueSize,
+        });
+        tracker?.updateProviderConfig(providerId, {
+            name: body.provider.name,
+            maxConcurrency: finalMaxConcurrency,
+            queueTimeoutMs: finalQueueTimeoutMs,
+            maxQueueSize: finalMaxQueueSize,
+        });
+        return reply.code(HTTP_CREATED).send({ success: true, provider_id: providerId });
+    });
+    done();
+};

package/dist/admin/recommended.js

@@ -7,7 +7,11 @@ export const adminRecommendedRoutes = (app, options, done) => {
     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)));
+        // Return all rules with `exists` flag, so the frontend can show all and mark existing ones
+        return reply.send(rules.map(r => ({
+            ...r,
+            exists: existing.has(r.name),
+        })));
     });
     app.post("/admin/api/recommended/reload", async (_req, reply) => {
         reloadConfig();

package/dist/admin/routes.js

@@ -14,6 +14,7 @@ import { adminSettingsRoutes } from "./settings.js";
 import { adminRecommendedRoutes } from "./recommended.js";
 import { adminUsageRoutes } from "./usage.js";
 import { adminUpgradeRoutes } from "./upgrade.js";
+import { adminQuickSetupRoutes } from "./quick-setup.js";
 import { adminImportExportRoutes } from "./settings-import-export.js";
 import { adminTransformRuleRoutes } from "./transform-rules.js";
 import { adminScheduleRoutes } from "./schedules.js";
@@ -37,6 +38,7 @@ export const adminRoutes = (app, options, done) => {
     app.register(adminImportExportRoutes, { db: options.db, stateRegistry: options.stateRegistry, pluginRegistry: options.pluginRegistry });
     app.register(adminRecommendedRoutes, { db: options.db });
     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(adminTransformRuleRoutes, { db: options.db, pluginRegistry: options.pluginRegistry });
     done();

package/dist/config/model-context.d.ts

@@ -1,10 +1,16 @@
 export interface ModelInfo {
     name: string;
     context_window: number | null;
+    patches: string[];
+}
+export interface ModelEntry {
+    name: string;
+    context_window?: number;
+    patches?: string[];
 }
 export declare const MODEL_CONTEXT_WINDOWS: Record<string, number>;
 export declare const DEFAULT_CONTEXT_WINDOW = 200000;
 export declare const OVERFLOW_THRESHOLD = 1000000;
 export declare function lookupContextWindow(modelName: string): number;
-export declare function parseModels(raw: string): string[];
-export declare function buildModelInfoList(modelNames: string[], overrides: Map<string, number>): ModelInfo[];
+export declare function parseModels(raw: string): ModelEntry[];
+export declare function buildModelInfoList(modelEntries: ModelEntry[], overrides: Map<string, number>): ModelInfo[];

package/dist/config/model-context.js

@@ -91,15 +91,27 @@ export function parseModels(raw) {
         const parsed = JSON.parse(raw);
         if (!Array.isArray(parsed))
             return [];
-        return parsed.map((item) => typeof item === 'string' ? item : item?.name ?? '').filter(Boolean);
+        return parsed.map((item) => {
+            if (typeof item === 'string') {
+                return item ? { name: item, patches: [] } : null;
+            }
+            const obj = item;
+            if (!obj || !obj.name)
+                return null;
+            return {
+                name: obj.name,
+                patches: obj.patches ?? [],
+            };
+        }).filter((e) => e !== null);
     }
     catch {
         return [];
     }
 }
-export function buildModelInfoList(modelNames, overrides) {
-    return modelNames.map(name => ({
-        name,
-        context_window: overrides.get(name) ?? lookupContextWindow(name),
+export function buildModelInfoList(modelEntries, overrides) {
+    return modelEntries.map(entry => ({
+        name: entry.name,
+        context_window: overrides.get(entry.name) ?? lookupContextWindow(entry.name),
+        patches: entry.patches ?? [],
     }));
 }

package/dist/config/recommended.d.ts

@@ -1,7 +1,7 @@
 export interface ProviderPreset {
     plan: string;
     presetName: string;
-    apiType: 'openai' | 'anthropic';
+    apiType: 'openai' | 'openai-responses' | 'anthropic';
     baseUrl: string;
     models: string[];
 }
@@ -17,6 +17,7 @@ export interface RecommendedRetryRule {
     retry_delay_ms: number;
     max_retries: number;
     max_delay_ms: number;
+    providers?: string[];
 }
 export declare function loadRecommendedConfig(dir?: string): void;
 export declare function getRecommendedProviders(): ProviderGroup[];

package/dist/config/recommended.js

@@ -1,22 +1,18 @@
 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;
+    return loadJson('recommended-providers.json');
 }
 export function getRecommendedRetryRules() {
-    return cachedRetryRules;
-}
-export function reloadConfig() {
-    loadRecommendedConfig(configDir);
+    return loadJson('recommended-retry-rules.json');
 }
+// No-op: kept for backward compat (reload endpoint, upgrade flow)
+// Config is now always read from disk, no caching.
+export function reloadConfig() { }
 function loadJson(filename) {
     const filePath = path.join(configDir, filename);
     try {

package/dist/core/constants.js

@@ -14,6 +14,8 @@ export const PROXY_API_TYPES = {
     "/v1/chat/completions": "openai",
     "/v1/models": "openai",
     "/v1/messages": "anthropic",
+    "/v1/responses": "openai-responses",
+    "/responses": "openai-responses",
 };
 export function getProxyApiType(url) {
     const path = url.split("?")[0];

package/dist/db/index.js

@@ -14,6 +14,11 @@ const MIGRATION_RENAMES = {
     "028_convert_old_rule_format.sql": "029_convert_old_rule_format.sql",
     "029_add_input_tokens_estimated.sql": "030_add_input_tokens_estimated.sql",
     "030_add_tps_breakdown.sql": "031_add_tps_breakdown.sql",
+    // 消除双 033/034，重新编号 035→038
+    "033_add_pipeline_snapshot.sql": "033_add_adaptive_concurrency.sql",
+    "034_drop_redundant_log_columns.sql": "035_drop_redundant_log_columns.sql",
+    "035_add_openai_responses_api_type.sql": "036_add_openai_responses_api_type.sql",
+    "036_fix_035_data_corruption.sql": "037_fix_035_data_corruption.sql",
 };
 export function initDatabase(dbPath) {
     if (dbPath !== ":memory:") {

package/dist/db/migrations/033_add_adaptive_concurrency.sql

@@ -1,3 +1,6 @@
 -- 033_add_adaptive_concurrency.sql
 ALTER TABLE providers ADD COLUMN adaptive_enabled INTEGER NOT NULL DEFAULT 0;
 ALTER TABLE providers ADD COLUMN adaptive_min INTEGER NOT NULL DEFAULT 1;
+
+-- (merged from 033_add_pipeline_snapshot)
+ALTER TABLE request_logs ADD COLUMN pipeline_snapshot TEXT;

package/dist/db/migrations/036_add_openai_responses_api_type.sql

@@ -0,0 +1,68 @@
+-- Expand api_type CHECK constraint to include 'openai-responses'
+-- SQLite doesn't support ALTER TABLE ... ALTER CONSTRAINT, so we recreate the table.
+-- We must temporarily drop referencing foreign key tables and recreate them after.
+
+-- Note: This migration runs inside db.transaction() in the migration runner,
+-- so we don't need our own BEGIN/COMMIT. PRAGMA foreign_keys doesn't work
+-- inside transactions, so we handle FK tables explicitly instead.
+
+-- Step 1: Save referencing table data as temp tables
+CREATE TABLE IF NOT EXISTS _tmp_provider_model_info AS SELECT * FROM provider_model_info;
+CREATE TABLE IF NOT EXISTS _tmp_provider_transform_rules AS SELECT * FROM provider_transform_rules;
+
+-- Step 2: Drop referencing tables
+DROP TABLE IF EXISTS provider_model_info;
+DROP TABLE IF EXISTS provider_transform_rules;
+
+-- Step 3: Recreate providers with expanded CHECK
+CREATE TABLE providers_new (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL UNIQUE,
+  api_type TEXT NOT NULL CHECK(api_type IN ('openai', 'openai-responses', 'anthropic')),
+  base_url TEXT NOT NULL,
+  api_key TEXT NOT NULL,
+  api_key_preview TEXT,
+  models TEXT NOT NULL DEFAULT '[]',
+  is_active INTEGER NOT NULL DEFAULT 1,
+  max_concurrency INTEGER NOT NULL DEFAULT 0,
+  queue_timeout_ms INTEGER NOT NULL DEFAULT 0,
+  max_queue_size INTEGER NOT NULL DEFAULT 100,
+  adaptive_enabled INTEGER NOT NULL DEFAULT 0,
+  adaptive_min INTEGER NOT NULL DEFAULT 1,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+INSERT INTO providers_new (id, name, api_type, base_url, api_key, api_key_preview, models, is_active, max_concurrency, queue_timeout_ms, max_queue_size, adaptive_enabled, adaptive_min, created_at, updated_at)
+SELECT id, name, api_type, base_url, api_key, api_key_preview, models, is_active, max_concurrency, queue_timeout_ms, max_queue_size, adaptive_enabled, adaptive_min, created_at, updated_at FROM providers;
+DROP TABLE providers;
+ALTER TABLE providers_new RENAME TO providers;
+
+-- Step 4: Recreate referencing tables with their original schemas
+CREATE TABLE provider_model_info (
+  provider_id TEXT NOT NULL,
+  model_name TEXT NOT NULL,
+  context_window INTEGER NOT NULL,
+  PRIMARY KEY (provider_id, model_name),
+  FOREIGN KEY (provider_id) REFERENCES providers(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS provider_transform_rules (
+  provider_id TEXT PRIMARY KEY REFERENCES providers(id) ON DELETE CASCADE,
+  inject_headers TEXT,
+  request_defaults TEXT,
+  drop_fields TEXT,
+  field_overrides TEXT,
+  plugin_name TEXT,
+  is_active INTEGER DEFAULT 1,
+  created_at TEXT DEFAULT (datetime('now')),
+  updated_at TEXT DEFAULT (datetime('now'))
+);
+
+-- Step 5: Restore data
+INSERT INTO provider_model_info SELECT * FROM _tmp_provider_model_info;
+INSERT OR IGNORE INTO provider_transform_rules SELECT * FROM _tmp_provider_transform_rules;
+
+-- Step 6: Cleanup
+DROP TABLE _tmp_provider_model_info;
+DROP TABLE _tmp_provider_transform_rules;

package/dist/db/migrations/037_fix_035_data_corruption.sql

@@ -0,0 +1,54 @@
+-- Fix data corruption caused by migration 036.
+-- Migration 035 used `INSERT INTO providers_new SELECT * FROM providers`
+-- which matches columns by position, not by name. The new table had a different
+-- column order than the old table (where columns were added sequentially via
+-- ALTER TABLE ADD COLUMN). This shifted every column from position 6 onward.
+--
+-- Old column order (via ALTER TABLE ADD COLUMN):
+--   id, name, api_type, base_url, api_key, is_active, created_at, updated_at,
+--   api_key_preview, models, max_concurrency, queue_timeout_ms, max_queue_size,
+--   adaptive_enabled, adaptive_min
+--
+-- New column order (035):
+--   id, name, api_type, base_url, api_key, api_key_preview, models, is_active,
+--   max_concurrency, queue_timeout_ms, max_queue_size, adaptive_enabled,
+--   adaptive_min, created_at, updated_at
+--
+-- Positional mapping of what actually went where:
+--   old(6) is_active            → new api_key_preview
+--   old(7) created_at           → new models
+--   old(8) updated_at           → new is_active
+--   old(9) api_key_preview      → new max_concurrency  ← visible bug
+--   old(10) models              → new queue_timeout_ms
+--   old(11) max_concurrency     → new max_queue_size
+--   old(12) queue_timeout_ms    → new adaptive_enabled
+--   old(13) max_queue_size      → new adaptive_min
+--   old(14) adaptive_enabled    → new created_at
+--   old(15) adaptive_min        → new updated_at
+--
+-- Guard: only fixes rows where max_concurrency contains text data
+-- (api_key_preview leaked into an INTEGER column). Providers created after
+-- 035 have correct INTEGER values and are not affected.
+
+-- Step 1: Snapshot current data before fixing
+CREATE TABLE _m036_snapshot AS SELECT rowid, * FROM providers;
+
+-- Step 2: Only fix rows where max_concurrency is text (corrupted by api_key_preview).
+-- Each column reads from the snapshot position where the OLD value actually ended up.
+UPDATE providers SET
+  api_key_preview  = (SELECT max_concurrency   FROM _m036_snapshot s WHERE s.rowid = providers.rowid),
+  models           = (SELECT queue_timeout_ms  FROM _m036_snapshot s WHERE s.rowid = providers.rowid),
+  is_active        = (SELECT CAST(api_key_preview  AS INTEGER) FROM _m036_snapshot s WHERE s.rowid = providers.rowid),
+  max_concurrency  = (SELECT CAST(max_queue_size   AS INTEGER) FROM _m036_snapshot s WHERE s.rowid = providers.rowid),
+  queue_timeout_ms = (SELECT CAST(adaptive_enabled AS INTEGER) FROM _m036_snapshot s WHERE s.rowid = providers.rowid),
+  max_queue_size   = (SELECT CAST(adaptive_min     AS INTEGER) FROM _m036_snapshot s WHERE s.rowid = providers.rowid),
+  adaptive_enabled = (SELECT CAST(created_at      AS INTEGER) FROM _m036_snapshot s WHERE s.rowid = providers.rowid),
+  adaptive_min     = (SELECT CAST(updated_at      AS INTEGER) FROM _m036_snapshot s WHERE s.rowid = providers.rowid),
+  created_at       = (SELECT models    FROM _m036_snapshot s WHERE s.rowid = providers.rowid),
+  updated_at       = (SELECT is_active FROM _m036_snapshot s WHERE s.rowid = providers.rowid)
+WHERE typeof((
+  SELECT max_concurrency FROM _m036_snapshot s WHERE s.rowid = providers.rowid
+)) = 'text';
+
+-- Step 3: Cleanup
+DROP TABLE _m036_snapshot;

package/dist/db/providers.d.ts

@@ -2,7 +2,7 @@ import Database from "better-sqlite3";
 export interface Provider {
     id: string;
     name: string;
-    api_type: "openai" | "anthropic";
+    api_type: "openai" | "openai-responses" | "anthropic";
     base_url: string;
     api_key: string;
     api_key_preview?: string;
@@ -20,12 +20,12 @@ export declare const PROVIDER_CONCURRENCY_DEFAULTS: {
     readonly queue_timeout_ms: 0;
     readonly max_queue_size: 100;
 };
-export declare function getActiveProviders(db: Database.Database, apiType: "openai" | "anthropic"): Provider[];
+export declare function getActiveProviders(db: Database.Database, apiType: "openai" | "openai-responses" | "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";
+    api_type: "openai" | "openai-responses" | "anthropic";
     base_url: string;
     api_key: string;
     api_key_preview?: string;

package/dist/index.js

@@ -17,6 +17,7 @@ import { loadRecommendedConfig } from "./config/recommended.js";
 import { authMiddleware } from "./middleware/auth.js";
 import { openaiProxy } from "./proxy/handler/openai.js";
 import { anthropicProxy } from "./proxy/handler/anthropic.js";
+import { responsesProxy } from "./proxy/handler/responses.js";
 import { adminRoutes } from "./admin/routes.js";
 import { RetryRuleMatcher } from "./proxy/orchestration/retry-rules.js";
 import { PluginRegistry } from "./proxy/transform/plugin-registry.js";
@@ -230,6 +231,7 @@ export async function buildApp(options) {
     app.register(authMiddleware, { db });
     app.register(openaiProxy, { db, container });
     app.register(anthropicProxy, { db, container });
+    app.register(responsesProxy, { db, container });
     // StateRegistry — Admin 层通过此接口触发 proxy 层状态刷新，消除 admin→proxy 依赖
     const stateRegistry = {
         refreshRetryRules: () => matcher.load(db),
@@ -344,13 +346,15 @@ export async function main() {
         }
         /* eslint-enable taste/no-silent-catch */
     });
-    // 优雅关闭：SIGTERM（systemd/docker stop）和 SIGINT（Ctrl+C）
+    // 优雅关闭：SIGTERM 和 SIGINT（Ctrl+C）
+    // 首次 = 优雅关闭，再次 = 强制退出
     let isShuttingDown = false;
     const GRACEFUL_SHUTDOWN_TIMEOUT_MS = 10_000;
     const shutdown = async (signal) => {
-        // 防止重复触发：多次 Ctrl+C 只执行一次关闭
+        // 第二次收到信号 = 强制退出（Ctrl+C 卡住时用户可再按一次）
         if (isShuttingDown) {
-            app.log.info(`Received ${signal} again, already shutting down...`);
+            app.log.warn(`Received ${signal} again, forcing exit`);
+            process.exit(1);
             return;
         }
         isShuttingDown = true;

package/dist/metrics/metrics-extractor.d.ts

@@ -20,10 +20,11 @@ export declare class MetricsExtractor {
     private textStreamStartTime;
     private toolUseContentBuffer;
     private toolUseStreamStartTime;
-    constructor(apiType: "openai" | "anthropic", requestStartTime: number);
+    constructor(apiType: "openai" | "openai-responses" | "anthropic", requestStartTime: number);
     processEvent(event: SSEEvent): void;
     getMetrics(): MetricsResult;
-    static fromNonStreamResponse(apiType: "openai" | "anthropic", responseBody: string): MetricsResult | null;
+    static fromNonStreamResponse(apiType: "openai" | "openai-responses" | "anthropic", responseBody: string): MetricsResult | null;
+    private processResponsesEvent;
     private processAnthropicEvent;
     private processOpenAIEvent;
 }

package/dist/metrics/metrics-extractor.js

@@ -32,6 +32,9 @@ export class MetricsExtractor {
         if (this.apiType === "anthropic") {
             this.processAnthropicEvent(event);
         }
+        else if (this.apiType === "openai-responses") {
+            this.processResponsesEvent(event);
+        }
         else {
             this.processOpenAIEvent(event);
         }
@@ -118,6 +121,48 @@ export class MetricsExtractor {
         }
         return extractAnthropicNonStream(parsed);
     }
+    processResponsesEvent(event) {
+        let obj;
+        try {
+            obj = JSON.parse(event.data);
+        }
+        catch {
+            return;
+        }
+        const type = obj.type;
+        // Track first content for TTFT
+        const isContentDelta = type === "response.output_text.delta"
+            || type === "response.function_call_arguments.delta"
+            || type === "response.reasoning_summary_text.delta";
+        if (isContentDelta) {
+            const delta = obj.delta ?? "";
+            if (delta && !this.firstContentReceived) {
+                this.firstContentReceived = true;
+                this.ttftMs = Date.now() - this.requestStartTime;
+            }
+            this.textContentBuffer += delta;
+        }
+        // Track completion
+        if (type === "response.completed" || type === "response.incomplete") {
+            this.streamEndTime = Date.now();
+            this.complete = true;
+            const resp = obj.response;
+            if (resp) {
+                const usage = resp.usage;
+                if (usage) {
+                    this.inputTokens = usage.input_tokens ?? null;
+                    this.outputTokens = usage.output_tokens ?? null;
+                }
+                const status = resp.status;
+                if (status === "completed")
+                    this.stopReason = "end_turn";
+                else if (status === "incomplete")
+                    this.stopReason = "max_tokens";
+                else
+                    this.stopReason = "stop";
+            }
+        }
+    }
     processAnthropicEvent(event) {
         let parsed;
         try {

package/dist/metrics/sse-metrics-transform.d.ts

@@ -27,7 +27,7 @@ export declare class SSEMetricsTransform extends Transform {
     private throttleMs;
     private lastCallbackTime;
     private flushed;
-    constructor(apiType: "openai" | "anthropic", requestStartTime: number, options?: MetricsTransformOptions);
+    constructor(apiType: "openai" | "openai-responses" | "anthropic", requestStartTime: number, options?: MetricsTransformOptions);
     _transform(chunk: Buffer, _encoding: BufferEncoding, callback: TransformCallback): void;
     _flush(callback: TransformCallback): void;
     getExtractor(): MetricsExtractor;

package/dist/metrics/sse-metrics-transform.js

@@ -83,6 +83,16 @@ export class SSEMetricsTransform extends Transform {
                 if (delta.type === "input_json_delta" && typeof delta.partial_json === "string")
                     return delta.partial_json;
             }
+            else if (this.apiType === "openai-responses") {
+                const type = parsed.type;
+                if (type === "response.output_text.delta")
+                    return parsed.delta;
+                if (type === "response.reasoning_summary_text.delta")
+                    return parsed.delta;
+                if (type === "response.function_call_arguments.delta")
+                    return parsed.delta;
+                return undefined;
+            }
             else {
                 const choices = parsed.choices;
                 if (!Array.isArray(choices) || choices.length === 0)

package/dist/monitor/request-tracker.d.ts

@@ -34,7 +34,7 @@ export declare class RequestTracker {
     private scheduleStreamContentPush;
     private flushStreamContentPush;
     update(id: string, patch: Partial<ActiveRequest>): void;
-    appendStreamChunk(id: string, rawLine: string, apiType: "openai" | "anthropic", maxRaw: number, maxText: number): void;
+    appendStreamChunk(id: string, rawLine: string, apiType: "openai" | "openai-responses" | "anthropic", maxRaw: number, maxText: number): void;
     complete(id: string, result: {
         status: "completed" | "failed";
         statusCode?: number;

package/dist/monitor/stream-content-accumulator.d.ts

@@ -9,6 +9,6 @@ export declare class StreamContentAccumulator {
     private totalChars;
     private blocks;
     constructor(maxRaw?: number, maxText?: number);
-    append(rawLine: string, apiType: "openai" | "anthropic"): void;
+    append(rawLine: string, apiType: "openai" | "openai-responses" | "anthropic"): void;
     getSnapshot(): StreamContentSnapshot;
 }

package/dist/monitor/stream-extractor.d.ts

@@ -8,4 +8,4 @@ export interface StreamExtraction {
         name?: string;
     } | null;
 }
-export declare function extractStreamText(line: string, apiType: "openai" | "anthropic"): StreamExtraction;
+export declare function extractStreamText(line: string, apiType: "openai" | "openai-responses" | "anthropic"): StreamExtraction;