vidspotai-shared 1.0.117 → 1.0.119

package/lib/services/aiGen/providers/openai/openai.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openai.service.d.ts","sourceRoot":"","sources":["../../../../../src/services/aiGen/providers/openai/openai.service.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AACxE,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACrB,qBAAqB,EACrB,oBAAoB,EACpB,oBAAoB,EACpB,qBAAqB,EACrB,qBAAqB,EACrB,iBAAiB,EACjB,iBAAiB,EAClB,MAAM,UAAU,CAAC;AAclB,qBAAa,aAAc,SAAQ,wBAAwB;IACzD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAa;IACxC,OAAO,CAAC,MAAM,CAAS;;IAQjB,aAAa,CACjB,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,qBAAqB,CAAC;IAwF3B,gBAAgB,CAAC,EACrB,IAAI,EACJ,cAAc,EACd,cAAyB,GAC1B,EAAE,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IA8B3C,YAAY,CAChB,MAAM,EAAE,oBAAoB,GAC3B,OAAO,CAAC,oBAAoB,CAAC;IA2ChC;;;;OAIG;IACG,aAAa,CACjB,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,qBAAqB,CAAC;IA2HjC,aAAa,CAAC,EACZ,QAAQ,EACR,UAAuB,EACvB,QAAY,EACZ,SAAiB,EACjB,SAAa,EACb,OAAO,EACP,WAAW,GACZ,EAAE,iBAAiB,GAAG,MAAM;CAqB9B"}
+{"version":3,"file":"openai.service.d.ts","sourceRoot":"","sources":["../../../../../src/services/aiGen/providers/openai/openai.service.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AACxE,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACrB,qBAAqB,EACrB,oBAAoB,EACpB,oBAAoB,EACpB,qBAAqB,EACrB,qBAAqB,EACrB,iBAAiB,EACjB,iBAAiB,EAClB,MAAM,UAAU,CAAC;AAclB,qBAAa,aAAc,SAAQ,wBAAwB;IACzD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAa;IACxC,OAAO,CAAC,MAAM,CAAS;;IAQjB,aAAa,CACjB,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,qBAAqB,CAAC;IAwF3B,gBAAgB,CAAC,EACrB,IAAI,EACJ,cAAc,EACd,cAAyB,GAC1B,EAAE,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IA8B3C,YAAY,CAChB,MAAM,EAAE,oBAAoB,GAC3B,OAAO,CAAC,oBAAoB,CAAC;IA2ChC;;;;OAIG;IACG,aAAa,CACjB,MAAM,EAAE,qBAAqB,GAC5B,OAAO,CAAC,qBAAqB,CAAC;IA6JjC,aAAa,CAAC,EACZ,QAAQ,EACR,UAAuB,EACvB,QAAY,EACZ,SAAiB,EACjB,SAAa,EACb,OAAO,EACP,WAAW,GACZ,EAAE,iBAAiB,GAAG,MAAM;CAqB9B"}

package/lib/services/aiGen/providers/openai/openai.service.js

@@ -235,70 +235,102 @@ class OpenaiService extends baseAiGenProvider_service_1.BaseAiGenProviderService
         // non-streaming overload always applies; TS can't narrow the union
         // automatically from the absence of a field.
         let resp;
-        if (isEdit) {
-            const images = await Promise.all(refs.map(async (url) => {
-                const r = await (0, storage_1.fetchOwnMedia)(url);
-                if (!r.ok) {
-                    logger_1.logger.error("openai: ref fetch failed", {
-                        url,
-                        status: r.status,
-                        statusText: r.statusText,
-                    });
-                    throw new Error(`openai ref fetch ${r.status}`);
-                }
-                const name = (url.split("?")[0] ?? "ref").split("/").pop() || "ref.png";
-                return (0, openai_1.toFile)(r, name, { type: imageMimeFromUrl(url) });
-            }));
-            const mask = params.maskImageUrl
-                ? await (async () => {
-                    const r = await (0, storage_1.fetchOwnMedia)(params.maskImageUrl);
+        try {
+            if (isEdit) {
+                const images = await Promise.all(refs.map(async (url) => {
+                    const r = await (0, storage_1.fetchOwnMedia)(url);
                     if (!r.ok) {
-                        logger_1.logger.error("openai: mask fetch failed", {
-                            url: params.maskImageUrl,
+                        logger_1.logger.error("openai: ref fetch failed", {
+                            url,
                             status: r.status,
                             statusText: r.statusText,
                         });
-                        throw new Error(`openai mask fetch ${r.status}`);
+                        throw new Error(`openai ref fetch ${r.status}`);
                     }
-                    return (0, openai_1.toFile)(r, "mask.png", { type: imageMimeFromUrl(params.maskImageUrl) });
-                })()
-                : undefined;
-            resp = (await this.client.images.edit({
-                model: modelId,
-                prompt: params.prompt,
-                image: images.length === 1 ? images[0] : images,
-                ...(mask ? { mask } : {}),
-                ...(params.numImages ? { n: params.numImages } : {}),
-                ...(size ? { size: size } : {}),
-                ...(params.quality ? { quality: params.quality } : {}),
-                ...(params.background ? { background: params.background } : {}),
-                ...(params.outputFormat ? { output_format: params.outputFormat } : {}),
-            }));
-            if (!resp?.data?.length) {
-                logger_1.logger.error("openai: images endpoint returned no data", {
-                    endpoint: "edit",
-                    responseKeys: resp ? Object.keys(resp) : null,
-                });
-                throw new Error("openai images: empty data[]");
+                    const name = (url.split("?")[0] ?? "ref").split("/").pop() || "ref.png";
+                    return (0, openai_1.toFile)(r, name, { type: imageMimeFromUrl(url) });
+                }));
+                const mask = params.maskImageUrl
+                    ? await (async () => {
+                        const r = await (0, storage_1.fetchOwnMedia)(params.maskImageUrl);
+                        if (!r.ok) {
+                            logger_1.logger.error("openai: mask fetch failed", {
+                                url: params.maskImageUrl,
+                                status: r.status,
+                                statusText: r.statusText,
+                            });
+                            throw new Error(`openai mask fetch ${r.status}`);
+                        }
+                        return (0, openai_1.toFile)(r, "mask.png", { type: imageMimeFromUrl(params.maskImageUrl) });
+                    })()
+                    : undefined;
+                resp = (await this.client.images.edit({
+                    model: modelId,
+                    prompt: params.prompt,
+                    image: images.length === 1 ? images[0] : images,
+                    ...(mask ? { mask } : {}),
+                    ...(params.numImages ? { n: params.numImages } : {}),
+                    ...(size ? { size: size } : {}),
+                    ...(params.quality ? { quality: params.quality } : {}),
+                    ...(params.background ? { background: params.background } : {}),
+                    ...(params.outputFormat ? { output_format: params.outputFormat } : {}),
+                }));
+                if (!resp?.data?.length) {
+                    logger_1.logger.error("openai: images endpoint returned no data", {
+                        endpoint: "edit",
+                        responseKeys: resp ? Object.keys(resp) : null,
+                    });
+                    throw new Error("openai images: empty data[]");
+                }
+            }
+            else {
+                resp = (await this.client.images.generate({
+                    model: modelId,
+                    prompt: params.prompt,
+                    ...(params.numImages ? { n: params.numImages } : {}),
+                    ...(size ? { size: size } : {}),
+                    ...(params.quality ? { quality: params.quality } : {}),
+                    ...(params.background ? { background: params.background } : {}),
+                    ...(params.outputFormat ? { output_format: params.outputFormat } : {}),
+                }));
+                if (!resp?.data?.length) {
+                    logger_1.logger.error("openai: images endpoint returned no data", {
+                        endpoint: "generate",
+                        responseKeys: resp ? Object.keys(resp) : null,
+                    });
+                    throw new Error("openai images: empty data[]");
+                }
             }
         }
-        else {
-            resp = (await this.client.images.generate({
-                model: modelId,
-                prompt: params.prompt,
-                ...(params.numImages ? { n: params.numImages } : {}),
-                ...(size ? { size: size } : {}),
-                ...(params.quality ? { quality: params.quality } : {}),
-                ...(params.background ? { background: params.background } : {}),
-                ...(params.outputFormat ? { output_format: params.outputFormat } : {}),
-            }));
-            if (!resp?.data?.length) {
-                logger_1.logger.error("openai: images endpoint returned no data", {
-                    endpoint: "generate",
-                    responseKeys: resp ? Object.keys(resp) : null,
-                });
-                throw new Error("openai images: empty data[]");
+        catch (err) {
+            // Only remap genuine OpenAI APIErrors (they carry `.status`). The
+            // ref/mask-fetch and empty-data[] errors thrown above are our own plain
+            // Errors with no `.status`, so they fall through unchanged and keep
+            // paging — those ARE ops-actionable (our storage/CDN, not user input).
+            const status = err?.status ?? err?.response?.status;
+            if (status === undefined)
+                throw err;
+            const message = err?.message ?? String(err);
+            if (status === 400) {
+                // The images.edit endpoint's most common 400 is a rejected reference
+                // image (unsupported mode/corrupt file/size mismatch) — user-fixable,
+                // not an ops incident. Fall back to the generic capability-mismatch
+                // code for other 400s (e.g. bad size/quality combination).
+                const code = isEdit && /image/i.test(message)
+                    ? errors_1.USER_FACING_ERROR_CODES.INPUT_IMAGE_REJECTED
+                    : errors_1.USER_FACING_ERROR_CODES.CAPABILITY_MISMATCH;
+                throw new errors_1.UserFacingError(message, code);
+            }
+            if (status === 401 || status === 403) {
+                throw new errors_1.UserFacingError(message, errors_1.USER_FACING_ERROR_CODES.PROVIDER_AUTH_ERROR);
             }
+            if (status === 429) {
+                const oaCode = err?.code ?? err?.error?.code ?? err?.type ?? err?.error?.type ?? "";
+                const isQuota = /insufficient_quota|billing|exceeded_current_quota/i.test(oaCode) ||
+                    /quota|billing|insufficient/i.test(message);
+                throw new errors_1.UserFacingError(message, isQuota ? errors_1.USER_FACING_ERROR_CODES.ACCOUNT_QUOTA_EXCEEDED : errors_1.USER_FACING_ERROR_CODES.CAPABILITY_MISMATCH);
+            }
+            throw err;
         }
         const data = resp.data ?? [];
         const ts = Date.now();

package/lib/services/aiGen/providers/topaz/topaz.service.d.ts

@@ -0,0 +1,51 @@
+import { BaseAiGenProviderService } from "../baseAiGenProvider.service";
+import { CreditUsageParams, UpscaleImageParams, UpscaleImageStatusResult, UpscaleStatusParams, UpscaleSubmitResult, UpscaleVideoParams, UpscaleVideoStatusResult } from "../types";
+/**
+ * Topaz Labs upscale provider (image + video). Both APIs are async — submit
+ * returns a provider request id, the caller (queue processor) polls the
+ * matching `checkUpscale*Status` method until a terminal state. On success
+ * the status method has ALREADY rehosted Topaz's time-limited result URL into
+ * our own storage (mediaStorage) — never the provider's own temp URL, same
+ * "always control our own copy" convention as every other provider
+ * (see runway.service.ts checkVideoStatus).
+ */
+export declare class TopazService extends BaseAiGenProviderService {
+    private readonly apiKey;
+    constructor();
+    /**
+     * POST /enhance/async (multipart). Topaz needs the actual image bytes, so
+     * we download the caller's `inputImageUrl` first rather than passing the
+     * URL through — the input is already our own stored asset (from
+     * /v1/media/single-upload) by the time this runs.
+     */
+    upscaleImage(params: UpscaleImageParams): Promise<UpscaleSubmitResult>;
+    /**
+     * GET /status/{id} then, on completion, GET /download/{id} for a temporary
+     * URL — which we immediately rehost into mediaStorage. Never return
+     * Topaz's own URL as the job's final `outputUrl`.
+     */
+    checkUpscaleImageStatus({ providerRequestId, outputFilename, outputFilePath, }: UpscaleStatusParams): Promise<UpscaleImageStatusResult>;
+    /**
+     * Drives Topaz's full submit -> accept -> upload -> complete-upload
+     * sequence in one call so the queue processor only has to poll afterwards.
+     * Splitting this across separate BullMQ steps would multiply the ways a job
+     * can get stuck between retries with no clean resume point — Topaz's own
+     * `status` polling is the one resumable point post-submit.
+     */
+    upscaleVideo(params: UpscaleVideoParams): Promise<UpscaleSubmitResult>;
+    /**
+     * GET /video/{id}/status. On completion, downloads the returned link and
+     * rehosts it into mediaStorage — same "never persist the provider's own
+     * temp URL" rule as the image path above.
+     */
+    checkUpscaleVideoStatus({ providerRequestId, outputFilename, outputFilePath, }: UpscaleStatusParams): Promise<UpscaleVideoStatusResult>;
+    /**
+     * Image: priced per output megapixel (`cost.perMegapixel`), floored at
+     * MIN_CREDITS_PER_IMAGE_OP. Video: `cost.perSecond` is an UNVERIFIED
+     * placeholder (Topaz doesn't publish a video pricing formula — see
+     * topaz.ts module docblock) floored at the standard paid-op floor until the
+     * real rate is confirmed.
+     */
+    getCreditUsed({ modelKey, outputMegapixels, duration, creditFloor }: CreditUsageParams): number;
+}
+//# sourceMappingURL=topaz.service.d.ts.map

package/lib/services/aiGen/providers/topaz/topaz.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"topaz.service.d.ts","sourceRoot":"","sources":["../../../../../src/services/aiGen/providers/topaz/topaz.service.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AACxE,OAAO,EACL,iBAAiB,EACjB,kBAAkB,EAClB,wBAAwB,EACxB,mBAAmB,EACnB,mBAAmB,EACnB,kBAAkB,EAClB,wBAAwB,EACzB,MAAM,UAAU,CAAC;AA4BlB;;;;;;;;GAQG;AACH,qBAAa,YAAa,SAAQ,wBAAwB;IACxD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;;IAchC;;;;;OAKG;IACG,YAAY,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAkD5E;;;;OAIG;IACG,uBAAuB,CAAC,EAC5B,iBAAiB,EACjB,cAAc,EACd,cAAiC,GAClC,EAAE,mBAAmB,GAAG,OAAO,CAAC,wBAAwB,CAAC;IA2C1D;;;;;;OAMG;IACG,YAAY,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IA6I5E;;;;OAIG;IACG,uBAAuB,CAAC,EAC5B,iBAAiB,EACjB,cAAc,EACd,cAAiC,GAClC,EAAE,mBAAmB,GAAG,OAAO,CAAC,wBAAwB,CAAC;IAyC1D;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,QAAQ,EAAE,gBAAgB,EAAE,QAAY,EAAE,WAAW,EAAE,EAAE,iBAAiB,GAAG,MAAM;CAmBpG"}

package/lib/services/aiGen/providers/topaz/topaz.service.js

@@ -0,0 +1,321 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TopazService = void 0;
+const aiModels_1 = require("../../../../globals/aiModels");
+const creditUnit_1 = require("../../../../globals/creditUnit");
+const storage_1 = require("../../../../libs/storage");
+const errors_1 = require("../../../../utils/errors");
+const helpers_1 = require("../../../../utils/helpers");
+const logger_1 = require("../../../../utils/logger");
+const transientRetry_1 = require("../../transientRetry");
+const baseAiGenProvider_service_1 = require("../baseAiGenProvider.service");
+const IMAGE_BASE_URL = "https://api.topazlabs.com/image/v1";
+const VIDEO_BASE_URL = "https://api.topazlabs.com/video";
+/**
+ * Classify a Topaz HTTP failure (non-2xx). Same shape as every other
+ * provider's classifier (see pixverse.service.ts's classifyPixVerseHttpError)
+ * — 401/403 is a deploy/config bug (fail fast, no Slack noise per job), 5xx/429
+ * is transient and retried by withTransientRetry, everything else is a real
+ * bug worth alerting on.
+ */
+function classifyTopazHttpError(status, body, op) {
+    if (status === 401 || status === 403) {
+        return new errors_1.UserFacingError(`Topaz rejected the API key (HTTP ${status}). Ask an operator to verify TOPAZ_API_KEY.`, errors_1.USER_FACING_ERROR_CODES.PROVIDER_AUTH_ERROR);
+    }
+    if (status >= 500 || status === 429) {
+        return new transientRetry_1.TransientHttpError(status, `Topaz ${op} transient HTTP ${status}: ${body.slice(0, 200)}`);
+    }
+    return new Error(`Topaz ${op} failed (${status}): ${body}`);
+}
+const IMAGE_TERMINAL_COMPLETED = ["completed", "complete", "succeeded", "success"];
+const VIDEO_TERMINAL_COMPLETED = ["completed", "complete", "succeeded", "success"];
+/**
+ * Topaz Labs upscale provider (image + video). Both APIs are async — submit
+ * returns a provider request id, the caller (queue processor) polls the
+ * matching `checkUpscale*Status` method until a terminal state. On success
+ * the status method has ALREADY rehosted Topaz's time-limited result URL into
+ * our own storage (mediaStorage) — never the provider's own temp URL, same
+ * "always control our own copy" convention as every other provider
+ * (see runway.service.ts checkVideoStatus).
+ */
+class TopazService extends baseAiGenProvider_service_1.BaseAiGenProviderService {
+    constructor() {
+        super();
+        if (!process.env.TOPAZ_API_KEY) {
+            throw new Error("Missing TOPAZ_API_KEY in environment variables");
+        }
+        this.apiKey = process.env.TOPAZ_API_KEY;
+    }
+    // ============================================================
+    // IMAGE UPSCALE
+    // ============================================================
+    /**
+     * POST /enhance/async (multipart). Topaz needs the actual image bytes, so
+     * we download the caller's `inputImageUrl` first rather than passing the
+     * URL through — the input is already our own stored asset (from
+     * /v1/media/single-upload) by the time this runs.
+     */
+    async upscaleImage(params) {
+        const modelId = aiModels_1.aiModelConfigs[params.modelKey]?.modelId;
+        if (!modelId) {
+            throw new Error(`Unknown Topaz image modelKey: ${params.modelKey}`);
+        }
+        const srcResp = await fetch(params.inputImageUrl);
+        if (!srcResp.ok) {
+            throw new errors_1.UserFacingError("Your input image could not be read for upscaling. Please try uploading it again.", errors_1.USER_FACING_ERROR_CODES.INPUT_IMAGE_REJECTED);
+        }
+        const contentType = srcResp.headers.get("content-type") || "image/jpeg";
+        const imageBuffer = Buffer.from(await srcResp.arrayBuffer());
+        const form = new FormData();
+        form.append("model", modelId);
+        form.append("output_format", params.outputFormat ?? "jpeg");
+        form.append("image", new Blob([imageBuffer], { type: contentType }), "input");
+        return (0, transientRetry_1.withTransientRetry)("topaz:upscaleImage", async () => {
+            const resp = await fetch(`${IMAGE_BASE_URL}/enhance/async`, {
+                method: "POST",
+                headers: { "X-API-KEY": this.apiKey },
+                body: form,
+            });
+            if (!resp.ok) {
+                throw classifyTopazHttpError(resp.status, await resp.text(), "upscaleImage");
+            }
+            const data = (await resp.json());
+            if (!data.process_id) {
+                throw new Error("Topaz image upscale did not return a process_id");
+            }
+            return { providerRequestId: data.process_id };
+        }, {
+            onRetry: ({ attempt, maxAttempts, backoffMs, err }) => logger_1.logger.warn("Topaz upscaleImage transient error — retrying", {
+                attempt,
+                maxAttempts,
+                backoffMs,
+                message: err.message,
+            }),
+        });
+    }
+    /**
+     * GET /status/{id} then, on completion, GET /download/{id} for a temporary
+     * URL — which we immediately rehost into mediaStorage. Never return
+     * Topaz's own URL as the job's final `outputUrl`.
+     */
+    async checkUpscaleImageStatus({ providerRequestId, outputFilename, outputFilePath = "upscale_images", }) {
+        const statusResp = await fetch(`${IMAGE_BASE_URL}/status/${providerRequestId}`, {
+            headers: { "X-API-KEY": this.apiKey },
+        });
+        if (!statusResp.ok) {
+            throw classifyTopazHttpError(statusResp.status, await statusResp.text(), "checkUpscaleImageStatus");
+        }
+        const statusData = (await statusResp.json());
+        const normalized = (statusData.status ?? "").toLowerCase();
+        if (normalized === "failed" || normalized === "error") {
+            return { status: "failed", errorMessage: statusData.error ?? "Topaz image upscale failed" };
+        }
+        if (!IMAGE_TERMINAL_COMPLETED.includes(normalized)) {
+            return { status: "processing" };
+        }
+        const downloadResp = await fetch(`${IMAGE_BASE_URL}/download/${providerRequestId}`, {
+            headers: { "X-API-KEY": this.apiKey },
+        });
+        if (!downloadResp.ok) {
+            throw classifyTopazHttpError(downloadResp.status, await downloadResp.text(), "checkUpscaleImageStatus:download");
+        }
+        const { url } = (await downloadResp.json());
+        if (!url)
+            throw new Error("Topaz image download endpoint did not return a url");
+        const assetResp = await fetch(url);
+        if (!assetResp.ok) {
+            throw new Error(`Failed to download Topaz upscaled image: ${assetResp.status}`);
+        }
+        const contentType = assetResp.headers.get("content-type") || "image/jpeg";
+        const ext = (contentType.split("/")[1] || "jpeg").toLowerCase();
+        const buffer = Buffer.from(await assetResp.arrayBuffer());
+        // mediaStorage: GCS write + best-effort R2 mirror (zero-egress delivery).
+        const signedUrl = await storage_1.mediaStorage.put(`${outputFilePath}/${outputFilename}.${ext}`, buffer, contentType);
+        return { status: "completed", outputUrl: signedUrl };
+    }
+    // ============================================================
+    // VIDEO UPSCALE
+    // ============================================================
+    /**
+     * Drives Topaz's full submit -> accept -> upload -> complete-upload
+     * sequence in one call so the queue processor only has to poll afterwards.
+     * Splitting this across separate BullMQ steps would multiply the ways a job
+     * can get stuck between retries with no clean resume point — Topaz's own
+     * `status` polling is the one resumable point post-submit.
+     */
+    async upscaleVideo(params) {
+        const modelId = aiModels_1.aiModelConfigs[params.modelKey]?.modelId;
+        if (!modelId) {
+            throw new Error(`Unknown Topaz video modelKey: ${params.modelKey}`);
+        }
+        const { source } = params;
+        const requestId = await (0, transientRetry_1.withTransientRetry)("topaz:upscaleVideo:submit", async () => {
+            const resp = await fetch(`${VIDEO_BASE_URL}/`, {
+                method: "POST",
+                headers: { "X-API-Key": this.apiKey, "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    source: {
+                        container: source.container,
+                        size: source.size,
+                        resolution: source.resolution,
+                        frameRate: source.frameRate,
+                        frameCount: source.frameCount,
+                        duration: source.duration,
+                    },
+                    output: {
+                        resolution: {
+                            width: source.resolution.width * params.scale,
+                            height: source.resolution.height * params.scale,
+                        },
+                        frameRate: source.frameRate,
+                        container: source.container,
+                    },
+                    filters: [{ model: modelId, type: "upscale" }],
+                }),
+            });
+            if (!resp.ok) {
+                throw classifyTopazHttpError(resp.status, await resp.text(), "upscaleVideo:submit");
+            }
+            const data = (await resp.json());
+            const id = data.id ?? data.requestId;
+            if (!id)
+                throw new Error("Topaz video submit did not return a request id");
+            return id;
+        }, {
+            onRetry: ({ attempt, maxAttempts, backoffMs, err }) => logger_1.logger.warn("Topaz upscaleVideo submit transient error — retrying", {
+                attempt,
+                maxAttempts,
+                backoffMs,
+                message: err.message,
+            }),
+        });
+        const uploadUrl = await (0, transientRetry_1.withTransientRetry)("topaz:upscaleVideo:accept", async () => {
+            const resp = await fetch(`${VIDEO_BASE_URL}/${requestId}/accept`, {
+                method: "PATCH",
+                headers: { "X-API-Key": this.apiKey },
+            });
+            if (!resp.ok) {
+                throw classifyTopazHttpError(resp.status, await resp.text(), "upscaleVideo:accept");
+            }
+            const data = (await resp.json());
+            const url = data.url ?? data.urls?.[0];
+            if (!url)
+                throw new Error("Topaz video accept did not return an upload url");
+            return url;
+        }, {
+            onRetry: ({ attempt, maxAttempts, backoffMs, err }) => logger_1.logger.warn("Topaz upscaleVideo accept transient error — retrying", {
+                attempt,
+                maxAttempts,
+                backoffMs,
+                message: err.message,
+            }),
+        });
+        // Our own already-persisted source (from /v1/media/single-upload) — never
+        // a browser upload stream directly.
+        const srcResp = await fetch(params.inputVideoUrl);
+        if (!srcResp.ok) {
+            throw new errors_1.UserFacingError("Your input video could not be read for upscaling. Please try uploading it again.", errors_1.USER_FACING_ERROR_CODES.INPUT_IMAGE_REJECTED);
+        }
+        const videoBuffer = Buffer.from(await srcResp.arrayBuffer());
+        const eTag = await (0, transientRetry_1.withTransientRetry)("topaz:upscaleVideo:upload", async () => {
+            const putResp = await fetch(uploadUrl, {
+                method: "PUT",
+                headers: { "Content-Type": `video/${source.container}` },
+                body: videoBuffer,
+            });
+            if (!putResp.ok) {
+                throw classifyTopazHttpError(putResp.status, await putResp.text(), "upscaleVideo:upload");
+            }
+            const tag = putResp.headers.get("etag");
+            if (!tag)
+                throw new Error("Topaz video upload did not return an ETag");
+            return tag;
+        }, {
+            onRetry: ({ attempt, maxAttempts, backoffMs, err }) => logger_1.logger.warn("Topaz upscaleVideo upload transient error — retrying", {
+                attempt,
+                maxAttempts,
+                backoffMs,
+                message: err.message,
+            }),
+        });
+        await (0, transientRetry_1.withTransientRetry)("topaz:upscaleVideo:complete", async () => {
+            const resp = await fetch(`${VIDEO_BASE_URL}/${requestId}/complete-upload`, {
+                method: "PATCH",
+                headers: { "X-API-Key": this.apiKey, "Content-Type": "application/json" },
+                body: JSON.stringify({ eTag }),
+            });
+            if (!resp.ok) {
+                throw classifyTopazHttpError(resp.status, await resp.text(), "upscaleVideo:complete");
+            }
+        }, {
+            onRetry: ({ attempt, maxAttempts, backoffMs, err }) => logger_1.logger.warn("Topaz upscaleVideo complete-upload transient error — retrying", {
+                attempt,
+                maxAttempts,
+                backoffMs,
+                message: err.message,
+            }),
+        });
+        return { providerRequestId: requestId };
+    }
+    /**
+     * GET /video/{id}/status. On completion, downloads the returned link and
+     * rehosts it into mediaStorage — same "never persist the provider's own
+     * temp URL" rule as the image path above.
+     */
+    async checkUpscaleVideoStatus({ providerRequestId, outputFilename, outputFilePath = "upscale_videos", }) {
+        const resp = await fetch(`${VIDEO_BASE_URL}/${providerRequestId}/status`, {
+            headers: { "X-API-Key": this.apiKey },
+        });
+        if (!resp.ok) {
+            throw classifyTopazHttpError(resp.status, await resp.text(), "checkUpscaleVideoStatus");
+        }
+        const data = (await resp.json());
+        const normalized = (data.status ?? "").toLowerCase();
+        if (normalized === "failed" || normalized === "error") {
+            return { status: "failed", errorMessage: data.error ?? "Topaz video upscale failed" };
+        }
+        if (normalized === "cancelled" || normalized === "canceled") {
+            return { status: "cancelled", errorMessage: data.error ?? "Topaz video upscale was cancelled" };
+        }
+        const downloadUrl = data.downloadUrl ?? data.download_url;
+        if (!VIDEO_TERMINAL_COMPLETED.includes(normalized) || !downloadUrl) {
+            return { status: "processing" };
+        }
+        const assetResp = await fetch(downloadUrl);
+        if (!assetResp.ok) {
+            throw new Error(`Failed to download Topaz upscaled video: ${assetResp.status}`);
+        }
+        const buffer = Buffer.from(await assetResp.arrayBuffer());
+        // mediaStorage: GCS write + best-effort R2 mirror (zero-egress delivery).
+        const signedUrl = await storage_1.mediaStorage.put(`${outputFilePath}/${outputFilename}.mp4`, buffer, "video/mp4");
+        return { status: "completed", outputUrl: signedUrl };
+    }
+    // ============================================================
+    // CREDITS
+    // ============================================================
+    /**
+     * Image: priced per output megapixel (`cost.perMegapixel`), floored at
+     * MIN_CREDITS_PER_IMAGE_OP. Video: `cost.perSecond` is an UNVERIFIED
+     * placeholder (Topaz doesn't publish a video pricing formula — see
+     * topaz.ts module docblock) floored at the standard paid-op floor until the
+     * real rate is confirmed.
+     */
+    getCreditUsed({ modelKey, outputMegapixels, duration = 5, creditFloor }) {
+        const modelConfig = aiModels_1.aiModelConfigs[modelKey];
+        const cost = modelConfig?.cost;
+        if (cost?.perMegapixel !== undefined) {
+            // Fall back to a conservative 24MP (Topaz's 1-credit tier boundary) if
+            // the caller didn't compute an exact output size.
+            const megapixels = outputMegapixels ?? 24;
+            return (0, helpers_1.getCreditsFromCost)(cost.perMegapixel * megapixels, true, creditFloor ?? creditUnit_1.MIN_CREDITS_PER_IMAGE_OP);
+        }
+        if (cost?.perSecond !== undefined) {
+            return (0, helpers_1.getCreditsFromCost)(cost.perSecond * duration, true, creditFloor);
+        }
+        logger_1.logger.warn(`Topaz getCreditUsed: no cost config for modelKey="${modelKey}" — returning fallback`, {
+            modelKey,
+        });
+        return (0, helpers_1.getCreditsFromCost)(1.0, true, creditFloor);
+    }
+}
+exports.TopazService = TopazService;

package/lib/services/aiGen/providers/types.d.ts

@@ -1,4 +1,4 @@
-import { EImageGenModelKey, EMusicGenModels, ESfxGenModels, ETextGenModels, EVideoGenModels } from "../../../globals/aiModels";
+import { EImageGenModelKey, EMusicGenModels, ESfxGenModels, ETextGenModels, EUpscaleImageModelKey, EUpscaleVideoModelKey, EVideoGenModels } from "../../../globals/aiModels";
 import { EVideoSceneStatus, TVideoJobTask } from "../../../globals/types";
 import { EVideoMode } from "../types";
 import type { CameraControl } from "../canonicalAdapters/cameraControl.types";
@@ -304,8 +304,73 @@ export interface SfxGenerationResult {
     mimeType: string;
     extension: string;
 }
+/**
+ * Image upscale (Topaz). Async — the provider returns a `providerRequestId`
+ * immediately; the caller polls `checkUpscaleImageStatus()` until the status
+ * is terminal. On success the result's `outputUrl` is already persisted into
+ * OUR storage (mediaStorage) — never the provider's own temporary URL, same
+ * convention as `VideoStatusResult.videoUrl`.
+ */
+export interface UpscaleImageParams {
+    modelKey: EUpscaleImageModelKey;
+    inputImageUrl: string;
+    /** 2 or 4 — see topaz.ts model config `fields.scale`. */
+    scale: number;
+    outputFormat?: "jpeg" | "png";
+}
+export interface UpscaleSubmitResult {
+    providerRequestId: string;
+}
+export type TUpscaleProviderStatus = "processing" | "completed" | "failed" | "cancelled";
+export interface UpscaleStatusParams {
+    providerRequestId: string;
+    /** Object-storage filename (no extension) the result is persisted under on completion. */
+    outputFilename: string;
+    /** Object-storage folder. Defaults to "upscale_images" / "upscale_videos" per provider. */
+    outputFilePath?: string;
+}
+export interface UpscaleImageStatusResult {
+    status: TUpscaleProviderStatus;
+    /** Present once status is "completed" — already a mediaStorage-signed URL. */
+    outputUrl?: string;
+    width?: number;
+    height?: number;
+    errorMessage?: string;
+}
+/**
+ * Video upscale (Topaz). Multi-step: submit → accept (upload URL) → upload
+ * source bytes → complete-upload → poll. `upscaleVideo()` drives the whole
+ * submit-through-complete-upload sequence and returns the request id;
+ * `checkUpscaleVideoStatus()` polls from there.
+ */
+export interface UpscaleVideoParams {
+    modelKey: EUpscaleVideoModelKey;
+    inputVideoUrl: string;
+    scale: number;
+    source: {
+        resolution: {
+            width: number;
+            height: number;
+        };
+        container: string;
+        /** Bytes. */
+        size: number;
+        /** Seconds. */
+        duration: number;
+        frameRate: number;
+        frameCount: number;
+    };
+}
+export interface UpscaleVideoStatusResult {
+    status: TUpscaleProviderStatus;
+    outputUrl?: string;
+    width?: number;
+    height?: number;
+    durationSec?: number;
+    errorMessage?: string;
+}
 export interface CreditUsageParams {
-    modelKey: EVideoGenModels | ETextGenModels | EImageGenModelKey | EMusicGenModels | ESfxGenModels;
+    modelKey: EVideoGenModels | ETextGenModels | EImageGenModelKey | EMusicGenModels | ESfxGenModels | EUpscaleImageModelKey | EUpscaleVideoModelKey;
     mode?: EVideoMode;
     duration?: number;
     resolution?: string;
@@ -338,5 +403,11 @@ export interface CreditUsageParams {
      * MIN_CREDITS_PER_PAID_OP. See globals/creditUnit.ts.
      */
     creditFloor?: number;
+    /**
+     * Topaz image upscale — output megapixels (post-scale width*height/1e6),
+     * priced per-megapixel (see topaz.ts `cost.perMegapixel`). Left undefined
+     * for every other modality.
+     */
+    outputMegapixels?: number;
 }
 //# sourceMappingURL=types.d.ts.map