@myagentroam/agent 0.11.33 → 0.11.34

package/dist/extensions/settings.js

@@ -0,0 +1,115 @@
+import { AgentError } from '../error.js';
+import { cloneCoreJson } from './data.js';
+export function coreSettingsBinding(bindings) {
+    const backend = bindings?.['settings'];
+    if (backend === undefined)
+        return undefined;
+    if (!backend ||
+        typeof backend !== 'object' ||
+        ['describe', 'read', 'update'].some((name) => typeof backend[name] !== 'function'))
+        throw new AgentError('MAR_AGENT_SETTINGS_BINDING_INVALID', 'Settings binding must provide describe, read and update.');
+    return backend;
+}
+export function settingsCapabilities(base, bound) {
+    const list = Object.freeze([
+        ...base.list().filter((id) => id !== 'settings'),
+        ...(bound ? ['settings'] : [])
+    ]);
+    return Object.freeze({ has: (id) => list.includes(id), list: () => list });
+}
+function copyInput(input) {
+    if (!input ||
+        typeof input !== 'object' ||
+        Array.isArray(input) ||
+        (input.scope !== undefined && (typeof input.scope !== 'string' || !input.scope)))
+        throw invalid('INPUT');
+    if ('key' in input) {
+        const update = input;
+        if (typeof update.key !== 'string' ||
+            !update.key ||
+            (update.expectedRevision !== undefined &&
+                (!Number.isSafeInteger(update.expectedRevision) || update.expectedRevision < 0)))
+            throw invalid('INPUT');
+        try {
+            return { ...input, value: cloneCoreJson(update.value) };
+        }
+        catch {
+            throw invalid('INPUT');
+        }
+    }
+    return { ...input };
+}
+function copyOutput(value) {
+    try {
+        return cloneCoreJson(value);
+    }
+    catch {
+        throw invalid('OUTPUT');
+    }
+}
+function invalid(kind) {
+    return new AgentError(`MAR_AGENT_SETTINGS_${kind}_INVALID`, `Settings ${kind === 'INPUT' ? 'input' : 'result'} is invalid.`);
+}
+function object(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+export function bindCoreSettings(backend, run, hooks) {
+    const invoke = async (name, raw) => {
+        const input = copyInput(raw);
+        return run((call) => hooks.invoke(`settings.${name}`, input, call, async (candidate, effective) => {
+            const supplied = copyInput(candidate);
+            if (name === 'update' && (!('key' in supplied) || !('value' in supplied)))
+                throw invalid('INPUT');
+            if (typeof backend[name] !== 'function')
+                throw new AgentError('MAR_AGENT_HOST_PORT_UNAVAILABLE', 'Bound settings operation is unavailable.', { details: { operation: name } });
+            const handler = backend[name];
+            const output = copyOutput(await handler.call(backend, supplied, effective));
+            if (!object(output) ||
+                !Number.isSafeInteger(output['revision']) ||
+                output['revision'] < 0)
+                throw invalid('OUTPUT');
+            if (name === 'describe') {
+                const definitions = output['definitions'];
+                if (!Array.isArray(definitions) ||
+                    definitions.some((item) => !object(item) ||
+                        typeof item['key'] !== 'string' ||
+                        !item['key'] ||
+                        typeof item['source'] !== 'string' ||
+                        typeof item['writable'] !== 'boolean' ||
+                        (item['sensitive'] !== undefined && typeof item['sensitive'] !== 'boolean') ||
+                        (item['label'] !== undefined && typeof item['label'] !== 'string') ||
+                        (item['owner'] !== undefined && typeof item['owner'] !== 'string') ||
+                        (typeof item['schema'] !== 'boolean' && !object(item['schema']))) ||
+                    new Set(definitions.map((item) => item.key)).size !==
+                        definitions.length)
+                    throw invalid('OUTPUT');
+            }
+            else if (name === 'read') {
+                if (!object(output['values']))
+                    throw invalid('OUTPUT');
+            }
+            else if (!['updated', 'unchanged', 'denied'].includes(String(output['status'])) ||
+                (output['status'] === 'denied'
+                    ? !object(output['reason']) ||
+                        typeof output['reason']['code'] !== 'string' ||
+                        !output['reason']['code'] ||
+                        typeof output['reason']['message'] !== 'string'
+                    : !('value' in output)))
+                throw invalid('OUTPUT');
+            await hooks.emit('settings.completed', {
+                operation: name,
+                revision: output['revision'],
+                ...(supplied.scope === undefined ? {} : { scope: supplied.scope }),
+                ...(name === 'update'
+                    ? { status: output['status'] }
+                    : {})
+            }, effective);
+            return output;
+        }), input.signal);
+    };
+    return {
+        describe: (input = {}) => invoke('describe', input),
+        read: (input = {}) => invoke('read', input),
+        update: (input) => invoke('update', input)
+    };
+}

package/dist/extensions/store.d.ts

@@ -0,0 +1,10 @@
+import { type ExtensionStoreApi } from './data.js';
+type StoreRun = <T>(operation: (signal: AbortSignal) => Promise<T>) => Promise<T>;
+/** One application-bound installation namespace, independent from Session JSONL or Code Mode state. */
+export declare class ExtensionStore {
+    #private;
+    readonly directory: string;
+    constructor(directory: string);
+    bind(run: StoreRun): ExtensionStoreApi;
+}
+export {};

package/dist/extensions/store.js

@@ -0,0 +1,131 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, open, readFile, rename, rm } from 'node:fs/promises';
+import { isAbsolute, join } from 'node:path';
+import { AgentError } from '../error.js';
+import { acquireFileLock } from '../storage/file-lock.js';
+import { cloneCoreJson } from './data.js';
+/** One application-bound installation namespace, independent from Session JSONL or Code Mode state. */
+export class ExtensionStore {
+    directory;
+    #path;
+    constructor(directory) {
+        this.directory = directory;
+        if (typeof directory !== 'string' || !isAbsolute(directory))
+            throw new AgentError('MAR_AGENT_EXTENSION_STORE_INVALID', 'Extension store requires an absolute data directory.');
+        this.#path = join(directory, 'core-store.json');
+    }
+    bind(run) {
+        const commit = (input) => run((signal) => this.#commit(input, signal));
+        return {
+            get: ({ key }) => run(async (signal) => {
+                validateKey(key);
+                const document = await this.#read(signal);
+                const value = Object.hasOwn(document.values, key) ? document.values[key] : undefined;
+                return {
+                    revision: document.revision,
+                    ...(value === undefined ? {} : { value: cloneCoreJson(value) })
+                };
+            }),
+            keys: () => run(async (signal) => {
+                const document = await this.#read(signal);
+                return { revision: document.revision, keys: Object.keys(document.values).sort() };
+            }),
+            set: async ({ key, value, expectedRevision }) => {
+                const copied = cloneCoreJson(value);
+                const result = await commit({
+                    writes: [{ key, value: copied }],
+                    ...(expectedRevision === undefined ? {} : { expectedRevision })
+                });
+                return { revision: result.revision, value: copied };
+            },
+            delete: ({ key, expectedRevision }) => commit({
+                writes: [{ key }],
+                ...(expectedRevision === undefined ? {} : { expectedRevision })
+            }),
+            commit
+        };
+    }
+    async #read(signal) {
+        signal.throwIfAborted();
+        let text;
+        try {
+            text = await readFile(this.#path, { encoding: 'utf8', signal });
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return { revision: 0, values: {} };
+            throw error;
+        }
+        signal.throwIfAborted();
+        try {
+            const value = JSON.parse(text);
+            if (!value ||
+                !Number.isSafeInteger(value.revision) ||
+                value.revision < 0 ||
+                !value.values ||
+                typeof value.values !== 'object' ||
+                Array.isArray(value.values))
+                throw new Error();
+            const values = cloneCoreJson(value.values);
+            return { revision: value.revision, values };
+        }
+        catch {
+            throw new AgentError('MAR_AGENT_EXTENSION_STORE_CORRUPT', 'Extension store document is invalid.');
+        }
+    }
+    async #commit(input, signal) {
+        if (!input ||
+            !Array.isArray(input.writes) ||
+            (input.expectedRevision !== undefined &&
+                (!Number.isSafeInteger(input.expectedRevision) || input.expectedRevision < 0)))
+            throw new AgentError('MAR_AGENT_EXTENSION_STORE_INVALID', 'Store mutation or expected revision is invalid.');
+        const writes = input.writes.map((write) => {
+            if (!write || typeof write !== 'object')
+                throw new AgentError('MAR_AGENT_EXTENSION_STORE_INVALID', 'Store mutation is invalid.');
+            const { key, value } = write;
+            validateKey(key);
+            return { key, ...(value === undefined ? {} : { value: cloneCoreJson(value) }) };
+        });
+        signal.throwIfAborted();
+        await mkdir(this.directory, { recursive: true });
+        const release = await acquireFileLock(join(this.directory, 'core-store.lock'), 'Extension store is busy.', 5000, { signal, code: 'MAR_AGENT_EXTENSION_STORE_LOCKED' });
+        const temporary = join(this.directory, `.core-store-${randomUUID()}.tmp`);
+        try {
+            const document = await this.#read(signal);
+            if (input.expectedRevision !== undefined && document.revision !== input.expectedRevision)
+                throw new AgentError('MAR_AGENT_EXTENSION_STORE_CONFLICT', 'Store revision changed before commit.');
+            const values = Object.assign(Object.create(null), document.values);
+            for (const { key, value } of writes)
+                if (value === undefined)
+                    delete values[key];
+                else
+                    values[key] = value;
+            const revision = document.revision + 1;
+            if (!Number.isSafeInteger(revision))
+                throw new AgentError('MAR_AGENT_EXTENSION_STORE_INVALID', 'Store revision is exhausted.');
+            const handle = await open(temporary, 'wx', 0o600);
+            try {
+                await handle.writeFile(JSON.stringify({ revision, values }));
+                await handle.sync();
+            }
+            finally {
+                await handle.close();
+            }
+            signal.throwIfAborted();
+            await rename(temporary, this.#path);
+            return { revision };
+        }
+        finally {
+            try {
+                await rm(temporary, { force: true });
+            }
+            finally {
+                await release();
+            }
+        }
+    }
+}
+function validateKey(key) {
+    if (typeof key !== 'string')
+        throw new AgentError('MAR_AGENT_EXTENSION_STORE_INVALID', 'Store key must be a string.');
+}

package/dist/extensions/tool-runtime.d.ts

@@ -0,0 +1,16 @@
+import type { ClientToolDefinition, McpToolCatalog, ToolCall, ToolExecutionResult } from '../tools/contracts.js';
+import type { ExtensionOperationContext } from './operation.js';
+/** Tool operations needed by the Extension ingress; SDK supplies the Tool implementation. */
+export interface ExtensionToolRuntime {
+    currentPermissions(call: ExtensionOperationContext): {
+        readonly mode: string;
+        assertDispatch(): void;
+        prepare(input: ToolCall, call: ExtensionOperationContext, definition: ClientToolDefinition): ToolCall;
+        authorize(input: ToolCall, call: ExtensionOperationContext): Promise<ToolCall>;
+    } | undefined;
+    normalizeInput(input: unknown, schema: unknown): unknown;
+    validateResult(result: ToolExecutionResult): ToolExecutionResult;
+    independent<T>(run: () => T): T;
+    validateCallers(definition: ClientToolDefinition): void;
+    validateMcpCatalog(catalog: McpToolCatalog): void;
+}

package/dist/extensions/tools.d.ts

@@ -0,0 +1,80 @@
+import type { ClientToolDefinition, McpCatalogTool, ToolCall, ToolExecutionResult } from '../tools/contracts.js';
+import type { ExtensionCallbackRunner, ExtensionOperationContext } from './operation.js';
+import { ExtensionResourceScope, type ExtensionResourceRegistration } from './resources.js';
+export interface ExtensionToolSpec extends ClientToolDefinition {
+    readonly override?: 'replace' | 'wrap';
+    /** Optional native validator/parser for schema features outside the built-in converter. */
+    readonly parseInput?: (input: unknown) => unknown | Promise<unknown>;
+    readonly validateOutput?: (data: unknown) => void | Promise<void>;
+    execute(input: unknown, call: ExtensionOperationContext, next: (input: unknown) => Promise<ToolExecutionResult>): ToolExecutionResult | Promise<ToolExecutionResult>;
+}
+export interface ExtensionToolRef {
+    readonly mcp?: McpCatalogTool;
+    readonly definition: ClientToolDefinition;
+    readonly source: Readonly<{
+        id: string;
+        revision: string;
+        kind: 'builtin' | 'host' | 'mcp' | 'extension';
+        instanceId?: string;
+    }>;
+}
+export interface ExtensionToolInvocation extends ToolCall {
+    readonly ref?: ExtensionToolRef;
+}
+export interface ExtensionToolCheck {
+    readonly available: boolean;
+    readonly code?: string;
+    readonly source?: ExtensionToolRef['source'];
+}
+export interface ExtensionToolAttempt {
+    readonly attemptId: string;
+    readonly parentAttemptId?: string;
+    readonly name: string;
+    readonly callId?: string;
+    readonly stage: 'leaf' | 'wrapper' | 'result';
+    readonly source?: ExtensionToolRef['source'];
+}
+export interface ExtensionToolCompletion extends ExtensionToolAttempt {
+    readonly result: ToolExecutionResult;
+}
+export interface ExtensionToolFailure extends ExtensionToolAttempt {
+    readonly status: 'failed' | 'cancelled';
+    readonly errorCode: string;
+}
+export interface ExtensionToolBinding extends ExtensionToolRef {
+    readonly mcp?: McpCatalogTool;
+    registered?(): boolean;
+    available?(context: ExtensionOperationContext): boolean;
+    invoke(call: ToolCall, context: ExtensionOperationContext): Promise<ToolExecutionResult>;
+}
+export interface ExtensionToolsApi {
+    register(spec: ExtensionToolSpec): ExtensionResourceRegistration;
+    catalog(): readonly ExtensionToolRef[];
+    check(call: ExtensionToolInvocation): Promise<ExtensionToolCheck>;
+    invoke(call: ExtensionToolInvocation): Promise<ToolExecutionResult>;
+}
+/** Builds one immutable catalog from real sources; snapshots keep their captured handlers. */
+export declare class ExtensionTools {
+    #private;
+    readonly trace: (binding: ExtensionToolBinding, stage: 'leaf' | 'wrapper') => ExtensionToolBinding;
+    readonly callback: ExtensionCallbackRunner;
+    readonly validateCallers: (definition: ClientToolDefinition) => void;
+    constructor(trace: ((binding: ExtensionToolBinding, stage: "leaf" | "wrapper") => ExtensionToolBinding) | undefined, callback: ExtensionCallbackRunner | undefined, validateCallers: (definition: ClientToolDefinition) => void);
+    get revision(): number;
+    /** Internal bridge for a real owner-bound backend, not an author-supplied handler authority. */
+    contributeSource(owner: ExtensionResourceScope, source: ExtensionToolBinding): ExtensionResourceRegistration;
+    register(owner: ExtensionResourceScope, id: string, spec: ExtensionToolSpec): ExtensionResourceRegistration;
+    capture(base?: readonly ExtensionToolBinding[], includeStaged?: boolean): ReadonlyMap<string, ExtensionToolBinding>;
+}
+export interface DomainToolOperations {
+    'tool.invoke': {
+        input: ToolCall;
+        output: ToolExecutionResult;
+    };
+}
+export interface DomainToolFacts {
+    'tool.completed': ExtensionToolCompletion;
+    'tool.failed': ExtensionToolFailure;
+    'tool.attempt.completed': ExtensionToolCompletion;
+    'tool.attempt.failed': ExtensionToolFailure;
+}

package/dist/extensions/tools.js

@@ -0,0 +1,270 @@
+import { randomUUID } from 'node:crypto';
+import { AgentError } from '../error.js';
+import { fromJSONSchema } from 'zod';
+import { ExtensionResourceScope } from './resources.js';
+/** Builds one immutable catalog from real sources; snapshots keep their captured handlers. */
+export class ExtensionTools {
+    trace;
+    callback;
+    validateCallers;
+    #entries = [];
+    #sources = [];
+    #revision = 0;
+    constructor(trace = (binding) => binding, callback = async (call, run) => run(call), validateCallers) {
+        this.trace = trace;
+        this.callback = callback;
+        this.validateCallers = validateCallers;
+    }
+    get revision() {
+        return this.#revision;
+    }
+    /** Internal bridge for a real owner-bound backend, not an author-supplied handler authority. */
+    contributeSource(owner, source) {
+        const entry = {
+            owner,
+            binding: Object.freeze({
+                ...source,
+                definition: deepFreeze(copyDefinition(source.definition)),
+                source: Object.freeze({ ...source.source }),
+                ...(source.mcp === undefined ? {} : { mcp: deepFreeze(structuredClone(source.mcp)) })
+            })
+        };
+        const registration = owner.effect(() => () => {
+            const index = this.#sources.indexOf(entry);
+            if (index !== -1) {
+                this.#sources.splice(index, 1);
+                this.#revision++;
+            }
+        });
+        this.#sources.push(entry);
+        this.#revision++;
+        return registration;
+    }
+    register(owner, id, spec) {
+        if (typeof spec.name !== 'string' ||
+            !spec.name.trim() ||
+            typeof spec.description !== 'string' ||
+            typeof spec.execute !== 'function' ||
+            !spec.inputSchema ||
+            typeof spec.inputSchema !== 'object' ||
+            Array.isArray(spec.inputSchema) ||
+            (spec.override !== undefined && spec.override !== 'replace' && spec.override !== 'wrap'))
+            throw new AgentError('MAR_AGENT_EXTENSION_TOOL_INVALID', 'Extension tool definition or handler is invalid.');
+        const definition = copyDefinition(spec);
+        const parse = spec.parseInput ?? schemaValidator(spec.inputSchema, 'MAR_AGENT_TOOL_INPUT_INVALID');
+        const validateOutput = spec.validateOutput ??
+            (spec.outputSchema
+                ? schemaValidator(spec.outputSchema, 'MAR_AGENT_TOOL_OUTPUT_INVALID')
+                : undefined);
+        this.validateCallers({
+            ...definition,
+            allowedCallers: spec.allowedCallers ?? ['direct', 'programmatic']
+        });
+        const entry = {
+            owner,
+            id,
+            revision: randomUUID(),
+            parse,
+            ...(validateOutput ? { validateOutput } : {}),
+            spec: Object.freeze({
+                ...definition,
+                ...(spec.override ? { override: spec.override } : {}),
+                execute: spec.execute
+            })
+        };
+        const registration = owner.effect(() => () => {
+            const index = this.#entries.indexOf(entry);
+            if (index !== -1) {
+                this.#entries.splice(index, 1);
+                this.#revision++;
+            }
+        });
+        this.#entries.push(entry);
+        this.#revision++;
+        return registration;
+    }
+    capture(base = [], includeStaged = false) {
+        const bindings = new Map();
+        const sources = this.#sources
+            .filter(({ owner }) => owner.state === 'ACTIVE' || (includeStaged && owner.state === 'STAGED'))
+            .filter(({ binding }) => binding.registered?.() !== false)
+            .map(({ binding }) => binding);
+        for (const original of [...base, ...sources]) {
+            const binding = Object.freeze({
+                ...original,
+                definition: deepFreeze(copyDefinition(original.definition)),
+                source: Object.freeze({ ...original.source }),
+                ...(original.mcp === undefined ? {} : { mcp: deepFreeze(structuredClone(original.mcp)) })
+            });
+            if (bindings.has(binding.definition.name))
+                throw new AgentError('MAR_AGENT_EXTENSION_TOOL_CONFLICT', 'Tool sources conflict.');
+            bindings.set(binding.definition.name, this.trace(binding, 'leaf'));
+        }
+        for (const entry of this.#entries) {
+            if (entry.owner.state !== 'ACTIVE' && !(includeStaged && entry.owner.state === 'STAGED'))
+                continue;
+            if (this.#entries
+                .slice(this.#entries.indexOf(entry) + 1)
+                .some((later) => later.owner === entry.owner && later.spec.name === entry.spec.name))
+                continue;
+            const lower = bindings.get(entry.spec.name);
+            if (lower && !entry.spec.override)
+                throw new AgentError('MAR_AGENT_EXTENSION_TOOL_CONFLICT', 'Tool replacement must be explicit.');
+            if (!lower && entry.spec.override === 'wrap') {
+                if (entry.owner.state === 'ACTIVE')
+                    continue;
+                throw new AgentError('MAR_AGENT_EXTENSION_DEPENDENCY_MISSING', 'Tool wrapper has no lower implementation.');
+            }
+            const definition = copyDefinition(entry.spec);
+            definition.allowedCallers ??= lower
+                ? (lower.definition.allowedCallers ??
+                    (lower.source.kind === 'mcp' ? ['direct', 'programmatic'] : ['direct']))
+                : ['direct', 'programmatic'];
+            if (entry.spec.override === 'wrap' && lower?.definition.agentScope !== undefined)
+                definition.agentScope ??= lower.definition.agentScope;
+            if (entry.spec.override === 'wrap' && lower?.definition.codeModeExposure !== undefined)
+                definition.codeModeExposure ??= lower.definition.codeModeExposure;
+            const binding = Object.freeze({
+                definition: deepFreeze(definition),
+                ...(entry.spec.override === 'wrap' && lower?.mcp ? { mcp: lower.mcp } : {}),
+                source: Object.freeze({
+                    kind: 'extension',
+                    id: entry.id,
+                    revision: entry.revision,
+                    instanceId: entry.owner.instanceId
+                }),
+                available: () => entry.owner.state === 'ACTIVE' ||
+                    (entry.owner.state === 'STAGED' && ExtensionResourceScope.initializing),
+                invoke: async (call, context) => entry.owner.run((signal) => this.callback(Object.freeze({ ...context, signal, ownerInstanceId: entry.owner.instanceId }), async (context) => {
+                    const signal = context.signal;
+                    const input = await entry.parse(call.arguments);
+                    signal.throwIfAborted();
+                    const controller = new AbortController();
+                    const effective = AbortSignal.any([signal, controller.signal]);
+                    const pending = new Set();
+                    let open = true;
+                    let output;
+                    try {
+                        output = await entry.spec.execute(input, Object.freeze({
+                            ...context,
+                            signal: effective,
+                            ownerInstanceId: entry.owner.instanceId
+                        }), (input) => {
+                            const result = Promise.resolve().then(() => {
+                                effective.throwIfAborted();
+                                if (!open)
+                                    throw new AgentError('MAR_AGENT_TOOL_NOT_AVAILABLE', 'Tool continuation has finished.');
+                                if (!lower || entry.spec.override !== 'wrap')
+                                    throw new AgentError('MAR_AGENT_EXTENSION_DEPENDENCY_MISSING', 'Tool has no wrapper continuation.');
+                                return lower.invoke({ ...call, arguments: input }, Object.freeze({ ...context, signal: effective }));
+                            });
+                            const settled = result.then(() => undefined, () => undefined);
+                            pending.add(settled);
+                            void settled.then(() => pending.delete(settled));
+                            return result;
+                        });
+                    }
+                    catch (error) {
+                        controller.abort();
+                        throw error;
+                    }
+                    finally {
+                        while (pending.size)
+                            await Promise.all([...pending]);
+                        open = false;
+                    }
+                    if (!output || typeof output.content !== 'string')
+                        throw new AgentError('MAR_AGENT_TOOL_OUTPUT_INVALID', 'Tool result must contain string content.');
+                    await entry.validateOutput?.(output.data);
+                    return output;
+                }), context.signal)
+            });
+            bindings.set(definition.name, this.trace(binding, entry.spec.override === 'wrap' ? 'wrapper' : 'leaf'));
+        }
+        const view = Object.freeze({
+            get size() {
+                return bindings.size;
+            },
+            get: (name) => bindings.get(name),
+            has: (name) => bindings.has(name),
+            entries: () => bindings.entries(),
+            keys: () => bindings.keys(),
+            values: () => bindings.values(),
+            [Symbol.iterator]: () => bindings[Symbol.iterator](),
+            forEach: (callback, thisArg) => {
+                for (const [key, value] of bindings)
+                    callback.call(thisArg, value, key, view);
+            }
+        });
+        return view;
+    }
+}
+function schemaValidator(schema, code) {
+    let validator;
+    try {
+        validator = fromJSONSchema(withoutDefaults(schema));
+    }
+    catch {
+        throw new AgentError('MAR_AGENT_EXTENSION_TOOL_SCHEMA_UNSUPPORTED', 'Schema requires an explicit native parser.');
+    }
+    return (input) => {
+        if (!validator.safeParse(input).success)
+            throw new AgentError(code, 'Tool value does not match its declared schema.');
+        return input;
+    };
+}
+/** JSON Schema defaults are annotations, not permission to insert missing input values. */
+function withoutDefaults(schema) {
+    if (typeof schema === 'boolean')
+        return schema;
+    const copied = structuredClone(schema);
+    delete copied.default;
+    for (const key of ['properties', 'patternProperties', '$defs', 'definitions']) {
+        const children = copied[key];
+        if (children && typeof children === 'object')
+            for (const [name, child] of Object.entries(children)) {
+                if (child && typeof child === 'object' && !Array.isArray(child))
+                    children[name] = withoutDefaults(child);
+            }
+    }
+    for (const key of ['anyOf', 'allOf', 'oneOf', 'prefixItems', 'items']) {
+        const children = copied[key];
+        if (Array.isArray(children))
+            copied[key] = children.map((child) => withoutDefaults(child));
+    }
+    for (const key of [
+        'items',
+        'additionalItems',
+        'additionalProperties',
+        'contains',
+        'not',
+        'propertyNames'
+    ]) {
+        const child = copied[key];
+        if (child && typeof child === 'object' && !Array.isArray(child))
+            copied[key] = withoutDefaults(child);
+    }
+    return copied;
+}
+function deepFreeze(value) {
+    if (value && typeof value === 'object' && !Object.isFrozen(value)) {
+        for (const child of Object.values(value))
+            deepFreeze(child);
+        Object.freeze(value);
+    }
+    return value;
+}
+function copyDefinition(spec) {
+    return {
+        name: spec.name,
+        description: spec.description,
+        inputSchema: structuredClone(spec.inputSchema),
+        ...(spec.nativeType ? { nativeType: spec.nativeType } : {}),
+        ...(spec.outputSchema ? { outputSchema: structuredClone(spec.outputSchema) } : {}),
+        ...(spec.allowedCallers ? { allowedCallers: [...spec.allowedCallers] } : {}),
+        ...(spec.codeModeExposure !== undefined ? { codeModeExposure: spec.codeModeExposure } : {}),
+        ...(spec.inputMode ? { inputMode: spec.inputMode } : {}),
+        ...(spec.parallelSafety ? { parallelSafety: spec.parallelSafety } : {}),
+        ...(spec.agentScope ? { agentScope: spec.agentScope } : {})
+    };
+}

package/dist/extensions.d.ts

@@ -0,0 +1,22 @@
+export type { ExtensionAgentCompletion, ExtensionAgentHandledResult, ExtensionAgentManySnapshot, ExtensionAgentMessageInput, ExtensionAgentsApi, ExtensionAgentsBackend, ExtensionAgentSnapshot, ExtensionAgentSpawnInput, ExtensionAgentSpawnResult, ExtensionAgentTarget, ExtensionAgentWaitInput, ExtensionAgentWaitResult } from './extensions/agents.js';
+export type { ExtensionCompactContext, ExtensionCompactDiagnostic, ExtensionCompactMessage, ExtensionCompactResult } from './extensions/compaction.js';
+export type { AgentExtension, AgentExtensionContext, ExtensionCapabilitySnapshot, ExtensionCommandSpec, ExtensionDiagnostic, ExtensionDomainFacts, ExtensionDomainOperations, ExtensionHookRegistrar, ExtensionPromptSection, ExtensionServiceDeclaration, ExtensionServiceDependency, ExtensionSnapshot, ExtensionSource, SessionExtensionContext } from './extensions/contracts.js';
+export type { ExtensionCheckpoint, ExtensionCheckpointApi, ExtensionDataApi, ExtensionJsonValue, ExtensionStateApi, ExtensionStateChange, ExtensionStoreApi, ExtensionStoreCommit } from './extensions/data.js';
+export type { ExtensionEnvironmentApi, ExtensionEnvironmentBackend, ExtensionEnvironmentChange, ExtensionEnvironmentCompletion, ExtensionEnvironmentKey, ExtensionEnvironmentSet } from './extensions/environment.js';
+export type { ExtensionFileCompletion, ExtensionFileEntry, ExtensionFileInfo, ExtensionFilePath, ExtensionFileRemove, ExtensionFilesApi, ExtensionFilesBackend, ExtensionFileTransfer, ExtensionFileType, ExtensionFileWrite } from './extensions/files.js';
+export type { ExtensionHookOptions, ExtensionInterceptor } from './extensions/hooks.js';
+export type { ExtensionMcpApi, ExtensionMcpBackend, ExtensionMcpCallInput, ExtensionMcpCatalog, ExtensionMcpCompletion, ExtensionMcpConnectInput, ExtensionMcpConnectionBackend, ExtensionMcpConnectionInput, ExtensionMcpConnectionRef, ExtensionMcpServerDefinition, ExtensionMcpServerRef, ExtensionMcpServerRegistration, ExtensionMcpToolCall } from './extensions/mcp.js';
+export type { ExtensionModelMessage, ExtensionModelRequest, ExtensionRequestSnapshot } from './extensions/model-request.js';
+export type { ExtensionModelEvent } from './extensions/model-stream.js';
+export type { ExtensionGenerateInput, ExtensionGenerateResult, ExtensionModelDescription, ExtensionModelsApi, ExtensionModelTextBlock } from './extensions/models.js';
+export type { ExtensionHttpCompletion, ExtensionHttpRequest, ExtensionHttpResponse, ExtensionNetworkApi, ExtensionNetworkBackend } from './extensions/network.js';
+export type { ExtensionOperationContext } from './extensions/operation.js';
+export type { ExtensionProcessCompletion, ExtensionProcessesApi, ExtensionProcessesBackend, ExtensionProcessExit, ExtensionProcessHandle, ExtensionProcessInput, ExtensionProcessResult, ExtensionProcessRunInput } from './extensions/processes.js';
+export type { ExtensionPromptComposition, ExtensionPromptFacts, ExtensionPromptSectionInput } from './extensions/prompt-composition.js';
+export type { ExtensionPromptInput, ExtensionPromptResult } from './extensions/prompt-input.js';
+export type { ExtensionDisposer, ExtensionResourceRegistration, ExtensionResourceScope } from './extensions/resources.js';
+export type { ExtensionServiceKey, ExtensionServiceRegistry } from './extensions/services.js';
+export type { ExtensionAppendInput, ExtensionCompactInput, ExtensionInputSource, ExtensionSessionActionResult, ExtensionSessionApi, ExtensionSessionDescription, ExtensionSessionInspection, ExtensionSessionMessage, ExtensionSessionMessages, ExtensionSessionMessagesInput, ExtensionSessionOperationStatus, ExtensionSessionReceipt, ExtensionSubmitInput } from './extensions/session-input.js';
+export type { ExtensionSettingDefinition, ExtensionSettingsApi, ExtensionSettingsBackend, ExtensionSettingsCompletion, ExtensionSettingsDescription, ExtensionSettingsReadInput, ExtensionSettingsResult, ExtensionSettingsSnapshot, ExtensionSettingsUpdate } from './extensions/settings.js';
+export type { ExtensionToolAttempt, ExtensionToolCheck, ExtensionToolCompletion, ExtensionToolFailure, ExtensionToolInvocation, ExtensionToolRef, ExtensionToolSpec } from './extensions/tools.js';
+export type { PromptPart } from './prompts/prompt-sections.js';