@qvac/sdk 0.10.2 → 0.11.0

package/dist/server/bare/plugins/parakeet-transcription/plugin.d.ts

@@ -46,6 +46,9 @@ export declare const parakeetPlugin: {
             sha256Checksum: import("zod").ZodOptional<import("zod").ZodString>;
             addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
                 embeddings: "embeddings";
+                diffusion: "diffusion";
+                tts: "tts";
+                ocr: "ocr";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -58,9 +61,6 @@ export declare const parakeetPlugin: {
                 whisper: "whisper";
                 nmt: "nmt";
                 parakeet: "parakeet";
-                tts: "tts";
-                ocr: "ocr";
-                diffusion: "diffusion";
             }>, import("zod").ZodLiteral<"vad">]>>;
         }, import("zod/v4/core").$strip>]>>;
         parakeetDecoderSrc: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
@@ -76,6 +76,9 @@ export declare const parakeetPlugin: {
             sha256Checksum: import("zod").ZodOptional<import("zod").ZodString>;
             addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
                 embeddings: "embeddings";
+                diffusion: "diffusion";
+                tts: "tts";
+                ocr: "ocr";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -88,9 +91,6 @@ export declare const parakeetPlugin: {
                 whisper: "whisper";
                 nmt: "nmt";
                 parakeet: "parakeet";
-                tts: "tts";
-                ocr: "ocr";
-                diffusion: "diffusion";
             }>, import("zod").ZodLiteral<"vad">]>>;
         }, import("zod/v4/core").$strip>]>>;
         parakeetVocabSrc: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
@@ -106,6 +106,9 @@ export declare const parakeetPlugin: {
             sha256Checksum: import("zod").ZodOptional<import("zod").ZodString>;
             addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
                 embeddings: "embeddings";
+                diffusion: "diffusion";
+                tts: "tts";
+                ocr: "ocr";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -118,9 +121,6 @@ export declare const parakeetPlugin: {
                 whisper: "whisper";
                 nmt: "nmt";
                 parakeet: "parakeet";
-                tts: "tts";
-                ocr: "ocr";
-                diffusion: "diffusion";
             }>, import("zod").ZodLiteral<"vad">]>>;
         }, import("zod/v4/core").$strip>]>>;
         parakeetPreprocessorSrc: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
@@ -136,6 +136,9 @@ export declare const parakeetPlugin: {
             sha256Checksum: import("zod").ZodOptional<import("zod").ZodString>;
             addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
                 embeddings: "embeddings";
+                diffusion: "diffusion";
+                tts: "tts";
+                ocr: "ocr";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -148,9 +151,6 @@ export declare const parakeetPlugin: {
                 whisper: "whisper";
                 nmt: "nmt";
                 parakeet: "parakeet";
-                tts: "tts";
-                ocr: "ocr";
-                diffusion: "diffusion";
             }>, import("zod").ZodLiteral<"vad">]>>;
         }, import("zod/v4/core").$strip>]>>;
         parakeetCtcModelSrc: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
@@ -166,6 +166,9 @@ export declare const parakeetPlugin: {
             sha256Checksum: import("zod").ZodOptional<import("zod").ZodString>;
             addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
                 embeddings: "embeddings";
+                diffusion: "diffusion";
+                tts: "tts";
+                ocr: "ocr";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -178,9 +181,6 @@ export declare const parakeetPlugin: {
                 whisper: "whisper";
                 nmt: "nmt";
                 parakeet: "parakeet";
-                tts: "tts";
-                ocr: "ocr";
-                diffusion: "diffusion";
             }>, import("zod").ZodLiteral<"vad">]>>;
         }, import("zod/v4/core").$strip>]>>;
         parakeetTokenizerSrc: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
@@ -196,6 +196,9 @@ export declare const parakeetPlugin: {
             sha256Checksum: import("zod").ZodOptional<import("zod").ZodString>;
             addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
                 embeddings: "embeddings";
+                diffusion: "diffusion";
+                tts: "tts";
+                ocr: "ocr";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -208,9 +211,6 @@ export declare const parakeetPlugin: {
                 whisper: "whisper";
                 nmt: "nmt";
                 parakeet: "parakeet";
-                tts: "tts";
-                ocr: "ocr";
-                diffusion: "diffusion";
             }>, import("zod").ZodLiteral<"vad">]>>;
         }, import("zod/v4/core").$strip>]>>;
         parakeetSortformerSrc: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
