@umituz/react-native-ai-generation-content 1.61.62 → 1.61.63

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.61.62",
+  "version": "1.61.63",
   "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/presentation/hooks/generationExecutor.ts

@@ -0,0 +1,65 @@
+import { buildWizardInput } from "../../infrastructure/strategies";
+import type { WizardScenarioData } from "./wizard-generation.types";
+import type { Scenario } from "../../../../scenarios/domain/scenario.types";
+import type { GenerationAction } from "./wizard-state-machine";
+
+declare const __DEV__: boolean;
+
+interface ExecuteGenerationParams {
+  wizardData: WizardScenarioData;
+  scenario: Scenario;
+  isVideoMode: boolean;
+  isMountedRef: React.MutableRefObject<boolean>;
+  dispatch: React.Dispatch<GenerationAction>;
+  onError?: (error: string) => void;
+  videoGenerationFn: (input: any, prompt: string) => Promise<void>;
+  photoGenerationFn: (input: any, prompt: string) => Promise<void>;
+}
+
+export const executeWizardGeneration = async (params: ExecuteGenerationParams): Promise<void> => {
+  const {
+    wizardData,
+    scenario,
+    isVideoMode,
+    isMountedRef,
+    dispatch,
+    onError,
+    videoGenerationFn,
+    photoGenerationFn,
+  } = params;
+
+  try {
+    const input = await buildWizardInput(wizardData, scenario);
+
+    if (!isMountedRef.current) return;
+
+    if (!input) {
+      dispatch({ type: "ERROR", error: "Failed to build generation input" });
+      onError?.("Failed to build generation input");
+      return;
+    }
+
+    dispatch({ type: "START_GENERATION" });
+
+    if (__DEV__) {
+      console.log("[WizardGeneration] GENERATING -", isVideoMode ? "VIDEO" : "PHOTO");
+    }
+
+    const typedInput = input as { prompt?: string };
+    const generationFn = isVideoMode ? videoGenerationFn : photoGenerationFn;
+    await generationFn(input, typedInput.prompt || "");
+
+    if (isMountedRef.current) {
+      dispatch({ type: "COMPLETE" });
+    }
+  } catch (error: any) {
+    if (!isMountedRef.current) return;
+
+    const errorMsg = error?.message || "error.generation.unknown";
+    if (__DEV__) {
+      console.error("[WizardGeneration] Error:", errorMsg, error);
+    }
+    dispatch({ type: "ERROR", error: errorMsg });
+    onError?.(errorMsg);
+  }
+};

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

@@ -0,0 +1,35 @@
+export type GenerationStatus = "IDLE" | "PREPARING" | "GENERATING" | "ERROR" | "COMPLETED";
+
+export interface GenerationState {
+  status: GenerationStatus;
+  error?: string;
+}
+
+export type GenerationAction =
+  | { type: "START_PREPARATION" }
+  | { type: "START_GENERATION" }
+  | { type: "COMPLETE" }
+  | { type: "ERROR"; error: string }
+  | { type: "RESET" };
+
+export const generationReducer = (
+  state: GenerationState,
+  action: GenerationAction,
+): GenerationState => {
+  switch (action.type) {
+    case "START_PREPARATION":
+      return { status: "PREPARING" };
+    case "START_GENERATION":
+      return { status: "GENERATING" };
+    case "COMPLETE":
+      return { status: "COMPLETED" };
+    case "ERROR":
+      return { status: "ERROR", error: action.error };
+    case "RESET":
+      return { status: "IDLE" };
+    default:
+      return state;
+  }
+};
+
+export const INITIAL_STATE: GenerationState = { status: "IDLE" };

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

@@ -0,0 +1,13 @@
+import type { Creation } from "../../../../creations/domain/entities/Creation";
+
+export const isCreation = (result: unknown): result is Creation => {
+  if (!result || typeof result !== "object") return false;
+  const creation = result as Partial<Creation>;
+  return (
+    typeof creation.id === "string" &&
+    typeof creation.uri === "string" &&
+    typeof creation.type === "string" &&
+    creation.createdAt instanceof Date &&
+    typeof creation.isShared === "boolean"
+  );
+};

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

