@myagentroam/agent 0.11.43 → 0.11.44

package/dist/tools/code-mode/cells.d.ts

@@ -3,7 +3,7 @@ import type { ToolExecutionContext, ToolExecutionResult } from '../contracts.js'
 import type { CodeObservation, CodeToolCallRecord } from '../../session/code-observation-contract.js';
 export interface CellOutput {
     call(value: CodeToolCallRecord): void;
-    observe(value: CodeObservation): void;
+    observe(value: CodeObservation, display?: CodeObservation, displayHeadTruncated?: boolean): void;
     text(value: string, originalBytes?: number): void;
     image(value: NonNullable<ToolExecutionResult['images']>[number]): void;
     yield(): void;

package/dist/tools/code-mode/cells.js

@@ -6,6 +6,7 @@ import { TOOL_EXECUTION_LIMITS as limits } from '../execution-limits.js';
 import { waitForToolCondition, waitMetadata } from '../wait.js';
 import { BoundedTextOutput, renderCapturedText } from './text-output.js';
 import { boundObservations, newObservationId } from './observations.js';
+import { publicCodeObservations } from '../output-projection.js';
 import { selectObservationImages, visibleObservation } from '../../session/code-observation-projection.js';
 /** Keeps a failed tool call observable without discarding earlier explicit output. */
 export class CodeCellExecutionError extends AgentError {
@@ -214,7 +215,18 @@ export class CodeCells {
             releaseSession = await context.codeMode?.retainSession?.();
             return run(source, { ...context, signal: controller.signal, waitInterrupt: undefined }, {
                 call: (value) => cell.calls.set(value.callId, value),
-                observe: (value) => cell.observations.push(value),
+                observe: (value, display = value, displayHeadTruncated = false) => {
+                    cell.observations.push(value);
+                    const observations = [...(cell.display?.observations ?? []), display];
+                    cell.display = publicCodeObservations(observations, {
+                        cellId: cell.cellId,
+                        status: cell.status,
+                        observations,
+                        ...(cell.display?.outputHeadTruncated || displayHeadTruncated
+                            ? { outputHeadTruncated: true }
+                            : {})
+                    });
+                },
                 text: (text, originalBytes) => cell.text.append(text, originalBytes),
                 image: (image) => cell.images.push(image),
                 yield: () => {
@@ -359,7 +371,14 @@ export class CodeCells {
                         observations: visible.observations.map(visibleObservation)
                     }),
                     data,
-                    eventData: { ...data, executionSource: cell.source },
+                    eventData: {
+                        ...data,
+                        ...cell.display,
+                        status: cell.status,
+                        cached: true,
+                        ...wait,
+                        executionSource: cell.source
+                    },
                     truncated: data.truncated
                 };
             }
@@ -430,7 +449,12 @@ export class CodeCells {
             calls: [...cell.calls.values()],
             observations: remapped,
             data,
-            eventData: { ...data, executionSource: cell.source },
+            eventData: {
+                ...data,
+                ...cell.display,
+                status: cell.status,
+                executionSource: cell.source
+            },
             truncated: cell.truncated || structured.truncated,
             ...(visibleImages.length ? { images: visibleImages } : {})
         };

package/dist/tools/code-mode/dispatch.js

@@ -49,6 +49,9 @@ export function createCodeToolDispatch(input) {
                 const { eventData: _eventData, ...guestResult } = result;
                 return {
                     ...guestResult,
+                    ...((call.name === 'exec' || call.name === 'exec_wait') && data !== undefined
+                        ? { eventData: { ...data } }
+                        : {}),
                     content: bounded.content,
                     truncated: result.truncated === true || bounded.truncated
                 };

package/dist/tools/code-mode/engine.d.ts

@@ -41,6 +41,8 @@ export interface CodeModeEngine {
             format: 'text' | 'json';
             value: string;
             originalBytes: number;
+            /** Public display tail, independent of the model capture budget. */
+            displayValue?: string;
         } | {
             type: 'image';
             value: unknown;

package/dist/tools/code-mode/index.js

@@ -300,7 +300,7 @@ export class CodeModeTool {
         const images = [];
         const observations = [];
         let observationBytes = 0;
-        const appendObservation = (value, originalBytes) => {
+        const appendObservation = (value, originalBytes, display) => {
             const capture = new BoundedTextOutput(Math.max(0, limits.codeMaxOutputBytes - observationBytes), '');
             const body = value.type === 'tool_result' ? value.result.content : value.value;
             capture.append(body);
@@ -323,7 +323,10 @@ export class CodeModeTool {
                     truncated: value.truncated === true || bounded.droppedBytes > 0
                 };
             observations.push(observation);
-            output?.observe(observation);
+            output?.observe(observation, display ?? value, display !== undefined &&
+                (display.type === 'tool_result'
+                    ? display.result.truncated === true
+                    : display.truncated === true));
         };
         const toolResults = new Map();
         let transportBytes = 0;
@@ -389,6 +392,7 @@ export class CodeModeTool {
                     return index;
                 };
                 let observation;
+                let displayObservation;
                 if (value.type === 'tool_result' && typeof value.operationId === 'string') {
                     const original = toolResults.get(value.operationId);
                     if (!original)
@@ -423,6 +427,23 @@ export class CodeModeTool {
                             ...(indices?.length ? { imageIndices: indices } : {})
                         }
                     };
+                    const display = original.result.eventData?.displayOutput;
+                    if ((original.source.toolName === 'exec' || original.source.toolName === 'exec_wait') &&
+                        display !== null &&
+                        typeof display === 'object' &&
+                        'stdout' in display &&
+                        'stderr' in display &&
+                        typeof display.stdout === 'string' &&
+                        typeof display.stderr === 'string')
+                        displayObservation = {
+                            ...observation,
+                            result: {
+                                content: '',
+                                data: { stdout: display.stdout, stderr: display.stderr },
+                                truncated: ('stdoutDroppedBytes' in display && Number(display.stdoutDroppedBytes) > 0) ||
+                                    ('stderrDroppedBytes' in display && Number(display.stderrDroppedBytes) > 0)
+                            }
+                        };
                 }
                 else if (value.type === 'image') {
                     observation = {
@@ -444,12 +465,22 @@ export class CodeModeTool {
                         truncated: typeof value.originalBytes === 'number' &&
                             value.originalBytes > Buffer.byteLength(value.value)
                     };
+                    if (typeof value.displayValue === 'string') {
+                        if (Buffer.byteLength(value.displayValue) > 10_000)
+                            throw new AgentError('MAR_AGENT_CODE_PROTOCOL_ERROR', 'Code Mode sent oversized display text.');
+                        displayObservation = {
+                            ...observation,
+                            value: value.displayValue,
+                            truncated: typeof value.originalBytes === 'number' &&
+                                value.originalBytes > Buffer.byteLength(value.displayValue)
+                        };
+                    }
                 }
                 else
                     throw new AgentError('MAR_AGENT_CODE_PROTOCOL_ERROR', 'Invalid observation frame.');
                 appendObservation(observation, value.type === 'value' && typeof value.originalBytes === 'number'
                     ? value.originalBytes
-                    : undefined);
+                    : undefined, displayObservation);
             }
             else if (frame.kind === 'text' && typeof frame.value === 'string') {
                 const originalBytes = frame.originalBytes ?? Buffer.byteLength(frame.value);
@@ -527,10 +558,11 @@ export class CodeModeTool {
                                     : undefined
                             }
                         });
-                        const { content, ...structured } = output;
+                        const { eventData: _eventData, ...guestOutput } = output;
+                        const { content, ...structured } = guestOutput;
                         const projected = output.data !== undefined && content === JSON.stringify(output.data)
                             ? structured
-                            : output;
+                            : guestOutput;
                         await write({ id, ok: true, output: projected });
                     }
                     catch (error) {

package/dist/tools/code-mode/quickjs-engine.js

@@ -354,6 +354,7 @@ export async function createCodeModeEngine(options) {
                 }
                 const separatorBytes = textCalls ? 1 : 0;
                 const capture = new BoundedTextOutput(Math.max(0, input.limits.outputBytes - outputBytes - separatorBytes), '');
+                const display = new BoundedTextOutput(10_000, '', 'tail');
                 const emit = vm.newFunction('textChunk', (chunk) => {
                     if (!chunk || vm.typeof(chunk) !== 'string')
                         return {
@@ -366,7 +367,9 @@ export async function createCodeModeEngine(options) {
                         return {
                             error: guestError('MAR_AGENT_TOOL_OUTPUT_LIMIT', 'Text serialization chunk limit exceeded.')
                         };
-                    capture.append(vm.getString(chunk));
+                    const text = vm.getString(chunk);
+                    capture.append(text);
+                    display.append(text);
                     return vm.undefined;
                 });
                 const result = callGuest(formatText, vm.undefined, handle ?? vm.undefined, emit);
@@ -381,6 +384,7 @@ export async function createCodeModeEngine(options) {
                         type: 'value',
                         format: handle && vm.typeof(handle) === 'object' ? 'json' : 'text',
                         value: captured.text,
+                        displayValue: display.snapshot().text,
                         originalBytes: captured.originalBytes
                     });
                 }

package/dist/tools/code-mode/text-output.d.ts

@@ -1,9 +1,10 @@
 export function renderCapturedText(snapshot: any, imageCount?: number): string;
 /** Bounded UTF-8 capture shared by trusted engines, the bridge and retained cells. */
 export class BoundedTextOutput {
-    constructor(maximumBytes: any, separator?: string);
+    constructor(maximumBytes: any, separator?: string, retention?: string);
     maximumBytes: any;
     separator: string;
+    retention: string;
     append(value: any, originalBytes?: number): void;
     snapshot(): {
         text: string;

package/dist/tools/code-mode/text-output.js

@@ -6,9 +6,10 @@ export class BoundedTextOutput {
     #retained = 0;
     #hasValue = false;
     #sealed = false;
-    constructor(maximumBytes, separator = '\n') {
+    constructor(maximumBytes, separator = '\n', retention = 'head') {
         this.maximumBytes = maximumBytes;
         this.separator = separator;
+        this.retention = retention;
     }
     append(value, originalBytes = Buffer.byteLength(value)) {
         const separator = this.#hasValue ? this.separator : '';
@@ -16,10 +17,22 @@ export class BoundedTextOutput {
         this.#original += Buffer.byteLength(separator) + originalBytes;
         this.#capture(separator);
         this.#capture(value);
-        if (originalBytes > Buffer.byteLength(value))
+        if (this.retention === 'head' && originalBytes > Buffer.byteLength(value))
             this.#sealed = true;
     }
     #capture(value) {
+        if (this.retention === 'tail') {
+            let start = Math.max(0, value.length - this.maximumBytes);
+            if (start > 0 && /[\uDC00-\uDFFF]/u.test(value[start]))
+                start++;
+            const bytes = Buffer.from(this.#chunks.join('') + value.slice(start));
+            let offset = Math.max(0, bytes.length - this.maximumBytes);
+            while (offset < bytes.length && (bytes[offset] & 0xc0) === 0x80)
+                offset++;
+            this.#chunks = [bytes.subarray(offset).toString('utf8')];
+            this.#retained = bytes.length - offset;
+            return;
+        }
         const remaining = Math.max(0, this.maximumBytes - this.#used);
         if (this.#sealed || !value.length)
             return;

package/dist/tools/output-projection.d.ts

@@ -12,6 +12,8 @@ export declare function boundedModelToolOutput(toolName: string, value: string,
 };
 /** The opted-in allowlist fails closed and never mutates the invocation arguments. */
 export declare function publicToolEventInput(value: unknown, fields: readonly string[]): Readonly<Record<string, unknown>>;
+/** Explicit observations are public, but their event projection must remain bounded. */
+export declare function publicCodeObservations(values: unknown, data: CodeCellEventData): CodeCellEventData;
 /** Project only known, validated tool result shapes into public structured events. */
 export declare function structuredToolEventData(toolName: string, value: unknown): CodeCellEventData | ExecResult | ApplyPatchResult | ReadEventData | ViewImageResult | SleepResult | PublicToolMetadata | undefined;
 /** Partial patch facts are allowlisted; arbitrary error details never become public event data. */

package/dist/tools/output-projection.js

@@ -68,7 +68,7 @@ export function publicToolEventInput(value, fields) {
     }
 }
 /** Explicit observations are public, but their event projection must remain bounded. */
-function publicCodeObservations(values, data) {
+export function publicCodeObservations(values, data) {
     if (!Array.isArray(values))
         return data;
     const retained = new Set(data.observations ?? []);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/agent",
-  "version": "0.11.43",
+  "version": "0.11.44",
   "description": "Embeddable MAR coding agent SDK and CLI.",
   "license": "Apache-2.0",
   "type": "module",