@umituz/react-native-ai-generation-content 1.49.0 → 1.50.0

package/package.json

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

@@ -43,6 +43,10 @@ export async function buildVideoInput(
     if (defaultPrompt) {
       basePrompt = defaultPrompt;
     } else {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.error("[VideoStrategy] No prompt found for scenario:", scenario.id);
+        console.error("[VideoStrategy] Available defaults:", Object.keys(VIDEO_PROCESSING_PROMPTS));
+      }
       throw new Error("error.generation.promptRequired");
     }
   }

package/src/domains/generation/wizard/infrastructure/strategies/wizard-strategy.constants.ts

@@ -50,4 +50,7 @@ export const VIDEO_PROCESSING_PROMPTS: Record<string, string> = {
   "ai-kiss": "Create a romantic video where these two people share a gentle, loving kiss",
   "ai-hug": "Create a heartwarming video where these two people share a warm, affectionate hug",
   "image-to-video": "Animate this image with natural, smooth motion while preserving the original style",
+  "solo_renaissance_portrait": "Transform this person into an elegant Renaissance-style animated portrait with classical artistic movements and period-appropriate lighting",
+  "renaissance_portrait": "Transform this portrait into a majestic Renaissance-style animated painting with subtle classical movements",
+  "historical_portrait": "Animate this portrait in a historical style with period-appropriate subtle movements",
 };

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

@@ -0,0 +1,47 @@
+/**
+ * Generation Result Utilities
+ * Shared utilities for extracting and processing generation results
+ */
+
+export interface FalResult {
+  video?: { url?: string };
+  output?: string;
+  images?: Array<{ url?: string }>;
+  image?: { url?: string };
+}
+
+export interface GenerationUrls {
+  imageUrl?: string;
+  videoUrl?: string;
+}
+
+/**
+ * Extracts image/video URL from FAL result
+ * Handles various result formats from different FAL models
+ */
+export function extractResultUrl(result: FalResult): GenerationUrls {
+  // Video result
+  if (result.video?.url) {
+    return { videoUrl: result.video.url };
+  }
+
+  // Output URL (some models return direct URL)
+  if (typeof result.output === "string" && result.output.startsWith("http")) {
+    if (result.output.includes(".mp4") || result.output.includes("video")) {
+      return { videoUrl: result.output };
+    }
+    return { imageUrl: result.output };
+  }
+
+  // Images array (most image models)
+  if (result.images?.[0]?.url) {
+    return { imageUrl: result.images[0].url };
+  }
+
+  // Single image
+  if (result.image?.url) {
+    return { imageUrl: result.image.url };
+  }
+
+  return {};
+}

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

