@myagentroam/agent 0.11.32 → 0.11.34

package/dist/agent-core/tools/agent/smart-compact.js

@@ -1,23 +0,0 @@
-import { MarAgentError } from '../../error.js';
-import { SMART_COMPACTION_MARKER } from '../../runtime/compaction/smart.js';
-export const smartCompactToolDefinition = {
-    name: 'smart_compact',
-    allowedCallers: ['direct', 'programmatic'],
-    parallelSafety: 'safe',
-    description: 'Request background context compaction only when the current real user message includes this runtime note: ' +
-        SMART_COMPACTION_MARKER +
-        ' The note indicates capacity eligibility, not a recommendation; historical notes do not qualify the current input. Judge the phase transition from the conversation; call only if key state can be retained in a summary. Do not call merely because context is long, for a one-off question, or while continuing unresolved work that still needs prior evidence. A new user message or completed reply alone is not a phase transition. If uncertain, skip. Prefer calling alongside the first necessary tools. Acceptance does not wait for generation or installation.',
-    inputSchema: { type: 'object', properties: {}, additionalProperties: false }
-};
-export function executeSmartCompact(arguments_, context) {
-    if (!arguments_ ||
-        typeof arguments_ !== 'object' ||
-        Array.isArray(arguments_) ||
-        Object.keys(arguments_).length)
-        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Smart Compaction input must be an empty object.');
-    if (!context.requestSmartCompact)
-        throw new MarAgentError('MAR_AGENT_SMART_COMPACT_DENIED', 'The current user input is not eligible for Smart Compaction.');
-    context.requestSmartCompact();
-    const data = { status: 'accepted' };
-    return Promise.resolve({ content: JSON.stringify(data), data });
-}

package/dist/agent-core/tools/agent/todo-read.d.ts

@@ -1,14 +0,0 @@
-import type { ClientToolDefinition } from '../../model/contracts.js';
-import type { ToolRuntimeContext } from '../runtime-context.js';
-export declare const todoReadToolDefinition: ClientToolDefinition;
-export declare function executeTodoRead(context: ToolRuntimeContext): Promise<{
-    content: string;
-    data: {
-        revision: number;
-        items: {
-            id: string;
-            step: string;
-            status: "pending" | "in_progress" | "completed";
-        }[];
-    };
-}>;

package/dist/agent-core/tools/agent/todo-write.d.ts

@@ -1,14 +0,0 @@
-import type { ClientToolDefinition } from '../../model/contracts.js';
-import type { ToolRuntimeContext } from '../runtime-context.js';
-export declare const todoWriteToolDefinition: ClientToolDefinition;
-export declare function executeTodoWrite(arguments_: unknown, context: ToolRuntimeContext): Promise<{
-    content: string;
-    data: {
-        revision: number;
-        items: {
-            id: string;
-            step: string;
-            status: "pending" | "in_progress" | "completed";
-        }[];
-    };
-}>;

package/dist/agent-core/tools/agent/todo-write.js

