evolclaw 2.8.3 → 3.1.0

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

@@ -0,0 +1,486 @@
+import { logger } from '../../utils/logger.js';
+import { summarizeToolInput } from '../permission.js';
+import fs from 'fs';
+import path from 'path';
+import { resolvePaths } from '../../paths.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,
+                suppress: opts.suppressActivities,
+            });
+        }
+    }
+    // ── 公开接口 ──
+    /** 推入 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');
+    }
+    /** 是否有待发送的文本 */
+    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.timer) {
+            clearTimeout(this.timer);
+            this.timer = undefined;
+        }
+        const text = this.textBuffer;
+        this.textBuffer = '';
+        // 清掉 itemsQueue 中的 text items（已发出）
+        this.itemsQueue = this.itemsQueue.filter(it => it.kind !== 'text');
+        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] flushText send failed:', e));
+        await this.sendChain;
+        this.lastFlush = Date.now();
+        this.flushCount++;
+    }
+    /** 是否已发送过内容（用于决定最终 flush 是否带 isFinal 标题） */
+    hasSentContent() {
+        return this.sentContent;
+    }
+    /** 累积的全部文本（流式 + 最终） */
+    getFinalText() {
+        return this.allText;
+    }
+    /** 当前 buffer 中尚未 flush 的文本 */
+    getRemainingText() {
+        return this.textBuffer;
+    }
+    /** 从 buffer 中移除指定 pattern（用于文件标记预处理） */
+    stripFromBuffer(pattern) {
+        this.textBuffer = this.textBuffer.replace(pattern, '').trim();
+        // itemsQueue 中的 text items 也同步过滤
+        for (const item of this.itemsQueue) {
+            if (item.kind === 'text') {
+                item.text = item.text.replace(pattern, '');
+            }
+        }
+    }
+    // ── 文本/活动注入（替代 StreamFlusher.addText/addActivity）──
+    /** 添加文本片段（流式 text） */
+    addText(text) {
+        if (this.opts.envelope.chatmode === 'proactive')
+            return;
+        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) {
+        if (this.opts.envelope.chatmode === 'proactive')
+            return;
+        if (this.opts.suppressActivities)
+            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;
+        if (this.opts.suppressActivities)
+            return;
+        this.itemsQueue.push({
+            kind: 'tool_result',
+            call_id: callId || this.synthCallId(),
+            name,
+            ok,
+            result,
+            error,
+            duration_ms: durationMs,
+            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.opts.suppressActivities)
+            return;
+        this.itemsQueue.push({
+            kind: 'progress',
+            text,
+            state: opts.state,
+            tool_uses: opts.toolUses,
+            duration_ms: opts.durationMs,
+        });
+        this.messageTimestamps.push(Date.now());
+        this.scheduleFlush();
+    }
+    /** 添加系统提示 / 通知。force=true 时绕过 suppressActivities（用于 compact/retry/error 等操作反馈） */
+    addNotice(text, severity, subtype, force = false) {
+        if (this.opts.envelope.chatmode === 'proactive')
+            return;
+        if (this.opts.suppressActivities && !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 ?? 4000;
+        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');
+        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;
+        }
+        // 文件标记过滤
+        if (this.opts.fileMarkerPattern) {
+            this.textBuffer = this.textBuffer.replace(this.opts.fileMarkerPattern, '').trim();
+            for (const item of this.itemsQueue) {
+                if (item.kind === 'text')
+                    item.text = item.text.replace(this.opts.fileMarkerPattern, '');
+            }
+        }
+        // 清掉空 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 = 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++;
+        }
+        // 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++;
+        }
+    }
+    // ── 内部：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;
+        }
+        const payload = { kind: 'activity.batch', items: [item] };
+        // fire-and-forget
+        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 || {});
+                return {
+                    kind: 'tool_call',
+                    call_id: event.callId || this.synthCallId(),
+                    name: event.name,
+                    arguments: event.input,
+                    text: desc,
+                };
+            }
+            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 : '执行失败'),
+                    };
+                }
+                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,
+                    };
+                }
+            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}` : ''}`;
+                return {
+                    kind: 'progress',
+                    text,
+                    state: 'processing',
+                    tool_uses: event.toolUses,
+                    duration_ms: event.durationMs,
+                };
+            }
+            case 'error':
+                return { kind: 'notice', text: event.error, severity: 'warn' };
+            case 'complete':
+                if (event.isError) {
+                    const errText = event.errors?.join('; ') || event.result || '任务失败';
+                    return {
+                        kind: 'summary',
+                        text: errText,
+                        is_error: true,
+                        subtype: event.subtype,
+                        duration_ms: event.durationMs,
+                    };
+                }
+                if (event.result) {
+                    return {
+                        kind: 'summary',
+                        text: event.result,
+                        subtype: event.subtype,
+                        duration_ms: event.durationMs,
+                    };
+                }
+                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(', ');
+    }
+}

package/dist/core/message/items-formatter.js

@@ -0,0 +1,68 @@
+/**
+ * 把结构化 ThoughtItem 数组降级为人类可读的纯文本。
+ * 用于不支持 thought 能力的渠道（Feishu/WeChat/DingTalk/QQBot/WeCom），
+ * 在 send() 中收到 activity.batch 后调用。
+ */
+export function formatItemsAsText(items) {
+    if (!items || items.length === 0)
+        return ''; // early exit
+    const lines = [];
+    for (const item of items) {
+        const line = formatItem(item);
+        if (line)
+            lines.push(line);
+    }
+    return lines.join('\n');
+}
+function formatItem(item) {
+    switch (item.kind) {
+        case 'text':
+            return item.text;
+        case 'reasoning':
+            return `💭 ${item.text}`;
+        case 'tool_call': {
+            const desc = item.text || summarizeArgs(item.arguments);
+            if (!desc)
+                return `🔧 ${item.name}`;
+            // 多行 desc（如 Edit diff）：第一行跟工具名同行，代码块从新行开始
+            if (desc.includes('\n')) {
+                const nlIdx = desc.indexOf('\n');
+                return `🔧 ${item.name}  ${desc.slice(0, nlIdx)}\n${desc.slice(nlIdx + 1)}`;
+            }
+            return `🔧 ${item.name}: ${desc}`;
+        }
+        case 'tool_result': {
+            if (!item.ok) {
+                const errMsg = item.error || (typeof item.result === 'string' ? item.result : '执行失败');
+                return `⚠️ ${item.name}: ${errMsg}`;
+            }
+            return item.text ? `✓ ${item.name}: ${item.text}` : `✓ ${item.name}`;
+        }
+        case 'progress':
+            return `⏳ ${item.text}`;
+        case 'notice':
+            return item.severity === 'warn' ? `⚠️ ${item.text}` : item.text;
+        case 'summary':
+            return item.is_error ? `❌ ${item.text}` : item.text;
+        default:
+            return '';
+    }
+}
+function summarizeArgs(args) {
+    if (!args || typeof args !== 'object')
+        return '';
+    const a = args;
+    if (typeof a.description === 'string')
+        return a.description;
+    if (typeof a.file_path === 'string')
+        return a.file_path;
+    if (typeof a.pattern === 'string')
+        return a.pattern;
+    if (typeof a.command === 'string')
+        return a.command.substring(0, 80);
+    if (typeof a.prompt === 'string')
+        return a.prompt.substring(0, 80);
+    if (typeof a.query === 'string')
+        return a.query.substring(0, 80);
+    return '';
+}