@@ -0,0 +1,132 @@
+/**
+ * usePhotoBlockingGeneration Hook
+ * Handles photo generation via blocking execution
+ * - Uses orchestrator for synchronous generation
+ * - Waits for result before returning
+ * - Best for quick image operations (10-30 seconds)
+ */
+
+import { useRef, useCallback } from "react";
+import { useGenerationOrchestrator } from "../../../../../presentation/hooks/generation";
+import type { CreationPersistence } from "../../infrastructure/utils/creation-persistence.util";
+import type { WizardStrategy } from "../../infrastructure/strategies/wizard-strategy.types";
+import type { WizardScenarioData } from "./wizard-generation.types";
+import type { AlertMessages } from "../../../../../presentation/hooks/generation/types";
+
+declare const __DEV__: boolean;
+
+export interface UsePhotoBlockingGenerationProps {
+  readonly userId?: string;
+  readonly scenario: WizardScenarioData;
+  readonly persistence: CreationPersistence;
+  readonly strategy: WizardStrategy;
+  readonly alertMessages: AlertMessages;
+  readonly onSuccess?: (result: unknown) => void;
+  readonly onError?: (error: string) => void;
+  readonly onCreditsExhausted?: () => void;
+}
+
+export interface UsePhotoBlockingGenerationReturn {
+  readonly isGenerating: boolean;
+  readonly startGeneration: (input: unknown, prompt: string) => Promise<void>;
+}
+
+export function usePhotoBlockingGeneration(
+  props: UsePhotoBlockingGenerationProps,
+): UsePhotoBlockingGenerationReturn {
+  const {
+    userId,
+    scenario,
+    persistence,
+    strategy,
+    alertMessages,
+    onSuccess,
+    onError,
+    onCreditsExhausted,
+  } = props;
+
+  const creationIdRef = useRef<string | null>(null);
+
+  const handleSuccess = useCallback(
+    async (result: unknown) => {
+      const typedResult = result as { imageUrl?: string; videoUrl?: string };
+      const creationId = creationIdRef.current;
+
+      if (creationId && userId) {
+        try {
+          await persistence.updateToCompleted(userId, creationId, {
+            uri: typedResult.imageUrl || typedResult.videoUrl || "",
+            imageUrl: typedResult.imageUrl,
+            videoUrl: typedResult.videoUrl,
+          });
+        } catch (err) {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.error("[PhotoBlockingGeneration] updateToCompleted error:", err);
+          }
+        }
+      }
+
+      creationIdRef.current = null;
+      onSuccess?.(result);
+    },
+    [userId, persistence, onSuccess],
+  );
+
+  const handleError = useCallback(
+    async (err: { message: string }) => {
+      const creationId = creationIdRef.current;
+
+      if (creationId && userId) {
+        try {
+          await persistence.updateToFailed(userId, creationId, err.message);
+        } catch (updateErr) {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.error("[PhotoBlockingGeneration] updateToFailed error:", updateErr);
+          }
+        }
+      }
+
+      creationIdRef.current = null;
+      onError?.(err.message);
+    },
+    [userId, persistence, onError],
+  );
+
+  const { generate, isGenerating } = useGenerationOrchestrator(strategy, {
+    userId,
+    alertMessages,
+    onCreditsExhausted,
+    onSuccess: handleSuccess,
+    onError: handleError,
+  });
+
+  const startGeneration = useCallback(
+    async (input: unknown, prompt: string) => {
+      // Save to Firestore first
+      if (userId && prompt) {
+        try {
+          const creationId = await persistence.saveAsProcessing(userId, {
+            scenarioId: scenario.id,
+            scenarioTitle: scenario.title || scenario.id,
+            prompt,
+          });
+          creationIdRef.current = creationId;
+
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.log("[PhotoBlockingGeneration] Saved as processing:", creationId);
+          }
+        } catch (err) {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.error("[PhotoBlockingGeneration] saveAsProcessing error:", err);
+          }
+        }
+      }
+
+      // Start blocking generation
+      generate(input);
+    },
+    [userId, scenario, persistence, generate],
+  );
+
+  return { isGenerating, startGeneration };
+}

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

