@qvac/sdk 0.14.1 → 0.16.0

package/dist/schemas/embed.js

@@ -1,46 +1,35 @@
-import { z } from "zod";
+import { z } from 'zod';
 export const embedParamsSchema = z.object({
-    modelId: z.string().describe("The identifier of the embedding model to use"),
+    modelId: z.string().describe('The identifier of the embedding model to use'),
     text: z
         .union([
-        z.string().min(1, "Text cannot be empty"),
-        z
-            .array(z.string().min(1, "Text cannot be empty"))
-            .min(1, "Text array cannot be empty"),
+        z.string().min(1, 'Text cannot be empty'),
+        z.array(z.string().min(1, 'Text cannot be empty')).min(1, 'Text array cannot be empty')
     ])
-        .describe("The input text(s) to embed. A single string returns `number[]`; an array returns `number[][]`."),
+        .describe('The input text(s) to embed. A single string returns `number[]`; an array returns `number[][]`.')
 });
 export const embedRequestSchema = embedParamsSchema.extend({
-    type: z.literal("embed"),
+    type: z.literal('embed'),
     requestId: z
         .string()
         .min(1)
         .optional()
-        .describe("Stable identifier for this in-flight embed, generated by the client at call time. Surfaces on the registry so callers can target it with `cancel({ requestId })`. Optional on the wire — the server falls back to a server-generated id when the field is missing."),
+        .describe('Stable identifier for this in-flight embed, generated by the client at call time. Surfaces on the registry so callers can target it with `cancel({ requestId })`. Optional on the wire — the server falls back to a server-generated id when the field is missing.')
 });
 export const embedStatsSchema = z.object({
-    totalTime: z
-        .number()
-        .optional()
-        .describe("Total embedding time in milliseconds"),
-    tokensPerSecond: z
-        .number()
-        .optional()
-        .describe("Tokens processed per second"),
-    totalTokens: z.number().optional().describe("Total tokens processed"),
-    backendDevice: z
-        .enum(["cpu", "gpu"])
-        .optional()
-        .describe("Compute backend used for inference"),
-    contextSize: z.number().optional().describe("Context size in tokens"),
+    totalTime: z.number().optional().describe('Total embedding time in milliseconds'),
+    tokensPerSecond: z.number().optional().describe('Tokens processed per second'),
+    totalTokens: z.number().optional().describe('Total tokens processed'),
+    backendDevice: z.enum(['cpu', 'gpu']).optional().describe('Compute backend used for inference'),
+    contextSize: z.number().optional().describe('Context size in tokens')
 });
 export const embedResponseSchema = z.object({
-    type: z.literal("embed"),
+    type: z.literal('embed'),
     success: z.boolean(),
     embedding: z
         .union([z.array(z.number()), z.array(z.array(z.number()))])
         .default([])
-        .describe("The embedding vector(s). Single `number[]` when `text` is a string; `number[][]` when `text` is an array."),
-    stats: embedStatsSchema.optional().describe("Performance statistics"),
-    error: z.string().optional(),
+        .describe('The embedding vector(s). Single `number[]` when `text` is a string; `number[][]` when `text` is an array.'),
+    stats: embedStatsSchema.optional().describe('Performance statistics'),
+    error: z.string().optional()
 });

package/dist/schemas/engine-addon-map.d.ts

