@brotu/ai 0.4.0 → 0.6.0

package/dist/index.js

@@ -1,4 +1,5 @@
 import {
+  BROTU_SUPPORTED_CATEGORIES,
   BYTEPLUS_CATALOG,
   BYTEPLUS_IMAGE_MODELS,
   BYTEPLUS_MODELS,
@@ -26,6 +27,11 @@ import {
   QWEN_IMAGE_PATHS,
   QWEN_TEXT_MODELS,
   QWEN_VIDEO_MODELS,
+  TOPAZ_CATALOG,
+  TOPAZ_IMAGE_MODELS,
+  TOPAZ_MODELS,
+  TOPAZ_VIDEO_MODELS,
+  describeModels,
   fieldsFor,
   getAvailableModels,
   getModel,
@@ -36,7 +42,7 @@ import {
   resetCatalog,
   resolveProvider,
   videoPathFor
-} from "./chunk-QOWHHKSI.js";
+} from "./chunk-QQIHMDJC.js";
 
 // src/lib/jobs.ts
 import { AsyncLocalStorage } from "async_hooks";
@@ -111,7 +117,7 @@ var BrotuAdapter = class {
   }
   opts;
   providerName = "brotu";
-  supportedTypes = ["image", "video"];
+  supportedTypes = BROTU_SUPPORTED_CATEGORIES;
   workspaceIdCache;
   get origin() {
     return (this.opts.apiUrl ?? DEFAULT_API_URL).replace(/\/$/, "");
@@ -2423,6 +2429,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 PIXELS = {
+  "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 PIXELS["1080p"];
+    const named = PIXELS[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 };
@@ -2439,6 +2914,22 @@ function failFrom(code, cause, context) {
   });
 }
 
+// src/lib/hooks.ts
+function hookName(kind, stage) {
+  return `on${kind[0].toUpperCase()}${kind.slice(1)}${stage}`;
+}
+function findHook(hooks, kind, stage) {
+  if (!hooks || !kind) return void 0;
+  return hooks[hookName(kind, stage)];
+}
+async function runHook(hook, event) {
+  if (!hook) return;
+  try {
+    await hook(event);
+  } catch {
+  }
+}
+
 // src/lib/storage.ts
 async function loadS3(config) {
   let s3;
@@ -2607,9 +3098,10 @@ var NATIVE_PROVIDERS = [
   "google",
   "kling",
   "openai",
-  "qwen"
+  "qwen",
+  "topaz"
 ];
-function brotuClient(options) {
+function brotu(options) {
   const apiKey = options.apiKey?.trim();
   if (!apiKey) {
     throw new Error(
@@ -2706,6 +3198,12 @@ function brotuClient(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) {
@@ -2722,7 +3220,10 @@ function brotuClient(options) {
   }
   async function notifySettled(input) {
     const config = webhookFor(input.params);
-    if (!config) return;
+    const kind = input.kind ?? input.job?.kind;
+    const stage = input.event === "generation.succeeded" ? "Success" : "Error";
+    const hook = findHook(options.hooks, kind, stage);
+    if (!config && !hook) return;
     const jobId = input.job?.id;
     if (jobId) {
       if (notifiedJobIds.has(jobId)) return;
@@ -2733,14 +3234,38 @@ function brotuClient(options) {
       jobId,
       provider: input.provider ?? input.job?.provider,
       model: input.model ?? input.job?.model,
-      kind: input.kind ?? input.job?.kind,
+      kind,
       outputs: input.outputs,
       error: input.error ? { code: input.error.code, message: input.error.message } : void 0,
       metadata: input.metadata ?? input.job?.metadata,
       processingTimeMs: input.processingTimeMs,
       completedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    await deliverWebhook(config, payload);
+    if (hook && kind) {
+      await runHook(hook, {
+        kind,
+        stage,
+        provider: payload.provider ?? "",
+        model: payload.model ?? "",
+        jobId: payload.jobId,
+        outputs: payload.outputs,
+        error: payload.error,
+        metadata: payload.metadata,
+        processingTimeMs: payload.processingTimeMs,
+        at: payload.completedAt
+      });
+    }
+    if (config) await deliverWebhook(config, payload);
+  }
+  function notifyLoading(kind, routed, params) {
+    return runHook(findHook(options.hooks, kind, "Loading"), {
+      kind,
+      stage: "Loading",
+      provider: routed.provider,
+      model: routed.model,
+      metadata: params.metadata,
+      at: (/* @__PURE__ */ new Date()).toISOString()
+    });
   }
   async function toGeneration(raw, metadata) {
     if (!raw.success) {
@@ -2763,6 +3288,7 @@ function brotuClient(options) {
   async function generate(kind, params) {
     const routed = route(params.model);
     if (routed.error) return fail(routed.error);
+    await notifyLoading(kind, routed.data, params);
     try {
       const result = await toGeneration(
         await generateWith(routed.data.adapter, kind, params),
@@ -2813,6 +3339,7 @@ function brotuClient(options) {
   async function submit(kind, params) {
     const routed = route(params.model);
     if (routed.error) return fail(routed.error);
+    await notifyLoading(kind, routed.data, params);
     const base = {
       provider: routed.data.provider,
       model: routed.data.model,
@@ -2984,24 +3511,88 @@ function brotuClient(options) {
       }
     };
   }
+  function listFor(category) {
+    return describeModels(optionsWithKey).filter(
+      (entry) => entry.model.category === category
+    );
+  }
   return {
     google: googleNamespace(),
     kling: klingNamespace(),
     image: {
       submit: (params) => submit("image", params),
-      generate: (params) => generate("image", params)
+      generate: (params) => generate("image", params),
+      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)
+      generate: (params) => generate("video", params),
+      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),
-      generate: (params) => generate("text", params)
+      generate: (params) => generate("text", params),
+      list: () => listFor("text")
     },
     audio: {
       submit: (params) => submit("audio", params),
-      generate: (params) => generate("audio", params)
+      generate: (params) => generate("audio", params),
+      list: () => listFor("audio")
     },
     webhook: {
       set(value) {
@@ -3067,6 +3658,7 @@ function brotuClient(options) {
   };
 }
 export {
+  BROTU_SUPPORTED_CATEGORIES,
   BYTEPLUS_CATALOG,
   BYTEPLUS_MODELS,
   BrotuAdapter,
@@ -3098,9 +3690,15 @@ export {
   QWEN_TEXT_MODELS,
   QWEN_VIDEO_MODELS,
   QwenAdapter,
-  brotuClient,
+  TOPAZ_CATALOG,
+  TOPAZ_IMAGE_MODELS,
+  TOPAZ_MODELS,
+  TOPAZ_VIDEO_MODELS,
+  TopazAdapter,
+  brotu,
   createS3Storage,
   deliverWebhook,
+  describeModels,
   fail,
   getAvailableModels,
   getModel,