@cc-monitoring/proxy-core 0.3.1 → 0.4.1

package/dist/server/chat-route.js

@@ -1,10 +1,9 @@
 import { Readable } from 'stream';
 import { randomUUID } from 'node:crypto';
 import { loadConfig } from '../config/index.js';
-import { saveRequestDB, extractTokenUsage, loadSessionHistory } from '../utils/request-writer.js';
+import { createRequestRecorder, recordIteration, loadSessionHistory } from '../utils/request-writer.js';
 import { cleanOldRequestsDB } from '../utils/request-writer.js';
-import { pushNewRequest } from './data-push.js';
-import { initDatabase, getDatabase } from '../utils/db.js';
+import { initDatabase } from '../utils/db.js';
 import { resolveProxyTarget, getProxyModel, filterForwardHeaders, extractSafeHeaders } from './proxy.js';
 import { injectMcpTools } from '../utils/tool-injector.js';
 import { findInjectedCall, runJsonInjectLoop, runStreamingInjectLoop } from '../utils/inject-loop.js';
@@ -12,6 +11,7 @@ import { findEnabledTool } from '../tools/index.js';
 import { writeSSEEvent, writeTextAsSSE, shouldMock } from '../utils/sse-writer.js';
 import { SSEStreamProcessor } from '../utils/sse-stream-processor.js';
 import { getMachineIdSync, preloadMachineId } from '../utils/machine-id.js';