@@ -0,0 +1,169 @@
+/**
+ * useVideoQueueGeneration Hook
+ * Handles video generation via FAL queue with background support
+ * - Submits to queue for non-blocking generation
+ * - Polls for completion status
+ * - Supports background generation (user can dismiss wizard)
+ */
+
+import { useEffect, useRef, useCallback, useState } from "react";
+import { providerRegistry } from "../../../../../infrastructure/services/provider-registry.service";
+import { extractResultUrl, type FalResult, type GenerationUrls } from "./generation-result.utils";
+import type { CreationPersistence } from "../../infrastructure/utils/creation-persistence.util";
+import type { WizardStrategy } from "../../infrastructure/strategies/wizard-strategy.types";
+import type { WizardScenarioData } from "./wizard-generation.types";
+
+declare const __DEV__: boolean;
+
+const POLL_INTERVAL_MS = 3000;
+
+export interface UseVideoQueueGenerationProps {
+  readonly userId?: string;
+  readonly scenario: WizardScenarioData;
+  readonly persistence: CreationPersistence;
+  readonly strategy: WizardStrategy;
+  readonly onSuccess?: (result: unknown) => void;
+  readonly onError?: (error: string) => void;
+}
+
+export interface UseVideoQueueGenerationReturn {
+  readonly isGenerating: boolean;
+  readonly startGeneration: (input: unknown, prompt: string) => Promise<void>;
+}
+
+export function useVideoQueueGeneration(
+  props: UseVideoQueueGenerationProps,
+): UseVideoQueueGenerationReturn {
+  const { userId, scenario, persistence, strategy, onSuccess, onError } = props;
+
+  const creationIdRef = useRef<string | null>(null);
+  const requestIdRef = useRef<string | null>(null);
+  const modelRef = useRef<string | null>(null);
+  const pollingRef = useRef<ReturnType<typeof setInterval> | null>(null);
+  const [isGenerating, setIsGenerating] = useState(false);
+
+  // Cleanup polling on unmount
+  useEffect(() => {
+    return () => {
+      if (pollingRef.current) {
+        clearInterval(pollingRef.current);
+        pollingRef.current = null;
+      }
+    };
+  }, []);
+
+  const resetRefs = useCallback(() => {
+    creationIdRef.current = null;
+    requestIdRef.current = null;
+    modelRef.current = null;
+    setIsGenerating(false);
+  }, []);
+
+  const handleComplete = useCallback(
+    async (urls: GenerationUrls) => {
+      const creationId = creationIdRef.current;
+      if (creationId && userId) {
+        try {
+          await persistence.updateToCompleted(userId, creationId, {
+            uri: urls.videoUrl || urls.imageUrl || "",
+            imageUrl: urls.imageUrl,
+            videoUrl: urls.videoUrl,
+          });
+        } catch (err) {
+          if (typeof __DEV__ !== "undefined" && __DEV__) console.error("[VideoQueueGeneration] updateToCompleted error:", err);
+        }
+      }
+      resetRefs();
+      onSuccess?.(urls);
+    },
+    [userId, persistence, onSuccess, resetRefs],
+  );
+
+  const handleError = useCallback(
+    async (errorMsg: string) => {
+      const creationId = creationIdRef.current;
+      if (creationId && userId) {
+        try {
+          await persistence.updateToFailed(userId, creationId, errorMsg);
+        } catch (err) {
+          if (typeof __DEV__ !== "undefined" && __DEV__) console.error("[VideoQueueGeneration] updateToFailed error:", err);
+        }
+      }
+      resetRefs();
+      onError?.(errorMsg);
+    },
+    [userId, persistence, onError, resetRefs],
+  );
+
+  const pollQueueStatus = useCallback(async () => {
+    const requestId = requestIdRef.current;
+    const model = modelRef.current;
+    const provider = providerRegistry.getActiveProvider();
+    if (!requestId || !model || !provider) return;
+
+    try {
+      const status = await provider.getJobStatus(model, requestId);
+      if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[VideoQueueGeneration] Poll:", status.status);
+
+      if (status.status === "COMPLETED" || status.status === "FAILED") {
+        if (pollingRef.current) { clearInterval(pollingRef.current); pollingRef.current = null; }
+        if (status.status === "COMPLETED") {
+          const result = await provider.getJobResult<FalResult>(model, requestId);
+          await handleComplete(extractResultUrl(result));
+        } else {
+          await handleError("Generation failed");
+        }
+      }
+    } catch (err) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) console.error("[VideoQueueGeneration] Poll error:", err);
+    }
+  }, [handleComplete, handleError]);
+
+  const startGeneration = useCallback(
+    async (input: unknown, prompt: string) => {
+      if (!strategy.submitToQueue) { onError?.("Queue submission not available"); return; }
+      setIsGenerating(true);
+
+      // Save to Firestore FIRST (enables background visibility)
+      let creationId: string | null = null;
+      if (userId && prompt) {
+        try {
+          creationId = await persistence.saveAsProcessing(userId, {
+            scenarioId: scenario.id, scenarioTitle: scenario.title || scenario.id, prompt,
+          });
+          creationIdRef.current = creationId;
+          if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[VideoQueueGeneration] Saved:", creationId);
+        } catch (err) {
+          if (typeof __DEV__ !== "undefined" && __DEV__) console.error("[VideoQueueGeneration] save error:", err);
+        }
+      }
+
+      const queueResult = await strategy.submitToQueue(input);
+      if (!queueResult.success || !queueResult.requestId || !queueResult.model) {
+        if (creationId && userId) await persistence.updateToFailed(userId, creationId, queueResult.error || "Queue submission failed");
+        setIsGenerating(false);
+        onError?.(queueResult.error || "Queue submission failed");
+        return;
+      }
+
+      requestIdRef.current = queueResult.requestId;
+      modelRef.current = queueResult.model;
+
+      // Update with requestId for background polling
+      if (creationId && userId) {
+        try {
+          await persistence.updateRequestId(userId, creationId, queueResult.requestId, queueResult.model);
+          if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[VideoQueueGeneration] Updated requestId:", queueResult.requestId);
+        } catch (err) {
+          if (typeof __DEV__ !== "undefined" && __DEV__) console.error("[VideoQueueGeneration] updateRequestId error:", err);
+        }
+      }
+
+      pollingRef.current = setInterval(() => void pollQueueStatus(), POLL_INTERVAL_MS);
+      void pollQueueStatus();
+    },
+    [userId, scenario, persistence, strategy, pollQueueStatus, onError],
+  );
+
+  return { isGenerating, startGeneration };
+}

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

