@qvac/sdk 0.10.2 → 0.12.0

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" | "vla" | "llm" | "whisper" | "nmt" | "parakeet" | "classification" | "vad" | "other";
     isCached: boolean;
     isLoaded: boolean;
     cacheFiles: {

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

@@ -19,8 +19,13 @@ export { getLoadedModelInfo } from "./get-loaded-model-info";
 export { ocr } from "./ocr";
 export { invokePlugin, invokePluginStream } from "./invoke-plugin";
 export { diffusion, type DiffusionProgressTick } from "./diffusion";
+export { classify } from "./classify";
+export { video, type VideoProgressTick } from "./video";
+export { upscale } from "./upscale";
 export { modelRegistryList, modelRegistrySearch, modelRegistryGetModel, type ModelRegistrySearchParams, } from "./registry";
 export { suspend } from "./suspend";
 export { resume } from "./resume";
 export { state } from "./state";
+export { vla, vlaHparams } from "./vla";
+export { vlaPreprocessImage, vlaPadState, VLA_DEFAULT_IMAGE_SIZE, } from "./vla-helpers";
 //# sourceMappingURL=index.d.ts.map

package/dist/client/api/index.js

@@ -19,7 +19,12 @@ 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 { classify } from "./classify.js";
+export { video } from "./video.js";
+export { upscale } from "./upscale.js";
 export { modelRegistryList, modelRegistrySearch, modelRegistryGetModel, } from "./registry.js";
 export { suspend } from "./suspend.js";
 export { resume } from "./resume.js";
 export { state } from "./state.js";
+export { vla, vlaHparams } from "./vla.js";
+export { vlaPreprocessImage, vlaPadState, VLA_DEFAULT_IMAGE_SIZE, } from "./vla-helpers.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

@@ -1,11 +1,34 @@
 import { send, stream } from "../rpc/rpc-client.js";
 import { startLoggingStreamForModel } from "../logging-stream-registry.js";
-import { loadModelOptionsToRequestSchema, reloadConfigOptionsToRequestSchema, isModelTypeAlias, normalizeModelType, inferModelTypeFromModelSrc, } from "../../schemas/index.js";
+import { loadModelOptionsToRequestSchema, reloadConfigOptionsToRequestSchema, isModelTypeAlias, normalizeModelType, inferModelTypeFromModelSrc, ModelType, } from "../../schemas/index.js";
 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) {
+function isReactNativeRuntime() {
+    const runtime = globalThis;
+    return runtime.navigator?.product === "ReactNative";
+}
+let warnedLocalVideoModelLoad = false;
+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.
@@ -27,7 +50,31 @@ export async function loadModel(options, rpcOptions) {
             const canonical = normalizeModelType(modelType);
             logger.warn(`Model type "${modelType}" is an alias and will be deprecated. Use "${canonical}" instead.`);
         }
+        const canonicalModelType = typeof modelType === "string" ? normalizeModelType(modelType) : modelType;
+        const modelConfig = resolvedOptions["modelConfig"];
+        if (isReactNativeRuntime() &&
+            canonicalModelType === ModelType.sdcppGeneration &&
+            modelConfig?.mode === "video" &&
+            resolvedOptions["delegate"] === undefined &&
+            !warnedLocalVideoModelLoad) {
+            warnedLocalVideoModelLoad = true;
+            const message = "QVAC video generation works on React Native, but loading the video " +
+                "model on-device will usually fail or take several minutes — the video " +
+                "diffusion models currently shipped by the SDK are too large to load " +
+                "on typical mobile devices. Pass a `delegate` to `loadModel(...)` to " +
+                "run generation on a desktop peer instead.";
+            logger.warn(message);
+            // Surface via console too - if an RN host app doesn't wire getClientLogger()
+            // to a visible transport, logger.warn alone won't reach the dev.
+            console.warn(message);
+        }
     }
+    // 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,17 @@ 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 & {
+    parakeetStreamingConfig: NonNullable<TranscribeStreamClientParams["parakeetStreamingConfig"]>;
+}, options?: RPCOptions): Promise<TranscribeStreamConversationSession>;
 export declare function transcribeStream(params: TranscribeStreamClientParams & {
     metadata: true;
 }, options?: RPCOptions): Promise<TranscribeStreamMetadataSession>;

package/dist/client/api/transcribe.js

@@ -2,8 +2,10 @@ import { transcribeResponseSchema, transcribeStreamResponseSchema, } from "../..
 import { stream, duplex } from "../rpc/rpc-client.js";
 import { getClientLogger } from "../../logging/index.js";
 import { TranscriptionFailedError } from "../../utils/errors-client.js";
