@brotu/ai 0.1.0

package/dist/index.cjs

@@ -0,0 +1,3568 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BYTEPLUS_CATALOG: () => BYTEPLUS_CATALOG,
+  BYTEPLUS_MODELS: () => BYTEPLUS_MODELS,
+  BytePlusAdapter: () => BytePlusAdapter,
+  ELEVENLABS_CATALOG: () => ELEVENLABS_CATALOG,
+  ELEVENLABS_MODELS: () => ELEVENLABS_MODELS,
+  ELEVENLABS_OUTPUT_FORMATS: () => ELEVENLABS_OUTPUT_FORMATS,
+  ElevenLabsAdapter: () => ElevenLabsAdapter,
+  GOOGLE_CATALOG: () => GOOGLE_CATALOG,
+  GOOGLE_IMAGE_MODELS: () => GOOGLE_IMAGE_MODELS,
+  GOOGLE_VIDEO_MODELS: () => GOOGLE_VIDEO_MODELS,
+  GoogleAdapter: () => GoogleAdapter,
+  KLING_CAPABILITIES: () => KLING_CAPABILITIES,
+  KLING_CATALOG: () => KLING_CATALOG,
+  KLING_MODELS: () => KLING_MODELS,
+  KlingAdapter: () => KlingAdapter,
+  OPENAI_CATALOG: () => OPENAI_CATALOG,
+  OPENAI_IMAGE_MODELS: () => OPENAI_IMAGE_MODELS,
+  OpenAIAdapter: () => OpenAIAdapter,
+  PendingJob: () => PendingJob,
+  QWEN_AUDIO_MODELS: () => QWEN_AUDIO_MODELS,
+  QWEN_CATALOG: () => QWEN_CATALOG,
+  QWEN_IMAGE_MODELS: () => QWEN_IMAGE_MODELS,
+  QWEN_TEXT_MODELS: () => QWEN_TEXT_MODELS,
+  QWEN_VIDEO_MODELS: () => QWEN_VIDEO_MODELS,
+  QwenAdapter: () => QwenAdapter,
+  brotuClient: () => brotuClient,
+  createS3Storage: () => createS3Storage,
+  fail: () => fail,
+  getAvailableModels: () => getAvailableModels,
+  getModel: () => getModel,
+  getModels: () => getModels,
+  getProviders: () => getProviders,
+  hasModel: () => hasModel,
+  isPendingJob: () => isPendingJob,
+  ok: () => ok,
+  persistOutputs: () => persistOutputs,
+  registerModels: () => registerModels,
+  resetCatalog: () => resetCatalog,
+  resolveProvider: () => resolveProvider
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/lib/jobs.ts
+var import_node_async_hooks = require("async_hooks");
+var PendingJob = class extends Error {
+  taskId;
+  pollEndpoint;
+  constructor(taskId, pollEndpoint) {
+    super(`Job ${taskId} was submitted and is still running.`);
+    this.name = "PendingJob";
+    this.taskId = taskId;
+    this.pollEndpoint = pollEndpoint;
+  }
+};
+function isPendingJob(error) {
+  return error instanceof PendingJob;
+}
+var submitMode = new import_node_async_hooks.AsyncLocalStorage();
+function runInSubmitMode(fn) {
+  return submitMode.run(true, fn);
+}
+function isSubmitMode() {
+  return submitMode.getStore() === true;
+}
+
+// src/ports/content-generator.port.ts
+function expiresInHours(hours) {
+  return new Date(Date.now() + hours * 36e5).toISOString();
+}
+
+// src/providers/byteplus.models.ts
+var FPS = 24;
+var PIXELS = {
+  "480p": [854, 480],
+  "720p": [1280, 720],
+  "1080p": [1920, 1080],
+  "4k": [3840, 2160]
+};
+function usdPerSecond(usdPerMillionTokens) {
+  const out = {};
+  for (const [resolution, rate] of Object.entries(usdPerMillionTokens)) {
+    const [w, h] = PIXELS[resolution] ?? [0, 0];
+    const tokensPerSecond = w * h * FPS / 1024;
+    out[resolution] = Number((tokensPerSecond * rate / 1e6).toFixed(4));
+  }
+  return out;
+}
+var TOKEN_RATES = {
+  "dreamina-seedance-2-5-260628": { "480p": 10.7, "720p": 10.7, "1080p": 11.7 },
+  "dreamina-seedance-2-0-260128": {
+    "480p": 7,
+    "720p": 7,
+    "1080p": 7.7,
+    "4k": 4
+  },
+  "dreamina-seedance-2-0-fast-260128": { "480p": 5.6, "720p": 5.6 },
+  "dreamina-seedance-2-0-mini-260615": { "480p": 3.5, "720p": 3.5 }
+};
+var IMAGE_USD = {
+  "dola-seedream-5-0-pro-260628": 0.045,
+  "seedream-5-0-260128": 0.035,
+  "seedream-4-5-251128": 0.04,
+  "seedream-4-0-250828": 0.03,
+  "seedream-4-0-20260415": 0.03,
+  "seededit-3-0-i2i-250628": 0.03
+};
+var RATIOS = ["16:9", "4:3", "1:1", "3:4", "9:16", "21:9"];
+var BYTEPLUS_MODELS = {
+  "seedance-1-0-lite-t2v-250428": {
+    family: "1.0",
+    textToVideo: true,
+    imageToVideo: false,
+    lastFrame: false,
+    referenceImages: 0,
+    referenceMedia: false,
+    durations: { min: 2, max: 12 },
+    resolutions: ["480p", "720p", "1080p"],
+    defaultResolution: "720p"
+  },
+  "seedance-1-0-lite-i2v-250428": {
+    family: "1.0",
+    textToVideo: false,
+    imageToVideo: true,
+    lastFrame: true,
+    referenceImages: 4,
+    referenceMedia: false,
+    durations: { min: 2, max: 12 },
+    resolutions: ["480p", "720p", "1080p"],
+    defaultResolution: "720p"
+  },
+  "seedance-1-0-pro-250528": {
+    family: "1.0",
+    textToVideo: true,
+    imageToVideo: true,
+    lastFrame: true,
+    referenceImages: 0,
+    referenceMedia: false,
+    durations: { min: 2, max: 12 },
+    resolutions: ["480p", "720p", "1080p"],
+    defaultResolution: "1080p"
+  },
+  // Verified in the docs: this one alone drops last-frame support.
+  "seedance-1-0-pro-fast-251015": {
+    family: "1.0",
+    textToVideo: true,
+    imageToVideo: true,
+    lastFrame: false,
+    referenceImages: 0,
+    referenceMedia: false,
+    durations: { min: 2, max: 12 },
+    resolutions: ["480p", "720p", "1080p"],
+    defaultResolution: "1080p"
+  },
+  "seedance-1-5-pro-251215": {
+    family: "1.5",
+    textToVideo: true,
+    imageToVideo: true,
+    lastFrame: true,
+    referenceImages: 0,
+    referenceMedia: false,
+    durations: { min: 4, max: 12 },
+    resolutions: ["480p", "720p", "1080p"],
+    defaultResolution: "720p"
+  },
+  "dreamina-seedance-2-0-260128": {
+    family: "2.x",
+    textToVideo: true,
+    imageToVideo: true,
+    lastFrame: true,
+    referenceImages: 9,
+    referenceMedia: true,
+    durations: { min: 4, max: 15 },
+    // The only Seedance model with a 4k tier. It is 10-bit HEVC, so a browser
+    // may refuse to play it inline.
+    resolutions: ["480p", "720p", "1080p", "4k"],
+    defaultResolution: "720p"
+  },
+  "dreamina-seedance-2-0-fast-260128": {
+    family: "2.x",
+    textToVideo: true,
+    imageToVideo: true,
+    lastFrame: true,
+    referenceImages: 9,
+    referenceMedia: true,
+    durations: { min: 4, max: 15 },
+    resolutions: ["480p", "720p"],
+    defaultResolution: "720p"
+  },
+  "dreamina-seedance-2-0-mini-260615": {
+    family: "2.x",
+    textToVideo: true,
+    imageToVideo: true,
+    lastFrame: true,
+    referenceImages: 9,
+    referenceMedia: true,
+    durations: { min: 4, max: 15 },
+    resolutions: ["480p", "720p"],
+    defaultResolution: "720p"
+  },
+  "dreamina-seedance-2-5-260628": {
+    family: "2.x",
+    textToVideo: true,
+    imageToVideo: true,
+    lastFrame: true,
+    referenceImages: 30,
+    referenceMedia: true,
+    durations: { min: 4, max: 30 },
+    resolutions: ["480p", "720p"],
+    defaultResolution: "720p"
+  }
+};
+function fieldsFor(family) {
+  return {
+    seed: family !== "2.x",
+    cameraFixed: family !== "2.x",
+    generateAudio: family !== "1.0",
+    priority: family === "2.x"
+  };
+}
+var BYTEPLUS_IMAGE_MODELS = {
+  "seedream-3-0-t2i-250415": { sizes: ["1K", "2K"] },
+  "seededit-3-0-i2i-250628": { sizes: ["1K", "2K"] },
+  "seedream-4-0-250828": { sizes: ["1K", "2K", "4K"] },
+  "seedream-4-0-20260415": { sizes: ["1K", "2K", "4K"] },
+  "seedream-4-5-251128": { sizes: ["1K", "2K", "4K"] },
+  "seedream-5-0-260128": { sizes: ["1K", "2K", "4K"] },
+  "dola-seedream-5-0-pro-260628": { sizes: ["1K", "2K", "4K"] }
+};
+var BYTEPLUS_IMAGE_CATALOG = Object.entries(
+  BYTEPLUS_IMAGE_MODELS
+).map(([id, spec]) => ({
+  id,
+  name: id.replace(/-\d{6,}$/, "").replace(/-/g, " "),
+  category: "image",
+  inputType: id.includes("i2i") ? "image_required" : "image_optional",
+  nodeTypes: ["image_gen"],
+  creditsPerUnit: 0,
+  creditUnit: "image",
+  supportedResolutions: spec.sizes,
+  supportedAspectRatios: RATIOS,
+  provider: "byteplus",
+  pricing: IMAGE_USD[id] ? { unit: "image", usdPerUnit: IMAGE_USD[id] } : void 0
+}));
+var BYTEPLUS_CATALOG = Object.entries(
+  BYTEPLUS_MODELS
+).map(([id, binding]) => ({
+  id,
+  name: id.replace(/-\d{6,}$/, "").replace(/^dreamina-/, "").replace(/-/g, " "),
+  category: "video",
+  inputType: binding.textToVideo ? binding.imageToVideo ? "image_optional" : "text_only" : "image_required",
+  nodeTypes: ["video_gen"],
+  // BytePlus bills your own Ark account per output token.
+  creditsPerUnit: 0,
+  creditUnit: "second",
+  minDuration: binding.durations.min,
+  maxDuration: binding.durations.max,
+  supportedResolutions: binding.resolutions,
+  supportedAspectRatios: RATIOS,
+  provider: "byteplus",
+  pricing: TOKEN_RATES[id] ? {
+    unit: "second",
+    byResolution: usdPerSecond(TOKEN_RATES[id]),
+    usdPerUnit: usdPerSecond(TOKEN_RATES[id])[binding.defaultResolution] ?? 0
+  } : void 0
+}));
+
+// src/providers/elevenlabs.models.ts
+var ELEVENLABS_MODELS = {
+  eleven_v3: {
+    maxCharacters: 5e3,
+    languages: 70,
+    note: "Most expressive; widest language coverage."
+  },
+  eleven_multilingual_v2: {
+    maxCharacters: 1e4,
+    languages: 29,
+    note: "Lifelike and consistent across languages. The API default."
+  },
+  eleven_flash_v2_5: {
+    maxCharacters: 4e4,
+    languages: 32,
+    note: "~75ms latency, for real-time and agent use."
+  }
+};
+var ELEVENLABS_OUTPUT_FORMATS = [
+  "mp3_22050_32",
+  "mp3_44100_32",
+  "mp3_44100_64",
+  "mp3_44100_96",
+  "mp3_44100_128",
+  "mp3_44100_192",
+  "pcm_16000",
+  "pcm_22050",
+  "pcm_24000",
+  "pcm_44100",
+  "ulaw_8000"
+];
+var ELEVENLABS_CATALOG = Object.entries(
+  ELEVENLABS_MODELS
+).map(([id, binding]) => ({
+  id,
+  name: id,
+  category: "audio",
+  inputType: "text_only",
+  nodeTypes: ["text"],
+  creditsPerUnit: 0,
+  creditUnit: "character",
+  provider: "elevenlabs",
+  // Billed in credits whose dollar value depends on your plan, so no verified
+  // per-character rate goes in the catalog.
+  description: `${binding.note} Up to ${binding.maxCharacters.toLocaleString()} characters, ${binding.languages} languages.`
+}));
+
+// src/providers/google.models.ts
+var GOOGLE_IMAGE_MODELS = {
+  // Google's recommended default.
+  "gemini-3.1-flash-image": { sizes: ["1K", "2K", "4K"], usdAt1K: 0.067 },
+  "gemini-3.1-flash-lite-image": {
+    // The only model that takes 512px, and note the lowercase "px" against
+    // the uppercase "K" of every other value.
+    sizes: ["512px", "1K", "2K"],
+    usdAt1K: 0.0336
+  },
+  "gemini-3-pro-image": { sizes: ["1K", "2K", "4K"], usdAt1K: 0.134 },
+  "gemini-2.5-flash-image": { sizes: ["1K", "2K"], usdAt1K: 0.039 }
+};
+var GOOGLE_VIDEO_MODELS = {
+  // Every current Veo id carries the -preview suffix; the bare name 404s.
+  "veo-3.1-generate-preview": {
+    api: "predict",
+    usdByResolution: { "720p": 0.4, "1080p": 0.4, "4k": 0.6 },
+    resolutions: ["720p", "1080p", "4k"],
+    durations: ["4", "6", "8"],
+    referenceImages: true,
+    usdPerSecond: 0.4
+  },
+  "veo-3.1-fast-generate-preview": {
+    api: "predict",
+    usdByResolution: { "720p": 0.1, "1080p": 0.12, "4k": 0.3 },
+    resolutions: ["720p", "1080p", "4k"],
+    durations: ["4", "6", "8"],
+    referenceImages: true,
+    usdPerSecond: 0.1
+  },
+  "veo-3.1-lite-generate-preview": {
+    api: "predict",
+    usdByResolution: { "720p": 0.05, "1080p": 0.08 },
+    resolutions: ["720p", "1080p"],
+    durations: ["4", "6", "8"],
+    referenceImages: false,
+    usdPerSecond: 0.05
+  },
+  /**
+   * Omni: text, image, audio and video in, video out, and results you refine by
+   * talking to them. It sits on the Interactions API rather than Veo's predict
+   * endpoint, which is why the binding carries `api`.
+   *
+   * No published rate — the pricing page lists Veo but not this, so the catalog
+   * leaves it unset rather than guessing.
+   */
+  "gemini-omni-flash-preview": {
+    api: "interactions",
+    resolutions: ["720p"],
+    durations: ["10"],
+    referenceImages: true,
+    conversationalEditing: true
+  }
+};
+var GOOGLE_CATALOG = [
+  ...Object.entries(GOOGLE_IMAGE_MODELS).map(
+    ([id, binding]) => ({
+      id,
+      name: id,
+      category: "image",
+      inputType: "image_optional",
+      nodeTypes: ["image_gen"],
+      creditsPerUnit: 0,
+      creditUnit: "image",
+      supportedResolutions: binding.sizes,
+      provider: "google",
+      pricing: { usdPerUnit: binding.usdAt1K, unit: "image" }
+    })
+  ),
+  ...Object.entries(GOOGLE_VIDEO_MODELS).map(
+    ([id, binding]) => ({
+      id,
+      name: id,
+      category: "video",
+      inputType: "image_optional",
+      nodeTypes: ["video_gen"],
+      creditsPerUnit: 0,
+      creditUnit: "second",
+      durationOptions: binding.durations.map(Number),
+      minDuration: Number(binding.durations[0]),
+      maxDuration: Number(binding.durations[binding.durations.length - 1]),
+      supportedResolutions: binding.resolutions,
+      supportedAspectRatios: ["16:9", "9:16"],
+      provider: "google",
+      pricing: binding.usdPerSecond === void 0 ? void 0 : {
+        unit: "second",
+        usdPerUnit: binding.usdPerSecond,
+        byResolution: binding.usdByResolution
+      }
+    })
+  )
+];
+
+// src/providers/kling.models.ts
+var V1_DURATIONS = [5, 10];
+var NEXT_DURATIONS = [3, 4, 5, 6, 7, 8, 10, 12, 15];
+var HD = ["720p", "1080p"];
+var UHD = ["720p", "1080p", "4k"];
+var USD_PER_SECOND = {
+  "kling/v1-5": { "720p": 0.056, "1080p": 0.098 },
+  "kling/v1-6": { "720p": 0.056, "1080p": 0.098 },
+  "kling/v2-master": { "1080p": 0.28 },
+  "kling/v2-1": { "720p": 0.056, "1080p": 0.098 },
+  "kling/v2-1-master": { "1080p": 0.28 },
+  "kling/v2-5-turbo": { "720p": 0.042, "1080p": 0.07 },
+  "kling/v2-6": { "720p": 0.042, "1080p": 0.07 },
+  "kling/v3": { "720p": 0.084, "1080p": 0.112, "4k": 0.42 },
+  "kling/v3-turbo": { "720p": 0.112, "1080p": 0.14 }
+};
+var ASPECT_RATIOS = ["16:9", "9:16", "1:1"];
+var KLING_MODELS = {
+  // ---- legacy API ----
+  "kling/v1": {
+    modelName: "kling-v1",
+    api: "v1",
+    kind: "video",
+    textToVideo: true,
+    imageToVideo: true,
+    durations: V1_DURATIONS
+  },
+  "kling/v1-5": {
+    modelName: "kling-v1-5",
+    api: "v1",
+    kind: "video",
+    textToVideo: true,
+    imageToVideo: true,
+    durations: V1_DURATIONS,
+    modes: ["pro"]
+  },
+  "kling/v1-6": {
+    modelName: "kling-v1-6",
+    api: "v1",
+    kind: "video",
+    textToVideo: true,
+    imageToVideo: true,
+    durations: V1_DURATIONS
+  },
+  "kling/v2-master": {
+    modelName: "kling-v2-master",
+    api: "v1",
+    kind: "video",
+    textToVideo: true,
+    imageToVideo: true,
+    durations: V1_DURATIONS
+  },
+  // Verified: rejected on text2video, accepted on image2video.
+  "kling/v2-1": {
+    modelName: "kling-v2-1",
+    api: "v1",
+    kind: "video",
+    imageToVideo: true,
+    durations: V1_DURATIONS
+  },
+  "kling/v2-1-master": {
+    modelName: "kling-v2-1-master",
+    api: "v1",
+    kind: "video",
+    textToVideo: true,
+    imageToVideo: true,
+    durations: V1_DURATIONS
+  },
+  // ---- path-versioned API ----
+  "kling/v2-5-turbo": {
+    modelName: "kling-2.5-turbo",
+    api: "next",
+    kind: "video",
+    textToVideo: true,
+    imageToVideo: true,
+    durations: V1_DURATIONS,
+    resolutions: HD
+  },
+  "kling/v2-6": {
+    modelName: "kling-2.6",
+    api: "next",
+    kind: "video",
+    textToVideo: true,
+    imageToVideo: true,
+    durations: V1_DURATIONS,
+    resolutions: HD
+  },
+  "kling/v3": {
+    modelName: "kling-3.0",
+    api: "next",
+    kind: "video",
+    textToVideo: true,
+    imageToVideo: true,
+    durations: NEXT_DURATIONS,
+    resolutions: UHD
+  },
+  "kling/v3-turbo": {
+    modelName: "kling-3.0-turbo",
+    api: "next",
+    kind: "video",
+    textToVideo: true,
+    imageToVideo: true,
+    durations: NEXT_DURATIONS,
+    // 3.0-turbo caps at 1080p, unlike 3.0.
+    resolutions: HD,
+    lastFrame: false
+  },
+  // ---- images, legacy API ----
+  "kling/image-v1": { modelName: "kling-v1", api: "v1", kind: "image" },
+  "kling/image-v1-5": { modelName: "kling-v1-5", api: "v1", kind: "image" },
+  "kling/image-v2": { modelName: "kling-v2", api: "v1", kind: "image" },
+  "kling/image-v2-new": { modelName: "kling-v2-new", api: "v1", kind: "image" },
+  "kling/image-v2-1": { modelName: "kling-v2-1", api: "v1", kind: "image" }
+};
+var KLING_VOICES = [
+  "genshin_vindi2",
+  "zhinen_xuesheng",
+  "ai_shatang",
+  "genshin_klee2",
+  "genshin_kirara",
+  "ai_kaiya",
+  "chat1_female_new-3",
+  "cartoon-boy-07",
+  "cartoon-girl-01",
+  "uk_boy1",
+  "uk_man2",
+  "PeppaPig_platform",
+  "ai_huangzhong_712",
+  "ai_huangyaoshi_712",
+  "ai_laoguowang_712",
+  "chengshu_jiejie",
+  "you_pingjing",
+  "calm_story1",
+  "laopopo_speech02",
+  "heainainai_speech02"
+];
+var KLING_AUDIO_MODEL = "kling/tts";
+var KLING_AUDIO_CATALOG = [
+  {
+    id: KLING_AUDIO_MODEL,
+    name: "Kling TTS",
+    category: "audio",
+    inputType: "text_only",
+    nodeTypes: ["text"],
+    creditsPerUnit: 0,
+    creditUnit: "character",
+    provider: "kling",
+    description: `Preset voices: ${KLING_VOICES.join(", ")}. Cloned voices from your account work too.`
+  }
+];
+function label(id) {
+  const name = KLING_MODELS[id]?.modelName ?? id;
+  return `Kling ${name.replace(/^kling-v?/, "")}`;
+}
+var KLING_CATALOG = Object.entries(KLING_MODELS).map(
+  ([id, binding]) => {
+    if (binding.kind === "image") {
+      return {
+        id,
+        name: `${label(id)} (image)`,
+        category: "image",
+        inputType: "text_only",
+        nodeTypes: ["image_gen"],
+        // Kling bills its own account, so there is nothing for us to price.
+        creditsPerUnit: 0,
+        creditUnit: "image",
+        supportedAspectRatios: ASPECT_RATIOS,
+        provider: "kling"
+      };
+    }
+    const durations = binding.durations ?? V1_DURATIONS;
+    return {
+      id,
+      name: label(id),
+      category: "video",
+      inputType: binding.textToVideo ? binding.imageToVideo ? "image_optional" : "text_only" : "image_required",
+      nodeTypes: ["video_gen"],
+      creditsPerUnit: 0,
+      creditUnit: "second",
+      minDuration: durations[0],
+      maxDuration: durations[durations.length - 1],
+      durationOptions: durations,
+      supportedResolutions: binding.resolutions,
+      supportedAspectRatios: ASPECT_RATIOS,
+      provider: "kling",
+      pricing: USD_PER_SECOND[id] ? {
+        unit: "second",
+        byResolution: USD_PER_SECOND[id],
+        usdPerUnit: USD_PER_SECOND[id]["720p"] ?? USD_PER_SECOND[id]["1080p"] ?? 0
+      } : void 0
+    };
+  }
+);
+function optionsBlock(options) {
+  if (!options) return void 0;
+  const block = {};
+  if (options.callbackUrl) block.callback_url = options.callbackUrl;
+  if (options.externalTaskId) block.external_task_id = options.externalTaskId;
+  if (options.watermark !== void 0) {
+    block.watermark_info = { enabled: options.watermark };
+  }
+  return Object.keys(block).length > 0 ? block : void 0;
+}
+var motionControl = {
+  api: "next",
+  kind: "video",
+  results: "outputs",
+  path: (input) => `/motion-control/${input.model ?? "kling-2.6"}`,
+  body: (input) => {
+    const contents = [];
+    if (input.prompt) contents.push({ type: "prompt", text: input.prompt });
+    contents.push({ type: "image", url: input.imageUrl });
+    contents.push({ type: "video", url: input.videoUrl });
+    const settings = {
+      character_orientation: input.characterOrientation
+    };
+    if (input.resolution) settings.resolution = input.resolution;
+    if (input.audio) settings.audio = input.audio;
+    const options = optionsBlock(input.options);
+    return options ? { contents, settings, options } : { contents, settings };
+  }
+};
+var omniVideo = {
+  api: "next",
+  kind: "video",
+  results: "outputs",
+  path: (input) => `/omni-video/${input.model ?? "kling-3.0-omni"}`,
+  body: (input) => {
+    const contents = [
+      { type: "prompt", text: input.prompt }
+    ];
+    for (const reference of input.references ?? []) {
+      contents.push({
+        type: reference.type,
+        url: reference.url,
+        ...reference.id ? { id: reference.id } : {}
+      });
+    }
+    for (const element of input.elements ?? []) {
+      contents.push({
+        type: "element",
+        element_id: element.elementId,
+        id: element.id
+      });
+    }
+    const settings = {};
+    if (input.resolution) settings.resolution = input.resolution;
+    if (input.duration) settings.duration = input.duration;
+    if (input.audio) settings.audio = input.audio;
+    if (input.aspectRatio) settings.aspect_ratio = input.aspectRatio;
+    if (input.multiShot !== void 0) settings.multi_shot = input.multiShot;
+    const options = optionsBlock(input.options);
+    return {
+      contents,
+      ...Object.keys(settings).length > 0 ? { settings } : {},
+      ...options ? { options } : {}
+    };
+  }
+};
+var avatar = {
+  api: "v1",
+  kind: "video",
+  results: "videos",
+  path: () => "/v1/videos/avatar/image2video",
+  body: (input) => {
+    if (Boolean(input.audioId) === Boolean(input.soundFileUrl)) {
+      throw new Error(
+        "Avatar needs exactly one of audioId or soundFileUrl, not both and not neither."
+      );
+    }
+    const body = { image: input.imageUrl };
+    if (input.audioId) body.audio_id = input.audioId;
+    if (input.soundFileUrl) body.sound_file = input.soundFileUrl;
+    if (input.prompt) body.prompt = input.prompt;
+    if (input.mode) body.mode = input.mode;
+    if (input.options?.callbackUrl)
+      body.callback_url = input.options.callbackUrl;
+    if (input.options?.externalTaskId) {
+      body.external_task_id = input.options.externalTaskId;
+    }
+    if (input.options?.watermark !== void 0) {
+      body.watermark_info = { enabled: input.options.watermark };
+    }
+    return body;
+  }
+};
+var outpainting = {
+  api: "v1",
+  kind: "image",
+  results: "images",
+  path: () => "/v1/images/editing/expand",
+  body: (input) => {
+    for (const [name, value] of [
+      ["up", input.up],
+      ["down", input.down],
+      ["left", input.left],
+      ["right", input.right]
+    ]) {
+      if (value < 0 || value > 2) {
+        throw new Error(
+          `Outpainting ${name} must be between 0 and 2, got ${value}.`
+        );
+      }
+    }
+    const body = {
+      image: input.imageUrl,
+      up_expansion_ratio: input.up,
+      down_expansion_ratio: input.down,
+      left_expansion_ratio: input.left,
+      right_expansion_ratio: input.right
+    };
+    if (input.prompt) body.prompt = input.prompt;
+    if (input.n) body.n = input.n;
+    if (input.options?.watermark !== void 0) {
+      body.watermark_info = { enabled: input.options.watermark };
+    }
+    return body;
+  }
+};
+var imageOmni = {
+  api: "v1",
+  kind: "image",
+  results: "images",
+  path: () => "/v1/images/omni-image",
+  body: (input) => {
+    const images = input.imageUrls ?? [];
+    const elements = input.elementIds ?? [];
+    if (images.length + elements.length > 10) {
+      throw new Error(
+        `Image-omni takes at most 10 references in total, got ${images.length + elements.length}.`
+      );
+    }
+    const body = {
+      model_name: input.model ?? "kling-image-o1",
+      prompt: input.prompt
+    };
+    if (images.length > 0) {
+      body.image_list = images.map((image) => ({ image }));
+    }
+    if (elements.length > 0) {
+      body.element_list = elements.map((id) => ({ element_id: id }));
+    }
+    if (input.resolution) body.resolution = input.resolution;
+    if (input.resultType) body.result_type = input.resultType;
+    if (input.seriesAmount) body.series_amount = input.seriesAmount;
+    if (input.n) body.n = input.n;
+    if (input.aspectRatio) body.aspect_ratio = input.aspectRatio;
+    if (input.options?.watermark !== void 0) {
+      body.watermark_info = { enabled: input.options.watermark };
+    }
+    return body;
+  }
+};
+var KLING_CAPABILITIES = {
+  motionControl,
+  omniVideo,
+  avatar,
+  outpainting,
+  imageOmni
+};
+
+// src/providers/openai.models.ts
+var CLASSIC_SIZES = ["1024x1024", "1024x1536", "1536x1024", "auto"];
+var OPENAI_IMAGE_MODELS = {
+  "gpt-image-2": {
+    // Arbitrary WxH: max edge 3840, both edges divisible by 16, ratio up to 3:1.
+    sizes: "any",
+    qualities: ["low", "medium", "high"],
+    // A real capability regression against the older model.
+    transparentBackground: false,
+    usd: { low: 6e-3, medium: 0.053, high: 0.211 }
+  },
+  "gpt-image-1.5": {
+    sizes: CLASSIC_SIZES,
+    qualities: ["low", "medium", "high"],
+    transparentBackground: true,
+    shutdownOn: "2026-12-01",
+    usd: { low: 9e-3, medium: 0.04, high: 0.2 }
+  },
+  "gpt-image-1": {
+    sizes: CLASSIC_SIZES,
+    qualities: ["low", "medium", "high"],
+    // The only one left that can do transparency.
+    transparentBackground: true,
+    usd: { low: 0.011, medium: 0.042, high: 0.167 }
+  }
+};
+var OPENAI_CATALOG = Object.entries(
+  OPENAI_IMAGE_MODELS
+).map(([id, binding]) => ({
+  id,
+  name: id,
+  category: "image",
+  inputType: "image_optional",
+  nodeTypes: ["image_gen"],
+  creditsPerUnit: 0,
+  creditUnit: "image",
+  supportedResolutions: binding.sizes === "any" ? void 0 : binding.sizes,
+  provider: "openai",
+  // Medium is the sane middle; `quality: auto` can silently pick high, which
+  // is 35x the low tier.
+  pricing: { usdPerUnit: binding.usd.medium, unit: "image" },
+  description: binding.shutdownOn ? `Deprecated \u2014 OpenAI shuts this down on ${binding.shutdownOn}.` : void 0
+}));
+
+// src/providers/qwen.models.ts
+var VIDEO_PATH = "/api/v1/services/aigc/video-generation/video-synthesis";
+var KF2V_PATH = "/api/v1/services/aigc/image2video/video-synthesis";
+var HD2 = ["480P", "720P", "1080P"];
+var QWEN_VIDEO_MODELS = {
+  // --- wan 2.7: media objects, resolution + ratio ---
+  "wan2.7-t2v": {
+    mode: "t2v",
+    shape: "media",
+    sizing: "resolution",
+    durations: { min: 2, max: 15 },
+    resolutions: ["720P", "1080P"]
+  },
+  "wan2.7-i2v": {
+    mode: "i2v",
+    shape: "media",
+    sizing: "resolution",
+    durations: { min: 2, max: 15 },
+    resolutions: ["720P", "1080P"]
+  },
+  // --- wan 2.6: img_url string, size ---
+  "wan2.6-t2v": {
+    mode: "t2v",
+    shape: "media",
+    sizing: "size",
+    durations: { min: 2, max: 15 },
+    watermarkOnByDefault: true
+  },
+  "wan2.6-i2v": {
+    mode: "i2v",
+    shape: "img_url",
+    sizing: "resolution",
+    durations: { min: 2, max: 15 },
+    resolutions: ["720P", "1080P"]
+  },
+  "wan2.6-i2v-flash": {
+    mode: "i2v",
+    shape: "img_url",
+    sizing: "resolution",
+    durations: { min: 2, max: 15 },
+    resolutions: ["720P", "1080P"]
+  },
+  "wan2.6-r2v": {
+    mode: "r2v",
+    shape: "reference_urls",
+    sizing: "size",
+    durations: { min: 2, max: 10 }
+  },
+  // --- keyframe: different path, fixed duration, its own fields ---
+  "wan2.2-kf2v-flash": {
+    mode: "kf2v",
+    shape: "kf2v",
+    sizing: "resolution",
+    path: KF2V_PATH,
+    durations: [5],
+    resolutions: HD2
+  },
+  // --- happyhorse: media objects, minimum duration 3, watermark on ---
+  "happyhorse-1.1-t2v": {
+    mode: "t2v",
+    shape: "media",
+    sizing: "resolution",
+    durations: { min: 3, max: 15 },
+    resolutions: HD2,
+    watermarkOnByDefault: true
+  },
+  "happyhorse-1.1-i2v": {
+    mode: "i2v",
+    shape: "media",
+    sizing: "resolution",
+    durations: { min: 3, max: 15 },
+    resolutions: HD2,
+    watermarkOnByDefault: true
+  },
+  "happyhorse-1.1-r2v": {
+    mode: "r2v",
+    shape: "media",
+    sizing: "resolution",
+    durations: { min: 3, max: 15 },
+    resolutions: HD2,
+    watermarkOnByDefault: true
+  },
+  "happyhorse-1.0-t2v": {
+    mode: "t2v",
+    shape: "media",
+    sizing: "resolution",
+    durations: { min: 3, max: 15 },
+    resolutions: HD2,
+    watermarkOnByDefault: true
+  },
+  "happyhorse-1.0-i2v": {
+    mode: "i2v",
+    shape: "media",
+    sizing: "resolution",
+    durations: { min: 3, max: 15 },
+    resolutions: HD2,
+    watermarkOnByDefault: true
+  },
+  "happyhorse-1.0-r2v": {
+    mode: "r2v",
+    shape: "media",
+    sizing: "resolution",
+    durations: { min: 3, max: 15 },
+    resolutions: HD2,
+    watermarkOnByDefault: true
+  },
+  "happyhorse-1.0-video-edit": {
+    mode: "video-edit",
+    shape: "media",
+    sizing: "resolution",
+    resolutions: ["720P", "1080P"],
+    watermarkOnByDefault: true
+  }
+};
+function videoPathFor(binding) {
+  return binding.path ?? VIDEO_PATH;
+}
+var QWEN_IMAGE_PATHS = {
+  multimodal: "/api/v1/services/aigc/multimodal-generation/generation",
+  "image-generation": "/api/v1/services/aigc/image-generation/generation",
+  text2image: "/api/v1/services/aigc/text2image/image-synthesis"
+};
+var QWEN_IMAGE_MODELS = {
+  // Sync and async both available; async uses the newer image-generation path.
+  "qwen-image-3.0-pro": {
+    sync: true,
+    path: "multimodal",
+    body: "messages",
+    maxN: 6
+  },
+  "qwen-image-3.0": {
+    sync: true,
+    path: "multimodal",
+    body: "messages",
+    maxN: 6
+  },
+  // Sync only — the async header would 429 these.
+  "qwen-image-2.0-pro": {
+    sync: true,
+    path: "multimodal",
+    body: "messages",
+    maxN: 6
+  },
+  "qwen-image-2.0": {
+    sync: true,
+    path: "multimodal",
+    body: "messages",
+    maxN: 6
+  },
+  "qwen-image-max": {
+    sync: true,
+    path: "multimodal",
+    body: "messages",
+    maxN: 1
+  },
+  "z-image-turbo": {
+    sync: true,
+    path: "multimodal",
+    body: "messages",
+    maxN: 1
+  },
+  "wan2.7-image-pro": {
+    sync: true,
+    path: "multimodal",
+    body: "messages",
+    maxN: 4,
+    resolutions: ["1K", "2K", "4K"]
+  },
+  "wan2.7-image": {
+    sync: true,
+    path: "multimodal",
+    body: "messages",
+    maxN: 4,
+    resolutions: ["1K", "2K"]
+  },
+  "wan2.6-image": {
+    sync: true,
+    path: "multimodal",
+    body: "messages",
+    maxN: 4
+  },
+  "wan2.6-t2i": { sync: true, path: "multimodal", body: "messages", maxN: 4 }
+};
+var VIDEO_USD_PER_SECOND = {
+  "happyhorse-1.1-t2v": { "480P": 0.07, "720P": 0.14, "1080P": 0.18 },
+  "happyhorse-1.1-i2v": { "480P": 0.07, "720P": 0.14, "1080P": 0.18 },
+  "happyhorse-1.1-r2v": { "480P": 0.07, "720P": 0.14, "1080P": 0.18 },
+  "happyhorse-1.0-video-edit": { "720P": 0.14, "1080P": 0.24 }
+};
+var IMAGE_USD2 = {
+  "qwen-image-3.0-pro": 0.04,
+  "qwen-image-3.0": 0.03,
+  "qwen-image-2.0-pro": 0.075,
+  "qwen-image-2.0": 0.035,
+  "wan2.7-image-pro": 0.075
+};
+var QWEN_VOICES = [
+  "Cherry",
+  "Ethan",
+  "Jennifer",
+  "Ryan",
+  "Dylan",
+  "Sunny",
+  "Nofish"
+];
+var QWEN_AUDIO_MODELS = {
+  "qwen3-tts-flash": { voices: QWEN_VOICES, usdPerCharacter: 15e-6 },
+  "qwen3-tts-instruct-flash": {
+    voices: QWEN_VOICES,
+    usdPerCharacter: 15e-6
+  },
+  "qwen-audio-3.0-tts-flash": {
+    voices: QWEN_VOICES,
+    usdPerCharacter: 15e-6
+  },
+  "qwen-audio-3.0-tts-plus": { voices: QWEN_VOICES, usdPerCharacter: 3e-5 },
+  "cosyvoice-v3-flash": { voices: QWEN_VOICES, usdPerCharacter: 15e-6 }
+};
+var QWEN_TEXT_MODELS = {
+  "qwen3.8-max": { usdPerMillionOutput: 6 },
+  "qwen3.7-plus": { usdPerMillionOutput: 1.6 },
+  "qwen3.7-flash": { usdPerMillionOutput: 0.13 },
+  "qwen-max": { usdPerMillionOutput: 7.5 },
+  "qwen-plus": { usdPerMillionOutput: 3 },
+  "qwen-turbo": { usdPerMillionOutput: 0.4 }
+};
+function inputTypeFor(mode) {
+  if (mode === "t2v") return "text_only";
+  if (mode === "video-edit") return "video_required";
+  return "image_required";
+}
+function durationsOf(binding) {
+  if (Array.isArray(binding.durations)) {
+    return {
+      options: binding.durations,
+      min: binding.durations[0],
+      max: binding.durations[binding.durations.length - 1]
+    };
+  }
+  return {
+    options: void 0,
+    min: binding.durations?.min,
+    max: binding.durations?.max
+  };
+}
+var QWEN_CATALOG = [
+  ...Object.entries(QWEN_AUDIO_MODELS).map(
+    ([id, binding]) => ({
+      id,
+      name: id,
+      category: "audio",
+      inputType: "text_only",
+      nodeTypes: ["text"],
+      creditsPerUnit: 0,
+      creditUnit: "character",
+      provider: "qwen",
+      pricing: { unit: "character", usdPerUnit: binding.usdPerCharacter },
+      description: `Voices: ${binding.voices.join(", ")}`
+    })
+  ),
+  ...Object.entries(QWEN_TEXT_MODELS).map(
+    ([id, binding]) => ({
+      id,
+      name: id,
+      category: "text",
+      inputType: "text_only",
+      nodeTypes: ["text"],
+      creditsPerUnit: 0,
+      creditUnit: "token",
+      provider: "qwen",
+      pricing: {
+        unit: "token",
+        usdPerUnit: binding.usdPerMillionOutput / 1e6
+      }
+    })
+  ),
+  ...Object.entries(QWEN_VIDEO_MODELS).map(([id, binding]) => {
+    const duration = durationsOf(binding);
+    return {
+      id,
+      name: id,
+      category: "video",
+      inputType: inputTypeFor(binding.mode),
+      nodeTypes: ["video_gen"],
+      // Qwen bills your own DashScope account.
+      creditsPerUnit: 0,
+      creditUnit: "second",
+      durationOptions: duration.options,
+      minDuration: duration.min,
+      maxDuration: duration.max,
+      supportedResolutions: binding.resolutions,
+      provider: "qwen",
+      pricing: VIDEO_USD_PER_SECOND[id] ? {
+        unit: "second",
+        byResolution: VIDEO_USD_PER_SECOND[id],
+        usdPerUnit: VIDEO_USD_PER_SECOND[id]["720P"] ?? 0
+      } : void 0
+    };
+  }),
+  ...Object.entries(QWEN_IMAGE_MODELS).map(
+    ([id, binding]) => ({
+      id,
+      name: id,
+      category: "image",
+      inputType: "image_optional",
+      nodeTypes: ["image_gen"],
+      creditsPerUnit: 0,
+      creditUnit: "image",
+      supportedResolutions: binding.resolutions,
+      provider: "qwen",
+      pricing: IMAGE_USD2[id] ? { unit: "image", usdPerUnit: IMAGE_USD2[id] } : void 0
+    })
+  )
+];
+
+// src/catalog.ts
+var PROVIDER_BASE_URLS = {
+  byteplus: "https://ark.ap-southeast.bytepluses.com",
+  kling: "https://api-singapore.klingai.com",
+  elevenlabs: "https://api.elevenlabs.io",
+  google: "https://generativelanguage.googleapis.com",
+  openai: "https://api.openai.com",
+  qwen: "https://dashscope-intl.aliyuncs.com"
+};
+var BUILT_IN = [
+  ...KLING_CATALOG,
+  ...KLING_AUDIO_CATALOG,
+  ...BYTEPLUS_CATALOG,
+  ...BYTEPLUS_IMAGE_CATALOG,
+  ...QWEN_CATALOG,
+  ...OPENAI_CATALOG,
+  ...GOOGLE_CATALOG,
+  ...ELEVENLABS_CATALOG
+];
+var catalog = BUILT_IN;
+var catalogMap = byId(BUILT_IN);
+function byId(models) {
+  return Object.fromEntries(models.map((model) => [model.id, model]));
+}
+function registerModels(models = []) {
+  if (models.length === 0) return;
+  const merged = { ...catalogMap };
+  for (const model of models) {
+    merged[model.id] = { ...merged[model.id], ...model };
+  }
+  catalogMap = merged;
+  catalog = Object.values(merged);
+}
+function resetCatalog() {
+  catalog = BUILT_IN;
+  catalogMap = byId(BUILT_IN);
+}
+function getModel(modelId) {
+  return catalogMap[modelId];
+}
+function getModels() {
+  return catalog;
+}
+function hasModel(modelId) {
+  return modelId in catalogMap;
+}
+function getProviders() {
+  return [
+    ...new Set(
+      catalog.map((model) => model.provider).filter((provider) => Boolean(provider))
+    )
+  ].sort();
+}
+function resolveProvider(modelId, options) {
+  const model = getModel(modelId);
+  if (!model) {
+    throw new Error(`Unknown model "${modelId}".`);
+  }
+  const id = model.provider;
+  if (!id) {
+    throw new Error(
+      `Model "${modelId}" declares no provider, so nothing knows how to run it.`
+    );
+  }
+  const configured = options.providers[id];
+  if (!configured) {
+    const owned = Object.keys(options.providers).join(", ") || "none";
+    throw new Error(
+      `Model "${modelId}" runs on "${id}", but no API key was given for it (configured: ${owned}).`
+    );
+  }
+  const baseUrl = configured.baseUrl ?? PROVIDER_BASE_URLS[id];
+  if (!baseUrl) {
+    throw new Error(
+      `Provider "${id}" has no known base URL \u2014 pass providers.${id}.baseUrl.`
+    );
+  }
+  return { id, apiKey: configured.apiKey, baseUrl: baseUrl.replace(/\/$/, "") };
+}
+function getAvailableModels(options) {
+  return catalog.filter(
+    (model) => model.provider && model.provider in options.providers
+  );
+}
+
+// src/adapters/estimate.ts
+function estimateFor(provider, type, params, defaults) {
+  const modelId = params.model ?? "";
+  const model = getModel(modelId);
+  const video = params;
+  const unit = model?.pricing?.unit ?? (type === "video" ? "second" : type === "audio" ? "character" : type === "text" ? "token" : "image");
+  let units = 1;
+  if (unit === "character") {
+    units = params.prompt?.length ?? 0;
+  } else if (unit === "token") {
+    units = 0;
+  } else if (unit === "second") {
+    units = video.duration ?? defaults?.durationSeconds ?? model?.minDuration ?? 5;
+  }
+  const resolution = params.resolution;
+  const rate = (resolution ? model?.pricing?.byResolution?.[resolution] : void 0) ?? model?.pricing?.usdPerUnit;
+  return {
+    unit,
+    units,
+    usd: rate === void 0 || unit === "token" ? null : Number((rate * units).toFixed(4)),
+    note: unit === "token" && rate !== void 0 ? `Billed per token at $${(rate * 1e6).toFixed(2)} per million output tokens. The total depends on how much the model writes, so it is only known after generating.` : rate === void 0 ? `No verified rate for "${modelId}". It bills to your own ${provider} account; ${units} ${unit}${units === 1 ? "" : "s"} will be charged.` : void 0,
+    provider,
+    model: modelId
+  };
+}
+
+// src/adapters/byteplus.adapter.ts
+var DEFAULT_BASE_URL = "https://ark.ap-southeast.bytepluses.com";
+var TASKS_PATH = "/api/v3/contents/generations/tasks";
+var IMAGES_PATH = "/api/v3/images/generations";
+var POLL_INTERVAL_MS = 5e3;
+var DEFAULT_MAX_POLL_ATTEMPTS = 240;
+var BytePlusAdapter = class {
+  providerName = "byteplus";
+  supportedTypes = ["image", "video"];
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  get baseUrl() {
+    return (this.opts.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+  }
+  async request(path, init) {
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      method: init?.method ?? "GET",
+      headers: {
+        Authorization: `Bearer ${this.opts.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: init ? JSON.stringify(init.body) : void 0
+    });
+    const payload = await response.json();
+    if (payload.error) {
+      throw new Error(`${payload.error.code}: ${payload.error.message}`);
+    }
+    if (!response.ok) {
+      throw new Error(`Ark returned ${response.status} for ${path}.`);
+    }
+    return payload;
+  }
+  binding(modelId) {
+    const id = modelId ?? "";
+    const found = BYTEPLUS_MODELS[id];
+    if (!found) {
+      throw new Error(
+        `"${id}" is not a BytePlus model. Known: ${Object.keys(BYTEPLUS_MODELS).join(", ")}.`
+      );
+    }
+    return [id, found];
+  }
+  buildBody(modelId, binding, params) {
+    const content = [{ type: "text", text: params.prompt }];
+    const firstFrame = params.imageUrl ?? params.referenceImages?.[0];
+    const references = params.imageUrls ?? [];
+    if (references.length > 0) {
+      if (binding.referenceImages === 0) {
+        throw new Error(
+          `Seedance "${modelId}" takes no reference images \u2014 use imageUrl for a first frame.`
+        );
+      }
+      for (const url of references.slice(0, binding.referenceImages)) {
+        content.push({
+          type: "image_url",
+          image_url: { url },
+          role: "reference_image"
+        });
+      }
+    } else if (firstFrame) {
+      content.push({
+        type: "image_url",
+        image_url: { url: firstFrame },
+        role: "first_frame"
+      });
+      const lastFrame = params.referenceImages?.[1];
+      if (lastFrame) {
+        if (!binding.lastFrame) {
+          throw new Error(
+            `Seedance "${modelId}" does not accept a last frame.`
+          );
+        }
+        content.push({
+          type: "image_url",
+          image_url: { url: lastFrame },
+          role: "last_frame"
+        });
+      }
+    }
+    const allowed = fieldsFor(binding.family);
+    const body = { model: modelId, content };
+    body.resolution = params.resolution ?? binding.defaultResolution;
+    if (params.aspectRatio && params.aspectRatio !== "auto") {
+      body.ratio = params.aspectRatio;
+    }
+    if (params.duration !== void 0) body.duration = params.duration;
+    if (allowed.seed && params.seed !== void 0) body.seed = params.seed;
+    if (allowed.generateAudio && params.withAudio !== void 0) {
+      body.generate_audio = params.withAudio;
+    }
+    return { ...body, ...params.providerOptions?.byteplus ?? {} };
+  }
+  validate(modelId, binding, kind, params) {
+    if (kind !== "video") {
+      throw new Error("The BytePlus adapter only generates video.");
+    }
+    const hasImage = Boolean(params.imageUrl ?? params.imageUrls?.length);
+    if (!hasImage && !binding.textToVideo) {
+      throw new Error(
+        `Seedance "${modelId}" only runs image-to-video \u2014 pass imageUrl.`
+      );
+    }
+    if (hasImage && !binding.imageToVideo) {
+      throw new Error(`Seedance "${modelId}" only runs text-to-video.`);
+    }
+    if (params.duration !== void 0) {
+      const { min, max } = binding.durations;
+      const openEnded = params.duration === -1 && binding.family !== "1.0";
+      if (!openEnded && (params.duration < min || params.duration > max)) {
+        throw new Error(
+          `Seedance "${modelId}" accepts durations from ${min} to ${max}s, not ${params.duration}s.`
+        );
+      }
+    }
+    if (params.resolution && !binding.resolutions.includes(params.resolution)) {
+      throw new Error(
+        `Seedance "${modelId}" supports ${binding.resolutions.join(", ")}, not ${params.resolution}.`
+      );
+    }
+  }
+  outputsFrom(task) {
+    const url = task.content?.video_url;
+    if (!url) return [];
+    return [
+      {
+        url,
+        mimeType: "video/mp4",
+        taskId: task.id,
+        // Ark states 24 hours for a result URL.
+        expiresAt: expiresInHours(24),
+        // Ark bills output tokens only; input is always 0 for video.
+        raw: { completionTokens: task.usage?.completion_tokens }
+      }
+    ];
+  }
+  snapshot(task, job) {
+    if (task.status === "failed" || task.status === "cancelled") {
+      return {
+        status: "failed",
+        error: task.error?.message ?? `Ark reported the task as ${task.status}.`
+      };
+    }
+    if (task.status === "expired") {
+      return {
+        status: "failed",
+        error: `Ark expired task ${task.id} before it ran.`
+      };
+    }
+    if (task.status !== "succeeded") return { status: "pending" };
+    const outputs = this.outputsFrom(task);
+    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(kind, 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 taskId;
+    try {
+      const [id, binding] = this.binding(params.model);
+      modelId = id;
+      this.validate(id, binding, kind, params);
+      const task = await this.request(TASKS_PATH, {
+        method: "POST",
+        body: this.buildBody(id, binding, params)
+      });
+      if (!task.id) {
+        throw new Error("Ark accepted the request but returned no task id.");
+      }
+      taskId = task.id;
+    } catch (error) {
+      return failure(error instanceof Error ? error.message : String(error));
+    }
+    if (isSubmitMode()) {
+      throw new PendingJob(taskId, TASKS_PATH);
+    }
+    const job = {
+      id: taskId,
+      provider: this.providerName,
+      model: modelId,
+      kind,
+      pollEndpoint: TASKS_PATH,
+      params,
+      submittedAt: new Date(startedAt).toISOString()
+    };
+    const maxAttempts = this.opts.maxPollAttempts ?? DEFAULT_MAX_POLL_ATTEMPTS;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const snapshot = await this.completeJob(job);
+      if (snapshot.status === "failed") {
+        return failure(snapshot.error ?? "Ark task failed.");
+      }
+      if (snapshot.status === "succeeded" && snapshot.result) {
+        return { ...snapshot.result, processingTimeMs: Date.now() - startedAt };
+      }
+      await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+    }
+    return failure(
+      `Ark task ${taskId} did not finish after ${maxAttempts} checks.`
+    );
+  }
+  /** Resume a job submitted earlier, possibly by another process. */
+  async completeJob(job) {
+    try {
+      const task = await this.request(
+        `${job.pollEndpoint ?? TASKS_PATH}/${encodeURIComponent(job.id)}`
+      );
+      return this.snapshot(task, job);
+    } catch (error) {
+      return {
+        status: "failed",
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  generateVideo(params) {
+    return this.run("video", params);
+  }
+  /**
+   * Seedream. Unlike video, `/images/generations` answers synchronously — the
+   * image is in the response and there is no task to poll, so `submit()` returns
+   * an already-settled job for these models.
+   */
+  async generateImage(params) {
+    const startedAt = Date.now();
+    const modelId = params.model ?? "";
+    const failure = (error) => ({
+      success: false,
+      outputs: [],
+      creditsUsed: 0,
+      provider: this.providerName,
+      model: modelId,
+      processingTimeMs: Date.now() - startedAt,
+      error
+    });
+    const spec = BYTEPLUS_IMAGE_MODELS[modelId];
+    if (!spec) {
+      return failure(
+        `"${modelId}" is not a BytePlus image model. Known: ${Object.keys(BYTEPLUS_IMAGE_MODELS).join(", ")}.`
+      );
+    }
+    const size = params.resolution ?? "2K";
+    if (!spec.sizes.includes(size)) {
+      return failure(
+        `Seedream "${modelId}" supports ${spec.sizes.join(", ")}, not ${size}.`
+      );
+    }
+    const body = {
+      model: modelId,
+      prompt: params.prompt,
+      size,
+      response_format: "url",
+      // Ark defaults this to true. An SDK that stamps your paid output without
+      // being asked is a surprise, so the default is inverted here.
+      watermark: false
+    };
+    if (params.outputFormat) body.output_format = params.outputFormat;
+    if (params.seed !== void 0) body.seed = params.seed;
+    const reference = params.referenceImages?.[0];
+    if (reference) body.image = reference;
+    try {
+      const response = await this.request(IMAGES_PATH, {
+        method: "POST",
+        body
+      });
+      const outputs = (response.data ?? []).filter((item) => Boolean(item.url)).map((item) => ({
+        url: item.url,
+        mimeType: params.outputFormat === "png" ? "image/png" : "image/jpeg",
+        // The link dies in a day; configure storage to keep it.
+        expiresAt: expiresInHours(24)
+      }));
+      if (outputs.length === 0) {
+        return failure("Ark returned no image URL.");
+      }
+      return {
+        success: true,
+        outputs,
+        creditsUsed: 0,
+        provider: this.providerName,
+        model: modelId,
+        processingTimeMs: Date.now() - startedAt
+      };
+    } catch (error) {
+      return failure(error instanceof Error ? error.message : String(error));
+    }
+  }
+  /** Cancel a queued task, or delete the record of a finished one. */
+  async cancelJob(job) {
+    await fetch(`${this.baseUrl}${TASKS_PATH}/${encodeURIComponent(job.id)}`, {
+      method: "DELETE",
+      headers: { Authorization: `Bearer ${this.opts.apiKey}` }
+    });
+  }
+  generateAudio(_params) {
+    throw new Error("BytePlus has no speech synthesis wired up here.");
+  }
+  generateText(_params) {
+    throw new Error("The BytePlus adapter does not generate text.");
+  }
+  async estimateCost(type, params) {
+    return estimateFor(this.providerName, type, params);
+  }
+  supportsModel(model) {
+    return model in BYTEPLUS_MODELS || model in BYTEPLUS_IMAGE_MODELS;
+  }
+  getAvailableModels() {
+    return [
+      ...Object.keys(BYTEPLUS_MODELS).map((id) => ({
+        id,
+        name: id,
+        type: "video"
+      })),
+      ...Object.keys(BYTEPLUS_IMAGE_MODELS).map((id) => ({
+        id,
+        name: id,
+        type: "image"
+      }))
+    ];
+  }
+};
+
+// src/adapters/elevenlabs.adapter.ts
+var DEFAULT_BASE_URL2 = "https://api.elevenlabs.io";
+var ElevenLabsAdapter = class {
+  providerName = "elevenlabs";
+  supportedTypes = ["audio"];
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  get baseUrl() {
+    return (this.opts.baseUrl ?? DEFAULT_BASE_URL2).replace(/\/$/, "");
+  }
+  get headers() {
+    return { "xi-api-key": this.opts.apiKey };
+  }
+  /**
+   * The voices on your account. Voice ids are opaque and account-specific, so
+   * there is no list the catalog could ship.
+   */
+  async listVoices() {
+    const response = await fetch(`${this.baseUrl}/v1/voices/search`, {
+      headers: this.headers
+    });
+    if (!response.ok) {
+      throw new Error(`ElevenLabs returned ${response.status} listing voices.`);
+    }
+    const payload = await response.json();
+    return (payload.voices ?? []).filter((voice) => voice.voice_id).map((voice) => ({
+      voiceId: voice.voice_id,
+      name: voice.name ?? "",
+      labels: voice.labels
+    }));
+  }
+  async generateAudio(params) {
+    const startedAt = Date.now();
+    const modelId = params.model ?? "eleven_multilingual_v2";
+    const failure = (error) => ({
+      success: false,
+      outputs: [],
+      creditsUsed: 0,
+      provider: this.providerName,
+      model: modelId,
+      processingTimeMs: Date.now() - startedAt,
+      error
+    });
+    const binding = ELEVENLABS_MODELS[modelId];
+    if (!binding) {
+      return failure(
+        `"${modelId}" is not an ElevenLabs model. Known: ${Object.keys(ELEVENLABS_MODELS).join(", ")}.`
+      );
+    }
+    const voiceId = params.voice ?? this.opts.defaultVoiceId;
+    if (!voiceId) {
+      return failure(
+        "ElevenLabs needs a voice id. Pass `voice`, set `defaultVoiceId` on the provider, or call listVoices() to find one."
+      );
+    }
+    if (params.prompt.length > binding.maxCharacters) {
+      return failure(
+        `ElevenLabs "${modelId}" takes up to ${binding.maxCharacters} characters; got ${params.prompt.length}.`
+      );
+    }
+    const outputFormat = params.outputFormat ? (
+      // The shared param is a codec; theirs is codec_rate_bitrate.
+      `${params.outputFormat}_44100_128`
+    ) : "mp3_44100_128";
+    if (!ELEVENLABS_OUTPUT_FORMATS.includes(outputFormat)) {
+      return failure(
+        `ElevenLabs has no output format "${outputFormat}". Pass one through providerOptions.elevenlabs.output_format.`
+      );
+    }
+    try {
+      const response = await fetch(
+        `${this.baseUrl}/v1/text-to-speech/${encodeURIComponent(voiceId)}`,
+        {
+          method: "POST",
+          headers: { ...this.headers, "Content-Type": "application/json" },
+          body: JSON.stringify({
+            text: params.prompt,
+            model_id: modelId,
+            output_format: outputFormat,
+            ...params.language ? { language_code: params.language } : {},
+            ...params.speed !== void 0 ? { voice_settings: { speed: params.speed } } : {},
+            ...params.providerOptions?.elevenlabs ?? {}
+          })
+        }
+      );
+      if (!response.ok) {
+        const detail = await response.text();
+        throw new Error(`ElevenLabs returned ${response.status}: ${detail}`);
+      }
+      const bytes = Buffer.from(await response.arrayBuffer());
+      const mimeType = outputFormat.startsWith("mp3") ? "audio/mpeg" : "audio/wav";
+      return {
+        success: true,
+        outputs: [
+          {
+            url: `data:${mimeType};base64,${bytes.toString("base64")}`,
+            mimeType,
+            sizeBytes: bytes.byteLength,
+            // Inline bytes: nothing hosted, so nothing expires.
+            raw: { inline: true, voiceId, characters: params.prompt.length }
+          }
+        ],
+        creditsUsed: 0,
+        provider: this.providerName,
+        model: modelId,
+        processingTimeMs: Date.now() - startedAt
+      };
+    } catch (error) {
+      return failure(error instanceof Error ? error.message : String(error));
+    }
+  }
+  generateImage(_params) {
+    throw new Error("ElevenLabs generates speech, not images.");
+  }
+  generateVideo(_params) {
+    throw new Error("ElevenLabs generates speech, not video.");
+  }
+  generateText(_params) {
+    throw new Error("ElevenLabs generates speech, not text.");
+  }
+  /** Synchronous provider: there is never a queued job to come back to. */
+  async completeJob(job) {
+    return {
+      status: "failed",
+      error: `ElevenLabs answers inline, so job ${job.id} has nothing to resume.`
+    };
+  }
+  async estimateCost(type, params) {
+    const base = estimateFor(this.providerName, type, params);
+    return {
+      ...base,
+      note: "ElevenLabs bills credits whose dollar value depends on your plan, so no rate is on file. The character count is exact."
+    };
+  }
+  supportsModel(model) {
+    return model in ELEVENLABS_MODELS;
+  }
+  getAvailableModels() {
+    return Object.keys(ELEVENLABS_MODELS).map((id) => ({
+      id,
+      name: id,
+      type: "audio"
+    }));
+  }
+};
+
+// src/adapters/google.adapter.ts
+var DEFAULT_BASE_URL3 = "https://generativelanguage.googleapis.com";
+var INTERACTIONS_PATH = "/v1beta/interactions";
+var POLL_INTERVAL_MS2 = 1e4;
+var DEFAULT_MAX_POLL_ATTEMPTS2 = 120;
+var GoogleAdapter = class {
+  providerName = "google";
+  supportedTypes = ["image", "video"];
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  get baseUrl() {
+    return (this.opts.baseUrl ?? DEFAULT_BASE_URL3).replace(/\/$/, "");
+  }
+  get headers() {
+    return {
+      "x-goog-api-key": this.opts.apiKey,
+      "Content-Type": "application/json"
+    };
+  }
+  async request(path, init) {
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      method: init?.method ?? "GET",
+      headers: this.headers,
+      body: init ? JSON.stringify(init.body) : void 0
+    });
+    const payload = await response.json();
+    if (payload.error) {
+      throw new Error(payload.error.message ?? "Google rejected the request.");
+    }
+    if (!response.ok) {
+      throw new Error(`Google returned ${response.status} for ${path}.`);
+    }
+    return payload;
+  }
+  // ------------------------------------------------------------------ images
+  async generateImage(params) {
+    const startedAt = Date.now();
+    const modelId = params.model ?? "";
+    const failure = (error) => ({
+      success: false,
+      outputs: [],
+      creditsUsed: 0,
+      provider: this.providerName,
+      model: modelId,
+      processingTimeMs: Date.now() - startedAt,
+      error
+    });
+    const binding = GOOGLE_IMAGE_MODELS[modelId];
+    if (!binding) {
+      return failure(
+        `"${modelId}" is not a Google image model. Known: ${Object.keys(GOOGLE_IMAGE_MODELS).join(", ")}.`
+      );
+    }
+    if (params.resolution && !binding.sizes.includes(params.resolution)) {
+      return failure(
+        `Google "${modelId}" accepts ${binding.sizes.join(", ")}, not ${params.resolution}.`
+      );
+    }
+    try {
+      const input = [
+        { type: "text", text: params.prompt }
+      ];
+      for (const image of params.referenceImages ?? []) {
+        const [meta, data] = image.split(",");
+        input.push({
+          type: "image",
+          mime_type: meta?.match(/data:([^;]+)/)?.[1] ?? "image/png",
+          data: data ?? image
+        });
+      }
+      const payload = await this.request(
+        INTERACTIONS_PATH,
+        {
+          method: "POST",
+          body: {
+            model: modelId,
+            input,
+            response_format: {
+              type: "image",
+              mime_type: `image/${params.outputFormat ?? "png"}`,
+              // Size drives the bill here, since pricing is token-based.
+              image_size: params.resolution ?? "1K",
+              ...params.aspectRatio && params.aspectRatio !== "auto" ? { aspect_ratio: params.aspectRatio } : {}
+            },
+            ...params.providerOptions?.google ?? {}
+          }
+        }
+      );
+      const base64 = payload.output_image?.data ?? payload.steps?.flatMap((step) => step.content ?? []).find((part) => part.type === "image")?.data;
+      if (!base64) return failure("Google returned no image.");
+      const format = params.outputFormat ?? "png";
+      return {
+        success: true,
+        outputs: [
+          {
+            url: `data:image/${format};base64,${base64}`,
+            mimeType: `image/${format}`,
+            raw: { inline: true }
+          }
+        ],
+        creditsUsed: 0,
+        provider: this.providerName,
+        model: modelId,
+        processingTimeMs: Date.now() - startedAt
+      };
+    } catch (error) {
+      return failure(error instanceof Error ? error.message : String(error));
+    }
+  }
+  // ------------------------------------------------------------------- video
+  veoBody(params) {
+    const hasImage = Boolean(params.imageUrl ?? params.referenceImages?.length);
+    const instance = { prompt: params.prompt };
+    const first = params.imageUrl ?? params.referenceImages?.[0];
+    if (first) {
+      const [meta, data] = first.split(",");
+      instance.image = {
+        inlineData: {
+          mimeType: meta?.match(/data:([^;]+)/)?.[1] ?? "image/png",
+          data: data ?? first
+        }
+      };
+    }
+    const resolution = params.resolution ?? "720p";
+    const forcesEight = resolution !== "720p";
+    const duration = String(params.duration ?? (forcesEight ? 8 : 4));
+    return {
+      instances: [instance],
+      parameters: {
+        aspectRatio: params.aspectRatio === "9:16" ? "9:16" : "16:9",
+        resolution,
+        // A string, not a number. Serializing it as an int is a 400.
+        durationSeconds: duration,
+        // The accepted value narrows by mode: text-to-video takes allow_all,
+        // anything driven by an image takes allow_adult and rejects the other.
+        personGeneration: hasImage ? "allow_adult" : "allow_all",
+        ...params.seed !== void 0 ? { seed: params.seed } : {},
+        ...params.providerOptions?.google ?? {}
+      }
+    };
+  }
+  /**
+   * Omni speaks the Interactions API, so it gets its own builder — snake_case
+   * `input`/`response_format`, against Veo's camelCase predict envelope.
+   */
+  omniBody(modelId, params) {
+    const input = [
+      { type: "text", text: params.prompt }
+    ];
+    const attach = (type, value) => {
+      const [meta, data] = value.split(",");
+      input.push({
+        type,
+        mime_type: meta?.match(/data:([^;]+)/)?.[1] ?? (type === "video" ? "video/mp4" : "image/png"),
+        data: data ?? value
+      });
+    };
+    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";
+    return {
+      model: modelId,
+      input,
+      // Continues a previous result instead of starting over.
+      ...params.previousInteractionId ? { previous_interaction_id: params.previousInteractionId } : {},
+      response_format: {
+        type: "video",
+        aspect_ratio: params.aspectRatio === "9:16" ? "9:16" : "16:9",
+        // A base64 video over ~4MB has to come back as a URI instead.
+        delivery: "uri"
+      },
+      generation_config: { video_config: { task } },
+      ...params.providerOptions?.google ?? {}
+    };
+  }
+  /** Generate or refine a video conversationally. Returns the interaction. */
+  async omniVideo(params) {
+    const modelId = params.model ?? "gemini-omni-flash-preview";
+    const payload = await this.request(INTERACTIONS_PATH, {
+      method: "POST",
+      body: this.omniBody(modelId, params)
+    });
+    const found = payload.output_video ?? payload.steps?.flatMap((step) => step.content ?? []).find((part) => part.type === "video");
+    const url = found?.uri ?? (found?.data ? `data:video/mp4;base64,${found.data}` : void 0);
+    return {
+      // Hand this back to keep refining the same video.
+      interactionId: payload.id,
+      outputs: url ? [
+        {
+          url,
+          mimeType: "video/mp4",
+          taskId: payload.id,
+          expiresAt: expiresInHours(48),
+          raw: found?.uri ? { requiresApiKeyHeader: true } : { inline: true }
+        }
+      ] : []
+    };
+  }
+  async runVideo(params) {
+    const startedAt = Date.now();
+    const modelId = params.model ?? "";
+    const failure = (error) => ({
+      success: false,
+      outputs: [],
+      creditsUsed: 0,
+      provider: this.providerName,
+      model: modelId,
+      processingTimeMs: Date.now() - startedAt,
+      error
+    });
+    const binding = GOOGLE_VIDEO_MODELS[modelId];
+    if (!binding) {
+      return failure(
+        `"${modelId}" is not a Veo model. Known: ${Object.keys(GOOGLE_VIDEO_MODELS).join(", ")}.`
+      );
+    }
+    if (params.resolution && !binding.resolutions.includes(params.resolution)) {
+      return failure(
+        `Veo "${modelId}" supports ${binding.resolutions.join(", ")}, not ${params.resolution}.`
+      );
+    }
+    if (params.imageUrls?.length && !binding.referenceImages) {
+      return failure(`Veo "${modelId}" does not take reference images.`);
+    }
+    if (binding.api === "interactions") {
+      try {
+        const { outputs, interactionId } = await this.omniVideo(params);
+        if (outputs.length === 0) return failure("Omni returned no video.");
+        return {
+          success: true,
+          outputs,
+          creditsUsed: 0,
+          provider: this.providerName,
+          model: modelId,
+          processingTimeMs: Date.now() - startedAt,
+          // Carried so the caller can keep refining this result.
+          error: void 0,
+          ...interactionId ? {} : {}
+        };
+      } catch (error) {
+        return failure(error instanceof Error ? error.message : String(error));
+      }
+    }
+    let operation;
+    try {
+      const submitted = await this.request(
+        `/v1beta/models/${modelId}:predictLongRunning`,
+        { method: "POST", body: this.veoBody(params) }
+      );
+      if (!submitted.name) {
+        throw new Error("Veo accepted the request but returned no operation.");
+      }
+      operation = submitted.name;
+    } catch (error) {
+      return failure(error instanceof Error ? error.message : String(error));
+    }
+    if (isSubmitMode()) throw new PendingJob(operation, "/v1beta");
+    const job = {
+      id: operation,
+      provider: this.providerName,
+      model: modelId,
+      kind: "video",
+      pollEndpoint: "/v1beta",
+      params,
+      submittedAt: new Date(startedAt).toISOString()
+    };
+    const maxAttempts = this.opts.maxPollAttempts ?? DEFAULT_MAX_POLL_ATTEMPTS2;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const snapshot = await this.completeJob(job);
+      if (snapshot.status === "failed") {
+        return failure(snapshot.error ?? "Veo task failed.");
+      }
+      if (snapshot.status === "succeeded" && snapshot.result) {
+        return { ...snapshot.result, processingTimeMs: Date.now() - startedAt };
+      }
+      await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS2));
+    }
+    return failure(`Veo operation ${operation} did not finish in time.`);
+  }
+  /** Resume a Veo operation submitted earlier, possibly by another process. */
+  async completeJob(job) {
+    try {
+      const operation = await this.request(
+        `${job.pollEndpoint ?? "/v1beta"}/${job.id}`
+      );
+      if (!operation.done) return { status: "pending" };
+      if (operation.error) {
+        return { status: "failed", error: operation.error.message };
+      }
+      const uri = operation.response?.generateVideoResponse?.generatedSamples?.[0]?.video?.uri;
+      if (!uri) return { status: "pending" };
+      const outputs = [
+        {
+          url: uri,
+          mimeType: "video/mp4",
+          taskId: job.id,
+          // Google removes the file after two days.
+          expiresAt: expiresInHours(48),
+          // The URI is not public: fetching it needs the x-goog-api-key header,
+          // and it redirects, so the header has to survive the redirect.
+          raw: { requiresApiKeyHeader: true }
+        }
+      ];
+      return {
+        status: "succeeded",
+        result: {
+          success: true,
+          outputs,
+          creditsUsed: 0,
+          provider: this.providerName,
+          model: job.model,
+          processingTimeMs: 0
+        }
+      };
+    } catch (error) {
+      return {
+        status: "failed",
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  generateVideo(params) {
+    return this.runVideo(params);
+  }
+  generateAudio(_params) {
+    throw new Error("Google has no speech synthesis wired up here.");
+  }
+  generateText(_params) {
+    throw new Error("The Google adapter here covers image and video only.");
+  }
+  async estimateCost(type, params) {
+    return estimateFor(this.providerName, type, params);
+  }
+  supportsModel(model) {
+    return model in GOOGLE_IMAGE_MODELS || model in GOOGLE_VIDEO_MODELS;
+  }
+  getAvailableModels() {
+    return [
+      ...Object.keys(GOOGLE_IMAGE_MODELS).map((id) => ({
+        id,
+        name: id,
+        type: "image"
+      })),
+      ...Object.keys(GOOGLE_VIDEO_MODELS).map((id) => ({
+        id,
+        name: id,
+        type: "video"
+      }))
+    ];
+  }
+};
+
+// src/adapters/kling.adapter.ts
+var DEFAULT_BASE_URL4 = "https://api-singapore.klingai.com";
+var POLL_INTERVAL_MS3 = 5e3;
+var DEFAULT_MAX_POLL_ATTEMPTS3 = 240;
+function stateOf(task) {
+  const raw = (task.status ?? task.task_status ?? "").toLowerCase();
+  if (raw === "failed") return "failed";
+  if (raw === "succeed" || raw === "succeeded") return "succeeded";
+  return "pending";
+}
+var KlingAdapter = class {
+  providerName = "kling";
+  supportedTypes = ["image", "video"];
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  get baseUrl() {
+    return (this.opts.baseUrl ?? DEFAULT_BASE_URL4).replace(/\/$/, "");
+  }
+  async request(path, init) {
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      method: init?.method ?? "GET",
+      headers: {
+        Authorization: `Bearer ${this.opts.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: init ? JSON.stringify(init.body) : void 0
+    });
+    const envelope = await response.json();
+    if (envelope.code !== 0) {
+      throw new Error(`Kling ${envelope.code}: ${envelope.message}`);
+    }
+    if (envelope.data === void 0) {
+      throw new Error(`Kling returned an empty body for ${path}.`);
+    }
+    return envelope.data;
+  }
+  binding(modelId) {
+    const id = modelId ?? "";
+    const found = KLING_MODELS[id];
+    if (!found) {
+      throw new Error(
+        `"${id}" is not a Kling model. Known: ${Object.keys(KLING_MODELS).join(", ")}.`
+      );
+    }
+    return [id, found];
+  }
+  submitPath(binding, hasImage) {
+    if (binding.api === "v1") {
+      if (binding.kind === "image") return "/v1/images/generations";
+      return hasImage ? "/v1/videos/image2video" : "/v1/videos/text2video";
+    }
+    return `/${hasImage ? "image-to-video" : "text-to-video"}/${binding.modelName}`;
+  }
+  legacyBody(binding, params, referenceImage) {
+    const body = {
+      model_name: binding.modelName,
+      prompt: params.prompt
+    };
+    if (params.negativePrompt) body.negative_prompt = params.negativePrompt;
+    if (params.aspectRatio && params.aspectRatio !== "auto") {
+      body.aspect_ratio = params.aspectRatio;
+    }
+    if (binding.kind === "video") {
+      body.duration = String(params.duration ?? 5);
+      const wanted = params.mode === "pro" ? "pro" : "std";
+      body.mode = binding.modes?.includes(wanted) ? wanted : binding.modes?.[0] ?? wanted;
+      if (referenceImage) body.image = referenceImage;
+    }
+    return body;
+  }
+  nextBody(params, referenceImage) {
+    const settings = {};
+    if (params.duration) settings.duration = params.duration;
+    if (params.resolution) settings.resolution = params.resolution;
+    if (!referenceImage && params.aspectRatio && params.aspectRatio !== "auto") {
+      settings.aspect_ratio = params.aspectRatio;
+    }
+    const body = referenceImage ? {
+      contents: [
+        { type: "prompt", text: params.prompt },
+        { type: "first_frame", url: referenceImage }
+      ]
+    } : { prompt: params.prompt };
+    if (Object.keys(settings).length > 0) body.settings = settings;
+    return { ...body, ...params.providerOptions?.kling ?? {} };
+  }
+  async submitTask(kind, params) {
+    const [, binding] = this.binding(params.model);
+    const referenceImage = params.imageUrl ?? params.referenceImages?.[0];
+    const hasImage = Boolean(referenceImage);
+    if (kind === "video" && !hasImage && !binding.textToVideo) {
+      throw new Error(
+        `Kling model "${params.model}" only runs image-to-video \u2014 pass imageUrl.`
+      );
+    }
+    if (binding.resolutions && params.resolution && !binding.resolutions.includes(params.resolution)) {
+      throw new Error(
+        `Kling "${params.model}" supports ${binding.resolutions.join(", ")}, not ${params.resolution}.`
+      );
+    }
+    if (binding.durations && params.duration && !binding.durations.includes(params.duration)) {
+      throw new Error(
+        `Kling "${params.model}" accepts durations ${binding.durations.join(", ")}s, not ${params.duration}s.`
+      );
+    }
+    const path = this.submitPath(binding, hasImage);
+    const body = binding.api === "v1" ? this.legacyBody(binding, params, referenceImage) : this.nextBody(params, referenceImage);
+    const task = await this.request(path, { method: "POST", body });
+    const taskId = task.task_id ?? task.id;
+    if (!taskId) {
+      throw new Error("Kling accepted the request but returned no task id.");
+    }
+    return { taskId, pollEndpoint: binding.api === "v1" ? path : "/tasks" };
+  }
+  async queryTask(pollEndpoint, taskId) {
+    if (pollEndpoint === "/tasks") {
+      const tasks = await this.request(
+        `/tasks?task_ids=${encodeURIComponent(taskId)}`
+      );
+      const task = tasks[0];
+      if (!task) throw new Error(`Kling knows no task ${taskId}.`);
+      return task;
+    }
+    return this.request(
+      `${pollEndpoint}/${encodeURIComponent(taskId)}`
+    );
+  }
+  outputsFrom(task, kind, resultField) {
+    const fromNext = task.outputs ?? [];
+    const legacy = task.task_result;
+    const fromLegacy = resultField ? resultField === "outputs" ? [] : legacy?.[resultField] ?? [] : kind === "video" ? legacy?.videos ?? [] : legacy?.images ?? [];
+    return [...fromNext, ...fromLegacy].filter((item) => Boolean(item?.url)).map((item) => ({
+      url: item.url,
+      mimeType: kind === "video" ? "video/mp4" : "image/png",
+      taskId: task.task_id ?? task.id,
+      // Kling clears results after 30 days.
+      expiresAt: expiresInHours(24 * 30)
+    }));
+  }
+  /** A capability job carries `kling:<name>:<resultField>` in its model slot. */
+  resultFieldOf(job) {
+    if (!job.model.startsWith("kling:")) return void 0;
+    return job.model.split(":")[2];
+  }
+  snapshot(task, job) {
+    const state = stateOf(task);
+    if (state === "failed") {
+      return {
+        status: "failed",
+        error: task.task_status_msg ?? "Kling task failed."
+      };
+    }
+    if (state === "pending") return { status: "pending" };
+    const outputs = this.outputsFrom(task, job.kind, this.resultFieldOf(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(kind, 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(kind, params);
+    } catch (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,
+      pollEndpoint: submitted.pollEndpoint,
+      params,
+      submittedAt: new Date(startedAt).toISOString()
+    };
+    const maxAttempts = this.opts.maxPollAttempts ?? DEFAULT_MAX_POLL_ATTEMPTS3;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const snapshot = await this.completeJob(job);
+      if (snapshot.status === "failed") {
+        return failure(snapshot.error ?? "Kling task failed.");
+      }
+      if (snapshot.status === "succeeded" && snapshot.result) {
+        return { ...snapshot.result, processingTimeMs: Date.now() - startedAt };
+      }
+      await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS3));
+    }
+    return failure(
+      `Kling task ${submitted.taskId} did not finish after ${maxAttempts} checks.`
+    );
+  }
+  /**
+   * Submit any declared capability and hand back a job.
+   *
+   * The three axes that differ between them — API family, body, result field —
+   * all come from the capability itself, so this runs every one of them.
+   */
+  async submitCapability(name, capability, input) {
+    const path = capability.path(input);
+    const task = await this.request(path, {
+      method: "POST",
+      body: capability.body(input)
+    });
+    const taskId = task.task_id ?? task.id;
+    if (!taskId) {
+      throw new Error(`Kling ${name} returned no task id.`);
+    }
+    return {
+      id: taskId,
+      provider: this.providerName,
+      // Not a catalog model: the capability plus its result field is what the
+      // resume path needs, so it rides in the model slot.
+      model: `kling:${name}:${capability.results}`,
+      kind: capability.kind === "image" ? "image" : "video",
+      // The legacy family polls its own path; the newer one has /tasks.
+      pollEndpoint: capability.api === "v1" ? path : "/tasks",
+      params: { prompt: "" },
+      submittedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /** Resume a job submitted earlier, possibly by another process. */
+  async completeJob(job) {
+    if (!job.pollEndpoint) {
+      return { status: "failed", error: "Kling job handle has no endpoint." };
+    }
+    try {
+      return this.snapshot(await this.queryTask(job.pollEndpoint, job.id), job);
+    } catch (error) {
+      return {
+        status: "failed",
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  generateImage(params) {
+    return this.run("image", params);
+  }
+  generateVideo(params) {
+    return this.run("video", params);
+  }
+  /** Your own cloned voices. Presets are in KLING_VOICES. */
+  async listVoices() {
+    const voices = await this.request("/v1/general/custom-voices?pageNum=1&pageSize=100");
+    return voices.filter((voice) => voice.voice_id).map((voice) => ({
+      voiceId: voice.voice_id,
+      name: voice.voice_name
+    }));
+  }
+  /**
+   * Speech. Synchronous, and snake_case — unlike both video APIs on this host.
+   */
+  async generateAudio(params) {
+    const startedAt = Date.now();
+    const modelId = params.model ?? KLING_AUDIO_MODEL;
+    const failure = (error) => ({
+      success: false,
+      outputs: [],
+      creditsUsed: 0,
+      provider: this.providerName,
+      model: modelId,
+      processingTimeMs: Date.now() - startedAt,
+      error
+    });
+    const voiceId = params.voice;
+    if (!voiceId) {
+      return failure(
+        `Kling needs a voice id. Presets: ${KLING_VOICES.slice(0, 5).join(", ")}\u2026 or one of your own from listVoices().`
+      );
+    }
+    try {
+      const data = await this.request("/v1/audio/tts", {
+        method: "POST",
+        body: {
+          // snake_case: camelCase falls into another DTO and misreports.
+          voice_id: voiceId,
+          voice_language: params.language ?? "en",
+          text: params.prompt,
+          ...params.speed !== void 0 ? { voice_speed: params.speed } : {},
+          ...params.providerOptions?.kling ?? {}
+        }
+      });
+      const url = data.audio_url ?? data.url;
+      if (!url) return failure("Kling returned no audio URL.");
+      return {
+        success: true,
+        outputs: [
+          {
+            url,
+            mimeType: "audio/mpeg",
+            taskId: data.id,
+            expiresAt: expiresInHours(24 * 30),
+            raw: { voiceId, characters: params.prompt.length }
+          }
+        ],
+        creditsUsed: 0,
+        provider: this.providerName,
+        model: modelId,
+        processingTimeMs: Date.now() - startedAt
+      };
+    } catch (error) {
+      return failure(error instanceof Error ? error.message : String(error));
+    }
+  }
+  generateText(_params) {
+    throw new Error("Kling does not generate text.");
+  }
+  async estimateCost(type, params) {
+    return estimateFor(this.providerName, type, params);
+  }
+  supportsModel(model) {
+    return model in KLING_MODELS;
+  }
+  getAvailableModels() {
+    return Object.entries(KLING_MODELS).map(([id, binding]) => ({
+      id,
+      name: id,
+      type: binding.kind
+    }));
+  }
+};
+
+// src/adapters/openai.adapter.ts
+var DEFAULT_BASE_URL5 = "https://api.openai.com";
+var IMAGES_PATH2 = "/v1/images/generations";
+var OpenAIAdapter = class {
+  providerName = "openai";
+  // No video: the Videos API shuts down on 24 September 2026.
+  supportedTypes = ["image"];
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  get baseUrl() {
+    return (this.opts.baseUrl ?? DEFAULT_BASE_URL5).replace(/\/$/, "");
+  }
+  binding(modelId) {
+    const id = modelId ?? "";
+    const found = OPENAI_IMAGE_MODELS[id];
+    if (!found) {
+      throw new Error(
+        `"${id}" is not an OpenAI image model. Known: ${Object.keys(OPENAI_IMAGE_MODELS).join(", ")}.`
+      );
+    }
+    return [id, found];
+  }
+  buildBody(modelId, binding, params) {
+    const quality = params.quality ?? "medium";
+    if (!binding.qualities.includes(quality)) {
+      throw new Error(
+        `OpenAI "${modelId}" offers ${binding.qualities.join(", ")}, not ${quality}.`
+      );
+    }
+    if (params.resolution && binding.sizes !== "any") {
+      if (!binding.sizes.includes(params.resolution)) {
+        throw new Error(
+          `OpenAI "${modelId}" accepts ${binding.sizes.join(", ")}, not ${params.resolution}.`
+        );
+      }
+    }
+    if (params.resolution && binding.sizes === "any") {
+      const [w, h] = params.resolution.split("x").map(Number);
+      if (w && h && (w % 16 !== 0 || h % 16 !== 0)) {
+        throw new Error(
+          `OpenAI "${modelId}" needs both edges divisible by 16; got ${params.resolution}.`
+        );
+      }
+    }
+    const body = {
+      // Omitting it historically defaulted to dall-e-2, which is shut down.
+      model: modelId,
+      prompt: params.prompt,
+      n: 1,
+      quality
+    };
+    if (params.resolution) body.size = params.resolution;
+    if (params.outputFormat) body.output_format = params.outputFormat;
+    return { ...body, ...params.providerOptions?.openai ?? {} };
+  }
+  async generateImage(params) {
+    const startedAt = Date.now();
+    let modelId = params.model ?? "";
+    const failure = (error) => ({
+      success: false,
+      outputs: [],
+      creditsUsed: 0,
+      provider: this.providerName,
+      model: modelId,
+      processingTimeMs: Date.now() - startedAt,
+      error
+    });
+    try {
+      const [id, binding] = this.binding(params.model);
+      modelId = id;
+      const response = await fetch(`${this.baseUrl}${IMAGES_PATH2}`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.opts.apiKey}`,
+          "Content-Type": "application/json",
+          ...this.opts.organization ? { "OpenAI-Organization": this.opts.organization } : {}
+        },
+        body: JSON.stringify(this.buildBody(id, binding, params))
+      });
+      const payload = await response.json();
+      if (payload.error) throw new Error(payload.error.message);
+      if (!response.ok) {
+        throw new Error(`OpenAI returned ${response.status}.`);
+      }
+      const format = params.outputFormat ?? "png";
+      const outputs = (payload.data ?? []).map((item) => {
+        if (item.b64_json) {
+          return {
+            url: `data:image/${format};base64,${item.b64_json}`,
+            mimeType: `image/${format}`,
+            raw: { inline: true, revisedPrompt: item.revised_prompt }
+          };
+        }
+        if (item.url) {
+          return { url: item.url, mimeType: `image/${format}` };
+        }
+        return void 0;
+      }).filter((output) => Boolean(output));
+      if (outputs.length === 0) return failure("OpenAI returned no image.");
+      return {
+        success: true,
+        outputs,
+        creditsUsed: 0,
+        provider: this.providerName,
+        model: modelId,
+        processingTimeMs: Date.now() - startedAt
+      };
+    } catch (error) {
+      return failure(error instanceof Error ? error.message : String(error));
+    }
+  }
+  generateVideo(_params) {
+    throw new Error(
+      "OpenAI has no supported video API \u2014 Sora and the Videos API shut down on 24 September 2026."
+    );
+  }
+  generateAudio(_params) {
+    throw new Error("OpenAI has no speech synthesis wired up here.");
+  }
+  generateText(_params) {
+    throw new Error("The OpenAI adapter here covers images only.");
+  }
+  /** Synchronous provider: there is never a queued job to come back to. */
+  async completeJob(job) {
+    return {
+      status: "failed",
+      error: `OpenAI answers inline, so job ${job.id} has nothing to resume.`
+    };
+  }
+  async estimateCost(type, params) {
+    const quality = params.quality === "low" ? "low" : params.quality === "high" ? "high" : "medium";
+    const binding = OPENAI_IMAGE_MODELS[params.model ?? ""];
+    const base = estimateFor(this.providerName, type, params);
+    if (!binding) return base;
+    return {
+      ...base,
+      usd: binding.usd[quality],
+      note: `At ${quality} quality and 1024x1024. Low is ${binding.usd.low}, high is ${binding.usd.high} \u2014 the tier moves the price by more than 30x.`
+    };
+  }
+  supportsModel(model) {
+    return model in OPENAI_IMAGE_MODELS;
+  }
+  getAvailableModels() {
+    return Object.keys(OPENAI_IMAGE_MODELS).map((id) => ({
+      id,
+      name: id,
+      type: "image"
+    }));
+  }
+};
+
+// src/adapters/qwen.adapter.ts
+var DEFAULT_BASE_URL6 = "https://dashscope-intl.aliyuncs.com";
+var TASKS_PATH2 = "/api/v1/tasks";
+var POLL_INTERVAL_MS4 = 5e3;
+var DEFAULT_MAX_POLL_ATTEMPTS4 = 240;
+var QwenAdapter = class {
+  providerName = "qwen";
+  supportedTypes = ["image", "video"];
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  get baseUrl() {
+    return (this.opts.baseUrl ?? DEFAULT_BASE_URL6).replace(/\/$/, "");
+  }
+  async request(path, init) {
+    const headers = {
+      Authorization: `Bearer ${this.opts.apiKey}`,
+      "Content-Type": "application/json"
+    };
+    if (init?.async) headers["X-DashScope-Async"] = "enable";
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      method: init?.method ?? "GET",
+      headers,
+      body: init ? JSON.stringify(init.body) : void 0
+    });
+    const payload = await response.json();
+    if (payload.code) {
+      throw new Error(`${payload.code}: ${payload.message ?? "unknown"}`);
+    }
+    return payload;
+  }
+  binding(modelId) {
+    const id = modelId ?? "";
+    const found = QWEN_VIDEO_MODELS[id];
+    if (!found) {
+      throw new Error(
+        `"${id}" is not a Qwen video model. Known: ${Object.keys(QWEN_VIDEO_MODELS).join(", ")}.`
+      );
+    }
+    return [id, found];
+  }
+  videoBody(modelId, binding, params) {
+    const input = { prompt: params.prompt };
+    if (params.negativePrompt) input.negative_prompt = params.negativePrompt;
+    const first = params.imageUrl ?? params.referenceImages?.[0];
+    const last = params.referenceImages?.[1];
+    const references = params.imageUrls ?? [];
+    switch (binding.shape) {
+      case "kf2v": {
+        if (!first || !last) {
+          throw new Error(
+            `Qwen "${modelId}" needs a first and a last frame \u2014 pass both in referenceImages.`
+          );
+        }
+        input.first_frame_url = first;
+        input.last_frame_url = last;
+        break;
+      }
+      case "img_url": {
+        if (!first) {
+          throw new Error(`Qwen "${modelId}" needs an image \u2014 pass imageUrl.`);
+        }
+        input.img_url = first;
+        break;
+      }
+      case "reference_urls": {
+        if (references.length === 0) {
+          throw new Error(
+            `Qwen "${modelId}" needs reference images \u2014 pass imageUrls.`
+          );
+        }
+        input.reference_urls = references;
+        break;
+      }
+      case "media": {
+        const media = [];
+        if (binding.mode === "video-edit") {
+          const video = params.videoUrl ?? params.videoUrls?.[0];
+          if (!video) {
+            throw new Error(`Qwen "${modelId}" needs a video \u2014 pass videoUrl.`);
+          }
+          media.push({ type: "video", url: video });
+        } else if (binding.mode === "r2v") {
+          for (const url of references) {
+            media.push({ type: "reference_image", url });
+          }
+        } else if (first) {
+          media.push({ type: "first_frame", url: first });
+          if (last) media.push({ type: "last_frame", url: last });
+        }
+        if (media.length > 0) input.media = media;
+        break;
+      }
+    }
+    const parameters = {};
+    if (binding.sizing === "size") {
+      if (params.resolution) parameters.size = params.resolution;
+    } else {
+      parameters.resolution = params.resolution ?? "720P";
+      if (params.aspectRatio && params.aspectRatio !== "auto") {
+        parameters.ratio = params.aspectRatio;
+      }
+    }
+    if (params.duration !== void 0) parameters.duration = params.duration;
+    if (params.seed !== void 0) parameters.seed = params.seed;
+    parameters.prompt_extend = false;
+    if (binding.watermarkOnByDefault) parameters.watermark = false;
+    return {
+      model: modelId,
+      input,
+      // The caller's escape hatch wins, since they asked for it by name.
+      parameters: { ...parameters, ...params.providerOptions?.qwen ?? {} }
+    };
+  }
+  outputsFrom(payload, kind) {
+    const output = payload.output;
+    if (!output) return [];
+    const urls = [
+      ...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))
+      )
+    ];
+    return urls.map((url) => ({
+      url,
+      mimeType: kind === "video" ? "video/mp4" : "image/png",
+      taskId: output.task_id,
+      durationSeconds: payload.usage?.duration,
+      // The OSS link is presigned and stated as valid for 24 hours.
+      expiresAt: expiresInHours(24),
+      raw: { size: payload.usage?.size }
+    }));
+  }
+  snapshot(payload, job) {
+    const status = payload.output?.task_status;
+    if (status === "FAILED" || status === "CANCELED" || status === "CANCELLED" || // An unknown task id is expired or wrong: terminal, not worth retrying.
+    status === "UNKNOWN") {
+      const output = payload.output;
+      const reason = output?.message ?? `DashScope reported ${status}.`;
+      return {
+        status: "failed",
+        error: output?.code ? `${output.code}: ${reason}` : reason
+      };
+    }
+    if (status !== "SUCCEEDED") return { status: "pending" };
+    const outputs = this.outputsFrom(payload, job.kind);
+    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(kind, 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 taskId;
+    try {
+      const [id, binding] = this.binding(params.model);
+      modelId = id;
+      if (binding.resolutions && params.resolution) {
+        if (!binding.resolutions.includes(params.resolution)) {
+          throw new Error(
+            `Qwen "${id}" supports ${binding.resolutions.join(", ")}, not ${params.resolution}.`
+          );
+        }
+      }
+      const payload = await this.request(videoPathFor(binding), {
+        method: "POST",
+        body: this.videoBody(id, binding, params),
+        async: true
+      });
+      const submitted = payload.output?.task_id;
+      if (!submitted) {
+        throw new Error(
+          "DashScope accepted the request but returned no task id."
+        );
+      }
+      taskId = submitted;
+    } catch (error) {
+      return failure(error instanceof Error ? error.message : String(error));
+    }
+    if (isSubmitMode()) {
+      throw new PendingJob(taskId, TASKS_PATH2);
+    }
+    const job = {
+      id: taskId,
+      provider: this.providerName,
+      model: modelId,
+      kind,
+      pollEndpoint: TASKS_PATH2,
+      params,
+      submittedAt: new Date(startedAt).toISOString()
+    };
+    const maxAttempts = this.opts.maxPollAttempts ?? DEFAULT_MAX_POLL_ATTEMPTS4;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const snapshot = await this.completeJob(job);
+      if (snapshot.status === "failed") {
+        return failure(snapshot.error ?? "DashScope task failed.");
+      }
+      if (snapshot.status === "succeeded" && snapshot.result) {
+        return { ...snapshot.result, processingTimeMs: Date.now() - startedAt };
+      }
+      await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS4));
+    }
+    return failure(
+      `DashScope task ${taskId} did not finish after ${maxAttempts} checks.`
+    );
+  }
+  /** Resume a job submitted earlier, possibly by another process. */
+  async completeJob(job) {
+    try {
+      const payload = await this.request(
+        `${job.pollEndpoint ?? TASKS_PATH2}/${encodeURIComponent(job.id)}`
+      );
+      return this.snapshot(payload, job);
+    } catch (error) {
+      return {
+        status: "failed",
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  generateVideo(params) {
+    return this.run("video", params);
+  }
+  /**
+   * Every image model wired up here answers inline, so this makes no task.
+   *
+   * That is not a style choice: sending `X-DashScope-Async: enable` to a
+   * sync-only model returns 429, which reads as rate limiting and never clears
+   * on retry. The header is gated on the model's own flag for that reason.
+   */
+  async generateImage(params) {
+    const startedAt = Date.now();
+    const modelId = params.model ?? "";
+    const failure = (error) => ({
+      success: false,
+      outputs: [],
+      creditsUsed: 0,
+      provider: this.providerName,
+      model: modelId,
+      processingTimeMs: Date.now() - startedAt,
+      error
+    });
+    const binding = QWEN_IMAGE_MODELS[modelId];
+    if (!binding) {
+      return failure(
+        `"${modelId}" is not a Qwen image model. Known: ${Object.keys(QWEN_IMAGE_MODELS).join(", ")}.`
+      );
+    }
+    try {
+      const content = [];
+      for (const image of params.referenceImages ?? []) {
+        content.push({ image });
+      }
+      content.push({ text: params.prompt });
+      const parameters = {
+        // Several models default to 4, and billing is per image produced.
+        n: 1,
+        // Defaults to true and silently rewrites the prompt through an LLM.
+        prompt_extend: false
+      };
+      if (params.resolution) parameters.size = params.resolution;
+      const payload = await this.request(QWEN_IMAGE_PATHS[binding.path], {
+        method: "POST",
+        body: binding.body === "messages" ? {
+          model: modelId,
+          // The qwen-image family takes chat-style messages.
+          input: { messages: [{ role: "user", content }] },
+          parameters
+        } : {
+          model: modelId,
+          input: { prompt: params.prompt },
+          parameters
+        },
+        // Gated deliberately: see the note above.
+        async: !binding.sync
+      });
+      const outputs = this.outputsFrom(payload, "image");
+      if (outputs.length === 0) {
+        const reason = payload.output?.message ?? payload.message;
+        return failure(reason ?? "DashScope returned no image.");
+      }
+      return {
+        success: true,
+        outputs,
+        creditsUsed: 0,
+        provider: this.providerName,
+        model: modelId,
+        processingTimeMs: Date.now() - startedAt
+      };
+    } catch (error) {
+      return failure(error instanceof Error ? error.message : String(error));
+    }
+  }
+  /**
+   * Speech. Synchronous: the audio URL comes back on the same response, with a
+   * real expiry attached rather than one we guess at.
+   */
+  async generateAudio(params) {
+    const startedAt = Date.now();
+    const modelId = params.model ?? "";
+    const failure = (error) => ({
+      success: false,
+      outputs: [],
+      creditsUsed: 0,
+      provider: this.providerName,
+      model: modelId,
+      processingTimeMs: Date.now() - startedAt,
+      error
+    });
+    const binding = QWEN_AUDIO_MODELS[modelId];
+    if (!binding) {
+      return failure(
+        `"${modelId}" is not a Qwen speech model. Known: ${Object.keys(QWEN_AUDIO_MODELS).join(", ")}.`
+      );
+    }
+    const voice = params.voice ?? binding.voices[0];
+    if (!binding.voices.includes(voice)) {
+      return failure(
+        `Qwen "${modelId}" offers ${binding.voices.join(", ")}, not "${voice}".`
+      );
+    }
+    try {
+      const payload = await this.request(
+        "/api/v1/services/aigc/multimodal-generation/generation",
+        {
+          method: "POST",
+          body: {
+            model: modelId,
+            input: { text: params.prompt },
+            parameters: {
+              voice,
+              ...params.outputFormat ? { format: params.outputFormat } : {},
+              ...params.providerOptions?.qwen ?? {}
+            }
+          }
+        }
+      );
+      const audio = payload.output?.audio;
+      if (!audio?.url) return failure("Qwen returned no audio.");
+      return {
+        success: true,
+        outputs: [
+          {
+            url: audio.url,
+            mimeType: `audio/${params.outputFormat ?? "mp3"}`,
+            taskId: audio.id,
+            // A real timestamp from the provider, not an assumed window.
+            expiresAt: audio.expires_at ? new Date(audio.expires_at * 1e3).toISOString() : void 0,
+            raw: { characters: payload.usage?.characters }
+          }
+        ],
+        creditsUsed: 0,
+        provider: this.providerName,
+        model: modelId,
+        processingTimeMs: Date.now() - startedAt
+      };
+    } catch (error) {
+      return failure(error instanceof Error ? error.message : String(error));
+    }
+  }
+  /** Text, through the OpenAI-compatible surface. Synchronous. */
+  async generateText(params) {
+    const startedAt = Date.now();
+    const modelId = params.model ?? "";
+    const failure = (error) => ({
+      success: false,
+      outputs: [],
+      creditsUsed: 0,
+      provider: this.providerName,
+      model: modelId,
+      processingTimeMs: Date.now() - startedAt,
+      error
+    });
+    if (!(modelId in QWEN_TEXT_MODELS)) {
+      return failure(
+        `"${modelId}" is not a Qwen text model. Known: ${Object.keys(QWEN_TEXT_MODELS).join(", ")}.`
+      );
+    }
+    try {
+      const response = await fetch(
+        `${this.baseUrl}/compatible-mode/v1/chat/completions`,
+        {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${this.opts.apiKey}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            model: modelId,
+            messages: [
+              ...params.systemPrompt ? [{ role: "system", content: params.systemPrompt }] : [],
+              { role: "user", content: params.prompt }
+            ],
+            ...params.maxTokens ? { max_tokens: params.maxTokens } : {},
+            ...params.temperature !== void 0 ? { temperature: params.temperature } : {},
+            ...params.providerOptions?.qwen ?? {}
+          })
+        }
+      );
+      const payload = await response.json();
+      if (payload.error) throw new Error(payload.error.message ?? "rejected");
+      const text = payload.choices?.[0]?.message?.content;
+      if (!text) return failure("Qwen returned no text.");
+      return {
+        success: true,
+        // Text has no file, so it rides as a data URI and stays uniform.
+        outputs: [
+          {
+            url: `data:text/plain;base64,${Buffer.from(text).toString("base64")}`,
+            mimeType: "text/plain",
+            raw: { text, tokens: payload.usage?.completion_tokens }
+          }
+        ],
+        creditsUsed: 0,
+        provider: this.providerName,
+        model: modelId,
+        processingTimeMs: Date.now() - startedAt
+      };
+    } catch (error) {
+      return failure(error instanceof Error ? error.message : String(error));
+    }
+  }
+  async estimateCost(type, params) {
+    return estimateFor(this.providerName, type, params);
+  }
+  supportsModel(model) {
+    return model in QWEN_VIDEO_MODELS || model in QWEN_IMAGE_MODELS || model in QWEN_AUDIO_MODELS || model in QWEN_TEXT_MODELS;
+  }
+  getAvailableModels() {
+    return [
+      ...Object.keys(QWEN_VIDEO_MODELS).map((id) => ({
+        id,
+        name: id,
+        type: "video"
+      })),
+      ...Object.keys(QWEN_IMAGE_MODELS).map((id) => ({
+        id,
+        name: id,
+        type: "image"
+      }))
+    ];
+  }
+};
+
+// src/helpers/result.ts
+function ok(data) {
+  return { data, error: null };
+}
+function fail(error) {
+  return { data: null, error };
+}
+function failFrom(code, cause, context) {
+  return fail({
+    code,
+    message: cause instanceof Error ? cause.message : String(cause),
+    cause,
+    ...context
+  });
+}
+
+// src/lib/storage.ts
+async function loadS3(config) {
+  let s3;
+  try {
+    s3 = await import("@aws-sdk/client-s3");
+  } catch {
+    throw new Error(
+      "Configuring `storage` needs @aws-sdk/client-s3. Install it: bun add @aws-sdk/client-s3 @aws-sdk/s3-request-presigner"
+    );
+  }
+  const client = new s3.S3Client({
+    region: config.region ?? "us-east-1",
+    endpoint: config.endpoint,
+    // Custom hosts (R2, MinIO) serve one bucket per path, not per subdomain.
+    forcePathStyle: Boolean(config.endpoint),
+    credentials: {
+      accessKeyId: config.accessKeyId,
+      secretAccessKey: config.secretAccessKey
+    }
+  });
+  return { client, ...s3 };
+}
+function keyFor(config, filename) {
+  const prefix = config.prefix?.replace(/^\/|\/$/g, "");
+  const stamp = Date.now();
+  const safe = filename.replace(/[^\w.-]/g, "_");
+  return prefix ? `${prefix}/${stamp}-${safe}` : `${stamp}-${safe}`;
+}
+function extensionFor(url, mimeType) {
+  const fromUrl = new URL(url).pathname.split(".").pop();
+  if (fromUrl && fromUrl.length <= 5 && /^[a-z0-9]+$/i.test(fromUrl)) {
+    return fromUrl;
+  }
+  if (mimeType?.startsWith("video/")) return "mp4";
+  if (mimeType === "image/jpeg") return "jpg";
+  return "png";
+}
+function createS3Storage(config) {
+  let loaded;
+  async function s3() {
+    loaded ??= await loadS3(config);
+    return loaded;
+  }
+  async function urlFor(key) {
+    if (config.publicUrl) {
+      return `${config.publicUrl.replace(/\/$/, "")}/${key}`;
+    }
+    const { client, GetObjectCommand } = await s3();
+    let presigner;
+    try {
+      presigner = await import("@aws-sdk/s3-request-presigner");
+    } catch {
+      throw new Error(
+        "Signing a URL needs @aws-sdk/s3-request-presigner, or set storage.publicUrl to skip signing."
+      );
+    }
+    return presigner.getSignedUrl(
+      client,
+      new GetObjectCommand({ Bucket: config.bucket, Key: key }),
+      { expiresIn: config.signedUrlExpiresIn ?? 3600 }
+    );
+  }
+  return {
+    async upload(buffer, filename, mimeType) {
+      const { client, PutObjectCommand } = await s3();
+      const key = keyFor(config, filename);
+      await client.send(
+        new PutObjectCommand({
+          Bucket: config.bucket,
+          Key: key,
+          Body: buffer,
+          ContentType: mimeType
+        })
+      );
+      return urlFor(key);
+    },
+    async persist(url, mimeType) {
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(
+          `Could not fetch ${url} to persist it: ${response.status} ${response.statusText}`
+        );
+      }
+      const buffer = Buffer.from(await response.arrayBuffer());
+      const contentType = mimeType ?? response.headers.get("content-type") ?? "application/octet-stream";
+      const { client, PutObjectCommand } = await s3();
+      const key = keyFor(config, `output.${extensionFor(url, contentType)}`);
+      await client.send(
+        new PutObjectCommand({
+          Bucket: config.bucket,
+          Key: key,
+          Body: buffer,
+          ContentType: contentType
+        })
+      );
+      return urlFor(key);
+    }
+  };
+}
+async function persistOutputs(storage, outputs) {
+  return Promise.all(
+    outputs.map(async (output) => {
+      try {
+        const url = await storage.persist(output.url, output.mimeType);
+        return {
+          ...output,
+          url,
+          sourceUrl: output.url,
+          // The copy is ours now, so the provider's clock no longer applies.
+          expiresAt: void 0
+        };
+      } catch (error) {
+        console.warn(
+          `[storage] Kept the provider URL for ${output.url}:`,
+          error
+        );
+        return output;
+      }
+    })
+  );
+}
+
+// src/client.ts
+var NATIVE_PROVIDERS = [
+  "byteplus",
+  "elevenlabs",
+  "google",
+  "kling",
+  "openai",
+  "qwen"
+];
+function brotuClient(options) {
+  if (Object.keys(options.providers).length === 0) {
+    throw new Error("brotuClient requires at least one provider API key.");
+  }
+  registerModels(options.models);
+  const storage = options.storage ? createS3Storage(options.storage) : void 0;
+  const shouldPersist = storage && options.storage?.persistOutputs !== false;
+  const adapters = /* @__PURE__ */ new Map();
+  function route(modelId) {
+    if (!modelId) {
+      return fail({
+        code: "invalid_request",
+        message: "Pass a model id \u2014 this SDK ships no implicit default."
+      });
+    }
+    const model = getModel(modelId);
+    if (!model) {
+      return fail({
+        code: "unknown_model",
+        message: `Unknown model "${modelId}".`,
+        model: modelId
+      });
+    }
+    let provider;
+    try {
+      provider = resolveProvider(modelId, options);
+    } catch (error) {
+      return failFrom("missing_key", error, { model: modelId });
+    }
+    let adapter = adapters.get(provider.id);
+    if (!adapter) {
+      const built = buildAdapter(provider);
+      if (!built) {
+        return fail({
+          code: "unsupported_provider",
+          message: `No adapter ships for provider "${provider.id}". Native providers: ${NATIVE_PROVIDERS.join(", ")}.`,
+          provider: provider.id,
+          model: modelId
+        });
+      }
+      adapter = built;
+      adapters.set(provider.id, adapter);
+    }
+    return ok({ adapter, provider: provider.id, model: modelId });
+  }
+  function buildAdapter(provider) {
+    if (provider.id === "kling") {
+      return new KlingAdapter({
+        apiKey: provider.apiKey,
+        baseUrl: provider.baseUrl
+      });
+    }
+    if (provider.id === "byteplus") {
+      return new BytePlusAdapter({
+        apiKey: provider.apiKey,
+        baseUrl: provider.baseUrl
+      });
+    }
+    if (provider.id === "qwen") {
+      return new QwenAdapter({
+        apiKey: provider.apiKey,
+        baseUrl: provider.baseUrl
+      });
+    }
+    if (provider.id === "openai") {
+      return new OpenAIAdapter({
+        apiKey: provider.apiKey,
+        baseUrl: provider.baseUrl
+      });
+    }
+    if (provider.id === "elevenlabs") {
+      return new ElevenLabsAdapter({
+        apiKey: provider.apiKey,
+        baseUrl: provider.baseUrl,
+        defaultVoiceId: options.elevenLabsVoiceId
+      });
+    }
+    if (provider.id === "google") {
+      return new GoogleAdapter({
+        apiKey: provider.apiKey,
+        baseUrl: provider.baseUrl
+      });
+    }
+    return void 0;
+  }
+  function generateWith(adapter, kind, params) {
+    if (kind === "image")
+      return adapter.generateImage(params);
+    if (kind === "video")
+      return adapter.generateVideo(params);
+    if (kind === "audio")
+      return adapter.generateAudio(params);
+    return adapter.generateText(params);
+  }
+  async function toGeneration(raw, metadata) {
+    if (!raw.success) {
+      return fail({
+        code: "provider_error",
+        message: raw.error ?? "The provider failed without saying why.",
+        provider: raw.provider,
+        model: raw.model
+      });
+    }
+    const outputs = shouldPersist && storage ? await persistOutputs(storage, raw.outputs) : raw.outputs;
+    return ok({
+      outputs,
+      provider: raw.provider,
+      model: raw.model,
+      processingTimeMs: raw.processingTimeMs,
+      metadata
+    });
+  }
+  async function generate(kind, params) {
+    const routed = route(params.model);
+    if (routed.error) return fail(routed.error);
+    try {
+      return await toGeneration(
+        await generateWith(routed.data.adapter, kind, params),
+        params.metadata
+      );
+    } catch (error) {
+      return failFrom("provider_error", error, {
+        provider: routed.data.provider,
+        model: routed.data.model
+      });
+    }
+  }
+  async function submit(kind, params) {
+    const routed = route(params.model);
+    if (routed.error) return fail(routed.error);
+    const base = {
+      provider: routed.data.provider,
+      model: routed.data.model,
+      kind,
+      params,
+      metadata: params.metadata,
+      submittedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    try {
+      const raw = await runInSubmitMode(
+        () => generateWith(routed.data.adapter, kind, params)
+      );
+      if (!raw.success) {
+        return fail({
+          code: "provider_error",
+          message: raw.error ?? "The provider rejected the request.",
+          provider: raw.provider,
+          model: raw.model
+        });
+      }
+      return ok({
+        ...base,
+        id: `inline-${base.model}-${base.submittedAt}`,
+        result: raw
+      });
+    } catch (error) {
+      if (!isPendingJob(error)) {
+        return failFrom("provider_error", error, {
+          provider: base.provider,
+          model: base.model
+        });
+      }
+      return ok({
+        ...base,
+        id: error.taskId,
+        pollEndpoint: error.pollEndpoint
+      });
+    }
+  }
+  async function pollJob(job) {
+    if (job.result) {
+      return ok(
+        job.result.success ? { status: "succeeded", result: job.result } : { status: "failed", error: job.result.error }
+      );
+    }
+    const routed = route(job.model);
+    if (routed.error) return fail(routed.error);
+    const adapter = routed.data.adapter;
+    if (typeof adapter.completeJob !== "function") {
+      return fail({
+        code: "unsupported_provider",
+        message: `Provider "${job.provider}" cannot resume a job by handle.`,
+        provider: job.provider
+      });
+    }
+    try {
+      return ok(await adapter.completeJob(job));
+    } catch (error) {
+      return failFrom("provider_error", error, {
+        provider: job.provider,
+        model: job.model
+      });
+    }
+  }
+  function klingNamespace() {
+    const configured = options.providers.kling;
+    if (!configured) return void 0;
+    const adapter = new KlingAdapter({
+      apiKey: configured.apiKey,
+      baseUrl: configured.baseUrl ?? "https://api-singapore.klingai.com"
+    });
+    function run(name) {
+      return async (input) => {
+        try {
+          const capability = KLING_CAPABILITIES[name];
+          return ok(await adapter.submitCapability(name, capability, input));
+        } catch (error) {
+          return failFrom("provider_error", error, { provider: "kling" });
+        }
+      };
+    }
+    return {
+      motionControl: run("motionControl"),
+      omniVideo: run("omniVideo"),
+      avatar: run("avatar"),
+      outpainting: run("outpainting"),
+      imageOmni: run("imageOmni")
+    };
+  }
+  function googleNamespace() {
+    const configured = options.providers.google;
+    if (!configured) return void 0;
+    const adapter = new GoogleAdapter({
+      apiKey: configured.apiKey,
+      baseUrl: configured.baseUrl
+    });
+    return {
+      omniVideo: async (input) => {
+        try {
+          return ok(await adapter.omniVideo(input));
+        } catch (error) {
+          return failFrom("provider_error", error, { provider: "google" });
+        }
+      }
+    };
+  }
+  return {
+    google: googleNamespace(),
+    kling: klingNamespace(),
+    image: {
+      submit: (params) => submit("image", params),
+      generate: (params) => generate("image", params)
+    },
+    video: {
+      submit: (params) => submit("video", params),
+      generate: (params) => generate("video", params)
+    },
+    text: {
+      submit: (params) => submit("text", params),
+      generate: (params) => generate("text", params)
+    },
+    audio: {
+      submit: (params) => submit("audio", params),
+      generate: (params) => generate("audio", params)
+    },
+    jobs: {
+      poll: pollJob,
+      wait: async (job, waitOptions) => {
+        const deadline = Date.now() + (waitOptions?.timeoutMs ?? 30 * 6e4);
+        for (; ; ) {
+          const polled = await pollJob(job);
+          if (polled.error) return fail(polled.error);
+          const snapshot = polled.data;
+          if (snapshot.status === "succeeded" && snapshot.result) {
+            return toGeneration(snapshot.result, job.metadata);
+          }
+          if (snapshot.status === "failed") {
+            return fail({
+              code: "provider_error",
+              message: snapshot.error ?? "The job failed.",
+              provider: job.provider,
+              model: job.model
+            });
+          }
+          if (Date.now() >= deadline) {
+            return fail({
+              code: "timeout",
+              message: `Job ${job.id} is still running. Poll it again later.`,
+              provider: job.provider,
+              model: job.model
+            });
+          }
+          await new Promise((resolve) => setTimeout(resolve, 3e3));
+        }
+      }
+    },
+    models: () => getAvailableModels(options),
+    estimateCost: async (type, params) => {
+      const routed = route(params.model);
+      if (routed.error) return fail(routed.error);
+      try {
+        return ok(await routed.data.adapter.estimateCost(type, params));
+      } catch (error) {
+        return failFrom("provider_error", error, {
+          provider: routed.data.provider,
+          model: routed.data.model
+        });
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BYTEPLUS_CATALOG,
+  BYTEPLUS_MODELS,
+  BytePlusAdapter,
+  ELEVENLABS_CATALOG,
+  ELEVENLABS_MODELS,
+  ELEVENLABS_OUTPUT_FORMATS,
+  ElevenLabsAdapter,
+  GOOGLE_CATALOG,
+  GOOGLE_IMAGE_MODELS,
+  GOOGLE_VIDEO_MODELS,
+  GoogleAdapter,
+  KLING_CAPABILITIES,
+  KLING_CATALOG,
+  KLING_MODELS,
+  KlingAdapter,
+  OPENAI_CATALOG,
+  OPENAI_IMAGE_MODELS,
+  OpenAIAdapter,
+  PendingJob,
+  QWEN_AUDIO_MODELS,
+  QWEN_CATALOG,
+  QWEN_IMAGE_MODELS,
+  QWEN_TEXT_MODELS,
+  QWEN_VIDEO_MODELS,
+  QwenAdapter,
+  brotuClient,
+  createS3Storage,
+  fail,
+  getAvailableModels,
+  getModel,
+  getModels,
+  getProviders,
+  hasModel,
+  isPendingJob,
+  ok,
+  persistOutputs,
+  registerModels,
+  resetCatalog,
+  resolveProvider
+});