@@ -226,6 +226,9 @@ export declare const parakeetPlugin: {
             sha256Checksum: import("zod").ZodOptional<import("zod").ZodString>;
             addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
                 embeddings: "embeddings";
+                diffusion: "diffusion";
+                tts: "tts";
+                ocr: "ocr";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -238,9 +241,6 @@ export declare const parakeetPlugin: {
                 whisper: "whisper";
                 nmt: "nmt";
                 parakeet: "parakeet";
-                tts: "tts";
-                ocr: "ocr";
-                diffusion: "diffusion";
             }>, import("zod").ZodLiteral<"vad">]>>;
         }, import("zod/v4/core").$strip>]>>;
     }, import("zod/v4/core").$strip>;
@@ -260,6 +260,7 @@ export declare const parakeetPlugin: {
                 value: import("zod").ZodString;
             }, import("zod/v4/core").$strip>], "type">;
             type: import("zod").ZodLiteral<"transcribe">;
+            requestId: import("zod").ZodOptional<import("zod").ZodString>;
         }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
             text: import("zod").ZodOptional<import("zod").ZodString>;
             done: import("zod").ZodOptional<import("zod").ZodBoolean>;
@@ -283,6 +284,13 @@ export declare const parakeetPlugin: {
                 append: import("zod").ZodBoolean;
                 id: import("zod").ZodNumber;
             }, import("zod/v4/core").$strip>>;
+            vad: import("zod").ZodOptional<import("zod").ZodObject<{
+                speaking: import("zod").ZodBoolean;
+                probability: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>>;
+            endOfTurn: import("zod").ZodOptional<import("zod").ZodObject<{
+                silenceDurationMs: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>>;
             type: import("zod").ZodLiteral<"transcribe">;
         }, import("zod/v4/core").$strip>>;
     };

package/dist/server/bare/plugins/parakeet-transcription/plugin.js

