@qvac/sdk 0.10.0 → 0.10.1

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

@@ -1,4 +1,5 @@
 import type { CollectOptions, ProcessedModel } from "./types";
 export { processRegistryModel, extractModelName, toHexString, } from "./processing";
 export declare function collectModels(options?: CollectOptions): Promise<ProcessedModel[]>;
+export declare function deduplicateModels(models: ProcessedModel[], showDuplicates: boolean): ProcessedModel[];
 //# sourceMappingURL=registry.d.ts.map

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

@@ -32,7 +32,20 @@ export async function collectModels(options = {}) {
     }
     return deduplicateModels(withCompanions, showDuplicates);
 }
-function deduplicateModels(models, showDuplicates) {
+export function deduplicateModels(models, showDuplicates) {
+    // Paths referenced as companion files in any companion set. Dropping one of
+    // these on sha256 collision would leave its companion set without a
+    // standalone RegistryItem that `getModelByPath()` can resolve, causing
+    // recursive registry resolutions (e.g. the Bergamot shared vocab) to fall
+    // into the metadata-less fallback where `expectedSize` is `0`.
+    const companionReferencedPaths = new Set();
+    for (const m of models) {
+        if (!m.companionSet)
+            continue;
+        for (const f of m.companionSet.files) {
+            companionReferencedPaths.add(`${f.registrySource}:${f.registryPath}`);
+        }
+    }
     const seenChecksums = new Map();
     const dedupedModels = [];
     const skipped = [];
@@ -42,6 +55,11 @@ function deduplicateModels(models, showDuplicates) {
             continue;
         }
         if (seenChecksums.has(model.sha256Checksum)) {
+            const pathKey = `${model.registrySource}:${model.registryPath}`;
+            if (companionReferencedPaths.has(pathKey)) {
+                dedupedModels.push(model);
+                continue;
+            }
             skipped.push({
                 name: model.registryPath,
                 checksum: model.sha256Checksum,

package/dist/schemas/common.d.ts

@@ -3384,6 +3384,7 @@ export declare const requestSchema: z.ZodUnion<readonly [z.ZodObject<{
         hermes: "hermes";
         pythonic: "pythonic";
         json: "json";
+        harmony: "harmony";
     }>>;
     responseFormat: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"text">;

package/dist/schemas/completion-stream.d.ts

@@ -8,11 +8,13 @@ export { completionStatsSchema, type CompletionStats } from "./completion-event"
  * - `"hermes"`:   `<tool_call>{"name":"get_weather","arguments":{"city":"Tokyo"}}</tool_call>`
  * - `"pythonic"`: `[get_weather(city="Tokyo")]` (optionally `<|tool_call_start|>...<|tool_call_end|>`-wrapped)
  * - `"json"`:     `{"name":"get_weather","arguments":{"city":"Tokyo"}}` or `{"tool_calls":[{"name":"...","arguments":{...}}]}`
+ * - `"harmony"`:  `<|channel|>commentary to=functions.get_weather <|constrain|>json<|message|>{"city":"Tokyo"}<|call|>`
  */
 export declare const toolDialectSchema: z.ZodEnum<{
     hermes: "hermes";
     pythonic: "pythonic";
     json: "json";
+    harmony: "harmony";
 }>;
 export declare const attachmentSchema: z.ZodObject<{
     path: z.ZodString;
@@ -99,6 +101,7 @@ export declare const completionClientParamsSchema: z.ZodObject<{
         hermes: "hermes";
         pythonic: "pythonic";
         json: "json";
+        harmony: "harmony";
     }>>;
     responseFormat: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"text">;
@@ -162,6 +165,7 @@ export declare const completionStreamRequestSchema: z.ZodObject<{
         hermes: "hermes";
         pythonic: "pythonic";
         json: "json";
+        harmony: "harmony";
     }>>;
     responseFormat: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"text">;

package/dist/schemas/completion-stream.js

@@ -10,8 +10,9 @@ export { completionStatsSchema } from "./completion-event.js";
  * - `"hermes"`:   `<tool_call>{"name":"get_weather","arguments":{"city":"Tokyo"}}</tool_call>`
  * - `"pythonic"`: `[get_weather(city="Tokyo")]` (optionally `<|tool_call_start|>...<|tool_call_end|>`-wrapped)
  * - `"json"`:     `{"name":"get_weather","arguments":{"city":"Tokyo"}}` or `{"tool_calls":[{"name":"...","arguments":{...}}]}`
+ * - `"harmony"`:  `<|channel|>commentary to=functions.get_weather <|constrain|>json<|message|>{"city":"Tokyo"}<|call|>`
  */
-export const toolDialectSchema = z.enum(["hermes", "pythonic", "json"]);
+export const toolDialectSchema = z.enum(["hermes", "pythonic", "json", "harmony"]);
 export const attachmentSchema = z.object({
     path: z
         .string()

package/dist/server/bare/plugins/llamacpp-completion/plugin.d.ts

@@ -165,6 +165,7 @@ export declare const llmPlugin: {
                 hermes: "hermes";
                 pythonic: "pythonic";
                 json: "json";
+                harmony: "harmony";
             }>>;
             responseFormat: import("zod").ZodOptional<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
                 type: import("zod").ZodLiteral<"text">;

package/dist/server/bare/plugins/llamacpp-completion/plugin.js

@@ -91,9 +91,9 @@ export const llmPlugin = definePlugin({
                     toolCalling: toolsActive ? "textParse" : "none",
                     thinkingFraming: request.captureThinking ? "thinkTags" : "none",
                 };
-                const dialect = toolsActive
-                    ? (request.toolDialect ?? detectToolDialect(request.modelId))
-                    : "hermes";
+                // Dialect runs regardless of tool availability — thinking/content
+                // stripping is needed even on plain completions.
+                const dialect = request.toolDialect ?? detectToolDialect(request.modelId);
                 const normalizer = createCompletionNormalizer({
                     capabilities,
                     tools: request.tools ?? [],

package/dist/server/bare/plugins/nmtcpp-translation/plugin.js

@@ -3,35 +3,9 @@ import TranslationNmtcpp, {} from "@qvac/translation-nmtcpp";
 import { definePlugin, defineHandler, translateRequestSchema, translateResponseSchema, ModelType, nmtConfigBaseSchema, ADDON_NMT, BERGAMOT_CJK_LANG_PAIRS, } from "../../../../schemas/index.js";
 import { createStreamLogger, registerAddonLogger } from "../../../../logging/index.js";
 import path from "bare-path";
-import { ModelLoadFailedError } from "../../../../utils/errors-server.js";
 import { translate } from "../../ops/translate.js";
 import { attachModelExecutionMs } from "../../../../profiling/model-execution.js";
-function buildBergamotVocabSources(basePath, langPair) {
-    if (BERGAMOT_CJK_LANG_PAIRS.includes(langPair)) {
-        return {
-            srcVocabSrc: `${basePath}srcvocab.${langPair}.spm`,
-            dstVocabSrc: `${basePath}trgvocab.${langPair}.spm`,
-        };
-    }
-    const sharedVocab = `${basePath}vocab.${langPair}.spm`;
-    return { srcVocabSrc: sharedVocab, dstVocabSrc: sharedVocab };
-}
-function deriveBergamotVocabSources(modelSrc) {
-    const match = modelSrc.match(/^pear:\/\/([a-f0-9]+)\/model\.([a-z]+)\.intgemm\.alphas\.bin$/);
-    if (!match?.[1] || !match[2])
-        return null;
-    const basePath = `pear://${match[1]}/`;
-    const langPair = match[2];
-    return buildBergamotVocabSources(basePath, langPair);
-}
-function deriveBergamotRegistryVocabSources(modelSrc) {
-    const match = modelSrc.match(/^(registry:\/\/.+\/)model\.([a-z]+)\.intgemm\.alphas\.bin$/);
-    if (!match?.[1] || !match[2])
-        return null;
-    const basePath = match[1];
-    const langPair = match[2];
-    return buildBergamotVocabSources(basePath, langPair);
-}
+import { resolveBergamotVocab, } from "./resolve-vocab.js";
 /**
  * Derive absolute vocab paths from a resolved Bergamot model path.
  * Works for both companion-set layout (colocated files) and any layout where
@@ -101,61 +75,6 @@ function createNmtModel(modelId, modelPath, nmtConfig, srcVocabPath, dstVocabPat
     });
     return { model };
 }
-async function resolveBergamotVocab(nmtConfig, ctx, srcVocabSrc, dstVocabSrc, pivotModel) {
-    let srcSrc = srcVocabSrc;
-    let dstSrc = dstVocabSrc;
-    if (!srcSrc || !dstSrc) {
-        const derived = ctx.modelSrc.startsWith("pear://")
-            ? deriveBergamotVocabSources(ctx.modelSrc)
-            : ctx.modelSrc.startsWith("registry://")
-                ? deriveBergamotRegistryVocabSources(ctx.modelSrc)
-                : null;
-        if (derived) {
-            srcSrc = srcSrc ?? derived.srcVocabSrc;
-            dstSrc = dstSrc ?? derived.dstVocabSrc;
-        }
-    }
-    if (!srcSrc || !dstSrc) {
-        throw new ModelLoadFailedError("Bergamot requires srcVocabSrc and dstVocabSrc. Provide them in modelConfig or use a pear:// or registry:// model source for auto-derivation.");
-    }
-    if (!pivotModel) {
-        const [srcVocabPath, dstVocabPath] = await Promise.all([
-            ctx.resolveModelPath(srcSrc),
-            ctx.resolveModelPath(dstSrc),
-        ]);
-        return {
-            config: nmtConfig,
-            artifacts: { srcVocabPath, dstVocabPath },
-        };
-    }
-    let pivotSrcSrc = pivotModel.srcVocabSrc;
-    let pivotDstSrc = pivotModel.dstVocabSrc;
-    if (!pivotSrcSrc || !pivotDstSrc) {
-        const pivotDerived = pivotModel.modelSrc.startsWith("pear://")
-            ? deriveBergamotVocabSources(pivotModel.modelSrc)
-            : pivotModel.modelSrc.startsWith("registry://")
-                ? deriveBergamotRegistryVocabSources(pivotModel.modelSrc)
-                : null;
-        if (pivotDerived) {
-            pivotSrcSrc = pivotSrcSrc ?? pivotDerived.srcVocabSrc;
-            pivotDstSrc = pivotDstSrc ?? pivotDerived.dstVocabSrc;
-        }
-    }
-    if (!pivotSrcSrc || !pivotDstSrc) {
-        throw new ModelLoadFailedError("Bergamot pivot model requires srcVocabSrc and dstVocabSrc. Provide them in modelConfig or use a pear:// or registry:// model source for auto-derivation.");
-    }
-    const [srcVocabPath, dstVocabPath, pivotSrcVocabPath, pivotDstVocabPath, pivotModelPath] = await Promise.all([
-        ctx.resolveModelPath(srcSrc),
-        ctx.resolveModelPath(dstSrc),
-        ctx.resolveModelPath(pivotSrcSrc),
-        ctx.resolveModelPath(pivotDstSrc),
-        ctx.resolveModelPath(pivotModel.modelSrc),
-    ]);
-    return {
-        config: nmtConfig,
-        artifacts: { srcVocabPath, dstVocabPath, pivotSrcVocabPath, pivotDstVocabPath, pivotModelPath },
-    };
-}
 export const nmtPlugin = definePlugin({
     modelType: ModelType.nmtcppTranslation,
     displayName: "NMT (nmtcpp)",

package/dist/server/bare/plugins/nmtcpp-translation/resolve-vocab.d.ts

@@ -0,0 +1,32 @@
+import { type ModelSrcInput, type NmtConfig, type ResolveContext, type ResolveResult } from "../../../../schemas/index";
+export interface PivotModelConfig {
+    modelSrc: string;
+    srcVocabSrc?: ModelSrcInput;
+    dstVocabSrc?: ModelSrcInput;
+}
+export declare function buildBergamotVocabSources(basePath: string, langPair: string): {
+    srcVocabSrc: string;
+    dstVocabSrc: string;
+};
+export declare function deriveBergamotVocabSources(modelSrc: string): {
+    srcVocabSrc: string;
+    dstVocabSrc: string;
+} | null;
+export declare function deriveBergamotRegistryVocabSources(modelSrc: string): {
+    srcVocabSrc: string;
+    dstVocabSrc: string;
+} | null;
+/**
+ * Resolves Bergamot vocab sources to absolute filesystem paths via the SDK
+ * resolver context, optionally including a pivot model.
+ *
+ * For `registry://` sources with auto-derived vocabs, this skips per-vocab
+ * resolution because the companion-set download already colocates the vocabs
+ * next to the primary model under `sets/<setKey>/`. `createModel` then derives
+ * the colocated paths via `deriveColocatedBergamotVocabPaths`. This avoids a
+ * redundant flat-cache copy and sidesteps the dedup edge case in QVAC-18420
+ * where two directions of a bidirectional pair ship the same vocab blob under
+ * distinct registry paths and only one survives sha256 dedup.
+ */
+export declare function resolveBergamotVocab(nmtConfig: NmtConfig, ctx: ResolveContext, srcVocabSrc: ModelSrcInput | undefined, dstVocabSrc: ModelSrcInput | undefined, pivotModel?: PivotModelConfig): Promise<ResolveResult<Record<string, unknown>>>;
+//# sourceMappingURL=resolve-vocab.d.ts.map

package/dist/server/bare/plugins/nmtcpp-translation/resolve-vocab.js

@@ -0,0 +1,117 @@
+import { BERGAMOT_CJK_LANG_PAIRS, } from "../../../../schemas/index.js";
+import { ModelLoadFailedError } from "../../../../utils/errors-server.js";
+export function buildBergamotVocabSources(basePath, langPair) {
+    if (BERGAMOT_CJK_LANG_PAIRS.includes(langPair)) {
+        return {
+            srcVocabSrc: `${basePath}srcvocab.${langPair}.spm`,
+            dstVocabSrc: `${basePath}trgvocab.${langPair}.spm`,
+        };
+    }
+    const sharedVocab = `${basePath}vocab.${langPair}.spm`;
+    return { srcVocabSrc: sharedVocab, dstVocabSrc: sharedVocab };
+}
+export function deriveBergamotVocabSources(modelSrc) {
+    const match = modelSrc.match(/^pear:\/\/([a-f0-9]+)\/model\.([a-z]+)\.intgemm\.alphas\.bin$/);
+    if (!match?.[1] || !match[2])
+        return null;
+    const basePath = `pear://${match[1]}/`;
+    const langPair = match[2];
+    return buildBergamotVocabSources(basePath, langPair);
+}
+export function deriveBergamotRegistryVocabSources(modelSrc) {
+    const match = modelSrc.match(/^(registry:\/\/.+\/)model\.([a-z]+)\.intgemm\.alphas\.bin$/);
+    if (!match?.[1] || !match[2])
+        return null;
+    const basePath = match[1];
+    const langPair = match[2];
+    return buildBergamotVocabSources(basePath, langPair);
+}
+/**
+ * Resolves Bergamot vocab sources to absolute filesystem paths via the SDK
+ * resolver context, optionally including a pivot model.
+ *
+ * For `registry://` sources with auto-derived vocabs, this skips per-vocab
+ * resolution because the companion-set download already colocates the vocabs
+ * next to the primary model under `sets/<setKey>/`. `createModel` then derives
+ * the colocated paths via `deriveColocatedBergamotVocabPaths`. This avoids a
+ * redundant flat-cache copy and sidesteps the dedup edge case in QVAC-18420
+ * where two directions of a bidirectional pair ship the same vocab blob under
+ * distinct registry paths and only one survives sha256 dedup.
+ */
+export async function resolveBergamotVocab(nmtConfig, ctx, srcVocabSrc, dstVocabSrc, pivotModel) {
+    let srcSrc = srcVocabSrc;
+    let dstSrc = dstVocabSrc;
+    if (!srcSrc || !dstSrc) {
+        const derived = ctx.modelSrc.startsWith("pear://")
+            ? deriveBergamotVocabSources(ctx.modelSrc)
+            : ctx.modelSrc.startsWith("registry://")
+                ? deriveBergamotRegistryVocabSources(ctx.modelSrc)
+                : null;
+        if (derived) {
+            srcSrc = srcSrc ?? derived.srcVocabSrc;
+            dstSrc = dstSrc ?? derived.dstVocabSrc;
+        }
+    }
+    if (!srcSrc || !dstSrc) {
+        throw new ModelLoadFailedError("Bergamot requires srcVocabSrc and dstVocabSrc. Provide them in modelConfig or use a pear:// or registry:// model source for auto-derivation.");
+    }
+    if (!pivotModel) {
+        const modelIsRegistry = ctx.modelSrc.startsWith("registry://");
+        const vocabsAreDerived = !srcVocabSrc && !dstVocabSrc;
+        if (modelIsRegistry && vocabsAreDerived) {
+            return { config: nmtConfig };
+        }
+        const [srcVocabPath, dstVocabPath] = await Promise.all([
+            ctx.resolveModelPath(srcSrc),
+            ctx.resolveModelPath(dstSrc),
+        ]);
+        return {
+            config: nmtConfig,
+            artifacts: { srcVocabPath, dstVocabPath },
+        };
+    }
+    let pivotSrcSrc = pivotModel.srcVocabSrc;
+    let pivotDstSrc = pivotModel.dstVocabSrc;
+    if (!pivotSrcSrc || !pivotDstSrc) {
+        const pivotDerived = pivotModel.modelSrc.startsWith("pear://")
+            ? deriveBergamotVocabSources(pivotModel.modelSrc)
+            : pivotModel.modelSrc.startsWith("registry://")
+                ? deriveBergamotRegistryVocabSources(pivotModel.modelSrc)
+                : null;
+        if (pivotDerived) {
+            pivotSrcSrc = pivotSrcSrc ?? pivotDerived.srcVocabSrc;
+            pivotDstSrc = pivotDstSrc ?? pivotDerived.dstVocabSrc;
+        }
+    }
+    if (!pivotSrcSrc || !pivotDstSrc) {
+        throw new ModelLoadFailedError("Bergamot pivot model requires srcVocabSrc and dstVocabSrc. Provide them in modelConfig or use a pear:// or registry:// model source for auto-derivation.");
+    }
+    const modelIsRegistry = ctx.modelSrc.startsWith("registry://");
+    const pivotIsRegistry = pivotModel.modelSrc.startsWith("registry://");
+    const primaryVocabsAreDerived = !srcVocabSrc && !dstVocabSrc;
+    const pivotVocabsAreDerived = !pivotModel.srcVocabSrc && !pivotModel.dstVocabSrc;
+    if (modelIsRegistry &&
+        pivotIsRegistry &&
+        primaryVocabsAreDerived &&
+        pivotVocabsAreDerived) {
+        const pivotModelPath = await ctx.resolveModelPath(pivotModel.modelSrc);
+        return { config: nmtConfig, artifacts: { pivotModelPath } };
+    }
+    const [srcVocabPath, dstVocabPath, pivotSrcVocabPath, pivotDstVocabPath, pivotModelPath,] = await Promise.all([
+        ctx.resolveModelPath(srcSrc),
+        ctx.resolveModelPath(dstSrc),
+        ctx.resolveModelPath(pivotSrcSrc),
+        ctx.resolveModelPath(pivotDstSrc),
+        ctx.resolveModelPath(pivotModel.modelSrc),
+    ]);
+    return {
+        config: nmtConfig,
+        artifacts: {
+            srcVocabPath,
+            dstVocabPath,
+            pivotSrcVocabPath,
+            pivotDstVocabPath,
+            pivotModelPath,
+        },
+    };
+}