@umituz/react-native-ai-fal-provider 3.2.36 → 3.2.38

package/package.json

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

package/src/domain/types/index.ts

@@ -13,6 +13,7 @@ export type {
   ReplaceBackgroundOptions,
   VideoFromImageOptions,
   TextToVideoOptions,
+  TextToVoiceOptions,
   FaceSwapOptions,
 } from "./input-builders.types";
 

package/src/domain/types/input-builders.types.ts

@@ -54,6 +54,22 @@ export interface TextToVideoOptions {
   readonly resolution?: string;
 }
 
+/**
+ * Options for text-to-voice generation (TTS)
+ */
+export interface TextToVoiceOptions {
+  /** Text content to convert to speech (required) */
+  readonly text: string;
+  /** Voice preset name (model-specific, e.g., "aria", "marcus") */
+  readonly voice?: string;
+  /** Language code (e.g., "en", "es", "fr") */
+  readonly language?: string;
+  /** Exaggeration factor for voice expressiveness (0.0 - 1.0) */
+  readonly exaggeration?: number;
+  /** CFG/pace control weight */
+  readonly cfgWeight?: number;
+}
+
 export interface FaceSwapOptions {
   readonly enhanceFaces?: boolean;
 }

package/src/exports/domain.ts

@@ -33,6 +33,7 @@ export type {
   ReplaceBackgroundOptions,
   VideoFromImageOptions,
   TextToVideoOptions,
+  TextToVoiceOptions,
   ImageFeatureType,
   VideoFeatureType,
   AIProviderConfig,

package/src/infrastructure/services/fal-provider-subscription.ts

@@ -310,7 +310,9 @@ export async function handleFalSubscription<T = unknown>(
       const totalElapsed = Date.now() - overallStart;
       const retryInfo = attempt > 0 ? ` after ${attempt + 1} attempts` : '';
       generationLogCollector.error(sessionId, TAG, `Subscription FAILED in ${totalElapsed}ms${retryInfo}: ${message}`);
-      throw new Error(message);
+      // Re-throw original error to preserve type info (ApiError, ValidationError, etc.)
+      // so downstream mapFalError() can categorize by HTTP status code
+      throw error;
     }
   }
 
