@umituz/react-native-ai-generation-content 1.19.8 → 1.20.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.19.8",
+  "version": "1.20.1",
   "description": "Provider-agnostic AI generation orchestration for React Native with result preview components",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/features/couple-future/index.ts

@@ -14,8 +14,6 @@ export type {
   CoupleFeatureSelection,
 } from "./domain/types";
 export { COUPLE_FUTURE_DEFAULTS } from "./domain/types";
-export { useCoupleFutureGeneration } from "./presentation/hooks/useCoupleFutureGeneration";
-export type { CoupleFutureConfig as UseCoupleFutureGenerationConfig } from "./presentation/hooks/useCoupleFutureGeneration";
 export { useCoupleFutureFlow } from "./presentation/hooks/useCoupleFutureFlow";
 export type {
   CoupleFutureFlowConfig,

package/src/features/couple-future/presentation/hooks/useCoupleFutureFlow.ts

@@ -1,105 +1,146 @@
 /**
  * useCoupleFutureFlow Hook
- * Handles couple future wizard flow logic
+ * Optimized: Merged flow + generation logic
+ * Uses centralized orchestrator directly
  */
 
-import { useCallback, useEffect, useRef } from "react";
+import { useCallback, useEffect, useRef, useMemo } from "react";
 import { InteractionManager } from "react-native";
-import { useCoupleFutureGeneration } from "./useCoupleFutureGeneration";
+import {
+  useGenerationOrchestrator,
+  type GenerationStrategy,
+  type AlertMessages,
+} from "../../../../presentation/hooks/generation";
+import { executeCoupleFuture } from "../../infrastructure/executor";
 import { buildGenerationInputFromConfig } from "../../infrastructure/generationUtils";
+import { createCreationsRepository } from "../../../../domains/creations/infrastructure/adapters";
 import type { UploadedImage } from "../../../partner-upload/domain/types";
-import type {
-  CoupleFutureFlowConfig,
-  CoupleFutureFlowState,
-  CoupleFutureFlowActions,
-  CoupleFutureFlowProps,
-} from "./coupleFutureFlow.types";
+import type { CoupleFutureInput } from "../../domain/types";
+import type { Creation } from "../../../../domains/creations/domain/entities/Creation";
 
 declare const __DEV__: boolean;
 
-export type {
-  CoupleFutureFlowConfig,
-  CoupleFutureFlowState,
-  CoupleFutureFlowActions,
-  CoupleFutureFlowProps,
-};
+export interface CoupleFutureFlowConfig<TStep, TScenarioId> {
+  steps: {
+    SCENARIO: TStep;
+    SCENARIO_PREVIEW: TStep;
+    COUPLE_FEATURE_SELECTOR: TStep;
+    TEXT_INPUT: TStep;
+    PARTNER_A: TStep;
+    PARTNER_B: TStep;
+    GENERATING: TStep;
+  };
+  customScenarioId: TScenarioId;
+}
+
+export interface CoupleFutureFlowState<TStep, TScenarioId> {
+  step: TStep;
+  selectedScenarioId: TScenarioId | null;
+  selectedFeature: string | null;
+  partnerA: unknown;
+  partnerB: unknown;
+  partnerAName: string;
+  partnerBName: string;
+  customPrompt: string | null;
+  visualStyle: string | null;
+  selection: unknown;
+  isProcessing: boolean;
+  scenarioConfig: unknown;
+  selectedScenarioData: { requiresPhoto?: boolean } | null;
+}
+
+export interface CoupleFutureFlowActions<TStep, TScenarioId, TResult> {
+  setStep: (step: TStep) => void;
+  selectScenario: (id: TScenarioId) => void;
+  setPartnerA: (image: unknown) => void;
+  setPartnerAName: (name: string) => void;
+  setPartnerB: (image: unknown) => void;
+  setPartnerBName: (name: string) => void;
+  setCustomPrompt: (prompt: string) => void;
+  setVisualStyle: (style: string) => void;
+  startGeneration: () => void;
+  generationSuccess: (result: TResult) => void;
+  generationError: (error: string) => void;
+  requireFeature: (callback: () => void) => void;
+  onNavigateToHistory: () => void;
+}
+
+export interface CoupleFutureFlowProps<TStep, TScenarioId, TResult> {
+  userId?: string;
+  config: CoupleFutureFlowConfig<TStep, TScenarioId>;
+  state: CoupleFutureFlowState<TStep, TScenarioId>;
+  actions: CoupleFutureFlowActions<TStep, TScenarioId, TResult>;
+  generationConfig: {
+    visualStyleModifiers: Record<string, string>;
+    defaultPartnerAName: string;
+    defaultPartnerBName: string;
+  };
+  alertMessages: AlertMessages;
+  processResult: (imageUrl: string, input: CoupleFutureInput) => TResult;
+  buildCreation: (result: TResult, input: CoupleFutureInput) => Creation | null;
+  onCreditsExhausted: () => void;
+}
 
 export const useCoupleFutureFlow = <TStep, TScenarioId, TResult>(
   props: CoupleFutureFlowProps<TStep, TScenarioId, TResult>,
 ) => {
-  const { config, state, actions, generationConfig, alertMessages } = props;
-  const { processResult, buildCreation, onCreditsExhausted, userId } = props;
+  const { config, state, actions, generationConfig, alertMessages, userId } = props;
+  const { processResult, buildCreation, onCreditsExhausted } = props;
   const hasStarted = useRef(false);
+  const lastInputRef = useRef<CoupleFutureInput | null>(null);
+  const repository = useMemo(() => createCreationsRepository("creations"), []);
 
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[CoupleFutureFlow] Hook initialized:", { userId, step: state.step });
-  }
+  // Strategy for orchestrator - directly uses executor
+  const strategy: GenerationStrategy<CoupleFutureInput, TResult> = useMemo(
+    () => ({
+      execute: async (input, onProgress) => {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[CoupleFutureFlow] 🎯 Executing generation...");
+        }
+        lastInputRef.current = input;
+        const result = await executeCoupleFuture(
+          { partnerABase64: input.partnerABase64, partnerBBase64: input.partnerBBase64, prompt: input.prompt },
+          { onProgress },
+        );
+        if (!result.success || !result.imageUrl) throw new Error(result.error || "Generation failed");
+        return processResult(result.imageUrl, input);
+      },
+      getCreditCost: () => 1,
+      save: async (result, uid) => {
+        const input = lastInputRef.current;
+        if (!input) return;
+        const creation = buildCreation(result, input);
+        if (creation) await repository.create(uid, creation);
+      },
+    }),
+    [processResult, buildCreation, repository],
+  );
 
