@myagentroam/agent 0.11.33 → 0.11.35

package/dist/agent-core/extensions/session-input.js

@@ -1,411 +0,0 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
-import { randomUUID } from 'node:crypto';
-import { MarAgentError } from '../error.js';
-import { captureCorePromptInput } from './prompt-input.js';
-const physicalCommits = new WeakMap();
-/** Internal writer evidence survives errors after commit, without settling the operation early. */
-export function recordSessionInputCommit(entry, outcome) {
-    const previous = physicalCommits.get(entry);
-    const committed = {
-        ...previous,
-        ...outcome,
-        changed: !!previous?.changed || outcome.changed,
-        modelChanged: !!previous?.modelChanged || (outcome.modelChanged ?? outcome.changed)
-    };
-    physicalCommits.set(entry, committed);
-    entry.receipt = {
-        ...entry.receipt,
-        changed: committed.changed,
-        ...(committed.recordId === undefined ? {} : { recordId: committed.recordId }),
-        ...(committed.executionId === undefined ? {} : { executionId: committed.executionId })
-    };
-}
-/** One Session FIFO shared by native writes and the existing parent mailbox. No model loop. */
-export class SessionInputCoordinator {
-    diagnose;
-    #pending = [];
-    #records = [];
-    #current = new AsyncLocalStorage();
-    #sequence = 0;
-    #closed = false;
-    #draining;
-    #settled = new Map();
-    constructor(diagnose = () => { }) {
-        this.diagnose = diagnose;
-    }
-    get hasPending() {
-        return this.#pending.length > 0;
-    }
-    get boundarySize() {
-        return this.#pending.length;
-    }
-    get hasIdleBarrier() {
-        return this.#pending.some((entry) => entry.receipt.status !== 'cancelled' &&
-            !entry.source.signal.aborted &&
-            entry.request.kind === 'submit' &&
-            entry.request.input.delivery === 'idle');
-    }
-    restoreSteer(recordId, text, source) {
-        const index = this.#pending.findIndex((entry) => entry.nativeSteer?.recordId === recordId);
-        const previous = this.#pending[index];
-        if (previous &&
-            !previous.source.signal.aborted &&
-            !['cancelled', 'failed'].includes(previous.receipt.status))
-            return;
-        const entry = this.#record({ kind: 'submit', input: { text } }, source, (request, call, next) => next(request, call), 'accepted');
-        entry.nativeSteer = { recordId, ready: Promise.resolve() };
-        if (index >= 0)
-            this.#pending[index] = entry;
-        else
-            this.#pending.unshift(entry);
-    }
-    get hasBoundaryPending() {
-        const head = this.#pending.find((entry) => entry.receipt.status !== 'cancelled' && !entry.source.signal.aborted);
-        return !!head && (head.request.kind !== 'submit' || head.request.input.delivery !== 'idle');
-    }
-    get executing() {
-        return this.#current.getStore()?.receipt.status === 'in-progress';
-    }
-    get hasBoundaryCompactPending() {
-        for (const entry of this.#pending) {
-            if (entry.receipt.status === 'cancelled' || entry.source.signal.aborted)
-                continue;
-            if (entry.request.kind === 'submit' && entry.request.input.delivery === 'idle')
-                return false;
-            if (entry.request.kind === 'compact')
-                return true;
-        }
-        return false;
-    }
-    currentCompact() {
-        const entry = this.#current.getStore();
-        return entry?.request.kind === 'compact' && entry.receipt.status === 'in-progress'
-            ? Object.freeze({ ...entry.receipt })
-            : undefined;
-    }
-    inspect() {
-        return this.#records.map((entry) => Object.freeze({ ...entry.receipt }));
-    }
-    async performAppend(input, call, action, leaf) {
-        const entry = this.#record({ kind: 'append', input }, call, action, 'accepted');
-        await this.#execute(entry, call, leaf);
-        return Object.freeze({ ...entry.receipt });
-    }
-    /** SDK manual/automatic compaction shares the same active receipt as queued compaction. */
-    recordCompactCommit(outcome) {
-        const entry = this.#current.getStore();
-        if (!entry || entry.request.kind !== 'compact')
-            throw new MarAgentError('MAR_AGENT_SESSION_INPUT_INVALID', 'No active compaction owns this commit.');
-        recordSessionInputCommit(entry, outcome);
-    }
-    async performCompact(input, call, action) {
-        const existing = this.currentCompact() ? this.#current.getStore() : undefined;
-        const entry = existing ??
-            this.accept({ kind: 'compact', input }, call, (request, effective, next) => next(request, effective), 'queued');
-        if (!existing) {
-            this.#pending.splice(this.#pending.indexOf(entry), 1);
-            entry.receipt = {
-                ...entry.receipt,
-                status: 'in-progress',
-                ...(call.executionId ? { executionId: call.executionId } : {})
-            };
-        }
-        const commit = (outcome) => {
-            entry.receipt = {
-                ...entry.receipt,
-                changed: !!entry.receipt.changed || outcome.changed,
-                ...(outcome.executionId ? { executionId: outcome.executionId } : {})
-            };
-        };
-        try {
-            const outcome = await this.#current.run(entry, () => action(commit));
-            if (!existing)
-                this.#finish(entry, 'completed', {
-                    ...outcome,
-                    changed: !!entry.receipt.changed || outcome.changed
-                });
-            return outcome;
-        }
-        catch (error) {
-            if (!existing)
-                this.#finish(entry, call.signal.aborted ? 'cancelled' : 'failed', undefined, error instanceof MarAgentError ? error.code : 'MAR_AGENT_SESSION_INPUT_FAILED');
-            throw error;
-        }
-        finally {
-            if (!existing)
-                physicalCommits.delete(entry);
-        }
-    }
-    accept(request, source, action, status, parentMessage) {
-        const entry = this.#record(request, source, action, status, parentMessage);
-        this.#pending.push(entry);
-        return entry;
-    }
-    handled(input, call, value) {
-        const entry = this.#record({ kind: 'submit', input }, call, (request, effective, next) => next(request, effective), 'accepted');
-        this.#finish(entry, 'handled', { changed: false });
-        if (value !== undefined)
-            entry.receipt = { ...entry.receipt, handledValue: value };
-        return Object.freeze({ ...entry.receipt });
-    }
-    #record(request, source, action, status, parentMessage) {
-        if (this.#closed)
-            throw new MarAgentError('MAR_AGENT_SESSION_INPUT_CLOSED', 'Session input coordinator is closed.');
-        source.signal.throwIfAborted();
-        validateCoreSessionRequest(request);
-        let complete;
-        let started;
-        const entry = {
-            request: structuredClone(request),
-            source,
-            action,
-            receipt: {
-                operationId: source.operationId || randomUUID(),
-                sequence: ++this.#sequence,
-                kind: request.kind,
-                status,
-                ...(source.ownerInstanceId ? { ownerInstanceId: source.ownerInstanceId } : {}),
-                ...(source.extensionId ? { extensionId: source.extensionId } : {}),
-                ...(source.parentOperationId ? { parentOperationId: source.parentOperationId } : {})
-            },
-            ...(parentMessage === undefined ? {} : { parentMessage }),
-            started: new Promise((resolve) => {
-                started = resolve;
-            }),
-            start: () => started(),
-            terminal: new Promise((resolve) => {
-                complete = resolve;
-            }),
-            complete: () => {
-                source.signal.removeEventListener('abort', abort);
-                started();
-                complete();
-            }
-        };
-        const abort = () => {
-            if (entry.receipt.status === 'queued' || entry.receipt.status === 'accepted')
-                this.#finish(entry, 'cancelled');
-        };
-        source.signal.addEventListener('abort', abort, { once: true });
-        this.#records.push(entry);
-        this.#trim();
-        return entry;
-    }
-    drain(leaf, execution, limit = Number.POSITIVE_INFINITY) {
-        if (this.#draining && (!this.executing || !execution?.restoring))
-            return this.executing ? Promise.resolve(false) : this.#draining;
-        const drain = async () => {
-            let changed = false;
-            let consumed = 0;
-            while (this.#pending.length && consumed++ < limit) {
-                const head = this.#pending[0];
-                // Accepted guidance is never permission to launch a new idle execution.
-                if (!execution && head.nativeSteer) {
-                    this.#pending.shift();
-                    this.#finish(head, 'cancelled');
-                    continue;
-                }
-                // An idle prompt is a new Turn, not a mailbox delivery into the active Turn.
-                // Preserve the single FIFO: entries behind it cannot overtake it.
-                if (execution &&
-                    head.request.kind === 'submit' &&
-                    head.request.input.delivery === 'idle' &&
-                    !head.source.signal.aborted &&
-                    head.receipt.status !== 'cancelled')
-                    break;
-                const entry = this.#pending.shift();
-                if (entry.receipt.status === 'cancelled' || entry.source.signal.aborted) {
-                    this.#finish(entry, 'cancelled');
-                    continue;
-                }
-                const { executionId: _oldExecution, turnId: _oldTurn, ...identity } = entry.source;
-                const call = Object.freeze({
-                    ...identity,
-                    signal: execution
-                        ? AbortSignal.any([entry.source.signal, execution.signal])
-                        : entry.source.signal,
-                    ...(execution ? { executionId: execution.executionId, turnId: execution.turnId } : {})
-                });
-                const executing = this.#execute(entry, call, leaf);
-                if (execution && entry.request.kind === 'compact' && entry.request.input.async) {
-                    // Keep the receipt in progress while the main loop reaches adoption checkpoints.
-                    void executing.catch(() => undefined);
-                    await Promise.race([entry.started, executing]);
-                    continue;
-                }
-                const applied = await executing;
-                changed ||= applied;
-            }
-            return changed;
-        };
-        if (this.#draining)
-            return drain();
-        this.#draining = drain().finally(() => {
-            this.#draining = undefined;
-        });
-        return this.#draining;
-    }
-    async #execute(entry, call, leaf) {
-        entry.receipt = {
-            ...entry.receipt,
-            status: 'in-progress',
-            ...(call.executionId ? { executionId: call.executionId } : {})
-        };
-        let changed = false;
-        let effects = 0;
-        let committed;
-        try {
-            if (entry.nativeSteer) {
-                await entry.nativeSteer.ready;
-                call.signal.throwIfAborted();
-                if (!entry.nativeSteer.recordId) {
-                    this.#finish(entry, 'handled', { changed: false });
-                    return false;
-                }
-            }
-            const outcome = await this.#current.run(entry, () => entry.action(entry.request, call, async (request, effective) => {
-                validateCoreSessionRequest(request);
-                effective.signal.throwIfAborted();
-                const returned = await leaf(entry, request, effective);
-                const outcome = physicalCommits.get(entry) ?? returned;
-                effects++;
-                committed = { ...outcome, changed: !!committed?.changed || outcome.changed };
-                changed ||= outcome.modelChanged ?? outcome.changed;
-                return outcome;
-            }));
-            const physical = physicalCommits.get(entry);
-            if (physical) {
-                committed = physical;
-                changed ||= physical.modelChanged ?? physical.changed;
-            }
-            else if (!effects)
-                changed ||= outcome.modelChanged ?? outcome.changed;
-            this.#finish(entry, (committed ?? outcome).handled && !committed?.changed
-                ? 'handled'
-                : effects || physical
-                    ? entry.request.kind === 'submit'
-                        ? 'committed'
-                        : entry.request.kind === 'append'
-                            ? 'committed'
-                            : 'completed'
-                    : 'handled', committed ?? outcome);
-        }
-        catch (error) {
-            committed = physicalCommits.get(entry) ?? committed;
-            changed ||= (committed?.modelChanged ?? committed?.changed) || !!entry.receipt.changed;
-            this.#finish(entry, call.signal.aborted ? 'cancelled' : 'failed', committed, error instanceof MarAgentError ? error.code : 'MAR_AGENT_SESSION_INPUT_FAILED');
-            if (entry.nativeSteer?.recordId)
-                throw error;
-        }
-        finally {
-            physicalCommits.delete(entry);
-        }
-        return changed;
-    }
-    async idle() {
-        await this.#draining;
-        await Promise.all(this.#records
-            .filter((entry) => entry.receipt.status === 'in-progress')
-            .map((entry) => entry.terminal));
-    }
-    async retire(instanceId) {
-        if (!instanceId)
-            this.#closed = true;
-        const owned = this.#records.filter((entry) => !instanceId || entry.source.ownerInstanceId === instanceId);
-        for (const entry of owned)
-            if (entry.receipt.status === 'queued' || entry.receipt.status === 'accepted')
-                this.#finish(entry, 'cancelled');
-        await Promise.all(owned.filter((entry) => entry.receipt.status === 'in-progress').map((entry) => entry.terminal));
-    }
-    startExecution(entry, executionId) {
-        entry.receipt = { ...entry.receipt, executionId };
-        entry.start();
-    }
-    settleExecution(executionId, status) {
-        this.#settled.set(executionId, status);
-        if (this.#settled.size > 200)
-            this.#settled.delete(this.#settled.keys().next().value);
-        for (const entry of this.#records)
-            if (entry.request.kind === 'submit' &&
-                entry.receipt.executionId === executionId &&
-                entry.receipt.status === 'committed')
-                entry.receipt = { ...entry.receipt, status };
-        this.#trim();
-    }
-    #finish(entry, status, outcome, errorCode) {
-        entry.receipt = {
-            ...entry.receipt,
-            status,
-            ...(outcome
-                ? {
-                    changed: outcome.changed,
-                    ...(outcome.recordId === undefined ? {} : { recordId: outcome.recordId }),
-                    ...(outcome.executionId ? { executionId: outcome.executionId } : {})
-                }
-                : {}),
-            ...(errorCode ? { errorCode } : {})
-        };
-        if (status === 'committed' && entry.request.kind === 'submit' && entry.receipt.executionId) {
-            const settled = this.#settled.get(entry.receipt.executionId);
-            if (settled)
-                entry.receipt = { ...entry.receipt, status: settled };
-        }
-        entry.complete();
-        if (status === 'failed')
-            this.diagnose(Object.freeze({ ...entry.receipt }));
-        this.#trim();
-    }
-    #trim() {
-        while (this.#records.length > 200) {
-            const index = this.#records.findIndex((entry) => !['queued', 'accepted', 'in-progress'].includes(entry.receipt.status) &&
-                !(entry.receipt.status === 'committed' && entry.request.kind === 'submit'));
-            if (index === -1)
-                break;
-            this.#records.splice(index, 1);
-        }
-    }
-}
-export function validateCoreSessionRequest(request) {
-    if (request?.kind === 'submit')
-        captureCorePromptInput(request.input);
-    if (!request ||
-        !request.input ||
-        !['append', 'submit', 'compact'].includes(request.kind) ||
-        (request.kind === 'append' &&
-            (typeof request.input.content !== 'string' ||
-                'agentId' in request.input ||
-                (request.input.delivery !== undefined &&
-                    request.input.delivery !== 'boundary' &&
-                    request.input.delivery !== 'immediate') ||
-                (request.input.visibility !== undefined &&
-                    request.input.visibility !== 'model' &&
-                    request.input.visibility !== 'transcript') ||
-                (request.input.textBlocks !== undefined &&
-                    (!Array.isArray(request.input.textBlocks) ||
-                        !Array.from(request.input.textBlocks).every((block) => block && typeof block.text === 'string') ||
-                        request.input.textBlocks.map((block) => block.text).join('') !==
-                            request.input.content)) ||
-                (request.input.attribution !== undefined &&
-                    typeof request.input.attribution !== 'string'))) ||
-        (request.kind === 'submit' &&
-            (typeof request.input.text !== 'string' ||
-                (!request.input.text.trim() && request.input.modelText === undefined) ||
-                (request.input.delivery !== undefined &&
-                    request.input.delivery !== 'boundary' &&
-                    request.input.delivery !== 'idle') ||
-                (request.input.waitFor !== undefined &&
-                    request.input.waitFor !== 'admission' &&
-                    request.input.waitFor !== 'start' &&
-                    request.input.waitFor !== 'commit') ||
-                (request.input.modelText !== undefined && typeof request.input.modelText !== 'string') ||
-                (request.input.context !== undefined &&
-                    (!Array.isArray(request.input.context) ||
-                        !request.input.context.every((text) => typeof text === 'string'))) ||
-                (request.input.provenance !== undefined && typeof request.input.provenance !== 'string') ||
-                (request.input.modelAttribution !== undefined &&
-                    request.input.modelAttribution !== 'none'))) ||
-        (request.kind === 'compact' &&
-            ((request.input.focus !== undefined && typeof request.input.focus !== 'string') ||
-                (request.input.async !== undefined && typeof request.input.async !== 'boolean'))))
-        throw new MarAgentError('MAR_AGENT_SESSION_INPUT_INVALID', 'Session input is invalid.');
-}

