@cc-monitoring/proxy-core 0.3.1 → 0.4.1

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

@@ -1,6 +1,6 @@
-export interface RequestData {
-    requestId: string;
+export interface RecordedRequest {
     sessionId: string;
+    localRequestId: string;
     timestamp: string;
     apiKey?: string;
     proxyApiKey?: string;
@@ -13,14 +13,6 @@ export interface RequestData {
         headers: Record<string, string>;
         body?: any;
     };
-    response?: {
-        statusCode: number;
-        headers?: Record<string, string>;
-        events?: any[];
-        completedAt?: string;
-        closedAt?: string;
-        error?: string;
-    };
 }
 export interface TokenUsage {
     input_tokens?: number;
@@ -44,33 +36,92 @@ export interface RequestSummary {
     machineId?: string;
     userAgent?: string;
     usage?: TokenUsage;
+    closedAt?: string;
+    error?: string;
+}
+export interface RequestRecorder {
+    pending(): Promise<void>;
+    appendEvent(event: any): void;
+    headers(args: {
+        statusCode: number;
+        headers?: Record<string, string>;
+    }): void;
+    complete(args: {
+        cloudRequestId?: string;
+        statusCode: number;
+        headers?: Record<string, string>;
+    }): Promise<void>;
+    interrupt(args: {
+        statusCode: number;
+        error: string;
+    }): void;
+    fail(args: {
+        statusCode: number;
+        error: string;
+    }): void;
+}
+interface LoadedRequest {
+    requestId: string;
+    sessionId: string;
+    timestamp: string;
+    apiKey?: string;
+    proxyApiKey?: string;
+    baseUrl?: string;
+    model?: string;
+    machineId?: string;
+    request: {
+        method: string;
+        path: string;
+        headers: Record<string, string>;
+        body?: any;
+    };
+    response?: {
+        statusCode: number;
+        headers?: Record<string, string>;
+        events?: any[];
+        completedAt?: string;
+        closedAt?: string;
+        error?: string;
+    };
 }
-export declare function extractTokenUsage(events: any[] | undefined): TokenUsage | undefined;
-export declare const EVENT_BATCH_SIZE = 10;
 /**
- * Flush a batch of SSE events to the response_events table.
- * Called during streaming every ~10 events to avoid in-memory accumulation.
+ * 判断事件集合是否构成一条完整返回的流。
+ * Claude：出现 type === 'message_stop'。
+ * OpenAI 兼容：chunk 内 choices[0].finish_reason 非空
+ * （[DONE] 不入库，不能作为 DB 判定依据）。
  */
-export declare function flushEventBatch(sessionId: string, requestId: string, batch: Array<{
-    index: number;
-    type?: string;
-    data: unknown;
-}>, startIndex: number): void;
+export declare function isStreamCompleteEvents(events: any[] | undefined): boolean;
 /**
- * Delete response_events rows for a request (used when cloudRequestId differs from local requestId).
+ * 从事件集合按字段合并重建 usage，不做整体覆盖。
+ * Claude：message_start.usage（input_tokens / cache_*）为底；
+ * message_delta.usage 的字段优先（output_tokens 为主，cache 字段也合入）。
+ * OpenAI：取带 .usage 的 chunk（prompt_tokens/completion_tokens）。
  */
-export declare function deleteResponseEvents(requestId: string, sessionId: string): void;
-export declare function saveRequestDB(sessionId: string, requestId: string, data: RequestData): Promise<void>;
-export declare function updateRequestTokens(requestId: string, sessionId: string, usage: TokenUsage | undefined): void;
-export declare function deleteRequestRow(requestId: string, sessionId: string): void;
-export declare function loadRequestDB(compositeId: string): Promise<RequestData>;
+export declare function reconstructUsageFromEvents(events: any[] | undefined): TokenUsage | undefined;
+export declare function createRequestRecorder(meta: RecordedRequest): RequestRecorder;
+export declare function recordIteration(meta: RecordedRequest & {
+    response: {
+        statusCode: number;
+        headers?: Record<string, string>;
+        events?: any[];
+    };
+}): Promise<void>;
+export declare function loadRequestDB(compositeId: string): Promise<LoadedRequest>;
 export declare function listRequestDB(limit?: number, before?: string): Promise<{
     requests: RequestSummary[];
     hasMore: boolean;
 }>;
 export declare function cleanOldRequestsDB(daysToKeep?: number): Promise<void>;
-export declare function sessionIdExists(sessionId: string): boolean;
+export declare function interruptStaleRequestsOnStartup(maxAgeMs?: number): {
+    completed: number;
+    interrupted: number;
+};
+export declare function repairClosedRequests(): {
+    recovered: number;
+    tokensFilled: number;
+};
 export declare function loadSessionHistory(sessionId: string): {
     messages: any[];
     system?: any;
 } | null;
+export {};

package/dist/utils/request-writer.js

@@ -1,62 +1,153 @@
 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) {
-        insertEventStmt = db.prepare('INSERT INTO response_events (request_id, session_id, event_index, event_type, event_data) VALUES (?, ?, ?, ?, ?)');
+        insertEventStmt = db.prepare('INSERT OR IGNORE INTO response_events (request_id, session_id, event_index, event_type, event_data) VALUES (?, ?, ?, ?, ?)');
     }
     for (let i = 0; i < batch.length; i++) {
         const event = batch[i];
         insertEventStmt.run(requestId, sessionId, startIndex + i, event.type ?? null, JSON.stringify(event.data));
     }
 }
