@qvac/sdk 0.14.1 → 0.16.0

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

@@ -1,7 +1,7 @@
-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";
+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
@@ -12,11 +12,11 @@ function asUpscalerModel(model, modelId) {
     }
     const entry = getModelEntry(modelId);
     const modelType = entry && !entry.isDelegated ? entry.local.modelType : ModelType.sdcppGeneration;
-    throw new ModelOperationNotSupportedError(modelId, modelType, "upscale", ["diffusion"], []);
+    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 });
+    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
@@ -25,16 +25,16 @@ export async function* upscale(request) {
     for await (const chunk of response.iterate()) {
         if (chunk instanceof Uint8Array) {
             yield {
-                type: "upscaleStream",
-                data: Buffer.from(chunk).toString("base64"),
-                outputIndex: outputIndex++,
+                type: 'upscaleStream',
+                data: Buffer.from(chunk).toString('base64'),
+                outputIndex: outputIndex++
             };
         }
     }
     const responseWithStats = response;
     yield {
-        type: "upscaleStream",
+        type: 'upscaleStream',
         done: true,
-        stats: responseWithStats.stats ?? undefined,
+        stats: responseWithStats.stats ?? undefined
     };
 }

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

@@ -1,3 +1,5 @@
-import type { VideoRequest, VideoStreamResponse } from "../../../../../schemas/sdcpp-config";
+import { VideoStableDiffusion } from '@qvac/diffusion-cpp';
+import { type VideoRequest, type VideoStreamResponse } from '../../../../../schemas/sdcpp-config';
+export declare function markLtxVideoModel(model: VideoStableDiffusion): void;
 export declare function video(request: VideoRequest): AsyncGenerator<VideoStreamResponse>;
 //# sourceMappingURL=video.d.ts.map

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

@@ -50,13 +50,37 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-import { VideoStableDiffusion } from "@qvac/diffusion-cpp";
-import { getServerLogger } from "../../../../../logging/index.js";
-import { getModel, getModelEntry, } from "../../../registry/model-registry.js";
-import { getRequestRegistry, withRequestContext } from "../../../runtime/index.js";
-import { generateServerRequestId } from "../../../runtime/request-id.js";
-import { ModelOperationNotSupportedError } from "../../../../../utils/errors-server.js";
-import { ModelType } from "../../../../../schemas/index.js";
+import { VideoStableDiffusion } from '@qvac/diffusion-cpp';
+import { getServerLogger } from '../../../../../logging/index.js';
+import { getModel, getModelEntry } from '../../../registry/model-registry.js';
+import { getRequestRegistry, withRequestContext } from '../../../runtime/index.js';
+import { generateServerRequestId } from '../../../runtime/request-id.js';
+import { ModelOperationNotSupportedError, PluginRequestValidationFailedError } from '../../../../../utils/errors-server.js';
+import { formatZodError } from '../../../../../utils/zod-error.js';
+import { ModelType } from '../../../../../schemas/index.js';
+import { ltxVideoRequestSchema } from '../../../../../schemas/sdcpp-config.js';
+const ltxVideoModels = new WeakSet();
+export function markLtxVideoModel(model) {
+    ltxVideoModels.add(model);
+}
+function parseLtxVideoRequest(request) {
+    const result = ltxVideoRequestSchema.safeParse(request);
+    if (!result.success) {
+        throw new PluginRequestValidationFailedError('videoStream', formatZodError(result.error));
+    }
+}
+// The addon reports `hasAudio` as a numeric flag (1/0); the SDK surfaces it as
+// a boolean so consumers get a readable `stats.hasAudio` instead of a magic
+// number. Everything else passes through and is validated client-side.
+function toVideoStats(stats) {
+    if (!stats)
+        return undefined;
+    const { hasAudio, ...rest } = stats;
+    return {
+        ...rest,
+        ...(hasAudio !== undefined && { hasAudio: hasAudio !== 0 })
+    };
+}
 // The diffusion plugin instantiates `VideoStableDiffusion` when the model is
 // loaded with `modelConfig.mode === "video"` and `ImgStableDiffusion` (or
 // `EsrganUpscaler`) otherwise. Those have no video `run()` shape, so we refuse
