@cc-monitoring/proxy-core 0.4.0 → 0.4.2

package/dist/server/__tests__/proxy.test.js

@@ -1,12 +1,33 @@
-import { getErrorStatusCode, getErrorMessage, resolveProxyTarget, filterForwardHeaders } from '../proxy';
+import { getErrorStatusCode, getErrorMessage, resolveProxyTarget, filterForwardHeaders, setupProxy } from '../proxy';
+import Fastify from 'fastify';
+import http from 'node:http';
 import Database from 'better-sqlite3';
+import { WebSocket } from 'ws';
+import { addDataClient, removeDataClient } from '../data-push';
 jest.mock('@utils/db', () => ({
     __esModule: true,
     getDatabase: jest.fn(),
     initDatabase: jest.fn(),
     closeDatabase: jest.fn()
 }));
-const { getDatabase } = jest.requireMock('@utils/db');
+jest.mock('@config/index', () => ({
+    loadConfig: jest.fn().mockResolvedValue({ storage: { maxDays: 7 } })
+}));
+jest.mock('../../utils/mcp-manager', () => ({
+    mcpManager: {
+        init: jest.fn().mockResolvedValue(undefined),
+        close: jest.fn().mockResolvedValue(undefined)
+    }
+}));
+jest.mock('../../utils/machine-id', () => ({
+    getMachineId: jest.fn().mockResolvedValue('test-machine-id'),
+    getMachineIdSync: jest.fn().mockReturnValue('test-machine-id'),
+    preloadMachineId: jest.fn().mockResolvedValue(undefined)
+}));
+jest.mock('../../utils/stats-aggregator', () => ({
+    aggregateStats: jest.fn()
+}));
+const { getDatabase, initDatabase } = jest.requireMock('@utils/db');
 function makeError(code, message) {
     const error = new Error(message);
     error.code = code;
@@ -135,3 +156,345 @@ describe('filterForwardHeaders with authStyle', () => {
         expect(out['x-api-key']).toBe('inbound-key');
     });
 });
