evolcore 0.0.32 → 0.0.34

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

@@ -1,9 +1,10 @@
 import { logger } from '../../utils/logger.js';
 import { summarizeToolInput, summarizeToolInputForDisplay, toolInputForDisplay } from '../../utils/tool-summary.js';
-import { getErrorMessage, isContextTooLongText } from '../../utils/error-utils.js';
+import { getErrorMessage, getToolResultErrorText, isContextTooLongText } from '../../utils/error-utils.js';
 import { tagErrorTextWithEvolcoreVersion } from '../../utils/evolcore-version.js';
 import { DEFAULT_FLUSH_DELAY_MS } from '../../types.js';
 import { classifyAunToolErrorCode, normalizeToolErrorClassification } from '../permission/tool-error-code.js';
+import { foldSubtaskTerminal } from './subtask-tool-projection.js';
 export class IMRenderer {
     opts;
     itemsQueue = [];
@@ -22,6 +23,16 @@ export class IMRenderer {
     syntheticCallSeq = 0;
     currentAssistantUuid;
     currentTextPhase;
+    /** 无来源工具时合成的子任务卡片；与 lifecycle 边界一样，不算抑制兜底错误的正文/过程内容。 */
+    subtaskItems = new WeakSet();
+    /** 本轮已投影的工具调用 call_id → 工具名；子任务只归拢到本轮可见的来源工具卡片。 */
+    toolCallNames = new Map();
+    /**
+     * 归拢到来源工具的子任务：call_id → 状态。
+     * running 期间到达的 tool_result（后台占位结果）先扣住，等终态合并后再发；
+     * 终态先到（前台）时记下终态，等真实 tool_result 到达时合并。
+     */
+    parentSubtasks = new Map();
     constructor(opts) {
         this.opts = opts;
     }
@@ -66,7 +77,8 @@ export class IMRenderer {
     /** 强制刷新所有 pending 事件 */
     async flush(isFinal, attention) {
         if (this.opts.envelope.chatmode === 'proactive') {
-            // proactive 是 fire-and-forget，无 pending buffer
+            // proactive 是 fire-and-forget，无 pending buffer；只需放出仍被扣住的工具结果
+            this.releaseHeldToolResults();
             return;
         }
         return this.flushInternal(isFinal, attention);
@@ -79,16 +91,24 @@ export class IMRenderer {
     }
     /** 是否有 pending 内容 */
     hasContent() {
-        return this.textBuffer.length > 0 || this.itemsQueue.some(it => it.kind !== 'text');
+        return this.textBuffer.length > 0 || this.itemsQueue.some(it => it.kind !== 'text') || this.hasHeldToolResults();
     }
     /** 是否有会抑制兜底错误消息的正文/过程内容；lifecycle 边界不算。 */
     hasNonLifecycleContent() {
-        return this.textBuffer.trim().length > 0 || this.itemsQueue.some(it => {
+        return this.textBuffer.trim().length > 0 || this.hasHeldToolResults() || this.itemsQueue.some(it => {
             if (it.kind === 'text')
                 return it.text.trim().length > 0;
+            if (this.subtaskItems.has(it))
+                return false;
             return it.kind !== 'started' && it.kind !== 'completed';
         });
     }
+    hasHeldToolResults() {
+        for (const state of this.parentSubtasks.values())
+            if (state.held)
+                return true;
+        return false;
+    }
     /** 是否有待发送的文本 */
     hasTextPending() {
         return this.textBuffer.length > 0;
@@ -234,6 +254,7 @@ export class IMRenderer {
             ...(evolCommand ? { evolCommand } : {}),
             ...(assistantUuid ? { forkAnchor: { assistantMessageId: assistantUuid } } : {}),
         };
+        this.toolCallNames.set(item.call_id, name);
         this.recordActivity(item);
         if (this.suppressActivityItems())
             return;
@@ -245,7 +266,6 @@ export class IMRenderer {
     addToolResult(name, ok, result, error, callId, durationMs, descText, classification, assistantUuid) {
         if (this.opts.envelope.chatmode === 'proactive')
             return;
-        this.emitProgress('tool_result', undefined, undefined, { toolName: name, callId, ok, durationMs });
         const normalizedClassification = !ok
             ? normalizeToolErrorClassification(classification ?? {})
             : undefined;
@@ -255,7 +275,13 @@ export class IMRenderer {
             name,
             ok,
             ...(result !== undefined && { result }),
-            ...(error !== undefined && { error }),
+            ...(!ok
+                ? { error: getToolResultErrorText({ name, result, error, exitCode: classification?.exitCode }) }
+                : error !== undefined ? { error } : {}),
+            ...(typeof classification?.exitCode === 'number' && Number.isInteger(classification.exitCode)
+                ? { exit_code: classification.exitCode }
+                : {}),
+            ...(classification?.outputKind ? { output_kind: classification.outputKind } : {}),
             ...(!ok && {
                 error_code: classifyAunToolErrorCode({
                     ...(classification ?? {}),
@@ -269,6 +295,22 @@ export class IMRenderer {
             ...(descText !== undefined && { text: descText }),
             ...(assistantUuid ? { forkAnchor: { assistantMessageId: assistantUuid } } : {}),
         };
+        const resolved = this.resolveParentToolResult(item);
+        if (!resolved)
+            return;
+        this.deliverToolResult(resolved);
+    }
+    /** 投递一条工具结果（interactive 入队 / proactive 直发），并记录任务活动。 */
+    deliverToolResult(item) {
+        if (item.kind !== 'tool_result')
+            return;
+        if (this.opts.envelope.chatmode === 'proactive') {
+            this.emitProactiveItem(item);
+            return;
+        }
+        this.emitProgress('tool_result', undefined, undefined, {
+            toolName: item.name, callId: item.call_id, ok: item.ok, durationMs: item.duration_ms,
+        });
         this.recordActivity(item);
         if (this.suppressActivityItems())
             return;
@@ -276,6 +318,73 @@ export class IMRenderer {
         this.messageTimestamps.push(Date.now());
         this.scheduleFlush();
     }
+    /**
+     * 工具结果与归拢子任务的会合点。
+     * - 无归拢子任务：原样放行
+     * - 子任务已终态（前台：通知先于真实结果到达）：合并终态后放行
+     * - 子任务仍在跑（后台：先到的是占位结果）：扣住，返回 null，等 endParentSubtask 合并后发出
+     */
+    resolveParentToolResult(item) {
+        if (item.kind !== 'tool_result')
+            return item;
+        const state = this.parentSubtasks.get(item.call_id);
+        if (!state)
+            return item;
+        if (state.terminal) {
+            this.parentSubtasks.delete(item.call_id);
+            return foldSubtaskTerminal(item, state.terminal);
+        }
+        state.held = item;
+        return null;
+    }
+    /**
+     * 子任务开始：若来源工具卡片在本轮可见，登记归拢，不另出卡片。
+     * 返回 false 表示无法归拢（无来源工具或卡片不在本轮），调用方应改发独立卡片。
+     */
+    beginParentSubtask(toolUseId) {
+        if (!toolUseId || !this.toolCallNames.has(toolUseId))
+            return false;
+        if (!this.parentSubtasks.has(toolUseId))
+            this.parentSubtasks.set(toolUseId, {});
+        return true;
+    }
+    /**
+     * 子任务终态：合并进来源工具的 tool_result。
+     * - 已扣住占位结果（后台）：合并后立即发出
+     * - 结果尚未到达（前台）：记下终态，等结果到达时合并
+     * 返回 false 表示本轮没有登记该归拢（卡片已提前释放或不在本轮），调用方应补发一条同 call_id 的终态结果。
+     */
+    endParentSubtask(toolUseId, terminal) {
+        if (!toolUseId)
+            return false;
+        const state = this.parentSubtasks.get(toolUseId);
+        if (!state)
+            return false;
+        if (state.held) {
+            this.parentSubtasks.delete(toolUseId);
+            this.deliverToolResult(foldSubtaskTerminal(state.held, terminal));
+        }
+        else {
+            state.terminal = terminal;
+        }
+        return true;
+    }
+    /** 来源工具的名称（本轮可见时）；补发终态结果时用来对齐卡片名。 */
+    toolNameForCall(callId) {
+        return callId ? this.toolCallNames.get(callId) : undefined;
+    }
+    /**
+     * 放出仍被扣住的工具结果（不带子任务终态，原样发出）。
+     * 轮次结束或出错收尾时调用，避免来源工具卡片停在"执行中"。
+     */
+    releaseHeldToolResults() {
+        for (const [callId, state] of this.parentSubtasks) {
+            if (!state.held)
+                continue;
+            this.parentSubtasks.delete(callId);
+            this.deliverToolResult(state.held);
+        }
+    }
     /** 添加进度提示 */
     addProgress(text, opts = {}) {
         if (this.opts.envelope.chatmode === 'proactive')
@@ -348,6 +457,26 @@ export class IMRenderer {
         this.messageTimestamps.push(Date.now());
         this.scheduleFlush();
     }
+    /**
+     * 添加子任务活动（由 subtask-tool-projection 构造的 tool_call / tool_result）。
+     *
+     * 与 addToolCall/addToolResult 不同：不发 status.progress（子任务不是本轮模型正在发起的工具调用），
+     * 且 proactive 下照常投影为 thought（mapEventToItem 不处理 task_* 事件，不会重复）。
+     * 活动记录与 addToolCall 一致，在抑制前写入，保证任务活动 Menu 历史完整。
+     */
+    addSubtaskActivity(item) {
+        this.subtaskItems.add(item);
+        if (this.opts.envelope.chatmode === 'proactive') {
+            this.emitProactiveItem(item);
+            return;
+        }
+        this.recordActivity(item);
+        if (this.suppressActivityItems())
+            return;
+        this.itemsQueue.push(item);
+        this.messageTimestamps.push(Date.now());
+        this.scheduleFlush();
+    }
     /**
      * proactive 下放行为 thought 的 notice subtype 白名单——仅"真·终态错误"：
      * - context-too-long：上下文超限且无法 auto-compact，任务到此终止
@@ -553,6 +682,16 @@ export class IMRenderer {
             clearTimeout(this.timer);
             this.timer = undefined;
         }
+        // 显式 flush（轮次结束、出错收尾）时放出被扣住的后台占位结果；定时 flush 不放，
+        // 否则长时间后台任务会在终态到达前就把占位结果发出去。放出的结果随本次 flush 一起发，
+        // 不需要它重新挂上的定时器。
+        if (!scheduled) {
+            this.releaseHeldToolResults();
+            if (this.timer) {
+                clearTimeout(this.timer);
+                this.timer = undefined;
+            }
+        }
         // 文件标记过滤：marker 任何时候都不该出现在用户文本里，必须在 *每次* flush
         // （含非最终的定时 flush）执行。否则文本块若滞留 buffer 后被定时器触发，会走
         // 下方非-final 的 result.text 路径，把 [SEND_FILE:...] 原样发给用户。
@@ -717,6 +856,16 @@ export class IMRenderer {
         if (item.kind === 'progress') {
             return;
         }
+        if (item.kind === 'tool_call') {
+            this.toolCallNames.set(item.call_id, item.name);
+        }
+        else if (item.kind === 'tool_result') {
+            const resolved = this.resolveParentToolResult(item);
+            if (!resolved)
+                return;
+            this.emitProactiveItem(resolved);
+            return;
+        }
         this.emitProactiveItem(item);
     }
     /** proactive 模式逐条投影：单个 ThoughtItem 包成 activity.batch[1] 发出（fire-and-forget）。 */
@@ -761,7 +910,13 @@ export class IMRenderer {
                     item.arguments = toolInputForDisplay(event.name, event.input);
                 return item;
             }
-            case 'tool_result':
+            case 'tool_result': {
+                const executionFields = {
+                    ...(typeof event.exitCode === 'number' && Number.isInteger(event.exitCode)
+                        ? { exit_code: event.exitCode }
+                        : {}),
+                    ...(event.outputKind ? { output_kind: event.outputKind } : {}),
+                };
                 if (event.isError) {
                     const classification = normalizeToolErrorClassification(event);
                     return {
@@ -769,9 +924,11 @@ export class IMRenderer {
                         call_id: event.callId || this.synthCallId(),
                         name: event.name,
                         ok: false,
+                        ...executionFields,
+                        ...(event.result !== undefined ? { result: event.result } : {}),
                         error_code: classifyAunToolErrorCode({ ...event, ...classification }),
                         ...(classification.errorDetailCode ? { detail_code: classification.errorDetailCode } : {}),
-                        error: event.error || (typeof event.result === 'string' ? event.result : '执行失败'),
+                        error: getToolResultErrorText(event),
                         ...(event.durationMs !== undefined && { duration_ms: event.durationMs }),
                     };
                 }
@@ -782,11 +939,13 @@ export class IMRenderer {
                         call_id: event.callId || this.synthCallId(),
                         name: event.name,
                         ok: true,
+                        ...executionFields,
                         result: event.result,
                         text: resultText,
                         ...(event.durationMs !== undefined && { duration_ms: event.durationMs }),
                     };
                 }
+            }
             case 'compact':
                 return {
                     kind: 'notice',
@@ -814,7 +973,7 @@ export class IMRenderer {
                 // 上下文过长错误不输出（留给外层 auto-compact 处理）
                 if (isContextTooLongText(event.error || ''))
                     return null;
-                const text = getErrorMessage(new Error(event.error || '任务执行失败'), undefined, false);
+                const text = getErrorMessage(new Error(event.error), undefined, false);
                 return { kind: 'notice', text: tagErrorTextWithEvolcoreVersion(text), severity: 'warn' };
             }
             case 'complete': {
@@ -828,7 +987,7 @@ export class IMRenderer {
                     return null;
                 }
                 if (event.isError) {
-                    const errText = event.errors?.join('; ') || event.result || '任务失败';
+                    const errText = event.errors?.join('; ') || event.result || '';
                     const text = getErrorMessage(new Error(errText), event.terminalReason, false);
                     const item = {
                         kind: 'summary',

package/dist/core/message/message-bridge.js

@@ -137,7 +137,8 @@ export class MessageBridge {
                     logger.debug(`[MessageBridge] Decision context group rules unavailable: ${String(error)}`);
                 }
             }
-            const personalPath = path.join(agentDir(item.selfAid), 'personal', 'personal.md');
+            // persona.md 是唯一的人格/个人资料文件（personal.md 已废弃并入）
+            const personalPath = path.join(agentDir(item.selfAid), 'personal', 'persona.md');
             if (fs.existsSync(personalPath))
                 resources.personal = fs.readFileSync(personalPath, 'utf8');
             if (item.projectPath) {
@@ -1895,9 +1896,19 @@ export class MessageBridge {
                 case 'menu.list':
                     if (args?.view === 'catalog') {
                         validateMenuCatalogArgs(args);
-                        const data = await this.cmdHandler.getMenuCatalog(channel, msg.channelId, authSubject, args.context, msg.isControlChannel ? 'control' : 'agent', !msg.isControlChannel || (msg.encrypted === true
-                            && msg.protectedHeaders?.auth_method !== 'remote-access-token'
-                            && msg.protectedHeaders?.auth_method !== 'ecweb-token'));
+                        const catalogArgs = [
+                            channel,
+                            msg.channelId,
+                            authSubject,
+                            args.context,
+                            msg.isControlChannel ? 'control' : 'agent',
+                            !msg.isControlChannel || (msg.encrypted === true
+                                && msg.protectedHeaders?.auth_method !== 'remote-access-token'
+                                && msg.protectedHeaders?.auth_method !== 'ecweb-token'),
+                        ];
+                        const data = msg.threadId
+                            ? await this.cmdHandler.getMenuCatalog(...catalogArgs, transportReplyContext)
+                            : await this.cmdHandler.getMenuCatalog(...catalogArgs);
                         return menuSuccess(header, data);
                     }
                     if (args?.view !== undefined) {

package/dist/core/message/message-log.js

@@ -20,6 +20,7 @@ const TRANSIENT_PROTOCOL_TYPES = new Set([
     'thought',
     'handoff_state',
     'handoff_result',
+    'topic-created', // 话题创建系统消息，不进大模型上下文
 ]);
 const KNOWN_AUN_PAYLOAD_TYPES = new Set([
     'text',

package/dist/core/message/peer-mode.js

@@ -14,8 +14,11 @@ export function resolveChatMode(params) {
         configured = undefined;
     }
     const kind = normalizePeerType(params.peerType);
+    // 运行时硬约束（非配置项）：system/service 始终 interactive；agent 始终 proactive
     if (kind === 'system' || kind === 'service')
         return 'interactive';
+    if (kind === 'agent')
+        return 'proactive';
     const field = chatmodeFieldForPeer(params.chatType, params.peerType);
     const decision = resolveRuntimeStringField({
         selfAid: params.self,
@@ -70,9 +73,11 @@ export function isSystemOrServicePeer(peerType) {
  */
 export function resolveChatModeForPeer(params) {
     const kind = normalizePeerType(params.peerType);
-    // 运行时硬约束（非配置项）：system/service 对端始终同步交互
+    // 运行时硬约束（非配置项）：system/service 对端始终同步交互；agent 对端始终主动响应
     if (kind === 'system' || kind === 'service')
         return 'interactive';
+    if (kind === 'agent')
+        return 'proactive';
     // 合并后的场景表 → 出厂默认表
     const field = chatmodeFieldForPeer(params.chatType, params.peerType);
     return params.configured?.[field] ?? chatmodeFactoryDefaults()[field];