@@ -67,96 +91,99 @@ function asVideoModel(model, modelId) {
         return model;
     }
     const entry = getModelEntry(modelId);
-    const modelType = entry && !entry.isDelegated
-        ? entry.local.modelType
-        : ModelType.sdcppGeneration;
-    throw new ModelOperationNotSupportedError(modelId, modelType, "video", ["diffusion"], []);
+    const modelType = entry && !entry.isDelegated ? entry.local.modelType : ModelType.sdcppGeneration;
+    throw new ModelOperationNotSupportedError(modelId, modelType, 'video', ['diffusion'], []);
 }
 export async function* video(request) {
     const env_1 = { stack: [], error: void 0, hasError: false };
     try {
         const ctx = __addDisposableResource(env_1, await getRequestRegistry().begin({
             requestId: request.requestId ?? generateServerRequestId(),
-            kind: "diffusion",
-            modelId: request.modelId,
+            kind: 'diffusion',
+            modelId: request.modelId
         }), true);
         const requestLogger = withRequestContext(getServerLogger(), ctx);
         const model = asVideoModel(getModel(request.modelId), request.modelId);
+        if (ltxVideoModels.has(model))
+            parseLtxVideoRequest(request);
         const onAbort = () => {
             model.cancel().catch((err) => {
                 requestLogger.warn(`[cancel] model.cancel() rejected during abort for modelId=${request.modelId}: ${err instanceof Error ? err.message : String(err)}`);
             });
         };
-        ctx.signal.addEventListener("abort", onAbort, { once: true });
+        ctx.signal.addEventListener('abort', onAbort, { once: true });
         if (ctx.signal.aborted)
             onAbort();
         ctx.scope.defer(() => {
-            ctx.signal.removeEventListener("abort", onAbort);
+            ctx.signal.removeEventListener('abort', onAbort);
         });
         const response = await model.run({
             mode: request.mode,
             prompt: request.prompt,
             ...(request.negative_prompt !== undefined && {
-                negative_prompt: request.negative_prompt,
+                negative_prompt: request.negative_prompt
             }),
             ...(request.width !== undefined && { width: request.width }),
             ...(request.height !== undefined && { height: request.height }),
             ...(request.video_frames !== undefined && {
-                video_frames: request.video_frames,
+                video_frames: request.video_frames
             }),
             ...(request.fps !== undefined && { fps: request.fps }),
             ...(request.seed !== undefined && { seed: request.seed }),
             ...(request.steps !== undefined && { steps: request.steps }),
             ...(request.sampling_method !== undefined && {
-                sampling_method: request.sampling_method,
+                sampling_method: request.sampling_method
             }),
             ...(request.scheduler !== undefined && { scheduler: request.scheduler }),
             ...(request.cfg_scale !== undefined && { cfg_scale: request.cfg_scale }),
             ...(request.flow_shift !== undefined && { flow_shift: request.flow_shift }),
             ...(request.high_noise_steps !== undefined && {
-                high_noise_steps: request.high_noise_steps,
+                high_noise_steps: request.high_noise_steps
             }),
             ...(request.high_noise_sampler !== undefined && {
-                high_noise_sampler: request.high_noise_sampler,
+                high_noise_sampler: request.high_noise_sampler
             }),
             ...(request.high_noise_scheduler !== undefined && {
-                high_noise_scheduler: request.high_noise_scheduler,
+                high_noise_scheduler: request.high_noise_scheduler
             }),
             ...(request.high_noise_cfg_scale !== undefined && {
-                high_noise_cfg_scale: request.high_noise_cfg_scale,
+                high_noise_cfg_scale: request.high_noise_cfg_scale
             }),
             ...(request.high_noise_flow_shift !== undefined && {
-                high_noise_flow_shift: request.high_noise_flow_shift,
+                high_noise_flow_shift: request.high_noise_flow_shift
             }),
             ...(request.moe_boundary !== undefined && {
-                moe_boundary: request.moe_boundary,
+                moe_boundary: request.moe_boundary
             }),
             ...(request.vace_strength !== undefined && {
-                vace_strength: request.vace_strength,
+                vace_strength: request.vace_strength
             }),
             ...(request.init_image !== undefined && {
-                init_image: Buffer.from(request.init_image, "base64"),
+                init_image: Buffer.from(request.init_image, 'base64')
             }),
             ...(request.strength !== undefined && {
-                strength: request.strength,
+                strength: request.strength
             }),
             ...(request.control_frames !== undefined && {
-                control_frames: request.control_frames.map((b64) => Buffer.from(b64, "base64")),
+                control_frames: request.control_frames.map((b64) => Buffer.from(b64, 'base64'))
             }),
             ...(request.vae_tiling !== undefined && { vae_tiling: request.vae_tiling }),
             ...(request.vae_tile_size !== undefined && {
-                vae_tile_size: request.vae_tile_size,
+                vae_tile_size: request.vae_tile_size
             }),
             ...(request.vae_tile_overlap !== undefined && {
-                vae_tile_overlap: request.vae_tile_overlap,
+                vae_tile_overlap: request.vae_tile_overlap
+            }),
+            ...(request.temporal_tiling !== undefined && {
+                temporal_tiling: request.temporal_tiling
             }),
             ...(request.cache_mode !== undefined && { cache_mode: request.cache_mode }),
             ...(request.cache_preset !== undefined && {
-                cache_preset: request.cache_preset,
+                cache_preset: request.cache_preset
             }),
             ...(request.cache_threshold !== undefined && {
-                cache_threshold: request.cache_threshold,
-            }),
+                cache_threshold: request.cache_threshold
+            })
         });
         let outputIndex = 0;
         for await (const chunk of response.iterate()) {
@@ -164,20 +191,20 @@ export async function* video(request) {
                 break;
             if (chunk instanceof Uint8Array) {
                 yield {
-                    type: "videoStream",
-                    data: Buffer.from(chunk).toString("base64"),
-                    outputIndex: outputIndex++,
+                    type: 'videoStream',
+                    data: Buffer.from(chunk).toString('base64'),
+                    outputIndex: outputIndex++
                 };
             }
-            else if (typeof chunk === "string") {
+            else if (typeof chunk === 'string') {
                 try {
                     const tick = JSON.parse(chunk);
-                    if ("step" in tick) {
+                    if ('step' in tick) {
                         yield {
-                            type: "videoStream",
-                            step: tick["step"],
-                            totalSteps: tick["total"],
-                            elapsedMs: tick["elapsed_ms"],
+                            type: 'videoStream',
+                            step: tick['step'],
+                            totalSteps: tick['total'],
+                            elapsedMs: tick['elapsed_ms']
                         };
                     }
                 }
@@ -188,9 +215,9 @@ export async function* video(request) {
         }
         const responseWithStats = response;
         yield {
-            type: "videoStream",
+            type: 'videoStream',
             done: true,
-            stats: responseWithStats.stats ?? undefined,
+            stats: toVideoStats(responseWithStats.stats)
         };
     }
     catch (e_1) {

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

@@ -1,5 +1,5 @@
-import { type CreateModelParams, type PluginModelResult, type ResolveContext, type ResolveResult, type SdcppConfig } from "../../../../schemas/index";
-type DiffusionArtifactKey = "clipLModelPath" | "clipGModelPath" | "clipVisionModelPath" | "t5XxlModelPath" | "llmModelPath" | "vaeModelPath" | "highNoiseDiffusionModelPath" | "esrganModelPath";
+import { type CreateModelParams, type PluginModelResult, type ResolveContext, type ResolveResult, type SdcppConfig } from '../../../../schemas/index';
+type DiffusionArtifactKey = 'clipLModelPath' | 'clipGModelPath' | 'clipVisionModelPath' | 't5XxlModelPath' | 'llmModelPath' | 'vaeModelPath' | 'highNoiseDiffusionModelPath' | 'uncondModelPath' | 'audioVaeModelPath' | 'embeddingsConnectorsModelPath' | 'esrganModelPath';
 /**
  * Stable-diffusion.cpp plugin for image diffusion, upscaling, and Wan video.
  *
@@ -20,9 +20,13 @@ export declare const diffusionPlugin: {
         }>>;
         threads: import("zod").ZodOptional<import("zod").ZodNumber>;
         device: import("zod").ZodOptional<import("zod").ZodEnum<{
-            cpu: "cpu";
             gpu: "gpu";
+            cpu: "cpu";
         }>>;
+        'main-gpu': import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodNumber, import("zod").ZodEnum<{
+            integrated: "integrated";
+            dedicated: "dedicated";
+        }>]>>;
         prediction: import("zod").ZodOptional<import("zod").ZodEnum<{
             auto: "auto";
             eps: "eps";
@@ -291,6 +295,43 @@ export declare const diffusionPlugin: {
                 classification: "classification";
             }>, import("zod").ZodLiteral<"vad">]>>;
         }, import("zod/v4/core").$strip>]>>;
+        uncondModelSrc: 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";
+                vla: "vla";
+                "llamacpp-completion": "llamacpp-completion";
+                "whispercpp-transcription": "whispercpp-transcription";
+                "bci-whispercpp-transcription": "bci-whispercpp-transcription";
+                "llamacpp-embedding": "llamacpp-embedding";
+                "nmtcpp-translation": "nmtcpp-translation";
+                "onnx-tts": "onnx-tts";
+                "tts-ggml": "tts-ggml";
+                "parakeet-transcription": "parakeet-transcription";
+                "ggml-ocr": "ggml-ocr";
+                "sdcpp-generation": "sdcpp-generation";
+                "ggml-vla": "ggml-vla";
+                "ggml-classification": "ggml-classification";
+                llm: "llm";
+                whisper: "whisper";
+                bci: "bci";
+                nmt: "nmt";
+                parakeet: "parakeet";
+                classification: "classification";
+            }>, import("zod").ZodLiteral<"vad">]>>;
+        }, import("zod/v4/core").$strip>]>>;
         clipVisionModelSrc: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
             src: import("zod").ZodString;
             name: import("zod").ZodOptional<import("zod").ZodString>;
@@ -328,6 +369,80 @@ export declare const diffusionPlugin: {
                 classification: "classification";
             }>, import("zod").ZodLiteral<"vad">]>>;
         }, import("zod/v4/core").$strip>]>>;
+        audioVaeModelSrc: 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";
+                vla: "vla";
+                "llamacpp-completion": "llamacpp-completion";
+                "whispercpp-transcription": "whispercpp-transcription";
+                "bci-whispercpp-transcription": "bci-whispercpp-transcription";
+                "llamacpp-embedding": "llamacpp-embedding";
+                "nmtcpp-translation": "nmtcpp-translation";
+                "onnx-tts": "onnx-tts";
+                "tts-ggml": "tts-ggml";
+                "parakeet-transcription": "parakeet-transcription";
+                "ggml-ocr": "ggml-ocr";
+                "sdcpp-generation": "sdcpp-generation";
+                "ggml-vla": "ggml-vla";
+                "ggml-classification": "ggml-classification";
+                llm: "llm";
+                whisper: "whisper";
+                bci: "bci";
+                nmt: "nmt";
+                parakeet: "parakeet";
+                classification: "classification";
+            }>, import("zod").ZodLiteral<"vad">]>>;
+        }, import("zod/v4/core").$strip>]>>;
+        embeddingsConnectorsModelSrc: 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";
+                vla: "vla";
+                "llamacpp-completion": "llamacpp-completion";
+                "whispercpp-transcription": "whispercpp-transcription";
+                "bci-whispercpp-transcription": "bci-whispercpp-transcription";
+                "llamacpp-embedding": "llamacpp-embedding";
+                "nmtcpp-translation": "nmtcpp-translation";
+                "onnx-tts": "onnx-tts";
+                "tts-ggml": "tts-ggml";
+                "parakeet-transcription": "parakeet-transcription";
+                "ggml-ocr": "ggml-ocr";
+                "sdcpp-generation": "sdcpp-generation";
+                "ggml-vla": "ggml-vla";
+                "ggml-classification": "ggml-classification";
+                llm: "llm";
+                whisper: "whisper";
+                bci: "bci";
+                nmt: "nmt";
+                parakeet: "parakeet";
+                classification: "classification";
+            }>, 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<{
@@ -439,6 +554,11 @@ export declare const diffusionPlugin: {
             stats: import("zod").ZodOptional<import("zod").ZodObject<{
                 modelLoadMs: import("zod").ZodOptional<import("zod").ZodNumber>;
                 generationMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                conditionerMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                denoiseMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                vaeMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                postProcessMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                stepsPerSecond: import("zod").ZodOptional<import("zod").ZodNumber>;
                 totalGenerationMs: import("zod").ZodOptional<import("zod").ZodNumber>;
                 totalWallMs: import("zod").ZodOptional<import("zod").ZodNumber>;
                 totalSteps: import("zod").ZodOptional<import("zod").ZodNumber>;
@@ -530,6 +650,7 @@ export declare const diffusionPlugin: {
             vae_tiling: import("zod").ZodOptional<import("zod").ZodBoolean>;
             vae_tile_size: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodNumber, import("zod").ZodString]>>;
             vae_tile_overlap: import("zod").ZodOptional<import("zod").ZodNumber>;
+            temporal_tiling: import("zod").ZodOptional<import("zod").ZodBoolean>;
             cache_mode: import("zod").ZodOptional<import("zod").ZodEnum<{
                 disabled: "disabled";
                 easycache: "easycache";
@@ -560,6 +681,11 @@ export declare const diffusionPlugin: {
                 height: import("zod").ZodOptional<import("zod").ZodNumber>;
                 modelLoadMs: import("zod").ZodOptional<import("zod").ZodNumber>;
                 generationMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                conditionerMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                denoiseMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                vaeMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                postProcessMs: import("zod").ZodOptional<import("zod").ZodNumber>;
+                stepsPerSecond: import("zod").ZodOptional<import("zod").ZodNumber>;
                 totalGenerationMs: import("zod").ZodOptional<import("zod").ZodNumber>;
                 totalWallMs: import("zod").ZodOptional<import("zod").ZodNumber>;
                 totalSteps: import("zod").ZodOptional<import("zod").ZodNumber>;
@@ -570,6 +696,8 @@ export declare const diffusionPlugin: {
                 totalVideoFrames: import("zod").ZodOptional<import("zod").ZodNumber>;
                 videoFrames: import("zod").ZodOptional<import("zod").ZodNumber>;
                 fps: import("zod").ZodOptional<import("zod").ZodNumber>;
+                hasAudio: import("zod").ZodOptional<import("zod").ZodBoolean>;
+                audioSampleRate: import("zod").ZodOptional<import("zod").ZodNumber>;
             }, import("zod/v4/core").$strip>>;
         }, import("zod/v4/core").$strip>>;
         upscaleStream: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodObject<{
@@ -593,8 +721,8 @@ export declare const diffusionPlugin: {
                 height: import("zod").ZodOptional<import("zod").ZodNumber>;
                 repeats: import("zod").ZodOptional<import("zod").ZodNumber>;
                 backendDevice: import("zod").ZodOptional<import("zod").ZodEnum<{
-                    cpu: "cpu";
                     gpu: "gpu";
+                    cpu: "cpu";
                 }>>;
             }, import("zod/v4/core").$strip>>;
         }, import("zod/v4/core").$strip>>;