@@ -1,66 +0,0 @@
-import { MarAgentError } from '../../error.js';
-import { TOOL_EXECUTION_LIMITS } from '../execution-limits.js';
-export const todoWriteToolDefinition = {
-    name: 'todo_write',
-    allowedCallers: ['direct', 'programmatic'],
-    parallelSafety: 'serial',
-    description: 'Replace this session’s entire Todo list with the supplied items; no prior read is required. Preserve stable IDs and statuses only when extending the same objective. For a materially different objective, include only the new objective’s items. Do not retain completed items from an earlier objective; when all current items are completed, default a substantive new request to replacement unless the user explicitly asks to continue, extend, verify, or follow up. Use only after Todo has been chosen for coordination-heavy work; straightforward bounded work does not need it. Keep at most one in_progress item and update statuses after meaningful stage changes. When another substantive tool call is already ready and does not depend on the Todo result, include both in the same model response instead of spending a response only for Todo bookkeeping.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            items: {
-                type: 'array',
-                maxItems: TOOL_EXECUTION_LIMITS.todoMaxItems,
-                items: {
-                    type: 'object',
-                    properties: {
-                        id: { type: 'string' },
-                        step: { type: 'string', maxLength: TOOL_EXECUTION_LIMITS.todoMaxTextCharacters },
-                        status: { enum: ['pending', 'in_progress', 'completed'] }
-                    },
-                    required: ['id', 'step', 'status'],
-                    additionalProperties: false
-                }
-            }
-        },
-        required: ['items'],
-        additionalProperties: false
-    }
-};
-export async function executeTodoWrite(arguments_, context) {
-    const value = parseTodoWriteInput(arguments_);
-    const todo = context.todo.write(value);
-    await context.emit({ type: 'todo.updated', revision: todo.revision, items: todo.items });
-    return {
-        content: JSON.stringify({ revision: todo.revision, count: todo.items.length }),
-        data: todo
-    };
-}
-function parseTodoWriteInput(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return invalid();
-    const input = value;
-    if (Object.keys(input).some((key) => key !== 'items') ||
-        !Array.isArray(input.items) ||
-        input.items.length > TOOL_EXECUTION_LIMITS.todoMaxItems)
-        return invalid();
-    const items = input.items.map((item) => {
-        if (!item || typeof item !== 'object' || Array.isArray(item))
-            return invalid();
-        const record = item;
-        if (Object.keys(record).some((key) => !['id', 'step', 'status'].includes(key)) ||
-            typeof record.id !== 'string' ||
-            record.id.trim().length === 0 ||
-            record.id.length > 128 ||
-            typeof record.step !== 'string' ||
-            record.step.trim().length === 0 ||
-            record.step.length > TOOL_EXECUTION_LIMITS.todoMaxTextCharacters ||
-            !['pending', 'in_progress', 'completed'].includes(String(record.status)))
-            return invalid();
-        return { id: record.id, step: record.step, status: record.status };
-    });
-    return { items };
-}
-function invalid() {
-    throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Todo input is invalid.');
-}

package/dist/agent-core/tools/agent/todo.d.ts

@@ -1,26 +0,0 @@
-import type { TodoItem, TodoSnapshot } from '../contracts.js';
-export type { TodoItem, TodoSnapshot } from '../contracts.js';
-export declare class TodoStore {
-    #private;
-    static restore(snapshot: TodoSnapshot): TodoStore;
-    read(): {
-        revision: number;
-        items: {
-            id: string;
-            step: string;
-            status: "pending" | "in_progress" | "completed";
-        }[];
-    };
-    write(input: {
-        items: readonly TodoItem[];
-    }): {
-        revision: number;
-        items: {
-            id: string;
-            step: string;
-            status: "pending" | "in_progress" | "completed";
-        }[];
-    };
-}
-export declare function todoItemsFromSnapshot(snapshot: unknown): TodoItem[] | undefined;
-export declare function restoreTodoStore(snapshots: readonly unknown[]): TodoStore;

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

