@cc-monitoring/proxy-core 0.3.1 → 0.4.0

package/dist/utils/request-writer.js

@@ -1,30 +1,22 @@
 import { initDatabase, getDatabase } from './db.js';
 import { parseUpstreamEvents } from './inject-loop.js';
-export function extractTokenUsage(events) {
-    if (!events)
-        return undefined;
-    const messageDelta = events.find((e) => e?.type === 'message_delta');
-    return messageDelta?.usage;
-}
-// --- SSE Event Batch Writer (incremental DB writes during streaming) ---
-export const EVENT_BATCH_SIZE = 10;
-// Cached prepared statements for batch writes
+import { pushNewRequest } from '../server/data-push.js';
+// --- Private implementation ---
+const EVENT_BATCH_SIZE = 10;
+// Cached prepared statement for batch writes
 let insertEventStmt = null;
-let deleteRequestStmt = null;
 let cachedDbInstance = null;
-// Invalidate cached stmts when DB instance changes (tests create fresh DB per suite)
+// Invalidate cached stmt when DB instance changes (tests create fresh DB per suite)
 function ensureStmtCacheValid(db) {
     if (db !== cachedDbInstance) {
         insertEventStmt = null;
-        deleteRequestStmt = null;
         cachedDbInstance = db;
     }
 }
 /**
  * Flush a batch of SSE events to the response_events table.
- * Called during streaming every ~10 events to avoid in-memory accumulation.
  */