@@ -1,19 +1,10 @@
-/**
- * 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 { QUEUE_STATUS } from "../../../../../domain/constants/queue-status.constants";
+import { pollQueueStatus } from "./videoQueuePoller";
 import { DEFAULT_POLL_INTERVAL_MS } from "../../../../../infrastructure/constants/polling.constants";
 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 { GenerationUrls } from "./generation-result.utils";
 
 declare const __DEV__: boolean;
 
@@ -31,9 +22,7 @@ export interface UseVideoQueueGenerationReturn {
   readonly startGeneration: (input: unknown, prompt: string) => Promise<void>;
 }
 
-export function useVideoQueueGeneration(
-  props: UseVideoQueueGenerationProps,
-): UseVideoQueueGenerationReturn {
+export function useVideoQueueGeneration(props: UseVideoQueueGenerationProps): UseVideoQueueGenerationReturn {
   const { userId, scenario, persistence, strategy, onSuccess, onError } = props;
 
   const creationIdRef = useRef<string | null>(null);
@@ -44,7 +33,6 @@ export function useVideoQueueGeneration(
   const isPollingRef = useRef(false);
   const [isGenerating, setIsGenerating] = useState(false);
 
-  // Cleanup polling on unmount
   useEffect(() => {
     return () => {
       if (pollingRef.current) {
@@ -74,7 +62,7 @@ export function useVideoQueueGeneration(
             videoUrl: urls.videoUrl,
           });
         } catch (err) {
-          if (typeof __DEV__ !== "undefined" && __DEV__) console.error("[VideoQueueGeneration] updateToCompleted error:", err);
+          if (__DEV__) console.error("[VideoQueueGeneration] updateToCompleted error:", err);
         }
       }
       resetRefs();
@@ -90,7 +78,7 @@ export function useVideoQueueGeneration(
         try {
           await persistence.updateToFailed(userId, creationId, errorMsg);
         } catch (err) {
-          if (typeof __DEV__ !== "undefined" && __DEV__) console.error("[VideoQueueGeneration] updateToFailed error:", err);
+          if (__DEV__) console.error("[VideoQueueGeneration] updateToFailed error:", err);
         }
       }
       resetRefs();
@@ -99,75 +87,52 @@ export function useVideoQueueGeneration(
     [userId, persistence, onError, resetRefs],
   );
 
-  const pollQueueStatus = useCallback(async () => {
-    // Guard against concurrent polls
-    if (isPollingRef.current) return;
-
+  const pollStatus = useCallback(async () => {
     const requestId = requestIdRef.current;
     const model = modelRef.current;
-    const provider = providerRegistry.getActiveProvider();
-    if (!requestId || !model || !provider) return;
-
-    isPollingRef.current = true;
-    try {
-      const status = await provider.getJobStatus(model, requestId);
-      if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[VideoQueueGeneration] Poll:", status.status);
-
-      if (status.status === QUEUE_STATUS.COMPLETED || status.status === QUEUE_STATUS.FAILED) {
-        if (pollingRef.current) { clearInterval(pollingRef.current); pollingRef.current = null; }
-        if (status.status === QUEUE_STATUS.COMPLETED) {
-          try {
-            const result = await provider.getJobResult<FalResult>(model, requestId);
-            await handleComplete(extractResultUrl(result));
-          } catch (resultErr) {
-            // Handle errors when getting/extracting result (e.g., ValidationError, content policy)
-            const errorMessage = resultErr instanceof Error ? resultErr.message : "Generation failed";
-            if (typeof __DEV__ !== "undefined" && __DEV__) {
-              console.error("[VideoQueueGeneration] Result error:", errorMessage);
-            }
-            await handleError(errorMessage);
-          }
-        } else {
-          await handleError("Generation failed");
-        }
-      }
-    } catch (err) {
-      // Handle polling errors - stop polling and show error to user
-      if (pollingRef.current) { clearInterval(pollingRef.current); pollingRef.current = null; }
-      const errorMessage = err instanceof Error ? err.message : "Generation failed";
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.error("[VideoQueueGeneration] Poll error:", errorMessage);
-      }
-      await handleError(errorMessage);
-    } finally {
-      isPollingRef.current = false;
-    }
+    if (!requestId || !model) return;
+
+    await pollQueueStatus({
+      requestId,
+      model,
+      isPollingRef,
+      pollingRef,
+      onComplete: handleComplete,
+      onError: handleError,
+    });
   }, [handleComplete, handleError]);
 
   const startGeneration = useCallback(
     async (input: unknown, prompt: string) => {
-      if (!strategy.submitToQueue) { onError?.("Queue submission not available"); return; }
+      if (!strategy.submitToQueue) {
+        onError?.("Queue submission not available");
+        return;
+      }
       if (isGeneratingRef.current) return;
+
       isGeneratingRef.current = true;
       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,
+            scenarioId: scenario.id,
+            scenarioTitle: scenario.title || scenario.id,
+            prompt,
           });
           creationIdRef.current = creationId;
-          if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[VideoQueueGeneration] Saved:", creationId);
+          if (__DEV__) console.log("[VideoQueueGeneration] Saved:", creationId);
         } catch (err) {
-          if (typeof __DEV__ !== "undefined" && __DEV__) console.error("[VideoQueueGeneration] save error:", err);
+          if (__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");
+        if (creationId && userId) {
+          await persistence.updateToFailed(userId, creationId, queueResult.error || "Queue submission failed");
+        }
         setIsGenerating(false);
         onError?.(queueResult.error || "Queue submission failed");
         return;
@@ -176,21 +141,19 @@ export function useVideoQueueGeneration(
       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);
+          if (__DEV__) console.log("[VideoQueueGeneration] Updated requestId:", queueResult.requestId);
         } catch (err) {
-          if (typeof __DEV__ !== "undefined" && __DEV__) console.error("[VideoQueueGeneration] updateRequestId error:", err);
+          if (__DEV__) console.error("[VideoQueueGeneration] updateRequestId error:", err);
         }
       }
 
-      pollingRef.current = setInterval(() => void pollQueueStatus(), DEFAULT_POLL_INTERVAL_MS);
-      // Immediate poll to avoid waiting for first interval tick
-      void pollQueueStatus();
+      pollingRef.current = setInterval(() => void pollStatus(), DEFAULT_POLL_INTERVAL_MS);
+      void pollStatus();
     },
-    [userId, scenario, persistence, strategy, pollQueueStatus, onError],
+    [userId, scenario, persistence, strategy, pollStatus, onError],
   );
 
   return { isGenerating, startGeneration };

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

@@ -1,32 +1,9 @@
-/**
- * Wizard Flow Handlers Hook
- * Extracts callback handlers from WizardFlowContent
- */
-
 import { useCallback } from "react";
 import { AlertType, AlertMode, useAlert } from "@umituz/react-native-design-system";
 import { StepType, type StepDefinition } from "../../../../../domain/entities/flow-config.types";
 import type { UploadedImage } from "../../../../../presentation/hooks/generation/useAIGenerateState";
 import type { Creation } from "../../../../creations/domain/entities/Creation";
