@ai-sdk/black-forest-labs 1.0.49 → 1.0.50

package/dist/index.js

@@ -27,12 +27,53 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/black-forest-labs-provider.ts
-var import_provider = require("@ai-sdk/provider");
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
+var import_provider2 = require("@ai-sdk/provider");
+var import_provider_utils5 = require("@ai-sdk/provider-utils");
 
 // src/black-forest-labs-image-model.ts
+var import_provider_utils2 = require("@ai-sdk/provider-utils");
+var import_v42 = require("zod/v4");
+
+// src/black-forest-labs-api.ts
 var import_provider_utils = require("@ai-sdk/provider-utils");
 var import_v4 = require("zod/v4");
+var bflErrorSchema = import_v4.z.object({
+  message: import_v4.z.string().optional(),
+  detail: import_v4.z.any().optional()
+});
+function bflErrorToMessage(error) {
+  const parsed = bflErrorSchema.safeParse(error);
+  if (!parsed.success) return void 0;
+  const { message, detail } = parsed.data;
+  if (typeof detail === "string") return detail;
+  if (detail != null) {
+    try {
+      return JSON.stringify(detail);
+    } catch (e) {
+    }
+  }
+  return message;
+}
+var bflFailedResponseHandler = (0, import_provider_utils.createJsonErrorResponseHandler)({
+  errorSchema: bflErrorSchema,
+  errorToMessage: (error) => {
+    var _a;
+    return (_a = bflErrorToMessage(error)) != null ? _a : "Unknown Black Forest Labs error";
+  }
+});
+function isTrustedUrl(url, baseUrl) {
+  if ((0, import_provider_utils.isSameOrigin)(url, baseUrl)) {
+    return true;
+  }
+  try {
+    const { protocol, hostname } = new URL(url);
+    return protocol === "https:" && (hostname === "bfl.ai" || hostname.endsWith(".bfl.ai"));
+  } catch (e) {
+    return false;
+  }
+}
+
+// src/black-forest-labs-image-model.ts
 var DEFAULT_POLL_INTERVAL_MILLIS = 500;
 var DEFAULT_POLL_TIMEOUT_MILLIS = 6e4;
 var BlackForestLabsImageModel = class {
@@ -70,7 +111,7 @@ var BlackForestLabsImageModel = class {
         details: "Black Forest Labs ignores size when aspectRatio is provided. Use the width and height provider options to specify dimensions for models that support them"
       });
     }
