@myagentroam/node 0.11.44 → 0.11.45

package/dist/runner/mar-agent/agent-operation-presentation.js

@@ -0,0 +1,167 @@
+import { agentOperationPresentationSchema } from '@myagentroam/protocol';
+import { isPlainRecord } from '../../util/records.js';
+const actions = {
+    agent_start: 'START',
+    agent_send: 'SEND',
+    agent_wait: 'WAIT',
+    agent_stop: 'STOP',
+    agent_list: 'LIST',
+    agent_view: 'VIEW'
+};
+export function agentOperationAction(toolName) {
+    return Object.hasOwn(actions, toolName) ? actions[toolName] : undefined;
+}
+function text(value, max = 128) {
+    return typeof value === 'string' && value.trim()
+        ? value.slice(0, max).replace(/[\uD800-\uDBFF]$/u, '')
+        : undefined;
+}
+function latestWaitMessage(updates) {
+    if (!Array.isArray(updates))
+        return undefined;
+    const message = updates.findLast((entry) => isPlainRecord(entry) && entry.kind === 'message' && typeof entry.value === 'string');
+    if (!isPlainRecord(message))
+        return undefined;
+    const value = text(message.value, 800);
+    if (!value)
+        return undefined;
+    return {
+        value,
+        ...(message.final === true ? { final: true } : {}),
+        ...(message.truncated === true || message.value.length > 800
+            ? { truncated: true }
+            : {})
+    };
+}
+/** Input identities are display-only; only successful Node results establish navigation. */
+export function agentOperationPresentation(toolName, input, data) {
+    const action = agentOperationAction(toolName);
+    if (!action)
+        return undefined;
+    const parsed = agentOperationPresentationSchema.safeParse(isPlainRecord(data) ? data.agentOperation : undefined);
+    if (parsed.success && parsed.data.action === action)
+        return parsed.data;
+    const value = isPlainRecord(input) ? input : {};
+    const ids = typeof value.agentId === 'string'
+        ? [value.agentId]
+        : Array.isArray(value.agentIds)
+            ? value.agentIds
+            : [];
+    return {
+        action,
+        targets: ids
+            .filter((id) => typeof id === 'string' && id.length > 0 && id.length <= 128)
+            .slice(0, 8)
+            .map((agentId) => ({ agentId })),
+        ...(text(value.scope, 32) ? { scope: text(value.scope, 32) } : {})
+    };
+}
+/** Whitelist public receipts; never serialize configuration, credentials or full history. */
+export function agentOperationEvent(action, input, result) {
+    const operation = agentOperationPresentation(`agent_${action}`, input);
+    const value = isPlainRecord(result) ? result : {};
+    const args = isPlainRecord(input) ? input : {};
+    const rows = action === 'list' ? value.sessions : action === 'wait' ? value.agents : undefined;
+    const records = Array.isArray(rows)
+        ? rows
+        : action === 'list'
+            ? []
+            : action === 'view'
+                ? isPlainRecord(value.session)
+                    ? [value.session]
+                    : []
+                : typeof value.agentId === 'string'
+                    ? [value]
+                    : [];
+    const returnedTargets = records
+        .flatMap((entry) => {
+        if (!isPlainRecord(entry))
+            return [];
+        const rawId = entry.agentId ?? entry.id;
+        const agentId = typeof rawId === 'string' && rawId.length <= 128 ? text(rawId) : undefined;
+        if (!agentId)
+            return [];
+        const title = text(entry.title ?? (action === 'start' ? args.title : undefined), 500);
+        return [{ agentId, sessionId: agentId, ...(title ? { title } : {}) }];
+    })
+        .slice(0, 100);
+    // An any-wait may return one result for several requested targets; keep the call multi-target.
+    const targets = action === 'wait' && operation.targets.length > 0
+        ? operation.targets.map((target) => returnedTargets.find((result) => result.agentId === target.agentId) ?? target)
+        : returnedTargets;
+    const presentation = { ...operation, targets };
+    if (records.length > returnedTargets.length)
+        presentation.targetsTruncated = true;
+    // Core accepts at most 8 KiB of explicit extension event data.
+    while (Buffer.byteLength(JSON.stringify({ agentOperation: presentation }), 'utf8') > 7000) {
+        targets.pop();
+        presentation.targetsTruncated = true;
+    }
+    const receipt = {};
+    if (action === 'list' && Array.isArray(value.models)) {
+        receipt.runner = text(value.runner);
+        receipt.modelCount = value.models.length;
+    }
+    if (action === 'view' && isPlainRecord(value.session)) {
+        for (const key of ['status', 'model', 'effort']) {
+            const field = text(value.session[key]);
+            if (field)
+                receipt[key] = field;
+        }
+        const message = isPlainRecord(value.session.latestMessage)
+            ? value.session.latestMessage
+            : undefined;
+        const messageText = text(message?.text, 800);
+        if (messageText)
+            receipt.latestMessage = {
+                text: messageText,
+                truncated: message?.truncated === true || messageText !== message?.text
+            };
+    }
+    for (const key of ['status', 'waitOutcome', 'waitFor', 'mode', 'reason', 'executionId']) {
+        const field = text(value[key]);
+        if (field)
+            receipt[key] = field;
+    }
+    for (const key of ['message', 'cancel', 'goal', 'approval', 'observation']) {
+        const item = value[key];
+        if (!isPlainRecord(item))
+            continue;
+        receipt[key] = {
+            ...(text(item.status) ? { status: text(item.status) } : {}),
+            ...(text(item.code) ? { code: text(item.code) } : {}),
+            ...(isPlainRecord(item.result) && text(item.result.delivery)
+                ? { delivery: text(item.result.delivery) }
+                : {})
+        };
+    }
+    if (Array.isArray(rows))
+        receipt.count = rows.length;
+    if (action === 'wait' && Array.isArray(rows))
+        receipt.agents = rows.slice(0, 8).map((entry) => {
+            const agent = isPlainRecord(entry) ? entry : {};
+            return {
+                agentId: text(agent.agentId),
+                status: text(agent.status),
+                waitOutcome: text(agent.waitOutcome),
+                summary: text(agent.summary, 800),
+                latestMessage: latestWaitMessage(agent.updates),
+                ...(agent.summaryTruncated === true ||
+                    (typeof agent.summary === 'string' && agent.summary.length > 800)
+                    ? { summaryTruncated: true }
+                    : {})
+            };
+        });
+    if (action === 'wait' && !Array.isArray(rows))
+        receipt.latestMessage = latestWaitMessage(value.updates);
+    const summary = text(value.summary, 4000);
+    if (summary)
+        receipt.summary = summary;
+    if (value.summaryTruncated === true ||
+        (typeof value.summary === 'string' && value.summary.length > 4000))
+        receipt.summaryTruncated = true;
+    return {
+        eventData: { agentOperation: presentation },
+        eventSummary: JSON.stringify(receipt)
+    };
+}

