@try-works/dsh-model-as-tool 0.1.2 → 0.3.6

package/lib/extension-registrar.d.ts

@@ -0,0 +1,100 @@
+/**
+ * The host-side contribution registrar (EXT-21..EXT-30, ARCH-06).
+ *
+ * This is the bridge that was MISSING: `ExtensionLifecycle` could install, activate and
+ * publish contributions, and the SDK was fully tested doing so — but the HOST never
+ * mounted the lifecycle, so **no extension's tools ever reached the DSH registry**. An
+ * extension could be installed, activated and reported `observedActivation: 'active'` with
+ * its tool listed, and a caller still could not invoke it.
+ *
+ * The registrar is the other half: it turns a published contribution into a real registry
+ * entry, and withdraws it again on deactivation.
+ *
+ * Four rules, each of which has been a real defect somewhere:
+ *
+ * - **Handles are opaque and unguessable.** An extension must not be able to construct a
+ *   handle and withdraw a contribution it does not own. A sequence number is guessable;
+ *   the handle is a branded object the caller never sees the inside of.
+ * - **Withdrawing is idempotent.** A deactivation that runs twice must not throw the
+ *   second time, and must not withdraw a DIFFERENT contribution that reused the handle.
+ * - **A name collision is refused, not silently overwritten.** Two extensions contributing
+ *   `transcribe` is a configuration error; letting the second win would silently change
+ *   what an existing caller reaches.
+ * - **The host stamps identity.** The contribution carries an extension id, but the HOST
+ *   decides what that means; a package claiming another's id is refused rather than
+ *   trusted.
+ *
+ * @module @try-works/dsh-model-as-tool/extension-registrar
+ */
+import type { Contribution, ContributionRegistrar } from '@try-works/tool-mode-extension-sdk';
+/** One thing the registrar can put into the DSH registry. */
+export interface RegistrableTool {
+    /** The caller-facing tool name. */
+    readonly name: string;
+    /** The extension that owns it, as the HOST resolved it. */
+    readonly ownerExtension: string;
+    /** The contract it implements, when it declares one. */
+    readonly contractId?: string;
+}
+/** What the registrar needs from the host registry. */
+export interface HostRegistrySurface {
+    /**
+     * Register one tool.
+     * @param tool - the tool, with identity already stamped by the host.
+     * @returns a disposer that removes it.
+     */
+    registerTool(tool: RegistrableTool): () => void;
+    /** Register one skill, returning a disposer. */
+    registerSkill?(skill: {
+        readonly name: string;
+        readonly ownerExtension: string;
+    }): () => void;
+    /**
+     * Register the CALLER-FACING tools of one declarative implementation (RCP-01).
+     *
+     * A declarative package declares implementations only — its manifest has no
+     * `tools` array — so the tool names and schemas come from the RESOLVED RECIPES,
+     * which only the host can turn into registry entries (the recipes need the
+     * deployment's harness provider to be served at all). The contribution arrives
+     * per implementation; the host resolves the package's recipes and registers the
+     * matching tool, returning its disposer. Absent (or a non-declarative package)
+     * keeps the earlier behavior: implementations publish nothing.
+     */
+    registerDeclarative?(contribution: {
+        readonly extensionId: string;
+        readonly name: string;
+        readonly contractId?: string;
+    }): () => void;
+}
+/** Raised when a contribution cannot be published. */
+export declare class ContributionError extends Error {
+    readonly name = "ContributionError";
+    readonly code: 'name-collision' | 'unsupported-kind' | 'unknown-extension';
+    constructor(code: ContributionError['code'], message: string);
+}
+/**
+ * The published contributions, keyed by handle id.
+ *
+ * A Map rather than a field on the handle, so an extension that receives a handle cannot
+ * reach the disposer or another extension's entry through it.
+ */
+export interface RegistrarOptions {
+    readonly registry: HostRegistrySurface;
+    /**
+     * The extensions the host has ACTIVATED.
+     *
+     * A contribution from an extension not in this set is refused: publishing is a privilege
+     * of activation, and without this check any code holding the registrar could register a
+     * tool under an extension that was never installed.
+     */
+    readonly activated: ReadonlySet<string>;
+    /** Called when a contribution is refused, so the reason is recorded rather than lost. */
+    readonly onRefused?: (contribution: Contribution, error: ContributionError) => void;
+}
+/**
+ * Create the registrar the lifecycle publishes through.
+ * @param options - the registry surface and the activated set.
+ * @returns the registrar.
+ */
+export declare function createContributionRegistrar(options: RegistrarOptions): ContributionRegistrar;
+//# sourceMappingURL=extension-registrar.d.ts.map

