@qvac/sdk 0.10.1 → 0.11.0

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

package/dist/client/api/embed.js

@@ -1,10 +1,23 @@
 import { send } from "../rpc/rpc-client.js";
 import {} from "../../schemas/index.js";
 import { InvalidResponseError } from "../../utils/errors-client.js";
-export async function embed(params, options) {
+import { decoratePromise } from "../../utils/decorate-promise.js";
+import { generateClientRequestId } from "./client-request-id.js";
+export function embed(params, options) {
+    // Client-generated `requestId` is surfaced synchronously on the
+    // returned promise so the caller can `cancel({ requestId })` before
+    // `await` resolves. The same id is threaded onto the wire envelope so
+    // the server's registry entry uses it as the canonical key —
+    // matching the `loadModel` / `downloadAsset` / `completion` shape.
+    const requestId = generateClientRequestId();
+    const inner = runEmbed(params, requestId, options);
+    return decoratePromise(inner, { requestId });
+}
+async function runEmbed(params, requestId, options) {
     const request = {
         type: "embed",
         ...params,
+        requestId,
     };
     const response = await send(request, options);
     if (response.type !== "embed") {

package/dist/client/api/get-model-info.d.ts

@@ -12,7 +12,7 @@ export declare function getModelInfo(params: GetModelInfoParams): Promise<{
     modelId: string;
     expectedSize: number;
     sha256Checksum: string;
-    addon: "embeddings" | "llm" | "whisper" | "nmt" | "parakeet" | "tts" | "ocr" | "diffusion" | "vad" | "other";
+    addon: "embeddings" | "diffusion" | "tts" | "ocr" | "llm" | "whisper" | "nmt" | "parakeet" | "vad" | "other";
     isCached: boolean;
     isLoaded: boolean;
     cacheFiles: {

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

@@ -19,6 +19,7 @@ export { getLoadedModelInfo } from "./get-loaded-model-info";
 export { ocr } from "./ocr";
 export { invokePlugin, invokePluginStream } from "./invoke-plugin";
 export { diffusion, type DiffusionProgressTick } from "./diffusion";
+export { upscale } from "./upscale";
 export { modelRegistryList, modelRegistrySearch, modelRegistryGetModel, type ModelRegistrySearchParams, } from "./registry";
 export { suspend } from "./suspend";
 export { resume } from "./resume";

package/dist/client/api/index.js

@@ -19,6 +19,7 @@ export { getLoadedModelInfo } from "./get-loaded-model-info.js";
 export { ocr } from "./ocr.js";
 export { invokePlugin, invokePluginStream } from "./invoke-plugin.js";
 export { diffusion } from "./diffusion.js";
+export { upscale } from "./upscale.js";
 export { modelRegistryList, modelRegistrySearch, modelRegistryGetModel, } from "./registry.js";
 export { suspend } from "./suspend.js";
 export { resume } from "./resume.js";

package/dist/client/api/load-model.d.ts

@@ -17,7 +17,9 @@ import { type LoadModelOptions, type LoadCustomPluginModelOptions, type LoadMode
  * await loadModel({ modelSrc: WHISPER_TINY });
  * ```
  */
-export declare function loadModel<S extends ModelDescriptor>(options: LoadModelDescriptorParam<S>, rpcOptions?: RPCOptions): Promise<string>;
+export declare function loadModel<S extends ModelDescriptor>(options: LoadModelDescriptorParam<S>, rpcOptions?: RPCOptions): Promise<string> & {
+    requestId: string;
+};
 /**
  * Loads a machine learning model from a local path, remote URL, or Hyperdrive key.
  *
@@ -110,7 +112,9 @@ export declare function loadModel<S extends ModelDescriptor>(options: LoadModelD
  * });
  * ```
  */
-export declare function loadModel(options: LoadModelOptions, rpcOptions?: RPCOptions): Promise<string>;
+export declare function loadModel(options: LoadModelOptions, rpcOptions?: RPCOptions): Promise<string> & {
+    requestId: string;
+};
 /**
  * Loads a custom plugin model (any non-built-in `modelType` string).
  * `modelConfig` is plugin-defined; the SDK does not narrow it.
@@ -122,7 +126,9 @@ export declare function loadModel(options: LoadModelOptions, rpcOptions?: RPCOpt
  * @param rpcOptions - Optional RPC options including per-call profiling.
  * @returns Promise that resolves to the loaded model ID.
  */
-export declare function loadModel<T extends string>(options: LoadCustomPluginModelOptions<T>, rpcOptions?: RPCOptions): Promise<string>;
+export declare function loadModel<T extends string>(options: LoadCustomPluginModelOptions<T>, rpcOptions?: RPCOptions): Promise<string> & {
+    requestId: string;
+};
 /**
  * Hot-reloads configuration on an already loaded model.
  *
@@ -155,5 +161,7 @@ export declare function loadModel<T extends string>(options: LoadCustomPluginMod
  * });
  * ```
  */
-export declare function loadModel(options: ReloadConfigOptions, rpcOptions?: RPCOptions): Promise<string>;
+export declare function loadModel(options: ReloadConfigOptions, rpcOptions?: RPCOptions): Promise<string> & {
+    requestId: string;
+};
 //# sourceMappingURL=load-model.d.ts.map

package/dist/client/api/load-model.js

@@ -4,8 +4,26 @@ import { loadModelOptionsToRequestSchema, reloadConfigOptionsToRequestSchema, is
 import { ModelLoadFailedError, ModelTypeRequiredError, StreamEndedError, InvalidResponseError, } from "../../utils/errors-client.js";
 import { assertModelSrcMatchesModelType } from "../../utils/load-model-validation.js";
 import { getClientLogger } from "../../logging/index.js";
+import { decoratePromise } from "../../utils/decorate-promise.js";
+import { generateClientRequestId } from "./client-request-id.js";
 const logger = getClientLogger();
-export async function loadModel(options, rpcOptions) {
+export function loadModel(options, rpcOptions) {
+    // Generate a stable `requestId` once, synchronously, before kicking
+    // off any async work. The same id is:
+    //   - threaded onto the request envelope (`request.requestId`) so the
+    //     server's `registry.begin(...)` records it on the registry
+    //     entry; and
+    //   - attached to the returned promise via `decoratePromise` so the
+    //     caller can target this exact call with `cancel({ requestId })`
+    //     before `await` resolves. Generating client-side and surfacing
+    //     it synchronously is what closes the "stop-button race" gap for
+    //     `loadModel` / `downloadAsset` callers — same shape as the
+    //     `CompletionRun.requestId` contract.
+    const requestId = generateClientRequestId();
+    const inner = runLoadModel(options, requestId, rpcOptions);
+    return decoratePromise(inner, { requestId });
+}
+async function runLoadModel(options, requestId, rpcOptions) {
     const isReloadConfig = "modelId" in options && !("modelSrc" in options);
     // Infer `modelType` from `modelSrc` when omitted; the schema still validates
     // the resolved options below.
@@ -28,6 +46,12 @@ export async function loadModel(options, rpcOptions) {
             logger.warn(`Model type "${modelType}" is an alias and will be deprecated. Use "${canonical}" instead.`);
         }
     }
+    // Splice the client-generated `requestId` onto the resolved options so
+    // the wire envelope carries it. The server uses the same value as the
+    // registry-entry key — that match is what makes
+    // `cancel({ requestId: op.requestId })` a no-op when no match exists
+    // and a precise abort when it does.
+    resolvedOptions = { ...resolvedOptions, requestId };
     const request = isReloadConfig
         ? reloadConfigOptionsToRequestSchema.parse(resolvedOptions)
         : loadModelOptionsToRequestSchema.parse(resolvedOptions);

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

@@ -65,7 +65,9 @@ export declare function ragChunk(params: RagChunkParams, options?: RPCOptions):
 export declare function ragIngest(params: RagIngestParams, options?: RPCOptions): Promise<{
     processed: RagSaveEmbeddingsResult[];
     droppedIndices: number[];
-}>;
+}> & {
+    requestId: string;
+};
 /**
  * Saves pre-embedded documents to the RAG vector database.
  * Part of the segregated flow: chunk() → embed() → saveEmbeddings()
@@ -99,7 +101,9 @@ export declare function ragIngest(params: RagIngestParams, options?: RPCOptions)
  * });
  * ```
  */
-export declare function ragSaveEmbeddings(params: RagSaveEmbeddingsParams, options?: RPCOptions): Promise<RagSaveEmbeddingsResult[]>;
+export declare function ragSaveEmbeddings(params: RagSaveEmbeddingsParams, options?: RPCOptions): Promise<RagSaveEmbeddingsResult[]> & {
+    requestId: string;
+};
 /**
  * Searches for similar documents in the RAG vector database.
  *
@@ -186,7 +190,9 @@ export declare function ragDeleteEmbeddings(params: RagDeleteEmbeddingsParams, o
  * });
  * ```
  */
-export declare function ragReindex(params: RagReindexParams, options?: RPCOptions): Promise<RagReindexResult>;
+export declare function ragReindex(params: RagReindexParams, options?: RPCOptions): Promise<RagReindexResult> & {
+    requestId: string;
+};
 /**
  * Lists all RAG workspaces with their open status.
  *

package/dist/client/api/rag.js

@@ -1,5 +1,7 @@
 import { send, stream } from "../rpc/rpc-client.js";
 import { InvalidResponseError, InvalidOperationError, StreamEndedError, RAGChunkFailedError, RAGSaveFailedError, RAGSearchFailedError, RAGDeleteFailedError, RAGCloseWorkspaceFailedError, RAGListWorkspacesFailedError, } from "../../utils/errors-client.js";
+import { generateClientRequestId } from "./client-request-id.js";
+import { decoratePromise } from "../../utils/decorate-promise.js";
 // ============== Chunk ==============
 /**
  * Chunks documents into smaller pieces for embedding.
@@ -82,7 +84,12 @@ export async function ragChunk(params, options) {
  * });
  * ```
  */
-export async function ragIngest(params, options) {
+export function ragIngest(params, options) {
+    const requestId = generateClientRequestId();
+    const inner = runRagIngest(params, requestId, options);
+    return decoratePromise(inner, { requestId });
+}
+async function runRagIngest(params, requestId, options) {
     const { onProgress, ...requestParams } = params;
     const request = {
         type: "rag",
@@ -90,6 +97,7 @@ export async function ragIngest(params, options) {
         ...requestParams,
         chunk: requestParams.chunk ?? true,
         withProgress: onProgress ? true : undefined,
+        requestId,
     };
     if (onProgress) {
         // Use streaming for progress updates
@@ -160,13 +168,19 @@ export async function ragIngest(params, options) {
  * });
  * ```
  */
-export async function ragSaveEmbeddings(params, options) {
+export function ragSaveEmbeddings(params, options) {
+    const requestId = generateClientRequestId();
+    const inner = runRagSaveEmbeddings(params, requestId, options);
+    return decoratePromise(inner, { requestId });
+}
+async function runRagSaveEmbeddings(params, requestId, options) {
     const { onProgress, ...requestParams } = params;
     const request = {
         type: "rag",
         operation: "saveEmbeddings",
         ...requestParams,
         withProgress: onProgress ? true : undefined,
+        requestId,
     };
     if (onProgress) {
         for await (const event of stream(request, options)) {
@@ -321,13 +335,19 @@ export async function ragDeleteEmbeddings(params, options) {
  * });
  * ```
  */
-export async function ragReindex(params, options) {
+export function ragReindex(params, options) {
+    const requestId = generateClientRequestId();
+    const inner = runRagReindex(params, requestId, options);
+    return decoratePromise(inner, { requestId });
+}
+async function runRagReindex(params, requestId, options) {
     const { onProgress, ...requestParams } = params;
     const request = {
         type: "rag",
         operation: "reindex",
         ...requestParams,
         withProgress: onProgress ? true : undefined,
+        requestId,
     };
     if (onProgress) {
         for await (const event of stream(request, options)) {

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

@@ -1,4 +1,4 @@
-import { type TranscribeClientParams, type RPCOptions, type TranscribeSegment, type TranscribeStreamClientParams, type TranscribeStreamSession, type TranscribeStreamMetadataSession } from "../../schemas/index";
+import { type TranscribeClientParams, type RPCOptions, type TranscribeSegment, type TranscribeStreamClientParams, type TranscribeStreamSession, type TranscribeStreamMetadataSession, type TranscribeStreamConversationSession } from "../../schemas/index";
 /**
  * Transcribe audio and return the complete text. Accepts either a file
  * path or an audio buffer.
@@ -11,13 +11,21 @@ import { type TranscribeClientParams, type RPCOptions, type TranscribeSegment, t
  *                          segments (`{ text, startMs, endMs, append, id }`)
  *                          instead of joined text. Whisper engine only.
  * @param options - Optional RPC options including per-call profiling
- * @returns The complete transcribed text, or — when `metadata` is true —
- *          the list of transcript segments in emission order.
+ * @returns A promise (decorated with `requestId`) resolving to the
+ *          complete transcribed text, or — when `metadata` is true —
+ *          the list of transcript segments in emission order. The
+ *          `requestId` is reachable synchronously so callers can target
+ *          this in-flight transcription with `cancel({ requestId })`
+ *          before `await` resolves.
  */
 export declare function transcribe(params: TranscribeClientParams & {
     metadata: true;
-}, options?: RPCOptions): Promise<TranscribeSegment[]>;
-export declare function transcribe(params: TranscribeClientParams, options?: RPCOptions): Promise<string>;
+}, options?: RPCOptions): Promise<TranscribeSegment[]> & {
+    requestId: string;
+};
+export declare function transcribe(params: TranscribeClientParams, options?: RPCOptions): Promise<string> & {
+    requestId: string;
+};
 /**
  * @deprecated Pass audio via `transcribe()` instead. This overload will be
  * removed in the next major version.
@@ -50,10 +58,14 @@ export declare function transcribeStream(params: TranscribeClientParams, options
  *                          objects (`{ text, startMs, endMs, append, id }`)
  *                          instead of plain text. Whisper engine only.
  * @param options - Optional RPC options including per-call profiling.
- * @returns A session object: call `write(buffer)` to feed audio,
- *          iterate with `for await (...)` to receive transcription,
- *          and `end()` to signal end of audio.
+ * @returns A session object: call `write(audioChunk)` with a `Uint8Array`
+ *          (Node `Buffer` is a `Uint8Array` subtype) to feed audio,
+ *          iterate with `for await (...)` to receive transcription, and
+ *          `end()` to signal end of audio.
  */
+export declare function transcribeStream(params: TranscribeStreamClientParams & {
+    emitVadEvents: true;
+}, options?: RPCOptions): Promise<TranscribeStreamConversationSession>;
 export declare function transcribeStream(params: TranscribeStreamClientParams & {
     metadata: true;
 }, options?: RPCOptions): Promise<TranscribeStreamMetadataSession>;