package/dist/runner/mar-agent/conversation-normalizer.js

@@ -7,8 +7,9 @@ export function normalizeMarAgentUsage(usage) {
 import { boundedConversationItemId, compactRunnerText, compactRunnerValue } from '../normalization.js';
 import { runnerErrorProjection } from '../runner-error.js';
 import { toolPresentationSchema } from '@myagentroam/protocol';
-import { boundExecutionPresentation } from '../execution-presentation.js';
-import { publicOutputSnapshot } from '../normalization.js';
+import { publicOutputSnapshot, publicToolOutput } from '../normalization.js';
+import { boundToolOutput } from '@myagentroam/protocol';
+import { agentOperationAction, agentOperationPresentation } from './agent-operation-presentation.js';
 function boundCodeOutputSnapshots(sources) {
     for (const channel of ['outputPreview', 'stdout', 'stderr']) {
         const text = (entry) => channel === 'outputPreview' ? entry.outputPreview : entry.displayOutput[channel];
@@ -147,15 +148,18 @@ export class MarAgentConversationNormalizer {
                     this.#finishCodeModeOutputCall(event.callId, event.parentCallId);
                 return [];
             }
-            // Read/web calls and generated artifacts stay visible independently of cell observations.
+            // Public Agent calls, read/web calls and artifacts do not depend on model observations.
             if (event.parentCallId !== undefined &&
                 event.toolName !== 'read' &&
                 event.toolName !== 'web_search' &&
                 event.toolName !== 'web_fetch' &&
+                agentOperationAction(event.toolName) === undefined &&
                 !isImageGenerationTool(event.toolName)) {
                 this.#finishCodeModeOutputCall(event.callId, event.parentCallId);
                 return [];
             }
+            if (event.parentCallId !== undefined && agentOperationAction(event.toolName) !== undefined)
+                this.#codeModeSourceCallIds.add(event.callId);
             if (event.type === 'tool.started')
                 return this.#toolStarted(event);
             this.#finishToolCall(event);
@@ -252,6 +256,7 @@ export class MarAgentConversationNormalizer {
             input: event.input,
             itemId: ownItemId,
             structured: 'input' in event,
+            inputTruncated: event.truncated === true,
             executionId: event.executionId,
             ...(event.turnId === undefined ? {} : { turnId: event.turnId }),
             active: true,
@@ -264,7 +269,7 @@ export class MarAgentConversationNormalizer {
         if (event.toolName === 'apply_patch' && 'input' in event)
             return [fileChangeItem(ownItemId, 'IN_PROGRESS', [])];
         return [
-            genericToolItem(ownItemId, event.toolName, 'IN_PROGRESS', event.input, null, null, event.truncated === true, event.data, subagentTitle, subagentDetails)
+            genericToolItem(ownItemId, event.toolName, 'IN_PROGRESS', event.input, null, null, event.truncated === true, event.data, subagentTitle, subagentDetails, undefined, undefined, event.truncated === true)
         ];
     }
     #toolOutput(event) {
@@ -279,14 +284,13 @@ export class MarAgentConversationNormalizer {
             stderrDroppedBytes: 0
         };
         const displayed = [displayOutput.stdout, displayOutput.stderr].filter(Boolean).join('\n');
-        const bounded = publicOutputSnapshot(displayed, output.truncated ||
-            displayOutput.stdoutDroppedBytes > 0 ||
-            displayOutput.stderrDroppedBytes > 0);
+        const bounded = publicOutputSnapshot(displayed, event.outputTruncation !== undefined);
         const snapshot = {
             outputPreview: bounded.text,
             truncated: bounded.truncated || inputOutput.length > 10_000,
             displayOutput,
-            processId: output.processId
+            processId: output.processId,
+            ...(event.outputTruncation ? { outputTruncation: event.outputTruncation } : {})
         };
         if (parentCallId !== undefined && (toolName === 'exec' || toolName === 'exec_wait'))
             return this.#codeModeToolOutput(callId, parentCallId, toolName, executionId, turnId, output.processId, snapshot);
@@ -309,7 +313,7 @@ export class MarAgentConversationNormalizer {
                     displayOutput: snapshot.displayOutput,
                     outputHeadTruncated: snapshot.displayOutput.stdoutDroppedBytes > 0 ||
                         snapshot.displayOutput.stderrDroppedBytes > 0
-                })
+                }, undefined, undefined, undefined, event.outputTruncation, state.inputTruncated)
             ];
         }
         const command = this.#commands.get(state.commandOrigin);