package/lib/extension-registrar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension-registrar.d.ts","sourceRoot":"","sources":["../src/extension-registrar.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAA;AAE7F,6DAA6D;AAC7D,MAAM,WAAW,eAAe;IAC9B,mCAAmC;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,2DAA2D;IAC3D,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;IAC/B,wDAAwD;IACxD,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAC7B;AAED,uDAAuD;AACvD,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,YAAY,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM,IAAI,CAAA;IAC/C,gDAAgD;IAChD,aAAa,CAAC,CAAC,KAAK,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;KAAE,GAAG,MAAM,IAAI,CAAA;IAC7F;;;;;;;;;;OAUG;IACH,mBAAmB,CAAC,CAAC,YAAY,EAAE;QACjC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;QAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;QACrB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAC7B,GAAG,MAAM,IAAI,CAAA;CACf;AAED,sDAAsD;AACtD,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,SAAkB,IAAI,uBAAsB;IAC5C,QAAQ,CAAC,IAAI,EAAE,gBAAgB,GAAG,kBAAkB,GAAG,mBAAmB,CAAA;gBAC9D,IAAI,EAAE,iBAAiB,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,MAAM;CAI7D;AAUD;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,CAAA;IACtC;;;;;;OAMG;IACH,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IACvC,yFAAyF;IACzF,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,YAAY,EAAE,YAAY,EAAE,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAA;CACpF;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,gBAAgB,GAAG,qBAAqB,CAkG5F"}

package/lib/extension-registrar.js

