@umituz/react-native-ai-fal-provider 3.2.31 → 3.2.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-fal-provider",
-  "version": "3.2.31",
+  "version": "3.2.32",
   "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/input-preprocessor.util.ts

@@ -1,6 +1,10 @@
 /**
  * Input Preprocessor Utility
  * Detects and uploads base64/local file images to FAL storage before API calls
+ *
+ * Upload strategy:
+ * - Array fields (image_urls): SEQUENTIAL uploads to avoid bandwidth contention
+ * - Individual fields (image_url, face_image_url): parallel (typically only 1)
  */
 
 import { uploadToFalStorage, uploadLocalFileToFalStorage } from "./fal-storage.util";
@@ -17,10 +21,33 @@ function isLocalFileUri(value: unknown): value is string {
   );
 }
 
+/**
+ * Classify a network error into a user-friendly message.
+ * Technical details are preserved in Firestore logs/session subcollection.
+ */
+function classifyUploadError(errorMsg: string): string {
+  const lower = errorMsg.toLowerCase();
+
+  if (lower.includes('timed out') || lower.includes('timeout')) {
+    return 'Photo upload took too long. Please try again on a stronger connection (WiFi recommended).';
+  }
+  if (lower.includes('network request failed') || lower.includes('network') || lower.includes('fetch')) {
+    return 'Photo upload failed due to network issues. Please check your internet connection and try again.';
+  }
+  if (lower.includes('econnrefused') || lower.includes('enotfound')) {
+    return 'Could not reach the upload server. Please check your internet connection and try again.';
+  }
+
+  return errorMsg;
+}
+
 /**
  * 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.
+ *
+ * Array fields are uploaded SEQUENTIALLY to avoid bandwidth contention
+ * on slow mobile connections (prevents simultaneous upload failures).
  */
 export async function preprocessInput(
   input: Record<string, unknown>,
@@ -38,7 +65,7 @@ export async function preprocessInput(
     generationLogCollector.warn(sessionId, TAG, `Stripped sync_mode from input`);
   }
 
-  // Handle individual image URL keys
+  // Handle individual image URL keys (parallel — typically only 1 field)
   let individualUploadCount = 0;
   for (const key of IMAGE_URL_FIELDS) {
     const value = result[key];
@@ -78,76 +105,45 @@ export async function preprocessInput(
     generationLogCollector.log(sessionId, TAG, `${individualUploadCount} individual field upload(s) queued`);
   }
 
-  // Handle image URL arrays
+  // Handle image URL arrays — SEQUENTIAL to avoid bandwidth contention
   for (const arrayField of ["image_urls", "input_image_urls", "reference_image_urls"] as const) {
     if (Array.isArray(result[arrayField]) && (result[arrayField] as unknown[]).length > 0) {
       const imageUrls = result[arrayField] as unknown[];
-      generationLogCollector.log(sessionId, TAG, `Processing ${arrayField}: ${imageUrls.length} item(s)`);
+      generationLogCollector.log(sessionId, TAG, `Processing ${arrayField}: ${imageUrls.length} item(s) (sequential)`);
 
-      const uploadTasks: Array<{ index: number; url: string | Promise<string> }> = [];
-      const errors: string[] = [];
+      const processedUrls: string[] = [];
+      const arrayStartTime = Date.now();
 
       for (let i = 0; i < imageUrls.length; i++) {
         const imageUrl = imageUrls[i];
 
         if (!imageUrl) {
-          errors.push(`${arrayField}[${i}] is null or undefined`);
-          continue;
+          throw new Error(`${arrayField}[${i}] is null or undefined`);
         }
 
         if (isBase64DataUri(imageUrl)) {
-          generationLogCollector.log(sessionId, TAG, `${arrayField}[${i}]: base64 (${Math.round(String(imageUrl).length / 1024)}KB) - uploading`);
-          const uploadPromise = uploadToFalStorage(imageUrl, sessionId)
-            .then((url) => url)
-            .catch((error) => {
-              const errorMessage = `Failed to upload ${arrayField}[${i}]: ${getErrorMessage(error)}`;
-              generationLogCollector.error(sessionId, TAG, errorMessage);
-              errors.push(errorMessage);
-              throw new Error(errorMessage);
-            });
-          uploadTasks.push({ index: i, url: uploadPromise });
+          const sizeKB = Math.round(String(imageUrl).length / 1024);
+          generationLogCollector.log(sessionId, TAG, `${arrayField}[${i}/${imageUrls.length}]: base64 (${sizeKB}KB) - uploading...`);
+
+          try {
+            const url = await uploadToFalStorage(imageUrl, sessionId);
+            processedUrls.push(url);
+            generationLogCollector.log(sessionId, TAG, `${arrayField}[${i}/${imageUrls.length}]: upload OK`);
+          } catch (error) {
+            const elapsed = Date.now() - arrayStartTime;
+            const technicalMsg = getErrorMessage(error);
+            generationLogCollector.error(sessionId, TAG, `${arrayField}[${i}] upload FAILED after ${elapsed}ms: ${technicalMsg}`);
+            throw new Error(classifyUploadError(technicalMsg));
+          }
         } else if (typeof imageUrl === "string") {
-          generationLogCollector.log(sessionId, TAG, `${arrayField}[${i}]: already URL - pass through`);
-          uploadTasks.push({ index: i, url: imageUrl });
+          generationLogCollector.log(sessionId, TAG, `${arrayField}[${i}/${imageUrls.length}]: already URL - pass through`);
+          processedUrls.push(imageUrl);
         } else {
-          errors.push(`${arrayField}[${i}] has invalid type: ${typeof imageUrl}`);
+          throw new Error(`${arrayField}[${i}] has invalid type: ${typeof imageUrl}`);
         }
       }
 
-      if (errors.length > 0) {
-        generationLogCollector.error(sessionId, TAG, `Validation errors in ${arrayField}`, { errors });
-        throw new Error(`Image URL validation failed:\n${errors.join('\n')}`);
-      }
-
-      if (uploadTasks.length === 0) {
-        throw new Error(`${arrayField} array must contain at least one valid image URL`);
-      }
-
-      const arrayStartTime = Date.now();
-      const uploadResults = await Promise.allSettled(
-        uploadTasks.map((task) => Promise.resolve(task.url))
-      );
-
-      const processedUrls: string[] = [];
-      const uploadErrors: string[] = [];
-
-      uploadResults.forEach((uploadResult, index) => {
-        if (uploadResult.status === 'fulfilled') {
-          processedUrls.push(uploadResult.value);
-        } else {
-          uploadErrors.push(
-            `Upload ${index} failed: ${getErrorMessage(uploadResult.reason)}`
-          );
-        }
-      });
-
       const arrayElapsed = Date.now() - arrayStartTime;
-
-      if (uploadErrors.length > 0) {
-        generationLogCollector.error(sessionId, TAG, `${arrayField} upload FAILED: ${processedUrls.length}/${uploadTasks.length} succeeded in ${arrayElapsed}ms`);
-        throw new Error(`Image upload failures:\n${uploadErrors.join('\n')}`);
-      }
-
       generationLogCollector.log(sessionId, TAG, `${arrayField}: all ${processedUrls.length} upload(s) succeeded in ${arrayElapsed}ms`);
       result[arrayField] = processedUrls;
     }
@@ -159,16 +155,16 @@ export async function preprocessInput(
     const individualUploadResults = await Promise.allSettled(uploadPromises);
 
     const failedUploads = individualUploadResults.filter(
-      (result) => result.status === 'rejected'
+      (r) => r.status === 'rejected'
     );
 
     if (failedUploads.length > 0) {
       const successCount = individualUploadResults.length - failedUploads.length;
-      const errorMessages = failedUploads.map((result) =>
-        result.status === 'rejected' ? getErrorMessage(result.reason) : 'Unknown error'
+      const errorMessages = failedUploads.map((r) =>
+        r.status === 'rejected' ? getErrorMessage(r.reason) : 'Unknown error'
       );
       generationLogCollector.error(sessionId, TAG, `Individual uploads: ${successCount}/${individualUploadResults.length} succeeded`, { errors: errorMessages });
-      throw new Error(`Some image uploads failed:\n${errorMessages.join('\n')}`);
+      throw new Error(classifyUploadError(errorMessages[0]));
     }
   }