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

package/package.json

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

@@ -28,8 +28,6 @@ export class FalProvider implements IAIProvider {
   private apiKey: string | null = null;
   private initialized = false;
   private lastRequestKey: string | null = null;
-  /** Tracks the active sessionId so callers can retrieve logs */
-  private activeSessionId: string | null = null;
 
   initialize(config: AIProviderConfig): void {
     this.apiKey = config.apiKey;
@@ -80,7 +78,6 @@ export class FalProvider implements IAIProvider {
     this.validateInit();
     validateInput(model, input);
     const sessionId = generationLogCollector.startSession();
-    this.activeSessionId = sessionId;
     generationLogCollector.log(sessionId, 'fal-provider', `submitJob() for model: ${model}`);
     const processedInput = await preprocessInput(input, sessionId);
     return queueOps.submitJob(model, processedInput);
@@ -108,7 +105,6 @@ export class FalProvider implements IAIProvider {
 
     // Start a fresh log session for this generation
     const sessionId = generationLogCollector.startSession();
-    this.activeSessionId = sessionId;
     generationLogCollector.log(sessionId, TAG, `subscribe() called for model: ${model}`);
 
     const preprocessStart = Date.now();
@@ -140,7 +136,12 @@ export class FalProvider implements IAIProvider {
       .then((res) => {
         const totalElapsed = Date.now() - totalStart;
         generationLogCollector.log(sessionId, TAG, `Generation SUCCESS in ${totalElapsed}ms (preprocess: ${preprocessElapsed}ms)`);
-        resolvePromise(res.result);
+        // Attach providerSessionId to result for concurrent-safe log retrieval
+        const result = res.result;
+        if (result && typeof result === 'object') {
+          Object.defineProperty(result, '__providerSessionId', { value: sessionId, enumerable: false });
+        }
+        resolvePromise(result);
       })
       .catch((error) => {
         const totalElapsed = Date.now() - totalStart;
@@ -163,7 +164,6 @@ export class FalProvider implements IAIProvider {
     validateInput(model, input);
 
     const sessionId = generationLogCollector.startSession();
-    this.activeSessionId = sessionId;
     generationLogCollector.log(sessionId, 'fal-provider', `run() for model: ${model}`);
 
     const processedInput = await preprocessInput(input, sessionId);
@@ -173,13 +173,17 @@ export class FalProvider implements IAIProvider {
       throw new Error("Request cancelled by user");
     }
 
-    return handleFalRun<T>(model, processedInput, sessionId, options);
+    const result = await handleFalRun<T>(model, processedInput, sessionId, options);
+    // Attach providerSessionId to result for concurrent-safe log retrieval
+    if (result && typeof result === 'object') {
+      Object.defineProperty(result, '__providerSessionId', { value: sessionId, enumerable: false });
+    }
+    return result;
   }
 
   reset(): void {
     cancelAllRequests();
     this.lastRequestKey = null;
-    this.activeSessionId = null;
     this.apiKey = null;
     this.initialized = false;
   }
@@ -196,22 +200,21 @@ export class FalProvider implements IAIProvider {
   }
 
   /**
-   * Get all log entries collected during the current/last generation session.
-   * Returns empty array if no active session.
+   * Get log entries for a specific provider session.
+   * Extract sessionId from result.__providerSessionId for concurrent safety.
    */
-  getSessionLogs(): LogEntry[] {
-    if (!this.activeSessionId) return [];
-    return generationLogCollector.getEntries(this.activeSessionId);
+  getSessionLogs(sessionId?: string): LogEntry[] {
+    if (!sessionId) return [];
+    return generationLogCollector.getEntries(sessionId);
   }
 
   /**
-   * End the current log session and return all entries. Clears the buffer.
+   * End a provider log session and return all entries. Clears the buffer.
+   * Extract sessionId from result.__providerSessionId for concurrent safety.
    */
-  endLogSession(): LogEntry[] {
-    if (!this.activeSessionId) return [];
-    const entries = generationLogCollector.endSession(this.activeSessionId);
-    this.activeSessionId = null;
-    return entries;
+  endLogSession(sessionId?: string): LogEntry[] {
+    if (!sessionId) return [];
+    return generationLogCollector.endSession(sessionId);
   }
 }
 

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]));
     }
   }