@cc-monitoring/proxy-core 0.1.4 → 0.1.5-alpha.1

package/README.md

@@ -1,8 +1,6 @@
 # @cc-monitoring/proxy-core
 
-Claude Code 代理 + 监控 CLI。Fastify 应用层转发 + PM2 守护进程 + Web 管理面板 + 完整请求记录。
-
-一站式解决国内网络访问 Claude Code 的问题，同时提供请求日志、Token 统计、供应商切换、SSE 流式抓包等运维能力。
+Claude Code 代理工具 + Token 消耗监控面板。一行命令启动代理，实时追踪每次请求的模型、Token 用量和响应状态。
 
 [![npm version](https://img.shields.io/npm/v/@cc-monitoring/proxy-core.svg)](https://www.npmjs.com/package/@cc-monitoring/proxy-core)
 [![License: Apache-2.0](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
@@ -27,7 +25,7 @@ ccm start
 ccm ui
 
 # 3. 把 Claude Code 的 ANTHROPIC_BASE_URL 指向本地代理
-export ANTHROPIC_BASE_URL=http://localhost:3000
+export ANTHROPIC_BASE_URL=http://localhost:9527
 ```
 
 首次运行会在 `~/.cc-monitoring/` 生成配置文件和数据库：
@@ -67,20 +65,21 @@ ccm config set proxy.target https://xxx   # 修改上游地址
 
 ```json
 {
-  "server": { "port": 3000, "host": "localhost" },
+  "server": { "port": 9527, "host": "localhost" },
   "proxy": {
-    "target": "https://token-plan.cn-beijing.maas.aliyuncs.com/apps/anthropic",
-    "changeOrigin": true,
-    "rewritePrefix": ""
+    "target": "https://ark.cn-beijing.volces.com/api/coding",
+    "changeOrigin": true
   },
-  "logging": { "level": "info", "file": "logs/proxy.log" },
-  "auth": { "token": "" }
+  "logging": { "level": "info", "file": "logs/proxy.log", "maxSize": "10m", "interval": "1d", "compress": true },
+  "storage": { "type": "sqlite", "path": "logs/proxy.db", "maxDays": 7 }
 }
 ```
 
+> `logs/` 路径相对于 config 所在目录解析，实际存 `~/.cc-monitoring/logs/` 下。
+
 | 字段 | 类型 | 说明 |
 |------|------|------|
-| `server.port` | number (1-65535) | 监听端口，默认 3000 |
+| `server.port` | number (1-65535) | 监听端口，默认 9527 |
 | `server.host` | string | 监听主机 |
 | `proxy.target` | URL | 上游 AI 供应商 API |
 | `proxy.changeOrigin` | boolean | 是否重写 Origin 头 |
@@ -92,7 +91,7 @@ ccm config set proxy.target https://xxx   # 修改上游地址
 
 ## Web 管理面板
 
-`ccm ui` 或访问 `http://localhost:3000/ui`：
+`ccm ui` 或访问 `http://localhost:9527/ui`：
 
 - **状态监控**：CPU / 内存 / 运行时间 / 重启次数（5s 刷新）
 - **实时日志**：WebSocket 推流、级别过滤、关键字搜索
@@ -100,29 +99,6 @@ ccm config set proxy.target https://xxx   # 修改上游地址
 - **配置编辑**：可视化改 `config.json`，Zod 实时校验
 - **供应商管理**：多供应商配置，一键切换 baseUrl / apiKey / model
 
-## 架构要点
-
-**应用层转发**（Controller + Fetch + SSE Pipe），非透明代理：
-
-```
-Claude Code
-   ↓ POST /v1/messages
-Fastify（解析 body）
-   ↓ saveRequest（记录完整 payload）
-fetch → 上游 API
-   ↓ Web ReadableStream
-reply.hijack() + Readable.fromWeb().pipe(reply.raw)
-   ↓ 原样 SSE 转发
-Claude Code
-```
-
-为什么不用透明代理：`@fastify/http-proxy` 内部消费 request stream，无法同时完成「记录 body + 转发 SSE + 未来鉴权/统计」。HTTP stream 只能消费一次。
-
-**关键处理**：
-- Web Stream → Node Stream：`Readable.fromWeb(response.body)`
-- 头处理：删 `host`（阿里云 404）、`content-length`（长度变化），保留 `anthropic-version` / `x-api-key` / `accept: text/event-stream`
-- SSE 记录：`nodeStream.on('end')` 落盘完整 events 数组
-
 ## 环境变量
 
 | 变量 | 说明 |

package/dist/config/index.js

@@ -51,7 +51,8 @@ export async function resetConfig(configPath = getConfigPath()) {
             type: 'sqlite',
             path: 'logs/proxy.db',
             maxDays: 7
-        }
+        },
+        mcpServers: []
     };
     await saveConfig(defaultConfig, configPath);
 }

package/dist/config/schema.d.ts

@@ -65,6 +65,34 @@ export declare const AppConfigSchema: z.ZodObject<{
     }, {
         token: string;
     }>>;
+    mcpServers: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        transport_type: z.ZodEnum<["stdio", "sse", "streamable-http"]>;
+        command: z.ZodOptional<z.ZodString>;
+        args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        url: z.ZodOptional<z.ZodString>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        transport_type: "stdio" | "sse" | "streamable-http";
+        enabled: boolean;
+        command?: string | undefined;
+        args?: string[] | undefined;
+        env?: Record<string, string> | undefined;
+        url?: string | undefined;
+        headers?: Record<string, string> | undefined;
+    }, {
+        name: string;
+        transport_type: "stdio" | "sse" | "streamable-http";
+        command?: string | undefined;
+        args?: string[] | undefined;
+        env?: Record<string, string> | undefined;
+        url?: string | undefined;
+        headers?: Record<string, string> | undefined;
+        enabled?: boolean | undefined;
+    }>, "many">>>;
 }, "strip", z.ZodTypeAny, {
     server: {
         port: number;
@@ -88,6 +116,16 @@ export declare const AppConfigSchema: z.ZodObject<{
         type: "sqlite";
         maxDays: number;
     };
+    mcpServers: {
+        name: string;
+        transport_type: "stdio" | "sse" | "streamable-http";
+        enabled: boolean;
+        command?: string | undefined;
+        args?: string[] | undefined;
+        env?: Record<string, string> | undefined;
+        url?: string | undefined;
+        headers?: Record<string, string> | undefined;
+    }[];
     auth?: {
         token: string;
     } | undefined;
@@ -117,6 +155,16 @@ export declare const AppConfigSchema: z.ZodObject<{
     auth?: {
         token: string;
     } | undefined;
+    mcpServers?: {
+        name: string;
+        transport_type: "stdio" | "sse" | "streamable-http";
+        command?: string | undefined;
+        args?: string[] | undefined;
+        env?: Record<string, string> | undefined;
+        url?: string | undefined;
+        headers?: Record<string, string> | undefined;
+        enabled?: boolean | undefined;
+    }[] | undefined;
 }>;
 export type AppConfig = z.infer<typeof AppConfigSchema>;
 export declare function validateConfig(config: unknown): ValidationResult;

package/dist/config/schema.js

@@ -24,7 +24,17 @@ export const AppConfigSchema = z.object({
     }).optional().default({ type: 'sqlite', path: 'logs/proxy.db', maxDays: 7 }),
     auth: z.object({
         token: z.string().min(1)
-    }).optional()
+    }).optional(),
+    mcpServers: z.array(z.object({
+        name: z.string().min(1),
+        transport_type: z.enum(['stdio', 'sse', 'streamable-http']),
+        command: z.string().optional(),
+        args: z.array(z.string()).optional(),
+        env: z.record(z.string()).optional(),
+        url: z.string().optional(),
+        headers: z.record(z.string()).optional(),
+        enabled: z.boolean().default(true)
+    })).optional().default([])
 });
 export function validateConfig(config) {
     const result = AppConfigSchema.safeParse(config);

package/dist/server/chat-route.d.ts

@@ -0,0 +1,3 @@
+import { FastifyInstance } from 'fastify';
+import { ProxyConfig } from '../types/config.js';
+export declare function setupChatRoute(fastify: FastifyInstance, proxyConfig: ProxyConfig): Promise<void>;

package/dist/server/chat-route.js

@@ -0,0 +1,401 @@
+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 { cleanOldRequestsDB } from '../utils/request-writer.js';
+import { pushNewRequest } from './data-push.js';
+import { initDatabase, getDatabase } 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';
+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';
+export async function setupChatRoute(fastify, proxyConfig) {
+    const fullConfig = await loadConfig();
+    const maxDays = fullConfig.storage?.maxDays ?? 7;
+    initDatabase();
+    await preloadMachineId();
+    fastify.post('/api/chat', async (request, reply) => {
+        const startTime = Date.now();
+        const resolved = resolveProxyTarget(proxyConfig);
+        // Generate or reuse session ID
+        const providedSessionId = request.headers['x-chat-session-id'];
+        const sessionId = providedSessionId || randomUUID();
+        // Validate request body
+        if (!request.body?.model || !Array.isArray(request.body?.messages)) {
+            return reply.code(400).send({
+                error: 'invalid_request',
+                message: 'Request body must contain "model" and "messages" fields'
+            });
+        }
+        // Session resume: if sessionId exists in DB, load history and prepend
+        if (providedSessionId) {
+            const history = loadSessionHistory(providedSessionId);
+            if (history) {
+                // Prepend history messages before the new user messages
+                request.body.messages = [...history.messages, ...request.body.messages];
+                // Carry over system prompt if provided and not in current request
+                if (history.system && !request.body.system && !request.body.system_prompt) {
+                    request.body.system = history.system;
+                }
+                request.log.info(`[chat] session resumed: ${providedSessionId}, history: ${history.messages.length} messages`);
+            }
+        }
+        // Rewrite model based on tier
+        const originalModel = request.body.model;
+        const proxyModel = getProxyModel(originalModel, resolved);
+        if (proxyModel) {
+            request.body.model = proxyModel;
+        }
+        const forwardedModel = request.body.model;
+        // Inject MCP tools only (not probe/curl)
+        const injectedNames = injectMcpTools(request.body);
+        const injected = injectedNames.length > 0;
+        if (injected) {
+            request.log.info(`[chat] MCP tools injected: ${injectedNames.join(',')} (${request.id})`);
+        }
+        // Filter and forward headers
+        const forwardHeaders = filterForwardHeaders(extractSafeHeaders(request.headers), resolved.apiKey);
+        forwardHeaders['x-chat-session-id'] = sessionId;
+        // Extract API keys for recording
+        const authHeader = request.headers['authorization'];
+        const apiKey = authHeader?.startsWith('Bearer ')
+            ? authHeader.slice(7)
+            : request.headers['x-api-key'];
+        const forwardedAuthHeader = forwardHeaders['authorization'];
+        const proxyApiKey = forwardHeaders['x-api-key'] ||
+            (forwardedAuthHeader?.startsWith('Bearer ') ? forwardedAuthHeader.slice(7) : undefined);
+        // Build request data
+        const machineId = getMachineIdSync() ?? undefined;
+        const requestData = {
+            requestId: request.id,
+            sessionId,
+            timestamp: new Date().toISOString(),
+            apiKey,
+            proxyApiKey,
+            baseUrl: resolved.baseUrl,
+            model: forwardedModel,
+            machineId,
+            request: {
+                method: request.method,
+                path: request.url,
+                headers: forwardHeaders,
+                body: request.body
+            },
+            response: {
+                statusCode: 0,
+                events: []
+            }
+        };
+        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,
+            baseUrl: resolved.baseUrl
+        }, 'pending');
+        // Mock interception (PoC)
+        if (shouldMock(request.body)) {
+            reply.hijack();
+            reply.raw.writeHead(200, {
+                'content-type': 'text/event-stream',
+                'cache-control': 'no-cache',
+                'connection': 'keep-alive'
+            });
+            writeTextAsSSE(reply.raw, '[PoC] 这是 /api/chat 构造的合成响应，未经过真实大模型。', `msg_poc_chat_${request.id}`);
+            reply.raw.end();
+            return;
+        }
+        // Build target URL — always target /v1/messages
+        const targetUrlStr = `${resolved.baseUrl}${resolved.targetPath}/v1/messages`;
+        request.log.info(`[chat] forwarding to: ${targetUrlStr}`);
+        // Forward to upstream
+        const response = await fetch(targetUrlStr, {
+            method: 'POST',
+            headers: forwardHeaders,
+            body: JSON.stringify(request.body)
+        });
+        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');
+        const isJSON = contentType.includes('application/json');
+        // === JSON response (non-streaming) ===
+        if (isJSON && !isSSE && response.body) {
+            const responseBody = await response.text();
+            let jsonBody;
+            try {
+                jsonBody = JSON.parse(responseBody);
+                requestData.response.events.push(jsonBody);
+            }
+            catch {
+                requestData.response.events.push({ raw: responseBody });
+            }
+            // JSON inject loop: if MCP tools injected and response has tool_use
+            if (injected && jsonBody && jsonBody.stop_reason === 'tool_use') {
+                const toolCalls = (jsonBody.content || []).filter((b) => b.type === 'tool_use');
+                const hitCall = toolCalls.find((b) => findEnabledTool(b.name));
+                if (hitCall) {
+                    request.log.info(`[chat] json tool hit: ${hitCall.name} (${cloudRequestId})`);
+                    const loopResult = await runJsonInjectLoop({
+                        initialBody: jsonBody,
+                        requestBody: request.body,
+                        callUpstream: async (b) => {
+                            const r = await fetch(targetUrlStr, {
+                                method: 'POST',
+                                headers: forwardHeaders,
+                                body: JSON.stringify(b)
+                            });
+                            const loopResponseBody = await r.text();
+                            let loopJson;
+                            try {
+                                loopJson = JSON.parse(loopResponseBody);
+                            }
+                            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,
+                                    statusCode: r.status,
+                                    responseTime: 0,
+                                    model: forwardedModel,
+                                    machineId,
+                                    baseUrl: resolved.baseUrl,
+                                    usage: loopUsage
+                                }, 'completed');
+                            }
+                            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,
+                        statusCode: response.status,
+                        responseTime: Date.now() - startTime,
+                        model: forwardedModel,
+                        machineId,
+                        baseUrl: resolved.baseUrl,
+                        usage,
+                        pendingId: cloudRequestId !== request.id ? `${sessionId}:${request.id}` : undefined
+                    }, 'completed');
+                    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,
+                statusCode: response.status,
+                responseTime: Date.now() - startTime,
+                model: forwardedModel,
+                machineId,
+                baseUrl: resolved.baseUrl,
+                usage,
+                pendingId: cloudRequestId !== request.id ? `${sessionId}:${request.id}` : undefined
+            }, 'completed');
+            // Inject session ID into response for passthrough
+            try {
+                const passthroughBody = JSON.parse(responseBody);
+                passthroughBody._sessionId = sessionId;
+                reply.code(response.status);
+                reply.header('x-chat-session-id', sessionId);
+                reply.send(JSON.stringify(passthroughBody));
+            }
+            catch {
+                reply.code(response.status);
+                reply.headers(Object.fromEntries(response.headers));
+                reply.send(responseBody);
+            }
+            return;
+        }
+        // === SSE response (streaming — unified path) ===
+        if (isSSE && response.body) {
+            reply.hijack();
+            reply.raw.writeHead(response.status, { ...Object.fromEntries(response.headers), 'x-chat-session-id': sessionId });
+            const processor = new SSEStreamProcessor(reply.raw);
+            const nodeStream = Readable.fromWeb(response.body);
+            nodeStream.on('data', (chunk) => {
+                // SSEStreamProcessor.processChunk 同时转发到 reply.raw + 增量解析
+                processor.processChunk(chunk);
+            });
+            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,
+                    statusCode: response.status,
+                    responseTime: Date.now() - startTime,
+                    model: forwardedModel,
+                    machineId,
+                    baseUrl: resolved.baseUrl,
+                    usage,
+                    pendingId: cloudRequestId !== request.id ? `${sessionId}:${request.id}` : undefined
+                }, 'completed');
+                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()) {
+                    const injectedCall = findInjectedCall(processor.getParsedUpstream());
+                    // 通知客户端：proxy 正在代行 tool，同连接上还有续接数据
+                    writeSSEEvent(reply.raw, { type: 'proxy_status', status: 'tool_executing', tool: injectedCall?.name });
+                    request.log.info(`[chat] SSE tool hit, entering streaming inject loop: ${cloudRequestId}`);
+                    await runStreamingInjectLoop({
+                        initialParsed: processor.getParsedUpstream(),
+                        body: request.body,
+                        callUpstream: async (b) => {
+                            const r = await fetch(targetUrlStr, {
+                                method: 'POST',
+                                headers: forwardHeaders,
+                                body: JSON.stringify(b)
+                            });
+                            const loopRequestId = r.headers.get('x-request-id') || `loop_${request.id}_${Date.now()}`;
+                            return { response: r, requestId: loopRequestId };
+                        },
+                        streamAndParse: async (loopResponse) => {
+                            // 流式转发 loop 迭代的 SSE 到同一 reply.raw
+                            const loopProcessor = new SSEStreamProcessor(reply.raw);
+                            const loopStream = Readable.fromWeb(loopResponse.body);
+                            loopStream.on('data', (chunk) => loopProcessor.processChunk(chunk));
+                            return new Promise((resolve, reject) => {
+                                loopStream.on('end', () => {
+                                    loopProcessor.flushLeftover();
+                                    resolve({ processor: loopProcessor, statusCode: loopResponse.status });
+                                });
+                                loopStream.on('error', (err) => {
+                                    request.log.error({ err }, `[chat] loop stream error`);
+                                    reject(err);
+                                });
+                            });
+                        },
+                        sessionId,
+                        saveIterationDB: async (loopRequestId, loopProcessor, loopStatusCode, loopBody) => {
+                            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: loopBody },
+                                response: {
+                                    statusCode: loopStatusCode,
+                                    events: loopProcessor.events,
+                                    completedAt: new Date().toISOString()
+                                }
+                            };
+                            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,
+                                baseUrl: resolved.baseUrl,
+                                usage: loopUsage
+                            }, 'completed');
+                        },
+                        raw: reply.raw
+                    });
+                    request.log.info(`[chat] SSE streaming inject loop done: ${cloudRequestId}`);
+                }
+                reply.raw.end();
+            });
+            nodeStream.on('error', (err) => {
+                request.log.error({ err }, `[chat] stream error: ${cloudRequestId}`);
+                reply.raw.end();
+            });
+            return;
+        }
+        // No body — error
+        reply.code(response.status).send('');
+    });
+}

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

