@cc-monitoring/proxy-core 0.3.1 → 0.4.1

package/dist/utils/__tests__/db-migration.test.js

@@ -1,5 +1,5 @@
 import Database from 'better-sqlite3';
-import { applySchemaV2, applySchemaV3, applySchemaV9 } from '../db.js';
+import { applySchemaV2, applySchemaV3, applySchemaV9, applySchemaV12 } from '../db.js';
 describe('Schema Migration V2', () => {
     let db;
     beforeEach(() => {
@@ -100,3 +100,81 @@ describe('Schema Migration V2', () => {
         expect(authStyleCols.length).toBe(1);
     });
 });
+describe('Schema Migration V12', () => {
+    let db;
+    beforeEach(() => {
+        db = new Database(':memory:');
+        // 最小化构造 V12 所需的两张表（与生产列名一致）
+        db.exec(`
+      CREATE TABLE requests (request_id TEXT PRIMARY KEY)
+    `);
+        db.exec(`
+      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
+      )
+    `);
+        db.exec(`
+      CREATE INDEX idx_response_events_request
+      ON response_events(request_id, session_id, event_index)
+    `);
+    });
+    afterEach(() => {
+        db.close();
+    });
+    test('dedups repeated triples keeping MIN(id), deletes orphan events, creates unique index', () => {
+        db.prepare('INSERT INTO requests (request_id) VALUES (?)').run('req-ok');
+        const ins = db.prepare('INSERT INTO response_events (request_id, session_id, event_index, event_data) VALUES (?, ?, ?, ?)');
+        // 三元组 (req-ok, sess-a, 0) 重复 3 行 → id 1,2,3
+        ins.run('req-ok', 'sess-a', 0, 'a1');
+        ins.run('req-ok', 'sess-a', 0, 'a2');
+        ins.run('req-ok', 'sess-a', 0, 'a3');
+        // 三元组 (req-ok, sess-a, 1) 重复 2 行 → id 4,5
+        ins.run('req-ok', 'sess-a', 1, 'b1');
+        ins.run('req-ok', 'sess-a', 1, 'b2');
+        // 不重复组 → id 6
+        ins.run('req-ok', 'sess-a', 2, 'c');
+        // 孤儿事件（requests 无 req-gone）→ id 7,8
+        ins.run('req-gone', 'sess-a', 0, 'o1');
+        ins.run('req-gone', 'sess-a', 0, 'o2');
+        applySchemaV12(db);
+        // 不存在任何重复三元组
+        const dupGroups = db.prepare(`
+      SELECT COUNT(*) AS c FROM (
+        SELECT 1 FROM response_events
+        GROUP BY request_id, session_id, event_index
+        HAVING COUNT(*) > 1
+      )
+    `).get();
+        expect(dupGroups.c).toBe(0);
+        // 只剩三元组 A、B、c 各一行，孤儿删光
+        expect(db.prepare('SELECT COUNT(*) AS c FROM response_events').get().c).toBe(3);
+        expect(db.prepare("SELECT COUNT(*) AS c FROM response_events WHERE request_id = 'req-gone'").get().c).toBe(0);
+        // 每组保留 MIN(id)
+        const ids = db.prepare('SELECT id FROM response_events ORDER BY id').all()
+            .map(r => r.id);
+        expect(ids).toEqual([1, 4, 6]);
+        // 唯一索引存在
+        const indexes = db.prepare('PRAGMA index_list(response_events)').all();
+        const uq = indexes.find(i => i.name === 'uq_response_events');
+        expect(uq).toBeTruthy();
+        expect(uq?.unique).toBe(1);
+        // 唯一约束硬守：再插同三元组必须报错
+        expect(() => ins.run('req-ok', 'sess-a', 0, 'dup')).toThrow();
+    });
+    test('applySchemaV12 is idempotent', () => {
+        db.prepare('INSERT INTO requests (request_id) VALUES (?)').run('req-ok');
+        db.prepare('INSERT INTO response_events (request_id, session_id, event_index, event_data) VALUES (?, ?, ?, ?)').run('req-ok', 'sess-a', 0, 'a');
+        applySchemaV12(db);
+        // 再跑一次不报错，行数与唯一索引状态保持
+        expect(() => applySchemaV12(db)).not.toThrow();
+        expect(db.prepare('SELECT COUNT(*) AS c FROM response_events').get().c).toBe(1);
+        const indexes = db.prepare('PRAGMA index_list(response_events)').all();
+        const uqIndexes = indexes.filter(i => i.name === 'uq_response_events');
+        expect(uqIndexes).toHaveLength(1);
+    });
+});

package/dist/utils/__tests__/inject-loop.test.js

@@ -4,7 +4,7 @@ jest.mock('../../tools/index.js', () => ({
         ? { name: '__test_tool', enabled: true, exec: (input) => `executed: ${input?.echo ?? ''}` }
         : undefined
 }));
-import { parseSSEText, parseUpstreamEvents, findInjectedCall, runInjectLoop } from '../inject-loop.js';
+import { parseUpstreamEvents, findInjectedCall } from '../inject-loop.js';
 const TOOL_NAME = '__test_tool';
 // 构造一段 text end_turn 响应事件
 function textResponse(text) {
@@ -32,13 +32,6 @@ function toolResponse(echo) {
     ];
 }
 describe('inject-loop', () => {
-    describe('parseSSEText', () => {
-        it('should collect data: line JSON, skip [DONE] and non-json', () => {
-            const raw = 'event: message_stop\ndata: {"type":"message_stop"}\n\ndata: [DONE]\n\ndata: notjson\n\n';
-            const events = parseSSEText(raw);
-            expect(events).toEqual([{ type: 'message_stop' }]);
-        });
-    });
     describe('parseUpstreamEvents', () => {
         it('should rebuild text block and stop_reason', () => {
             const p = parseUpstreamEvents(textResponse('hello world'));
@@ -64,49 +57,4 @@ describe('inject-loop', () => {
             expect(findInjectedCall(p)).toBeUndefined();
         });
     });
-    describe('runInjectLoop', () => {
-        it('should execute tool, append messages, and return final text on end_turn', async () => {
-            const body = { messages: [{ role: 'user', content: 'do __PROBE__' }] };
-            let call = 0;
-            const result = await runInjectLoop({
-                events: toolResponse('echoed'),
-                body,
-                callUpstream: async () => {
-                    call++;
-                    // 第二次调用返回最终文本
-                    return textResponse('final answer');
-                }
-            });
-            expect(result.text).toBe('final answer');
-            expect(result.iterations).toBe(1);
-            expect(result.stoppedByLimit).toBe(false);
-            expect(call).toBe(1);
-            // messages 被追加了 assistant(tool_use) + user(tool_result)
-            expect(body.messages.length).toBe(3);
-            expect(body.messages[1]).toMatchObject({ role: 'assistant' });
-            expect(body.messages[2].content[0]).toMatchObject({ type: 'tool_result', tool_use_id: 'tu_1' });
-        });
-        it('should return immediately if first response is not an injected tool call', async () => {
-            const body = { messages: [] };
-            const result = await runInjectLoop({
-                events: textResponse('direct'),
-                body,
-                callUpstream: async () => textResponse('should not be called')
-            });
-            expect(result.text).toBe('direct');
-            expect(result.iterations).toBe(0);
-            expect(body.messages.length).toBe(0);
-        });
-        it('should stop at maxIterations when model keeps calling the tool (死循环护栏)', async () => {
-            const body = { messages: [] };
-            const result = await runInjectLoop({
-                events: toolResponse('loop'),
-                body,
-                callUpstream: async () => toolResponse('loop again'), // 永远调注入 tool
-                maxIterations: 2
-            });
-            expect(result.stoppedByLimit).toBe(true);
-            expect(result.iterations).toBe(2);
-        });
-    });
 });

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

@@ -0,0 +1,82 @@
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { configureDbPath, initDatabase, closeDatabase, getDatabase } from '../db.js';
+import { insertRunning, markCompleted, markFailed, markAborted, recoverCrashedTasks, } from '../learn-tasks-db.js';
+describe('learn-tasks-db', () => {
+    let tempDir;
+    beforeEach(() => {
+        tempDir = mkdtempSync(path.join(tmpdir(), 'ccm-lt-'));
+        configureDbPath(path.join(tempDir, 'test.db'));
+        initDatabase();
+    });
+    afterEach(() => {
+        closeDatabase();
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    function getRow(taskId) {
+        return getDatabase().prepare('SELECT * FROM learn_tasks WHERE task_id = ?').get(taskId);
+    }
+    test('insertRunning 落 running 行且字段正确', () => {
+        const { taskId } = insertRunning(getDatabase(), {
+            slug: 'my-slug',
+            sourceType: 'url',
+            label: 'https://x.com/',
+        });
+        const row = getRow(taskId);
+        expect(row).toMatchObject({
+            task_id: taskId,
+            slug: 'my-slug',
+            source_type: 'url',
+            label: 'https://x.com/',
+            status: 'running',
+        });
+        expect(row.error).toBeNull();
+        expect(row.ended_at).toBeNull();
+        expect(typeof row.created_at).toBe('string');
+    });
+    test('不同 slug 可同时 running；同 slug 第二次 insertRunning 撞 partial unique 约束', () => {
+        const db = getDatabase();
+        insertRunning(db, { slug: 'slug-a', sourceType: 'url', label: 'a' });
+        expect(() => insertRunning(db, { slug: 'slug-b', sourceType: 'file', label: 'b' })).not.toThrow();
+        expect(() => insertRunning(db, { slug: 'slug-a', sourceType: 'file', label: 'a2' })).toThrow(/UNIQUE constraint failed/);
+    });
+    const terminalCases = [
+        ['completed', (db, taskId) => markCompleted(db, taskId)],
+        ['failed', (db, taskId) => markFailed(db, taskId, 'boom')],
+        ['aborted', (db, taskId) => markAborted(db, taskId)],
+    ];
+    test.each(terminalCases)('终态 %s：写 ended_at 后同 slug 可再次 insertRunning', (status, transition) => {
+        const db = getDatabase();
+        const { taskId } = insertRunning(db, { slug: 'slug-x', sourceType: 'url', label: 'a' });
+        transition(db, taskId);
+        const row = getRow(taskId);
+        expect(row.status).toBe(status);
+        expect(typeof row.ended_at).toBe('string');
+        const again = insertRunning(db, { slug: 'slug-x', sourceType: 'url', label: 'a2' });
+        expect(getRow(again.taskId).status).toBe('running');
+    });
+    test('markFailed 写入 error 与 ended_at', () => {
+        const db = getDatabase();
+        const { taskId } = insertRunning(db, { slug: 'f', sourceType: 'file', label: 'f.md' });
+        markFailed(db, taskId, 'something broke');
+        const row = getRow(taskId);
+        expect(row.status).toBe('failed');
+        expect(row.error).toBe('something broke');
+        expect(typeof row.ended_at).toBe('string');
+    });
+    test('recoverCrashedTasks：running → crashed 且返回计数；非 running 行不动；recover 后同 slug 可再跑', () => {
+        const db = getDatabase();
+        const r1 = insertRunning(db, { slug: 's1', sourceType: 'url', label: 'a' });
+        const r2 = insertRunning(db, { slug: 's2', sourceType: 'url', label: 'b' });
+        markCompleted(db, r2.taskId);
+        expect(recoverCrashedTasks(db)).toBe(1);
+        const crashed = getRow(r1.taskId);
+        expect(crashed.status).toBe('crashed');
+        expect(typeof crashed.ended_at).toBe('string');
+        expect(getRow(r2.taskId).status).toBe('completed');
+        // crashed 释放 partial unique 守卫，同 slug 可再跑
+        const again = insertRunning(db, { slug: 's1', sourceType: 'url', label: 'c' });
+        expect(getRow(again.taskId).status).toBe('running');
+    });
+});

package/dist/utils/__tests__/openai-converter.test.js

@@ -0,0 +1,25 @@
+import { createStreamTransformer } from '../openai-converter.js';
+describe('createStreamTransformer', () => {
+    it('收到 [DONE] 后正常关闭且不产生 error（不 double callback）', (done) => {
+        const stream = createStreamTransformer('test-model');
+        let output = '';
+        let errored = null;
+        let closed = false;
+        stream.on('data', (chunk) => { output += chunk.toString(); });
+        stream.on('error', (err) => { errored = err; });
+        stream.on('close', () => { closed = true; });
+        // 正常帧：含 delta.content
+        stream.write('data: {"choices":[{"delta":{"content":"hi"}}]}\n\n');
+        // finish_reason 帧 + [DONE] 放同一 chunk
+        stream.write('data: {"choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}\n\ndata: [DONE]\n\n');
+        setTimeout(() => {
+            // double callback 若将来被 Node 升级为抛错，会在这里以 error/未关闭暴露
+            expect(errored).toBeNull();
+            expect(closed).toBe(true);
+            // 收尾帧中存在 message_delta（携带 stop_reason）
+            expect(output).toContain('message_delta');
+            expect(output).toContain('stop_reason');
+            done();
+        }, 100);
+    });
+});

package/dist/utils/__tests__/pi-crawl-tools.test.js

@@ -270,14 +270,25 @@ describe('CrawlGuard signal 透传', () => {
     it('crawl_open/crawl_visit 的 execute 把 signal 透传给 guard.navigate', async () => {
         const nav = jest.fn(async () => ({ title: 'A', text: 'A text', links: ['https://pi.dev/b'] }));
         const guard = new CrawlGuard({ entryUrl: 'https://pi.dev/', docsDir: docsDir(), slug: 'pi', navigate: nav });
-        const tools = createCrawlTools(guard);
-        const byName = Object.fromEntries(tools.map((t) => [t.name, t]));
         const signal = new AbortController().signal;
+        const tools = createCrawlTools(guard, signal);
+        const byName = Object.fromEntries(tools.map((t) => [t.name, t]));
         await byName.crawl_open.execute('id-1', {}, signal, undefined, {});
         expect(nav).toHaveBeenNthCalledWith(1, 'https://pi.dev/', signal);
         await byName.crawl_visit.execute('id-2', { url: 'https://pi.dev/b' }, signal, undefined, {});
         expect(nav).toHaveBeenNthCalledWith(2, 'https://pi.dev/b', signal);
     });
+    it('createCrawlTools 传入已 abort 的外部 signal：crawl_open 把中止 signal 透传给 runEgoBrowser', async () => {
+        mockRunEgoBrowser.mockResolvedValue(JSON.stringify({ title: 'A', text: 'A text', links: [] }));
+        const guard = new CrawlGuard({ entryUrl: 'https://pi.dev/', docsDir: docsDir(), slug: 'pi' });
+        const external = new AbortController();
+        external.abort();
+        const tools = createCrawlTools(guard, external.signal);
+        const byName = Object.fromEntries(tools.map((t) => [t.name, t]));
+        // 未传 SDK tool signal 时直接使用外部 signal 原引用
+        await byName.crawl_open.execute('id-3', {}, undefined, undefined, {});
+        expect(mockRunEgoBrowser).toHaveBeenCalledWith(expect.any(String), { timeoutMs: 60000, signal: external.signal });
+    });
 });
 describe('createCrawlTools', () => {
     function makeGuard() {
@@ -292,13 +303,13 @@ describe('createCrawlTools', () => {
         });
     }
     it('提供 crawl_open/crawl_visit/save_source/crawl_finish 四个工具', () => {
-        const tools = createCrawlTools(makeGuard());
+        const tools = createCrawlTools(makeGuard(), new AbortController().signal);
         expect(tools.map((t) => t.name)).toEqual(['crawl_open', 'crawl_visit', 'save_source', 'crawl_finish']);
     });
     it('工具错误以可读文本返回（不抛异常）', async () => {
         mockRunEgoBrowser.mockResolvedValue('closed');
         const guard = makeGuard();
-        const tools = createCrawlTools(guard);
+        const tools = createCrawlTools(guard, new AbortController().signal);
         const byName = Object.fromEntries(tools.map((t) => [t.name, t]));
         const textOf = (res) => res.content.map((c) => c.text ?? '').join('\n');
         // execute 签名 5 参（id/params/signal/onUpdate/ctx），测试只需前 2 个

package/dist/utils/__tests__/pi-dedup-reconcile.test.js

@@ -5,6 +5,8 @@ import path from 'path';
 import { runJsonPrompt } from '../pi-runtime.js';
 import { reconcileTopics, readAllTopics, readTopicDetail, mintSlug } from '../pi-dedup.js';
 const mockJson = runJsonPrompt;
+// 本文件用例只验证裁定/降级逻辑，signal 不触发，复用一个常驻 signal
+const signal = new AbortController().signal;
 let tmp;
 beforeEach(async () => {
     tmp = await mkdtemp(path.join(os.tmpdir(), 'pi-dedup-'));
@@ -15,7 +17,7 @@ test('预筛命中 → 调 LLM，match=true 透传 targetSlug/mergedTitle/itemsT
         confidence: 0.62, itemsToAdd: [{ id: 'x', title: 'X', oneLine: 'x' }] });
     const r = await reconcileTopics({ port: 1, docsDir: tmp, wantItems: true,
         candidate: { slug: 'new', title: 'React Hooks', tags: [] },
-        targets: [{ slug: 'a', title: 'React Hooks', summary: '', tags: [], chunks: [] }] });
+        targets: [{ slug: 'a', title: 'React Hooks', summary: '', tags: [], chunks: [] }], signal });
     expect(r.match).toBe(true);
     expect(r.targetSlug).toBe('a');
     expect(r.itemsToAdd).toHaveLength(1);
@@ -24,7 +26,7 @@ test('LLM 抛错（坏 JSON）→ 安全返回 match=false', async () => {
     mockJson.mockRejectedValue(new Error('no json object in response'));
     await expect(reconcileTopics({ port: 1, docsDir: tmp, wantItems: false,
         candidate: { slug: 'new', title: 'T', tags: [] },
-        targets: [{ slug: 'a', title: 'T', summary: '', tags: [], chunks: [] }] }))
+        targets: [{ slug: 'a', title: 'T', summary: '', tags: [], chunks: [] }], signal }))
         .resolves.toMatchObject({ match: false });
 });
 test('正载荷回显候选自身 slug（未提供的目标）→ match=false', async () => {
@@ -32,26 +34,26 @@ test('正载荷回显候选自身 slug（未提供的目标）→ match=false',
         mergedSummary: 's', itemsToAdd: [] });
     const r = await reconcileTopics({ port: 1, docsDir: tmp, wantItems: true,
         candidate: { slug: 'new', title: 'React Hooks', tags: [] },
-        targets: [{ slug: 'a', title: 'React Hooks', summary: '', tags: [], chunks: [] }] });
+        targets: [{ slug: 'a', title: 'React Hooks', summary: '', tags: [], chunks: [] }], signal });
     expect(r).toEqual({ match: false });
 });
 test('正载荷缺 mergedTitle → match=false', async () => {
     mockJson.mockResolvedValue({ match: true, targetSlug: 'a', mergedSummary: 's', itemsToAdd: [] });
     const r = await reconcileTopics({ port: 1, docsDir: tmp, wantItems: true,
         candidate: { slug: 'new', title: 'React Hooks', tags: [] },
-        targets: [{ slug: 'a', title: 'React Hooks', summary: '', tags: [], chunks: [] }] });
+        targets: [{ slug: 'a', title: 'React Hooks', summary: '', tags: [], chunks: [] }], signal });
     expect(r).toEqual({ match: false });
 });
 test('空目标 → 不调 LLM，match=false', async () => {
     const r = await reconcileTopics({ port: 1, docsDir: tmp, wantItems: false,
-        candidate: { slug: 'new', title: 'zzz', tags: [] }, targets: [] });
+        candidate: { slug: 'new', title: 'zzz', tags: [] }, targets: [], signal });
     expect(r).toEqual({ match: false });
     expect(mockJson).not.toHaveBeenCalled();
 });
 test('预筛空且目标>20 → 不调 LLM，match=false', async () => {
     const targets = Array.from({ length: 21 }, (_, i) => ({ slug: `s${i}`, title: `Distinct ${i}`, summary: '', tags: [], chunks: [] }));
     const r = await reconcileTopics({ port: 1, docsDir: tmp, wantItems: false,
-        candidate: { slug: 'new', title: 'zzzz-noise', tags: [] }, targets });
+        candidate: { slug: 'new', title: 'zzzz-noise', tags: [] }, targets, signal });
     expect(r.match).toBe(false);
     expect(mockJson).not.toHaveBeenCalled();
 });