@@ -1,16 +1,15 @@
 /**
  * useWizardGeneration Hook
- * Wizard generation with Firestore persistence and background support
- * - Uses queue submission for videos (enables true background generation)
- * - Uses blocking execution for images
- * - Saves requestId/model to Firestore for background polling
+ * Orchestrates wizard-based generation by delegating to appropriate mode:
+ * - Video: Queue-based generation with background support
+ * - Photo: Blocking execution for quick results
  */
 
-import { useEffect, useRef, useMemo, useCallback, useState } from "react";
-import { useGenerationOrchestrator } from "../../../../../presentation/hooks/generation";
-import { providerRegistry } from "../../../../../infrastructure/services/provider-registry.service";
+import { useEffect, useRef, useMemo } from "react";
 import { createWizardStrategy, buildWizardInput } from "../../infrastructure/strategies";
 import { createCreationPersistence } from "../../infrastructure/utils/creation-persistence.util";
+import { useVideoQueueGeneration } from "./useVideoQueueGeneration";
+import { usePhotoBlockingGeneration } from "./usePhotoBlockingGeneration";
 import type {
   UseWizardGenerationProps,
   UseWizardGenerationReturn,
@@ -18,8 +17,6 @@ import type {
 
 declare const __DEV__: boolean;
 
-const POLL_INTERVAL_MS = 3000;
-
 export type {
   WizardOutputType,
   WizardScenarioData,
@@ -27,32 +24,6 @@ export type {
   UseWizardGenerationReturn,
 } from "./wizard-generation.types";
 
-interface FalResult {
-  video?: { url?: string };
-  output?: string;
-  images?: Array<{ url?: string }>;
-  image?: { url?: string };
-}
-
-function extractResultUrl(result: FalResult): { imageUrl?: string; videoUrl?: string } {
-  if (result.video?.url) {
-    return { videoUrl: result.video.url };
-  }
-  if (typeof result.output === "string" && result.output.startsWith("http")) {
-    if (result.output.includes(".mp4") || result.output.includes("video")) {
-      return { videoUrl: result.output };
-    }
-    return { imageUrl: result.output };
-  }
-  if (result.images?.[0]?.url) {
-    return { imageUrl: result.images[0].url };
-  }
-  if (result.image?.url) {
-    return { imageUrl: result.image.url };
-  }
-  return {};
-}
-
 export const useWizardGeneration = (
   props: UseWizardGenerationProps,
 ): UseWizardGenerationReturn => {
@@ -69,11 +40,6 @@ export const useWizardGeneration = (
   } = props;
 
   const hasStarted = useRef(false);
-  const creationIdRef = useRef<string | null>(null);
-  const requestIdRef = useRef<string | null>(null);
-  const modelRef = useRef<string | null>(null);
-  const pollingRef = useRef<ReturnType<typeof setInterval> | null>(null);
-  const [isGenerating, setIsGenerating] = useState(false);
 
   const persistence = useMemo(() => createCreationPersistence(), []);
   const strategy = useMemo(
@@ -81,158 +47,35 @@ export const useWizardGeneration = (
     [scenario, creditCost],
   );
 
-  // Cleanup polling on unmount
-  useEffect(() => {
-    return () => {
-      if (pollingRef.current) {
-        clearInterval(pollingRef.current);
-        pollingRef.current = null;
-      }
-    };
-  }, []);
-
-  const handleQueueComplete = useCallback(
-    async (urls: { imageUrl?: string; videoUrl?: string }) => {
-      const creationId = creationIdRef.current;
-
-      if (creationId && userId) {
-        try {
-          await persistence.updateToCompleted(userId, creationId, {
-            uri: urls.videoUrl || urls.imageUrl || "",
-            imageUrl: urls.imageUrl,
-            videoUrl: urls.videoUrl,
-          });
-        } catch (err) {
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.error("[useWizardGeneration] updateToCompleted error:", err);
-          }
-        }
-      }
-
-      creationIdRef.current = null;
-      requestIdRef.current = null;
-      modelRef.current = null;
-      setIsGenerating(false);
-      onSuccess?.(urls);
-    },
-    [userId, persistence, onSuccess],
-  );
-
-  const handleQueueError = useCallback(
-    async (errorMsg: string) => {
-      const creationId = creationIdRef.current;
+  const isVideoMode = scenario.outputType === "video" && !!strategy.submitToQueue;
 
-      if (creationId && userId) {
-        try {
-          await persistence.updateToFailed(userId, creationId, errorMsg);
-        } catch (err) {
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.error("[useWizardGeneration] updateToFailed error:", err);
-          }
-        }
-      }
-
-      creationIdRef.current = null;
-      requestIdRef.current = null;
-      modelRef.current = null;
-      setIsGenerating(false);
-      onError?.(errorMsg);
-    },
-    [userId, persistence, onError],
-  );
-
-  const pollQueueStatus = useCallback(async () => {
-    const requestId = requestIdRef.current;
-    const model = modelRef.current;
-    const provider = providerRegistry.getActiveProvider();
-
-    if (!requestId || !model || !provider) return;
-
-    try {
-      const status = await provider.getJobStatus(model, requestId);
-
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[useWizardGeneration] Poll status:", status.status);
-      }
-
-      if (status.status === "COMPLETED") {
-        if (pollingRef.current) {
-          clearInterval(pollingRef.current);
-          pollingRef.current = null;
-        }
-        const result = await provider.getJobResult<FalResult>(model, requestId);
-        const urls = extractResultUrl(result);
-        await handleQueueComplete(urls);
-      } else if (status.status === "FAILED") {
-        if (pollingRef.current) {
-          clearInterval(pollingRef.current);
-          pollingRef.current = null;
-        }
-        await handleQueueError("Generation failed");
-      }
-    } catch (err) {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.error("[useWizardGeneration] Poll error:", err);
-      }
-    }
-  }, [handleQueueComplete, handleQueueError]);
-
-  // For images: use blocking execution with orchestrator
-  const handleBlockingSuccess = useCallback(
-    async (result: unknown) => {
-      const typedResult = result as { imageUrl?: string; videoUrl?: string };
-      const creationId = creationIdRef.current;
-
-      if (creationId && userId) {
-        try {
-          await persistence.updateToCompleted(userId, creationId, {
-            uri: typedResult.imageUrl || typedResult.videoUrl || "",
-            imageUrl: typedResult.imageUrl,
-            videoUrl: typedResult.videoUrl,
-          });
-        } catch (err) {
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.error("[useWizardGeneration] updateToCompleted error:", err);
-          }
-        }
-      }
-
-      creationIdRef.current = null;
-      onSuccess?.(result);
-    },
-    [userId, persistence, onSuccess],
-  );
-
-  const handleBlockingError = useCallback(
-    async (err: { message: string }) => {
-      const creationId = creationIdRef.current;
-
-      if (creationId && userId) {
-        try {
-          await persistence.updateToFailed(userId, creationId, err.message);
-        } catch (updateErr) {
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.error("[useWizardGeneration] updateToFailed error:", updateErr);
-          }
-        }
-      }
-
-      creationIdRef.current = null;
-      onError?.(err.message);
-    },
-    [userId, persistence, onError],
-  );
+  // Video generation hook (queue-based)
+  const videoGeneration = useVideoQueueGeneration({
+    userId,
+    scenario,
+    persistence,
+    strategy,
+    onSuccess,
+    onError,
+  });
 