package/dist/agent-core/extensions/session-messages.d.ts

@@ -1,41 +0,0 @@
-import type { ModelMessage } from '../model/contracts.js';
-import type { CoreModelMessage } from './model-request.js';
-export interface CoreSessionMessagesInput {
-    readonly view?: 'model' | 'conversation' | 'request';
-    readonly agentId?: string;
-    readonly includeImages?: boolean;
-    readonly cursor?: string;
-    readonly limit?: number;
-}
-/** Read-only persisted context, not additional writable model-request fields. */
-export type CoreSessionMessage = Extract<CoreModelMessage, {
-    readonly role: 'opaque';
-}> | (Exclude<CoreModelMessage, {
-    readonly role: 'opaque';
-}> & {
-    readonly contextKind?: 'environment';
-    readonly inputMode?: ModelMessage['inputMode'];
-    readonly calls?: ModelMessage['calls'];
-    readonly observations?: ModelMessage['observations'];
-    readonly toolSearchTools?: ModelMessage['toolSearchTools'];
-    readonly toolOutcome?: {
-        readonly isError: boolean;
-        readonly result?: unknown;
-    };
-    readonly modelIsError?: boolean;
-});
-export interface CoreSessionMessages {
-    readonly messages: readonly CoreSessionMessage[];
-    readonly nextCursor?: string;
-}
-export declare function normalizeSessionMessagesInput(input: CoreSessionMessagesInput): Readonly<{
-    view: "model" | "conversation" | "request";
-    agentId: string | undefined;
-    includeImages: boolean;
-    cursor: number;
-    limit: number;
-}>;
-export declare function sessionMessagesPage(messages: readonly ModelMessage[], input: ReturnType<typeof normalizeSessionMessagesInput>, outcomes?: WeakMap<ModelMessage, {
-    readonly isError: boolean;
-    readonly result?: unknown;
-}>): CoreSessionMessages;