@@ -1,60 +0,0 @@
-import { MarAgentError } from '../../error.js';
-export class TodoStore {
-    #revision = 0;
-    #items = [];
-    static restore(snapshot) {
-        if (!Number.isSafeInteger(snapshot.revision) || snapshot.revision < 0)
-            throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Todo revision is invalid.');
-        const todo = new TodoStore();
-        todo.#revision = snapshot.revision;
-        todo.#items = normalizeTodoItems(snapshot.items);
-        return todo;
-    }
-    read() {
-        return { revision: this.#revision, items: this.#items.map((item) => ({ ...item })) };
-    }
-    write(input) {
-        this.#items = normalizeTodoItems(input.items);
-        this.#revision++;
-        return this.read();
-    }
-}
-export function todoItemsFromSnapshot(snapshot) {
-    if (snapshot === null || typeof snapshot !== 'object' || Array.isArray(snapshot))
-        return undefined;
-    const items = snapshot.items;
-    if (!Array.isArray(items))
-        return undefined;
-    try {
-        return normalizeTodoItems(items);
-    }
-    catch (error) {
-        if (error instanceof MarAgentError && error.code === 'MAR_AGENT_TOOL_INPUT_INVALID')
-            return undefined;
-        throw error;
-    }
-}
-export function restoreTodoStore(snapshots) {
-    const todo = new TodoStore();
-    for (const snapshot of snapshots) {
-        const items = todoItemsFromSnapshot(snapshot);
-        if (!items)
-            continue;
-        todo.write({ items });
-    }
-    return todo;
-}
-function normalizeTodoItems(items) {
-    if (items.filter((item) => item?.status === 'in_progress').length > 1 ||
-        new Set(items.map((item) => item?.id)).size !== items.length ||
-        items.some((item) => item === null ||
-            typeof item !== 'object' ||
-            Array.isArray(item) ||
-            typeof item.id !== 'string' ||
-            !item.id ||
-            typeof item.step !== 'string' ||
-            !item.step.trim() ||
-            !['pending', 'in_progress', 'completed'].includes(item.status)))
-        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Todo items are invalid.');
-    return items.map((item) => ({ ...item, step: item.step.trim() }));
-}

package/dist/agent-core/tools/callers.d.ts

@@ -1,6 +0,0 @@
-import type { ClientToolDefinition, ToolCaller } from '../model/contracts.js';
-/** Normalize trusted Host policy independently of discovery, Agent scope and parallel safety. */
-export declare function toolCallers(tool: ClientToolDefinition): readonly ToolCaller[];
-export declare function allowsToolCaller(tool: ClientToolDefinition, caller: ToolCaller): boolean;
-/** Code Mode Only changes model exposure, never the Host's underlying caller permissions. */
-export declare function allowsDirectTool(tool: ClientToolDefinition, codeModeEnabled: boolean): boolean;

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

@@ -1,39 +0,0 @@
-import { MarAgentError } from '../error.js';
-/** Normalize trusted Host policy independently of discovery, Agent scope and parallel safety. */
-export function toolCallers(tool) {
-    if (tool.codeModeExposure !== undefined && tool.codeModeExposure !== 'both')
-        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Code Mode exposure is invalid.');
-    const value = tool.allowedCallers;
-    if (value === undefined)
-        return tool.name.startsWith('mcp__') ? ['direct', 'programmatic'] : ['direct'];
-    if (!Array.isArray(value) ||
-        value.length === 0 ||
-        value.some((caller) => caller !== 'direct' && caller !== 'programmatic'))
-        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Tool caller policy is invalid.');
-    return ['direct', 'programmatic'].filter((caller) => value.includes(caller));
-}
-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',
-            'tool_search',
-            'question',
-            'skill',
-            'sleep',
-            'agent_start',
-            'agent_wait',
-            'agent_message',
-            'agent_cancel'
-        ].includes(tool.name))
-        return false;
-    return toolCallers(tool).includes(caller);
-}
-/** Code Mode Only changes model exposure, never the Host's underlying caller permissions. */
-export function allowsDirectTool(tool, codeModeEnabled) {
-    return (allowsToolCaller(tool, 'direct') &&
-        (!codeModeEnabled ||
-            tool.codeModeExposure === 'both' ||
-            !allowsToolCaller(tool, 'programmatic')));
-}

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

