@myagentroam/agent 0.11.32 → 0.11.34

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

@@ -1,77 +0,0 @@
-import { MarAgentError } from '../error.js';
-import { randomUUID } from 'node:crypto';
-import { AGENT_TOOL_HANDLERS, BUILTIN_TOOL_DEFINITIONS } from './registry.js';
-import { normalizeToolInput } from './input.js';
-import { validateToolResult } from './output-projection.js';
-import { withToolResultExtensions } from './result-extensions.js';
-import { viewResourceImage } from './local/view-image.js';
-export async function executeRegisteredTool(name, arguments_, callId, context, caller = 'direct') {
-    return withToolResultExtensions(context.writeToolResultResource, async () => {
-        if (context.invokeTool)
-            return validateToolResult(await context.invokeTool({ name, arguments: arguments_, callId }, context, caller));
-        return validateToolResult(await executeCapturedTool(AGENT_TOOL_HANDLERS.has(name) ? 'builtin' : name.startsWith('mcp__') ? 'mcp' : 'host', { name, arguments: arguments_, callId }, context));
-    });
-}
-/** Invoke an already captured source; names never reselect a different backend. */
-export async function executeCapturedTool(kind, call, context) {
-    const definition = kind === 'builtin'
-        ? BUILTIN_TOOL_DEFINITIONS.find((tool) => tool.name === call.name)
-        : undefined;
-    if (definition)
-        call = { ...call, arguments: normalizeToolInput(call.arguments, definition.inputSchema) };
-    if (kind !== 'mcp' &&
-        call.name === 'view_image' &&
-        call.arguments !== null &&
-        typeof call.arguments === 'object' &&
-        'resourceId' in call.arguments &&
-        call.arguments.resourceId != null) {
-        const store = context.imageStore;
-        if (!store)
-            throw new MarAgentError('MAR_AGENT_TOOL_INPUT_INVALID', 'Session image resources are unavailable.');
-        return viewResourceImage(call.arguments, (resourceId) => store.readResource(context.sessionId, resourceId), context.signal);
-    }
-    if (kind === 'builtin') {
-        const handler = AGENT_TOOL_HANDLERS.get(call.name);
-        if (handler)
-            return handler(call.arguments, context, call.callId ?? randomUUID());
-    }
-    if (kind === 'mcp') {
-        if (!context.host.callMcpTool)
-            throw new MarAgentError('MAR_AGENT_MCP_FAILED', 'MCP execution is unavailable.');
-        return context.host.callMcpTool(call, context.signal, {
-            sessionId: context.sessionId,
-            executionId: context.executionId,
-            mode: context.mode,
-            ...(context.expectedMcpTool ? { expectedTool: context.expectedMcpTool } : {})
-        });
-    }
-    const { name, callId } = call;
-    return context.host.executeTool(call, {
-        mode: context.mode,
-        signal: context.signal,
-        waitInterrupt: context.waitInterrupt,
-        ...((name === 'exec' || name === 'exec_wait') && callId !== undefined
-            ? {
-                onOutput: (output) => context.emit({
-                    type: 'tool.output',
-                    toolName: name,
-                    callId,
-                    ...(context.parentCallId === undefined ? {} : { parentCallId: context.parentCallId }),
-                    output
-                })
-            }
-            : {}),
-        sessionId: context.sessionId,
-        executionId: context.executionId,
-        ...(context.modelId === undefined ? {} : { modelId: context.modelId }),
-        ...(context.recentImages === undefined
-            ? {}
-            : {
-                recentImages: context.recentImages.map((image) => ({
-                    ...image,
-                    data: Buffer.from(image.data)
-                }))
-            }),
-        ...(context.codeMode === undefined ? {} : { codeMode: context.codeMode })
-    });
-}

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

@@ -1,12 +0,0 @@
-import type { ClientToolDefinition } from '../model/contracts.js';
-/** A managed independent callback must not borrow its still-active creator's tool barrier. */
-export declare function withIndependentSessionTools<Value>(run: () => Value): Value;
-/** One barrier domain for foreground tools and all retained cells in a Session. */
-export declare function createSessionToolScheduler(): <T>(definition: ClientToolDefinition | undefined, run: () => Promise<T>) => Promise<T>;
-/** Schedules an incremental stream while preserving the same safe/serial barriers as batches. */
-export declare function createToolCallScheduler<TCall extends {
-    readonly name: string;
-}, TResult>(definitions: readonly ClientToolDefinition[], execute: (call: TCall) => Promise<TResult>): (call: TCall) => Promise<TResult>;
-export declare function scheduleToolCallBatch<TCall extends {
-    readonly name: string;
-}, TResult>(calls: readonly TCall[], definitions: readonly ClientToolDefinition[], execute: (call: TCall) => Promise<TResult>): Promise<TResult[]>;