package/dist/agent-core/extensions/session-messages.js

@@ -1,76 +0,0 @@
-import { MarAgentError } from '../error.js';
-import { ExtensionRequestBridge } from './model-request.js';
-export function normalizeSessionMessagesInput(input) {
-    if (!input ||
-        typeof input !== 'object' ||
-        Array.isArray(input) ||
-        (input.view !== undefined &&
-            input.view !== 'model' &&
-            input.view !== 'conversation' &&
-            input.view !== 'request') ||
-        (input.agentId !== undefined && (typeof input.agentId !== 'string' || !input.agentId)) ||
-        (input.includeImages !== undefined && typeof input.includeImages !== 'boolean') ||
-        (input.limit !== undefined && typeof input.limit !== 'number') ||
-        (input.cursor !== undefined && typeof input.cursor !== 'string'))
-        throw invalidInput();
-    const cursor = input.cursor === undefined ? 0 : Number(input.cursor);
-    const limit = input.limit ?? 100;
-    if (!Number.isSafeInteger(cursor) || cursor < 0 || !Number.isSafeInteger(limit) || limit <= 0)
-        throw invalidInput();
-    return Object.freeze({
-        view: input.view ?? 'model',
-        agentId: input.agentId,
-        includeImages: input.includeImages ?? false,
-        cursor,
-        limit
-    });
-}
-export function sessionMessagesPage(messages, input, outcomes) {
-    const selected = input.view === 'conversation'
-        ? messages.filter((message) => message.role !== 'provider' &&
-            message.contextKind !== 'environment' &&
-            message.contextKind !== 'private')
-        : messages;
-    // A private non-Provider record receives the same opaque treatment as Provider context.
-    const neutral = selected.map((message) => message.contextKind === 'private' ? { role: 'provider', content: '' } : message);
-    const view = new ExtensionRequestBridge('', { system: '', messages: neutral, tools: [] }).view
-        .messages;
-    const enriched = view.map((message, index) => {
-        if (message.role === 'opaque')
-            return message;
-        const original = selected[index];
-        const { images, ...text } = message;
-        return {
-            ...text,
-            ...(input.includeImages && images !== undefined ? { images } : {}),
-            ...(original.contextKind === 'environment' ? { contextKind: 'environment' } : {}),
-            ...(original.inputMode !== undefined ? { inputMode: original.inputMode } : {}),
-            ...(original.isError === undefined ? {} : { modelIsError: original.isError }),
-            ...(outcomes?.has(original) ? { toolOutcome: structuredClone(outcomes.get(original)) } : {}),
-            ...(original.calls !== undefined ? { calls: structuredClone(original.calls) } : {}),
-            ...(original.observations !== undefined
-                ? { observations: structuredClone(original.observations) }
-                : {}),
-            ...(original.toolSearchTools !== undefined
-                ? { toolSearchTools: structuredClone(original.toolSearchTools) }
-                : {})
-        };
-    });
-    return freeze({
-        messages: enriched.slice(input.cursor, input.cursor + input.limit),
-        ...(input.cursor + input.limit < enriched.length
-            ? { nextCursor: String(input.cursor + input.limit) }
-            : {})
-    });
-}
-function invalidInput() {
-    return new MarAgentError('MAR_AGENT_SESSION_INPUT_INVALID', 'Message view, target, media selection, cursor or limit is invalid.');
-}
-function freeze(value) {
-    if (value && typeof value === 'object' && !Object.isFrozen(value)) {
-        for (const child of Object.values(value))
-            freeze(child);
-        Object.freeze(value);
-    }
-    return value;
-}

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

