@umituz/react-native-ai-generation-content 1.26.26 → 1.26.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.26.26",
+  "version": "1.26.29",
   "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/wizard-strategy.factory.ts

@@ -18,8 +18,7 @@ declare const __DEV__: boolean;
 // ============================================================================
 
 interface ImageGenerationInput {
-  readonly partnerABase64: string;
-  readonly partnerBBase64: string;
+  readonly photos: readonly string[]; // Dynamic array - supports 1, 2, 3... N photos
   readonly prompt: string;
 }
 
@@ -44,8 +43,7 @@ async function executeImageGeneration(
   if (typeof __DEV__ !== "undefined" && __DEV__) {
     console.log("[WizardStrategy] executeImageGeneration ENTRY", {
       receivedModel: model,
-      hasPartnerA: !!input.partnerABase64,
-      hasPartnerB: !!input.partnerBBase64,
+      photoCount: input.photos.length,
       promptLength: input.prompt.length,
     });
   }
@@ -64,12 +62,10 @@ async function executeImageGeneration(
       return base64.startsWith("data:") ? base64 : `data:image/jpeg;base64,${base64}`;
     };
 
-    const imageUrls = [input.partnerABase64, input.partnerBBase64]
-      .filter(Boolean)
-      .map(formatBase64);
+    const imageUrls = input.photos.map(formatBase64);
 
-    if (imageUrls.length < 2) {
-      return { success: false, error: "Two images required" };
+    if (imageUrls.length === 0) {
+      return { success: false, error: "At least one image required" };
     }
 
     onProgress?.(10);
@@ -125,105 +121,171 @@ async function executeImageGeneration(
 }
 
 // ============================================================================
-// Input Builder
+// Photo Extraction (Generic - used by both image and video)
 // ============================================================================
 
-async function buildGenerationInput(
+async function extractPhotosFromWizardData(
   wizardData: Record<string, unknown>,
-  scenario: WizardScenarioData,
-): Promise<WizardGenerationInput | null> {
-  const photo1Key = Object.keys(wizardData).find((k) => k.includes("photo_1"));
-  const photo2Key = Object.keys(wizardData).find((k) => k.includes("photo_2"));
+): Promise<string[] | null> {
+  // Find ALL photo keys dynamically (photo_1, photo_2, photo_3, ...)
+  const photoKeys = Object.keys(wizardData)
+    .filter((k) => k.includes("photo_"))
+    .sort(); // Sort to maintain order (photo_1, photo_2, ...)
 
-  if (!photo1Key || !photo2Key) {
+  if (photoKeys.length === 0) {
     if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.error("[WizardStrategy] Missing photos in wizard data", {
+      console.error("[WizardStrategy] No photos found in wizard data", {
         keys: Object.keys(wizardData),
-        hasPhoto1: !!photo1Key,
-        hasPhoto2: !!photo2Key,
       });
     }
     return null;
   }
 
-  const photo1 = wizardData[photo1Key] as { uri?: string; base64?: string };
-  const photo2 = wizardData[photo2Key] as { uri?: string; base64?: string };
-
-  if (!photo1?.uri || !photo2?.uri) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.error("[WizardStrategy] Photos missing URI", {
-        photo1HasUri: !!photo1?.uri,
-        photo2HasUri: !!photo2?.uri,
-      });
+  // Extract photo URIs
+  const photoUris: string[] = [];
+  for (const key of photoKeys) {
+    const photo = wizardData[key] as { uri?: string; base64?: string };
+    if (!photo?.uri) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.error("[WizardStrategy] Photo missing URI", { key });
+      }
+      return null;
     }
-    return null;
+    photoUris.push(photo.uri);
   }
 
-  // Convert images to base64
-  const [photo1Base64, photo2Base64] = await Promise.all([
-    readFileAsBase64(photo1.uri),
-    readFileAsBase64(photo2.uri),
-  ]);
+  // Convert all images to base64 in parallel
+  const photosBase64 = await Promise.all(
+    photoUris.map((uri) => readFileAsBase64(uri)),
+  );
 
-  if (!photo1Base64 || !photo2Base64) {
+  // Filter out nulls/undefined
+  const validPhotos = photosBase64.filter(Boolean) as string[];
+
+  if (validPhotos.length === 0) {
     if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.error("[WizardStrategy] Failed to convert images to base64");
+      console.error("[WizardStrategy] Failed to convert any images to base64");
     }
     return null;
   }
 
-  // NO FALLBACK - scenario.aiPrompt is REQUIRED
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[WizardStrategy] Photos extracted", {
+      photoCount: validPhotos.length,
+      photoKeys,
+    });
+  }
+
+  return validPhotos;
+}
+
+// ============================================================================
+// Image Generation Input Builder
+// ============================================================================
+
+async function buildImageGenerationInput(
+  wizardData: Record<string, unknown>,
+  scenario: WizardScenarioData,
+): Promise<ImageGenerationInput | null> {
+  // Extract photos
+  const photos = await extractPhotosFromWizardData(wizardData);
+  if (!photos) return null;
+
+  // Validate scenario prompt
   if (!scenario.aiPrompt || scenario.aiPrompt.trim() === "") {
     if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.error("[WizardStrategy] CRITICAL: scenario.aiPrompt is missing or empty!", {
+      console.error("[WizardStrategy] scenario.aiPrompt missing", {
         scenarioId: scenario.id,
-        aiPrompt: scenario.aiPrompt,
       });
     }
     throw new Error(`Scenario "${scenario.id}" must have aiPrompt field`);
   }
 
   let prompt = scenario.aiPrompt;
-  const outputType = scenario.outputType || "video";
 
-  // For image generation, enhance prompt with style selections
-  if (outputType === "image") {
-    const styleEnhancements: string[] = [];
+  // Enhance prompt with style selections (image-specific)
+  const styleEnhancements: string[] = [];
 
-    // Romantic mood (multi-select array)
-    const romanticMoods = wizardData.selection_romantic_mood as string[] | undefined;
-    if (romanticMoods && romanticMoods.length > 0) {
-      styleEnhancements.push(`Mood: ${romanticMoods.join(", ")}`);
-    }
+  // Romantic mood (multi-select array)
+  const romanticMoods = wizardData.selection_romantic_mood as string[] | undefined;
+  if (romanticMoods && romanticMoods.length > 0) {
+    styleEnhancements.push(`Mood: ${romanticMoods.join(", ")}`);
+  }
 
-    // Art style (single select)
-    const artStyle = wizardData.selection_art_style as string | undefined;
-    if (artStyle && artStyle !== "original") {
-      styleEnhancements.push(`Art style: ${artStyle}`);
-    }
+  // Art style (single select)
+  const artStyle = wizardData.selection_art_style as string | undefined;
+  if (artStyle && artStyle !== "original") {
+    styleEnhancements.push(`Art style: ${artStyle}`);
+  }
+
+  // Artist style (single select)
+  const artist = wizardData.selection_artist_style as string | undefined;
+  if (artist && artist !== "original") {
+    styleEnhancements.push(`Artist style: ${artist}`);
+  }
+
+  // Enhance prompt with selected styles
+  if (styleEnhancements.length > 0) {
+    prompt = `${prompt}. ${styleEnhancements.join(", ")}`;
+  }
 
-    // Artist style (single select)
-    const artist = wizardData.selection_artist_style as string | undefined;
-    if (artist && artist !== "original") {
-      styleEnhancements.push(`Artist style: ${artist}`);
+  return {
+    photos, // Dynamic array - supports 1, 2, 3... N photos
+    prompt,
+  };
+}
+
+// ============================================================================
+// Video Generation Input Builder
+// ============================================================================
+
+async function buildVideoGenerationInput(
+  wizardData: Record<string, unknown>,
+  scenario: WizardScenarioData,
+): Promise<VideoGenerationInput | null> {
+  // Extract photos
+  const photos = await extractPhotosFromWizardData(wizardData);
+  if (!photos) return null;
+
+  // Video requires at least 1 photo (can duplicate if only 1)
+  if (photos.length < 1) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.error("[WizardStrategy] Video generation needs at least 1 photo");
     }
+    return null;
+  }
 
-    // Enhance prompt with selected styles
-    if (styleEnhancements.length > 0) {
-      prompt = `${prompt}. ${styleEnhancements.join(", ")}`;
+  // Validate scenario prompt
+  if (!scenario.aiPrompt || scenario.aiPrompt.trim() === "") {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.error("[WizardStrategy] scenario.aiPrompt missing", {
+        scenarioId: scenario.id,
+      });
     }
+    throw new Error(`Scenario "${scenario.id}" must have aiPrompt field`);
+  }
+
+  return {
+    sourceImageBase64: photos[0],
+    targetImageBase64: photos[1] || photos[0], // Use first photo if only 1 provided
+    prompt: scenario.aiPrompt,
+  };
+}
+
+// ============================================================================
+// Input Builder Dispatcher (Routes to correct builder)
+// ============================================================================
+
+async function buildGenerationInput(
+  wizardData: Record<string, unknown>,
+  scenario: WizardScenarioData,
+): Promise<WizardGenerationInput | null> {
+  const outputType = scenario.outputType || "video";
 
-    return {
-      partnerABase64: photo1Base64,
-      partnerBBase64: photo2Base64,
-      prompt,
-    } as ImageGenerationInput;
+  if (outputType === "image") {
+    return buildImageGenerationInput(wizardData, scenario);
   } else {
-    return {
-      sourceImageBase64: photo1Base64,
-      targetImageBase64: photo2Base64,
-      prompt,
-    } as VideoGenerationInput;
+    return buildVideoGenerationInput(wizardData, scenario);
   }
 }
 

package/src/domains/scenarios/domain/scenario.types.ts

@@ -187,7 +187,7 @@ export type CoupleFeatureId = string;
  */
 export interface CoupleFeatureSelection {
   readonly featureId: CoupleFeatureId | null;
-  readonly [key: string]: any;
+  readonly [key: string]: CoupleFeatureId | string | boolean | number | null | undefined;
 }
 
 export interface ScenarioData {

package/src/domains/scenarios/presentation/screens/MainCategoryScreen.tsx

@@ -69,8 +69,7 @@ export const MainCategoryScreen: React.FC<MainCategoryScreenProps> = ({
       return (
         <AtomicCard
           image={item.image}
-          // Fallback to emoji/icon if no image (though we expect images now)
-          leftIcon={!item.image && !item.emoji ? (item.icon as any) : undefined}
+          leftIcon={item.icon}
           title={title}
           subtitle={description}
           imageAspectRatio={1.5}

package/src/domains/scenarios/presentation/screens/SubCategoryScreen.tsx

@@ -86,12 +86,11 @@ export const SubCategoryScreen: React.FC<SubCategoryScreenProps> = ({
       return (
         <AtomicCard
           image={item.image}
-          leftIcon={!item.emoji ? (item.icon as any) : undefined}
+          leftIcon={item.icon}
           badge={item.emoji}
           title={title}
           subtitle={description}
-          // Smaller aspect ratio for subcategories if they have images, or standard if not
-          imageAspectRatio={item.image ? 1.5 : undefined} 
+          imageAspectRatio={item.image ? 1.5 : undefined}
           onPress={() => handleSubCategoryPress(item.id)}
           testID={`sub-category-${item.id}`}
           style={{ marginBottom: tokens.spacing.md }}

package/src/infrastructure/constants/index.ts

@@ -0,0 +1,11 @@
+/**
+ * Infrastructure Constants
+ */
+
+export {
+  IMAGE_PROGRESS,
+  VIDEO_PROGRESS,
+  POLLING_PROGRESS,
+  VIDEO_TIMEOUT_MS,
+  MAX_TRANSIENT_ERRORS,
+} from "./progress.constants";

package/src/infrastructure/constants/progress.constants.ts

@@ -0,0 +1,36 @@
+/**
+ * Progress Constants
+ * Standardized progress values for generation pipelines
+ */
+
+/** Image generation progress stages */
+export const IMAGE_PROGRESS = {
+  START: 10,
+  INPUT_PREPARED: 30,
+  REQUEST_SENT: 40,
+  RESULT_RECEIVED: 90,
+  COMPLETE: 100,
+} as const;
+
+/** Video generation progress stages */
+export const VIDEO_PROGRESS = {
+  START: 5,
+  INPUT_PREPARED: 10,
+  REQUEST_SENT: 15,
+  IN_QUEUE: 20,
+  IN_PROGRESS: 50,
+  RESULT_RECEIVED: 90,
+  COMPLETE: 100,
+} as const;
+
+/** Polling progress stages */
+export const POLLING_PROGRESS = {
+  RESULT_RECEIVED: 90,
+  COMPLETE: 100,
+} as const;
+
+/** Video generation timeout in milliseconds (5 minutes) */
+export const VIDEO_TIMEOUT_MS = 300000;
+
+/** Maximum consecutive transient errors before failing */
+export const MAX_TRANSIENT_ERRORS = 5;

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

@@ -5,16 +5,14 @@
  */
 
 import { providerRegistry } from "./provider-registry.service";
-import { cleanBase64 } from "../utils";
+import { cleanBase64, extractErrorMessage } from "../utils";
+import { extractImageResult } from "../utils/url-extractor";
+import { IMAGE_PROGRESS } from "../constants";
+import type { ImageResultExtractor } from "../utils/url-extractor";
 import type { ImageFeatureType, ImageFeatureInputData } from "../../domain/interfaces";
 
 declare const __DEV__: boolean;
 
-/**
- * Result extractor function type
- */
-export type ImageResultExtractor = (result: unknown) => string | undefined;
-
 /**
  * Execution options
  */
@@ -43,57 +41,6 @@ export interface ImageFeatureRequest {
   options?: Record<string, unknown>;
 }
 
-/**
- * Default result extractor - handles common response formats
- * Supports both direct response and data-wrapped response (fal.ai)
- */
-function defaultExtractImageResult(result: unknown): string | undefined {
-  if (typeof result !== "object" || result === null) return undefined;
-
-  const r = result as Record<string, unknown>;
-
-  if (__DEV__) {
-    console.log("[ImageExtractor] Result keys:", Object.keys(r));
-    console.log("[ImageExtractor] Has data:", !!r.data);
-    console.log("[ImageExtractor] Has images:", !!r.images);
-  }
-
-  // Handle fal.ai data wrapper
-  const data = (r.data as Record<string, unknown>) ?? r;
-
-  if (__DEV__) {
-    console.log("[ImageExtractor] Data keys:", Object.keys(data));
-  }
-
-  // Direct string values
-  if (typeof data.image === "string") return data.image;
-  if (typeof data.imageUrl === "string") return data.imageUrl;
-  if (typeof data.output === "string") return data.output;
-
-  // Object with url property (birefnet, rembg format: data.image.url)
-  const imageObj = data.image as Record<string, unknown> | undefined;
-  if (imageObj && typeof imageObj === "object" && typeof imageObj.url === "string") {
-    if (__DEV__) {
-      console.log("[ImageExtractor] Found data.image.url:", imageObj.url);
-    }
-    return imageObj.url;
-  }
-
-  // Array format (flux, etc: data.images[0].url)
-  if (Array.isArray(data.images) && typeof data.images[0]?.url === "string") {
-    if (__DEV__) {
-      console.log("[ImageExtractor] Found images[0].url:", data.images[0].url);
-    }
-    return data.images[0].url;
-  }
-
-  if (__DEV__) {
-    console.log("[ImageExtractor] No image URL found in result");
-  }
-
-  return undefined;
-}
-
 /**
  * Execute any image feature using the active provider
  */
@@ -122,7 +69,7 @@ export async function executeImageFeature(
   }
 
   try {
-    onProgress?.(10);
+    onProgress?.(IMAGE_PROGRESS.START);
 
     const inputData: ImageFeatureInputData = {
       imageBase64: request.imageBase64 ? cleanBase64(request.imageBase64) : "",
@@ -133,20 +80,20 @@ export async function executeImageFeature(
       options: request.options,
     };
 
-    onProgress?.(30);
+    onProgress?.(IMAGE_PROGRESS.INPUT_PREPARED);
 
     const input = provider.buildImageFeatureInput(featureType, inputData);
 
-    onProgress?.(40);
+    onProgress?.(IMAGE_PROGRESS.REQUEST_SENT);
 
     const result = await provider.run(model, input);
 
-    onProgress?.(90);
+    onProgress?.(IMAGE_PROGRESS.RESULT_RECEIVED);
 
-    const extractor = extractResult ?? defaultExtractImageResult;
+    const extractor = extractResult ?? extractImageResult;
     const imageUrl = extractor(result);
 
-    onProgress?.(100);
+    onProgress?.(IMAGE_PROGRESS.COMPLETE);
 
     if (!imageUrl) {
       return { success: false, error: "No image in response" };
@@ -158,26 +105,7 @@ export async function executeImageFeature(
       requestId: (result as { requestId?: string })?.requestId,
     };
   } catch (error) {
-    // Extract detailed error message from FAL API errors
-    let message = "Processing failed";
-    if (error instanceof Error) {
-      message = error.message;
-    } else if (typeof error === "object" && error !== null) {
-      const errObj = error as Record<string, unknown>;
-      // FAL API error format: {detail: [{msg, type, loc}]} or {message}
-      if (Array.isArray(errObj.detail) && errObj.detail[0]?.msg) {
-        message = String(errObj.detail[0].msg);
-      } else if (errObj.detail) {
-        message = JSON.stringify(errObj.detail);
-      } else if (errObj.message) {
-        message = String(errObj.message);
-      } else if (errObj.msg) {
-        message = String(errObj.msg);
-      }
-    }
-    if (__DEV__) {
-      console.error(`[Image:${featureType}] Error:`, message, error);
-    }
+    const message = extractErrorMessage(error, "Processing failed", `Image:${featureType}`);
     return { success: false, error: message };
   }
 }

package/src/infrastructure/services/index.ts

@@ -17,11 +17,11 @@ export {
   hasImageFeatureSupport,
 } from "./image-feature-executor.service";
 export type {
-  ImageResultExtractor,
   ExecuteImageFeatureOptions,
   ImageFeatureResult,
   ImageFeatureRequest,
 } from "./image-feature-executor.service";
+export type { ImageResultExtractor } from "../utils/url-extractor";
 export {
   executeVideoFeature,
   hasVideoFeatureSupport,

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

@@ -9,44 +9,23 @@ import { providerRegistry } from "./provider-registry.service";
 declare const __DEV__: boolean;
 
 export class ProviderValidator {
-    getProvider(): IAIProvider {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-             
-            console.log("[ProviderValidator] getProvider() called");
-        }
-
-        const provider = providerRegistry.getActiveProvider();
-
-        if (!provider) {
-            if (typeof __DEV__ !== "undefined" && __DEV__) {
-                 
-                console.error("[ProviderValidator] No active provider found!");
-            }
-            throw new Error(
-                "No active AI provider. Register and set a provider first.",
-            );
-        }
-
-        if (!provider.isInitialized()) {
-            if (typeof __DEV__ !== "undefined" && __DEV__) {
-                 
-                console.error("[ProviderValidator] Provider not initialized:", provider.providerId);
-            }
-            throw new Error(
-                `Provider ${provider.providerId} is not initialized.`,
-            );
-        }
-
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-             
-            console.log("[ProviderValidator] getProvider() returning:", {
-                providerId: provider.providerId,
-                isInitialized: provider.isInitialized(),
-            });
-        }
+  getProvider(): IAIProvider {
+    const provider = providerRegistry.getActiveProvider();
+
+    if (!provider) {
+      if (__DEV__) {
+        console.error("[ProviderValidator] No active provider found");
+      }
+      throw new Error("No active AI provider. Register and set a provider first.");
+    }
 
-        return provider;
+    if (!provider.isInitialized()) {
+      if (__DEV__) {
+        console.error("[ProviderValidator] Provider not initialized:", provider.providerId);
+      }
+      throw new Error(`Provider ${provider.providerId} is not initialized.`);
     }
-}
 
-export const providerValidator = new ProviderValidator();
+    return provider;
+  }
+}

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

@@ -5,8 +5,9 @@
  */
 
 import { providerRegistry } from "./provider-registry.service";
-import { cleanBase64 } from "../utils";
-import { defaultExtractVideoResult } from "../utils/video-result-extractor.util";
+import { cleanBase64, extractErrorMessage } from "../utils";
+import { extractVideoResult } from "../utils/url-extractor";
+import { VIDEO_PROGRESS, VIDEO_TIMEOUT_MS } from "../constants";
 import type { VideoFeatureType, VideoFeatureInputData } from "../../domain/interfaces";
 import type {
   ExecuteVideoFeatureOptions,
@@ -44,7 +45,7 @@ export async function executeVideoFeature(
   }
 
   try {
-    onProgress?.(5);
+    onProgress?.(VIDEO_PROGRESS.START);
 
     const inputData: VideoFeatureInputData = {
       sourceImageBase64: cleanBase64(request.sourceImageBase64),
@@ -53,34 +54,32 @@ export async function executeVideoFeature(
       options: request.options,
     };
 
-    onProgress?.(10);
+    onProgress?.(VIDEO_PROGRESS.INPUT_PREPARED);
 
     const input = provider.buildVideoFeatureInput(featureType, inputData);
 
-    onProgress?.(15);
+    onProgress?.(VIDEO_PROGRESS.REQUEST_SENT);
 
-    // Use subscribe for video features - provides queue updates and handles long-running tasks
     const result = await provider.subscribe(model, input, {
-      timeoutMs: 300000, // 5 minutes timeout for video generation
+      timeoutMs: VIDEO_TIMEOUT_MS,
       onQueueUpdate: (status) => {
         if (__DEV__) {
           console.log(`[Video:${featureType}] Queue update:`, status.status);
         }
-        // Map queue status to progress percentage
         if (status.status === "IN_QUEUE") {
-          onProgress?.(20);
+          onProgress?.(VIDEO_PROGRESS.IN_QUEUE);
         } else if (status.status === "IN_PROGRESS") {
-          onProgress?.(50);
+          onProgress?.(VIDEO_PROGRESS.IN_PROGRESS);
         }
       },
     });
 
-    onProgress?.(90);
+    onProgress?.(VIDEO_PROGRESS.RESULT_RECEIVED);
 
-    const extractor = extractResult ?? defaultExtractVideoResult;
+    const extractor = extractResult ?? extractVideoResult;
     const videoUrl = extractor(result);
 
-    onProgress?.(100);
+    onProgress?.(VIDEO_PROGRESS.COMPLETE);
 
     if (!videoUrl) {
       if (__DEV__) {
@@ -95,35 +94,11 @@ export async function executeVideoFeature(
       requestId: (result as { requestId?: string })?.requestId,
     };
   } catch (error) {
-    const message = extractErrorMessage(error, featureType);
+    const message = extractErrorMessage(error, "Processing failed", `Video:${featureType}`);
     return { success: false, error: message };
   }
 }
 
-/**
- * Extract error message from various error formats
- */
-function extractErrorMessage(error: unknown, featureType: VideoFeatureType): string {
-  let message = "Processing failed";
-
-  if (error instanceof Error) {
-    message = error.message;
-  } else if (typeof error === "object" && error !== null) {
-    const errObj = error as Record<string, unknown>;
-    if (errObj.detail) {
-      message = JSON.stringify(errObj.detail);
-    } else if (errObj.message) {
-      message = String(errObj.message);
-    }
-  }
-
-  if (__DEV__) {
-    console.error(`[Video:${featureType}] Error:`, message, error);
-  }
-
-  return message;
-}
-
 /**
  * Check if video features are supported
  */

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

@@ -2,10 +2,7 @@
  * Video Feature Executor Type Definitions
  */
 
-/**
- * Result extractor function type
- */
-export type VideoResultExtractor = (result: unknown) => string | undefined;
+import type { VideoResultExtractor } from "../utils/url-extractor";
 
 /**
  * Execution options

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

@@ -0,0 +1,41 @@
+/**
+ * Error Message Extractor
+ * Extracts error messages from various API error formats
+ */
+
+declare const __DEV__: boolean;
+
+/**
+ * Extract error message from FAL API and other error formats
+ * Supports: Error instances, FAL API errors, generic objects
+ */
+export function extractErrorMessage(
+  error: unknown,
+  defaultMessage = "Processing failed",
+  debugPrefix?: string,
+): string {
+  let message = defaultMessage;
+
+  if (error instanceof Error) {
+    message = error.message;
+  } else if (typeof error === "object" && error !== null) {
+    const errObj = error as Record<string, unknown>;
+
+    // FAL API error format: {detail: [{msg, type, loc}]}
+    if (Array.isArray(errObj.detail) && errObj.detail[0]?.msg) {
+      message = String(errObj.detail[0].msg);
+    } else if (errObj.detail) {
+      message = JSON.stringify(errObj.detail);
+    } else if (errObj.message) {
+      message = String(errObj.message);
+    } else if (errObj.msg) {
+      message = String(errObj.msg);
+    }
+  }
+
+  if (__DEV__ && debugPrefix) {
+    console.error(`[${debugPrefix}] Error:`, message, error);
+  }
+
+  return message;
+}

package/src/infrastructure/utils/index.ts

@@ -3,6 +3,7 @@
  */
 
 export * from "./error-classifier.util";
+export * from "./error-message-extractor.util";
 export * from "./polling-interval.util";
 export * from "./progress-calculator.util";
 export * from "./status-checker.util";
@@ -11,5 +12,4 @@ export * from "./url-extractor.util";
 export * from "./photo-generation";
 export * from "./feature-utils";
 export * from "./video-helpers";
-export * from "./video-result-extractor.util";
 export * from "./media-actions.util";

package/src/infrastructure/utils/url-extractor/extraction-rules.ts

@@ -0,0 +1,57 @@
+/**
+ * Extraction Rules
+ * Declarative configuration for AI provider response formats
+ * OCP compliant - add new formats without modifying extraction logic
+ */
+
+/**
+ * Rule definition for extracting URL from response
+ */
+export interface ExtractionRule {
+  /** Field path to check: ['data', 'image', 'url'] */
+  path: readonly string[];
+  /** Human-readable description for debugging */
+  description?: string;
+}
+
+/**
+ * Image extraction rules - checked in order, first success wins
+ * Supports: FAL.ai wrapper, birefnet, rembg, flux, and direct formats
+ */
+export const IMAGE_EXTRACTION_RULES: readonly ExtractionRule[] = [
+  // FAL.ai data wrapper formats
+  { path: ["data", "image"], description: "data.image (string)" },
+  { path: ["data", "imageUrl"], description: "data.imageUrl" },
+  { path: ["data", "output"], description: "data.output" },
+  { path: ["data", "image", "url"], description: "data.image.url (birefnet/rembg)" },
+  { path: ["data", "images", "0", "url"], description: "data.images[0].url (flux)" },
+  // Direct formats (no wrapper)
+  { path: ["image"], description: "image (string)" },
+  { path: ["imageUrl"], description: "imageUrl" },
+  { path: ["output"], description: "output" },
+  { path: ["image", "url"], description: "image.url" },
+  { path: ["images", "0", "url"], description: "images[0].url" },
+] as const;
+
+/**
+ * Video extraction rules - checked in order, first success wins
+ * Supports: FAL.ai wrapper, direct formats, nested objects, arrays
+ */
+export const VIDEO_EXTRACTION_RULES: readonly ExtractionRule[] = [
+  // FAL.ai data wrapper formats
+  { path: ["data", "video"], description: "data.video (string)" },
+  { path: ["data", "videoUrl"], description: "data.videoUrl" },
+  { path: ["data", "video_url"], description: "data.video_url" },
+  { path: ["data", "output"], description: "data.output" },
+  { path: ["data", "url"], description: "data.url" },
+  { path: ["data", "video", "url"], description: "data.video.url" },
+  { path: ["data", "videos", "0", "url"], description: "data.videos[0].url" },
+  // Direct formats (no wrapper)
+  { path: ["video"], description: "video (string)" },
+  { path: ["videoUrl"], description: "videoUrl" },
+  { path: ["video_url"], description: "video_url" },
+  { path: ["output"], description: "output" },
+  { path: ["url"], description: "url" },
+  { path: ["video", "url"], description: "video.url" },
+  { path: ["videos", "0", "url"], description: "videos[0].url" },
+] as const;

package/src/infrastructure/utils/url-extractor/image-result-extractor.ts

@@ -0,0 +1,21 @@
+/**
+ * Image Result Extractor
+ * Extracts image URL from AI provider responses using declarative rules
+ */
+
+import { IMAGE_EXTRACTION_RULES } from "./extraction-rules";
+import { executeRules } from "./rule-executor";
+
+/**
+ * Result extractor function type
+ */
+export type ImageResultExtractor = (result: unknown) => string | undefined;
+
+/**
+ * Extract image URL from AI generation result
+ * Uses Chain of Responsibility pattern with declarative rules
+ * Supports: FAL.ai wrapper, birefnet, rembg, flux, and direct formats
+ */
+export const extractImageResult: ImageResultExtractor = (result) => {
+  return executeRules(result, IMAGE_EXTRACTION_RULES, "ImageExtractor");
+};

package/src/infrastructure/utils/url-extractor/index.ts

@@ -3,20 +3,21 @@
  * Exports all URL extraction functions
  */
 
-export {
-  extractOutputUrl,
-} from "./base-extractor";
-
-export {
-  extractVideoUrl,
-  extractAudioUrl,
-  extractImageUrls,
-} from "./media-extractors";
-
-export {
-  extractOutputUrls,
-} from "./multi-extractor";
-
-export {
-  extractThumbnailUrl,
-} from "./thumbnail-extractor";
+export { extractOutputUrl } from "./base-extractor";
+
+export { extractVideoUrl, extractAudioUrl, extractImageUrls } from "./media-extractors";
+
+export { extractOutputUrls } from "./multi-extractor";
+
+export { extractThumbnailUrl } from "./thumbnail-extractor";
+
+export type { ExtractionRule } from "./extraction-rules";
+export { IMAGE_EXTRACTION_RULES, VIDEO_EXTRACTION_RULES } from "./extraction-rules";
+
+export { executeRules } from "./rule-executor";
+
+export type { ImageResultExtractor } from "./image-result-extractor";
+export { extractImageResult } from "./image-result-extractor";
+
+export type { VideoResultExtractor } from "./video-result-extractor";
+export { extractVideoResult } from "./video-result-extractor";

package/src/infrastructure/utils/url-extractor/rule-executor.ts

@@ -0,0 +1,67 @@
+/**
+ * Rule Executor
+ * Chain of Responsibility pattern for URL extraction
+ * Tries each rule in order, returns first successful extraction
+ */
+
+import type { ExtractionRule } from "./extraction-rules";
+
+declare const __DEV__: boolean;
+
+/**
+ * Get value from object by path array
+ * Supports array indices as string numbers: ['images', '0', 'url']
+ */
+function getValueByPath(obj: unknown, path: readonly string[]): unknown {
+  let current: unknown = obj;
+
+  for (const key of path) {
+    if (current === null || current === undefined) {
+      return undefined;
+    }
+
+    if (typeof current !== "object") {
+      return undefined;
+    }
+
+    const record = current as Record<string, unknown>;
+    current = record[key];
+  }
+
+  return current;
+}
+
+/**
+ * Execute extraction rules in order
+ * Returns first successful string extraction or undefined
+ */
+export function executeRules(
+  result: unknown,
+  rules: readonly ExtractionRule[],
+  debugPrefix?: string,
+): string | undefined {
+  if (typeof result !== "object" || result === null) {
+    return undefined;
+  }
+
+  if (__DEV__ && debugPrefix) {
+    console.log(`[${debugPrefix}] Result keys:`, Object.keys(result as object));
+  }
+
+  for (const rule of rules) {
+    const value = getValueByPath(result, rule.path);
+
+    if (typeof value === "string" && value.length > 0) {
+      if (__DEV__ && debugPrefix) {
+        console.log(`[${debugPrefix}] Found via ${rule.description}:`, value);
+      }
+      return value;
+    }
+  }
+
+  if (__DEV__ && debugPrefix) {
+    console.log(`[${debugPrefix}] No URL found in result`);
+  }
+
+  return undefined;
+}

package/src/infrastructure/utils/url-extractor/video-result-extractor.ts

@@ -0,0 +1,21 @@
+/**
+ * Video Result Extractor
+ * Extracts video URL from AI provider responses using declarative rules
+ */
+
+import { VIDEO_EXTRACTION_RULES } from "./extraction-rules";
+import { executeRules } from "./rule-executor";
+
+/**
+ * Result extractor function type
+ */
+export type VideoResultExtractor = (result: unknown) => string | undefined;
+
+/**
+ * Extract video URL from AI generation result
+ * Uses Chain of Responsibility pattern with declarative rules
+ * Supports: FAL.ai wrapper, direct formats, nested objects, arrays
+ */
+export const extractVideoResult: VideoResultExtractor = (result) => {
+  return executeRules(result, VIDEO_EXTRACTION_RULES, "VideoExtractor");
+};

package/src/infrastructure/utils/url-extractor.util.ts

@@ -11,4 +11,15 @@ export {
   extractImageUrls,
   extractOutputUrls,
   extractThumbnailUrl,
+  extractImageResult,
+  extractVideoResult,
+  executeRules,
+  IMAGE_EXTRACTION_RULES,
+  VIDEO_EXTRACTION_RULES,
+} from "./url-extractor";
+
+export type {
+  ExtractionRule,
+  ImageResultExtractor,
+  VideoResultExtractor,
 } from "./url-extractor";

package/src/infrastructure/utils/video-result-extractor.util.ts

@@ -1,59 +0,0 @@
-/**
- * Video Result Extractor Utility
- * Extracts video URL from various provider response formats
- */
-
-import type { VideoResultExtractor } from "../services/video-feature-executor.types";
-
-declare const __DEV__: boolean;
-
-/**
- * Default result extractor - handles common response formats
- * Supports FAL data wrapper and nested object formats
- */
-export const defaultExtractVideoResult: VideoResultExtractor = (result) => {
-  if (typeof result !== "object" || result === null) return undefined;
-
-  const r = result as Record<string, unknown>;
-
-  if (__DEV__) {
-    console.log("[VideoExtractor] Result keys:", Object.keys(r));
-  }
-
-  // Handle fal.ai data wrapper
-  const data = (r.data as Record<string, unknown>) ?? r;
-
-  if (__DEV__) {
-    console.log("[VideoExtractor] Data keys:", Object.keys(data));
-  }
-
-  // Direct string values
-  if (typeof data.video === "string") return data.video;
-  if (typeof data.videoUrl === "string") return data.videoUrl;
-  if (typeof data.video_url === "string") return data.video_url;
-  if (typeof data.output === "string") return data.output;
-  if (typeof data.url === "string") return data.url;
-
-  // Object with url property (e.g., { video: { url: "..." } })
-  const videoObj = data.video as Record<string, unknown> | undefined;
-  if (videoObj && typeof videoObj === "object" && typeof videoObj.url === "string") {
-    if (__DEV__) {
-      console.log("[VideoExtractor] Found data.video.url:", videoObj.url);
-    }
-    return videoObj.url;
-  }
-
-  // Array format (e.g., { videos: [{ url: "..." }] })
-  if (Array.isArray(data.videos) && typeof data.videos[0]?.url === "string") {
-    if (__DEV__) {
-      console.log("[VideoExtractor] Found videos[0].url:", data.videos[0].url);
-    }
-    return data.videos[0].url;
-  }
-
-  if (__DEV__) {
-    console.log("[VideoExtractor] No video URL found in result");
-  }
-
-  return undefined;
-};