@myagentroam/agent 0.9.139 → 0.9.141

package/dist/sdk/agent.js

@@ -1,6 +1,7 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { isDeepStrictEqual } from 'node:util';
 import { describeMarAgentError, MarAgentError } from '../error.js';
+import { CodeCellExecutionError } from '../tools/code-mode/cells.js';
 import { negotiateHost } from '../host/contracts.js';
 import { AnthropicMessagesAdapter, isAnthropicRecoverableStreamError } from '../model/anthropic-messages.js';
 import { marAgentReasoningEffortSchema, resolveModelDefaultReasoningEffort, usesResponsesConfigurationUpdates } from '../model/configuration.js';
@@ -36,8 +37,8 @@ import { createCodeToolDispatch } from '../tools/code-mode/dispatch.js';
 import { createSessionToolScheduler, scheduleToolCallBatch } from '../tools/scheduler.js';
 import { projectCodeModeSearchResult, projectCodeModeTools } from '../tools/code-mode.js';
 import { allowsDirectTool, allowsToolCaller, toolCallers } from '../tools/callers.js';
+import { modelStreamEventObservedAt } from '../model/sse.js';
 import { SubagentSessionController } from '../subagent/session-controller.js';
-const MODEL_PERFORMANCE_MIN_INTERVAL_MS = 1_000;
 /** Retry only classified recoverable failures within the attempt budget; never retry cancellation. */
 async function recoverModelStream(error, retryState, signal) {
     if (signal.aborted ||
@@ -612,7 +613,14 @@ export async function createMarAgentWithAdapter(options) {
                         instructionContent: renderAgentInstructions(instructionEntries, compactMayContainAgentInstructions ||
                             contextualWorldState.instructionSnapshot !== undefined),
                         resourceSnapshot: currentResourceSnapshot,
-                        previousMayContainResources: compactMayContainRetainedResources
+                        previousMayContainResources: (!contextualWorldState.initialized && compactMayContainRetainedResources) ||
+                            (options.host.listSessionResources !== undefined &&
+                                currentResourceSnapshot === undefined &&
+                                messages
+                                    .slice(contextualWorldState.entries.findLast((entry) => entry.kind === 'resources')
+                                    ?.index ?? 0)
+                                    .some((message) => message.role === 'tool_call' &&
+                                    ['exec', 'code_exec', 'code_mode', 'agent_start'].includes(message.name ?? '')))
                     });
                     sessionRuntime.contextualWorldState = contextualWorldState;
                     if (!isDeepStrictEqual(previousContextualWorldState, contextualWorldState))
@@ -898,40 +906,39 @@ export async function createMarAgentWithAdapter(options) {
                         let sawModelSemanticEvent = false;
                         let requestStartedAt;
                         let firstModelResponseAt;
+                        let firstOutputDeltaAt;
+                        let lastOutputDeltaAt;
                         let requestCompletedAt;
                         let requestOutputTokens;
-                        let outputTokenRevision = 0;
-                        let lastPerformanceEmittedAt;
-                        let lastPublishedOutputTokenRevision = 0;
-                        let performanceEmitted = false;
                         const roundMessageCount = messages.length;
-                        const emitPerformance = async (sampledAt, force = false) => {
+                        const emitLatency = async () => {
                             if (mode === 'compact' || firstModelResponseAt === undefined)
                                 return;
-                            const outputDurationMs = Math.max(0, Math.round(sampledAt - firstModelResponseAt));
-                            const outputTokens = requestOutputTokens;
-                            const tokensPerSecond = outputTokens !== undefined && outputDurationMs > 0
-                                ? Number(((outputTokens * 1000) / outputDurationMs).toFixed(2))
-                                : undefined;
-                            if (performanceEmitted &&
-                                (tokensPerSecond === undefined ||
-                                    outputTokenRevision === lastPublishedOutputTokenRevision))
+                            await emit({
+                                type: 'model.performance',
+                                latencyMs: Math.max(0, Math.round(firstModelResponseAt - requestStartedAt))
+                            });
+                        };
+                        const emitFinalPerformance = async (completedAt) => {
+                            if (mode === 'compact' ||
+                                firstModelResponseAt === undefined ||
+                                firstOutputDeltaAt === undefined ||
+                                lastOutputDeltaAt === undefined ||
+                                lastOutputDeltaAt - firstOutputDeltaAt < 1)
                                 return;
-                            if (!force &&
-                                lastPerformanceEmittedAt !== undefined &&
-                                sampledAt - lastPerformanceEmittedAt < MODEL_PERFORMANCE_MIN_INTERVAL_MS)
+                            const outputDuration = completedAt - firstOutputDeltaAt;
+                            const outputTokens = requestOutputTokens;
+                            if (outputTokens === undefined ||
+                                outputDuration < 1 ||
+                                completedAt < lastOutputDeltaAt)
                                 return;
                             await emit({
                                 type: 'model.performance',
                                 latencyMs: Math.max(0, Math.round(firstModelResponseAt - requestStartedAt)),
-                                ...(outputTokens === undefined ? {} : { outputTokens }),
-                                outputDurationMs,
-                                ...(tokensPerSecond === undefined ? {} : { tokensPerSecond })
+                                outputTokens,
+                                outputDurationMs: Math.round(outputDuration),
+                                tokensPerSecond: Number(((outputTokens * 1000) / outputDuration).toFixed(2))
                             });
-                            performanceEmitted = true;
-                            lastPerformanceEmittedAt = sampledAt;
-                            if (tokensPerSecond !== undefined)
-                                lastPublishedOutputTokenRevision = outputTokenRevision;
                         };
                         const persistToolCalls = async (calls) => {
                             for (const call of calls) {
@@ -978,10 +985,25 @@ export async function createMarAgentWithAdapter(options) {
                                 ...(modelInputImages?.length ? { images: modelInputImages } : {}),
                                 onAttemptDiagnostic: recordModelAttempt(mode === 'compact' ? 'COMPACTION' : 'EXECUTION')
                             })) {
-                                const modelResponseAt = mode !== 'compact' && isModelResponseEvent(event) ? performance.now() : undefined;
+                                if (event.type === 'output.reset') {
+                                    firstOutputDeltaAt = undefined;
+                                    lastOutputDeltaAt = undefined;
+                                    requestOutputTokens = undefined;
+                                    continue;
+                                }
+                                const modelResponseAt = mode !== 'compact' && isModelResponseEvent(event)
+                                    ? Math.max(requestStartedAt, modelStreamEventObservedAt(event) ?? performance.now())
+                                    : undefined;
+                                const isFirstModelResponse = modelResponseAt !== undefined && firstModelResponseAt === undefined;
                                 if (modelResponseAt !== undefined) {
-                                    sawModelSemanticEvent = true;
+                                    if (event.type !== 'output.delta')
+                                        sawModelSemanticEvent = true;
                                     firstModelResponseAt ??= modelResponseAt;
+                                    if (event.type === 'output.delta' ||
+                                        (event.type === 'text.delta' && event.delta.length > 0)) {
+                                        firstOutputDeltaAt ??= modelResponseAt;
+                                        lastOutputDeltaAt = modelResponseAt;
+                                    }
                                 }
                                 if (event.type === 'response.item') {
                                     // Compaction keeps only its successful checkpoint, never intermediate native output.
@@ -1070,7 +1092,6 @@ export async function createMarAgentWithAdapter(options) {
                                         : undefined;
                                     if (outputTokens !== undefined) {
                                         requestOutputTokens = outputTokens;
-                                        outputTokenRevision++;
                                     }
                                     const reportedContext = event.usage.contextInputTokens ?? event.usage.inputTokens;
                                     if (reportedContext !== undefined &&
@@ -1119,14 +1140,14 @@ export async function createMarAgentWithAdapter(options) {
                                 }
                                 else if (event.type === 'completed') {
                                     stop = event.reason;
-                                    requestCompletedAt = performance.now();
+                                    requestCompletedAt = modelStreamEventObservedAt(event) ?? performance.now();
                                 }
-                                if (modelResponseAt !== undefined)
-                                    await emitPerformance(modelResponseAt);
+                                if (isFirstModelResponse)
+                                    await emitLatency();
                             }
                             if (mode !== 'compact' && firstModelResponseAt !== undefined) {
                                 const completedAt = requestCompletedAt ?? performance.now();
-                                await emitPerformance(completedAt, true);
+                                await emitFinalPerformance(completedAt);
                             }
                             pendingOutputContinuation = undefined;
                             incompleteToolCall = pendingTools.some((call) => call.argumentError !== undefined);
@@ -1291,6 +1312,7 @@ export async function createMarAgentWithAdapter(options) {
                             }
                             catch (error) {
                                 const diagnostic = describeMarAgentError(error, 'MAR_AGENT_HOST_OPERATION_FAILED');
+                                const partial = error instanceof CodeCellExecutionError ? error.result : undefined;
                                 await emit({
                                     type: 'tool.failed',
                                     toolName: call.name,
@@ -1301,13 +1323,16 @@ export async function createMarAgentWithAdapter(options) {
                                 });
                                 return {
                                     call,
-                                    content: JSON.stringify({
-                                        error: diagnostic.code,
-                                        message: diagnostic.message,
-                                        ...(error instanceof MarAgentError && error.retryable
-                                            ? { retryable: true }
-                                            : {})
-                                    }),
+                                    content: partial === undefined
+                                        ? JSON.stringify({
+                                            error: diagnostic.code,
+                                            message: diagnostic.message,
+                                            ...(error instanceof MarAgentError && error.retryable
+                                                ? { retryable: true }
+                                                : {})
+                                        })
+                                        : boundedModelToolOutput(call.name, partial.content, partial.data).content,
+                                    ...(partial?.images?.length ? { images: partial.images } : {}),
                                     failed: true,
                                     error
                                 };
@@ -2237,7 +2262,7 @@ function updateContextualWorldState(state, index, current) {
         if (current.instructionContent !== undefined)
             entries.push({ index, kind: 'instructions', content: current.instructionContent });
     }
-    const resourceContent = retainedSessionResourcesUpdate(current.resourceSnapshot, state.initialized ? state.resourceSnapshot : undefined, !state.initialized && current.previousMayContainResources);
+    const resourceContent = retainedSessionResourcesUpdate(current.resourceSnapshot, state.initialized ? state.resourceSnapshot : undefined, current.previousMayContainResources);
     if (resourceContent !== undefined)
         entries.push({ index, kind: 'resources', content: resourceContent });
     return {
@@ -2283,7 +2308,7 @@ function estimatedRequestTokens(system, messages, tools, images) {
         transientImageCount * AGENT_EXECUTION_POLICY.estimatedTokensPerImage);
 }
 function boundedModelToolOutput(toolName, value, data) {
-    const execDiagnostics = toolName === 'exec' &&
+    const execDiagnostics = (toolName === 'exec' || toolName === 'exec_wait') &&
         isRecord(data) &&
         typeof data.stdout === 'string' &&
         typeof data.stderr === 'string'
@@ -2390,7 +2415,7 @@ function structuredToolEventData(toolName, value) {
         typeof value.sha256 === 'string' &&
         /^[a-f0-9]{64}$/u.test(value.sha256))
         return value;
-    if (toolName === 'exec' &&
+    if ((toolName === 'exec' || toolName === 'exec_wait') &&
         (value.status === 'running' || value.status === 'completed' || value.status === 'cancelled') &&
         typeof value.stdout === 'string' &&
         typeof value.stderr === 'string' &&
@@ -2457,6 +2482,7 @@ function isModelResponseEvent(event) {
     if (event.type === 'text.completed' || event.type === 'reasoning.summary')
         return event.text.length > 0;
     return (event.type === 'response.item' ||
+        event.type === 'output.delta' ||
         event.type === 'client_tool.call' ||
         event.type === 'hosted_tool' ||
         event.type === 'citation');

package/dist/session/context-gc-checkpoint.d.ts

@@ -50,7 +50,7 @@ export type ContextGcReplacement = {
     readonly evidenceSequences: readonly number[];
 } | {
     readonly kind: 'TOOL_CALL_INPUT';
-    readonly toolName: 'apply_patch' | 'exec' | 'code_mode' | 'code_exec';
+    readonly toolName: 'apply_patch' | 'exec' | 'exec_wait' | 'code_mode' | 'code_exec';
     readonly callId: string;
     readonly target: ContextGcTarget;
     readonly replacementArguments: unknown;

package/dist/session/context-gc-checkpoint.js

@@ -350,8 +350,9 @@ function replacementMatchesRecords(replacement, records, recordsBySequence, work
     if (!isSuccessfulExecLifecycleEvidence(replacement, source, records, recordsBySequence))
         return false;
     if (replacement.kind === 'TOOL_CALL_INPUT')
-        return isDeepStrictEqual(replacement.replacementArguments, contextGcExecInputReplacement(source.payload.arguments, execInputReplacementFormatVersion(replacement.replacementArguments)));
-    const targetEvidence = successfulToolEvidence(records, recordsBySequence, source.sequence, 'exec');
+        return isDeepStrictEqual(replacement.replacementArguments, contextGcExecInputReplacement(source.payload.arguments, execInputReplacementFormatVersion(replacement.replacementArguments), replacement.toolName));
+    const targetEvidence = successfulToolEvidence(records, recordsBySequence, source.sequence, 'exec') ??
+        successfulToolEvidence(records, recordsBySequence, source.sequence, 'exec_wait');
     const result = normalizeContextGcExecResult(source.payload.content, targetEvidence?.completed.payload);
     return (result !== undefined &&
         replacement.replacementContent ===
@@ -474,7 +475,8 @@ function successfulPatchEvidenceForPath(records, recordsBySequence, evidenceSequ
         : undefined;
 }
 function isSuccessfulExecLifecycleEvidence(replacement, source, records, recordsBySequence) {
-    const evidence = successfulToolEvidence(records, recordsBySequence, replacement.evidenceSequence, 'exec');
+    const evidence = successfulToolEvidence(records, recordsBySequence, replacement.evidenceSequence, 'exec') ??
+        successfulToolEvidence(records, recordsBySequence, replacement.evidenceSequence, 'exec_wait');
     if (!evidence || !isRecord(evidence.call.payload) || !isRecord(evidence.result.payload))
         return false;
     const finalResult = normalizeContextGcExecResult(evidence.result.payload.content, evidence.completed.payload);
@@ -487,7 +489,7 @@ function isSuccessfulExecLifecycleEvidence(replacement, source, records, records
         targetCall.sequence > evidence.call.sequence ||
         !isRecord(targetCall.payload) ||
         targetCall.payload.role !== 'tool_call' ||
-        targetCall.payload.name !== 'exec' ||
+        (targetCall.payload.name !== 'exec' && targetCall.payload.name !== 'exec_wait') ||
         targetCall.payload.callId !== replacement.callId)
         return false;
     const targetResult = replacement.kind === 'EXEC_OUTPUT'
@@ -495,7 +497,7 @@ function isSuccessfulExecLifecycleEvidence(replacement, source, records, records
         : modelToolResultForCall(records, targetCall, evidence.result.sequence);
     if (!targetResult)
         return false;
-    const targetEvidence = successfulToolEvidence(records, recordsBySequence, targetResult.sequence, 'exec');
+    const targetEvidence = successfulToolEvidence(records, recordsBySequence, targetResult.sequence, targetCall.payload.name);
     if (!targetEvidence || targetEvidence.call.sequence !== targetCall.sequence)
         return false;
     if (targetEvidence.callId === evidence.callId)
@@ -631,6 +633,7 @@ function isContextGcReplacement(value) {
             value.target.role === 'tool_call' &&
             (value.toolName === 'apply_patch' ||
                 value.toolName === 'exec' ||
+                value.toolName === 'exec_wait' ||
                 value.toolName === 'code_mode' ||
                 value.toolName === 'code_exec') &&
             value.target.toolName === value.toolName &&

package/dist/session/context-gc-replacements.d.ts

@@ -56,7 +56,7 @@ export declare function contextGcStaleReadReplacement(input: {
     readonly formatVersion?: 1 | 2;
 }): string;
 export declare function contextGcWebOutputReplacement(toolName: ContextGcWebToolName, originalContent: string, truncated: boolean): string;
-export declare function contextGcExecInputReplacement(arguments_: unknown, formatVersion?: 1 | 2 | 3): unknown;
+export declare function contextGcExecInputReplacement(arguments_: unknown, formatVersion?: 1 | 2 | 3, toolName?: string): unknown;
 export declare function contextGcExecOutputReplacement(result: ContextGcExecResult, formatVersion?: 1 | 2 | 3): string;
 export declare function normalizeContextGcExecResult(modelContent: unknown, completedPayload: unknown): ContextGcExecResult | undefined;
 export declare function parseContextGcExecResult(value: unknown): ContextGcExecResult | undefined;

package/dist/session/context-gc-replacements.js

@@ -97,14 +97,16 @@ export function contextGcWebOutputReplacement(toolName, originalContent, truncat
         contextGc: 'Detailed web tool output was reclaimed after six successful rollouts. An incomplete preview is not the complete search result or page, and GC did not access the network.'
     });
 }
-export function contextGcExecInputReplacement(arguments_, formatVersion = 3) {
+export function contextGcExecInputReplacement(arguments_, formatVersion = 3, toolName = 'exec') {
     if (!isRecord(arguments_))
         return `<context_gc kind="terminal_exec_input"${formatVersion === 3 ? ' formatVersion="3"' : ''} originalBytes="${Buffer.byteLength(stableJson(arguments_))}"${formatVersion === 3 ? '' : ` originalSha256="${sha256(stableJson(arguments_))}"`} />`;
     const action = typeof arguments_.action === 'string'
         ? arguments_.action
         : typeof arguments_.command === 'string'
             ? 'start'
-            : 'unknown';
+            : toolName === 'exec_wait'
+                ? 'poll'
+                : 'unknown';
     const original = stableJson(arguments_);
     const retained = {
         action,
@@ -190,7 +192,7 @@ export function normalizeContextGcExecResult(modelContent, completedPayload) {
     if (typeof modelContent !== 'string' ||
         !isRecord(completedPayload) ||
         completedPayload.type !== 'tool.completed' ||
-        completedPayload.toolName !== 'exec' ||
+        (completedPayload.toolName !== 'exec' && completedPayload.toolName !== 'exec_wait') ||
         completedPayload.truncated !== true)
         return undefined;
     const data = completedPayload.data;

package/dist/tools/agent-wait.js

@@ -4,7 +4,7 @@ export const agentWaitToolDefinition = {
     name: 'agent_wait',
     allowedCallers: ['direct', 'programmatic'],
     parallelSafety: 'serial',
-    description: 'Read or wait a bounded time for a child agent result. 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 with action:"poll" instead. 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. Every result includes 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. 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. Every result includes 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/tools/apply-patch.js

@@ -8,7 +8,7 @@ export const applyPatchToolDefinition = {
     name: 'apply_patch',
     allowedCallers: ['direct', 'programmatic'],
     parallelSafety: 'serial',
-    description: `Preferred for precise, reviewable local edits. Do not batch all task files merely to reduce tool calls. Group only a few tightly coupled edits whose combined patch is quick to generate and review; split broad or independent work into successive bounded patches before composing them. Submit a raw *** Begin Patch / *** End Patch patch. Supports Add File, Update File, Delete File, and Move to. Add File may replace an existing regular file, and Move to may replace an existing regular destination; duplicate operations on the same resolved path remain invalid. Update hunks accept @@ or @@ <change context>; context-only hunks may also be used as ordered anchors before a later changing hunk. Context is searched forward with Codex-style exact, whitespace-tolerant, then common Unicode punctuation-tolerant matching. Syntax and resolved paths are validated before writing, then file units are committed in order. Each file unit is atomic, and a Move keeps its source and destination atomic. On MAR_AGENT_PATCH_PARTIAL, earlier files remain applied; the error lists applied, failed, and pending paths, so retry only failed and pending paths. Existing file permissions, line endings, and final-newline state are preserved. Returns changed file paths and operations with per-file and total line counts when all units succeed. In Code Mode, the Promise resolves on success and rejects with code/message on failure; the returned envelope has data.files and data.totals, not an ok or success flag. Oversized patches are rejected without advertising defensive limits as recommended patch sizes. A first-unit MAR_AGENT_PATCH_CONFLICT applies nothing; hunk match conflicts identify the affected path and hunk so you can reread only that file before retrying.`,
+    description: `Preferred for precise, reviewable local edits. Do not batch all task files merely to reduce tool calls. Group only a few tightly coupled edits whose combined patch is quick to generate and review; split broad or independent work into successive bounded patches before composing them. Submit a raw *** Begin Patch / *** End Patch patch. Supports Add File, Update File, Delete File, and Move to. Add File may replace an existing regular file, and Move to may replace an existing regular destination; duplicate operations on the same resolved path remain invalid. Update hunks accept @@ or @@ <change context>; context-only hunks may also be used as ordered anchors before a later changing hunk. Omit unchanged file sections: an Update File must change or move the file, and its last hunk must not be context-only. Context is searched forward with Codex-style exact, whitespace-tolerant, then common Unicode punctuation-tolerant matching. Syntax and resolved paths are validated before writing, then file units are committed in order. Each file unit is atomic, and a Move keeps its source and destination atomic. On MAR_AGENT_PATCH_PARTIAL, earlier files remain applied; the error lists applied, failed, and pending paths, so retry only failed and pending paths. Existing file permissions, line endings, and final-newline state are preserved. Returns changed file paths and operations with per-file and total line counts when all units succeed. In Code Mode, the Promise resolves on success and rejects with code/message on failure; the returned envelope has data.files and data.totals, not an ok or success flag. Oversized patches are rejected without advertising defensive limits as recommended patch sizes. A first-unit MAR_AGENT_PATCH_CONFLICT applies nothing; hunk match conflicts identify the affected path and hunk so you can reread only that file before retrying.`,
     inputMode: 'freeform',
     outputSchema: {
         type: 'object',

package/dist/tools/callers.js

@@ -13,7 +13,7 @@ export function toolCallers(tool) {
 export function allowsToolCaller(tool, caller) {
     // Control tools cannot be widened by a Host override or historical definition.
     if (caller === 'programmatic' &&
-        ['code_exec', 'code_exec_wait', 'code_mode', 'tool_search', 'question'].includes(tool.name))
+        ['code_exec', 'code_exec_wait', 'code_mode', 'tool_search', 'question', 'skill'].includes(tool.name))
         return false;
     return toolCallers(tool).includes(caller);
 }

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

@@ -1,9 +1,15 @@
+import { MarAgentError } from '../../error.js';
 import type { ToolExecutionContext, ToolExecutionResult } from '../../sdk/types.js';
 export interface CellOutput {
-    text(value: string): void;
+    text(value: string, originalBytes?: number): void;
     image(value: NonNullable<ToolExecutionResult['images']>[number]): void;
     yield(): void;
 }
+/** Keeps a failed tool call observable without discarding earlier explicit output. */
+export declare class CodeCellExecutionError extends MarAgentError {
+    readonly result: ToolExecutionResult;
+    constructor(error: unknown, result: ToolExecutionResult);
+}
 type Status = 'running' | 'completed' | 'failed' | 'cancelled';
 /** Session-owned execution, separate from the cancellable model-tool wait. */
 export declare class CodeCells {

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

@@ -2,6 +2,19 @@ import { randomUUID } from 'node:crypto';
 import { MarAgentError, describeMarAgentError } from '../../error.js';
 import { TOOL_EXECUTION_LIMITS as limits } from '../execution-limits.js';
 import { truncateModelText } from '../../runtime/token-budget.js';
+import { BoundedTextOutput, renderCapturedText } from './text-output.js';
+/** Keeps a failed tool call observable without discarding earlier explicit output. */
+export class CodeCellExecutionError extends MarAgentError {
+    result;
+    constructor(error, result) {
+        const diagnostic = describeMarAgentError(error, 'MAR_AGENT_CODE_FAILED');
+        super(diagnostic.code, diagnostic.message.replace(`${diagnostic.code}: `, ''), {
+            cause: error,
+            ...(error instanceof MarAgentError ? { retryable: error.retryable } : {})
+        });
+        this.result = result;
+    }
+}
 function options(value, wait) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
         throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Code Exec options must be an object.');
@@ -11,11 +24,11 @@ function options(value, wait) {
         : ['yieldMs', 'maxOutputTokens'];
     if (Object.keys(input).some((key) => !keys.includes(key)))
         throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Unknown Code Exec option.');
-    const yieldMs = input.yieldMs ?? limits.codeDefaultYieldMs;
+    const yieldMs = input.yieldMs ?? (wait ? limits.codeDefaultWaitYieldMs : limits.codeDefaultYieldMs);
     const maxOutputTokens = input.maxOutputTokens ?? limits.codeMaxOutputTokens;
     if (!Number.isSafeInteger(yieldMs) ||
         Number(yieldMs) < 0 ||
-        Number(yieldMs) > limits.codeMaxYieldMs ||
+        Number(yieldMs) > (wait ? limits.codeMaxWaitYieldMs : limits.codeMaxYieldMs) ||
         !Number.isSafeInteger(maxOutputTokens) ||
         Number(maxOutputTokens) < 1 ||
         Number(maxOutputTokens) > limits.codeMaxOutputTokens ||
@@ -73,9 +86,10 @@ export class CodeCells {
             executionId: context.executionId,
             controller,
             status: 'running',
-            text: [],
+            text: new BoundedTextOutput(limits.codeMaxOutputBytes),
             images: [],
             yielded: false,
+            truncated: false,
             listeners: new Set(),
             done: Promise.resolve()
         };
@@ -90,7 +104,7 @@ export class CodeCells {
             .then(async () => {
             releaseSession = await context.codeMode?.retainSession?.();
             return run(source, { ...context, signal: controller.signal }, {
-                text: (text) => cell.text.push(text),
+                text: (text, originalBytes) => cell.text.append(text, originalBytes),
                 image: (image) => cell.images.push(image),
                 yield: () => {
                     cell.yielded = true;
@@ -187,7 +201,12 @@ export class CodeCells {
         if (cell.terminal) {
             const snapshot = cell.terminal.data;
             const bounded = truncateModelText(snapshot.output, input.maxOutputTokens);
-            const data = { ...snapshot, output: bounded.content, cached: true };
+            const data = {
+                ...snapshot,
+                output: bounded.content,
+                truncated: cell.terminal.truncated || bounded.truncated,
+                cached: true
+            };
             return {
                 ...cell.terminal,
                 data,
@@ -195,10 +214,12 @@ export class CodeCells {
                 truncated: cell.terminal.truncated || bounded.truncated
             };
         }
-        const text = cell.text.splice(0).join('\n');
+        const captured = cell.text.drain();
         const images = cell.images.splice(0);
+        const text = renderCapturedText(captured, images.length);
         cell.yielded = false;
         const bounded = truncateModelText(text, input.maxOutputTokens);
+        cell.truncated ||= captured.droppedBytes > 0 || bounded.truncated;
         const error = cell.error === undefined
             ? undefined
             : describeMarAgentError(cell.error, 'MAR_AGENT_CODE_FAILED');
@@ -207,13 +228,16 @@ export class CodeCells {
             status: cell.status,
             output: bounded.content,
             ...cell.result?.data,
+            outputBytes: captured.originalBytes,
+            outputDroppedBytes: captured.droppedBytes,
+            truncated: cell.truncated,
             ...(error ? { error: { code: error.code, message: error.message } } : {}),
             cached: false
         };
         const result = {
             content: JSON.stringify(data),
             data,
-            truncated: bounded.truncated,
+            truncated: cell.truncated,
             ...(images.length ? { images } : {})
         };
         if (cell.status !== 'running')
@@ -221,7 +245,7 @@ export class CodeCells {
         // Keep synchronous completion compatible; retained waits always include explicit lifecycle metadata.
         if (initial && cell.status !== 'running') {
             if (cell.error !== undefined)
-                throw cell.error;
+                throw new CodeCellExecutionError(cell.error, result);
             return { ...result, content: bounded.content || 'Code Exec completed without emitted text.' };
         }
         return result;

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

@@ -1,5 +1,8 @@
 import type { ToolCall, ToolExecutionResult } from '../../sdk/types.js';
 import type { CodeModeStateEntry, CodeModeStateMutation } from './state.js';
+export type ProgrammaticToolResult = Omit<ToolExecutionResult, 'content'> & {
+    content?: string;
+};
 export interface CodeModeCatalogEntry {
     readonly name: string;
     readonly description: string;
@@ -26,8 +29,8 @@ export interface CodeModeEngine {
             stateTotalBytes: number;
             sleepMs: number;
         };
-        onToolCall(call: ToolCall): Promise<ToolExecutionResult>;
-        onText(value: string): void;
+        onToolCall(call: ToolCall): Promise<ProgrammaticToolResult>;
+        onText(value: string, originalBytes?: number): void;
         onImage(value: unknown): void;
         onYield(): void;
     }): Promise<{