package/dist/agent-core/tools/shared/path-resolver.js

@@ -1,133 +0,0 @@
-import { lstat, realpath } from 'node:fs/promises';
-import { dirname, isAbsolute, posix, relative, resolve, sep } from 'node:path';
-import { MarAgentError } from '../../error.js';
-export class WorkspacePathResolver {
-    root;
-    #restrictPaths;
-    #roots;
-    #logicalWorkspacePath;
-    constructor(root, options = {}) {
-        this.root = resolve(root);
-        this.#restrictPaths = options.restrictPaths === true;
-        this.#roots = [
-            { physicalPath: this.root, writable: options.rootWritable !== false },
-            ...(options.mounts ?? []).map((mount) => ({
-                logicalPath: logicalRoot(mount.logicalPath),
-                physicalPath: resolve(mount.physicalPath),
-                writable: mount.writable
-            }))
-        ];
-        const logicalPaths = this.#roots
-            .flatMap((candidate) => (candidate.logicalPath === undefined ? [] : [candidate.logicalPath]))
-            .sort();
-        if (new Set(logicalPaths).size !== logicalPaths.length)
-            throw denied('Logical mount paths must be unique.');
-        const logicalMounts = this.#roots.filter((candidate) => candidate.logicalPath !== undefined);
-        for (const [index, mount] of logicalMounts.entries()) {
-            if (logicalMounts
-                .slice(index + 1)
-                .some((candidate) => candidate.physicalPath === mount.physicalPath && candidate.writable !== mount.writable))
-                throw denied('Logical aliases for one physical path must use the same access mode.');
-        }
-        this.#logicalWorkspacePath = logicalMounts.find((candidate) => candidate.physicalPath === this.root)?.logicalPath;
-    }
-    async resolve(input, allowMissing = false, access = 'read') {
-        return (await this.resolveWithDisplay(input, allowMissing, access)).physicalPath;
-    }
-    async resolveWithDisplay(input, allowMissing = false, access = 'read') {
-        const selected = this.#select(input);
-        if (access === 'write' && !selected.root.writable)
-            throw denied('The requested path is read-only.');
-        const target = selected.target;
-        if (this.#restrictPaths && !withinOrEqual(selected.root.physicalPath, target))
-            throw denied('The requested path is outside the allowed roots.');
-        try {
-            const resolved = await realpath(target);
-            await lstat(resolved);
-            if (this.#restrictPaths &&
-                !withinOrEqual(await realpath(selected.root.physicalPath), resolved))
-                throw denied('The requested path escapes the allowed root.');
-        }
-        catch (error) {
-            if (error instanceof MarAgentError)
-                throw error;
-            if (!allowMissing)
-                throw error;
-            const parent = await nearestExistingParent(dirname(target));
-            if (this.#restrictPaths &&
-                !withinOrEqual(await realpath(selected.root.physicalPath), await realpath(parent)))
-                throw denied('The requested path escapes the allowed root.');
-        }
-        return {
-            physicalPath: target,
-            displayPath: this.#display(selected)
-        };
-    }
-    #select(input) {
-        if (!isAbsolute(input)) {
-            if (this.#logicalWorkspacePath !== undefined)
-                return this.#selectAbsolute(posix.join(this.#logicalWorkspacePath, input.replaceAll('\\', '/')));
-            const root = this.#roots[0];
-            return { root, target: resolve(root.physicalPath, input) };
-        }
-        return this.#selectAbsolute(input);
-    }
-    #display(selected) {
-        if (selected.root.logicalPath === undefined)
-            return selected.target;
-        const suffix = relative(selected.root.physicalPath, selected.target).split(sep).filter(Boolean);
-        return suffix.length === 0
-            ? selected.root.logicalPath
-            : posix.join(selected.root.logicalPath, ...suffix);
-    }
-    #selectAbsolute(input) {
-        const normalized = posix.normalize(input.replaceAll('\\', '/'));
-        const mount = this.#roots
-            .filter((candidate) => candidate.logicalPath !== undefined)
-            .sort((left, right) => right.logicalPath.length - left.logicalPath.length)
-            .find((candidate) => normalized === candidate.logicalPath || normalized.startsWith(`${candidate.logicalPath}/`));
-        if (mount !== undefined) {
-            const suffix = normalized.slice(mount.logicalPath.length).replace(/^\/+/u, '');
-            return {
-                root: mount,
-                target: resolve(mount.physicalPath, ...suffix.split('/').filter(Boolean))
-            };
-        }
-        if (this.#restrictPaths)
-            throw denied('The requested path is outside the allowed roots.');
-        return {
-            root: { physicalPath: dirname(resolve(input)), writable: true },
-            target: resolve(input)
-        };
-    }
-}
-function logicalRoot(value) {
-    const normalized = posix.normalize(value.replaceAll('\\', '/'));
-    if (!normalized.startsWith('/') || normalized === '/' || normalized.includes('\0'))
-        throw denied('Logical mount path is invalid.');
-    return normalized.replace(/\/+$/u, '');
-}
-function withinOrEqual(parent, candidate) {
-    const relation = relative(parent, candidate);
-    return relation === '' || (relation !== '..' && !relation.startsWith(`..${sep}`));
-}
-async function nearestExistingParent(path) {
-    let candidate = path;
-    for (;;) {
-        try {
-            await lstat(candidate);
-            return candidate;
-        }
-        catch (error) {
-            if (error.code !== 'ENOENT')
-                throw error;
-            const parent = dirname(candidate);
-            if (parent === candidate)
-                throw error;
-            candidate = parent;
-        }
-    }
-}
-function denied(message) {
-    return new MarAgentError('MAR_AGENT_FILE_ACCESS_DENIED', message);
-}

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