@@ -1,69 +0,0 @@
-import type { ToolCall, ToolExecutionResult } from '../tools/contracts.js';
-import type { CoreDomainFacts, CoreDomainOperations, CoreExtensionDiagnostic, CorePromptSection, CoreRuntimeExtension, CoreSessionExtensionContext, CoreCapabilitySnapshot } from './contracts.js';
-import { ExtensionHooks } from './hooks.js';
-import { type CorePromptPart, type CorePromptComposition } from './prompt-composition.js';
-import type { CoreModelEvent } from './model-stream.js';
-import type { ModelTextBlock } from '../model/contracts.js';
-import { ExtensionMcp } from './mcp.js';
-import { type CoreAgentsBackend } from './agents.js';
-import type { SubagentController } from '../subagent/contracts.js';
-import type { CoreHostExtensionPorts } from '../host/contracts.js';
-import { ExtensionOperations, type CoreOperationContext } from './operation.js';
-import { ExtensionResourceScope } from './resources.js';
-import { ExtensionServices } from './services.js';
-import { ExtensionTools, type CoreToolBinding, type CoreToolRef, type CoreToolInvocation, type CoreToolCheck } from './tools.js';
-import type { CoreModelsBackend } from './models.js';
-import { type CoreCheckpointBackend } from './data.js';
-import type { CoreSessionBackend } from './session-input.js';
-/** Session-local definitions and facades; SDK supplies real Host sources for each operation. */
-export declare class ExtensionSession {
-    #private;
-    readonly id: string;
-    readonly epoch: number;
-    readonly operations: ExtensionOperations;
-    readonly capabilities: CoreCapabilitySnapshot;
-    readonly diagnose: (diagnostic: CoreExtensionDiagnostic) => void;
-    readonly baseTools: (context?: CoreOperationContext) => readonly CoreToolBinding[];
-    readonly models?: CoreModelsBackend | undefined;
-    readonly checkpoint?: CoreCheckpointBackend | undefined;
-    readonly sessionBackend?: CoreSessionBackend | undefined;
-    readonly hostPorts?: CoreHostExtensionPorts | undefined;
-    readonly agentsBackend?: CoreAgentsBackend | undefined;
-    readonly allowTool: (name: string, definition?: CoreToolBinding['definition']) => boolean;
-    readonly scheduleTool: <T>(definition: CoreToolBinding['definition'], run: () => Promise<T>) => Promise<T>;
-    isEnding: boolean;
-    readonly mcp: ExtensionMcp;
-    readonly tools: ExtensionTools;
-    readonly hooks: ExtensionHooks<CoreDomainOperations, CoreDomainFacts>;
-    readonly services: ExtensionServices;
-    readonly scopes: ExtensionResourceScope[];
-    /** The SDK calls this after admission, outside the composition manager's serial lane. */
-    ready(call: CoreOperationContext): Promise<void>;
-    assertLive(): void;
-    retire(): void;
-    get hasReferences(): boolean;
-    pin(): () => void;
-    private get toolFrame();
-    withTools<T>(bindings: ReadonlyMap<string, CoreToolBinding>, schedule: <Value>(definition: CoreToolBinding['definition'], run: () => Promise<Value>) => Promise<Value>, run: () => T): T;
-    constructor(id: string, epoch: number, agentServices: ExtensionServices, operations: ExtensionOperations, capabilities: CoreCapabilitySnapshot, diagnose: (diagnostic: CoreExtensionDiagnostic) => void, baseTools?: (context?: CoreOperationContext) => readonly CoreToolBinding[], models?: CoreModelsBackend | undefined, checkpoint?: CoreCheckpointBackend | undefined, sessionBackend?: CoreSessionBackend | undefined, hostPorts?: CoreHostExtensionPorts | undefined, agentsBackend?: CoreAgentsBackend | undefined, allowTool?: (name: string, definition?: CoreToolBinding['definition']) => boolean, scheduleTool?: <T>(definition: CoreToolBinding['definition'], run: () => Promise<T>) => Promise<T>);
-    context(extension: CoreRuntimeExtension, scope: ExtensionResourceScope): CoreSessionExtensionContext;
-    toolRef(binding: CoreToolBinding): CoreToolRef;
-    capture(context?: CoreOperationContext, includeStaged?: boolean, base?: readonly CoreToolBinding[]): ReadonlyMap<string, CoreToolBinding>;
-    sections(): readonly CorePromptSection[];
-    bindAgents(controller: SubagentController): SubagentController;
-    modelEvent(event: CoreModelEvent, call: CoreOperationContext): Promise<CoreModelEvent | undefined>;
-    composeSections(input: CorePromptComposition, call: CoreOperationContext): Promise<CorePromptComposition>;
-    compose(system: string | CorePromptComposition, call: CoreOperationContext): Promise<string>;
-    composeModelSystem(system: string | CorePromptComposition, call: CoreOperationContext): Promise<{
-        text: string;
-        blocks?: readonly ModelTextBlock[];
-        sections?: readonly CorePromptPart[];
-    }>;
-    invoke(call: ToolCall, context: CoreOperationContext, snapshot?: ReadonlyMap<string, CoreToolBinding>): Promise<ToolExecutionResult>;
-    private assertToolAvailable;
-    private toolAttempt;
-    check(call: CoreToolInvocation, context: CoreOperationContext): CoreToolCheck;
-    invocationSnapshot(call: CoreToolInvocation, context: CoreOperationContext): ReadonlyMap<string, CoreToolBinding>;
-    activate(): void;
-    dispose(): Promise<void>;
-}