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

package/remote/spec.mjs

@@ -0,0 +1,439 @@
+/**
+ * The single source of truth for the `modelTools` Remote namespace.
+ *
+ * Three artifacts are built from this module and must never drift:
+ * - `typert.host.mjs`: the Host Loader face the `typert-loader` registers as
+ *   strict invocation descriptors (`./typert` package export);
+ * - `typert.remote-client.mjs`: the mountable Client contribution (`./remote`);
+ * - `client/client.model-tools.js`: the package-local lazy-CJS chunk the
+ *   plugin's browser half loads with `require.async('./client.model-tools.js')`
+ *   (the client module system serves only `./client`, so the contribution the
+ *   page mounts travels as a sibling chunk).
+ *
+ * The wire method for install is `installExtension`, not `install`: DSH's
+ * client RemoteNamespaceService owns a private method `install` and refuses a
+ * descriptor method that collides with it. The Host service keeps its member
+ * name `install`; the descriptor's `implementation` maps the two.
+ *
+ * These functions stay dependency-free and self-contained because
+ * `scripts/gen-remote-artifacts.mjs` inlines their source into the browser
+ * chunk; changing one to reference an enclosing binding breaks the chunk.
+ */
+
+/** npm package that owns the namespace. */
+export const PACKAGE = '@try-works/dsh-model-as-tool'
+/** Cordis service key the Host dispatch resolves. */
+export const SERVICE = 'modelTools'
+/** Wire namespace exposed as `ctx.remote.modelTools`. */
+export const NAMESPACE = 'modelTools'
+/** Browser-facing install method (see the collision note above). */
+export const INSTALL_WIRE_METHOD = 'installExtension'
+
+/** Structural validators for the JSON values the wire carries. */
+const STRING = { kind: 'string' }
+const BOOLEAN = { kind: 'boolean' }
+const NULLABLE_STRING = { kind: 'nullable', of: STRING }
+const STRING_LIST = { kind: 'array', of: STRING }
+const INTEGRITY = {
+  kind: 'union',
+  of: [
+    { kind: 'literal', value: 'unchanged' },
+    { kind: 'literal', value: 'changed' },
+    { kind: 'literal', value: 'unknown' },
+  ],
+}
+/** The preflight prerequisite vocabulary (`extensions-api.ts` task-92). */
+const REQUIREMENT_KIND = {
+  kind: 'union',
+  of: [
+    'store',
+    'source',
+    'dependencies',
+    'assets',
+    'executable',
+    'harness-model',
+    'platform',
+    'integrity',
+    'activation',
+  ].map(value => ({ kind: 'literal', value })),
+}
+/** The action that clears an unmet requirement. */
+const REQUIREMENT_ACTION = {
+  kind: 'union',
+  of: ['install', 'prepare', 'enable', 'config', 'none'].map(value => ({ kind: 'literal', value })),
+}
+const EXTENSION_REQUIREMENT = {
+  kind: 'object',
+  fields: {
+    kind: REQUIREMENT_KIND,
+    satisfied: BOOLEAN,
+    reason: STRING,
+    action: REQUIREMENT_ACTION,
+  },
+}
+/**
+ * One extension row.
+ *
+ * `requirements` and `blocked` are ADDITIVE against the older row shape: both
+ * are optional here so a Host that predates the requirements model still
+ * validates. The browser half treats an absent `requirements` as "the host did
+ * not check" (no invented rows) and an absent `blocked` as false.
+ */
+const EXTENSION_STATE = {
+  kind: 'object',
+  fields: {
+    id: STRING,
+    package: NULLABLE_STRING,
+    version: NULLABLE_STRING,
+    installed: BOOLEAN,
+    active: BOOLEAN,
+    disabled: BOOLEAN,
+    integrity: INTEGRITY,
+    tools: STRING_LIST,
+    reason: NULLABLE_STRING,
+    requirements: { kind: 'optional', of: { kind: 'array', of: EXTENSION_REQUIREMENT } },
+    blocked: { kind: 'optional', of: BOOLEAN },
+  },
+}
+const DESCRIBE_RESULT = {
+  kind: 'object',
+  fields: {
+    store: NULLABLE_STRING,
+    writable: BOOLEAN,
+    sourceDir: NULLABLE_STRING,
+    extensions: { kind: 'array', of: EXTENSION_STATE },
+  },
+}
+const INSTALL_RESULT = {
+  kind: 'object',
+  fields: { id: STRING, version: STRING, active: BOOLEAN },
+}
+const TOGGLE_RESULT = {
+  kind: 'object',
+  fields: { id: STRING, active: BOOLEAN, disabled: BOOLEAN },
+}
+const OPTIONAL_STRING = { kind: 'optional', of: STRING }
+const NUMBER = { kind: 'number' }
+/** The readiness vocabulary from `extensions-api.ts` (EXT-25 / RES-04). */
+const MODEL_READINESS = {
+  kind: 'union',
+  of: ['unavailable', 'needs-preparation', 'preparing', 'prepared-cold', 'loading', 'ready', 'busy', 'failed']
+    .map(value => ({ kind: 'literal', value })),
+}
+const PREPARATION_ASSET = {
+  kind: 'object',
+  fields: { assetId: STRING, bytes: NUMBER, source: STRING, executable: BOOLEAN },
+}
+const PREPARATION_LICENSE = {
+  kind: 'object',
+  fields: { name: STRING, url: STRING },
+}
+const PREPARATION_PLAN = {
+  kind: 'object',
+  fields: {
+    modelId: STRING,
+    modelRevision: STRING,
+    assets: { kind: 'array', of: PREPARATION_ASSET },
+    totalBytes: NUMBER,
+    storageBytes: NUMBER,
+    requiresExecutableApproval: BOOLEAN,
+    license: PREPARATION_LICENSE,
+  },
+}
+const PREPARE_RESULT = {
+  kind: 'object',
+  fields: {
+    id: STRING,
+    prepared: BOOLEAN,
+    reason: NULLABLE_STRING,
+    plan: { kind: 'nullable', of: PREPARATION_PLAN },
+    readiness: { kind: 'record', of: MODEL_READINESS },
+    groups: STRING_LIST,
+    activationReady: BOOLEAN,
+  },
+}
+
+/**
+ * Validate one boundary value against the declarative schema.
+ * @param schema - schema node from the METHOD_SPECS data.
+ * @param value - untrusted boundary value.
+ * @returns the validated value; objects are rebuilt without undeclared fields.
+ * @throws TypeError when the value does not match.
+ */
+export function parseModelToolsValue(schema, value) {
+  switch (schema.kind) {
+    case 'string':
+      if (typeof value !== 'string') throw new TypeError('expected a string')
+      return value
+    case 'boolean':
+      if (typeof value !== 'boolean') throw new TypeError('expected a boolean')
+      return value
+    case 'number':
+      if (typeof value !== 'number' || !Number.isFinite(value)) throw new TypeError('expected a finite number')
+      return value
+    case 'null':
+      if (value !== null) throw new TypeError('expected null')
+      return null
+    case 'literal':
+      if (value !== schema.value) throw new TypeError('expected ' + JSON.stringify(schema.value))
+      return value
+    case 'optional':
+      return value === undefined ? undefined : parseModelToolsValue(schema.of, value)
+    case 'nullable':
+      return value === null ? null : parseModelToolsValue(schema.of, value)
+    case 'array':
+      if (!Array.isArray(value)) throw new TypeError('expected an array')
+      return value.map((item) => parseModelToolsValue(schema.of, item))
+    case 'record': {
+      if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new TypeError('expected a string-keyed record')
+      }
+      const parsed = {}
+      for (const [key, item] of Object.entries(value)) parsed[key] = parseModelToolsValue(schema.of, item)
+      return parsed
+    }
+    case 'object': {
+      if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new TypeError('expected an object')
+      }
+      const parsed = {}
+      for (const [key, field] of Object.entries(schema.fields)) {
+        const raw = value[key]
+        if (field.kind === 'optional') {
+          const item = parseModelToolsValue(field, raw)
+          if (item !== undefined) parsed[key] = item
+          continue
+        }
+        if (raw === undefined) throw new TypeError('missing field ' + JSON.stringify(key))
+        parsed[key] = parseModelToolsValue(field, raw)
+      }
+      return parsed
+    }
+    case 'union': {
+      let last
+      for (const variant of schema.of) {
+        try {
+          return parseModelToolsValue(variant, value)
+        } catch (error) {
+          last = error
+        }
+      }
+      throw new TypeError('value matched no union variant: ' + last.message)
+    }
+    default:
+      throw new TypeError('unknown schema kind ' + JSON.stringify(schema.kind))
+  }
+}
+
+/**
+ * Build one strict boundary codec from a declarative schema.
+ * @param typeSymbol - stable type identity recorded on the codec.
+ * @param schema - declarative schema the parser enforces.
+ * @returns strict codec with a cached parser factory.
+ */
+export function codecForModelToolsValue(typeSymbol, schema) {
+  let parser
+  return {
+    mode: 'strict',
+    typeSymbol,
+    create: () => (parser ??= { parse: (value) => parseModelToolsValue(schema, value) }),
+  }
+}
+
+/**
+ * Turn the static method specs into Host/client invocation descriptors.
+ * @param packageName - owning npm package.
+ * @param serviceKey - Cordis service key the Host dispatch resolves.
+ * @param namespace - wire namespace (also the Client Remote service suffix).
+ * @param specs - METHOD_SPECS.
+ * @returns fresh descriptors both the Host registry and the Client mount accept.
+ */
+export function descriptorsFromModelToolsSpecs(packageName, serviceKey, namespace, specs) {
+  return specs.map((spec) => {
+    const descriptor = {
+      id: packageName + '#' + namespace + '/' + spec.method,
+      service: serviceKey,
+      namespace,
+      method: spec.method,
+      description: spec.description,
+      invocation: { kind: 'direct' },
+      parameters: spec.parameters.map((parameter) => {
+        const entry = {
+          name: parameter.name,
+          wire: parameter.wire,
+          source: 'json',
+          codec: codecForModelToolsValue(parameter.typeSymbol, parameter.schema),
+          strictCodec: codecForModelToolsValue(parameter.strictTypeSymbol, parameter.schema),
+        }
+        if (parameter.description !== undefined) entry.description = parameter.description
+        if (parameter.acceptsUndefined === true) entry.acceptsUndefined = true
+        return entry
+      }),
+      cancellation: { parameter: 'signal' },
+      result: {
+        mode: 'strict',
+        typeSymbol: spec.result.typeSymbol,
+        create: codecForModelToolsValue(spec.result.typeSymbol, spec.result.schema).create,
+        description: spec.result.description,
+      },
+    }
+    if (spec.implementation !== undefined) descriptor.implementation = spec.implementation
+    return descriptor
+  })
+}
+
+/** Static method specs. JSON-safe so the browser chunk can embed them verbatim. */
+export const METHOD_SPECS = [
+  {
+    method: 'describe',
+    description: 'Read the current extension state; the page calls it on mount and after each action.',
+    parameters: [],
+    result: {
+      typeSymbol: PACKAGE + '#' + NAMESPACE + '/describe:result',
+      description: 'the extension surface as the host currently sees it.',
+      schema: DESCRIBE_RESULT,
+    },
+  },
+  {
+    method: INSTALL_WIRE_METHOD,
+    implementation: 'install',
+    description: 'Install one extension from `source`, or the configured first-party source.',
+    parameters: [
+      {
+        name: 'id',
+        wire: 'id',
+        description: 'the extension id, for example `@try-works/extension-laya`.',
+        acceptsUndefined: false,
+        typeSymbol: PACKAGE + '#' + NAMESPACE + '/install:id',
+        strictTypeSymbol: PACKAGE + '#' + NAMESPACE + '/install:id',
+        schema: STRING,
+      },
+      {
+        name: 'source',
+        wire: 'source',
+        description: 'an explicit install directory; absent means the configured first-party source.',
+        acceptsUndefined: true,
+        typeSymbol: PACKAGE + '#' + NAMESPACE + '/install:source',
+        strictTypeSymbol: PACKAGE + '#' + NAMESPACE + '/install:source',
+        schema: OPTIONAL_STRING,
+      },
+    ],
+    result: {
+      typeSymbol: PACKAGE + '#' + NAMESPACE + '/install:result',
+      description: 'the installed extension; installation is not activation.',
+      schema: INSTALL_RESULT,
+    },
+  },
+  {
+    method: 'enable',
+    description: 'Activate an installed extension (removes it from `disabledExtensions`).',
+    parameters: [
+      {
+        name: 'id',
+        wire: 'id',
+        description: 'the extension id to activate.',
+        acceptsUndefined: false,
+        typeSymbol: PACKAGE + '#' + NAMESPACE + '/enable:id',
+        strictTypeSymbol: PACKAGE + '#' + NAMESPACE + '/enable:id',
+        schema: STRING,
+      },
+    ],
+    result: {
+      typeSymbol: PACKAGE + '#' + NAMESPACE + '/enable:result',
+      description: 'the extension state after activation.',
+      schema: TOGGLE_RESULT,
+    },
+  },
+  {
+    method: 'disable',
+    description: 'Deactivate an extension (adds it to `disabledExtensions`).',
+    parameters: [
+      {
+        name: 'id',
+        wire: 'id',
+        description: 'the extension id to deactivate.',
+        acceptsUndefined: false,
+        typeSymbol: PACKAGE + '#' + NAMESPACE + '/disable:id',
+        strictTypeSymbol: PACKAGE + '#' + NAMESPACE + '/disable:id',
+        schema: STRING,
+      },
+    ],
+    result: {
+      typeSymbol: PACKAGE + '#' + NAMESPACE + '/disable:result',
+      description: 'the extension state after deactivation.',
+      schema: TOGGLE_RESULT,
+    },
+  },
+  {
+    method: 'prepare',
+    description: 'Acquire and verify the installed extension\'s model assets, then record the readiness a following enable needs.',
+    parameters: [
+      {
+        name: 'id',
+        wire: 'id',
+        description: 'the installed extension id to prepare.',
+        acceptsUndefined: false,
+        typeSymbol: PACKAGE + '#' + NAMESPACE + '/prepare:id',
+        strictTypeSymbol: PACKAGE + '#' + NAMESPACE + '/prepare:id',
+        schema: STRING,
+      },
+    ],
+    result: {
+      typeSymbol: PACKAGE + '#' + NAMESPACE + '/prepare:result',
+      description: 'the preparation outcome, its RES-02 disclosure, and the readiness recorded for each declared model.',
+      schema: PREPARE_RESULT,
+    },
+  },
+]
+
+/** The mountable Client contribution (and the Host artifact's invocation source). */
+export function buildContribution() {
+  return {
+    package: PACKAGE,
+    descriptors: descriptorsFromModelToolsSpecs(PACKAGE, SERVICE, NAMESPACE, METHOD_SPECS),
+  }
+}
+
+/** Host documentation for the methods, kept beside their specs. */
+const SERVICE_MODEL = {
+  description: 'Host service backing the generated `ctx.remote.modelTools` namespace. It reports the extension store truthfully (store null when unconfigured), performs staged installs, persisted enable/disable, and model-asset preparation with the RES-02 disclosure.',
+  summary: 'Host service backing the generated `ctx.remote.modelTools` namespace.',
+  tags: [],
+  jsDoc: '/** Host service backing the generated `ctx.remote.modelTools` namespace. */',
+  key: SERVICE,
+  exportName: 'ExtensionsService',
+  members: METHOD_SPECS.map((spec) => ({
+    kind: 'method',
+    name: spec.implementation ?? spec.method,
+    signature: spec.method === 'describe'
+      ? 'describe(signal?: AbortSignal): Promise<ExtensionsDescribeResult>'
+      : spec.method === 'installExtension'
+        ? 'install(id: string, source?: string, signal?: AbortSignal): Promise<ExtensionInstallResult>'
+        : spec.method === 'prepare'
+          ? 'prepare(id: string, signal?: AbortSignal): Promise<ExtensionPrepareResult>'
+          : `${spec.method}(id: string, signal?: AbortSignal): Promise<ExtensionToggleResult>`,
+    description: spec.description,
+    jsDoc: `/** ${spec.description} */`,
+  })),
+  types: [],
+}
+
+/**
+ * Build the Host Loader manifest the `typert-loader` validates and registers.
+ * @returns `TYPERT` host-face contribution.
+ */
+export function buildHostManifest() {
+  return {
+    package: PACKAGE,
+    face: 'host',
+    schemas: [],
+    get invocations() {
+      return buildContribution().descriptors
+    },
+    model: {
+      services: [SERVICE_MODEL],
+      events: [],
+      objects: [],
+    },
+  }
+}