@@ -126,6 +126,9 @@ export const parakeetPlugin = definePlugin({
             requestSchema: transcribeRequestSchema,
             responseSchema: transcribeResponseSchema,
             streaming: true,
+            // Parakeet addon exposes a model-wide hard cancel — compute is
+            // interrupted on the currently-running transcription.
+            cancel: { scope: "model", hard: true },
             handler: async function* (request) {
                 if (request.metadata === true) {
                     throw new TranscriptionFailedError(`Parakeet transcription does not support metadata: true; only the whisper engine emits per-segment metadata. Use a whisper model to receive segments.`);
@@ -134,7 +137,7 @@ export const parakeetPlugin = definePlugin({
                     modelId: request.modelId,
                     audioChunk: request.audioChunk,
                     prompt: request.prompt,
-                });
+                }, request.requestId);
                 try {
                     let result = await stream.next();
                     while (!result.done) {

package/dist/server/bare/plugins/sdcpp-generation/ops/diffusion.js

@@ -4,6 +4,9 @@ export async function* diffusion(request) {
     const init_image = request.init_image
         ? Buffer.from(request.init_image, "base64")
         : undefined;
+    const init_images = request.init_images
+        ? request.init_images.map((b64) => Buffer.from(b64, "base64"))
+        : undefined;
     const response = await model.run({
         prompt: request.prompt,
         negative_prompt: request.negative_prompt,
@@ -20,7 +23,12 @@ export async function* diffusion(request) {
         vae_tiling: request.vae_tiling,
         cache_preset: request.cache_preset,
         init_image,
+        init_images,
+        increase_ref_index: request.increase_ref_index,
+        auto_resize_ref_image: request.auto_resize_ref_image,
         strength: request.strength,
+        lora: request.lora,
+        upscale: request.upscale === false ? undefined : request.upscale,
     });
     let outputIndex = 0;
     for await (const chunk of response.iterate()) {

package/dist/server/bare/plugins/sdcpp-generation/ops/upscale.d.ts

@@ -0,0 +1,3 @@
+import type { UpscaleRequest, UpscaleStreamResponse } from "../../../../../schemas/sdcpp-config";
+export declare function upscale(request: UpscaleRequest): AsyncGenerator<UpscaleStreamResponse>;
+//# sourceMappingURL=upscale.d.ts.map

package/dist/server/bare/plugins/sdcpp-generation/ops/upscale.js

@@ -0,0 +1,40 @@
+import { EsrganUpscaler } from "@qvac/diffusion-cpp";
+import { getModel, getModelEntry, } from "../../../registry/model-registry.js";
+import { ModelOperationNotSupportedError } from "../../../../../utils/errors-server.js";
+import { ModelType } from "../../../../../schemas/index.js";
+// The diffusion plugin instantiates `EsrganUpscaler` when the model is loaded
+// with `modelConfig.mode === "upscale"` and `ImgStableDiffusion` otherwise. The
+// latter has no `.upscale()` method, so we refuse the call upfront with a
+// structured error rather than letting a TypeError propagate.
+function asUpscalerModel(model, modelId) {
+    if (model instanceof EsrganUpscaler) {
+        return model;
+    }
+    const entry = getModelEntry(modelId);
+    const modelType = entry && !entry.isDelegated ? entry.local.modelType : ModelType.sdcppGeneration;
+    throw new ModelOperationNotSupportedError(modelId, modelType, "upscale", ["diffusion"], []);
+}
+export async function* upscale(request) {
+    const model = asUpscalerModel(getModel(request.modelId), request.modelId);
+    const response = await model.upscale(Buffer.from(request.image, "base64"), request.repeats === undefined ? undefined : { repeats: request.repeats });
+    // The addon emits exactly one final PNG regardless of `repeats`, so
+    // this loop typically iterates once. `outputIndex` is still emitted for
+    // wire parity with diffusionStream and to leave headroom for future
+    // multi-output variants.
+    let outputIndex = 0;
+    for await (const chunk of response.iterate()) {
+        if (chunk instanceof Uint8Array) {
+            yield {
+                type: "upscaleStream",
+                data: Buffer.from(chunk).toString("base64"),
+                outputIndex: outputIndex++,
+            };
+        }
+    }
+    const responseWithStats = response;
+    yield {
+        type: "upscaleStream",
+        done: true,
+        stats: responseWithStats.stats ?? undefined,
+    };
+}

package/dist/server/bare/plugins/sdcpp-generation/plugin.d.ts

@@ -1,10 +1,14 @@
 import { type CreateModelParams, type PluginModelResult, type ResolveContext, type ResolveResult, type SdcppConfig } from "../../../../schemas/index";
-type DiffusionArtifactKey = "clipLModelPath" | "clipGModelPath" | "t5XxlModelPath" | "llmModelPath" | "vaeModelPath";
+type DiffusionArtifactKey = "clipLModelPath" | "clipGModelPath" | "t5XxlModelPath" | "llmModelPath" | "vaeModelPath" | "esrganModelPath";
 export declare const diffusionPlugin: {
     modelType: "sdcpp-generation";
     displayName: string;
     addonPackage: "@qvac/diffusion-cpp";
     loadConfigSchema: import("zod").ZodObject<{
+        mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+            diffusion: "diffusion";
+            upscale: "upscale";
+        }>>;
         threads: import("zod").ZodOptional<import("zod").ZodNumber>;
         device: import("zod").ZodOptional<import("zod").ZodEnum<{
             cpu: "cpu";
@@ -49,6 +53,11 @@ export declare const diffusionPlugin: {
         vae_on_cpu: import("zod").ZodOptional<import("zod").ZodBoolean>;
         vae_tiling: import("zod").ZodOptional<import("zod").ZodBoolean>;
         flash_attn: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        lora_apply_mode: import("zod").ZodOptional<import("zod").ZodEnum<{
+            auto: "auto";
+            immediately: "immediately";
+            at_runtime: "at_runtime";
+        }>>;
         verbosity: import("zod").ZodOptional<import("zod").ZodNumber>;
         clipLModelSrc: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
             src: import("zod").ZodString;
@@ -63,6 +72,9 @@ export declare const diffusionPlugin: {
             sha256Checksum: import("zod").ZodOptional<import("zod").ZodString>;
             addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
                 embeddings: "embeddings";
+                diffusion: "diffusion";
+                tts: "tts";
+                ocr: "ocr";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -75,9 +87,6 @@ export declare const diffusionPlugin: {
                 whisper: "whisper";
                 nmt: "nmt";
                 parakeet: "parakeet";
-                tts: "tts";
-                ocr: "ocr";
-                diffusion: "diffusion";
             }>, import("zod").ZodLiteral<"vad">]>>;
         }, import("zod/v4/core").$strip>]>>;
         clipGModelSrc: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
@@ -93,6 +102,9 @@ export declare const diffusionPlugin: {
             sha256Checksum: import("zod").ZodOptional<import("zod").ZodString>;
             addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
                 embeddings: "embeddings";
+                diffusion: "diffusion";
+                tts: "tts";
+                ocr: "ocr";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -105,9 +117,6 @@ export declare const diffusionPlugin: {
                 whisper: "whisper";
                 nmt: "nmt";
                 parakeet: "parakeet";
-                tts: "tts";
-                ocr: "ocr";
-                diffusion: "diffusion";
             }>, import("zod").ZodLiteral<"vad">]>>;
         }, import("zod/v4/core").$strip>]>>;
         t5XxlModelSrc: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
@@ -123,6 +132,9 @@ export declare const diffusionPlugin: {
             sha256Checksum: import("zod").ZodOptional<import("zod").ZodString>;
             addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
                 embeddings: "embeddings";
+                diffusion: "diffusion";
+                tts: "tts";
+                ocr: "ocr";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -135,9 +147,6 @@ export declare const diffusionPlugin: {
                 whisper: "whisper";
                 nmt: "nmt";
                 parakeet: "parakeet";
-                tts: "tts";
-                ocr: "ocr";
-                diffusion: "diffusion";
             }>, import("zod").ZodLiteral<"vad">]>>;
         }, import("zod/v4/core").$strip>]>>;
         llmModelSrc: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
@@ -153,6 +162,9 @@ export declare const diffusionPlugin: {
             sha256Checksum: import("zod").ZodOptional<import("zod").ZodString>;
             addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
                 embeddings: "embeddings";
+                diffusion: "diffusion";
+                tts: "tts";
+                ocr: "ocr";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -165,9 +177,6 @@ export declare const diffusionPlugin: {
                 whisper: "whisper";
                 nmt: "nmt";
                 parakeet: "parakeet";
-                tts: "tts";
-                ocr: "ocr";
-                diffusion: "diffusion";
             }>, import("zod").ZodLiteral<"vad">]>>;
         }, import("zod/v4/core").$strip>]>>;
         vaeModelSrc: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
@@ -183,6 +192,9 @@ export declare const diffusionPlugin: {
             sha256Checksum: import("zod").ZodOptional<import("zod").ZodString>;
             addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
                 embeddings: "embeddings";
+                diffusion: "diffusion";
+                tts: "tts";
+                ocr: "ocr";
                 "llamacpp-completion": "llamacpp-completion";
                 "whispercpp-transcription": "whispercpp-transcription";
                 "llamacpp-embedding": "llamacpp-embedding";
@@ -195,11 +207,45 @@ export declare const diffusionPlugin: {
                 whisper: "whisper";
                 nmt: "nmt";
                 parakeet: "parakeet";
-                tts: "tts";
-                ocr: "ocr";
-                diffusion: "diffusion";
             }>, import("zod").ZodLiteral<"vad">]>>;
         }, import("zod/v4/core").$strip>]>>;
