@myagentroam/agent 0.9.135 → 0.9.137

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

@@ -0,0 +1,454 @@
+// This trusted module runs only in the Host-managed worker, never in the model's JS context.
+/** @returns {Promise<import('./engine.js').CodeModeEngine>} */
+export async function createCodeModeEngine(options) {
+    const { newQuickJSWASMModuleFromVariant } = await import(options.coreModuleUrl);
+    const variant = (await import(options.variantModuleUrl)).default;
+    const quickjs = await newQuickJSWASMModuleFromVariant(variant);
+    let runtime;
+    let context;
+    let disposed = false;
+    return {
+        async execute(input) {
+            if (disposed || runtime)
+                throw diagnostic('MAR_AGENT_CODE_FAILED', 'Engine is not reusable.');
+            runtime = quickjs.newRuntime();
+            runtime.setMemoryLimit(input.limits.memoryBytes);
+            runtime.setMaxStackSize(input.limits.stackBytes);
+            const deadline = Date.now() + input.limits.timeoutMs;
+            runtime.setInterruptHandler(() => input.signal.aborted || Date.now() >= deadline);
+            context = runtime.newContext();
+            const vm = context;
+            let wake;
+            let bridgeFailure;
+            const pending = new Set();
+            const deferreds = new Set();
+            const unconsumedToolCalls = new Set();
+            const sleepTimers = new Set();
+            const state = new Map(input.state.map((entry) => [entry.key, entry.value]));
+            const stateMutations = [];
+            let outputBytes = 0;
+            const notify = () => {
+                wake?.();
+                wake = undefined;
+            };
+            const fail = (handle) => {
+                const error = vm.dump(handle);
+                handle.dispose();
+                if (input.signal.aborted)
+                    throw input.signal.reason;
+                if (Date.now() >= deadline)
+                    throw diagnostic('MAR_AGENT_CODE_TIMEOUT', 'JavaScript execution exceeded its deadline.');
+                const message = String(error?.message ?? error).slice(0, 4096);
+                const code = message.includes('out of memory')
+                    ? 'MAR_AGENT_CODE_MEMORY_LIMIT'
+                    : typeof error?.code === 'string'
+                        ? error.code
+                        : 'MAR_AGENT_CODE_FAILED';
+                throw diagnostic(code, message);
+            };
+            const guestError = (code, message) => {
+                const handle = vm.newError({ name: 'Error', message });
+                const value = vm.newString(code);
+                vm.setProp(handle, 'code', value);
+                value.dispose();
+                return handle;
+            };
+            runtime.setModuleLoader(() => ({
+                error: guestError('MAR_AGENT_CODE_IMPORT_DENIED', 'Module imports are unavailable.')
+            }));
+            const setup = vm.evalCode(`
+        for (const name of ['console', 'process', 'require', 'module', 'Buffer', 'fetch',
+          'WebSocket', 'WebAssembly', 'SharedArrayBuffer', 'Atomics', 'text', 'image'])
+          delete globalThis[name];
+        globalThis.__parseJson = JSON.parse;
+        globalThis.__serialize = value => {
+          return JSON.stringify(value, (_key, item) => {
+            if (['bigint', 'function', 'symbol', 'undefined'].includes(typeof item))
+              throw Object.assign(new TypeError('Only JSON values may cross the tool bridge.'),
+                { code: 'MAR_AGENT_TOOL_INPUT_INVALID' });
+            return item;
+          });
+        };
+        globalThis.__text = value => {
+          if (value === null || ['string', 'number', 'boolean', 'bigint', 'undefined'].includes(typeof value))
+            return String(value);
+          return JSON.stringify(value, (_key, item) => {
+            if (['bigint', 'function', 'symbol', 'undefined'].includes(typeof item))
+              throw Object.assign(new TypeError('Only JSON values may be emitted.'),
+                { code: 'MAR_AGENT_TOOL_INPUT_INVALID' });
+            return item;
+          });
+        };
+        globalThis.__deepFreeze = function deepFreeze(value) {
+          if (value && typeof value === 'object' && !Object.isFrozen(value)) {
+            for (const item of Object.values(value)) deepFreeze(item);
+            Object.freeze(value);
+          }
+          return value;
+        };
+      `);
+            if (setup.error)
+                fail(setup.error);
+            setup.value.dispose();
+            const parseJson = vm.getProp(vm.global, '__parseJson');
+            const serialize = vm.getProp(vm.global, '__serialize');
+            const formatText = vm.getProp(vm.global, '__text');
+            const deepFreeze = vm.getProp(vm.global, '__deepFreeze');
+            const parse = (value) => {
+                const handle = vm.newString(JSON.stringify(value));
+                const parsed = vm.callFunction(parseJson, vm.undefined, handle);
+                handle.dispose();
+                if (parsed.error)
+                    fail(parsed.error);
+                return parsed.value;
+            };
+            const jsonValue = (handle) => {
+                const result = vm.callFunction(serialize, vm.undefined, handle);
+                if (result.error)
+                    return { error: result.error };
+                try {
+                    return { value: JSON.parse(vm.getString(result.value)) };
+                }
+                finally {
+                    result.value.dispose();
+                }
+            };
+            const method = (object, name, callback) => {
+                const handle = vm.newFunction(name, callback);
+                vm.setProp(object, name, handle);
+                handle.dispose();
+            };
+            const key = (handle) => {
+                if (!handle || vm.typeof(handle) !== 'string')
+                    return {
+                        error: guestError('MAR_AGENT_TOOL_INPUT_INVALID', 'State key must be a string.')
+                    };
+                const value = vm.getString(handle);
+                if (!value || Buffer.byteLength(value) > input.limits.stateKeyBytes)
+                    return {
+                        error: guestError('MAR_AGENT_TOOL_INPUT_INVALID', 'State key is invalid or too large.')
+                    };
+                return { value };
+            };
+            const validateState = () => {
+                if (state.size > input.limits.stateEntries)
+                    return guestError('MAR_AGENT_TOOL_OUTPUT_LIMIT', 'Code Mode state has too many entries.');
+                const entries = [...state].map(([entryKey, value]) => ({ key: entryKey, value }));
+                if (Buffer.byteLength(JSON.stringify(entries)) > input.limits.stateTotalBytes)
+                    return guestError('MAR_AGENT_TOOL_OUTPUT_LIMIT', 'Code Mode state is too large.');
+            };
+            const tools = vm.newObject();
+            let toolCallSequence = 0;
+            for (const name of input.tools) {
+                method(tools, name, (args = vm.undefined) => {
+                    const parsed = jsonValue(args);
+                    if (parsed.error)
+                        return parsed;
+                    const operationId = ++toolCallSequence;
+                    unconsumedToolCalls.add(operationId);
+                    const deferred = vm.newPromise();
+                    deferreds.add(deferred);
+                    const job = Promise.resolve()
+                        .then(() => input.onToolCall({ name, arguments: parsed.value }))
+                        .then((output) => {
+                        if (disposed || input.signal.aborted)
+                            return;
+                        const handle = parse(output);
+                        try {
+                            deferred.resolve(handle);
+                        }
+                        finally {
+                            handle.dispose();
+                        }
+                    }, (error) => {
+                        if (disposed || input.signal.aborted)
+                            return;
+                        const handle = vm.newError({
+                            name: 'Error',
+                            message: String(error?.message ?? error).slice(0, 4096)
+                        });
+                        const code = vm.newString(String(error?.code ?? 'MAR_AGENT_HOST_OPERATION_FAILED'));
+                        vm.setProp(handle, 'code', code);
+                        code.dispose();
+                        try {
+                            deferred.reject(handle);
+                        }
+                        finally {
+                            handle.dispose();
+                        }
+                    })
+                        .catch((error) => {
+                        bridgeFailure = diagnostic('MAR_AGENT_CODE_ENGINE_FAILED', String(error?.message ?? error).slice(0, 4096));
+                    })
+                        .finally(() => {
+                        pending.delete(job);
+                        deferreds.delete(deferred);
+                        if (deferred.alive)
+                            deferred.dispose();
+                        notify();
+                    });
+                    pending.add(job);
+                    const operation = vm.newObject();
+                    const id = vm.newNumber(operationId);
+                    vm.setProp(operation, 'id', id);
+                    vm.setProp(operation, 'promise', deferred.handle);
+                    id.dispose();
+                    return operation;
+                });
+            }
+            vm.setProp(vm.global, 'tools', tools);
+            tools.dispose();
+            const consumeToolCall = vm.newFunction('__consumeToolCall', (idHandle) => {
+                if (idHandle && vm.typeof(idHandle) === 'number')
+                    unconsumedToolCalls.delete(vm.getNumber(idHandle));
+                return vm.undefined;
+            });
+            vm.setProp(vm.global, '__consumeToolCall', consumeToolCall);
+            consumeToolCall.dispose();
+            const out = vm.newObject();
+            method(out, 'text', (handle) => {
+                const result = vm.callFunction(formatText, vm.undefined, handle ?? vm.undefined);
+                if (result.error)
+                    return { error: result.error };
+                try {
+                    const value = vm.getString(result.value);
+                    outputBytes += Buffer.byteLength(value) + 1;
+                    if (outputBytes > input.limits.outputBytes)
+                        return {
+                            error: guestError('MAR_AGENT_TOOL_OUTPUT_LIMIT', 'Text output limit exceeded.')
+                        };
+                    input.onText(value);
+                }
+                finally {
+                    result.value.dispose();
+                }
+                return vm.undefined;
+            });
+            method(out, 'image', (handle) => {
+                const parsed = jsonValue(handle ?? vm.undefined);
+                if (parsed.error)
+                    return parsed;
+                input.onImage(parsed.value);
+                return vm.undefined;
+            });
+            vm.setProp(vm.global, 'out', out);
+            out.dispose();
+            const stateObject = vm.newObject();
+            method(stateObject, 'get', (keyHandle) => {
+                const parsed = key(keyHandle);
+                if (parsed.error)
+                    return parsed;
+                return state.has(parsed.value) ? parse(state.get(parsed.value)) : vm.undefined;
+            });
+            method(stateObject, 'has', (keyHandle) => {
+                const parsed = key(keyHandle);
+                if (parsed.error)
+                    return parsed;
+                return state.has(parsed.value) ? vm.true : vm.false;
+            });
+            method(stateObject, 'set', (keyHandle, valueHandle = vm.undefined) => {
+                const parsedKey = key(keyHandle);
+                if (parsedKey.error)
+                    return parsedKey;
+                const parsedValue = jsonValue(valueHandle);
+                if (parsedValue.error)
+                    return parsedValue;
+                if (Buffer.byteLength(JSON.stringify(parsedValue.value)) > input.limits.stateValueBytes)
+                    return { error: guestError('MAR_AGENT_TOOL_INPUT_INVALID', 'State value is too large.') };
+                const previous = state.has(parsedKey.value)
+                    ? { exists: true, value: state.get(parsedKey.value) }
+                    : { exists: false };
+                state.set(parsedKey.value, parsedValue.value);
+                const invalid = validateState();
+                if (invalid) {
+                    if (previous.exists)
+                        state.set(parsedKey.value, previous.value);
+                    else
+                        state.delete(parsedKey.value);
+                    return { error: invalid };
+                }
+                if (stateMutations.length >= input.limits.stateMutations) {
+                    if (previous.exists)
+                        state.set(parsedKey.value, previous.value);
+                    else
+                        state.delete(parsedKey.value);
+                    return {
+                        error: guestError('MAR_AGENT_TOOL_OUTPUT_LIMIT', 'Too many state mutations.')
+                    };
+                }
+                stateMutations.push({ operation: 'set', key: parsedKey.value, value: parsedValue.value });
+                return vm.undefined;
+            });
+            method(stateObject, 'delete', (keyHandle) => {
+                const parsed = key(keyHandle);
+                if (parsed.error)
+                    return parsed;
+                if (!state.has(parsed.value))
+                    return vm.false;
+                if (stateMutations.length >= input.limits.stateMutations)
+                    return {
+                        error: guestError('MAR_AGENT_TOOL_OUTPUT_LIMIT', 'Too many state mutations.')
+                    };
+                state.delete(parsed.value);
+                stateMutations.push({ operation: 'delete', key: parsed.value });
+                return vm.true;
+            });
+            vm.setProp(vm.global, 'state', stateObject);
+            stateObject.dispose();
+            const catalog = vm.newObject();
+            method(catalog, 'tools', () => {
+                const value = parse(input.catalog);
+                const frozen = vm.callFunction(deepFreeze, vm.undefined, value);
+                value.dispose();
+                if (frozen.error)
+                    return { error: frozen.error };
+                return frozen.value;
+            });
+            vm.setProp(vm.global, 'catalog', catalog);
+            catalog.dispose();
+            const cell = vm.newObject();
+            method(cell, 'sleep', (durationHandle) => {
+                if (!durationHandle || vm.typeof(durationHandle) !== 'number')
+                    return {
+                        error: guestError('MAR_AGENT_TOOL_INPUT_INVALID', 'Sleep duration must be an integer.')
+                    };
+                const duration = vm.getNumber(durationHandle);
+                if (!Number.isSafeInteger(duration) || duration < 0 || duration > input.limits.sleepMs)
+                    return {
+                        error: guestError('MAR_AGENT_TOOL_INPUT_INVALID', 'Sleep duration is out of range.')
+                    };
+                const deferred = vm.newPromise();
+                deferreds.add(deferred);
+                let timer;
+                const job = new Promise((resolve) => {
+                    timer = setTimeout(resolve, duration);
+                    sleepTimers.add(timer);
+                })
+                    .then(() => {
+                    sleepTimers.delete(timer);
+                    if (!disposed && !input.signal.aborted)
+                        deferred.resolve(vm.undefined);
+                })
+                    .catch((error) => {
+                    bridgeFailure = diagnostic('MAR_AGENT_CODE_ENGINE_FAILED', String(error?.message ?? error).slice(0, 4096));
+                })
+                    .finally(() => {
+                    pending.delete(job);
+                    deferreds.delete(deferred);
+                    if (deferred.alive)
+                        deferred.dispose();
+                    notify();
+                });
+                pending.add(job);
+                return deferred.handle;
+            });
+            vm.setProp(vm.global, 'cell', cell);
+            cell.dispose();
+            const lock = vm.evalCode(`
+        const rawTools = globalThis.tools;
+        const consumeToolCall = globalThis.__consumeToolCall;
+        const wrappedTools = Object.fromEntries(Object.keys(rawTools).map(name => [name, (...args) => {
+          const operation = rawTools[name](...args);
+          const consume = () => consumeToolCall(operation.id);
+          return Object.freeze({
+            then(onFulfilled, onRejected) {
+              consume();
+              return operation.promise.then(onFulfilled, onRejected);
+            },
+            catch(onRejected) {
+              consume();
+              return operation.promise.catch(onRejected);
+            },
+            finally(onFinally) {
+              consume();
+              return operation.promise.finally(onFinally);
+            }
+          });
+        }]));
+        globalThis.tools = new Proxy(wrappedTools, { get(target, name) {
+          if (name === 'then') return undefined;
+          if (!Object.prototype.hasOwnProperty.call(target, name))
+            return () => { throw Object.assign(new Error('The requested nested tool is unavailable.'),
+              { code: 'MAR_AGENT_TOOL_NOT_AVAILABLE' }); };
+          return target[name];
+        }});
+        for (const name of ['tools', 'out', 'state', 'catalog', 'cell']) {
+          const value = globalThis[name];
+          Object.freeze(value);
+          Object.defineProperty(globalThis, name, {
+            value, writable: false, configurable: false, enumerable: true
+          });
+        }
+        delete globalThis.__parseJson;
+        delete globalThis.__serialize;
+        delete globalThis.__text;
+        delete globalThis.__deepFreeze;
+        delete globalThis.__consumeToolCall;
+      `);
+            if (lock.error)
+                fail(lock.error);
+            lock.value.dispose();
+            input.signal.addEventListener('abort', notify, { once: true });
+            let main;
+            try {
+                const evaluated = vm.evalCode(`(async () => {\n${input.code}\n})()`, 'code-mode.js');
+                if (evaluated.error)
+                    fail(evaluated.error);
+                main = evaluated.value;
+                for (;;) {
+                    input.signal.throwIfAborted();
+                    if (bridgeFailure)
+                        throw bridgeFailure;
+                    const jobs = runtime.executePendingJobs(100);
+                    if (jobs.error)
+                        fail(jobs.error);
+                    jobs.dispose();
+                    const promiseState = vm.getPromiseState(main);
+                    if (promiseState.type === 'rejected')
+                        fail(promiseState.error);
+                    if (promiseState.type === 'fulfilled') {
+                        promiseState.value.dispose();
+                        if (pending.size)
+                            throw diagnostic('MAR_AGENT_CODE_INCOMPLETE', 'Unawaited asynchronous operations remain; completed tool operations are not rolled back.');
+                        if (unconsumedToolCalls.size)
+                            throw diagnostic('MAR_AGENT_CODE_INCOMPLETE', 'Tool calls must be awaited; completed tool operations are not rolled back.');
+                        return { stateMutations };
+                    }
+                    if (runtime.hasPendingJob())
+                        continue;
+                    if (Date.now() >= deadline)
+                        throw diagnostic('MAR_AGENT_CODE_TIMEOUT', 'JavaScript execution exceeded its deadline.');
+                    if (!pending.size)
+                        throw diagnostic('MAR_AGENT_CODE_INCOMPLETE', 'JavaScript returned an unresolved promise without active operations.');
+                    await new Promise((resolve) => {
+                        wake = resolve;
+                    });
+                }
+            }
+            finally {
+                input.signal.removeEventListener('abort', notify);
+                disposed = true;
+                for (const timer of sleepTimers)
+                    clearTimeout(timer);
+                main?.dispose();
+                for (const deferred of deferreds)
+                    if (deferred.alive)
+                        deferred.dispose();
+                parseJson.dispose();
+                serialize.dispose();
+                formatText.dispose();
+                deepFreeze.dispose();
+            }
+        },
+        async dispose() {
+            disposed = true;
+            if (context?.alive)
+                context.dispose();
+            if (runtime?.alive)
+                runtime.dispose();
+        }
+    };
+}
+function diagnostic(code, message) {
+    return Object.assign(new Error(message), { code });
+}

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

