aicodeswitch 5.1.2 → 5.1.3

package/dist/server/coding-plan-headers.js

@@ -0,0 +1,121 @@
+"use strict";
+/**
+ * 编程套餐 Headers 覆盖模块
+ *
+ * 当 APIService 启用 enableCodingPlan 时，将发送到上游的请求 Headers
+ * 覆盖为对应编程工具（Claude Code / Codex）的标准 Headers，
+ * 使供应商验证通过。
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyCodingPlanHeaders = applyCodingPlanHeaders;
+const crypto_1 = __importDefault(require("crypto"));
+/**
+ * 代理已设置的需要保留的 Headers
+ * 这些 Headers 由 buildUpstreamHeaders 设置，不能被覆盖删除
+ */
+const KEEP_HEADERS = new Set([
+    'authorization', // 认证头
+    'x-api-key', // Claude 认证头
+    'x-goog-api-key', // Gemini 认证头
+    'content-type', // 内容类型
+    'accept', // 接受类型
+    'accept-encoding', // 编码
+    'connection', // 连接
+    'content-length', // 内容长度
+    'anthropic-version', // Claude API 版本
+]);
+/**
+ * 构建 Claude Code 标准请求 Headers
+ */
+function buildClaudeCodeHeaders(sessionId) {
+    return {
+        'user-agent': 'claude-cli/2.1.168 (external, claude-vscode, agent-sdk/0.3.168)',
+        'x-claude-code-session-id': sessionId,
+        'x-stainless-arch': 'arm64',
+        'x-stainless-lang': 'js',
+        'x-stainless-os': 'MacOS',
+        'x-stainless-package-version': '0.94.0',
+        'x-stainless-retry-count': '0',
+        'x-stainless-runtime': 'node',
+        'x-stainless-runtime-version': 'v24.3.0',
+        'x-stainless-timeout': '3000',
+        'anthropic-beta': 'claude-code-20250219,context-1m-2025-08-07,interleaved-thinking-2025-05-14,context-management-2025-06-27,prompt-caching-scope-2026-01-05,mid-conversation-system-2026-04-07,effort-2025-11-24',
+        'anthropic-dangerous-direct-browser-access': 'true',
+        'x-app': 'cli',
+    };
+}
+/**
+ * 构建 Codex 标准请求 Headers
+ */
+function buildCodexHeaders(sessionId) {
+    return {
+        'x-codex-beta-features': 'terminal_resize_reflow,remote_compaction_v2',
+        'x-codex-turn-metadata': JSON.stringify({
+            session_id: sessionId,
+            thread_id: sessionId,
+            thread_source: 'user',
+            turn_id: crypto_1.default.randomUUID(),
+            sandbox: 'none',
+            workspace_kind: 'project',
+            request_kind: 'turn',
+        }),
+        'x-codex-window-id': `${sessionId}:0`,
+        'x-client-request-id': sessionId,
+        'session-id': sessionId,
+        'thread-id': sessionId,
+        'originator': 'codex_vscode',
+        'user-agent': 'codex_vscode/0.137.0-alpha.4 (Mac OS 26.5.0; arm64) unknown (VS Code; 26.602.40724)',
+    };
+}
+/**
+ * 判断 sourceType 是否为 Claude 源
+ */
+function isClaudeSourceType(sourceType) {
+    return sourceType === 'claude' || sourceType === 'claude-chat';
+}
+/**
+ * 判断 sourceType 是否为 OpenAI 源
+ */
+function isOpenAISourceType(sourceType) {
+    return sourceType === 'openai' || sourceType === 'openai-chat';
+}
+/**
+ * 应用编程工具 Headers 覆盖
+ *
+ * 当 service.enableCodingPlan 为 true 时调用。
+ * 清除原始请求中无关的 Headers，注入对应编程工具的标准 Headers。
+ *
+ * - Claude 源（claude/claude-chat）→ 注入 Claude Code Headers
+ * - OpenAI 源（openai/openai-chat）→ 注入 Codex Headers
+ * - Gemini 源不处理，保持原样
+ *
+ * @param headers     当前已构建的上游 Headers（会被原地修改）
+ * @param sourceType  上游服务的源类型
+ */
+function applyCodingPlanHeaders(headers, sourceType) {
+    const isClaude = isClaudeSourceType(sourceType);
+    const isOpenAI = isOpenAISourceType(sourceType);
+    // Gemini 源不需要 Headers 覆盖
+    if (!isClaude && !isOpenAI) {
+        return;
+    }
+    const sessionId = crypto_1.default.randomUUID();
+    // 1. 删除不在保留列表中的 Headers
+    for (const key of Object.keys(headers)) {
+        if (!KEEP_HEADERS.has(key.toLowerCase())) {
+            delete headers[key];
+        }
+    }
+    // 2. 注入编程工具标准 Headers
+    // 2. 注入编程工具标准 Headers
+    const toolHeaders = isClaude
+        ? buildClaudeCodeHeaders(sessionId)
+        : buildCodexHeaders(sessionId);
+    for (const [key, value] of Object.entries(toolHeaders)) {
+        headers[key] = value;
+    }
+    console.log(`\x1b[36m[CodingPlan-Headers]\x1b[0m Applied ${isClaude ? 'Claude Code' : 'Codex'} header override for upstream sourceType=${sourceType}`);
+}

