@myagentroam/agent 0.11.32 → 0.11.34

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

@@ -1,265 +0,0 @@
-import type { CoreModelRequest } from './model-request.js';
-import type { CoreCompactContext, CoreCompactResult } from './compaction.js';
-import type { CorePromptInput, CorePromptResult } from './prompt-input.js';
-import type { CoreModelEvent } from './model-stream.js';
-import type { CorePromptComposition, CorePromptSectionInput } from './prompt-composition.js';
-import type { CoreModelsApi } from './models.js';
-import type { CoreAgentsApi, CoreAgentSpawnInput, CoreAgentWaitInput, CoreAgentWaitResult, CoreAgentMessageInput, CoreAgentTarget, CoreAgentSnapshot, CoreAgentSpawnResult, CoreAgentCompletion } from './agents.js';
-import type { CoreDataApi } from './data.js';
-import type { CoreMcpApi, CoreMcpConnectInput, CoreMcpConnectionInput, CoreMcpConnectionRef, CoreMcpCatalog, CoreMcpCompletion } from './mcp.js';
-import type { CoreFilesApi, CoreFileOperations, CoreFileCompletion } from './files.js';
-import type { CoreEnvironmentApi, CoreEnvironmentKey, CoreEnvironmentSet, CoreEnvironmentChange, CoreEnvironmentCompletion } from './environment.js';
-import type { CoreSettingsApi, CoreSettingsReadInput, CoreSettingsUpdate, CoreSettingsDescription, CoreSettingsSnapshot, CoreSettingsResult, CoreSettingsCompletion } from './settings.js';
-import type { CoreProcessesApi, CoreProcessInput, CoreProcessRunInput, CoreProcessHandle, CoreProcessResult, CoreProcessCompletion } from './processes.js';
-import type { CoreNetworkApi, CoreHttpRequest, CoreHttpResponse, CoreHttpCompletion } from './network.js';
-import type { CoreSessionApi, CoreAppendInput, CoreCompactInput, CoreSessionActionResult } from './session-input.js';
-import type { ToolCall, ToolExecutionResult } from '../tools/contracts.js';
-import type { CoreHookOptions, CoreInterceptor } from './hooks.js';
-import type { CoreOperationContext } from './operation.js';
-import type { CoreDisposer, CoreResourceRegistration, CoreResourceScope } from './resources.js';
-import type { CoreServiceRegistry } from './services.js';
-import type { CoreToolRef, CoreToolInvocation, CoreToolCheck, CoreToolSpec, CoreToolCompletion, CoreToolFailure } from './tools.js';
-export interface CoreDomainOperations extends CoreFileOperations {
-    'mcp.connect': {
-        input: CoreMcpConnectInput;
-        output: CoreMcpConnectionRef;
-    };
-    'mcp.catalog': {
-        input: CoreMcpConnectionInput;
-        output: CoreMcpCatalog;
-    };
-    'mcp.disconnect': {
-        input: CoreMcpConnectionInput;
-        output: void;
-    };
-    'agent.spawn': {
-        input: CoreAgentSpawnInput;
-        output: CoreAgentSpawnResult;
-    };
-    'agent.wait': {
-        input: CoreAgentWaitInput;
-        output: CoreAgentWaitResult;
-    };
-    'agent.message': {
-        input: CoreAgentMessageInput;
-        output: CoreAgentSnapshot;
-    };
-    'agent.cancel': {
-        input: CoreAgentTarget;
-        output: CoreAgentSnapshot;
-    };
-    'environment.get': {
-        input: CoreEnvironmentKey;
-        output: string | undefined;
-    };
-    'environment.set': {
-        input: CoreEnvironmentSet;
-        output: CoreEnvironmentChange;
-    };
-    'settings.describe': {
-        input: CoreSettingsReadInput;
-        output: CoreSettingsDescription;
-    };
-    'settings.read': {
-        input: CoreSettingsReadInput;
-        output: CoreSettingsSnapshot;
-    };
-    'settings.update': {
-        input: CoreSettingsUpdate;
-        output: CoreSettingsResult;
-    };
-    'process.spawn': {
-        input: CoreProcessInput;
-        output: CoreProcessHandle;
-    };
-    'process.run': {
-        input: CoreProcessRunInput;
-        output: CoreProcessResult;
-    };
-    'network.fetch': {
-        input: CoreHttpRequest;
-        output: CoreHttpResponse;
-    };
-    'prompt.compose': {
-        input: string;
-        output: string;
-    };
-    'prompt.submit': {
-        input: CorePromptInput;
-        output: CorePromptResult;
-    };
-    'prompt.sections': {
-        input: CorePromptComposition;
-        output: CorePromptComposition;
-    };
-    'prompt.section': {
-        input: CorePromptSectionInput;
-        output: string | null;
-    };
-    'model.request': {
-        input: CoreModelRequest;
-        output: CoreModelRequest;
-    };
-    'model.event': {
-        input: CoreModelEvent;
-        output: CoreModelEvent | undefined;
-    };
-    'tool.invoke': {
-        input: ToolCall;
-        output: ToolExecutionResult;
-    };
-    'session.append': {
-        input: CoreAppendInput;
-        output: CoreSessionActionResult;
-    };
-    'session.compact': {
-        input: CoreCompactInput;
-        output: CoreSessionActionResult;
-    };
-    'compact.generate': {
-        input: CoreCompactContext;
-        output: CoreCompactResult | undefined;
-    };
-}
-export interface CoreDomainFacts {
-    'session.ending': {
-        readonly sessionId: string;
-        readonly reason: 'clear' | 'other';
-        readonly resumable: boolean;
-    };
-    'session.ready': {
-        readonly sessionId: string;
-    };
-    'model.event': CoreModelEvent;
-    'mcp.completed': CoreMcpCompletion;
-    'agent.completed': CoreAgentCompletion;
-    'environment.completed': CoreEnvironmentCompletion;
-    'settings.completed': CoreSettingsCompletion;
-    'process.completed': CoreProcessCompletion;
-    'network.completed': CoreHttpCompletion;
-    'files.completed': CoreFileCompletion;
-    'tool.completed': CoreToolCompletion;
-    'tool.failed': CoreToolFailure;
-    'tool.attempt.completed': CoreToolCompletion;
-    'tool.attempt.failed': CoreToolFailure;
-}
-export interface CoreHookRegistrar {
-    intercept<Key extends keyof CoreDomainOperations>(key: Key, handler: CoreInterceptor<CoreDomainOperations[Key]['input'], CoreDomainOperations[Key]['output']>, options?: CoreHookOptions): CoreResourceRegistration;
-    observe<Key extends keyof CoreDomainFacts>(key: Key, handler: (fact: CoreDomainFacts[Key], call: CoreOperationContext) => void | Promise<void>, options?: CoreHookOptions): CoreResourceRegistration;
-}
-export interface CoreCapabilitySnapshot {
-    has(id: string): boolean;
-    list(): readonly string[];
-}
-export interface CoreCommandSpec {
-    readonly name: string;
-    readonly description?: string;
-    readonly override?: 'replace';
-    handler(args: unknown, call: CoreOperationContext): unknown | Promise<unknown>;
-}
-export interface CorePromptSection {
-    readonly id: string;
-    readonly text: string;
-}
-export interface CoreAgentExtensionContext {
-    readonly data?: Pick<CoreDataApi, 'store'>;
-    readonly resources: CoreResourceScope;
-    readonly services: CoreServiceRegistry;
-    readonly capabilities: CoreCapabilitySnapshot;
-    readonly bindings: Readonly<Record<string, unknown>>;
-    readonly observability: {
-        log(message: string): void;
-    };
-}
-export interface CoreSessionExtensionContext extends CoreAgentExtensionContext {
-    readonly mcp?: CoreMcpApi;
-    readonly agents?: CoreAgentsApi;
-    readonly environment?: CoreEnvironmentApi;
-    readonly settings?: CoreSettingsApi;
-    readonly processes?: CoreProcessesApi;
-    readonly network?: CoreNetworkApi;
-    readonly files?: CoreFilesApi;
-    readonly sessionId: string;
-    readonly models?: CoreModelsApi;
-    readonly data: CoreDataApi;
-    readonly session?: CoreSessionApi;
-    readonly hooks: CoreHookRegistrar;
-    readonly tools: {
-        register(spec: CoreToolSpec): CoreResourceRegistration;
-        catalog(): readonly CoreToolRef[];
-        check(call: CoreToolInvocation): Promise<CoreToolCheck>;
-        invoke(call: CoreToolInvocation): Promise<ToolExecutionResult>;
-    };
-    readonly commands: {
-        register(spec: CoreCommandSpec): CoreResourceRegistration;
-        list(): readonly Pick<CoreCommandSpec, 'name' | 'description'>[];
-        run(input: {
-            readonly name: string;
-            readonly args?: unknown;
-        }): Promise<unknown>;
-    };
-    readonly prompts: {
-        register(section: CorePromptSection): CoreResourceRegistration;
-        sections(): readonly CorePromptSection[];
-        compose(system: string): Promise<string>;
-        composeSections(input: CorePromptComposition): Promise<CorePromptComposition>;
-        composeDefault(facts?: import('./prompt-composition.js').CorePromptFacts): Promise<CorePromptComposition>;
-    };
-    readonly clock: {
-        now(): number;
-        sleep(input: {
-            readonly durationMs: number;
-            readonly signal?: AbortSignal;
-        }): Promise<void>;
-        after(durationMs: number, callback: (call: CoreOperationContext) => void | Promise<void>): CoreResourceRegistration;
-        every(durationMs: number, callback: (call: CoreOperationContext) => void | Promise<void>): CoreResourceRegistration;
-    };
-}
-export interface CoreServiceDeclaration {
-    readonly key: {
-        readonly id: string;
-        readonly scope: 'agent' | 'session';
-    };
-    readonly intent?: 'provide' | 'replace' | 'wrap';
-}
-export interface CoreServiceDependency {
-    readonly key: {
-        readonly id: string;
-        readonly scope: 'agent' | 'session';
-    };
-    readonly optional?: boolean;
-}
-export interface CoreRuntimeExtension {
-    readonly dataDirectory?: string;
-    readonly id: string;
-    readonly apiVersion: '1.0';
-    readonly bindings?: Readonly<Record<string, unknown>>;
-    readonly requires?: readonly {
-        readonly id: string;
-    }[];
-    readonly optional?: readonly {
-        readonly id: string;
-    }[];
-    readonly provides?: readonly CoreServiceDeclaration[];
-    readonly serviceDependencies?: readonly CoreServiceDependency[];
-    readonly failurePolicy?: 'disable-extension' | 'fail-composition';
-    setup?(context: CoreAgentExtensionContext): void | CoreDisposer | Promise<void | CoreDisposer>;
-    attachSession?(context: CoreSessionExtensionContext): void | CoreDisposer | Promise<void | CoreDisposer>;
-}
-export interface CoreExtensionSnapshot {
-    readonly revision: string;
-    readonly extensions: readonly CoreRuntimeExtension[];
-}
-export interface CoreExtensionSource {
-    resolve(input: {
-        readonly signal: AbortSignal;
-    }): Promise<CoreExtensionSnapshot>;
-}
-export interface CoreExtensionDiagnostic {
-    readonly code: string;
-    readonly extensionId?: string;
-    readonly sessionId?: string;
-    readonly revision?: string;
-    readonly operationId?: string;
-    readonly message?: string;
-}

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