-  const { generate, isGenerating, progress } = useCoupleFutureGeneration<TResult>({
+  // Use orchestrator directly
+  const { generate, isGenerating, progress } = useGenerationOrchestrator(strategy, {
     userId,
+    alertMessages,
     onCreditsExhausted,
     onSuccess: (result) => {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[CoupleFutureFlow] 🎉 onSuccess callback triggered");
-      }
-      actions.generationSuccess(result);
-      InteractionManager.runAfterInteractions(() => {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[CoupleFutureFlow] 🔄 Navigating to History in 300ms...");
-        }
-        setTimeout(() => actions.onNavigateToHistory(), 300);
-      });
+      if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[CoupleFutureFlow] 🎉 Success");
+      actions.generationSuccess(result as TResult);
+      InteractionManager.runAfterInteractions(() => setTimeout(() => actions.onNavigateToHistory(), 300));
     },
-    onError: (error) => {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[CoupleFutureFlow] ❌ onError callback:", error);
-      }
-      actions.generationError(error);
+    onError: (err) => {
+      if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[CoupleFutureFlow] ❌ Error:", err.message);
+      actions.generationError(err.message);
     },
-    processResult: processResult as never,
-    buildCreation: buildCreation as never,
-    alertMessages,
   });
 
-  const { step, isProcessing, selectedFeature, selectedScenarioId, selectedScenarioData } = state;
-
+  // Trigger generation when step changes to GENERATING
   useEffect(() => {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[CoupleFutureFlow] useEffect triggered:", {
-        step,
-        isProcessing,
-        hasStarted: hasStarted.current,
-        targetStep: config.steps.GENERATING,
-      });
-    }
-
-    if (step !== config.steps.GENERATING) {
+    if (state.step !== config.steps.GENERATING) {
       hasStarted.current = false;
       return;
     }
-    if (!isProcessing || hasStarted.current) {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[CoupleFutureFlow] ⚠️ Skipping generation:", {
-          reason: !isProcessing ? "isProcessing=false" : "already started",
-        });
-      }
-      return;
-    }
+    if (!state.isProcessing || hasStarted.current) return;
     hasStarted.current = true;
 
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[CoupleFutureFlow] 🚀 Building generation input...");
-      console.log("[CoupleFutureFlow] State:", {
-        hasPartnerA: !!state.partnerA,
-        hasPartnerB: !!state.partnerB,
-        partnerAName: state.partnerAName,
-        partnerBName: state.partnerBName,
-        hasScenarioConfig: !!state.scenarioConfig,
-        customPrompt: state.customPrompt?.slice(0, 100),
-        visualStyle: state.visualStyle,
-      });
-    }
-
     const input = buildGenerationInputFromConfig({
       partnerA: state.partnerA as never,
       partnerB: state.partnerB as never,
@@ -114,56 +155,29 @@ export const useCoupleFutureFlow = <TStep, TScenarioId, TResult>(
       visualStyles: generationConfig.visualStyleModifiers,
       customScenarioId: config.customScenarioId as string,
     });
+    if (input) generate(input);
+  }, [state, config, generationConfig, generate]);
 
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[CoupleFutureFlow] 📦 Generation input built:", {
-        hasInput: !!input,
-        prompt: input?.prompt?.slice(0, 200),
-      });
-    }
-
-    if (input) {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[CoupleFutureFlow] 🚀 Calling generate()...");
-      }
-      generate(input);
-    }
-  }, [step, isProcessing, state, config, generationConfig, generate]);
-
+  // Handlers
   const handleScenarioSelect = useCallback(
     (id: string) => {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[CoupleFutureFlow] handleScenarioSelect:", id);
-      }
       actions.selectScenario(id as TScenarioId);
       actions.setStep(config.steps.SCENARIO_PREVIEW);
     },
     [actions, config.steps.SCENARIO_PREVIEW],
   );
 
