@cc-monitoring/proxy-core 0.3.0 → 0.4.0

package/dist/utils/db.js

@@ -68,6 +68,14 @@ export function initDatabase() {
         applySchemaV9(db);
         db.prepare('INSERT OR REPLACE INTO schema_version (version) VALUES (9)').run();
     }
+    if (currentVersion < 10) {
+        applySchemaV10(db);
+        db.prepare('INSERT OR REPLACE INTO schema_version (version) VALUES (10)').run();
+    }
+    if (currentVersion < 11) {
+        applySchemaV11(db);
+        db.prepare('INSERT OR REPLACE INTO schema_version (version) VALUES (11)').run();
+    }
     return db;
 }
 export function applySchemaV2(db) {
@@ -146,6 +154,7 @@ function applySchemaV1(db) {
       proxy_api_key TEXT,
       base_url TEXT,
       model TEXT,
+      user_agent TEXT,
       input_tokens INTEGER,
       output_tokens INTEGER,
       cache_read_tokens INTEGER,
@@ -262,6 +271,39 @@ export function applySchemaV9(db) {
         db.exec("ALTER TABLE providers ADD COLUMN auth_style TEXT NOT NULL DEFAULT 'bearer'");
     }
 }
+export function applySchemaV10(db) {
+    // Add user_agent column to requests table
+    // ALTER TABLE ADD COLUMN is idempotent-safe via column-existence check
+    const columns = db.prepare("PRAGMA table_info(requests)").all();
+    if (!columns.some(c => c.name === 'user_agent')) {
+        db.exec('ALTER TABLE requests ADD COLUMN user_agent TEXT');
+    }
+    // Backfill historical rows from request_headers JSON (idempotent)
+    db.prepare(`
+    UPDATE requests SET user_agent = json_extract(request_headers, '$.user-agent')
+    WHERE user_agent IS NULL AND request_headers IS NOT NULL
+  `).run();
+}
+export function applySchemaV11(db) {
+    // learn 流水线状态机落库：文件操作前插 running，结束转 completed/failed/aborted；
+    // 服务启动时无主 running 回收为 crashed。partial unique index 硬守同 slug 并发运行。
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS 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
+    )
+  `);
+    db.exec(`
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_learn_tasks_running_slug
+      ON learn_tasks(slug) WHERE status = 'running'
+  `);
+}
 export function closeDatabase() {
     if (db) {
         db.close();

package/dist/utils/esm-dirname.d.ts

@@ -1,14 +1,3 @@
-/**
- * ESM-compatible __dirname for this module.
- *
- * In ESM runtime, __dirname is undefined. This module computes its own
- * directory path using import.meta.url, which can then be used to derive
- * other paths relative to known locations.
- *
- * In CJS test environments (Jest), import.meta is not available, so this
- * module should be mocked to return a suitable path.
- */
-declare const thisDirname: string;
 /**
  * Get the directory of a source file relative to this utility's location.
  *
@@ -22,10 +11,6 @@ declare const thisDirname: string;
  * Example: getCallerDirname('../server') => packages/core/src/server
  */
 export declare function getCallerDirname(relativePath: string): string;
-/**
- * Direct export of this module's __dirname for simple relative path derivation.
- */
-export { thisDirname as utilsDirname };
 /**
  * ESM-compatible accessor for the entry module's URL.
  *

package/dist/utils/esm-dirname.js

@@ -34,10 +34,6 @@ const thisDirname = (() => {
 export function getCallerDirname(relativePath) {
     return path.resolve(thisDirname, relativePath);
 }
-/**
- * Direct export of this module's __dirname for simple relative path derivation.
- */
-export { thisDirname as utilsDirname };
 /**
  * ESM-compatible accessor for the entry module's URL.
  *

package/dist/utils/inject-loop.d.ts

@@ -18,39 +18,13 @@ export interface ParsedUpstream {
     stopReason: string;
     usage: any;
 }
-/** 解析上游 SSE 全文 -> 事件数组（收集 data: 行的 JSON） */
-export declare function parseSSEText(text: string): any[];
 /** 从事件数组重建有序内容块 + stop_reason + usage */
 export declare function parseUpstreamEvents(events: any[]): ParsedUpstream;
 /** 找出命中的、已启用的注入 tool 调用块 */
 export declare function findInjectedCall(parsed: ParsedUpstream): ParsedBlock | undefined;
-export interface InjectLoopResult {
-    text: string;
-    iterations: number;
-    stoppedByLimit: boolean;
-}
-/**
- * SSE 内部循环：命中已启用 tool -> 执行 exec -> 追加对话 -> 再调上游 -> 直到 end_turn。
- * opts.body 会被原地追加 messages。
- *
- * @param opts.events 首次上游响应事件（已确认命中注入 tool）
- * @param opts.callUpstream 用给定 body 再次调上游，返回事件数组
- * @param opts.maxIterations 死循环护栏（tool 描述可能诱导模型反复调用）
- */
-export declare function runInjectLoop(opts: {
-    events: any[];
-    body: any;
-    callUpstream: (body: any) => Promise<any[]>;
-    maxIterations?: number;
-}): Promise<InjectLoopResult>;
 /**
  * SSE 流式注入循环：命中已启用 tool → 执行 exec → 追加对话 → 再调上游 → 新 SSE 流式转发到同一 reply.raw。
  * 每次迭代作为独立 DB 记录。客户端实时看到续接 SSE。
- *
- * 与 runInjectLoop 的区别：
- * - 不缓冲上游响应，直接流式转发
- * - 不返回合成 text，客户端已实时收到原始 SSE
- * - 每次迭代用 SSEStreamProcessor 边转发边解析
  */
 export interface StreamingInjectLoopResult {
     iterations: number;
@@ -79,7 +53,6 @@ export interface JsonInjectLoopResult {
 }
 /**
  * JSON 内部循环：非流式请求中命中 MCP tool -> 执行 exec -> 追加对话 -> 再调上游 -> 直到 end_turn。
- * 与 SSE 版 runInjectLoop 对称，但处理 parsed JSON response body 而非 SSE event 数组。
  *
  * @param opts.initialBody 首次上游 JSON 响应（已确认命中 MCP tool）
  * @param opts.requestBody 请求体（messages 会被原地追加）

package/dist/utils/inject-loop.js

@@ -1,22 +1,4 @@
 import { findEnabledTool } from '../tools/index.js';
-/** 解析上游 SSE 全文 -> 事件数组（收集 data: 行的 JSON） */
-export function parseSSEText(text) {
-    const events = [];
-    for (const line of text.split('\n')) {
-        if (line.startsWith('data:')) {
-            const d = line.slice(5).trim();
-            if (d && d !== '[DONE]') {
-                try {
-                    events.push(JSON.parse(d));
-                }
-                catch {
-                    // 非 JSON 行跳过
-                }
-            }
-        }
-    }
-    return events;
-}
 /** 从事件数组重建有序内容块 + stop_reason + usage */
 export function parseUpstreamEvents(events) {
     const blocks = new Map();
@@ -82,42 +64,6 @@ function blocksToAssistantContent(blocks) {
     }
     return content;
 }
-function collectText(parsed) {
-    return parsed.blocks
-        .filter((b) => b.type === 'text' && b.text)
-        .map((b) => b.text)
-        .join('');
-}
-/**
- * SSE 内部循环：命中已启用 tool -> 执行 exec -> 追加对话 -> 再调上游 -> 直到 end_turn。
- * opts.body 会被原地追加 messages。
- *
- * @param opts.events 首次上游响应事件（已确认命中注入 tool）
- * @param opts.callUpstream 用给定 body 再次调上游，返回事件数组
- * @param opts.maxIterations 死循环护栏（tool 描述可能诱导模型反复调用）
- */
-export async function runInjectLoop(opts) {
-    const maxIterations = opts.maxIterations ?? 3;
-    let parsed = parseUpstreamEvents(opts.events);
-    let iterations = 0;
-    while (iterations < maxIterations) {
-        const call = findInjectedCall(parsed);
-        if (!call || parsed.stopReason !== 'tool_use') {
-            return { text: collectText(parsed), iterations, stoppedByLimit: false };
-        }
-        const tool = findEnabledTool(call.name);
-        const result = await tool.exec(call.input);
-        opts.body.messages.push({ role: 'assistant', content: blocksToAssistantContent(parsed.blocks) });
-        opts.body.messages.push({
-            role: 'user',
-            content: [{ type: 'tool_result', tool_use_id: call.id, content: result }]
-        });
-        const nextEvents = await opts.callUpstream(opts.body);
-        parsed = parseUpstreamEvents(nextEvents);
-        iterations++;
-    }
-    return { text: collectText(parsed) || '(内部循环达到最大轮次)', iterations, stoppedByLimit: true };
-}
 export async function runStreamingInjectLoop(opts) {
     const maxIterations = opts.maxIterations ?? 3;
     let parsed = opts.initialParsed;
@@ -144,8 +90,9 @@ export async function runStreamingInjectLoop(opts) {
         const { processor, statusCode } = await opts.streamAndParse(response);
         // 保存这次迭代到 DB
         await opts.saveIterationDB(requestId, processor, statusCode, opts.body);
-        parsed = processor.getParsedUpstream();
+        // 先收尾残帧再取解析结果，保证最后一帧参与解析
         processor.flushLeftover();
+        parsed = processor.getParsedUpstream();
         iterations++;
     }
     const stoppedByLimit = iterations >= (opts.maxIterations ?? 3) &&
@@ -155,7 +102,6 @@ export async function runStreamingInjectLoop(opts) {
 }
 /**
  * JSON 内部循环：非流式请求中命中 MCP tool -> 执行 exec -> 追加对话 -> 再调上游 -> 直到 end_turn。
- * 与 SSE 版 runInjectLoop 对称，但处理 parsed JSON response body 而非 SSE event 数组。
  *
  * @param opts.initialBody 首次上游 JSON 响应（已确认命中 MCP tool）
  * @param opts.requestBody 请求体（messages 会被原地追加）

package/dist/utils/learn-tasks-db.d.ts

@@ -0,0 +1,15 @@
+import Database from 'better-sqlite3';
+export interface InsertRunningArgs {
+    slug: string;
+    sourceType: 'url' | 'file';
+    label: string;
+}
+/** 落 running 行；撞同 slug 唯一约束时错误原样抛出（SQLITE_CONSTRAINT_UNIQUE） */
+export declare function insertRunning(db: Database.Database, args: InsertRunningArgs): {
+    taskId: string;
+};
+export declare function markCompleted(db: Database.Database, taskId: string): void;
+export declare function markFailed(db: Database.Database, taskId: string, error: string): void;
+export declare function markAborted(db: Database.Database, taskId: string): void;
+/** 回收无主 running 行为 crashed（服务启动时调用），返回回收行数 */
+export declare function recoverCrashedTasks(db: Database.Database): number;

package/dist/utils/learn-tasks-db.js

@@ -0,0 +1,35 @@
+// learn_tasks 数据层：learn 流水线状态机落库
+// running → completed / failed / aborted；启动回收的无主 running → crashed。
+// 同 slug 并发运行由 partial unique index idx_learn_tasks_running_slug 硬守。
+import { randomUUID } from 'node:crypto';
+/** 落 running 行；撞同 slug 唯一约束时错误原样抛出（SQLITE_CONSTRAINT_UNIQUE） */
+export function insertRunning(db, args) {
+    const taskId = randomUUID();
+    db.prepare(`
+    INSERT INTO learn_tasks (task_id, slug, source_type, label, status)
+    VALUES (?, ?, ?, ?, 'running')
+  `).run(taskId, args.slug, args.sourceType, args.label);
+    return { taskId };
+}
+export function markCompleted(db, taskId) {
+    db.prepare(`
+    UPDATE learn_tasks SET status = 'completed', ended_at = ? WHERE task_id = ?
+  `).run(new Date().toISOString(), taskId);
+}
+export function markFailed(db, taskId, error) {
+    db.prepare(`
+    UPDATE learn_tasks SET status = 'failed', error = ?, ended_at = ? WHERE task_id = ?
+  `).run(error, new Date().toISOString(), taskId);
+}
+export function markAborted(db, taskId) {
+    db.prepare(`
+    UPDATE learn_tasks SET status = 'aborted', ended_at = ? WHERE task_id = ?
+  `).run(new Date().toISOString(), taskId);
+}
+/** 回收无主 running 行为 crashed（服务启动时调用），返回回收行数 */
+export function recoverCrashedTasks(db) {
+    const info = db.prepare(`
+    UPDATE learn_tasks SET status = 'crashed', ended_at = ? WHERE status = 'running'
+  `).run(new Date().toISOString());
+    return info.changes;
+}

package/dist/utils/openai-converter.js

@@ -1,4 +1,5 @@
 import { Transform } from 'stream';
+import { createSSEDecoder, encodeSSEFrame } from './sse-protocol.js';
 /**
  * Recursively cleans a JSON Schema for OpenAI API compatibility.
  * Removes '$schema' and 'additionalProperties'.
@@ -175,12 +176,16 @@ export function buildOpenAIHeaders(apiKey) {
  */
 export function createStreamTransformer(model) {
     let initialized = false;
-    let buffer = '';
     const messageId = `msg_${Math.random().toString(36).substr(2, 9)}`;
     const toolCalls = {};
     let contentBlockIndex = 0;
+    // 上一帧的原始 data 字符串（帧驱动下对应原 lines[length-2] 的数据来源）
+    let lastDataRaw = '';
+    let decoder = null;
+    // [DONE] 已在 decoder 回调内收尾，transform 末尾不再重复 callback
+    let doneHandled = false;
     const sendEvent = (event, data) => {
-        return `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+        return encodeSSEFrame({ event, data: JSON.stringify(data) });
     };
     return new Transform({
         transform(chunk, _encoding, callback) {
@@ -204,89 +209,94 @@ export function createStreamTransformer(model) {
                 }));
                 initialized = true;
             }
