@try-works/dsh-tool-mode 0.0.0-stage → 0.5.44

package/node_modules/@try-works/tool-mode-extension-sdk/lib/licensing.d.ts

@@ -0,0 +1,221 @@
+/**
+ * Licensing, attribution and permission records (LIC-01..LIC-04).
+ *
+ * Two rules here exist to stop a technical decision standing in for a legal one.
+ *
+ * - **A config boolean is not a licence grant** (LIC-03). A person records the
+ *   permission basis, the scope it covers, and their name. Turning on a setting
+ *   cannot produce that record, so the type has no way to express "someone ticked a
+ *   box".
+ * - **Do not describe telemetry-bearing software as network-free** (LIC-04). An
+ *   implementation that must report usage telemetry is INELIGIBLE for a strict
+ *   no-network deployment, and the ineligibility is reported rather than resolved by
+ *   quietly suppressing the telemetry — which would breach the licence and misdescribe
+ *   the product at the same time.
+ *
+ * LIC-01's other half is that the layers are tracked INDEPENDENTLY: an adapter's MIT
+ * licence says nothing about the weights it loads, and a missing layer is a gap rather
+ * than a default.
+ *
+ * @module @try-works/dsh-tool-mode/licensing
+ */
+/** The layers whose licences are tracked separately (LIC-01). */
+export type LicenseLayer = 
+/** The extension's own source. */
+'code'
+/** The inference engine or runtime. */
+ | 'engine'
+/** The model weights. */
+ | 'weights'
+/** Scripts or tools that converted the weights. */
+ | 'conversion-artifacts'
+/** A vendor SDK the extension depends on. */
+ | 'sdk';
+/** Every layer, so a missing one is detectable rather than absent. */
+export declare const LICENSE_LAYERS: readonly LicenseLayer[];
+/**
+ * Whether redistribution of a layer is permitted.
+ *
+ * `unclear` is a first-class value, because treating an unexamined licence as
+ * permitted is how a package ships bytes it had no right to.
+ */
+export type Redistribution = 'permitted' | 'not-permitted' | 'unclear';
+/** One layer's licence. */
+export interface LayerLicense {
+    readonly layer: LicenseLayer;
+    /** The licence name, e.g. `MIT` or `LicenseRef-DAL-Source-Available-1.0`. */
+    readonly name: string;
+    /** Where the terms live, so a reviewer can read them rather than trust a label. */
+    readonly url: string;
+    /** Whether the licence requires attribution in the product or its notices. */
+    readonly attributionRequired: boolean;
+    /** The exact notice text, when attribution is required. */
+    readonly attributionText?: string;
+    /**
+     * Whether the licence is OSI-approved open source.
+     *
+     * LIC-02 is explicit that Desert Ant's licence is source-available and NOT open
+     * source, so this is recorded per layer rather than inferred from the presence of a
+     * licence file.
+     */
+    readonly openSource: boolean;
+    /** Whether these bytes may be redistributed inside a package. */
+    readonly redistribution: Redistribution;
+    /** Obligations a deployer must meet, stated rather than implied. */
+    readonly obligations: readonly string[];
+}
+/**
+ * The Desert Ant Labs licence, as recorded from the vendor's own terms (LIC-02).
+ *
+ * Named as a constant because getting it wrong in one place is how a wrong belief
+ * spreads: this is source-available, NOT open source, and it forbids redistributing
+ * the models or SDKs as a standalone product.
+ */
+export declare function desertAntLabsLicense(layer: LicenseLayer): LayerLicense;
+/** A resolved licence record for one extension (LIC-01). */
+export interface ResolvedLicenseRecord {
+    readonly extensionId: string;
+    /** One entry per layer. A missing layer is a GAP, not a default. */
+    readonly layers: readonly LayerLicense[];
+    /** Where the notices must appear, kept with the record rather than looked up. */
+    readonly notices: readonly string[];
+}
+/**
+ * Build a licence record, reporting missing layers (LIC-01).
+ *
+ * @param extensionId - the extension.
+ * @param layers - the declared licences.
+ * @returns the record and the layers that were not declared.
+ */
+export declare function resolveLicenses(extensionId: string, layers: readonly LayerLicense[]): {
+    readonly record: ResolvedLicenseRecord;
+    readonly gaps: readonly LicenseLayer[];
+};
+/** The uses a permission basis can cover (LIC-03). */
+export type PermissionScope = 'native' | 'external-export' | 'distribution' | 'telemetry';
+/**
+ * How a permission was established (LIC-03).
+ *
+ * There is deliberately no `config-boolean` member: the requirement says a config
+ * boolean is not a licence grant, and a type that cannot express one is a stronger
+ * guarantee than a comment saying not to use one.
+ */
+export type PermissionBasis = 
+/** The vendor answered the question in writing. */
+{
+    readonly kind: 'vendor-clarification';
+    readonly reference: string;
+}
+/** Qualified review, e.g. counsel, decided the boundary. */
+ | {
+    readonly kind: 'qualified-review';
+    readonly reference: string;
+}
+/** The vendor's own published terms address it directly. */
+ | {
+    readonly kind: 'published-terms';
+    readonly url: string;
+}
+/** A commercial agreement covers it. */
+ | {
+    readonly kind: 'commercial-agreement';
+    readonly reference: string;
+};
+/** A human's record of one permission (LIC-03). */
+export interface PermissionRecord {
+    readonly extensionId: string;
+    readonly scope: PermissionScope;
+    readonly basis: PermissionBasis;
+    /**
+     * The responsible human.
+     *
+     * Required: an unattributed permission record cannot be reviewed or revisited, and
+     * the requirement says a RESPONSIBLE HUMAN must record it.
+     */
+    readonly recordedBy: string;
+    readonly recordedAt: string;
+    /** What the permission does NOT cover, so its limits travel with it. */
+    readonly excludes?: readonly string[];
+}
+/**
+ * Reject a permission claim that is not a human record (LIC-03).
+ *
+ * A boolean, a string or an empty object would all be "someone said yes" without a
+ * person or a reference, which is what the requirement forbids.
+ * @param value - the purported record.
+ * @returns whether it is a usable record.
+ */
+export declare function isUsablePermissionRecord(value: unknown): value is PermissionRecord;
+/**
+ * Whether a provider may be exposed over MCP (LIC-03).
+ *
+ * An unresolved EXTERNAL-EXPORT permission blocks THAT PROVIDER's export and nothing
+ * else. Blocking the whole plugin would punish every other provider for one
+ * unresolved question, which the requirement explicitly rules out.
+ * @param extensionId - the provider.
+ * @param permissions - every recorded permission.
+ * @returns the decision.
+ */
+export declare function exportDecision(extensionId: string, permissions: readonly PermissionRecord[]): {
+    readonly exportable: boolean;
+    readonly reason?: string;
+};
+/** An implementation's network behaviour, as DECLARED rather than assumed (LIC-04). */
+export interface NetworkBehaviour {
+    readonly extensionId: string;
+    /**
+     * Whether the software reports usage telemetry the licence REQUIRES.
+     *
+     * When true, suppressing it to appear network-free would breach the licence, so the
+     * implementation is ineligible for a no-network deployment instead.
+     */
+    readonly requiredTelemetry: boolean;
+    /** Whether it makes any other network call. */
+    readonly otherNetworkUse: boolean;
+    /** What the telemetry carries, so a description can be accurate. */
+    readonly telemetryContent?: readonly string[];
+}
+/** The verdict for a strict no-network deployment (LIC-04). */
+export interface NoNetworkVerdict {
+    readonly eligible: boolean;
+    /** Why not, when it is not. */
+    readonly reason?: string;
+    /** What a deployer should choose instead, rather than a bare refusal. */
+    readonly alternative?: string;
+}
+/**
+ * Decide whether an implementation is eligible for a strict no-network deployment
+ * (LIC-04).
+ *
+ * @param behaviour - the implementation's declared network behaviour.
+ * @returns the verdict, with an alternative when it is ineligible.
+ */
+export declare function noNetworkEligibility(behaviour: NetworkBehaviour): NoNetworkVerdict;
+/**
+ * How a deployment may DESCRIBE itself (LIC-04).
+ *
+ * The requirement forbids describing telemetry-bearing software as entirely
+ * network-free, so a description is derived from the declared behaviour rather than
+ * chosen by the deployer.
+ * @param behaviour - the implementation's network behaviour.
+ * @returns a description that is true of the implementation.
+ */
+export declare function describeNetwork(behaviour: NetworkBehaviour): string;
+/**
+ * Whether packaging a model grants the right to redistribute its weights (LIC-01).
+ *
+ * It does not. Packaging means an adapter plus licensed assets or ACQUISITION
+ * INSTRUCTIONS; technical availability does not imply export or redistribution
+ * permission.
+ * @param record - the licence record.
+ * @returns whether the weights may be shipped inside the package.
+ */
+export declare function mayPackageWeights(record: ResolvedLicenseRecord): boolean;
+/**
+ * Whether the notices required by a record are present in a shipped notice file.
+ * @param record - the licence record.
+ * @param noticeText - the notice file's contents.
+ * @returns the notices that are missing.
+ */
+export declare function missingNotices(record: ResolvedLicenseRecord, noticeText: string): readonly string[];
+//# sourceMappingURL=licensing.d.ts.map