package/remote/typert.host.mjs

@@ -0,0 +1,14 @@
+/**
+ * Host Loader face of the `modelTools` Remote namespace (`./typert` export).
+ *
+ * `@deepseek-ai/dsh-typert-loader` imports this module for the `model-tools`
+ * Loader entry, validates the manifest, and registers `TYPERT.invocations` in
+ * the Host Typert registry, where the Gateway dispatches them. The descriptors
+ * come from `./spec.mjs`, the same source the Client artifact and the browser
+ * chunk are built from.
+ */
+
+import { buildHostManifest } from './spec.mjs'
+
+/** Host contribution registered by the Typert loader. */
+export const TYPERT = buildHostManifest()

package/remote/typert.remote-client.mjs

@@ -0,0 +1,16 @@
+/**
+ * Client face of the `modelTools` Remote namespace (`./remote` export).
+ *
+ * A standard DSH Client assembly imports this module and mounts it through
+ * `ctx.remote.$mount(...)`; this plugin's own browser half mounts the same
+ * contribution from its package-local lazy-CJS chunk
+ * (`client/client.model-tools.js`), because the client module system serves
+ * only `./client` for an installed plugin.
+ */
+
+import { buildContribution } from './spec.mjs'
+
+/** Mountable contribution exposing `describe`, `installExtension`, `enable`, `disable`. */
+export const TYPERT_REMOTE = buildContribution()
+
+export default TYPERT_REMOTE

