@qvac/sdk 0.10.2 → 0.12.0

package/dist/schemas/common.js

@@ -19,13 +19,14 @@ import { deleteCacheRequestSchema, deleteCacheResponseSchema, } from "./delete-c
 import { getModelInfoRequestSchema, getModelInfoResponseSchema, } from "./get-model-info.js";
 import { getLoadedModelInfoRequestSchema, getLoadedModelInfoResponseSchema, } from "./get-loaded-model-info.js";
 import { ocrStreamRequestSchema, ocrStreamResponseSchema } from "./ocr.js";
-import { diffusionStreamRequestSchema, diffusionStreamResponseSchema, } from "./sdcpp-config.js";
+import { diffusionStreamRequestSchema, diffusionStreamResponseSchema, videoStreamRequestSchema, videoStreamResponseSchema, upscaleStreamRequestSchema, upscaleStreamResponseSchema, } from "./sdcpp-config.js";
 import { finetuneRequestSchema, finetuneResponseSchema, finetuneProgressResponseSchema, } from "./finetune.js";
 import { pluginInvokeRequestSchema, pluginInvokeResponseSchema, pluginInvokeStreamRequestSchema, pluginInvokeStreamResponseSchema, } from "./plugin.js";
 import { modelRegistryListRequestSchema, modelRegistryListResponseSchema, modelRegistrySearchRequestSchema, modelRegistrySearchResponseSchema, modelRegistryGetModelRequestSchema, modelRegistryGetModelResponseSchema, } from "./registry.js";
 import { suspendRequestSchema, suspendResponseSchema } from "./suspend.js";
 import { resumeRequestSchema, resumeResponseSchema } from "./resume.js";
 import { stateRequestSchema, stateResponseSchema } from "./state.js";
