@umituz/react-native-ai-generation-content 1.33.0 → 1.33.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.33.0",
+  "version": "1.33.2",
   "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

@@ -43,11 +43,24 @@ export interface VideoGenerationResult {
 async function extractPhotosFromWizardData(
   wizardData: Record<string, unknown>,
 ): Promise<string[]> {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[VideoStrategy:extractPhotos] Starting extraction", {
+      wizardDataKeys: Object.keys(wizardData),
+    });
+  }
+
   const photoKeys = Object.keys(wizardData)
     .filter((k) => k.includes(PHOTO_KEY_PREFIX))
     .sort();
 
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[VideoStrategy:extractPhotos] Found photo keys", { photoKeys });
+  }
+
   if (photoKeys.length === 0) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[VideoStrategy:extractPhotos] No photo keys found");
+    }
     return [];
   }
 
@@ -56,15 +69,35 @@ async function extractPhotosFromWizardData(
     const photo = wizardData[key] as { uri?: string };
     if (photo?.uri) {
       photoUris.push(photo.uri);
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[VideoStrategy:extractPhotos] Found photo URI", { key, uri: photo.uri.substring(0, 50) + "..." });
+      }
     }
   }
 
   if (photoUris.length === 0) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[VideoStrategy:extractPhotos] No photo URIs found");
+    }
     return [];
   }
 
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[VideoStrategy:extractPhotos] Converting to base64", { count: photoUris.length });
+  }
+
   const photosBase64 = await Promise.all(photoUris.map((uri) => readFileAsBase64(uri)));
-  return photosBase64.filter(Boolean) as string[];
+  const validPhotos = photosBase64.filter(Boolean) as string[];
+
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[VideoStrategy:extractPhotos] Converted photos", {
+      total: photoUris.length,
+      valid: validPhotos.length,
+      sizes: validPhotos.map((p) => `${(p.length / 1024).toFixed(1)}KB`),
+    });
+  }
+
+  return validPhotos;
 }
 
 // ============================================================================
@@ -91,20 +124,52 @@ export async function buildVideoInput(
   wizardData: Record<string, unknown>,
   scenario: WizardScenarioData,
 ): Promise<VideoGenerationInput | null> {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[VideoStrategy:buildInput] START", {
+      scenarioId: scenario.id,
+      outputType: scenario.outputType,
+      hasAiPrompt: !!scenario.aiPrompt,
+    });
+  }
+
   const photos = await extractPhotosFromWizardData(wizardData);
 
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[VideoStrategy:buildInput] Photos extracted", {
+      count: photos.length,
+      hasSource: !!photos[0],
+      hasTarget: !!photos[1],
+    });
+  }
+
   // Extract prompt using type-safe extractor with fallback
   let prompt = extractPrompt(wizardData, scenario.aiPrompt);
 
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[VideoStrategy:buildInput] Prompt from wizard", {
+      hasPrompt: !!prompt,
+      promptLength: prompt?.length ?? 0,
+    });
+  }
+
   // For video processing features, use default prompt if none provided
   if (!prompt) {
     const defaultPrompt = VIDEO_PROCESSING_PROMPTS[scenario.id];
     if (defaultPrompt) {
       prompt = defaultPrompt;
       if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[VideoStrategy] Using default prompt for", scenario.id);
+        console.log("[VideoStrategy:buildInput] Using default prompt", {
+          scenarioId: scenario.id,
+          prompt: prompt.substring(0, 50) + "...",
+        });
       }
     } else {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[VideoStrategy:buildInput] ERROR: No prompt available", {
+          scenarioId: scenario.id,
+          availablePrompts: Object.keys(VIDEO_PROCESSING_PROMPTS),
+        });
+      }
       throw new Error("Prompt is required for video generation");
     }
   }
