@brotu/ai 0.5.0 → 0.6.0

package/dist/index.cjs

@@ -62,6 +62,11 @@ __export(index_exports, {
   QWEN_TEXT_MODELS: () => QWEN_TEXT_MODELS,
   QWEN_VIDEO_MODELS: () => QWEN_VIDEO_MODELS,
   QwenAdapter: () => QwenAdapter,
+  TOPAZ_CATALOG: () => TOPAZ_CATALOG,
+  TOPAZ_IMAGE_MODELS: () => TOPAZ_IMAGE_MODELS,
+  TOPAZ_MODELS: () => TOPAZ_MODELS,
+  TOPAZ_VIDEO_MODELS: () => TOPAZ_VIDEO_MODELS,
+  TopazAdapter: () => TopazAdapter,
   brotu: () => brotu,
   createS3Storage: () => createS3Storage,
   deliverWebhook: () => deliverWebhook,
@@ -834,7 +839,7 @@ var imageOmni = {
       prompt: input.prompt
     };
     if (images.length > 0) {
-      body.image_list = images.map((image) => ({ image }));
+      body.image_list = images.map((image2) => ({ image: image2 }));
     }
     if (elements.length > 0) {
       body.element_list = elements.map((id) => ({ element_id: id }));
@@ -1236,6 +1241,105 @@ var QWEN_CATALOG = [
   )
 ];
 
+// src/providers/topaz.models.ts
+var VIDEO_RES = ["720p", "1080p", "4k"];
+function video(id, name, kind, description) {
+  return [id, { name, vendorModel: id, surface: "video", kind, description }];
+}
+function image(id, name, vendorModel, imagePath, description) {
+  return [
+    id,
+    { name, vendorModel, surface: "image", imagePath, description }
+  ];
+}
+var ENTRIES = [
+  // Precision video upscale (Proteus family)
+  video("prob-4", "Proteus", "upscale", "Default video upscale. Preserves the source."),
+  video("pnat-1", "Proteus Natural", "upscale", "Softer Proteus. 2\xD7 only."),
+  video("rhea-1", "Rhea", "upscale", "High-fidelity 4\xD7 upscale for fine detail."),
+  video("thd-3", "Theia Fine Tune Detail", "upscale", "More aggressive detail."),
+  video("thf-4", "Theia Fine Tune Fidelity", "upscale", "Lighter touch, closer to the source."),
+  video("thm-2", "Themis 2", "upscale", "Motion deblur."),
+  video("aaa-9", "Artemis Aliasing / Moire", "upscale", "Aliasing and moire cleanup."),
+  video("ahq-12", "Artemis High Quality", "upscale", "Artemis for clean footage."),
+  video("amq-13", "Artemis Medium Quality", "upscale", "Artemis for typical compression."),
+  video("amqs-2", "Artemis Medium Halo", "upscale", "Medium halo reduction."),
+  video("alq-13", "Artemis Low Quality", "upscale", "Artemis for degraded sources."),
+  video("alqs-2", "Artemis Strong Halo", "upscale", "Strong halo reduction."),
+  video("iris-3", "Iris Medium Quality", "upscale", "Face recovery, medium quality."),
+  video("iris-2", "Iris Low Quality", "upscale", "Face recovery, low quality."),
+  video("dtv-4", "Dione TV", "upscale", "Deinterlace broadcast footage."),
+  video("ddv-3", "Dione DV", "upscale", "Deinterlace camcorder footage."),
+  video("dtvs-2", "Dione Robust", "upscale", "Deinterlace degraded interlaced sources."),
+  video("dtd-4", "Dione Dehalo", "upscale", "Deinterlace with halo cleanup."),
+  video("dtds-2", "Dione Robust Dehalo", "upscale", "Deinterlace, degraded, with halo cleanup."),
+  video("ghq-5", "Gaia High Quality", "upscale", "CGI and animation, high quality."),
+  video("gcg-5", "Gaia CG", "upscale", "General CGI and renders."),
+  video("nyx-3", "Nyx", "upscale", "Default video denoise."),
+  video("nxl-1", "Nyx XL", "upscale", "Heavy video denoise."),
+  video("nxhf-1", "Nyx High Fidelity", "upscale", "Light denoise, keep texture."),
+  video("nxf-1", "Nyx Fast", "upscale", "Fast video denoise."),
+  video("color-1", "Video Colorization", "upscale", "Black-and-white to color."),
+  // Generative / creative video
+  video("slp-2.6", "Starlight Precise 2.6", "upscale", "Generative upscale to 4K. Faces, texture, text."),
+  video("slhq-1", "Starlight HQ", "upscale", "Maximum quality generative enhance."),
+  video("slf-2", "Starlight Fast 2", "upscale", "Faster generative upscale."),
+  video("slm-1", "Starlight Mini", "upscale", "Archival and interlaced restoration."),
+  video("wonder-1", "Starlight Sharp", "upscale", "Local-first sharpening restore."),
+  video("ast-2", "Astra 2", "upscale", "Creative GenAI video upscale."),
+  // Frame interpolation — not upscalers
+  video("aion-1", "Aion", "interpolation", "Extreme slow motion on complex, high-res motion."),
+  video("apo-8", "Apollo", "interpolation", "Default slow-mo and frame-rate conversion."),
+  video("apf-2", "Apollo Fast", "interpolation", "Faster Apollo."),
+  video("chr-2", "Chronos", "interpolation", "Interpolation for harder motion."),
+  video("chf-3", "Chronos Fast", "interpolation", "Faster Chronos."),
+  // Image — Gigapixel / enhance
+  image("standard-v2", "Standard 2", "Standard V2", "/image/v1/enhance/async", "Default image upscale."),
+  image("high-fidelity-v2", "High Fidelity 2", "High Fidelity V2", "/image/v1/enhance/async", "Maximum source preservation."),
+  image("low-resolution-v2", "Low Resolution 2", "Low Resolution V2", "/image/v1/enhance/async", "Tiny or heavily compressed sources."),
+  image("cgi", "Art & CGI", "CGI", "/image/v1/enhance/async", "Illustrations, renders, game art."),
+  image("text-refine", "Text & Shapes", "Text Refine", "/image/v1/enhance/async", "Documents, screenshots, type."),
+  // Image — generative enhance
+  image("standard-max", "Standard Max", "Standard MAX", "/image/v1/enhance-gen/async", "Default generative image upscale."),
+  image("wonder", "Wonder", "Wonder", "/image/v1/enhance-gen/async", "One-click generative restore."),
+  image("wonder-3.5", "Wonder 3.5", "Wonder 3.5", "/image/v1/enhance-gen/async", "Highest-quality generative image upscale."),
+  image("redefine", "Redefine", "Redefine", "/image/v1/enhance-gen/async", "Prompt-guided generative enhance."),
+  image("recovery-v2", "Recover 3", "Recovery V2", "/image/v1/enhance-gen/async", "Heavily damaged sources."),
+  image("bloom-2", "Bloom 2", "Bloom 2", "/image/v1/enhance-gen/async", "Creative upscale for GenAI images."),
+  image("denoise-max", "Denoise Max", "Denoise Max", "/image/v1/denoise-gen/async", "Highest-quality image denoise.")
+];
+var TOPAZ_MODELS = Object.fromEntries(
+  ENTRIES.flatMap(([id, binding]) => {
+    const rows = [[id, binding]];
+    if (binding.surface === "image" && binding.vendorModel !== id) {
+      rows.push([binding.vendorModel, binding]);
+    }
+    return rows;
+  })
+);
+function nodeTypes(binding) {
+  if (binding.surface === "image") return ["image_upscale"];
+  return binding.kind === "interpolation" ? ["video_gen"] : ["video_upscale"];
+}
+var TOPAZ_CATALOG = ENTRIES.map(([id, binding]) => ({
+  id,
+  name: binding.name,
+  category: binding.surface,
+  inputType: binding.surface === "video" ? "video_required" : "image_required",
+  nodeTypes: nodeTypes(binding),
+  creditsPerUnit: 0,
+  creditUnit: binding.surface === "video" ? "second" : "image",
+  supportedResolutions: binding.surface === "video" ? [...VIDEO_RES] : void 0,
+  provider: "topaz",
+  description: binding.description
+}));
+var TOPAZ_VIDEO_MODELS = Object.fromEntries(
+  ENTRIES.filter(([, binding]) => binding.surface === "video")
+);
+var TOPAZ_IMAGE_MODELS = Object.fromEntries(
+  ENTRIES.filter(([, binding]) => binding.surface === "image")
+);
+
 // src/catalog.ts
 var PROVIDER_BASE_URLS = {
   byteplus: "https://ark.ap-southeast.bytepluses.com",
@@ -1244,6 +1348,7 @@ var PROVIDER_BASE_URLS = {
   google: "https://generativelanguage.googleapis.com",
   openai: "https://api.openai.com",
   qwen: "https://dashscope-intl.aliyuncs.com",
+  topaz: "https://api.topazlabs.com",
   brotu: "https://api.brotu.app"
 };
 var DEFAULT_BROTU_API_URL = PROVIDER_BASE_URLS.brotu;
@@ -1261,7 +1366,8 @@ var BUILT_IN = [
   ...QWEN_CATALOG,
   ...OPENAI_CATALOG,
   ...GOOGLE_CATALOG,
-  ...ELEVENLABS_CATALOG
+  ...ELEVENLABS_CATALOG,
+  ...TOPAZ_CATALOG
 ];
 var catalog = BUILT_IN;
 var catalogMap = byId(BUILT_IN);
@@ -1403,7 +1509,7 @@ function expiresInHours(hours) {
 function estimateFor(provider, type, params, defaults) {
   const modelId = params.model ?? "";
   const model = getModel(modelId);
-  const video = params;
+  const video2 = params;
   const unit = model?.pricing?.unit ?? (type === "video" ? "second" : type === "audio" ? "character" : type === "text" ? "token" : "image");
   let units = 1;
   if (unit === "character") {
@@ -1411,7 +1517,7 @@ function estimateFor(provider, type, params, defaults) {
   } else if (unit === "token") {
     units = 0;
   } else if (unit === "second") {
-    units = video.duration ?? defaults?.durationSeconds ?? model?.minDuration ?? 5;
+    units = video2.duration ?? defaults?.durationSeconds ?? model?.minDuration ?? 5;
   }
   const resolution = params.resolution;
   const rate = (resolution ? model?.pricing?.byResolution?.[resolution] : void 0) ?? model?.pricing?.usdPerUnit;
@@ -1667,23 +1773,23 @@ var BrotuAdapter = class {
     }
     try {
       const workspaceId = await this.workspaceId();
-      const video = params;
-      const image = params;
+      const video2 = params;
+      const image2 = params;
       const payload = await this.request(
         this.studioPath("/api/v1/studio/estimate", workspaceId),
         {
           method: "POST",
           body: JSON.stringify({
             model: this.platformModel(params.model ?? ""),
-            duration: video.duration,
-            resolution: video.resolution ?? image.resolution,
-            aspectRatio: video.aspectRatio ?? image.aspectRatio,
-            withAudio: video.withAudio,
+            duration: video2.duration,
+            resolution: video2.resolution ?? image2.resolution,
+            aspectRatio: video2.aspectRatio ?? image2.aspectRatio,
+            withAudio: video2.withAudio,
             hasReferenceImage: Boolean(
-              video.imageUrl || video.imageUrls?.length || video.referenceImages?.length || image.referenceImages?.length
+              video2.imageUrl || video2.imageUrls?.length || video2.referenceImages?.length || image2.referenceImages?.length
             ),
-            hasReferenceVideo: Boolean(video.videoUrl || video.videoUrls?.length),
-            quality: image.quality
+            hasReferenceVideo: Boolean(video2.videoUrl || video2.videoUrls?.length),
+            quality: image2.quality
           })
         }
       );
@@ -2286,12 +2392,12 @@ var GoogleAdapter = class {
       const input = [
         { type: "text", text: params.prompt }
       ];
-      for (const image of params.referenceImages ?? []) {
-        const [meta, data] = image.split(",");
+      for (const image2 of params.referenceImages ?? []) {
+        const [meta, data] = image2.split(",");
         input.push({
           type: "image",
           mime_type: meta?.match(/data:([^;]+)/)?.[1] ?? "image/png",
-          data: data ?? image
+          data: data ?? image2
         });
       }
       const payload = await this.request(
@@ -2383,10 +2489,10 @@ var GoogleAdapter = class {
     };
     const first = params.imageUrl ?? params.referenceImages?.[0];
     if (first) attach("image", first);
-    for (const image of params.imageUrls ?? []) attach("image", image);
-    const video = params.videoUrl ?? params.videoUrls?.[0];
-    if (video) attach("video", video);
-    const task = video ? "edit" : params.imageUrls?.length ? "reference_to_video" : first ? "image_to_video" : "text_to_video";
+    for (const image2 of params.imageUrls ?? []) attach("image", image2);
+    const video2 = params.videoUrl ?? params.videoUrls?.[0];
+    if (video2) attach("video", video2);
+    const task = video2 ? "edit" : params.imageUrls?.length ? "reference_to_video" : first ? "image_to_video" : "text_to_video";
     return {
       model: modelId,
       input,
@@ -2555,12 +2661,12 @@ var GoogleAdapter = class {
     const input = [
       { type: "text", text: params.prompt }
     ];
-    for (const image of params.referenceImages ?? []) {
-      const [meta, data] = image.split(",");
+    for (const image2 of params.referenceImages ?? []) {
+      const [meta, data] = image2.split(",");
       input.push({
         type: "image",
         mime_type: meta?.match(/data:([^;]+)/)?.[1] ?? "image/png",
-        data: data ?? image
+        data: data ?? image2
       });
     }
     return {
@@ -3370,11 +3476,11 @@ var QwenAdapter = class {
       case "media": {
         const media = [];
         if (binding.mode === "video-edit") {
-          const video = params.videoUrl ?? params.videoUrls?.[0];
-          if (!video) {
+          const video2 = params.videoUrl ?? params.videoUrls?.[0];
+          if (!video2) {
             throw new Error(`Qwen "${modelId}" needs a video \u2014 pass videoUrl.`);
           }
-          media.push({ type: "video", url: video });
+          media.push({ type: "video", url: video2 });
         } else if (binding.mode === "r2v") {
           for (const url of references) {
             media.push({ type: "reference_image", url });
@@ -3414,7 +3520,7 @@ var QwenAdapter = class {
       ...output.video_url ? [output.video_url] : [],
       ...(output.results ?? []).map((result) => result.url).filter((url) => Boolean(url)),
       ...(output.choices ?? []).flatMap(
-        (choice) => (choice.message?.content ?? []).map((part) => part.image).filter((image) => Boolean(image))
+        (choice) => (choice.message?.content ?? []).map((part) => part.image).filter((image2) => Boolean(image2))
       )
     ];
     return urls.map((url) => ({
@@ -3562,8 +3668,8 @@ var QwenAdapter = class {
     }
     try {
       const content = [];
-      for (const image of params.referenceImages ?? []) {
-        content.push({ image });
+      for (const image2 of params.referenceImages ?? []) {
+        content.push({ image: image2 });
       }
       content.push({ text: params.prompt });
       const parameters = {
@@ -3756,6 +3862,475 @@ var QwenAdapter = class {
   }
 };
 
+// src/adapters/topaz.adapter.ts
+var DEFAULT_BASE_URL7 = "https://api.topazlabs.com";
+var POLL_INTERVAL_MS6 = 5e3;
+var DEFAULT_MAX_POLL_ATTEMPTS6 = 240;
+var DEFAULT_FPS = 30;
+var PIXELS2 = {
+  "720p": { width: 1280, height: 720 },
+  "720P": { width: 1280, height: 720 },
+  "1080p": { width: 1920, height: 1080 },
+  "1080P": { width: 1920, height: 1080 },
+  "4k": { width: 3840, height: 2160 },
+  "4K": { width: 3840, height: 2160 },
+  "1K": { width: 1024, height: 1024 },
+  "2K": { width: 2048, height: 2048 }
+};
+var TopazAdapter = class {
+  providerName = "topaz";
+  supportedTypes = ["video", "image"];
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  get baseUrl() {
+    return (this.opts.baseUrl ?? DEFAULT_BASE_URL7).replace(/\/$/, "");
+  }
+  get headers() {
+    return {
+      "X-API-Key": this.opts.apiKey,
+      accept: "application/json",
+      "Content-Type": "application/json"
+    };
+  }
+  binding(modelId) {
+    const id = modelId ?? "";
+    const found = TOPAZ_MODELS[id];
+    if (!found) {
+      throw new Error(
+        `"${id}" is not a Topaz model. Known: ${TOPAZ_CATALOG.map((model) => model.id).join(", ")}.`
+      );
+    }
+    return [id, found];
+  }
+  /** 720p / 1080p / 4k, or an explicit "1920x1080" / "1920*1080" pair. */
+  resolutionOf(resolution) {
+    if (!resolution) return PIXELS2["1080p"];
+    const named = PIXELS2[resolution];
+    if (named) return named;
+    const match = /^(\d{2,5})[x*](\d{2,5})$/i.exec(resolution.trim());
+    if (match?.[1] && match[2]) {
+      return { width: Number(match[1]), height: Number(match[2]) };
+    }
+    throw new Error(
+      `Topaz wants 720p, 1080p, 4k or WxH, not "${resolution}".`
+    );
+  }
+  containerOf(url) {
+    const path = url.split("?")[0]?.toLowerCase() ?? "";
+    if (path.endsWith(".mov")) return "mov";
+    if (path.endsWith(".mkv")) return "mkv";
+    return "mp4";
+  }
+  filterOf(binding, params) {
+    const extras = params.providerOptions?.topaz ?? {};
+    if (binding.kind === "upscale") {
+      return { auto: "Auto", ...extras, model: binding.vendorModel };
+    }
+    const slowmo = numberish(extras.slowmo) ?? 1;
+    const fps = numberish(extras.fps) ?? DEFAULT_FPS;
+    if (slowmo < 1 || slowmo > 16) {
+      throw new Error(`Topaz interpolation slowmo is 1\u201316, not ${slowmo}.`);
+    }
+    if (fps < 15 || fps > 240) {
+      throw new Error(`Topaz interpolation fps is 15\u2013240, not ${fps}.`);
+    }
+    const filter = {
+      model: binding.vendorModel,
+      slowmo,
+      fps
+    };
+    if (typeof extras.duplicate === "boolean") {
+      filter.duplicate = extras.duplicate;
+    }
+    if (extras.duplicateThreshold !== void 0) {
+      filter.duplicateThreshold = extras.duplicateThreshold;
+    }
+    return filter;
+  }
+  requestBody(binding, params, sourceUrl) {
+    const extras = params.providerOptions?.topaz ?? {};
+    const fps = numberish(extras.fps) ?? DEFAULT_FPS;
+    return {
+      source: { container: this.containerOf(sourceUrl) },
+      filters: [this.filterOf(binding, params)],
+      output: {
+        resolution: this.resolutionOf(params.resolution),
+        frameRate: fps,
+        audioCodec: "AAC",
+        audioTransfer: "Copy",
+        dynamicCompressionLevel: "High",
+        container: "mp4"
+      }
+    };
+  }
+  async request(path, init) {
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      method: init?.method ?? "GET",
+      headers: this.headers,
+      body: init?.body !== void 0 ? JSON.stringify(init.body) : void 0
+    });
+    const payload = await response.json();
+    if (!response.ok) {
+      throw new Error(
+        payload.message ?? `Topaz returned ${response.status} for ${path}.`
+      );
+    }
+    return payload;
+  }
+  async downloadSource(url) {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Could not download the source video (${response.status}).`);
+    }
+    return {
+      bytes: await response.arrayBuffer(),
+      contentType: response.headers.get("content-type") ?? "video/mp4"
+    };
+  }
+  async submitTask(params) {
+    const [, binding] = this.binding(params.model);
+    if (binding.surface !== "video") {
+      throw new Error(
+        `Topaz "${params.model}" is an image model. Use ai.image.`
+      );
+    }
+    const sourceUrl = params.videoUrl ?? params.videoUrls?.[0];
+    if (!sourceUrl) {
+      throw new Error(
+        `Topaz "${params.model}" needs a source video \u2014 pass videoUrl.`
+      );
+    }
+    const source = await this.downloadSource(sourceUrl);
+    const created = await this.request("/video/express", {
+      method: "POST",
+      body: this.requestBody(binding, params, sourceUrl)
+    });
+    const taskId = created.requestId?.trim();
+    const uploadUrl = created.uploadUrls?.[0];
+    if (!taskId || !uploadUrl) {
+      throw new Error(
+        "Topaz accepted the request but returned no request id or upload URL."
+      );
+    }
+    const uploaded = await fetch(uploadUrl, {
+      method: "PUT",
+      headers: { "Content-Type": source.contentType },
+      body: source.bytes
+    });
+    if (!uploaded.ok) {
+      throw new Error(`Topaz upload failed (${uploaded.status}).`);
+    }
+    return { taskId, pollEndpoint: `/video/${taskId}/status` };
+  }
+  outputsFrom(payload, job) {
+    const url = payload.download?.url;
+    if (!url) return [];
+    const expiresAtMs = payload.download?.expiresAt;
+    return [
+      {
+        url,
+        mimeType: "video/mp4",
+        taskId: job.id,
+        expiresAt: expiresAtMs ? new Date(expiresAtMs).toISOString() : expiresInHours(24),
+        raw: {
+          status: payload.status,
+          progress: payload.progress,
+          estimates: payload.estimates,
+          outputSize: payload.outputSize
+        }
+      }
+    ];
+  }
+  snapshot(payload, job) {
+    const raw = (payload.status ?? "").toLowerCase();
+    if (raw === "failed" || raw === "canceled") {
+      return {
+        status: "failed",
+        error: payload.message ?? `Topaz request ${raw}.`
+      };
+    }
+    if (raw !== "complete") return { status: "pending" };
+    const outputs = this.outputsFrom(payload, job);
+    if (outputs.length === 0) return { status: "pending" };
+    return {
+      status: "succeeded",
+      result: {
+        success: true,
+        outputs,
+        creditsUsed: 0,
+        provider: this.providerName,
+        model: job.model,
+        processingTimeMs: 0
+      }
+    };
+  }
+  async run(params) {
+    const startedAt = Date.now();
+    let modelId = params.model ?? "(none)";
+    const failure = (error) => ({
+      success: false,
+      outputs: [],
+      creditsUsed: 0,
+      provider: this.providerName,
+      model: modelId,
+      processingTimeMs: Date.now() - startedAt,
+      error
+    });
+    let submitted;
+    try {
+      modelId = this.binding(params.model)[0];
+      submitted = await this.submitTask(params);
+    } catch (error) {
+      if (isPendingJob(error)) throw error;
+      return failure(error instanceof Error ? error.message : String(error));
+    }
+    if (isSubmitMode()) {
+      throw new PendingJob(submitted.taskId, submitted.pollEndpoint);
+    }
+    const job = {
+      id: submitted.taskId,
+      provider: this.providerName,
+      model: modelId,
+      kind: "video",
+      pollEndpoint: submitted.pollEndpoint,
+      params,
+      submittedAt: new Date(startedAt).toISOString()
+    };
+    const maxAttempts = this.opts.maxPollAttempts ?? DEFAULT_MAX_POLL_ATTEMPTS6;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const snapshot = await this.completeJob(job);
+      if (snapshot.status === "failed") {
+        return failure(snapshot.error ?? "Topaz request failed.");
+      }
+      if (snapshot.status === "succeeded" && snapshot.result) {
+        return { ...snapshot.result, processingTimeMs: Date.now() - startedAt };
+      }
+      await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS6));
+    }
+    return failure(
+      `Topaz request ${submitted.taskId} did not finish after ${maxAttempts} checks.`
+    );
+  }
+  async completeJob(job) {
+    try {
+      if (job.pollEndpoint?.startsWith("/image/")) {
+        return this.imageSnapshot(job);
+      }
+      const payload = await this.request(
+        job.pollEndpoint ?? `/video/${job.id}/status`
+      );
+      return this.snapshot(payload, job);
+    } catch (error) {
+      return {
+        status: "failed",
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  generateVideo(params) {
+    return this.run(params);
+  }
+  imageBody(binding, params, sourceUrl) {
+    const extras = params.providerOptions?.topaz ?? {};
+    const pixels = params.resolution ? this.resolutionOf(params.resolution) : void 0;
+    const fields = {
+      source_url: sourceUrl,
+      model: binding.vendorModel,
+      output_format: params.outputFormat === "png" ? "png" : params.outputFormat === "jpeg" ? "jpeg" : "jpeg"
+    };
+    if (pixels) {
+      fields.output_width = String(pixels.width);
+      fields.output_height = String(pixels.height);
+    }
+    for (const [key, value] of Object.entries(extras)) {
+      if (value === void 0) continue;
+      fields[key] = typeof value === "string" ? value : String(value);
+    }
+    return fields;
+  }
+  async submitImage(params) {
+    const [, binding] = this.binding(params.model);
+    if (binding.surface !== "image" || !binding.imagePath) {
+      throw new Error(
+        `Topaz "${params.model}" is a video model. Use ai.video with videoUrl.`
+      );
+    }
+    const sourceUrl = params.referenceImages?.[0];
+    if (!sourceUrl) {
+      throw new Error(
+        `Topaz "${params.model}" needs a source image \u2014 pass referenceImages.`
+      );
+    }
+    const form = new FormData();
+    for (const [key, value] of Object.entries(
+      this.imageBody(binding, params, sourceUrl)
+    )) {
+      form.set(key, value);
+    }
+    const response = await fetch(`${this.baseUrl}${binding.imagePath}`, {
+      method: "POST",
+      headers: {
+        "X-API-Key": this.opts.apiKey,
+        accept: "application/json"
+      },
+      body: form
+    });
+    const payload = await response.json();
+    if (!response.ok) {
+      throw new Error(
+        payload.message ?? `Topaz returned ${response.status} enhancing the image.`
+      );
+    }
+    const taskId = payload.process_id?.trim();
+    if (!taskId) {
+      throw new Error(
+        "Topaz accepted the image but returned no process id."
+      );
+    }
+    return { taskId, pollEndpoint: `/image/v1/status/${taskId}` };
+  }
+  async imageSnapshot(job) {
+    const payload = await this.request(
+      job.pollEndpoint ?? `/image/v1/status/${job.id}`
+    );
+    const raw = (payload.status ?? "").toLowerCase();
+    if (raw === "failed" || raw === "cancelled") {
+      return {
+        status: "failed",
+        error: `Topaz image ${raw}.`
+      };
+    }
+    if (raw !== "completed") return { status: "pending" };
+    let url = payload.download_url;
+    let expiresAt = payload.eta ? new Date(payload.eta > 1e10 ? payload.eta : payload.eta * 1e3).toISOString() : void 0;
+    if (!url) {
+      const download = await this.request(
+        `/image/v1/download/${job.id}`
+      );
+      url = download.download_url;
+      if (download.expiry) {
+        expiresAt = new Date(
+          download.expiry > 1e10 ? download.expiry : download.expiry * 1e3
+        ).toISOString();
+      }
+    }
+    if (!url) return { status: "pending" };
+    return {
+      status: "succeeded",
+      result: {
+        success: true,
+        outputs: [
+          {
+            url,
+            mimeType: "image/jpeg",
+            taskId: job.id,
+            expiresAt: expiresAt ?? expiresInHours(1),
+            raw: {
+              status: payload.status,
+              progress: payload.progress,
+              model: payload.model
+            }
+          }
+        ],
+        creditsUsed: payload.credits ?? 0,
+        provider: this.providerName,
+        model: job.model,
+        processingTimeMs: 0
+      }
+    };
+  }
+  async runImage(params) {
+    const startedAt = Date.now();
+    let modelId = params.model ?? "(none)";
+    const failure = (error) => ({
+      success: false,
+      outputs: [],
+      creditsUsed: 0,
+      provider: this.providerName,
+      model: modelId,
+      processingTimeMs: Date.now() - startedAt,
+      error
+    });
+    let submitted;
+    try {
+      modelId = this.binding(params.model)[0];
+      submitted = await this.submitImage(params);
+    } catch (error) {
+      if (isPendingJob(error)) throw error;
+      return failure(error instanceof Error ? error.message : String(error));
+    }
+    if (isSubmitMode()) {
+      throw new PendingJob(submitted.taskId, submitted.pollEndpoint);
+    }
+    const job = {
+      id: submitted.taskId,
+      provider: this.providerName,
+      model: modelId,
+      kind: "image",
+      pollEndpoint: submitted.pollEndpoint,
+      params,
+      submittedAt: new Date(startedAt).toISOString()
+    };
+    const maxAttempts = this.opts.maxPollAttempts ?? DEFAULT_MAX_POLL_ATTEMPTS6;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const snapshot = await this.completeJob(job);
+      if (snapshot.status === "failed") {
+        return failure(snapshot.error ?? "Topaz image failed.");
+      }
+      if (snapshot.status === "succeeded" && snapshot.result) {
+        return { ...snapshot.result, processingTimeMs: Date.now() - startedAt };
+      }
+      await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS6));
+    }
+    return failure(
+      `Topaz image ${submitted.taskId} did not finish after ${maxAttempts} checks.`
+    );
+  }
+  generateImage(params) {
+    return this.runImage(params);
+  }
+  generateText(params) {
+    return Promise.resolve(unsupported(this.providerName, params.model, "text"));
+  }
+  generateAudio(params) {
+    return Promise.resolve(unsupported(this.providerName, params.model, "audio"));
+  }
+  estimateCost(type, params) {
+    return Promise.resolve(estimateFor(this.providerName, type, params));
+  }
+  supportsModel(model) {
+    return model in TOPAZ_MODELS;
+  }
+  getAvailableModels() {
+    return TOPAZ_CATALOG.map((model) => ({
+      id: model.id,
+      name: model.name,
+      type: model.category
+    }));
+  }
+};
+function numberish(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.length > 0) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : void 0;
+  }
+  return void 0;
+}
+function unsupported(provider, model, kind) {
+  return {
+    success: false,
+    outputs: [],
+    creditsUsed: 0,
+    provider,
+    model: model ?? "",
+    processingTimeMs: 0,
+    error: `Topaz does not generate ${kind} on this adapter.`
+  };
+}
+
 // src/helpers/result.ts
 function ok(data) {
   return { data, error: null };
@@ -3956,7 +4531,8 @@ var NATIVE_PROVIDERS = [
   "google",
   "kling",
   "openai",
-  "qwen"
+  "qwen",
+  "topaz"
 ];
 function brotu(options) {
   const apiKey = options.apiKey?.trim();
@@ -4055,6 +4631,12 @@ function brotu(options) {
         baseUrl: provider.baseUrl
       });
     }
+    if (provider.id === "topaz") {
+      return new TopazAdapter({
+        apiKey: provider.apiKey,
+        baseUrl: provider.baseUrl
+      });
+    }
     return void 0;
   }
   function generateWith(adapter, kind, params) {
@@ -4373,12 +4955,67 @@ function brotu(options) {
     image: {
       submit: (params) => submit("image", params),
       generate: (params) => generate("image", params),
-      list: () => listFor("image")
+      list: () => listFor("image"),
+      upscale: (params) => {
+        if (!params.imageUrl?.trim()) {
+          return Promise.resolve(
+            fail({
+              code: "invalid_request",
+              message: "image.upscale needs imageUrl.",
+              model: params.model
+            })
+          );
+        }
+        const model = getModel(params.model);
+        if (model && !model.nodeTypes.includes("image_upscale")) {
+          return Promise.resolve(
+            fail({
+              code: "invalid_request",
+              message: `"${params.model}" is not an image upscale model.`,
+              model: params.model
+            })
+          );
+        }
+        return generate("image", {
+          ...params,
+          prompt: params.prompt ?? "",
+          referenceImages: [
+            params.imageUrl,
+            ...params.referenceImages ?? []
+          ]
+        });
+      }
     },
     video: {
       submit: (params) => submit("video", params),
       generate: (params) => generate("video", params),
-      list: () => listFor("video")
+      list: () => listFor("video"),
+      upscale: (params) => {
+        if (!params.videoUrl?.trim()) {
+          return Promise.resolve(
+            fail({
+              code: "invalid_request",
+              message: "video.upscale needs videoUrl.",
+              model: params.model
+            })
+          );
+        }
+        const model = getModel(params.model);
+        if (model && !model.nodeTypes.includes("video_upscale")) {
+          return Promise.resolve(
+            fail({
+              code: "invalid_request",
+              message: `"${params.model}" is not a video upscale model. Interpolation models use ai.video.submit.`,
+              model: params.model
+            })
+          );
+        }
+        return submit("video", {
+          ...params,
+          prompt: params.prompt ?? "",
+          videoUrl: params.videoUrl
+        });
+      }
     },
     text: {
       submit: (params) => submit("text", params),
@@ -4487,6 +5124,11 @@ function brotu(options) {
   QWEN_TEXT_MODELS,
   QWEN_VIDEO_MODELS,
   QwenAdapter,
+  TOPAZ_CATALOG,
+  TOPAZ_IMAGE_MODELS,
+  TOPAZ_MODELS,
+  TOPAZ_VIDEO_MODELS,
+  TopazAdapter,
   brotu,
   createS3Storage,
   deliverWebhook,