@@ -0,0 +1,134 @@
+/**
+ * The host-side contribution registrar (EXT-21..EXT-30, ARCH-06).
+ *
+ * This is the bridge that was MISSING: `ExtensionLifecycle` could install, activate and
+ * publish contributions, and the SDK was fully tested doing so — but the HOST never
+ * mounted the lifecycle, so **no extension's tools ever reached the DSH registry**. An
+ * extension could be installed, activated and reported `observedActivation: 'active'` with
+ * its tool listed, and a caller still could not invoke it.
+ *
+ * The registrar is the other half: it turns a published contribution into a real registry
+ * entry, and withdraws it again on deactivation.
+ *
+ * Four rules, each of which has been a real defect somewhere:
+ *
+ * - **Handles are opaque and unguessable.** An extension must not be able to construct a
+ *   handle and withdraw a contribution it does not own. A sequence number is guessable;
+ *   the handle is a branded object the caller never sees the inside of.
+ * - **Withdrawing is idempotent.** A deactivation that runs twice must not throw the
+ *   second time, and must not withdraw a DIFFERENT contribution that reused the handle.
+ * - **A name collision is refused, not silently overwritten.** Two extensions contributing
+ *   `transcribe` is a configuration error; letting the second win would silently change
+ *   what an existing caller reaches.
+ * - **The host stamps identity.** The contribution carries an extension id, but the HOST
+ *   decides what that means; a package claiming another's id is refused rather than
+ *   trusted.
+ *
+ * @module @try-works/dsh-model-as-tool/extension-registrar
+ */
+/** Raised when a contribution cannot be published. */
+export class ContributionError extends Error {
+    name = 'ContributionError';
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+/**
+ * Create the registrar the lifecycle publishes through.
+ * @param options - the registry surface and the activated set.
+ * @returns the registrar.
+ */
+export function createContributionRegistrar(options) {
+    const published = new Map();
+    /** Names currently taken, so a collision is detected rather than overwritten. */
+    const takenNames = new Map();
+    let nextId = 1;
+    const refuse = (contribution, error) => {
+        options.onRefused?.(contribution, error);
+        throw error;
+    };
+    return {
+        publish(contribution) {
+            // ACTIVATION IS A PRECONDITION. A contribution from a package that was never
+            // activated is refused rather than registered.
+            if (!options.activated.has(contribution.extensionId)) {
+                return refuse(contribution, new ContributionError('unknown-extension', `${contribution.extensionId} is not activated, so it cannot publish ${contribution.name}`));
+            }
+            /**
+             * A COLLISION IS REFUSED. Letting the second registration win would silently change
+             * what an existing caller reaches — the same name would resolve to a different tool
+             * with no signal.
+             */
+            const existing = takenNames.get(contribution.name);
+            if (existing !== undefined) {
+                return refuse(contribution, new ContributionError('name-collision', `${contribution.name} is already published by ${existing}; `
+                    + `${contribution.extensionId} cannot take the name over`));
+            }
+            const handle = {
+                __contributionHandle: true,
+                id: nextId++,
+                extensionId: contribution.extensionId,
+                name: contribution.name,
+            };
+            let dispose;
+            if (contribution.kind === 'tool') {
+                dispose = options.registry.registerTool({
+                    name: contribution.name,
+                    // The HOST stamps the owner from the contribution it validated, so a package
+                    // cannot claim another's provenance.
+                    ownerExtension: contribution.extensionId,
+                    ...contribution.contractId === undefined ? {} : { contractId: contribution.contractId },
+                });
+            }
+            else if (contribution.kind === 'skill' && options.registry.registerSkill !== undefined) {
+                dispose = options.registry.registerSkill({
+                    name: contribution.name,
+                    ownerExtension: contribution.extensionId,
+                });
+            }
+            else if (contribution.kind === 'implementation' && options.registry.registerDeclarative !== undefined) {
+                // An `implementation` of a MODULE package is not a caller-facing tool: the model
+                // catalogue binds it. An implementation of a DECLARATIVE package, however, IS the
+                // whole package: the host turns its resolved recipe into the caller-facing tool
+                // here (RCP-01), and the returned disposer is tracked like any other handle.
+                dispose = options.registry.registerDeclarative({
+                    extensionId: contribution.extensionId,
+                    name: contribution.name,
+                    ...contribution.contractId === undefined ? {} : { contractId: contribution.contractId },
+                });
+            }
+            else {
+                dispose = () => { };
+            }
+            takenNames.set(contribution.name, contribution.extensionId);
+            published.set(handle.id, { handle, dispose });
+            // The SDK types the handle as a string; the runtime value is a branded object, which
+            // is what makes it unforgeable. The cast is the boundary between the two.
+            return handle;
+        },
+        withdraw(rawHandle) {
+            const handle = rawHandle;
+            // A handle that is not ours — a string, a number, a forged object — is ignored
+            // rather than treated as a lookup that might match something.
+            if (handle === null || typeof handle !== 'object' || handle.__contributionHandle !== true)
+                return;
+            const entry = published.get(handle.id);
+            if (entry === undefined) {
+                // IDEMPOTENT: withdrawing twice is not an error, and must not withdraw whatever
+                // might have reused the id.
+                return;
+            }
+            // The handle must be the SAME one that was issued, not merely an object with the
+            // right id, so a reconstructed handle cannot withdraw someone else's tool.
+            if (entry.handle !== handle)
+                return;
+            // Failed cleanup retains ownership and the handle for an explicit retry.
+            entry.dispose();
+            published.delete(handle.id);
+            takenNames.delete(handle.name);
+        },
+    };
+}
+//# sourceMappingURL=extension-registrar.js.map

package/lib/extensions-api.d.ts

@@ -0,0 +1,217 @@
+/**
+ * The wire contract between the Settings page and the host for extension
+ * management (install / enable / disable).
+ *
+ * This module is the single source of truth both halves implement:
+ * - the host service (`extensions-service.ts`) produces these values;
+ * - the generated/registered Remote artifact exposes them as `remote.modelTools`;
+ * - the browser half calls them after installing its Install/Enable controls.
+ *
+ * Every method is deliberately explicit about what is UNKNOWN rather than
+ * inventing state: `store` is null when no extension store is configured, and a
+ * row's `integrity` is absent when nothing was ever installed.
+ *
+ * @module @try-works/dsh-model-as-tool/extensions-api
+ */
+/** One extension, as the UI needs it. */
+/** What kind of prerequisite an extension (or a model it serves) has. */
+export type ExtensionRequirementKind = 'store' | 'source' | 'dependencies' | 'assets' | 'executable' | 'harness-model' | 'platform' | 'integrity' | 'activation';
+/** The action that clears an unmet requirement, when the deployment supports it. */
+export type ExtensionRequirementAction = 'install' | 'prepare' | 'enable' | 'config' | 'none';
+/**
+ * ONE activation prerequisite, computed by the host BEFORE install/enable.
+ *
+ * The point of this list is that a user never discovers a deployment gap by
+ * clicking Enable and reading an EXTENSION_FAULT: `blocked` rows carry the exact
+ * requirement that is unmet and the action (if any) that would satisfy it. A
+ * requirement is reported even when satisfied, so the page can distinguish
+ * "nothing to do" from "we did not look".
+ */
+export interface ExtensionRequirement {
+    readonly kind: ExtensionRequirementKind;
+    readonly satisfied: boolean;
+    /** Exact, actionable text; empty only when satisfied and self-evident. */
+    readonly reason: string;
+    readonly action: ExtensionRequirementAction;
+}
+export interface ExtensionState {
+    /** The extension's package identity, for example `@try-works/extension-laya`. */
+    readonly id: string;
+    /** The package name to install from, when the host knows one. */
+    readonly package: string | null;
+    /** Installed version, absent when the store does not hold it. */
+    readonly version: string | null;
+    /** Whether the store holds an installed copy. */
+    readonly installed: boolean;
+    /** Whether the host restored it on this load. */
+    readonly active: boolean;
+    /** Whether the operator disabled it (config `disabledExtensions`). */
+    readonly disabled: boolean;
+    /** Content verification of the installed copy. */
+    readonly integrity: 'unchanged' | 'changed' | 'unknown';
+    /** Tool names the extension exports once active. */
+    readonly tools: readonly string[];
+    /** Why the extension cannot install or activate, when known. */
+    readonly reason: string | null;
+    /** Every prerequisite this deployment checked, satisfied or not. */
+    readonly requirements: readonly ExtensionRequirement[];
+    /**
+     * Whether ANY unmet requirement blocks activation. Derived from
+     * `requirements`; carried explicitly so the page never has to re-derive it.
+     */
+    readonly blocked: boolean;
+}
+/** The state of the extension surface. */
+export interface ExtensionsDescribeResult {
+    /** The configured extension store directory, or null when unconfigured. */
+    readonly store: string | null;
+    /** Whether the host can write to the store (install/enable/disable). */
+    readonly writable: boolean;
+    /** Where the host would install first-party extensions from, or null. */
+    readonly sourceDir: string | null;
+    /** One row per extension the host knows about. */
+    readonly extensions: readonly ExtensionState[];
+}
+/** The result of an install request. */
+export interface ExtensionInstallResult {
+    readonly id: string;
+    readonly version: string;
+    /** Installation is not activation: `active` is false until it is enabled. */
+    readonly active: boolean;
+}
+/** The result of an enable/disable request. */
+export interface ExtensionToggleResult {
+    readonly id: string;
+    readonly active: boolean;
+    readonly disabled: boolean;
+}
+/**
+ * The readiness vocabulary a preparation reports (EXT-25 / RES-04).
+ *
+ * Only `prepared-cold`, `loading`, `ready` and `busy` permit activation; the
+ * others name WHY they do not.
+ */
+export type ExtensionModelReadiness = 'unavailable' | 'needs-preparation' | 'preparing' | 'prepared-cold' | 'loading' | 'ready' | 'busy' | 'failed';
+/**
+ * Readiness for each DECLARED model deployment, keyed by the manifest's model id.
+ *
+ * Declared ids are the projection: a stale readiness entry for a deployment the
+ * current manifest no longer declares is not reported.
+ */
+export type ExtensionReadinessMap = Readonly<Record<string, ExtensionModelReadiness>>;
+/** One asset in the RES-02 preparation disclosure. */
+export interface ExtensionPreparationAsset {
+    /** The stable asset id (`<group>/<asset>`). */
+    readonly assetId: string;
+    /** Download size in bytes. */
+    readonly bytes: number;
+    /** The pinned source the bytes come from. */
+    readonly source: string;
+    /** Whether the asset is executable, which needs the separate approval (RES-02). */
+    readonly executable: boolean;
+}
+/**
+ * The pre-approval disclosure of what a preparation downloads (RES-02).
+ *
+ * The same fields the management channel's `extensions-prepare-plan` action
+ * discloses; it travels with the result so the page can show bytes, storage,
+ * terms and the executable gate.
+ */
+export interface ExtensionPreparationPlan {
+    /** The manifest model deployment the assets belong to. */
+    readonly modelId: string;
+    /** The pinned model revision. */
+    readonly modelRevision: string;
+    /** Every asset the preparation acquires. */
+    readonly assets: readonly ExtensionPreparationAsset[];
+    /** Total download bytes. */
+    readonly totalBytes: number;
+    /** Total bytes retained after installation (stated separately from download). */
+    readonly storageBytes: number;
+    /** Whether any asset is executable and therefore needs the separate approval. */
+    readonly requiresExecutableApproval: boolean;
+    /** The pinned license terms, surfaced before the download. */
+    readonly license: {
+        readonly name: string;
+        readonly url: string;
+    };
+}
+/** The result of a preparation request. */
+export interface ExtensionPrepareResult {
+    readonly id: string;
+    /** Whether every declared asset was verified and the readiness was recorded. */
+    readonly prepared: boolean;
+    /** Why the preparation did not complete, when it did not; null on success. */
+    readonly reason: string | null;
+    /** The RES-02 disclosure this call executed, when a plan could be resolved. */
+    readonly plan: ExtensionPreparationPlan | null;
+    /** The readiness per DECLARED model deployment after the call. */
+    readonly readiness: ExtensionReadinessMap;
+    /** The prepared asset group ids (empty when nothing was prepared). */
+    readonly groups: readonly string[];
+    /**
+     * Whether no KNOWN blocker remains for activation: the installed bytes verify
+     * and every declared deployment is in a callable readiness state.
+     *
+     * This is the preparation question only; it does not promise that activation
+     * will publish (a schema or contribution refusal can still fail an enable).
+     */
+    readonly activationReady: boolean;
+}
+/** The methods the HOST service implements (raw values, in-process). */
+export interface ModelToolsRemote {
+    /** Read the current state; the page calls this on mount and after each action. */
+    describe(signal?: AbortSignal): Promise<ExtensionsDescribeResult>;
+    /** Install one extension from `source`, or the configured first-party source. */
+    install(id: string, source?: string, signal?: AbortSignal): Promise<ExtensionInstallResult>;
+    /** Activate an installed extension (removes it from `disabledExtensions`). */
+    enable(id: string, signal?: AbortSignal): Promise<ExtensionToggleResult>;
+    /** Deactivate an extension (adds it to `disabledExtensions`). */
+    disable(id: string, signal?: AbortSignal): Promise<ExtensionToggleResult>;
+    /**
+     * Acquire and verify the installed extension's model assets, then record the
+     * resulting readiness so a following `enable` can activate it.
+     */
+    prepare(id: string, signal?: AbortSignal): Promise<ExtensionPrepareResult>;
+}
+/**
+ * The Remote wire result wrapper.
+ *
+ * A generated Remote call resolves a `RemoteResult`, never a bare value: the
+ * gateway answers `{ok:true,value}` or `{ok:false,error}`. Declared locally (not
+ * imported) so this package does not couple to the harness gateway types, and
+ * because the browser half is plain JS that reads `.ok` structurally.
+ */
+export type RemoteResult<T> = {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly error: {
+        readonly code?: string;
+        readonly message: string;
+    };
+};
+/**
+ * The methods the BROWSER half calls, as `ctx.remote.modelTools`.
+ *
+ * Two wire facts a caller must respect:
+ * - `describe`/`enable`/`disable` resolve a {@link RemoteResult}, not a raw value.
+ * - The install method is named `installExtension`, not `install`: the harness
+ *   client's RemoteNamespaceService owns a private method `install`, and the
+ *   gateway rejects a descriptor method that collides with it
+ *   ("client api: method ... conflicts with its namespace service"). The host
+ *   service keeps `install`, and the descriptor maps the wire name to it.
+ */
+export interface ModelToolsRemoteClient {
+    describe(signal?: AbortSignal): Promise<RemoteResult<ExtensionsDescribeResult>>;
+    installExtension(id: string, source?: string, signal?: AbortSignal): Promise<RemoteResult<ExtensionInstallResult>>;
+    enable(id: string, signal?: AbortSignal): Promise<RemoteResult<ExtensionToggleResult>>;
+    disable(id: string, signal?: AbortSignal): Promise<RemoteResult<ExtensionToggleResult>>;
+    /**
+     * Acquire/verify the extension's model assets and record readiness. The wire
+     * name is `prepare` (no collision with the namespace service's members).
+     */
+    prepare(id: string, signal?: AbortSignal): Promise<RemoteResult<ExtensionPrepareResult>>;
+}
+//# sourceMappingURL=extensions-api.d.ts.map

package/lib/extensions-api.d.ts.map

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

package/lib/extensions-api.js

@@ -0,0 +1,17 @@
+/**
+ * The wire contract between the Settings page and the host for extension
+ * management (install / enable / disable).
+ *
+ * This module is the single source of truth both halves implement:
+ * - the host service (`extensions-service.ts`) produces these values;
+ * - the generated/registered Remote artifact exposes them as `remote.modelTools`;
+ * - the browser half calls them after installing its Install/Enable controls.
+ *
+ * Every method is deliberately explicit about what is UNKNOWN rather than
+ * inventing state: `store` is null when no extension store is configured, and a
+ * row's `integrity` is absent when nothing was ever installed.
+ *
+ * @module @try-works/dsh-model-as-tool/extensions-api
+ */
+export {};
+//# sourceMappingURL=extensions-api.js.map

package/lib/extensions-remote.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Host-side registration of the `modelTools` Remote namespace.
+ *
+ * The Host Gateway resolves each generated invocation through the Cordis
+ * service named by its descriptor (`modelTools`) and refuses a service without
+ * a visible `typertRemote` binding. The generated Host artifact
+ * (`remote/typert.host.mjs`, published as `./typert`) is registered
+ * automatically by `@deepseek-ai/dsh-typert-loader` for this package's Loader
+ * entry; this module supplies the other half: a bound, provided service object.
+ *
+ * Keeping both facts in one helper makes a half-wired composition fail loudly
+ * at apply time instead of on the first Remote call.
+ *
+ * The browser half is `remote/spec.mjs` + `client/client.model-tools.js`; the
+ * method-name split between the wire (`installExtension`) and the Host service
+ * (`install`) is documented in `./extensions-api.ts`.
+ *
+ * @module @try-works/dsh-model-as-tool/extensions-remote
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { ModelToolsRemote } from './extensions-api.ts';
+/** Cordis service key the Host dispatch resolves through the descriptor. */
+export declare const MODEL_TOOLS_SERVICE = "modelTools";
+/** Wire namespace the Client mounts as `ctx.remote.modelTools`. */
+export declare const MODEL_TOOLS_NAMESPACE = "modelTools";
+/**
+ * The binding shape the Gateway reads from a service object.
+ * Mirrors the protocol's `TypertGatewayBinding` without importing the harness.
+ */
+export interface ModelToolsBinding {
+    readonly service: object;
+    readonly serviceKey: string;
+    readonly namespace: string;
+}
+/**
+ * Attach the Gateway's `typertRemote` binding to a prepared service object.
+ * @param service - the implementation of {@link ModelToolsRemote}.
+ * @returns the same service, now bindable to the `modelTools` namespace.
+ * @throws TypeError when a required method is missing.
+ */
+export declare function bindModelToolsRemote<T extends ModelToolsRemote>(service: T): T;
+/**
+ * Provide the bound extension service as the `modelTools` Cordis service.
+ *
+ * The Host artifact registers strict descriptors for:
+ * `describe`, `installExtension` (dispatching to the service's `install`),
+ * `enable`, `disable`, and `prepare`.
+ *
+ * @param ctx - the plugin's Cordis context that should own the service.
+ * @param service - the prepared {@link ModelToolsRemote} implementation.
+ * @throws TypeError when the service cannot satisfy the wire contract.
+ */
+export declare function provideModelToolsService(ctx: Context, service: ModelToolsRemote): void;
+//# sourceMappingURL=extensions-remote.d.ts.map

package/lib/extensions-remote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extensions-remote.d.ts","sourceRoot":"","sources":["../src/extensions-remote.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AAE3D,4EAA4E;AAC5E,eAAO,MAAM,mBAAmB,eAAe,CAAA;AAC/C,mEAAmE;AACnE,eAAO,MAAM,qBAAqB,eAAe,CAAA;AAEjD;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B;AAKD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,gBAAgB,EAAE,OAAO,EAAE,CAAC,GAAG,CAAC,CAoB9E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,gBAAgB,GAAG,IAAI,CAEtF"}

package/lib/extensions-remote.js

@@ -0,0 +1,66 @@
+/**
+ * Host-side registration of the `modelTools` Remote namespace.
+ *
+ * The Host Gateway resolves each generated invocation through the Cordis
+ * service named by its descriptor (`modelTools`) and refuses a service without
+ * a visible `typertRemote` binding. The generated Host artifact
+ * (`remote/typert.host.mjs`, published as `./typert`) is registered
+ * automatically by `@deepseek-ai/dsh-typert-loader` for this package's Loader
+ * entry; this module supplies the other half: a bound, provided service object.
+ *
+ * Keeping both facts in one helper makes a half-wired composition fail loudly
+ * at apply time instead of on the first Remote call.
+ *
+ * The browser half is `remote/spec.mjs` + `client/client.model-tools.js`; the
+ * method-name split between the wire (`installExtension`) and the Host service
+ * (`install`) is documented in `./extensions-api.ts`.
+ *
+ * @module @try-works/dsh-model-as-tool/extensions-remote
+ */
+/** Cordis service key the Host dispatch resolves through the descriptor. */
+export const MODEL_TOOLS_SERVICE = 'modelTools';
+/** Wire namespace the Client mounts as `ctx.remote.modelTools`. */
+export const MODEL_TOOLS_NAMESPACE = 'modelTools';
+/** The public methods the Host service must expose for dispatch to work. */
+const REQUIRED_METHODS = ['describe', 'install', 'enable', 'disable', 'prepare'];
+/**
+ * Attach the Gateway's `typertRemote` binding to a prepared service object.
+ * @param service - the implementation of {@link ModelToolsRemote}.
+ * @returns the same service, now bindable to the `modelTools` namespace.
+ * @throws TypeError when a required method is missing.
+ */
+export function bindModelToolsRemote(service) {
+    const missing = REQUIRED_METHODS.filter(method => service[method] === undefined);
+    if (missing.length > 0) {
+        throw new TypeError(`model-tools: the Remote service is missing ${missing.map(method => JSON.stringify(method)).join(', ')}; `
+            + 'the modelTools namespace cannot be dispatched');
+    }
+    if (Object.hasOwn(service, 'typertRemote'))
+        return service;
+    Object.defineProperty(service, 'typertRemote', {
+        value: Object.freeze({
+            service,
+            serviceKey: MODEL_TOOLS_SERVICE,
+            namespace: MODEL_TOOLS_NAMESPACE,
+        }),
+        enumerable: false,
+        configurable: false,
+        writable: false,
+    });
+    return service;
+}
+/**
+ * Provide the bound extension service as the `modelTools` Cordis service.
+ *
+ * The Host artifact registers strict descriptors for:
+ * `describe`, `installExtension` (dispatching to the service's `install`),
+ * `enable`, `disable`, and `prepare`.
+ *
+ * @param ctx - the plugin's Cordis context that should own the service.
+ * @param service - the prepared {@link ModelToolsRemote} implementation.
+ * @throws TypeError when the service cannot satisfy the wire contract.
+ */
+export function provideModelToolsService(ctx, service) {
+    ctx.provide(MODEL_TOOLS_SERVICE, bindModelToolsRemote(service));
+}
+//# sourceMappingURL=extensions-remote.js.map