package/node_modules/@try-works/tool-mode-extension-sdk/lib/licensing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"licensing.d.ts","sourceRoot":"","sources":["../src/licensing.ts"],"names":[],"mappings":"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"}

package/node_modules/@try-works/tool-mode-extension-sdk/lib/licensing.js

@@ -0,0 +1,188 @@
+/**
+ * Licensing, attribution and permission records (LIC-01..LIC-04).
+ *
+ * Two rules here exist to stop a technical decision standing in for a legal one.
+ *
+ * - **A config boolean is not a licence grant** (LIC-03). A person records the
+ *   permission basis, the scope it covers, and their name. Turning on a setting
+ *   cannot produce that record, so the type has no way to express "someone ticked a
+ *   box".
+ * - **Do not describe telemetry-bearing software as network-free** (LIC-04). An
+ *   implementation that must report usage telemetry is INELIGIBLE for a strict
+ *   no-network deployment, and the ineligibility is reported rather than resolved by
+ *   quietly suppressing the telemetry — which would breach the licence and misdescribe
+ *   the product at the same time.
+ *
+ * LIC-01's other half is that the layers are tracked INDEPENDENTLY: an adapter's MIT
+ * licence says nothing about the weights it loads, and a missing layer is a gap rather
+ * than a default.
+ *
+ * @module @try-works/dsh-tool-mode/licensing
+ */
+/** Every layer, so a missing one is detectable rather than absent. */
+export const LICENSE_LAYERS = [
+    'code', 'engine', 'weights', 'conversion-artifacts', 'sdk',
+];
+/**
+ * The Desert Ant Labs licence, as recorded from the vendor's own terms (LIC-02).
+ *
+ * Named as a constant because getting it wrong in one place is how a wrong belief
+ * spreads: this is source-available, NOT open source, and it forbids redistributing
+ * the models or SDKs as a standalone product.
+ */
+export function desertAntLabsLicense(layer) {
+    return {
+        layer,
+        name: 'Desert Ant Labs Source-Available License 1.0',
+        url: 'https://license.desertant.com/1.0',
+        attributionRequired: true,
+        attributionText: 'Powered by Desert Ant Labs',
+        // LIC-02 says this in as many words.
+        openSource: false,
+        // No redistribution or re-hosting of the models, SDKs or a hosted service.
+        redistribution: 'not-permitted',
+        obligations: [
+            'display the attribution notice with a link to Desert Ant Labs',
+            'a commercial licence is required above the per-platform, per-model active-device threshold',
+            'do not redistribute the model, SDK or a hosted service as a standalone product',
+            'do not use outputs or logs to train a competing on-device model',
+            'do not extract weights or tamper with the usage telemetry',
+        ],
+    };
+}
+/**
+ * Build a licence record, reporting missing layers (LIC-01).
+ *
+ * @param extensionId - the extension.
+ * @param layers - the declared licences.
+ * @returns the record and the layers that were not declared.
+ */
+export function resolveLicenses(extensionId, layers) {
+    const declared = new Set(layers.map(layer => layer.layer));
+    // An undeclared layer is reported rather than assumed permissive: an adapter's MIT
+    // licence says nothing about the weights it loads.
+    const gaps = LICENSE_LAYERS.filter(layer => !declared.has(layer));
+    return {
+        record: {
+            extensionId,
+            layers,
+            // Collected from every layer that requires one, so a notice is never dropped by
+            // being attached to a layer nobody reads.
+            notices: layers
+                .filter(layer => layer.attributionRequired && layer.attributionText !== undefined)
+                .map(layer => layer.attributionText),
+        },
+        gaps,
+    };
+}
+/**
+ * Reject a permission claim that is not a human record (LIC-03).
+ *
+ * A boolean, a string or an empty object would all be "someone said yes" without a
+ * person or a reference, which is what the requirement forbids.
+ * @param value - the purported record.
+ * @returns whether it is a usable record.
+ */
+export function isUsablePermissionRecord(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const candidate = value;
+    return typeof candidate.extensionId === 'string'
+        && typeof candidate.scope === 'string'
+        && typeof candidate.recordedBy === 'string' && candidate.recordedBy.length > 0
+        && typeof candidate.recordedAt === 'string'
+        && typeof candidate.basis === 'object' && candidate.basis !== null;
+}
+/**
+ * Whether a provider may be exposed over MCP (LIC-03).
+ *
+ * An unresolved EXTERNAL-EXPORT permission blocks THAT PROVIDER's export and nothing
+ * else. Blocking the whole plugin would punish every other provider for one
+ * unresolved question, which the requirement explicitly rules out.
+ * @param extensionId - the provider.
+ * @param permissions - every recorded permission.
+ * @returns the decision.
+ */
+export function exportDecision(extensionId, permissions) {
+    const relevant = permissions.find(record => record.extensionId === extensionId && record.scope === 'external-export');
+    if (relevant === undefined) {
+        return {
+            exportable: false,
+            reason: `no external-export permission is recorded for ${extensionId}; `
+                + 'this blocks that provider only, not the other providers',
+        };
+    }
+    if (!isUsablePermissionRecord(relevant)) {
+        return { exportable: false, reason: `the external-export record for ${extensionId} is not a usable record` };
+    }
+    return { exportable: true };
+}
+/**
+ * Decide whether an implementation is eligible for a strict no-network deployment
+ * (LIC-04).
+ *
+ * @param behaviour - the implementation's declared network behaviour.
+ * @returns the verdict, with an alternative when it is ineligible.
+ */
+export function noNetworkEligibility(behaviour) {
+    if (behaviour.requiredTelemetry) {
+        // The honest outcome. Suppressing the telemetry would breach the licence AND
+        // misdescribe the software, so neither is offered.
+        return {
+            eligible: false,
+            reason: 'this implementation must report usage telemetry, so it cannot be described or deployed as network-free',
+            alternative: 'choose an implementation whose licence requires no telemetry, or run a profile that permits its telemetry',
+        };
+    }
+    if (behaviour.otherNetworkUse) {
+        return {
+            eligible: false,
+            reason: 'this implementation makes network calls unrelated to telemetry',
+            alternative: 'choose a local-only implementation, or run a profile that permits those destinations',
+        };
+    }
+    return { eligible: true };
+}
+/**
+ * How a deployment may DESCRIBE itself (LIC-04).
+ *
+ * The requirement forbids describing telemetry-bearing software as entirely
+ * network-free, so a description is derived from the declared behaviour rather than
+ * chosen by the deployer.
+ * @param behaviour - the implementation's network behaviour.
+ * @returns a description that is true of the implementation.
+ */
+export function describeNetwork(behaviour) {
+    if (behaviour.requiredTelemetry) {
+        const content = behaviour.telemetryContent ?? [];
+        return 'reports usage telemetry'
+            + (content.length > 0 ? ` (${content.join(', ')})` : '')
+            + '; it is not network-free';
+    }
+    return behaviour.otherNetworkUse ? 'makes network calls' : 'runs without network access';
+}
+/**
+ * Whether packaging a model grants the right to redistribute its weights (LIC-01).
+ *
+ * It does not. Packaging means an adapter plus licensed assets or ACQUISITION
+ * INSTRUCTIONS; technical availability does not imply export or redistribution
+ * permission.
+ * @param record - the licence record.
+ * @returns whether the weights may be shipped inside the package.
+ */
+export function mayPackageWeights(record) {
+    const weights = record.layers.find(layer => layer.layer === 'weights');
+    // `unclear` is not permission: treating an unexamined licence as permitted is how a
+    // package ships bytes it had no right to.
+    return weights?.redistribution === 'permitted';
+}
+/**
+ * Whether the notices required by a record are present in a shipped notice file.
+ * @param record - the licence record.
+ * @param noticeText - the notice file's contents.
+ * @returns the notices that are missing.
+ */
+export function missingNotices(record, noticeText) {
+    return record.notices.filter(notice => !noticeText.includes(notice));
+}
+//# sourceMappingURL=licensing.js.map