+import { createClientAbortSignal, createTimeoutSignal } from '../utils/abort-signals.js';
 export async function setupChatRoute(fastify, proxyConfig) {
     const fullConfig = await loadConfig();
     const maxDays = fullConfig.storage?.maxDays ?? 7;
@@ -20,6 +20,8 @@ export async function setupChatRoute(fastify, proxyConfig) {
     fastify.post('/api/chat', async (request, reply) => {
         const startTime = Date.now();
         const resolved = resolveProxyTarget(proxyConfig);
+        // 下游客户端中止：建一次，主 fetch 与 inject 循环内 fetch 全部复用同一 signal
+        const clientSignal = createClientAbortSignal(request.raw);
         // Generate or reuse session ID
         const providedSessionId = request.headers['x-chat-session-id'];
         const sessionId = providedSessionId || randomUUID();
@@ -57,7 +59,7 @@ export async function setupChatRoute(fastify, proxyConfig) {
             request.log.info(`[chat] MCP tools injected: ${injectedNames.join(',')} (${request.id})`);
         }
         // Filter and forward headers
-        const forwardHeaders = filterForwardHeaders(extractSafeHeaders(request.headers), resolved.apiKey);
+        const forwardHeaders = filterForwardHeaders(extractSafeHeaders(request.headers), resolved.apiKey, resolved.auth_style);
         forwardHeaders['x-chat-session-id'] = sessionId;
         // Extract API keys for recording
         const authHeader = request.headers['authorization'];
@@ -69,9 +71,9 @@ export async function setupChatRoute(fastify, proxyConfig) {
             (forwardedAuthHeader?.startsWith('Bearer ') ? forwardedAuthHeader.slice(7) : undefined);
         // Build request data
         const machineId = getMachineIdSync() ?? undefined;
-        const requestData = {
-            requestId: request.id,
+        const meta = {
             sessionId,
+            localRequestId: request.id,
             timestamp: new Date().toISOString(),
             apiKey,
             proxyApiKey,
@@ -83,29 +85,12 @@ export async function setupChatRoute(fastify, proxyConfig) {
                 path: request.url,
                 headers: forwardHeaders,
                 body: request.body
-            },
-            response: {
-                statusCode: 0,
-                events: []
             }
         };
+        const rec = createRequestRecorder(meta);
         await cleanOldRequestsDB(maxDays);
         // 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,
-            userAgent: request.headers['user-agent'],
-            baseUrl: resolved.baseUrl
-        }, 'pending');
+        await rec.pending();
         // Mock interception (PoC)
         if (shouldMock(request.body)) {
             reply.hijack();
@@ -126,14 +111,11 @@ export async function setupChatRoute(fastify, proxyConfig) {
             method: 'POST',
             headers: forwardHeaders,
             body: JSON.stringify(request.body),
-            signal: AbortSignal.timeout(300000)
+            signal: createTimeoutSignal(300000, clientSignal)
         });
         request.log.info(`[chat] 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');
@@ -144,10 +126,10 @@ export async function setupChatRoute(fastify, proxyConfig) {
             let jsonBody;
             try {
                 jsonBody = JSON.parse(responseBody);
-                requestData.response.events.push(jsonBody);
+                rec.appendEvent(jsonBody);
             }
             catch {
-                requestData.response.events.push({ raw: responseBody });
+                rec.appendEvent({ raw: responseBody });
             }
             // JSON inject loop: if MCP tools injected and response has tool_use
             if (injected && jsonBody && jsonBody.stop_reason === 'tool_use') {
@@ -163,7 +145,7 @@ export async function setupChatRoute(fastify, proxyConfig) {
                                 method: 'POST',
                                 headers: forwardHeaders,
                                 body: JSON.stringify(b),
-                                signal: AbortSignal.timeout(300000)
+                                signal: createTimeoutSignal(300000, clientSignal)
                             });
                             const loopResponseBody = await r.text();
                             let loopJson;
@@ -172,101 +154,42 @@ export async function setupChatRoute(fastify, proxyConfig) {
                             }
                             catch { /* ignore */ }
                             // Record each loop iteration as a separate request
-                            if (loopJson) {
-                                const loopRequestId = r.headers.get('x-request-id') || `loop_${request.id}_${Date.now()}`;
-                                const loopData = {
-                                    requestId: loopRequestId,
-                                    sessionId,
-                                    timestamp: new Date().toISOString(),
-                                    apiKey,
-                                    proxyApiKey,
-                                    baseUrl: resolved.baseUrl,
-                                    model: forwardedModel,
-                                    machineId,
-                                    request: { method: 'POST', path: '/api/chat', headers: forwardHeaders, body: b },
-                                    response: {
-                                        statusCode: r.status,
-                                        headers: Object.fromEntries(r.headers),
-                                        events: [loopJson],
-                                        completedAt: new Date().toISOString()
-                                    }
-                                };
-                                await saveRequestDB(sessionId, loopRequestId, loopData);
-                                const loopUsage = extractTokenUsage(loopData.response.events);
-                                pushNewRequest({
-                                    requestId: loopRequestId,
-                                    sessionId,
-                                    compositeId: `${sessionId}:${loopRequestId}`,
-                                    method: 'POST',
-                                    path: '/api/chat',
-                                    timestamp: loopData.timestamp,
+                            await recordIteration({
+                                sessionId,
+                                localRequestId: r.headers.get('x-request-id') || `loop_${request.id}_${Date.now()}`,
+                                timestamp: new Date().toISOString(),
+                                apiKey,
+                                proxyApiKey,
+                                baseUrl: resolved.baseUrl,
+                                model: forwardedModel,
+                                machineId,
+                                request: { method: 'POST', path: '/api/chat', headers: forwardHeaders, body: b },
+                                response: {
                                     statusCode: r.status,
-                                    responseTime: 0,
-                                    model: forwardedModel,
-                                    machineId,
-                                    userAgent: request.headers['user-agent'],
-                                    baseUrl: resolved.baseUrl,
-                                    usage: loopUsage
-                                }, 'completed');
-                            }
+                                    headers: Object.fromEntries(r.headers),
+                                    events: loopJson ? [loopJson] : []
+                                }
+                            });
                             return loopJson || JSON.parse(loopResponseBody);
                         }
                     });
                     request.log.info(`[chat] json loop done: ${loopResult.iterations} iter (${cloudRequestId})`);
-                    requestData.response.completedAt = new Date().toISOString();
-                    // Remove pending row if cloudRequestId differs from request.id
-                    if (cloudRequestId !== request.id) {
-                        const db = getDatabase();
-                        db.prepare('DELETE FROM requests WHERE request_id = ? AND session_id = ?').run(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,
+                    await rec.complete({
+                        cloudRequestId: cloudRequestId !== request.id ? cloudRequestId : undefined,
                         statusCode: response.status,
-                        responseTime: Date.now() - startTime,
-                        model: forwardedModel,
-                        machineId,
-                        userAgent: request.headers['user-agent'],
-                        baseUrl: resolved.baseUrl,
-                        usage,
-                        pendingId: cloudRequestId !== request.id ? `${sessionId}:${request.id}` : undefined
-                    }, 'completed');
+                        headers: Object.fromEntries(response.headers)
+                    });
                     const finalBody = { ...loopResult.finalBody, _sessionId: sessionId };
                     reply.code(200).header('x-chat-session-id', sessionId).send(JSON.stringify(finalBody));
                     return;
                 }
             }
             // Normal JSON passthrough
-            requestData.response.completedAt = new Date().toISOString();
-            // Remove pending row if cloudRequestId differs from request.id
-            if (cloudRequestId !== request.id) {
-                const db = getDatabase();
-                db.prepare('DELETE FROM requests WHERE request_id = ? AND session_id = ?').run(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,
+            await rec.complete({
+                cloudRequestId: cloudRequestId !== request.id ? cloudRequestId : undefined,
                 statusCode: response.status,
-                responseTime: Date.now() - startTime,
-                model: forwardedModel,
-                machineId,
-                userAgent: request.headers['user-agent'],
-                baseUrl: resolved.baseUrl,
-                usage,
-                pendingId: cloudRequestId !== request.id ? `${sessionId}:${request.id}` : undefined
-            }, 'completed');
+                headers: Object.fromEntries(response.headers)
+            });
             // Inject session ID into response for passthrough
             try {
                 const passthroughBody = JSON.parse(responseBody);
@@ -294,32 +217,13 @@ export async function setupChatRoute(fastify, proxyConfig) {
             });
             nodeStream.on('end', async () => {
                 processor.flushLeftover();
-                // 保存原始请求到 DB
-                requestData.response.events = processor.events;
-                requestData.response.completedAt = new Date().toISOString();
-                // Remove pending row if cloudRequestId differs from request.id
-                if (cloudRequestId !== request.id) {
-                    const db = getDatabase();
-                    db.prepare('DELETE FROM requests WHERE request_id = ? AND session_id = ?').run(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,
+                for (const ev of processor.events)
+                    rec.appendEvent(ev);
+                await rec.complete({
+                    cloudRequestId: cloudRequestId !== request.id ? cloudRequestId : undefined,
                     statusCode: response.status,
-                    responseTime: Date.now() - startTime,
-                    model: forwardedModel,
-                    machineId,
-                    userAgent: request.headers['user-agent'],
-                    baseUrl: resolved.baseUrl,
-                    usage,
-                    pendingId: cloudRequestId !== request.id ? `${sessionId}:${request.id}` : undefined
-                }, 'completed');
+                    headers: Object.fromEntries(response.headers)
+                });
                 request.log.info(`[chat] stream completed: ${cloudRequestId} ${response.status} (${Date.now() - startTime}ms, ${processor.events.length} events)`);
                 // 检测注入的 MCP tool_use → 发 proxy_status 信号 + 跑 streaming inject loop
                 if (processor.hasInjectedToolUse()) {
@@ -335,7 +239,7 @@ export async function setupChatRoute(fastify, proxyConfig) {
                                 method: 'POST',
                                 headers: forwardHeaders,
                                 body: JSON.stringify(b),
-                                signal: AbortSignal.timeout(300000)
+                                signal: createTimeoutSignal(300000, clientSignal)
                             });
                             const loopRequestId = r.headers.get('x-request-id') || `loop_${request.id}_${Date.now()}`;
                             return { response: r, requestId: loopRequestId };
@@ -358,9 +262,9 @@ export async function setupChatRoute(fastify, proxyConfig) {
                         },
                         sessionId,
                         saveIterationDB: async (loopRequestId, loopProcessor, loopStatusCode, loopBody) => {
-                            const loopData = {
-                                requestId: loopRequestId,
+                            await recordIteration({
                                 sessionId,
+                                localRequestId: loopRequestId,
                                 timestamp: new Date().toISOString(),
                                 apiKey,
                                 proxyApiKey,
@@ -370,27 +274,9 @@ export async function setupChatRoute(fastify, proxyConfig) {
                                 request: { method: 'POST', path: '/api/chat', headers: forwardHeaders, body: loopBody },
                                 response: {
                                     statusCode: loopStatusCode,
-                                    events: loopProcessor.events,
-                                    completedAt: new Date().toISOString()
+                                    events: loopProcessor.events
                                 }
-                            };
-                            await saveRequestDB(sessionId, loopRequestId, loopData);
-                            const loopUsage = extractTokenUsage(loopProcessor.events);
-                            pushNewRequest({
-                                requestId: loopRequestId,
-                                sessionId,
-                                compositeId: `${sessionId}:${loopRequestId}`,
-                                method: 'POST',
-                                path: '/api/chat',
-                                timestamp: loopData.timestamp,
-                                statusCode: loopStatusCode,
-                                responseTime: 0,
-                                model: forwardedModel,
-                                machineId,
-                                userAgent: request.headers['user-agent'],
-                                baseUrl: resolved.baseUrl,
-                                usage: loopUsage
-                            }, 'completed');
+                            });
                         },
                         raw: reply.raw
                     });

package/dist/server/data-push.d.ts

@@ -2,6 +2,7 @@ import { WebSocket } from 'ws';
 export declare function addDataClient(ws: WebSocket): void;
 export declare function removeDataClient(ws: WebSocket): void;
 export declare function getDataClientCount(): number;
+export declare function scheduleStatsNotify(delayMs?: number): void;
+export declare function clearStatsNotify(): void;
 export declare function pushNewRequest(summary: any, status?: 'pending' | 'completed'): void;
-export declare function pushStatsNotify(): void;
 export declare function broadcastToDataClients(msg: any): void;

package/dist/server/data-push.js

@@ -10,6 +10,24 @@ export function removeDataClient(ws) {
 export function getDataClientCount() {
     return dataClients.size;
 }
+// stats notify debounce timer（模块级单个，trailing：重复调用重置延迟）
+let statsNotifyTimer = null;
+// 请求终态后延迟广播一次 stats notify，并发终态合并为一次
+export function scheduleStatsNotify(delayMs = 1500) {
+    if (statsNotifyTimer)
+        clearTimeout(statsNotifyTimer);
+    statsNotifyTimer = setTimeout(() => {
+        statsNotifyTimer = null;
+        broadcast({ type: 'stats', action: 'notify' });
+    }, delayMs);
+}
+// 服务关闭时清理 pending 的 debounce timer
+export function clearStatsNotify() {
+    if (statsNotifyTimer) {
+        clearTimeout(statsNotifyTimer);
+        statsNotifyTimer = null;
+    }
+}
 // Broadcast helpers
 export function pushNewRequest(summary, status = 'completed') {
     broadcast({
@@ -17,13 +35,10 @@ export function pushNewRequest(summary, status = 'completed') {
         action: status === 'pending' ? 'new' : 'update',
         data: { ...summary, status }
     });
-}
-export function pushStatsNotify() {
-    broadcast({
-        type: 'stats',
-        action: 'notify',
-        data: { reason: 'file_updated' }
-    });
+    // 终态（complete/interrupt/error）后通知前端重取 stats；pending=请求开始不触发
+    if (status !== 'pending') {
+        scheduleStatsNotify();
+    }
 }
 function broadcast(msg) {
     const payload = JSON.stringify(msg);

package/dist/server/index.js

@@ -1,4 +1,5 @@
 import Fastify from 'fastify';
+import { nanoid } from 'nanoid';
 import { loadConfig } from '../config/index.js';
 import { createLogger } from '../logger/index.js';
 import { configureDbPath } from '../utils/db.js';
@@ -6,7 +7,6 @@ import { setupProxy } from './proxy.js';
 import { setupUiRoutes } from './ui-route.js';
 import { setupChatRoute } from './chat-route.js';
 import { setupDocsRoutes } from './docs-route.js';
-import { requestIdMiddleware } from './middleware/request-id.js';
 export async function createServer() {
     const config = await loadConfig();
     if (config.storage?.path) {
@@ -16,9 +16,10 @@ export async function createServer() {
     const fastify = Fastify({
         logger: logger,
         trustProxy: true,
-        requestTimeout: 310000
+        requestTimeout: 310000,
+        genReqId: () => nanoid(16),
+        requestIdHeader: 'x-request-id'
     });
-    fastify.register(requestIdMiddleware);
     await setupUiRoutes(fastify); // UI routes registered BEFORE proxy to avoid being proxied
     await setupProxy(fastify, config.proxy);
     await setupChatRoute(fastify, config.proxy); // MCP-enhanced chat endpoint