-
-declare const __DEV__: boolean;
-
-/**
- * Type guard to check if result is a valid Creation object
- */
-function isCreation(result: unknown): result is Creation {
-  if (!result || typeof result !== "object") {
-    return false;
-  }
-  const creation = result as Partial<Creation>;
-  return (
-    typeof creation.id === "string" &&
-    typeof creation.uri === "string" &&
-    typeof creation.type === "string" &&
-    creation.createdAt instanceof Date &&
-    typeof creation.isShared === "boolean"
-  );
-}
+import { isCreation } from "./typeGuards";
 
 export interface UseWizardFlowHandlersProps {
   readonly currentStepIndex: number;
@@ -77,21 +54,8 @@ export function useWizardFlowHandlers(props: UseWizardFlowHandlersProps) {
 
   const handleGenerationComplete = useCallback(
     (result: unknown) => {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[WizardFlowHandlers] Generation completed");
-      }
       setResult(result);
-
-      // Use type guard to safely check if result is a Creation
-      if (isCreation(result)) {
-        setCurrentCreation(result);
-      } else {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.warn("[WizardFlowHandlers] Result is not a valid Creation object:", result);
-        }
-        setCurrentCreation(null);
-      }
-
+      setCurrentCreation(isCreation(result) ? result : null);
       onGenerationComplete?.(result);
       if (!skipResultStep) nextStep();
     },
@@ -100,43 +64,17 @@ export function useWizardFlowHandlers(props: UseWizardFlowHandlersProps) {
 
   const handleGenerationError = useCallback(
     (errorMessage: string) => {
-      // Ensure we have a meaningful error message
       const safeErrorMessage = errorMessage?.trim() || "error.generation.unknown";
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[WizardFlowHandlers] Generation error:", {
-          original: errorMessage,
-          safe: safeErrorMessage,
-        });
-      }
-      // Translate error key if it looks like a translation key
-      const displayMessage = safeErrorMessage.startsWith("error.")
-        ? t(safeErrorMessage)
-        : safeErrorMessage;
-      // Show error alert to user
-      alert.show(
-        AlertType.ERROR,
-        AlertMode.MODAL,
-        t("common.error"),
-        displayMessage,
-      );
-      // Notify parent component
+      const displayMessage = safeErrorMessage.startsWith("error.") ? t(safeErrorMessage) : safeErrorMessage;
+      alert.show(AlertType.ERROR, AlertMode.MODAL, t("common.error"), displayMessage);
       onGenerationError?.(safeErrorMessage);
-      // Close the wizard
       onBack?.();
     },
     [alert, t, onGenerationError, onBack],
   );
 
   const handleDismissGenerating = useCallback(() => {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[WizardFlowHandlers] Dismissing - generation continues");
-    }
-    alert.show(
-      AlertType.INFO,
-      AlertMode.TOAST,
-      t("generator.backgroundTitle"),
-      t("generator.backgroundMessage"),
-    );
+    alert.show(AlertType.INFO, AlertMode.TOAST, t("generator.backgroundTitle"), t("generator.backgroundMessage"));
     onBack?.();
   }, [alert, t, onBack]);
 
