@myagentroam/agent 0.9.148 → 0.9.150

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

@@ -20,6 +20,7 @@ export interface CodeModeEngine {
         limits: {
             memoryBytes: number;
             stackBytes: number;
+            /** Cumulative synchronous guest execution budget; asynchronous waiting is excluded. */
             timeoutMs: number;
             outputBytes: number;
             stateEntries: number;

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

@@ -29,20 +29,19 @@ export const codeModeToolDefinition = {
 Tool calls:
 - tools.NAME(input) returns a Promise. Use the existing tool input schema; freeform tools such as apply_patch accept a raw string, not a JSON wrapper.
 - Results use the MAR envelope: { content?: string, data?: unknown, images?: Array<{mimeType:string,dataBase64:string}>, truncated?: boolean }. Redundant JSON content is omitted when it exactly renders data; independent text remains in content. Prefer data for programmatic results: result.data.results[0].text for read source text and result.data.exitCode/result.data.stdout for exec. content, when present, is rendered text, not raw file bytes. Use only fields documented by that tool; do not invent success or ok flags.
-- Tool errors reject with code/message and may be caught. A failed cell preserves already emitted output alongside its status and error; inspect it before retrying completed work. Await every call; unawaited calls fail the cell. Use Promise.all for independent calls and sequential await for dependencies. Runtime preserves safe/serial barriers and Host checks.
+- Tool errors reject with code/message and may be caught. A failed cell preserves already emitted output alongside its status and error; completed tool effects are not rolled back. Inspect it before retrying completed work. Await every call; unawaited calls fail the cell. Use Promise.all for independent calls and sequential await for dependencies. Runtime preserves safe/serial barriers and Host checks.
 - skill, tool_search, question, code_exec, code_exec_wait and direct-only tools cannot be called here. Load Skills directly and read their instructions before the next tool call. Use direct tool_search before a later code cell for deferred tools; the current cell's tools do not change.
 
 Built-in namespaces:
 - observe.result(result): void registers an unmodified complete tools.NAME result or caught tool error as a trusted tool_result, using the original text and all images without repeating program data. Non-original, copied or modified values are rejected. This selects evidence for the next model response, not a log and not a new model call. Prefer observe.result for inspecting tool results.
-- observe.text(value): void registers bounded text/JSON values. observe.image(value): void registers one image value using the existing capability, MIME and byte limits. Both accept original tool results for compatibility and use the same complete tool_result observation path; they do not select part of an original result. Extracted single images, copies and computed summaries are value observations, never trusted tool results. Observations are returned in registration order. Only explicitly observed evidence reaches the model; registration does not prove inspection. Sources and types are runtime-assigned. No out or callable observe(value) alias exists.
+- observe.text(value): void registers text/JSON values. observe.image(value): void registers one image value when image input is supported. Both accept original tool results for compatibility and use the same complete tool_result observation path; they do not select part of an original result. Extracted single images, copies and computed summaries are value observations, never trusted tool results. Observations are returned in registration order. Only explicitly observed evidence reaches the model; registration does not prove inspection. Sources and types are runtime-assigned. No out or callable observe(value) alias exists.
 - state.get(key), state.has(key), state.set(key, value), state.delete(key) access bounded session JSON state. Mutations commit atomically only when the cell succeeds; failed or cancelled cells discard them.
 - catalog.tools() returns a read-only snapshot of the tools callable in this cell, including name, description, inputSchema and inputMode. It does not discover or authorize additional tools.
-- await cell.sleep(ms) performs a cancellable Host-side delay up to 30000 ms and remains subject to the cell deadline.
+- await cell.sleep(ms) performs a cancellable delay up to ${limits.codeSleepMaxMs} ms.
 - await cell.yield_control() returns accumulated output to the model immediately while this cell continues running.
-- Optionally start source with // @options: {"yieldMs": ${limits.codeDefaultYieldMs}, "maxOutputTokens": 10000}. yieldMs defaults to ${limits.codeDefaultYieldMs} ms and is a wait window (0..${limits.codeMaxYieldMs}), not a cell timeout. Explicit values are preserved and do not change nested tools' wait windows. A running result includes cellId; use direct code_exec_wait for new output, completion or termination.
+- Optionally start source with // @options: {"yieldMs": ${limits.codeDefaultYieldMs}, "maxOutputTokens": 10000}. yieldMs defaults to ${limits.codeDefaultYieldMs} ms and controls this call's wait window (0..${limits.codeMaxYieldMs}), not nested tool timeouts or wait windows. A running result includes cellId; use direct code_exec_wait for new output, completion or termination.
 - Registered cells are Session warm resources: ending or cancelling the model Execution cancels its wait, not the cell. Reuse retained cellId; do not start duplicate work. Host cleanup or explicit termination stops the cell.
 - tools, observe, state, catalog and cell are frozen bindings. Do not shadow their names.
-- Input max 1 MiB; cumulative text capture max 1 MiB with truncation; 128 calls, 120 seconds. Tool-specific limits apply before explicit text capture. Protocol, image, memory and time limits remain hard failures. Failures do not roll back completed tool work; do not replay successful operations blindly.
 
 Examples (copy the JavaScript source, not the fences; use only tools available in the current directory):
 Independent reads, observing the original tool results:
@@ -84,7 +83,7 @@ export const codeExecWaitToolDefinition = {
                 minimum: 0,
                 maximum: limits.codeMaxWaitYieldMs,
                 default: limits.codeDefaultWaitYieldMs,
-                description: `Wait up to this many milliseconds. Defaults to ${limits.codeDefaultWaitYieldMs}; maximum ${limits.codeMaxWaitYieldMs}. Zero returns immediately without stopping the cell. This does not extend the cell execution deadline.`
+                description: `Wait up to this many milliseconds. Defaults to ${limits.codeDefaultWaitYieldMs}; maximum ${limits.codeMaxWaitYieldMs}. Zero returns immediately without stopping the cell. Waiting does not restart the cell or extend nested tool timeouts.`
             },
             maxOutputTokens: { type: 'integer', minimum: 1, maximum: limits.codeMaxOutputTokens },
             action: {
@@ -229,12 +228,10 @@ export class CodeModeTool {
             release = resolve;
         });
         this.#active.set(controller, { sessionId: context.sessionId, done });
-        const timer = setTimeout(() => controller.abort(new MarAgentError('MAR_AGENT_CODE_TIMEOUT', 'Code Mode exceeded its execution time limit.')), limits.codeTimeoutMs);
         try {
             return await this.#run(code, { ...context, signal }, controller, output);
         }
         finally {
-            clearTimeout(timer);
             this.#active.delete(controller);
             release();
         }

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

@@ -15,8 +15,30 @@ export async function createCodeModeEngine(options) {
             runtime = quickjs.newRuntime();
             runtime.setMemoryLimit(input.limits.memoryBytes);
             runtime.setMaxStackSize(input.limits.stackBytes);
-            const deadline = Date.now() + input.limits.timeoutMs;
-            runtime.setInterruptHandler(() => input.signal.aborted || Date.now() >= deadline);
+            let executionMs = 0;
+            let executionStarted;
+            const budgetExceeded = () => executionMs + (executionStarted === undefined ? 0 : performance.now() - executionStarted) >=
+                input.limits.timeoutMs;
+            const executionTimeout = () => diagnostic('MAR_AGENT_CODE_TIMEOUT', 'JavaScript execution exceeded its execution budget.');
+            // Charge only synchronous guest work, including reentrant bridge calls, not async waiting.
+            const runGuest = (run) => {
+                input.signal.throwIfAborted();
+                if (budgetExceeded())
+                    throw executionTimeout();
+                const outermost = executionStarted === undefined;
+                if (outermost)
+                    executionStarted = performance.now();
+                try {
+                    return run();
+                }
+                finally {
+                    if (outermost) {
+                        executionMs += performance.now() - executionStarted;
+                        executionStarted = undefined;
+                    }
+                }
+            };
+            runtime.setInterruptHandler(() => input.signal.aborted || budgetExceeded());
             context = runtime.newContext();
             const vm = context;
             let wake;
@@ -35,12 +57,15 @@ export async function createCodeModeEngine(options) {
                 wake = undefined;
             };
             const fail = (handle, locateSource = false) => {
-                const error = vm.dump(handle);
-                handle.dispose();
-                if (input.signal.aborted)
-                    throw input.signal.reason;
-                if (Date.now() >= deadline)
-                    throw diagnostic('MAR_AGENT_CODE_TIMEOUT', 'JavaScript execution exceeded its deadline.');
+                let error;
+                try {
+                    error = runGuest(() => vm.dump(handle));
+                }
+                finally {
+                    handle.dispose();
+                }
+                if (budgetExceeded())
+                    throw executionTimeout();
                 let message = String(error?.message ?? error).slice(0, 4096);
                 const syntaxError = locateSource && error?.name === 'SyntaxError';
                 if (syntaxError)
@@ -64,10 +89,12 @@ export async function createCodeModeEngine(options) {
                 value.dispose();
                 return handle;
             };
+            const evalGuest = (...args) => runGuest(() => vm.evalCode(...args));
+            const callGuest = (...args) => runGuest(() => vm.callFunction(...args));
             runtime.setModuleLoader(() => ({
                 error: guestError('MAR_AGENT_CODE_IMPORT_DENIED', 'Module imports are unavailable.')
             }));
-            const setup = vm.evalCode(`
+            const setup = evalGuest(`
         for (const name of ['console', 'process', 'require', 'module', 'Buffer', 'fetch',
           'WebSocket', 'WebAssembly', 'SharedArrayBuffer', 'Atomics', 'text', 'image'])
           delete globalThis[name];
@@ -119,7 +146,7 @@ export async function createCodeModeEngine(options) {
             const formatText = vm.getProp(vm.global, '__text');
             const snapshotFunction = vm.getProp(vm.global, '__snapshot');
             const snapshot = (handle, errorSnapshot = false) => {
-                const value = vm.callFunction(snapshotFunction, vm.undefined, handle, errorSnapshot ? vm.true : vm.false);
+                const value = callGuest(snapshotFunction, vm.undefined, handle, errorSnapshot ? vm.true : vm.false);
                 if (value.error) {
                     value.error.dispose();
                     return '';
@@ -134,14 +161,18 @@ export async function createCodeModeEngine(options) {
             const deepFreeze = vm.getProp(vm.global, '__deepFreeze');
             const parse = (value) => {
                 const handle = vm.newString(JSON.stringify(value));
-                const parsed = vm.callFunction(parseJson, vm.undefined, handle);
-                handle.dispose();
-                if (parsed.error)
-                    fail(parsed.error);
-                return parsed.value;
+                try {
+                    const parsed = callGuest(parseJson, vm.undefined, handle);
+                    if (parsed.error)
+                        fail(parsed.error);
+                    return parsed.value;
+                }
+                finally {
+                    handle.dispose();
+                }
             };
             const jsonValue = (handle) => {
-                const result = vm.callFunction(serialize, vm.undefined, handle);
+                const result = callGuest(serialize, vm.undefined, handle);
                 if (result.error)
                     return { error: result.error };
                 try {
@@ -191,44 +222,57 @@ export async function createCodeModeEngine(options) {
                         .then((output) => {
                         if (disposed || input.signal.aborted)
                             return;
-                        const handle = parse(output);
-                        origins.push({
-                            handle: handle.dup(),
-                            snapshot: snapshot(handle),
-                            errorSnapshot: false,
-                            operationId: String(operationId)
+                        runGuest(() => {
+                            const handle = parse(output);
+                            try {
+                                const fingerprint = snapshot(handle);
+                                origins.push({
+                                    handle: handle.dup(),
+                                    snapshot: fingerprint,
+                                    errorSnapshot: false,
+                                    operationId: String(operationId)
+                                });
+                                deferred.resolve(handle);
+                            }
+                            finally {
+                                handle.dispose();
+                            }
                         });
-                        try {
-                            deferred.resolve(handle);
-                        }
-                        finally {
-                            handle.dispose();
-                        }
                     }, (error) => {
                         if (disposed || input.signal.aborted)
                             return;
-                        const handle = vm.newError({
-                            name: 'Error',
-                            message: String(error?.message ?? error).slice(0, 4096)
-                        });
-                        const code = vm.newString(String(error?.code ?? 'MAR_AGENT_HOST_OPERATION_FAILED'));
-                        vm.setProp(handle, 'code', code);
-                        code.dispose();
-                        origins.push({
-                            handle: handle.dup(),
-                            snapshot: snapshot(handle, true),
-                            errorSnapshot: true,
-                            operationId: String(operationId)
+                        runGuest(() => {
+                            const handle = vm.newError({
+                                name: 'Error',
+                                message: String(error?.message ?? error).slice(0, 4096)
+                            });
+                            try {
+                                const code = vm.newString(String(error?.code ?? 'MAR_AGENT_HOST_OPERATION_FAILED'));
+                                try {
+                                    vm.setProp(handle, 'code', code);
+                                }
+                                finally {
+                                    code.dispose();
+                                }
+                                const fingerprint = snapshot(handle, true);
+                                origins.push({
+                                    handle: handle.dup(),
+                                    snapshot: fingerprint,
+                                    errorSnapshot: true,
+                                    operationId: String(operationId)
+                                });
+                                deferred.reject(handle);
+                            }
+                            finally {
+                                handle.dispose();
+                            }
                         });
-                        try {
-                            deferred.reject(handle);
-                        }
-                        finally {
-                            handle.dispose();
-                        }
                     })
                         .catch((error) => {
-                        bridgeFailure = diagnostic('MAR_AGENT_CODE_ENGINE_FAILED', String(error?.message ?? error).slice(0, 4096));
+                        bridgeFailure =
+                            error?.code === 'MAR_AGENT_CODE_TIMEOUT'
+                                ? error
+                                : diagnostic('MAR_AGENT_CODE_ENGINE_FAILED', String(error?.message ?? error).slice(0, 4096));
                     })
                         .finally(() => {
                         pending.delete(job);
@@ -294,7 +338,7 @@ export async function createCodeModeEngine(options) {
                     capture.append(vm.getString(chunk));
                     return vm.undefined;
                 });
-                const result = vm.callFunction(formatText, vm.undefined, handle ?? vm.undefined, emit);
+                const result = callGuest(formatText, vm.undefined, handle ?? vm.undefined, emit);
                 emit.dispose();
                 if (result.error)
                     return { error: result.error };
@@ -384,7 +428,7 @@ export async function createCodeModeEngine(options) {
             const catalog = vm.newObject();
             method(catalog, 'tools', () => {
                 const value = parse(input.catalog);
-                const frozen = vm.callFunction(deepFreeze, vm.undefined, value);
+                const frozen = callGuest(deepFreeze, vm.undefined, value);
                 value.dispose();
                 if (frozen.error)
                     return { error: frozen.error };
@@ -434,7 +478,7 @@ export async function createCodeModeEngine(options) {
             });
             vm.setProp(vm.global, 'cell', cell);
             cell.dispose();
-            const lock = vm.evalCode(`
+            const lock = evalGuest(`
         const rawTools = globalThis.tools;
         const consumeToolCall = globalThis.__consumeToolCall;
         const wrappedTools = Object.fromEntries(Object.keys(rawTools).map(name => [name, (...args) => {
@@ -482,7 +526,7 @@ export async function createCodeModeEngine(options) {
             input.signal.addEventListener('abort', notify, { once: true });
             let main;
             try {
-                const evaluated = vm.evalCode(`(async () => {\n${input.code}\n})()`, 'code-mode.js');
+                const evaluated = evalGuest(`(async () => {\n${input.code}\n})()`, 'code-mode.js');
                 if (evaluated.error)
                     fail(evaluated.error, true);
                 main = evaluated.value;
@@ -490,11 +534,13 @@ export async function createCodeModeEngine(options) {
                     input.signal.throwIfAborted();
                     if (bridgeFailure)
                         throw bridgeFailure;
-                    const jobs = runtime.executePendingJobs(100);
+                    const jobs = runGuest(() => runtime.executePendingJobs(100));
                     if (jobs.error)
                         fail(jobs.error);
                     jobs.dispose();
-                    const promiseState = vm.getPromiseState(main);
+                    if (budgetExceeded())
+                        throw executionTimeout();
+                    const promiseState = runGuest(() => vm.getPromiseState(main));
                     if (promiseState.type === 'rejected')
                         fail(promiseState.error);
                     if (promiseState.type === 'fulfilled') {
@@ -507,8 +553,6 @@ export async function createCodeModeEngine(options) {
                     }
                     if (runtime.hasPendingJob())
                         continue;
-                    if (Date.now() >= deadline)
-                        throw diagnostic('MAR_AGENT_CODE_TIMEOUT', 'JavaScript execution exceeded its deadline.');
                     if (!pending.size)
                         throw diagnostic('MAR_AGENT_CODE_INCOMPLETE', 'JavaScript returned an unresolved promise without active operations.');
                     await new Promise((resolve) => {

package/dist/agent-core/tools/execution-limits.js

@@ -38,7 +38,7 @@ export const TOOL_EXECUTION_LIMITS = Object.freeze({
     codeHeapMegabytes: 128,
     codeMemoryBytes: 33_554_432,
     codeStackBytes: 524_288,
-    codeTimeoutMs: 120_000,
+    codeTimeoutMs: 120_000, // Cumulative synchronous guest execution, not cell wall time.
     patchMaxBytes: 4_194_304,
     patchMaxFiles: 100,
     patchMaxFileBytes: 8_388_608,

package/dist/agent-core/tools/local/exec.js

@@ -69,7 +69,7 @@ export const execWaitToolDefinition = {
     name: 'exec_wait',
     allowedCallers: ['direct', 'programmatic'],
     parallelSafety: 'safe',
-    description: 'Wait for or control a managed process by processId. action defaults to poll: wait for new output or termination and return incremental stdout/stderr. write sends data to stdin; cancel terminates the process or removes its cached result. Terminal polls return a bounded snapshot marked cached for up to five minutes. Cancelling a wait does not terminate the process. Uses the same Session-owned processes as exec; cannot start a process or extend its timeout. Inspect stderr/exitCode; completed does not imply success. Supports direct and programmatic calls; in Code Mode use tools.exec_wait. The cell execution deadline still bounds waits made inside a cell.',
+    description: 'Wait for or control a managed process by processId. action defaults to poll: wait for new output or termination and return incremental stdout/stderr. write sends data to stdin; cancel terminates the process or removes its cached result. Terminal polls return a bounded snapshot marked cached for up to five minutes. Cancelling a wait does not terminate the process. Uses the same Session-owned processes as exec; cannot start a process or extend its timeout. Inspect stderr/exitCode; completed does not imply success. Supports direct and programmatic calls; in Code Mode use tools.exec_wait.',
     outputSchema: execToolDefinition.outputSchema,
     inputSchema: {
         type: 'object',

package/package.json

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