@@ -320,6 +324,10 @@ export class MarAgentConversationNormalizer {
             command.displayOutput = display;
         command.outputPreview = snapshot.outputPreview;
         command.truncated = snapshot.truncated;
+        if (event.outputTruncation)
+            command.outputTruncation = event.outputTruncation;
+        else
+            delete command.outputTruncation;
         return [commandItem(command, 'IN_PROGRESS')];
     }
     #toolOutputDelta(event) {
@@ -375,26 +383,11 @@ export class MarAgentConversationNormalizer {
         const command = target.commandOrigin === undefined ? undefined : this.#commands.get(target.commandOrigin);
         const item = command
             ? commandItem(command, 'IN_PROGRESS')
-            : genericToolItem(target.itemId, target.toolName, 'IN_PROGRESS', target.input, null, null);
-        const original = record(record(item.payload.toolPresentation)?.execution);
+            : genericToolItem(target.itemId, target.toolName, 'IN_PROGRESS', target.input, null, null, false, undefined, undefined, undefined, undefined, undefined, target.inputTruncated);
         const blocks = [
             ...(output.stdout ? [{ channel: 'STDOUT', text: output.stdout }] : []),
             ...(output.stderr ? [{ channel: 'STDERR', text: output.stderr }] : [])
         ];
-        const text = [output.stdout, output.stderr].filter(Boolean).join('\n');
-        const boundedText = publicOutputSnapshot(text, output.truncated);
-        const bounded = boundExecutionPresentation({
-            kind: parentCallId !== undefined
-                ? target.toolName === 'code_exec'
-                    ? 'CODE'
-                    : 'CONTROL'
-                : toolName === 'exec'
-                    ? 'SHELL'
-                    : 'CONTROL',
-            ...(typeof original?.toolName === 'string' ? { toolName: original.toolName } : {}),
-            output: blocks,
-            ...(output.truncated ? { truncation: { output: 'HEAD' } } : {})
-        });
         return [
             {
                 ...item,
@@ -402,9 +395,7 @@ export class MarAgentConversationNormalizer {
                 merge: true,
                 payload: {
                     ...item.payload,
-                    outputPreview: boundedText.text,
-                    output: boundedText,
-                    toolPresentation: bounded.presentation
+                    output: boundToolOutput(blocks, event.outputTruncation)
                 }
             }
         ];
@@ -458,7 +449,13 @@ export class MarAgentConversationNormalizer {
                         .filter(Boolean)
                         .join('')
                 }
-            })
+            }, undefined, undefined, undefined, entries.some((entry) => entry.outputTruncation === 'SOURCE')
+                ? 'SOURCE'
+                : entries.some((entry) => entry.outputTruncation === 'HEAD' ||
+                    entry.displayOutput.stdoutDroppedBytes > 0 ||
+                    entry.displayOutput.stderrDroppedBytes > 0)
+                    ? 'HEAD'
+                    : undefined, target.inputTruncated)
         ];
     }
     #trackCodeModeOutputCall(event) {