@@ -1,4 +1,4 @@
-import { type ModelRegistryEngine, type ModelRegistryEntryAddon } from "./registry";
+import { type ModelRegistryEngine, type ModelRegistryEntryAddon } from './registry';
 export declare const ENGINE_TO_ADDON: {
     readonly "llamacpp-completion": "llm";
     readonly "whispercpp-transcription": "whisper";
@@ -12,8 +12,9 @@ export declare const ENGINE_TO_ADDON: {
     readonly "sdcpp-generation": "diffusion";
     readonly "ggml-vla": "vla";
     readonly "ggml-classification": "classification";
-    readonly "onnx-vad": "vad";
+    readonly 'onnx-vad': "vad";
 };
+export declare const LEGACY_ENGINE_TO_CANONICAL: Record<string, ModelRegistryEngine>;
 export declare function resolveCanonicalEngine(engine: string): ModelRegistryEngine | null;
 export declare function getAddonFromEngine(engine: ModelRegistryEngine): ModelRegistryEntryAddon;
 //# sourceMappingURL=engine-addon-map.d.ts.map

package/dist/schemas/engine-addon-map.js

@@ -1,26 +1,26 @@
-import { ModelType } from "./model-types.js";
-import { ADDON_BCI, ADDON_CLASSIFICATION, ADDON_DIFFUSION, ADDON_EMBEDDING, ADDON_LLM, ADDON_NMT, ADDON_OCR, ADDON_PARAKEET, ADDON_TTS, ADDON_VLA, ADDON_WHISPER, } from "./plugin.js";
-import { modelRegistryEngineSchema, } from "./registry.js";
+import { ModelType } from './model-types.js';
+import { ADDON_BCI, ADDON_CLASSIFICATION, ADDON_DIFFUSION, ADDON_EMBEDDING, ADDON_LLM, ADDON_NMT, ADDON_OCR, ADDON_PARAKEET, ADDON_TTS, ADDON_VLA, ADDON_WHISPER } from './plugin.js';
+import { modelRegistryEngineSchema } from './registry.js';
 // Canonical engine → addon mapping (exhaustive). `as const` preserves
 // per-key literals so the addon can be derived from the engine at the type level.
 export const ENGINE_TO_ADDON = {
-    [ModelType.llamacppCompletion]: "llm",
-    [ModelType.whispercppTranscription]: "whisper",
-    [ModelType.bciWhispercppTranscription]: "bci",
-    [ModelType.llamacppEmbedding]: "embeddings",
-    [ModelType.nmtcppTranslation]: "nmt",
-    [ModelType.onnxTts]: "tts",
-    [ModelType.ttsGgml]: "tts",
-    [ModelType.ggmlOcr]: "ocr",
-    [ModelType.parakeetTranscription]: "parakeet",
-    [ModelType.sdcppGeneration]: "diffusion",
-    [ModelType.ggmlVla]: "vla",
-    [ModelType.ggmlClassification]: "classification",
-    "onnx-vad": "vad",
+    [ModelType.llamacppCompletion]: 'llm',
+    [ModelType.whispercppTranscription]: 'whisper',
+    [ModelType.bciWhispercppTranscription]: 'bci',
+    [ModelType.llamacppEmbedding]: 'embeddings',
+    [ModelType.nmtcppTranslation]: 'nmt',
+    [ModelType.onnxTts]: 'tts',
+    [ModelType.ttsGgml]: 'tts',
+    [ModelType.ggmlOcr]: 'ocr',
+    [ModelType.parakeetTranscription]: 'parakeet',
+    [ModelType.sdcppGeneration]: 'diffusion',
+    [ModelType.ggmlVla]: 'vla',
+    [ModelType.ggmlClassification]: 'classification',
+    'onnx-vad': 'vad'
 };
 // Legacy engine names → canonical engine.
 // Used for backward compatibility with old registry data that uses @qvac/* package names.
-const LEGACY_ENGINE_TO_CANONICAL = {
+export const LEGACY_ENGINE_TO_CANONICAL = {
     [ADDON_LLM]: ModelType.llamacppCompletion,
     [ADDON_WHISPER]: ModelType.whispercppTranscription,
     [ADDON_BCI]: ModelType.bciWhispercppTranscription,
@@ -29,21 +29,21 @@ const LEGACY_ENGINE_TO_CANONICAL = {
     [ADDON_TTS]: ModelType.ttsGgml,
     [ADDON_OCR]: ModelType.ggmlOcr,
     // Pre-GGML package / tag names from the ONNX era — resolve to the GGML engine.
-    "@qvac/ocr-onnx": ModelType.ggmlOcr,
-    "onnx-ocr": ModelType.ggmlOcr,
+    '@qvac/ocr-onnx': ModelType.ggmlOcr,
+    'onnx-ocr': ModelType.ggmlOcr,
     [ADDON_PARAKEET]: ModelType.parakeetTranscription,
-    "@qvac/translation-llamacpp": ModelType.nmtcppTranslation,
-    "@qvac/vad-silero": "onnx-vad",
+    '@qvac/translation-llamacpp': ModelType.nmtcppTranslation,
+    '@qvac/vad-silero': 'onnx-vad',
     // Legacy package / tag names from the ONNX era — resolve to the GGML engine.
-    "@qvac/tts": ModelType.ttsGgml,
-    "@qvac/tts-onnx": ModelType.ttsGgml,
+    '@qvac/tts': ModelType.ttsGgml,
+    '@qvac/tts-onnx': ModelType.ttsGgml,
     // Tag-style names (used by some older registry entries)
     generation: ModelType.llamacppCompletion,
     transcription: ModelType.whispercppTranscription,
     bci: ModelType.bciWhispercppTranscription,
     embedding: ModelType.llamacppEmbedding,
     translation: ModelType.nmtcppTranslation,
-    vad: "onnx-vad",
+    vad: 'onnx-vad',
     tts: ModelType.ttsGgml,
     ocr: ModelType.ggmlOcr,
     [ADDON_DIFFUSION]: ModelType.sdcppGeneration,
@@ -51,7 +51,7 @@ const LEGACY_ENGINE_TO_CANONICAL = {
     [ADDON_VLA]: ModelType.ggmlVla,
     vla: ModelType.ggmlVla,
     [ADDON_CLASSIFICATION]: ModelType.ggmlClassification,
-    classification: ModelType.ggmlClassification,
+    classification: ModelType.ggmlClassification
 };
 // Resolves any engine string (legacy or canonical) to a validated canonical engine.
 // Returns null if the engine is not recognized.

package/dist/schemas/error.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from 'zod';
 /**
  * Wire shape for errors thrown across the RPC boundary. The fields are
  * the union of (a) the legacy `QvacErrorBase` serialisation (`name`,

package/dist/schemas/error.js

@@ -1,6 +1,6 @@
-import { z } from "zod";
-import { QvacErrorBase } from "@qvac/error";
-import { formatZodError } from "../utils/zod-error.js";
+import { z } from 'zod';
+import { QvacErrorBase } from '@qvac/error';
+import { formatZodError } from '../utils/zod-error.js';
 /**
  * Wire shape for errors thrown across the RPC boundary. The fields are
  * the union of (a) the legacy `QvacErrorBase` serialisation (`name`,
@@ -18,21 +18,20 @@ import { formatZodError } from "../utils/zod-error.js";
  * side; the schema itself doesn't change.
  */
 export const errorResponseSchema = z.object({
-    type: z.literal("error"),
+    type: z.literal('error'),
     message: z.string(),
     stack: z.string().optional(),
     timestamp: z.string().optional(),
     name: z.string().optional(),
     code: z.number().optional(),
     cause: z.unknown().optional(),
-    typedFields: z.record(z.string(), z.unknown()).optional(),
+    typedFields: z.record(z.string(), z.unknown()).optional()
 });
 function hasTypedFields(error) {
     return (error !== null &&
-        typeof error === "object" &&
-        "toErrorResponseFields" in error &&
-        typeof error
-            .toErrorResponseFields === "function");
+        typeof error === 'object' &&
+        'toErrorResponseFields' in error &&
+        typeof error.toErrorResponseFields === 'function');
 }
 function isQvacError(error) {
     return error instanceof QvacErrorBase;
@@ -41,12 +40,12 @@ export function createErrorResponse(error) {
     if (isQvacError(error)) {
         const qvacData = error.toJSON();
         const response = {
-            type: "error",
+            type: 'error',
             name: qvacData.name,
             code: qvacData.code,
             message: qvacData.message,
             stack: qvacData.stack,
-            timestamp: new Date().toISOString(),
+            timestamp: new Date().toISOString()
         };
         if (hasTypedFields(error)) {
             response.typedFields = error.toErrorResponseFields();
@@ -60,9 +59,9 @@ export function createErrorResponse(error) {
             : String(error);
     const stack = error instanceof Error ? error.stack : undefined;
     return {
-        type: "error",
+        type: 'error',
         message,
         stack,
-        timestamp: new Date().toISOString(),
+        timestamp: new Date().toISOString()
     };
 }

package/dist/schemas/finetune.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from 'zod';
 export declare const finetuneValidationSchema: z.ZodPipe<z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"none">;
 }, z.core.$strict>, z.ZodObject<{

package/dist/schemas/finetune.js

@@ -1,43 +1,37 @@
-import { z } from "zod";
-const lrSchedulerValues = ["constant", "cosine", "linear"];
-const finetuneStatusValues = [
-    "IDLE",
-    "RUNNING",
-    "PAUSED",
-    "CANCELLED",
-    "COMPLETED",
-];
+import { z } from 'zod';
+const lrSchedulerValues = ['constant', 'cosine', 'linear'];
+const finetuneStatusValues = ['IDLE', 'RUNNING', 'PAUSED', 'CANCELLED', 'COMPLETED'];
 export const finetuneValidationSchema = z
-    .discriminatedUnion("type", [
+    .discriminatedUnion('type', [
     z
         .object({
-        type: z.literal("none"),
+        type: z.literal('none')
     })
         .strict(),
     z
         .object({
-        type: z.literal("split"),
-        fraction: z.number().min(0).max(1).optional(),
+        type: z.literal('split'),
+        fraction: z.number().min(0).max(1).optional()
     })
         .strict(),
     z
         .object({
-        type: z.literal("dataset"),
-        path: z.string().min(1, "Validation dataset path cannot be empty"),
+        type: z.literal('dataset'),
+        path: z.string().min(1, 'Validation dataset path cannot be empty')
     })
-        .strict(),
+        .strict()
 ])
-    .transform((validation) => validation.type === "split"
+    .transform((validation) => validation.type === 'split'
     ? {
         ...validation,
-        fraction: validation.fraction ?? 0.05,
+        fraction: validation.fraction ?? 0.05
     }
     : validation);
 const finetuneOptionsPayloadSchema = z
     .object({
-    trainDatasetDir: z.string().min(1, "Training dataset path cannot be empty"),
+    trainDatasetDir: z.string().min(1, 'Training dataset path cannot be empty'),
     validation: finetuneValidationSchema,
-    outputParametersDir: z.string().min(1, "Output parameters path cannot be empty"),
+    outputParametersDir: z.string().min(1, 'Output parameters path cannot be empty'),
     numberOfEpochs: z.number().int().positive().optional(),
     learningRate: z.number().positive().optional(),
     contextLength: z.number().int().positive().optional(),
@@ -58,67 +52,70 @@ const finetuneOptionsPayloadSchema = z
     warmupRatioSet: z.boolean().optional(),
     warmupSteps: z.number().int().min(0).optional(),
     warmupStepsSet: z.boolean().optional(),
-    weightDecay: z.number().min(0).optional(),
+    weightDecay: z.number().min(0).optional()
 })
     .strict();
 const finetuneModelParamsSchema = z
     .object({
-    modelId: z.string(),
+    modelId: z.string()
 })
     .strict();
 const finetuneRunParamsSchemaBase = finetuneModelParamsSchema
     .extend({
-    options: finetuneOptionsPayloadSchema,
+    options: finetuneOptionsPayloadSchema
 })
     .strict();
 export const finetuneRunParamsSchema = finetuneRunParamsSchemaBase
     .extend({
-    operation: z.enum(["start", "resume"]).optional(),
+    operation: z.enum(['start', 'resume']).optional()
 })
     .strict();
 export const finetuneGetStateParamsSchema = finetuneRunParamsSchemaBase
     .extend({
-    operation: z.literal("getState"),
+    operation: z.literal('getState')
 })
     .strict();
 export const finetuneStopParamsSchema = finetuneModelParamsSchema
     .extend({
-    operation: z.enum(["pause", "cancel"]),
+    operation: z.enum(['pause', 'cancel'])
 })
     .strict();
 export const finetuneParamsSchema = z.union([
     finetuneRunParamsSchema,
     finetuneGetStateParamsSchema,
-    finetuneStopParamsSchema,
+    finetuneStopParamsSchema
 ]);
 export const finetuneRunRequestSchema = finetuneRunParamsSchemaBase
     .extend({
-    type: z.literal("finetune"),
-    operation: z.enum(["start", "resume"]).optional(),
+    type: z.literal('finetune'),
+    operation: z.enum(['start', 'resume']).optional(),
     withProgress: z.boolean().optional(),
     requestId: z
         .string()
         .min(1)
         .optional()
-        .describe("Stable identifier for this in-flight finetune, generated by the client at call time. Surfaces on the registry so callers can target it with `cancel({ requestId })`. Optional on the wire — the server falls back to a server-generated id when the field is missing."),
+        .describe('Stable identifier for this in-flight finetune, generated by the client at call time. Surfaces on the registry so callers can target it with `cancel({ requestId })`. Optional on the wire — the server falls back to a server-generated id when the field is missing.')
 })
-    .strict();
+    .strict()
+    .meta({ title: 'FinetuneRunRequest' });
 export const finetuneGetStateRequestSchema = finetuneRunParamsSchemaBase
     .extend({
-    type: z.literal("finetune"),
-    operation: z.literal("getState"),
+    type: z.literal('finetune'),
+    operation: z.literal('getState')
 })
-    .strict();
+    .strict()
+    .meta({ title: 'FinetuneGetStateRequest' });
 export const finetuneStopRequestSchema = finetuneModelParamsSchema
     .extend({
-    type: z.literal("finetune"),
-    operation: z.enum(["pause", "cancel"]),
+    type: z.literal('finetune'),
+    operation: z.enum(['pause', 'cancel'])
 })
-    .strict();
+    .strict()
+    .meta({ title: 'FinetuneStopRequest' });
 export const finetuneRequestSchema = z.union([
     finetuneRunRequestSchema,
     finetuneGetStateRequestSchema,
-    finetuneStopRequestSchema,
+    finetuneStopRequestSchema
 ]);
 export const finetuneStatusSchema = z.enum(finetuneStatusValues);
 export const finetuneProgressSchema = z
@@ -133,7 +130,7 @@ export const finetuneProgressSchema = z
     current_batch: z.number().int().min(0),
     total_batches: z.number().int().min(0),
     elapsed_ms: z.number().min(0),
-    eta_ms: z.number().min(0),
+    eta_ms: z.number().min(0)
 })
     .strict();
 export const finetuneStatsSchema = z
@@ -148,19 +145,19 @@ export const finetuneStatsSchema = z
     val_accuracy_uncertainty: z.union([z.number(), z.nan()]).nullable().optional(),
     learning_rate: z.number().optional(),
     global_steps: z.number().int().min(0),
-    epochs_completed: z.number().int().min(0),
+    epochs_completed: z.number().int().min(0)
 })
     .strict();
 export const finetuneResponseSchema = z
     .object({
-    type: z.literal("finetune"),
+    type: z.literal('finetune'),
     status: finetuneStatusSchema,
-    stats: finetuneStatsSchema.optional(),
+    stats: finetuneStatsSchema.optional()
 })
     .strict();
 export const finetuneProgressResponseSchema = finetuneProgressSchema
     .extend({
-    type: z.literal("finetune:progress"),
-    modelId: z.string(),
+    type: z.literal('finetune:progress'),
+    modelId: z.string()
 })
     .strict();

package/dist/schemas/get-loaded-model-info.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from 'zod';
 export declare const getLoadedModelInfoParamsSchema: z.ZodObject<{
     modelId: z.ZodString;
 }, z.core.$strip>;
@@ -16,6 +16,14 @@ export declare const loadedModelInfoSchema: z.ZodDiscriminatedUnion<[z.ZodObject
     loadedAt: z.ZodCoercedDate<unknown>;
     name: z.ZodOptional<z.ZodString>;
     path: z.ZodOptional<z.ZodString>;
+    toolDialect: z.ZodOptional<z.ZodEnum<{
+        hermes: "hermes";
+        pythonic: "pythonic";
+        json: "json";
+        harmony: "harmony";
+        qwen35: "qwen35";
+        gemma4: "gemma4";
+    }>>;
 }, z.core.$strip>, z.ZodObject<{
     modelId: z.ZodString;
     isDelegated: z.ZodLiteral<true>;
@@ -36,6 +44,14 @@ export declare const getLoadedModelInfoResponseSchema: z.ZodObject<{
         loadedAt: z.ZodCoercedDate<unknown>;
         name: z.ZodOptional<z.ZodString>;
         path: z.ZodOptional<z.ZodString>;
+        toolDialect: z.ZodOptional<z.ZodEnum<{
+            hermes: "hermes";
+            pythonic: "pythonic";
+            json: "json";
+            harmony: "harmony";
+            qwen35: "qwen35";
+            gemma4: "gemma4";
+        }>>;
     }, z.core.$strip>, z.ZodObject<{
         modelId: z.ZodString;
         isDelegated: z.ZodLiteral<true>;

package/dist/schemas/get-loaded-model-info.js

@@ -1,18 +1,22 @@
-import { z } from "zod";
+import { z } from 'zod';
+import { toolDialectSchema } from './completion-stream.js';
 export const getLoadedModelInfoParamsSchema = z.object({
-    modelId: z.string(),
+    modelId: z.string()
 });
 export const getLoadedModelInfoRequestSchema = getLoadedModelInfoParamsSchema.extend({
-    type: z.literal("getLoadedModelInfo"),
+    type: z.literal('getLoadedModelInfo')
 });
 const delegatedProviderInfoSchema = z.object({
-    providerPublicKey: z.string(),
+    providerPublicKey: z.string()
 });
 /**
  * Loaded local model: routing plugin known on this node, so modelType +
- * handler vocabulary are authoritative.
+ * handler vocabulary are authoritative. `toolDialect` is the tool-call dialect
+ * the completion normalizer parses for this model (completion-capable models
+ * only), letting a consumer replay a prior tool call in the model's own dialect.
  */
-const localLoadedModelInfoSchema = z.object({
+const localLoadedModelInfoSchema = z
+    .object({
     modelId: z.string(),
     isDelegated: z.literal(false),
     modelType: z.string(),
@@ -22,23 +26,27 @@ const localLoadedModelInfoSchema = z.object({
     loadedAt: z.coerce.date(),
     name: z.string().optional(),
     path: z.string().optional(),
-});
+    toolDialect: toolDialectSchema.optional()
+})
+    .meta({ title: 'LocalLoadedModelInfo' });
 /**
  * Loaded delegated model: this node only stores routing info, so `modelType`,
  * `displayName`, `addonPackage`, `loadedAt`, `name`, and `path` are absent,
  * and `handlers` is always empty.
  */
-const delegatedLoadedModelInfoSchema = z.object({
+const delegatedLoadedModelInfoSchema = z
+    .object({
     modelId: z.string(),
     isDelegated: z.literal(true),
     handlers: z.array(z.string()),
-    providerInfo: delegatedProviderInfoSchema,
-});
-export const loadedModelInfoSchema = z.discriminatedUnion("isDelegated", [
+    providerInfo: delegatedProviderInfoSchema
+})
+    .meta({ title: 'DelegatedLoadedModelInfo' });
+export const loadedModelInfoSchema = z.discriminatedUnion('isDelegated', [
     localLoadedModelInfoSchema,
-    delegatedLoadedModelInfoSchema,
+    delegatedLoadedModelInfoSchema
 ]);
 export const getLoadedModelInfoResponseSchema = z.object({
-    type: z.literal("getLoadedModelInfo"),
-    info: loadedModelInfoSchema,
+    type: z.literal('getLoadedModelInfo'),
+    info: loadedModelInfoSchema
 });

package/dist/schemas/get-model-info.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from 'zod';
 export declare const getModelInfoParamsSchema: z.ZodObject<{
     name: z.ZodString;
 }, z.core.$strip>;