@umituz/react-native-ai-generation-content 1.53.0 → 1.55.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.53.0",
+  "version": "1.55.0",
   "description": "Provider-agnostic AI generation orchestration for React Native with result preview components",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/domains/generation/wizard/presentation/hooks/generation-result.utils.ts

@@ -3,11 +3,20 @@
  * Shared utilities for extracting and processing generation results
  */
 
+export interface FalErrorDetail {
+  msg?: string;
+  type?: string;
+  loc?: string[];
+  input?: string;
+}
+
 export interface FalResult {
   video?: { url?: string };
   output?: string;
   images?: Array<{ url?: string }>;
   image?: { url?: string };
+  detail?: FalErrorDetail[];
+  error?: string;
 }
 
 export interface GenerationUrls {
@@ -15,11 +24,43 @@ export interface GenerationUrls {
   videoUrl?: string;
 }
 
+/**
+ * Check if result contains an error and throw with appropriate message
+ */
+function checkForErrors(result: FalResult): void {
+  // Check for FAL API error format: {detail: [{msg, type}]}
+  if (result.detail && Array.isArray(result.detail) && result.detail.length > 0) {
+    const firstError = result.detail[0];
+    const errorType = firstError?.type || "unknown";
+    const errorMsg = firstError?.msg || "Generation failed";
+
+    // Map error type to translation key
+    if (errorType === "content_policy_violation") {
+      throw new Error("error.generation.content_policy");
+    }
+
+    if (errorType.includes("validation")) {
+      throw new Error("error.generation.validation");
+    }
+
+    throw new Error(errorMsg);
+  }
+
+  // Check for simple error field
+  if (result.error) {
+    throw new Error(result.error);
+  }
+}
+
 /**
  * Extracts image/video URL from FAL result
  * Handles various result formats from different FAL models
+ * Throws error if result contains error information
  */
 export function extractResultUrl(result: FalResult): GenerationUrls {
+  // First check for errors in the result
+  checkForErrors(result);
+
   // Video result
   if (result.video?.url) {
     return { videoUrl: result.video.url };

package/src/domains/generation/wizard/presentation/hooks/useVideoQueueGeneration.ts

@@ -109,14 +109,29 @@ export function useVideoQueueGeneration(
       if (status.status === QUEUE_STATUS.COMPLETED || status.status === QUEUE_STATUS.FAILED) {
         if (pollingRef.current) { clearInterval(pollingRef.current); pollingRef.current = null; }
         if (status.status === QUEUE_STATUS.COMPLETED) {
-          const result = await provider.getJobResult<FalResult>(model, requestId);
-          await handleComplete(extractResultUrl(result));
+          try {
+            const result = await provider.getJobResult<FalResult>(model, requestId);
+            await handleComplete(extractResultUrl(result));
+          } catch (resultErr) {
+            // Handle errors when getting/extracting result (e.g., ValidationError, content policy)
+            const errorMessage = resultErr instanceof Error ? resultErr.message : "Generation failed";
+            if (typeof __DEV__ !== "undefined" && __DEV__) {
+              console.error("[VideoQueueGeneration] Result error:", errorMessage);
+            }
+            await handleError(errorMessage);
+          }
         } else {
           await handleError("Generation failed");
         }
       }
     } catch (err) {
-      if (typeof __DEV__ !== "undefined" && __DEV__) console.error("[VideoQueueGeneration] Poll error:", err);
+      // Handle polling errors - stop polling and show error to user
+      if (pollingRef.current) { clearInterval(pollingRef.current); pollingRef.current = null; }
+      const errorMessage = err instanceof Error ? err.message : "Generation failed";
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.error("[VideoQueueGeneration] Poll error:", errorMessage);
+      }
+      await handleError(errorMessage);
     }
   }, [handleComplete, handleError]);
 

package/src/infrastructure/utils/error-message-extractor.util.ts

@@ -16,6 +16,42 @@ interface FalErrorDetail {
   readonly url?: string;
 }
 