+        upscaler: import("zod").ZodOptional<import("zod").ZodObject<{
+            type: import("zod").ZodOptional<import("zod").ZodLiteral<"esrgan">>;
+            model_src: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
+                src: import("zod").ZodString;
+                name: import("zod").ZodOptional<import("zod").ZodString>;
+                modelId: import("zod").ZodOptional<import("zod").ZodString>;
+                registryPath: import("zod").ZodOptional<import("zod").ZodString>;
+                registrySource: import("zod").ZodOptional<import("zod").ZodString>;
+                blobCoreKey: import("zod").ZodOptional<import("zod").ZodString>;
+                blobIndex: import("zod").ZodOptional<import("zod").ZodNumber>;
+                engine: import("zod").ZodOptional<import("zod").ZodString>;
+                expectedSize: import("zod").ZodOptional<import("zod").ZodNumber>;
+                sha256Checksum: import("zod").ZodOptional<import("zod").ZodString>;
+                addon: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodEnum<{
+                    embeddings: "embeddings";
+                    diffusion: "diffusion";
+                    tts: "tts";
+                    ocr: "ocr";
+                    "llamacpp-completion": "llamacpp-completion";
+                    "whispercpp-transcription": "whispercpp-transcription";
+                    "llamacpp-embedding": "llamacpp-embedding";
+                    "nmtcpp-translation": "nmtcpp-translation";
+                    "onnx-tts": "onnx-tts";
+                    "parakeet-transcription": "parakeet-transcription";
+                    "onnx-ocr": "onnx-ocr";
+                    "sdcpp-generation": "sdcpp-generation";
+                    llm: "llm";
+                    whisper: "whisper";
+                    nmt: "nmt";
+                    parakeet: "parakeet";
+                }>, import("zod").ZodLiteral<"vad">]>>;
+            }, import("zod/v4/core").$strip>]>>;
+            tile_size: import("zod").ZodOptional<import("zod").ZodNumber>;
+            direct: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            offload_params_to_cpu: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            threads: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodLiteral<-1>, import("zod").ZodNumber]>>;
+        }, import("zod/v4/core").$strict>>;
     }, import("zod/v4/core").$strip>;
     resolveConfig(cfg: SdcppConfig, ctx: ResolveContext): Promise<ResolveResult<SdcppConfig, DiffusionArtifactKey>>;
     createModel(params: CreateModelParams): PluginModelResult;