-            buffer += chunk.toString();
-            const lines = buffer.split('\n');
-            buffer = lines.pop() || '';
-            for (const line of lines) {
-                if (!line.startsWith('data: '))
-                    continue;
-                const data = line.substring(6);
-                if (data.trim() === '[DONE]') {
-                    // Send closing events
-                    this.push(sendEvent('content_block_stop', { type: 'content_block_stop', index: 0 }));
-                    Object.values(toolCalls).forEach(tc => {
-                        if (tc.started) {
-                            this.push(sendEvent('content_block_stop', { type: 'content_block_stop', index: tc.claudeIndex }));
+            if (!decoder) {
+                decoder = createSSEDecoder((frame) => {
+                    const data = frame.data.join('\n');
+                    if (data.trim() === '[DONE]') {
+                        // Send closing events
+                        this.push(sendEvent('content_block_stop', { type: 'content_block_stop', index: 0 }));
+                        Object.values(toolCalls).forEach(tc => {
+                            if (tc.started) {
+                                this.push(sendEvent('content_block_stop', { type: 'content_block_stop', index: tc.claudeIndex }));
+                            }
+                        });
+                        let finalStopReason = 'end_turn';
+                        try {
+                            const lastChunk = JSON.parse(lastDataRaw);
+                            const finishReason = lastChunk.choices[0].finish_reason;
+                            if (finishReason === 'tool_calls')
+                                finalStopReason = 'tool_use';
+                            if (finishReason === 'length')
+                                finalStopReason = 'max_tokens';
                         }
-                    });
-                    let finalStopReason = 'end_turn';
-                    try {
-                        const lastChunk = JSON.parse(lines[lines.length - 2].substring(6));
-                        const finishReason = lastChunk.choices[0].finish_reason;
-                        if (finishReason === 'tool_calls')
-                            finalStopReason = 'tool_use';
-                        if (finishReason === 'length')
-                            finalStopReason = 'max_tokens';
-                    }
-                    catch { }
-                    this.push(sendEvent('message_delta', {
-                        type: 'message_delta',
-                        delta: { stop_reason: finalStopReason, stop_sequence: null },
-                        usage: { output_tokens: 0 }
-                    }));
-                    this.push(sendEvent('message_stop', { type: 'message_stop' }));
-                    callback();
-                    this.destroy();
-                    return;
-                }
-                try {
-                    const openaiChunk = JSON.parse(data);
-                    const delta = openaiChunk.choices[0]?.delta;
-                    if (!delta)
-                        continue;
-                    if (delta.content) {
-                        this.push(sendEvent('content_block_delta', {
-                            type: 'content_block_delta',
-                            index: 0,
-                            delta: { type: 'text_delta', text: delta.content }
+                        catch { }
+                        this.push(sendEvent('message_delta', {
+                            type: 'message_delta',
+                            delta: { stop_reason: finalStopReason, stop_sequence: null },
+                            usage: { output_tokens: 0 }
                         }));
+                        this.push(sendEvent('message_stop', { type: 'message_stop' }));
+                        doneHandled = true;
+                        callback();
+                        this.destroy();
+                        return;
                     }
-                    if (delta.tool_calls) {
-                        for (const tc_delta of delta.tool_calls) {
-                            const index = tc_delta.index;
-                            if (!toolCalls[index]) {
-                                toolCalls[index] = { id: '', name: '', args: '', claudeIndex: 0, started: false };
-                            }
-                            if (tc_delta.id)
-                                toolCalls[index].id = tc_delta.id;
-                            if (tc_delta.function?.name)
-                                toolCalls[index].name = tc_delta.function.name;
-                            if (tc_delta.function?.arguments)
-                                toolCalls[index].args += tc_delta.function.arguments;
-                            if (toolCalls[index].id && toolCalls[index].name && !toolCalls[index].started) {
-                                contentBlockIndex++;
-                                toolCalls[index].claudeIndex = contentBlockIndex;
-                                toolCalls[index].started = true;
-                                this.push(sendEvent('content_block_start', {
-                                    type: 'content_block_start',
-                                    index: contentBlockIndex,
-                                    content_block: { type: 'tool_use', id: toolCalls[index].id, name: toolCalls[index].name, input: {} }
-                                }));
-                            }
-                            if (toolCalls[index].started && tc_delta.function?.arguments) {
-                                this.push(sendEvent('content_block_delta', {
-                                    type: 'content_block_delta',
-                                    index: toolCalls[index].claudeIndex,
-                                    delta: { type: 'input_json_delta', partial_json: tc_delta.function.arguments }
-                                }));
+                    lastDataRaw = data;
+                    try {
+                        const openaiChunk = JSON.parse(data);
+                        const delta = openaiChunk.choices[0]?.delta;
+                        if (!delta)
+                            return;
+                        if (delta.content) {
+                            this.push(sendEvent('content_block_delta', {
+                                type: 'content_block_delta',
+                                index: 0,
+                                delta: { type: 'text_delta', text: delta.content }
+                            }));
+                        }
+                        if (delta.tool_calls) {
+                            for (const tc_delta of delta.tool_calls) {
+                                const index = tc_delta.index;
+                                if (!toolCalls[index]) {
+                                    toolCalls[index] = { id: '', name: '', args: '', claudeIndex: 0, started: false };
+                                }
+                                if (tc_delta.id)
+                                    toolCalls[index].id = tc_delta.id;
+                                if (tc_delta.function?.name)
+                                    toolCalls[index].name = tc_delta.function.name;
+                                if (tc_delta.function?.arguments)
+                                    toolCalls[index].args += tc_delta.function.arguments;
+                                if (toolCalls[index].id && toolCalls[index].name && !toolCalls[index].started) {
+                                    contentBlockIndex++;
+                                    toolCalls[index].claudeIndex = contentBlockIndex;
+                                    toolCalls[index].started = true;
+                                    this.push(sendEvent('content_block_start', {
+                                        type: 'content_block_start',
+                                        index: contentBlockIndex,
+                                        content_block: { type: 'tool_use', id: toolCalls[index].id, name: toolCalls[index].name, input: {} }
+                                    }));
+                                }
+                                if (toolCalls[index].started && tc_delta.function?.arguments) {
+                                    this.push(sendEvent('content_block_delta', {
+                                        type: 'content_block_delta',
+                                        index: toolCalls[index].claudeIndex,
+                                        delta: { type: 'input_json_delta', partial_json: tc_delta.function.arguments }
+                                    }));
+                                }
                             }
                         }
                     }
-                }
-                catch {
-                    // Ignore JSON parse errors in SSE chunks
-                }
+                    catch {
+                        // Ignore JSON parse errors in SSE chunks
+                    }
+                });
             }
+            decoder.write(chunk);
+            if (!doneHandled)
+                callback();
+        },
+        flush(callback) {
+            decoder?.end();
             callback();
         }
     });

package/dist/utils/pi-browser-tools.d.ts

@@ -1,4 +1,3 @@
-import type { ToolDefinition } from '@earendil-works/pi-coding-agent';
 /**
  * 统一封装 ego-browser CLI：spawn 子进程 + 写入 Node 脚本 stdin，返回 cliLog 文本。
  * 每次调用独立进程，靠 useOrCreateTaskSpace 在同一 task space 复用 tab。
@@ -9,4 +8,3 @@ export declare function runEgoBrowser(scriptBody: string, opts?: {
 }): Promise<string>;
 /** 过滤 ego-browser 自身打到输出流的横幅行（如升级 notice），保留脚本 cliLog 的真实输出 */
 export declare function stripCliBanners(text: string): string;
-export declare const browserTools: ToolDefinition[];