@@ -0,0 +1,20 @@
+export interface CodeModeStateEntry {
+    readonly key: string;
+    readonly value: unknown;
+}
+export type CodeModeStateMutation = {
+    readonly operation: 'set';
+    readonly key: string;
+    readonly value: unknown;
+} | {
+    readonly operation: 'delete';
+    readonly key: string;
+};
+type StateRecord = {
+    readonly type: string;
+    readonly payload: unknown;
+};
+export declare function parseCodeModeStateMutations(value: unknown): CodeModeStateMutation[];
+export declare function restoreCodeModeState(records: readonly StateRecord[]): CodeModeStateEntry[];
+export declare function applyCodeModeStateMutations(entries: readonly CodeModeStateEntry[], mutations: readonly CodeModeStateMutation[]): CodeModeStateEntry[];
+export {};

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

@@ -0,0 +1,82 @@
+import { MarAgentError } from '../../error.js';
+import { TOOL_EXECUTION_LIMITS as limits } from '../execution-limits.js';
+export function parseCodeModeStateMutations(value) {
+    if (!Array.isArray(value) || value.length > limits.codeStateMaxMutations)
+        throw invalidState();
+    return value.map((item) => {
+        if (!isObject(item) || !validKey(item.key))
+            throw invalidState();
+        if (item.operation === 'delete' &&
+            Object.keys(item).every((key) => ['operation', 'key'].includes(key)))
+            return { operation: 'delete', key: item.key };
+        if (item.operation === 'set' &&
+            Object.keys(item).every((key) => ['operation', 'key', 'value'].includes(key)) &&
+            Object.prototype.hasOwnProperty.call(item, 'value'))
+            return { operation: 'set', key: item.key, value: cloneStateValue(item.value) };
+        throw invalidState();
+    });
+}
+export function restoreCodeModeState(records) {
+    let state = [];
+    for (const record of records) {
+        if (record.type !== 'code.state.updated')
+            continue;
+        if (!isObject(record.payload) ||
+            !Object.keys(record.payload).every((key) => key === 'mutations'))
+            throw corruptState();
+        let mutations;
+        try {
+            mutations = parseCodeModeStateMutations(record.payload.mutations);
+            state = applyCodeModeStateMutations(state, mutations);
+        }
+        catch (error) {
+            if (error instanceof MarAgentError)
+                throw new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Code Mode state is corrupt.', {
+                    cause: error
+                });
+            throw error;
+        }
+    }
+    return state;
+}
+export function applyCodeModeStateMutations(entries, mutations) {
+    const state = new Map(entries.map((entry) => [entry.key, cloneStateValue(entry.value)]));
+    for (const mutation of mutations) {
+        if (mutation.operation === 'delete')
+            state.delete(mutation.key);
+        else
+            state.set(mutation.key, cloneStateValue(mutation.value));
+    }
+    if (state.size > limits.codeStateMaxEntries)
+        throw new MarAgentError('MAR_AGENT_TOOL_OUTPUT_LIMIT', 'Code Mode state has too many entries.');
+    const result = [...state].map(([key, value]) => ({ key, value }));
+    if (Buffer.byteLength(JSON.stringify(result)) > limits.codeStateMaxTotalBytes)
+        throw new MarAgentError('MAR_AGENT_TOOL_OUTPUT_LIMIT', 'Code Mode state is too large.');
+    return result;
+}
+function validKey(value) {
+    return (typeof value === 'string' &&
+        value.length > 0 &&
+        Buffer.byteLength(value) <= limits.codeStateMaxKeyBytes);
+}
+function cloneStateValue(value) {
+    let serialized;
+    try {
+        serialized = JSON.stringify(value);
+    }
+    catch {
+        throw invalidState();
+    }
+    if (serialized === undefined || Buffer.byteLength(serialized) > limits.codeStateMaxValueBytes)
+        throw invalidState();
+    return JSON.parse(serialized);
+}
+function invalidState() {
+    return new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Code Mode state mutation is invalid.');
+}
+function corruptState() {
+    return new MarAgentError('MAR_AGENT_SESSION_CORRUPT', 'Code Mode state is corrupt.');
+}
+function isObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}

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

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

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