package/node_modules/@try-works/tool-mode-extension-sdk/lib/load.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Loading an extension through its public entry (EXT-17, EXT-19).
+ *
+ * The host reaches an extension ONLY through `./tool-mode` and the interfaces in
+ * `runtime.ts`. It never imports a file inside the package, never reaches into an
+ * adapter registry the host owns, and never special-cases a model name. That is
+ * what makes BASE-09's "no private built-in adapter path" true rather than
+ * aspirational: a first-party package and a third-party package are loaded by the
+ * same function, so there is no second route that only first-party code can take.
+ *
+ * Loading is split from activation deliberately. `loadExtensionModule` validates
+ * the SHAPE of the export; `activateExtension` calls `create()`. EXT-19 requires
+ * `create()` to be lightweight, and keeping the two calls separate is what lets a
+ * host reject a malformed package without ever running its code.
+ *
+ * @module @try-works/tool-mode-extension-sdk/load
+ */
+import { type ExtensionContextV1, type ExtensionInstanceV1, type ToolModeExtensionV1 } from './runtime.ts';
+import type { ExtensionDiscovery } from './discovery.ts';
+/** The public entry subpath every module extension declares. */
+export declare const EXTENSION_ENTRY = "./tool-mode";
+/**
+ * Resolve the absolute path of an installed extension's public entry.
+ *
+ * The path comes from the package's own `exports` map rather than from a
+ * convention, so the host reads the same declaration a Node resolver would and a
+ * package that points its entry elsewhere keeps working.
+ * @param discovery - the package discovery result.
+ * @returns the absolute entry path.
+ * @throws ManagementError when the package declares no importable `./tool-mode` entry.
+ */
+export declare function resolveExtensionEntry(discovery: ExtensionDiscovery): string;
+/**
+ * Import an extension's public entry and validate its shape.
+ *
+ * Importing runs the package's module top level, which is why EXT-19 constrains it
+ * to be lightweight, and why the shape is checked BEFORE `create()` is called.
+ * @param entryPath - absolute path of the module to import.
+ * @returns the validated extension.
+ * @throws ManagementError when the import fails or the export is malformed.
+ */
+export declare function loadExtensionModule(entryPath: string): Promise<ToolModeExtensionV1>;
+/**
+ * Activate a loaded extension.
+ *
+ * @param extension - the validated extension.
+ * @param context - the host-issued context.
+ * @returns the activated instance.
+ * @throws ManagementError when `create()` fails or returns no usable instance.
+ */
+export declare function activateExtension(extension: ToolModeExtensionV1, context: ExtensionContextV1): Promise<ExtensionInstanceV1>;
+//# sourceMappingURL=load.d.ts.map