+import { classifyRequestSchema, classifyResponseSchema, } from "./classification.js";
 export const requestSchema = z.union([
     heartbeatRequestSchema,
     loadModelRequestSchema,
@@ -48,6 +49,8 @@ export const requestSchema = z.union([
     getLoadedModelInfoRequestSchema,
     ocrStreamRequestSchema,
     diffusionStreamRequestSchema,
+    videoStreamRequestSchema,
+    upscaleStreamRequestSchema,
     finetuneRequestSchema,
     pluginInvokeRequestSchema,
     pluginInvokeStreamRequestSchema,
@@ -57,6 +60,7 @@ export const requestSchema = z.union([
     suspendRequestSchema,
     resumeRequestSchema,
     stateRequestSchema,
+    classifyRequestSchema,
 ]);
 export const responseSchema = z.discriminatedUnion("type", [
     heartbeatResponseSchema,
@@ -83,6 +87,8 @@ export const responseSchema = z.discriminatedUnion("type", [
     getLoadedModelInfoResponseSchema,
     ocrStreamResponseSchema,
     diffusionStreamResponseSchema,
+    videoStreamResponseSchema,
+    upscaleStreamResponseSchema,
     finetuneResponseSchema,
     finetuneProgressResponseSchema,
     pluginInvokeResponseSchema,
@@ -93,6 +99,7 @@ export const responseSchema = z.discriminatedUnion("type", [
     suspendResponseSchema,
     resumeResponseSchema,
     stateResponseSchema,
+    classifyResponseSchema,
 ]);
 export const rpcOptionsSchema = z.object({
     timeout: z

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

@@ -5,6 +5,7 @@ export declare const completionStatsSchema: z.ZodObject<{
     timeToFirstToken: z.ZodOptional<z.ZodNumber>;
     tokensPerSecond: z.ZodOptional<z.ZodNumber>;
     cacheTokens: z.ZodOptional<z.ZodNumber>;
+    promptTokens: z.ZodOptional<z.ZodNumber>;
     generatedTokens: z.ZodOptional<z.ZodNumber>;
     backendDevice: z.ZodOptional<z.ZodEnum<{
         cpu: "cpu";
@@ -58,6 +59,7 @@ export declare const statsEventSchema: z.ZodObject<{
         timeToFirstToken: z.ZodOptional<z.ZodNumber>;
         tokensPerSecond: z.ZodOptional<z.ZodNumber>;
         cacheTokens: z.ZodOptional<z.ZodNumber>;
+        promptTokens: z.ZodOptional<z.ZodNumber>;
         generatedTokens: z.ZodOptional<z.ZodNumber>;
         backendDevice: z.ZodOptional<z.ZodEnum<{
             cpu: "cpu";
@@ -69,6 +71,7 @@ export declare const completionErrorSchema: z.ZodObject<{
     message: z.ZodString;
 }, z.core.$strip>;
 declare const stopReasonEnum: z.ZodEnum<{
+    cancelled: "cancelled";
     eos: "eos";
     length: "length";
     stopSequence: "stopSequence";
@@ -87,6 +90,7 @@ export declare const doneEventSchema: z.ZodUnion<readonly [z.ZodObject<{
     type: z.ZodLiteral<"completionDone">;
     seq: z.ZodNumber;
     stopReason: z.ZodOptional<z.ZodEnum<{
+        cancelled: "cancelled";
         eos: "eos";
         length: "length";
         stopSequence: "stopSequence";
@@ -135,6 +139,7 @@ export declare const completionEventSchema: z.ZodUnion<readonly [z.ZodObject<{
         timeToFirstToken: z.ZodOptional<z.ZodNumber>;
         tokensPerSecond: z.ZodOptional<z.ZodNumber>;
         cacheTokens: z.ZodOptional<z.ZodNumber>;
+        promptTokens: z.ZodOptional<z.ZodNumber>;
         generatedTokens: z.ZodOptional<z.ZodNumber>;
         backendDevice: z.ZodOptional<z.ZodEnum<{
             cpu: "cpu";
@@ -155,6 +160,7 @@ export declare const completionEventSchema: z.ZodUnion<readonly [z.ZodObject<{
     type: z.ZodLiteral<"completionDone">;
     seq: z.ZodNumber;
     stopReason: z.ZodOptional<z.ZodEnum<{
+        cancelled: "cancelled";
         eos: "eos";
         length: "length";
         stopSequence: "stopSequence";
@@ -197,6 +203,17 @@ export type CompletionFinal = {
     cacheableAssistantContent?: string;
 };
 export type CompletionRun = {
+    /**
+     * Stable identifier for this run, generated client-side at call time
+     * (UUIDv4 when `crypto.randomUUID` is available, otherwise an opaque
+     * random hex token) and available synchronously the moment
+     * `completion(...)` returns. Pass it to `cancel({ requestId })` to
+     * target this specific request without affecting any other inference
+     * running on the same model. The cancel only takes effect once the
+     * server has begun the request, so a cancel issued in the same tick
+     * as `completion(...)` may race the begin and is logged as a no-match.
+     */
+    requestId: string;
     /** Ordered stream of typed completion events — the canonical consumption API. */
     events: AsyncIterable<CompletionEvent>;
     /** Resolves when the stream ends with aggregated content, thinking, tool calls, stats, and raw output. */

package/dist/schemas/completion-event.js

@@ -4,6 +4,7 @@ export const completionStatsSchema = z.object({
     timeToFirstToken: z.number().optional(),
     tokensPerSecond: z.number().optional(),
     cacheTokens: z.number().optional(),
+    promptTokens: z.number().optional(),
     generatedTokens: z.number().optional(),
     backendDevice: z.enum(["cpu", "gpu"]).optional(),
 });
@@ -44,7 +45,17 @@ export const completionErrorSchema = z.object({
 const rawOutputSchema = z.object({
     fullText: z.string(),
 });
-const stopReasonEnum = z.enum(["eos", "length", "stopSequence"]);
+// `"cancelled"` is a clean termination, not a mid-stream failure: the
+// stream ended on purpose because the request was aborted, just not at
+// EOS. It rides the success-done path (alongside "eos" / "length" /
+// "stopSequence") so consumers iterating `events` see the stream end
+// naturally. The companion error path (`errorDoneSchema` below) keeps
+// `stopReason: "error"` for actual mid-stream failures where the
+// partial state is unsafe to use. The promise-aggregates on the
+// client-side `CompletionRun` (`final` / `text` / `toolCalls` / `stats`)
+// reject with `InferenceCancelledError` carrying the partial state — see
+// `client/api/completion-stream.ts` for the rejection plumbing.
+const stopReasonEnum = z.enum(["eos", "length", "stopSequence", "cancelled"]);
 const successDoneSchema = z
     .object({
     type: z.literal("completionDone"),

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

@@ -1,5 +1,5 @@
 import { z } from "zod";
-export { completionStatsSchema, type CompletionStats } from "./completion-event";
+export { completionStatsSchema, type CompletionStats, } from "./completion-event";
 /**
  * Tool-call output dialect. Auto-detected from the model name; pass via
  * `completion({ toolDialect })` to override.
@@ -9,12 +9,16 @@ export { completionStatsSchema, type CompletionStats } from "./completion-event"
  * - `"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|>`
+ * - `"qwen35"`:   `<tool_call><function=NAME><parameter=KEY>VALUE</parameter></function></tool_call>`
+ * - `"gemma4"`:   `<|tool_call>call:NAME{key:<|"|>val<|"|>,...}<tool_call|>`
  */
 export declare const toolDialectSchema: z.ZodEnum<{
     hermes: "hermes";
     pythonic: "pythonic";
     json: "json";
     harmony: "harmony";
+    qwen35: "qwen35";
+    gemma4: "gemma4";
 }>;
 export declare const attachmentSchema: z.ZodObject<{
     path: z.ZodString;
@@ -28,6 +32,7 @@ export declare const generationParamsSchema: z.ZodObject<{
     frequency_penalty: z.ZodOptional<z.ZodNumber>;
     presence_penalty: z.ZodOptional<z.ZodNumber>;
     repeat_penalty: z.ZodOptional<z.ZodNumber>;
+    reasoning_budget: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<-1>, z.ZodLiteral<0>]>>;
 }, z.core.$strict>;
 export declare const responseFormatSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"text">;
@@ -94,6 +99,7 @@ export declare const completionClientParamsSchema: z.ZodObject<{
         frequency_penalty: z.ZodOptional<z.ZodNumber>;
         presence_penalty: z.ZodOptional<z.ZodNumber>;
         repeat_penalty: z.ZodOptional<z.ZodNumber>;
+        reasoning_budget: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<-1>, z.ZodLiteral<0>]>>;
     }, z.core.$strict>>;
     captureThinking: z.ZodOptional<z.ZodBoolean>;
     emitRawDeltas: z.ZodOptional<z.ZodBoolean>;
@@ -102,6 +108,8 @@ export declare const completionClientParamsSchema: z.ZodObject<{
         pythonic: "pythonic";
         json: "json";
         harmony: "harmony";
+        qwen35: "qwen35";
+        gemma4: "gemma4";
     }>>;
     responseFormat: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"text">;
@@ -116,6 +124,7 @@ export declare const completionClientParamsSchema: z.ZodObject<{
             strict: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strict>;
     }, z.core.$strict>], "type">>;
+    requestId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const completionStreamRequestSchema: z.ZodObject<{
     history: z.ZodArray<z.ZodObject<{
@@ -158,6 +167,7 @@ export declare const completionStreamRequestSchema: z.ZodObject<{
         frequency_penalty: z.ZodOptional<z.ZodNumber>;
         presence_penalty: z.ZodOptional<z.ZodNumber>;
         repeat_penalty: z.ZodOptional<z.ZodNumber>;
+        reasoning_budget: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<-1>, z.ZodLiteral<0>]>>;
     }, z.core.$strict>>;
     captureThinking: z.ZodOptional<z.ZodBoolean>;
     emitRawDeltas: z.ZodOptional<z.ZodBoolean>;
@@ -166,6 +176,8 @@ export declare const completionStreamRequestSchema: z.ZodObject<{
         pythonic: "pythonic";
         json: "json";
         harmony: "harmony";
+        qwen35: "qwen35";
+        gemma4: "gemma4";
     }>>;
     responseFormat: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"text">;
@@ -180,6 +192,7 @@ export declare const completionStreamRequestSchema: z.ZodObject<{
             strict: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strict>;
     }, z.core.$strict>], "type">>;
+    requestId: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"completionStream">;
 }, z.core.$strip>;
 export declare const completionStreamResponseSchema: z.ZodObject<{
@@ -225,6 +238,7 @@ export declare const completionStreamResponseSchema: z.ZodObject<{
             timeToFirstToken: z.ZodOptional<z.ZodNumber>;
             tokensPerSecond: z.ZodOptional<z.ZodNumber>;
             cacheTokens: z.ZodOptional<z.ZodNumber>;
+            promptTokens: z.ZodOptional<z.ZodNumber>;
             generatedTokens: z.ZodOptional<z.ZodNumber>;
             backendDevice: z.ZodOptional<z.ZodEnum<{
                 cpu: "cpu";
@@ -245,6 +259,7 @@ export declare const completionStreamResponseSchema: z.ZodObject<{
         type: z.ZodLiteral<"completionDone">;
         seq: z.ZodNumber;
         stopReason: z.ZodOptional<z.ZodEnum<{
+            cancelled: "cancelled";
             eos: "eos";
             length: "length";
             stopSequence: "stopSequence";

package/dist/schemas/completion-stream.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { toolSchema } from "./tools.js";
 import { completionEventSchema } from "./completion-event.js";
-export { completionStatsSchema } from "./completion-event.js";
+export { completionStatsSchema, } from "./completion-event.js";
 /**
  * Tool-call output dialect. Auto-detected from the model name; pass via
  * `completion({ toolDialect })` to override.
@@ -11,8 +11,17 @@ export { completionStatsSchema } from "./completion-event.js";
  * - `"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|>`
+ * - `"qwen35"`:   `<tool_call><function=NAME><parameter=KEY>VALUE</parameter></function></tool_call>`
+ * - `"gemma4"`:   `<|tool_call>call:NAME{key:<|"|>val<|"|>,...}<tool_call|>`
  */
-export const toolDialectSchema = z.enum(["hermes", "pythonic", "json", "harmony"]);
+export const toolDialectSchema = z.enum([
+    "hermes",
+    "pythonic",
+    "json",
+    "harmony",
+    "qwen35",
+    "gemma4"
+]);
 export const attachmentSchema = z.object({
     path: z
         .string()
@@ -40,10 +49,7 @@ export const generationParamsSchema = z
         .number()
         .optional()
         .describe("Max tokens to predict. `-1` = until stop token, `-2` = until context filled."),
-    seed: z
-        .number()
-        .optional()
-        .describe("Random seed for reproducibility."),
+    seed: z.number().optional().describe("Random seed for reproducibility."),
     frequency_penalty: z
         .number()
         .optional()
@@ -56,6 +62,10 @@ export const generationParamsSchema = z
         .number()
         .optional()
         .describe("Penalty applied to repeated tokens."),
+    reasoning_budget: z
+        .union([z.literal(-1), z.literal(0)])
+        .optional()
+        .describe("Per-request reasoning channel budget. `-1` keeps the model's reasoning channel on; `0` disables it for this request. Equivalent to the load-time `reasoning_budget` config but scoped to a single `run()` call; the prior value is restored afterwards."),
 })
     .strict();
 const jsonSchemaObjectSchema = z.record(z.string(), z.unknown());
@@ -67,7 +77,10 @@ export const responseFormatSchema = z.discriminatedUnion("type", [
         type: z.literal("json_schema"),
         json_schema: z
             .object({
-            name: z.string().min(1).describe("Schema identifier; OpenAI-compatibility only — not used by the addon."),
+            name: z
+                .string()
+                .min(1)
+                .describe("Schema identifier; OpenAI-compatibility only — not used by the addon."),
             description: z
                 .string()
                 .optional()
@@ -128,6 +141,11 @@ const completionClientParamsBaseSchema = completionParamsSchema.extend({
     responseFormat: responseFormatSchema
         .optional()
         .describe("Optional structured-output constraint: `text` (default, free-form), `json_object` (any valid JSON), or `json_schema` (output conforms to the provided JSON Schema). Mutually exclusive with `tools`."),
+    requestId: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Stable identifier for this in-flight request, generated by the client at call time (opaque token, UUIDv4 when available). Surfaced on the `CompletionRun` result so callers can target it with `cancel({ requestId })`. Optional on the wire so legacy clients keep working — the server falls back to a server-generated id when the field is missing. Note: cancel-by-requestId only takes effect once the server has begun the request, so a cancel issued in the same tick as `completion()` may arrive before the request is registered."),
 });
 function refineNoToolsWithStructuredOutput(data, ctx) {
     if (data.responseFormat &&

package/dist/schemas/download-asset.d.ts

@@ -14,21 +14,26 @@ export declare const downloadAssetOptionsSchema: z.ZodPipe<z.ZodObject<{
         sha256Checksum: z.ZodOptional<z.ZodString>;
         addon: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
             embeddings: "embeddings";
+            diffusion: "diffusion";
+            tts: "tts";
+            ocr: "ocr";
+            vla: "vla";
             "llamacpp-completion": "llamacpp-completion";
             "whispercpp-transcription": "whispercpp-transcription";
             "llamacpp-embedding": "llamacpp-embedding";
             "nmtcpp-translation": "nmtcpp-translation";
             "onnx-tts": "onnx-tts";
+            "tts-ggml": "tts-ggml";
             "parakeet-transcription": "parakeet-transcription";
             "onnx-ocr": "onnx-ocr";
             "sdcpp-generation": "sdcpp-generation";
+            "ggml-vla": "ggml-vla";
+            "ggml-classification": "ggml-classification";
             llm: "llm";
             whisper: "whisper";
             nmt: "nmt";
             parakeet: "parakeet";
-            tts: "tts";
-            ocr: "ocr";
-            diffusion: "diffusion";
+            classification: "classification";
         }>, z.ZodLiteral<"vad">]>>;
     }, z.core.$strip>]>;
     seed: z.ZodOptional<z.ZodBoolean>;
@@ -45,7 +50,7 @@ export declare const downloadAssetOptionsSchema: z.ZodPipe<z.ZodObject<{
         engine?: string | undefined;
         expectedSize?: number | undefined;
         sha256Checksum?: string | undefined;
-        addon?: "embeddings" | "llamacpp-completion" | "whispercpp-transcription" | "llamacpp-embedding" | "nmtcpp-translation" | "onnx-tts" | "parakeet-transcription" | "onnx-ocr" | "sdcpp-generation" | "llm" | "whisper" | "nmt" | "parakeet" | "tts" | "ocr" | "diffusion" | "vad" | undefined;
+        addon?: "embeddings" | "diffusion" | "tts" | "ocr" | "vla" | "llamacpp-completion" | "whispercpp-transcription" | "llamacpp-embedding" | "nmtcpp-translation" | "onnx-tts" | "tts-ggml" | "parakeet-transcription" | "onnx-ocr" | "sdcpp-generation" | "ggml-vla" | "ggml-classification" | "llm" | "whisper" | "nmt" | "parakeet" | "classification" | "vad" | undefined;
     };
 }, {
     assetSrc: string | {
@@ -59,7 +64,7 @@ export declare const downloadAssetOptionsSchema: z.ZodPipe<z.ZodObject<{
         engine?: string | undefined;
         expectedSize?: number | undefined;
         sha256Checksum?: string | undefined;
-        addon?: "embeddings" | "llamacpp-completion" | "whispercpp-transcription" | "llamacpp-embedding" | "nmtcpp-translation" | "onnx-tts" | "parakeet-transcription" | "onnx-ocr" | "sdcpp-generation" | "llm" | "whisper" | "nmt" | "parakeet" | "tts" | "ocr" | "diffusion" | "vad" | undefined;
+        addon?: "embeddings" | "diffusion" | "tts" | "ocr" | "vla" | "llamacpp-completion" | "whispercpp-transcription" | "llamacpp-embedding" | "nmtcpp-translation" | "onnx-tts" | "tts-ggml" | "parakeet-transcription" | "onnx-ocr" | "sdcpp-generation" | "ggml-vla" | "ggml-classification" | "llm" | "whisper" | "nmt" | "parakeet" | "classification" | "vad" | undefined;
     };
     seed?: boolean | undefined;
 }>>;
@@ -77,31 +82,38 @@ export declare const downloadAssetOptionsToRequestSchema: z.ZodPipe<z.ZodObject<
         sha256Checksum: z.ZodOptional<z.ZodString>;
         addon: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
             embeddings: "embeddings";
+            diffusion: "diffusion";
+            tts: "tts";
+            ocr: "ocr";
+            vla: "vla";
             "llamacpp-completion": "llamacpp-completion";
             "whispercpp-transcription": "whispercpp-transcription";
             "llamacpp-embedding": "llamacpp-embedding";
             "nmtcpp-translation": "nmtcpp-translation";
             "onnx-tts": "onnx-tts";
+            "tts-ggml": "tts-ggml";
             "parakeet-transcription": "parakeet-transcription";
             "onnx-ocr": "onnx-ocr";
             "sdcpp-generation": "sdcpp-generation";
+            "ggml-vla": "ggml-vla";
+            "ggml-classification": "ggml-classification";
             llm: "llm";
             whisper: "whisper";
             nmt: "nmt";
             parakeet: "parakeet";
-            tts: "tts";
-            ocr: "ocr";
-            diffusion: "diffusion";
+            classification: "classification";
         }>, z.ZodLiteral<"vad">]>>;
     }, z.core.$strip>]>;
     seed: z.ZodOptional<z.ZodBoolean>;
     onProgress: z.ZodOptional<z.ZodUnknown>;
     withProgress: z.ZodOptional<z.ZodBoolean>;
+    requestId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodTransform<{
     type: "downloadAsset";
     assetSrc: string;
     withProgress: boolean;
     seed: boolean;
+    requestId?: string;
 }, {
     assetSrc: string | {
         src: string;
@@ -114,27 +126,31 @@ export declare const downloadAssetOptionsToRequestSchema: z.ZodPipe<z.ZodObject<
         engine?: string | undefined;
         expectedSize?: number | undefined;
         sha256Checksum?: string | undefined;
-        addon?: "embeddings" | "llamacpp-completion" | "whispercpp-transcription" | "llamacpp-embedding" | "nmtcpp-translation" | "onnx-tts" | "parakeet-transcription" | "onnx-ocr" | "sdcpp-generation" | "llm" | "whisper" | "nmt" | "parakeet" | "tts" | "ocr" | "diffusion" | "vad" | undefined;
+        addon?: "embeddings" | "diffusion" | "tts" | "ocr" | "vla" | "llamacpp-completion" | "whispercpp-transcription" | "llamacpp-embedding" | "nmtcpp-translation" | "onnx-tts" | "tts-ggml" | "parakeet-transcription" | "onnx-ocr" | "sdcpp-generation" | "ggml-vla" | "ggml-classification" | "llm" | "whisper" | "nmt" | "parakeet" | "classification" | "vad" | undefined;
     };
     seed?: boolean | undefined;
     onProgress?: unknown;
     withProgress?: boolean | undefined;
+    requestId?: string | undefined;
 }>>;
 export declare const downloadAssetRequestSchema: z.ZodPipe<z.ZodObject<{
     type: z.ZodLiteral<"downloadAsset">;
     assetSrc: z.ZodString;
     withProgress: z.ZodOptional<z.ZodBoolean>;
     seed: z.ZodOptional<z.ZodBoolean>;
+    requestId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodTransform<{
     seed: boolean;
     type: "downloadAsset";
     assetSrc: string;
     withProgress?: boolean | undefined;
+    requestId?: string | undefined;
 }, {
     type: "downloadAsset";
     assetSrc: string;
     withProgress?: boolean | undefined;
     seed?: boolean | undefined;
+    requestId?: string | undefined;
 }>>;
 export declare const downloadAssetResponseSchema: z.ZodObject<{
     type: z.ZodLiteral<"downloadAsset">;

package/dist/schemas/download-asset.js

@@ -12,19 +12,30 @@ export const downloadAssetOptionsToRequestSchema = downloadAssetOptionsBaseSchem
     .extend({
     onProgress: z.unknown().optional(),
     withProgress: z.boolean().optional(),
+    requestId: z.string().min(1).optional(),
 })
-    .transform((data) => ({
-    type: "downloadAsset",
-    assetSrc: modelInputToSrcSchema.parse(data.assetSrc),
-    withProgress: data.withProgress ?? !!data.onProgress,
-    seed: data.seed ?? false,
-}));
+    .transform((data) => {
+    const out = {
+        type: "downloadAsset",
+        assetSrc: modelInputToSrcSchema.parse(data.assetSrc),
+        withProgress: data.withProgress ?? !!data.onProgress,
+        seed: data.seed ?? false,
+    };
+    if (data.requestId !== undefined)
+        out.requestId = data.requestId;
+    return out;
+});
 export const downloadAssetRequestSchema = z
     .object({
     type: z.literal("downloadAsset"),
     assetSrc: z.string(),
     withProgress: z.boolean().optional(),
     seed: z.boolean().optional(),
+    requestId: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Stable identifier for this in-flight download, generated by the client at call time. Optional on the wire so legacy clients keep working — the server falls back to a server-generated id when the field is missing. Exposed on the client-side decorated promise so callers can target this download with `cancel({ requestId })`."),
 })
     .transform((data) => ({
     ...data,

package/dist/schemas/embed.d.ts

@@ -7,6 +7,7 @@ export declare const embedRequestSchema: z.ZodObject<{
     modelId: z.ZodString;
     text: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
     type: z.ZodLiteral<"embed">;
+    requestId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const embedStatsSchema: z.ZodObject<{
     totalTime: z.ZodOptional<z.ZodNumber>;

package/dist/schemas/embed.js

@@ -12,6 +12,11 @@ export const embedParamsSchema = z.object({
 });
 export const embedRequestSchema = embedParamsSchema.extend({
     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."),
 });
 export const embedStatsSchema = z.object({
     totalTime: z

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

@@ -5,9 +5,12 @@ export declare const ENGINE_TO_ADDON: {
     readonly "llamacpp-embedding": "embeddings";
     readonly "nmtcpp-translation": "nmt";
     readonly "onnx-tts": "tts";
+    readonly "tts-ggml": "tts";
     readonly "onnx-ocr": "ocr";
     readonly "parakeet-transcription": "parakeet";
     readonly "sdcpp-generation": "diffusion";
+    readonly "ggml-vla": "vla";
+    readonly "ggml-classification": "classification";
     readonly "onnx-vad": "vad";
 };
 export declare function resolveCanonicalEngine(engine: string): ModelRegistryEngine | null;

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

@@ -1,5 +1,5 @@
 import { ModelType } from "./model-types.js";
-import { ADDON_DIFFUSION, ADDON_EMBEDDING, ADDON_LLM, ADDON_NMT, ADDON_OCR, ADDON_PARAKEET, ADDON_TTS, ADDON_WHISPER, } from "./plugin.js";
+import { 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.
@@ -9,9 +9,12 @@ export const ENGINE_TO_ADDON = {
     [ModelType.llamacppEmbedding]: "embeddings",
     [ModelType.nmtcppTranslation]: "nmt",
     [ModelType.onnxTts]: "tts",
+    [ModelType.ttsGgml]: "tts",
     [ModelType.onnxOcr]: "ocr",
     [ModelType.parakeetTranscription]: "parakeet",
     [ModelType.sdcppGeneration]: "diffusion",
+    [ModelType.ggmlVla]: "vla",
+    [ModelType.ggmlClassification]: "classification",
     "onnx-vad": "vad",
 };
 // Legacy engine names → canonical engine.
@@ -21,29 +24,39 @@ const LEGACY_ENGINE_TO_CANONICAL = {
     [ADDON_WHISPER]: ModelType.whispercppTranscription,
     [ADDON_EMBEDDING]: ModelType.llamacppEmbedding,
     [ADDON_NMT]: ModelType.nmtcppTranslation,
-    [ADDON_TTS]: ModelType.onnxTts,
+    [ADDON_TTS]: ModelType.ttsGgml,
     [ADDON_OCR]: ModelType.onnxOcr,
     [ADDON_PARAKEET]: ModelType.parakeetTranscription,
     "@qvac/translation-llamacpp": ModelType.nmtcppTranslation,
     "@qvac/vad-silero": "onnx-vad",
-    "@qvac/tts": ModelType.onnxTts,
+    // Legacy package / tag names from the ONNX era — resolve to the GGML engine.
+    "@qvac/tts": ModelType.ttsGgml,
+    "@qvac/tts-onnx": ModelType.ttsGgml,
     // Tag-style names (used by some older registry entries)
     generation: ModelType.llamacppCompletion,
     transcription: ModelType.whispercppTranscription,
     embedding: ModelType.llamacppEmbedding,
     translation: ModelType.nmtcppTranslation,
     vad: "onnx-vad",
-    tts: ModelType.onnxTts,
+    tts: ModelType.ttsGgml,
     ocr: ModelType.onnxOcr,
     [ADDON_DIFFUSION]: ModelType.sdcppGeneration,
     diffusion: ModelType.sdcppGeneration,
+    [ADDON_VLA]: ModelType.ggmlVla,
+    vla: ModelType.ggmlVla,
+    [ADDON_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.
 export function resolveCanonicalEngine(engine) {
     const direct = modelRegistryEngineSchema.safeParse(engine);
-    if (direct.success)
+    if (direct.success) {
+        // Registry rows and cached metadata may still say "onnx-tts"; route to GGML.
+        if (direct.data === ModelType.onnxTts)
+            return ModelType.ttsGgml;
         return direct.data;
+    }
     const canonical = LEGACY_ENGINE_TO_CANONICAL[engine];
     if (canonical)
         return canonical;

package/dist/schemas/error.d.ts

@@ -1,4 +1,20 @@
 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`,
+ * `code`, `message`, `stack`, `cause`, `timestamp`) and (b) the new
+ * `typedFields` map (0.11.0+) carrying per-class structured data the
+ * client-side reconstructor uses to rebuild the original typed error.
+ *
+ * `typedFields` is opaque on the wire — `z.unknown()` — and the
+ * per-class reconstructor in `client/rpc/rpc-error.ts` casts each
+ * member at the boundary. The single-map shape keeps the schema
+ * compact regardless of how many typed-error classes the SDK
+ * eventually surfaces across RPC. New typed-error classes that need
+ * cross-RPC reconstruction add a `toErrorResponseFields()` method on
+ * the server side and a row to the reconstructor map on the client
+ * side; the schema itself doesn't change.
+ */
 export declare const errorResponseSchema: z.ZodObject<{
     type: z.ZodLiteral<"error">;
     message: z.ZodString;
@@ -7,7 +23,22 @@ export declare const errorResponseSchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
     code: z.ZodOptional<z.ZodNumber>;
     cause: z.ZodOptional<z.ZodUnknown>;
+    typedFields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>;
 export type ErrorResponse = z.infer<typeof errorResponseSchema>;
+/**
+ * A `QvacErrorBase` subclass that opts into typed-field serialisation
+ * across the RPC boundary. The method returns the subset of own
+ * properties the client-side reconstructor needs to rebuild the
+ * original class with its named constructor arguments populated.
+ *
+ * Co-located with each class (see `utils/errors-server.ts`) so adding
+ * a new cross-RPC typed error is a three-step change in one PR: define
+ * the class, implement the method, add a reconstructor entry in
+ * `client/rpc/rpc-error.ts`.
+ */
+export interface TypedErrorSerializer {
+    toErrorResponseFields(): Record<string, unknown>;
+}
 export declare function createErrorResponse(error: unknown): ErrorResponse;
 //# sourceMappingURL=error.d.ts.map