package/lib/adapters/tongue.d.ts

@@ -1,31 +0,0 @@
-/**
- * Tongue adapter — on-device language identification for short text.
- *
- * Tongue is the one Desert Ant model that runs in plain Node on every platform:
- * it is pure JavaScript with no WASM or inference runtime, and its 2 MB model
- * ships inside the npm package. That makes it the reference adapter: the module
- * is imported on first use, the loaded model is cached for the process, and the
- * synchronous `detect()` is wrapped in the async tool contract.
- *
- * @module @try-works/dsh-model-as-tool/adapters/tongue
- */
-import type { ModelCatalogEntry } from '../types.ts';
-import { type ModelAdapter } from './types.ts';
-/** The npm package this adapter knows how to call. */
-export declare const TONGUE_PACKAGE = "@desert-ant-labs/tongue";
-/**
- * Build the Tongue adapter.
- *
- * The factory is keyed on the PACKAGE, not the catalog id: an adapter's job is to
- * know how to call one SDK, so any catalog row bound to this package can share it.
- * Keying on the model id instead would mean a second conforming implementation of
- * the same contract could never be served — exactly the model-name switch BASE-02
- * and EXT-01 exist to prevent.
- *
- * The model is loaded once and reused, because `Tongue.load()` parses the bundled
- * 2 MB weight file and detection afterwards is synchronous.
- * @param entry - the catalog entry this adapter serves.
- * @returns the adapter, or undefined if the entry does not use this SDK.
- */
-export declare function createTongueAdapter(entry: ModelCatalogEntry): ModelAdapter | undefined;
-//# sourceMappingURL=tongue.d.ts.map

