@myagentroam/node 0.11.29 → 0.11.30

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

@@ -30,10 +30,21 @@ export class MarAgentConversationNormalizer {
     #subagentDetails = new Map();
     #codeModeObservationIds = new Set();
     #codeModeSourceCallIds = new Set();
+    #toolOutputSnapshots = new Map();
+    #codeModeOutputCalls = new Map();
+    #codeModeOutputSnapshots = new Map();
+    #runningCodeModeCells = new Map();
+    #codeModeCellWaiters = new Map();
     messageItemId(nativeItemId) {
         return itemId('message', nativeItemId);
     }
     normalize(event, options = {}) {
+        if (event.type === 'tool.output')
+            return this.#toolOutput(event);
+        if (event.type === 'execution.started') {
+            this.#startExecution(event.executionId);
+            return [];
+        }
         if (event.type === 'input.received')
             return [this.input(event.entry)];
         if (event.type === 'execution.failed') {
@@ -93,15 +104,26 @@ export class MarAgentConversationNormalizer {
         if (event.type === 'tool.started' ||
             event.type === 'tool.completed' ||
             event.type === 'tool.failed') {
+            if (event.parentCallId !== undefined &&
+                (event.toolName === 'exec' || event.toolName === 'exec_wait')) {
+                if (event.type === 'tool.started')
+                    this.#trackCodeModeOutputCall(event);
+                else
+                    this.#finishCodeModeOutputCall(event.callId, event.parentCallId);
+                return [];
+            }
             // Read/web calls and generated artifacts stay visible independently of cell observations.
             if (event.parentCallId !== undefined &&
                 event.toolName !== 'read' &&
                 event.toolName !== 'web_search' &&
                 event.toolName !== 'web_fetch' &&
-                !isImageGenerationTool(event.toolName))
+                !isImageGenerationTool(event.toolName)) {
+                this.#finishCodeModeOutputCall(event.callId, event.parentCallId);
                 return [];
+            }
             if (event.type === 'tool.started')
                 return this.#toolStarted(event);
+            this.#finishToolCall(event);
             const permissionStop = permissionStopForToolEvent(event);
             const outerItems = event.type === 'tool.completed' ? this.#toolCompleted(event) : this.#toolFailed(event);
             return [
@@ -145,6 +167,10 @@ export class MarAgentConversationNormalizer {
     }
     #toolStarted(event) {
         const ownItemId = itemId('tool', event.callId);
+        this.#clearRetainedCodeModeCellsForOtherExecutions(event.executionId);
+        this.#toolOutputSnapshots.delete(event.callId);
+        this.#codeModeOutputCalls.delete(event.callId);
+        this.#clearCodeModeOutputSnapshots(event.callId);
         if (event.toolName === 'exec' || event.toolName === 'exec_wait') {
             const input = record(event.input) ?? {};
             const action = input.action ??
@@ -170,6 +196,9 @@ export class MarAgentConversationNormalizer {
                     input: event.input,
                     itemId: ownItemId,
                     structured: true,
+                    executionId: event.executionId,
+                    ...(event.turnId === undefined ? {} : { turnId: event.turnId }),
+                    active: true,
                     commandOrigin: event.callId
                 });
                 return [commandItem(command, 'IN_PROGRESS')];
@@ -197,6 +226,9 @@ export class MarAgentConversationNormalizer {
                             input: event.input,
                             itemId: ownItemId,
                             structured: true,
+                            executionId: event.executionId,
+                            ...(event.turnId === undefined ? {} : { turnId: event.turnId }),
+                            active: true,
                             commandOrigin: event.callId
                         });
                         return [];
@@ -206,6 +238,9 @@ export class MarAgentConversationNormalizer {
                         input: event.input,
                         itemId: ownItemId,
                         structured: true,
+                        executionId: event.executionId,
+                        ...(event.turnId === undefined ? {} : { turnId: event.turnId }),
+                        active: true,
                         commandOrigin: origin
                     });
                     return [];
@@ -222,16 +257,228 @@ export class MarAgentConversationNormalizer {
             input: event.input,
             itemId: ownItemId,
             structured: 'input' in event,
+            executionId: event.executionId,
+            ...(event.turnId === undefined ? {} : { turnId: event.turnId }),
+            active: true,
             ...(event.data === undefined ? {} : { presentationData: event.data }),
             ...(subagentTitle === undefined ? {} : { subagentTitle }),
             ...(subagentDetails === undefined ? {} : { subagentDetails })
         });
+        if (event.toolName === 'code_exec_wait')
+            this.#trackCodeModeWait(event);
         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)
         ];
     }