@@ -147,18 +85,7 @@ export function useWizardFlowHandlers(props: UseWizardFlowHandlersProps) {
 
   const handleNextStep = useCallback(() => {
     const nextStepDef = flowSteps[currentStepIndex + 1];
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[WizardFlowHandlers] handleNextStep", {
-        currentStepIndex,
-        nextStepType: nextStepDef?.type,
-        isGenerating: nextStepDef?.type === StepType.GENERATING,
-        hasOnGenerationStart: !!onGenerationStart,
-      });
-    }
     if (nextStepDef?.type === StepType.GENERATING && onGenerationStart) {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[WizardFlowHandlers] Calling onGenerationStart callback");
-      }
       onGenerationStart(customData, nextStep);
       return;
     }
@@ -179,12 +106,7 @@ export function useWizardFlowHandlers(props: UseWizardFlowHandlersProps) {
       const success = await repository.rate(userId, currentCreation.id, rating, description);
       if (success) {
         setHasRated(true);
-        alert.show(
-          AlertType.SUCCESS,
-          AlertMode.TOAST,
-          t("result.rateSuccessTitle"),
-          t("result.rateSuccessMessage"),
-        );
+        alert.show(AlertType.SUCCESS, AlertMode.TOAST, t("result.rateSuccessTitle"), t("result.rateSuccessMessage"));
       }
       setShowRatingPicker(false);
     },

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

@@ -1,75 +1,16 @@
 /**
- * useWizardGeneration Hook
- * Orchestrates wizard-based generation by delegating to appropriate mode:
- * - Video: Queue-based generation with background support
- * - Photo: Blocking execution for quick results
- *
- * Architecture: State machine pattern with useReducer
- * States: IDLE → PREPARING → GENERATING → COMPLETED/ERROR → IDLE
+ * Wizard Generation Hook
+ * Orchestrates wizard-based generation (Video: queue, Photo: blocking)
  */
 
 import { useEffect, useReducer, useMemo, useRef } from "react";
-import { createWizardStrategy, buildWizardInput } from "../../infrastructure/strategies";
+import { createWizardStrategy } from "../../infrastructure/strategies";
 import { createCreationPersistence } from "../../infrastructure/utils/creation-persistence.util";
 import { useVideoQueueGeneration } from "./useVideoQueueGeneration";
 import { usePhotoBlockingGeneration } from "./usePhotoBlockingGeneration";