@@ -334,7 +336,10 @@ export async function handleFalRun<T = unknown>(
   options?.onProgress?.({ progress: -1, status: "IN_PROGRESS" as const });
 
   try {
-    const rawResult = await fal.run(model, { input });
+    const rawResult = await fal.run(model, {
+      input,
+      ...(options?.signal && { abortSignal: options.signal }),
+    });
     const { data } = unwrapFalResult<T>(rawResult);
 
     validateNoBase64InResponse(data);
@@ -355,6 +360,7 @@ export async function handleFalRun<T = unknown>(
 
     const message = formatFalError(error);
     generationLogCollector.error(sessionId, runTag, `Run FAILED after ${elapsed}ms for model ${model}: ${message}`);
-    throw new Error(message);
+    // Re-throw original error to preserve type info for downstream mapFalError()
+    throw error;
   }
 }

package/src/infrastructure/services/fal-provider.ts

@@ -12,6 +12,7 @@ import type {
 import { DEFAULT_FAL_CONFIG, FAL_CAPABILITIES } from "./fal-provider.constants";
 import { handleFalSubscription, handleFalRun } from "./fal-provider-subscription";
 import { preprocessInput } from "../utils";
+import { getErrorMessage } from "../utils/helpers/error-helpers.util";
 import { generationLogCollector } from "../utils/log-collector";
 import type { LogEntry } from "../utils/log-collector";
 import {
@@ -79,8 +80,15 @@ export class FalProvider implements IAIProvider {
     validateInput(model, input);
     const sessionId = generationLogCollector.startSession();
     generationLogCollector.log(sessionId, 'fal-provider', `submitJob() for model: ${model}`);
-    const processedInput = await preprocessInput(input, sessionId);
-    return queueOps.submitJob(model, processedInput);
+    try {
+      const processedInput = await preprocessInput(input, sessionId);
+      const result = await queueOps.submitJob(model, processedInput);
+      generationLogCollector.endSession(sessionId);
+      return result;
+    } catch (error) {
+      generationLogCollector.endSession(sessionId);
+      throw error;
+    }
   }
 
   async getJobStatus(model: string, requestId: string): Promise<JobStatus> {
@@ -145,14 +153,17 @@ export class FalProvider implements IAIProvider {
       })
       .catch((error) => {
         const totalElapsed = Date.now() - totalStart;
-        generationLogCollector.error(sessionId, TAG, `Generation FAILED in ${totalElapsed}ms: ${error instanceof Error ? error.message : String(error)}`);
+        generationLogCollector.error(sessionId, TAG, `Generation FAILED in ${totalElapsed}ms: ${getErrorMessage(error)}`);
+        // End the log session on failure — consumer can't access sessionId from errors,
+        // so auto-cleanup prevents memory leak from orphaned sessions
+        generationLogCollector.endSession(sessionId);
         rejectPromise(error);
       })
       .finally(() => {
         try {
           removeRequest(key);
         } catch (cleanupError) {
-          generationLogCollector.warn(sessionId, TAG, `Error removing request: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+          generationLogCollector.warn(sessionId, TAG, `Error removing request: ${getErrorMessage(cleanupError)}`);
         }
       });
 
@@ -170,15 +181,21 @@ export class FalProvider implements IAIProvider {
 
     const signal = options?.signal;
     if (signal?.aborted) {
+      generationLogCollector.endSession(sessionId);
       throw new Error("Request cancelled by user");
     }
 
-    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 });
+    try {
+      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;
+    } catch (error) {
+      generationLogCollector.endSession(sessionId);
+      throw error;
     }
-    return result;
   }
 
   reset(): void {

package/src/infrastructure/services/request-store.ts

@@ -51,16 +51,27 @@ function sortKeys(obj: unknown): unknown {
 }
 
 /**
- * Create a deterministic request key using model and input hash
+ * Create a deterministic request key using model and input hash.
+ * Uses dual 32-bit hashes (FNV-1a + DJB2) for collision resistance.
+ * 64-bit combined hash space makes accidental collisions extremely unlikely.
  */
 export function createRequestKey(model: string, input: Record<string, unknown>): string {
   const inputStr = JSON.stringify(sortKeys(input));
-  let hash = 0;
+
+  // FNV-1a hash
+  let h1 = 0x811c9dc5;
   for (let i = 0; i < inputStr.length; i++) {
-    const char = inputStr.charCodeAt(i);
-    hash = ((hash << 5) - hash + char) | 0;
+    h1 ^= inputStr.charCodeAt(i);
+    h1 = Math.imul(h1, 0x01000193);
   }
-  return `${model}:${hash.toString(36)}`;
+
+  // DJB2 hash (independent seed)
+  let h2 = 5381;
+  for (let i = 0; i < inputStr.length; i++) {
+    h2 = ((h2 << 5) + h2 + inputStr.charCodeAt(i)) | 0;
+  }
+
+  return `${model}:${(h1 >>> 0).toString(36)}_${(h2 >>> 0).toString(36)}`;
 }
 
 export function getExistingRequest<T>(key: string): ActiveRequest<T> | undefined {

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

@@ -47,13 +47,13 @@ async function withRetry<T>(
       return await fn();
     } catch (error) {
       lastError = error;
-      const errorMsg = getErrorMessage(error);
+      const errorMsg = getErrorMessage(error).toLowerCase();
       const isTransient =
-        errorMsg.toLowerCase().includes('network') ||
+        errorMsg.includes('network') ||
         errorMsg.includes('timeout') ||
         errorMsg.includes('timed out') ||
-        errorMsg.includes('ECONNREFUSED') ||
-        errorMsg.includes('ENOTFOUND') ||
+        errorMsg.includes('econnrefused') ||
+        errorMsg.includes('enotfound') ||
         errorMsg.includes('fetch');
 
       if (attempt < maxRetries && isTransient) {

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

@@ -135,6 +135,19 @@ export async function preprocessInput(
             generationLogCollector.error(sessionId, TAG, `${arrayField}[${i}] upload FAILED after ${elapsed}ms: ${technicalMsg}`);
             throw new Error(classifyUploadError(technicalMsg));
           }
+        } else if (isLocalFileUri(imageUrl)) {
+          generationLogCollector.log(sessionId, TAG, `${arrayField}[${i}/${imageUrls.length}]: local file - uploading...`);
+
+          try {
+            const url = await uploadLocalFileToFalStorage(imageUrl, sessionId);
+            processedUrls.push(url);
+            generationLogCollector.log(sessionId, TAG, `${arrayField}[${i}/${imageUrls.length}]: local file upload OK`);
+          } catch (error) {
+            const elapsed = Date.now() - arrayStartTime;
+            const technicalMsg = getErrorMessage(error);
+            generationLogCollector.error(sessionId, TAG, `${arrayField}[${i}] local file upload FAILED after ${elapsed}ms: ${technicalMsg}`);
+            throw new Error(classifyUploadError(technicalMsg));
+          }
         } else if (typeof imageUrl === "string") {
           generationLogCollector.log(sessionId, TAG, `${arrayField}[${i}/${imageUrls.length}]: already URL - pass through`);
           processedUrls.push(imageUrl);

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

@@ -35,11 +35,11 @@ export function calculateVideoCredits(
       : COSTS.VIDEO_720P_PER_SECOND;
   let cost = costPerSec * duration;
   if (hasImageInput) cost += COSTS.IMAGE_INPUT;
-  return Math.ceil((cost * MARKUP) / CREDIT_PRICE);
+  return Math.max(1, Math.ceil((cost * MARKUP) / CREDIT_PRICE));
 }
 
 export function calculateImageCredits(): number {
-  return Math.ceil((COSTS.IMAGE * MARKUP) / CREDIT_PRICE);
+  return Math.max(1, Math.ceil((COSTS.IMAGE * MARKUP) / CREDIT_PRICE));
 }
 
 export function calculateCreditsFromConfig(

package/src/infrastructure/validators/nsfw-validator.ts

@@ -55,10 +55,14 @@ export function validateNSFWContent(result: Record<string, unknown>): void {
     throw new NSFWContentError();
   }
 
-  // Format 5: content_policy_violation object
-  const policyViolation = result?.content_policy_violation as { type: string; severity?: string } | undefined;
+  // Format 5: content_policy_violation — boolean true or object with type field
+  const policyViolation = result?.content_policy_violation;
+  if (policyViolation === true) {
+    throw new NSFWContentError();
+  }
   if (policyViolation && typeof policyViolation === "object") {
-    const type = (policyViolation.type || "").toLowerCase();
+    const typed = policyViolation as { type?: string; severity?: string };
+    const type = (typed.type || "").toLowerCase();
     if (type.includes("nsfw") || type.includes("adult") || type.includes("explicit")) {
       throw new NSFWContentError();
     }

package/src/init/initializeFalProvider.ts

@@ -12,24 +12,23 @@ import { falProvider } from '../infrastructure/services';
  */
 export function initializeFalProvider(config: {
   apiKey: string | undefined;
+  /** When true (default), sets this provider as the active/default provider */
+  setAsActive?: boolean;
 }): boolean {
-  try {
-    const { apiKey } = config;
+  const { apiKey, setAsActive = true } = config;
 
-    if (!apiKey) {
-      return false;
-    }
+  if (!apiKey) {
+    return false;
+  }
 
-    falProvider.initialize({ apiKey });
+  falProvider.initialize({ apiKey });
 
-    if (!providerRegistry.hasProvider(falProvider.providerId)) {
-      providerRegistry.register(falProvider);
-    }
+  if (!providerRegistry.hasProvider(falProvider.providerId)) {
+    providerRegistry.register(falProvider);
+  }
+  if (setAsActive) {
     providerRegistry.setActiveProvider(falProvider.providerId);
-
-    return true;
-  } catch (error) {
-    console.error('[initializeFalProvider] Initialization failed:', error);
-    throw error;
   }
+
+  return true;
 }

package/src/presentation/hooks/use-fal-generation.ts

@@ -50,6 +50,7 @@ export function useFalGeneration<T = unknown>(
   const [error, setError] = useState<FalErrorInfo | null>(null);
   const [isLoading, setIsLoading] = useState(false);
   const [isCancelling, setIsCancelling] = useState(false);
+  const [requestId, setRequestId] = useState<string | null>(null);
 
   const stateManagerRef = useRef<FalGenerationStateManager<T> | null>(null);
   const optionsRef = useRef(options);
@@ -76,14 +77,12 @@ export function useFalGeneration<T = unknown>(
         stateManagerRef.current = null;
       }
 
-      // Cancel any running requests
-      if (falProvider.hasRunningRequest()) {
-        try {
-          falProvider.cancelCurrentRequest();
-        } catch (error) {
-          console.warn('[useFalGeneration] Error cancelling request on unmount:', error);
-        }
-      }
+      // On unmount, do NOT cancel via falProvider.cancelCurrentRequest() —
+      // it only tracks the LAST started request across ALL hook instances.
+      // If another component started a generation after us, cancelling here
+      // would kill THEIR request, not ours. Instead, rely on checkMounted()
+      // to silently discard results for this unmounted component.
+      // The user-initiated cancel() function still works for explicit cancellation.
     };
   }, []); // Empty deps - only run on mount/unmount
 
@@ -97,12 +96,16 @@ export function useFalGeneration<T = unknown>(
       setError(null);
       setData(null);
       stateManager.setCurrentRequestId(null);
+      setRequestId(null);
       setIsCancelling(false);
 
       try {
         const result = await falProvider.subscribe<T>(modelEndpoint, input, {
           timeoutMs: optionsRef.current?.timeoutMs,
           onQueueUpdate: (status: JobStatus) => {
+            if (status.requestId && status.requestId !== stateManager.getCurrentRequestId()) {
+              setRequestId(status.requestId);
+            }
             const falStatus = convertJobStatusToFalQueueStatus(
               status,
               stateManager.getCurrentRequestId()
@@ -153,11 +156,10 @@ export function useFalGeneration<T = unknown>(
     setError(null);
     setIsLoading(false);
     setIsCancelling(false);
+    setRequestId(null);
     stateManagerRef.current?.clearLastRequest();
   }, [cancel]);
 
-  const requestId = stateManagerRef.current?.getCurrentRequestId() ?? null;
-
   return {
     data,
     error,