@cc-monitoring/proxy-core 0.1.4 → 0.1.5

package/dist/server/proxy.js

@@ -1,22 +1,23 @@
-import { Readable } from 'stream';
+import { Readable, finished } from 'stream';
+import { convertClaudeToOpenAIRequest, convertOpenAIToClaudeResponse, createStreamTransformer, buildOpenAIHeaders } from '../utils/openai-converter.js';
 import { loadConfig } from '../config/index.js';
-import { saveRequestDB, extractTokenUsage } from '../utils/request-writer.js';
+import { saveRequestDB, extractTokenUsage, flushEventBatch, deleteResponseEvents, deleteRequestRow, updateRequestTokens, EVENT_BATCH_SIZE } from '../utils/request-writer.js';
 import { cleanOldRequestsDB } from '../utils/request-writer.js';
 import { pushNewRequest } from './data-push.js';
 import { initDatabase, closeDatabase, getDatabase } from '../utils/db.js';
 import { aggregateStats } from '../utils/stats-aggregator.js';
-import { writeTextAsSSE, shouldMock } from '../utils/sse-writer.js';
-import { injectTools } from '../utils/tool-injector.js';
-import { parseSSEText, parseUpstreamEvents, findInjectedCall, runInjectLoop } from '../utils/inject-loop.js';
-import { hasEnabledTools } from '../tools/index.js';
+import { mcpManager } from '../utils/mcp-manager.js';
 import { getMachineIdSync, preloadMachineId } from '../utils/machine-id.js';