-  const handleScenarioPreviewBack = useCallback(
-    () => actions.setStep(config.steps.SCENARIO),
-    [actions, config.steps.SCENARIO],
-  );
+  const handleScenarioPreviewBack = useCallback(() => actions.setStep(config.steps.SCENARIO), [actions, config.steps.SCENARIO]);
 
   const handleScenarioPreviewContinue = useCallback(() => {
-    if (selectedFeature) {
-      actions.setStep(config.steps.COUPLE_FEATURE_SELECTOR);
-    } else if (
-      selectedScenarioId === config.customScenarioId ||
-      selectedScenarioData?.requiresPhoto === false
-    ) {
+    if (state.selectedFeature) actions.setStep(config.steps.COUPLE_FEATURE_SELECTOR);
+    else if (state.selectedScenarioId === config.customScenarioId || state.selectedScenarioData?.requiresPhoto === false)
       actions.setStep(config.steps.TEXT_INPUT);
-    } else {
-      actions.setStep(config.steps.PARTNER_A);
-    }
-  }, [actions, config, selectedFeature, selectedScenarioId, selectedScenarioData]);
+    else actions.setStep(config.steps.PARTNER_A);
+  }, [actions, config, state.selectedFeature, state.selectedScenarioId, state.selectedScenarioData]);
 
   const handlePartnerAContinue = useCallback(
     (image: UploadedImage, name: string) => {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[CoupleFutureFlow] handlePartnerAContinue:", { hasImage: !!image, name });
-      }
       actions.setPartnerA(image);
       actions.setPartnerAName(name);
       actions.setStep(config.steps.PARTNER_B);
@@ -172,23 +186,12 @@ export const useCoupleFutureFlow = <TStep, TScenarioId, TResult>(
   );
 
   const handlePartnerABack = useCallback(() => {
-    const targetStep =
-      selectedScenarioId === config.customScenarioId
-        ? config.steps.TEXT_INPUT
-        : config.steps.SCENARIO_PREVIEW;
-    actions.setStep(targetStep);
-  }, [actions, config, selectedScenarioId]);
+    actions.setStep(state.selectedScenarioId === config.customScenarioId ? config.steps.TEXT_INPUT : config.steps.SCENARIO_PREVIEW);
+  }, [actions, config, state.selectedScenarioId]);
 
   const handlePartnerBContinue = useCallback(
     (image: UploadedImage, name: string) => {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[CoupleFutureFlow] handlePartnerBContinue:", { hasImage: !!image, name });
-        console.log("[CoupleFutureFlow] Calling requireFeature()...");
-      }
       actions.requireFeature(() => {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[CoupleFutureFlow] 🔓 Feature gate passed, starting generation");
-        }
         actions.setPartnerB(image);
         actions.setPartnerBName(name);
         actions.startGeneration();
@@ -197,34 +200,19 @@ export const useCoupleFutureFlow = <TStep, TScenarioId, TResult>(
     [actions],
   );
 
-  const handlePartnerBBack = useCallback(
-    () => actions.setStep(config.steps.PARTNER_A),
-    [actions, config.steps.PARTNER_A],
-  );
+  const handlePartnerBBack = useCallback(() => actions.setStep(config.steps.PARTNER_A), [actions, config.steps.PARTNER_A]);
 
   const handleMagicPromptContinue = useCallback(
     (prompt: string, style: string) => {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[CoupleFutureFlow] handleMagicPromptContinue:", {
-          promptLength: prompt.length,
-          style,
-        });
-      }
       actions.setCustomPrompt(prompt);
       actions.setVisualStyle(style);
-      if (selectedScenarioId === config.customScenarioId) {
-        actions.setStep(config.steps.PARTNER_A);
-      } else {
-        actions.startGeneration();
-      }
+      if (state.selectedScenarioId === config.customScenarioId) actions.setStep(config.steps.PARTNER_A);
+      else actions.startGeneration();
     },
-    [actions, config, selectedScenarioId],
+    [actions, config, state.selectedScenarioId],
   );
 