@@ -1,29 +0,0 @@
-import { MarAgentError } from '../../error.js';
-import type { ToolExecutionContext, ToolExecutionResult } from '../contracts.js';
-import { type CodeObservation } from './observations.js';
-export interface CellOutput {
-    call(value: import('./observations.js').CodeToolCallRecord): void;
-    observe(value: CodeObservation): 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 {
-    #private;
-    start(value: unknown, context: ToolExecutionContext, run: (code: string, context: ToolExecutionContext, output: CellOutput) => Promise<ToolExecutionResult>): Promise<ToolExecutionResult>;
-    wait(value: unknown, context: ToolExecutionContext): Promise<ToolExecutionResult>;
-    snapshot(sessionId: string): {
-        cellId: string;
-        status: Status;
-        executionId: string;
-    }[];
-    dispose(sessionId?: string): Promise<void>;
-}
-export {};

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

@@ -1,337 +0,0 @@
-import { permissionStopFromError } from '../permissions.js';
-import { RuntimeResourceHandles } from '../runtime-resource-handles.js';
-import { MarAgentError, describeMarAgentError } from '../../error.js';
-import { truncateModelText } from '../../runtime/token-budget.js';
-import { TOOL_EXECUTION_LIMITS as limits } from '../execution-limits.js';
-import { waitForToolCondition, waitMetadata } from '../wait.js';
-import { BoundedTextOutput, renderCapturedText } from './text-output.js';
-import { boundObservations, selectObservationImages, newObservationId, visibleObservation } from './observations.js';
-/** Keeps a failed tool call observable without discarding earlier explicit output. */
-export class CodeCellExecutionError extends MarAgentError {
-    result;
-    constructor(error, result) {
-        // Preserve the original chain; the public boundary summarizes its causes only once.
-        const diagnostic = describeMarAgentError(error, 'MAR_AGENT_CODE_FAILED', undefined, false);
-        super(diagnostic.code, diagnostic.message, {
-            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.');
-    const input = value;
-    const yieldMs = input.yieldMs ?? (wait ? limits.codeDefaultWaitYieldMs : limits.codeDefaultYieldMs);
-    if (!Number.isSafeInteger(yieldMs) ||
-        Number(yieldMs) < 0 ||
-        Number(yieldMs) > (wait ? limits.codeMaxWaitYieldMs : limits.codeMaxYieldMs) ||
-        (wait && (typeof input.cellId !== 'string' || !input.cellId)) ||
-        (input.action !== undefined && input.action !== 'poll' && input.action !== 'cancel'))
-        throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Code Exec options are out of range.');
-    return {
-        cellId: input.cellId,
-        yieldMs: Number(yieldMs),
-        action: input.action ?? 'poll'
-    };
-}
-/** Session-owned execution, separate from the cancellable model-tool wait. */
-export class CodeCells {
-    #cells = new Map();
-    #handles = new RuntimeResourceHandles('cell', (id) => this.#cells.has(id));
-    #closed = false;
-    #disposing = new Set();
-    async start(value, context, run) {
-        const source = typeof value === 'string'
-            ? value
-            : value &&
-                typeof value === 'object' &&
-                !Array.isArray(value) &&
-                Object.keys(value).length === 1 &&
-                'code' in value
-                ? value.code
-                : undefined;
-        if (typeof source !== 'string' ||
-            !source.trim() ||
-            Buffer.byteLength(source) > limits.codeMaxInputBytes)
-            throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Code must be a nonempty bounded JavaScript string.');
-        let settings = options({}, false);
-        const pragma = /^\/\/ @options:\s*([^\r\n]*)(?:\r?\n|$)/u.exec(source);
-        if (pragma) {
-            try {
-                settings = options(JSON.parse(pragma[1]), false);
-            }
-            catch (error) {
-                if (error instanceof MarAgentError)
-                    throw error;
-                throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Code Exec options must be valid JSON.');
-            }
-        }
-        context.signal.throwIfAborted();
-        if (this.#closed || this.#disposing.has(context.sessionId))
-            throw new MarAgentError('MAR_AGENT_CODE_CANCELLED', 'Code Exec resources are being released.');
-        if ([...this.#cells.values()].filter((cell) => cell.status === 'running').length >=
-            limits.codeMaxConcurrentCells)
-            throw new MarAgentError('MAR_AGENT_PROCESS_LIMIT', `The Local Host shared running-cell limit (${limits.codeMaxConcurrentCells}) was reached.`);
-        const controller = new AbortController();
-        const cell = {
-            cellId: this.#handles.create(),
-            sessionId: context.sessionId,
-            executionId: context.executionId,
-            controller,
-            status: 'running',
-            text: new BoundedTextOutput(limits.codeMaxOutputBytes),
-            images: [],
-            observations: [],
-            calls: new Map(),
-            imageOffset: 0,
-            yielded: false,
-            truncated: false,
-            listeners: new Set(),
-            done: Promise.resolve()
-        };
-        this.#cells.set(cell.cellId, cell);
-        const notify = () => {
-            for (const listener of cell.listeners)
-                listener();
-        };
-        let releaseSession;
-        let outcome = 'running';
-        cell.done = Promise.resolve()
-            .then(async () => {
-            releaseSession = await context.codeMode?.retainSession?.();
-            return run(source, { ...context, signal: controller.signal, waitInterrupt: undefined }, {
-                call: (value) => cell.calls.set(value.callId, value),
-                observe: (value) => cell.observations.push(value),
-                text: (text, originalBytes) => cell.text.append(text, originalBytes),
-                image: (image) => cell.images.push(image),
-                yield: () => {
-                    cell.yielded = true;
-                    notify();
-                }
-            });
-        })
-            .then((result) => {
-            cell.result = {
-                content: '',
-                ...(result.data === undefined ? {} : { data: result.data })
-            };
-            outcome = 'completed';
-        }, (error) => {
-            cell.error = error;
-            outcome = controller.signal.aborted ? 'cancelled' : 'failed';
-        })
-            .then(async () => {
-            try {
-                await context.codeMode?.onSettled?.({
-                    cellId: cell.cellId,
-                    status: outcome,
-                    ...(permissionStopFromError(cell.error)
-                        ? { permissionStop: permissionStopFromError(cell.error) }
-                        : {})
-                });
-            }
-            catch (error) {
-                cell.error = error;
-                outcome = 'failed';
-            }
-            try {
-                await releaseSession?.();
-            }
-            catch (error) {
-                cell.error = error;
-                outcome = 'failed';
-            }
-            cell.status = outcome;
-            // Terminal capacity follows completion order, not the original start order.
-            this.#cells.delete(cell.cellId);
-            this.#cells.set(cell.cellId, cell);
-            cell.retention = setTimeout(() => this.#cells.delete(cell.cellId), limits.codeCompletedRetentionMs);
-            cell.retention.unref();
-            const completed = [...this.#cells.values()].filter((entry) => entry.sessionId === cell.sessionId && entry.status !== 'running');
-            for (const entry of completed.slice(0, Math.max(0, completed.length - limits.codeMaxCompletedResults))) {
-                clearTimeout(entry.retention);
-                this.#cells.delete(entry.cellId);
-            }
-            notify();
-        });
-        return this.#wait(cell, settings, context.signal, true, context.codeMode?.supportsImages === true, context.waitInterrupt);
-    }
-    async wait(value, context) {
-        const input = options(value, true);
-        context.signal.throwIfAborted();
-        this.#handles.assertType(input.cellId);
-        const cell = this.#cells.get(input.cellId);
-        if (!cell || cell.sessionId !== context.sessionId)
-            throw new MarAgentError('MAR_AGENT_CODE_CELL_NOT_FOUND', 'Code Exec cell is unavailable in this Session.');
-        if (input.action === 'cancel' && cell.status === 'running') {
-            cell.controller.abort(new MarAgentError('MAR_AGENT_CODE_CANCELLED', 'Code Exec cell was terminated.'));
-            await new Promise((resolve, reject) => {
-                const abort = () => reject(context.signal.reason);
-                context.signal.addEventListener('abort', abort, { once: true });
-                void cell.done.then(() => {
-                    context.signal.removeEventListener('abort', abort);
-                    resolve();
-                });
-                if (context.signal.aborted)
-                    abort();
-            });
-        }
-        return this.#wait(cell, input, context.signal, false, context.codeMode?.supportsImages === true, input.action === 'poll' ? context.waitInterrupt : undefined);
-    }
-    async #wait(cell, input, signal, initial, supportsImages, interrupt) {
-        const outcome = input.yieldMs === 0
-            ? undefined
-            : await waitForToolCondition({
-                ready: () => cell.status !== 'running' || cell.yielded,
-                subscribe: (notify) => {
-                    cell.listeners.add(notify);
-                    return () => {
-                        cell.listeners.delete(notify);
-                    };
-                },
-                waitMs: input.yieldMs,
-                signal,
-                interrupt
-            });
-        const wait = waitMetadata(input.yieldMs === 0
-            ? 'snapshot'
-            : cell.status !== 'running'
-                ? 'completion'
-                : cell.yielded
-                    ? 'yield'
-                    : outcome === 'interrupted'
-                        ? 'interrupted'
-                        : 'timeout');
-        signal.throwIfAborted();
-        if (!supportsImages && (cell.images.length || cell.terminal?.images?.length))
-            throw new MarAgentError('MAR_AGENT_INPUT_CAPABILITY_UNSUPPORTED', 'The current model cannot receive this cell image output.');
-        if (cell.terminal) {
-            if (cell.terminal.observations) {
-                const bounded = boundObservations(cell.terminal.observations, limits.codeMaxOutputTokens);
-                const visible = selectObservationImages(bounded.observations, cell.terminal.images ?? []);
-                const original = cell.terminal.data;
-                const data = {
-                    ...original,
-                    output: truncateModelText(original.output ?? '', limits.codeMaxOutputTokens).content,
-                    observations: visible.observations,
-                    cached: true,
-                    ...wait,
-                    truncated: cell.terminal.truncated === true || bounded.truncated
-                };
-                return {
-                    ...cell.terminal,
-                    observations: visible.observations,
-                    images: visible.images,
-                    content: JSON.stringify({
-                        ...data,
-                        output: undefined,
-                        calls: undefined,
-                        observations: visible.observations.map(visibleObservation)
-                    }),
-                    data,
-                    truncated: data.truncated
-                };
-            }
-            const snapshot = cell.terminal.data;
-            const bounded = truncateModelText(snapshot.output, limits.codeMaxOutputTokens);
-            const data = {
-                ...snapshot,
-                output: bounded.content,
-                truncated: cell.terminal.truncated || bounded.truncated,
-                cached: true,
-                ...wait
-            };
-            return {
-                ...cell.terminal,
-                data,
-                content: JSON.stringify(data),
-                truncated: cell.terminal.truncated || bounded.truncated
-            };
-        }
-        const captured = cell.text.drain();
-        const images = cell.images.splice(0);
-        const text = renderCapturedText(captured, images.length);
-        cell.yielded = false;
-        const bounded = truncateModelText(text, limits.codeMaxOutputTokens);
-        const pending = cell.observations.splice(0);
-        if (!pending.length && captured.text)
-            pending.push({
-                type: 'value',
-                id: newObservationId(),
-                format: 'text',
-                value: captured.text,
-                truncated: captured.droppedBytes > 0
-            });
-        const structured = boundObservations(pending, limits.codeMaxOutputTokens);
-        const visible = selectObservationImages(structured.observations, images, cell.imageOffset);
-        const remapped = visible.observations;
-        const visibleImages = visible.images;
-        cell.imageOffset += images.length;
-        cell.truncated ||= captured.droppedBytes > 0 || bounded.truncated || structured.truncated;
-        const error = cell.error === undefined
-            ? undefined
-            : describeMarAgentError(cell.error, 'MAR_AGENT_CODE_FAILED');
-        const data = {
-            cellId: cell.cellId,
-            status: cell.status,
-            ...wait,
-            ...(permissionStopFromError(cell.error)
-                ? { permissionStop: permissionStopFromError(cell.error) }
-                : {}),
-            output: bounded.content,
-            observations: remapped,
-            calls: [...cell.calls.values()],
-            ...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,
-                output: undefined,
-                calls: undefined,
-                observations: remapped.map(visibleObservation)
-            }),
-            calls: [...cell.calls.values()],
-            observations: remapped,
-            data,
-            truncated: cell.truncated || structured.truncated,
-            ...(visibleImages.length ? { images: visibleImages } : {})
-        };
-        if (cell.status !== 'running')
-            cell.terminal = result;
-        // Keep synchronous completion compatible; retained waits always include explicit lifecycle metadata.
-        if (initial && cell.status !== 'running') {
-            if (cell.error !== undefined)
-                throw new CodeCellExecutionError(cell.error, result);
-            return result;
-        }
-        return result;
-    }
-    snapshot(sessionId) {
-        return [...this.#cells.values()]
-            .filter((cell) => cell.sessionId === sessionId)
-            .map(({ cellId, status, executionId }) => ({ cellId, status, executionId }));
-    }
-    async dispose(sessionId) {
-        if (sessionId === undefined)
-            this.#closed = true;
-        else
-            this.#disposing.add(sessionId);
-        const cells = [...this.#cells.values()].filter((cell) => sessionId === undefined || cell.sessionId === sessionId);
-        for (const cell of cells)
-            cell.controller.abort(new MarAgentError('MAR_AGENT_CODE_CANCELLED', 'Code Exec resources were released.'));
-        await Promise.all(cells.map((cell) => cell.done));
-        for (const cell of cells) {
-            clearTimeout(cell.retention);
-            this.#cells.delete(cell.cellId);
-        }
-        if (sessionId !== undefined)
-            this.#disposing.delete(sessionId);
-    }
-}

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

@@ -1,20 +0,0 @@
-import type { ClientToolDefinition } from '../../model/contracts.js';
-import type { MarAgentEvent } from '../../runtime/events.js';
-import type { McpToolCallContext, ToolCall, ToolExecutionResult } from '../contracts.js';
-import type { ToolRuntimeContext } from '../runtime-context.js';
-import type { createSessionToolScheduler } from '../scheduler.js';
-type ToolEvent = Extract<MarAgentEvent, {
-    type: 'tool.started' | 'tool.output' | 'tool.completed' | 'tool.failed';
-}>;
-type Payload<T = ToolEvent> = T extends ToolEvent ? Omit<T, 'eventId' | 'sequence' | 'timestamp' | 'sessionId' | 'executionId' | 'turnId'> : never;
-/** Capture only the cell's immutable dispatch identity, never the model loop or its AbortSignal. */
-export declare function createCodeToolDispatch(input: {
-    context: Omit<ToolRuntimeContext, 'signal' | 'codeMode' | 'expectedMcpTool' | 'searchMcpTools'>;
-    tools: readonly ClientToolDefinition[];
-    expectations: ReadonlyMap<string, McpToolCallContext['expectedTool']>;
-    parentCallId: string;
-    schedule: ReturnType<typeof createSessionToolScheduler>;
-    assertLive: () => void;
-    emit: (event: Payload) => Promise<void>;
-}): (call: ToolCall, signal: AbortSignal) => Promise<ToolExecutionResult>;
-export {};