@myagentroam/agent 0.10.43 → 0.10.45

package/dist/agent-core/prompts/index.d.ts

@@ -1,6 +1,6 @@
 import type { ExecutionMode } from '../runtime/contracts.js';
 import { type CorePromptPart } from '../extensions/prompt-composition.js';
-export declare const MAR_AGENT_PROMPT_VERSION = "1.65";
+export declare const MAR_AGENT_PROMPT_VERSION = "1.66";
 interface SystemPromptInput {
     mode: ExecutionMode;
     platform: string;

package/dist/agent-core/prompts/index.js

@@ -5,7 +5,7 @@ import { modePrompt } from './modes.js';
 import { outputStylePrompt } from './output.js';
 import { subagentPrompt } from './subagent.js';
 import { interactionPrompt, longRunningPrompt, safetyPrompt, toolUsagePrompt, workflowPrompt } from './workflow.js';
-export const MAR_AGENT_PROMPT_VERSION = '1.65';
+export const MAR_AGENT_PROMPT_VERSION = '1.66';
 export function buildSystemPrompt(input) {
     return renderPromptSections(buildSystemPromptSections(input));
 }

package/dist/agent-core/prompts/subagent.js

@@ -1,5 +1,6 @@
 export const subagentPrompt = [
     '# Subagents',
+    'Unread child messages and terminal results are supplied before the next model request.',
     'Call agent_start, agent_wait, agent_message and agent_cancel directly, never inside code_exec; they are absent from the cell tools namespace.',
     'Delegate bounded, self-contained tasks when independent progress or context savings materially helps. Keep simple or tightly coupled work local; do not split work merely to use agents.',
     'All agents share the filesystem. Give each child an objective, necessary context, expected output, and an exclusive write scope or a read-only boundary; avoid conflicting writes.',

package/dist/agent-core/sdk/session.js

@@ -30,6 +30,7 @@ import { MAR_AGENT_PROMPT_VERSION, buildSystemPromptSections } from '../prompts/
 import { renderPromptSections } from '../extensions/prompt-composition.js';
 import { retainedSessionResourcesSnapshot } from '../prompts/resources.js';
 import { childSubagentInstruction } from '../prompts/subagent.js';
+import { renderSubagentUpdate } from '../subagent/model-update.js';
 import { AsyncQueue } from '../runtime/async-queue.js';
 import { CompactionOperation } from '../runtime/compaction/operation.js';
 import { CompactCoordinator } from '../runtime/compaction/coordinator.js';
@@ -1516,8 +1517,29 @@ export function createSessionOpener(services) {
                                 });
                                 messageSources.set(message, stored);
                             }),
