@myagentroam/agent 0.9.159 → 0.9.160

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

@@ -0,0 +1,351 @@
+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 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';
+    }
+    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)
+            return this.executing ? Promise.resolve(false) : this.#draining;
+        this.#draining = (async () => {
+            let changed = false;
+            let consumed = 0;
+            while (this.#pending.length && consumed++ < limit) {
+                const head = this.#pending[0];
+                // 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 applied = await this.#execute(entry, call, leaf);
+                changed ||= applied;
+            }
+            return changed;
+        })().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 {
+            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');
+        }
+        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'))
+        throw new MarAgentError('MAR_AGENT_SESSION_INPUT_INVALID', 'Session input is invalid.');
+}

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

@@ -0,0 +1,41 @@
+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" | "request" | "conversation";
+    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

@@ -0,0 +1,76 @@
+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

@@ -0,0 +1,68 @@
+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 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[];
+    }>;
+    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>;
+}