@@ -0,0 +1,65 @@
+import { createInterface } from 'node:readline';
+// The worker evaluates only a trusted engine module. Model source is passed as data to that engine.
+const lines = createInterface({ input: process.stdin, crlfDelay: Infinity });
+const send = (message) => process.stdout.write(JSON.stringify(message) + '\n');
+const pending = new Map();
+const controller = new AbortController();
+let sequence = 0;
+let started = false;
+lines.on('line', async (line) => {
+    let engine;
+    try {
+        const frame = JSON.parse(line);
+        if (started) {
+            const deferred = pending.get(frame.id);
+            if (!deferred)
+                return;
+            pending.delete(frame.id);
+            if (frame.ok)
+                deferred.resolve(frame.output);
+            else
+                deferred.reject(Object.assign(new Error(frame.error.message), { code: frame.error.code }));
+            return;
+        }
+        started = true;
+        const { createCodeModeEngine } = await import(frame.engine.moduleUrl);
+        engine = await createCodeModeEngine(frame.engine.options ?? {});
+        const result = await engine.execute({
+            code: frame.code,
+            tools: frame.tools,
+            catalog: frame.catalog,
+            state: frame.state,
+            limits: frame.limits,
+            signal: controller.signal,
+            onText: (value) => send({ kind: 'text', value }),
+            onImage: (value) => send({ kind: 'image', value }),
+            onToolCall: (call) => new Promise((resolve, reject) => {
+                const id = ++sequence;
+                pending.set(id, { resolve, reject });
+                send({ kind: 'call', id, name: call.name, arguments: call.arguments });
+            })
+        });
+        if (pending.size)
+            throw Object.assign(new Error('Unawaited tool calls remain.'), {
+                code: 'MAR_AGENT_CODE_INCOMPLETE'
+            });
+        await engine.dispose();
+        engine = undefined;
+        await new Promise((resolve) => process.stdout.write(JSON.stringify({ kind: 'done', stateMutations: result.stateMutations }) + '\n', resolve));
+    }
+    catch (error) {
+        controller.abort(error);
+        for (const deferred of pending.values())
+            deferred.reject(error);
+        pending.clear();
+        try {
+            await engine?.dispose();
+        }
+        catch { }
+        await new Promise((resolve) => process.stdout.write(JSON.stringify({
+            kind: 'error',
+            code: typeof error?.code === 'string' ? error.code : 'MAR_AGENT_CODE_ENGINE_FAILED',
+            message: String(error?.message ?? error).slice(0, 4096)
+        }) + '\n', resolve));
+    }
+});

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