package/dist/server/conversions/index.js

@@ -91,6 +91,7 @@ const response_js_12 = require("./pairs/gemini-responses/response.js");
 const streaming_js_12 = require("./pairs/gemini-responses/streaming.js");
 // --- Provider-driven post-processing ---
 const mapper_js_2 = require("./thinking/mapper.js");
+const tool_result_js_1 = require("./utils/tool-result.js");
 const effort_js_1 = require("./thinking/effort.js");
 // ============================================================
 // Public API: Request Transformation
@@ -294,6 +295,13 @@ function buildTargetBody(options) {
     if (toFormat === 'claude' && result.thinking && result.messages) {
         result.messages = (0, mapper_js_2.fixThinkingHistory)(result.messages, 'claude');
     }
+    // --- Ensure tool_result blocks have id for Claude-compatible providers ---
+    // Some providers (e.g. GLM) require an id field on tool_result content blocks,
+    // but standard Claude API tool_result blocks only have tool_use_id without id.
+    if (toFormat === 'claude' && result.messages) {
+        const { messages: patchedMessages } = (0, tool_result_js_1.ensureToolResultIds)(result.messages);
+        result.messages = patchedMessages;
+    }
     return result;
 }
 /** Identity converter that passes events through unchanged */

package/dist/server/conversions/utils/tool-result.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * Tool result content block utilities.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureToolResultIds = ensureToolResultIds;
+/**
+ * 为所有缺少 id 的 tool_result 块补上 id。
+ *
+ * 部分 Claude 兼容端点（如 GLM）要求 tool_result 内容块必须包含 id 字段，
+ * 但标准 Claude API 的 tool_result 块仅有 tool_use_id 而不带 id。
+ *
+ * id 取值策略：优先使用 tool_use_id（与对应的 tool_use.id 保持一致），
+ * 若 tool_use_id 也不存在则生成唯一 id。
+ */
+function ensureToolResultIds(messages) {
+    let totalPatched = 0;
+    const result = messages.map(msg => {
+        if (msg.role !== 'user' || !Array.isArray(msg.content))
+            return msg;
+        let patched = false;
+        const newContent = msg.content.map((b) => {
+            if (b.type === 'tool_result' && !b.id) {
+                patched = true;
+                totalPatched++;
+                // 使用 tool_use_id 作为 id，保持与对应 tool_use 块的 id 一致
+                const id = b.tool_use_id || `toolu_${crypto.randomUUID().replace(/-/g, '').slice(0, 24)}`;
+                return Object.assign(Object.assign({}, b), { id });
+            }
+            return b;
+        });
+        return patched ? Object.assign(Object.assign({}, msg), { content: newContent }) : msg;
+    });
+    return { messages: result, patchedCount: totalPatched };
+}

