@ai-sdk/fal 1.0.21 → 1.0.23

package/dist/index.mjs

@@ -15,10 +15,94 @@ import {
   createJsonErrorResponseHandler,
   createStatusCodeErrorResponseHandler,
   getFromApi,
+  parseProviderOptions,
   postJsonToApi,
   resolve
 } from "@ai-sdk/provider-utils";
+import { z as z2 } from "zod/v4";
+
+// src/fal-image-options.ts
+import { lazySchema, zodSchema } from "@ai-sdk/provider-utils";
 import { z } from "zod/v4";
+var falImageProviderOptionsSchema = lazySchema(
+  () => zodSchema(
+    z.object({
+      imageUrl: z.string().nullish(),
+      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(),
+      // Deprecated snake_case versions
+      image_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 = [];
+      const mapKey = (snakeKey, camelKey) => {
+        const snakeValue = data[snakeKey];
+        const camelValue = data[camelKey];
+        if (snakeValue !== void 0 && snakeValue !== null) {
+          deprecatedKeys.push(snakeKey);
+          result[camelKey] = snakeValue;
+        } else if (camelValue !== void 0 && camelValue !== null) {
+          result[camelKey] = camelValue;
+        }
+      };
+      mapKey("image_url", "imageUrl");
+      mapKey("guidance_scale", "guidanceScale");
+      mapKey("num_inference_steps", "numInferenceSteps");
+      mapKey("enable_safety_checker", "enableSafetyChecker");
+      mapKey("output_format", "outputFormat");
+      mapKey("sync_mode", "syncMode");
+      mapKey("safety_tolerance", "safetyTolerance");
+      if (data.strength !== void 0 && data.strength !== null) {
+        result.strength = data.strength;
+      }
+      if (data.acceleration !== void 0 && data.acceleration !== null) {
+        result.acceleration = data.acceleration;
+      }
+      for (const [key, value] of Object.entries(data)) {
+        if (![
+          // camelCase known keys
+          "imageUrl",
+          "guidanceScale",
+          "numInferenceSteps",
+          "enableSafetyChecker",
+          "outputFormat",
+          "syncMode",
+          "strength",
+          "acceleration",
+          "safetyTolerance",
+          // snake_case known keys
+          "image_url",
+          "guidance_scale",
+          "num_inference_steps",
+          "enable_safety_checker",
+          "output_format",
+          "sync_mode",
+          "safety_tolerance"
+        ].includes(key)) {
+          result[key] = value;
+        }
+      }
+      if (deprecatedKeys.length > 0) {
+        result.__deprecatedKeys = deprecatedKeys;
+      }
+      return result;
+    })
+  )
+);
+
+// src/fal-image-model.ts
 var FalImageModel = class {
   constructor(modelId, config) {
     this.modelId = modelId;
@@ -29,17 +113,15 @@ var FalImageModel = class {
   get provider() {
     return this.config.provider;
   }
-  async doGenerate({
+  async getArgs({
     prompt,
     n,
     size,
     aspectRatio,
     seed,
-    providerOptions,
-    headers,
-    abortSignal
+    providerOptions
   }) {
-    var _a, _b, _c, _d;
+    var _a;
     const warnings = [];
     let imageSize;
     if (size) {
@@ -48,22 +130,66 @@ var FalImageModel = class {
     } else if (aspectRatio) {
       imageSize = convertAspectRatioToSize(aspectRatio);
     }
+    const falOptions = await parseProviderOptions({
+      provider: "fal",
+      providerOptions,
+      schema: falImageProviderOptionsSchema
+    });
+    const requestBody = {
+      prompt,
+      seed,
+      image_size: imageSize,
+      num_images: n
+    };
+    if (falOptions) {
+      const deprecatedKeys = "__deprecatedKeys" in falOptions ? falOptions.__deprecatedKeys : void 0;
+      if (deprecatedKeys && deprecatedKeys.length > 0) {
+        warnings.push({
+          type: "other",
+          message: `The following provider options use deprecated snake_case and will be removed in @ai-sdk/fal v2.0. Please use camelCase instead: ${deprecatedKeys.map((key) => {
+            const camelCase = key.replace(
+              /_([a-z])/g,
+              (_, letter) => letter.toUpperCase()
+            );
+            return `'${key}' (use '${camelCase}')`;
+          }).join(", ")}`
+        });
+      }
+      const fieldMapping = {
+        imageUrl: "image_url",
+        guidanceScale: "guidance_scale",
+        numInferenceSteps: "num_inference_steps",
+        enableSafetyChecker: "enable_safety_checker",
+        outputFormat: "output_format",
+        syncMode: "sync_mode",
+        safetyTolerance: "safety_tolerance"
+      };
+      for (const [key, value] of Object.entries(falOptions)) {
+        if (key === "__deprecatedKeys") continue;
+        const apiKey = (_a = fieldMapping[key]) != null ? _a : key;
+        if (value !== void 0) {
+          requestBody[apiKey] = value;
+        }
+      }
+    }
+    return { requestBody, warnings };
+  }
+  async doGenerate(options) {
+    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 postJsonToApi({
       url: `${this.config.baseURL}/${this.modelId}`,
-      headers: combineHeaders(await resolve(this.config.headers), headers),
-      body: {
-        prompt,
-        seed,
-        image_size: imageSize,
-        num_images: n,
-        ...(_d = providerOptions.fal) != null ? _d : {}
-      },
+      headers: combineHeaders(
+        await resolve(this.config.headers),
+        options.headers
+      ),
+      body: requestBody,
       failedResponseHandler: falFailedResponseHandler,
       successfulResponseHandler: createJsonResponseHandler(
         falImageResponseSchema
       ),
-      abortSignal,
+      abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
     const {
@@ -77,7 +203,9 @@ var FalImageModel = class {
       ...responseMetaData
     } = value;
     const downloadedImages = await Promise.all(
-      targetImages.map((image) => this.downloadImage(image.url, abortSignal))
+      targetImages.map(
+        (image) => this.downloadImage(image.url, options.abortSignal)
+      )
     );
     return {
       images: downloadedImages,
@@ -157,56 +285,56 @@ function convertAspectRatioToSize(aspectRatio) {
   }
   return void 0;
 }
-var falValidationErrorSchema = z.object({
-  detail: z.array(
-    z.object({
-      loc: z.array(z.string()),
-      msg: z.string(),
-      type: z.string()
+var falValidationErrorSchema = z2.object({
+  detail: z2.array(
+    z2.object({
+      loc: z2.array(z2.string()),
+      msg: z2.string(),
+      type: z2.string()
     })
   )
 });
-var falHttpErrorSchema = z.object({
-  message: z.string()
+var falHttpErrorSchema = z2.object({
+  message: z2.string()
 });
-var falErrorSchema = z.union([falValidationErrorSchema, falHttpErrorSchema]);
-var falImageSchema = z.object({
-  url: z.string(),
-  width: z.number().nullish(),
-  height: 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: z.string().nullish(),
+  content_type: z2.string().nullish(),
   // e.g. https://fal.ai/models/fal-ai/flowedit/api#schema-output
-  file_name: z.string().nullish(),
-  file_data: z.string().optional(),
-  file_size: z.number().nullish()
+  file_name: z2.string().nullish(),
+  file_data: z2.string().optional(),
+  file_size: z2.number().nullish()
 });
-var loraFileSchema = z.object({
-  url: z.string(),
-  content_type: z.string().optional(),
-  file_name: z.string().nullable().optional(),
-  file_data: z.string().optional(),
-  file_size: 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 = z.object({
-  timings: z.object({
-    inference: z.number().optional()
+var commonResponseSchema = z2.object({
+  timings: z2.object({
+    inference: z2.number().optional()
   }).optional(),
-  seed: z.number().optional(),
-  has_nsfw_concepts: z.array(z.boolean()).optional(),
-  prompt: 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: z.array(z.boolean()).optional(),
-  num_inference_steps: 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 = z.looseObject(commonResponseSchema.shape);
-var falImageResponseSchema = z.union([
-  base.extend({ images: 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: 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;
 }
@@ -232,18 +360,18 @@ import {
   createJsonResponseHandler as createJsonResponseHandler2,
   delay,
   getFromApi as getFromApi2,
-  parseProviderOptions,
+  parseProviderOptions as parseProviderOptions2,
   postJsonToApi as postJsonToApi2
 } from "@ai-sdk/provider-utils";
-import { z as z3 } from "zod/v4";
+import { z as z4 } from "zod/v4";
 
 // src/fal-error.ts
-import { z as z2 } from "zod/v4";
+import { z as z3 } from "zod/v4";
 import { createJsonErrorResponseHandler as createJsonErrorResponseHandler2 } from "@ai-sdk/provider-utils";
-var falErrorDataSchema = z2.object({
-  error: z2.object({
-    message: z2.string(),
-    code: z2.number()
+var falErrorDataSchema = z3.object({
+  error: z3.object({
+    message: z3.string(),
+    code: z3.number()
   })
 });
 var falFailedResponseHandler2 = createJsonErrorResponseHandler2({
@@ -252,33 +380,33 @@ var falFailedResponseHandler2 = createJsonErrorResponseHandler2({
 });
 
 // src/fal-transcription-model.ts
-var falProviderOptionsSchema = z3.object({
+var falProviderOptionsSchema = 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: z3.union([z3.enum(["en"]), z3.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: z3.boolean().nullish().default(true),
+  diarize: z4.boolean().nullish().default(true),
   /**
    * Level of the chunks to return. Either segment or word. Default value: "segment"
    */
-  chunkLevel: z3.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: z3.enum(["3"]).nullish().default("3"),
+  version: z4.enum(["3"]).nullish().default("3"),
   /**
    * Default value: 64
    */
-  batchSize: z3.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: z3.number().nullable().nullish()
+  numSpeakers: z4.number().nullable().nullish()
 });
 var FalTranscriptionModel = class {
   constructor(modelId, config) {
@@ -294,7 +422,7 @@ var FalTranscriptionModel = class {
   }) {
     var _a, _b, _c;
     const warnings = [];
-    const falOptions = await parseProviderOptions({
+    const falOptions = await parseProviderOptions2({
       provider: "fal",
       providerOptions,
       schema: falProviderOptionsSchema
@@ -426,18 +554,18 @@ var FalTranscriptionModel = class {
     };
   }
 };
-var falJobResponseSchema = z3.object({
-  request_id: z3.string().nullish()
+var falJobResponseSchema = z4.object({
+  request_id: z4.string().nullish()
 });
-var falTranscriptionResponseSchema = z3.object({
-  text: z3.string(),
-  chunks: z3.array(
-    z3.object({
-      text: z3.string(),
-      timestamp: z3.array(z3.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: z3.array(z3.string()).nullish()
+  inferred_languages: z4.array(z4.string()).nullish()
 });
 
 // src/fal-speech-model.ts
@@ -447,10 +575,10 @@ import {
   createJsonResponseHandler as createJsonResponseHandler3,
   createStatusCodeErrorResponseHandler as createStatusCodeErrorResponseHandler2,
   getFromApi as getFromApi3,
-  parseProviderOptions as parseProviderOptions2,
+  parseProviderOptions as parseProviderOptions3,
   postJsonToApi as postJsonToApi3
 } from "@ai-sdk/provider-utils";
-import { z as z4 } from "zod/v4";
+import { z as z5 } from "zod/v4";
 
 // src/fal-api-types.ts
 var FAL_LANGUAGE_BOOSTS = [
@@ -491,18 +619,18 @@ var FAL_EMOTIONS = [
 ];
 
 // src/fal-speech-model.ts
-var falSpeechProviderOptionsSchema = z4.looseObject({
-  voice_setting: z4.object({
-    speed: z4.number().nullish(),
-    vol: z4.number().nullish(),
-    voice_id: z4.string().nullish(),
-    pitch: z4.number().nullish(),
-    english_normalization: z4.boolean().nullish(),
-    emotion: z4.enum(FAL_EMOTIONS).nullish()
+var falSpeechProviderOptionsSchema = 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: z4.record(z4.string(), z4.unknown()).nullish(),
-  language_boost: z4.enum(FAL_LANGUAGE_BOOSTS).nullish(),
-  pronunciation_dict: z4.record(z4.string(), z4.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) {
@@ -522,7 +650,7 @@ var FalSpeechModel = class {
     providerOptions
   }) {
     const warnings = [];
-    const falOptions = await parseProviderOptions2({
+    const falOptions = await parseProviderOptions3({
       provider: "fal",
       providerOptions,
       schema: falSpeechProviderOptionsSchema
@@ -595,14 +723,14 @@ var FalSpeechModel = class {
     };
   }
 };
-var falSpeechResponseSchema = z4.object({
-  audio: z4.object({ url: z4.string() }),
-  duration_ms: z4.number().optional(),
-  request_id: z4.string().optional()
+var falSpeechResponseSchema = z5.object({
+  audio: z5.object({ url: z5.string() }),
+  duration_ms: z5.number().optional(),
+  request_id: z5.string().optional()
 });
 
 // src/version.ts
-var VERSION = true ? "1.0.21" : "0.0.0-test";
+var VERSION = true ? "1.0.23" : "0.0.0-test";
 
 // src/fal-provider.ts
 var defaultBaseURL = "https://fal.run";