-  const handleMagicPromptBack = useCallback(
-    () => actions.setStep(config.steps.SCENARIO_PREVIEW),
-    [actions, config.steps.SCENARIO_PREVIEW],
-  );
+  const handleMagicPromptBack = useCallback(() => actions.setStep(config.steps.SCENARIO_PREVIEW), [actions, config.steps.SCENARIO_PREVIEW]);
 
   return {
     isGenerating,

package/src/features/text-to-image/presentation/hooks/useGeneration.ts

@@ -1,9 +1,14 @@
 /**
  * Text-to-Image Generation Hook
- * Orchestrates generation with app-provided callbacks
+ * Uses centralized orchestrator for auth, credits, and error handling
  */
 
-import { useState, useCallback } from "react";
+import { useCallback, useMemo } from "react";
+import {
+  useGenerationOrchestrator,
+  type GenerationStrategy,
+  type AlertMessages,
+} from "../../../../presentation/hooks/generation";
 import type {
   TextToImageFormState,
   TextToImageCallbacks,
@@ -11,91 +16,95 @@ import type {
   TextToImageGenerationRequest,
 } from "../../domain/types";
 
-export interface GenerationState {
-  isGenerating: boolean;
-  progress: number;
-  error: string | null;
-}
+declare const __DEV__: boolean;
 
 export interface UseGenerationOptions {
   formState: TextToImageFormState;
   callbacks: TextToImageCallbacks;
+  userId?: string;
   onPromptCleared?: () => void;
 }
 
+export interface GenerationState {
+  isGenerating: boolean;
+  progress: number;
+  error: string | null;
+}
+
 export interface UseGenerationReturn {
   generationState: GenerationState;
   totalCost: number;
   handleGenerate: () => Promise<TextToImageGenerationResult | null>;
 }
 
-const initialState: GenerationState = {
-  isGenerating: false,
-  progress: 0,
-  error: null,
+const DEFAULT_ALERT_MESSAGES: AlertMessages = {
+  networkError: "No internet connection. Please check your network.",
+  policyViolation: "Content not allowed. Please try again.",
+  saveFailed: "Failed to save. Please try again.",
+  creditFailed: "Credit operation failed. Please try again.",
+  unknown: "An error occurred. Please try again.",
+  authRequired: "Please sign in to continue.",
 };
 
-declare const __DEV__: boolean;
-
 export function useGeneration(options: UseGenerationOptions): UseGenerationReturn {
-  const { formState, callbacks, onPromptCleared } = options;
-  const [generationState, setGenerationState] = useState<GenerationState>(initialState);
+  const { formState, callbacks, userId, onPromptCleared } = options;
 
   const totalCost = callbacks.calculateCost(formState.numImages, formState.selectedModel);
 
-  const handleGenerate = useCallback(async (): Promise<TextToImageGenerationResult | null> => {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-       
-      console.log("[TextToImage] handleGenerate called");
-    }
-
-    const trimmedPrompt = formState.prompt.trim();
-
-    if (!trimmedPrompt) {
+  // Build strategy for orchestrator
+  const strategy: GenerationStrategy<TextToImageGenerationRequest, string[]> = useMemo(
+    () => ({
+      execute: async (request) => {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[TextToImage] Executing generation:", JSON.stringify(request, null, 2));
+        }
+        const result = await callbacks.executeGeneration(request);
+        if (result.success === false) {
+          throw new Error(result.error);
+        }
+        return result.imageUrls;
+      },
+      getCreditCost: () => totalCost,
+    }),
+    [callbacks, totalCost],
+  );
+
+  // Use orchestrator with auth support
+  const { generate, isGenerating, progress, error } = useGenerationOrchestrator(strategy, {
+    userId,
+    alertMessages: DEFAULT_ALERT_MESSAGES,
+    onCreditsExhausted: () => callbacks.onCreditsRequired?.(totalCost),
+    auth: {
+      isAuthenticated: callbacks.isAuthenticated,
+      onAuthRequired: callbacks.onAuthRequired,
+    },
+    onSuccess: (result) => {
+      const imageUrls = result as string[];
       if (typeof __DEV__ !== "undefined" && __DEV__) {
-         
-        console.log("[TextToImage] No prompt provided");
+        console.log("[TextToImage] Success! Generated", imageUrls.length, "image(s)");
       }
-      setGenerationState((prev) => ({ ...prev, error: "Prompt is required" }));
-      return null;
-    }
-
-    const isAuth = callbacks.isAuthenticated();
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-       
-      console.log("[TextToImage] isAuthenticated:", isAuth);
-    }
-
-    if (!isAuth) {
+      callbacks.onSuccess?.(imageUrls);
+      onPromptCleared?.();
+    },
+    onError: (err) => {
       if (typeof __DEV__ !== "undefined" && __DEV__) {
-         
-        console.log("[TextToImage] Auth required - calling onAuthRequired");
+        console.log("[TextToImage] Error:", err.message);
       }
-      callbacks.onAuthRequired?.();
-      return null;
-    }
+      callbacks.onError?.(err.message);
+    },
+  });
 
-    const affordable = callbacks.canAfford(totalCost);
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-       
-      console.log("[TextToImage] canAfford:", affordable, "totalCost:", totalCost);
-    }
+  const handleGenerate = useCallback(async (): Promise<TextToImageGenerationResult | null> => {
+    const trimmedPrompt = formState.prompt.trim();
 
-    if (!affordable) {
+    if (!trimmedPrompt) {
       if (typeof __DEV__ !== "undefined" && __DEV__) {
-         
-        console.log("[TextToImage] Credits required - calling onCreditsRequired");
+        console.log("[TextToImage] No prompt provided");
       }
-      callbacks.onCreditsRequired?.(totalCost);
-      return null;
+      callbacks.onError?.("Prompt is required");
+      return { success: false, error: "Prompt is required" };
     }
 
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-       
-      console.log("[TextToImage] Starting generation...");
-    }
-    setGenerationState({ isGenerating: true, progress: 0, error: null });
-
     const request: TextToImageGenerationRequest = {
       prompt: trimmedPrompt,
       model: formState.selectedModel ?? undefined,
@@ -109,51 +118,22 @@ export function useGeneration(options: UseGenerationOptions): UseGenerationRetur
     };
 
     if (typeof __DEV__ !== "undefined" && __DEV__) {
-       
-      console.log("[TextToImage] Request:", JSON.stringify(request, null, 2));
-    }
-
-    try {
-      const result = await callbacks.executeGeneration(request);
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        const logResult = {
-          success: result.success,
-          imageCount: result.success ? result.imageUrls?.length : 0,
-          error: result.success === false ? result.error : undefined,
-        };
-         
-        console.log("[TextToImage] Result:", JSON.stringify(logResult));
-      }
-
-      if (result.success === true) {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-           
-          console.log("[TextToImage] Success! Generated", result.imageUrls?.length, "image(s)");
-        }
-        callbacks.onSuccess?.(result.imageUrls);
-        onPromptCleared?.();
-        setGenerationState({ isGenerating: false, progress: 100, error: null });
-      } else {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-           
-          console.log("[TextToImage] Generation failed:", result.error);
-        }
-        setGenerationState({ isGenerating: false, progress: 0, error: result.error });
-        callbacks.onError?.(result.error);
-      }
-
-      return result;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-         
-        console.error("[TextToImage] Exception:", message);
-      }
-      setGenerationState({ isGenerating: false, progress: 0, error: message });
-      callbacks.onError?.(message);
-      return null;
+      console.log("[TextToImage] Starting generation...");
     }