+// --- G2: 逻辑终止识别 + 收割接入（setupProxy 集成测试）---
+// 构造集成测试用内存库：仅建 proxy.ts 运行路径触及的表
+function createIntegrationDb() {
+    const db = new Database(':memory:');
+    db.exec(`
+    CREATE TABLE requests (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      request_id TEXT UNIQUE NOT NULL,
+      session_id TEXT NOT NULL,
+      timestamp TEXT NOT NULL,
+      method TEXT NOT NULL,
+      path TEXT NOT NULL,
+      status_code INTEGER NOT NULL,
+      response_time INTEGER NOT NULL,
+      api_key TEXT,
+      proxy_api_key TEXT,
+      base_url TEXT,
+      model TEXT,
+      machine_id TEXT,
+      user_agent TEXT,
+      input_tokens INTEGER,
+      output_tokens INTEGER,
+      cache_read_tokens INTEGER,
+      cache_creation_tokens INTEGER,
+      request_headers TEXT,
+      request_body TEXT,
+      response_headers TEXT,
+      response_events TEXT,
+      completed_at TEXT,
+      closed_at TEXT,
+      error TEXT,
+      created_at TEXT DEFAULT CURRENT_TIMESTAMP
+    );
+    CREATE TABLE response_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      request_id TEXT NOT NULL,
+      session_id TEXT NOT NULL,
+      event_index INTEGER NOT NULL,
+      event_type TEXT,
+      event_data TEXT NOT NULL
+    );
+    CREATE TABLE learn_tasks (
+      task_id TEXT PRIMARY KEY,
+      slug TEXT NOT NULL,
+      source_type TEXT NOT NULL,
+      label TEXT NOT NULL,
+      status TEXT NOT NULL,
+      error TEXT,
+      created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      ended_at TEXT
+    );
+    CREATE TABLE providers (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT UNIQUE NOT NULL,
+      base_url TEXT,
+      api_key TEXT,
+      model TEXT,
+      haiku_model TEXT,
+      sonnet_model TEXT,
+      opus_model TEXT,
+      subagent_model TEXT,
+      provider TEXT NOT NULL,
+      is_default INTEGER NOT NULL DEFAULT 0,
+      is_openai_compatible INTEGER NOT NULL DEFAULT 0,
+      auth_style TEXT NOT NULL DEFAULT 'bearer',
+      created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+      updated_at TEXT DEFAULT CURRENT_TIMESTAMP
+    );
+  `);
+    return db;
+}
+function sseFrame(event, data) {
+    const body = typeof data === 'string' ? data : JSON.stringify(data);
+    return event !== null ? `event: ${event}\ndata: ${body}\n\n` : `data: ${body}\n\n`;
+}
+const completeClaudeFrames = [
+    sseFrame('message_start', { type: 'message_start', usage: { input_tokens: 10, cache_read_input_tokens: 2 } }),
+    sseFrame('ping', { type: 'ping' }),
+    sseFrame('message_delta', { type: 'message_delta', usage: { output_tokens: 4 } }),
+    sseFrame('message_stop', { type: 'message_stop' })
+];
+const incompleteClaudeFrames = [
+    sseFrame('message_start', { type: 'message_start', usage: { input_tokens: 3 } }),
+    sseFrame('content_block_start', { type: 'content_block_start', index: 0, content_block: { type: 'text', text: '' } }),
+    sseFrame('content_block_delta', { type: 'content_block_delta', index: 0, delta: { type: 'text_delta', text: 'hel' } })
+];
+// 上游 Web 流：逐帧异步入队；endAfter=false 时入队后保持悬挂（不 close）。
+// singleChunk=true 时所有帧合并为一次 enqueue（模拟真实 TCP 合包，如
+// finish_reason chunk 与紧随的 [DONE] 通常在同一缓冲到达）。
+function createUpstreamWebStream(frames, endAfter = false, singleChunk = false) {
+    let controller;
+    const webStream = new ReadableStream({
+        start(c) { controller = c; }
+    });
+    void (async () => {
+        try {
+            if (singleChunk) {
+                controller.enqueue(Buffer.from(frames.join(''), 'utf-8'));
+            }
+            else {
+                for (const frame of frames) {
+                    controller.enqueue(Buffer.from(frame, 'utf-8'));
+                    await new Promise(r => setTimeout(r, 3));
+                }
+            }
+            if (endAfter)
+                controller.close();
+        }
+        catch {
+            // nodeStream.destroy 取消 web 流后 controller 已关闭，忽略后续入队
+        }
+    })();
+    return webStream;
+}
+async function waitFor(predicate, { timeout = 3000, interval = 20 } = {}) {
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+        const value = predicate();
+        if (value !== undefined)
+            return value;
+        await new Promise(r => setTimeout(r, interval));
+    }
+    throw new Error('waitFor timed out');
+}
+function mockUpstreamFetch(webStream, requestId) {
+    return jest.spyOn(globalThis, 'fetch').mockImplementation(async () => new Response(webStream, {
+        status: 200,
+        headers: { 'content-type': 'text/event-stream', 'x-request-id': requestId }
+    }));
+}
+// 挂一个假数据客户端捕获 WS 广播（request new/update 等）
+let mockWs;
+function attachMockWs() {
+    const sent = [];
+    mockWs = {
+        readyState: WebSocket.OPEN,
+        send: jest.fn((payload) => { sent.push(JSON.parse(payload)); })
+    };
+    addDataClient(mockWs);
+    return sent;
+}
+const proxyConfig = {
+    target: 'https://upstream.example.com/apps/anthropic',
+    changeOrigin: true
+};
+const requestPayload = JSON.stringify({
+    model: 'claude-sonnet-4-20250514',
+    max_tokens: 16,
+    messages: [{ role: 'user', content: 'hi' }]
+});
+describe('setupProxy SSE lifecycle (G2)', () => {
+    let db;
+    let fastify;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        db = createIntegrationDb();
+        getDatabase.mockReturnValue(db);
+        initDatabase.mockReturnValue(db);
+        fastify = Fastify();
+    });
+    afterEach(async () => {
+        delete process.env.CCM_STREAM_IDLE_TIMEOUT_MS;
+        if (mockWs) {
+            removeDataClient(mockWs);
+            mockWs = undefined;
+        }
+        await fastify.close();
+        db.close();
+    });
+    test('message_stop 已发出后上游悬挂：行落 completed_at，不标中断，客户端不悬挂', async () => {
+        await setupProxy(fastify, proxyConfig);
+        mockUpstreamFetch(createUpstreamWebStream(completeClaudeFrames), 'cloud-req-1');
+        const response = await fastify.inject({
+            method: 'POST',
+            url: '/v1/messages',
+            headers: { 'content-type': 'application/json' },
+            payload: requestPayload
+        });
+        expect(response.statusCode).toBe(200);
+        expect(response.payload).toContain('message_stop');
+        const row = db.prepare('SELECT * FROM requests WHERE request_id = ?').get('cloud-req-1');
+        expect(row).toBeDefined();
+        expect(row.completed_at).not.toBeNull();
+        expect(row.closed_at).toBeNull();
+        expect(row.error).toBeNull();
+    });
+    test('无 message_stop 的 idle 超时仍标中断（closed_at + error）', async () => {
+        // 测试专用时长覆盖：真实定时器，只缩短看门狗超时
+        process.env.CCM_STREAM_IDLE_TIMEOUT_MS = '80';
+        await setupProxy(fastify, proxyConfig);
+        mockUpstreamFetch(createUpstreamWebStream(incompleteClaudeFrames), 'cloud-req-2');
+        // 走真实 TCP：中断分支 pipe 不结束客户端（保持既有语义），客户端自行判超时
+        await fastify.listen({ port: 0, host: '127.0.0.1' });
+        const port = fastify.server.address().port;
+        const clientReq = http.request({
+            port,
+            host: '127.0.0.1',
+            method: 'POST',
+            path: '/v1/messages',
+            headers: { 'content-type': 'application/json', 'content-length': Buffer.byteLength(requestPayload) }
+        });
+        clientReq.on('error', () => { });
+        clientReq.end(requestPayload);
+        // 客户端收到数据后看门狗触发，不再有数据；保底 1s 后自毁连接
+        const clientTimer = setTimeout(() => clientReq.destroy(), 1000);
+        clientReq.on('close', () => clearTimeout(clientTimer));
+        const row = await waitFor(() => {
+            const r = db.prepare('SELECT * FROM requests LIMIT 1').get();
+            return r && r.closed_at ? r : undefined;
+        });
+        expect(row.completed_at).toBeNull();
+        expect(row.closed_at).not.toBeNull();
+        expect(row.error).toContain('idle timeout');
+        expect(row.status_code).toBe(200);
+    });
+    test('OpenAI 流 finish_reason + [DONE] 后上游悬挂：行落 completed_at', async () => {
+        db.prepare(`
+      INSERT INTO providers (name, base_url, api_key, model, provider, is_default, is_openai_compatible, auth_style)
+      VALUES ('openai-test', 'https://openai.example.com/v1', 'k', 'gpt-4o', 'openai', 1, 1, 'bearer')
+    `).run();
+        await setupProxy(fastify, proxyConfig);
+        const openaiFrames = [
+            sseFrame(null, { id: 'chat-1', choices: [{ delta: { role: 'assistant' }, finish_reason: null }] }),
+            sseFrame(null, { id: 'chat-1', choices: [{ delta: { content: 'hi' }, finish_reason: null }] }),
+            sseFrame(null, { id: 'chat-1', choices: [{ delta: {}, finish_reason: 'stop' }], usage: { prompt_tokens: 5, completion_tokens: 7 } }),
+            sseFrame(null, '[DONE]')
+        ];
+        const fetchSpy = mockUpstreamFetch(createUpstreamWebStream(openaiFrames, false, true), 'cloud-openai-1');
+        const response = await fastify.inject({
+            method: 'POST',
+            url: '/v1/messages',
+            headers: { 'content-type': 'application/json' },
+            payload: requestPayload
+        });
+        expect(response.statusCode).toBe(200);
+        expect(response.payload).toContain('message_stop');
+        expect(fetchSpy.mock.calls[0][0]).toBe('https://openai.example.com/v1/chat/completions');
+        const row = db.prepare('SELECT * FROM requests WHERE request_id = ?').get('cloud-openai-1');
+        expect(row).toBeDefined();
+        expect(row.completed_at).not.toBeNull();
+        expect(row.closed_at).toBeNull();
+        expect(row.error).toBeNull();
+    });
+    test('message_stop 到达后客户端断开：内容已完整交付，仍走 complete', async () => {
+        await setupProxy(fastify, proxyConfig);
+        mockUpstreamFetch(createUpstreamWebStream(completeClaudeFrames), 'cloud-req-3');
+        await fastify.listen({ port: 0, host: '127.0.0.1' });
+        const port = fastify.server.address().port;
+        await new Promise((resolve, reject) => {
+            const clientReq = http.request({
+                port,
+                host: '127.0.0.1',
+                method: 'POST',
+                path: '/v1/messages',
+                headers: { 'content-type': 'application/json', 'content-length': Buffer.byteLength(requestPayload) }
+            });
+            clientReq.on('error', () => { });
+            clientReq.on('response', (res) => {
+                res.on('data', (chunk) => {
+                    if (chunk.toString().includes('message_stop'))
+                        clientReq.destroy();
+                });
+            });
+            clientReq.on('close', () => resolve());
+            setTimeout(() => reject(new Error('client did not close')), 3000).unref();
+            clientReq.end(requestPayload);
+        });
+        const row = await waitFor(() => {
+            const r = db.prepare('SELECT * FROM requests WHERE request_id = ?').get('cloud-req-3');
+            return r && r.completed_at ? r : undefined;
+        });
+        expect(row.closed_at).toBeNull();
+        expect(row.error).toBeNull();
+    });
+    test('上游只返回 request-id 头（无 x-request-id）：completed 行取该值，WS update 的 pendingId 指向 local 行', async () => {
+        await setupProxy(fastify, proxyConfig);
+        const upstreamId = 'req_upstream_abc';
+        jest.spyOn(globalThis, 'fetch').mockImplementation(async () => new Response(createUpstreamWebStream(completeClaudeFrames), { status: 200, headers: { 'content-type': 'text/event-stream', 'request-id': upstreamId } }));
+        const sent = attachMockWs();
+        const response = await fastify.inject({
+            method: 'POST',
+            url: '/v1/messages',
+            headers: { 'content-type': 'application/json' },
+            payload: requestPayload
+        });
+        expect(response.statusCode).toBe(200);
+        const row = db.prepare('SELECT * FROM requests WHERE request_id = ?').get(upstreamId);
+        expect(row).toBeDefined();
+        expect(row.completed_at).not.toBeNull();
+        const localId = sent.find(m => m.type === 'request' && m.action === 'new').data.requestId;
+        const update = sent.find(m => m.type === 'request' && m.action === 'update' && m.data.requestId === upstreamId);
+        expect(update).toBeDefined();
+        expect(update.data.pendingId).toBe(`unknown-session:${localId}`);
+    });
+    test('Claude 模式上游 204 且 body 为 null：行落终态、WS 收到 completed、不挂起', async () => {
+        await setupProxy(fastify, proxyConfig);
+        jest.spyOn(globalThis, 'fetch').mockImplementation(async () => new Response(null, {
+            status: 204,
+            headers: { 'x-request-id': 'cloud-204-1' }
+        }));
+        const sent = attachMockWs();
+        const response = await fastify.inject({
+            method: 'POST',
+            url: '/v1/messages',
+            headers: { 'content-type': 'application/json' },
+            payload: requestPayload
+        });
+        expect(response.statusCode).toBe(204);
+        const row = db.prepare('SELECT * FROM requests WHERE request_id = ?').get('cloud-204-1');
+        expect(row).toBeDefined();
+        expect(row.completed_at).not.toBeNull();
+        expect(row.closed_at).toBeNull();
+        expect(row.error).toBeNull();
+        const update = sent.find(m => m.type === 'request' && m.action === 'update' && m.data.requestId === 'cloud-204-1');
+        expect(update).toBeDefined();
+    });
+    test('OpenAI 模式上游 204 且 body 为 null：行落终态、WS 收到 completed、不挂起', async () => {
+        db.prepare(`
+      INSERT INTO providers (name, base_url, api_key, model, provider, is_default, is_openai_compatible, auth_style)
+      VALUES ('openai-test', 'https://openai.example.com/v1', 'k', 'gpt-4o', 'openai', 1, 1, 'bearer')
+    `).run();
+        await setupProxy(fastify, proxyConfig);
+        jest.spyOn(globalThis, 'fetch').mockImplementation(async () => new Response(null, {
+            status: 204,
+            headers: { 'x-request-id': 'cloud-204-openai' }
+        }));
+        const sent = attachMockWs();
+        const response = await fastify.inject({
+            method: 'POST',
+            url: '/v1/messages',
+            headers: { 'content-type': 'application/json' },
+            payload: requestPayload
+        });
+        expect(response.statusCode).toBe(204);
+        const row = db.prepare('SELECT * FROM requests WHERE request_id = ?').get('cloud-204-openai');
+        expect(row).toBeDefined();
+        expect(row.completed_at).not.toBeNull();
+        expect(row.closed_at).toBeNull();
+        const update = sent.find(m => m.type === 'request' && m.action === 'update' && m.data.requestId === 'cloud-204-openai');
+        expect(update).toBeDefined();
+    });
+});