+    #toolOutput(event) {
+        const { callId, toolName, executionId, turnId, parentCallId, output } = event;
+        const inputOutput = [output.stdout, output.stderr].filter(Boolean).join('\n');
+        const snapshot = {
+            outputPreview: compactRunnerText(inputOutput, 10_000),
+            truncated: output.truncated || inputOutput.length > 10_000
+        };
+        if (parentCallId !== undefined)
+            return this.#codeModeToolOutput(callId, parentCallId, toolName, executionId, turnId, output.processId, snapshot);
+        const state = this.#tools.get(callId);
+        if (state === undefined ||
+            !state.active ||
+            state.toolName !== toolName ||
+            state.executionId !== executionId ||
+            (state.turnId !== undefined && turnId !== undefined && state.turnId !== turnId) ||
+            state.commandOrigin === undefined)
+            return [];
+        const input = record(state.input);
+        if (typeof input?.processId === 'string' && input.processId !== output.processId)
+            return [];
+        const command = this.#commands.get(state.commandOrigin);
+        if (command === undefined || command.status !== 'IN_PROGRESS')
+            return [];
+        this.#toolOutputSnapshots.set(callId, {
+            commandOrigin: state.commandOrigin,
+            ...snapshot
+        });
+        return [
+            commandItem(commandWithOutputSnapshots(command, [...this.#toolOutputSnapshots.values()].filter((entry) => entry.commandOrigin === state.commandOrigin)), 'IN_PROGRESS')
+        ];
+    }
+    #codeModeToolOutput(callId, parentCallId, toolName, executionId, turnId, processId, snapshot) {
+        const parent = this.#tools.get(parentCallId);
+        const child = this.#codeModeOutputCalls.get(callId);
+        if (parent === undefined ||
+            (parent.toolName !== 'code_exec' && parent.toolName !== 'code_exec_wait') ||
+            parent.executionId !== executionId ||
+            (parent.turnId !== undefined && turnId !== undefined && parent.turnId !== turnId) ||
+            child === undefined ||
+            child.parentCallId !== parentCallId ||
+            child.toolName !== toolName ||
+            child.executionId !== executionId ||
+            (child.turnId !== undefined && turnId !== undefined && child.turnId !== turnId))
+            return [];
+        const target = parent.active
+            ? parent
+            : this.#runningCodeModeCells.get(parentCallId)?.executionId === executionId
+                ? this.#activeCodeModeWaiter(this.#runningCodeModeCells.get(parentCallId))
+                : undefined;
+        if (target === undefined)
+            return [];
+        const input = record(child.input);
+        if (typeof input?.processId === 'string' && input.processId !== processId)
+            return [];
+        const snapshots = this.#codeModeOutputSnapshots.get(parentCallId) ?? new Map();
+        snapshots.set(callId, snapshot);
+        this.#codeModeOutputSnapshots.set(parentCallId, snapshots);
+        const combined = [...snapshots.values()]
+            .map((entry) => entry.outputPreview)
+            .filter(Boolean)
+            .join('\n');
+        const truncated = [...snapshots.values()].some((entry) => entry.truncated) || combined.length > 10_000;
+        return [
+            genericToolItem(target.itemId, target.toolName, 'IN_PROGRESS', target.input, compactRunnerText(combined, 10_000), null, truncated)
+        ];
+    }
+    #trackCodeModeOutputCall(event) {
+        const parentCallId = event.parentCallId;
+        if (parentCallId === undefined || (event.toolName !== 'exec' && event.toolName !== 'exec_wait'))
+            return;
+        const parent = this.#tools.get(parentCallId);
+        const retainedCell = this.#runningCodeModeCells.get(parentCallId);
+        const canResumeRetainedCell = parent !== undefined && !parent.active && retainedCell?.executionId === event.executionId;
+        if (parent === undefined ||
+            (parent.toolName !== 'code_exec' && parent.toolName !== 'code_exec_wait') ||
+            parent.executionId !== event.executionId ||
+            (parent.turnId !== undefined && event.turnId !== undefined && parent.turnId !== event.turnId))
+            return;
+        if (!parent.active && !canResumeRetainedCell)
+            return;
+        this.#codeModeOutputCalls.delete(event.callId);
+        const snapshots = this.#codeModeOutputSnapshots.get(parentCallId);
+        snapshots?.delete(event.callId);
+        this.#codeModeOutputCalls.set(event.callId, {
+            parentCallId,
+            executionId: event.executionId,
+            ...(event.turnId === undefined ? {} : { turnId: event.turnId }),
+            toolName: event.toolName,
+            input: event.input
+        });
+    }
+    #finishCodeModeOutputCall(callId, parentCallId) {
+        const call = this.#codeModeOutputCalls.get(callId);
+        if (call?.parentCallId === parentCallId) {
+            this.#codeModeOutputCalls.delete(callId);
+            this.#codeModeOutputSnapshots.get(parentCallId)?.delete(callId);
+        }
+    }
+    #trackCodeModeWait(event) {
+        const cellId = record(event.input)?.cellId;
+        if (typeof cellId !== 'string' || cellId.length === 0)
+            return;
+        const cell = [...this.#runningCodeModeCells.values()].find((candidate) => candidate.cellId === cellId && candidate.executionId === event.executionId);
+        if (cell === undefined)
+            return;
+        const waiters = this.#codeModeCellWaiters.get(cellId) ?? new Set();
+        waiters.add(event.callId);
+        this.#codeModeCellWaiters.set(cellId, waiters);
+    }
+    #activeCodeModeWaiter(cell) {
+        const waiters = this.#codeModeCellWaiters.get(cell.cellId);
+        if (waiters === undefined)
+            return undefined;
+        for (const callId of [...waiters].reverse()) {
+            const state = this.#tools.get(callId);
+            const input = record(state?.input);
+            if (state?.active === true &&
+                state.toolName === 'code_exec_wait' &&
+                state.executionId === cell.executionId &&
+                input?.cellId === cell.cellId)
+                return state;
+            waiters.delete(callId);
+        }
+        if (waiters.size === 0)
+            this.#codeModeCellWaiters.delete(cell.cellId);
+        return undefined;
+    }
+    #finishToolCall(event) {
+        const state = this.#tools.get(event.callId);
+        if (state !== undefined)
+            state.active = false;
+        this.#toolOutputSnapshots.delete(event.callId);
+        const data = record(event.data);
+        const cellId = typeof data?.cellId === 'string' ? data.cellId : undefined;
+        const status = data?.status;
+        if (state?.toolName === 'code_exec') {
+            if (event.type === 'tool.completed' &&
+                event.toolName === 'code_exec' &&
+                status === 'running' &&
+                cellId !== undefined &&
+                cellId.length > 0) {
+                this.#runningCodeModeCells.set(event.callId, {
+                    cellId,
+                    executionId: event.executionId
+                });
+                return;
+            }
+            this.#clearRunningCodeModeCell(event.callId);
+            return;
+        }
+        if (state?.toolName === 'code_exec_wait') {
+            const inputCellId = record(state.input)?.cellId;
+            if (typeof inputCellId === 'string')
+                this.#removeCodeModeWaiter(inputCellId, event.callId);
+            if ((status === 'completed' || status === 'failed' || status === 'cancelled') &&
+                typeof (cellId ?? inputCellId) === 'string') {
+                const finishedCellId = (cellId ?? inputCellId);
+                for (const [sourceCallId, cell] of this.#runningCodeModeCells)
+                    if (cell.cellId === finishedCellId && cell.executionId === event.executionId)
+                        this.#clearRunningCodeModeCell(sourceCallId);
+            }
+            this.#clearCodeModeOutputSnapshots(event.callId);
+            return;
+        }
+        this.#clearCodeModeOutputSnapshots(event.callId);
+    }
+    #clearCodeModeOutputSnapshots(parentCallId) {
+        this.#codeModeOutputSnapshots.delete(parentCallId);
+        for (const [callId, state] of this.#codeModeOutputCalls)
+            if (state.parentCallId === parentCallId)
+                this.#codeModeOutputCalls.delete(callId);
+    }
+    #removeCodeModeWaiter(cellId, callId) {
+        const waiters = this.#codeModeCellWaiters.get(cellId);
+        waiters?.delete(callId);
+        if (waiters?.size === 0)
+            this.#codeModeCellWaiters.delete(cellId);
+    }
+    #clearRunningCodeModeCell(sourceCallId) {
+        const cell = this.#runningCodeModeCells.get(sourceCallId);
+        if (cell !== undefined) {
+            this.#runningCodeModeCells.delete(sourceCallId);
+            this.#codeModeCellWaiters.delete(cell.cellId);
+        }
+        this.#clearCodeModeOutputSnapshots(sourceCallId);
+    }
+    #startExecution(executionId) {
+        for (const [callId, state] of this.#tools)
+            if (state.executionId !== executionId) {
+                state.active = false;
+                this.#toolOutputSnapshots.delete(callId);
+            }
+        for (const [callId, state] of this.#codeModeOutputCalls)
+            if (state.executionId !== executionId)
+                this.#codeModeOutputCalls.delete(callId);
+        for (const [sourceCallId, cell] of this.#runningCodeModeCells)
+            if (cell.executionId !== executionId)
+                this.#clearRunningCodeModeCell(sourceCallId);
+        for (const parentCallId of this.#codeModeOutputSnapshots.keys())
+            if (this.#tools.get(parentCallId)?.executionId !== executionId)
+                this.#codeModeOutputSnapshots.delete(parentCallId);
+    }
+    #clearRetainedCodeModeCellsForOtherExecutions(executionId) {
+        for (const [sourceCallId, cell] of this.#runningCodeModeCells)
+            if (cell.executionId !== executionId)
+                this.#clearRunningCodeModeCell(sourceCallId);
+    }
     #compactAnchorItemId(event, publicItemIdPrefix) {
         const anchor = event.anchor;
         if (anchor === undefined || !validCompactAnchor(anchor.id))
@@ -730,6 +977,21 @@ function commandItem(command, status, title) {
         merge: true
     };
 }
+function commandWithOutputSnapshots(command, snapshots) {
+    const outputPreview = [
+        command.outputPreview,
+        ...snapshots.map((snapshot) => snapshot.outputPreview)
+    ]
+        .filter(Boolean)
+        .join('\n');
+    return {
+        ...command,
+        outputPreview: compactRunnerText(outputPreview, 10_000),
+        truncated: command.truncated ||
+            snapshots.some((snapshot) => snapshot.truncated) ||
+            outputPreview.length > 10_000
+    };
+}
 function applyCommandResult(command, result) {
     const output = [result.stdout, result.stderr].filter(Boolean).join('\n');
     if (output.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.11.29",
+  "version": "0.11.30",
   "description": "MyAgentRoam Node runtime CLI.",
   "license": "Apache-2.0 AND GPL-2.0-or-later",
   "type": "module",
@@ -38,10 +38,10 @@
     "sharp": "0.35.5",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/agent": "0.11.29",
+    "@myagentroam/agent": "0.11.30",
     "@myagentroam/code-navigation": "0.11.0",
-    "@myagentroam/protocol": "0.11.29",
-    "@myagentroam/marctl": "0.11.1"
+    "@myagentroam/marctl": "0.11.1",
+    "@myagentroam/protocol": "0.11.30"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"