@qvac/sdk 0.10.2 → 0.12.0

package/README.md

@@ -16,6 +16,8 @@ See [https://docs.qvac.tether.io/sdk/getting-started](https://docs.qvac.tether.i
 
 For AI/LLM tools, use [https://docs.qvac.tether.io/llms-full.txt](https://docs.qvac.tether.io/llms-full.txt) as the consolidated plaintext documentation export.
 
+> **Assembling a custom worker on Bare?** See [`@qvac/bare-sdk`](../bare-sdk/README.md) — the same SDK surface with no built-in plugin addons, designed for consumers wiring their own worker entry (Pear apps, bare-expo apps, direct Bare scripts).
+
 ## Supported environments and installation
 
 See https://docs.qvac.tether.io/sdk/getting-started/installation

package/dist/client/api/cancel.d.ts

@@ -1,43 +1,35 @@
-import { type CancelParams } from "../../schemas/index";
+import { type CancelClientInput } from "../../schemas/index";
 /**
  * Cancels an ongoing operation.
  *
- * @param params - The parameters for the cancellation
- * @param params.operation - The type of operation to cancel ("inference", "downloadAsset", or "rag")
- * @param params.modelId - The model ID (required for inference cancellation)
- * @param params.downloadKey - The download key (required for download cancellation)
- * @param params.clearCache - If true, deletes the partial download file (default: false)
- * @param params.delegate - Delegation target for remote download cancellation (optional)
- * @param params.workspace - The RAG workspace to cancel (optional, defaults to "default")
- * @throws {QvacErrorBase} When the response type is invalid or when the cancellation fails
+ * Two cancel paths are supported:
+ *  - **By `requestId`** (primary) — pass the `requestId` exposed on
+ *    the result of a long-running call (`completion(...)`,
+ *    `loadModel(...)`, `downloadAsset(...)`, `embed(...)`,
+ *    `transcribe(...)`, `ragIngest(...)`, etc.) to cancel exactly
+ *    that request. A cancel that races the originating call is
+ *    recorded and applied retroactively when the begin arrives.
+ *  - **Broad by `modelId`** (escape hatch) — `{ modelId, kind? }`
+ *    cancels every in-flight request on that model. Useful for
+ *    model unload, app shutdown, or admin sweeps where the caller
+ *    doesn't have a `requestId` to hand.
  *
- * @example
- * // Cancel inference
- * await cancel({ operation: "inference", modelId: "model-123" });
- *
- * @example
- * // Pause download (preserves partial file for automatic resume)
- * await cancel({ operation: "downloadAsset", downloadKey: "download-key" });
+ * The legacy `{ operation: "inference" | "embeddings", modelId }`
+ * sugars remain callable for source compatibility. For migration off
+ * the removed `{ operation: "downloadAsset" | "rag" }` shapes, see
+ * the 0.11.0 changelog / release notes.
  *
- * @example
- * // Cancel download completely (deletes partial file)
- * await cancel({ operation: "downloadAsset", downloadKey: "download-key", clearCache: true });
- *
- * @example
- * // Cancel delegated remote download
- * await cancel({
- *   operation: "downloadAsset",
- *   downloadKey: "download-key",
- *   delegate: { providerPublicKey: "peerHex" },
- * });
+ * @param params - The cancellation parameters.
+ * @throws {QvacErrorBase} When the response type is invalid or the cancellation fails.
  *
  * @example
- * // Cancel RAG operation on default workspace
- * await cancel({ operation: "rag" });
+ * // Cancel by requestId (primary path)
+ * const run = completion({ ... });
+ * await cancel({ requestId: run.requestId });
  *
  * @example
- * // Cancel RAG operation on specific workspace
- * await cancel({ operation: "rag", workspace: "my-workspace" });
+ * // Broad-cancel every inference running on a model
+ * await cancel({ modelId: "model-123", kind: "completion" });
  */
-export declare function cancel(params: CancelParams): Promise<void>;
+export declare function cancel(params: CancelClientInput): Promise<void>;
 //# sourceMappingURL=cancel.d.ts.map

package/dist/client/api/cancel.js

@@ -4,47 +4,40 @@ import { InvalidResponseError, CancelFailedError } from "../../utils/errors-clie
 /**
  * Cancels an ongoing operation.
  *
- * @param params - The parameters for the cancellation
- * @param params.operation - The type of operation to cancel ("inference", "downloadAsset", or "rag")
- * @param params.modelId - The model ID (required for inference cancellation)
- * @param params.downloadKey - The download key (required for download cancellation)
- * @param params.clearCache - If true, deletes the partial download file (default: false)
- * @param params.delegate - Delegation target for remote download cancellation (optional)
- * @param params.workspace - The RAG workspace to cancel (optional, defaults to "default")
- * @throws {QvacErrorBase} When the response type is invalid or when the cancellation fails
+ * Two cancel paths are supported:
+ *  - **By `requestId`** (primary) — pass the `requestId` exposed on
+ *    the result of a long-running call (`completion(...)`,
+ *    `loadModel(...)`, `downloadAsset(...)`, `embed(...)`,
+ *    `transcribe(...)`, `ragIngest(...)`, etc.) to cancel exactly
+ *    that request. A cancel that races the originating call is
+ *    recorded and applied retroactively when the begin arrives.
+ *  - **Broad by `modelId`** (escape hatch) — `{ modelId, kind? }`
+ *    cancels every in-flight request on that model. Useful for
+ *    model unload, app shutdown, or admin sweeps where the caller
+ *    doesn't have a `requestId` to hand.
  *
- * @example
- * // Cancel inference
- * await cancel({ operation: "inference", modelId: "model-123" });
- *
- * @example
- * // Pause download (preserves partial file for automatic resume)
- * await cancel({ operation: "downloadAsset", downloadKey: "download-key" });
+ * The legacy `{ operation: "inference" | "embeddings", modelId }`
+ * sugars remain callable for source compatibility. For migration off
+ * the removed `{ operation: "downloadAsset" | "rag" }` shapes, see
+ * the 0.11.0 changelog / release notes.
  *
- * @example
- * // Cancel download completely (deletes partial file)
- * await cancel({ operation: "downloadAsset", downloadKey: "download-key", clearCache: true });
- *
- * @example
- * // Cancel delegated remote download
- * await cancel({
- *   operation: "downloadAsset",
- *   downloadKey: "download-key",
- *   delegate: { providerPublicKey: "peerHex" },
- * });
+ * @param params - The cancellation parameters.
+ * @throws {QvacErrorBase} When the response type is invalid or the cancellation fails.
  *
  * @example
- * // Cancel RAG operation on default workspace
- * await cancel({ operation: "rag" });
+ * // Cancel by requestId (primary path)
+ * const run = completion({ ... });
+ * await cancel({ requestId: run.requestId });
  *
  * @example
- * // Cancel RAG operation on specific workspace
- * await cancel({ operation: "rag", workspace: "my-workspace" });
+ * // Broad-cancel every inference running on a model
+ * await cancel({ modelId: "model-123", kind: "completion" });
  */
 export async function cancel(params) {
+    const wireParams = normalizeCancelParams(params);
     const request = {
         type: "cancel",
-        ...params,
+        ...wireParams,
     };
     const response = await send(request);
     if (response.type !== "cancel") {
@@ -54,3 +47,37 @@ export async function cancel(params) {
         throw new CancelFailedError(response.error);
     }
 }
+function normalizeCancelParams(params) {
+    if ("operation" in params) {
+        if (params.operation === "request" || params.operation === "broad") {
+            return params;
+        }
+        // Legacy per-kind sugar: { operation: "inference"|"embeddings", modelId }
+        if (params.operation === "inference") {
+            return {
+                operation: "broad",
+                modelId: params.modelId,
+                kind: "completion",
+            };
+        }
+        return { operation: "broad", modelId: params.modelId, kind: "embeddings" };
+    }
+    if ("requestId" in params) {
+        const wire = {
+            operation: "request",
+            requestId: params.requestId,
+        };
+        if (params.clearCache !== undefined) {
+            wire.clearCache = params.clearCache;
+        }
+        return wire;
+    }
+    const broad = {
+        operation: "broad",
+        modelId: params.modelId,
+    };
+    if (params.kind !== undefined) {
+        broad.kind = params.kind;
+    }
+    return broad;
+}

package/dist/client/api/classify.d.ts

@@ -0,0 +1,23 @@
+import { type ClassifyClientParams, type ClassificationResult } from "../../schemas/index";
+/**
+ * Classifies an image using a loaded classification model.
+ *
+ * The bundled MobileNetV3-Small model produces 3 labels: `"food"`, `"report"`, `"other"`.
+ * Custom models may emit different labels sourced from the GGUF metadata.
+ *
+ * @param params.modelId - The identifier of the loaded classification model
+ * @param params.image - JPEG or PNG buffer; raw RGB bytes also accepted with `width`, `height`, `channels`
+ * @param params.topK - Limit results to top-K classes (default: all)
+ * @returns Sorted classification results, highest confidence first
+ *
+ * @example
+ * ```typescript
+ * const modelId = await loadModel({ modelType: "ggml-classification" });
+ * const jpeg = fs.readFileSync("photo.jpg");
+ * const results = await classify({ modelId, image: jpeg });
+ * // [ { label: "food", confidence: 0.93 }, { label: "other", confidence: 0.05 }, ... ]
+ * await unloadModel({ modelId });
+ * ```
+ */
+export declare function classify(params: ClassifyClientParams): Promise<ClassificationResult[]>;
+//# sourceMappingURL=classify.d.ts.map

package/dist/client/api/classify.js

@@ -0,0 +1,43 @@
+import { classifyResponseSchema, } from "../../schemas/index.js";
+import { stream as streamRpc } from "../rpc/rpc-client.js";
+import { encodeBase64 } from "../../utils/encoding.js";
+/**
+ * Classifies an image using a loaded classification model.
+ *
+ * The bundled MobileNetV3-Small model produces 3 labels: `"food"`, `"report"`, `"other"`.
+ * Custom models may emit different labels sourced from the GGUF metadata.
+ *
+ * @param params.modelId - The identifier of the loaded classification model
+ * @param params.image - JPEG or PNG buffer; raw RGB bytes also accepted with `width`, `height`, `channels`
+ * @param params.topK - Limit results to top-K classes (default: all)
+ * @returns Sorted classification results, highest confidence first
+ *
+ * @example
+ * ```typescript
+ * const modelId = await loadModel({ modelType: "ggml-classification" });
+ * const jpeg = fs.readFileSync("photo.jpg");
+ * const results = await classify({ modelId, image: jpeg });
+ * // [ { label: "food", confidence: 0.93 }, { label: "other", confidence: 0.05 }, ... ]
+ * await unloadModel({ modelId });
+ * ```
+ */
+export async function classify(params) {
+    const request = {
+        type: "classify",
+        modelId: params.modelId,
+        image: encodeBase64(params.image),
+        ...(params.topK !== undefined && { topK: params.topK }),
+        ...(params.width !== undefined && { width: params.width }),
+        ...(params.height !== undefined && { height: params.height }),
+        ...(params.channels !== undefined && { channels: params.channels }),
+    };
+    for await (const response of streamRpc(request)) {
+        if (response && typeof response === "object" && "type" in response && response.type === "classify") {
+            const parsed = classifyResponseSchema.parse(response);
+            if (parsed.done) {
+                return parsed.results;
+            }
+        }
+    }
+    return [];
+}

package/dist/client/api/client-request-id.d.ts

@@ -0,0 +1,17 @@
+/**
+ * UUIDv4 generator for client-side request ids. The Web Crypto API
+ * ships `crypto.randomUUID` everywhere we run today (Bun, modern Node,
+ * modern browsers, React Native via the polyfill that the workbench-
+ * desktop / RN runtime config injects). The fallback exists so the SDK
+ * never crashes in an exotic JS environment without
+ * `crypto.randomUUID` — `requestId` semantics still hold (uniqueness,
+ * opaque to the caller), just without the UUIDv4 wire shape.
+ *
+ * Shared with the long-running call sites that decorate their promises
+ * with `requestId`: `completion(...)`, `loadModel(...)`,
+ * `downloadAsset(...)`. The decorated promise's `op.requestId` and the
+ * server's registry entry's `requestId` must match — generating once
+ * here keeps that invariant.
+ */
+export declare function generateClientRequestId(): string;
+//# sourceMappingURL=client-request-id.d.ts.map

package/dist/client/api/client-request-id.js

@@ -0,0 +1,27 @@
+/**
+ * UUIDv4 generator for client-side request ids. The Web Crypto API
+ * ships `crypto.randomUUID` everywhere we run today (Bun, modern Node,
+ * modern browsers, React Native via the polyfill that the workbench-
+ * desktop / RN runtime config injects). The fallback exists so the SDK
+ * never crashes in an exotic JS environment without
+ * `crypto.randomUUID` — `requestId` semantics still hold (uniqueness,
+ * opaque to the caller), just without the UUIDv4 wire shape.
+ *
+ * Shared with the long-running call sites that decorate their promises
+ * with `requestId`: `completion(...)`, `loadModel(...)`,
+ * `downloadAsset(...)`. The decorated promise's `op.requestId` and the
+ * server's registry entry's `requestId` must match — generating once
+ * here keeps that invariant.
+ */
+export function generateClientRequestId() {
+    const c = globalThis.crypto;
+    if (c?.randomUUID)
+        return c.randomUUID();
+    // Fallback: 128 random bits encoded as a hex string. Distinct enough
+    // for in-flight cancel targeting; not a wire-spec UUID.
+    const bytes = new Uint8Array(16);
+    for (let i = 0; i < bytes.length; i++) {
+        bytes[i] = Math.floor(Math.random() * 256);
+    }
+    return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}

package/dist/client/api/completion-stream.d.ts

@@ -28,7 +28,7 @@ type CompletionParams = Omit<CompletionClientParams, "tools"> & {
  * @param params.mcp - Optional array of MCP client inputs for tool integration
  * @param params.captureThinking - Best-effort parsing of `<think>` blocks into `thinkingDelta` events; `final.raw.fullText` always preserves the original output
  * @param params.emitRawDeltas - When true, every raw model token is also emitted as a `rawDelta` event
- * @param params.toolDialect - Override the SDK's name-based dialect detection. Use when your model emits a known format (`"hermes"`, `"pythonic"`, or `"json"`) the auto-router doesn't recognise. Drives both streaming frame detection and finalization parsing.
+ * @param params.toolDialect - Override the SDK's name-based dialect detection. Supported values: `"hermes"`, `"pythonic"`, `"json"`, `"harmony"`, `"qwen35"` (Qwen3.5/3.6), `"gemma4"`. Use when the auto-router doesn't recognise your model name. Drives both streaming frame detection and finalization parsing.
  * Common override case: Llama 3.x tool-calling fine-tunes that emit the native pythonic header (`<|start_header_id|>tool_call<|end_header_id|>...<|eot_id|>`).
  * @param params.responseFormat - Optional structured-output constraint applied to the model's output:
  *   - `{ type: "text" }` — no constraint (default behavior)

package/dist/client/api/completion-stream.js

@@ -1,10 +1,11 @@
 import { stream as streamRpc } from "../rpc/rpc-client.js";
 import { getClientLogger } from "../../logging/index.js";
 import { completionStreamResponseSchema, } from "../../schemas/index.js";
-import { CompletionFailedError } from "../../utils/errors-server.js";
+import { CompletionFailedError, InferenceCancelledError, } from "../../utils/errors-server.js";
 import { getMcpToolsWithHandlers } from "../../utils/mcp-adapter.js";
 import { validateTools, } from "../../utils/tool-helpers.js";
 import { buildFinalFromEvents } from "../../utils/aggregate-events.js";
+import { generateClientRequestId } from "./client-request-id.js";
 const logger = getClientLogger();
 /**
  * Generates completion from a language model based on conversation history.
@@ -27,7 +28,7 @@ const logger = getClientLogger();
  * @param params.mcp - Optional array of MCP client inputs for tool integration
  * @param params.captureThinking - Best-effort parsing of `<think>` blocks into `thinkingDelta` events; `final.raw.fullText` always preserves the original output
  * @param params.emitRawDeltas - When true, every raw model token is also emitted as a `rawDelta` event
- * @param params.toolDialect - Override the SDK's name-based dialect detection. Use when your model emits a known format (`"hermes"`, `"pythonic"`, or `"json"`) the auto-router doesn't recognise. Drives both streaming frame detection and finalization parsing.
+ * @param params.toolDialect - Override the SDK's name-based dialect detection. Supported values: `"hermes"`, `"pythonic"`, `"json"`, `"harmony"`, `"qwen35"` (Qwen3.5/3.6), `"gemma4"`. Use when the auto-router doesn't recognise your model name. Drives both streaming frame detection and finalization parsing.
  * Common override case: Llama 3.x tool-calling fine-tunes that emit the native pythonic header (`<|start_header_id|>tool_call<|end_header_id|>...<|eot_id|>`).
  * @param params.responseFormat - Optional structured-output constraint applied to the model's output:
  *   - `{ type: "text" }` — no constraint (default behavior)
@@ -102,6 +103,13 @@ const logger = getClientLogger();
  * ```
  */
 export function completion(params) {
+    // Stable identity for this run, generated client-side so it's
+    // available synchronously the moment we return — before the first
+    // network round-trip and therefore before the user could possibly
+    // have a "stop" handler. Surfaced on the returned `CompletionRun`
+    // (`run.requestId`) so callers can `cancel({ requestId })` at any
+    // point during the stream.
+    const requestId = generateClientRequestId();
     let statsResolver = () => { };
     let statsRejecter = () => { };
     const statsPromise = new Promise((resolve, reject) => {
@@ -182,6 +190,7 @@ export function completion(params) {
                 emitRawDeltas: params.emitRawDeltas,
                 toolDialect: params.toolDialect,
                 responseFormat: params.responseFormat,
+                requestId,
             };
             const responses = streamRpc(request, params.rpcOptions);
             for await (const response of responses) {
@@ -202,13 +211,33 @@ export function completion(params) {
                     }
                     notifyWaiters();
                     if (streamResponse.done) {
-                        const { final, error } = buildFinalFromEvents(allEvents, allHandlers);
+                        const { final, error, cancelled } = buildFinalFromEvents(allEvents, allHandlers);
                         if (error) {
                             const err = new CompletionFailedError(error.message, error);
                             finalRejecter(err);
                             statsRejecter(err);
                             toolCallsRejecter(err);
                         }
+                        else if (cancelled) {
+                            // The wire stream ended with `stopReason: "cancelled"` — the
+                            // run was aborted mid-flight. Cancellation contract: `events`
+                            // ends normally (consumers iterating `run.events` see the
+                            // cancelled `completionDone` and exit naturally), and the
+                            // promise-aggregates reject with `InferenceCancelledError`
+                            // carrying whatever the aggregator accumulated up to the
+                            // cancel point. Consumers do `instanceof
+                            // InferenceCancelledError` and read `.partial.text` /
+                            // `.partial.toolCalls` / `.partial.stats` if they want the
+                            // partial output.
+                            const err = new InferenceCancelledError(requestId, {
+                                text: final.contentText,
+                                toolCalls: final.toolCalls,
+                                ...(final.stats && { stats: final.stats }),
+                            });
+                            finalRejecter(err);
+                            statsRejecter(err);
+                            toolCallsRejecter(err);
+                        }
                         else {
                             finalResolver(final);
                             statsResolver(final.stats);
@@ -291,6 +320,7 @@ export function completion(params) {
             }
         })();
         return {
+            requestId,
             events: eventStream,
             final: finalPromise,
             tokenStream,
@@ -308,6 +338,7 @@ export function completion(params) {
             //Empty generator for non-streaming mode
         })();
         return {
+            requestId,
             events: eventStream,
             final: finalPromise,
             tokenStream,

package/dist/client/api/diffusion.d.ts

@@ -34,6 +34,52 @@ interface DiffusionResult {
  * // modelConfig: { prediction: "flux2_flow" } })`).
  * const { outputs } = diffusion({ modelId, prompt: "turn into watercolor", init_image: initImage });
  *
+ * // FLUX.2 multi-reference fusion
+ * // IMPORTANT: requires the model loaded with `modelConfig: { prediction: "flux2_flow" }`
+ * // and a Qwen3 text encoder via `llmModelSrc` (same loadModel requirements as the
+ * // FLUX.2 img2img example above). `init_image` and `init_images` are mutually
+ * // exclusive — pass one or the other, not both.
+ * const refA = fs.readFileSync("scientist-a.jpg");
+ * const refB = fs.readFileSync("scientist-b.jpg");
+ * const { outputs } = diffusion({
+ *   modelId,
+ *   prompt: "a portrait using most visual traits from @image1 and the eyes from @image2",
+ *   init_images: [refA, refB],
+ *   width: 768,
+ *   height: 768,
+ * });
+ *
+ * // LoRA adapter for this generation (absolute path required).
+ * // Persistence across subsequent diffusion() calls is controlled at
+ * // loadModel time via `modelConfig.lora_apply_mode`.
+ * const { outputs } = diffusion({
+ *   modelId,
+ *   prompt: "a watercolor cat",
+ *   lora: "/home/user/loras/watercolor.safetensors",
+ * });
+ *
+ * // ESRGAN upscale; requires the model to be loaded with `modelConfig.upscaler.model_src` set.
+ * const { outputs: singleOutputs } = diffusion({
+ *   modelId,
+ *   prompt: "a fox portrait",
+ *   width: 128,
+ *   height: 128,
+ *   upscale: true, // one native-scale pass
+ * });
+ * const single = await singleOutputs;
+ * fs.writeFileSync("upscaled.png", single[0]);
+ *
+ * // Repeat upscale passes when needed.
+ * const { outputs: hiresOutputs } = diffusion({
+ *   modelId,
+ *   prompt: "a fox portrait",
+ *   width: 128,
+ *   height: 128,
+ *   upscale: { repeats: 2 },
+ * });
+ * const hires = await hiresOutputs;
+ * fs.writeFileSync("hires.png", hires[0]);
+ *
  * // With progress tracking
  * const { progressStream, outputs } = diffusion({ modelId, prompt: "a cat" });
  * for await (const { step, totalSteps } of progressStream) {

package/dist/client/api/diffusion.js

@@ -26,6 +26,52 @@ import { decodeBase64, encodeBase64 } from "../../utils/encoding.js";
  * // modelConfig: { prediction: "flux2_flow" } })`).
  * const { outputs } = diffusion({ modelId, prompt: "turn into watercolor", init_image: initImage });
  *
+ * // FLUX.2 multi-reference fusion
+ * // IMPORTANT: requires the model loaded with `modelConfig: { prediction: "flux2_flow" }`
+ * // and a Qwen3 text encoder via `llmModelSrc` (same loadModel requirements as the
+ * // FLUX.2 img2img example above). `init_image` and `init_images` are mutually
+ * // exclusive — pass one or the other, not both.
+ * const refA = fs.readFileSync("scientist-a.jpg");
+ * const refB = fs.readFileSync("scientist-b.jpg");
+ * const { outputs } = diffusion({
+ *   modelId,
+ *   prompt: "a portrait using most visual traits from @image1 and the eyes from @image2",
+ *   init_images: [refA, refB],
+ *   width: 768,
+ *   height: 768,
+ * });
+ *
+ * // LoRA adapter for this generation (absolute path required).
+ * // Persistence across subsequent diffusion() calls is controlled at
+ * // loadModel time via `modelConfig.lora_apply_mode`.
+ * const { outputs } = diffusion({
+ *   modelId,
+ *   prompt: "a watercolor cat",
+ *   lora: "/home/user/loras/watercolor.safetensors",
+ * });
+ *
+ * // ESRGAN upscale; requires the model to be loaded with `modelConfig.upscaler.model_src` set.
+ * const { outputs: singleOutputs } = diffusion({
+ *   modelId,
+ *   prompt: "a fox portrait",
+ *   width: 128,
+ *   height: 128,
+ *   upscale: true, // one native-scale pass
+ * });
+ * const single = await singleOutputs;
+ * fs.writeFileSync("upscaled.png", single[0]);
+ *
+ * // Repeat upscale passes when needed.
+ * const { outputs: hiresOutputs } = diffusion({
+ *   modelId,
+ *   prompt: "a fox portrait",
+ *   width: 128,
+ *   height: 128,
+ *   upscale: { repeats: 2 },
+ * });
+ * const hires = await hiresOutputs;
+ * fs.writeFileSync("hires.png", hires[0]);
+ *
  * // With progress tracking
  * const { progressStream, outputs } = diffusion({ modelId, prompt: "a cat" });
  * for await (const { step, totalSteps } of progressStream) {
@@ -35,10 +81,13 @@ import { decodeBase64, encodeBase64 } from "../../utils/encoding.js";
  * ```
  */
 export function diffusion(params) {
-    const { init_image, ...rest } = params;
+    const { init_image, init_images, ...rest } = params;
     const request = {
         ...rest,
         ...(init_image !== undefined && { init_image: encodeBase64(init_image) }),
+        ...(init_images !== undefined && {
+            init_images: init_images.map(encodeBase64),
+        }),
         type: "diffusionStream",
     };
     let statsResolver = () => { };

package/dist/client/api/download-asset.d.ts

@@ -13,7 +13,9 @@ export type DownloadAssetOptions = BaseDownloadAssetOptions;
  *   - onProgress: Optional callback for download progress
  * @param rpcOptions - Optional RPC options including per-call profiling configuration
  *
- * @returns Promise that resolves to the asset ID (either the provided assetSrc or a generated ID)
+ * @returns Promise that resolves to the asset ID (either the provided assetSrc or a generated ID),
+ *   decorated with a synchronous `requestId` field for use with
+ *   `cancel({ requestId: op.requestId })` before the promise resolves.
  *
  * @throws {QvacErrorBase} When asset download fails, with details in the error message
  * @throws {QvacErrorBase} When streaming ends unexpectedly (only when using onProgress)
@@ -34,7 +36,15 @@ export type DownloadAssetOptions = BaseDownloadAssetOptions;
  *     console.log(`Downloaded: ${progress.percentage}%`);
  *   }
  * });
+ *
+ * // Targeted cancel by requestId — grab the id synchronously, then
+ * // cancel before the download resolves.
+ * const op = downloadAsset({ assetSrc: "https://example.com/large.gguf" });
+ * setTimeout(() => cancel({ requestId: op.requestId }), 1000);
+ * await op; // rejects with `InferenceCancelledError`
  * ```
  */
-export declare function downloadAsset(options: DownloadAssetOptions, rpcOptions?: RPCOptions): Promise<string>;
+export declare function downloadAsset(options: DownloadAssetOptions, rpcOptions?: RPCOptions): Promise<string> & {
+    requestId: string;
+};
 //# sourceMappingURL=download-asset.d.ts.map

package/dist/client/api/download-asset.js

@@ -1,6 +1,8 @@
 import { send, stream } from "../rpc/rpc-client.js";
 import { downloadAssetOptionsToRequestSchema, } from "../../schemas/index.js";
 import { DownloadAssetFailedError, StreamEndedError, InvalidResponseError, } from "../../utils/errors-client.js";
+import { decoratePromise } from "../../utils/decorate-promise.js";
+import { generateClientRequestId } from "./client-request-id.js";
 /**
  * Downloads an asset (model file) without loading it into memory.
  *
@@ -14,7 +16,9 @@ import { DownloadAssetFailedError, StreamEndedError, InvalidResponseError, } fro
  *   - onProgress: Optional callback for download progress
  * @param rpcOptions - Optional RPC options including per-call profiling configuration
  *
- * @returns Promise that resolves to the asset ID (either the provided assetSrc or a generated ID)
+ * @returns Promise that resolves to the asset ID (either the provided assetSrc or a generated ID),
+ *   decorated with a synchronous `requestId` field for use with
+ *   `cancel({ requestId: op.requestId })` before the promise resolves.
  *
  * @throws {QvacErrorBase} When asset download fails, with details in the error message
  * @throws {QvacErrorBase} When streaming ends unexpectedly (only when using onProgress)
@@ -35,10 +39,24 @@ import { DownloadAssetFailedError, StreamEndedError, InvalidResponseError, } fro
  *     console.log(`Downloaded: ${progress.percentage}%`);
  *   }
  * });
+ *
+ * // Targeted cancel by requestId — grab the id synchronously, then
+ * // cancel before the download resolves.
+ * const op = downloadAsset({ assetSrc: "https://example.com/large.gguf" });
+ * setTimeout(() => cancel({ requestId: op.requestId }), 1000);
+ * await op; // rejects with `InferenceCancelledError`
  * ```
  */
-export async function downloadAsset(options, rpcOptions) {
-    const request = downloadAssetOptionsToRequestSchema.parse(options);
+export function downloadAsset(options, rpcOptions) {
+    const requestId = generateClientRequestId();
+    const inner = runDownloadAsset(options, requestId, rpcOptions);
+    return decoratePromise(inner, { requestId });
+}
+async function runDownloadAsset(options, requestId, rpcOptions) {
+    const request = downloadAssetOptionsToRequestSchema.parse({
+        ...options,
+        requestId,
+    });
     if (options.onProgress) {
         // Use streaming for progress updates
         for await (const response of stream(request, rpcOptions)) {

package/dist/client/api/embed.d.ts

@@ -7,7 +7,7 @@ import { type EmbedStats, type RPCOptions } from "../../schemas/index";
  * @param params.modelId - The identifier of the embedding model to use
  * @param params.text - The input text to embed
  * @param options - Optional RPC options including per-call profiling
- * @returns A promise resolving to an object with `embedding` (a single `number[]` vector) and optional `stats` performance data.
+ * @returns A promise (decorated with `requestId`) resolving to an object with `embedding` (a single `number[]` vector) and optional `stats` performance data.
  * @throws {QvacErrorBase} When the response type is invalid or when the embedding fails
  */
 export declare function embed(params: {
@@ -16,7 +16,9 @@ export declare function embed(params: {
 }, options?: RPCOptions): Promise<{
     embedding: number[];
     stats?: EmbedStats;
-}>;
+}> & {
+    requestId: string;
+};
 /**
  * Generates embeddings for multiple texts using a specified model.
  *
@@ -25,7 +27,7 @@ export declare function embed(params: {
  * @param params.modelId - The identifier of the embedding model to use
  * @param params.text - The input texts to embed
  * @param options - Optional RPC options including per-call profiling
- * @returns A promise resolving to an object with `embedding` (one `number[]` vector per input text, i.e. `number[][]`) and optional `stats` performance data.
+ * @returns A promise (decorated with `requestId`) resolving to an object with `embedding` (one `number[]` vector per input text, i.e. `number[][]`) and optional `stats` performance data.
  * @throws {QvacErrorBase} When the response type is invalid or when the embedding fails
  */
 export declare function embed(params: {
@@ -34,5 +36,7 @@ export declare function embed(params: {
 }, options?: RPCOptions): Promise<{
     embedding: number[][];
     stats?: EmbedStats;
-}>;
+}> & {
+    requestId: string;
+};
 //# sourceMappingURL=embed.d.ts.map