+function extractUsage(events) {
+    if (!events)
+        return undefined;
+    const messageDelta = events.find((e) => e?.type === 'message_delta');
+    return messageDelta?.usage;
+}
+// --- 流完整性判定与 usage 重建（纯函数，事件数组入参）---
 /**
- * Delete response_events rows for a request (used when cloudRequestId differs from local requestId).
+ * 判断事件集合是否构成一条完整返回的流。
+ * Claude：出现 type === 'message_stop'。
+ * OpenAI 兼容：chunk 内 choices[0].finish_reason 非空
+ * （[DONE] 不入库，不能作为 DB 判定依据）。
  */
-export function deleteResponseEvents(requestId, sessionId) {
-    const db = getDatabase();
-    db.prepare('DELETE FROM response_events WHERE request_id = ? AND session_id = ?').run(requestId, sessionId);
+export function isStreamCompleteEvents(events) {
+    if (!Array.isArray(events))
+        return false;
+    return events.some(e => {
+        if (!e || typeof e !== 'object')
+            return false;
+        if (e.type === 'message_stop')
+            return true;
+        const finishReason = e.choices?.[0]?.finish_reason;
+        return finishReason !== undefined && finishReason !== null && finishReason !== '';
+    });
 }
-// --- 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);
+/**
+ * 从事件集合按字段合并重建 usage，不做整体覆盖。
+ * Claude：message_start.usage（input_tokens / cache_*）为底；
+ * message_delta.usage 的字段优先（output_tokens 为主，cache 字段也合入）。
+ * OpenAI：取带 .usage 的 chunk（prompt_tokens/completion_tokens）。
+ */
+export function reconstructUsageFromEvents(events) {
+    if (!Array.isArray(events))
+        return undefined;
+    const usage = {};
+    let found = false;
+    const merge = (field, value, precedence) => {
+        if (typeof value !== 'number')
+            return;
+        if (precedence || usage[field] === undefined) {
+            usage[field] = value;
+            found = true;
+        }
+    };
+    for (const e of events) {
+        if (!e || typeof e !== 'object')
+            continue;
+        if (e.type === 'message_start' || e.type === 'message_delta') {
+            const u = e.usage;
+            if (u && typeof u === 'object') {
+                const isDelta = e.type === 'message_delta';
+                merge('input_tokens', u.input_tokens, isDelta);
+                merge('output_tokens', u.output_tokens, isDelta);
+                merge('cache_read_input_tokens', u.cache_read_input_tokens, isDelta);
+                merge('cache_creation_input_tokens', u.cache_creation_input_tokens, isDelta);
+            }
+        }
+        // OpenAI 兼容：带 usage 的 chunk（event_type 通常为 NULL）
+        if (e.usage && typeof e.usage === 'object' && e.type !== 'message_start' && e.type !== 'message_delta') {
+            const u = e.usage;
+            merge('input_tokens', u.input_tokens ?? u.prompt_tokens, false);
+            merge('output_tokens', u.output_tokens ?? u.completion_tokens, false);
+        }
     }
+    return found ? usage : undefined;
+}
+// 定向加载重建所需事件，禁止全量加载事件流（实测有 8000+ 行）：
+// 1) Claude 锚点事件（message_start/message_delta/message_stop，通常仅数行）
+// 2) 尾部 10 条事件（覆盖 OpenAI 的 finish_reason / usage，其 event_type 可能为 NULL）
+function loadTargetedEvents(db, requestId, sessionId) {
+    const anchorRows = db.prepare(`
+    SELECT event_data FROM response_events
+    WHERE request_id = ? AND session_id = ?
+      AND event_type IN ('message_start', 'message_delta', 'message_stop')
+    ORDER BY event_index ASC
+  `).all(requestId, sessionId);
+    const tailRows = db.prepare(`
+    SELECT event_data FROM response_events
+    WHERE request_id = ? AND session_id = ?
+    ORDER BY event_index DESC
+    LIMIT 10
+  `).all(requestId, sessionId);
+    const seen = new Set();
+    const events = [];
+    for (const row of [...anchorRows, ...tailRows]) {
+        if (seen.has(row.event_data))
+            continue;
+        seen.add(row.event_data);
+        try {
+            events.push(JSON.parse(row.event_data));
+        }
+        catch {
+            // 忽略损坏行
+        }
+    }
+    return events;
+}
+// 按字段回填 token 列（只补 NULL 列），返回是否有列被更新
+function fillTokenColumns(db, requestId, sessionId, usage) {
+    const current = db.prepare(`
+    SELECT input_tokens, output_tokens, cache_read_tokens, cache_creation_tokens
+    FROM requests WHERE request_id = ? AND session_id = ?
+  `).get(requestId, sessionId);
+    if (!current)
+        return false;
+    const pairs = [
+        ['input_tokens', usage.input_tokens],
+        ['output_tokens', usage.output_tokens],
+        ['cache_read_tokens', usage.cache_read_input_tokens],
+        ['cache_creation_tokens', usage.cache_creation_input_tokens]
+    ];
+    const updatable = pairs.filter(([col, v]) => current[col] === null && typeof v === 'number');
+    if (updatable.length === 0)
+        return false;
+    const setSql = updatable.map(([col]) => `${col} = ?`).join(', ');
+    db.prepare(`UPDATE requests SET ${setSql} WHERE request_id = ? AND session_id = ?`).run(...updatable.map(([, v]) => v), requestId, sessionId);
+    return true;
+}
+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 +159,171 @@ 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;
+    // recorder 生命周期开始前的事件行下界。complete() 把事件从 localRequestId 迁到
+    // cloudRequestId 时只允许迁移 id 大于它的行：request_id（req-N 计数器）在进程
+    // 重启后可能复用，同 localRequestId 的历史残留事件属于别的请求，不能被一起迁走。
+    const startRow = getDatabase()
+        .prepare('SELECT MAX(id) AS m FROM response_events')
+        .get();
+    const startEventRowId = startRow.m ?? 0;
+    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(() => {
+                    // id > startEventRowId：只迁本 recorder 创建后写入的事件，
+                    // 不迁同 localRequestId 的历史残留事件
+                    db.prepare('UPDATE response_events SET request_id = ? WHERE request_id = ? AND session_id = ? AND id > ?').run(finalId, meta.localRequestId, meta.sessionId, startEventRowId);
+                    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 标记中断；
+        // 同时通过定向 SQL（锚点事件 + 尾部事件）重建 usage 并按字段回填 token
+        interrupt({ statusCode, error }) {
+            flushRemaining();
+            const db = getDatabase();
+            const responseTime = Date.now() - startTime;
+            const closedAt = new Date().toISOString();
+            db.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);
+            const events = loadTargetedEvents(db, meta.localRequestId, meta.sessionId);
+            const usage = reconstructUsageFromEvents(events);
+            if (usage) {
+                fillTokenColumns(db, meta.localRequestId, meta.sessionId, usage);
+            }
+            pushNewRequest(buildSummary(meta, meta.localRequestId, statusCode, responseTime, usage, 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 +403,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, error
     FROM requests
     ${whereClause}
     ORDER BY timestamp DESC
@@ -194,7 +432,9 @@ 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,
+            error: row.error || undefined
         })),
         hasMore
     };
@@ -211,14 +451,80 @@ export async function cleanOldRequestsDB(daysToKeep = 7) {
     // Delete response_events first (foreign data), then requests
     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);
+    // 例行还页：auto_vacuum 未开启时为 no-op；经 ccm vacuum 开启
+    // INCREMENTAL 后，删除产生的空闲页在此廉价归还文件系统。
+    db.pragma('incremental_vacuum');
 }