-                            prepareRound: async function prepareRound(pendingOutputContinuation) {
+                            prepareRound: async function prepareRound(pendingOutputContinuation, subagentUpdatesCollected = false) {
                                 await appendMailboxMessages();
+                                if (!subagentUpdatesCollected && subagents)
+                                    await withRecordProjection(async () => {
+                                        controller.signal.throwIfAborted();
+                                        for (const update of subagents.collectModelUpdates()) {
+                                            controller.signal.throwIfAborted();
+                                            const message = {
+                                                role: 'user',
+                                                content: renderSubagentUpdate(update.snapshot, update.truncated),
+                                                contextKind: 'contextual'
+                                            };
+                                            const stored = await store.append(sessionId, {
+                                                type: 'model.context',
+                                                payload: message,
+                                                executionId,
+                                                turnId
+                                            }, { signal: controller.signal });
+                                            messages.push(message);
+                                            messageSources.set(message, stored);
+                                            update.acknowledge();
+                                        }
+                                    });
                                 updateMcpRegistry();
                                 executionTools = mcpRegistry.project(baseTools());
                                 await syncMcpWorldState(messages.length);
@@ -1557,7 +1579,6 @@ export function createSessionOpener(services) {
                                         : {}),
                                     messages: modelMessages,
                                     tools: requestTools,
-                                    ...(permissionPolicy.mode === 'auto' ? { allowHostedTools: false } : {}),
                                     promptCacheKey: sessionId,
                                     reasoningEffort,
                                     ...(requestReasoningEffort === undefined ? {} : { requestReasoningEffort }),
@@ -1587,7 +1608,7 @@ export function createSessionOpener(services) {
                                 if (lateCoreChange || lateAdopted) {
                                     // Middleware may admit a blocking join after the initial checkpoint.
                                     // Never sample the candidate assembled against the replaced context.
-                                    return prepareRound(pendingOutputContinuation);
+                                    return prepareRound(pendingOutputContinuation, true);
                                 }
                                 return { request, toolScope };
                             },

package/dist/agent-core/subagent/model-update.d.ts

@@ -0,0 +1,2 @@
+import type { SubagentTaskSnapshot } from './contracts.js';
+export declare function renderSubagentUpdate(snapshot: SubagentTaskSnapshot, truncated?: boolean): string;

package/dist/agent-core/subagent/model-update.js

@@ -0,0 +1,85 @@
+import { escapeMarkupText, markupAttributes } from '../prompts/markup.js';
+import { TOOL_EXECUTION_LIMITS } from '../tools/execution-limits.js';
+export function renderSubagentUpdate(snapshot, truncated = false) {
+    const attributes = (values) => markupAttributes(Object.fromEntries(Object.entries(values).map(([key, value]) => {
+        if (value === undefined)
+            return [key, undefined];
+        let bounded = '';
+        let count = 0;
+        for (const point of String(value)) {
+            if (count++ === 256) {
+                truncated = true;
+                break;
+            }
+            bounded += point;
+        }
+        return [key, bounded];
+    })));
+    const root = '<mar_subagent_update' +
+        attributes({
+            agentId: snapshot.agentId,
+            status: snapshot.status,
+            modelId: snapshot.modelId,
+            modelName: snapshot.modelName,
+            reasoningEffort: snapshot.reasoningEffort,
+            messageId: snapshot.messageId,
+            turnId: snapshot.turnId,
+            deliveryStatus: snapshot.deliveryStatus
+        });
+    const close = '</mar_subagent_update>';
+    let remaining = TOOL_EXECUTION_LIMITS.subagentUpdateMaxBytes -
+        Buffer.byteLength(root + ' truncated="false">\n' + close);
+    const lines = [];
+    const field = (name, value, metadata = {}, limit = remaining) => {
+        let attrs = attributes(metadata);
+        const overhead = Buffer.byteLength('  <' + name + attrs + '></' + name + '>\n');
+        if (overhead > remaining) {
+            truncated = true;
+            return;
+        }
+        let budget = Math.min(limit, remaining - overhead);
+        let text = '';
+        let clipped = false;
+        for (const point of value) {
+            const encoded = escapeMarkupText(point);
+            const bytes = Buffer.byteLength(encoded);
+            if (bytes > budget) {
+                clipped = true;
+                break;
+            }
+            text += encoded;
+            budget -= bytes;
+        }
+        if (clipped) {
+            truncated = true;
+            if ('truncated' in metadata)
+                attrs = attributes({ ...metadata, truncated: true });
+        }
+        const opening = '  <' + name + attrs;
+        const line = text === '' ? opening + ' />\n' : opening + '>' + text + '</' + name + '>\n';
+        remaining -= Buffer.byteLength(line);
+        lines.push(line);
+    };
+    // Preserve failure/permission facts before spending the remaining budget on result text.
+    if (snapshot.errorCode !== undefined || snapshot.errorMessage !== undefined)
+        field('error', snapshot.errorMessage ?? '', { code: snapshot.errorCode }, 1024);
+    if (snapshot.permissionStop)
+        field('permission_stop', snapshot.permissionStop.reason, { action: snapshot.permissionStop.action, ...snapshot.permissionStop.source }, 1024);
+    field('description', snapshot.description, {}, 1024);
+    if (snapshot.latestMessage) {
+        const { text, ...metadata } = snapshot.latestMessage;
+        truncated ||= metadata.truncated;
+        field('message', text, metadata, TOOL_EXECUTION_LIMITS.subagentSummaryMaxBytes);
+    }
+    if (snapshot.summary !== undefined)
+        field('summary', snapshot.summary);
+    for (const path of snapshot.changedFiles ?? [])
+        field('changed_file', path);
+    for (const text of snapshot.verification ?? [])
+        field('verification', text);
+    for (const { path, startLine, endLine } of snapshot.evidence ?? [])
+        field('evidence', path, { startLine, endLine });
+    if (snapshot.latestActivity)
+        field('activity', '', snapshot.latestActivity);
+    return root + ' truncated="' + String(truncated) + '">\n' + lines.join('') + close;
+}

package/dist/agent-core/subagent/session-controller.d.ts

@@ -107,6 +107,11 @@ export declare class SubagentSessionController implements SubagentController {
     withOperation<T>(operation: SubagentParentOperation, run: () => T): T;
     inspect(agentId: string): Promise<SubagentTaskSnapshot>;
     inspectAll(): readonly SubagentTaskSnapshot[];
+    collectModelUpdates(): readonly {
+        snapshot: SubagentTaskSnapshot;
+        truncated: boolean;
+        acknowledge(): void;
+    }[];
     cancelOwned(ownerInstanceId: string): Promise<void>;
     endParentExecution(executionId: string): void;
     parentExecution(executionId: string): SubagentParentExecution | undefined;

package/dist/agent-core/subagent/session-controller.js

@@ -86,6 +86,41 @@ export class SubagentSessionController {
             throw new MarAgentError('MAR_AGENT_DISPOSED', 'Subagent controller is disposed.');
         return [...this.#agents.values()].map((state) => this.#snapshot(state, { full: true }));
     }
+    collectModelUpdates() {
+        return [...this.#agents.values()]
+            .filter((state) => state.messageRevision > state.observedMessageRevision ||
+            (isTerminalState(state) &&
+                state.terminalRevision !== undefined &&
+                state.terminalRevision > state.observedTerminalRevision))
+            .sort((left, right) => left.resourceRevision - right.resourceRevision)
+            .slice(0, TOOL_EXECUTION_LIMITS.agentWaitMaxAgents)
+            .map((state) => {
+            const messageRevision = state.messageRevision;
+            const terminalRevision = isTerminalState(state) ? state.terminalRevision : undefined;
+            const includeTerminalDetails = terminalRevision !== undefined && terminalRevision > state.observedTerminalRevision;
+            const snapshot = this.#snapshot(state, {
+                includeLatestMessage: messageRevision > state.observedMessageRevision,
+                includeTerminalDetails,
+                full: false
+            });
+            return {
+                snapshot,
+                truncated: snapshot.latestMessage?.truncated === true ||
+                    (includeTerminalDetails &&
+                        (snapshot.summary !== state.summary ||
+                            (snapshot.changedFiles?.length ?? 0) < state.changedFiles.length ||
+                            (snapshot.evidence?.length ?? 0) < state.evidence.length ||
+                            (snapshot.verification?.length ?? 0) < state.verification.length ||
+                            (snapshot.verification?.some((value, index) => value !== state.verification[index]) ??
+                                false))),
+                acknowledge: () => {
+                    state.observedMessageRevision = Math.max(state.observedMessageRevision, messageRevision);
+                    if (includeTerminalDetails)
+                        state.observedTerminalRevision = Math.max(state.observedTerminalRevision, terminalRevision);
+                }
+            };
+        });
+    }
     async cancelOwned(ownerInstanceId) {
         for (const pending of this.#pendingDeliveries)
             if (pending.ownerInstanceId === ownerInstanceId)
@@ -548,7 +583,7 @@ export class SubagentSessionController {
             if (index >= 0)
                 this.#queue.splice(index, 1);
             state.status = 'cancelled';
-            this.#touchResource(state);
+            this.#touchResource(state, true);
             this.#closeReceipt(state);
             state.terminalPending = true;
             await this.#publishTerminal(state);
@@ -731,7 +766,7 @@ export class SubagentSessionController {
                 state.errorMessage = result.errorMessage ?? 'Subagent execution failed.';
             }
             state.terminalPending = true;
-            this.#touchResource(state);
+            this.#touchResource(state, true);
             this.#closeReceipt(state);
             await this.#publishTerminal(state);
         }
@@ -767,10 +802,12 @@ export class SubagentSessionController {
         state.errorCode = diagnostic.code;
         state.errorMessage = diagnostic.message;
         state.terminalPending = true;
-        this.#touchResource(state);
+        this.#touchResource(state, true);
     }
-    #touchResource(state) {
+    #touchResource(state, terminal = false) {
         state.resourceRevision = ++this.#resourceRevision;
+        if (terminal)
+            state.terminalRevision = state.resourceRevision;
     }
     #waitForAnyCompletion(candidates, waitMs, signal) {
         return waitForCompletionNotification(this.#completionWaiters, (state) => candidates.includes(state), waitMs, signal);

package/dist/agent-core/tools/agent/agent-wait.js

@@ -5,7 +5,7 @@ export const agentWaitToolDefinition = {
     name: 'agent_wait',
     allowedCallers: ['direct'],
     parallelSafety: 'serial',
-    description: 'Read or wait a bounded time for a child agent result. Wait only when the next local step depends on the child result; otherwise continue useful non-overlapping work. waitFor defaults to "completion"; use "message" only when a fresh public commentary/final message would change the next decision. Omit agentId to wait for whichever live child returns first, matching Codex-style untargeted waiting and avoiding UUID transcription; provide the exact agentId returned by agent_start only when observing a specific child. If no child is live, untargeted waiting reads the most recently created child. For an exec processId, use exec_wait instead (tools.exec_wait in Code Mode). Omitting waitMs waits up to 30 seconds by default; waitMs=0 returns the current snapshot immediately. Positive waits range up to 5 minutes, and positive values below 10 seconds are raised to 10 seconds. When blocked on a live child result, prefer one 300000 ms completion wait rather than repeated short waits. Use agentIds with mode any (default) or all to wait for an explicit non-empty set of up to 8 distinct child IDs; never combine agentId and agentIds or use mode without agentIds. mode and waitFor are independent. A group uses one deadline and returns mode, waitFor, waitOutcome, agents in input order, and pendingAgentIds. Failed, cancelled and interrupted turns also satisfy completion; terminal state satisfies message waits too. Group waitMs=0 returns only snapshots without consuming messages. Single-target and untargeted results include waitOutcome as snapshot, message, completion, or timeout plus the real agentId and description. A message, timeout with unread progress, or first terminal completion result includes the newly observed latest public commentary/final message; snapshots and repeated observations omit previously observed message text. latestActivity can still identify a public message or bounded tool started/completed/failed status. A queued or running result is not completion. A message wait consumes only the latest unread public message in the current Session runtime; tool activity does not wake it, and parent cancellation preserves unread progress for a later Execution. Do not use message waits as heartbeat checks or request progress merely to confirm that a child is still running. First terminal results include bounded summary, changedFiles, verification, and read evidence with path/line ranges; use that evidence to avoid repeating the full exploration, while independently checking consequential edits and claims.',
+    description: 'Read or wait a bounded time for a child agent result. Unread child messages and terminal results are supplied automatically before the next model request. Wait only when the next local step depends on the child result; otherwise continue useful non-overlapping work. waitFor defaults to "completion"; use "message" only when a fresh public commentary/final message would change the next decision. Omit agentId to wait for whichever live child returns first, matching Codex-style untargeted waiting and avoiding UUID transcription; provide the exact agentId returned by agent_start only when observing a specific child. If no child is live, untargeted waiting reads the most recently created child. For an exec processId, use exec_wait instead (tools.exec_wait in Code Mode). Omitting waitMs waits up to 30 seconds by default; waitMs=0 returns the current snapshot immediately. Positive waits range up to 5 minutes, and positive values below 10 seconds are raised to 10 seconds. When blocked on a live child result, prefer one 300000 ms completion wait rather than repeated short waits. Use agentIds with mode any (default) or all to wait for an explicit non-empty set of up to 8 distinct child IDs; never combine agentId and agentIds or use mode without agentIds. mode and waitFor are independent. A group uses one deadline and returns mode, waitFor, waitOutcome, agents in input order, and pendingAgentIds. Failed, cancelled and interrupted turns also satisfy completion; terminal state satisfies message waits too. Group waitMs=0 returns only snapshots without consuming messages. Single-target and untargeted results include waitOutcome as snapshot, message, completion, or timeout plus the real agentId and description. A message, timeout with unread progress, or first terminal completion result includes the newly observed latest public commentary/final message; snapshots and repeated observations omit previously observed message text. latestActivity can still identify a public message or bounded tool started/completed/failed status. A queued or running result is not completion. A message wait consumes only the latest unread public message in the current Session runtime; tool activity does not wake it, and parent cancellation preserves unread progress for a later Execution. Do not use message waits as heartbeat checks or request progress merely to confirm that a child is still running. First terminal results include bounded summary, changedFiles, verification, and read evidence with path/line ranges; use that evidence to avoid repeating the full exploration, while independently checking consequential edits and claims.',
     inputSchema: {
         type: 'object',
         properties: {

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

@@ -32,7 +32,7 @@ export const codeModeToolDefinition = {
 - Use only standard ECMAScript built-ins and the explicitly documented tools, observe, state, catalog and cell namespaces. Do not use Node.js, browser or Web APIs. Module imports, filesystem and network APIs are unavailable. Obtain external capabilities only through available tools. Use tools.exec to start managed processes when permitted; use tools.exec_wait afterward to wait, write stdin or cancel.
 
 Tool calls:
-- tools.NAME(input) returns a Promise. Use the current catalog input schema: raw text only when inputMode is freeform; use the declared JSON form when inputMode is json. For parameterless tools prefer tools.NAME({}); tools.NAME() is accepted only for explicitly closed empty-object schemas.
+- tools.NAME(input) returns a Promise. Pass a JavaScript value matching the current catalog inputSchema. For parameterless tools prefer tools.NAME({}); tools.NAME() is accepted only for explicitly closed empty-object schemas.
 - 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, except nested Auto deny, which skips only that call and resolves with data.error/data.message. 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.
@@ -41,7 +41,7 @@ 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 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.
+- catalog.tools() returns a read-only snapshot of the tools callable in this cell, including name, description and inputSchema. It does not discover or authorize additional tools.
 - 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}}. 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.
@@ -63,7 +63,7 @@ Inspect before a dependent edit; successful await needs no invented success flag
 const inspected = await tools.read({ reads: [{ path: "source.txt" }] });
 const sourceText = inspected.data.results[0].text;
 if (!sourceText?.includes("original=1")) throw new Error("Unexpected source");
-const patched = await tools.apply_patch("*** Begin Patch\\n*** Update File: source.txt\\n@@\\n original=1\\n+updated=2\\n*** End Patch");
+const patched = await tools.apply_patch({ patch: "*** Begin Patch\\n*** Update File: source.txt\\n@@\\n original=1\\n+updated=2\\n*** End Patch" });
 observe.result(patched);
 \`\`\``,
     inputMode: 'freeform',
@@ -102,6 +102,13 @@ export const codeExecWaitToolDefinition = {
     allowedCallers: ['direct'],
     parallelSafety: 'safe'
 };
+function projectProgrammaticTool(tool) {
+    return {
+        name: tool.name,
+        description: `Call only as tools.${tool.name} inside code_exec, never as a direct model tool.\nPass a JavaScript value matching inputSchema.\n${tool.description}`,
+        inputSchema: stableToolSchema(tool.inputSchema)
+    };
+}
 /** Deferred definitions travel in search results, not in the stable Code Mode description. */
 export function projectCodeModeTools(tools, residentTools = tools) {
     const codeModeEnabled = tools.some((tool) => tool.name === 'code_exec' && allowsToolCaller(tool, 'direct'));
@@ -113,12 +120,7 @@ export function projectCodeModeTools(tools, residentTools = tools) {
     const programmatic = orderToolDefinitions(residentTools.filter((tool) => allowsToolCaller(tool, 'programmatic')));
     const directory = JSON.stringify({
         callableNames: programmatic.map((tool) => tool.name),
-        programmaticOnly: programmatic.map((tool) => ({
-            name: tool.name,
-            description: tool.description,
-            inputSchema: stableToolSchema(tool.inputSchema),
-            inputMode: tool.inputMode ?? 'json'
-        }))
+        programmaticOnly: programmatic.map(projectProgrammaticTool)
     });
     if (Buffer.byteLength(directory) > 32 * 1024)
         throw new MarAgentError('MAR_AGENT_TOOL_EXPOSURE_LIMIT', 'Programmatic tool directory is too large.');
@@ -141,12 +143,14 @@ export function projectCodeModeSearchResult(message, codeModeEnabled) {
                 .map(stableToolDefinition)
         };
     const tools = message.toolSearchTools.map((tool) => ({
-        name: tool.name,
-        description: allowsToolCaller(tool, 'programmatic')
-            ? `Call only as tools.${tool.name} inside code_exec, never as a direct model tool.\n${tool.description}`
-            : tool.description,
-        inputSchema: stableToolSchema(tool.inputSchema),
-        inputMode: tool.inputMode ?? 'json',
+        ...(allowsToolCaller(tool, 'programmatic')
+            ? projectProgrammaticTool(tool)
+            : {
+                name: tool.name,
+                description: tool.description,
+                inputSchema: stableToolSchema(tool.inputSchema),
+                inputMode: tool.inputMode ?? 'json'
+            }),
         caller: allowsToolCaller(tool, 'programmatic') ? 'programmatic' : 'direct'
     }));
     return {
@@ -631,9 +635,7 @@ export class CodeModeTool {
                     catalog: context
                         .codeMode.tools.filter((tool) => available.has(tool.name))
                         .map((tool) => ({
-                        name: tool.name,
-                        description: tool.description,
-                        inputSchema: tool.inputSchema,
+                        ...projectProgrammaticTool(tool),
                         ...(tool.parameterless ? { parameterless: true } : {}),
                         inputMode: tool.inputMode ?? 'json'
                     })),

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

@@ -451,7 +451,11 @@ export async function createCodeModeEngine(options) {
             stateObject.dispose();
             const catalog = vm.newObject();
             method(catalog, 'tools', () => {
-                const value = parse(input.catalog);
+                const value = parse(input.catalog.map(({ name, description, inputSchema }) => ({
+                    name,
+                    description,
+                    inputSchema
+                })));
                 const frozen = callGuest(deepFreeze, vm.undefined, value);
                 value.dispose();
                 if (frozen.error)

package/dist/agent-core/tools/execution-limits.d.ts

@@ -52,6 +52,7 @@ export declare const TOOL_EXECUTION_LIMITS: Readonly<{
     subagentMessageMaxBytes: 131072;
     subagentReasoningEffortMaxCharacters: 64;
     subagentSummaryMaxBytes: 16384;
+    subagentUpdateMaxBytes: 32768;
     subagentRunningLatestMessageMaxCharacters: 2000;
     subagentEvidenceMaxItems: 64;
     subagentVerificationMaxItems: 16;

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

@@ -52,6 +52,7 @@ export const TOOL_EXECUTION_LIMITS = Object.freeze({
     subagentMessageMaxBytes: 131_072,
     subagentReasoningEffortMaxCharacters: 64,
     subagentSummaryMaxBytes: 16_384,
+    subagentUpdateMaxBytes: 32_768,
     subagentRunningLatestMessageMaxCharacters: 2_000,
     subagentEvidenceMaxItems: 64,
     subagentVerificationMaxItems: 16,

package/package.json

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