-  }, [formState, callbacks, totalCost, onPromptCleared]);
 
-  return { generationState, totalCost, handleGenerate };
+    await generate(request);
+
+    // Return result based on orchestrator state
+    return null; // Result handled via callbacks
+  }, [formState, generate, callbacks]);
+
+  return {
+    generationState: {
+      isGenerating,
+      progress,
+      error: error?.message || null,
+    },
+    totalCost,
+    handleGenerate,
+  };
 }

package/src/presentation/hooks/generation/index.ts

@@ -20,6 +20,10 @@ export type {
   GenerationErrorType,
   AlertMessages,
   UseGenerationOrchestratorReturn,
+  AuthCallbacks,
+  ModerationCallbacks,
+  ModerationResult,
+  CreditCallbacks,
 } from "./types";
 
 export type {

package/src/presentation/hooks/generation/orchestrator.ts

@@ -1,6 +1,8 @@
 /**
  * Generation Orchestrator
  * Feature-agnostic hook for AI generation with centralized:
+ * - Auth checking (optional)
+ * - Content moderation (optional)
  * - Credit management
  * - Error handling
  * - Alert display
@@ -32,24 +34,100 @@ export const useGenerationOrchestrator = <TInput, TResult>(
   strategy: GenerationStrategy<TInput, TResult>,
   config: GenerationConfig,
 ): UseGenerationOrchestratorReturn<TInput, TResult> => {
-  const { userId, alertMessages, onCreditsExhausted, onSuccess, onError } = config;
+  const { userId, alertMessages, onCreditsExhausted, onSuccess, onError, auth, moderation, credits } = config;
 
   if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[Orchestrator] Hook initialized:", { userId, hasAlertMessages: !!alertMessages });
+    console.log("[Orchestrator] Hook initialized:", {
+      userId,
+      hasAuth: !!auth,
+      hasModeration: !!moderation,
+      hasCreditsCallbacks: !!credits,
+    });
   }
 
   const [state, setState] = useState<GenerationState<TResult>>(INITIAL_STATE);
   const isGeneratingRef = useRef(false);
+  const pendingInputRef = useRef<TInput | null>(null);
   const offlineStore = useOfflineStore();
   const { showError, showSuccess } = useAlert();
-  const { checkCredits, deductCredit } = useDeductCredit({ userId, onCreditsExhausted });
+  const defaultCredits = useDeductCredit({ userId, onCreditsExhausted });
+
+  // Use provided credit callbacks or default to useDeductCredit hook
+  const checkCredits = credits?.checkCredits ?? defaultCredits.checkCredits;
+  const deductCredit = credits?.deductCredits ?? defaultCredits.deductCredit;
+  const handleCreditsExhausted = credits?.onCreditsExhausted ?? onCreditsExhausted;
+
+  // Core execution logic (after all checks pass)
+  const executeGeneration = useCallback(
+    async (input: TInput) => {
+      const creditCost = strategy.getCreditCost();
+
+      setState((prev) => ({ ...prev, status: "generating", progress: 10 }));
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[Orchestrator] 🎨 Starting strategy.execute()");
+      }
+
+      const result = await strategy.execute(input, (progress) => {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[Orchestrator] 📊 Progress update:", progress);
+        }
+        setState((prev) => ({ ...prev, progress }));
+      });
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[Orchestrator] ✅ strategy.execute() completed");
+      }
+
+      setState((prev) => ({ ...prev, progress: 70 }));
+
+      // Save result
+      if (strategy.save && userId) {
+        setState((prev) => ({ ...prev, status: "saving" }));
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[Orchestrator] 💾 Saving result...");
+        }
+        try {
+          await strategy.save(result, userId);
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.log("[Orchestrator] ✅ Save completed");
+          }
+        } catch (saveErr) {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.log("[Orchestrator] ❌ Save failed:", saveErr);
+          }
+          throw createGenerationError("save", "Failed to save", saveErr instanceof Error ? saveErr : undefined);
+        }
+      }
+
+      setState((prev) => ({ ...prev, progress: 90 }));
+
+      // Deduct credit
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[Orchestrator] 💳 Deducting credit:", creditCost);
+      }
+      await deductCredit(creditCost);
+
+      // Success
+      setState({ status: "success", isGenerating: false, progress: 100, result, error: null });
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[Orchestrator] 🎉 Generation SUCCESS");
+      }
+
+      if (alertMessages.success) {
+        void showSuccess("Success", alertMessages.success);
+      }
+
+      onSuccess?.(result);
+    },
+    [strategy, userId, alertMessages, deductCredit, showSuccess, onSuccess],
+  );
 
   const generate = useCallback(
     async (input: TInput) => {
       if (typeof __DEV__ !== "undefined" && __DEV__) {
         console.log("[Orchestrator] 🚀 generate() called");
         console.log("[Orchestrator] Input:", JSON.stringify(input, null, 2).slice(0, 500));
-        console.log("[Orchestrator] isGeneratingRef:", isGeneratingRef.current);
       }
 
       if (isGeneratingRef.current) {
@@ -60,149 +138,141 @@ export const useGenerationOrchestrator = <TInput, TResult>(
       }
 
       isGeneratingRef.current = true;
+      pendingInputRef.current = input;
       setState({ ...INITIAL_STATE, status: "checking", isGenerating: true });
 
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[Orchestrator] State set to: checking, isGenerating: true");
-      }
-
       try {
-        // Network check
+        // 1. Auth check (optional)
+        if (auth) {
+          setState((prev) => ({ ...prev, status: "authenticating" }));
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.log("[Orchestrator] 🔐 Checking authentication...");
+          }
+
+          if (!auth.isAuthenticated()) {
+            if (typeof __DEV__ !== "undefined" && __DEV__) {
+              console.log("[Orchestrator] ❌ Not authenticated");
+            }
+            isGeneratingRef.current = false;
+            setState(INITIAL_STATE);
+            auth.onAuthRequired?.();
+            return;
+          }
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.log("[Orchestrator] ✅ Authentication passed");
+          }
+        }
+
+        // 2. Network check
         if (!offlineStore.isOnline) {
           if (typeof __DEV__ !== "undefined" && __DEV__) {
             console.log("[Orchestrator] ❌ Network check failed - offline");
           }
           throw createGenerationError("network", "No internet connection");
         }
-
         if (typeof __DEV__ !== "undefined" && __DEV__) {
           console.log("[Orchestrator] ✅ Network check passed");
         }
 
-        // Credit check
+        // 3. Credit check
         const creditCost = strategy.getCreditCost();
         if (typeof __DEV__ !== "undefined" && __DEV__) {
           console.log("[Orchestrator] 💳 Credit cost:", creditCost);
         }
 
         const hasCredits = await checkCredits(creditCost);
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[Orchestrator] 💳 Has credits:", hasCredits);
-        }
-
         if (!hasCredits) {
           if (typeof __DEV__ !== "undefined" && __DEV__) {
             console.log("[Orchestrator] ❌ No credits, opening paywall");
           }
           isGeneratingRef.current = false;
           setState(INITIAL_STATE);
-          onCreditsExhausted?.();
+          handleCreditsExhausted?.();
           return;
         }
-
-        // Start generation
-        setState((prev) => ({ ...prev, status: "generating", progress: 10 }));
         if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[Orchestrator] 🎨 Starting strategy.execute()");
+          console.log("[Orchestrator] ✅ Credit check passed");
         }
 
-        const result = await strategy.execute(input, (progress) => {
+        // 4. Content moderation (optional)
+        if (moderation) {
+          setState((prev) => ({ ...prev, status: "moderating" }));
           if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.log("[Orchestrator] 📊 Progress update:", progress);
+            console.log("[Orchestrator] 🛡️ Checking content moderation...");
           }
-          setState((prev) => ({ ...prev, progress }));
-        });
 
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[Orchestrator] ✅ strategy.execute() completed");
-          console.log("[Orchestrator] Result type:", typeof result);
-        }
-
-        setState((prev) => ({ ...prev, progress: 70 }));
-
-        // Save result
-        if (strategy.save && userId) {
-          setState((prev) => ({ ...prev, status: "saving" }));
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.log("[Orchestrator] 💾 Saving result...");
-          }
-          try {
-            await strategy.save(result, userId);
+          const moderationResult = await moderation.checkContent(input);
+          if (!moderationResult.allowed && moderationResult.warnings.length > 0) {
             if (typeof __DEV__ !== "undefined" && __DEV__) {
-              console.log("[Orchestrator] ✅ Save completed");
+              console.log("[Orchestrator] ⚠️ Moderation warnings:", moderationResult.warnings);
             }
-          } catch (saveErr) {
-            if (typeof __DEV__ !== "undefined" && __DEV__) {
-              console.log("[Orchestrator] ❌ Save failed:", saveErr);
+
+            if (moderation.onShowWarning) {
+              // Show warning and let user decide
+              moderation.onShowWarning(
+                moderationResult.warnings,
+                () => {
+                  // User cancelled
+                  if (typeof __DEV__ !== "undefined" && __DEV__) {
+                    console.log("[Orchestrator] User cancelled after moderation warning");
+                  }
+                  isGeneratingRef.current = false;
+                  setState(INITIAL_STATE);
+                },
+                async () => {
+                  // User continued - execute generation
+                  if (typeof __DEV__ !== "undefined" && __DEV__) {
+                    console.log("[Orchestrator] User continued after moderation warning");
+                  }
+                  try {
+                    await executeGeneration(input);
+                  } catch (err) {
+                    const error = parseError(err);
+                    setState({ status: "error", isGenerating: false, progress: 0, result: null, error });
+                    void showError("Error", getAlertMessage(error, alertMessages));
+                    onError?.(error);
+                  } finally {
+                    isGeneratingRef.current = false;
+                  }
+                },
+              );
+              return; // Exit here - callback will handle the rest
             }
-            throw createGenerationError(
-              "save",
-              "Failed to save",
-              saveErr instanceof Error ? saveErr : undefined,
-            );
+            // No warning handler - block the request
+            throw createGenerationError("policy", "Content policy violation");
+          }
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.log("[Orchestrator] ✅ Moderation passed");
           }
         }
 
-        setState((prev) => ({ ...prev, progress: 90 }));
-
-        // Deduct credit
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[Orchestrator] 💳 Deducting credit:", creditCost);
-        }
-        await deductCredit(creditCost);
-
-        // Success
-        setState({
-          status: "success",
-          isGenerating: false,
-          progress: 100,
-          result,
-          error: null,
-        });
-
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[Orchestrator] 🎉 Generation SUCCESS");
-        }
-
-        if (alertMessages.success) {
-          void showSuccess("Success", alertMessages.success);
-        }
-
-        onSuccess?.(result);
+        // 5. Execute generation
+        await executeGeneration(input);
       } catch (err) {
         const error = parseError(err);
-
         if (typeof __DEV__ !== "undefined" && __DEV__) {
           console.log("[Orchestrator] ❌ Generation ERROR:", error);
         }
-
-        setState({
-          status: "error",
-          isGenerating: false,
-          progress: 0,
-          result: null,
-          error,
-        });
-
+        setState({ status: "error", isGenerating: false, progress: 0, result: null, error });
         void showError("Error", getAlertMessage(error, alertMessages));
         onError?.(error);
       } finally {
         isGeneratingRef.current = false;
         if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[Orchestrator] 🏁 generate() finished, isGeneratingRef reset to false");
+          console.log("[Orchestrator] 🏁 generate() finished");
         }
       }
     },
     [
+      auth,
+      moderation,
       strategy,
-      userId,
       alertMessages,
       offlineStore.isOnline,
       checkCredits,
-      deductCredit,
+      handleCreditsExhausted,
+      executeGeneration,
       showError,
-      showSuccess,
-      onSuccess,
       onError,
     ],
   );

package/src/presentation/hooks/generation/types.ts

@@ -6,6 +6,8 @@
 export type OrchestratorStatus =
   | "idle"
   | "checking"
+  | "authenticating"
+  | "moderating"
   | "generating"
   | "saving"
   | "success"
@@ -30,6 +32,43 @@ export interface AlertMessages {
   creditFailed: string;
   unknown: string;
   success?: string;
+  authRequired?: string;
+}
+
+/** Content moderation result */
+export interface ModerationResult {
+  allowed: boolean;
+  warnings: string[];
+}
+
+/** Auth callbacks for features that need authentication */
+export interface AuthCallbacks {
+  /** Check if user is authenticated */
+  isAuthenticated: () => boolean;
+  /** Called when auth is required */
+  onAuthRequired?: () => void;
+}
+
+/** Moderation callbacks for content filtering */
+export interface ModerationCallbacks {
+  /** Check content for policy violations */
+  checkContent: (input: unknown) => Promise<ModerationResult>;
+  /** Show moderation warning with continue/cancel options */
+  onShowWarning?: (
+    warnings: string[],
+    onCancel: () => void,
+    onContinue: () => void,
+  ) => void;
+}
+
+/** Credit callbacks for features that manage credits via callbacks */
+export interface CreditCallbacks {
+  /** Check if user can afford the cost */
+  checkCredits: (cost: number) => Promise<boolean>;
+  /** Deduct credits after successful generation */
+  deductCredits: (cost: number) => Promise<void>;
+  /** Called when credits are exhausted */
+  onCreditsExhausted?: () => void;
 }
 
 export interface GenerationConfig {
@@ -38,6 +77,12 @@ export interface GenerationConfig {
   onCreditsExhausted?: () => void;
   onSuccess?: (result: unknown) => void;
   onError?: (error: GenerationError) => void;
+  /** Optional auth callbacks - if not provided, auth is skipped */
+  auth?: AuthCallbacks;
+  /** Optional moderation callbacks - if not provided, moderation is skipped */
+  moderation?: ModerationCallbacks;
+  /** Optional credit callbacks - if provided, overrides default useDeductCredit */
+  credits?: CreditCallbacks;
 }
 
 export interface GenerationState<TResult> {

package/src/features/couple-future/presentation/hooks/coupleFutureFlow.types.ts

@@ -1,71 +0,0 @@
-/**
- * Couple Future Flow Types
- * Type definitions for couple future wizard flow
- */
-
-export interface CoupleFutureFlowConfig<TStep, TScenarioId> {
-  steps: {
-    SCENARIO: TStep;
-    SCENARIO_PREVIEW: TStep;
-    COUPLE_FEATURE_SELECTOR: TStep;
-    TEXT_INPUT: TStep;
-    PARTNER_A: TStep;
-    PARTNER_B: TStep;
-    GENERATING: TStep;
-  };
-  customScenarioId: TScenarioId;
-}
-
-export interface CoupleFutureFlowState<TStep, TScenarioId> {
-  step: TStep;
-  selectedScenarioId: TScenarioId | null;
-  selectedFeature: string | null;
-  partnerA: unknown;
-  partnerB: unknown;
-  partnerAName: string;
-  partnerBName: string;
-  customPrompt: string | null;
-  visualStyle: string | null;
-  selection: unknown;
-  isProcessing: boolean;
-  scenarioConfig: unknown;
-  selectedScenarioData: { requiresPhoto?: boolean } | null;
-}
-
-export interface CoupleFutureFlowActions<TStep, TScenarioId, TResult> {
-  setStep: (step: TStep) => void;
-  selectScenario: (id: TScenarioId) => void;
-  setPartnerA: (image: unknown) => void;
-  setPartnerAName: (name: string) => void;
-  setPartnerB: (image: unknown) => void;
-  setPartnerBName: (name: string) => void;
-  setCustomPrompt: (prompt: string) => void;
-  setVisualStyle: (style: string) => void;
-  startGeneration: () => void;
-  generationSuccess: (result: TResult) => void;
-  generationError: (error: string) => void;
-  requireFeature: (callback: () => void) => void;
-  onNavigateToHistory: () => void;
-}
-
-export interface CoupleFutureFlowProps<TStep, TScenarioId, TResult> {
-  userId?: string;
-  config: CoupleFutureFlowConfig<TStep, TScenarioId>;
-  state: CoupleFutureFlowState<TStep, TScenarioId>;
-  actions: CoupleFutureFlowActions<TStep, TScenarioId, TResult>;
-  generationConfig: {
-    visualStyleModifiers: Record<string, string>;
-    defaultPartnerAName: string;
-    defaultPartnerBName: string;
-  };
-  alertMessages: {
-    networkError: string;
-    policyViolation: string;
-    saveFailed: string;
-    creditFailed: string;
-    unknown: string;
-  };
-  processResult: (imageUrl: string, input: unknown) => TResult;
-  buildCreation: (result: TResult, input: unknown) => unknown;
-  onCreditsExhausted: () => void;
-}

package/src/features/couple-future/presentation/hooks/useCoupleFutureGeneration.ts

@@ -1,141 +0,0 @@
-/**
- * useCoupleFutureGeneration Hook
- * Couple future generation using centralized orchestrator
- */
-
-import { useMemo, useCallback, useRef } from "react";
-import {
-  useGenerationOrchestrator,
-  type GenerationStrategy,
-  type AlertMessages,
-} from "../../../../presentation/hooks/generation";
-import { executeCoupleFuture } from "../../infrastructure/executor";
-import type { CoupleFutureInput } from "../../domain/types";
-import { createCreationsRepository } from "../../../../domains/creations/infrastructure/adapters";
-import type { Creation } from "../../../../domains/creations/domain/entities/Creation";
-
-declare const __DEV__: boolean;
-
-export interface CoupleFutureConfig<TResult> {
-  userId: string | undefined;
-  processResult: (imageUrl: string, input: CoupleFutureInput) => TResult;
-  buildCreation?: (result: TResult, input: CoupleFutureInput) => Creation | null;
-  onCreditsExhausted?: () => void;
-  onSuccess?: (result: TResult) => void;
-  onError?: (error: string) => void;
-  alertMessages: AlertMessages;
-}
-
-export const useCoupleFutureGeneration = <TResult>(config: CoupleFutureConfig<TResult>) => {
-  const { userId, processResult, buildCreation, onCreditsExhausted, onSuccess, onError, alertMessages } = config;
-
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[CoupleFutureGeneration] Hook initialized:", {
-      userId,
-      hasBuildCreation: !!buildCreation,
-      hasOnSuccess: !!onSuccess,
-    });
-  }
-
-  const repository = useMemo(() => createCreationsRepository("creations"), []);
-  const lastInputRef = useRef<CoupleFutureInput | null>(null);
-
-  const strategy: GenerationStrategy<CoupleFutureInput, TResult> = useMemo(
-    () => ({
-      execute: async (input, onProgress) => {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[CoupleFutureGeneration] 🎯 strategy.execute() START");
-          console.log("[CoupleFutureGeneration] Input prompt:", input.prompt?.slice(0, 200));
-          console.log("[CoupleFutureGeneration] Has partnerA:", !!input.partnerABase64);
-          console.log("[CoupleFutureGeneration] Has partnerB:", !!input.partnerBBase64);
-        }
-
-        lastInputRef.current = input;
-
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[CoupleFutureGeneration] 📡 Calling executeCoupleFuture()...");
-        }
-
-        const result = await executeCoupleFuture(
-          {
-            partnerABase64: input.partnerABase64,
-            partnerBBase64: input.partnerBBase64,
-            prompt: input.prompt,
-          },
-          { onProgress },
-        );
-
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[CoupleFutureGeneration] 📡 executeCoupleFuture() returned:", {
-            success: result.success,
-            hasImageUrl: !!result.imageUrl,
-            error: result.error,
-          });
-        }
-
-        if (!result.success || !result.imageUrl) {
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.log("[CoupleFutureGeneration] ❌ Generation failed:", result.error);
-          }
-          throw new Error(result.error || "Generation failed");
-        }
-
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[CoupleFutureGeneration] ✅ Processing result with processResult()");
-        }
-
-        return processResult(result.imageUrl, input);
-      },
-      getCreditCost: () => 1,
-      save: buildCreation
-        ? async (result, uid) => {
-            if (typeof __DEV__ !== "undefined" && __DEV__) {
-              console.log("[CoupleFutureGeneration] 💾 strategy.save() START");
-            }
-            const input = lastInputRef.current;
-            if (input) {
-              const creation = buildCreation(result, input);
-              if (creation) {
-                if (typeof __DEV__ !== "undefined" && __DEV__) {
-                  console.log("[CoupleFutureGeneration] 💾 Saving creation to repository...");
-                }
-                await repository.create(uid, creation);
-                if (typeof __DEV__ !== "undefined" && __DEV__) {
-                  console.log("[CoupleFutureGeneration] ✅ Creation saved");
-                }
-              }
-            }
-          }
-        : undefined,
-    }),
-    [processResult, buildCreation, repository],
-  );
-
-  const handleError = useCallback(
-    (error: { message: string }) => {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[CoupleFutureGeneration] ❌ handleError:", error.message);
-      }
-      onError?.(error.message);
-    },
-    [onError],
-  );
-
-  const handleSuccess = useCallback(
-    (result: unknown) => {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[CoupleFutureGeneration] 🎉 handleSuccess called");
-      }
-      onSuccess?.(result as TResult);
-    },
-    [onSuccess],
-  );
-
-  return useGenerationOrchestrator(strategy, {
-    userId,
-    alertMessages,
-    onCreditsExhausted,
-    onSuccess: handleSuccess,
-    onError: handleError,
-  });
-};