aicodeswitch 5.2.1 → 5.2.3

package/dist/server/conversions/compact.js

@@ -122,10 +122,14 @@ function extractMessageContent(content) {
 /**
  * 检测消息是否为 Claude Code 的 compact 命令请求。
  *
+ * 采用两级检测策略：
+ * - 严格匹配：四个关键词全部命中（适配已知格式）
+ * - 宽松匹配："TEXT ONLY" + "<summary>" 组合（覆盖 prompt 格式变化）
+ *
  * Compact 命令触发时，Claude Code 会在 messages 末尾插入一条特殊指令：
  * - role 为 "user"
  * - content 为数组，包含一个 text 块
- * - text 内容以 "CRITICAL: Respond with TEXT ONLY" 开头
+ * - text 内容包含 "CRITICAL: Respond with TEXT ONLY" 等标识
  * - 包含对话摘要生成指令，要求输出 <analysis> 和 <summary> 结构
  */
 function isClaudeCompactRequest(message) {
@@ -139,10 +143,21 @@ function isClaudeCompactRequest(message) {
     for (const block of content) {
         if ((block === null || block === void 0 ? void 0 : block.type) === 'text' && typeof block.text === 'string') {
             const text = block.text;
-            if (text.includes('CRITICAL: Respond with TEXT ONLY') &&
-                text.includes('create a detailed summary of the conversation') &&
-                text.includes('<analysis>') &&
-                text.includes('<summary>')) {
+            const hasTextOnly = text.includes('TEXT ONLY');
+            const hasSummary = text.includes('<summary>');
+            const hasCritical = text.includes('CRITICAL: Respond with TEXT ONLY');
+            const hasDetailedSummary = text.includes('create a detailed summary of the conversation');
+            const hasAnalysis = text.includes('<analysis>');
+            // 严格匹配：Claude Code 标准格式（四个关键词）
+            if (hasCritical && hasDetailedSummary && hasAnalysis && hasSummary) {
+                console.log('[COMPACT] Strict match: all 4 markers found');
+                return true;
+            }
+            // 宽松匹配：覆盖 Claude Code prompt 格式变化
+            // "TEXT ONLY" 是紧凑指令的核心标识，<summary> 是输出格式标签
+            // 两者组合在非 compact 请求中几乎不可能同时出现
+            if (hasTextOnly && hasSummary) {
+                console.log(`[COMPACT] Loose match: CRITICAL=${hasCritical}, detailed_summary=${hasDetailedSummary}, <analysis>=${hasAnalysis}`);
                 return true;
             }
         }
@@ -150,13 +165,22 @@ function isClaudeCompactRequest(message) {
     return false;
 }
 /**
- * 检测消息列表中的最后一条消息是否为 Claude Code compact 请求。
+ * 检测消息列表中是否包含 Claude Code compact 请求。
+ *
+ * 从最后一条消息开始往前搜索，最多检查 3 条，
+ * 处理 compact 指令后面可能跟了 assistant 占位消息的边缘情况。
  */
 function isLastClaudeMessageCompact(messages) {
     if (!Array.isArray(messages) || messages.length === 0) {
         return false;
     }
-    return isClaudeCompactRequest(messages[messages.length - 1]);
+    const checkCount = Math.min(messages.length, 3);
+    for (let i = messages.length - 1; i >= messages.length - checkCount; i--) {
+        if (isClaudeCompactRequest(messages[i])) {
+            return true;
+        }
+    }
+    return false;
 }
 /**
  * 检测请求是否为 Codex 的 compact（压缩）请求。

package/dist/server/main.js

@@ -1045,6 +1045,12 @@ const listInstalledSkills = () => {
 const registerRoutes = (dbManager, proxyServer) => __awaiter(void 0, void 0, void 0, function* () {
     updateProxyConfig(dbManager.getConfig());
     app.get('/health', (_req, res) => res.json({ status: 'ok' }));
+    // 数据就绪验证端点（供 Tauri 启动阶段确认后端完全可用）
+    app.get('/api/ready', (_req, res) => {
+        const vendors = dbManager.getVendors();
+        const routes = dbManager.getRoutes();
+        res.json({ ready: true, vendorsCount: vendors.length, routesCount: routes.length });
+    });
     // 局域网访问控制中间件：当 enableLanDiscovery 关闭时，仅允许本机访问 /api/* 路由
     app.use('/api', (req, res, next) => {
         const config = dbManager.getConfig();

package/dist/server/proxy-server.js

@@ -1385,6 +1385,161 @@ class ProxyServer {
     isResponseCommitted(res) {
         return res.headersSent || this.isDownstreamClosed(res);
     }
+    /**
+     * SSE 流预检：在提交响应头之前读取上游流的第一个有意义的 SSE 事件，
+     * 判断上游是否健康。若首事件为错误（response.failed / error），则不提交响应头，
+     * 允许外层故障切换循环尝试下一个候选服务。
+     *
+     * @returns healthy=true 时携带 bufferedRaw（预检期间读取的原始字节），
+     *          healthy=false 时携带 failureInfo 用于构建错误信息。
+     */
+    preflightStream(upstreamStream, options = {}) {
+        const { timeoutMs = 5000 } = options;
+        return new Promise((resolve) => {
+            const chunks = [];
+            const tempParser = new streaming_1.SSEParserTransform();
+            const events = [];
+            let settled = false;
+            let timer;
+            const finish = (result) => {
+                var _a;
+                if (settled)
+                    return;
+                settled = true;
+                if (timer)
+                    clearTimeout(timer);
+                // 停止从上游流读取，但不 destroy（后续可能还需要用）
+                (_a = upstreamStream.removeAllListeners) === null || _a === void 0 ? void 0 : _a.call(upstreamStream);
+                resolve(result);
+            };
+            // 超时保护
+            timer = setTimeout(() => {
+                finish({
+                    healthy: false,
+                    failureInfo: { statusCode: 504, errorMessage: 'Stream preflight timed out waiting for first event' },
+                    bufferedRaw: Buffer.concat(chunks),
+                });
+            }, timeoutMs);
+            // 将原始数据喂给临时 parser 解析 SSE 事件
+            const onData = (chunk) => {
+                if (settled)
+                    return;
+                chunks.push(chunk);
+                // 手动喂给 parser
+                tempParser.write(chunk);
+                drainParserEvents();
+            };
+            const drainParserEvents = () => {
+                var _a, _b;
+                // 从 tempParser 的 readable 侧读出解析后的事件
+                let event;
+                while (null !== (event = tempParser.read())) {
+                    if (settled)
+                        return;
+                    events.push(event);
+                    // 跳过无意义的空事件和 done
+                    const eventType = (_a = event.event) === null || _a === void 0 ? void 0 : _a.trim();
+                    const eventData = event.data;
+                    if (!eventType && eventData && typeof eventData === 'object' && eventData.type === 'done')
+                        continue;
+                    if (!eventType && !eventData)
+                        continue;
+                    // 检查是否为错误事件
+                    if (eventType === 'response.failed' || eventType === 'error') {
+                        const parsed = event.data ? this.safeJsonParse(event.data) : null;
+                        const errorObj = ((_b = parsed === null || parsed === void 0 ? void 0 : parsed.response) === null || _b === void 0 ? void 0 : _b.error) || (parsed === null || parsed === void 0 ? void 0 : parsed.error) || parsed;
+                        const errorCode = errorObj === null || errorObj === void 0 ? void 0 : errorObj.code;
+                        const errorMessage = (errorObj === null || errorObj === void 0 ? void 0 : errorObj.message)
+                            || (parsed === null || parsed === void 0 ? void 0 : parsed.message)
+                            || `Upstream stream returned ${eventType}`;
+                        const statusCode = errorCode === 'server_is_overloaded' ? 503 : 502;
+                        finish({
+                            healthy: false,
+                            failureInfo: {
+                                statusCode,
+                                errorMessage: `Upstream stream returned ${eventType}: ${errorMessage}`,
+                            },
+                            bufferedRaw: Buffer.concat(chunks),
+                            errorData: event.data,
+                        });
+                        return;
+                    }
+                    // 首个有意义的正常事件 → 健康通过
+                    finish({
+                        healthy: true,
+                        bufferedRaw: Buffer.concat(chunks),
+                    });
+                    return;
+                }
+            };
+            const onEnd = () => {
+                if (settled)
+                    return;
+                // 流结束了但没读到有意义的 event
+                if (events.length === 0 && chunks.length === 0) {
+                    finish({
+                        healthy: false,
+                        failureInfo: { statusCode: 502, errorMessage: 'Upstream stream ended before sending any data' },
+                        bufferedRaw: Buffer.concat(chunks),
+                    });
+                }
+                else {
+                    // 读到了一些数据但没有明确的错误 → 视为健康
+                    finish({
+                        healthy: true,
+                        bufferedRaw: Buffer.concat(chunks),
+                    });
+                }
+            };
+            const onError = (err) => {
+                if (settled)
+                    return;
+                finish({
+                    healthy: false,
+                    failureInfo: { statusCode: 502, errorMessage: `Upstream stream error during preflight: ${err.message}` },
+                    bufferedRaw: Buffer.concat(chunks),
+                });
+            };
+            upstreamStream.on('data', onData);
+            upstreamStream.once('end', onEnd);
+            upstreamStream.once('error', onError);
+            // 暂停自动读取 — 我们只需要第一个事件
+            // 注意：不能 pause，因为 axios stream 需要 flow mode 才能获取数据
+        });
+    }
+    /**
+     * 创建一个组合流：先输出 bufferedRaw 中的原始字节，再透传上游流的剩余数据。
+     * 用于预检通过后无缝衔接后续的 SSE 管道。
+     */
+    createPreflightCombinedStream(upstreamStream, bufferedRaw) {
+        let pushed = false;
+        const combined = new stream_1.Readable({
+            read() {
+                var _a, _b;
+                if (!pushed) {
+                    pushed = true;
+                    if (bufferedRaw.length > 0) {
+                        this.push(bufferedRaw);
+                    }
+                    // 将上游流 pipe 到 combined
+                    upstreamStream.on('data', (chunk) => {
+                        if (!this.push(chunk)) {
+                            upstreamStream.pause();
+                        }
+                    });
+                    upstreamStream.once('end', () => {
+                        this.push(null);
+                    });
+                    upstreamStream.once('error', (err) => {
+                        this.destroy(err);
+                    });
+                    // 如果上游已经暂停了（预检时消费了一些数据），恢复它
+                    (_b = (_a = upstreamStream).resume) === null || _b === void 0 ? void 0 : _b.call(_a);
+                }
+            },
+        });
+        return combined;
+    }
     isClientDisconnectError(error, res) {
         const code = error === null || error === void 0 ? void 0 : error.code;
         if (code === 'CLIENT_DISCONNECTED' || code === 'ERR_CANCELED') {
@@ -1624,6 +1779,28 @@ class ProxyServer {
                     return rule;
                 }
             }
+            // compact 规则同样拥有最高优先级，确保压缩请求不被其他规则覆盖
+            if (contentType === 'compact') {
+                const compactRules = enabledRules.filter(rule => rule.contentType === 'compact');
+                for (const rule of compactRules) {
+                    const isBlacklisted = yield this.dbManager.isServiceBlacklisted(rule.targetServiceId, routeId, rule.contentType);
+                    if (isBlacklisted) {
+                        continue;
+                    }
+                    this.dbManager.checkAndResetRuleIfNeeded(rule.id);
+                    this.dbManager.checkAndResetRequestCountIfNeeded(rule.id);
+                    if (rule.tokenLimit && rule.totalTokensUsed !== undefined && rule.totalTokensUsed >= rule.tokenLimit * 1000) {
+                        continue;
+                    }
+                    if (rule.requestCountLimit && rule.totalRequestsUsed !== undefined && rule.totalRequestsUsed >= rule.requestCountLimit) {
+                        continue;
+                    }
+                    if (this.isFrequencyLimitExceeded(rule)) {
+                        continue;
+                    }
+                    return rule;
+                }
+            }
             // 1. 查找其他内容类型的规则
             const contentTypeRules = enabledRules.filter(rule => rule.contentType === contentType);
             // 过滤黑名单和token限制
@@ -3193,7 +3370,7 @@ class ProxyServer {
     }
     proxyRequest(req, res, route, rule, service, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
             res.locals.skipLog = true;
             const startTime = Date.now();
             const rawSourceType = service.sourceType || 'openai-chat';
@@ -3815,6 +3992,64 @@ class ProxyServer {
                     return;
                 }
                 if (isEventStream && response.data) {
+                    // ── SSE 预检：在提交响应头之前，先读取第一个 SSE 事件以检测上游错误 ──
+                    // 这使得故障切换能在流式场景下生效（首事件为 error 时不提交响应头，允许切换到下一个服务）
+                    const preflightResult = yield this.preflightStream(response.data, { timeoutMs: 5000 });
+                    if (!preflightResult.healthy) {
+                        // 预检失败（首事件是错误 / 超时 / 流提前关闭）
+                        const failureInfo = preflightResult.failureInfo;
+                        console.warn(`[Proxy] Stream preflight failed: ${(failureInfo === null || failureInfo === void 0 ? void 0 : failureInfo.errorMessage) || 'unknown'}`);
+                        // 尝试读取完整错误体用于日志
+                        let errorBody = preflightResult.errorData;
+                        if (!errorBody && preflightResult.bufferedRaw.length > 0) {
+                            errorBody = this.safeJsonParse(preflightResult.bufferedRaw.toString('utf8'));
+                        }
+                        responseHeadersForLog = this.normalizeResponseHeaders(responseHeaders);
+                        const errorMsg = (failureInfo === null || failureInfo === void 0 ? void 0 : failureInfo.errorMessage) || 'Stream preflight detected upstream error';
+                        // 记录错误日志
+                        try {
+                            yield this.dbManager.addErrorLog({
+                                timestamp: Date.now(),
+                                method: req.method,
+                                path: req.path,
+                                statusCode: (failureInfo === null || failureInfo === void 0 ? void 0 : failureInfo.statusCode) || 502,
+                                errorMessage: errorMsg,
+                                requestHeaders: this.normalizeHeaders(req.headers),
+                                requestBody: req.body ? JSON.stringify(req.body) : undefined,
+                                upstreamRequest: upstreamRequestForLog,
+                                responseHeaders: responseHeadersForLog,
+                                responseBody: preflightResult.bufferedRaw.toString('utf8'),
+                                ruleId: rule.id,
+                                targetType,
+                                targetServiceId: service.id,
+                                targetServiceName: service.name,
+                                targetModel: rule.targetModel || ((_d = req.body) === null || _d === void 0 ? void 0 : _d.model),
+                                vendorId: service.vendorId,
+                                vendorName: vendor === null || vendor === void 0 ? void 0 : vendor.name,
+                                requestModel: (_e = req.body) === null || _e === void 0 ? void 0 : _e.model,
+                                responseTime: Date.now() - startTime,
+                            });
+                        }
+                        catch (logError) {
+                            console.error('[Proxy] Failed to log preflight error:', logError);
+                        }
+                        yield finalizeLog((failureInfo === null || failureInfo === void 0 ? void 0 : failureInfo.statusCode) || 502, errorMsg);
+                        // 销毁上游流
+                        if (typeof response.data.destroy === 'function') {
+                            response.data.destroy();
+                        }
+                        // 响应头未提交 → 可以触发故障切换
+                        if (failoverEnabled) {
+                            throw this.createFailoverError(errorMsg, (failureInfo === null || failureInfo === void 0 ? void 0 : failureInfo.statusCode) || 502);
+                        }
+                        // 非 failover 模式：直接返回错误给客户端
+                        res.status((failureInfo === null || failureInfo === void 0 ? void 0 : failureInfo.statusCode) || 502).json({
+                            error: { message: errorMsg, type: 'upstream_error' },
+                        });
+                        return;
+                    }
+                    // ── 预检通过：提交响应头，使用组合流继续管道传输 ──
+                    const streamSource = this.createPreflightCombinedStream(response.data, preflightResult.bufferedRaw);
                     res.status(response.status);
                     // 默认stream处理(无转换)
                     const parser = new streaming_1.SSEParserTransform();
@@ -3827,7 +4062,7 @@ class ProxyServer {
                         ? new ClaudeCompactResponseSanitizer()
                         : null;
                     // 流式 model 回写：将上游返回的 model 改写为客户端请求时的原始模型名
-                    const originalModel = (_d = req.body) === null || _d === void 0 ? void 0 : _d.model;
+                    const originalModel = (_f = req.body) === null || _f === void 0 ? void 0 : _f.model;
                     const modelRewriter = originalModel ? new model_rewrite_transform_1.ModelRewriteTransform(originalModel) : null;
                     responseHeadersForLog = this.normalizeResponseHeaders(responseHeaders);
                     // 使用 transformSSEToTool 方法选择转换器
@@ -3864,7 +4099,7 @@ class ProxyServer {
                         ensureResponseWritable();
                         return yield new Promise((resolve, reject) => {
                             if (converter) {
-                                const streamStages = [response.data, parser, eventCollector, converter];
+                                const streamStages = [streamSource, parser, eventCollector, converter];
                                 if (compactResponseSanitizer) {
                                     streamStages.push(compactResponseSanitizer);
                                 }
@@ -3882,7 +4117,7 @@ class ProxyServer {
                                 });
                                 return;
                             }
-                            const streamStages = [response.data, parser, eventCollector];
+                            const streamStages = [streamSource, parser, eventCollector];
                             if (compactResponseSanitizer) {
                                 streamStages.push(compactResponseSanitizer);
                             }
@@ -3927,10 +4162,10 @@ class ProxyServer {
                                 targetType,
                                 targetServiceId: service.id,
                                 targetServiceName: service.name,
-                                targetModel: rule.targetModel || ((_e = req.body) === null || _e === void 0 ? void 0 : _e.model),
+                                targetModel: rule.targetModel || ((_g = req.body) === null || _g === void 0 ? void 0 : _g.model),
                                 vendorId: service.vendorId,
                                 vendorName: vendor === null || vendor === void 0 ? void 0 : vendor.name,
-                                requestModel: (_f = req.body) === null || _f === void 0 ? void 0 : _f.model,
+                                requestModel: (_h = req.body) === null || _h === void 0 ? void 0 : _h.model,
                                 responseTime: Date.now() - startTime,
                             });
                         }
@@ -3974,10 +4209,10 @@ class ProxyServer {
                                 targetType,
                                 targetServiceId: service.id,
                                 targetServiceName: service.name,
-                                targetModel: rule.targetModel || ((_g = req.body) === null || _g === void 0 ? void 0 : _g.model),
+                                targetModel: rule.targetModel || ((_j = req.body) === null || _j === void 0 ? void 0 : _j.model),
                                 vendorId: service.vendorId,
                                 vendorName: vendor === null || vendor === void 0 ? void 0 : vendor.name,
-                                requestModel: (_h = req.body) === null || _h === void 0 ? void 0 : _h.model,
+                                requestModel: (_k = req.body) === null || _k === void 0 ? void 0 : _k.model,
                                 responseTime: Date.now() - startTime,
                             });
                         }
@@ -3996,7 +4231,7 @@ class ProxyServer {
                 let responseData = response.data;
                 if (streamRequested && response.data && typeof response.data.on === 'function' && !isEventStream) {
                     const raw = yield this.readStreamBody(response.data);
-                    responseData = (_j = this.safeJsonParse(raw)) !== null && _j !== void 0 ? _j : raw;
+                    responseData = (_l = this.safeJsonParse(raw)) !== null && _l !== void 0 ? _l : raw;
                 }
                 // 收集响应头
                 responseHeadersForLog = this.normalizeResponseHeaders(responseHeaders);
@@ -4018,7 +4253,7 @@ class ProxyServer {
                 usageForLog = this.extractTokenUsageFromResponse(responseData, sourceType);
                 console.log('[Proxy] Non-stream response: extracted usageForLog:', usageForLog);
                 // 回写 model 字段：将上游返回的 model 改写为客户端请求时的原始模型名
-                const originalModel = (_k = req.body) === null || _k === void 0 ? void 0 : _k.model;
+                const originalModel = (_m = req.body) === null || _m === void 0 ? void 0 : _m.model;
                 (0, model_rewrite_transform_1.rewriteResponseModel)(normalizedConverted, originalModel);
                 (0, model_rewrite_transform_1.rewriteResponseModel)(responseData, originalModel);
                 this.copyResponseHeaders(responseHeaders, res);
@@ -4083,10 +4318,10 @@ class ProxyServer {
                         targetType,
                         targetServiceId: service.id,
                         targetServiceName: service.name,
-                        targetModel: rule.targetModel || ((_l = req.body) === null || _l === void 0 ? void 0 : _l.model),
+                        targetModel: rule.targetModel || ((_o = req.body) === null || _o === void 0 ? void 0 : _o.model),
                         vendorId: service.vendorId,
                         vendorName: vendor === null || vendor === void 0 ? void 0 : vendor.name,
-                        requestModel: (_m = req.body) === null || _m === void 0 ? void 0 : _m.model,
+                        requestModel: (_p = req.body) === null || _p === void 0 ? void 0 : _p.model,
                         upstreamRequest: upstreamRequestForLog,
                         responseTime: Date.now() - startTime,
                     });
@@ -4101,7 +4336,7 @@ class ProxyServer {
                 console.error('Proxy error:', error);
                 // 检测是否是 timeout 错误
                 const isTimeout = error.code === 'ECONNABORTED' ||
-                    ((_o = error.message) === null || _o === void 0 ? void 0 : _o.toLowerCase().includes('timeout')) ||
+                    ((_q = error.message) === null || _q === void 0 ? void 0 : _q.toLowerCase().includes('timeout')) ||
                     (error.errno && error.errno === 'ETIMEDOUT');
                 const statusCode = isTimeout ? 504 : this.getErrorStatusCode(error, 500);
                 const baseErrorMessage = isTimeout
@@ -4127,10 +4362,10 @@ class ProxyServer {
                     targetType,
                     targetServiceId: service.id,
                     targetServiceName: service.name,
-                    targetModel: rule.targetModel || ((_p = req.body) === null || _p === void 0 ? void 0 : _p.model),
+                    targetModel: rule.targetModel || ((_r = req.body) === null || _r === void 0 ? void 0 : _r.model),
                     vendorId: service.vendorId,
                     vendorName: vendor === null || vendor === void 0 ? void 0 : vendor.name,
-                    requestModel: (_q = req.body) === null || _q === void 0 ? void 0 : _q.model,
+                    requestModel: (_s = req.body) === null || _s === void 0 ? void 0 : _s.model,
                     upstreamRequest: upstreamRequestForLog,
                     responseHeaders: responseHeadersForLog,
                     responseTime: Date.now() - startTime,
@@ -4605,6 +4840,31 @@ class ProxyServer {
                     return;
                 }
                 if (isEventStream && response.data) {
+                    // ── SSE 预检：在提交响应头之前，先读取第一个 SSE 事件以检测上游错误 ──
+                    const preflightResult = yield this.preflightStream(response.data, { timeoutMs: 5000 });
+                    if (!preflightResult.healthy) {
+                        const failureInfo = preflightResult.failureInfo;
+                        console.warn(`[ApiPathProxy] Stream preflight failed: ${(failureInfo === null || failureInfo === void 0 ? void 0 : failureInfo.errorMessage) || 'unknown'}`);
+                        let errorBody = preflightResult.errorData;
+                        if (!errorBody && preflightResult.bufferedRaw.length > 0) {
+                            errorBody = this.safeJsonParse(preflightResult.bufferedRaw.toString('utf8'));
+                        }
+                        responseHeadersForLog = this.normalizeResponseHeaders(responseHeaders);
+                        const errorMsg = (failureInfo === null || failureInfo === void 0 ? void 0 : failureInfo.errorMessage) || 'Stream preflight detected upstream error';
+                        yield finalizeLog((failureInfo === null || failureInfo === void 0 ? void 0 : failureInfo.statusCode) || 502, errorMsg);
+                        if (typeof response.data.destroy === 'function') {
+                            response.data.destroy();
+                        }
+                        if (failoverEnabled) {
+                            throw this.createFailoverError(errorMsg, (failureInfo === null || failureInfo === void 0 ? void 0 : failureInfo.statusCode) || 502);
+                        }
+                        res.status((failureInfo === null || failureInfo === void 0 ? void 0 : failureInfo.statusCode) || 502).json({
+                            error: { message: errorMsg, type: 'upstream_error' },
+                        });
+                        return;
+                    }
+                    // ── 预检通过：使用组合流继续管道传输 ──
+                    const streamSource = this.createPreflightCombinedStream(response.data, preflightResult.bufferedRaw);
                     // Stream pipeline
                     const parser = new streaming_1.SSEParserTransform();
                     const eventCollector = new chunk_collector_1.SSEEventCollectorTransform();
@@ -4646,7 +4906,7 @@ class ProxyServer {
                                 return stages;
                             };
                             if (converter) {
-                                const stages = buildStages(response.data, parser, eventCollector, converter);
+                                const stages = buildStages(streamSource, parser, eventCollector, converter);
                                 stream_1.pipeline(...stages, (error) => {
                                     if (error) {
                                         reject(error);
@@ -4656,7 +4916,7 @@ class ProxyServer {
                                 });
                             }
                             else {
-                                const stages = buildStages(response.data, parser, eventCollector);
+                                const stages = buildStages(streamSource, parser, eventCollector);
                                 stream_1.pipeline(...stages, (error) => {
                                     if (error) {
                                         reject(error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aicodeswitch",
-  "version": "5.2.1",
+  "version": "5.2.3",
   "description": "A tool to help you manage AI programming tools to access large language models locally. It allows your Claude Code, Codex and other tools to no longer be limited to official models.",
   "author": "tangshuang",
   "license": "GPL-3.0",
@@ -46,6 +46,7 @@
     "prepublishOnly": "npm run build",
     "release": "standard-version --no-changelog",
     "tauri:dev": "tauri dev",
+    "tauri:start": "yarn build && node tauri/prepare-resources.js && cd tauri && cargo run",
     "tauri:build": "tauri build && node tauri/move-bundle.js",
     "tauri:icon": "tauri icon src/ui/assets/logo.png"
   },