@qvac/sdk 0.9.2 → 0.10.0

package/dist/models/update-models/codegen.js

@@ -1,20 +1,32 @@
 import { generateExportName } from "./naming.js";
 export function generateModelsFileContent(models) {
     const usedNames = new Set();
+    const named = new Map();
+    const exportable = models.filter((m) => !m.isCompanionOnly);
+    const companionOnly = models.filter((m) => m.isCompanionOnly);
+    for (const m of exportable) {
+        named.set(m, assignName(m, usedNames));
+    }
+    for (const m of companionOnly) {
+        named.set(m, assignName(m, usedNames));
+    }
     const modelsWithNames = models.map((m) => ({
         ...m,
-        name: generateExportName({
-            path: m.registryPath,
-            engine: m.engine,
-            name: m.modelName,
-            quantization: m.quantization,
-            params: m.params,
-            tags: m.tags,
-            usedNames,
-        }),
+        name: named.get(m),
     }));
     return generateFileContentWithNames(modelsWithNames);
 }
+function assignName(m, usedNames) {
+    return generateExportName({
+        path: m.registryPath,
+        engine: m.engine,
+        name: m.modelName,
+        quantization: m.quantization,
+        params: m.params,
+        tags: m.tags,
+        usedNames,
+    });
+}
 function generateFileContentWithNames(modelsWithNames) {
     const entries = modelsWithNames
         .map((m) => {
@@ -37,12 +49,17 @@ function generateFileContentWithNames(modelsWithNames) {
         if (m.shardMetadata) {
             entry += `,\n    shardMetadata: ${JSON.stringify(m.shardMetadata)}`;
         }
+        if (m.companionSet) {
+            entry += `,\n    companionSet: ${JSON.stringify(m.companionSet)}`;
+        }
         entry += "\n  }";
         return entry;
     })
         .join(",\n");
     const exports = modelsWithNames
-        .map((m, i) => {
+        .filter((m) => !m.isCompanionOnly)
+        .map((m) => {
+        const i = modelsWithNames.indexOf(m);
         return `export const ${m.name} = {
   name: "${m.name}",
   src: \`registry://\${models[${i}].registrySource}/\${models[${i}].registryPath}\`,
@@ -65,6 +82,14 @@ function generateFileContentWithNames(modelsWithNames) {
     return `// THIS FILE IS AUTO-GENERATED BY models/update-models
 // DO NOT MODIFY MANUALLY
 
+import type {
+  ModelRegistryEngine,
+  ModelRegistryEntryAddon,
+} from "../../schemas/registry.js";
+import type { ENGINE_TO_ADDON } from "../../schemas/engine-addon-map.js";
+
+type AddonOfEngine<E extends ModelRegistryEngine> = (typeof ENGINE_TO_ADDON)[E];
+
 export type RegistryItem = {
   name: string;
   registryPath: string;
@@ -74,24 +99,44 @@ export type RegistryItem = {
   blobBlockLength: number;
   blobByteOffset: number;
   modelId: string;
-  addon: "llm" | "whisper" | "embeddings" | "nmt" | "vad" | "tts" | "ocr" | "parakeet" | "diffusion" | "other";
+  addon: ModelRegistryEntryAddon;
   expectedSize: number;
   sha256Checksum: string;
-  engine: string;
+  engine: ModelRegistryEngine;
   quantization: string;
   params: string;
-  shardMetadata?: readonly { 
-    filename: string; 
-    expectedSize: number; 
-    sha256Checksum: string; 
-    blobCoreKey: string; 
+  shardMetadata?: readonly {
+    filename: string;
+    expectedSize: number;
+    sha256Checksum: string;
+    blobCoreKey: string;
     blobBlockOffset: number;
     blobBlockLength: number;
     blobByteOffset: number;
   }[];
+  companionSet?: {
+    setKey: string;
+    primaryKey: string;
+    files: readonly {
+      key: string;
+      registryPath: string;
+      registrySource: string;
+      targetName: string;
+      expectedSize: number;
+      sha256Checksum: string;
+      blobCoreKey: string;
+      blobBlockOffset: number;
+      blobBlockLength: number;
+      blobByteOffset: number;
+      primary?: boolean;
+    }[];
+  };
 };
 
-export type ModelConstant = {
+/** Generic so callers can preserve per-constant literals: \`ModelConstant<"llamacpp-completion">\`. */
+export type ModelConstant<
+  TEngine extends ModelRegistryEngine = ModelRegistryEngine,
+> = {
   name: string;
   src: string;
   registryPath: string;
@@ -103,8 +148,8 @@ export type ModelConstant = {
   modelId: string;
   expectedSize: number;
   sha256Checksum: string;
-  addon: "llm" | "whisper" | "embeddings" | "nmt" | "vad" | "tts" | "ocr" | "parakeet" | "diffusion" | "other";
-  engine: string;
+  addon: AddonOfEngine<TEngine>;
+  engine: TEngine;
   quantization: string;
   params: string;
 };
@@ -117,17 +162,33 @@ ${entries}
 // These contain all metadata and can be used directly: loadModel({ modelSrc: WHISPER_TINY, ... })
 ${exports}
 
-// Helper function to get model by name
+/**
+ * Looks up a model in the built-in catalog by its constant name.
+ *
+ * @param name - The model constant name (e.g. \`"WHISPER_TINY"\`) to look up.
+ * @returns The matching \`RegistryItem\`, or \`undefined\` when no catalog entry has that name.
+ */
 export function getModelByName(name: string): RegistryItem | undefined {
   return models.find((model) => model.name === name);
 }
 
-// Helper function to get model by registry path
+/**
+ * Looks up a model in the built-in catalog by its registry path.
+ *
+ * @param registryPath - Registry-relative path of the model to look up.
+ * @returns The matching \`RegistryItem\`, or \`undefined\` when no catalog entry has that registry path.
+ */
 export function getModelByPath(registryPath: string): RegistryItem | undefined {
   return models.find((model) => model.registryPath === registryPath);
 }
 
-// Helper function for blob-based lookups
+/**
+ * Looks up a model in the built-in catalog by model file ID and blob core key.
+ *
+ * @param modelId - The model file ID to match against the catalog.
+ * @param blobCoreKey - The Hyperdrive blob core key to match against the catalog.
+ * @returns The matching \`RegistryItem\`, or \`undefined\` when no catalog entry has both the given \`modelId\` and \`blobCoreKey\`.
+ */
 export function getModelBySrc(modelId: string, blobCoreKey: string): RegistryItem | undefined {
   return models.find((model) => model.modelId === modelId && model.blobCoreKey === blobCoreKey);
 }

package/dist/models/update-models/companions.d.ts

@@ -0,0 +1,18 @@
+import type { ProcessedModel } from "./types";
+/**
+ * Detects companion file relationships among processed models and
+ * attaches `companionSet` metadata to each primary entry.
+ * Companion-only entries are marked with `isCompanionOnly` so
+ * codegen can exclude them from exported model constants.
+ *
+ * Detection families:
+ *   ONNX pairs:
+ *     Primary: registryPath ends with `.onnx`
+ *     Companion: `${primaryPath}_data` or `${primaryPath}.data`
+ *
+ *   Bergamot NMT sets (directory-based):
+ *     Primary: `model.<langPair>.intgemm.alphas.bin`
+ *     Companions in same directory: lex, vocab/srcvocab+trgvocab, metadata
+ */
+export declare function groupCompanionSets(models: ProcessedModel[]): ProcessedModel[];
+//# sourceMappingURL=companions.d.ts.map

package/dist/models/update-models/companions.js

@@ -0,0 +1,175 @@
+import { createHash } from "crypto";
+import { BERGAMOT_MODEL_RE } from "../../schemas/index.js";
+/**
+ * Detects companion file relationships among processed models and
+ * attaches `companionSet` metadata to each primary entry.
+ * Companion-only entries are marked with `isCompanionOnly` so
+ * codegen can exclude them from exported model constants.
+ *
+ * Detection families:
+ *   ONNX pairs:
+ *     Primary: registryPath ends with `.onnx`
+ *     Companion: `${primaryPath}_data` or `${primaryPath}.data`
+ *
+ *   Bergamot NMT sets (directory-based):
+ *     Primary: `model.<langPair>.intgemm.alphas.bin`
+ *     Companions in same directory: lex, vocab/srcvocab+trgvocab, metadata
+ */
+export function groupCompanionSets(models) {
+    const bySourcePath = new Map();
+    for (const model of models) {
+        bySourcePath.set(sourceKey(model.registrySource, model.registryPath), model);
+    }
+    const companionKeys = new Set();
+    groupOnnxCompanions(models, bySourcePath, companionKeys);
+    groupBergamotCompanions(models, bySourcePath, companionKeys);
+    return models.map((model) => {
+        const key = sourceKey(model.registrySource, model.registryPath);
+        if (companionKeys.has(key)) {
+            return { ...model, isCompanionOnly: true };
+        }
+        return model;
+    });
+}
+function groupOnnxCompanions(models, bySourcePath, companionKeys) {
+    for (const model of models) {
+        if (!model.registryPath.endsWith(".onnx"))
+            continue;
+        const dataKey = findOnnxCompanionKey(model.registrySource, model.registryPath, bySourcePath);
+        if (!dataKey)
+            continue;
+        const companion = bySourcePath.get(dataKey);
+        const primaryFilename = model.registryPath.split("/").pop() || model.registryPath;
+        const dataFilename = companion.registryPath.split("/").pop() || companion.registryPath;
+        const setKey = shortHash(`${model.registrySource}:${model.registryPath}`);
+        const primaryEntry = {
+            key: "modelPath",
+            registryPath: model.registryPath,
+            registrySource: model.registrySource,
+            targetName: primaryFilename,
+            expectedSize: model.expectedSize,
+            sha256Checksum: model.sha256Checksum,
+            blobCoreKey: model.blobCoreKey,
+            blobBlockOffset: model.blobBlockOffset,
+            blobBlockLength: model.blobBlockLength,
+            blobByteOffset: model.blobByteOffset,
+            primary: true,
+        };
+        const dataEntry = {
+            key: "dataPath",
+            registryPath: companion.registryPath,
+            registrySource: companion.registrySource,
+            targetName: dataFilename,
+            expectedSize: companion.expectedSize,
+            sha256Checksum: companion.sha256Checksum,
+            blobCoreKey: companion.blobCoreKey,
+            blobBlockOffset: companion.blobBlockOffset,
+            blobBlockLength: companion.blobBlockLength,
+            blobByteOffset: companion.blobByteOffset,
+        };
+        const companionSetMetadata = {
+            setKey,
+            primaryKey: "modelPath",
+            files: [primaryEntry, dataEntry],
+        };
+        model.companionSet = companionSetMetadata;
+        companionKeys.add(dataKey);
+    }
+}
+function groupBergamotCompanions(models, bySourcePath, companionKeys) {
+    for (const model of models) {
+        const match = model.registryPath.match(BERGAMOT_MODEL_RE);
+        if (!match?.[1] || !match[2])
+            continue;
+        const dirPrefix = match[1];
+        const langPair = match[2];
+        const source = model.registrySource;
+        const companions = findBergamotCompanions(source, dirPrefix, langPair, bySourcePath);
+        if (companions.length === 0)
+            continue;
+        const primaryFilename = model.registryPath.split("/").pop();
+        const setKey = shortHash(`${source}:${model.registryPath}`);
+        const primaryEntry = {
+            key: "modelPath",
+            registryPath: model.registryPath,
+            registrySource: source,
+            targetName: primaryFilename,
+            expectedSize: model.expectedSize,
+            sha256Checksum: model.sha256Checksum,
+            blobCoreKey: model.blobCoreKey,
+            blobBlockOffset: model.blobBlockOffset,
+            blobBlockLength: model.blobBlockLength,
+            blobByteOffset: model.blobByteOffset,
+            primary: true,
+        };
+        const companionEntries = [];
+        for (const { key: entryKey, model: comp } of companions) {
+            const filename = comp.registryPath.split("/").pop();
+            companionEntries.push({
+                key: entryKey,
+                registryPath: comp.registryPath,
+                registrySource: comp.registrySource,
+                targetName: filename,
+                expectedSize: comp.expectedSize,
+                sha256Checksum: comp.sha256Checksum,
+                blobCoreKey: comp.blobCoreKey,
+                blobBlockOffset: comp.blobBlockOffset,
+                blobBlockLength: comp.blobBlockLength,
+                blobByteOffset: comp.blobByteOffset,
+            });
+            companionKeys.add(sourceKey(comp.registrySource, comp.registryPath));
+        }
+        model.companionSet = {
+            setKey,
+            primaryKey: "modelPath",
+            files: [primaryEntry, ...companionEntries],
+        };
+    }
+}
+function findBergamotCompanions(source, dirPrefix, langPair, bySourcePath) {
+    const found = [];
+    const lexPath = `${dirPrefix}lex.50.50.${langPair}.s2t.bin`;
+    const lexModel = bySourcePath.get(sourceKey(source, lexPath));
+    if (lexModel) {
+        found.push({ key: "lexPath", model: lexModel });
+    }
+    const sharedVocabPath = `${dirPrefix}vocab.${langPair}.spm`;
+    const sharedVocab = bySourcePath.get(sourceKey(source, sharedVocabPath));
+    if (sharedVocab) {
+        found.push({ key: "sharedVocabPath", model: sharedVocab });
+    }
+    else {
+        const srcVocabPath = `${dirPrefix}srcvocab.${langPair}.spm`;
+        const trgVocabPath = `${dirPrefix}trgvocab.${langPair}.spm`;
+        const srcVocab = bySourcePath.get(sourceKey(source, srcVocabPath));
+        const trgVocab = bySourcePath.get(sourceKey(source, trgVocabPath));
+        if (srcVocab && trgVocab) {
+            found.push({ key: "srcVocabPath", model: srcVocab });
+            found.push({ key: "dstVocabPath", model: trgVocab });
+        }
+    }
+    const metadataPath = `${dirPrefix}metadata.json`;
+    const metadata = bySourcePath.get(sourceKey(source, metadataPath));
+    if (metadata) {
+        found.push({ key: "metadataPath", model: metadata });
+    }
+    return found;
+}
+function sourceKey(source, path) {
+    return `${source}:${path}`;
+}
+function findOnnxCompanionKey(source, primaryPath, bySourcePath) {
+    const candidates = [
+        `${primaryPath}_data`,
+        `${primaryPath}.data`,
+    ];
+    for (const candidate of candidates) {
+        const key = sourceKey(source, candidate);
+        if (bySourcePath.has(key))
+            return key;
+    }
+    return undefined;
+}
+function shortHash(input) {
+    return createHash("sha256").update(input).digest("hex").substring(0, 16);
+}

package/dist/models/update-models/naming.js

@@ -167,9 +167,6 @@ function generateNmtName(input) {
         lowerFilename.includes("indictrans")) {
         return generateNmtIndictransName(input);
     }
-    if (lowerPath.includes("opus") || lowerFilename.includes("opus")) {
-        return generateNmtOpusName(input);
-    }
     if (lowerPath.includes("bergamot") || lowerFilename.includes("bergamot")) {
         return generateNmtBergamotName(input);
     }
@@ -194,28 +191,6 @@ function generateNmtIndictransName({ filename, quantization, }) {
     const nameParts = [langPair, "INDIC", size, quantization].filter((p) => p && p !== "");
     return `MARIAN_${nameParts.map(cleanPart).join("_")}`;
 }
-function generateNmtOpusName({ filename, quantization, tagExtra, }) {
-    const langMatch = filename.match(/-([a-z]{2,3})-([a-z]{2,3})\./i);
-    let langPair = "";
-    if (langMatch) {
-        langPair = `${langMatch[1].toUpperCase()}_${langMatch[2].toUpperCase()}`;
-    }
-    else {
-        const tagLang = tagExtra || "";
-        if (tagLang.match(/^[a-z]{2}-[a-z]{2}$/i)) {
-            const [src, tgt] = tagLang.split("-");
-            langPair = `${src.toUpperCase()}_${tgt.toUpperCase()}`;
-        }
-    }
-    if (!langPair) {
-        const roaMatch = filename.match(/-([a-z]{2,3})-([a-z]{2,3})-f16/i);
-        if (roaMatch) {
-            langPair = `${roaMatch[1].toUpperCase()}_${roaMatch[2].toUpperCase()}`;
-        }
-    }
-    const nameParts = [langPair, quantization].filter((p) => p && p !== "");
-    return `MARIAN_OPUS_${nameParts.map(cleanPart).join("_")}`;
-}
 function generateNmtBergamotName({ filename }) {
     const langMatch = filename.match(/[.]([a-z]{2,4})[.]/i);
     let langPair = "";

package/dist/models/update-models/registry.js

@@ -1,5 +1,6 @@
 import { QVACRegistryClient } from "@qvac/registry-client";
 import { groupShardedModels } from "./shards.js";
+import { groupCompanionSets } from "./companions.js";
 import { processRegistryModel } from "./processing.js";
 import { DEFAULT_REGISTRY_CORE_KEY } from "../../constants/index.js";
 // Re-export for backward compat
@@ -24,11 +25,12 @@ export async function collectModels(options = {}) {
         await client.close();
     }
     const groupedModels = groupShardedModels(models);
+    const withCompanions = groupCompanionSets(groupedModels);
     if (noDedup) {
         console.log(`\n⏭️  Skipping deduplication (--no-dedup flag set)`);
-        return groupedModels;
+        return withCompanions;
     }
-    return deduplicateModels(groupedModels, showDuplicates);
+    return deduplicateModels(withCompanions, showDuplicates);
 }
 function deduplicateModels(models, showDuplicates) {
     const seenChecksums = new Map();

package/dist/models/update-models/types.d.ts

@@ -10,8 +10,7 @@ export interface NotSharded {
     isSharded: false;
 }
 export type ShardDetection = ShardInfo | NotSharded;
-export interface ShardMetadataEntry {
-    filename: string;
+export interface BlobRef {
     expectedSize: number;
     sha256Checksum: string;
     blobCoreKey: string;
@@ -19,17 +18,44 @@ export interface ShardMetadataEntry {
     blobBlockLength: number;
     blobByteOffset: number;
 }
-export interface ProcessedModel {
+export interface ShardMetadataEntry extends BlobRef {
+    filename: string;
+}
+/**
+ * A single file within a companion set (e.g., an `.onnx` model or its `_data` file).
+ *
+ * @property key - Identifier for this file within the set
+ *   Used by plugins to look up resolved paths from the download artifacts.
+ * @property targetName - Filename used when writing to the cache directory.
+ * @property primary - When true, this is the main file whose resolved path is returned to
+ *   the addon. Exactly one file per set should be primary.
+ */
+export interface CompanionSetMetadataEntry extends BlobRef {
+    key: string;
+    registryPath: string;
+    registrySource: string;
+    targetName: string;
+    primary?: boolean;
+}
+/**
+ * Describes a group of files that must be downloaded and cached together
+ *
+ * @property setKey - Deterministic hash identifying this set. Used as the cache
+ *   subdirectory: `<cacheDir>/sets/<setKey>/`.
+ * @property primaryKey - The `key` value of the primary file in the `files` array.
+ *   The resolver returns this file's path to the addon after download.
+ * @property files - All files in the set, including the primary.
+ */
+export interface CompanionSetMetadata {
+    setKey: string;
+    primaryKey: string;
+    files: readonly CompanionSetMetadataEntry[];
+}
+export interface ProcessedModel extends BlobRef {
     registryPath: string;
     registrySource: string;
-    blobCoreKey: string;
-    blobBlockOffset: number;
-    blobBlockLength: number;
-    blobByteOffset: number;
     modelId: string;
     addon: ModelRegistryEntryAddon;
-    expectedSize: number;
-    sha256Checksum: string;
     engine: ModelRegistryEngine;
     modelName: string;
     quantization: string;
@@ -38,6 +64,8 @@ export interface ProcessedModel {
     isShardPart?: boolean;
     shardInfo?: ShardInfo;
     shardMetadata?: ShardMetadataEntry[];
+    companionSet?: CompanionSetMetadata;
+    isCompanionOnly?: boolean;
     name?: string;
 }
 export interface CurrentModel {

package/dist/profiling/index.d.ts

@@ -14,17 +14,66 @@
 import * as controller from "./controller";
 import type { ProfilerRuntimeOptions, ProfilingEvent, ProfilerExport, AggregatedStats } from "./types";
 export declare const profiler: {
+    /**
+     * Enables profiling and resets all previously aggregated data.
+     *
+     * @param options - Optional runtime options (profiling mode, server breakdown, operation filters, ring-buffer capacity).
+     */
     enable: (options?: ProfilerRuntimeOptions) => void;
+    /**
+     * Disables profiling. New SDK operations will no longer be recorded.
+     */
     disable: () => void;
+    /**
+     * Returns whether profiling is currently enabled.
+     *
+     * @returns `true` when profiling is currently enabled, `false` otherwise.
+     */
     isEnabled: () => boolean;
+    /**
+     * Exports profiling data as a structured JSON object suitable for machine consumption.
+     *
+     * @param options - Export options.
+     * @param options.includeRecentEvents - When `true`, includes the ring buffer of recent events in the export (only populated when profiler was enabled in `"verbose"` mode).
+     * @returns A `ProfilerExport` snapshot of aggregated stats and (optionally) recent events.
+     */
     exportJSON: (options?: {
         includeRecentEvents?: boolean;
     }) => ProfilerExport;
+    /**
+     * Exports aggregated stats as a formatted ASCII table suitable for terminal output.
+     *
+     * @returns A multi-line string rendering of the aggregated stats table.
+     */
     exportTable: () => string;
+    /**
+     * Exports a short, human-readable summary string of the aggregated stats.
+     *
+     * @returns A one-paragraph summary of the profiling data.
+     */
     exportSummary: () => string;
+    /**
+     * Registers a listener for profiling events; returns an unsubscribe function.
+     *
+     * @param callback - Invoked once per recorded profiling event.
+     * @returns An unsubscribe function; call it to remove the listener.
+     */
     onRecord: (callback: (event: ProfilingEvent) => void) => () => void;
+    /**
+     * Returns the current effective profiler configuration.
+     *
+     * @returns The effective `ResolvedProfilerConfig` (defaults merged with user overrides).
+     */
     getConfig: () => controller.ResolvedProfilerConfig;
+    /**
+     * Returns all aggregated stats keyed by operation name.
+     *
+     * @returns A record of `AggregatedStats` keyed by operation name.
+     */
     getAggregates: () => Record<string, AggregatedStats>;
+    /**
+     * Clears all aggregated data and the recent-events ring buffer.
+     */
     clear: () => void;
 };
 export type { ProfilerRuntimeOptions, ProfilingEvent, ProfilerExport, AggregatedStats, ProfilingEventKind, } from "./types";

package/dist/profiling/index.js

@@ -14,15 +14,64 @@
 import * as controller from "./controller.js";
 import * as exporters from "./exporters.js";
 export const profiler = {
+    /**
+     * Enables profiling and resets all previously aggregated data.
+     *
+     * @param options - Optional runtime options (profiling mode, server breakdown, operation filters, ring-buffer capacity).
+     */
     enable: (options) => controller.enable(options),
+    /**
+     * Disables profiling. New SDK operations will no longer be recorded.
+     */
     disable: () => controller.disable(),
+    /**
+     * Returns whether profiling is currently enabled.
+     *
+     * @returns `true` when profiling is currently enabled, `false` otherwise.
+     */
     isEnabled: () => controller.isEnabled(),
+    /**
+     * Exports profiling data as a structured JSON object suitable for machine consumption.
+     *
+     * @param options - Export options.
+     * @param options.includeRecentEvents - When `true`, includes the ring buffer of recent events in the export (only populated when profiler was enabled in `"verbose"` mode).
+     * @returns A `ProfilerExport` snapshot of aggregated stats and (optionally) recent events.
+     */
     exportJSON: (options) => exporters.exportJSON(options),
+    /**
+     * Exports aggregated stats as a formatted ASCII table suitable for terminal output.
+     *
+     * @returns A multi-line string rendering of the aggregated stats table.
+     */
     exportTable: () => exporters.exportTable(),
+    /**
+     * Exports a short, human-readable summary string of the aggregated stats.
+     *
+     * @returns A one-paragraph summary of the profiling data.
+     */
     exportSummary: () => exporters.exportSummary(),
+    /**
+     * Registers a listener for profiling events; returns an unsubscribe function.
+     *
+     * @param callback - Invoked once per recorded profiling event.
+     * @returns An unsubscribe function; call it to remove the listener.
+     */
     onRecord: (callback) => controller.onRecord(callback),
+    /**
+     * Returns the current effective profiler configuration.
+     *
+     * @returns The effective `ResolvedProfilerConfig` (defaults merged with user overrides).
+     */
     getConfig: () => controller.getEffectiveConfig(),
+    /**
+     * Returns all aggregated stats keyed by operation name.
+     *
+     * @returns A record of `AggregatedStats` keyed by operation name.
+     */
     getAggregates: () => controller.getAggregates(),
+    /**
+     * Clears all aggregated data and the recent-events ring buffer.
+     */
     clear: () => controller.clear(),
 };
 export { nowMs } from "./clock.js";

package/dist/schemas/cancel.d.ts

@@ -10,7 +10,6 @@ declare const cancelParamsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     downloadKey: z.ZodString;
     clearCache: z.ZodOptional<z.ZodBoolean>;
     delegate: z.ZodOptional<z.ZodObject<{
-        topic: z.ZodString;
         providerPublicKey: z.ZodString;
         timeout: z.ZodOptional<z.ZodNumber>;
         healthCheckTimeout: z.ZodOptional<z.ZodNumber>;
@@ -18,6 +17,9 @@ declare const cancelParamsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
 }, z.core.$strip>, z.ZodObject<{
     operation: z.ZodLiteral<"rag">;
     workspace: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    modelId: z.ZodString;
+    operation: z.ZodLiteral<"embeddings">;
 }, z.core.$strip>], "operation">;
 export declare const cancelRequestSchema: z.ZodIntersection<z.ZodObject<{
     type: z.ZodLiteral<"cancel">;
@@ -29,7 +31,6 @@ export declare const cancelRequestSchema: z.ZodIntersection<z.ZodObject<{
     downloadKey: z.ZodString;
     clearCache: z.ZodOptional<z.ZodBoolean>;
     delegate: z.ZodOptional<z.ZodObject<{
-        topic: z.ZodString;
         providerPublicKey: z.ZodString;
         timeout: z.ZodOptional<z.ZodNumber>;
         healthCheckTimeout: z.ZodOptional<z.ZodNumber>;
@@ -37,6 +38,9 @@ export declare const cancelRequestSchema: z.ZodIntersection<z.ZodObject<{
 }, z.core.$strip>, z.ZodObject<{
     operation: z.ZodLiteral<"rag">;
     workspace: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    modelId: z.ZodString;
+    operation: z.ZodLiteral<"embeddings">;
 }, z.core.$strip>], "operation">>;
 export declare const cancelResponseSchema: z.ZodObject<{
     type: z.ZodLiteral<"cancel">;