@@ -1,82 +0,0 @@
-import { MarAgentError } from '../error.js';
-export function createToolWaitInterrupt(pending) {
-    const listeners = new Set();
-    return {
-        pending,
-        subscribe(listener) {
-            listeners.add(listener);
-            return () => {
-                listeners.delete(listener);
-            };
-        },
-        notify() {
-            for (const listener of listeners)
-                listener();
-        }
-    };
-}
-export function waitMetadata(waitOutcome) {
-    return { waitOutcome, ...(waitOutcome === 'interrupted' ? { reason: 'steer' } : {}) };
-}
-/** All exits release listeners; a ready result wins over steer and the deadline. */
-export function waitForToolCondition(input) {
-    input.signal?.throwIfAborted();
-    return new Promise((resolve, reject) => {
-        let settled = false;
-        let unsubscribe = () => { };
-        let unsubscribeInterrupt = () => { };
-        let cancelTimer = () => { };
-        const finish = (outcome, error) => {
-            if (settled)
-                return;
-            settled = true;
-            unsubscribe();
-            unsubscribeInterrupt();
-            cancelTimer();
-            input.signal?.removeEventListener('abort', abort);
-            if (error === undefined)
-                resolve(outcome);
-            else
-                reject(error);
-        };
-        const check = () => {
-            if (input.signal?.aborted)
-                abort();
-            else if (input.ready())
-                finish('ready');
-            else if (input.interrupt?.pending())
-                finish('interrupted');
-        };
-        const abort = () => finish('interrupted', input.signal?.reason ??
-            new MarAgentError('MAR_AGENT_EXECUTION_CANCELLED', 'Execution cancelled.'));
-        unsubscribe = input.subscribe(check);
-        unsubscribeInterrupt = input.interrupt?.subscribe(check) ?? (() => { });
-        cancelTimer = waitDeadline(input.waitMs, () => {
-            check();
-            finish('timeout');
-        });
-        input.signal?.addEventListener('abort', abort, { once: true });
-        check();
-    });
-}
-/** Explicit waits retain their deadline without overflowing the platform timer. */
-export function waitDeadline(waitMs, finish) {
-    if (waitMs <= 2_147_483_647) {
-        const timer = setTimeout(finish, waitMs);
-        return () => clearTimeout(timer);
-    }
-    const deadline = performance.now() + waitMs;
-    let timer;
-    const tick = () => {
-        const remaining = deadline - performance.now();
-        if (remaining <= 0)
-            finish();
-        else
-            arm(remaining);
-    };
-    const arm = (remaining) => {
-        timer = setTimeout(tick, Math.min(remaining, 2_147_483_647));
-    };
-    arm(waitMs);
-    return () => clearTimeout(timer);
-}