@@ -1,84 +0,0 @@
-import type { CoreCallbackRunner, CoreOperationContext } from './operation.js';
-import type { CoreResourceRegistration } from './resources.js';
-import { ExtensionResourceScope } from './resources.js';
-export type CoreJsonValue = null | boolean | number | string | readonly CoreJsonValue[] | {
-    readonly [key: string]: CoreJsonValue;
-};
-export interface CoreCheckpoint {
-    readonly revision: number;
-    readonly value?: CoreJsonValue;
-}
-export interface CoreCheckpointApi {
-    get(input: {
-        readonly key: string;
-    }): Promise<CoreCheckpoint>;
-    set(input: {
-        readonly key: string;
-        readonly value: CoreJsonValue;
-        readonly expectedRevision?: number;
-    }): Promise<CoreCheckpoint>;
-    delete(input: {
-        readonly key: string;
-        readonly expectedRevision?: number;
-    }): Promise<CoreCheckpoint>;
-}
-export interface CoreCheckpointBackend {
-    read(extensionId: string, key: string, call: CoreOperationContext): Promise<CoreCheckpoint>;
-    write(extensionId: string, key: string, value: CoreJsonValue | undefined, expectedRevision: number | undefined, call: CoreOperationContext): Promise<CoreCheckpoint>;
-}
-export interface CoreStateChange {
-    readonly key: string;
-    readonly revision: number;
-    readonly value?: CoreJsonValue;
-}
-export interface CoreStateApi {
-    read(key: string): Promise<CoreJsonValue | undefined>;
-    write(key: string, value: CoreJsonValue): Promise<number>;
-    delete(key: string): Promise<number>;
-    watch(handler: (change: CoreStateChange, call: CoreOperationContext) => void | Promise<void>): CoreResourceRegistration;
-}
-export interface CoreDataApi {
-    readonly store?: CoreStoreApi;
-    readonly state: CoreStateApi;
-    readonly checkpoint?: CoreCheckpointApi;
-}
-export interface CoreStoreCommit {
-    readonly expectedRevision?: number;
-    readonly writes: readonly {
-        readonly key: string;
-        readonly value?: CoreJsonValue;
-    }[];
-}
-export interface CoreStoreApi {
-    get(input: {
-        readonly key: string;
-    }): Promise<CoreCheckpoint>;
-    keys(): Promise<{
-        readonly revision: number;
-        readonly keys: readonly string[];
-    }>;
-    set(input: {
-        readonly key: string;
-        readonly value: CoreJsonValue;
-        readonly expectedRevision?: number;
-    }): Promise<CoreCheckpoint>;
-    delete(input: {
-        readonly key: string;
-        readonly expectedRevision?: number;
-    }): Promise<CoreCheckpoint>;
-    commit(input: CoreStoreCommit): Promise<{
-        readonly revision: number;
-    }>;
-}
-export declare function cloneCoreJson(value: unknown): CoreJsonValue;
-/** Explicit reactive state, not a proxy over the Session or a second persistence mechanism. */
-export declare class ExtensionState {
-    #private;
-    readonly scope: ExtensionResourceScope;
-    readonly diagnose: () => void;
-    readonly callback: CoreCallbackRunner;
-    constructor(scope: ExtensionResourceScope, diagnose: () => void, callback?: CoreCallbackRunner);
-    read(key: string): CoreJsonValue | undefined;
-    write(key: string, value: CoreJsonValue | undefined, call: CoreOperationContext): Promise<number>;
-    watch(handler: (change: CoreStateChange, call: CoreOperationContext) => void | Promise<void>): CoreResourceRegistration;
-}

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