+import { decoratePromise } from "../../utils/decorate-promise.js";
+import { generateClientRequestId } from "./client-request-id.js";
 const logger = getClientLogger();
-function buildTranscribeRequest(params) {
+function buildTranscribeRequest(params, requestId) {
     return {
         type: "transcribe",
         modelId: params.modelId,
@@ -12,10 +14,21 @@ function buildTranscribeRequest(params) {
             : { type: "base64", value: params.audioChunk.toString("base64") },
         ...(params.prompt && { prompt: params.prompt }),
         ...(params.metadata === true && { metadata: true }),
+        requestId,
     };
 }
-export async function transcribe(params, options) {
-    const request = buildTranscribeRequest(params);
+export function transcribe(params, options) {
+    // Client-generated id surfaced synchronously on the returned promise
+    // — same shape as `loadModel` / `downloadAsset` / `completion`. The
+    // CLI cancel bridge in `qvac serve` binds `req.on('close')` to
+    // `cancel({ requestId })` immediately after the call returns so a
+    // client disconnect aborts the in-flight transcription.
+    const requestId = generateClientRequestId();
+    const inner = runTranscribe(params, requestId, options);
+    return decoratePromise(inner, { requestId });
+}
+async function runTranscribe(params, requestId, options) {
+    const request = buildTranscribeRequest(params, requestId);
     if (params.metadata === true) {
         const segments = [];
         for await (const response of stream(request, options)) {
@@ -54,6 +67,10 @@ export function transcribeStream(params, options) {
         return transcribeStreamWithAudio(params, options);
     }
     const streamParams = params;
+    if (streamParams.emitVadEvents === true ||
+        streamParams.parakeetStreamingConfig !== undefined) {
+        return transcribeStreamDuplexConversation(streamParams, options);
+    }
     if (streamParams.metadata === true) {
         return transcribeStreamDuplexMetadata(streamParams, options);
     }
@@ -64,7 +81,7 @@ export function transcribeStream(params, options) {
  * the value extracted from each response frame until `done` is seen.
  */
 async function* streamTranscribeValues(params, options, extract) {
-    const request = buildTranscribeRequest(params);
+    const request = buildTranscribeRequest(params, generateClientRequestId());
     for await (const response of stream(request, options)) {
         if (response.type === "transcribe") {
             const parsed = transcribeResponseSchema.parse(response);
@@ -88,6 +105,16 @@ function buildTranscribeStreamRequest(params) {
         modelId: params.modelId,
         ...(params.prompt && { prompt: params.prompt }),
         ...(params.metadata === true && { metadata: true }),
+        ...(params.emitVadEvents === true && { emitVadEvents: true }),
+        ...(params.endOfTurnSilenceMs !== undefined && {
+            endOfTurnSilenceMs: params.endOfTurnSilenceMs,
+        }),
+        ...(params.vadRunIntervalMs !== undefined && {
+            vadRunIntervalMs: params.vadRunIntervalMs,
+        }),
+        ...(params.parakeetStreamingConfig && {
+            parakeetStreamingConfig: params.parakeetStreamingConfig,
+        }),
     };
 }
 /**
@@ -126,6 +153,10 @@ function transcribeStreamDuplex(params, options) {
 function transcribeStreamDuplexMetadata(params, options) {
     return createTranscribeStreamSession(params, options, processLineMetadata, "TranscribeStreamMetadataSession");
 }
+function transcribeStreamDuplexConversation(params, options) {
+    const wantsMetadata = params.metadata === true;
+    return createTranscribeStreamSession(params, options, (line) => processLineConversation(line, wantsMetadata), "TranscribeStreamConversationSession");
+}
 /**
  * Line-delimited parser: reads newline-separated frames from a duplex
  * response stream, passes each non-empty line through `process`, and yields
@@ -190,3 +221,37 @@ function processLine(line) {
 function processLineMetadata(line) {
     return processWith(line, (response) => response.segment);
 }
+function processLineConversation(line, wantsMetadata) {
+    return processWith(line, (response) => {
+        if (response.vad) {
+            return {
+                type: "vad",
+                speaking: response.vad.speaking,
+                probability: response.vad.probability,
+            };
+        }
+        if (response.endOfTurn) {
+            if (response.endOfTurn.source === "whisper") {
+                return {
+                    type: "endOfTurn",
+                    source: "whisper",
+                    silenceDurationMs: response.endOfTurn.silenceDurationMs,
+                };
+            }
+            return {
+                type: "endOfTurn",
+                source: "parakeet",
+            };
+        }
+        if (wantsMetadata) {
+            if (response.segment) {
+                return { type: "segment", segment: response.segment };
+            }
+            return undefined;
+        }
+        if (response.text && response.text.trim()) {
+            return { type: "text", text: response.text };
+        }
+        return undefined;
+    });
+}

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

@@ -3,12 +3,15 @@ import { type UnloadModelParams } from "../../schemas/index";
  * Unloads a previously loaded model from the server.
  *
  * When the last model is unloaded (no more models remain), this function
- * automatically closes the RPC connection, allowing the process to exit
- * naturally without requiring manual cleanup.
+ * automatically closes the RPC connection on Node/Electron, allowing the
+ * process to exit naturally without requiring manual cleanup. On Bare the
+ * connection is left open by default so long-lived workers survive a routine
+ * unload; pass `autoClose: true` to opt in to closing.
  *
  * @param params - The parameters for unloading the model
  * @param params.modelId - The unique identifier of the model to unload
  * @param params.clearStorage - Whether to clear the storage for the model
+ * @param params.autoClose - Override the runtime-default auto-close behavior
  * @throws {QvacErrorBase} When the response type is invalid or when the unload operation fails
  */
 export declare function unloadModel(params: UnloadModelParams): Promise<void>;

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

@@ -1,3 +1,4 @@
+import { isBare } from "which-runtime";
 import {} from "../../schemas/index.js";
 import { send, close } from "../rpc/rpc-client.js";
 import { stopLoggingStreamForModel } from "../logging-stream-registry.js";
@@ -8,12 +9,15 @@ const logger = getClientLogger();
  * Unloads a previously loaded model from the server.
  *
  * When the last model is unloaded (no more models remain), this function
- * automatically closes the RPC connection, allowing the process to exit
- * naturally without requiring manual cleanup.
+ * automatically closes the RPC connection on Node/Electron, allowing the
+ * process to exit naturally without requiring manual cleanup. On Bare the
+ * connection is left open by default so long-lived workers survive a routine
+ * unload; pass `autoClose: true` to opt in to closing.
  *
  * @param params - The parameters for unloading the model
  * @param params.modelId - The unique identifier of the model to unload
  * @param params.clearStorage - Whether to clear the storage for the model
+ * @param params.autoClose - Override the runtime-default auto-close behavior
  * @throws {QvacErrorBase} When the response type is invalid or when the unload operation fails
  */
 export async function unloadModel(params) {
@@ -30,8 +34,9 @@ export async function unloadModel(params) {
         throw new ModelUnloadFailedError(params.modelId);
     }
     stopLoggingStreamForModel(params.modelId);
-    // Auto-close when no models remain AND no providers are active
-    if (response.hasActiveModels === false &&
+    const shouldAutoClose = params.autoClose ?? !isBare;
+    if (shouldAutoClose &&
+        response.hasActiveModels === false &&
         response.hasActiveProviders === false) {
         logger.info("🧹 No models or providers active, automatically closing RPC connection...");
         await close();

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

@@ -0,0 +1,45 @@
+import { type UpscaleClientParams, type UpscaleStats } from "../../schemas/sdcpp-config";
+interface UpscaleResult {
+    outputs: Promise<Uint8Array[]>;
+    stats: Promise<UpscaleStats | undefined>;
+}
+/**
+ * Runs standalone ESRGAN upscaling on an arbitrary PNG/JPEG image.
+ *
+ * The model must have been loaded with `modelType: "diffusion"` and
+ * `modelConfig.mode: "upscale"` — calling `upscale()` against a model
+ * loaded in default (`mode: "diffusion"`) mode throws
+ * `ModelOperationNotSupportedError` upfront.
+ *
+ * `outputs` always resolves to length 1: `repeats` runs N passes
+ * internally and emits a single final image at `source * scale^repeats`
+ * dimensions. The `Uint8Array[]` shape reserves headroom for future
+ * multi-output variants.
+ *
+ * @param params - `{ modelId, image, repeats? }`. `image` is raw PNG/JPEG
+ *   bytes; the client base64-encodes them on the wire.
+ * @returns `{ outputs, stats }` — `outputs` resolves to a single-element
+ *   array containing the final upscaled PNG; `stats` resolves to
+ *   addon-side stats (load/upscale ms, final width/height, repeats
+ *   actually executed, etc.).
+ * @throws {ModelOperationNotSupportedError} If the model was not loaded
+ *   with `mode: "upscale"`.
+ * @throws {StreamEndedError} If the RPC stream closes without emitting a
+ *   terminal `done` chunk.
+ *
+ * @example
+ * ```ts
+ * const modelId = await loadModel(REALESRGAN_X4PLUS_ANIME_6B, {
+ *   modelType: "diffusion",
+ *   modelConfig: { mode: "upscale", upscaler: { tile_size: 128 } },
+ * });
+ * const pngBytes = fs.readFileSync("input.png");
+ * const { outputs, stats } = upscale({ modelId, image: pngBytes, repeats: 2 });
+ * const [upscaledPng] = await outputs;
+ * fs.writeFileSync("upscaled.png", upscaledPng);
+ * console.log(await stats);
+ * ```
+ */
+export declare function upscale(params: UpscaleClientParams): UpscaleResult;
+export {};
+//# sourceMappingURL=upscale.d.ts.map

package/dist/client/api/upscale.js

@@ -0,0 +1,99 @@
+import { upscaleStreamResponseSchema, } from "../../schemas/sdcpp-config.js";
+import { stream as streamRpc } from "../rpc/rpc-client.js";
+import { decodeBase64, encodeBase64 } from "../../utils/encoding.js";
+import { StreamEndedError } from "../../utils/errors-client.js";
+/**
+ * Runs standalone ESRGAN upscaling on an arbitrary PNG/JPEG image.
+ *
+ * The model must have been loaded with `modelType: "diffusion"` and
+ * `modelConfig.mode: "upscale"` — calling `upscale()` against a model
+ * loaded in default (`mode: "diffusion"`) mode throws
+ * `ModelOperationNotSupportedError` upfront.
+ *
+ * `outputs` always resolves to length 1: `repeats` runs N passes
+ * internally and emits a single final image at `source * scale^repeats`
+ * dimensions. The `Uint8Array[]` shape reserves headroom for future
+ * multi-output variants.
+ *
+ * @param params - `{ modelId, image, repeats? }`. `image` is raw PNG/JPEG
+ *   bytes; the client base64-encodes them on the wire.
+ * @returns `{ outputs, stats }` — `outputs` resolves to a single-element
+ *   array containing the final upscaled PNG; `stats` resolves to
+ *   addon-side stats (load/upscale ms, final width/height, repeats
+ *   actually executed, etc.).
+ * @throws {ModelOperationNotSupportedError} If the model was not loaded
+ *   with `mode: "upscale"`.
+ * @throws {StreamEndedError} If the RPC stream closes without emitting a
+ *   terminal `done` chunk.
+ *
+ * @example
+ * ```ts
+ * const modelId = await loadModel(REALESRGAN_X4PLUS_ANIME_6B, {
+ *   modelType: "diffusion",
+ *   modelConfig: { mode: "upscale", upscaler: { tile_size: 128 } },
+ * });
+ * const pngBytes = fs.readFileSync("input.png");
+ * const { outputs, stats } = upscale({ modelId, image: pngBytes, repeats: 2 });
+ * const [upscaledPng] = await outputs;
+ * fs.writeFileSync("upscaled.png", upscaledPng);
+ * console.log(await stats);
+ * ```
+ */
+export function upscale(params) {
+    const request = {
+        modelId: params.modelId,
+        image: encodeBase64(params.image),
+        ...(params.repeats !== undefined && { repeats: params.repeats }),
+        type: "upscaleStream",
+    };
+    let statsResolver = () => { };
+    let statsRejecter = () => { };
+    const statsPromise = new Promise((resolve, reject) => {
+        statsResolver = resolve;
+        statsRejecter = reject;
+    });
+    statsPromise.catch(() => { });
+    let outputsResolver = () => { };
+    let outputsRejecter = () => { };
+    const outputsPromise = new Promise((resolve, reject) => {
+        outputsResolver = resolve;
+        outputsRejecter = reject;
+    });
+    outputsPromise.catch(() => { });
+    const collectedBuffers = [];
+    async function processResponses() {
+        let sawDone = false;
+        try {
+            for await (const response of streamRpc(request)) {
+                if (response &&
+                    typeof response === "object" &&
+                    "type" in response &&
+                    response.type === "upscaleStream") {
+                    const parsed = upscaleStreamResponseSchema.parse(response);
+                    if (parsed.data) {
+                        collectedBuffers.push(decodeBase64(parsed.data));
+                    }
+                    if (parsed.done) {
+                        sawDone = true;
+                        statsResolver(parsed.stats);
+                        outputsResolver(collectedBuffers);
+                    }
+                }
+            }
+            if (!sawDone) {
+                const error = new StreamEndedError();
+                statsRejecter(error);
+                outputsRejecter(error);
+            }
+        }
+        catch (error) {
+            statsRejecter(error);
+            outputsRejecter(error);
+        }
+    }
+    void processResponses();
+    return {
+        outputs: outputsPromise,
+        stats: statsPromise,
+    };
+}