package/lib/adapters/tongue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tongue.d.ts","sourceRoot":"","sources":["../../src/adapters/tongue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AACpD,OAAO,EAKL,KAAK,YAAY,EAClB,MAAM,YAAY,CAAA;AAwBnB,sDAAsD;AACtD,eAAO,MAAM,cAAc,4BAA4B,CAAA;AAMvD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,iBAAiB,GAAG,YAAY,GAAG,SAAS,CAwDtF"}

package/lib/adapters/tongue.js

@@ -1,93 +0,0 @@
-/**
- * Tongue adapter — on-device language identification for short text.
- *
- * Tongue is the one Desert Ant model that runs in plain Node on every platform:
- * it is pure JavaScript with no WASM or inference runtime, and its 2 MB model
- * ships inside the npm package. That makes it the reference adapter: the module
- * is imported on first use, the loaded model is cached for the process, and the
- * synchronous `detect()` is wrapped in the async tool contract.
- *
- * @module @try-works/dsh-model-as-tool/adapters/tongue
- */
-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 { optionalInteger, requireString, throwIfAborted, } from "./types.js";
-/** The npm package this adapter knows how to call. */
-export const TONGUE_PACKAGE = '@desert-ant-labs/tongue';
-/** Default number of runner-up candidates reported to the model. */
-const DEFAULT_TOP = 3;
-const MAX_TOP = 20;
-/**
- * Build the Tongue adapter.
- *
- * The factory is keyed on the PACKAGE, not the catalog id: an adapter's job is to
- * know how to call one SDK, so any catalog row bound to this package can share it.
- * Keying on the model id instead would mean a second conforming implementation of
- * the same contract could never be served — exactly the model-name switch BASE-02
- * and EXT-01 exist to prevent.
- *
- * The model is loaded once and reused, because `Tongue.load()` parses the bundled
- * 2 MB weight file and detection afterwards is synchronous.
- * @param entry - the catalog entry this adapter serves.
- * @returns the adapter, or undefined if the entry does not use this SDK.
- */
-export function createTongueAdapter(entry) {
-    if (entry.npmPackage !== TONGUE_PACKAGE)
-        return undefined;
-    let loaded;
-    const load = async () => {
-        loaded ??= (async () => {
-            try {
-                // A dynamic import keyed off a variable keeps this out of the module
-                // graph until the tool is actually called: the package is an optional
-                // dependency, so a static import would break installs that skip it.
-                const specifier = entry.npmPackage;
-                const module = await import(__rewriteRelativeImportExtension(specifier));
-                return await module.Tongue.load();
-            }
-            catch (error) {
-                // Clear the cache so a transient failure (or a later install) can be
-                // retried by the next call rather than poisoning the tool for the life
-                // of the plugin.
-                loaded = undefined;
-                throw new Error(`Tongue could not be loaded: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        })();
-        return loaded;
-    };
-    return {
-        modelId: entry.id,
-        async invoke({ args, signal }) {
-            throwIfAborted(signal);
-            const text = requireString(args, 'text');
-            const top = optionalInteger(args, 'top', { min: 1, max: MAX_TOP, fallback: DEFAULT_TOP });
-            const tongue = await load();
-            throwIfAborted(signal);
-            const detection = tongue.detect(text);
-            const candidates = (detection.candidates ?? []).slice(0, top);
-            return {
-                language: detection.language,
-                reliability: detection.reliability ?? 'unknown',
-                isTooCloseToCall: detection.isTooCloseToCall ?? false,
-                candidates: candidates.map(candidate => ({
-                    language: candidate.language,
-                    probability: candidate.probability,
-                })),
-            };
-        },
-        async dispose() {
-            if (loaded === undefined)
-                return;
-            const instance = await loaded.catch(() => undefined);
-            instance?.dispose?.();
-            loaded = undefined;
-        },
-    };
-}
-//# sourceMappingURL=tongue.js.map

package/lib/adapters/voz.d.ts

@@ -1,28 +0,0 @@
-/**
- * Voz adapter — on-device speech recognition with word timestamps.
- *
- * Voz has no prebuilt Node core; it runs the same WebAssembly/ONNX Runtime
- * pipeline everywhere and requires the caller to hand it an ONNX Runtime
- * module. `onnxruntime-node` ships win32-x64 binaries, which is what makes Voz
- * the one audio model that works on Windows.
- *
- * Loading is expensive (the weights are ~349 MB and ONNX Runtime compiles three
- * graphs), so the instance is cached for the process and reused.
- *
- * @module @try-works/dsh-model-as-tool/adapters/voz
- */
-import type { ModelCatalogEntry } from '../types.ts';
-import { type ModelAdapter } from './types.ts';
-/** The npm package this adapter knows how to call. */
-export declare const VOZ_PACKAGE = "@desert-ant-labs/voz";
-/**
- * Build the Voz adapter.
- *
- * Keyed on the package rather than the catalog id, for the same reason as the
- * Tongue adapter: the adapter knows an SDK, so any catalog row bound to it can be
- * served, which is what lets a second implementation join the contract.
- * @param entry - the catalog entry this adapter serves.
- * @returns the adapter, or undefined if the entry does not use this SDK.
- */
-export declare function createVozAdapter(entry: ModelCatalogEntry): ModelAdapter | undefined;
-//# sourceMappingURL=voz.d.ts.map

package/lib/adapters/voz.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"voz.d.ts","sourceRoot":"","sources":["../../src/adapters/voz.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AACpD,OAAO,EAKL,KAAK,YAAY,EAClB,MAAM,YAAY,CAAA;AAgCnB,sDAAsD;AACtD,eAAO,MAAM,WAAW,yBAAyB,CAAA;AAKjD;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,iBAAiB,GAAG,YAAY,GAAG,SAAS,CAsEnF"}