@umituz/react-native-ai-generation-content 1.26.25 → 1.26.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.26.25",
+  "version": "1.26.28",
   "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/generation/wizard/presentation/components/GenericWizardFlow.tsx

@@ -17,10 +17,12 @@ import { View, StyleSheet } from "react-native";
 import { useAppDesignTokens } from "@umituz/react-native-design-system";
 import { useFlow } from "../../../infrastructure/flow/useFlow";
 import { StepType, type StepDefinition } from "../../../../../domain/entities/flow-config.types";
-import type { WizardFeatureConfig } from "../../domain/entities/wizard-config.types";
+import type { WizardFeatureConfig, WizardStepConfig } from "../../domain/entities/wizard-config.types";
 import { buildFlowStepsFromWizard } from "../../infrastructure/builders/dynamic-step-builder";
 import { useWizardGeneration, type WizardScenarioData } from "../hooks/useWizardGeneration";
 import type { AlertMessages } from "../../../../../presentation/hooks/generation/types";
+import { PhotoStep } from "../../../../../presentation/components/photo-step/PhotoStep";
+import { usePhotoUploadState } from "../hooks/usePhotoUploadState";
 
 export interface GenericWizardFlowProps {
   readonly featureConfig: WizardFeatureConfig;
@@ -232,6 +234,25 @@ export const GenericWizardFlow: React.FC<GenericWizardFlowProps> = ({
     }
   }, [currentStepIndex, previousStep, onBack]);
 
+  // Photo upload state translations (generic, used for all photo upload steps)
+  const photoUploadTranslations = useMemo(() => ({
+    fileTooLarge: t("common.errors.file_too_large"),
+    maxFileSize: t("common.errors.max_file_size"),
+    error: t("common.error"),
+    uploadFailed: t("common.errors.upload_failed"),
+  }), [t]);
+
+  const photoUploadHook = usePhotoUploadState({
+    translations: photoUploadTranslations,
+  });
+
+  // Save photo when uploaded
+  useEffect(() => {
+    if (photoUploadHook.image && currentStep) {
+      setCustomData(currentStep.id, photoUploadHook.image);
+    }
+  }, [photoUploadHook.image, currentStep, setCustomData]);
+
   // Render current step
   const renderCurrentStep = useCallback(() => {
     const step = currentStep;
@@ -261,6 +282,49 @@ export const GenericWizardFlow: React.FC<GenericWizardFlowProps> = ({
       case StepType.RESULT_PREVIEW:
         return renderResult?.(generationResult) || null;
 
+      case StepType.PARTNER_UPLOAD: {
+        // Get wizard step config
+        const wizardConfig = step.config as WizardStepConfig;
+
+        // Use titleKey from config, fallback to step-specific translation key
+        const titleKey = wizardConfig?.titleKey || `wizard.steps.${step.id}.title`;
+        const title = t(titleKey);
+
+        // Subtitle is optional
+        const subtitle = wizardConfig?.subtitleKey ? t(wizardConfig.subtitleKey) : undefined;
+
+        // Get existing photo for this step from customData
+        const existingPhoto = customData[step.id];
+        const imageUri = existingPhoto && typeof existingPhoto === "object" && "uri" in existingPhoto
+          ? (existingPhoto.uri as string)
+          : photoUploadHook.image?.uri || null;
+
+        return (
+          <PhotoStep
+            config={{
+              enabled: true,
+              order: currentStepIndex,
+              id: step.id,
+              header: {},
+              photoCard: {},
+              enableValidation: false,
+            }}
+            imageUri={imageUri}
+            isValidating={false}
+            isValid={null}
+            onPhotoSelect={photoUploadHook.handlePickImage}
+            disabled={false}
+            title={title}
+            subtitle={subtitle}
+            translations={{
+              tapToUpload: t("photoUpload.tapToUpload"),
+              selectPhoto: t("photoUpload.selectPhoto"),
+              change: t("common.change"),
+            }}
+          />
+        );
+      }
+
       default:
         // Other step types should be handled by custom render props
         if (typeof __DEV__ !== "undefined" && __DEV__) {

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/services/image-feature-executor.service.ts

@@ -6,15 +6,12 @@
 
 import { providerRegistry } from "./provider-registry.service";
 import { cleanBase64 } from "../utils";
+import { extractImageResult } from "../utils/url-extractor";
+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 +40,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
  */
@@ -143,7 +89,7 @@ export async function executeImageFeature(
 
     onProgress?.(90);
 
-    const extractor = extractResult ?? defaultExtractImageResult;
+    const extractor = extractResult ?? extractImageResult;
     const imageUrl = extractor(result);
 
     onProgress?.(100);

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/video-feature-executor.service.ts

@@ -6,7 +6,7 @@
 
 import { providerRegistry } from "./provider-registry.service";
 import { cleanBase64 } from "../utils";
-import { defaultExtractVideoResult } from "../utils/video-result-extractor.util";
+import { extractVideoResult } from "../utils/url-extractor";
 import type { VideoFeatureType, VideoFeatureInputData } from "../../domain/interfaces";
 import type {
   ExecuteVideoFeatureOptions,
@@ -77,7 +77,7 @@ export async function executeVideoFeature(
 
     onProgress?.(90);
 
-    const extractor = extractResult ?? defaultExtractVideoResult;
+    const extractor = extractResult ?? extractVideoResult;
     const videoUrl = extractor(result);
 
     onProgress?.(100);

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/index.ts

@@ -11,5 +11,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;
-};