@@ -67,15 +69,15 @@ test('readAllTopics: 空/缺失目录返回 []', async () => {
 describe('mintSlug', () => {
     test('LLM 返回合法且空闲的 slug → 直接使用', async () => {
         mockJson.mockResolvedValue({ slug: 'react-hooks' });
-        await expect(mintSlug({ port: 1, title: 'React Hooks', existing: [] })).resolves.toBe('react-hooks');
+        await expect(mintSlug({ port: 1, title: 'React Hooks', existing: [], signal })).resolves.toBe('react-hooks');
     });
     test('LLM 返回非法 slug → 降级 slugFromLabel(title)', async () => {
         mockJson.mockResolvedValue({ slug: 'Bad Slug!' });
-        await expect(mintSlug({ port: 1, title: 'Hello World', existing: [] })).resolves.toBe('hello-world');
+        await expect(mintSlug({ port: 1, title: 'Hello World', existing: [], signal })).resolves.toBe('hello-world');
     });
     test('LLM slug 与 slugFromLabel(title) 均被占 → 追加 -2', async () => {
         mockJson.mockResolvedValue({ slug: 'my-topic' });
-        await expect(mintSlug({ port: 1, title: 'My Topic', existing: ['my-topic'] }))
+        await expect(mintSlug({ port: 1, title: 'My Topic', existing: ['my-topic'], signal }))
             .resolves.toBe('my-topic-2');
     });
 });

package/dist/utils/__tests__/pi-events.test.d.ts

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

package/dist/utils/__tests__/pi-events.test.js

@@ -0,0 +1,172 @@
+import { createPiEventEmitter, isAssistantMessage, extractAssistantDelta, extractToolResultText, } from '../pi-events.js';
+// 合成原始 pi SDK 事件的小构造器
+const messageStart = (role) => ({ type: 'message_start', message: { role } });
+const messageEnd = (role) => ({ type: 'message_end', message: { role } });
+const update = (ae) => ({ type: 'message_update', assistantMessageEvent: ae });
+const textDelta = (delta) => update({ type: 'text_delta', delta });
+const thinkingDelta = (delta) => update({ type: 'thinking_delta', delta });
+const toolStart = (over = {}) => ({
+    type: 'tool_execution_start',
+    toolCallId: 'call-1',
+    toolName: 'read_source',
+    args: { topic: 'x' },
+    ...over,
+});
+const toolEnd = (over = {}) => ({
+    type: 'tool_execution_end',
+    toolCallId: 'call-1',
+    toolName: 'read_source',
+    result: { content: [{ type: 'text', text: 'ok' }] },
+    ...over,
+});
+function collect() {
+    const events = [];
+    const { write } = createPiEventEmitter((ev) => events.push(ev));
+    return { events, write };
+}
+describe('pi-events 纯 helper', () => {
+    test('isAssistantMessage：只认 assistant 角色', () => {
+        expect(isAssistantMessage(messageStart('assistant'))).toBe(true);
+        expect(isAssistantMessage(messageEnd('assistant'))).toBe(true);
+        expect(isAssistantMessage(messageStart('user'))).toBe(false);
+        expect(isAssistantMessage(messageEnd('toolResult'))).toBe(false);
+        expect(isAssistantMessage({ message: {} })).toBe(false);
+        expect(isAssistantMessage(null)).toBe(false);
+    });
+    test('extractAssistantDelta：text / thinking 解包，其余 null', () => {
+        expect(extractAssistantDelta(textDelta('abc'))).toEqual({ kind: 'text', delta: 'abc' });
+        expect(extractAssistantDelta(thinkingDelta('嗯'))).toEqual({ kind: 'thinking', delta: '嗯' });
+        // 非 string delta
+        expect(extractAssistantDelta(textDelta(123))).toBeNull();
+        expect(extractAssistantDelta(thinkingDelta(null))).toBeNull();
+        // 其他 ae.type
+        expect(extractAssistantDelta(update({ type: 'text_start', delta: 'x' }))).toBeNull();
+        expect(extractAssistantDelta(update({ type: 'thinking_end' }))).toBeNull();
+        expect(extractAssistantDelta(update(undefined))).toBeNull();
+        // 非 message_update
+        expect(extractAssistantDelta({ type: 'other' })).toBeNull();
+        expect(extractAssistantDelta(null)).toBeNull();
+    });
+    test('extractToolResultText：多段 text 拼接，无 content 为空串', () => {
+        expect(extractToolResultText({ content: [
+                { type: 'text', text: 'a' },
+                { type: 'text', text: 'b' },
+            ] })).toBe('a\nb');
+        // 非数组 / 缺失
+        expect(extractToolResultText({})).toBe('');
+        expect(extractToolResultText(null)).toBe('');
+        expect(extractToolResultText({ content: 'nope' })).toBe('');
+    });
+});
+describe('createPiEventEmitter', () => {
+    test('非 assistant 的 message_start / message_end 被忽略', () => {
+        const { events, write } = collect();
+        write(messageStart('user'));
+        write(messageEnd('user'));
+        write(messageStart('toolResult'));
+        write(messageEnd('toolResult'));
+        expect(events).toEqual([]);
+    });
+    test('round 1-based：首轮 roundIndex=1，第二轮=2，end 与 start 索引一致', () => {
+        const { events, write } = collect();
+        write(messageStart('assistant'));
+        write(messageEnd('assistant'));
+        write(messageStart('assistant'));
+        write(messageEnd('assistant'));
+        expect(events).toEqual([
+            { type: 'round_start', roundIndex: 1 },
+            { type: 'round_end', roundIndex: 1 },
+            { type: 'round_start', roundIndex: 2 },
+            { type: 'round_end', roundIndex: 2 },
+        ]);
+    });
+    test('text_delta / thinking_delta 解包；无效 delta 与其他 ae.type 忽略', () => {
+        const { events, write } = collect();
+        write(textDelta('Hello '));
+        write(thinkingDelta('想想'));
+        write(textDelta(42));
+        write(update({ type: 'text_start', delta: 'ignored' }));
+        expect(events).toEqual([
+            { type: 'text_delta', content: 'Hello ' },
+            { type: 'thinking_delta', content: '想想' },
+        ]);
+    });
+    test('tool_start 字段透传', () => {
+        const { events, write } = collect();
+        write(toolStart({ toolName: 'add_topic', args: { slug: 's', tags: ['a'] } }));
+        expect(events).toEqual([{
+                type: 'tool_start',
+                toolCallId: 'call-1',
+                toolName: 'add_topic',
+                args: { slug: 's', tags: ['a'] },
+            }]);
+    });
+    test('tool_end：durationMs 缺失为 0、有值透传、isError 布尔化、多段 text 拼接、无 content 为空串', () => {
+        const { events, write } = collect();
+        // 缺 durationMs / isError
+        write(toolEnd({
+            result: { content: [
+                    { type: 'text', text: 'part1' },
+                    { type: 'text', text: 'part2' },
+                ] },
+        }));
+        // 有 durationMs、isError 真值
+        write(toolEnd({
+            toolCallId: 'call-2',
+            toolName: 'add_topic',
+            isError: 1,
+            durationMs: 88,
+            result: { content: [{ type: 'text', text: 'err' }] },
+        }));
+        // 无 content
+        write(toolEnd({ toolCallId: 'call-3', result: {} }));
+        expect(events).toEqual([
+            { type: 'tool_end', toolCallId: 'call-1', toolName: 'read_source', isError: false, durationMs: 0, result: 'part1\npart2' },
+            { type: 'tool_end', toolCallId: 'call-2', toolName: 'add_topic', isError: true, durationMs: 88, result: 'err' },
+            { type: 'tool_end', toolCallId: 'call-3', toolName: 'read_source', isError: false, durationMs: 0, result: '' },
+        ]);
+    });
+    test('未知/其他事件类型忽略（含 agent_end）', () => {
+        const { events, write } = collect();
+        write({ type: 'agent_end' });
+        write({ type: 'something_else', foo: 1 });
+        write(null);
+        expect(events).toEqual([]);
+    });
+    test('initialIndex：首轮自增在初始值之上继续（initialIndex=2 → roundIndex=3）', () => {
+        const events = [];
+        const { write } = createPiEventEmitter((ev) => events.push(ev), { initialIndex: 2 });
+        write(messageStart('assistant'));
+        write(messageEnd('assistant'));
+        expect(events).toEqual([
+            { type: 'round_start', roundIndex: 3 },
+            { type: 'round_end', roundIndex: 3 },
+        ]);
+    });
+    test('onIndexChange：以自增后的新值被调用；回调抛错不导致 write 抛错', () => {
+        const seen = [];
+        const events = [];
+        const { write } = createPiEventEmitter((ev) => events.push(ev), {
+            initialIndex: 1,
+            onIndexChange: (n) => {
+                seen.push(n);
+                throw new Error('callback boom');
+            },
+        });
+        expect(() => write(messageStart('assistant'))).not.toThrow();
+        expect(seen).toEqual([2]);
+        // 回调在 try 内、emit 之前，抛错被吞不波及 write；后续事件仍正常映射
+        expect(events).toEqual([]);
+        write(messageEnd('assistant'));
+        expect(events).toEqual([{ type: 'round_end', roundIndex: 2 }]);
+    });
+    test('emit 抛错不导致 write 抛错', () => {
+        const throwing = createPiEventEmitter(() => {
+            throw new Error('emit boom');
+        });
+        expect(() => throwing.write(messageStart('assistant'))).not.toThrow();
+        expect(() => throwing.write(textDelta('x'))).not.toThrow();
+        expect(() => throwing.write(toolStart())).not.toThrow();
+        expect(() => throwing.write(toolEnd())).not.toThrow();
+    });
+});