package/dist/server/fs-database.js

@@ -1597,6 +1597,18 @@ class FileSystemDatabaseManager {
             yield this.saveRules();
             this.routes.splice(index, 1);
             yield this.saveRoutes();
+            // 级联清理：清除绑定到该路由的会话的绑定关系
+            let sessionChanged = false;
+            for (const session of this.sessions) {
+                if (session.routeId === id) {
+                    session.routeId = undefined;
+                    session.routeName = undefined;
+                    sessionChanged = true;
+                }
+            }
+            if (sessionChanged) {
+                yield this.saveSessions();
+            }
             return true;
         });
     }
@@ -3052,6 +3064,11 @@ class FileSystemDatabaseManager {
                 existing.highIqRuleId = session.highIqRuleId;
             if (Object.prototype.hasOwnProperty.call(session, 'highIqEnabledAt'))
                 existing.highIqEnabledAt = session.highIqEnabledAt;
+            // 保留已有的路由绑定（不传入时不覆盖）
+            if (session.routeId !== undefined)
+                existing.routeId = session.routeId;
+            if (session.routeName !== undefined)
+                existing.routeName = session.routeName;
         }
         else {
             // 创建新 session
@@ -3071,11 +3088,52 @@ class FileSystemDatabaseManager {
                 highIqMode: session.highIqMode,
                 highIqRuleId: session.highIqRuleId,
                 highIqEnabledAt: session.highIqEnabledAt,
+                routeId: session.routeId,
+                routeName: session.routeName,
             });
         }
         // 异步保存（不阻塞）
         this.saveSessions().catch(console.error);
     }
+    /**
+     * 绑定会话到路由
+     */
+    bindSessionRoute(sessionId, routeId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const session = this.sessions.find(s => s.id === sessionId);
+            if (!session)
+                return null;
+            const route = this.routes.find(r => r.id === routeId);
+            if (!route)
+                return null;
+            session.routeId = routeId;
+            session.routeName = route.name;
+            yield this.saveSessions();
+            return session;
+        });
+    }
+    /**
+     * 解绑会话路由
+     */
+    unbindSessionRoute(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const session = this.sessions.find(s => s.id === sessionId);
+            if (!session)
+                return false;
+            session.routeId = undefined;
+            session.routeName = undefined;
+            yield this.saveSessions();
+            return true;
+        });
+    }
+    /**
+     * 获取绑定到指定路由的所有会话
+     */
+    getBoundSessions(routeId) {
+        return this.sessions
+            .filter(s => s.routeId === routeId)
+            .sort((a, b) => b.lastRequestAt - a.lastRequestAt);
+    }
     // 新增方法：获取规则黑名单状态
     getRuleBlacklistStatus(serviceId, routeId, contentType) {
         return __awaiter(this, void 0, void 0, function* () {

package/dist/server/main.js

@@ -33,6 +33,8 @@ const config_metadata_1 = require("./config-metadata");
 const config_merge_1 = require("./config-merge");
 const config_managed_fields_1 = require("./config-managed-fields");
 const config_1 = require("./config");
+const session_migration_1 = require("./session-migration");
+const session_launcher_1 = require("./session-launcher");
 const appDir = path_1.default.join(os_1.default.homedir(), '.aicodeswitch');
 const legacyDataDir = path_1.default.join(appDir, 'data');
 const dataDir = path_1.default.join(appDir, 'fs-db');
@@ -1770,6 +1772,150 @@ ${instruction}
         dbManager.clearSessions();
         res.json(true);
     })));