@@ -626,9 +623,13 @@ export class MarAgentConversationNormalizer {
         const state = this.#tools.get(event.callId);
         if (event.toolName === 'exec' && state?.commandOrigin !== undefined) {
             const command = this.#commands.get(state.commandOrigin);
-            const result = execResult(event.data, event.summary, event.truncated === true);
+            const result = execResult(event.data, event.summary, event.outputTruncation !== undefined);
             if (command !== undefined && result !== undefined) {
                 applyCommandResult(command, result);
+                if (event.outputTruncation)
+                    command.outputTruncation = event.outputTruncation;
+                else
+                    delete command.outputTruncation;
                 const data = record(event.data);
                 const display = execDisplayOutput(data?.displayOutput);
                 if (display !== undefined)
@@ -672,7 +673,7 @@ export class MarAgentConversationNormalizer {
         }
         const item = genericToolItem(state?.itemId ?? itemId('tool', event.callId), event.toolName, 'COMPLETED', state?.input, generatedImages.length === 0
             ? event.summary
-            : generatedImages.map((image) => image.name).join(', '), null, event.truncated, event.data, agentId === undefined ? state?.subagentTitle : this.#subagentTitles.get(agentId), details, state?.sleepStartedAt);
+            : generatedImages.map((image) => image.name).join(', '), null, event.outputTruncation !== undefined, event.data, agentId === undefined ? state?.subagentTitle : this.#subagentTitles.get(agentId), details, state?.sleepStartedAt, event.outputTruncation, state?.inputTruncated, event.summaryTruncated === true);
         return [
             {
                 ...item,
@@ -703,7 +704,7 @@ export class MarAgentConversationNormalizer {
         return [
             genericToolItem(state?.itemId ?? itemId('tool', event.callId), event.toolName, event.code === 'MAR_AGENT_CANCELLED' || event.code === 'MAR_AGENT_EXECUTION_CANCELLED'
                 ? 'CANCELLED'
-                : 'FAILED', state?.input, event.message ?? event.code, event.code, event.truncated === true, state?.presentationData, state?.subagentTitle, state?.subagentDetails, state?.sleepStartedAt)
+                : 'FAILED', state?.input, event.message ?? event.code, event.code, event.truncated === true, state?.presentationData, state?.subagentTitle, state?.subagentDetails, state?.sleepStartedAt, event.outputTruncation, state?.inputTruncated)
         ];
     }
     #codeModeToolResults(event) {
@@ -1026,33 +1027,30 @@ function codeExecutionError(data) {
         message: compactRunnerText(error.message, 1000)
     };
 }
-function genericToolItem(id, toolName, status, input, outputSummary = null, errorCode = null, truncated = false, output, subagentTitle, knownSubagentDetails, sleepStartedAt) {
+function genericToolItem(id, toolName, status, input, outputSummary = null, errorCode = null, truncated = false, output, subagentTitle, knownSubagentDetails, sleepStartedAt, outputTruncation, inputTruncated = false, summaryTruncated = false) {
     if (toolName === 'code_exec') {
         const code = typeof input === 'string' ? input : record(input)?.code;
         const source = typeof code === 'string' ? code : compactRunnerValue(input, 10_000).text || toolName;
         const resultData = record(output);
-        const codeOutput = codeObservationOutput(resultData, outputSummary);
+        const codeOutput = codeObservationOutput(resultData, null);
         const resultError = codeExecutionError(resultData);
         const preview = errorCode === null
             ? (outputSummary ?? '')
             : [errorCode, outputSummary].filter(Boolean).join(': ');
-        return commandItem({
+        const item = commandItem({
             itemId: id,
             command: compactRunnerText(source, 10_000),
             cwd: null,
-            outputPreview: compactRunnerText(preview, 10_000),
+            outputPreview: '',
             exitCode: null,
-            truncated: truncated ||
-                resultData?.truncated === true ||
-                source.length > 10_000 ||
-                preview.length > 10_000
+            truncated: truncated || source.length > 10_000 || preview.length > 10_000
         }, status, 'Code execution', {
             kind: 'CODE',
-            ...(source.length > 10_000 || resultData?.outputHeadTruncated === true
+            ...(source.length > 10_000 || inputTruncated || outputTruncation !== undefined
                 ? {
                     truncation: {
-                        ...(source.length > 10_000 ? { input: true } : {}),
-                        ...(resultData?.outputHeadTruncated === true ? { output: 'HEAD' } : {})
+                        ...(source.length > 10_000 || inputTruncated ? { input: true } : {}),
+                        ...(outputTruncation === undefined ? {} : { output: outputTruncation })
                     }
                 }
                 : {}),
@@ -1068,6 +1066,12 @@ function genericToolItem(id, toolName, status, input, outputSummary = null, erro
                 }),
             ...(codeOutput === undefined ? {} : { output: codeOutput })
         }, toolName);
+        if (codeOutput === undefined && errorCode === null && outputSummary !== null) {
+            item.payload.outputSummary = compactRunnerText(outputSummary, 10_000);
+            if (summaryTruncated || outputSummary.length > 10_000)
+                item.payload.outputSummaryTruncated = true;
+        }
+        return item;
     }
     if (toolName === 'code_exec_wait' || toolName === 'exec_wait') {
         const inputRecord = record(input);
@@ -1081,40 +1085,17 @@ function genericToolItem(id, toolName, status, input, outputSummary = null, erro
                 ? [{ channel: 'STDERR', text: resultData.stderr }]
                 : [])
         ];
-        const codeOutput = toolName === 'code_exec_wait' ? codeObservationOutput(resultData, outputSummary) : undefined;
+        const codeOutput = toolName === 'code_exec_wait' ? codeObservationOutput(resultData, null) : undefined;
         const resultError = toolName === 'code_exec_wait' ? codeExecutionError(resultData) : undefined;
         const action = typeof inputRecord?.action === 'string' ? inputRecord.action : 'poll';
         const inputSummary = compactRunnerValue(input, 10_000);
-        const result = output === undefined ? null : compactRunnerValue(output, 10_000);
-        const resultSummary = [outputSummary, result?.text]
-            .filter((value, index, values) => typeof value === 'string' && value.length > 0 && values.indexOf(value) === index)
-            .join('\n');
-        const details = [
-            `Action: ${compactRunnerText(action, 128)}`,
-            `Input: ${inputSummary.text || '{}'}`,
-            resultSummary.length === 0 ? '' : `Result: ${compactRunnerText(resultSummary, 10_000)}`,
-            errorCode === null ? '' : `Error: ${compactRunnerText(errorCode, 80)}`
-        ]
-            .filter(Boolean)
-            .join('\n');
-        return commandItem({
+        const item = commandItem({
             itemId: id,
             command: '',
             cwd: null,
-            outputPreview: status === 'IN_PROGRESS' && outputSummary !== null
-                ? outputSummary
-                : legacyBlocks.length > 0
-                    ? legacyBlocks
-                        .map((block) => block.text)
-                        .filter(Boolean)
-                        .join('\n')
-                    : details,
+            outputPreview: '',
             exitCode: typeof resultData?.exitCode === 'number' ? resultData.exitCode : null,
-            truncated: truncated ||
-                resultData?.truncated === true ||
-                inputSummary.truncated ||
-                result?.truncated === true ||
-                resultSummary.length > 10_000
+            truncated: truncated || inputSummary.truncated
         }, status, toolName === 'code_exec_wait' ? 'Code execution wait' : 'Command wait', {
             kind: 'CONTROL',
             toolName,
@@ -1135,21 +1116,21 @@ function genericToolItem(id, toolName, status, input, outputSummary = null, erro
                 }),
             ...(display === undefined && legacyBlocks.length > 0 ? { output: legacyBlocks } : {}),
             ...(codeOutput === undefined ? {} : { output: codeOutput }),
-            ...((typeof inputRecord?.data === 'string' && inputRecord.data.length > 10_000) ||
-                resultData?.outputHeadTruncated === true ||
-                (display !== undefined && (display.stdoutDroppedBytes || display.stderrDroppedBytes)) ||
-                (display === undefined && legacyBlocks.length > 0 && truncated)
+            ...(inputTruncated ||
+                (typeof inputRecord?.data === 'string' && inputRecord.data.length > 10_000) ||
+                outputTruncation !== undefined ||
+                (display !== undefined && (display.stdoutDroppedBytes || display.stderrDroppedBytes))
                 ? {
                     truncation: {
-                        ...(typeof inputRecord?.data === 'string' && inputRecord.data.length > 10_000
+                        ...(inputTruncated ||
+                            (typeof inputRecord?.data === 'string' && inputRecord.data.length > 10_000)
                             ? { input: true }
                             : {}),
-                        ...(resultData?.outputHeadTruncated === true ||
-                            (display !== undefined &&
-                                (display.stdoutDroppedBytes || display.stderrDroppedBytes))
-                            ? { output: 'HEAD' }
-                            : display === undefined && legacyBlocks.length > 0 && truncated
-                                ? { output: 'SOURCE' }
+                        ...(outputTruncation !== undefined
+                            ? { output: outputTruncation }
+                            : display !== undefined &&
+                                (display.stdoutDroppedBytes || display.stderrDroppedBytes)
+                                ? { output: 'HEAD' }
                                 : {})
                     }
                 }
@@ -1165,8 +1146,32 @@ function genericToolItem(id, toolName, status, input, outputSummary = null, erro
                     }
                 })
         });
+        if (display === undefined &&
+            legacyBlocks.length === 0 &&
+            codeOutput === undefined &&
+            errorCode === null &&
+            outputSummary !== null) {
+            item.payload.outputSummary = compactRunnerText(outputSummary, 10_000);
+            if (summaryTruncated || outputSummary.length > 10_000)
+                item.payload.outputSummaryTruncated = true;
+        }
+        return item;
     }
     const subagent = marAgentSubagentProjection(toolName, input, output, subagentTitle, knownSubagentDetails);
+    const agentOperation = agentOperationPresentation(toolName, input, output);
+    if (agentOperation &&
+        record(output)?.agentOperation === undefined &&
+        typeof subagent?.subagentId === 'string') {
+        agentOperation.targets = [
+            {
+                agentId: subagent.subagentId,
+                ...(typeof subagent.subagentSessionId === 'string'
+                    ? { sessionId: subagent.subagentSessionId }
+                    : {}),
+                ...(typeof subagent.title === 'string' ? { title: subagent.title } : {})
+            }
+        ];
+    }
     const toolCategory = isImageGenerationTool(toolName) ? 'IMAGE_GENERATION' : undefined;
     const presentation = projectToolPresentation(toolName, input, output, sleepStartedAt);
     const inputSummary = compactRunnerValue(input, 10_000);
@@ -1179,13 +1184,20 @@ function genericToolItem(id, toolName, status, input, outputSummary = null, erro
             toolName: compactRunnerText(toolName, 128) || 'unknown',
             title: compactRunnerText(toolName, 500) || 'unknown',
             inputSummary: inputSummary.text || null,
-            outputSummary: outputSummary === null ? null : compactRunnerText(outputSummary, 10_000),
-            ...(outputSummary === null ? {} : { output: publicOutputSnapshot(outputSummary, truncated) }),
+            outputSummary: typeof output === 'string' || errorCode !== null ? null : outputSummary,
+            ...(typeof output === 'string' ? { output: publicToolOutput(output, outputTruncation) } : {}),
+            ...(typeof output !== 'string' && outputSummary !== null && summaryTruncated
+                ? { outputSummaryTruncated: true }
+                : {}),
             progressLabel: status === 'IN_PROGRESS' ? 'Running' : null,
             errorCode: errorCode === null ? null : compactRunnerText(errorCode, 80),
-            truncated: truncated || inputSummary.truncated || (outputSummary?.length ?? 0) > 10_000,
+            ...(errorCode !== null && outputSummary
+                ? { errorMessage: compactRunnerText(outputSummary, 1000) }
+                : {}),
+            ...(inputTruncated || inputSummary.truncated ? { inputTruncated: true } : {}),
             ...(toolCategory === undefined ? {} : { toolCategory }),
             ...(presentation === undefined ? {} : { toolPresentation: presentation }),
+            ...(agentOperation === undefined ? {} : { agentOperation }),
             ...subagent
         },
         merge: true
@@ -1294,7 +1306,14 @@ function commandItem(command, status, title, execution, toolName = 'exec') {
                 ]
             })
     };
-    const bounded = boundExecutionPresentation({ toolName, ...detail });
+    const { output: detailOutput, truncation, ...executionMetadata } = detail;
+    const blocks = detailOutput ??
+        (!detail.error && command.outputPreview
+            ? [{ channel: 'COMBINED', text: command.outputPreview }]
+            : undefined);
+    const output = blocks === undefined
+        ? undefined
+        : boundToolOutput(blocks, command.outputTruncation ?? truncation?.output);
     return {
         itemId: command.itemId,
         kind: 'command_execution',
@@ -1303,22 +1322,17 @@ function commandItem(command, status, title, execution, toolName = 'exec') {
             ...(title === undefined ? {} : { title }),
             command: command.command,
             cwd: command.cwd,
-            outputPreview: command.outputPreview,
-            output: {
-                text: publicOutputSnapshot(bounded.presentation.execution.output
-                    ?.map((block) => block.text)
-                    .filter(Boolean)
-                    .join('\n') ?? command.outputPreview).text,
-                truncated: command.truncated || bounded.truncated
-            },
+            ...(output === undefined ? {} : { output }),
             exitCode: command.exitCode,
             durationMs: null,
-            truncated: command.truncated ||
-                command.inputTruncated === true ||
-                bounded.truncated ||
-                (display !== undefined &&
-                    (display.stdoutDroppedBytes > 0 || display.stderrDroppedBytes > 0)),
-            toolPresentation: bounded.presentation
+            toolPresentation: {
+                kind: 'EXECUTION',
+                execution: {
+                    toolName,
+                    ...executionMetadata,
+                    ...(truncation?.input ? { truncation: { input: true } } : {})
+                }
+            }
         },
         merge: true
     };
@@ -1421,8 +1435,8 @@ function execResult(value, summary, eventTruncated = false) {
         ...(exitCode === undefined ? {} : { exitCode }),
         ...(data?.cached === true || summaryData?.cached === true ? { cached: true } : {}),
         truncated: eventTruncated ||
-            data?.truncated === true ||
-            summaryData?.truncated === true ||
+            (execDisplayOutput(data?.displayOutput) === undefined && data?.truncated === true) ||
+            (data === undefined && summaryData?.truncated === true) ||
             structuredSummaryIncomplete
     };
 }
@@ -1458,14 +1472,11 @@ function marAgentSubagentProjection(toolName, input, output, knownTitle, knownDe
         ...(title.length === 0 ? {} : { title }),
         ...subagentPayload(details),
         ...(typeof details.latestMessage?.text === 'string'
-            ? {
-                outputSummary: boundedToolSummary(details.latestMessage.text),
-                output: publicOutputSnapshot(details.latestMessage.text, details.latestMessage.truncated === true)
-            }
+            ? { outputSummary: null, output: undefined }
             : typeof outputData?.errorMessage === 'string'
                 ? {
-                    outputSummary: compactRunnerText(outputData.errorMessage, 10_000),
-                    output: publicOutputSnapshot(outputData.errorMessage)
+                    outputSummary: null,
+                    output: publicToolOutput(outputData.errorMessage)
                 }
                 : {}),
         ...(typeof outputData?.errorCode === 'string'

package/dist/runner/normalization.js

@@ -1,3 +1,4 @@
+import { boundToolOutput } from '@myagentroam/protocol';
 export function compactRunnerText(value, limit) {
     return value.length <= limit ? value : `${value.slice(0, Math.max(0, limit - 1))}…`;
 }
@@ -9,6 +10,10 @@ export function publicOutputSnapshot(value, truncated = false) {
         bounded = bounded.slice(1);
     return { text: bounded, truncated: truncated || text.length > 10_000 };
 }
+export function publicToolOutput(value, truncation, channel = 'TEXT') {
+    const text = typeof value === 'string' ? value : compactRunnerValue(value, Number.MAX_SAFE_INTEGER).text;
+    return boundToolOutput(text ? [{ channel, text }] : [], truncation);
+}
 export function compactRunnerValue(value, limit) {
     if (value === undefined || value === null)
         return { text: '', truncated: false };