@myagentroam/agent 0.11.33 → 0.11.35

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

@@ -0,0 +1,8 @@
+import type { CodeObservation } from '../../session/code-observation-contract.js';
+/** Truncate each body before encoding, never a JSON array or its trusted identity. */
+export declare function boundObservations(values: readonly CodeObservation[], maximumTokens: number): {
+    observations: CodeObservation[];
+    content: string;
+    truncated: boolean;
+};
+export declare function newObservationId(): string;

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

@@ -0,0 +1,64 @@
+import { randomUUID } from 'node:crypto';
+import { truncateModelText, countModelTokens } from '../../runtime/token-budget.js';
+import { observationContent, visibleObservationText, renderObservations } from '../../session/code-observation-projection.js';
+/** Truncate each body before encoding, never a JSON array or its trusted identity. */
+export function boundObservations(values, maximumTokens) {
+    let remaining = Math.max(0, maximumTokens - 2);
+    let truncated = false;
+    const observations = [];
+    const selected = [];
+    let overheadBudget = 0;
+    for (const original of values) {
+        const empty = original.type === 'tool_result'
+            ? { ...original, result: { ...original.result, content: '', truncated: true } }
+            : { ...original, value: '', truncated: true };
+        const overhead = countModelTokens(visibleObservationText(empty)) + 8;
+        if (overheadBudget + overhead > remaining) {
+            truncated = true;
+            break;
+        }
+        selected.push({ original, overhead });
+        overheadBudget += overhead;
+    }
+    for (const { original, overhead } of selected) {
+        let bodyBudget = Math.max(0, remaining - overheadBudget - 12);
+        let value;
+        let bodyTruncated = false;
+        for (;;) {
+            const bounded = truncateModelText(observationContent(original), bodyBudget);
+            bodyTruncated ||= bounded.truncated;
+            value =
+                original.type === 'tool_result'
+                    ? {
+                        ...original,
+                        result: {
+                            ...original.result,
+                            content: bounded.content,
+                            truncated: original.result.truncated === true || bodyTruncated
+                        }
+                    }
+                    : {
+                        ...original,
+                        value: bounded.content,
+                        truncated: original.truncated === true || bodyTruncated
+                    };
+            if (countModelTokens(visibleObservationText(value)) + 1 <=
+                remaining - (overheadBudget - overhead) ||
+                bodyBudget === 0)
+                break;
+            bodyBudget = Math.floor(bodyBudget / 2);
+        }
+        overheadBudget -= overhead;
+        observations.push(value);
+        remaining -= countModelTokens(visibleObservationText(value)) + 1;
+        truncated ||=
+            bodyTruncated ||
+                (original.type === 'tool_result'
+                    ? original.result.truncated === true
+                    : original.truncated === true);
+    }
+    return { observations, content: renderObservations(observations), truncated };
+}
+export function newObservationId() {
+    return randomUUID();
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/tools/contracts.d.ts

@@ -0,0 +1,193 @@
+import type { ExecutionMode } from '../runtime/contracts.js';
+import type { ModelToolDefinition } from '../model/contracts.js';
+import type { CodeModeStateEntry, CodeModeStateMutation } from '../session/code-state.js';
+export type { CodeModeStateEntry, CodeModeStateMutation } from '../session/code-state.js';
+export type { TodoItem, TodoSnapshot } from '../session/todo.js';
+export type ToolCaller = 'direct' | 'programmatic';
+export interface ClientToolDefinition extends ModelToolDefinition {
+    /** Runtime-only result contract; never forwarded as an upstream tool field. */
+    outputSchema?: Record<string, unknown>;
+    /** Runtime-only policy. MCP defaults to both callers; other tools default to direct only. */
+    allowedCallers?: readonly ToolCaller[];
+    /** Runtime-only exposure override; retains both permitted entry points with Code Mode enabled. */
+    codeModeExposure?: 'both';
+    parallelSafety?: 'safe' | 'serial';
+    /** Preserved business-schema eligibility after framework metadata projection. */
+    parameterless?: boolean;
+    /** Runtime-only Agent catalog scope; never forwarded as an upstream tool field. */
+    agentScope?: 'ROOT_AND_SUBAGENTS' | 'ROOT_ONLY';
+}
+export interface ToolCall {
+    name: string;
+    arguments: unknown;
+    callId?: string;
+    /** Framework metadata for native invocations, never a business argument. */
+    permission?: import('./permission-contract.js').ToolPermission | null;
+}
+export interface ToolExecutionContext {
+    mode: ExecutionMode;
+    signal: AbortSignal;
+    waitInterrupt?: import('./wait.js').ToolWaitInterrupt | undefined;
+    /** Live-only process output; does not consume the eventual tool result. */
+    onOutput?: (output: ExecOutputSnapshot) => Promise<void>;
+    sessionId: string;
+    executionId: string;
+    /** Current model identity for neutral Host-owned tool policies. */
+    modelId?: string;
+    recentImages?: readonly {
+        readonly mimeType: string;
+        readonly data: Buffer;
+    }[];
+    codeMode?: {
+        retainSession?(): Promise<() => Promise<void>>;
+        onSettled?(result: CodeCellEventData): Promise<void>;
+        supportsImages?: boolean;
+        permissionStop?(): import('./permission-contract.js').PermissionStop | undefined;
+        tools: readonly ClientToolDefinition[];
+        state?: readonly CodeModeStateEntry[];
+        commitState?(mutations: readonly CodeModeStateMutation[]): Promise<readonly CodeModeStateEntry[]>;
+        invoke(call: ToolCall, signal: AbortSignal): Promise<ToolExecutionResult>;
+    };
+}
+export interface McpToolCatalogContext extends Pick<ToolExecutionContext, 'sessionId' | 'executionId' | 'modelId'> {
+    executionScopeId?: string;
+    claimExecutionScope?: boolean;
+}
+export interface McpToolCatalog {
+    readonly revision: string;
+    readonly servers: readonly {
+        readonly id: string;
+        readonly name: string;
+        readonly description?: string;
+        readonly instructions?: string;
+    }[];
+    readonly tools: readonly McpCatalogTool[];
+}
+export interface McpCatalogTool {
+    readonly definition: ClientToolDefinition;
+    readonly serverId: string;
+    readonly rawName: string;
+    readonly sourceIdentity: string;
+    readonly definitionRevision: string;
+    readonly lifetime: 'session' | 'execution';
+    readonly exposure: 'direct' | 'deferred';
+    /** Untrusted MCP hints; never an authorization or parallel-safety decision. */
+    readonly annotations?: Readonly<Record<string, unknown>>;
+}
+export interface McpToolCallContext extends Pick<ToolExecutionContext, 'sessionId' | 'executionId'> {
+    readonly mode?: ExecutionMode;
+    readonly expectedTool?: {
+        readonly sourceIdentity: string;
+        readonly definitionRevision: string;
+    };
+}
+export interface AgentToolImageArtifact {
+    kind: 'image';
+    name: string;
+    mimeType: 'image/png';
+    byteSize: number;
+    sha256: string;
+    fileName: string;
+}
+export type AgentToolArtifact = AgentToolImageArtifact;
+export interface ExecOutputSnapshot {
+    processId: string;
+    stdout: string;
+    stderr: string;
+    truncated: boolean;
+}
+export interface ToolExecutionResult {
+    calls?: readonly import('../session/code-observation-contract.js').CodeToolCallRecord[];
+    content: string;
+    observations?: readonly import('../session/code-observation-contract.js').CodeObservation[];
+    data?: unknown;
+    /** Runtime-only definitions used to encode a Tool Search output. */
+    toolSearchTools?: readonly ClientToolDefinition[];
+    truncated?: boolean;
+    images?: readonly import('../model/image-contract.js').ModelImage[];
+    artifacts?: readonly AgentToolArtifact[];
+    /** Host-facing evidence, excluded from model and programmatic guest results. */
+    resultExtensions?: readonly import('./result-extension-contract.js').ToolResultExtension[];
+}
+export interface CodeCellEventData {
+    permissionStop?: import('./permission-contract.js').PermissionStop;
+    calls?: readonly import('../session/code-observation-contract.js').CodeToolCallRecord[];
+    cellId: string;
+    status: 'running' | 'completed' | 'failed' | 'cancelled';
+    waitOutcome?: import('./wait.js').ToolWaitOutcome;
+    reason?: 'steer';
+    cached?: boolean;
+    observations?: readonly import('../session/code-observation-contract.js').CodeObservation[];
+}
+export interface ExecResult {
+    status: 'running' | 'completed' | 'cancelled';
+    waitOutcome?: import('./wait.js').ToolWaitOutcome;
+    reason?: 'steer';
+    processId?: string;
+    stdout: string;
+    stderr: string;
+    exitCode?: number | null;
+    truncated: boolean;
+    stdoutBytes: number;
+    stderrBytes: number;
+    stdoutDroppedBytes: number;
+    stderrDroppedBytes: number;
+    /** A terminal snapshot replay rather than new process output. */
+    cached?: boolean;
+}
+export interface ApplyPatchFileResult {
+    path: string;
+    targetPath?: string;
+    operation: 'added' | 'modified' | 'deleted' | 'moved';
+    addedLines: number;
+    deletedLines: number;
+}
+export interface ApplyPatchResult {
+    files: ApplyPatchFileResult[];
+    totals: {
+        files: number;
+        addedLines: number;
+        deletedLines: number;
+    };
+}
+export interface ApplyPatchPartialResult extends ApplyPatchResult {
+    failedFile: string;
+    pendingFiles: string[];
+}
+export interface ReadEventData {
+    mode: 'batch';
+    results: Array<{
+        path: string;
+        startLine?: number;
+        endLine?: number;
+        error?: {
+            code: string;
+            message: string;
+        };
+    }>;
+    truncated: boolean;
+}
+export interface ViewImageRegion {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface ViewImageResult {
+    /** The input source; transformations may produce a different output resource. */
+    path?: string;
+    resourceId?: string;
+    mimeType: 'image/png' | 'image/jpeg' | 'image/webp';
+    bytes: number;
+    width: number;
+    height: number;
+    sourceWidth?: number;
+    sourceHeight?: number;
+    region?: ViewImageRegion;
+    sha256: string;
+}
+export interface SleepResult {
+    durationMs: number;
+    elapsedMs: number;
+    wakeReason: 'elapsed' | 'steer' | 'subagent_message';
+}

package/dist/tools/contracts.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export { orderToolDefinitions, stableToolDefinition, stableToolSchema } from '../model/tool-definition-projection.js';

package/dist/tools/definition-projection.js

@@ -0,0 +1 @@
+export { orderToolDefinitions, stableToolDefinition, stableToolSchema } from '../model/tool-definition-projection.js';

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

@@ -0,0 +1,69 @@
+export declare const TOOL_EXECUTION_LIMITS: Readonly<{
+    sleepMaxDurationMs: 1800000;
+    questionMaxTextCharacters: 1000;
+    questionMaxOptionCharacters: 500;
+    todoMaxItems: 100;
+    todoMaxTextCharacters: 1000;
+    agentWaitMinWaitMs: 0;
+    agentWaitWaitFloorMs: 10000;
+    agentWaitDefaultWaitMs: 30000;
+    agentWaitMaxWaitMs: 300000;
+    agentWaitMaxAgents: 8;
+    subagentDescriptionMaxCharacters: 80;
+    subagentPromptMaxBytes: 131072;
+    subagentMessageMaxBytes: 131072;
+    subagentReasoningEffortMaxCharacters: 64;
+    subagentSummaryMaxBytes: 16384;
+    subagentUpdateMaxBytes: 32768;
+    subagentRunningLatestMessageMaxCharacters: 2000;
+    subagentEvidenceMaxItems: 64;
+    subagentVerificationMaxItems: 16;
+    subagentChangedFilesMaxItems: 200;
+    readDefaultLines: 200;
+    readMaxLines: 2000;
+    readMaxBytes: 1048576;
+    readMaxBatchItems: 16;
+    readBatchConcurrency: 4;
+    readMaxBatchBytes: 4194304;
+    viewImageMaxBytes: 3145728;
+    viewImageMaxSourceBytes: 20971520;
+    viewImageMaxPixels: 16777216;
+    execMaxTimeoutMs: 3600000;
+    execDefaultYieldMs: 10000;
+    execMaxYieldMs: 30000;
+    execMaxPollYieldMs: 300000;
+    execTerminationGraceMs: 1000;
+    execDefaultMaxOutputBytes: 1000000;
+    execProgressMaxOutputBytes: 8192;
+    execProgressIntervalMs: 100;
+    maxProcesses: 64;
+    execMaxCompletedResults: 16;
+    execCompletedRetentionMs: 300000;
+    codeMaxInputBytes: 1048576;
+    codeMaxOutputBytes: 1048576;
+    codeMaxFrameBytes: 33554432;
+    codeMaxTransportBytes: 67108864;
+    codeMaxCalls: 128;
+    codeMaxConcurrentCells: 64;
+    codeDefaultYieldMs: 30000;
+    codeDefaultWaitYieldMs: 10000;
+    codeMaxYieldMs: 30000;
+    codeMaxWaitYieldMs: 300000;
+    codeMaxOutputTokens: 10000;
+    codeCompletedRetentionMs: 600000;
+    codeMaxCompletedResults: 32;
+    codeStateMaxEntries: 128;
+    codeStateMaxMutations: 128;
+    codeStateMaxKeyBytes: 256;
+    codeStateMaxValueBytes: 65536;
+    codeStateMaxTotalBytes: 1048576;
+    codeSleepMaxMs: 30000;
+    codeHeapMegabytes: 128;
+    codeMemoryBytes: 33554432;
+    codeStackBytes: 524288;
+    codeTimeoutMs: 120000;
+    patchMaxBytes: 4194304;
+    patchMaxFiles: 100;
+    patchMaxFileBytes: 8388608;
+    patchMaxTotalBytes: 33554432;
+}>;

package/dist/tools/execution-limits.js

@@ -0,0 +1,58 @@
+import { CODE_STATE_LIMITS } from '../session/code-state.js';
+import { HISTORY_INPUT_LIMITS } from '../session/history-input-limits.js';
+import { SUBAGENT_LIMITS } from '../subagent/limits.js';
+export const TOOL_EXECUTION_LIMITS = Object.freeze({
+    readDefaultLines: 200,
+    readMaxLines: 2_000,
+    readMaxBytes: 1_048_576,
+    readMaxBatchItems: 16,
+    readBatchConcurrency: 4,
+    readMaxBatchBytes: 4_194_304,
+    viewImageMaxBytes: 3_145_728,
+    viewImageMaxSourceBytes: 20_971_520,
+    viewImageMaxPixels: 16_777_216,
+    execMaxTimeoutMs: 3_600_000,
+    execDefaultYieldMs: 10_000,
+    execMaxYieldMs: 30_000,
+    execMaxPollYieldMs: 300_000,
+    execTerminationGraceMs: 1_000,
+    execDefaultMaxOutputBytes: 1_000_000,
+    execProgressMaxOutputBytes: 8_192,
+    execProgressIntervalMs: 100,
+    maxProcesses: 64,
+    execMaxCompletedResults: 16,
+    execCompletedRetentionMs: 300_000,
+    codeMaxInputBytes: HISTORY_INPUT_LIMITS.codeMaxInputBytes,
+    codeMaxOutputBytes: 1_048_576,
+    codeMaxFrameBytes: 33_554_432,
+    codeMaxTransportBytes: 67_108_864,
+    codeMaxCalls: 128,
+    codeMaxConcurrentCells: 64,
+    codeDefaultYieldMs: 30_000,
+    codeDefaultWaitYieldMs: 10_000,
+    codeMaxYieldMs: 30_000,
+    codeMaxWaitYieldMs: 300_000,
+    codeMaxOutputTokens: 10_000,
+    codeCompletedRetentionMs: 600_000,
+    codeMaxCompletedResults: 32,
+    codeStateMaxEntries: CODE_STATE_LIMITS.codeStateMaxEntries,
+    codeStateMaxMutations: CODE_STATE_LIMITS.codeStateMaxMutations,
+    codeStateMaxKeyBytes: CODE_STATE_LIMITS.codeStateMaxKeyBytes,
+    codeStateMaxValueBytes: CODE_STATE_LIMITS.codeStateMaxValueBytes,
+    codeStateMaxTotalBytes: CODE_STATE_LIMITS.codeStateMaxTotalBytes,
+    codeSleepMaxMs: 30_000,
+    codeHeapMegabytes: 128,
+    codeMemoryBytes: 33_554_432,
+    codeStackBytes: 524_288,
+    codeTimeoutMs: 120_000, // Cumulative synchronous guest execution, not cell wall time.
+    patchMaxBytes: HISTORY_INPUT_LIMITS.patchMaxBytes,
+    patchMaxFiles: 100,
+    patchMaxFileBytes: 8_388_608,
+    patchMaxTotalBytes: 33_554_432,
+    ...SUBAGENT_LIMITS,
+    sleepMaxDurationMs: 1_800_000,
+    questionMaxTextCharacters: 1_000,
+    questionMaxOptionCharacters: 500,
+    todoMaxItems: 100,
+    todoMaxTextCharacters: 1_000
+});

package/dist/tools/execution.d.ts

@@ -0,0 +1,30 @@
+import type { ClientToolCall, ExecutedToolCall } from '../runtime/tool-round-contract.js';
+export type { ClientToolCall, ExecutedToolCall } from '../runtime/tool-round-contract.js';
+import type { EventPayload } from '../runtime/events.js';
+import type { ClientToolDefinition, McpToolCallContext, ToolExecutionContext } from './contracts.js';
+import type { ToolRuntimeContext, ToolRuntimeImage } from './runtime-context.js';
+import { type createSessionToolScheduler } from './scheduler.js';
+import type { ToolCall } from './contracts.js';
+/** One immutable model round's catalog; execution resources remain owned by the SDK/Host. */
+export interface RoundToolScope {
+    readonly context: Omit<ToolRuntimeContext, 'codeMode' | 'expectedMcpTool' | 'searchMcpTools' | 'recentImages'>;
+    readonly tools: readonly ClientToolDefinition[];
+    readonly expectations: ReadonlyMap<string, McpToolCallContext['expectedTool']>;
+    readonly extensionToolNames: ReadonlySet<string>;
+    readonly schedule: ReturnType<typeof createSessionToolScheduler>;
+    readonly assertLive: () => void;
+    readonly assertExecutionLive: () => void;
+    readonly emit: (event: EventPayload, assertLive?: () => void) => Promise<void>;
+    readonly searchMcpTools: NonNullable<ToolRuntimeContext['searchMcpTools']>;
+    readonly recentImages: () => Promise<ToolRuntimeImage[]>;
+    readonly captureCodeContext: () => Omit<ToolRuntimeContext, 'signal' | 'codeMode' | 'expectedMcpTool' | 'searchMcpTools'>;
+    readonly codeModeContext: (call: ToolCall & {
+        readonly callId: string;
+    }) => Promise<Omit<NonNullable<ToolExecutionContext['codeMode']>, 'invoke'>>;
+}
+/** Shared raw context construction for physical tools and native calls in a real model round. */
+export declare function createRoundToolRuntimeContext(scope: RoundToolScope, call: ToolCall & {
+    readonly callId: string;
+}, signal: AbortSignal): Promise<ToolRuntimeContext>;
+/** Complete every call in model order even if individual execution fails. */
+export declare function executeRoundTools(calls: readonly ClientToolCall[], scope: RoundToolScope): Promise<ExecutedToolCall[]>;

package/dist/tools/execution.js

@@ -0,0 +1,191 @@
+import { AgentError, describeAgentError } from '../error.js';
+import { toolEventSummary } from '../runtime/event-projection.js';
+import { allowsToolCaller } from './callers.js';
+import { CodeCellExecutionError } from './code-mode/cells.js';
+import { createCodeToolDispatch } from './code-mode/dispatch.js';
+import { boundedModelToolOutput, structuredToolArtifacts, structuredToolEventData, structuredToolFailureData } from './output-projection.js';
+import { publishModelResources } from '../runtime/resource-publication.js';
+import { executeRegisteredTool } from './runtime.js';
+import { failedToolResultExtensions } from './result-extensions.js';
+import { permissionStopFromError } from './permissions.js';
+import { scheduleToolCallBatch } from './scheduler.js';
+/** Shared raw context construction for physical tools and native calls in a real model round. */
+export async function createRoundToolRuntimeContext(scope, call, signal) {
+    scope.assertLive();
+    signal.throwIfAborted();
+    const codeMode = await scope.codeModeContext(call);
+    const recentImages = scope.extensionToolNames.has(call.name) ||
+        call.name === 'code_exec' ||
+        call.name === 'code_exec_wait'
+        ? await scope.recentImages()
+        : undefined;
+    scope.assertLive();
+    signal.throwIfAborted();
+    const assertSessionLive = scope.assertLive;
+    const assertExecutionLive = scope.assertExecutionLive;
+    const emitCodeEvent = scope.emit;
+    const retainSession = codeMode.retainSession?.bind(codeMode);
+    let retained = 0;
+    const assertDispatchLive = () => {
+        assertSessionLive();
+        if (retained === 0)
+            assertExecutionLive();
+    };
+    return {
+        ...scope.context,
+        ...(scope.expectations.get(call.name)
+            ? { expectedMcpTool: scope.expectations.get(call.name) }
+            : {}),
+        searchMcpTools: scope.searchMcpTools,
+        signal,
+        codeMode: {
+            ...codeMode,
+            ...(retainSession === undefined
+                ? {}
+                : {
+                    retainSession: async () => {
+                        assertDispatchLive();
+                        const release = await retainSession();
+                        retained++;
+                        let released = false;
+                        return async () => {
+                            if (released)
+                                return;
+                            released = true;
+                            retained--;
+                            await release();
+                        };
+                    }
+                }),
+            invoke: createCodeToolDispatch({
+                context: {
+                    ...scope.captureCodeContext(),
+                    ...(recentImages === undefined ? {} : { recentImages })
+                },
+                tools: scope.tools,
+                expectations: scope.expectations,
+                parentCallId: call.callId,
+                schedule: scope.schedule,
+                assertLive: assertDispatchLive,
+                emit: (event) => emitCodeEvent(event, assertDispatchLive)
+            })
+        },
+        ...(scope.extensionToolNames.has(call.name) && recentImages !== undefined
+            ? { recentImages }
+            : {})
+    };
+}
+/** Complete every call in model order even if individual execution fails. */
+export async function executeRoundTools(calls, scope) {
+    const executeCall = async (call, signal = scope.context.signal, caller = 'direct', parentCallId) => {
+        await scope.emit({
+            type: 'tool.started',
+            toolName: call.name,
+            callId: call.callId,
+            ...(parentCallId === undefined ? {} : { parentCallId }),
+            input: call.arguments
+        });
+        try {
+            if (call.argumentError)
+                throw new AgentError('MAR_AGENT_TOOL_INPUT_INVALID', call.argumentError);
+            if (!scope.tools.some((tool) => tool.name === call.name && allowsToolCaller(tool, caller)))
+                throw new AgentError('MAR_AGENT_TOOL_NOT_AVAILABLE', 'Tool is unavailable in this execution.');
+            const context = await createRoundToolRuntimeContext(scope, call, signal);
+            const runTool = () => {
+                signal.throwIfAborted();
+                return executeRegisteredTool(call.name, call.arguments, call.callId, context);
+            };
+            const rawOutput = call.name === 'code_exec' || call.name === 'code_exec_wait'
+                ? await runTool()
+                : await scope.schedule(scope.tools.find((tool) => tool.name === call.name), runTool);
+            const publishedImages = await publishModelResources(scope.context.host, rawOutput.images, {
+                sessionId: scope.context.sessionId,
+                executionId: scope.context.executionId
+            }, scope.context.imageStore);
+            const output = publishedImages === rawOutput.images
+                ? rawOutput
+                : {
+                    ...rawOutput,
+                    ...(publishedImages === undefined ? {} : { images: publishedImages })
+                };
+            const modelOutput = boundedModelToolOutput(call.name, output.content, output.data);
+            const eventSummary = toolEventSummary(output.content);
+            const structuredData = structuredToolEventData(call.name, output.data);
+            const artifacts = structuredToolArtifacts(output.artifacts);
+            await scope.emit({
+                type: 'tool.completed',
+                ...(output.resultExtensions ? { resultExtensions: output.resultExtensions } : {}),
+                toolName: call.name,
+                callId: call.callId,
+                ...(parentCallId === undefined ? {} : { parentCallId }),
+                summary: eventSummary.summary,
+                truncated: output.truncated === true || modelOutput.truncated || eventSummary.truncated,
+                ...(artifacts === undefined ? {} : { artifacts }),
+                ...(structuredData === undefined ? {} : { data: structuredData })
+            });
+            return {
+                call,
+                output,
+                content: modelOutput.content,
+                ...(rawOutput.images?.length ? { sourceImages: rawOutput.images } : {}),
+                ...(output.calls
+                    ? { calls: output.calls.map(({ resultExtensions: _evidence, ...call }) => call) }
+                    : {}),
+                ...(output.observations ? { observations: output.observations } : {}),
+                ...(output.images?.length ? { images: output.images } : {}),
+                failed: false
+            };
+        }
+        catch (error) {
+            const diagnostic = describeAgentError(error, 'MAR_AGENT_HOST_OPERATION_FAILED');
+            const partialResult = error instanceof CodeCellExecutionError ? error.result : undefined;
+            const publishedPartialImages = await publishModelResources(scope.context.host, partialResult?.images, { sessionId: scope.context.sessionId, executionId: scope.context.executionId }, scope.context.imageStore);
+            const partial = partialResult !== undefined && publishedPartialImages !== partialResult.images
+                ? { ...partialResult, images: publishedPartialImages }
+                : partialResult;
+            const failureData = structuredToolFailureData(call.name, error);
+            const eventData = failureData ??
+                (partial?.data === undefined
+                    ? undefined
+                    : structuredToolEventData(call.name, partial.data));
+            await scope.emit({
+                type: 'tool.failed',
+                ...(failedToolResultExtensions(error)
+                    ? { resultExtensions: failedToolResultExtensions(error) }
+                    : {}),
+                toolName: call.name,
+                callId: call.callId,
+                ...(parentCallId === undefined ? {} : { parentCallId }),
+                code: diagnostic.code,
+                message: diagnostic.message,
+                ...(permissionStopFromError(error)
+                    ? { permissionStop: permissionStopFromError(error) }
+                    : {}),
+                ...(eventData === undefined ? {} : { data: eventData })
+            });
+            return {
+                call,
+                content: partial === undefined
+                    ? boundedModelToolOutput(call.name, JSON.stringify({
+                        error: diagnostic.code,
+                        message: diagnostic.message,
+                        ...(permissionStopFromError(error)
+                            ? { permissionStop: permissionStopFromError(error) }
+                            : {}),
+                        ...(failureData === undefined ? {} : { data: failureData }),
+                        ...(error instanceof AgentError && error.retryable ? { retryable: true } : {})
+                    }), failureData).content
+                    : boundedModelToolOutput(call.name, partial.content, partial.data).content,
+                ...(partial?.images?.length ? { images: partial.images } : {}),
+                ...(partialResult?.images?.length ? { sourceImages: partialResult.images } : {}),
+                failed: true,
+                ...(partial?.calls
+                    ? { calls: partial.calls.map(({ resultExtensions: _evidence, ...call }) => call) }
+                    : {}),
+                ...(partial?.observations ? { observations: partial.observations } : {}),
+                error
+            };
+        }
+    };
+    return scheduleToolCallBatch(calls, scope.tools, executeCall);
+}