@@ -1,5 +1,5 @@
 import { WebSocket } from 'ws';
 export declare function addDataClient(ws: WebSocket): void;
 export declare function removeDataClient(ws: WebSocket): void;
-export declare function pushNewRequest(summary: any): void;
+export declare function pushNewRequest(summary: any, status?: 'pending' | 'completed'): void;
 export declare function pushStatsNotify(): void;

package/dist/server/data-push.js

@@ -8,11 +8,11 @@ export function removeDataClient(ws) {
     dataClients.delete(ws);
 }
 // Broadcast helpers
-export function pushNewRequest(summary) {
+export function pushNewRequest(summary, status = 'completed') {
     broadcast({
         type: 'request',
-        action: 'new',
-        data: summary
+        action: status === 'pending' ? 'new' : 'update',
+        data: { ...summary, status }
     });
 }
 export function pushStatsNotify() {

package/dist/server/index.js

@@ -5,6 +5,7 @@ import { configureDbPath } from '../utils/db.js';
 import { getCurrentModuleUrl } from '../utils/esm-dirname.js';
 import { setupProxy } from './proxy.js';
 import { setupUiRoutes } from './ui-route.js';
+import { setupChatRoute } from './chat-route.js';
 import { requestIdMiddleware } from './middleware/request-id.js';
 export async function createServer() {
     const config = await loadConfig();
@@ -19,6 +20,7 @@ export async function createServer() {
     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
     return fastify;
 }
 export async function startServer() {

package/dist/server/mcp-route.d.ts

@@ -0,0 +1,2 @@
+import { FastifyInstance } from 'fastify';
+export declare function setupMcpRoutes(fastify: FastifyInstance, config: any): Promise<void>;