@myagentroam/agent 0.11.32 → 0.11.34

package/dist/tools/runtime.js

@@ -0,0 +1,77 @@
+import { AgentError } 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 AgentError('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 AgentError('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/tools/scheduler.d.ts

@@ -0,0 +1,12 @@
+import type { ClientToolDefinition } from './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/tools/shared/path-resolver.js

@@ -0,0 +1,133 @@
+import { lstat, realpath } from 'node:fs/promises';
+import { dirname, isAbsolute, posix, relative, resolve, sep } from 'node:path';
+import { AgentError } 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 AgentError)
+                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 AgentError('MAR_AGENT_FILE_ACCESS_DENIED', message);
+}

package/dist/tools/wait.d.ts

@@ -0,0 +1 @@
+export * from '../runtime/wait.js';

package/dist/tools/wait.js

@@ -0,0 +1 @@
+export * from '../runtime/wait.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/agent",
-  "version": "0.11.32",
+  "version": "0.11.34",
   "description": "Embeddable MAR coding agent SDK and CLI.",
   "license": "Apache-2.0",
   "type": "module",
@@ -20,8 +20,20 @@
       "default": "./dist/sandbox/linux/index.js"
     },
     "./host/network": {
-      "types": "./dist/agent-core/host/network.d.ts",
-      "default": "./dist/agent-core/host/network.js"
+      "types": "./dist/host/network.d.ts",
+      "default": "./dist/host/network.js"
+    },
+    "./host": {
+      "types": "./dist/host.d.ts",
+      "default": "./dist/host.js"
+    },
+    "./extensions": {
+      "types": "./dist/extensions.d.ts",
+      "default": "./dist/extensions.js"
+    },
+    "./session-store": {
+      "types": "./dist/session-store.d.ts",
+      "default": "./dist/session-store.js"
     }
   },
   "bin": {

package/dist/agent-core/error.d.ts

@@ -1,15 +0,0 @@
-export declare class MarAgentError extends Error {
-    readonly code: string;
-    readonly publicMessage: string;
-    readonly details: Readonly<Record<string, unknown>> | undefined;
-    readonly retryable: boolean;
-    constructor(code: string, message: string, options?: {
-        details?: Readonly<Record<string, unknown>>;
-        retryable?: boolean;
-        cause?: unknown;
-    });
-}
-export declare function describeMarAgentError(error: unknown, fallbackCode: string, fallbackMessage?: string, includeCauses?: boolean): {
-    code: string;
-    message: string;
-};

package/dist/agent-core/error.js

@@ -1,74 +0,0 @@
-export class MarAgentError extends Error {
-    code;
-    publicMessage;
-    details;
-    retryable;
-    constructor(code, message, options = {}) {
-        super(`${code}: ${message}`, { cause: options.cause });
-        this.name = 'MarAgentError';
-        this.code = code;
-        this.publicMessage = message;
-        this.details = options.details;
-        this.retryable = options.retryable ?? false;
-    }
-}
-const MAX_ERROR_MESSAGE_CHARACTERS = 1_000;
-export function describeMarAgentError(error, fallbackCode, fallbackMessage = 'MAR Agent operation failed.', includeCauses = true) {
-    const code = diagnosticCode(error) ?? fallbackCode;
-    const messages = [];
-    const seen = new Set();
-    let current = error;
-    while (current !== undefined && current !== null && !seen.has(current) && messages.length < 4) {
-        seen.add(current);
-        const currentCode = diagnosticCode(current);
-        const message = diagnosticMessage(current, currentCode);
-        const summary = message && currentCode !== undefined && currentCode !== code
-            ? `${currentCode}: ${message}`
-            : message;
-        if (summary && !messages.includes(summary))
-            messages.push(summary);
-        if (!includeCauses)
-            break;
-        current = diagnosticCause(current);
-    }
-    return {
-        code,
-        message: truncateErrorMessage(messages.join(' Caused by: ') || fallbackMessage)
-    };
-}
-function diagnosticCode(value) {
-    if (value instanceof MarAgentError)
-        return value.code;
-    if (value === null || typeof value !== 'object' || !('code' in value))
-        return undefined;
-    const code = value.code;
-    return typeof code === 'string' && code.trim().length > 0 ? code.trim().slice(0, 80) : undefined;
-}
-function diagnosticMessage(value, code) {
-    const message = value instanceof MarAgentError
-        ? value.publicMessage
-        : value instanceof Error
-            ? value.message
-            : value !== null &&
-                typeof value === 'object' &&
-                'message' in value &&
-                typeof value.message === 'string'
-                ? value.message
-                : typeof value === 'string'
-                    ? value
-                    : undefined;
-    const normalized = message?.trim();
-    if (!normalized)
-        return undefined;
-    return code !== undefined && normalized.startsWith(`${code}: `)
-        ? normalized.slice(code.length + 2)
-        : normalized;
-}
-function diagnosticCause(value) {
-    if (value === null || typeof value !== 'object' || !('cause' in value))
-        return undefined;
-    return value.cause;
-}
-function truncateErrorMessage(value) {
-    return [...value].slice(0, MAX_ERROR_MESSAGE_CHARACTERS).join('');
-}

package/dist/agent-core/extensions/agents.d.ts

@@ -1,79 +0,0 @@
-import type { MarAgentReasoningEffort } from '../model/configuration.js';
-import type { SubagentController, SubagentTaskSnapshot, SubagentManyOutput, SubagentHandledResult } from '../subagent/contracts.js';
-import type { CoreOperationContext } from './operation.js';
-import type { ExtensionResourceScope } from './resources.js';
-import type { ExtensionHooks } from './hooks.js';
-import type { CoreDomainOperations, CoreDomainFacts, CoreCapabilitySnapshot } from './contracts.js';
-export type CoreAgentSnapshot = Readonly<SubagentTaskSnapshot>;
-export type CoreAgentManySnapshot = Readonly<SubagentManyOutput>;
-export type CoreAgentWaitResult = CoreAgentSnapshot | CoreAgentManySnapshot;
-export type CoreAgentHandledResult = SubagentHandledResult;
-export type CoreAgentSpawnResult = CoreAgentSnapshot | CoreAgentHandledResult;
-export declare function isHandledAgentResult(value: CoreAgentSpawnResult | CoreAgentManySnapshot): value is CoreAgentHandledResult;
-export interface CoreAgentSpawnInput {
-    readonly turnSignal?: AbortSignal;
-    readonly waitFor?: 'start' | 'completion';
-    readonly background?: boolean;
-    readonly prompt: string;
-    readonly description?: string;
-    readonly modelId?: string;
-    readonly reasoningEffort?: MarAgentReasoningEffort;
-    readonly role?: 'general-purpose' | 'explore';
-    readonly signal?: AbortSignal;
-}
-export interface CoreAgentTarget {
-    readonly agentId: string;
-    readonly signal?: AbortSignal;
-}
-export interface CoreAgentWaitInput {
-    readonly untilSettled?: true;
-    readonly agentId?: string;
-    readonly agentIds?: readonly string[];
-    readonly mode?: 'any' | 'all';
-    readonly signal?: AbortSignal;
-    readonly waitMs?: number;
-    readonly waitFor?: 'completion' | 'message';
-}
-export interface CoreAgentMessageInput extends CoreAgentTarget {
-    readonly message: string;
-    readonly delivery?: 'append' | 'replace';
-}
-export interface CoreAgentsBackend {
-    own(ownerInstanceId: string): () => Promise<void>;
-    spawn(input: CoreAgentSpawnInput, call: CoreOperationContext): Promise<CoreAgentSnapshot>;
-    list(call: CoreOperationContext): Promise<readonly CoreAgentSnapshot[]>;
-    inspect(input: CoreAgentTarget, call: CoreOperationContext): Promise<CoreAgentSnapshot>;
-    wait(input: CoreAgentWaitInput, call: CoreOperationContext): Promise<CoreAgentWaitResult>;
-    message(input: CoreAgentMessageInput, call: CoreOperationContext): Promise<CoreAgentSnapshot>;
-    cancel(input: CoreAgentTarget, call: CoreOperationContext): Promise<CoreAgentSnapshot>;
-}
-export interface CoreAgentsApi {
-    spawn(input: CoreAgentSpawnInput): Promise<CoreAgentSpawnResult>;
-    list(input?: {
-        readonly signal?: AbortSignal;
-    }): Promise<readonly CoreAgentSnapshot[]>;
-    inspect(input: CoreAgentTarget): Promise<CoreAgentSnapshot>;
-    wait(input: CoreAgentWaitInput & {
-        readonly agentIds: readonly string[];
-    }): Promise<CoreAgentManySnapshot>;
-    wait(input: CoreAgentWaitInput & {
-        readonly agentIds?: undefined;
-    }): Promise<CoreAgentSnapshot>;
-    wait(input: CoreAgentWaitInput): Promise<CoreAgentWaitResult>;
-    message(input: CoreAgentMessageInput): Promise<CoreAgentSnapshot>;
-    cancel(input: CoreAgentTarget): Promise<CoreAgentSnapshot>;
-}
-export interface CoreAgentCompletion {
-    readonly operation: 'spawn' | 'wait' | 'message' | 'cancel';
-    readonly agentId: string;
-    readonly status: SubagentTaskSnapshot['status'];
-    readonly deliveryStatus?: SubagentTaskSnapshot['deliveryStatus'];
-}
-type AgentOperation = 'agent.spawn' | 'agent.wait' | 'agent.message' | 'agent.cancel';
-export type CoreAgentAction = <Key extends AgentOperation>(key: Key, input: CoreDomainOperations[Key]['input'], leaf: (input: CoreDomainOperations[Key]['input'], call: CoreOperationContext) => Promise<CoreDomainOperations[Key]['output']>) => Promise<CoreDomainOperations[Key]['output']>;
-/** All callers share one interception and authoritative leaf-completion boundary. */
-export declare function invokeCoreAgentOperation<Key extends AgentOperation>(hooks: ExtensionHooks<CoreDomainOperations, CoreDomainFacts>, key: Key, input: CoreDomainOperations[Key]['input'], call: CoreOperationContext, leaf: (input: CoreDomainOperations[Key]['input'], call: CoreOperationContext) => Promise<CoreDomainOperations[Key]['output']>): Promise<CoreDomainOperations[Key]['output']>;
-export declare function bindAgentController(controller: SubagentController, action: CoreAgentAction): SubagentController;
-export declare function agentCapabilities(capabilities: CoreCapabilitySnapshot, available: boolean): CoreCapabilitySnapshot;
-export declare function bindCoreAgents(backend: CoreAgentsBackend, scope: ExtensionResourceScope, run: <Value>(operation: (call: CoreOperationContext) => Promise<Value>, signal?: AbortSignal) => Promise<Value>, hooks: ExtensionHooks<CoreDomainOperations, CoreDomainFacts>): CoreAgentsApi;
-export {};

package/dist/agent-core/extensions/agents.js

@@ -1,186 +0,0 @@
-import { MarAgentError } from '../error.js';
-import { parseAgentWaitTargets } from '../subagent/wait.js';
-export function isHandledAgentResult(value) {
-    return 'outcome' in value && value.outcome === 'handled' && !Object.hasOwn(value, 'agentId');
-}
-/** All callers share one interception and authoritative leaf-completion boundary. */
-export function invokeCoreAgentOperation(hooks, key, input, call, leaf) {
-    return hooks.invoke(key, input, call, async (input, effective) => {
-        const result = structuredClone(await leaf(input, effective));
-        if (isHandledAgentResult(result))
-            return result;
-        const agents = Array.isArray(result.agents)
-            ? result.agents
-            : [result];
-        for (const agent of agents)
-            await hooks.emit('agent.completed', {
-                operation: key.slice('agent.'.length),
-                agentId: agent.agentId,
-                status: agent.status,
-                ...(agent.deliveryStatus === undefined ? {} : { deliveryStatus: agent.deliveryStatus })
-            }, effective);
-        return result;
-    });
-}
-function resolveAgentSpawn(input) {
-    if (!input ||
-        typeof input !== 'object' ||
-        Array.isArray(input) ||
-        typeof input.prompt !== 'string' ||
-        !input.prompt.trim() ||
-        (input.turnSignal !== undefined && !(input.turnSignal instanceof AbortSignal)) ||
-        (input.description !== undefined &&
-            (typeof input.description !== 'string' || !input.description.trim())) ||
-        (input.modelId !== undefined && (typeof input.modelId !== 'string' || !input.modelId)) ||
-        (input.role !== undefined && input.role !== 'general-purpose' && input.role !== 'explore') ||
-        (input.background !== undefined && typeof input.background !== 'boolean') ||
-        (input.waitFor !== undefined && input.waitFor !== 'start' && input.waitFor !== 'completion') ||
-        (input.reasoningEffort !== undefined &&
-            !['low', 'medium', 'high', 'xhigh', 'max', 'ultra'].includes(input.reasoningEffort)))
-        throw invalid('Agent spawn input is invalid.');
-    return {
-        prompt: input.prompt,
-        ...(input.turnSignal === undefined ? {} : { turnSignal: input.turnSignal }),
-        ...(input.waitFor === undefined ? {} : { waitFor: input.waitFor }),
-        ...(input.background === undefined ? {} : { background: input.background }),
-        description: input.description ?? 'Extension agent',
-        ...(input.signal === undefined ? {} : { signal: input.signal }),
-        ...(input.modelId === undefined ? {} : { modelId: input.modelId }),
-        ...(input.reasoningEffort === undefined ? {} : { reasoningEffort: input.reasoningEffort }),
-        role: input.role ?? 'general-purpose'
-    };
-}
-export function bindAgentController(controller, action) {
-    const wait = (input, waitInterrupt) => action('agent.wait', input, (target, call) => {
-        const selection = parseAgentWaitTargets(target);
-        return selection.agentIds !== undefined
-            ? controller.outputMany(selection.agentIds, {
-                ...target,
-                waitInterrupt,
-                mode: selection.mode ?? 'any',
-                signal: call.signal
-            })
-            : target.agentId === undefined
-                ? controller.outputAny({ ...target, waitInterrupt, signal: call.signal })
-                : controller.output(target.agentId, { ...target, waitInterrupt, signal: call.signal });
-    });
-    return {
-        run: (input, options) => {
-            return action('agent.spawn', {
-                ...(options?.waitFor === undefined ? {} : { waitFor: options.waitFor }),
-                prompt: input.prompt,
-                description: input.description,
-                role: input.role,
-                background: input.background ?? false,
-                ...(input.modelId === undefined ? {} : { modelId: input.modelId }),
-                ...(input.reasoningEffort === undefined ? {} : { reasoningEffort: input.reasoningEffort })
-            }, async (target, call) => {
-                const task = resolveAgentSpawn(target);
-                return controller.run({
-                    prompt: task.prompt,
-                    description: task.description ?? input.description,
-                    role: task.role ?? input.role,
-                    background: task.background ?? false,
-                    ...(input.parentSubagentId === undefined
-                        ? {}
-                        : { parentSubagentId: input.parentSubagentId }),
-                    ...(task.modelId === undefined ? {} : { modelId: task.modelId }),
-                    ...(task.reasoningEffort === undefined
-                        ? {}
-                        : { reasoningEffort: task.reasoningEffort })
-                }, {
-                    ...options,
-                    ...(task.turnSignal === undefined ? {} : { turnSignal: task.turnSignal }),
-                    ...(task.waitFor === undefined ? {} : { waitFor: task.waitFor }),
-                    signal: call.signal
-                });
-            });
-        },
-        output: (id, options) => {
-            const { waitInterrupt, ...input } = options ?? {};
-            return wait({ ...input, agentId: id }, waitInterrupt);
-        },
-        outputAny: (options) => {
-            const { waitInterrupt, ...input } = options ?? {};
-            return wait(input, waitInterrupt);
-        },
-        outputMany: (ids, options) => {
-            const { waitInterrupt, ...input } = options ?? {};
-            return wait({ ...input, agentIds: ids }, waitInterrupt);
-        },
-        message: (id, message, options) => action('agent.message', { ...options, agentId: id, message }, (target, call) => controller.message(target.agentId, target.message, {
-            ...(target.delivery === undefined ? {} : { delivery: target.delivery }),
-            signal: call.signal
-        })),
-        cancel: (id) => action('agent.cancel', { agentId: id }, (target) => controller.cancel(target.agentId)),
-        listSessionResources: () => controller.listSessionResources(),
-        dispose: () => controller.dispose()
-    };
-}
-export function agentCapabilities(capabilities, available) {
-    const values = Object.freeze(capabilities.list().filter((id) => id !== 'agents' || available));
-    return Object.freeze({ has: (id) => values.includes(id), list: () => values });
-}
-export function bindCoreAgents(backend, scope, run, hooks) {
-    scope.effect(() => backend.own(scope.instanceId));
-    const invoke = (key, input) => run((call) => invokeCoreAgentOperation(hooks, key, input, call, async (effectiveInput, effective) => {
-        let result;
-        switch (key) {
-            case 'agent.spawn':
-                result = await backend.spawn({
-                    ...resolveAgentSpawn(effectiveInput),
-                    ...(effectiveInput.turnSignal === undefined
-                        ? {}
-                        : {
-                            turnSignal: AbortSignal.any([
-                                scope.signal,
-                                effectiveInput.turnSignal
-                            ])
-                        })
-                }, effective);
-                break;
-            case 'agent.wait':
-                result = await backend.wait(effectiveInput, effective);
-                break;
-            case 'agent.message':
-                result = await backend.message(effectiveInput, effective);
-                break;
-            case 'agent.cancel':
-                result = await backend.cancel(effectiveInput, effective);
-                break;
-        }
-        return result;
-    }), input.signal);
-    const target = (input) => {
-        if (!input ||
-            typeof input !== 'object' ||
-            Array.isArray(input) ||
-            typeof input.agentId !== 'string' ||
-            !input.agentId)
-            throw invalid('Agent target is invalid.');
-        return { ...input };
-    };
-    return {
-        spawn: (input) => invoke('agent.spawn', { ...input }),
-        list: async (input = {}) => {
-            if (!input || typeof input !== 'object' || Array.isArray(input))
-                throw invalid('Agent list input is invalid.');
-            return run(async (call) => structuredClone(await backend.list(call)), input.signal);
-        },
-        inspect: async (input) => {
-            const copied = target(input);
-            return run(async (call) => structuredClone(await backend.inspect(copied, call)), copied.signal);
-        },
-        wait: (async (input) => {
-            if (!input || typeof input !== 'object' || Array.isArray(input))
-                throw invalid('Agent wait input is invalid.');
-            const selection = parseAgentWaitTargets(input);
-            return invoke('agent.wait', input.agentId === undefined ? { ...input, ...selection } : target(input));
-        }),
-        message: async (input) => invoke('agent.message', target(input)),
-        cancel: async (input) => invoke('agent.cancel', target(input))
-    };
-}
-function invalid(message) {
-    return new MarAgentError('MAR_AGENT_EXTENSION_AGENT_INPUT_INVALID', message);
-}

package/dist/agent-core/extensions/compaction.d.ts

@@ -1,48 +0,0 @@
-import type { ModelMessage, ModelUsage } from '../model/contracts.js';
-export interface CoreCompactDiagnostic {
-    readonly modelId: string;
-    readonly providerModelId?: string;
-    readonly reasoningEffort: string;
-    readonly state: 'STARTED' | 'SUCCEEDED' | 'DECLINED' | 'FAILED';
-    readonly inputTokensEstimateBefore: number;
-    readonly inputTokensEstimateAfter: number;
-    readonly modelRequests: number;
-    readonly elapsedMs: number;
-    readonly reason?: 'INPUT_BUDGET_EXHAUSTED' | 'MODEL_INCOMPLETE' | 'MODEL_FAILED';
-    readonly errorCode?: string;
-    readonly trigger?: 'manual' | 'automatic';
-    readonly causeCode?: string;
-    readonly errorReason?: string;
-    readonly httpStatus?: number;
-    readonly retryable?: boolean;
-    readonly transport?: 'HTTP' | 'WEBSOCKET';
-}
-export interface CoreCompactMessage {
-    readonly role: 'user' | 'assistant' | 'tool' | 'tool_call';
-    readonly content: string;
-    readonly callId?: string;
-    readonly name?: string;
-    readonly arguments?: unknown;
-}
-export interface CoreCompactContext {
-    readonly reportModelUsage?: ((usage: import('../model/usage-observer.js').ModelRequestUsage) => Promise<void> | void) | undefined;
-    readonly operationId: string;
-    readonly reason: 'manual' | 'automatic';
-    readonly messages: readonly CoreCompactMessage[];
-    readonly focus?: string;
-    readonly summaryTokenBudget: number;
-    /** Return the Core's default structured handoff contract, independent of model configuration. */
-    readonly getPrompt: () => string;
-    /** Private, bounded telemetry only; reporting never changes the generation result. */
-    readonly reportDiagnostic?: (diagnostic: CoreCompactDiagnostic) => Promise<void>;
-}
-export interface CoreCompactResult {
-    readonly summary: string;
-    readonly usage?: Readonly<ModelUsage>;
-}
-/** Copy only neutral evidence; a hook never receives provider payloads or history ownership. */
-export declare function compactExtensionMessages(messages: readonly ModelMessage[]): readonly CoreCompactMessage[];
-/** Whitelist scalar facts; never copy arbitrary plugin payloads into the session log. */
-export declare function compactExtensionDiagnostic(value: unknown): CoreCompactDiagnostic | undefined;
-/** Invalid plugin results decline generation rather than altering the checkpoint contract. */
-export declare function compactExtensionResult(value: unknown, budget: number): CoreCompactResult | undefined;