-export function flushEventBatch(sessionId, requestId, batch, startIndex) {
+function flushEventBatch(sessionId, requestId, batch, startIndex) {
     const db = getDatabase();
     ensureStmtCacheValid(db);
     if (!insertEventStmt) {
@@ -35,28 +27,15 @@ export function flushEventBatch(sessionId, requestId, batch, startIndex) {
         insertEventStmt.run(requestId, sessionId, startIndex + i, event.type ?? null, JSON.stringify(event.data));
     }
 }
-/**
- * Delete response_events rows for a request (used when cloudRequestId differs from local requestId).
- */
-export function deleteResponseEvents(requestId, sessionId) {
-    const db = getDatabase();
-    db.prepare('DELETE FROM response_events WHERE request_id = ? AND session_id = ?').run(requestId, sessionId);
+function extractUsage(events) {
+    if (!events)
+        return undefined;
+    const messageDelta = events.find((e) => e?.type === 'message_delta');
+    return messageDelta?.usage;
 }
-// --- Request DB Operations ---
-// Save request to SQLite database
-export async function saveRequestDB(sessionId, requestId, data) {
-    const db = initDatabase();
-    const events = data.response?.events;
-    const usage = events ? extractTokenUsage(events) : undefined;
-    // For JSON responses (non-streaming), events are still in the array — flush them first
-    if (events && events.length > 0) {
-        const batch = events.map((e, i) => ({
-            index: i,
-            type: e?.type ?? undefined,
-            data: e
-        }));
-        flushEventBatch(sessionId, requestId, batch, 0);
-    }
+function writeCompletedRow(args) {
+    const db = getDatabase();
+    const { meta } = args;
     const stmt = db.prepare(`
     INSERT OR REPLACE INTO requests (
       request_id, session_id, timestamp, method, path, status_code, response_time,
@@ -68,24 +47,155 @@ export async function saveRequestDB(sessionId, requestId, data) {
       ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
     )
   `);
-    stmt.run(requestId, sessionId, data.timestamp, data.request.method, data.request.path, data.response?.statusCode ?? 0, data.response?.completedAt && data.timestamp
-        ? Math.round(new Date(data.response.completedAt).getTime() - new Date(data.timestamp).getTime())
-        : 0, data.apiKey || null, data.proxyApiKey || null, data.baseUrl || null, data.model || null, data.machineId || null, data.request.headers['user-agent'] || null, usage?.input_tokens || null, usage?.output_tokens || null, usage?.cache_read_input_tokens || null, usage?.cache_creation_input_tokens || null, JSON.stringify(data.request.headers), data.request.body ? JSON.stringify(data.request.body) : null, data.response?.headers ? JSON.stringify(data.response.headers) : null, null, // response_events now stored in separate table
-    data.response?.completedAt || null, data.response?.closedAt || null, data.response?.error || null);
+    stmt.run(args.requestId, meta.sessionId, meta.timestamp, meta.request.method, meta.request.path, args.statusCode, args.responseTime, meta.apiKey || null, meta.proxyApiKey || null, meta.baseUrl || null, meta.model || null, meta.machineId || null, meta.request.headers['user-agent'] || null, args.usage?.input_tokens || null, args.usage?.output_tokens || null, args.usage?.cache_read_input_tokens || null, args.usage?.cache_creation_input_tokens || null, JSON.stringify(meta.request.headers), meta.request.body ? JSON.stringify(meta.request.body) : null, args.headers ? JSON.stringify(args.headers) : null, null, // response_events now stored in separate table
+    args.completedAt || null, args.closedAt || null, args.error || null);
 }
-// Update token columns for a request (streaming: usage extracted from tailBuffer after save)
-export function updateRequestTokens(requestId, sessionId, usage) {
-    const db = getDatabase();
-    db.prepare('UPDATE requests SET input_tokens = ?, output_tokens = ?, cache_read_tokens = ?, cache_creation_tokens = ? WHERE request_id = ? AND session_id = ?').run(usage?.input_tokens || null, usage?.output_tokens || null, usage?.cache_read_input_tokens || null, usage?.cache_creation_input_tokens || null, requestId, sessionId);
+function buildSummary(meta, requestId, statusCode, responseTime, usage, withPendingId, closedAt) {
+    return {
+        requestId,
+        sessionId: meta.sessionId,
+        compositeId: `${meta.sessionId}:${requestId}`,
+        timestamp: meta.timestamp,
+        method: meta.request.method,
+        path: meta.request.path,
+        statusCode,
+        responseTime,
+        baseUrl: meta.baseUrl,
+        model: meta.model,
+        machineId: meta.machineId,
+        userAgent: meta.request.headers['user-agent'],
+        usage,
+        pendingId: withPendingId ? `${meta.sessionId}:${meta.localRequestId}` : undefined,
+        closedAt
+    };
 }
-// Delete a request row by requestId + sessionId (for pending → completed replacement)
-export function deleteRequestRow(requestId, sessionId) {
-    const db = getDatabase();
-    ensureStmtCacheValid(db);
-    if (!deleteRequestStmt) {
-        deleteRequestStmt = db.prepare('DELETE FROM requests WHERE request_id = ? AND session_id = ?');
+// --- Public API ---
+export function createRequestRecorder(meta) {
+    const eventBatch = [];
+    const tailBuffer = [];
+    let eventIndex = 0;
+    const startTime = Date.now();
+    let pendingCalled = false;
+    function flushRemaining() {
+        if (eventBatch.length > 0) {
+            flushEventBatch(meta.sessionId, meta.localRequestId, eventBatch, eventIndex - eventBatch.length);
+            eventBatch.length = 0;
+        }
     }
-    deleteRequestStmt.run(requestId, sessionId);
+    function appendEvent(event) {
+        const entry = { index: eventIndex, type: event?.type, data: event };
+        eventBatch.push(entry);
+        // Maintain tail buffer (last 5 events for usage extraction)
+        tailBuffer.push(event);
+        if (tailBuffer.length > 5) {
+            tailBuffer.shift();
+        }
+        // Flush batch to DB when threshold reached
+        if (eventBatch.length >= EVENT_BATCH_SIZE) {
+            flushEventBatch(meta.sessionId, meta.localRequestId, eventBatch, eventIndex - eventBatch.length + 1);
+            eventBatch.length = 0; // Reset batch (memory freed)
+        }
+        eventIndex++;
+    }
+    return {
+        async pending() {
+            if (pendingCalled)
+                return;
+            pendingCalled = true;
+            writeCompletedRow({
+                meta,
+                requestId: meta.localRequestId,
+                statusCode: 0,
+                responseTime: 0
+            });
+            pushNewRequest(buildSummary(meta, meta.localRequestId, 0, 0, undefined, false), 'pending');
+        },
+        appendEvent,
+        // 上游响应头到达：回写真实 status_code，状态仍 pending（UI 保留 spinner）
+        headers({ statusCode, headers }) {
+            getDatabase().prepare('UPDATE requests SET status_code = ?, response_headers = ? WHERE request_id = ? AND session_id = ?').run(statusCode, headers ? JSON.stringify(headers) : null, meta.localRequestId, meta.sessionId);
+            pushNewRequest(buildSummary(meta, meta.localRequestId, statusCode, 0, undefined, false, undefined), 'pending');
+        },
+        async complete({ cloudRequestId, statusCode, headers }) {
+            // Flush remaining events in batch
+            flushRemaining();
+            // Usage synthesis: prefer message_delta, otherwise convert OpenAI-style usage
+            let usage = extractUsage(tailBuffer);
+            if (!usage) {
+                const openaiEvent = tailBuffer.find((e) => e?.usage);
+                if (openaiEvent) {
+                    appendEvent({
+                        type: 'message_delta',
+                        usage: {
+                            output_tokens: openaiEvent.usage.completion_tokens || 0
+                        }
+                    });
+                    usage = extractUsage(tailBuffer);
+                }
+            }
+            // Ensure the synthetic event (if any) is written before row replacement
+            flushRemaining();
+            const completedAt = new Date().toISOString();
+            const finalId = cloudRequestId ?? meta.localRequestId;
+            const responseTime = Date.now() - startTime;
+            const db = getDatabase();
+            if (finalId !== meta.localRequestId) {
+                const replace = db.transaction(() => {
+                    db.prepare('UPDATE response_events SET request_id = ? WHERE request_id = ? AND session_id = ?').run(finalId, meta.localRequestId, meta.sessionId);
+                    writeCompletedRow({
+                        meta, requestId: finalId, statusCode, responseTime, headers, usage, completedAt
+                    });
+                    db.prepare('DELETE FROM requests WHERE request_id = ? AND session_id = ?').run(meta.localRequestId, meta.sessionId);
+                });
+                replace();
+            }
+            else {
+                writeCompletedRow({
+                    meta, requestId: finalId, statusCode, responseTime, headers, usage, completedAt
+                });
+            }
+            pushNewRequest(buildSummary(meta, finalId, statusCode, responseTime, usage, finalId !== meta.localRequestId), 'completed');
+        },
+        // 流被截断/挂死：保留真实 status_code，通过 closed_at + error 标记中断
+        interrupt({ statusCode, error }) {
+            flushRemaining();
+            const responseTime = Date.now() - startTime;
+            const closedAt = new Date().toISOString();
+            getDatabase().prepare('UPDATE requests SET status_code = ?, response_time = ?, closed_at = ?, error = ? WHERE request_id = ? AND session_id = ?').run(statusCode, responseTime, closedAt, error, meta.localRequestId, meta.sessionId);
+            pushNewRequest(buildSummary(meta, meta.localRequestId, statusCode, responseTime, undefined, false, closedAt), 'completed');
+        },
+        fail({ statusCode, error }) {
+            const responseTime = Date.now() - startTime;
+            const closedAt = new Date().toISOString();
+            getDatabase().prepare('UPDATE requests SET status_code = ?, response_time = ?, closed_at = ?, error = ? WHERE request_id = ? AND session_id = ?').run(statusCode, responseTime, closedAt, error, meta.localRequestId, meta.sessionId);
+            pushNewRequest(buildSummary(meta, meta.localRequestId, statusCode, responseTime, undefined, false, closedAt), 'completed');
+        }
+    };
+}
+// Record an inject loop iteration: completed row + events + push, no pending, responseTime 0
+export async function recordIteration(meta) {
+    initDatabase();
+    const events = meta.response.events ?? [];
+    if (events.length > 0) {
+        const batch = events.map((e, i) => ({
+            index: i,
+            type: e?.type,
+            data: e
+        }));
+        flushEventBatch(meta.sessionId, meta.localRequestId, batch, 0);
+    }
+    const usage = extractUsage(events);
+    const completedAt = new Date().toISOString();
+    writeCompletedRow({
+        meta,
+        requestId: meta.localRequestId,
+        statusCode: meta.response.statusCode,
+        responseTime: 0,
+        headers: meta.response.headers,
+        usage,
+        completedAt
+    });
+    pushNewRequest(buildSummary(meta, meta.localRequestId, meta.response.statusCode, 0, usage, false), 'completed');
 }
 // Load single request by compositeId (sessionId:requestId)
 export async function loadRequestDB(compositeId) {
@@ -165,7 +275,7 @@ export async function listRequestDB(limit = 1000, before) {
     SELECT
       request_id, session_id, timestamp, method, path, status_code, response_time,
       api_key, proxy_api_key, base_url, model, machine_id, user_agent,
-      input_tokens, output_tokens, cache_read_tokens, cache_creation_tokens
+      input_tokens, output_tokens, cache_read_tokens, cache_creation_tokens, closed_at
     FROM requests
     ${whereClause}
     ORDER BY timestamp DESC
@@ -194,7 +304,8 @@ export async function listRequestDB(limit = 1000, before) {
                 output_tokens: row.output_tokens,
                 cache_read_input_tokens: row.cache_read_tokens,
                 cache_creation_input_tokens: row.cache_creation_tokens
-            } : undefined
+            } : undefined,
+            closedAt: row.closed_at || undefined
         })),
         hasMore
     };
@@ -212,13 +323,22 @@ export async function cleanOldRequestsDB(daysToKeep = 7) {
     db.prepare(`DELETE FROM response_events WHERE request_id IN (SELECT request_id FROM requests WHERE timestamp < ?)`).run(cutoff);
     db.prepare(`DELETE FROM requests WHERE timestamp < ?`).run(cutoff);
 }
-// Check if a sessionId exists in the database
-export function sessionIdExists(sessionId) {
+// 启动时回收上次进程遗留的僵尸 SSE 行：未完成、未关闭且超龄，逐行标记为中断
+// （status_code 保持原值不动），返回处理行数
+export function interruptStaleRequestsOnStartup(maxAgeMs = 5 * 60000) {
     const db = initDatabase();
-    const row = db.prepare(`
-    SELECT 1 FROM requests WHERE session_id = ? LIMIT 1
-  `).get(sessionId);
-    return !!row;
+    const cutoff = new Date(Date.now() - maxAgeMs).toISOString();
+    const rows = db.prepare(`
+    SELECT request_id, session_id
+    FROM requests
+    WHERE completed_at IS NULL AND closed_at IS NULL AND timestamp < ?
+  `).all(cutoff);
+    const closedAt = new Date().toISOString();
+    const stmt = db.prepare('UPDATE requests SET closed_at = ?, error = ? WHERE request_id = ? AND session_id = ?');
+    for (const row of rows) {
+        stmt.run(closedAt, 'interrupted: proxy restarted', row.request_id, row.session_id);
+    }
+    return rows.length;
 }
 // Load session history for multi-turn chat resume
 // Returns the last request's messages + assistant response, to prepend to new messages

package/dist/utils/sse-protocol.d.ts

@@ -0,0 +1,34 @@
+/**
+ * SSE 帧协议：字节流 ↔ SSE 帧 的唯一知识收敛点。
+ *
+ * - SSE 帧（frame）：字节流按 SSE 规范切分出的单位，由若干字段行
+ *   （event: / data: / id: / 注释 / 空行分发）组成。
+ * - SSE 事件（event）：SSE 帧的 data 字段解析出的 JSON 消息。
+ *
+ * 解析遵循 HTML spec 的 event stream 语义：残帧缓冲、LF/CRLF/CR 行尾、
+ * 空行分发、字段行去掉恰好一个可选空格。
+ */
+export interface SSEFrame {
+    event?: string;
+    data: string[];
+    id?: string;
+}
+export interface SSEDecoder {
+    write(chunk: Buffer | string): void;
+    end(): void;
+}
+/** 创建 SSE 帧解码器：每分发一个完整 SSE 帧回调一次 */
+export declare function createSSEDecoder(onFrame: (frame: SSEFrame) => void): SSEDecoder;
+/**
+ * 编码单个 SSE 帧。data 为已序列化好的字符串（调用方负责 JSON.stringify）。
+ * 有 event：`event: <event>\ndata: <data>\n\n`；无 event：`data: <data>\n\n`。
+ */
+export declare function encodeSSEFrame(args: {
+    event?: string;
+    data: string;
+}): string;
+/**
+ * 创建 SSE 事件解码器：帧 data 用 \n join 后，[DONE] 触发 onDone，
+ * 其余尝试 JSON.parse 成功后触发 onEvent，解析失败静默跳过。
+ */
+export declare function createEventDecoder(onEvent: (event: any) => void, onDone?: () => void): SSEDecoder;

package/dist/utils/sse-protocol.js

@@ -0,0 +1,121 @@
+/**
+ * SSE 帧协议：字节流 ↔ SSE 帧 的唯一知识收敛点。
+ *
+ * - SSE 帧（frame）：字节流按 SSE 规范切分出的单位，由若干字段行
+ *   （event: / data: / id: / 注释 / 空行分发）组成。
+ * - SSE 事件（event）：SSE 帧的 data 字段解析出的 JSON 消息。
+ *
+ * 解析遵循 HTML spec 的 event stream 语义：残帧缓冲、LF/CRLF/CR 行尾、
+ * 空行分发、字段行去掉恰好一个可选空格。
+ */
+/** 创建 SSE 帧解码器：每分发一个完整 SSE 帧回调一次 */
+export function createSSEDecoder(onFrame) {
+    // 残帧缓冲：跨 chunk 的不完整行
+    let leftover = '';
+    let event;
+    let data = [];
+    let id;
+    /** 分发当前帧：至少含一个 data 行才回调；分发后重置字段状态 */
+    function dispatch() {
+        if (data.length > 0) {
+            onFrame({ event, data, id });
+        }
+        event = undefined;
+        id = undefined;
+        data = [];
+    }
+    /** 处理一个完整行 */
+    function handleLine(line) {
+        // 空行 = 一帧分发
+        if (line === '') {
+            dispatch();
+            return;
+        }
+        // 以冒号开头的行是注释，忽略
+        if (line.startsWith(':'))
+            return;
+        let field;
+        let value;
+        const colon = line.indexOf(':');
+        if (colon === -1) {
+            field = line;
+            value = '';
+        }
+        else {
+            field = line.slice(0, colon);
+            value = line.slice(colon + 1);
+            // 去掉字段值行首恰好一个可选空格
+            if (value.startsWith(' '))
+                value = value.slice(1);
+        }
+        if (field === 'event') {
+            event = value;
+        }
+        else if (field === 'data') {
+            // 多行 data 逐行保留，消费时用 \n join
+            data.push(value);
+        }
+        else if (field === 'id') {
+            id = value;
+        }
+    }
+    /** 消费文本中所有完整行，末段保留为残帧 */
+    function feed(text) {
+        // CRLF 与单独 CR 统一为 LF
+        const normalized = text.replace(/\r\n?/g, '\n');
+        const lines = normalized.split('\n');
+        leftover = lines.pop() || '';
+        for (const line of lines)
+            handleLine(line);
+    }
+    return {
+        write(chunk) {
+            const chunkText = typeof chunk === 'string' ? chunk : chunk.toString('utf-8');
+            feed(leftover + chunkText);
+        },
+        end() {
+            // 先按残帧缓冲补一次切行
+            if (leftover !== '') {
+                const normalized = leftover.replace(/\r\n?/g, '\n');
+                leftover = '';
+                for (const line of normalized.split('\n'))
+                    handleLine(line);
+            }
+            // 再对缓冲中尚未分发的非空帧做一次分发（末尾无空行也能输出最后一帧）
+            if (data.length > 0)
+                dispatch();
+            // 清空状态
+            leftover = '';
+            event = undefined;
+            id = undefined;
+            data = [];
+        }
+    };
+}
+/**
+ * 编码单个 SSE 帧。data 为已序列化好的字符串（调用方负责 JSON.stringify）。
+ * 有 event：`event: <event>\ndata: <data>\n\n`；无 event：`data: <data>\n\n`。
+ */
+export function encodeSSEFrame(args) {
+    const prefix = args.event !== undefined ? `event: ${args.event}\n` : '';
+    return `${prefix}data: ${args.data}\n\n`;
+}
+/**
+ * 创建 SSE 事件解码器：帧 data 用 \n join 后，[DONE] 触发 onDone，
+ * 其余尝试 JSON.parse 成功后触发 onEvent，解析失败静默跳过。
+ */
+export function createEventDecoder(onEvent, onDone) {
+    return createSSEDecoder((frame) => {
+        const text = frame.data.join('\n');
+        if (text.trim() === '[DONE]') {
+            onDone?.();
+            return;
+        }
+        try {
+            onEvent(JSON.parse(text));
+        }
+        catch {
+            // 非 JSON data 静默跳过
+        }
+    });
+}

package/dist/utils/sse-stream-processor.d.ts

@@ -4,23 +4,18 @@ import { type ParsedUpstream } from './inject-loop.js';
  * SSE 增量流式处理器：边转发原始 chunk 到客户端，边增量解析事件累积状态。
  * stream end 后提供 getParsedUpstream() 和 hasInjectedToolUse() 供注入检测。
  *
- * 跨 chunk 行边界通过 leftover 缓冲处理（参考 SSEAccumulator）。
+ * 跨 chunk 残帧由内部 sse-protocol decoder 缓冲处理。
  */
 export declare class SSEStreamProcessor {
     events: any[];
-    private contentBlocks;
-    private stopReason;
-    private usage;
-    private leftover;
+    private decoder;
     private raw;
     constructor(raw: ServerResponse);
     /** 处理一个 chunk：转发到 reply.raw + 增量解析事件 */
     processChunk(chunk: Buffer): void;
-    /** 处理 leftover 中残留的最后一行（stream end 后调用） */
+    /** 收尾残帧（stream end 后调用） */
     flushLeftover(): void;
-    /** 增量解析单个事件，更新 contentBlocks / stopReason / usage */
-    private processEvent;
-    /** 从累积状态构建 ParsedUpstream */
+    /** 从累积事件构建 ParsedUpstream */
     getParsedUpstream(): ParsedUpstream;
     /** 检测是否有注入的 MCP tool_use */
     hasInjectedToolUse(): boolean;

package/dist/utils/sse-stream-processor.js

@@ -1,9 +1,10 @@
-import { findInjectedCall } from './inject-loop.js';
+import { findInjectedCall, parseUpstreamEvents } from './inject-loop.js';
+import { createEventDecoder } from './sse-protocol.js';
 /**
  * SSE 增量流式处理器：边转发原始 chunk 到客户端，边增量解析事件累积状态。
  * stream end 后提供 getParsedUpstream() 和 hasInjectedToolUse() 供注入检测。
  *
- * 跨 chunk 行边界通过 leftover 缓冲处理（参考 SSEAccumulator）。
+ * 跨 chunk 残帧由内部 sse-protocol decoder 缓冲处理。
  */
 export class SSEStreamProcessor {
     constructor(raw) {
@@ -13,29 +14,11 @@ export class SSEStreamProcessor {
             writable: true,
             value: []
         });
-        Object.defineProperty(this, "contentBlocks", {
+        Object.defineProperty(this, "decoder", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new Map()
-        });
-        Object.defineProperty(this, "stopReason", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ''
-        });
-        Object.defineProperty(this, "usage", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: undefined
-        });
-        Object.defineProperty(this, "leftover", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ''
+            value: void 0
         });
         Object.defineProperty(this, "raw", {
             enumerable: true,
@@ -44,101 +27,27 @@ export class SSEStreamProcessor {
             value: void 0
         });
         this.raw = raw;
+        this.decoder = createEventDecoder((event) => this.events.push(event));
     }
     /** 处理一个 chunk：转发到 reply.raw + 增量解析事件 */
     processChunk(chunk) {
         // 转发原始 chunk 到客户端
         this.raw.write(chunk);
-        const text = this.leftover + chunk.toString('utf-8');
-        const lines = text.split('\n');
-        // 最后一行可能不完整，保留到下次
-        this.leftover = lines.pop() || '';
-        for (const line of lines) {
-            if (line.startsWith('data:')) {
-                const d = line.slice(5).trim();
-                if (!d || d === '[DONE]')
-                    continue;
-                try {
-                    const event = JSON.parse(d);
-                    this.events.push(event);
-                    this.processEvent(event);
-                }
-                catch {
-                    // 非 JSON 行跳过
-                }
-            }
-        }
+        this.decoder.write(chunk);
     }
-    /** 处理 leftover 中残留的最后一行（stream end 后调用） */
+    /** 收尾残帧（stream end 后调用） */
     flushLeftover() {
-        if (this.leftover.startsWith('data:')) {
-            const d = this.leftover.slice(5).trim();
-            if (d && d !== '[DONE]') {
-                try {
-                    const event = JSON.parse(d);
-                    this.events.push(event);
-                    this.processEvent(event);
-                }
-                catch {
-                    // skip
-                }
-            }
-        }
-        this.leftover = '';
+        this.decoder.end();
     }
-    /** 增量解析单个事件，更新 contentBlocks / stopReason / usage */
-    processEvent(e) {
-        if (e?.type === 'content_block_start') {
-            const cb = e.content_block || {};
-            this.contentBlocks.set(e.index, {
-                type: cb.type,
-                text: cb.type === 'text' ? '' : undefined,
-                id: cb.id,
-                name: cb.name,
-                input: cb.type === 'tool_use' ? '' : undefined
-            });
-        }
-        else if (e?.type === 'content_block_delta') {
-            const b = this.contentBlocks.get(e.index);
-            if (!b)
-                return;
-            const d = e.delta || {};
-            if (d.type === 'text_delta')
-                b.text = (b.text || '') + d.text;
-            if (d.type === 'thinking_delta')
-                b.text = (b.text || '') + d.thinking;
-            if (d.type === 'input_json_delta')
-                b.input = (b.input || '') + (d.partial_json || '');
-        }
-        else if (e?.type === 'message_delta') {
-            this.stopReason = e.delta?.stop_reason || this.stopReason;
-            this.usage = e.usage;
-        }
-    }
-    /** 从累积状态构建 ParsedUpstream */
+    /** 从累积事件构建 ParsedUpstream */
     getParsedUpstream() {
-        const ordered = Array.from(this.contentBlocks.entries())
-            .sort((a, b) => a[0] - b[0])
-            .map(([, b]) => {
-            if (b.type === 'tool_use') {
-                let input = {};
-                try {
-                    input = b.input ? JSON.parse(b.input) : {};
-                }
-                catch {
-                    input = {};
-                }
-                return { ...b, input };
-            }
-            return b;
-        });
-        return { blocks: ordered, stopReason: this.stopReason, usage: this.usage };
+        return parseUpstreamEvents(this.events);
     }
     /** 检测是否有注入的 MCP tool_use */
     hasInjectedToolUse() {
-        if (this.stopReason !== 'tool_use')
-            return false;
         const parsed = this.getParsedUpstream();
+        if (parsed.stopReason !== 'tool_use')
+            return false;
         return !!findInjectedCall(parsed);
     }
 }

package/dist/utils/sse-writer.d.ts

@@ -1,6 +1,6 @@
 import type { ServerResponse } from 'http';
 /**
- * SSE 构造器（后端）—— 与 sse-accumulator（解析器）互为逆向。
+ * SSE 构造器（后端）—— 与 sse-protocol（帧解析器）互为逆向。
  *
  * 用于 proxy 主动构造并回写合成 SSE 流，让 Claude Code 客户端
  * 将其识别为一次正常的模型文本回答。事件骨架遵循 Anthropic

package/dist/utils/sse-writer.js

@@ -1,5 +1,6 @@
+import { encodeSSEFrame } from './sse-protocol.js';
 /**
- * SSE 构造器（后端）—— 与 sse-accumulator（解析器）互为逆向。
+ * SSE 构造器（后端）—— 与 sse-protocol（帧解析器）互为逆向。
  *
  * 用于 proxy 主动构造并回写合成 SSE 流，让 Claude Code 客户端
  * 将其识别为一次正常的模型文本回答。事件骨架遵循 Anthropic
@@ -7,7 +8,7 @@
  */
 /** 写单个 SSE 事件：`event: <type>\ndata: {json}\n\n`（Anthropic 双行格式） */
 export function writeSSEEvent(raw, event) {
-    raw.write(`event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`);
+    raw.write(encodeSSEFrame({ event: event.type, data: JSON.stringify(event) }));
 }
 /**
  * 把一段文本伪装成模型的正常 text 输出，构造完整合成流写回。