-// Check if a sessionId exists in the database
-export function sessionIdExists(sessionId) {
+// 启动时回收上次进程遗留的僵尸 SSE 行：未完成、未关闭且超龄，逐行分流
+// （status_code 保持原值不动）——事件流完整（message_stop / OpenAI finish_reason）
+// 的走完成语义：写 completed_at，不写 closed_at/error；不完整的维持
+// closed_at + 'interrupted: proxy restarted'。两条路径都按字段回填 token 列。
+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, timestamp, response_time
+    FROM requests
+    WHERE completed_at IS NULL AND closed_at IS NULL AND timestamp < ?
+  `).all(cutoff);
+    let completed = 0;
+    let interrupted = 0;
+    const nowIso = new Date().toISOString();
+    for (const row of rows) {
+        const events = loadTargetedEvents(db, row.request_id, row.session_id);
+        const usage = reconstructUsageFromEvents(events);
+        if (isStreamCompleteEvents(events)) {
+            // response_time 原值为 0（pending 占位）时，用 timestamp→现在给合理值
+            const responseTime = row.response_time > 0
+                ? row.response_time
+                : Math.max(0, Date.now() - Date.parse(row.timestamp));
+            db.prepare('UPDATE requests SET completed_at = ?, response_time = ? WHERE request_id = ? AND session_id = ?').run(nowIso, responseTime, row.request_id, row.session_id);
+            completed += 1;
+        }
+        else {
+            db.prepare('UPDATE requests SET closed_at = ?, error = ? WHERE request_id = ? AND session_id = ?').run(nowIso, 'interrupted: proxy restarted', row.request_id, row.session_id);
+            interrupted += 1;
+        }
+        if (usage) {
+            fillTokenColumns(db, row.request_id, row.session_id, usage);
+        }
+    }
+    return { completed, interrupted };
+}
+// 存量回填（供 CLI repair-requests 使用），幂等可重跑：
+// 扫描 closed_at 非空的行——事件流完整且 completed_at 为空的：清 closed_at/error、
+// 写 completed_at（completed_at 已非空的跳过）；对 token 全 NULL 但事件可恢复
+// usage 的行按字段补 token。同样只走定向 SQL。
+export function repairClosedRequests() {
+    const db = initDatabase();
+    const rows = db.prepare(`
+    SELECT
+      request_id, session_id, completed_at,
+      input_tokens, output_tokens, cache_read_tokens, cache_creation_tokens
+    FROM requests
+    WHERE closed_at IS NOT NULL
+  `).all();
+    let recovered = 0;
+    let tokensFilled = 0;
+    const nowIso = new Date().toISOString();
+    for (const row of rows) {
+        const events = loadTargetedEvents(db, row.request_id, row.session_id);
+        if (row.completed_at === null && isStreamCompleteEvents(events)) {
+            db.prepare('UPDATE requests SET closed_at = NULL, error = NULL, completed_at = ? WHERE request_id = ? AND session_id = ?').run(nowIso, row.request_id, row.session_id);
+            recovered += 1;
+        }
+        const allTokensNull = row.input_tokens === null &&
+            row.output_tokens === null &&
+            row.cache_read_tokens === null &&
+            row.cache_creation_tokens === null;
+        if (allTokensNull) {
+            const usage = reconstructUsageFromEvents(events);
+            if (usage && fillTokenColumns(db, row.request_id, row.session_id, usage)) {
+                tokensFilled += 1;
+            }
+        }
+    }
+    return { recovered, tokensFilled };
 }
 // 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;