-  const { generate, isGenerating: isBlockingGenerating } = useGenerationOrchestrator(strategy, {
+  // Photo generation hook (blocking)
+  const photoGeneration = usePhotoBlockingGeneration({
     userId,
+    scenario,
+    persistence,
+    strategy,
     alertMessages,
+    onSuccess,
+    onError,
     onCreditsExhausted,
-    onSuccess: handleBlockingSuccess,
-    onError: handleBlockingError,
   });
 
+  // Main effect: trigger generation when step becomes active
   useEffect(() => {
-    if (isGeneratingStep && !hasStarted.current && !isGenerating && !isBlockingGenerating) {
+    const isAlreadyGenerating = videoGeneration.isGenerating || photoGeneration.isGenerating;
+
+    if (isGeneratingStep && !hasStarted.current && !isAlreadyGenerating) {
       hasStarted.current = true;
 
       buildWizardInput(wizardData, scenario)
@@ -244,86 +87,21 @@ export const useWizardGeneration = (
           }
 
           const typedInput = input as { prompt?: string };
-          const useQueueMode = scenario.outputType === "video" && !!strategy.submitToQueue;
 
           if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.log("[useWizardGeneration] Mode:", useQueueMode ? "QUEUE" : "BLOCKING");
+            console.log("[WizardGeneration] Mode:", isVideoMode ? "VIDEO_QUEUE" : "PHOTO_BLOCKING");
           }
 
-          if (useQueueMode && strategy.submitToQueue) {
-            // Queue mode for videos
-            setIsGenerating(true);
-
-            // Submit to queue first to get requestId
-            const queueResult = await strategy.submitToQueue(input);
-
-            if (!queueResult.success || !queueResult.requestId || !queueResult.model) {
-              hasStarted.current = false;
-              setIsGenerating(false);
-              onError?.(queueResult.error || "Queue submission failed");
-              return;
-            }
-
-            requestIdRef.current = queueResult.requestId;
-            modelRef.current = queueResult.model;
-
-            // Save to Firestore with requestId and model
-            if (userId && typedInput.prompt) {
-              try {
-                const creationId = await persistence.saveAsProcessing(userId, {
-                  scenarioId: scenario.id,
-                  scenarioTitle: scenario.title || scenario.id,
-                  prompt: typedInput.prompt,
-                  requestId: queueResult.requestId,
-                  model: queueResult.model,
-                });
-                creationIdRef.current = creationId;
-
-                if (typeof __DEV__ !== "undefined" && __DEV__) {
-                  console.log("[useWizardGeneration] Saved with requestId:", {
-                    creationId,
-                    requestId: queueResult.requestId,
-                  });
-                }
-              } catch (err) {
-                if (typeof __DEV__ !== "undefined" && __DEV__) {
-                  console.error("[useWizardGeneration] saveAsProcessing error:", err);
-                }
-              }
-            }
-
-            // Start polling for completion
-            pollingRef.current = setInterval(() => {
-              void pollQueueStatus();
-            }, POLL_INTERVAL_MS);
-
-            // Initial poll
-            void pollQueueStatus();
+          if (isVideoMode) {
+            await videoGeneration.startGeneration(input, typedInput.prompt || "");
           } else {
-            // Blocking mode for images
-            if (userId && typedInput.prompt) {
-              try {
-                const creationId = await persistence.saveAsProcessing(userId, {
-                  scenarioId: scenario.id,
-                  scenarioTitle: scenario.title || scenario.id,
-                  prompt: typedInput.prompt,
-                });
-                creationIdRef.current = creationId;
-
-                if (typeof __DEV__ !== "undefined" && __DEV__) {
-                  console.log("[useWizardGeneration] Saved as processing:", creationId);
-                }
-              } catch (err) {
-                if (typeof __DEV__ !== "undefined" && __DEV__) {
-                  console.error("[useWizardGeneration] saveAsProcessing error:", err);
-                }
-              }
-            }
-
-            generate(input);
+            await photoGeneration.startGeneration(input, typedInput.prompt || "");
           }
         })
         .catch((error) => {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.error("[WizardGeneration] Build input error:", error.message);
+          }
           hasStarted.current = false;
           onError?.(error.message);
         });
@@ -336,15 +114,13 @@ export const useWizardGeneration = (
     isGeneratingStep,
     scenario,
     wizardData,
-    isGenerating,
-    isBlockingGenerating,
-    generate,
+    isVideoMode,
+    videoGeneration,
+    photoGeneration,
     onError,
-    userId,
-    persistence,
-    strategy,
-    pollQueueStatus,
   ]);
 
-  return { isGenerating: isGenerating || isBlockingGenerating };
+  return {
+    isGenerating: videoGeneration.isGenerating || photoGeneration.isGenerating,
+  };
 };