package/node_modules/@try-works/tool-mode-extension-sdk/lib/load.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../src/load.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,OAAO,EAEL,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,EACzB,MAAM,cAAc,CAAA;AACrB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAExD,gEAAgE;AAChE,eAAO,MAAM,eAAe,gBAAgB,CAAA;AAE5C;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,kBAAkB,GAAG,MAAM,CAU3E;AAED;;;;;;;;GAQG;AACH,wBAAsB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAuCzF;AAED;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,mBAAmB,EAC9B,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,mBAAmB,CAAC,CA+B9B"}

package/node_modules/@try-works/tool-mode-extension-sdk/lib/load.js

@@ -0,0 +1,102 @@
+/**
+ * Loading an extension through its public entry (EXT-17, EXT-19).
+ *
+ * The host reaches an extension ONLY through `./tool-mode` and the interfaces in
+ * `runtime.ts`. It never imports a file inside the package, never reaches into an
+ * adapter registry the host owns, and never special-cases a model name. That is
+ * what makes BASE-09's "no private built-in adapter path" true rather than
+ * aspirational: a first-party package and a third-party package are loaded by the
+ * same function, so there is no second route that only first-party code can take.
+ *
+ * Loading is split from activation deliberately. `loadExtensionModule` validates
+ * the SHAPE of the export; `activateExtension` calls `create()`. EXT-19 requires
+ * `create()` to be lightweight, and keeping the two calls separate is what lets a
+ * host reject a malformed package without ever running its code.
+ *
+ * @module @try-works/tool-mode-extension-sdk/load
+ */
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { pathToFileURL } from 'node:url';
+import { ManagementError } from "./errors.js";
+import { EXTENSION_API_VERSION, } from "./runtime.js";
+/** The public entry subpath every module extension declares. */
+export const EXTENSION_ENTRY = './tool-mode';
+/**
+ * Resolve the absolute path of an installed extension's public entry.
+ *
+ * The path comes from the package's own `exports` map rather than from a
+ * convention, so the host reads the same declaration a Node resolver would and a
+ * package that points its entry elsewhere keeps working.
+ * @param discovery - the package discovery result.
+ * @returns the absolute entry path.
+ * @throws ManagementError when the package declares no importable `./tool-mode` entry.
+ */
+export function resolveExtensionEntry(discovery) {
+    if (discovery.entryPath === undefined) {
+        throw new ManagementError('INVALID_EXTENSION', 'activate', `the package declares no importable ${EXTENSION_ENTRY} export, so it has no module entry`, `Declare "${EXTENSION_ENTRY}": "./<file>.js" in package.json exports; the host does not guess entry points.`);
+    }
+    return discovery.entryPath;
+}
+/**
+ * Import an extension's public entry and validate its shape.
+ *
+ * Importing runs the package's module top level, which is why EXT-19 constrains it
+ * to be lightweight, and why the shape is checked BEFORE `create()` is called.
+ * @param entryPath - absolute path of the module to import.
+ * @returns the validated extension.
+ * @throws ManagementError when the import fails or the export is malformed.
+ */
+export async function loadExtensionModule(entryPath) {
+    let module;
+    try {
+        module = await import(__rewriteRelativeImportExtension(pathToFileURL(entryPath).href));
+    }
+    catch (error) {
+        throw new ManagementError('INVALID_EXTENSION', 'activate', `the extension entry could not be imported: ${error instanceof Error ? error.message : String(error)}`, 'Confirm the entry is a valid ES module and that its dependencies are installed.');
+    }
+    const candidate = (module.default ?? module.extension);
+    if (candidate === undefined || typeof candidate !== 'object') {
+        throw new ManagementError('INVALID_EXTENSION', 'activate', 'the extension entry default-exports nothing usable', `Default-export an object with apiVersion ${EXTENSION_API_VERSION} and create(context).`);
+    }
+    if (candidate.apiVersion !== EXTENSION_API_VERSION) {
+        throw new ManagementError('INCOMPATIBLE_PROTOCOL', 'activate', `the extension declares apiVersion ${String(candidate.apiVersion)}, but this host implements ${EXTENSION_API_VERSION}`, 'Install a build of the extension for this API major, or upgrade the host.');
+    }
+    if (typeof candidate.create !== 'function') {
+        throw new ManagementError('INVALID_EXTENSION', 'activate', 'the extension entry default-exports no create(context) function', 'Implement create() on the default export.');
+    }
+    return candidate;
+}
+/**
+ * Activate a loaded extension.
+ *
+ * @param extension - the validated extension.
+ * @param context - the host-issued context.
+ * @returns the activated instance.
+ * @throws ManagementError when `create()` fails or returns no usable instance.
+ */
+export async function activateExtension(extension, context) {
+    let instance;
+    try {
+        instance = await extension.create(context);
+    }
+    catch (error) {
+        throw new ManagementError('EXTENSION_FAULT', 'activate', `the extension failed to activate: ${error instanceof Error ? error.message : String(error)}`, 'Check the extension diagnostics; the package was not published.');
+    }
+    if (instance === null || typeof instance !== 'object' || typeof instance.createProvider !== 'function') {
+        throw new ManagementError('INVALID_EXTENSION', 'activate', 'the extension returned no createProvider(modelId, configuration)', 'Return an instance implementing the ExtensionInstanceV1 contract.');
+    }
+    if (typeof instance.dispose !== 'function') {
+        // A missing dispose is worse than a missing feature: the host would have no
+        // way to release the instance, so deactivation could never fully stop.
+        throw new ManagementError('INVALID_EXTENSION', 'activate', 'the extension instance implements no dispose(reason)', 'Implement dispose() so the host can release the instance on deactivation.');
+    }
+    return instance;
+}
+//# sourceMappingURL=load.js.map