@@ -1,83 +0,0 @@
-import { MarAgentError } from '../error.js';
-export function cloneCoreJson(value) {
-    try {
-        const ancestors = new Set();
-        const copy = (value) => {
-            if (value === null || typeof value === 'string' || typeof value === 'boolean')
-                return value;
-            if (typeof value === 'number' && Number.isFinite(value))
-                return value;
-            if (typeof value !== 'object' || !value || ancestors.has(value))
-                throw new Error();
-            ancestors.add(value);
-            try {
-                if (Array.isArray(value))
-                    return Array.from(value, copy);
-                if (Object.prototype.toString.call(value) !== '[object Object]')
-                    throw new Error();
-                // Define own JSON keys, including __proto__, without assigning to a prototype setter.
-                return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, copy(item)]));
-            }
-            finally {
-                ancestors.delete(value);
-            }
-        };
-        return copy(value);
-    }
-    catch {
-        throw new MarAgentError('MAR_AGENT_EXTENSION_DATA_INVALID', 'Extension data must be serializable JSON.');
-    }
-}
-/** Explicit reactive state, not a proxy over the Session or a second persistence mechanism. */
-export class ExtensionState {
-    scope;
-    diagnose;
-    callback;
-    #values = new Map();
-    #observers = [];
-    #revision = 0;
-    constructor(scope, diagnose, callback = async (call, run) => run(call)) {
-        this.scope = scope;
-        this.diagnose = diagnose;
-        this.callback = callback;
-    }
-    read(key) {
-        const value = this.#values.get(key);
-        return value === undefined ? undefined : cloneCoreJson(value);
-    }
-    async write(key, value, call) {
-        if (typeof key !== 'string')
-            throw new MarAgentError('MAR_AGENT_EXTENSION_DATA_INVALID', 'State key must be a string.');
-        const committed = value === undefined ? undefined : cloneCoreJson(value);
-        if (committed === undefined)
-            this.#values.delete(key);
-        else
-            this.#values.set(key, committed);
-        const revision = ++this.#revision;
-        const change = {
-            key,
-            revision,
-            ...(committed !== undefined ? { value: cloneCoreJson(committed) } : {})
-        };
-        if (this.scope.state === 'ACTIVE')
-            for (const observer of [...this.#observers]) {
-                try {
-                    await this.scope.run((signal) => this.callback(Object.freeze({ ...call, signal }), (effective) => observer(structuredClone(change), effective)), call.signal);
-                }
-                catch {
-                    call.signal.throwIfAborted();
-                    this.diagnose();
-                }
-            }
-        return revision;
-    }
-    watch(handler) {
-        const registration = this.scope.effect(() => () => {
-            const index = this.#observers.indexOf(handler);
-            if (index !== -1)
-                this.#observers.splice(index, 1);
-        });
-        this.#observers.push(handler);
-        return registration;
-    }
-}

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

@@ -1,27 +0,0 @@
-import type { CoreOperationContext } from './operation.js';
-import type { CoreDomainFacts, CoreDomainOperations } from './contracts.js';
-import type { ExtensionHooks } from './hooks.js';
-export interface CoreEnvironmentKey {
-    readonly key: string;
-    readonly signal?: AbortSignal;
-}
-export interface CoreEnvironmentSet extends CoreEnvironmentKey {
-    readonly value?: string;
-}
-export interface CoreEnvironmentChange {
-    readonly changed: boolean;
-}
-export interface CoreEnvironmentApi {
-    get(input: CoreEnvironmentKey): Promise<string | undefined>;
-    set(input: CoreEnvironmentSet): Promise<CoreEnvironmentChange>;
-}
-export interface CoreEnvironmentBackend {
-    get(input: CoreEnvironmentKey, call: CoreOperationContext): Promise<string | undefined>;
-    set(input: CoreEnvironmentSet, call: CoreOperationContext): Promise<CoreEnvironmentChange>;
-}
-export interface CoreEnvironmentCompletion {
-    readonly operation: 'get' | 'set';
-    readonly changed?: boolean;
-}
-export declare function validateEnvironmentInput(input: CoreEnvironmentKey): void;
-export declare function bindCoreEnvironment(backend: CoreEnvironmentBackend, run: <Value>(operation: (call: CoreOperationContext) => Promise<Value>, signal?: AbortSignal) => Promise<Value>, hooks: ExtensionHooks<CoreDomainOperations, CoreDomainFacts>): CoreEnvironmentApi;

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

@@ -1,52 +0,0 @@
-import { MarAgentError } from '../error.js';
-export function validateEnvironmentInput(input) {
-    if (!input ||
-        typeof input.key !== 'string' ||
-        !input.key ||
-        input.key.includes('=') ||
-        input.key.includes('\0') ||
-        ('value' in input &&
-            input.value !== undefined &&
-            (typeof input.value !== 'string' || input.value.includes('\0'))))
-        throw new MarAgentError('MAR_AGENT_ENVIRONMENT_INPUT_INVALID', 'Environment variable input is invalid.');
-}
-export function bindCoreEnvironment(backend, run, hooks) {
-    return {
-        get: async (input) => {
-            input = { ...input };
-            validateEnvironmentInput(input);
-            return run((call) => hooks.invoke('environment.get', input, call, async (input, effective) => {
-                validateEnvironmentInput(input);
-                if (typeof backend.get !== 'function')
-                    throw unavailable('get');
-                const value = await backend.get({ ...input }, effective);
-                if (value !== undefined && typeof value !== 'string')
-                    throw invalidResult();
-                await hooks.emit('environment.completed', { operation: 'get' }, effective);
-                return value;
-            }), input.signal);
-        },
-        set: async (input) => {
-            input = { ...input };
-            validateEnvironmentInput(input);
-            return run((call) => hooks.invoke('environment.set', input, call, async (input, effective) => {
-                validateEnvironmentInput(input);
-                if (typeof backend.set !== 'function')
-                    throw unavailable('set');
-                const output = await backend.set({ ...input }, effective);
-                const changed = output?.changed;
-                if (typeof changed !== 'boolean')
-                    throw invalidResult();
-                const result = { changed };
-                await hooks.emit('environment.completed', { operation: 'set', ...result }, effective);
-                return result;
-            }), input.signal);
-        }
-    };
-}
-function unavailable(operation) {
-    return new MarAgentError('MAR_AGENT_HOST_PORT_UNAVAILABLE', 'Native environment port is unavailable.', { details: { operation } });
-}
-function invalidResult() {
-    return new MarAgentError('MAR_AGENT_ENVIRONMENT_OUTPUT_INVALID', 'Native environment result is invalid.');
-}

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

@@ -1,64 +0,0 @@
-import type { CoreOperationContext } from './operation.js';
-import type { CoreDomainFacts, CoreDomainOperations } from './contracts.js';
-import type { ExtensionHooks } from './hooks.js';
-export type CoreFileType = 'file' | 'directory' | 'symlink' | 'other';
-export interface CoreFilePath {
-    readonly path: string;
-}
-export interface CoreFileInfo {
-    readonly path: string;
-    readonly type: CoreFileType;
-    readonly size: number;
-    readonly modifiedAtMs: number;
-    readonly createdAtMs: number;
-}
-export interface CoreFileEntry {
-    readonly name: string;
-    readonly type: CoreFileType;
-}
-export interface CoreFileWrite extends CoreFilePath {
-    readonly bytes: Uint8Array;
-    readonly createParents?: boolean;
-}
-export interface CoreFileRemove extends CoreFilePath {
-    readonly recursive?: boolean;
-    readonly force?: boolean;
-}
-export interface CoreFileTransfer {
-    readonly from: string;
-    readonly to: string;
-}
-export interface CoreFilesApi {
-    read(input: CoreFilePath): Promise<Uint8Array>;
-    write(input: CoreFileWrite): Promise<{
-        readonly bytesWritten: number;
-    }>;
-    stat(input: CoreFilePath): Promise<CoreFileInfo>;
-    list(input: CoreFilePath): Promise<readonly CoreFileEntry[]>;
-    mkdir(input: CoreFilePath & {
-        readonly recursive?: boolean;
-    }): Promise<void>;
-    remove(input: CoreFileRemove): Promise<void>;
-    move(input: CoreFileTransfer): Promise<void>;
-    copy(input: CoreFileTransfer): Promise<void>;
-}
-type Input<Name extends keyof CoreFilesApi> = Parameters<CoreFilesApi[Name]>[0];
-type Output<Name extends keyof CoreFilesApi> = Awaited<ReturnType<CoreFilesApi[Name]>>;
-export type CoreFilesBackend = {
-    [Name in keyof CoreFilesApi]: (input: Input<Name>, call: CoreOperationContext) => Promise<Output<Name>>;
-};
-export type CoreFileOperations = {
-    [Name in keyof CoreFilesApi as `files.${Name}`]: {
-        input: Input<Name>;
-        output: Output<Name>;
-    };
-};
-export type CoreFileCompletion = {
-    [Name in keyof CoreFilesApi]: {
-        readonly operation: Name;
-        readonly input: Input<Name>;
-        readonly output: Output<Name>;
-    };
-}[keyof CoreFilesApi];
-export declare function bindCoreFiles(backend: CoreFilesBackend, run: <Value>(operation: (call: CoreOperationContext) => Promise<Value>) => Promise<Value>, hooks: ExtensionHooks<CoreDomainOperations, CoreDomainFacts>): CoreFilesApi;
-export {};

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

@@ -1,26 +0,0 @@
-import { MarAgentError } from '../error.js';
-export function bindCoreFiles(backend, run, hooks) {
-    const invoke = (name, input) => run((call) => {
-        const handler = backend[name];
-        if (typeof handler !== 'function')
-            throw new MarAgentError('MAR_AGENT_HOST_PORT_UNAVAILABLE', 'Native file port is unavailable.', { details: { operation: name } });
-        return hooks.invoke(`files.${name}`, input, call, async (input, effective) => {
-            const factInput = input && 'bytes' in input && input.bytes instanceof Uint8Array
-                ? { ...input, bytes: new Uint8Array(input.bytes) }
-                : { ...input };
-            const output = await handler.call(backend, input, effective);
-            await hooks.emit('files.completed', { operation: name, input: factInput, output }, effective);
-            return output;
-        });
-    });
-    return {
-        read: (input) => invoke('read', input),
-        write: (input) => invoke('write', input),
-        stat: (input) => invoke('stat', input),
-        list: (input) => invoke('list', input),
-        mkdir: (input) => invoke('mkdir', input),
-        remove: (input) => invoke('remove', input),
-        move: (input) => invoke('move', input),
-        copy: (input) => invoke('copy', input)
-    };
-}

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

@@ -1,32 +0,0 @@
-import type { CoreCallbackRunner, CoreOperationContext } from './operation.js';
-import type { CoreResourceRegistration } from './resources.js';
-import { ExtensionResourceScope } from './resources.js';
-export interface CoreHookOptions {
-    readonly reentry?: 'skip-active' | 'allow';
-}
-export interface CoreHookDiagnostic {
-    readonly code: 'MAR_AGENT_EXTENSION_OBSERVER_FAILED';
-    readonly operationId: string;
-}
-export type CoreInterceptor<Input, Output> = (input: Input, call: CoreOperationContext, next: (input: Input) => Promise<Output>) => Output | Promise<Output>;
-/** Typed domain chains with per-dispatch snapshots and async-ancestor reentry tracking. */
-export declare class ExtensionHooks<Operations extends {
-    [Key in keyof Operations]: {
-        input: unknown;
-        output: unknown;
-    };
-}, Facts extends object> {
-    #private;
-    readonly diagnose: (diagnostic: CoreHookDiagnostic) => void;
-    readonly callback: CoreCallbackRunner;
-    constructor(diagnose?: (diagnostic: CoreHookDiagnostic) => void, callback?: CoreCallbackRunner);
-    /** Internal physical callback ingress; unrelated dispatch must not inherit reentry suppression. */
-    independent<Value>(run: () => Value): Value;
-    /** Avoid materializing public views when no active interceptor can consume them. */
-    hasInterceptors(key: keyof Operations): boolean;
-    intercept<Key extends keyof Operations>(owner: ExtensionResourceScope, key: Key, handler: CoreInterceptor<Operations[Key]['input'], Operations[Key]['output']>, options?: CoreHookOptions): CoreResourceRegistration;
-    observe<Key extends keyof Facts>(owner: ExtensionResourceScope, key: Key, handler: (fact: Facts[Key], call: CoreOperationContext) => void | Promise<void>, options?: CoreHookOptions): CoreResourceRegistration;
-    invoke<Key extends keyof Operations>(key: Key, input: Operations[Key]['input'], call: CoreOperationContext, leaf: (input: Operations[Key]['input'], call: CoreOperationContext) => Promise<Operations[Key]['output']>): Promise<Operations[Key]['output']>;
-    hasObservers<Key extends keyof Facts>(key: Key): boolean;
-    emit<Key extends keyof Facts>(key: Key, fact: Facts[Key], call: CoreOperationContext, settled?: boolean): Promise<void>;
-}

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

@@ -1,39 +0,0 @@
-import type { CoreCapabilitySnapshot, CoreExtensionDiagnostic, CoreExtensionSource, CoreRuntimeExtension } from './contracts.js';
-import { ExtensionOperations, type CoreOperationContext } from './operation.js';
-import { ExtensionSession } from './session.js';
-import type { CoreToolBinding } from './tools.js';
-import type { CoreModelsBackend } from './models.js';
-import type { CoreCheckpointBackend } from './data.js';
-import type { CoreSessionBackend } from './session-input.js';
-import type { CoreHostExtensionPorts } from '../host/contracts.js';
-import { type CoreAgentsBackend } from './agents.js';
-export interface ExtensionManagerOptions {
-    readonly hostPorts?: CoreHostExtensionPorts;
-    readonly extensions: readonly CoreRuntimeExtension[] | CoreExtensionSource;
-    readonly capabilities: readonly string[];
-    readonly busyExcept: (sessionId: string) => boolean;
-    readonly baseTools?: (sessionId: string, context?: Pick<CoreOperationContext, 'executionId'>) => readonly CoreToolBinding[];
-    readonly models?: CoreModelsBackend;
-    readonly checkpoint?: CoreCheckpointBackend;
-    readonly sessionBackend?: (sessionId: string) => CoreSessionBackend | undefined;
-    readonly agentsBackend?: (sessionId: string) => CoreAgentsBackend | undefined;
-    readonly allowTool?: (sessionId: string, name: string, definition?: CoreToolBinding['definition']) => boolean;
-    readonly scheduleTool?: (sessionId: string) => ExtensionSession['scheduleTool'];
-}
-/** Agent admission coordinates a single composition generation, never parallel replacement loops. */
-export declare class ExtensionManager {
-    #private;
-    readonly options: ExtensionManagerOptions;
-    readonly operations: ExtensionOperations;
-    readonly capabilities: CoreCapabilitySnapshot;
-    constructor(options: ExtensionManagerOptions);
-    diagnostics(): readonly CoreExtensionDiagnostic[];
-    session(id: string): ExtensionSession | undefined;
-    get revision(): string | undefined;
-    hasReferences(): boolean;
-    prepare(sessionId: string, signal: AbortSignal, baseTools?: readonly CoreToolBinding[], refresh?: boolean): Promise<ExtensionSession>;
-    clearSession(id: string): Promise<void>;
-    endSession(id: string, reason: 'clear' | 'other', resumable?: boolean): Promise<void>;
-    retireSession(id: string): void;
-    dispose(): Promise<void>;
-}