@@ -114,7 +179,7 @@ export async function buildVideoInput(
   const aspectRatio = extractAspectRatio(wizardData);
   const resolution = extractResolution(wizardData);
 
-  return {
+  const input: VideoGenerationInput = {
     sourceImageBase64: photos[0],
     targetImageBase64: photos[1] || photos[0],
     prompt,
@@ -122,6 +187,21 @@ export async function buildVideoInput(
     aspectRatio,
     resolution,
   };
+
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[VideoStrategy:buildInput] COMPLETE", {
+      hasSource: !!input.sourceImageBase64,
+      hasTarget: !!input.targetImageBase64,
+      sourceSize: input.sourceImageBase64 ? `${(input.sourceImageBase64.length / 1024).toFixed(1)}KB` : "N/A",
+      targetSize: input.targetImageBase64 ? `${(input.targetImageBase64.length / 1024).toFixed(1)}KB` : "N/A",
+      prompt: input.prompt.substring(0, 50) + "...",
+      duration: input.duration,
+      aspectRatio: input.aspectRatio,
+      resolution: input.resolution,
+    });
+  }
+
+  return input;
 }
 
 // ============================================================================
@@ -138,6 +218,14 @@ export function createVideoStrategy(options: CreateVideoStrategyOptions): Wizard
   const repository = createCreationsRepository(collectionName);
   const videoFeatureType = getVideoFeatureType(scenario.id);
 
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[VideoStrategy:create] Created strategy", {
+      scenarioId: scenario.id,
+      videoFeatureType,
+      collectionName,
+    });
+  }
+
   let lastInputRef: VideoGenerationInput | null = null;
 
   return {
@@ -145,6 +233,15 @@ export function createVideoStrategy(options: CreateVideoStrategyOptions): Wizard
       const videoInput = input as VideoGenerationInput;
       lastInputRef = videoInput;
 
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[VideoStrategy:execute] START", {
+          featureType: videoFeatureType,
+          hasSource: !!videoInput.sourceImageBase64,
+          hasTarget: !!videoInput.targetImageBase64,
+          prompt: videoInput.prompt.substring(0, 50) + "...",
+        });
+      }
+
       const result = await executeVideoFeature(
         videoFeatureType,
         {
@@ -159,10 +256,28 @@ export function createVideoStrategy(options: CreateVideoStrategyOptions): Wizard
         },
       );
 
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[VideoStrategy:execute] RESULT", {
+          success: result.success,
+          hasVideoUrl: !!result.videoUrl,
+          error: result.error,
+          requestId: result.requestId,
+        });
+      }
+
       if (!result.success || !result.videoUrl) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[VideoStrategy:execute] FAILED", { error: result.error });
+        }
         throw new Error(result.error || "Video generation failed");
       }
 
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[VideoStrategy:execute] SUCCESS", {
+          videoUrl: result.videoUrl.substring(0, 80) + "...",
+        });
+      }
+
       return { videoUrl: result.videoUrl };
     },
 

package/src/domains/scenarios/configs/wizard-configs.ts

