evolcore 0.0.1 → 0.0.3

package/dist/core/message/im-renderer.js

@@ -0,0 +1,659 @@
+import { logger } from '../../utils/logger.js';
+import { summarizeToolInput } from '../../utils/tool-summary.js';
+import { CONTEXT_TOO_LONG_PATTERN, getErrorMessage, isContextTooLongText } from '../../utils/error-utils.js';
+import fs from 'fs';
+import path from 'path';
+import { resolvePaths } from '../../paths.js';
+import { DEFAULT_FLUSH_DELAY_MS } from '../../types.js';
+let diagStream = null;
+function getDiagStream() {
+    if (!diagStream) {
+        const logDir = resolvePaths().logs;
+        diagStream = fs.createWriteStream(path.join(logDir, 'im-renderer-diag.log'), { flags: 'a' });
+    }
+    return diagStream;
+}
+function diag(instanceId, action, meta = {}) {
+    const line = JSON.stringify({ ts: new Date().toISOString(), id: instanceId, action, ...meta });
+    getDiagStream().write(line + '\n');
+}
+let instanceCounter = 0;
+export class IMRenderer {
+    opts;
+    itemsQueue = [];
+    textBuffer = '';
+    timer;
+    lastFlush = Date.now();
+    allText = '';
+    sentContent = false;
+    flushCount = 0;
+    messageTimestamps = [];
+    instanceId;
+    diagEnabled;
+    /** 串行发送队列：保证消息按序到达 */
+    sendChain = Promise.resolve();
+    /** proactive：是否已发过 text 文本（用于去重 complete.result） */
+    hasEmittedText = false;
+    /** 自增 callId 兜底（runner 没提供时用） */
+    syntheticCallSeq = 0;
+    constructor(opts) {
+        this.opts = opts;
+        this.diagEnabled = opts.diagEnabled ?? false;
+        this.instanceId = `R${++instanceCounter}`;
+        if (this.diagEnabled) {
+            diag(this.instanceId, 'created', {
+                chatmode: opts.envelope.chatmode,
+                flushDelay: opts.flushDelay,
+                suppressActivityItems: this.suppressActivityItems(),
+                suppressIntermediateText: this.suppressIntermediateText(),
+            });
+        }
+    }
+    suppressActivityItems() {
+        return this.opts.suppressActivityItems ?? this.opts.suppressActivities ?? false;
+    }
+    suppressIntermediateText() {
+        return this.opts.suppressIntermediateText ?? this.opts.suppressActivities ?? false;
+    }
+    // ── 公开接口 ──
+    /** 推入 AgentEvent，按 chatmode 投影 */
+    emit(event) {
+        try {
+            logger.event({ source: 'runner', taskId: this.opts.envelope.taskId, channelId: this.opts.envelope.channelId, event });
+        }
+        catch {
+            // logger.event 失败不影响业务
+        }
+        if (this.opts.envelope.chatmode === 'proactive') {
+            this.emitProactive(event);
+        }
+        // interactive 模式由 MessageProcessor 显式调 addText/addToolCall/... 推入 items
+    }
+    /** 强制刷新所有 pending 事件 */
+    async flush(isFinal) {
+        if (this.opts.envelope.chatmode === 'proactive') {
+            // proactive 是 fire-and-forget，无 pending buffer
+            return;
+        }
+        return this.flushInternal(isFinal);
+    }
+    /** 仅 flush activities，保留 textBuffer（用于中间 complete 事件） */
+    async flushActivitiesOnly() {
+        if (this.opts.envelope.chatmode === 'proactive')
+            return;
+        return this.flushActivitiesInternal();
+    }
+    /** 是否有 pending 内容 */
+    hasContent() {
+        return this.textBuffer.length > 0 || this.itemsQueue.some(it => it.kind !== 'text');
+    }
+    /** 是否有会抑制兜底错误消息的正文/过程内容；lifecycle 边界不算。 */
+    hasNonLifecycleContent() {
+        return this.textBuffer.length > 0 || this.itemsQueue.some(it => {
+            if (it.kind === 'text')
+                return it.text.length > 0;
+            return it.kind !== 'started' && it.kind !== 'completed';
+        });
+    }
+    /** 是否有待发送的文本 */
+    hasTextPending() {
+        return this.textBuffer.length > 0;
+    }
+    /** flush 当前 textBuffer 作为独立的 result.text（非 final），然后清空 buffer */
+    async flushText() {
+        if (this.opts.envelope.chatmode === 'proactive')
+            return;
+        if (this.textBuffer.length === 0)
+            return;
+        if (this.suppressIntermediateText()) {
+            this.itemsQueue = this.itemsQueue.filter(it => it.kind !== 'text');
+            return;
+        }
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = undefined;
+        }
+        // 文件标记过滤：tool_use 前的文本块也不能把 marker 暴露给用户
+        const rawText = this.opts.fileMarkerPattern
+            ? this.textBuffer.replace(this.opts.fileMarkerPattern, '')
+            : this.textBuffer;
+        this.textBuffer = '';
+        if (!rawText)
+            return;
+        // 清掉 itemsQueue 中的 text items（已发出）
+        this.itemsQueue = this.itemsQueue.filter(it => it.kind !== 'text');
+        const payload = { kind: 'result.text', text: rawText, isFinal: false };
+        this.sentContent = true;
+        this.sendChain = this.sendChain
+            .then(() => this.opts.send(payload))
+            .catch(e => logger.warn('[IMRenderer] flushText send failed:', e));
+        await this.sendChain;
+        this.lastFlush = Date.now();
+        this.flushCount++;
+    }
+    /** 是否已发送过内容（用于决定最终 flush 是否带 isFinal 标题） */
+    hasSentContent() {
+        return this.sentContent;
+    }
+    /** 累积的全部文本（流式 + 最终） */
+    getFinalText() {
+        return this.allText;
+    }
+    /** 丢弃当前 attempt 的未发送内容；用于命中可重试错误后避免把瞬时错误文本发给用户。 */
+    discardPending() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = undefined;
+        }
+        this.itemsQueue = [];
+        this.textBuffer = '';
+        this.allText = '';
+    }
+    /** 仅丢弃尚未发送的正文，保留 notice/tool 等活动项。 */
+    discardPendingText() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = undefined;
+        }
+        this.itemsQueue = this.itemsQueue.filter(it => it.kind !== 'text');
+        this.textBuffer = '';
+    }
+    /** 当前 buffer 中尚未 flush 的文本 */
+    getRemainingText() {
+        return this.textBuffer;
+    }
+    // ── 文本/活动注入（替代 StreamFlusher.addText/addActivity）──
+    /** 添加文本片段（流式 text） */
+    addText(text, outputTokens, turn) {
+        if (this.opts.envelope.chatmode === 'proactive')
+            return;
+        this.emitProgress('text', outputTokens, turn);
+        if (!text)
+            return;
+        // 同一窗口内连续 text delta 合并到最后一个 text item
+        const last = this.itemsQueue[this.itemsQueue.length - 1];
+        if (last && last.kind === 'text') {
+            last.text += text;
+        }
+        else {
+            this.itemsQueue.push({ kind: 'text', text });
+        }
+        this.textBuffer += text;
+        this.allText += text;
+        this.messageTimestamps.push(Date.now());
+        if (this.diagEnabled) {
+            diag(this.instanceId, 'addText', {
+                len: text.length,
+                preview: text.substring(0, 60),
+                bufLen: this.textBuffer.length,
+            });
+        }
+        this.scheduleFlush();
+    }
+    /** 添加工具调用 */
+    addToolCall(name, input, callId, descText, turn, outputTokens) {
+        if (this.opts.envelope.chatmode === 'proactive')
+            return;
+        this.emitProgress('tool_call', outputTokens, turn, { toolName: name, callId });
+        if (this.suppressActivityItems())
+            return;
+        this.itemsQueue.push({
+            kind: 'tool_call',
+            call_id: callId || this.synthCallId(),
+            name,
+            arguments: input,
+            text: descText,
+        });
+        this.messageTimestamps.push(Date.now());
+        if (this.diagEnabled)
+            diag(this.instanceId, 'addToolCall', { name, callId });
+        this.scheduleFlush();
+    }
+    /** 添加工具结果 */
+    addToolResult(name, ok, result, error, callId, durationMs, descText) {
+        if (this.opts.envelope.chatmode === 'proactive')
+            return;
+        this.emitProgress('tool_result', undefined, undefined, { toolName: name, callId, ok, durationMs });
+        if (this.suppressActivityItems())
+            return;
+        this.itemsQueue.push({
+            kind: 'tool_result',
+            call_id: callId || this.synthCallId(),
+            name,
+            ok,
+            ...(result !== undefined && { result }),
+            ...(error !== undefined && { error }),
+            ...(durationMs !== undefined && { duration_ms: durationMs }),
+            ...(descText !== undefined && { text: descText }),
+        });
+        this.messageTimestamps.push(Date.now());
+        if (this.diagEnabled)
+            diag(this.instanceId, 'addToolResult', { name, ok, callId });
+        this.scheduleFlush();
+    }
+    /** 添加进度提示 */
+    addProgress(text, opts = {}) {
+        if (this.opts.envelope.chatmode === 'proactive')
+            return;
+        if (this.suppressActivityItems())
+            return;
+        this.emitProgress('progress', undefined, undefined, {
+            text,
+            state: opts.state,
+            toolUses: opts.toolUses,
+            durationMs: opts.durationMs,
+        });
+    }
+    /** 添加任务生命周期边界事件，复用 activity.batch 投影路径。 */
+    addLifecycle(phase, metadata, text) {
+        const item = {
+            kind: phase,
+            ...(text !== undefined && { text }),
+            ...(metadata !== undefined && { metadata }),
+        };
+        if (this.opts.envelope.chatmode === 'proactive') {
+            this.emitProactiveItem(item);
+            return;
+        }
+        if (this.suppressActivityItems())
+            return;
+        this.itemsQueue.push(item);
+        this.messageTimestamps.push(Date.now());
+        this.scheduleFlush();
+    }
+    /**
+     * proactive 下放行为 thought 的 notice subtype 白名单——仅"真·终态错误"：
+     * - context-too-long：上下文超限且无法 auto-compact，任务到此终止
+     * - process-exit：Agent 子进程异常崩溃（无 complete 事件，emit 完全覆盖不到）
+     * 二者都是用户必须知道、否则会困惑"任务为什么停了"的终态信号。
+     *
+     * 其余 subtype 一律不发：
+     * - compact / runtime-error / task-error：emit() 路径（mapEventToItem）已投影，重复
+     * - compact-start / compact-trigger / compact-retry / retry：内部机务噪音（压缩中/
+     *   重试中/压缩完成），proactive 下用户要的是工作产出而非流水账，压缩后 thought 会
+     *   继续输出，过程本身无需播报。
+     */
+    static PROACTIVE_NOTICE_ALLOW = new Set(['context-too-long', 'process-exit']);
+    /** 添加系统提示 / 通知。force=true 仅跳过入队门禁；最终 flush 仍遵守 activity 抑制。 */
+    addNotice(text, severity, subtype, force = false) {
+        // proactive 模式：只放行真·终态错误，机务噪音（压缩/重试）和 emit 已覆盖的 subtype 均不发。
+        if (this.opts.envelope.chatmode === 'proactive') {
+            if (subtype == null || !IMRenderer.PROACTIVE_NOTICE_ALLOW.has(subtype))
+                return;
+            this.emitProactiveItem({ kind: 'notice', text, severity, subtype });
+            return;
+        }
+        if (this.suppressActivityItems() && !force)
+            return;
+        this.itemsQueue.push({ kind: 'notice', text, severity, subtype });
+        this.messageTimestamps.push(Date.now());
+        this.scheduleFlush();
+    }
+    // ── 内部：interactive 模式聚合窗口 ──
+    synthCallId() {
+        return `synth-${this.opts.envelope.taskId}-${++this.syntheticCallSeq}`;
+    }
+    scheduleFlush() {
+        if (this.timer) {
+            if (this.diagEnabled)
+                diag(this.instanceId, 'scheduleFlush:skip', { reason: 'timer_exists' });
+            return;
+        }
+        const interval = this.opts.flushDelay ?? DEFAULT_FLUSH_DELAY_MS;
+        let targetDelay;
+        if (this.flushCount === 0) {
+            targetDelay = 500;
+        }
+        else if (this.flushCount <= 3) {
+            targetDelay = Math.ceil(interval / 2);
+        }
+        else if (this.messageTimestamps.length >= 5) {
+            targetDelay = this.calculateDynamicDelay(interval);
+        }
+        else {
+            targetDelay = interval;
+        }
+        const elapsed = Date.now() - this.lastFlush;
+        const delay = Math.max(0, targetDelay - elapsed);
+        if (this.diagEnabled) {
+            diag(this.instanceId, 'scheduleFlush:set', {
+                flushCount: this.flushCount,
+                targetDelay,
+                elapsed,
+                actualDelay: delay,
+            });
+        }
+        this.timer = setTimeout(() => this.flushInternal(), delay);
+    }
+    calculateDynamicDelay(interval) {
+        const recent = this.messageTimestamps.slice(-10);
+        const intervals = [];
+        for (let i = 1; i < recent.length; i++) {
+            intervals.push(recent[i] - recent[i - 1]);
+        }
+        if (intervals.length === 0)
+            return interval;
+        const avgInterval = intervals.reduce((a, b) => a + b) / intervals.length;
+        const dynamicDelay = avgInterval * 3;
+        const minDelay = interval;
+        const maxDelay = interval * 2.5;
+        return Math.max(minDelay, Math.min(maxDelay, dynamicDelay));
+    }
+    /** 仅 flush 非 text items（text items 和 textBuffer 保留，等待下次完整 flush） */
+    async flushActivitiesInternal() {
+        const nonThinking = this.itemsQueue.filter(it => it.kind !== 'text');
+        if (nonThinking.length === 0)
+            return;
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = undefined;
+        }
+        // 移除已 flush 的 non-text items，保留 text items
+        this.itemsQueue = this.itemsQueue.filter(it => it.kind === 'text');
+        if (this.suppressActivityItems())
+            return;
+        const payload = { kind: 'activity.batch', items: nonThinking };
+        if (this.diagEnabled)
+            diag(this.instanceId, 'flushActivitiesOnly', { itemCount: nonThinking.length });
+        this.sentContent = true;
+        this.sendChain = this.sendChain
+            .then(() => this.opts.send(payload))
+            .catch(e => logger.warn('[IMRenderer] activity.batch send failed:', e));
+        await this.sendChain;
+        this.lastFlush = Date.now();
+        this.flushCount++;
+    }
+    /**
+     * 完整 flush：把 itemsQueue 里所有 items 打包成 activity.batch 发送。
+     * 如果 isFinal=true，还会在 batch 之后单独发一条 result.text 作为最终回复。
+     */
+    async flushInternal(isFinal) {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = undefined;
+        }
+        // 文件标记过滤：marker 任何时候都不该出现在用户文本里，必须在 *每次* flush
+        // （含非最终的定时 flush）执行。否则文本块若滞留 buffer 后被定时器触发，会走
+        // 下方非-final 的 result.text 路径，把 [SEND_FILE:...] 原样发给用户。
+        // 非最终 flush 不做 trim，避免 trim 掉 Markdown 块级换行。
+        if (this.opts.fileMarkerPattern) {
+            const strip = (s) => {
+                const replaced = s.replace(this.opts.fileMarkerPattern, '');
+                return isFinal ? replaced.trim() : replaced;
+            };
+            this.textBuffer = strip(this.textBuffer);
+            for (const item of this.itemsQueue) {
+                if (item.kind === 'text')
+                    item.text = item.text.replace(this.opts.fileMarkerPattern, '');
+            }
+        }
+        if (isFinal) {
+            // 上下文错误短语过滤：剔除错误关键词本身，保留前后内容。
+            // 只在最终 flush 清理，避免中间定时 flush trim 掉 Markdown 块级换行。
+            const ctxErrPattern = new RegExp(CONTEXT_TOO_LONG_PATTERN.source, 'gi');
+            const stripCtxErr = (s) => s.replace(ctxErrPattern, '').trim();
+            this.textBuffer = stripCtxErr(this.textBuffer);
+            this.allText = stripCtxErr(this.allText);
+            for (const item of this.itemsQueue) {
+                if (item.kind === 'text')
+                    item.text = stripCtxErr(item.text);
+            }
+        }
+        // 清掉空 text items
+        const items = this.itemsQueue.filter(it => {
+            if (it.kind === 'text')
+                return it.text.length > 0;
+            return true;
+        });
+        this.itemsQueue = [];
+        const finalText = isFinal ? this.textBuffer : '';
+        if (isFinal)
+            this.textBuffer = '';
+        if (this.diagEnabled) {
+            diag(this.instanceId, 'flush', {
+                isFinal,
+                itemCount: items.length,
+                finalTextLen: finalText.length,
+                flushCount: this.flushCount,
+                sinceLastFlush: Date.now() - this.lastFlush,
+            });
+        }
+        // 1. interactive 模式下：不发 text items（由 result.text 统一发送最终文本）
+        let itemsForBatch = this.suppressActivityItems() ? [] : items.filter(it => it.kind !== 'text');
+        if (itemsForBatch.length > 0) {
+            const payload = { kind: 'activity.batch', items: itemsForBatch };
+            this.sentContent = true;
+            this.sendChain = this.sendChain
+                .then(() => this.opts.send(payload))
+                .catch(e => logger.warn('[IMRenderer] activity.batch send failed:', e));
+            await this.sendChain;
+            this.lastFlush = Date.now();
+            this.flushCount++;
+        }
+        // 1.5 非最终定时 flush：把已累积的文本块作为独立 result.text 发出。
+        //   每个 text 事件本身是完整语义块（runner 已合并流式 delta），工具调用前的
+        //   文本一向作为独立气泡发送（见 message-processor 的 flushText 调用）。
+        //   这里补上「文本块后面没有紧跟 tool_use」的情况——例如 readonly 拒绝写文件时
+        //   SDK 直接拒绝、不产生 tool_use 事件，文本会一直滞留 buffer，直到下一个
+        //   tool_use 才被 flushText 带出，并与其后的文本合并成一条（用户侧表现为：
+        //   第一条文本等待一分多钟后才和第二条凑成一条发出）。定时器到期即发，根除滞留。
+        if (!isFinal && this.textBuffer.length > 0) {
+            if (this.suppressIntermediateText())
+                return;
+            const text = this.textBuffer;
+            this.textBuffer = '';
+            const payload = { kind: 'result.text', text, isFinal: false };
+            this.sentContent = true;
+            this.sendChain = this.sendChain
+                .then(() => this.opts.send(payload))
+                .catch(e => logger.warn('[IMRenderer] timed result.text send failed:', e));
+            await this.sendChain;
+            this.lastFlush = Date.now();
+            this.flushCount++;
+        }
+        // 2. isFinal=true 时单独发最终回复文本
+        if (isFinal && finalText.length > 0) {
+            const payload = { kind: 'result.text', text: finalText, isFinal: true };
+            this.sentContent = true;
+            this.sendChain = this.sendChain
+                .then(() => this.opts.send(payload))
+                .catch(e => logger.warn('[IMRenderer] result.text send failed:', e));
+            await this.sendChain;
+            this.lastFlush = Date.now();
+            this.flushCount++;
+        }
+    }
+    // ── 内部：status.progress 发送 ──
+    emitProgress(activityType, outputTokens, turn, extra) {
+        if (this.suppressActivityItems())
+            return;
+        const payload = {
+            kind: 'status.progress',
+            metadata: {
+                activityType,
+                ...(turn != null && { turn }),
+                ...(outputTokens != null && { outputTokens }),
+                ...(extra?.toolName != null && { toolName: extra.toolName }),
+                ...(extra?.callId != null && { callId: extra.callId }),
+                ...(extra?.ok != null && { ok: extra.ok }),
+                ...(extra?.durationMs != null && { durationMs: extra.durationMs }),
+                ...(extra?.text != null && { text: extra.text }),
+                ...(extra?.state != null && { state: extra.state }),
+                ...(extra?.toolUses != null && { toolUses: extra.toolUses }),
+            },
+        };
+        this.opts.send(payload).catch(() => { });
+    }
+    // ── 内部：proactive 模式（逐事件 activity.batch[1 item]） ──
+    emitProactive(event) {
+        // 对齐 interactive 的 dedup：流式 text 已推过时，complete.result 不再重复发 summary
+        if (event.type === 'complete' &&
+            !event.isError &&
+            event.result &&
+            this.hasEmittedText) {
+            return;
+        }
+        const item = this.mapEventToItem(event);
+        if (!item)
+            return;
+        if (item.kind === 'text') {
+            this.hasEmittedText = true;
+            this.allText += item.text;
+        }
+        // proactive 模式：status.progress 是 interactive 的处理状态指示器，proactive 下
+        // 过程由 thought（activity.batch）表达，不再发 status.progress（与 addProgress 在
+        // proactive 下的拦截保持一致）。progress-kind item 若进 activity.batch 会被 aun 侧
+        // 回转成 status.progress（见 aun.ts 'activity.batch' 分支），故直接丢弃。
+        // 终态 status（started/completed/interrupted/error）由 message-processor 发送，不受影响。
+        if (item.kind === 'progress') {
+            return;
+        }
+        this.emitProactiveItem(item);
+    }
+    /** proactive 模式逐条投影：单个 ThoughtItem 包成 activity.batch[1] 发出（fire-and-forget）。 */
+    emitProactiveItem(item) {
+        const payload = { kind: 'activity.batch', items: [item] };
+        this.opts.send(payload).catch(err => {
+            logger.debug(`[IMRenderer] proactive send failed: ${err.message}`);
+        });
+    }
+    mapEventToItem(event) {
+        switch (event.type) {
+            case 'text':
+                if (!event.text)
+                    return null;
+                return { kind: 'text', text: event.text };
+            case 'tool_use': {
+                const desc = summarizeToolInput(event.name, event.input || {});
+                const item = {
+                    kind: 'tool_call',
+                    call_id: event.callId || this.synthCallId(),
+                    name: event.name,
+                    text: desc,
+                };
+                if (event.input !== undefined)
+                    item.arguments = event.input;
+                return item;
+            }
+            case 'tool_result':
+                if (event.isError) {
+                    return {
+                        kind: 'tool_result',
+                        call_id: event.callId || this.synthCallId(),
+                        name: event.name,
+                        ok: false,
+                        error: event.error || (typeof event.result === 'string' ? event.result : '执行失败'),
+                        ...(event.durationMs !== undefined && { duration_ms: event.durationMs }),
+                    };
+                }
+                else {
+                    const resultText = this.truncate(this.stringifyResult(event.result), 200);
+                    return {
+                        kind: 'tool_result',
+                        call_id: event.callId || this.synthCallId(),
+                        name: event.name,
+                        ok: true,
+                        result: event.result,
+                        text: resultText,
+                        ...(event.durationMs !== undefined && { duration_ms: event.durationMs }),
+                    };
+                }
+            case 'compact':
+                return {
+                    kind: 'notice',
+                    text: `💡 会话压缩完成 (压缩前 tokens: ${event.preTokens})`,
+                    severity: 'info',
+                    subtype: 'compact',
+                };
+            case 'task_progress': {
+                const stats = this.formatTaskStats(event);
+                const text = event.summary
+                    ? `子任务: ${event.summary}${stats ? ` (${stats})` : ''}`
+                    : `子任务进行中${stats ? `: ${stats}` : ''}`;
+                const item = {
+                    kind: 'progress',
+                    text,
+                    state: 'processing',
+                };
+                if (event.toolUses !== undefined)
+                    item.tool_uses = event.toolUses;
+                if (event.durationMs !== undefined)
+                    item.duration_ms = event.durationMs;
+                return item;
+            }
+            case 'error': {
+                // 上下文过长错误不输出（留给外层 auto-compact 处理）
+                if (isContextTooLongText(event.error || ''))
+                    return null;
+                const text = getErrorMessage(new Error(event.error || '任务执行失败'), undefined, false);
+                return { kind: 'notice', text, severity: 'warn' };
+            }
+            case 'complete': {
+                if (event.queryFinal === false)
+                    return null;
+                // 上下文过长错误不输出（留给外层 auto-compact 处理）
+                const hasContextError = event.terminalReason === 'prompt_too_long'
+                    || isContextTooLongText(event.errors?.join(' ') || '')
+                    || isContextTooLongText(event.result || '');
+                if (event.isError && hasContextError) {
+                    return null;
+                }
+                if (event.isError) {
+                    const errText = event.errors?.join('; ') || event.result || '任务失败';
+                    const text = getErrorMessage(new Error(errText), event.terminalReason, false);
+                    const item = {
+                        kind: 'summary',
+                        text,
+                        is_error: true,
+                    };
+                    if (event.subtype !== undefined)
+                        item.subtype = event.subtype;
+                    if (event.durationMs !== undefined)
+                        item.duration_ms = event.durationMs;
+                    return item;
+                }
+                if (event.result) {
+                    const item = {
+                        kind: 'summary',
+                        text: event.result,
+                    };
+                    if (event.subtype !== undefined)
+                        item.subtype = event.subtype;
+                    if (event.durationMs !== undefined)
+                        item.duration_ms = event.durationMs;
+                    return item;
+                }
+                return null;
+            }
+            case 'session_id':
+            case 'state_changed':
+            case 'status':
+                return null;
+            default:
+                return null;
+        }
+    }
+    stringifyResult(result) {
+        if (result === null || result === undefined)
+            return '';
+        if (typeof result === 'string')
+            return result;
+        try {
+            return JSON.stringify(result);
+        }
+        catch {
+            return String(result);
+        }
+    }
+    truncate(text, maxLen) {
+        return text.length > maxLen ? text.substring(0, maxLen) + '...' : text;
+    }
+    formatTaskStats(event) {
+        const parts = [];
+        if (event.toolUses)
+            parts.push(`${event.toolUses} tools`);
+        if (event.durationMs)
+            parts.push(`${Math.round(event.durationMs / 1000)}s`);
+        return parts.join(', ');
+    }
+}