@ai-sdk/fal 3.0.0-beta.19 → 3.0.0-beta.20

package/dist/index.js

@@ -1,72 +1,60 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  VERSION: () => VERSION,
-  createFal: () => createFal,
-  fal: () => fal
-});
-module.exports = __toCommonJS(index_exports);
-
 // src/fal-provider.ts
-var import_provider3 = require("@ai-sdk/provider");
-var import_provider_utils7 = require("@ai-sdk/provider-utils");
+import {
+  NoSuchModelError
+} from "@ai-sdk/provider";
+import {
+  withoutTrailingSlash,
+  withUserAgentSuffix
+} from "@ai-sdk/provider-utils";
 
 // src/fal-image-model.ts
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
-var import_v42 = require("zod/v4");
+import {
+  combineHeaders,
+  convertImageModelFileToDataUri,
+  createBinaryResponseHandler,
+  createJsonErrorResponseHandler,
+  createJsonResponseHandler,
+  createStatusCodeErrorResponseHandler,
+  getFromApi,
+  parseProviderOptions,
+  postJsonToApi,
+  resolve
+} from "@ai-sdk/provider-utils";
+import { z as z2 } from "zod/v4";
 
 // src/fal-image-options.ts
-var import_provider_utils = require("@ai-sdk/provider-utils");
-var import_v4 = require("zod/v4");
-var falImageModelOptionsSchema = (0, import_provider_utils.lazySchema)(
-  () => (0, import_provider_utils.zodSchema)(
-    import_v4.z.object({
+import { lazySchema, zodSchema } from "@ai-sdk/provider-utils";
+import { z } from "zod/v4";
+var falImageModelOptionsSchema = lazySchema(
+  () => zodSchema(
+    z.object({
       /** @deprecated use prompt.images instead */
-      imageUrl: import_v4.z.string().nullish().meta({
+      imageUrl: z.string().nullish().meta({
         deprecated: true,
         description: "Use `prompt.images` instead"
       }),
-      maskUrl: import_v4.z.string().nullish().meta({ deprecated: true, description: "Use `prompt.mask` instead" }),
-      guidanceScale: import_v4.z.number().min(1).max(20).nullish(),
-      numInferenceSteps: import_v4.z.number().min(1).max(50).nullish(),
-      enableSafetyChecker: import_v4.z.boolean().nullish(),
-      outputFormat: import_v4.z.enum(["jpeg", "png"]).nullish(),
-      syncMode: import_v4.z.boolean().nullish(),
-      strength: import_v4.z.number().nullish(),
-      acceleration: import_v4.z.enum(["none", "regular", "high"]).nullish(),
-      safetyTolerance: import_v4.z.enum(["1", "2", "3", "4", "5", "6"]).or(import_v4.z.number().min(1).max(6)).nullish(),
+      maskUrl: z.string().nullish().meta({ deprecated: true, description: "Use `prompt.mask` instead" }),
+      guidanceScale: z.number().min(1).max(20).nullish(),
+      numInferenceSteps: z.number().min(1).max(50).nullish(),
+      enableSafetyChecker: z.boolean().nullish(),
+      outputFormat: z.enum(["jpeg", "png"]).nullish(),
+      syncMode: z.boolean().nullish(),
+      strength: z.number().nullish(),
+      acceleration: z.enum(["none", "regular", "high"]).nullish(),
+      safetyTolerance: z.enum(["1", "2", "3", "4", "5", "6"]).or(z.number().min(1).max(6)).nullish(),
       /**
        * When true, converts multiple input images to `image_urls` array instead of `image_url` string.
        */
-      useMultipleImages: import_v4.z.boolean().nullish(),
+      useMultipleImages: z.boolean().nullish(),
       // Deprecated snake_case versions
-      image_url: import_v4.z.string().nullish(),
-      mask_url: import_v4.z.string().nullish(),
-      guidance_scale: import_v4.z.number().min(1).max(20).nullish(),
-      num_inference_steps: import_v4.z.number().min(1).max(50).nullish(),
-      enable_safety_checker: import_v4.z.boolean().nullish(),
-      output_format: import_v4.z.enum(["jpeg", "png"]).nullish(),
-      sync_mode: import_v4.z.boolean().nullish(),
-      safety_tolerance: import_v4.z.enum(["1", "2", "3", "4", "5", "6"]).or(import_v4.z.number().min(1).max(6)).nullish()
+      image_url: z.string().nullish(),
+      mask_url: z.string().nullish(),
+      guidance_scale: z.number().min(1).max(20).nullish(),
+      num_inference_steps: z.number().min(1).max(50).nullish(),
+      enable_safety_checker: z.boolean().nullish(),
+      output_format: z.enum(["jpeg", "png"]).nullish(),
+      sync_mode: z.boolean().nullish(),
+      safety_tolerance: z.enum(["1", "2", "3", "4", "5", "6"]).or(z.number().min(1).max(6)).nullish()
     }).passthrough().transform((data) => {
       const result = {};
       const deprecatedKeys = [];
@@ -162,7 +150,7 @@ var FalImageModel = class {
     } else if (aspectRatio) {
       imageSize = convertAspectRatioToSize(aspectRatio);
     }
-    const falOptions = await (0, import_provider_utils2.parseProviderOptions)({
+    const falOptions = await parseProviderOptions({
       provider: "fal",
       providerOptions,
       schema: falImageModelOptionsSchema
@@ -177,10 +165,10 @@ var FalImageModel = class {
       const useMultipleImages = (falOptions == null ? void 0 : falOptions.useMultipleImages) === true;
       if (useMultipleImages) {
         requestBody.image_urls = files.map(
-          (file) => (0, import_provider_utils2.convertImageModelFileToDataUri)(file)
+          (file) => convertImageModelFileToDataUri(file)
         );
       } else {
-        requestBody.image_url = (0, import_provider_utils2.convertImageModelFileToDataUri)(files[0]);
+        requestBody.image_url = convertImageModelFileToDataUri(files[0]);
         if (files.length > 1) {
           warnings.push({
             type: "other",
@@ -190,7 +178,7 @@ var FalImageModel = class {
       }
     }
     if (mask != null) {
-      requestBody.mask_url = (0, import_provider_utils2.convertImageModelFileToDataUri)(mask);
+      requestBody.mask_url = convertImageModelFileToDataUri(mask);
     }
     if (falOptions) {
       const deprecatedKeys = "__deprecatedKeys" in falOptions ? falOptions.__deprecatedKeys : void 0;
@@ -231,15 +219,15 @@ var FalImageModel = class {
     var _a, _b, _c;
     const { requestBody, 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 { value, responseHeaders } = await (0, import_provider_utils2.postJsonToApi)({
+    const { value, responseHeaders } = await postJsonToApi({
       url: `${this.config.baseURL}/${this.modelId}`,
-      headers: (0, import_provider_utils2.combineHeaders)(
-        await (0, import_provider_utils2.resolve)(this.config.headers),
+      headers: combineHeaders(
+        await resolve(this.config.headers),
         options.headers
       ),
       body: requestBody,
       failedResponseHandler: falFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils2.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler(
         falImageResponseSchema
       ),
       abortSignal: options.abortSignal,
@@ -298,13 +286,13 @@ var FalImageModel = class {
     };
   }
   async downloadImage(url, abortSignal) {
-    const { value: response } = await (0, import_provider_utils2.getFromApi)({
+    const { value: response } = await getFromApi({
       url,
       // No specific headers should be needed for this request as it's a
       // generated image provided by fal.ai.
       abortSignal,
-      failedResponseHandler: (0, import_provider_utils2.createStatusCodeErrorResponseHandler)(),
-      successfulResponseHandler: (0, import_provider_utils2.createBinaryResponseHandler)(),
+      failedResponseHandler: createStatusCodeErrorResponseHandler(),
+      successfulResponseHandler: createBinaryResponseHandler(),
       fetch: this.config.fetch
     });
     return response;
@@ -338,60 +326,60 @@ function convertAspectRatioToSize(aspectRatio) {
   }
   return void 0;
 }
-var falValidationErrorSchema = import_v42.z.object({
-  detail: import_v42.z.array(
-    import_v42.z.object({
-      loc: import_v42.z.array(import_v42.z.string()),
-      msg: import_v42.z.string(),
-      type: import_v42.z.string()
+var falValidationErrorSchema = z2.object({
+  detail: z2.array(
+    z2.object({
+      loc: z2.array(z2.string()),
+      msg: z2.string(),
+      type: z2.string()
     })
   )
 });
-var falHttpErrorSchema = import_v42.z.object({
-  message: import_v42.z.string()
+var falHttpErrorSchema = z2.object({
+  message: z2.string()
 });
-var falErrorSchema = import_v42.z.union([falValidationErrorSchema, falHttpErrorSchema]);
-var falImageSchema = import_v42.z.object({
-  url: import_v42.z.string(),
-  width: import_v42.z.number().nullish(),
-  height: import_v42.z.number().nullish(),
+var falErrorSchema = z2.union([falValidationErrorSchema, falHttpErrorSchema]);
+var falImageSchema = z2.object({
+  url: z2.string(),
+  width: z2.number().nullish(),
+  height: z2.number().nullish(),
   // e.g. https://fal.ai/models/fal-ai/fashn/tryon/v1.6/api#schema-output
-  content_type: import_v42.z.string().nullish(),
+  content_type: z2.string().nullish(),
   // e.g. https://fal.ai/models/fal-ai/flowedit/api#schema-output
-  file_name: import_v42.z.string().nullish(),
-  file_data: import_v42.z.string().optional(),
-  file_size: import_v42.z.number().nullish()
+  file_name: z2.string().nullish(),
+  file_data: z2.string().optional(),
+  file_size: z2.number().nullish()
 });
-var loraFileSchema = import_v42.z.object({
-  url: import_v42.z.string(),
-  content_type: import_v42.z.string().optional(),
-  file_name: import_v42.z.string().nullable().optional(),
-  file_data: import_v42.z.string().optional(),
-  file_size: import_v42.z.number().nullable().optional()
+var loraFileSchema = z2.object({
+  url: z2.string(),
+  content_type: z2.string().optional(),
+  file_name: z2.string().nullable().optional(),
+  file_data: z2.string().optional(),
+  file_size: z2.number().nullable().optional()
 });
-var commonResponseSchema = import_v42.z.object({
-  timings: import_v42.z.object({
-    inference: import_v42.z.number().optional()
+var commonResponseSchema = z2.object({
+  timings: z2.object({
+    inference: z2.number().optional()
   }).optional(),
-  seed: import_v42.z.number().optional(),
-  has_nsfw_concepts: import_v42.z.array(import_v42.z.boolean()).optional(),
-  prompt: import_v42.z.string().optional(),
+  seed: z2.number().optional(),
+  has_nsfw_concepts: z2.array(z2.boolean()).optional(),
+  prompt: z2.string().optional(),
   // https://fal.ai/models/fal-ai/lcm/api#schema-output
-  nsfw_content_detected: import_v42.z.array(import_v42.z.boolean()).optional(),
-  num_inference_steps: import_v42.z.number().optional(),
+  nsfw_content_detected: z2.array(z2.boolean()).optional(),
+  num_inference_steps: z2.number().optional(),
   // https://fal.ai/models/fal-ai/lora/api#schema-output
   debug_latents: loraFileSchema.optional(),
   debug_per_pass_latents: loraFileSchema.optional()
 });
-var base = import_v42.z.looseObject(commonResponseSchema.shape);
-var falImageResponseSchema = import_v42.z.union([
-  base.extend({ images: import_v42.z.array(falImageSchema) }),
+var base = z2.looseObject(commonResponseSchema.shape);
+var falImageResponseSchema = z2.union([
+  base.extend({ images: z2.array(falImageSchema) }),
   base.extend({ image: falImageSchema })
-]).transform((v) => "images" in v ? v : { ...v, images: [v.image] }).pipe(base.extend({ images: import_v42.z.array(falImageSchema) }));
+]).transform((v) => "images" in v ? v : { ...v, images: [v.image] }).pipe(base.extend({ images: z2.array(falImageSchema) }));
 function isValidationError(error) {
   return falValidationErrorSchema.safeParse(error).success;
 }
-var falFailedResponseHandler = (0, import_provider_utils2.createJsonErrorResponseHandler)({
+var falFailedResponseHandler = createJsonErrorResponseHandler({
   errorSchema: falErrorSchema,
   errorToMessage: (error) => {
     var _a;
@@ -403,52 +391,63 @@ var falFailedResponseHandler = (0, import_provider_utils2.createJsonErrorRespons
 });
 
 // src/fal-transcription-model.ts
-var import_provider = require("@ai-sdk/provider");
-var import_provider_utils4 = require("@ai-sdk/provider-utils");
-var import_v44 = require("zod/v4");
+import {
+  AISDKError
+} from "@ai-sdk/provider";
+import {
+  combineHeaders as combineHeaders2,
+  convertUint8ArrayToBase64,
+  createJsonErrorResponseHandler as createJsonErrorResponseHandler3,
+  createJsonResponseHandler as createJsonResponseHandler2,
+  delay,
+  getFromApi as getFromApi2,
+  parseProviderOptions as parseProviderOptions2,
+  postJsonToApi as postJsonToApi2
+} from "@ai-sdk/provider-utils";
+import { z as z4 } from "zod/v4";
 
 // src/fal-error.ts
-var import_v43 = require("zod/v4");
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
-var falErrorDataSchema = import_v43.z.object({
-  error: import_v43.z.object({
-    message: import_v43.z.string(),
-    code: import_v43.z.number()
+import { z as z3 } from "zod/v4";
+import { createJsonErrorResponseHandler as createJsonErrorResponseHandler2 } from "@ai-sdk/provider-utils";
+var falErrorDataSchema = z3.object({
+  error: z3.object({
+    message: z3.string(),
+    code: z3.number()
   })
 });
-var falFailedResponseHandler2 = (0, import_provider_utils3.createJsonErrorResponseHandler)({
+var falFailedResponseHandler2 = createJsonErrorResponseHandler2({
   errorSchema: falErrorDataSchema,
   errorToMessage: (data) => data.error.message
 });
 
 // src/fal-transcription-model.ts
-var falTranscriptionModelOptionsSchema = import_v44.z.object({
+var falTranscriptionModelOptionsSchema = z4.object({
   /**
    * Language of the audio file. If set to null, the language will be automatically detected. Defaults to null.
    *
    * If translate is selected as the task, the audio will be translated to English, regardless of the language selected.
    */
-  language: import_v44.z.union([import_v44.z.enum(["en"]), import_v44.z.string()]).nullish().default("en"),
+  language: z4.union([z4.enum(["en"]), z4.string()]).nullish().default("en"),
   /**
    * Whether to diarize the audio file. Defaults to true.
    */
-  diarize: import_v44.z.boolean().nullish().default(true),
+  diarize: z4.boolean().nullish().default(true),
   /**
    * Level of the chunks to return. Either segment or word. Default value: "segment"
    */
-  chunkLevel: import_v44.z.enum(["segment", "word"]).nullish().default("segment"),
+  chunkLevel: z4.enum(["segment", "word"]).nullish().default("segment"),
   /**
    * Version of the model to use. All of the models are the Whisper large variant. Default value: "3"
    */
-  version: import_v44.z.enum(["3"]).nullish().default("3"),
+  version: z4.enum(["3"]).nullish().default("3"),
   /**
    * Default value: 64
    */
-  batchSize: import_v44.z.number().nullish().default(64),
+  batchSize: z4.number().nullish().default(64),
   /**
    * Number of speakers in the audio file. Defaults to null. If not provided, the number of speakers will be automatically detected.
    */
-  numSpeakers: import_v44.z.number().nullable().nullish()
+  numSpeakers: z4.number().nullable().nullish()
 });
 var FalTranscriptionModel = class {
   constructor(modelId, config) {
@@ -464,7 +463,7 @@ var FalTranscriptionModel = class {
   }) {
     var _a, _b, _c;
     const warnings = [];
-    const falOptions = await (0, import_provider_utils4.parseProviderOptions)({
+    const falOptions = await parseProviderOptions2({
       provider: "fal",
       providerOptions,
       schema: falTranscriptionModelOptionsSchema
@@ -495,20 +494,20 @@ var FalTranscriptionModel = class {
     var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
     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 { body, warnings } = await this.getArgs(options);
-    const base64Audio = typeof options.audio === "string" ? options.audio : (0, import_provider_utils4.convertUint8ArrayToBase64)(options.audio);
+    const base64Audio = typeof options.audio === "string" ? options.audio : convertUint8ArrayToBase64(options.audio);
     const audioUrl = `data:${options.mediaType};base64,${base64Audio}`;
-    const { value: queueResponse } = await (0, import_provider_utils4.postJsonToApi)({
+    const { value: queueResponse } = await postJsonToApi2({
       url: this.config.url({
         path: `https://queue.fal.run/fal-ai/${this.modelId}`,
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils4.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders2(this.config.headers(), options.headers),
       body: {
         ...body,
         audio_url: audioUrl
       },
       failedResponseHandler: falFailedResponseHandler2,
-      successfulResponseHandler: (0, import_provider_utils4.createJsonResponseHandler)(falJobResponseSchema),
+      successfulResponseHandler: createJsonResponseHandler2(falJobResponseSchema),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
@@ -524,12 +523,12 @@ var FalTranscriptionModel = class {
           value: statusResponse,
           responseHeaders: statusHeaders,
           rawValue: statusRawResponse
-        } = await (0, import_provider_utils4.getFromApi)({
+        } = await getFromApi2({
           url: this.config.url({
             path: `https://queue.fal.run/fal-ai/${this.modelId}/requests/${queueResponse.request_id}`,
             modelId: this.modelId
           }),
-          headers: (0, import_provider_utils4.combineHeaders)(this.config.headers(), options.headers),
+          headers: combineHeaders2(this.config.headers(), options.headers),
           failedResponseHandler: async ({
             requestBodyValues,
             response: response2,
@@ -544,12 +543,12 @@ var FalTranscriptionModel = class {
                 responseHeaders: {}
               };
             }
-            return (0, import_provider_utils4.createJsonErrorResponseHandler)({
+            return createJsonErrorResponseHandler3({
               errorSchema: falErrorDataSchema,
               errorToMessage: (data) => data.error.message
             })({ requestBodyValues, response: response2, url });
           },
-          successfulResponseHandler: (0, import_provider_utils4.createJsonResponseHandler)(
+          successfulResponseHandler: createJsonResponseHandler2(
             falTranscriptionResponseSchema
           ),
           abortSignal: options.abortSignal,
@@ -566,13 +565,13 @@ var FalTranscriptionModel = class {
         }
       }
       if (Date.now() - startTime > timeoutMs) {
-        throw new import_provider.AISDKError({
+        throw new AISDKError({
           message: "Transcription request timed out after 60 seconds",
           name: "TranscriptionRequestTimedOut",
           cause: response
         });
       }
-      await (0, import_provider_utils4.delay)(pollIntervalMs);
+      await delay(pollIntervalMs);
     }
     return {
       text: response.text,
@@ -596,23 +595,31 @@ var FalTranscriptionModel = class {
     };
   }
 };
-var falJobResponseSchema = import_v44.z.object({
-  request_id: import_v44.z.string().nullish()
+var falJobResponseSchema = z4.object({
+  request_id: z4.string().nullish()
 });
-var falTranscriptionResponseSchema = import_v44.z.object({
-  text: import_v44.z.string(),
-  chunks: import_v44.z.array(
-    import_v44.z.object({
-      text: import_v44.z.string(),
-      timestamp: import_v44.z.array(import_v44.z.number()).nullish()
+var falTranscriptionResponseSchema = z4.object({
+  text: z4.string(),
+  chunks: z4.array(
+    z4.object({
+      text: z4.string(),
+      timestamp: z4.array(z4.number()).nullish()
     })
   ).nullish(),
-  inferred_languages: import_v44.z.array(import_v44.z.string()).nullish()
+  inferred_languages: z4.array(z4.string()).nullish()
 });
 
 // src/fal-speech-model.ts
-var import_provider_utils5 = require("@ai-sdk/provider-utils");
-var import_v45 = require("zod/v4");
+import {
+  combineHeaders as combineHeaders3,
+  createBinaryResponseHandler as createBinaryResponseHandler2,
+  createJsonResponseHandler as createJsonResponseHandler3,
+  createStatusCodeErrorResponseHandler as createStatusCodeErrorResponseHandler2,
+  getFromApi as getFromApi3,
+  parseProviderOptions as parseProviderOptions3,
+  postJsonToApi as postJsonToApi3
+} from "@ai-sdk/provider-utils";
+import { z as z5 } from "zod/v4";
 
 // src/fal-api-types.ts
 var FAL_LANGUAGE_BOOSTS = [
@@ -653,18 +660,18 @@ var FAL_EMOTIONS = [
 ];
 
 // src/fal-speech-model.ts
-var falSpeechModelOptionsSchema = import_v45.z.looseObject({
-  voice_setting: import_v45.z.object({
-    speed: import_v45.z.number().nullish(),
-    vol: import_v45.z.number().nullish(),
-    voice_id: import_v45.z.string().nullish(),
-    pitch: import_v45.z.number().nullish(),
-    english_normalization: import_v45.z.boolean().nullish(),
-    emotion: import_v45.z.enum(FAL_EMOTIONS).nullish()
+var falSpeechModelOptionsSchema = z5.looseObject({
+  voice_setting: z5.object({
+    speed: z5.number().nullish(),
+    vol: z5.number().nullish(),
+    voice_id: z5.string().nullish(),
+    pitch: z5.number().nullish(),
+    english_normalization: z5.boolean().nullish(),
+    emotion: z5.enum(FAL_EMOTIONS).nullish()
   }).partial().nullish(),
-  audio_setting: import_v45.z.record(import_v45.z.string(), import_v45.z.unknown()).nullish(),
-  language_boost: import_v45.z.enum(FAL_LANGUAGE_BOOSTS).nullish(),
-  pronunciation_dict: import_v45.z.record(import_v45.z.string(), import_v45.z.string()).nullish()
+  audio_setting: z5.record(z5.string(), z5.unknown()).nullish(),
+  language_boost: z5.enum(FAL_LANGUAGE_BOOSTS).nullish(),
+  pronunciation_dict: z5.record(z5.string(), z5.string()).nullish()
 });
 var FalSpeechModel = class {
   constructor(modelId, config) {
@@ -684,7 +691,7 @@ var FalSpeechModel = class {
     providerOptions
   }) {
     const warnings = [];
-    const falOptions = await (0, import_provider_utils5.parseProviderOptions)({
+    const falOptions = await parseProviderOptions3({
       provider: "fal",
       providerOptions,
       schema: falSpeechModelOptionsSchema
@@ -720,25 +727,25 @@ var FalSpeechModel = class {
       value: json,
       responseHeaders,
       rawValue
-    } = await (0, import_provider_utils5.postJsonToApi)({
+    } = await postJsonToApi3({
       url: this.config.url({
         path: `https://fal.run/${this.modelId}`,
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils5.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders3(this.config.headers(), options.headers),
       body: requestBody,
       failedResponseHandler: falFailedResponseHandler2,
-      successfulResponseHandler: (0, import_provider_utils5.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler3(
         falSpeechResponseSchema
       ),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
     const audioUrl = json.audio.url;
-    const { value: audio } = await (0, import_provider_utils5.getFromApi)({
+    const { value: audio } = await getFromApi3({
       url: audioUrl,
-      failedResponseHandler: (0, import_provider_utils5.createStatusCodeErrorResponseHandler)(),
-      successfulResponseHandler: (0, import_provider_utils5.createBinaryResponseHandler)(),
+      failedResponseHandler: createStatusCodeErrorResponseHandler2(),
+      successfulResponseHandler: createBinaryResponseHandler2(),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
@@ -757,31 +764,44 @@ var FalSpeechModel = class {
     };
   }
 };
-var falSpeechResponseSchema = import_v45.z.object({
-  audio: import_v45.z.object({ url: import_v45.z.string() }),
-  duration_ms: import_v45.z.number().optional(),
-  request_id: import_v45.z.string().optional()
+var falSpeechResponseSchema = z5.object({
+  audio: z5.object({ url: z5.string() }),
+  duration_ms: z5.number().optional(),
+  request_id: z5.string().optional()
 });
 
 // src/fal-video-model.ts
-var import_provider2 = require("@ai-sdk/provider");
-var import_provider_utils6 = require("@ai-sdk/provider-utils");
-var import_v46 = require("zod/v4");
-var falVideoModelOptionsSchema = (0, import_provider_utils6.lazySchema)(
-  () => (0, import_provider_utils6.zodSchema)(
-    import_v46.z.object({
+import {
+  AISDKError as AISDKError2
+} from "@ai-sdk/provider";
+import {
+  combineHeaders as combineHeaders4,
+  convertImageModelFileToDataUri as convertImageModelFileToDataUri2,
+  createJsonErrorResponseHandler as createJsonErrorResponseHandler4,
+  createJsonResponseHandler as createJsonResponseHandler4,
+  delay as delay2,
+  getFromApi as getFromApi4,
+  lazySchema as lazySchema2,
+  parseProviderOptions as parseProviderOptions4,
+  postJsonToApi as postJsonToApi4,
+  zodSchema as zodSchema2
+} from "@ai-sdk/provider-utils";
+import { z as z6 } from "zod/v4";
+var falVideoModelOptionsSchema = lazySchema2(
+  () => zodSchema2(
+    z6.object({
       // Video loop - only for Luma models
-      loop: import_v46.z.boolean().nullish(),
+      loop: z6.boolean().nullish(),
       // Motion strength (provider-specific)
-      motionStrength: import_v46.z.number().min(0).max(1).nullish(),
+      motionStrength: z6.number().min(0).max(1).nullish(),
       // Polling configuration
-      pollIntervalMs: import_v46.z.number().positive().nullish(),
-      pollTimeoutMs: import_v46.z.number().positive().nullish(),
+      pollIntervalMs: z6.number().positive().nullish(),
+      pollTimeoutMs: z6.number().positive().nullish(),
       // Resolution (model-specific, e.g., '480p', '720p', '1080p')
-      resolution: import_v46.z.string().nullish(),
+      resolution: z6.string().nullish(),
       // Model-specific parameters
-      negativePrompt: import_v46.z.string().nullish(),
-      promptOptimizer: import_v46.z.boolean().nullish()
+      negativePrompt: z6.string().nullish(),
+      promptOptimizer: z6.boolean().nullish()
     }).passthrough()
   )
 );
@@ -803,7 +823,7 @@ var FalVideoModel = class {
     var _a, _b, _c, _d, _e, _f, _g;
     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 warnings = [];
-    const falOptions = await (0, import_provider_utils6.parseProviderOptions)({
+    const falOptions = await parseProviderOptions4({
       provider: "fal",
       providerOptions: options.providerOptions,
       schema: falVideoModelOptionsSchema
@@ -816,7 +836,7 @@ var FalVideoModel = class {
       if (options.image.type === "url") {
         body.image_url = options.image.url;
       } else {
-        body.image_url = (0, import_provider_utils6.convertImageModelFileToDataUri)(options.image);
+        body.image_url = convertImageModelFileToDataUri2(options.image);
       }
     }
     if (options.aspectRatio) {
@@ -859,21 +879,21 @@ var FalVideoModel = class {
         }
       }
     }
-    const { value: queueResponse } = await (0, import_provider_utils6.postJsonToApi)({
+    const { value: queueResponse } = await postJsonToApi4({
       url: this.config.url({
         path: `https://queue.fal.run/fal-ai/${this.normalizedModelId}`,
         modelId: this.modelId
       }),
-      headers: (0, import_provider_utils6.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders4(this.config.headers(), options.headers),
       body,
       failedResponseHandler: falFailedResponseHandler2,
-      successfulResponseHandler: (0, import_provider_utils6.createJsonResponseHandler)(falJobResponseSchema2),
+      successfulResponseHandler: createJsonResponseHandler4(falJobResponseSchema2),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
     const responseUrl = queueResponse.response_url;
     if (!responseUrl) {
-      throw new import_provider2.AISDKError({
+      throw new AISDKError2({
         name: "FAL_VIDEO_GENERATION_ERROR",
         message: "No response URL returned from queue endpoint"
       });
@@ -885,12 +905,12 @@ var FalVideoModel = class {
     let responseHeaders;
     while (true) {
       try {
-        const { value: statusResponse, responseHeaders: statusHeaders } = await (0, import_provider_utils6.getFromApi)({
+        const { value: statusResponse, responseHeaders: statusHeaders } = await getFromApi4({
           url: this.config.url({
             path: responseUrl,
             modelId: this.modelId
           }),
-          headers: (0, import_provider_utils6.combineHeaders)(this.config.headers(), options.headers),
+          headers: combineHeaders4(this.config.headers(), options.headers),
           failedResponseHandler: async ({
             response: response2,
             url,
@@ -904,12 +924,12 @@ var FalVideoModel = class {
                 responseHeaders: {}
               };
             }
-            return (0, import_provider_utils6.createJsonErrorResponseHandler)({
+            return createJsonErrorResponseHandler4({
               errorSchema: falErrorDataSchema,
               errorToMessage: (data) => data.error.message
             })({ response: response2, url, requestBodyValues });
           },
-          successfulResponseHandler: (0, import_provider_utils6.createJsonResponseHandler)(
+          successfulResponseHandler: createJsonResponseHandler4(
             falVideoResponseSchema
           ),
           abortSignal: options.abortSignal,
@@ -925,14 +945,14 @@ var FalVideoModel = class {
         }
       }
       if (Date.now() - startTime > pollTimeoutMs) {
-        throw new import_provider2.AISDKError({
+        throw new AISDKError2({
           name: "FAL_VIDEO_GENERATION_TIMEOUT",
           message: `Video generation request timed out after ${pollTimeoutMs}ms`
         });
       }
-      await (0, import_provider_utils6.delay)(pollIntervalMs);
+      await delay2(pollIntervalMs);
       if ((_f = options.abortSignal) == null ? void 0 : _f.aborted) {
-        throw new import_provider2.AISDKError({
+        throw new AISDKError2({
           name: "FAL_VIDEO_GENERATION_ABORTED",
           message: "Video generation request was aborted"
         });
@@ -940,7 +960,7 @@ var FalVideoModel = class {
     }
     const videoUrl = (_g = response.video) == null ? void 0 : _g.url;
     if (!videoUrl || !response.video) {
-      throw new import_provider2.AISDKError({
+      throw new AISDKError2({
         name: "FAL_VIDEO_GENERATION_ERROR",
         message: "No video URL in response"
       });
@@ -980,29 +1000,29 @@ var FalVideoModel = class {
     };
   }
 };
-var falJobResponseSchema2 = import_v46.z.object({
-  request_id: import_v46.z.string().nullish(),
-  response_url: import_v46.z.string().nullish()
+var falJobResponseSchema2 = z6.object({
+  request_id: z6.string().nullish(),
+  response_url: z6.string().nullish()
 });
-var falVideoResponseSchema = import_v46.z.object({
-  video: import_v46.z.object({
-    url: import_v46.z.string(),
-    width: import_v46.z.number().nullish(),
-    height: import_v46.z.number().nullish(),
-    duration: import_v46.z.number().nullish(),
-    fps: import_v46.z.number().nullish(),
-    content_type: import_v46.z.string().nullish()
+var falVideoResponseSchema = z6.object({
+  video: z6.object({
+    url: z6.string(),
+    width: z6.number().nullish(),
+    height: z6.number().nullish(),
+    duration: z6.number().nullish(),
+    fps: z6.number().nullish(),
+    content_type: z6.string().nullish()
   }).nullish(),
-  seed: import_v46.z.number().nullish(),
-  timings: import_v46.z.object({
-    inference: import_v46.z.number().nullish()
+  seed: z6.number().nullish(),
+  timings: z6.object({
+    inference: z6.number().nullish()
   }).nullish(),
-  has_nsfw_concepts: import_v46.z.array(import_v46.z.boolean()).nullish(),
-  prompt: import_v46.z.string().nullish()
+  has_nsfw_concepts: z6.array(z6.boolean()).nullish(),
+  prompt: z6.string().nullish()
 });
 
 // src/version.ts
-var VERSION = true ? "3.0.0-beta.19" : "0.0.0-test";
+var VERSION = true ? "3.0.0-beta.20" : "0.0.0-test";
 
 // src/fal-provider.ts
 var defaultBaseURL = "https://fal.run";
@@ -1039,8 +1059,8 @@ function loadFalApiKey({
 }
 function createFal(options = {}) {
   var _a;
-  const baseURL = (0, import_provider_utils7.withoutTrailingSlash)((_a = options.baseURL) != null ? _a : defaultBaseURL);
-  const getHeaders = () => (0, import_provider_utils7.withUserAgentSuffix)(
+  const baseURL = withoutTrailingSlash((_a = options.baseURL) != null ? _a : defaultBaseURL);
+  const getHeaders = () => withUserAgentSuffix(
     {
       Authorization: `Key ${loadFalApiKey({
         apiKey: options.apiKey
@@ -1074,7 +1094,7 @@ function createFal(options = {}) {
     fetch: options.fetch
   });
   const embeddingModel = (modelId) => {
-    throw new import_provider3.NoSuchModelError({
+    throw new NoSuchModelError({
       modelId,
       modelType: "embeddingModel"
     });
@@ -1084,7 +1104,7 @@ function createFal(options = {}) {
     imageModel: createImageModel,
     image: createImageModel,
     languageModel: (modelId) => {
-      throw new import_provider3.NoSuchModelError({
+      throw new NoSuchModelError({
         modelId,
         modelType: "languageModel"
       });
@@ -1098,10 +1118,9 @@ function createFal(options = {}) {
   };
 }
 var fal = createFal();
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   VERSION,
   createFal,
   fal
-});
+};
 //# sourceMappingURL=index.js.map