+// Cached prepared statement for active provider lookup (avoids per-request allocation)
+let activeProviderStmt = null;
+let cachedDbInstance = null;
 /**
  * Resolves the proxy target per request:
  * - If a provider with is_default=1 exists in DB, use its base_url + api_key + tier models (partial replacement)
  * - Otherwise fall back to config.json proxy.target + proxy.apiKey
  *
  * Called per request for hot-swap support (no server restart needed on activation change).
- * better-sqlite3 is synchronous and ~us-level for a single-row SELECT; no caching needed.
+ * better-sqlite3 is synchronous and ~us-level for a single-row SELECT; cached statement avoids repeated allocation.
  */
 export function resolveProxyTarget(proxyConfig) {
     // Default to config values
@@ -27,13 +28,22 @@ export function resolveProxyTarget(proxyConfig) {
     let haiku_model;
     let sonnet_model;
     let opus_model;
+    let is_openai_compatible;
     try {
         // Parse config target as base
         const configUrl = new URL(proxyConfig.target);
         baseUrl = configUrl.origin;
         targetPath = configUrl.pathname.replace(/\/$/, '');
         const db = getDatabase();
-        const active = db.prepare('SELECT base_url, api_key, model, haiku_model, sonnet_model, opus_model FROM providers WHERE is_default = 1 LIMIT 1').get();
+        // Invalidate cached stmt if DB instance changed (happens in tests with fresh DB per test)
+        if (db !== cachedDbInstance) {
+            activeProviderStmt = null;
+            cachedDbInstance = db;
+        }
+        if (!activeProviderStmt) {
+            activeProviderStmt = db.prepare('SELECT base_url, api_key, model, haiku_model, sonnet_model, opus_model, is_openai_compatible FROM providers WHERE is_default = 1 LIMIT 1');
+        }
+        const active = activeProviderStmt.get();
         if (active) {
             // Replace base_url only if provided
             if (active.base_url && active.base_url.trim() !== '') {
@@ -54,6 +64,8 @@ export function resolveProxyTarget(proxyConfig) {
                 sonnet_model = active.sonnet_model;
             if (active.opus_model && active.opus_model.trim() !== '')
                 opus_model = active.opus_model;
+            // Populate is_openai_compatible
+            is_openai_compatible = !!active.is_openai_compatible;
         }
     }
     catch {
@@ -62,7 +74,7 @@ export function resolveProxyTarget(proxyConfig) {
         baseUrl = configUrl.origin;
         targetPath = configUrl.pathname.replace(/\/$/, '');
     }
-    return { baseUrl, targetPath, apiKey, model, haiku_model, sonnet_model, opus_model };
+    return { baseUrl, targetPath, apiKey, model, haiku_model, sonnet_model, opus_model, is_openai_compatible };
 }
 /**
  * Selects the proxy model based on the original request model and provider tier config.
@@ -87,7 +99,7 @@ export function getProxyModel(originalModel, tierModels) {
     return tierModels.model || undefined;
 }
 // Extract safe headers (avoid circular reference)
-function extractSafeHeaders(headers) {
+export function extractSafeHeaders(headers) {
     const safeHeaders = {};
     for (const [key, value] of Object.entries(headers)) {
         if (typeof value === 'string' || typeof value === 'number') {
@@ -100,23 +112,29 @@ function extractSafeHeaders(headers) {
     return safeHeaders;
 }
 // Filter headers for forwarding (remove problematic ones, replace API key if configured)
-function filterForwardHeaders(headers, proxyApiKey) {
+export function filterForwardHeaders(headers, proxyApiKey) {
     const filtered = { ...headers };
     // Remove headers that cause issues
     delete filtered.host;
     delete filtered['content-length'];
     delete filtered['x-req-key'];
-    // Replace API key if proxy key is configured
+    // Inject or replace API key when proxy key is available
     if (proxyApiKey) {
-        // Only replace existing headers, don't add new ones
-        if ('x-api-key' in filtered) {
+        const hasApiKey = 'x-api-key' in filtered;
+        const hasAuth = 'authorization' in filtered || 'Authorization' in filtered;
+        if (hasApiKey) {
+            // Replace existing x-api-key
             filtered['x-api-key'] = proxyApiKey;
         }
-        if ('authorization' in filtered || 'Authorization' in filtered) {
-            // Use the same case as the original header
+        else if (hasAuth) {
+            // Replace existing authorization
             const key = 'authorization' in filtered ? 'authorization' : 'Authorization';
             filtered[key] = `Bearer ${proxyApiKey}`;
         }
+        else {
+            // No auth header in request → inject x-api-key from provider
+            filtered['x-api-key'] = proxyApiKey;
+        }
     }
     return filtered;
 }
@@ -129,6 +147,56 @@ export function getErrorStatusCode(error) {
     }
     return 500;
 }
+/**
+ * Push a parsed SSE event into batch/tail buffers.
+ * Flushes batch to DB when it reaches EVENT_BATCH_SIZE (10).
+ * Only memory held: current batch (≤10 events) + tail (≤5 events).
+ */
+function pushEventToBuffers(event, sessionId, requestId, eventBatch, tailBuffer, eventIndexRef) {
+    const entry = { index: eventIndexRef.value, 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(sessionId, requestId, eventBatch, eventIndexRef.value - eventBatch.length + 1);
+        eventBatch.length = 0; // Reset batch (memory freed)
+    }
+    eventIndexRef.value++;
+}
+/**
+ * Flush remaining batch + update request completion in DB.
+ * Extracts token usage from tail buffer (no need for full events array).
+ */
+async function completeStreamSave(sessionId, requestId, requestData, eventBatch, tailBuffer, eventIndexRef, startTime, statusCode, resolved, forwardedModel, originalModel, machineId, request) {
+    // Flush remaining events in batch
+    if (eventBatch.length > 0) {
+        flushEventBatch(sessionId, requestId, eventBatch, eventIndexRef.value - eventBatch.length);
+        eventBatch.length = 0;
+    }
+    requestData.response.completedAt = new Date().toISOString();
+    requestData.response.events = []; // Not needed for streaming, clear to avoid serialization
+    await saveRequestDB(sessionId, requestId, requestData);
+    const usage = extractTokenUsage(tailBuffer);
+    updateRequestTokens(requestId, sessionId, usage);
+    pushNewRequest({
+        requestId,
+        sessionId,
+        compositeId: `${sessionId}:${requestId}`,
+        method: request.method,
+        path: request.url,
+        timestamp: requestData.timestamp,
+        statusCode,
+        responseTime: Date.now() - startTime,
+        model: forwardedModel || originalModel,
+        machineId,
+        baseUrl: resolved.baseUrl,
+        usage
+    }, 'completed');
+}
 export function getErrorMessage(error) {
     if (error.code === 'ECONNREFUSED') {
         return 'Target server unreachable';
@@ -147,6 +215,13 @@ export async function setupProxy(fastify, proxyConfig) {
     const maxDays = fullConfig.storage?.maxDays ?? 7;
     // Initialize SQLite database
     initDatabase();
+    // Initialize MCP connections (after DB is ready)
+    try {
+        await mcpManager.init();
+    }
+    catch (err) {
+        console.error('MCP manager init failed:', err);
+    }
     // Preload machine ID
     await preloadMachineId();
     // Start stats aggregation timer (every 5 minutes)
@@ -158,6 +233,15 @@ export async function setupProxy(fastify, proxyConfig) {
             console.error('Stats aggregation failed:', err);
         }
     }, 300000); // 5 minutes
+    // Periodic cleanup timer (every 30 minutes, not per-request)
+    const cleanupTimer = setInterval(() => {
+        try {
+            cleanOldRequestsDB(maxDays);
+        }
+        catch (err) {
+            console.error('Cleanup failed:', err);
+        }
+    }, 1800000); // 30 minutes
     // Initial aggregation on startup
     try {
         aggregateStats();
@@ -165,9 +249,18 @@ export async function setupProxy(fastify, proxyConfig) {
     catch (err) {
         console.error('Initial stats aggregation failed:', err);
     }
-    // Cleanup database and timer on server close
+    // Initial cleanup on startup
+    try {
+        cleanOldRequestsDB(maxDays);
+    }
+    catch (err) {
+        console.error('Initial cleanup failed:', err);
+    }
+    // Cleanup database, MCP connections, and timer on server close
     fastify.addHook('onClose', async () => {
         clearInterval(statsTimer);
+        clearInterval(cleanupTimer);
+        await mcpManager.close();
         closeDatabase();
     });
     // Application-layer forwarding (Controller + Fetch + SSE Pipe)
@@ -218,38 +311,166 @@ export async function setupProxy(fastify, proxyConfig) {
                 },
                 response: {
                     statusCode: 0, // Will be updated after fetch
-                    events: [] // SSE events will be recorded here
+                    events: [] // Only used for JSON responses; streaming uses batch buffer
                 }
             };
-            await cleanOldRequestsDB(maxDays);
+            // SSE event batch buffer: flush to DB every ~10 events to avoid in-memory accumulation
+            // Tail buffer: keep last 5 events for token usage extraction at stream end
+            const eventBatch = [];
+            const tailBuffer = [];
+            const eventIndexRef = { value: 0 };
             request.log.info(`request logged: ${request.id} ${request.method} ${request.url}`);
-            // [PoC] 魔法词拦截：最新 user message 含 __MOCK__ 时，不转发上游，
-            // 直接构造合成 SSE 流返回，验证客户端能否将其识别为正常回答。
-            if (shouldMock(request.body)) {
-                reply.hijack();
-                reply.raw.writeHead(200, {
-                    'content-type': 'text/event-stream',
-                    'cache-control': 'no-cache',
-                    'connection': 'keep-alive'
+            // Save initial record + push pending status to frontend
+            await saveRequestDB(sessionId, request.id, requestData);
+            pushNewRequest({
+                requestId: request.id,
+                sessionId,
+                compositeId: `${sessionId}:${request.id}`,
+                method: request.method,
+                path: request.url,
+                timestamp: requestData.timestamp,
+                statusCode: 0,
+                responseTime: 0,
+                model: forwardedModel,
+                machineId,
+                baseUrl: resolved.baseUrl
+            }, 'pending');
+            // --- OpenAI Compatible Mode ---
+            if (resolved.is_openai_compatible) {
+                const openaiRequest = convertClaudeToOpenAIRequest(request.body, forwardedModel);
+                const openaiHeaders = buildOpenAIHeaders(resolved.apiKey || '');
+                // Build target URL: /chat/completions for OpenAI format
+                const targetUrlStr = `${resolved.baseUrl}${resolved.targetPath}/chat/completions`;
+                request.log.info(`forwarding (openai mode) to: ${targetUrlStr}`);
+                // Forward converted request to OpenAI-compatible API
+                const response = await fetch(targetUrlStr, {
+                    method: request.method,
+                    headers: openaiHeaders,
+                    body: JSON.stringify(openaiRequest)
                 });
-                writeTextAsSSE(reply.raw, '[PoC] 这是 proxy 构造的合成响应，未经过真实大模型。', `msg_poc_${request.id}`);
-                reply.raw.end();
-                request.log.info(`[PoC] mock intercepted: ${request.id}`);
+                request.log.info(`response status: ${response.status}`);
+                // Extract cloud request ID
+                const cloudRequestId = response.headers.get('x-request-id') || request.id;
+                requestData.requestId = cloudRequestId;
+                requestData.response.statusCode = response.status;
+                requestData.response.headers = Object.fromEntries(response.headers);
+                // Check response type
+                const contentType = response.headers.get('content-type') || '';
+                const isSSE = contentType.includes('text/event-stream');
+                const isJSON = contentType.includes('application/json');
+                // Handle non-streaming JSON response
+                if (isJSON && !isSSE && response.body) {
+                    const responseBody = await response.text();
+                    let claudeResponseBody;
+                    try {
+                        const openaiRes = JSON.parse(responseBody);
+                        const claudeRes = convertOpenAIToClaudeResponse(openaiRes, forwardedModel || originalModel);
+                        claudeResponseBody = JSON.stringify(claudeRes);
+                        requestData.response.events.push(claudeRes);
+                    }
+                    catch {
+                        claudeResponseBody = responseBody;
+                        try {
+                            requestData.response.events.push(JSON.parse(responseBody));
+                        }
+                        catch {
+                            requestData.response.events.push({ raw: responseBody });
+                        }
+                    }
+                    requestData.response.completedAt = new Date().toISOString();
+                    if (cloudRequestId !== request.id) {
+                        deleteResponseEvents(request.id, sessionId);
+                        deleteRequestRow(request.id, sessionId);
+                    }
+                    await saveRequestDB(sessionId, cloudRequestId, requestData);
+                    const usage = extractTokenUsage(requestData.response.events);
+                    pushNewRequest({
+                        requestId: cloudRequestId,
+                        sessionId,
+                        compositeId: `${sessionId}:${cloudRequestId}`,
+                        method: request.method,
+                        path: request.url,
+                        timestamp: requestData.timestamp,
+                        statusCode: response.status,
+                        responseTime: Date.now() - startTime,
+                        model: forwardedModel,
+                        machineId,
+                        baseUrl: resolved.baseUrl,
+                        usage,
+                        pendingId: cloudRequestId !== request.id ? `${sessionId}:${request.id}` : undefined
+                    }, 'completed');
+                    const elapsed = Date.now() - startTime;
+                    request.log.info(`json response (openai): ${cloudRequestId} ${response.status} (${elapsed}ms)`);
+                    reply.code(response.status).headers({ 'Content-Type': 'application/json' }).send(claudeResponseBody);
+                    return;
+                }
+                // Handle SSE streaming response
+                reply.hijack();
+                const responseHeaders = Object.fromEntries(response.headers);
+                // Replace content-type with Claude SSE format
+                responseHeaders['content-type'] = 'text/event-stream';
+                reply.raw.writeHead(response.status, responseHeaders);
+                if (response.body) {
+                    const nodeStream = Readable.fromWeb(response.body);
+                    const transformStream = createStreamTransformer(forwardedModel || originalModel);
+                    // Record SSE events via batch buffer (memory: ≤10 batch + ≤5 tail)
+                    nodeStream.on('data', (chunk) => {
+                        const text = chunk.toString();
+                        const lines = text.split('\n');
+                        for (const line of lines) {
+                            if (line.startsWith('data:')) {
+                                const eventData = line.slice(5).trim();
+                                if (eventData && eventData !== '[DONE]') {
+                                    try {
+                                        const event = JSON.parse(eventData);
+                                        pushEventToBuffers(event, sessionId, cloudRequestId, eventBatch, tailBuffer, eventIndexRef);
+                                    }
+                                    catch {
+                                        // Not valid JSON, skip
+                                    }
+                                }
+                            }
+                        }
+                    });
+                    // Use finished() for reliable stream completion detection
+                    finished(nodeStream, async (err) => {
+                        if (err) {
+                            request.log.error(`openai stream error: ${err.message}`);
+                        }
+                        // Convert OpenAI stream usage to Claude format for extractTokenUsage compatibility
+                        const lastChunk = tailBuffer.find((e) => e?.usage);
+                        if (lastChunk?.usage) {
+                            const syntheticEvent = {
+                                type: 'message_delta',
+                                usage: {
+                                    output_tokens: lastChunk.usage.completion_tokens || 0
+                                }
+                            };
+                            pushEventToBuffers(syntheticEvent, sessionId, cloudRequestId, eventBatch, tailBuffer, eventIndexRef);
+                        }
+                        if (cloudRequestId !== request.id) {
+                            deleteResponseEvents(request.id, sessionId);
+                            deleteRequestRow(request.id, sessionId);
+                        }
+                        // Flush remaining batch + complete request
+                        try {
+                            await completeStreamSave(sessionId, cloudRequestId, requestData, eventBatch, tailBuffer, eventIndexRef, startTime, response.status, resolved, forwardedModel, originalModel, machineId, request);
+                            const elapsed = Date.now() - startTime;
+                            request.log.info(`stream completed (openai): ${cloudRequestId} ${response.status} (${elapsed}ms, ${eventIndexRef.value} events)`);
+                        }
+                        catch (dbErr) {
+                            request.log.error(`openai stream save failed: ${dbErr.message}`);
+                        }
+                    });
+                    // Pipe: OpenAI SSE → Transform → Claude SSE → Client
+                    nodeStream.pipe(transformStream).pipe(reply.raw);
+                }
                 return;
             }
+            // --- Claude Mode (existing direct forwarding) ---
             // Build target URL correctly
             // request.url = '/v1/messages' -> should become '/apps/anthropic/v1/messages'
             const targetUrlStr = `${resolved.baseUrl}${resolved.targetPath}${request.url}`;
-            // Tool 注入：存在启用 tool 时，向主对话请求的 tools 末尾注入自定义 tool。
-            // 无启用 tool 时完全不进此分支，走下方原 pipe 路径（零影响）。
-            let injectedNames = [];
-            if (hasEnabledTools()) {
-                injectedNames = injectTools(request.body);
-                if (injectedNames.length) {
-                    request.log.info(`[inject] tools injected: ${injectedNames.join(',')} (${request.id})`);
-                }
-            }
-            const injected = injectedNames.length > 0;
             request.log.info(`forwarding to: ${targetUrlStr}`);
             // Forward request to Aliyun with filtered headers
             const response = await fetch(targetUrlStr, {
@@ -277,10 +498,14 @@ export async function setupProxy(fastify, proxyConfig) {
                     requestData.response.events.push(jsonBody);
                 }
                 catch {
-                    // Not valid JSON, record as raw text
                     requestData.response.events.push({ raw: responseBody });
                 }
                 requestData.response.completedAt = new Date().toISOString();
+                // Remove pending row if cloudRequestId differs from request.id
+                if (cloudRequestId !== request.id) {
+                    deleteResponseEvents(request.id, sessionId);
+                    deleteRequestRow(request.id, sessionId);
+                }
                 await saveRequestDB(sessionId, cloudRequestId, requestData);
                 const usage = extractTokenUsage(requestData.response.events);
                 pushNewRequest({
@@ -295,74 +520,16 @@ export async function setupProxy(fastify, proxyConfig) {
                     model: forwardedModel,
                     machineId,
                     baseUrl: resolved.baseUrl,
-                    usage
-                });
+                    usage,
+                    pendingId: cloudRequestId !== request.id ? `${sessionId}:${request.id}` : undefined
+                }, 'completed');
                 const elapsed = Date.now() - startTime;
                 request.log.info(`json response: ${cloudRequestId} ${response.status} (${elapsed}ms)`);
-                // Send response to client
                 reply.code(response.status);
                 reply.headers(Object.fromEntries(response.headers));
                 reply.send(responseBody);
                 return;
             }
-            // 条件缓冲：注入生效且为 SSE 时，收完整流检测是否命中已启用 tool。
-            // 命中 -> 内部循环 -> 合成 SSE 回写；未命中 -> 原样回放缓冲字节。
-            // 未注入时完全不进此分支，走下方原有 pipe 路径（零影响）。
-            if (injected && isSSE && response.body) {
-                const fullText = await response.text();
-                const events = parseSSEText(fullText);
-                requestData.response.events = events;
-                const parsed = parseUpstreamEvents(events);
-                const hitInjected = findInjectedCall(parsed) && parsed.stopReason === 'tool_use';
-                reply.hijack();
-                if (!hitInjected) {
-                    // 未命中：原样回放上游缓冲字节，客户端无感知
-                    reply.raw.writeHead(response.status, Object.fromEntries(response.headers));
-                    reply.raw.end(fullText);
-                }
-                else {
-                    // 命中：进入内部循环，代行「执行 tool -> 追加对话 -> 再调上游」
-                    request.log.info(`[inject] tool hit, entering loop: ${cloudRequestId}`);
-                    const loop = await runInjectLoop({
-                        events,
-                        body: request.body,
-                        callUpstream: async (b) => {
-                            const r = await fetch(targetUrlStr, {
-                                method: request.method,
-                                headers: forwardHeaders,
-                                body: JSON.stringify(b)
-                            });
-                            return parseSSEText(await r.text());
-                        }
-                    });
-                    reply.raw.writeHead(200, {
-                        'content-type': 'text/event-stream',
-                        'cache-control': 'no-cache',
-                        'connection': 'keep-alive'
-                    });
-                    writeTextAsSSE(reply.raw, loop.text, `msg_inject_${cloudRequestId}`);
-                    reply.raw.end();
-                    request.log.info(`[inject] loop done: ${cloudRequestId} (${loop.iterations} iter, limit=${loop.stoppedByLimit})`);
-                }
-                requestData.response.completedAt = new Date().toISOString();
-                await saveRequestDB(sessionId, cloudRequestId, requestData);
-                const usage = extractTokenUsage(requestData.response.events);
-                pushNewRequest({
-                    requestId: cloudRequestId,
-                    sessionId,
-                    compositeId: `${sessionId}:${cloudRequestId}`,
-                    method: request.method,
-                    path: request.url,
-                    timestamp: requestData.timestamp,
-                    statusCode: response.status,
-                    responseTime: Date.now() - startTime,
-                    model: forwardedModel,
-                    machineId,
-                    baseUrl: resolved.baseUrl,
-                    usage
-                });
-                return;
-            }
             // Hijack reply to take full control of SSE stream
             reply.hijack();
             // Write response headers (preserve original from Aliyun)
@@ -372,20 +539,17 @@ export async function setupProxy(fastify, proxyConfig) {
             if (response.body) {
                 // Convert Web ReadableStream to Node Readable stream
                 const nodeStream = Readable.fromWeb(response.body);
-                // Record SSE events while forwarding
+                // Record SSE events via batch buffer (memory: ≤10 batch + ≤5 tail)
                 nodeStream.on('data', (chunk) => {
                     const text = chunk.toString();
                     const lines = text.split('\n');
                     for (const line of lines) {
-                        // Handle both standard SSE and Aliyun format
-                        // Standard: data: {...}
-                        // Aliyun: event:xxx\ndata:{...}
                         if (line.startsWith('data:')) {
-                            const eventData = line.slice(5).trim(); // Remove 'data:' prefix
+                            const eventData = line.slice(5).trim();
                             if (eventData && eventData !== '[DONE]') {
                                 try {
                                     const event = JSON.parse(eventData);
-                                    requestData.response.events.push(event);
+                                    pushEventToBuffers(event, sessionId, cloudRequestId, eventBatch, tailBuffer, eventIndexRef);
                                 }
                                 catch {
                                     // Not valid JSON, skip
@@ -395,25 +559,22 @@ export async function setupProxy(fastify, proxyConfig) {
                     }
                 });
                 // Save request data when stream completes
-                nodeStream.on('end', async () => {
-                    const elapsed = Date.now() - startTime;
-                    requestData.response.completedAt = new Date().toISOString();
-                    await saveRequestDB(sessionId, cloudRequestId, requestData);
-                    const usage = extractTokenUsage(requestData.response.events);
-                    pushNewRequest({
-                        requestId: cloudRequestId,
-                        sessionId,
-                        compositeId: `${sessionId}:${cloudRequestId}`,
-                        method: request.method,
-                        path: request.url,
-                        timestamp: requestData.timestamp,
-                        statusCode: response.status,
-                        responseTime: elapsed,
-                        model: forwardedModel,
-                        machineId,
-                        usage
-                    });
-                    request.log.info(`stream completed: ${cloudRequestId} ${response.status} (${elapsed}ms, ${requestData.response.events.length} events)`);
+                finished(nodeStream, async (err) => {
+                    if (err) {
+                        request.log.error(`claude stream error: ${err.message}`);
+                    }
+                    if (cloudRequestId !== request.id) {
+                        deleteResponseEvents(request.id, sessionId);
+                        deleteRequestRow(request.id, sessionId);
+                    }
+                    try {
+                        await completeStreamSave(sessionId, cloudRequestId, requestData, eventBatch, tailBuffer, eventIndexRef, startTime, response.status, resolved, forwardedModel, originalModel, machineId, request);
+                        const elapsed = Date.now() - startTime;
+                        request.log.info(`stream completed: ${cloudRequestId} ${response.status} (${elapsed}ms, ${eventIndexRef.value} events)`);
+                    }
+                    catch (dbErr) {
+                        request.log.error(`stream save failed: ${dbErr.message}`);
+                    }
                 });
                 // Pipe: Aliyun -> Claude Code
                 nodeStream.pipe(reply.raw);
@@ -439,7 +600,7 @@ export async function setupProxy(fastify, proxyConfig) {
                 model: originalModel,
                 machineId: getMachineIdSync() ?? undefined,
                 baseUrl: resolved.baseUrl
-            });
+            }, 'completed');
             const statusCode = getErrorStatusCode(error);
             reply.code(statusCode).send({
                 error: getErrorMessage(error),