@umituz/react-native-ai-fal-provider 3.2.13 → 3.2.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-fal-provider",
-  "version": "3.2.13",
+  "version": "3.2.15",
   "description": "FAL AI provider for React Native - implements IAIProvider interface for unified AI generation",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/infrastructure/utils/fal-storage.util.ts

@@ -42,6 +42,23 @@ export async function uploadToFalStorage(base64: string): Promise<string> {
   }
 }
 
+/**
+ * Upload a local file (file:// or content:// URI) to FAL storage
+ * Directly fetches the file as a blob — no base64 intermediate step
+ */
+export async function uploadLocalFileToFalStorage(fileUri: string): Promise<string> {
+  try {
+    const response = await fetch(fileUri);
+    const blob = await response.blob();
+    const url = await fal.storage.upload(blob);
+    return url;
+  } catch (error) {
+    throw new Error(
+      `Failed to upload local file to FAL storage: ${getErrorMessage(error)}`
+    );
+  }
+}
+
 /**
  * Upload multiple images to FAL storage in parallel
  * Uses Promise.allSettled to handle partial failures gracefully

package/src/infrastructure/utils/input-preprocessor.util.ts

@@ -1,16 +1,26 @@
 /**
  * Input Preprocessor Utility
- * Detects and uploads base64 images to FAL storage before API calls
+ * Detects and uploads base64/local file images to FAL storage before API calls
  */
 
-import { uploadToFalStorage } from "./fal-storage.util";
+import { uploadToFalStorage, uploadLocalFileToFalStorage } from "./fal-storage.util";
 import { getErrorMessage } from './helpers/error-helpers.util';
 import { IMAGE_URL_FIELDS } from './constants/image-fields.constants';
 import { isImageDataUri as isBase64DataUri } from './validators/data-uri-validator.util';
 
 /**
- * Preprocess input by uploading base64 images to FAL storage
- * Returns input with URLs instead of base64 data URIs
+ * Check if a value is a local file URI (file:// or content://)
+ */
+function isLocalFileUri(value: unknown): value is string {
+  return typeof value === "string" && (
+    value.startsWith("file://") || value.startsWith("content://")
+  );
+}
+
+/**
+ * Preprocess input by uploading base64/local file images to FAL storage.
+ * Also strips sync_mode to prevent base64 data URI responses.
+ * Returns input with HTTPS URLs instead of base64/local URIs.
  */
 export async function preprocessInput(
   input: Record<string, unknown>,
@@ -18,9 +28,24 @@ export async function preprocessInput(
   const result = { ...input };
   const uploadPromises: Promise<unknown>[] = [];
 
+  // SAFETY: Strip sync_mode to prevent base64 data URI responses
+  // FAL returns base64 when sync_mode:true — we always want CDN URLs
+  if ("sync_mode" in result) {
+    delete result.sync_mode;
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.warn(
+        "[preprocessInput] Stripped sync_mode from input. " +
+        "sync_mode:true returns base64 data URIs which break Firestore persistence. " +
+        "Use falProvider.subscribe() for CDN URLs."
+      );
+    }
+  }
+
   // Handle individual image URL keys
   for (const key of IMAGE_URL_FIELDS) {
     const value = result[key];
+
+    // Upload base64 data URIs to FAL storage
     if (isBase64DataUri(value)) {
       const uploadPromise = uploadToFalStorage(value)
         .then((url) => {
@@ -35,8 +60,24 @@ export async function preprocessInput(
 
       uploadPromises.push(uploadPromise);
     }
+    // Upload local file URIs to FAL storage (file://, content://)
+    else if (isLocalFileUri(value)) {
+      const uploadPromise = uploadLocalFileToFalStorage(value)
+        .then((url) => {
+          result[key] = url;
+          return url;
+        })
+        .catch((error) => {
+          const errorMessage = `Failed to upload local file ${key}: ${getErrorMessage(error)}`;
+          console.error(`[preprocessInput] ${errorMessage}`);
+          throw new Error(errorMessage);
+        });
+
+      uploadPromises.push(uploadPromise);
+    }
   }
 
+
   // Handle image_urls array (for multi-person generation)
   if (Array.isArray(result.image_urls) && result.image_urls.length > 0) {
     const imageUrls = result.image_urls as unknown[];

package/src/infrastructure/utils/input-validator.util.ts

@@ -22,7 +22,6 @@ function hasSuspiciousContent(value: string): boolean {
     /<object/i,                    // object tags
     /data:(?!image\/)/i,          // data URLs that aren't images
     /vbscript:/i,                  // vbscript protocol
-    /file:/i,                      // file protocol
   ];
 
   return suspiciousPatterns.some(pattern => pattern.test(value));
@@ -52,6 +51,11 @@ function isValidAndSafeUrl(value: string): boolean {
     }
   }
 
+  // Allow local file URIs (file://, content://) — preprocessInput uploads them to FAL storage
+  if (value.startsWith('file://') || value.startsWith('content://')) {
+    return true;
+  }
+
   // Allow base64 image data URIs only
   if (isImageDataUri(value)) {
     // Check for suspicious content in data URI
@@ -95,6 +99,14 @@ export function validateInput(
     errors.push({ field: "input", message: "Input must be a non-empty object" });
   }
 
+  // BLOCK sync_mode:true — it causes FAL to return base64 data URIs instead of CDN URLs
+  if (input.sync_mode === true) {
+    errors.push({
+      field: "sync_mode",
+      message: "sync_mode:true is forbidden. It returns base64 data URIs instead of HTTPS CDN URLs, which breaks Firestore persistence (2048 char limit). Use falProvider.subscribe() for CDN URLs.",
+    });
+  }
+
   // Validate and check prompt for malicious content
   if (input.prompt !== undefined) {
     if (!isValidPrompt(input.prompt)) {