@qvac/sdk 0.17.0 → 0.18.0

package/dist/examples/llamacpp-dynamic-tools.js

@@ -1,152 +0,0 @@
-/**
- * Dynamic-tools mode example.
- *
- * In `dynamic` mode each user prompt can carry its own tool set: the addon
- * anchors tools after the last user message, runs the tool-call chain, then
- * trims the tools + chain output from the kv-cache so a later turn can ship
- * a different tool list without poisoning the cache. Compare with
- * `llamacpp-native-tools.ts`, which uses the default `static` mode where
- * one shared tool set lives at the top of the session.
- *
- * Run with:
- *   bun run build
- *   bun run bare:example dist/examples/llamacpp-dynamic-tools.js
- */
-import { z } from 'zod';
-import { completion, loadModel, unloadModel, QWEN3_1_7B_INST_Q4 } from '@qvac/sdk';
-const weatherSchema = z.object({
-    city: z.string().describe('City name')
-});
-const horoscopeSchema = z.object({
-    sign: z.string().describe('An astrological sign, e.g. Taurus or Aquarius')
-});
-const dateSchema = z.object({});
-const toolSchemas = {
-    get_weather: weatherSchema,
-    get_horoscope: horoscopeSchema,
-    get_date: dateSchema
-};
-const weatherTools = [
-    {
-        name: 'get_weather',
-        description: 'Get current weather for a city',
-        parameters: weatherSchema
-    }
-];
-const horoscopeTools = [
-    {
-        name: 'get_horoscope',
-        description: "Get today's horoscope for an astrological sign",
-        parameters: horoscopeSchema
-    }
-];
-const dateTools = [
-    {
-        name: 'get_date',
-        description: "Get today's date",
-        parameters: dateSchema
-    }
-];
-function executeToolCall(call) {
-    if (call.name === 'get_weather') {
-        const args = call.arguments;
-        return `The weather in ${args.city} is rainy, 8°C with heavy clouds.`;
-    }
-    if (call.name === 'get_horoscope') {
-        const args = call.arguments;
-        return `Horoscope for ${args.sign}: a great day for new beginnings.`;
-    }
-    if (call.name === 'get_date') {
-        return new Date().toISOString().slice(0, 10);
-    }
-    return `Unknown tool: ${call.name}`;
-}
-async function chatTurn({ modelId, kvCache, history, tools }) {
-    const result = completion({
-        modelId,
-        history,
-        tools,
-        kvCache,
-        stream: true
-    });
-    const tokensTask = (async () => {
-        for await (const token of result.tokenStream) {
-            process.stdout.write(token);
-        }
-    })();
-    const toolEventsTask = (async () => {
-        for await (const evt of result.toolCallStream) {
-            console.log(`\n▸ tool call: ${evt.call.name}(${JSON.stringify(evt.call.arguments)})`);
-        }
-    })();
-    await Promise.all([tokensTask, toolEventsTask]);
-    const text = await result.text;
-    const toolCalls = await result.toolCalls;
-    if (toolCalls.length === 0) {
-        history.push({ role: 'assistant', content: text });
-        return;
-    }
-    for (const call of toolCalls) {
-        const schema = toolSchemas[call.name];
-        if (schema) {
-            const parsed = schema.safeParse(call.arguments);
-            if (!parsed.success) {
-                console.log(`✖ validation failed for ${call.name}:`, parsed.error);
-            }
-        }
-    }
-    history.push({ role: 'assistant', content: text });
-    for (const call of toolCalls) {
-        history.push({ role: 'tool', content: executeToolCall(call) });
-    }
-    // Follow-up turn so the model can incorporate the tool results.
-    await chatTurn({ modelId, kvCache, history, tools });
-}
-async function main() {
-    const modelId = await loadModel({
-        modelSrc: QWEN3_1_7B_INST_Q4,
-        modelConfig: {
-            ctx_size: 4096,
-            tools: true,
-            toolsMode: 'dynamic'
-        },
-        onProgress: (p) => {
-            const mb = (n) => (n / 1e6).toFixed(1);
-            const line = `▸ Downloading ${p.percentage.toFixed(0)}% (${mb(p.downloaded)}/${mb(p.total)} MB)`;
-            process.stderr.write(process.stderr.isTTY ? `\r${line}` : `${line}\n`);
-            if (p.percentage >= 100)
-                process.stderr.write('\n');
-        }
-    });
-    console.log(`▸ Model loaded: ${modelId}`);
-    const kvCache = `dynamic-tools-${Date.now()}`;
-    const history = [
-        {
-            role: 'system',
-            content: 'You are a helpful assistant that uses tools when they are available. ' +
-                "User's cat is named Windy and dog is named Butch."
-        }
-    ];
-    // Turn 1 — only weather tools available.
-    history.push({ role: 'user', content: "What's the weather in Tokyo?" });
-    console.log('\n▸ Turn 1 (tools=weather):\n');
-    await chatTurn({ modelId, kvCache, history, tools: weatherTools });
-    // Turn 2 — same session, swap to horoscope tools. Dynamic mode lets the
-    // model see a different tool set without invalidating the kv-cache.
-    history.push({
-        role: 'user',
-        content: 'Now check my horoscope for Aquarius.'
-    });
-    console.log('\n\n▸ Turn 2 (tools=horoscope):\n');
-    await chatTurn({ modelId, kvCache, history, tools: horoscopeTools });
-    // Turn 3 — swap to a parameterless tool to confirm empty-arg flows work.
-    history.push({ role: 'user', content: "What's today's date?" });
-    console.log('\n\n▸ Turn 3 (tools=date):\n');
-    await chatTurn({ modelId, kvCache, history, tools: dateTools });
-    console.log('\n\n▸ Done.');
-    await unloadModel({ modelId, clearStorage: false });
-}
-main().catch((err) => {
-    console.error('✖', err);
-    process.exit(1);
-});

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

