@ai-sdk/black-forest-labs 2.0.19 → 2.0.21

package/dist/index.js

@@ -12,12 +12,10 @@ import {
 import {
   combineHeaders,
   createBinaryResponseHandler,
-  createJsonErrorResponseHandler,
   createJsonResponseHandler,
   createStatusCodeErrorResponseHandler,
   delay,
   getFromApi,
-  isSameOrigin,
   parseProviderOptions,
   postJsonToApi,
   resolve,
@@ -25,51 +23,93 @@ import {
   WORKFLOW_SERIALIZE,
   WORKFLOW_DESERIALIZE
 } from "@ai-sdk/provider-utils";
-import { z as z2 } from "zod/v4";
+import { z as z3 } from "zod/v4";
+
+// src/black-forest-labs-api.ts
+import {
+  createJsonErrorResponseHandler,
+  isSameOrigin
+} from "@ai-sdk/provider-utils";
+import { z } from "zod/v4";
+var bflErrorSchema = z.object({
+  message: z.string().optional(),
+  detail: 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 = createJsonErrorResponseHandler({
+  errorSchema: bflErrorSchema,
+  errorToMessage: (error) => {
+    var _a;
+    return (_a = bflErrorToMessage(error)) != null ? _a : "Unknown Black Forest Labs error";
+  }
+});
+function isTrustedUrl(url, baseUrl) {
+  if (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-options.ts
 import {
   lazySchema,
   zodSchema
 } from "@ai-sdk/provider-utils";
-import { z } from "zod/v4";
+import { z as z2 } from "zod/v4";
 var blackForestLabsImageModelOptionsSchema = lazySchema(
   () => zodSchema(
-    z.object({
-      imagePrompt: z.string().optional(),
-      imagePromptStrength: z.number().min(0).max(1).optional(),
+    z2.object({
+      imagePrompt: z2.string().optional(),
+      imagePromptStrength: z2.number().min(0).max(1).optional(),
       /** @deprecated use prompt.images instead */
-      inputImage: z.string().optional(),
+      inputImage: z2.string().optional(),
       /** @deprecated use prompt.images instead */
-      inputImage2: z.string().optional(),
+      inputImage2: z2.string().optional(),
       /** @deprecated use prompt.images instead */
-      inputImage3: z.string().optional(),
+      inputImage3: z2.string().optional(),
       /** @deprecated use prompt.images instead */
-      inputImage4: z.string().optional(),
+      inputImage4: z2.string().optional(),
       /** @deprecated use prompt.images instead */
-      inputImage5: z.string().optional(),
+      inputImage5: z2.string().optional(),
       /** @deprecated use prompt.images instead */
-      inputImage6: z.string().optional(),
+      inputImage6: z2.string().optional(),
       /** @deprecated use prompt.images instead */
-      inputImage7: z.string().optional(),
+      inputImage7: z2.string().optional(),
       /** @deprecated use prompt.images instead */
-      inputImage8: z.string().optional(),
+      inputImage8: z2.string().optional(),
       /** @deprecated use prompt.images instead */
-      inputImage9: z.string().optional(),
+      inputImage9: z2.string().optional(),
       /** @deprecated use prompt.images instead */
-      inputImage10: z.string().optional(),
-      steps: z.number().int().positive().optional(),
-      guidance: z.number().min(0).optional(),
-      width: z.number().int().min(256).max(1920).optional(),
-      height: z.number().int().min(256).max(1920).optional(),
-      outputFormat: z.enum(["jpeg", "png"]).optional(),
-      promptUpsampling: z.boolean().optional(),
-      raw: z.boolean().optional(),
-      safetyTolerance: z.number().int().min(0).max(6).optional(),
-      webhookSecret: z.string().optional(),
-      webhookUrl: z.url().optional(),
-      pollIntervalMillis: z.number().int().positive().optional(),
-      pollTimeoutMillis: z.number().int().positive().optional()
+      inputImage10: z2.string().optional(),
+      steps: z2.number().int().positive().optional(),
+      guidance: z2.number().min(0).optional(),
+      width: z2.number().int().min(256).max(1920).optional(),
+      height: z2.number().int().min(256).max(1920).optional(),
+      outputFormat: z2.enum(["jpeg", "png"]).optional(),
+      promptUpsampling: z2.boolean().optional(),
+      raw: z2.boolean().optional(),
+      safetyTolerance: z2.number().int().min(0).max(6).optional(),
+      webhookSecret: z2.string().optional(),
+      webhookUrl: z2.url().optional(),
+      pollIntervalMillis: z2.number().int().positive().optional(),
+      pollTimeoutMillis: z2.number().int().positive().optional()
     })
   )
 );
@@ -329,17 +369,6 @@ var BlackForestLabsImageModel = class _BlackForestLabsImageModel {
     throw new Error("Black Forest Labs generation timed out.");
   }
 };
-function isTrustedUrl(url, baseUrl) {
-  if (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;
-  }
-}
 function convertSizeToAspectRatio(size) {
   const [wStr, hStr] = size.split("x");
   const width = Number(wStr);
@@ -360,30 +389,30 @@ function gcd(a, b) {
   }
   return x;
 }
-var bflSubmitSchema = z2.object({
-  id: z2.string(),
-  polling_url: z2.url(),
-  cost: z2.number().nullish(),
-  input_mp: z2.number().nullish(),
-  output_mp: z2.number().nullish()
+var bflSubmitSchema = z3.object({
+  id: z3.string(),
+  polling_url: z3.url(),
+  cost: z3.number().nullish(),
+  input_mp: z3.number().nullish(),
+  output_mp: z3.number().nullish()
 });
-var bflStatus = z2.union([
-  z2.literal("Pending"),
-  z2.literal("Ready"),
-  z2.literal("Error"),
-  z2.literal("Failed"),
-  z2.literal("Request Moderated")
+var bflStatus = z3.union([
+  z3.literal("Pending"),
+  z3.literal("Ready"),
+  z3.literal("Error"),
+  z3.literal("Failed"),
+  z3.literal("Request Moderated")
 ]);
-var bflPollSchema = z2.object({
+var bflPollSchema = z3.object({
   status: bflStatus.optional(),
   state: bflStatus.optional(),
-  details: z2.unknown().optional(),
-  result: z2.object({
-    sample: z2.url(),
-    seed: z2.number().optional(),
-    start_time: z2.number().optional(),
-    end_time: z2.number().optional(),
-    duration: z2.number().optional()
+  details: z3.unknown().optional(),
+  result: z3.object({
+    sample: z3.url(),
+    seed: z3.number().optional(),
+    start_time: z3.number().optional(),
+    end_time: z3.number().optional(),
+    duration: z3.number().optional()
   }).nullish()
 }).refine((v) => v.status != null || v.state != null, {
   message: "Missing status in Black Forest Labs poll response"
@@ -394,33 +423,659 @@ var bflPollSchema = z2.object({
     result: v.result
   };
 });
-var bflErrorSchema = z2.object({
-  message: z2.string().optional(),
-  detail: z2.any().optional()
+
+// src/black-forest-labs-video-model.ts
+import {
+  AISDKError,
+  InvalidArgumentError
+} from "@ai-sdk/provider";
+import {
+  combineHeaders as combineHeaders2,
+  createJsonResponseHandler as createJsonResponseHandler2,
+  delay as delay2,
+  getFromApi as getFromApi2,
+  getTopLevelMediaType,
+  parseProviderOptions as parseProviderOptions2,
+  postJsonToApi as postJsonToApi2,
+  resolve as resolve2,
+  serializeModelOptions as serializeModelOptions2,
+  WORKFLOW_DESERIALIZE as WORKFLOW_DESERIALIZE2,
+  WORKFLOW_SERIALIZE as WORKFLOW_SERIALIZE2
+} from "@ai-sdk/provider-utils";
+import { z as z5 } from "zod/v4";
+
+// src/black-forest-labs-video-model-options.ts
+import {
+  lazySchema as lazySchema2,
+  zodSchema as zodSchema2
+} from "@ai-sdk/provider-utils";
+import { z as z4 } from "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 = z4.tuple([
+  z4.number().min(0).max(20),
+  z4.string()
+]);
+var blackForestLabsVideoKeyframesSchema = z4.union([
+  z4.array(z4.string()).min(1).max(10),
+  z4.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 = z4.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: z4.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: z4.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: z4.number().int().min(0).max(4).optional(),
+  /**
+   * Render a fast, lower-quality preview instead of the finished video.
+   * Defaults to `false`.
+   */
+  draft: z4.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: z4.string().optional(),
+  /**
+   * Model version to pin. Only `latest` is available today.
+   */
+  version: z4.literal("latest").optional()
 });
-var bflFailedResponseHandler = createJsonErrorResponseHandler({
-  errorSchema: bflErrorSchema,
-  errorToMessage: (error) => {
-    var _a;
-    return (_a = bflErrorToMessage(error)) != null ? _a : "Unknown Black Forest Labs error";
+var blackForestLabsVideoModelOptionsSchema = lazySchema2(
+  () => zodSchema2(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 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 _BlackForestLabsVideoModel {
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.specificationVersion = "v4";
+    this.maxVideosPerCall = 1;
+  }
+  get provider() {
+    return this.config.provider;
+  }
+  static [WORKFLOW_SERIALIZE2](model) {
+    return serializeModelOptions2({
+      modelId: model.modelId,
+      config: model.config
+    });
+  }
+  static [WORKFLOW_DESERIALIZE2](options) {
+    return new _BlackForestLabsVideoModel(options.modelId, options.config);
+  }
+  async getArgs(options) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const warnings = [];
+    const bflOptions = await parseProviderOptions2({
+      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 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 doStart(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 = combineHeaders2(
+      await resolve2(this.config.headers),
+      options.headers
+    );
+    const { value: submit, responseHeaders } = await postJsonToApi2({
+      url: `${this.config.baseURL}/${this.modelId}`,
+      headers: combinedHeaders,
+      body,
+      failedResponseHandler: bflFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler2(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 doStatus(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 = combineHeaders2(
+      await resolve2(this.config.headers),
+      options.headers
+    );
+    const { value, responseHeaders } = await getFromApi2({
+      url: url.toString(),
+      // The polling URL comes from the provider response; validate it.
+      validateUrl: true,
+      trustedOrigin: this.config.baseURL,
+      // Only send credentials when it stays on a trusted provider host.
+      headers: isTrustedUrl(url.toString(), this.config.baseURL) ? combinedHeaders : void 0,
+      failedResponseHandler: bflFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler2(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 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.doStart(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 delay2(pollIntervalMillis, { abortSignal: options.abortSignal });
+      if (Date.now() - startTime > pollTimeoutMillis) {
+        throw new 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.doStatus({
+        operation,
+        headers: options.headers,
+        abortSignal: options.abortSignal
+      });
+      if (statusResult.status === "pending") {
+        continue;
+      }
+      if (statusResult.status === "error") {
+        throw new 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 = z5.object({
+  id: z5.string(),
+  polling_url: z5.url(),
+  cost: z5.number().nullish(),
+  input_mp: z5.number().nullish(),
+  output_mp: z5.number().nullish()
+});
+var bflVideoResultSchema = z5.object({
+  sample: z5.url(),
+  seed: z5.number().nullish(),
+  start_time: z5.number().nullish(),
+  end_time: z5.number().nullish(),
+  duration: z5.number().nullish(),
+  draft_cache: z5.string().nullish()
+});
+var bflVideoPollSchema = z5.object({
+  status: z5.string().optional(),
+  state: z5.string().optional(),
+  details: z5.unknown().optional(),
+  result: z5.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 ? "2.0.19" : "0.0.0-test";
+var VERSION = true ? "2.0.21" : "0.0.0-test";
 
 // src/black-forest-labs-provider.ts
 var defaultBaseURL = "https://api.bfl.ai/v1";
@@ -446,6 +1101,14 @@ 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 NoSuchModelError({
       modelId,
@@ -456,6 +1119,8 @@ function createBlackForestLabs(options = {}) {
     specificationVersion: "v4",
     imageModel: createImageModel,
     image: createImageModel,
+    videoModel: createVideoModel,
+    video: createVideoModel,
     languageModel: (modelId) => {
       throw new NoSuchModelError({
         modelId,