-import type {
-  UseWizardGenerationProps,
-  UseWizardGenerationReturn,
-} from "./wizard-generation.types";
-
-declare const __DEV__: boolean;
-
-/**
- * Generation orchestration states
- */
-type GenerationStatus =
-  | "IDLE"        // Not started
-  | "PREPARING"   // Building input
-  | "GENERATING"  // Generation in progress
-  | "ERROR"       // Failed (prevents retry)
-  | "COMPLETED";  // Success
-
-/**
- * State machine state
- */
-interface GenerationState {
-  status: GenerationStatus;
-  error?: string;
-}
-
-/**
- * State machine actions
- */
-type GenerationAction =
-  | { type: "START_PREPARATION" }
-  | { type: "START_GENERATION" }
-  | { type: "COMPLETE" }
-  | { type: "ERROR"; error: string }
-  | { type: "RESET" };
-
-/**
- * State machine reducer
- */
-const generationReducer = (
-  state: GenerationState,
-  action: GenerationAction,
-): GenerationState => {
-  switch (action.type) {
-    case "START_PREPARATION":
-      return { status: "PREPARING" };
-    case "START_GENERATION":
-      return { status: "GENERATING" };
-    case "COMPLETE":
-      return { status: "COMPLETED" };
-    case "ERROR":
-      return { status: "ERROR", error: action.error };
-    case "RESET":
-      return { status: "IDLE" };
-    default:
-      return state;
-  }
-};
+import { generationReducer, INITIAL_STATE } from "./generationStateMachine";
+import { executeWizardGeneration } from "./generationExecutor";
+import type { UseWizardGenerationProps, UseWizardGenerationReturn } from "./wizard-generation.types";
 
 export type {
   WizardOutputType,
@@ -78,9 +19,7 @@ export type {
   UseWizardGenerationReturn,
 } from "./wizard-generation.types";
 
-export const useWizardGeneration = (
-  props: UseWizardGenerationProps,
-): UseWizardGenerationReturn => {
+export const useWizardGeneration = (props: UseWizardGenerationProps): UseWizardGenerationReturn => {
   const {
     scenario,
     wizardData,
@@ -93,10 +32,7 @@ export const useWizardGeneration = (
     onCreditsExhausted,
   } = props;
 
-  // State machine: replaces multiple useRef flags
-  const [state, dispatch] = useReducer(generationReducer, { status: "IDLE" });
-
-  // Mounted ref to prevent state updates after unmount
+  const [state, dispatch] = useReducer(generationReducer, INITIAL_STATE);
   const isMountedRef = useRef(true);
 
   useEffect(() => {
@@ -107,14 +43,9 @@ export const useWizardGeneration = (
   }, []);
 
   const persistence = useMemo(() => createCreationPersistence(), []);
-  const strategy = useMemo(
-    () => createWizardStrategy({ scenario, creditCost }),
-    [scenario, creditCost],
-  );
-
+  const strategy = useMemo(() => createWizardStrategy({ scenario, creditCost }), [scenario, creditCost]);
   const isVideoMode = scenario.outputType === "video" && !!strategy.submitToQueue;
 
-  // Video generation hook (queue-based)
   const videoGeneration = useVideoQueueGeneration({
     userId,
     scenario,
@@ -124,7 +55,6 @@ export const useWizardGeneration = (
     onError,
   });
 
-  // Photo generation hook (blocking)
   const photoGeneration = usePhotoBlockingGeneration({
     userId,
     scenario,
@@ -136,67 +66,25 @@ export const useWizardGeneration = (
     onCreditsExhausted,
   });
 
-  // Main effect: trigger generation when step becomes active
   useEffect(() => {
     const isAlreadyGenerating = videoGeneration.isGenerating || photoGeneration.isGenerating;
 
-    // Start generation: Simple single condition using state machine
     if (isGeneratingStep && state.status === "IDLE" && !isAlreadyGenerating) {
       dispatch({ type: "START_PREPARATION" });
 
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[WizardGeneration] State: PREPARING");
-      }
-
-      buildWizardInput(wizardData, scenario)
-        .then(async (input) => {
-          // Check if component is still mounted
-          if (!isMountedRef.current) return;
-
-          if (!input) {
-            dispatch({ type: "ERROR", error: "Failed to build generation input" });
-            onError?.("Failed to build generation input");
-            return;
-          }
-
-          dispatch({ type: "START_GENERATION" });
-
-          const typedInput = input as { prompt?: string };
-
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.log("[WizardGeneration] State: GENERATING");
-            console.log("[WizardGeneration] Mode:", isVideoMode ? "VIDEO_QUEUE" : "PHOTO_BLOCKING");
-          }
-
-          if (isVideoMode) {
-            await videoGeneration.startGeneration(input, typedInput.prompt || "");
-          } else {
-            await photoGeneration.startGeneration(input, typedInput.prompt || "");
-          }
-
-          // Check again before final state update
-          if (isMountedRef.current) {
-            dispatch({ type: "COMPLETE" });
-          }
-        })
-        .catch((error) => {
-          // Check if component is still mounted before error handling
-          if (!isMountedRef.current) return;
-
-          const errorMsg = error?.message || "error.generation.unknown";
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.error("[WizardGeneration] Build input error:", errorMsg, error);
-          }
-          dispatch({ type: "ERROR", error: errorMsg });
-          onError?.(errorMsg);
-        });
+      executeWizardGeneration({
+        wizardData,
+        scenario,
+        isVideoMode,
+        isMountedRef,
+        dispatch,
+        onError,
+        videoGenerationFn: videoGeneration.startGeneration,
+        photoGenerationFn: photoGeneration.startGeneration,
+      });
     }
 
-    // Reset state when leaving generating step
     if (!isGeneratingStep && state.status !== "IDLE") {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[WizardGeneration] State: RESET");
-      }
       dispatch({ type: "RESET" });
     }
   }, [

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

@@ -0,0 +1,59 @@
+import { providerRegistry } from "../../../../../infrastructure/services/provider-registry.service";
+import { extractResultUrl, type FalResult, type GenerationUrls } from "./generation-result.utils";
+import { QUEUE_STATUS } from "../../../../../domain/constants/queue-status.constants";
+
+declare const __DEV__: boolean;
+
+interface PollParams {
+  requestId: string;
+  model: string;
+  isPollingRef: React.MutableRefObject<boolean>;
+  pollingRef: React.MutableRefObject<ReturnType<typeof setInterval> | null>;
+  onComplete: (urls: GenerationUrls) => Promise<void>;
+  onError: (error: string) => Promise<void>;
+}
+
+export const pollQueueStatus = async (params: PollParams): Promise<void> => {
+  const { requestId, model, isPollingRef, pollingRef, onComplete, onError } = params;
+
+  if (isPollingRef.current) return;
+
+  const provider = providerRegistry.getActiveProvider();
+  if (!provider) return;
+
+  isPollingRef.current = true;
+  try {
+    const status = await provider.getJobStatus(model, requestId);
+    if (__DEV__) console.log("[VideoQueueGeneration] Poll:", status.status);
+
+    if (status.status === QUEUE_STATUS.COMPLETED || status.status === QUEUE_STATUS.FAILED) {
+      if (pollingRef.current) {
+        clearInterval(pollingRef.current);
+        pollingRef.current = null;
+      }
+
+      if (status.status === QUEUE_STATUS.COMPLETED) {
+        try {
+          const result = await provider.getJobResult<FalResult>(model, requestId);
+          await onComplete(extractResultUrl(result));
+        } catch (resultErr) {
+          const errorMessage = resultErr instanceof Error ? resultErr.message : "Generation failed";
+          if (__DEV__) console.error("[VideoQueueGeneration] Result error:", errorMessage);
+          await onError(errorMessage);
+        }
+      } else {
+        await onError("Generation failed");
+      }
+    }
+  } catch (err) {
+    if (pollingRef.current) {
+      clearInterval(pollingRef.current);
+      pollingRef.current = null;
+    }
+    const errorMessage = err instanceof Error ? err.message : "Generation failed";
+    if (__DEV__) console.error("[VideoQueueGeneration] Poll error:", errorMessage);
+    await onError(errorMessage);
+  } finally {
+    isPollingRef.current = false;
+  }
+};