@umituz/react-native-ai-fal-provider 3.2.14 → 3.2.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-fal-provider",
-  "version": "3.2.14",
+  "version": "3.2.16",
   "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/services/fal-provider-subscription.ts

@@ -146,6 +146,9 @@ export async function handleFalSubscription<T = unknown>(
           const statusWithPosition = `${jobStatus.status}:${jobStatus.queuePosition ?? ""}`;
           if (statusWithPosition !== lastStatus) {
             lastStatus = statusWithPosition;
+            if (typeof __DEV__ !== "undefined" && __DEV__) {
+              console.log(`[fal-provider] Job Status Update: ${jobStatus.status}${jobStatus.queuePosition ? ` (Position: ${jobStatus.queuePosition})` : ""}`);
+            }
             if (options?.onProgress) {
               if (jobStatus.status === "IN_QUEUE" || jobStatus.status === "IN_PROGRESS") {
                 options.onProgress({ progress: -1, status: jobStatus.status });
@@ -182,9 +185,15 @@ export async function handleFalSubscription<T = unknown>(
     const rawResult = await Promise.race(promises);
     const { data, requestId } = unwrapFalResult<T>(rawResult);
 
+    // Validate response for base64 data URIs
+    // Since we use subscribe, we should always get CDN URLs, not base64 data URIs
     validateNoBase64InResponse(data);
     validateNSFWContent(data as Record<string, unknown>);
 
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log(`[fal-provider] Subscription completed successfully. Request ID: ${requestId}`);
+    }
+
     options?.onResult?.(data);
     return { result: data, requestId };
   } catch (error) {

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

@@ -15,6 +15,10 @@ import { getErrorMessage } from './helpers/error-helpers.util';
  * Uses design system's filesystem utilities for React Native compatibility
  */
 export async function uploadToFalStorage(base64: string): Promise<string> {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log(`[fal-storage] Uploading base64 image to FAL (first 50 chars): ${base64.substring(0, 50)}...`);
+  }
+
   // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-assignment
   const tempUri = (await base64ToTempFile(base64));
 
@@ -26,6 +30,11 @@ export async function uploadToFalStorage(base64: string): Promise<string> {
     const response = await fetch(tempUri);
     const blob = await response.blob();
     const url = await fal.storage.upload(blob);
+    
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log(`[fal-storage] Successfully uploaded base64 data to FAL. URL: ${url}`);
+    }
+
     return url;
   } finally {
     try {
@@ -42,6 +51,32 @@ 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 {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log(`[fal-storage] Starting local file upload to FAL: ${fileUri}`);
+    }
+
+    const response = await fetch(fileUri);
+    const blob = await response.blob();
+    const url = await fal.storage.upload(blob);
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log(`[fal-storage] Successfully uploaded local file to FAL. URL: ${url}`);
+    }
+
+    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,26 +1,57 @@
 /**
  * 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>,
 ): Promise<Record<string, unknown>> {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[preprocessInput] Starting input preprocessing...", {
+      keys: Object.keys(input)
+    });
+  }
+
   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 +66,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)) {