@cc-monitoring/proxy-core 0.3.1 → 0.4.1

package/dist/utils/__tests__/sse-protocol.test.js

@@ -0,0 +1,115 @@
+import { createSSEDecoder, createEventDecoder, encodeSSEFrame } from '../sse-protocol.js';
+// 收集分发帧的辅助
+function collectFrames() {
+    const frames = [];
+    const decoder = createSSEDecoder((frame) => frames.push(frame));
+    return { frames, decoder };
+}
+describe('sse-protocol', () => {
+    // 样例 1：单帧含 event: + data:
+    it('1. 单帧含 event 和 data', () => {
+        const { frames, decoder } = collectFrames();
+        decoder.write('event: foo\ndata: {"a":1}\n\n');
+        expect(frames).toEqual([
+            { event: 'foo', data: ['{"a":1}'], id: undefined }
+        ]);
+    });
+    // 样例 2：仅 data:（event 为 undefined）
+    it('2. 仅 data，event 缺省为 undefined', () => {
+        const { frames, decoder } = collectFrames();
+        decoder.write('data: {"b":2}\n\n');
+        expect(frames).toEqual([
+            { event: undefined, data: ['{"b":2}'], id: undefined }
+        ]);
+    });
+    // 样例 3：一个 data 行切成 3 个 chunk（残帧缓冲）
+    it('3. data 行跨 3 个 chunk 恰好得到一帧', () => {
+        const { frames, decoder } = collectFrames();
+        decoder.write('dat');
+        expect(frames).toHaveLength(0);
+        decoder.write('a: {"x');
+        expect(frames).toHaveLength(0);
+        decoder.write('":1}\n\n');
+        expect(frames).toEqual([
+            { event: undefined, data: ['{"x":1}'], id: undefined }
+        ]);
+    });
+    // 样例 4：CRLF 行尾 + 空行分帧
+    it('4. CRLF 行尾与空行分帧', () => {
+        const { frames, decoder } = collectFrames();
+        decoder.write('event: ping\r\ndata: {"y":2}\r\n\r\n');
+        expect(frames).toEqual([
+            { event: 'ping', data: ['{"y":2}'], id: undefined }
+        ]);
+    });
+    // 样例 5：同一帧内多行 data:，数组保留两行，消费 join('\n') 正确
+    it('5. 多行 data 逐行保留且 join 正确', () => {
+        const { frames, decoder } = collectFrames();
+        decoder.write('data: line1\ndata: line2\n\n');
+        expect(frames).toHaveLength(1);
+        expect(frames[0].data).toEqual(['line1', 'line2']);
+        expect(frames[0].data.join('\n')).toBe('line1\nline2');
+    });
+    // 样例 6：注释行不产生帧
+    it('6. 注释行被忽略不产生帧', () => {
+        const { frames, decoder } = collectFrames();
+        decoder.write(': ping\n\n');
+        expect(frames).toHaveLength(0);
+        // 注释与真实帧混合时仅真实帧分发
+        decoder.write(': keep-alive\ndata: {"r":1}\n\n');
+        expect(frames).toEqual([
+            { event: undefined, data: ['{"r":1}'], id: undefined }
+        ]);
+    });
+    // 样例 7：data: [DONE] → onDone 触发、onEvent 不触发
+    it('7. [DONE] 仅触发 onDone', () => {
+        const events = [];
+        let doneCount = 0;
+        const decoder = createEventDecoder((e) => events.push(e), () => { doneCount++; });
+        decoder.write('data: [DONE]\n\n');
+        expect(events).toHaveLength(0);
+        expect(doneCount).toBe(1);
+    });
+    // 样例 8：非 JSON data → onEvent 不触发、不抛错
+    it('8. 非 JSON data 静默跳过', () => {
+        const events = [];
+        const decoder = createEventDecoder((e) => events.push(e));
+        expect(() => {
+            decoder.write('data: not-json\n\n');
+        }).not.toThrow();
+        expect(events).toHaveLength(0);
+    });
+    // 样例 9：末尾帧无尾空行，write 不触发，end() 后恰好一帧
+    it('9. end() 输出末尾无空行的残留帧', () => {
+        const { frames, decoder } = collectFrames();
+        decoder.write('data: {"z":9}');
+        expect(frames).toHaveLength(0);
+        decoder.end();
+        expect(frames).toEqual([
+            { event: undefined, data: ['{"z":9}'], id: undefined }
+        ]);
+    });
+    // 样例 10：id: 行保留在帧 id 字段
+    it('10. id 字段保留在帧上', () => {
+        const { frames, decoder } = collectFrames();
+        decoder.write('id: e1\ndata: {"i":1}\n\n');
+        expect(frames).toEqual([
+            { event: undefined, data: ['{"i":1}'], id: 'e1' }
+        ]);
+    });
+    // 样例 11：encodeSSEFrame → createSSEDecoder 往返一致（有/无 event）
+    it('11. encode/decode 往返帧内容一致（有 event 和无 event）', () => {
+        const withEvent = encodeSSEFrame({ event: 'foo', data: '{"x":1}' });
+        const d1 = collectFrames();
+        d1.decoder.write(withEvent);
+        expect(d1.frames).toEqual([
+            { event: 'foo', data: ['{"x":1}'], id: undefined }
+        ]);
+        const withoutEvent = encodeSSEFrame({ data: '{"x":2}' });
+        const d2 = collectFrames();
+        d2.decoder.write(withoutEvent);
+        expect(d2.frames).toEqual([
+            { event: undefined, data: ['{"x":2}'], id: undefined }
+        ]);
+    });
+});