+/**
+ * Error types for user-friendly messages
+ */
+export const GenerationErrorType = {
+  CONTENT_POLICY: "content_policy",
+  VALIDATION: "validation",
+  NETWORK: "network",
+  TIMEOUT: "timeout",
+  RATE_LIMIT: "rate_limit",
+  QUOTA_EXCEEDED: "quota_exceeded",
+  UNKNOWN: "unknown",
+} as const;
+
+export type GenerationErrorTypeValue = typeof GenerationErrorType[keyof typeof GenerationErrorType];
+
+/**
+ * Structured generation error
+ */
+export interface GenerationError extends Error {
+  readonly errorType: GenerationErrorTypeValue;
+  readonly translationKey: string;
+}
+
+/**
+ * Create a structured generation error
+ */
+function createGenerationError(
+  type: GenerationErrorTypeValue,
+  message: string,
+): GenerationError {
+  const error = new Error(message) as GenerationError;
+  (error as { errorType: GenerationErrorTypeValue }).errorType = type;
+  (error as { translationKey: string }).translationKey = `error.generation.${type}`;
+  return error;
+}
+
 /**
  * Check if result contains a FAL API error response
  * FAL sometimes returns errors with COMPLETED status
@@ -40,22 +76,74 @@ export function checkFalApiError(result: unknown): void {
 
     // Throw specific error based on type
     if (errorType === "content_policy_violation") {
-      throw new Error(`Content policy violation: ${errorMsg}`);
+      throw createGenerationError(GenerationErrorType.CONTENT_POLICY, errorMsg);
+    }
+
+    if (errorType === "validation_error" || errorType.includes("validation")) {
+      throw createGenerationError(GenerationErrorType.VALIDATION, errorMsg);
     }
 
-    throw new Error(errorMsg);
+    throw createGenerationError(GenerationErrorType.UNKNOWN, errorMsg);
+  }
+}
+
+/**
+ * Check if error is a GenerationError with translation key
+ */
+export function isGenerationError(error: unknown): error is GenerationError {
+  return error instanceof Error && "errorType" in error && "translationKey" in error;
+}
+
+/**
+ * Get translation key from error (returns key if GenerationError, null otherwise)
+ */
+export function getErrorTranslationKey(error: unknown): string | null {
+  if (isGenerationError(error)) {
+    return error.translationKey;
+  }
+
+  // Check for content policy in error message
+  const message = error instanceof Error ? error.message : String(error);
+  const lowerMessage = message.toLowerCase();
+
+  if (lowerMessage.includes("content_policy") || lowerMessage.includes("policy violation")) {
+    return `error.generation.${GenerationErrorType.CONTENT_POLICY}`;
+  }
+
+  if (lowerMessage.includes("rate limit") || lowerMessage.includes("429")) {
+    return `error.generation.${GenerationErrorType.RATE_LIMIT}`;
+  }
+
+  if (lowerMessage.includes("timeout") || lowerMessage.includes("timed out")) {
+    return `error.generation.${GenerationErrorType.TIMEOUT}`;
+  }
+
+  if (lowerMessage.includes("network") || lowerMessage.includes("connection")) {
+    return `error.generation.${GenerationErrorType.NETWORK}`;
   }
+
+  return null;
 }
 
 /**
  * Extract error message from FAL API and other error formats
  * Supports: Error instances, FAL API errors, generic objects
+ * Returns translation key if available, otherwise original message
  */
 export function extractErrorMessage(
   error: unknown,
   defaultMessage = "Processing failed",
   debugPrefix?: string,
 ): string {
+  // First check if this is a GenerationError with translation key
+  const translationKey = getErrorTranslationKey(error);
+  if (translationKey) {
+    if (__DEV__ && debugPrefix) {
+      console.error(`[${debugPrefix}] Error (translation key):`, translationKey);
+    }
+    return translationKey;
+  }
+
   let message = defaultMessage;
 
   if (error instanceof Error) {
@@ -65,6 +153,11 @@ export function extractErrorMessage(
 
     // FAL API error format: {detail: [{msg, type, loc}]}
     if (Array.isArray(errObj.detail) && errObj.detail[0]?.msg) {
+      const detailType = errObj.detail[0]?.type;
+      // Check for content policy in FAL API response
+      if (detailType === "content_policy_violation") {
+        return `error.generation.${GenerationErrorType.CONTENT_POLICY}`;
+      }
       message = String(errObj.detail[0].msg);
     } else if (errObj.detail) {
       message = JSON.stringify(errObj.detail);