@@ -1,3 +0,0 @@
-import type { ProcessedModel } from './types.js';
-export declare function generateModelsFileContent(models: ProcessedModel[]): string;
-//# sourceMappingURL=codegen.d.ts.map

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

@@ -1,196 +0,0 @@
-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: 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) => {
-        const addonAlias = m.addon;
-        let entry = `  {
-    name: "${m.name}",
-    registryPath: "${m.registryPath}",
-    registrySource: "${m.registrySource}",
-    blobCoreKey: "${m.blobCoreKey}",
-    blobBlockOffset: ${m.blobBlockOffset},
-    blobBlockLength: ${m.blobBlockLength},
-    blobByteOffset: ${m.blobByteOffset},
-    modelId: "${m.modelId}",
-    addon: "${addonAlias}",
-    expectedSize: ${m.expectedSize},
-    sha256Checksum: "${m.sha256Checksum}",
-    engine: "${m.engine}",
-    quantization: "${m.quantization || ''}",
-    params: "${m.params || ''}"`;
-        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
-        .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}\`,
-  registryPath: models[${i}].registryPath,
-  registrySource: models[${i}].registrySource,
-  blobCoreKey: models[${i}].blobCoreKey,
-  blobBlockOffset: models[${i}].blobBlockOffset,
-  blobBlockLength: models[${i}].blobBlockLength,
-  blobByteOffset: models[${i}].blobByteOffset,
-  modelId: models[${i}].modelId,
-  expectedSize: models[${i}].expectedSize,
-  sha256Checksum: models[${i}].sha256Checksum,
-  addon: models[${i}].addon,
-  engine: models[${i}].engine,
-  quantization: models[${i}].quantization,
-  params: models[${i}].params,
-} as const;`;
-    })
-        .join('\n\n');
-    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;
-  registrySource: string;
-  blobCoreKey: string;
-  blobBlockOffset: number;
-  blobBlockLength: number;
-  blobByteOffset: number;
-  modelId: string;
-  addon: ModelRegistryEntryAddon;
-  expectedSize: number;
-  sha256Checksum: string;
-  engine: ModelRegistryEngine;
-  quantization: string;
-  params: 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;
-    }[];
-  };
-};
-
-/** Generic so callers can preserve per-constant literals: \`ModelConstant<"llamacpp-completion">\`. */
-export type ModelConstant<
-  TEngine extends ModelRegistryEngine = ModelRegistryEngine,
-> = {
-  name: string;
-  src: string;
-  registryPath: string;
-  registrySource: string;
-  blobCoreKey: string;
-  blobBlockOffset: number;
-  blobBlockLength: number;
-  blobByteOffset: number;
-  modelId: string;
-  expectedSize: number;
-  sha256Checksum: string;
-  addon: AddonOfEngine<TEngine>;
-  engine: TEngine;
-  quantization: string;
-  params: string;
-};
-
-export const models = [
-${entries}
-] as const satisfies readonly RegistryItem[];
-
-// Individual model constants for direct import/use with loadModel
-// These contain all metadata and can be used directly: loadModel({ modelSrc: WHISPER_TINY, ... })
-${exports}
-
-/**
- * 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);
-}
-
-/**
- * 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);
-}
-
-/**
- * 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

@@ -1,30 +0,0 @@
-import type { ProcessedModel } from './types.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
- *
- *   BCI whisper.cpp sets (directory-based):
- *     Primary: `ggml-bci-windowed.bin`
- *     Companion in same directory: `bci-embedder.bin`
- *     The addon resolves the embedder by exact filename next to the model
- *     (`dirname(model)/bci-embedder.bin`), so the two files must be
- *     physically co-located — which the companion-set cache layout guarantees.
- *
- *   Chatterbox MeCab/IPAdic sets (directory-based):
- *     Primary: `char.bin`
- *     Companions in same directory: dicrc, matrix.bin, mecabrc, sys.dic, unk.dic
- *     The TTS addon receives the containing directory for Japanese tokenization.
- */
-export declare function groupCompanionSets(models: ProcessedModel[]): ProcessedModel[];
-//# sourceMappingURL=companions.d.ts.map

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

