llm-simple-router 0.1.0 → 0.2.0

package/dist/db/mappings.js

@@ -53,3 +53,75 @@ export function updateMappingGroup(db, id, fields) {
 export function deleteMappingGroup(db, id) {
     deleteById(db, "mapping_groups", id);
 }
+/** 从 providers.models 获取所有可用模型 */
+export function getActiveProviderModels(db) {
+    const providers = db.prepare("SELECT name, models, is_active FROM providers WHERE is_active = 1").all();
+    const results = [];
+    for (const p of providers) {
+        try {
+            const models = JSON.parse(p.models);
+            for (const m of models) {
+                results.push({ provider_name: p.name, backend_model: m });
+            }
+        }
+        catch { /* 忽略解析失败 */ }
+    }
+    return results;
+}
+function isTargetLike(obj) {
+    return typeof obj === "object" && obj !== null &&
+        typeof obj.backend_model === "string" &&
+        typeof obj.provider_id === "string";
+}
+function extractTargets(rule) {
+    const results = [];
+    if (isTargetLike(rule.default))
+        results.push(rule.default);
+    if (Array.isArray(rule.targets)) {
+        for (const t of rule.targets) {
+            if (isTargetLike(t))
+                results.push(t);
+        }
+    }
+    if (Array.isArray(rule.windows)) {
+        for (const w of rule.windows) {
+            if (w && typeof w === "object" && isTargetLike(w.target)) {
+                results.push(w.target);
+            }
+        }
+    }
+    return results;
+}
+/**
+ * 根据 "provider_name/backend_model" 验证模型是否存在于 provider 配置中。
+ * 同时尝试从 mapping_groups 中找到对应的 client_model 用于路由。
+ * 如果找不到 mapping，返回 backend_model 本身（由 proxy-core 兜底处理）。
+ */
+export function resolveByProviderModel(db, providerName, backendModel) {
+    const providerRow = db.prepare("SELECT id, models FROM providers WHERE name = ? AND is_active = 1").get(providerName);
+    if (!providerRow)
+        return null;
+    try {
+        const models = JSON.parse(providerRow.models);
+        if (!models.includes(backendModel))
+            return null;
+    }
+    catch {
+        return null;
+    }
+    // 尝试从 mapping_groups 找到包含此 provider+backend_model 的 client_model
+    const groups = db.prepare("SELECT client_model, rule FROM mapping_groups").all();
+    for (const g of groups) {
+        try {
+            const rule = JSON.parse(g.rule);
+            const targets = extractTargets(rule);
+            const match = targets.find(t => t.provider_id === providerRow.id && t.backend_model === backendModel);
+            if (match) {
+                return { client_model: g.client_model, provider_id: providerRow.id, backend_model: backendModel };
+            }
+        }
+        catch { /* continue */ }
+    }
+    // provider 有这个模型但没有 mapping group，直接返回 provider 维度信息
+    return { client_model: backendModel, provider_id: providerRow.id, backend_model: backendModel };
+}

package/dist/db/migrations/014_create_settings.sql

@@ -0,0 +1,4 @@
+CREATE TABLE IF NOT EXISTS settings (
+  key   TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);

package/dist/db/migrations/015_add_original_model.sql

@@ -0,0 +1 @@
+ALTER TABLE request_logs ADD COLUMN original_model TEXT;

package/dist/db/migrations/016_create_session_model_tables.sql

@@ -0,0 +1,24 @@
+CREATE TABLE IF NOT EXISTS session_model_states (
+  id TEXT PRIMARY KEY,
+  router_key_id TEXT NOT NULL,
+  session_id TEXT NOT NULL,
+  current_model TEXT NOT NULL,
+  original_model TEXT,
+  last_active_at TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  UNIQUE(router_key_id, session_id),
+  FOREIGN KEY (router_key_id) REFERENCES router_keys(id)
+);
+CREATE INDEX idx_sms_router_key ON session_model_states(router_key_id);
+
+CREATE TABLE IF NOT EXISTS session_model_history (
+  id TEXT PRIMARY KEY,
+  router_key_id TEXT NOT NULL,
+  session_id TEXT NOT NULL,
+  old_model TEXT,
+  new_model TEXT NOT NULL,
+  trigger_type TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  FOREIGN KEY (router_key_id) REFERENCES router_keys(id)
+);
+CREATE INDEX idx_smh_session ON session_model_history(router_key_id, session_id);

package/dist/db/session-states.d.ts

@@ -0,0 +1,40 @@
+import Database from "better-sqlite3";
+export interface SessionModelState {
+    id: string;
+    router_key_id: string;
+    router_key_name?: string;
+    session_id: string;
+    current_model: string;
+    original_model: string | null;
+    last_active_at: string;
+    created_at: string;
+}
+export interface SessionModelHistory {
+    id: string;
+    router_key_id: string;
+    session_id: string;
+    old_model: string | null;
+    new_model: string;
+    trigger_type: string;
+    created_at: string;
+}
+export interface UpsertSessionStateInput {
+    id?: string;
+    router_key_id: string;
+    session_id: string;
+    current_model: string;
+    original_model?: string | null;
+}
+export interface InsertSessionHistoryInput {
+    router_key_id: string;
+    session_id: string;
+    old_model?: string | null;
+    new_model: string;
+    trigger_type: string;
+}
+export declare function getSessionStates(db: Database.Database): SessionModelState[];
+export declare function getSessionHistory(db: Database.Database, routerKeyId: string, sessionId: string): SessionModelHistory[];
+export declare function upsertSessionState(db: Database.Database, input: UpsertSessionStateInput): string;
+export declare function insertSessionHistory(db: Database.Database, input: InsertSessionHistoryInput): string;
+export declare function deleteSessionState(db: Database.Database, routerKeyId: string, sessionId: string): void;
+export declare function getSessionState(db: Database.Database, routerKeyId: string, sessionId: string): SessionModelState | undefined;

package/dist/db/session-states.js

@@ -0,0 +1,37 @@
+import { randomUUID } from "crypto";
+// --- CRUD ---
+export function getSessionStates(db) {
+    return db.prepare(`SELECT sms.*, rk.name AS router_key_name
+     FROM session_model_states sms
+     JOIN router_keys rk ON rk.id = sms.router_key_id
+     ORDER BY sms.last_active_at DESC`).all();
+}
+export function getSessionHistory(db, routerKeyId, sessionId) {
+    return db.prepare(`SELECT * FROM session_model_history
+     WHERE router_key_id = ? AND session_id = ?
+     ORDER BY created_at DESC`).all(routerKeyId, sessionId);
+}
+export function upsertSessionState(db, input) {
+    const now = new Date().toISOString();
+    const id = input.id ?? randomUUID();
+    db.prepare(`INSERT INTO session_model_states (id, router_key_id, session_id, current_model, original_model, last_active_at, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(router_key_id, session_id) DO UPDATE SET
+       current_model = excluded.current_model,
+       original_model = excluded.original_model,
+       last_active_at = excluded.last_active_at`).run(id, input.router_key_id, input.session_id, input.current_model, input.original_model ?? null, now, now);
+    return id;
+}
+export function insertSessionHistory(db, input) {
+    const id = randomUUID();
+    const now = new Date().toISOString();
+    db.prepare(`INSERT INTO session_model_history (id, router_key_id, session_id, old_model, new_model, trigger_type, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`).run(id, input.router_key_id, input.session_id, input.old_model ?? null, input.new_model, input.trigger_type, now);
+    return id;
+}
+export function deleteSessionState(db, routerKeyId, sessionId) {
+    db.prepare(`DELETE FROM session_model_states WHERE router_key_id = ? AND session_id = ?`).run(routerKeyId, sessionId);
+}
+export function getSessionState(db, routerKeyId, sessionId) {
+    return db.prepare(`SELECT * FROM session_model_states WHERE router_key_id = ? AND session_id = ?`).get(routerKeyId, sessionId);
+}

package/dist/db/settings.d.ts

@@ -0,0 +1,4 @@
+import Database from "better-sqlite3";
+export declare function getSetting(db: Database.Database, key: string): string | null;
+export declare function setSetting(db: Database.Database, key: string, value: string): void;
+export declare function isInitialized(db: Database.Database): boolean;

package/dist/db/settings.js

@@ -0,0 +1,10 @@
+export function getSetting(db, key) {
+    const row = db.prepare("SELECT value FROM settings WHERE key = ?").get(key);
+    return row?.value ?? null;
+}
+export function setSetting(db, key, value) {
+    db.prepare("INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?)").run(key, value);
+}
+export function isInitialized(db) {
+    return getSetting(db, "initialized") === "true";
+}

package/dist/index.d.ts

@@ -11,3 +11,4 @@ export declare function buildApp(options?: AppOptions): Promise<{
     db: Database.Database;
     close: () => Promise<void>;
 }>;
+export declare function main(): Promise<void>;

package/dist/index.js

@@ -2,8 +2,20 @@
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { existsSync } from "node:fs";
+import { randomUUID } from "crypto";
 import Fastify from "fastify";
+import { insertRequestLog } from "./db/logs.js";
 const HTTP_NOT_FOUND = 404;
+// 代理路由路径 → api_type，用于在全局 hook/errorHandler 中识别代理请求
+const PROXY_API_TYPES = {
+    "/v1/chat/completions": "openai",
+    "/v1/messages": "anthropic",
+    "/v1/models": "openai",
+};
+function getProxyApiType(url) {
+    const path = url.split("?")[0];
+    return PROXY_API_TYPES[path] ?? null;
+}
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 import { getConfig } from "./config.js";
@@ -13,9 +25,10 @@ import { openaiProxy } from "./proxy/openai.js";
 import { anthropicProxy } from "./proxy/anthropic.js";
 import { adminRoutes } from "./admin/routes.js";
 import { RetryRuleMatcher } from "./proxy/retry-rules.js";
+import { modelState } from "./proxy/model-state.js";
 import fastifyStatic from "@fastify/static";
 export async function buildApp(options) {
-    const config = options?.config ?? getConfig();
+    const config = options?.config ?? getBaseConfig();
     // 允许外部传入已初始化的 DB（测试用），否则自行创建
     let db;
     if (options?.db) {
@@ -24,9 +37,21 @@ export async function buildApp(options) {
     else {
         db = initDatabase(config.DB_PATH);
     }
+    const isDev = process.env.NODE_ENV !== "production";
     const app = Fastify({
         logger: {
             level: config.LOG_LEVEL,
+            ...(isDev
+                ? {
+                    transport: {
+                        target: "pino-pretty",
+                        options: {
+                            translateTime: "SYS:yyyy-mm-dd HH:MM:ss.l",
+                            ignore: "pid,hostname",
+                        },
+                    },
+                }
+                : {}),
         },
         // 统一 schema validation 错误格式为 { error: { message } }
         ajv: {
@@ -44,10 +69,28 @@ export async function buildApp(options) {
             .join("; ");
         return new Error(message);
     });
-    // 统一 schema validation 错误响应格式
-    app.setErrorHandler((error, _request, reply) => {
+    // 统一 schema validation 错误响应格式，代理路由的错误也记录到 request_logs
+    app.setErrorHandler((error, request, reply) => {
         const fastifyError = error;
         const status = fastifyError.statusCode ?? 500;
+        const proxyApiType = getProxyApiType(request.url);
+        if (proxyApiType) {
+            request.log.error({ statusCode: status, err: error }, `Proxy request error: ${fastifyError.message}`);
+            const body = request.body;
+            insertRequestLog(db, {
+                id: randomUUID(),
+                api_type: proxyApiType,
+                model: body?.model || null,
+                provider_id: null,
+                status_code: status,
+                latency_ms: 0,
+                is_stream: 0,
+                error_message: fastifyError.message,
+                created_at: new Date().toISOString(),
+                client_request: JSON.stringify({ headers: request.headers }),
+                router_key_id: request.routerKey?.id ?? null,
+            });
+        }
         if (status === 400 && fastifyError.validation) {
             return reply.code(400).send({ error: { message: fastifyError.message } });
         }
@@ -55,12 +98,13 @@ export async function buildApp(options) {
     });
     // 首次启动时插入默认重试规则（表为空时）
     seedDefaultRules(db);
+    // 注入 DB 到 modelState 单例，启用会话级持久化
+    modelState.init(db);
     const matcher = new RetryRuleMatcher();
     matcher.load(db);
     app.register(authMiddleware, { db });
     app.register(openaiProxy, {
         db,
-        encryptionKey: config.ENCRYPTION_KEY,
         streamTimeoutMs: config.STREAM_TIMEOUT_MS,
         retryMaxAttempts: config.RETRY_MAX_ATTEMPTS,
         retryBaseDelayMs: config.RETRY_BASE_DELAY_MS,
@@ -68,19 +112,12 @@ export async function buildApp(options) {
     });
     app.register(anthropicProxy, {
         db,
-        encryptionKey: config.ENCRYPTION_KEY,
         streamTimeoutMs: config.STREAM_TIMEOUT_MS,
         retryMaxAttempts: config.RETRY_MAX_ATTEMPTS,
         retryBaseDelayMs: config.RETRY_BASE_DELAY_MS,
         matcher,
     });
-    app.register(adminRoutes, {
-        db,
-        adminPassword: config.ADMIN_PASSWORD,
-        jwtSecret: config.JWT_SECRET,
-        encryptionKey: config.ENCRYPTION_KEY,
-        matcher,
-    });
+    app.register(adminRoutes, { db, matcher });
     // 前端静态文件服务（生产环境）
     const frontendDist = path.resolve(process.env.FRONTEND_DIST || path.join(__dirname, "../frontend-dist"));
     if (existsSync(frontendDist)) {
@@ -113,7 +150,9 @@ export async function buildApp(options) {
         },
     };
 }
-async function main() {
+// index.ts 自身也需要 getBaseConfig，避免循环依赖
+import { getBaseConfig } from "./config.js";
+export async function main() {
     const { app } = await buildApp();
     const config = getConfig();
     try {
@@ -125,6 +164,7 @@ async function main() {
         process.exit(1);
     }
 }
+// 开发时直接运行 tsx src/index.ts 仍可启动
 const isMainModule = process.argv[1]?.endsWith("index.js") || process.argv[1]?.endsWith("index.ts");
 if (isMainModule) {
     main();

package/dist/middleware/admin-auth.d.ts

@@ -1,7 +1,7 @@
 import { FastifyPluginCallback } from "fastify";
+import Database from "better-sqlite3";
 interface AdminAuthOptions {
-    adminPassword: string;
-    jwtSecret: string;
+    db: Database.Database;
 }
 export declare const adminAuthPlugin: FastifyPluginCallback<AdminAuthOptions>;
 export declare const adminLoginRoutes: FastifyPluginCallback<AdminAuthOptions>;

package/dist/middleware/admin-auth.js

@@ -1,22 +1,34 @@
 import fp from "fastify-plugin";
 import cookie from "@fastify/cookie";
 import jwt from "jsonwebtoken";
-import { timingSafeEqual } from "crypto";
+import { isInitialized, getSetting } from "../db/settings.js";
+import { verifyPassword } from "../utils/password.js";
 const HTTP_UNAUTHORIZED = 401;
 const adminAuthRaw = (app, options, done) => {
     app.register(cookie);
     app.addHook("onRequest", async (request, reply) => {
         const path = request.url.split("?")[0];
-        if (!path.startsWith("/admin/api/") || path === "/admin/api/login" || path === "/admin/api/logout") {
+        // Setup API 不需要 auth
+        if (path.startsWith("/admin/api/setup/"))
             return;
+        // Login/logout 不需要 auth
+        if (path === "/admin/api/login" || path === "/admin/api/logout")
+            return;
+        // 非 admin API 路径跳过
+        if (!path.startsWith("/admin/api/"))
+            return;
+        // 未初始化时返回 needsSetup
+        if (!isInitialized(options.db)) {
+            return reply.code(HTTP_UNAUTHORIZED).send({ error: { message: "Not initialized", needsSetup: true } });
         }
         const token = request.cookies["admin_token"];
         if (!token) {
             reply.code(HTTP_UNAUTHORIZED).send({ error: { message: "Not authenticated" } });
             return reply;
         }
+        const secret = getSetting(options.db, "jwt_secret");
         try {
-            jwt.verify(token, options.jwtSecret);
+            jwt.verify(token, secret ?? "");
         }
         catch (err) {
             request.log.debug({ err }, "invalid JWT token");
@@ -28,18 +40,19 @@ const adminAuthRaw = (app, options, done) => {
 };
 export const adminAuthPlugin = fp(adminAuthRaw, { name: "admin-auth" });
 export const adminLoginRoutes = (app, options, done) => {
-    const TOKEN_EXPIRY_SECONDS = 86400;
+    const TOKEN_EXPIRY_SECONDS = 172800; // 48 hours
     app.post("/admin/api/login", async (request, reply) => {
         const { password } = request.body;
         if (!password) {
             return reply.code(HTTP_UNAUTHORIZED).send({ error: { message: "Invalid password" } });
         }
-        const passwordBuf = Buffer.from(password);
-        const keyBuf = Buffer.from(options.adminPassword);
-        if (passwordBuf.length !== keyBuf.length || !timingSafeEqual(passwordBuf, keyBuf)) {
+        // DB 模式：scrypt hash 验证
+        const hash = getSetting(options.db, "admin_password_hash");
+        if (!hash || !verifyPassword(password, hash)) {
             return reply.code(HTTP_UNAUTHORIZED).send({ error: { message: "Invalid password" } });
         }
-        const token = jwt.sign({ role: "admin" }, options.jwtSecret, { expiresIn: TOKEN_EXPIRY_SECONDS });
+        const secret = getSetting(options.db, "jwt_secret");
+        const token = jwt.sign({ role: "admin" }, secret, { expiresIn: TOKEN_EXPIRY_SECONDS });
         reply.setCookie("admin_token", token, {
             path: "/admin",
             httpOnly: true,

package/dist/middleware/auth.js

@@ -1,5 +1,7 @@
-import { createHash } from "crypto";
+import { createHash, randomUUID } from "crypto";
 import fp from "fastify-plugin";
+import { isInitialized } from "../db/settings.js";
+import { insertRequestLog } from "../db/logs.js";
 const SKIP_PATHS = ["/health", "/admin"];
 const HTTP_UNAUTHORIZED = 401;
 const BEARER_PREFIX_LENGTH = "Bearer ".length;
@@ -16,14 +18,54 @@ function unauthorizedReply(reply) {
         },
     });
 }
+// 代理路由路径 → api_type 映射，用于记录被认证拒绝的请求
+const PROXY_API_TYPES = {
+    "/v1/chat/completions": "openai",
+    "/v1/messages": "anthropic",
+    "/v1/models": "openai",
+};
+function getProxyApiType(url) {
+    const path = url.split("?")[0];
+    return PROXY_API_TYPES[path] ?? null;
+}
+function logRejectedAuth(db, apiType, statusCode, errorMessage, request) {
+    insertRequestLog(db, {
+        id: randomUUID(),
+        api_type: apiType,
+        model: null,
+        provider_id: null,
+        status_code: statusCode,
+        latency_ms: 0,
+        is_stream: 0,
+        error_message: errorMessage,
+        created_at: new Date().toISOString(),
+        client_request: JSON.stringify({ headers: request.headers }),
+    });
+}
 const authMiddlewareRaw = (app, options, done) => {
     const stmt = options.db.prepare("SELECT id, name, allowed_models FROM router_keys WHERE key_hash = ? AND is_active = 1");
     app.addHook("onRequest", async (request, reply) => {
         if (shouldSkipAuth(request.url)) {
             return;
         }
+        const proxyApiType = getProxyApiType(request.url);
+        // 代理请求一到达就记录技术日志
+        if (proxyApiType) {
+            request.log.info({ method: request.method, url: request.url, ip: request.ip }, `Proxy request received [${proxyApiType}]`);
+        }
+        // 未初始化时代理层不可用
+        if (!isInitialized(options.db)) {
+            if (proxyApiType) {
+                logRejectedAuth(options.db, proxyApiType, 503, "Service not initialized", request);
+            }
+            reply.code(503).send({ error: { message: "Service not initialized" } });
+            return reply;
+        }
         const authHeader = request.headers.authorization;
         if (!authHeader || !authHeader.startsWith("Bearer ")) {
+            if (proxyApiType) {
+                logRejectedAuth(options.db, proxyApiType, 401, "Invalid API key", request);
+            }
             unauthorizedReply(reply);
             return reply;
         }
@@ -31,6 +73,9 @@ const authMiddlewareRaw = (app, options, done) => {
         const hash = createHash("sha256").update(token).digest("hex");
         const row = stmt.get(hash);
         if (!row) {
+            if (proxyApiType) {
+                logRejectedAuth(options.db, proxyApiType, 401, "Invalid API key", request);
+            }
             unauthorizedReply(reply);
             return reply;
         }

package/dist/proxy/anthropic.d.ts

@@ -3,7 +3,6 @@ import type { FastifyPluginCallback } from "fastify";
 import { RetryRuleMatcher } from "./retry-rules.js";
 export interface AnthropicProxyOptions {
     db: Database.Database;
-    encryptionKey: string;
     streamTimeoutMs: number;
     retryMaxAttempts: number;
     retryBaseDelayMs: number;

package/dist/proxy/anthropic.js

@@ -24,9 +24,9 @@ const anthropicErrors = {
     }),
 };
 const anthropicProxyRaw = (app, opts, done) => {
-    const { db, encryptionKey, streamTimeoutMs, retryMaxAttempts, retryBaseDelayMs, matcher } = opts;
+    const { db, streamTimeoutMs, retryMaxAttempts, retryBaseDelayMs, matcher } = opts;
     app.post(MESSAGES_PATH, async (request, reply) => {
-        const deps = { db, encryptionKey, streamTimeoutMs, retryMaxAttempts, retryBaseDelayMs, matcher };
+        const deps = { db, streamTimeoutMs, retryMaxAttempts, retryBaseDelayMs, matcher };
         return handleProxyPost(request, reply, "anthropic", MESSAGES_PATH, anthropicErrors, deps);
     });
     done();

package/dist/proxy/directive-parser.d.ts

@@ -0,0 +1,7 @@
+export interface DirectiveParseResult {
+    modelName: string | null;
+    command: string | null;
+    cleanedBody: Record<string, unknown>;
+    isCommandMessage: boolean;
+}
+export declare function parseDirective(body: Record<string, unknown>): DirectiveParseResult;

package/dist/proxy/directive-parser.js

@@ -0,0 +1,70 @@
+const MODEL_MAX_LEN = 128;
+const MODEL_RE = /^[a-zA-Z0-9][a-zA-Z0-9._:-]*$/;
+function isValidModelName(name) {
+    return name.length <= MODEL_MAX_LEN && MODEL_RE.test(name) && !/^\d+$/.test(name);
+}
+export function parseDirective(body) {
+    const messages = body.messages;
+    if (!messages?.length) {
+        return {
+            modelName: null,
+            command: null,
+            cleanedBody: body,
+            isCommandMessage: false,
+        };
+    }
+    let lastUserIdx = -1;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i].role === "user") {
+            lastUserIdx = i;
+            break;
+        }
+    }
+    if (lastUserIdx < 0) {
+        return {
+            modelName: null,
+            command: null,
+            cleanedBody: body,
+            isCommandMessage: false,
+        };
+    }
+    // Deep clone to avoid mutating the original request body
+    const cleanedBody = JSON.parse(JSON.stringify(body));
+    const cleanedMessages = cleanedBody.messages;
+    const lastUser = cleanedMessages[lastUserIdx];
+    const content = Array.isArray(lastUser.content)
+        ? lastUser.content
+        : [lastUser.content];
+    let modelName = null;
+    let command = null;
+    let isCommandMessage = false;
+    const reInline = /\$SELECT-MODEL=([a-zA-Z0-9._:-]+)/g;
+    const reModelTag = /\[router-model:\s*([a-zA-Z0-9._\/:-]+)\s*\]/g;
+    const reCommand = /\[router-command:\s*(\S+(?:\s+\S+)?)\s*\]/g;
+    for (const block of content) {
+        if (!block || typeof block !== "object")
+            continue;
+        const b = block;
+        if (b.type !== "text" || !b.text)
+            continue;
+        let text = b.text;
+        const cmdMatch = reCommand.exec(text);
+        if (cmdMatch) {
+            command = cmdMatch[1];
+            isCommandMessage = true;
+            text = text.replace(reCommand, "").trim();
+        }
+        const inlineMatch = reInline.exec(text);
+        if (inlineMatch && isValidModelName(inlineMatch[1])) {
+            modelName = inlineMatch[1];
+            text = text.replace(reInline, "").trim();
+        }
+        const modelTagMatch = reModelTag.exec(text);
+        if (modelTagMatch && isValidModelName(modelTagMatch[1])) {
+            modelName = modelTagMatch[1];
+            text = text.replace(reModelTag, "").trim();
+        }
+        b.text = text;
+    }
+    return { modelName, command, cleanedBody, isCommandMessage };
+}

package/dist/proxy/enhancement-handler.d.ts

@@ -0,0 +1,23 @@
+import type { FastifyRequest } from "fastify";
+import Database from "better-sqlite3";
+export interface InterceptResponse {
+    statusCode: number;
+    body: unknown;
+    /** 拦截元数据，用于日志记录 */
+    meta?: {
+        action: string;
+        detail?: string;
+    };
+}
+export interface EnhancementResult {
+    effectiveModel: string;
+    originalModel: string | null;
+    interceptResponse: InterceptResponse | null;
+}
+/**
+ * 在代理转发前应用代理增强逻辑（指令解析 + 会话记忆 + 模型替换 + 命令拦截）。
+ * 仅当 proxy_enhancement.claude_code_enabled 开启时生效。
+ */
+export declare function applyEnhancement(db: Database.Database, request: FastifyRequest, clientModel: string, sessionId?: string): EnhancementResult;
+/** 生成注入到非流式响应中的模型信息标签 */
+export declare function buildModelInfoTag(effectiveModel: string): string;