+    // ─── Session Route Binding API ───
+    app.put('/api/sessions/:id/bind-route', asyncHandler((req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        const sessionId = req.params.id;
+        const { routeId } = req.body || {};
+        if (!routeId) {
+            res.status(400).json({ success: false, error: 'routeId is required' });
+            return;
+        }
+        const session = dbManager.getSession(sessionId);
+        if (!session) {
+            res.status(404).json({ success: false, error: 'Session not found' });
+            return;
+        }
+        const updatedSession = yield dbManager.bindSessionRoute(sessionId, routeId);
+        if (!updatedSession) {
+            res.status(400).json({ success: false, error: 'Route not found' });
+            return;
+        }
+        res.json({ success: true, session: updatedSession });
+    })));
+    app.delete('/api/sessions/:id/bind-route', asyncHandler((req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        const sessionId = req.params.id;
+        const session = dbManager.getSession(sessionId);
+        if (!session) {
+            res.status(404).json({ success: false, error: 'Session not found' });
+            return;
+        }
+        const result = yield dbManager.unbindSessionRoute(sessionId);
+        res.json({ success: result });
+    })));
+    app.get('/api/routes/:id/bound-sessions', asyncHandler((req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        const routeId = req.params.id;
+        const route = dbManager.getRoute(routeId);
+        if (!route) {
+            res.status(404).json({ error: 'Route not found' });
+            return;
+        }
+        const sessions = dbManager.getBoundSessions(routeId);
+        res.json({
+            routeId,
+            sessions: sessions.map(s => ({
+                id: s.id,
+                title: s.title,
+                targetType: s.targetType,
+                requestCount: s.requestCount,
+                totalTokens: s.totalTokens,
+                lastRequestAt: s.lastRequestAt,
+            })),
+        });
+    })));
+    // ─── Session Migration API ───
+    app.post('/api/sessions/:id/migration-preview', asyncHandler((req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const sessionId = req.params.id;
+        const { targetTool, includeThinking, includeToolCalls, maxRounds } = req.body || {};
+        if (!targetTool || !['claude-code', 'codex'].includes(targetTool)) {
+            res.status(400).json({ error: 'Invalid targetTool. Must be "claude-code" or "codex".' });
+            return;
+        }
+        try {
+            const content = yield (0, session_migration_1.extractSessionContent)(dbManager, sessionId, {
+                sourceSessionId: sessionId,
+                targetTool,
+                includeThinking: includeThinking === true,
+                includeToolCalls: includeToolCalls !== false,
+                maxRounds: typeof maxRounds === 'number' ? maxRounds : 0,
+            });
+            const preview = (0, session_migration_1.previewMigration)(content, targetTool);
+            res.json(preview);
+        }
+        catch (err) {
+            if ((_a = err.message) === null || _a === void 0 ? void 0 : _a.includes('not found')) {
+                res.status(404).json({ error: err.message });
+            }
+            else {
+                res.status(500).json({ error: err.message || 'Migration preview failed' });
+            }
+        }
+    })));
+    app.post('/api/sessions/:id/migrate', asyncHandler((req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const sessionId = req.params.id;
+        const { targetTool, includeThinking, includeToolCalls, maxRounds, editedPrompt } = req.body || {};
+        if (!targetTool || !['claude-code', 'codex'].includes(targetTool)) {
+            res.status(400).json({ error: 'Invalid targetTool. Must be "claude-code" or "codex".' });
+            return;
+        }
+        try {
+            const content = yield (0, session_migration_1.extractSessionContent)(dbManager, sessionId, {
+                sourceSessionId: sessionId,
+                targetTool,
+                includeThinking: includeThinking === true,
+                includeToolCalls: includeToolCalls !== false,
+                maxRounds: typeof maxRounds === 'number' ? maxRounds : 0,
+            });
+            const result = (0, session_migration_1.migrateSession)(content, targetTool, editedPrompt);
+            res.json(result);
+        }
+        catch (err) {
+            if ((_a = err.message) === null || _a === void 0 ? void 0 : _a.includes('not found')) {
+                res.status(404).json({ error: err.message });
+            }
+            else {
+                res.status(500).json({ error: err.message || 'Migration failed' });
+            }
+        }
+    })));
+    app.post('/api/sessions/:id/migrate-launch', asyncHandler((req, res) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const sessionId = req.params.id;
+        const { targetTool, includeThinking, includeToolCalls, maxRounds } = req.body || {};
+        if (!targetTool || !['claude-code', 'codex'].includes(targetTool)) {
+            res.status(400).json({ error: 'Invalid targetTool. Must be "claude-code" or "codex".' });
+            return;
+        }
+        try {
+            // First extract content and generate prompt
+            const content = yield (0, session_migration_1.extractSessionContent)(dbManager, sessionId, {
+                sourceSessionId: sessionId,
+                targetTool,
+                includeThinking: includeThinking === true,
+                includeToolCalls: includeToolCalls !== false,
+                maxRounds: typeof maxRounds === 'number' ? maxRounds : 0,
+            });
+            const { prompt } = (0, session_migration_1.migrateSession)(content, targetTool);
+            // Resolve the project directory from session metadata
+            const projectDir = (0, session_launcher_1.resolveProjectDir)(sessionId, content.sourceTool);
+            // Write prompt to temp file
+            const tempFilePath = (0, session_launcher_1.writePromptToTempFile)(prompt, sessionId);
+            // Try to launch the target tool with the resolved project directory
+            const result = yield (0, session_launcher_1.launchTargetWithFallback)(targetTool, tempFilePath, prompt, projectDir || undefined);
+            // Schedule cleanup
+            (0, session_launcher_1.cleanupTempFile)(tempFilePath);
+            res.json(result);
+        }
+        catch (err) {
+            if ((_a = err.message) === null || _a === void 0 ? void 0 : _a.includes('not found')) {
+                res.status(404).json({ error: err.message });
+            }
+            else {
+                res.status(500).json({ error: err.message || 'Launch migration failed' });
+            }
+        }
+    })));
     app.get('/api/docs/recommend-vendors', asyncHandler((_req, res) => __awaiter(void 0, void 0, void 0, function* () {
         const resp = yield fetch('https://unpkg.com/aicodeswitch/docs/vendors-recommand.md');
         if (!resp.ok) {
@@ -2148,6 +2294,11 @@ const start = () => __awaiter(void 0, void 0, void 0, function* () {
     catch (error) {
         console.error('[Server] Tool config sync failed:', error);
     }
+    // 清理旧的迁移临时文件
+    try {
+        (0, session_launcher_1.cleanupOldTempFiles)();
+    }
+    catch ( /* ignore */_a) { /* ignore */ }
     const proxyServer = new proxy_server_1.ProxyServer(dbManager, app);
     // Initialize proxy server and register proxy routes last
     proxyServer.initialize();

package/dist/server/proxy-server.js

@@ -60,6 +60,7 @@ const type_migration_1 = require("./type-migration");
 const original_config_reader_1 = require("./original-config-reader");
 const compact_1 = require("./conversions/compact");
 const coding_plan_1 = require("./coding-plan");
+const coding_plan_headers_1 = require("./coding-plan-headers");
 const SUPPORTED_TARGETS = ['claude-code', 'codex'];
 /** 默认模型列表 */
 const DEFAULT_MODELS = [
@@ -314,14 +315,30 @@ class ProxyServer {
                 res.status(404).json({ error: { message: `API path ${apiPath} is not bound to any route. Please configure it in Route Mapping settings.` } });
                 return;
             }
-            // 加载绑定的路由
+            // 推断客户端格式
+            const clientFormat = apiPathToClientFormat(apiPath);
+            // 加载绑定的路由（默认从 API 路径绑定获取）
             const allRoutes = this.dbManager.getRoutes();
-            const route = allRoutes.find((r) => r.id === binding.routeId);
+            let route = allRoutes.find((r) => r.id === binding.routeId);
+            // 会话级路由覆盖：优先检查会话是否绑定了特定路由
+            const sessionId = this.extractSessionIdForFormat(req, clientFormat);
+            if (sessionId) {
+                const session = this.dbManager.getSession(sessionId);
+                if (session === null || session === void 0 ? void 0 : session.routeId) {
+                    const boundRoute = allRoutes.find((r) => r.id === session.routeId);
+                    if (boundRoute) {
+                        console.log(`[SESSION-ROUTE] API path ${apiPath} session ${sessionId} using bound route: ${boundRoute.name}`);
+                        route = boundRoute;
+                    }
+                    else {
+                        console.log(`[SESSION-ROUTE] Bound route ${session.routeId} not found for session ${sessionId}, clearing binding`);
+                        this.dbManager.unbindSessionRoute(sessionId).catch(console.error);
+                    }
+                }
+            }
             if (!route) {
                 return res.status(404).json({ error: { message: `Bound route '${binding.routeId}' not found or inactive. Please check Route Mapping settings.` } });
             }
-            // 推断客户端格式
-            const clientFormat = apiPathToClientFormat(apiPath);
             // 复用完整的代理请求处理
             yield this.handleApiPathProxyRequest(req, res, route, clientFormat, apiPath);
         }));
@@ -872,6 +889,24 @@ class ProxyServer {
         }
         if (!tool)
             return undefined;
+        // 优先检查会话级路由绑定
+        const sessionId = this.defaultExtractSessionId(req, tool);
+        if (sessionId) {
+            const session = this.dbManager.getSession(sessionId);
+            if (session === null || session === void 0 ? void 0 : session.routeId) {
+                const boundRoute = this.dbManager.getRoute(session.routeId);
+                if (boundRoute) {
+                    console.log(`[SESSION-ROUTE] Session ${sessionId} using bound route: ${boundRoute.name} (${boundRoute.id})`);
+                    return boundRoute;
+                }
+                else {
+                    // 路由已被删除，自动清除绑定
+                    console.log(`[SESSION-ROUTE] Bound route ${session.routeId} not found for session ${sessionId}, clearing binding`);
+                    this.dbManager.unbindSessionRoute(sessionId).catch(console.error);
+                }
+            }
+        }
+        // 回退到全局工具绑定
         const routeId = this.dbManager.getActiveRouteIdForTool(tool);
         if (!routeId)
             return undefined;
@@ -1040,7 +1075,9 @@ class ProxyServer {
                 const isBlacklisted = yield this.dbManager.isServiceBlacklisted(service.id, routeId, rule.contentType);
                 if (isBlacklisted)
                     continue;
-                return service.name;
+                const vendors = this.dbManager.getVendors();
+                const vendor = vendors.find(v => v.id === service.vendorId);
+                return vendor ? `${vendor.name}-${service.name}` : service.name;
             }
             return undefined;
         });
@@ -1049,7 +1086,7 @@ class ProxyServer {
         if (!forwardedToServiceName) {
             return '';
         }
-        return `；已自动转发给 ${forwardedToServiceName} 服务继续处理`;
+        return `；已自动转发给「${forwardedToServiceName}」服务继续处理`;
     }
     /**
      * 解析规则的有效超时时间（毫秒）。
@@ -2427,6 +2464,10 @@ class ProxyServer {
             const bodyStr = JSON.stringify(requestBody);
             headers['content-length'] = Buffer.byteLength(bodyStr, 'utf8').toString();
         }
+        // 编程套餐 Headers 覆盖：当服务启用了编程套餐时，替换为编程工具的标准 Headers
+        if (service.enableCodingPlan) {
+            (0, coding_plan_headers_1.applyCodingPlanHeaders)(headers, sourceType);
+        }
         return headers;
     }
     resolveEffectiveApiKey(service) {
@@ -2599,6 +2640,23 @@ class ProxyServer {
         }
         return rawUserId;
     }
+    /**
+     * 根据客户端格式提取 session ID（用于标准 API 路径的会话级路由覆盖）
+     */
+    extractSessionIdForFormat(request, format) {
+        var _a, _b;
+        if (format === 'claude') {
+            const rawUserId = (_b = (_a = request.body) === null || _a === void 0 ? void 0 : _a.metadata) === null || _b === void 0 ? void 0 : _b.user_id;
+            return ProxyServer.extractSessionIdFromUserId(rawUserId);
+        }
+        // 对于 completions/responses/gemini 格式，尝试从 headers 中提取
+        const sessionId = request.headers['session-id'] || request.headers['session_id'];
+        if (typeof sessionId === 'string')
+            return sessionId;
+        if (Array.isArray(sessionId))
+            return sessionId[0] || null;
+        return null;
+    }
     /**
      * 提取会话标题（默认方法）
      * 对于新会话，尝试从第一条消息的内容中提取标题
@@ -2685,6 +2743,7 @@ class ProxyServer {
     formatSessionTitle(text) {
         // 去除多余空白和换行符，替换为单个空格
         let formatted = text
+            .replace(/<\/?session>/g, '') // 移除 <session></session> 标签
             .replace(/\s+/g, ' ') // 多个空白字符替换为单个空格
             .replace(/[\r\n]+/g, ' ') // 换行符替换为空格
             .trim();
@@ -3412,7 +3471,9 @@ class ProxyServer {
                     const parser = new streaming_1.SSEParserTransform();
                     const eventCollector = new chunk_collector_1.SSEEventCollectorTransform();
                     const serializer = new streaming_1.SSESerializerTransform();
-                    const downstreamChunkCollector = new chunk_collector_1.ChunkCollectorTransform();
+                    const downstreamChunkCollector = new chunk_collector_1.ChunkCollectorTransform(() => {
+                        rules_status_service_1.rulesStatusBroadcaster.refreshRuleInUse(route.id, rule.id);
+                    });
                     const compactResponseSanitizer = rule.contentType === 'compact' && targetType === 'claude-code'
                         ? new ClaudeCompactResponseSanitizer()
                         : null;
@@ -4093,7 +4154,9 @@ class ProxyServer {
                     const parser = new streaming_1.SSEParserTransform();
                     const eventCollector = new chunk_collector_1.SSEEventCollectorTransform();
                     const serializer = new streaming_1.SSESerializerTransform();
-                    const downstreamChunkCollector = new chunk_collector_1.ChunkCollectorTransform();
+                    const downstreamChunkCollector = new chunk_collector_1.ChunkCollectorTransform(() => {
+                        rules_status_service_1.rulesStatusBroadcaster.refreshRuleInUse(route.id, rule.id);
+                    });
                     responseHeadersForLog = this.normalizeResponseHeaders(responseHeaders);
                     const { converter, extractUsage } = this.transformSSEByFormat(clientFormat, sourceType);
                     this.copyResponseHeaders(responseHeaders, res);

package/dist/server/rules-status-service.js

@@ -251,6 +251,22 @@ class RulesStatusBroadcaster {
             timestamp: Date.now(),
         });
     }
+    /**
+     * 刷新规则使用中的不活动定时器（轻量级，仅重置定时器，不修改状态）
+     * 用于 streaming 过程中持续保持 in_use 状态
+     */
+    refreshRuleInUse(routeId, ruleId) {
+        const currentStatus = this.ruleStates.get(ruleId);
+        // 仅当状态已经是 in_use 时才刷新定时器
+        if ((currentStatus === null || currentStatus === void 0 ? void 0 : currentStatus.status) !== 'in_use')
+            return;
+        const timeoutKey = `${routeId}:${ruleId}`;
+        this.clearRuleTimeout(timeoutKey);
+        const timeout = setTimeout(() => {
+            this.markRuleIdle(routeId, ruleId);
+        }, this.INACTIVITY_TIMEOUT);
+        this.ruleTimeouts.set(timeoutKey, timeout);
+    }
     /**
      * 更新规则使用量
      */