package/dist/server/__tests__/server.test.js

@@ -105,22 +105,27 @@ describe('createServer', () => {
         expect(response).toBeDefined();
         expect(typeof response.statusCode).toBe('number');
     });
-    it('propagates request ID from x-request-id header', async () => {
+    it('uses x-request-id header value as request id when header present', async () => {
         server = await createServer();
+        server.get('/request-id-echo', async (request) => ({ id: request.id }));
         const response = await server.inject({
             method: 'GET',
-            url: '/test',
-            headers: { 'x-request-id': 'custom-id-123' }
+            url: '/request-id-echo',
+            headers: { 'x-request-id': 'my-trace-123' }
         });
-        expect(response).toBeDefined();
+        expect(JSON.parse(response.body).id).toBe('my-trace-123');
     });
-    it('handles request without x-request-id header', async () => {
+    it('generates non-default nanoid request id without header, unique per request', async () => {
         server = await createServer();
-        const response = await server.inject({
-            method: 'GET',
-            url: '/test'
-        });
-        expect(response).toBeDefined();
+        server.get('/request-id-echo', async (request) => ({ id: request.id }));
+        const response1 = await server.inject({ method: 'GET', url: '/request-id-echo' });
+        const response2 = await server.inject({ method: 'GET', url: '/request-id-echo' });
+        const id1 = JSON.parse(response1.body).id;
+        const id2 = JSON.parse(response2.body).id;
+        expect(id1).not.toMatch(/^req-\d+$/);
+        expect(id2).not.toMatch(/^req-\d+$/);
+        expect(id1).toHaveLength(16);
+        expect(id1).not.toBe(id2);
     });
     it('server closes cleanly', async () => {
         server = await createServer();

package/dist/server/__tests__/ui-route.test.js

@@ -1,4 +1,5 @@
 import Fastify from 'fastify';
+import * as statsAggregator from '@utils/stats-aggregator';
 import { setupUiRoutes } from '../ui-route';
 // Mock PM2 utils
 jest.mock('@utils/pm2', () => ({
@@ -372,4 +373,46 @@ describe('setupUiRoutes', () => {
             expect(body.error).toContain('Disk write failed');
         });
     });
+    describe('GET /ui/api/stats', () => {
+        let aggregateSpy;
+        let getStatsSpy;
+        beforeEach(() => {
+            aggregateSpy = jest.spyOn(statsAggregator, 'aggregateStats').mockImplementation(() => { });
+            getStatsSpy = jest.spyOn(statsAggregator, 'getStatsData').mockReturnValue({ hourly: {}, lastUpdated: null });
+        });
+        afterEach(() => {
+            aggregateSpy.mockRestore();
+            getStatsSpy.mockRestore();
+        });
+        it('读前触发 aggregateStats 并返回 200', async () => {
+            const response = await server.inject({ method: 'GET', url: '/ui/api/stats' });
+            expect(aggregateSpy).toHaveBeenCalledTimes(1);
+            expect(aggregateSpy).toHaveBeenCalledWith(7);
+            expect(getStatsSpy).toHaveBeenCalledTimes(1);
+            // 必须先聚合再读取
+            expect(aggregateSpy.mock.invocationCallOrder[0]).toBeLessThan(getStatsSpy.mock.invocationCallOrder[0]);
+            expect(response.statusCode).toBe(200);
+            expect(JSON.parse(response.body)).toEqual({ hourly: {}, lastUpdated: null });
+        });
+        it('聚合失败只记录不阻断读取，仍返回 200', async () => {
+            aggregateSpy.mockImplementation(() => { throw new Error('agg boom'); });
+            // inject 请求的 request.log 来自 server.log.child()，替换为可观测的 mock
+            const logError = jest.fn();
+            jest.spyOn(server.log, 'child').mockReturnValue({
+                level: 'info',
+                fatal: jest.fn(),
+                error: logError,
+                warn: jest.fn(),
+                info: jest.fn(),
+                debug: jest.fn(),
+                trace: jest.fn(),
+                child: jest.fn()
+            });
+            const response = await server.inject({ method: 'GET', url: '/ui/api/stats' });
+            expect(response.statusCode).toBe(200);
+            expect(getStatsSpy).toHaveBeenCalledTimes(1);
+            // 聚合异常必须记录日志
+            expect(logError).toHaveBeenCalledTimes(1);
+        });
+    });
 });

package/dist/server/chat-route.js

@@ -115,7 +115,7 @@ export async function setupChatRoute(fastify, proxyConfig) {
         });
         request.log.info(`[chat] response status: ${response.status}`);
         // Extract cloud request ID
-        const cloudRequestId = response.headers.get('x-request-id') || request.id;
+        const cloudRequestId = response.headers.get('x-request-id') || response.headers.get('request-id') || request.id;
         // Check response type
         const contentType = response.headers.get('content-type') || '';
         const isSSE = contentType.includes('text/event-stream');
@@ -156,7 +156,7 @@ export async function setupChatRoute(fastify, proxyConfig) {
                             // Record each loop iteration as a separate request
                             await recordIteration({
                                 sessionId,
-                                localRequestId: r.headers.get('x-request-id') || `loop_${request.id}_${Date.now()}`,
+                                localRequestId: r.headers.get('x-request-id') || r.headers.get('request-id') || `loop_${request.id}_${Date.now()}`,
                                 timestamp: new Date().toISOString(),
                                 apiKey,
                                 proxyApiKey,
@@ -241,7 +241,7 @@ export async function setupChatRoute(fastify, proxyConfig) {
                                 body: JSON.stringify(b),
                                 signal: createTimeoutSignal(300000, clientSignal)
                             });
-                            const loopRequestId = r.headers.get('x-request-id') || `loop_${request.id}_${Date.now()}`;
+                            const loopRequestId = r.headers.get('x-request-id') || r.headers.get('request-id') || `loop_${request.id}_${Date.now()}`;
                             return { response: r, requestId: loopRequestId };
                         },
                         streamAndParse: async (loopResponse) => {

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

@@ -2,5 +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 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,6 +35,10 @@ export function pushNewRequest(summary, status = 'completed') {
         action: status === 'pending' ? 'new' : 'update',
         data: { ...summary, status }
     });
+    // 终态（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