@@ -1,296 +0,0 @@
-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
- *
- *   BCI whisper.cpp sets (directory-based):
- *     Primary: `ggml-bci-windowed.bin`
- *     Companion in same directory: `bci-embedder.bin`
- *     The addon resolves the embedder by exact filename next to the model
- *     (`dirname(model)/bci-embedder.bin`), so the two files must be
- *     physically co-located — which the companion-set cache layout guarantees.
- *
- *   Chatterbox MeCab/IPAdic sets (directory-based):
- *     Primary: `char.bin`
- *     Companions in same directory: dicrc, matrix.bin, mecabrc, sys.dic, unk.dic
- *     The TTS addon receives the containing directory for Japanese tokenization.
- */
-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);
-    groupBciCompanions(models, bySourcePath, companionKeys);
-    groupMecabCompanions(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]
-        };
-    }
-}
-const BCI_PRIMARY_FILENAME = 'ggml-bci-windowed.bin';
-const BCI_EMBEDDER_FILENAME = 'bci-embedder.bin';
-function groupBciCompanions(models, bySourcePath, companionKeys) {
-    for (const model of models) {
-        const filename = model.registryPath.split('/').pop();
-        if (filename !== BCI_PRIMARY_FILENAME)
-            continue;
-        const lastSep = model.registryPath.lastIndexOf('/');
-        const dirPrefix = lastSep >= 0 ? model.registryPath.slice(0, lastSep + 1) : '';
-        const source = model.registrySource;
-        const embedderPath = `${dirPrefix}${BCI_EMBEDDER_FILENAME}`;
-        const embedder = bySourcePath.get(sourceKey(source, embedderPath));
-        if (!embedder)
-            continue;
-        const setKey = shortHash(`${source}:${model.registryPath}`);
-        const primaryEntry = {
-            key: 'modelPath',
-            registryPath: model.registryPath,
-            registrySource: source,
-            targetName: BCI_PRIMARY_FILENAME,
-            expectedSize: model.expectedSize,
-            sha256Checksum: model.sha256Checksum,
-            blobCoreKey: model.blobCoreKey,
-            blobBlockOffset: model.blobBlockOffset,
-            blobBlockLength: model.blobBlockLength,
-            blobByteOffset: model.blobByteOffset,
-            primary: true
-        };
-        const embedderEntry = {
-            key: 'embedderPath',
-            registryPath: embedder.registryPath,
-            registrySource: embedder.registrySource,
-            targetName: BCI_EMBEDDER_FILENAME,
-            expectedSize: embedder.expectedSize,
-            sha256Checksum: embedder.sha256Checksum,
-            blobCoreKey: embedder.blobCoreKey,
-            blobBlockOffset: embedder.blobBlockOffset,
-            blobBlockLength: embedder.blobBlockLength,
-            blobByteOffset: embedder.blobByteOffset
-        };
-        model.companionSet = {
-            setKey,
-            primaryKey: 'modelPath',
-            files: [primaryEntry, embedderEntry]
-        };
-        companionKeys.add(sourceKey(embedder.registrySource, embedder.registryPath));
-    }
-}
-const MECAB_PRIMARY_FILENAME = 'char.bin';
-const MECAB_REQUIRED_FILENAMES = ['dicrc', 'matrix.bin', 'mecabrc', 'sys.dic', 'unk.dic'];
-const MECAB_IPADIC_DIR_SUFFIX = '/mecab-ipadic/';
-function groupMecabCompanions(models, bySourcePath, companionKeys) {
-    for (const model of models) {
-        if (!model.registryPath.includes(MECAB_IPADIC_DIR_SUFFIX))
-            continue;
-        const lastSep = model.registryPath.lastIndexOf('/');
-        const filename = lastSep >= 0 ? model.registryPath.slice(lastSep + 1) : model.registryPath;
-        if (filename !== MECAB_PRIMARY_FILENAME)
-            continue;
-        const dirPrefix = lastSep >= 0 ? model.registryPath.slice(0, lastSep + 1) : '';
-        const source = model.registrySource;
-        const companions = findMecabCompanions(source, dirPrefix, bySourcePath);
-        if (companions.length !== MECAB_REQUIRED_FILENAMES.length)
-            continue;
-        const setKey = shortHash(`${source}:${dirPrefix}`);
-        const primaryEntry = {
-            key: 'mecabDictPath',
-            registryPath: model.registryPath,
-            registrySource: source,
-            targetName: MECAB_PRIMARY_FILENAME,
-            expectedSize: model.expectedSize,
-            sha256Checksum: model.sha256Checksum,
-            blobCoreKey: model.blobCoreKey,
-            blobBlockOffset: model.blobBlockOffset,
-            blobBlockLength: model.blobBlockLength,
-            blobByteOffset: model.blobByteOffset,
-            primary: true
-        };
-        const companionEntries = companions.map(({ filename, model: comp }) => {
-            companionKeys.add(sourceKey(comp.registrySource, comp.registryPath));
-            return {
-                key: `mecab:${filename}`,
-                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
-            };
-        });
-        model.companionSet = {
-            setKey,
-            primaryKey: 'mecabDictPath',
-            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 findMecabCompanions(source, dirPrefix, bySourcePath) {
-    const found = [];
-    for (const filename of MECAB_REQUIRED_FILENAMES) {
-        const model = bySourcePath.get(sourceKey(source, `${dirPrefix}${filename}`));
-        if (!model)
-            return [];
-        found.push({ filename, model });
-    }
-    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);
-}