@@ -1,16 +1,20 @@
 import { type LocalProcessExecutor } from '../host/local-process-executor.js';
-import type { ClientToolDefinition } from '../model/contracts.js';
+import type { ClientToolDefinition, ModelMessage } from '../model/contracts.js';
 import type { ToolExecutionContext, ToolExecutionResult } from '../sdk/types.js';
 import { WorkspacePathResolver } from './shared/path-resolver.js';
+import type { CodeModeEngineFactory } from './code-mode/engine.js';
 export declare const codeModeToolDefinition: ClientToolDefinition;
-/** Render tool-owned result contracts without changing provider schemas or tool execution. */
-export declare function withCodeModeResultTypes(tools: readonly ClientToolDefinition[]): ClientToolDefinition[];
+/** Deferred definitions travel in search results, not in the stable Code Mode description. */
+export declare function projectCodeModeTools(tools: readonly ClientToolDefinition[], residentTools?: readonly ClientToolDefinition[]): ClientToolDefinition[];
+/** Preserve native search definitions while providing the same discovery evidence to other protocols. */
+export declare function projectCodeModeSearchResult(message: ModelMessage, codeModeEnabled: boolean): ModelMessage;
 export declare class CodeModeTool {
     #private;
     private readonly paths;
     private readonly environment;
     private readonly executor;
-    constructor(paths: WorkspacePathResolver, environment?: NodeJS.ProcessEnv, executor?: LocalProcessExecutor);
+    private readonly engineFactory;
+    constructor(paths: WorkspacePathResolver, environment?: NodeJS.ProcessEnv, executor?: LocalProcessExecutor, engineFactory?: CodeModeEngineFactory);
     execute(value: unknown, context: ToolExecutionContext): Promise<ToolExecutionResult>;
     dispose(sessionId?: string): Promise<void>;
 }