package/dist/utils/__tests__/stats-aggregator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/__tests__/stats-aggregator.test.js

@@ -0,0 +1,114 @@
+import { mkdtempSync, rmSync } from 'fs';
+import { tmpdir } from 'os';
+import path from 'path';
+import { configureDbPath, initDatabase, closeDatabase, getDatabase } from '../db.js';
+import { aggregateStats, getStatsData, getTodayStats } from '../stats-aggregator.js';
+let counter = 0;
+// 直接往 requests 表插行，绕过 request-writer，聚焦聚合口径
+function insertRequest(opts) {
+    counter += 1;
+    getDatabase()
+        .prepare(`
+      INSERT INTO requests (
+        request_id, session_id, timestamp, method, path, status_code, response_time,
+        model, input_tokens, output_tokens, cache_read_tokens, cache_creation_tokens, closed_at
+      ) VALUES (?, ?, ?, 'POST', '/v1/messages', 200, 100, ?, ?, ?, ?, ?, ?)
+    `)
+        .run(`req_${counter}`, `sess_${counter}`, opts.timestamp, opts.model ?? null, opts.inputTokens ?? null, opts.outputTokens ?? null, opts.cacheReadTokens ?? null, opts.cacheCreationTokens ?? null, opts.closedAt ?? null);
+}
+function hourKeyOf(iso) {
+    const d = new Date(iso);
+    return `${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, '0')}-${String(d.getUTCDate()).padStart(2, '0')}-${String(d.getUTCHours()).padStart(2, '0')}`;
+}
+describe('stats-aggregator', () => {
+    let tempDir;
+    beforeEach(() => {
+        tempDir = mkdtempSync(path.join(tmpdir(), 'ccm-stats-'));
+        configureDbPath(path.join(tempDir, 'test.db'));
+        initDatabase();
+    });
+    afterEach(() => {
+        closeDatabase();
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    it('P0: requests 源行删除后重算，冻结的 hourly 快照同步消失', () => {
+        const ts = new Date(Date.now() - 2 * 3600000).toISOString();
+        const key = hourKeyOf(ts);
+        insertRequest({ timestamp: ts, inputTokens: 100, outputTokens: 20 });
+        aggregateStats();
+        let stats = getStatsData();
+        expect(stats.hourly[key]).toBeTruthy();
+        expect(stats.hourly[key].input_tokens).toBe(100);
+        expect(stats.hourly[key].request_count).toBe(1);
+        // 模拟 cleanOldRequestsDB 把源行删掉
+        getDatabase().prepare('DELETE FROM requests').run();
+        aggregateStats();
+        stats = getStatsData();
+        expect(stats.hourly[key]).toBeUndefined();
+    });
+    it('P2: closed_at 非空的中断行仍计入 aggregateStats 与 getTodayStats', () => {
+        const ts = new Date().toISOString();
+        const key = hourKeyOf(ts);
+        insertRequest({
+            timestamp: ts,
+            inputTokens: 100,
+            outputTokens: 50,
+            cacheReadTokens: 10,
+            cacheCreationTokens: 3,
+            closedAt: new Date().toISOString(),
+            model: 'claude-interrupted'
+        });
+        aggregateStats();
+        const entry = getStatsData().hourly[key];
+        expect(entry).toBeTruthy();
+        expect(entry.input_tokens).toBe(100);
+        expect(entry.output_tokens).toBe(50);
+        expect(entry.cache_read_tokens).toBe(10);
+        expect(entry.cache_creation_tokens).toBe(3);
+        expect(entry.request_count).toBe(1);
+        const since = new Date(Date.now() - 3600000).toISOString();
+        const today = getTodayStats(since);
+        expect(today.input_tokens).toBe(100);
+        expect(today.output_tokens).toBe(50);
+        expect(today.cache_read_tokens).toBe(10);
+        expect(today.request_count).toBe(1);
+        expect(today.models['claude-interrupted']).toBe(1);
+    });
+    it('P1: aggregateStats(1) 只保留 1 天窗口，无参仍为 30 天窗口', () => {
+        const nowIso = new Date().toISOString();
+        const oldIso = new Date(Date.now() - 2 * 86400000).toISOString();
+        const nowKey = hourKeyOf(nowIso);
+        const oldKey = hourKeyOf(oldIso);
+        insertRequest({ timestamp: nowIso, inputTokens: 1 });
+        insertRequest({ timestamp: oldIso, inputTokens: 2 });
+        aggregateStats(1);
+        let stats = getStatsData();
+        expect(stats.hourly[nowKey]).toBeTruthy();
+        expect(stats.hourly[oldKey]).toBeUndefined();
+        aggregateStats();
+        stats = getStatsData();
+        expect(stats.hourly[nowKey]).toBeTruthy();
+        expect(stats.hourly[oldKey]).toBeTruthy();
+    });
+    describe('P1b: aggregateStats 的 windowDays 分支（截断与回退）', () => {
+        // 31 天前落在 30 天窗口外、40 天窗口内：保留它意味着窗口被放宽到 40，
+        // 删除它才是「截断/回退为 30」；2 天前始终在窗口内。
+        it.each([
+            [40, '超过 30 截断为 30'],
+            [0, '0 回退默认 30'],
+            [-3, '负数回退默认 30'],
+            [1.5, '非整数回退默认 30']
+        ])('maxDays = %s（%s）：2 天前保留，31 天前删除', (maxDays, _desc) => {
+            const recentIso = new Date(Date.now() - 2 * 86400000).toISOString();
+            const oldIso = new Date(Date.now() - 31 * 86400000).toISOString();
+            const recentKey = hourKeyOf(recentIso);
+            const oldKey = hourKeyOf(oldIso);
+            insertRequest({ timestamp: recentIso, inputTokens: 2 });
+            insertRequest({ timestamp: oldIso, inputTokens: 31 });
+            aggregateStats(maxDays);
+            const stats = getStatsData();
+            expect(stats.hourly[recentKey]).toBeTruthy();
+            expect(stats.hourly[oldKey]).toBeUndefined();
+        });
+    });
+});

package/dist/utils/__tests__/vault.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/__tests__/{knowledge-store.test.js → vault.test.js}

@@ -1,7 +1,7 @@
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
-import { createKnowledgeStore } from '../knowledge-store.js';
+import { createVault } from '../vault.js';
 async function makeTmpDocs() {
     const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'kb-test-'));
     // 根 index.json
@@ -22,10 +22,10 @@ async function makeTmpDocs() {
     await fs.writeFile(path.join(dir, 'react-hooks', 'chunks', 'chunk-001.md'), '# 状态管理：useState\n\nuseState 用于组件状态。', 'utf8');
     return dir;
 }
-describe('knowledge-store', () => {
+describe('vault', () => {
     it('listTopics 解析根 index.json', async () => {
         const root = await makeTmpDocs();
-        const store = createKnowledgeStore(root);
+        const store = createVault(root);
         const topics = await store.listTopics();
         expect(topics).toEqual([
             { slug: 'react-hooks', title: 'React Hooks 参考', summary: 'React hooks 用法', tags: ['react', 'hooks'] },
@@ -33,12 +33,12 @@ describe('knowledge-store', () => {
     });
     it('listTopics 根 index.json 不存在返回空数组', async () => {
         const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'kb-empty-'));
-        const store = createKnowledgeStore(dir);
+        const store = createVault(dir);
         expect(await store.listTopics()).toEqual([]);
     });
     it('getTopic 返回元数据 + 片段清单', async () => {
         const root = await makeTmpDocs();
-        const store = createKnowledgeStore(root);
+        const store = createVault(root);
         const detail = await store.getTopic('react-hooks');
         expect(detail.title).toBe('React Hooks 参考');
         expect(detail.tags).toEqual(['react', 'hooks']);
@@ -46,25 +46,25 @@ describe('knowledge-store', () => {
     });
     it('readChunk 返回单片正文', async () => {
         const root = await makeTmpDocs();
-        const store = createKnowledgeStore(root);
+        const store = createVault(root);
         const text = await store.readChunk('react-hooks', 'chunk-001');
         expect(text).toContain('useState 用于组件状态');
     });
     it('readChunk 拒绝路径穿越', async () => {
         const root = await makeTmpDocs();
-        const store = createKnowledgeStore(root);
+        const store = createVault(root);
         await expect(store.readChunk('..', 'chunk-001')).rejects.toThrow();
         await expect(store.readChunk('react-hooks', '../chunk-001')).rejects.toThrow();
     });
     it('searchChunks 关键词命中返回清单', async () => {
         const root = await makeTmpDocs();
-        const store = createKnowledgeStore(root);
+        const store = createVault(root);
         const hits = await store.searchChunks('useState');
         expect(hits).toEqual([{ topic: 'react-hooks', chunkId: 'chunk-001', title: '状态管理：useState' }]);
     });
     it('upsertTopic 两次不同 slug → listTopics 返回 2 条，不覆盖', async () => {
         const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'kb-upsert-'));
-        const store = createKnowledgeStore(dir);
+        const store = createVault(dir);
         await store.upsertTopic({ slug: 'topic-a', title: 'A', summary: 'sa', tags: [] });
         await store.upsertTopic({ slug: 'topic-b', title: 'B', summary: 'sb', tags: ['x'] });
         const topics = await store.listTopics();
@@ -73,7 +73,7 @@ describe('knowledge-store', () => {
     });
     it('upsertTopic 同 slug 再调更新 summary，chunks 数组不变，listTopics 仍 1 条', async () => {
         const root = await makeTmpDocs();
-        const store = createKnowledgeStore(root);
+        const store = createVault(root);
         // 先登记一个额外 chunk ref
         await store.upsertChunkRef({ topic: 'react-hooks', chunkId: 'chunk-002', title: 'T2', summary: 'S2', tags: [] });
         await store.upsertTopic({
@@ -92,7 +92,7 @@ describe('knowledge-store', () => {
     });
     it('upsertChunkRef 同 topic 两次不同 chunk_id → getTopic 返回 2 chunks', async () => {
         const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'kb-chunk-'));
-        const store = createKnowledgeStore(dir);
+        const store = createVault(dir);
         await store.upsertTopic({ slug: 't1', title: 'T1', summary: 's', tags: [] });
         await store.upsertChunkRef({ topic: 't1', chunkId: 'chunk-001', title: 'c1', summary: 's1', tags: [] });
         await store.upsertChunkRef({ topic: 't1', chunkId: 'chunk-002', title: 'c2', summary: 's2', tags: [] });
@@ -102,12 +102,12 @@ describe('knowledge-store', () => {
     });
     it('upsertChunkRef topic 不存在 → rejects', async () => {
         const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'kb-no-topic-'));
-        const store = createKnowledgeStore(dir);
+        const store = createVault(dir);
         await expect(store.upsertChunkRef({ topic: 'ghost', chunkId: 'chunk-001', title: 'c', summary: 's', tags: [] })).rejects.toThrow(/topic not found: ghost/);
     });
     it('tags: upsertChunkRef 落盘 tags，重复调用覆写 tags', async () => {
         const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'kb-tags-'));
-        const store = createKnowledgeStore(dir);
+        const store = createVault(dir);
         await store.upsertTopic({ slug: 't1', title: 'T1', summary: 's', tags: [] });
         await store.upsertChunkRef({ topic: 't1', chunkId: 'chunk-001', title: 'c1', summary: 's1', tags: ['redis', '缓存'] });
         // 落盘验证
@@ -128,7 +128,7 @@ describe('knowledge-store', () => {
             slug: 'old', title: 'Old', summary: 'so', tags: [],
             chunks: [{ id: 'chunk-001', title: 'oc', summary: 'os' }],
         }), 'utf8');
-        const store = createKnowledgeStore(dir);
+        const store = createVault(dir);
         const detail = await store.getTopic('old');
         expect(detail.chunks[0].tags).toEqual([]);
     });
@@ -144,7 +144,7 @@ describe('knowledge-store', () => {
         }), 'utf8');
         await fs.writeFile(path.join(dir, 'redis', 'chunks', 'chunk-001.md'), '# 缓存详解\n\n正文讲缓存。', 'utf8');
         await fs.writeFile(path.join(dir, 'redis', 'chunks', 'chunk-002.md'), '# 故障转移\n\n正文讲哨兵。', 'utf8');
-        const store = createKnowledgeStore(dir);
+        const store = createVault(dir);
         // body
         expect(await store.searchChunks('缓存')).toEqual([
             { topic: 'redis', chunkId: 'chunk-001', title: '缓存详解' },
@@ -177,7 +177,7 @@ describe('knowledge-store', () => {
             chunks: [{ id: 'chunk-001', title: '缓存详解', summary: '缓存摘要' }],
         }), 'utf8');
         await fs.writeFile(path.join(dir, 'redis', 'chunks', 'chunk-001.md'), '# 缓存详解\n\n正文讲缓存。', 'utf8');
-        const store = createKnowledgeStore(dir);
+        const store = createVault(dir);
         expect(await store.searchChunks('缓存')).toEqual([
             { topic: 'redis', chunkId: 'chunk-001', title: '缓存详解' },
         ]);

package/dist/utils/abort-signals.d.ts

@@ -0,0 +1,13 @@
+import type { IncomingMessage } from 'node:http';
+/**
+ * 监听 Node IncomingMessage，客户端在响应结束前中止连接时 abort 返回的 signal。
+ * close 时以 req.aborted 区分：true=客户端侧中止；正常响应结束后的 close 为 false。
+ */
+export declare function createClientAbortSignal(req: IncomingMessage): AbortSignal;
+/** 合成：固定超时 + 外部取消，任意触发即 abort */
+export declare function createTimeoutSignal(ms: number, external?: AbortSignal): AbortSignal;
+/**
+ * 把 source signal 接到 abortFn：source 已 abort 立即调，否则将来 abort 时调一次。
+ * abortFn 异步拒绝不外泄（由调用方保证幂等）。
+ */
+export declare function bindAbort(source: AbortSignal, abortFn: () => Promise<void>): void;

package/dist/utils/abort-signals.js

@@ -0,0 +1,33 @@
+/**
+ * 监听 Node IncomingMessage，客户端在响应结束前中止连接时 abort 返回的 signal。
+ * close 时以 req.aborted 区分：true=客户端侧中止；正常响应结束后的 close 为 false。
+ */
+export function createClientAbortSignal(req) {
+    const controller = new AbortController();
+    // 传入时已 aborted（或已 close 过）：立即 abort，不再依赖 close 事件
+    if (req.aborted) {
+        controller.abort();
+        return controller.signal;
+    }
+    req.on('close', () => {
+        if (req.aborted)
+            controller.abort();
+    });
+    return controller.signal;
+}
+/** 合成：固定超时 + 外部取消，任意触发即 abort */
+export function createTimeoutSignal(ms, external) {
+    return AbortSignal.any([AbortSignal.timeout(ms), ...(external ? [external] : [])]);
+}
+/**
+ * 把 source signal 接到 abortFn：source 已 abort 立即调，否则将来 abort 时调一次。
+ * abortFn 异步拒绝不外泄（由调用方保证幂等）。
+ */
+export function bindAbort(source, abortFn) {
+    if (source.aborted) {
+        abortFn().catch(() => { });
+    }
+    else {
+        source.addEventListener('abort', () => abortFn().catch(() => { }), { once: true });
+    }
+}

package/dist/utils/db-maintenance.d.ts

@@ -0,0 +1,8 @@
+import Database from 'better-sqlite3';
+export interface VacuumResult {
+    autoVacuumBefore: number;
+    pagesBefore: number;
+    pagesAfter: number;
+    pageSize: number;
+}
+export declare function vacuumDatabase(db: Database.Database): VacuumResult;

package/dist/utils/db-maintenance.js

@@ -0,0 +1,18 @@
+// 回收空闲页。auto_vacuum 不是 INCREMENTAL 时，pragma 修改只对新建库生效，
+// 已有库必须先 VACUUM 全库重写才能让 pragma 生效；之后例行调用走
+// incremental_vacuum，只还页不重写，代价低。
+export function vacuumDatabase(db) {
+    const autoVacuumBefore = db.pragma('auto_vacuum', { simple: true }) ?? 0;
+    const pagesBefore = db.pragma('page_count', { simple: true });
+    const pageSize = db.pragma('page_size', { simple: true });
+    if (autoVacuumBefore !== 2) {
+        db.pragma('auto_vacuum = INCREMENTAL');
+        // 首次：全库重写，pragma 在重写后生效
+        db.exec('VACUUM');
+    }
+    else {
+        db.pragma('incremental_vacuum');
+    }
+    const pagesAfter = db.pragma('page_count', { simple: true });
+    return { autoVacuumBefore, pagesBefore, pagesAfter, pageSize };
+}

package/dist/utils/db.d.ts

@@ -10,5 +10,7 @@ export declare function applySchemaV7(db: Database.Database): void;
 export declare function applySchemaV8(db: Database.Database): void;
 export declare function applySchemaV9(db: Database.Database): void;
 export declare function applySchemaV10(db: Database.Database): void;
+export declare function applySchemaV11(db: Database.Database): void;
+export declare function applySchemaV12(db: Database.Database): void;
 export declare function closeDatabase(): void;
 export declare function getDatabase(): Database.Database;

package/dist/utils/db.js

@@ -72,6 +72,14 @@ export function initDatabase() {
         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();
+    }
+    if (currentVersion < 12) {
+        applySchemaV12(db);
+        db.prepare('INSERT OR REPLACE INTO schema_version (version) VALUES (12)').run();
+    }
     return db;
 }
 export function applySchemaV2(db) {
@@ -280,6 +288,84 @@ export function applySchemaV10(db) {
     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 applySchemaV12(db) {
+    // response_events 历史上存在 (request_id, session_id, event_index) 三元组重复行
+    // （request_id 计数器重启复用所致）和 requests 表无对应行的孤儿事件；清理后加
+    // 唯一索引硬守。生产库约 800 万行：先一次性把待删行号收集进临时表，再按主键
+    // 分批删除（每批 5000 行、独立事务），避免单个巨型事务长时间锁库。
+    //
+    // 注意：不能用 `GROUP BY ... HAVING COUNT(*) > 1 AND id != MIN(id)` 直接选行——
+    // SQLite 裸列 id 在该计划下取 MIN(id) 所在行，HAVING 恒假，实测删除 0 行。
+    const batchSize = 5000;
+    db.exec('DROP TABLE IF EXISTS temp.ids_to_purge');
+    db.exec('CREATE TEMP TABLE ids_to_purge (id INTEGER PRIMARY KEY)');
+    // a) 去重：每组 (request_id, session_id, event_index) 保留 MIN(id)，其余入临时表
+    db.prepare(`
+    INSERT INTO ids_to_purge
+    SELECT id FROM response_events
+    WHERE id NOT IN (
+      SELECT MIN(id) FROM response_events
+      GROUP BY request_id, session_id, event_index
+    )
+  `).run();
+    purgeResponseEventsBatched(db, batchSize);
+    // b) 孤儿事件：requests 表中无对应 request_id
+    db.prepare(`
+    INSERT INTO ids_to_purge
+    SELECT re.id FROM response_events re
+    WHERE NOT EXISTS (
+      SELECT 1 FROM requests r WHERE r.request_id = re.request_id
+    )
+  `).run();
+    purgeResponseEventsBatched(db, batchSize);
+    db.exec('DROP TABLE IF EXISTS temp.ids_to_purge');
+    // c) 唯一索引（IF NOT EXISTS，幂等）
+    db.exec(`
+    CREATE UNIQUE INDEX IF NOT EXISTS uq_response_events
+      ON response_events(request_id, session_id, event_index)
+  `);
+}
+// 按临时表 ids_to_purge 收集的行号分批删除 response_events；每批同时剪除临时表中
+// 已处理的行号，整批包在一个事务里，循环直到没有可删行。
+function purgeResponseEventsBatched(db, batchSize) {
+    const deleteEvents = db.prepare(`
+    DELETE FROM response_events
+    WHERE id IN (SELECT id FROM ids_to_purge ORDER BY id LIMIT ?)
+  `);
+    const pruneTemp = db.prepare(`
+    DELETE FROM ids_to_purge
+    WHERE id IN (SELECT id FROM ids_to_purge ORDER BY id LIMIT ?)
+  `);
+    const runBatch = db.transaction(() => {
+        const info = deleteEvents.run(batchSize);
+        pruneTemp.run(batchSize);
+        return info.changes;
+    });
+    while (true) {
+        if (runBatch() === 0)
+            break;
+    }
+}
 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 会被原地追加）