@@ -248,7 +294,14 @@ export declare const diffusionPlugin: {
             vae_tiling: import("zod").ZodOptional<import("zod").ZodBoolean>;
             cache_preset: import("zod").ZodOptional<import("zod").ZodString>;
             init_image: import("zod").ZodOptional<import("zod").ZodString>;
+            init_images: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+            increase_ref_index: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            auto_resize_ref_image: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            lora: import("zod").ZodOptional<import("zod").ZodString>;
             strength: import("zod").ZodOptional<import("zod").ZodNumber>;
+            upscale: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodBoolean, import("zod").ZodObject<{
+                repeats: import("zod").ZodOptional<import("zod").ZodNumber>;
+            }, import("zod/v4/core").$strict>]>>;
         }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
             type: import("zod").ZodLiteral<"diffusionStream">;
             step: import("zod").ZodOptional<import("zod").ZodNumber>;
@@ -271,6 +324,28 @@ export declare const diffusionPlugin: {
                 seed: import("zod").ZodOptional<import("zod").ZodNumber>;
             }, import("zod/v4/core").$strip>>;
         }, import("zod/v4/core").$strip>>;
+        upscaleStream: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodObject<{
+            modelId: import("zod").ZodString;
+            image: import("zod").ZodString;
+            repeats: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"upscaleStream">;
+            data: import("zod").ZodOptional<import("zod").ZodString>;
+            outputIndex: import("zod").ZodOptional<import("zod").ZodNumber>;
+            done: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            stats: import("zod").ZodOptional<import("zod").ZodObject<{
+                modelLoadMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                upscaleMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                totalUpscaleMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                totalWallMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                totalUpscales: import("zod").ZodOptional<import("zod").ZodNumber>;
+                totalImages: import("zod").ZodOptional<import("zod").ZodNumber>;
+                totalPixels: import("zod").ZodOptional<import("zod").ZodNumber>;
+                width: import("zod").ZodOptional<import("zod").ZodNumber>;
+                height: import("zod").ZodOptional<import("zod").ZodNumber>;
+                repeats: import("zod").ZodOptional<import("zod").ZodNumber>;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>>;
     };
     logging: {
         module: import("@qvac/diffusion-cpp/addonLogging").AddonLogging;

package/dist/server/bare/plugins/sdcpp-generation/plugin.js

@@ -1,27 +1,72 @@
-import ImgStableDiffusion, {} from "@qvac/diffusion-cpp";
+import ImgStableDiffusion, { EsrganUpscaler, } from "@qvac/diffusion-cpp";
 import addonLogging from "@qvac/diffusion-cpp/addonLogging.js";
-import { definePlugin, defineHandler, sdcppConfigSchema, diffusionRequestSchema, diffusionStreamResponseSchema, ModelType, ADDON_DIFFUSION, } from "../../../../schemas/index.js";
+import { definePlugin, defineHandler, sdcppConfigSchema, diffusionRequestSchema, diffusionStreamResponseSchema, upscaleRequestSchema, upscaleStreamResponseSchema, ModelType, ADDON_DIFFUSION, } from "../../../../schemas/index.js";
 import { createStreamLogger, registerAddonLogger } from "../../../../logging/index.js";
+import { ModelLoadFailedError } from "../../../../utils/errors-server.js";
 import { diffusion } from "./ops/diffusion.js";
+import { upscale } from "./ops/upscale.js";
+// Single source of truth for `SdcppConfig.upscaler.*` → addon-config key
+// mapping. Used by both the diffusion-mode (post-generation upscaler) and the
+// standalone-upscale-mode branches; keeping the mapping in one place avoids
+// drift if `@qvac/diffusion-cpp` ever adds or renames an `upscaler_*` key.
+function flattenUpscalerKeys(upscaler) {
+    if (!upscaler)
+        return {};
+    return {
+        ...(upscaler.tile_size !== undefined && {
+            upscaler_tile_size: upscaler.tile_size,
+        }),
+        ...(upscaler.direct !== undefined && {
+            upscaler_direct: upscaler.direct,
+        }),
+        ...(upscaler.offload_params_to_cpu !== undefined && {
+            upscaler_offload_params_to_cpu: upscaler.offload_params_to_cpu,
+        }),
+        ...(upscaler.threads !== undefined && {
+            upscaler_threads: upscaler.threads,
+        }),
+    };
+}
+function toEsrganAddonConfig(config) {
+    return {
+        ...flattenUpscalerKeys(config.upscaler),
+        ...(config.verbosity !== undefined && { verbosity: config.verbosity }),
+    };
+}
 export const diffusionPlugin = definePlugin({
     modelType: ModelType.sdcppGeneration,
-    displayName: "Image Generation (stable-diffusion.cpp)",
+    displayName: "Image Generation & Upscaling (stable-diffusion.cpp)",
     addonPackage: ADDON_DIFFUSION,
     loadConfigSchema: sdcppConfigSchema,
     async resolveConfig(cfg, ctx) {
-        const { clipLModelSrc, clipGModelSrc, t5XxlModelSrc, llmModelSrc, vaeModelSrc, ...runtimeConfig } = cfg;
-        const sources = { clipLModelSrc, clipGModelSrc, t5XxlModelSrc, llmModelSrc, vaeModelSrc };
+        // Standalone-upscaler mode never references auxiliary models: the primary
+        // modelSrc IS the ESRGAN file. Skip resolution to avoid downloading
+        // unused encoders/VAEs and to keep load fast.
+        if (cfg.mode === "upscale") {
+            return { config: cfg };
+        }
+        const { clipLModelSrc, clipGModelSrc, t5XxlModelSrc, llmModelSrc, vaeModelSrc, upscaler, ...rest } = cfg;
+        const { model_src: esrganModelSrc, ...upscalerRuntime } = upscaler ?? {};
+        const runtimeConfig = {
+            ...rest,
+            ...(upscaler && { upscaler: upscalerRuntime }),
+        };
+        const sources = {
+            clipLModelSrc, clipGModelSrc, t5XxlModelSrc,
+            llmModelSrc, vaeModelSrc, esrganModelSrc,
+        };
         const hasSources = Object.values(sources).some(Boolean);
         if (!hasSources) {
             return { config: runtimeConfig };
         }
         const resolve = ctx.resolveModelPath;
-        const [clipLModelPath, clipGModelPath, t5XxlModelPath, llmModelPath, vaeModelPath] = await Promise.all([
+        const [clipLModelPath, clipGModelPath, t5XxlModelPath, llmModelPath, vaeModelPath, esrganModelPath,] = await Promise.all([
             clipLModelSrc ? resolve(clipLModelSrc) : undefined,
             clipGModelSrc ? resolve(clipGModelSrc) : undefined,
             t5XxlModelSrc ? resolve(t5XxlModelSrc) : undefined,
             llmModelSrc ? resolve(llmModelSrc) : undefined,
             vaeModelSrc ? resolve(vaeModelSrc) : undefined,
+            esrganModelSrc ? resolve(esrganModelSrc) : undefined,
         ]);
         return {
             config: runtimeConfig,
@@ -31,14 +76,37 @@ export const diffusionPlugin = definePlugin({
                 ...(t5XxlModelPath && { t5XxlModelPath }),
                 ...(llmModelPath && { llmModelPath }),
                 ...(vaeModelPath && { vaeModelPath }),
+                ...(esrganModelPath && { esrganModelPath }),
             },
         };
     },
     createModel(params) {
         const { modelId, modelPath, modelConfig, artifacts } = params;
         const config = (modelConfig ?? {});
+        // In diffusion mode the ESRGAN file (when post-generation upscale is
+        // wanted) must come from upscaler.model_src — the primary modelPath is
+        // the main diffusion checkpoint. Reject early with a clear error
+        // instead of letting the native addon fail mid-load. Done before any
+        // logger / native side-effects so callers can recover cleanly.
+        if (config.mode !== "upscale" &&
+            config.upscaler !== undefined &&
+            !artifacts?.["esrganModelPath"]) {
+            throw new ModelLoadFailedError("modelConfig.upscaler.model_src is required when modelConfig.upscaler " +
+                "is set in diffusion mode. Provide the ESRGAN model, omit the " +
+                "upscaler block, or switch to modelConfig.mode = 'upscale' to load " +
+                "a standalone upscaler.");
+        }
         const logger = createStreamLogger(modelId, ModelType.sdcppGeneration);
         registerAddonLogger(modelId, ModelType.sdcppGeneration, logger);
+        if (config.mode === "upscale") {
+            const model = new EsrganUpscaler({
+                files: { esrgan: modelPath },
+                config: toEsrganAddonConfig(config),
+                logger,
+                opts: { stats: true },
+            });
+            return { model };
+        }
         const files = {
             model: modelPath,
             ...(artifacts?.["clipLModelPath"] && { clipL: artifacts["clipLModelPath"] }),
@@ -46,10 +114,20 @@ export const diffusionPlugin = definePlugin({
             ...(artifacts?.["t5XxlModelPath"] && { t5Xxl: artifacts["t5XxlModelPath"] }),
             ...(artifacts?.["llmModelPath"] && { llm: artifacts["llmModelPath"] }),
             ...(artifacts?.["vaeModelPath"] && { vae: artifacts["vaeModelPath"] }),
+            ...(artifacts?.["esrganModelPath"] && { esrgan: artifacts["esrganModelPath"] }),
+        };
+        // `mode` is consumed by this plugin to select the model class above; the
+        // stable-diffusion.cpp native config does not understand it. Strip it
+        // before forwarding `rest` to the addon.
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { upscaler, mode, ...rest } = config;
+        const addonConfig = {
+            ...rest,
+            ...flattenUpscalerKeys(upscaler),
         };
         const model = new ImgStableDiffusion({
             files,
-            config: config,
+            config: addonConfig,
             logger,
             opts: { stats: true },
         });
@@ -60,8 +138,20 @@ export const diffusionPlugin = definePlugin({
             requestSchema: diffusionRequestSchema,
             responseSchema: diffusionStreamResponseSchema,
             streaming: true,
+            // sdcpp diffusion exposes a model-wide hard cancel — compute
+            // is interrupted on the currently-running generation.
+            cancel: { scope: "model", hard: true },
             handler: diffusion,
         }),
+        upscaleStream: defineHandler({
+            requestSchema: upscaleRequestSchema,
+            responseSchema: upscaleStreamResponseSchema,
+            streaming: true,
+            // sdcpp upscale path has no cancel surface today — SDK falls
+            // back to soft-cancel.
+            cancel: { scope: "none" },
+            handler: upscale,
+        }),
     },
     logging: {
         module: addonLogging,