@@ -69,10 +69,10 @@ const INPUT_PATTERNS: Record<WizardInputType, RegExp[]> = {
  * Returns SINGLE_IMAGE as safe default
  */
 export const detectWizardInputType = (scenarioId: string): WizardInputType => {
-  // Check patterns in priority order: TEXT_INPUT, SINGLE_IMAGE, DUAL_IMAGE_FACE
-  // DUAL_IMAGE has no patterns - must be explicitly specified
+  // Check patterns in priority order: TEXT_INPUT, DUAL_IMAGE, DUAL_IMAGE_FACE, SINGLE_IMAGE
   const checkOrder: WizardInputType[] = [
     WizardInputType.TEXT_INPUT,
+    WizardInputType.DUAL_IMAGE,
     WizardInputType.DUAL_IMAGE_FACE,
     WizardInputType.SINGLE_IMAGE,
   ];

package/src/infrastructure/services/video-feature-executor.service.ts

@@ -26,13 +26,28 @@ export async function executeVideoFeature(
   request: VideoFeatureRequest,
   options?: ExecuteVideoFeatureOptions,
 ): Promise<VideoFeatureResult> {
+  if (__DEV__) {
+    console.log(`[VideoExecutor:${featureType}] START`, {
+      hasSource: !!request.sourceImageBase64,
+      hasTarget: !!request.targetImageBase64,
+      promptLength: request.prompt?.length ?? 0,
+      options: request.options,
+    });
+  }
+
   const provider = providerRegistry.getActiveProvider();
 
   if (!provider) {
+    if (__DEV__) {
+      console.log(`[VideoExecutor:${featureType}] ERROR: No provider`);
+    }
     return { success: false, error: "No AI provider configured" };
   }
 
   if (!provider.isInitialized()) {
+    if (__DEV__) {
+      console.log(`[VideoExecutor:${featureType}] ERROR: Provider not initialized`);
+    }
     return { success: false, error: "AI provider not initialized" };
   }
 
@@ -41,7 +56,7 @@ export async function executeVideoFeature(
   const model = provider.getVideoFeatureModel(featureType);
 
   if (__DEV__) {
-    console.log(`[Video:${featureType}] Provider: ${provider.providerId}, Model: ${model}`);
+    console.log(`[VideoExecutor:${featureType}] Provider: ${provider.providerId}, Model: ${model}`);
   }
 
   try {
@@ -52,31 +67,74 @@ export async function executeVideoFeature(
       options: request.options,
     };
 
+    if (__DEV__) {
+      console.log(`[VideoExecutor:${featureType}] InputData prepared`, {
+        sourceSize: inputData.sourceImageBase64 ? `${(inputData.sourceImageBase64.length / 1024).toFixed(1)}KB` : "N/A",
+        targetSize: inputData.targetImageBase64 ? `${(inputData.targetImageBase64.length / 1024).toFixed(1)}KB` : "N/A",
+        prompt: inputData.prompt?.substring(0, 50) + "...",
+      });
+    }
+
     const input = provider.buildVideoFeatureInput(featureType, inputData);
 
+    if (__DEV__) {
+      console.log(`[VideoExecutor:${featureType}] Built input for API`, {
+        inputKeys: Object.keys(input),
+        hasImageUrl: !!(input as Record<string, unknown>).image_url,
+        hasPrompt: !!(input as Record<string, unknown>).prompt,
+      });
+    }
+
+    let statusCount = 0;
     const result = await provider.subscribe(model, input, {
       timeoutMs: VIDEO_TIMEOUT_MS,
       onQueueUpdate: (status) => {
-        if (__DEV__) {
-          console.log(`[Video:${featureType}] Queue status:`, status.status);
+        statusCount++;
+        // Log every 10th status update to avoid spam
+        if (__DEV__ && statusCount % 10 === 1) {
+          console.log(`[VideoExecutor:${featureType}] Queue #${statusCount}:`, status.status);
         }
         onStatusChange?.(status.status);
       },
     });
 
+    if (__DEV__) {
+      console.log(`[VideoExecutor:${featureType}] API Response received`, {
+        totalStatusUpdates: statusCount,
+        resultKeys: result ? Object.keys(result as object) : "null",
+        resultType: typeof result,
+      });
+    }
+
     // Check for FAL API error in result (may return with COMPLETED status)
     checkFalApiError(result);
 
     const extractor = extractResult ?? extractVideoResult;
     const videoUrl = extractor(result);
 
+    if (__DEV__) {
+      console.log(`[VideoExecutor:${featureType}] Extracted video URL`, {
+        hasVideoUrl: !!videoUrl,
+        urlPreview: videoUrl ? videoUrl.substring(0, 80) + "..." : "N/A",
+      });
+    }
+
     if (!videoUrl) {
       if (__DEV__) {
-        console.log(`[Video:${featureType}] No video URL found in result`);
+        console.log(`[VideoExecutor:${featureType}] FAILED: No video URL`, {
+          result: JSON.stringify(result).substring(0, 500),
+        });
       }
       return { success: false, error: "No video in response" };
     }
 
+    if (__DEV__) {
+      console.log(`[VideoExecutor:${featureType}] SUCCESS`, {
+        videoUrl: videoUrl.substring(0, 80) + "...",
+        requestId: (result as { requestId?: string })?.requestId,
+      });
+    }
+
     return {
       success: true,
       videoUrl,
@@ -84,6 +142,12 @@ export async function executeVideoFeature(
     };
   } catch (error) {
     const message = extractErrorMessage(error, "Processing failed", `Video:${featureType}`);
+    if (__DEV__) {
+      console.log(`[VideoExecutor:${featureType}] EXCEPTION`, {
+        error: message,
+        originalError: error instanceof Error ? error.message : String(error),
+      });
+    }
     return { success: false, error: message };
   }
 }