@qvac/sdk 0.10.1 → 0.11.0

package/dist/schemas/common.js

@@ -19,7 +19,7 @@ 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, 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";
@@ -48,6 +48,7 @@ export const requestSchema = z.union([
     getLoadedModelInfoRequestSchema,
     ocrStreamRequestSchema,
     diffusionStreamRequestSchema,
+    upscaleStreamRequestSchema,
     finetuneRequestSchema,
     pluginInvokeRequestSchema,
     pluginInvokeStreamRequestSchema,
@@ -83,6 +84,7 @@ export const responseSchema = z.discriminatedUnion("type", [
     getLoadedModelInfoResponseSchema,
     ocrStreamResponseSchema,
     diffusionStreamResponseSchema,
+    upscaleStreamResponseSchema,
     finetuneResponseSchema,
     finetuneProgressResponseSchema,
     pluginInvokeResponseSchema,

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

@@ -69,6 +69,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 +88,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";
@@ -155,6 +157,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 +200,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

@@ -44,7 +44,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<{
@@ -245,6 +258,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,6 +14,9 @@ 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";
             "llamacpp-completion": "llamacpp-completion";
             "whispercpp-transcription": "whispercpp-transcription";
             "llamacpp-embedding": "llamacpp-embedding";
@@ -26,9 +29,6 @@ export declare const downloadAssetOptionsSchema: z.ZodPipe<z.ZodObject<{
             whisper: "whisper";
             nmt: "nmt";
             parakeet: "parakeet";
-            tts: "tts";
-            ocr: "ocr";
-            diffusion: "diffusion";
         }>, z.ZodLiteral<"vad">]>>;
     }, z.core.$strip>]>;
     seed: z.ZodOptional<z.ZodBoolean>;
@@ -45,7 +45,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" | "llamacpp-completion" | "whispercpp-transcription" | "llamacpp-embedding" | "nmtcpp-translation" | "onnx-tts" | "parakeet-transcription" | "onnx-ocr" | "sdcpp-generation" | "llm" | "whisper" | "nmt" | "parakeet" | "vad" | undefined;
     };
 }, {
     assetSrc: string | {
@@ -59,7 +59,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" | "llamacpp-completion" | "whispercpp-transcription" | "llamacpp-embedding" | "nmtcpp-translation" | "onnx-tts" | "parakeet-transcription" | "onnx-ocr" | "sdcpp-generation" | "llm" | "whisper" | "nmt" | "parakeet" | "vad" | undefined;
     };
     seed?: boolean | undefined;
 }>>;
@@ -77,6 +77,9 @@ 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";
             "llamacpp-completion": "llamacpp-completion";
             "whispercpp-transcription": "whispercpp-transcription";
             "llamacpp-embedding": "llamacpp-embedding";
@@ -89,19 +92,18 @@ export declare const downloadAssetOptionsToRequestSchema: z.ZodPipe<z.ZodObject<
             whisper: "whisper";
             nmt: "nmt";
             parakeet: "parakeet";
-            tts: "tts";
-            ocr: "ocr";
-            diffusion: "diffusion";
         }>, 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 +116,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" | "llamacpp-completion" | "whispercpp-transcription" | "llamacpp-embedding" | "nmtcpp-translation" | "onnx-tts" | "parakeet-transcription" | "onnx-ocr" | "sdcpp-generation" | "llm" | "whisper" | "nmt" | "parakeet" | "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/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

package/dist/schemas/error.js

@@ -1,5 +1,21 @@
 import { z } from "zod";
 import { QvacErrorBase } from "@qvac/error";
+/**
+ * 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 const errorResponseSchema = z.object({
     type: z.literal("error"),
     message: z.string(),
@@ -8,14 +24,22 @@ export const errorResponseSchema = z.object({
     name: z.string().optional(),
     code: z.number().optional(),
     cause: 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");
+}
 function isQvacError(error) {
     return error instanceof QvacErrorBase;
 }
 export function createErrorResponse(error) {
     if (isQvacError(error)) {
         const qvacData = error.toJSON();
-        return {
+        const response = {
             type: "error",
             name: qvacData.name,
             code: qvacData.code,
@@ -23,6 +47,10 @@ export function createErrorResponse(error) {
             stack: qvacData.stack,
             timestamp: new Date().toISOString(),
         };
+        if (hasTypedFields(error)) {
+            response.typedFields = error.toErrorResponseFields();
+        }
+        return response;
     }
     const message = error instanceof Error ? error.message : String(error);
     const stack = error instanceof Error ? error.stack : undefined;

package/dist/schemas/finetune.d.ts

@@ -336,6 +336,7 @@ export declare const finetuneRunRequestSchema: z.ZodObject<{
         resume: "resume";
     }>>;
     withProgress: z.ZodOptional<z.ZodBoolean>;
+    requestId: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export declare const finetuneGetStateRequestSchema: z.ZodObject<{
     modelId: z.ZodString;
@@ -466,6 +467,7 @@ export declare const finetuneRequestSchema: z.ZodUnion<readonly [z.ZodObject<{
         resume: "resume";
     }>>;
     withProgress: z.ZodOptional<z.ZodBoolean>;
+    requestId: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>, z.ZodObject<{
     modelId: z.ZodString;
     options: z.ZodObject<{

package/dist/schemas/finetune.js

@@ -96,6 +96,11 @@ export const finetuneRunRequestSchema = finetuneRunParamsSchemaBase
     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."),
 })
     .strict();
 export const finetuneGetStateRequestSchema = finetuneRunParamsSchemaBase

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

@@ -36,13 +36,13 @@ export declare const modelInfoSchema: z.ZodObject<{
     sha256Checksum: z.ZodString;
     addon: z.ZodEnum<{
         embeddings: "embeddings";
+        diffusion: "diffusion";
+        tts: "tts";
+        ocr: "ocr";
         llm: "llm";
         whisper: "whisper";
         nmt: "nmt";
         parakeet: "parakeet";
-        tts: "tts";
-        ocr: "ocr";
-        diffusion: "diffusion";
         vad: "vad";
         other: "other";
     }>;
@@ -83,13 +83,13 @@ export declare const getModelInfoResponseSchema: z.ZodObject<{
         sha256Checksum: z.ZodString;
         addon: z.ZodEnum<{
             embeddings: "embeddings";
+            diffusion: "diffusion";
+            tts: "tts";
+            ocr: "ocr";
             llm: "llm";
             whisper: "whisper";
             nmt: "nmt";
             parakeet: "parakeet";
-            tts: "tts";
-            ocr: "ocr";
-            diffusion: "diffusion";
             vad: "vad";
             other: "other";
         }>;