@umituz/react-native-ai-generation-content 1.52.2 → 1.54.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.52.2",
+  "version": "1.54.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/infrastructure/strategies/video-generation.strategy.ts

@@ -1,13 +1,13 @@
 /**
  * Video Generation Strategy
  * Handles video-specific generation logic (execution only)
+ * Uses clean prompts for Sora 2 - no complex identity preservation text
  */
 
 import {
   executeVideoFeature,
   submitVideoFeatureToQueue,
 } from "../../../../../infrastructure/services/video-feature-executor.service";
-import { buildUnifiedPrompt } from "./shared/unified-prompt-builder";
 import type { WizardScenarioData } from "../../presentation/hooks/useWizardGeneration";
 import type { WizardStrategy } from "./wizard-strategy.types";
 import { VIDEO_PROCESSING_PROMPTS } from "./wizard-strategy.constants";
@@ -36,12 +36,12 @@ export async function buildVideoInput(
     throw new Error(validation.errorKey ?? "error.generation.invalidInput");
   }
 
-  let basePrompt = extractPrompt(wizardData, scenario.aiPrompt);
+  let finalPrompt = extractPrompt(wizardData, scenario.aiPrompt);
 
-  if (!basePrompt) {
+  if (!finalPrompt) {
     const defaultPrompt = VIDEO_PROCESSING_PROMPTS[scenario.id];
     if (defaultPrompt) {
-      basePrompt = defaultPrompt;
+      finalPrompt = defaultPrompt;
     } else {
       if (typeof __DEV__ !== "undefined" && __DEV__) {
         console.error("[VideoStrategy] No prompt found for scenario:", scenario.id);
@@ -51,17 +51,11 @@ export async function buildVideoInput(
     }
   }
 
-  // Build unified prompt with face preservation
-  const finalPrompt = buildUnifiedPrompt({
-    basePrompt,
-    photoCount: photos.length,
-    interactionStyle: scenario.interactionStyle as string | undefined,
-  });
-
+  // For video generation with Sora 2, use clean prompt directly
+  // No need for complex identity preservation text - Sora 2 handles this natively
   if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[VideoStrategy] Prompt built", {
-      baseLength: basePrompt.length,
-      finalLength: finalPrompt.length,
+    console.log("[VideoStrategy] Using clean prompt for Sora 2", {
+      promptLength: finalPrompt.length,
       photoCount: photos.length,
     });
   }

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