-    const bflOptions = await (0, import_provider_utils.parseProviderOptions)({
+    const bflOptions = await (0, import_provider_utils2.parseProviderOptions)({
       provider: "blackForestLabs",
       providerOptions,
       schema: blackForestLabsImageModelOptionsSchema
@@ -151,16 +192,16 @@ var BlackForestLabsImageModel = class {
       abortSignal
     });
     const currentDate = (_c = (_b = (_a = this.config._internal) == null ? void 0 : _a.currentDate) == null ? void 0 : _b.call(_a)) != null ? _c : /* @__PURE__ */ new Date();
-    const combinedHeaders = (0, import_provider_utils.combineHeaders)(
-      await (0, import_provider_utils.resolve)(this.config.headers),
+    const combinedHeaders = (0, import_provider_utils2.combineHeaders)(
+      await (0, import_provider_utils2.resolve)(this.config.headers),
       headers
     );
-    const submit = await (0, import_provider_utils.postJsonToApi)({
+    const submit = await (0, import_provider_utils2.postJsonToApi)({
       url: `${this.config.baseURL}/${this.modelId}`,
       headers: combinedHeaders,
       body,
       failedResponseHandler: bflFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils.createJsonResponseHandler)(bflSubmitSchema),
+      successfulResponseHandler: (0, import_provider_utils2.createJsonResponseHandler)(bflSubmitSchema),
       abortSignal,
       fetch: this.config.fetch
     });
@@ -182,15 +223,15 @@ var BlackForestLabsImageModel = class {
         pollTimeoutMillis: bflOptions == null ? void 0 : bflOptions.pollTimeoutMillis
       }
     });
-    const { value: imageBytes, responseHeaders } = await (0, import_provider_utils.getFromApi)({
+    const { value: imageBytes, responseHeaders } = await (0, import_provider_utils2.getFromApi)({
       url: imageUrl,
       // Only send credentials if the response-supplied URL points back at the
       // provider; the image is typically delivered from a CDN, so the API key
       // must not travel to a foreign host.
       headers: isTrustedUrl(imageUrl, this.config.baseURL) ? combinedHeaders : void 0,
       abortSignal,
-      failedResponseHandler: (0, import_provider_utils.createStatusCodeErrorResponseHandler)(),
-      successfulResponseHandler: (0, import_provider_utils.createBinaryResponseHandler)(),
+      failedResponseHandler: (0, import_provider_utils2.createStatusCodeErrorResponseHandler)(),
+      successfulResponseHandler: (0, import_provider_utils2.createBinaryResponseHandler)(),
       fetch: this.config.fetch
     });
     return {
@@ -240,13 +281,13 @@ var BlackForestLabsImageModel = class {
       url.searchParams.set("id", requestId);
     }
     for (let i = 0; i < maxPollAttempts; i++) {
-      const { value } = await (0, import_provider_utils.getFromApi)({
+      const { value } = await (0, import_provider_utils2.getFromApi)({
         url: url.toString(),
         // The polling URL comes from the provider response; only send
         // credentials when it stays on a trusted provider host.
         headers: isTrustedUrl(url.toString(), this.config.baseURL) ? headers : void 0,
         failedResponseHandler: bflFailedResponseHandler,
-        successfulResponseHandler: (0, import_provider_utils.createJsonResponseHandler)(bflPollSchema),
+        successfulResponseHandler: (0, import_provider_utils2.createJsonResponseHandler)(bflPollSchema),
         abortSignal,
         fetch: this.config.fetch
       });
@@ -268,59 +309,48 @@ var BlackForestLabsImageModel = class {
       if (status === "Error" || status === "Failed") {
         throw new Error("Black Forest Labs generation failed.");
       }
-      await (0, import_provider_utils.delay)(pollIntervalMillis);
+      await (0, import_provider_utils2.delay)(pollIntervalMillis);
     }
     throw new Error("Black Forest Labs generation timed out.");
   }
 };
-function isTrustedUrl(url, baseUrl) {
-  if ((0, import_provider_utils.isSameOrigin)(url, baseUrl)) {
-    return true;
-  }
-  try {
-    const { protocol, hostname } = new URL(url);
-    return protocol === "https:" && (hostname === "bfl.ai" || hostname.endsWith(".bfl.ai"));
-  } catch (e) {
-    return false;
-  }
-}
-var blackForestLabsImageModelOptionsSchema = (0, import_provider_utils.lazySchema)(
-  () => (0, import_provider_utils.zodSchema)(
-    import_v4.z.object({
-      imagePrompt: import_v4.z.string().optional(),
-      imagePromptStrength: import_v4.z.number().min(0).max(1).optional(),
+var blackForestLabsImageModelOptionsSchema = (0, import_provider_utils2.lazySchema)(
+  () => (0, import_provider_utils2.zodSchema)(
+    import_v42.z.object({
+      imagePrompt: import_v42.z.string().optional(),
+      imagePromptStrength: import_v42.z.number().min(0).max(1).optional(),
       /** @deprecated use prompt.images instead */
-      inputImage: import_v4.z.string().optional(),
+      inputImage: import_v42.z.string().optional(),
       /** @deprecated use prompt.images instead */
-      inputImage2: import_v4.z.string().optional(),
+      inputImage2: import_v42.z.string().optional(),
       /** @deprecated use prompt.images instead */
-      inputImage3: import_v4.z.string().optional(),
+      inputImage3: import_v42.z.string().optional(),
       /** @deprecated use prompt.images instead */
-      inputImage4: import_v4.z.string().optional(),
+      inputImage4: import_v42.z.string().optional(),
       /** @deprecated use prompt.images instead */
-      inputImage5: import_v4.z.string().optional(),
+      inputImage5: import_v42.z.string().optional(),
       /** @deprecated use prompt.images instead */
-      inputImage6: import_v4.z.string().optional(),
+      inputImage6: import_v42.z.string().optional(),
       /** @deprecated use prompt.images instead */
-      inputImage7: import_v4.z.string().optional(),
+      inputImage7: import_v42.z.string().optional(),
       /** @deprecated use prompt.images instead */
-      inputImage8: import_v4.z.string().optional(),
+      inputImage8: import_v42.z.string().optional(),
       /** @deprecated use prompt.images instead */
-      inputImage9: import_v4.z.string().optional(),
+      inputImage9: import_v42.z.string().optional(),
       /** @deprecated use prompt.images instead */
-      inputImage10: import_v4.z.string().optional(),
-      steps: import_v4.z.number().int().positive().optional(),
-      guidance: import_v4.z.number().min(0).optional(),
-      width: import_v4.z.number().int().min(256).max(1920).optional(),
-      height: import_v4.z.number().int().min(256).max(1920).optional(),
-      outputFormat: import_v4.z.enum(["jpeg", "png"]).optional(),
-      promptUpsampling: import_v4.z.boolean().optional(),
-      raw: import_v4.z.boolean().optional(),
-      safetyTolerance: import_v4.z.number().int().min(0).max(6).optional(),
-      webhookSecret: import_v4.z.string().optional(),
-      webhookUrl: import_v4.z.url().optional(),
-      pollIntervalMillis: import_v4.z.number().int().positive().optional(),
-      pollTimeoutMillis: import_v4.z.number().int().positive().optional()
+      inputImage10: import_v42.z.string().optional(),
+      steps: import_v42.z.number().int().positive().optional(),
+      guidance: import_v42.z.number().min(0).optional(),
+      width: import_v42.z.number().int().min(256).max(1920).optional(),
+      height: import_v42.z.number().int().min(256).max(1920).optional(),
+      outputFormat: import_v42.z.enum(["jpeg", "png"]).optional(),
+      promptUpsampling: import_v42.z.boolean().optional(),
+      raw: import_v42.z.boolean().optional(),
+      safetyTolerance: import_v42.z.number().int().min(0).max(6).optional(),
+      webhookSecret: import_v42.z.string().optional(),
+      webhookUrl: import_v42.z.url().optional(),
+      pollIntervalMillis: import_v42.z.number().int().positive().optional(),
+      pollTimeoutMillis: import_v42.z.number().int().positive().optional()
     })
   )
 );
@@ -344,30 +374,30 @@ function gcd(a, b) {
   }
   return x;
 }
-var bflSubmitSchema = import_v4.z.object({
-  id: import_v4.z.string(),
-  polling_url: import_v4.z.url(),
-  cost: import_v4.z.number().nullish(),
-  input_mp: import_v4.z.number().nullish(),
-  output_mp: import_v4.z.number().nullish()
+var bflSubmitSchema = import_v42.z.object({
+  id: import_v42.z.string(),
+  polling_url: import_v42.z.url(),
+  cost: import_v42.z.number().nullish(),
+  input_mp: import_v42.z.number().nullish(),
+  output_mp: import_v42.z.number().nullish()
 });
-var bflStatus = import_v4.z.union([
-  import_v4.z.literal("Pending"),
-  import_v4.z.literal("Ready"),
-  import_v4.z.literal("Error"),
-  import_v4.z.literal("Failed"),
-  import_v4.z.literal("Request Moderated")
+var bflStatus = import_v42.z.union([
+  import_v42.z.literal("Pending"),
+  import_v42.z.literal("Ready"),
+  import_v42.z.literal("Error"),
+  import_v42.z.literal("Failed"),
+  import_v42.z.literal("Request Moderated")
 ]);
-var bflPollSchema = import_v4.z.object({
+var bflPollSchema = import_v42.z.object({
   status: bflStatus.optional(),
   state: bflStatus.optional(),
-  details: import_v4.z.unknown().optional(),
-  result: import_v4.z.object({
-    sample: import_v4.z.url(),
-    seed: import_v4.z.number().optional(),
-    start_time: import_v4.z.number().optional(),
-    end_time: import_v4.z.number().optional(),
-    duration: import_v4.z.number().optional()
+  details: import_v42.z.unknown().optional(),
+  result: import_v42.z.object({
+    sample: import_v42.z.url(),
+    seed: import_v42.z.number().optional(),
+    start_time: import_v42.z.number().optional(),
+    end_time: import_v42.z.number().optional(),
+    duration: import_v42.z.number().optional()
   }).nullish()
 }).refine((v) => v.status != null || v.state != null, {
   message: "Missing status in Black Forest Labs poll response"
@@ -378,42 +408,647 @@ var bflPollSchema = import_v4.z.object({
     result: v.result
   };
 });
-var bflErrorSchema = import_v4.z.object({
-  message: import_v4.z.string().optional(),
-  detail: import_v4.z.any().optional()
+
+// src/black-forest-labs-video-model.ts
+var import_provider = require("@ai-sdk/provider");
+var import_provider_utils4 = require("@ai-sdk/provider-utils");
+var import_v44 = require("zod/v4");
+
+// src/black-forest-labs-video-model-options.ts
+var import_provider_utils3 = require("@ai-sdk/provider-utils");
+var import_v43 = require("zod/v4");
+
+// src/black-forest-labs-video-settings.ts
+var blackForestLabsVideoAspectRatios = [
+  "21:9",
+  "2:1",
+  "16:9",
+  "4:3",
+  "1:1",
+  "3:4",
+  "9:16",
+  "auto"
+];
+var blackForestLabsVideoResolutions = ["hd", "fhd"];
+
+// src/black-forest-labs-video-model-options.ts
+var blackForestLabsTimedVideoKeyframeSchema = import_v43.z.tuple([
+  import_v43.z.number().min(0).max(20),
+  import_v43.z.string()
+]);
+var blackForestLabsVideoKeyframesSchema = import_v43.z.union([
+  import_v43.z.array(import_v43.z.string()).min(1).max(10),
+  import_v43.z.array(blackForestLabsTimedVideoKeyframeSchema).min(1).max(10).refine(
+    (keyframes) => keyframes.every(
+      (keyframe, index) => index === 0 || keyframe[0] > keyframes[index - 1][0]
+    ),
+    { message: "Timed keyframes must be in chronological order." }
+  )
+]);
+var blackForestLabsVideoProviderOptions = import_v43.z.object({
+  /**
+   * Output resolution tier. Takes precedence over the top-level `resolution`,
+   * which is expressed as `{width}x{height}` and has to be mapped onto a tier.
+   */
+  resolution: import_v43.z.enum(blackForestLabsVideoResolutions).optional(),
+  /**
+   * Aspect ratio of the generated video. Takes precedence over the top-level
+   * `aspectRatio`, and unlike it can be set to `auto`.
+   */
+  aspectRatio: import_v43.z.enum(blackForestLabsVideoAspectRatios).optional(),
+  /**
+   * Keyframes for image-to-video generation, for the shapes the top-level
+   * `image` and `frameImages` options cannot express: more than two images, or
+   * images pinned to a specific second. Takes precedence over both.
+   *
+   * One image opens the clip, two open and close it, and with more the extras
+   * are spaced evenly in between. Three or more plain images require an
+   * explicit `duration`.
+   */
+  keyframes: blackForestLabsVideoKeyframesSchema.optional(),
+  /**
+   * Moderation strictness from 0 (strictest) to 4. Defaults to 2. Sexual
+   * content is capped at 3 and hate content at 2 regardless of the request,
+   * and any request carrying conditioning media is capped at 2.
+   */
+  safetyTolerance: import_v43.z.number().int().min(0).max(4).optional(),
+  /**
+   * Render a fast, lower-quality preview instead of the finished video.
+   * Defaults to `false`.
+   */
+  draft: import_v43.z.boolean().optional(),
+  /**
+   * Encrypted draft-cache bundle from a prior `draft` generation, which
+   * switches the request to draft-enhance mode: the bundle is replayed at full
+   * quality.
+   *
+   * Either the base64-encoded `.bin` downloaded from the draft's `draftCache`
+   * URL, or that URL itself while it is still in its expiry window.
+   */
+  draftCache: import_v43.z.string().optional(),
+  /**
+   * Model version to pin. Only `latest` is available today.
+   */
+  version: import_v43.z.literal("latest").optional()
 });
-var bflFailedResponseHandler = (0, import_provider_utils.createJsonErrorResponseHandler)({
-  errorSchema: bflErrorSchema,
-  errorToMessage: (error) => {
-    var _a;
-    return (_a = bflErrorToMessage(error)) != null ? _a : "Unknown Black Forest Labs error";
+var blackForestLabsVideoModelOptionsSchema = (0, import_provider_utils3.lazySchema)(
+  () => (0, import_provider_utils3.zodSchema)(blackForestLabsVideoProviderOptions)
+);
+
+// src/black-forest-labs-video-model.ts
+var DEFAULT_POLL_INTERVAL_MILLIS2 = 2e3;
+var DEFAULT_POLL_TIMEOUT_MILLIS2 = 6e5;
+var MIN_DURATION_SECONDS = 5;
+var MAX_DURATION_SECONDS = 20;
+var UNTIMED_KEYFRAMES_NEEDING_DURATION = 3;
+var allowedAspectRatios = new Set(blackForestLabsVideoAspectRatios);
+var allowedResolutions = new Set(blackForestLabsVideoResolutions);
+var TERMINAL_FAILURE_STATUSES = /* @__PURE__ */ new Set([
+  "Error",
+  "Failed",
+  "Request Moderated",
+  "Content Moderated",
+  "Task not found"
+]);
+function getTopLevelMediaType(mediaType) {
+  return mediaType.split("/")[0];
+}
+function resolveTopLevelResolution(resolution) {
+  const named = resolution.toLowerCase();
+  if (allowedResolutions.has(named)) {
+    return { tier: named, derived: false };
   }
-});
-function bflErrorToMessage(error) {
-  const parsed = bflErrorSchema.safeParse(error);
-  if (!parsed.success) return void 0;
-  const { message, detail } = parsed.data;
-  if (typeof detail === "string") return detail;
-  if (detail != null) {
-    try {
-      return JSON.stringify(detail);
-    } catch (e) {
+  const match = resolution.match(/^(\d+)x(\d+)$/);
+  if (match == null) {
+    return void 0;
+  }
+  const shorterSide = Math.min(Number(match[1]), Number(match[2]));
+  return {
+    tier: shorterSide <= 720 ? "hd" : "fhd",
+    derived: shorterSide !== 720 && shorterSide !== 1080
+  };
+}
+function nonImageFrameMediaType(file) {
+  if (file.mediaType == null) {
+    return void 0;
+  }
+  const topLevelMediaType = getTopLevelMediaType(file.mediaType);
+  return topLevelMediaType === "image" ? void 0 : topLevelMediaType;
+}
+function getDraftEnhanceArgs(options, bflOptions) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const warnings = [];
+  const pinnedByBundle = [
+    ["prompt", ((_b = (_a = options.prompt) == null ? void 0 : _a.trim().length) != null ? _b : 0) > 0],
+    [
+      "aspectRatio",
+      options.aspectRatio != null || bflOptions.aspectRatio != null
+    ],
+    ["resolution", options.resolution != null || bflOptions.resolution != null],
+    ["duration", options.duration != null],
+    ["fps", options.fps != null],
+    ["seed", options.seed != null],
+    ["generateAudio", options.generateAudio != null],
+    ["image", options.image != null],
+    ["frameImages", ((_d = (_c = options.frameImages) == null ? void 0 : _c.length) != null ? _d : 0) > 0],
+    ["inputReferences", ((_f = (_e = options.inputReferences) == null ? void 0 : _e.length) != null ? _f : 0) > 0],
+    ["keyframes", ((_h = (_g = bflOptions.keyframes) == null ? void 0 : _g.length) != null ? _h : 0) > 0],
+    ["version", bflOptions.version != null]
+  ];
+  for (const [feature, isSet] of pinnedByBundle) {
+    if (isSet) {
+      warnings.push({
+        type: "unsupported",
+        feature,
+        details: `FLUX 3 draft enhance replays the draft bundle as it was generated, so "${feature}" was ignored. Set it on the original draft request instead.`
+      });
     }
   }
-  return message;
+  if (bflOptions.draft != null) {
+    warnings.push({
+      type: "unsupported",
+      feature: "draft",
+      details: "FLUX 3 draft enhance always renders at full quality. The draft option was ignored."
+    });
+  }
+  if (options.n != null && options.n > 1) {
+    warnings.push({
+      type: "unsupported",
+      feature: "n",
+      details: "FLUX 3 video generates a single video per call. Only 1 video will be generated."
+    });
+  }
+  return {
+    body: {
+      mode: "draft_enhance",
+      draft_cache: bflOptions.draftCache,
+      safety_tolerance: bflOptions.safetyTolerance
+    },
+    warnings
+  };
 }
+function describePollDetails(details) {
+  if (details == null) {
+    return void 0;
+  }
+  if (typeof details === "string") {
+    return details;
+  }
+  try {
+    return JSON.stringify(details);
+  } catch (e) {
+    return void 0;
+  }
+}
+function toBlackForestLabsFile(file) {
+  if (file.type === "url") {
+    return file.url;
+  }
+  if (typeof file.data === "string") {
+    return file.data;
+  }
+  return Buffer.from(file.data).toString("base64");
+}
+var BlackForestLabsVideoModel = class {
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.specificationVersion = "v3";
+    this.maxVideosPerCall = 1;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  async getArgs(options) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const warnings = [];
+    const bflOptions = await (0, import_provider_utils4.parseProviderOptions)({
+      provider: "blackForestLabs",
+      providerOptions: options.providerOptions,
+      schema: blackForestLabsVideoModelOptionsSchema
+    });
+    if ((bflOptions == null ? void 0 : bflOptions.draftCache) != null) {
+      return getDraftEnhanceArgs(options, bflOptions);
+    }
+    if (options.fps != null) {
+      warnings.push({
+        type: "unsupported",
+        feature: "fps",
+        details: "FLUX 3 video does not support a custom frame rate."
+      });
+    }
+    if (options.seed != null) {
+      warnings.push({
+        type: "unsupported",
+        feature: "seed",
+        details: "FLUX 3 video does not accept a seed."
+      });
+    }
+    if (options.n != null && options.n > 1) {
+      warnings.push({
+        type: "unsupported",
+        feature: "n",
+        details: "FLUX 3 video generates a single video per call. Only 1 video will be generated."
+      });
+    }
+    let resolution = bflOptions == null ? void 0 : bflOptions.resolution;
+    if (options.resolution != null) {
+      const resolved = resolveTopLevelResolution(options.resolution);
+      if (resolution != null) {
+        if (resolved == null) {
+          warnings.push({
+            type: "unsupported",
+            feature: "resolution",
+            details: `Unrecognized resolution "${options.resolution}". FLUX 3 video supports "hd" and "fhd", so providerOptions.blackForestLabs.resolution ("${resolution}") was used instead.`
+          });
+        }
+      } else if (resolved == null) {
+        warnings.push({
+          type: "unsupported",
+          feature: "resolution",
+          details: `Unrecognized resolution "${options.resolution}". FLUX 3 video supports "hd" and "fhd", or a {width}x{height} value to map onto one.`
+        });
+      } else {
+        resolution = resolved.tier;
+        if (resolved.derived) {
+          warnings.push({
+            type: "compatibility",
+            feature: "resolution",
+            details: `FLUX 3 video renders at "hd" or "fhd"; the requested resolution "${options.resolution}" was mapped to "${resolved.tier}".`
+          });
+        }
+      }
+    }
+    let aspectRatio = bflOptions == null ? void 0 : bflOptions.aspectRatio;
+    if (aspectRatio == null && options.aspectRatio != null) {
+      if (allowedAspectRatios.has(options.aspectRatio)) {
+        aspectRatio = options.aspectRatio;
+      } else {
+        warnings.push({
+          type: "unsupported",
+          feature: "aspectRatio",
+          details: `FLUX 3 video does not support the aspect ratio "${options.aspectRatio}". Using the provider default (auto).`
+        });
+      }
+    }
+    const firstFrameImage = (_b = (_a = options.frameImages) == null ? void 0 : _a.find(
+      (frame) => frame.frameType === "first_frame"
+    )) == null ? void 0 : _b.image;
+    let firstFrame = firstFrameImage != null ? firstFrameImage : options.image;
+    let lastFrame = (_d = (_c = options.frameImages) == null ? void 0 : _c.find(
+      (frame) => frame.frameType === "last_frame"
+    )) == null ? void 0 : _d.image;
+    const firstFrameMediaType = firstFrame != null ? nonImageFrameMediaType(firstFrame) : void 0;
+    if (firstFrame != null && firstFrameMediaType != null) {
+      warnings.push({
+        type: "unsupported",
+        feature: firstFrameImage != null ? "frameImages" : "image",
+        details: firstFrameMediaType === "video" ? "FLUX 3 video does not accept a video as a keyframe. Pass it as an inputReference to continue from it instead." : `FLUX 3 video only accepts an image as a keyframe; the "${firstFrame.mediaType}" file was ignored.`
+      });
+      firstFrame = void 0;
+    }
+    if (lastFrame != null) {
+      if (firstFrame == null) {
+        warnings.push({
+          type: "unsupported",
+          feature: "frameImages",
+          details: "FLUX 3 video requires a first_frame when a last_frame is provided. The last_frame was ignored."
+        });
+        lastFrame = void 0;
+      } else {
+        const lastFrameMediaType = nonImageFrameMediaType(lastFrame);
+        if (lastFrameMediaType != null) {
+          warnings.push({
+            type: "unsupported",
+            feature: "frameImages",
+            details: lastFrameMediaType === "video" ? "FLUX 3 video does not accept a video as a keyframe. The last_frame video was ignored." : `FLUX 3 video only accepts an image as a keyframe; the "${lastFrame.mediaType}" last_frame was ignored.`
+          });
+          lastFrame = void 0;
+        }
+      }
+    }
+    let keyframes = (bflOptions == null ? void 0 : bflOptions.keyframes) != null && bflOptions.keyframes.length > 0 ? [...bflOptions.keyframes] : void 0;
+    if (keyframes != null) {
+      if (firstFrame != null || lastFrame != null) {
+        warnings.push({
+          type: "unsupported",
+          feature: options.frameImages != null ? "frameImages" : "image",
+          details: "FLUX 3 video takes a single keyframe list. providerOptions.blackForestLabs.keyframes was used and the top-level frame images were ignored."
+        });
+      }
+    } else if (firstFrame != null) {
+      keyframes = [toBlackForestLabsFile(firstFrame)];
+      if (lastFrame != null) {
+        keyframes.push(toBlackForestLabsFile(lastFrame));
+      }
+    }
+    let startVideo;
+    const referenceFiles = (_e = options.inputReferences) != null ? _e : [];
+    const referenceVideos = [];
+    for (const file of referenceFiles) {
+      const topLevelMediaType = file.mediaType != null ? getTopLevelMediaType(file.mediaType) : void 0;
+      if (topLevelMediaType === "video") {
+        referenceVideos.push(file);
+      } else if (topLevelMediaType == null) {
+        warnings.push({
+          type: "compatibility",
+          feature: "inputReferences",
+          details: 'FLUX 3 video only accepts a video reference, so the reference with no mediaType was treated as the video to continue from. Pass { url, mediaType: "video/mp4" } to be explicit.'
+        });
+        referenceVideos.push(file);
+      } else if (topLevelMediaType === "image") {
+        warnings.push({
+          type: "unsupported",
+          feature: "inputReferences",
+          details: "FLUX 3 video has no reference-image input. Pass images as `image`, `frameImages`, or providerOptions.blackForestLabs.keyframes instead. The reference was ignored."
+        });
+      } else {
+        warnings.push({
+          type: "unsupported",
+          feature: "inputReferences",
+          details: `FLUX 3 video only accepts a video reference; the "${file.mediaType}" reference was ignored.`
+        });
+      }
+    }
+    if (referenceVideos.length > 0) {
+      if (keyframes != null) {
+        warnings.push({
+          type: "unsupported",
+          feature: "inputReferences",
+          details: "FLUX 3 video cannot combine keyframes with a video to continue from. The video reference was ignored."
+        });
+      } else {
+        startVideo = toBlackForestLabsFile(referenceVideos[0]);
+        if (referenceVideos.length > 1) {
+          warnings.push({
+            type: "unsupported",
+            feature: "inputReferences",
+            details: "FLUX 3 video continues from a single video. Only the first video reference was used."
+          });
+        }
+      }
+    }
+    let duration = options.duration;
+    if (duration != null) {
+      if (!Number.isInteger(duration)) {
+        const rounded = Math.round(duration);
+        warnings.push({
+          type: "unsupported",
+          feature: "duration",
+          details: `FLUX 3 video requires a whole number of seconds. The requested duration of ${duration} was rounded to ${rounded}.`
+        });
+        duration = rounded;
+      }
+      if (duration > MAX_DURATION_SECONDS) {
+        warnings.push({
+          type: "unsupported",
+          feature: "duration",
+          details: `FLUX 3 video supports at most ${MAX_DURATION_SECONDS} seconds. The requested duration of ${options.duration} was clamped to ${MAX_DURATION_SECONDS}.`
+        });
+        duration = MAX_DURATION_SECONDS;
+      } else if (duration < MIN_DURATION_SECONDS) {
+        warnings.push({
+          type: "unsupported",
+          feature: "duration",
+          details: `FLUX 3 video requires at least ${MIN_DURATION_SECONDS} seconds. The requested duration of ${options.duration} was clamped to ${MIN_DURATION_SECONDS}.`
+        });
+        duration = MIN_DURATION_SECONDS;
+      }
+    }
+    const untimedKeyframeCount = (_f = keyframes == null ? void 0 : keyframes.filter((keyframe) => typeof keyframe === "string").length) != null ? _f : 0;
+    if (duration == null && untimedKeyframeCount >= UNTIMED_KEYFRAMES_NEEDING_DURATION) {
+      throw new import_provider.InvalidArgumentError({
+        argument: "duration",
+        message: `FLUX 3 video requires an explicit duration when ${UNTIMED_KEYFRAMES_NEEDING_DURATION} or more keyframes are sent without a timestamp.`
+      });
+    }
+    const mode = keyframes != null ? "i2v" : startVideo != null ? "v2v" : "t2v";
+    const body = {
+      mode,
+      prompt: (_g = options.prompt) != null ? _g : "",
+      aspect_ratio: aspectRatio,
+      duration,
+      resolution,
+      version: bflOptions == null ? void 0 : bflOptions.version,
+      generate_audio: options.generateAudio,
+      safety_tolerance: bflOptions == null ? void 0 : bflOptions.safetyTolerance,
+      draft: bflOptions == null ? void 0 : bflOptions.draft,
+      ...mode === "i2v" && { keyframes },
+      ...mode === "v2v" && { start_video: startVideo }
+    };
+    return { body, warnings };
+  }
+  async start(options) {
+    var _a, _b, _c;
+    const { body, warnings } = await this.getArgs(options);
+    const currentDate = (_c = (_b = (_a = this.config._internal) == null ? void 0 : _a.currentDate) == null ? void 0 : _b.call(_a)) != null ? _c : /* @__PURE__ */ new Date();
+    const combinedHeaders = (0, import_provider_utils4.combineHeaders)(
+      await (0, import_provider_utils4.resolve)(this.config.headers),
+      options.headers
+    );
+    const { value: submit, responseHeaders } = await (0, import_provider_utils4.postJsonToApi)({
+      url: `${this.config.baseURL}/${this.modelId}`,
+      headers: combinedHeaders,
+      body,
+      failedResponseHandler: bflFailedResponseHandler,
+      successfulResponseHandler: (0, import_provider_utils4.createJsonResponseHandler)(bflVideoSubmitSchema),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    return {
+      operation: {
+        requestId: submit.id,
+        pollingUrl: submit.polling_url,
+        ...submit.cost != null && { cost: submit.cost },
+        ...submit.input_mp != null && {
+          inputMegapixels: submit.input_mp
+        },
+        ...submit.output_mp != null && {
+          outputMegapixels: submit.output_mp
+        }
+      },
+      warnings,
+      response: {
+        modelId: this.modelId,
+        timestamp: currentDate,
+        headers: responseHeaders
+      }
+    };
+  }
+  async getStatus(options) {
+    var _a, _b, _c;
+    const currentDate = (_c = (_b = (_a = this.config._internal) == null ? void 0 : _a.currentDate) == null ? void 0 : _b.call(_a)) != null ? _c : /* @__PURE__ */ new Date();
+    const operation = options.operation;
+    const url = new URL(operation.pollingUrl);
+    if (!url.searchParams.has("id")) {
+      url.searchParams.set("id", operation.requestId);
+    }
+    const combinedHeaders = (0, import_provider_utils4.combineHeaders)(
+      await (0, import_provider_utils4.resolve)(this.config.headers),
+      options.headers
+    );
+    const pollingUrl = url.toString();
+    if (!isTrustedUrl(pollingUrl, this.config.baseURL)) {
+      throw new import_provider.AISDKError({
+        name: "BLACK_FOREST_LABS_VIDEO_GENERATION_ERROR",
+        message: `Black Forest Labs returned an untrusted polling URL: ${pollingUrl}`
+      });
+    }
+    const { value, responseHeaders } = await (0, import_provider_utils4.getFromApi)({
+      url: pollingUrl,
+      headers: combinedHeaders,
+      failedResponseHandler: bflFailedResponseHandler,
+      successfulResponseHandler: (0, import_provider_utils4.createJsonResponseHandler)(bflVideoPollSchema),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    const response = {
+      modelId: this.modelId,
+      timestamp: currentDate,
+      headers: responseHeaders
+    };
+    const { status, result } = value;
+    if (status === "Ready") {
+      const parsed = bflVideoResultSchema.safeParse(result);
+      if (!parsed.success) {
+        throw new import_provider.AISDKError({
+          name: "BLACK_FOREST_LABS_VIDEO_GENERATION_ERROR",
+          message: `Black Forest Labs reported the video as Ready but returned no result.sample URL. Request id: ${operation.requestId}`
+        });
+      }
+      return {
+        status: "completed",
+        videos: [
+          {
+            type: "url",
+            url: parsed.data.sample,
+            mediaType: "video/mp4"
+          }
+        ],
+        warnings: [],
+        providerMetadata: {
+          blackForestLabs: {
+            videos: [
+              {
+                id: operation.requestId,
+                videoUrl: parsed.data.sample,
+                ...parsed.data.seed != null && { seed: parsed.data.seed },
+                ...parsed.data.start_time != null && {
+                  start_time: parsed.data.start_time
+                },
+                ...parsed.data.end_time != null && {
+                  end_time: parsed.data.end_time
+                },
+                ...parsed.data.duration != null && {
+                  duration: parsed.data.duration
+                },
+                ...parsed.data.draft_cache != null && {
+                  draftCache: parsed.data.draft_cache
+                },
+                ...operation.cost != null && { cost: operation.cost },
+                ...operation.inputMegapixels != null && {
+                  inputMegapixels: operation.inputMegapixels
+                },
+                ...operation.outputMegapixels != null && {
+                  outputMegapixels: operation.outputMegapixels
+                }
+              }
+            ]
+          }
+        },
+        response
+      };
+    }
+    if (TERMINAL_FAILURE_STATUSES.has(status)) {
+      const detail = describePollDetails(value.details);
+      return {
+        status: "error",
+        error: `Black Forest Labs video generation failed with status "${status}"${detail != null ? `: ${detail}` : ""}. Request id: ${operation.requestId}`,
+        response
+      };
+    }
+    return { status: "pending", response };
+  }
+  async doGenerate(options) {
+    var _a, _b;
+    const startResult = await this.start(options);
+    const operation = startResult.operation;
+    const pollIntervalMillis = (_a = this.config.pollIntervalMillis) != null ? _a : DEFAULT_POLL_INTERVAL_MILLIS2;
+    const pollTimeoutMillis = (_b = this.config.pollTimeoutMillis) != null ? _b : DEFAULT_POLL_TIMEOUT_MILLIS2;
+    const startTime = Date.now();
+    while (true) {
+      await (0, import_provider_utils4.delay)(pollIntervalMillis, { abortSignal: options.abortSignal });
+      if (Date.now() - startTime > pollTimeoutMillis) {
+        throw new import_provider.AISDKError({
+          name: "BLACK_FOREST_LABS_VIDEO_GENERATION_TIMEOUT",
+          message: `Black Forest Labs video generation timed out after ${pollTimeoutMillis}ms. Request id: ${operation.requestId}`
+        });
+      }
+      const statusResult = await this.getStatus({
+        operation,
+        headers: options.headers,
+        abortSignal: options.abortSignal
+      });
+      if (statusResult.status === "pending") {
+        continue;
+      }
+      if (statusResult.status === "error") {
+        throw new import_provider.AISDKError({
+          name: "BLACK_FOREST_LABS_VIDEO_GENERATION_FAILED",
+          message: statusResult.error
+        });
+      }
+      return {
+        videos: statusResult.videos,
+        warnings: [...startResult.warnings, ...statusResult.warnings],
+        providerMetadata: statusResult.providerMetadata,
+        response: statusResult.response
+      };
+    }
+  }
+};
+var bflVideoSubmitSchema = import_v44.z.object({
+  id: import_v44.z.string(),
+  polling_url: import_v44.z.url(),
+  cost: import_v44.z.number().nullish(),
+  input_mp: import_v44.z.number().nullish(),
+  output_mp: import_v44.z.number().nullish()
+});
+var bflVideoResultSchema = import_v44.z.object({
+  sample: import_v44.z.url(),
+  seed: import_v44.z.number().nullish(),
+  start_time: import_v44.z.number().nullish(),
+  end_time: import_v44.z.number().nullish(),
+  duration: import_v44.z.number().nullish(),
+  draft_cache: import_v44.z.string().nullish()
+});
+var bflVideoPollSchema = import_v44.z.object({
+  status: import_v44.z.string().optional(),
+  state: import_v44.z.string().optional(),
+  details: import_v44.z.unknown().optional(),
+  result: import_v44.z.unknown().optional()
+}).refine((v) => v.status != null || v.state != null, {
+  message: "Missing status in Black Forest Labs poll response"
+}).transform((v) => {
+  var _a;
+  return {
+    status: (_a = v.status) != null ? _a : v.state,
+    details: v.details,
+    result: v.result
+  };
+});
 
 // src/version.ts
-var VERSION = true ? "1.0.49" : "0.0.0-test";
+var VERSION = true ? "1.0.50" : "0.0.0-test";
 
 // src/black-forest-labs-provider.ts
 var defaultBaseURL = "https://api.bfl.ai/v1";
 function createBlackForestLabs(options = {}) {
   var _a;
-  const baseURL = (0, import_provider_utils2.withoutTrailingSlash)((_a = options.baseURL) != null ? _a : defaultBaseURL);
-  const getHeaders = () => (0, import_provider_utils2.withUserAgentSuffix)(
+  const baseURL = (0, import_provider_utils5.withoutTrailingSlash)((_a = options.baseURL) != null ? _a : defaultBaseURL);
+  const getHeaders = () => (0, import_provider_utils5.withUserAgentSuffix)(
     {
-      "x-key": (0, import_provider_utils2.loadApiKey)({
+      "x-key": (0, import_provider_utils5.loadApiKey)({
         apiKey: options.apiKey,
         environmentVariableName: "BFL_API_KEY",
         description: "Black Forest Labs"
@@ -430,8 +1065,16 @@ function createBlackForestLabs(options = {}) {
     pollIntervalMillis: options.pollIntervalMillis,
     pollTimeoutMillis: options.pollTimeoutMillis
   });
+  const createVideoModel = (modelId) => new BlackForestLabsVideoModel(modelId, {
+    provider: "black-forest-labs.video",
+    baseURL: baseURL != null ? baseURL : defaultBaseURL,
+    headers: getHeaders,
+    fetch: options.fetch,
+    pollIntervalMillis: options.pollIntervalMillis,
+    pollTimeoutMillis: options.pollTimeoutMillis
+  });
   const embeddingModel = (modelId) => {
-    throw new import_provider.NoSuchModelError({
+    throw new import_provider2.NoSuchModelError({
       modelId,
       modelType: "embeddingModel"
     });
@@ -440,8 +1083,10 @@ function createBlackForestLabs(options = {}) {
     specificationVersion: "v3",
     imageModel: createImageModel,
     image: createImageModel,
+    videoModel: createVideoModel,
+    video: createVideoModel,
     languageModel: (modelId) => {
-      throw new import_provider.NoSuchModelError({
+      throw new import_provider2.NoSuchModelError({
         modelId,
         modelType: "languageModel"
       });