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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.19.6",
+  "version": "1.19.8",
   "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/infrastructure/executor.ts

@@ -18,23 +18,51 @@ export async function executeCoupleFuture(
   input: CoupleFutureInput,
   config?: CoupleFutureConfig,
 ): Promise<CoupleFutureResult> {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[Executor] ========== COUPLE FUTURE START ==========");
+    console.log("[Executor] Input received:", {
+      hasPartnerA: !!input.partnerABase64,
+      partnerALength: input.partnerABase64?.length || 0,
+      hasPartnerB: !!input.partnerBBase64,
+      partnerBLength: input.partnerBBase64?.length || 0,
+      promptLength: input.prompt?.length || 0,
+      prompt: input.prompt?.slice(0, 300),
+    });
+    console.log("[Executor] Config:", {
+      hasOnProgress: !!config?.onProgress,
+      timeoutMs: config?.timeoutMs,
+      aspectRatio: config?.aspectRatio,
+      outputFormat: config?.outputFormat,
+    });
+  }
+
   const provider = providerRegistry.getActiveProvider();
 
   if (!provider) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[Executor] ❌ No AI provider configured");
+    }
     return { success: false, error: "No AI provider configured" };
   }
 
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[Executor] ✅ Provider found:", provider.constructor.name);
+  }
+
   if (!provider.isInitialized()) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[Executor] ❌ AI provider not initialized");
+    }
     return { success: false, error: "AI provider not initialized" };
   }
 
-  const { onProgress, timeoutMs, aspectRatio, outputFormat } = config ?? {};
-  let lastStatus = "";
-
   if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[CoupleFuture] Starting Nano Banana generation");
+    console.log("[Executor] ✅ Provider initialized");
   }
 
+  const { onProgress, timeoutMs, aspectRatio, outputFormat } = config ?? {};
+  let lastStatus = "";
+
   try {
     onProgress?.(5);
 
@@ -42,7 +70,18 @@ export async function executeCoupleFuture(
       .filter(Boolean)
       .map(formatBase64);
 
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[Executor] 🖼️ Image URLs prepared:", {
+        count: imageUrls.length,
+        url1Length: imageUrls[0]?.length || 0,
+        url2Length: imageUrls[1]?.length || 0,
+      });
+    }
+
     if (imageUrls.length < 2) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[Executor] ❌ Two reference images required, got:", imageUrls.length);
+      }
       return { success: false, error: "Two reference images required" };
     }
 
@@ -59,7 +98,16 @@ export async function executeCoupleFuture(
     };
 
     if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[CoupleFuture] Prompt:", enhancedPrompt);
+      console.log("[Executor] 📤 FAL AI Request:");
+      console.log("[Executor] Model:", COUPLE_FUTURE_DEFAULTS.model);
+      console.log("[Executor] Prompt:", enhancedPrompt.slice(0, 400));
+      console.log("[Executor] Aspect ratio:", modelInput.aspect_ratio);
+      console.log("[Executor] Output format:", modelInput.output_format);
+      console.log("[Executor] Timeout:", timeoutMs ?? COUPLE_FUTURE_DEFAULTS.timeoutMs);
+    }
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[Executor] 📡 Calling provider.subscribe()...");
     }
 
     const result = await provider.subscribe(COUPLE_FUTURE_DEFAULTS.model, modelInput, {
@@ -69,7 +117,10 @@ export async function executeCoupleFuture(
         lastStatus = status.status;
 
         if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[CoupleFuture] Status:", status.status);
+          console.log("[Executor] 📊 Queue status update:", {
+            status: status.status,
+            logs: status.logs?.slice(-3),
+          });
         }
 
         if (status.status === "IN_QUEUE") onProgress?.(20);
@@ -80,8 +131,10 @@ export async function executeCoupleFuture(
     onProgress?.(90);
 
     if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[CoupleFuture] Raw result:", JSON.stringify(result, null, 2));
-      console.log("[CoupleFuture] Result keys:", result ? Object.keys(result as object) : "null");
+      console.log("[Executor] 📥 FAL AI Response received");
+      console.log("[Executor] Raw result type:", typeof result);
+      console.log("[Executor] Raw result keys:", result ? Object.keys(result as object) : "null");
+      console.log("[Executor] Raw result:", JSON.stringify(result, null, 2).slice(0, 1000));
     }
 
     const rawResult = result as Record<string, unknown>;
@@ -89,21 +142,38 @@ export async function executeCoupleFuture(
     const imageUrl = data?.images?.[0]?.url;
 
     if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[CoupleFuture] Parsed data:", JSON.stringify(data, null, 2));
-      console.log("[CoupleFuture] Image URL:", imageUrl);
+      console.log("[Executor] 🔍 Parsed response:");
+      console.log("[Executor] Has data:", !!data);
+      console.log("[Executor] Images array length:", data?.images?.length || 0);
+      console.log("[Executor] First image URL:", imageUrl?.slice(0, 100));
     }
 
     onProgress?.(100);
 
     if (!imageUrl) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[Executor] ❌ No image URL in response");
+        console.log("[Executor] ========== COUPLE FUTURE END (FAILED) ==========");
+      }
       return { success: false, error: "No image generated" };
     }
 
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[Executor] ✅ Generation successful!");
+      console.log("[Executor] Image URL:", imageUrl.slice(0, 100));
+      console.log("[Executor] ========== COUPLE FUTURE END (SUCCESS) ==========");
+    }
+
     return { success: true, imageUrl };
   } catch (error) {
     const message = error instanceof Error ? error.message : "Generation failed";
     if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.error("[CoupleFuture] Error:", message);
+      console.error("[Executor] ❌ Exception caught:", {
+        message,
+        name: error instanceof Error ? error.name : "Unknown",
+        stack: error instanceof Error ? error.stack?.slice(0, 500) : undefined,
+      });
+      console.log("[Executor] ========== COUPLE FUTURE END (ERROR) ==========");
     }
     return { success: false, error: message };
   }

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

@@ -0,0 +1,71 @@
+/**
+ * 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/useCoupleFutureFlow.ts

@@ -8,73 +8,21 @@ import { InteractionManager } from "react-native";
 import { useCoupleFutureGeneration } from "./useCoupleFutureGeneration";
 import { buildGenerationInputFromConfig } from "../../infrastructure/generationUtils";
 import type { UploadedImage } from "../../../partner-upload/domain/types";
-
-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;
-}
+import type {
+  CoupleFutureFlowConfig,
+  CoupleFutureFlowState,
+  CoupleFutureFlowActions,
+  CoupleFutureFlowProps,
+} from "./coupleFutureFlow.types";
+
+declare const __DEV__: boolean;
+
+export type {
+  CoupleFutureFlowConfig,
+  CoupleFutureFlowState,
+  CoupleFutureFlowActions,
+  CoupleFutureFlowProps,
+};
 
 export const useCoupleFutureFlow = <TStep, TScenarioId, TResult>(
   props: CoupleFutureFlowProps<TStep, TScenarioId, TResult>,
@@ -83,82 +31,110 @@ export const useCoupleFutureFlow = <TStep, TScenarioId, TResult>(
   const { processResult, buildCreation, onCreditsExhausted, userId } = props;
   const hasStarted = useRef(false);
 
-  const { generate, isGenerating, progress } =
-    useCoupleFutureGeneration<TResult>({
-      userId,
-      onCreditsExhausted,
-      onSuccess: (result) => {
-        actions.generationSuccess(result);
-        InteractionManager.runAfterInteractions(() => {
-          setTimeout(() => actions.onNavigateToHistory(), 300);
-        });
-      },
-      onError: actions.generationError,
-      processResult: processResult as never,
-      buildCreation: buildCreation as never,
-      alertMessages,
-    });
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[CoupleFutureFlow] Hook initialized:", { userId, step: state.step });
+  }
 
-  const {
-    step,
-    isProcessing,
-    partnerA,
-    partnerB,
-    partnerAName,
-    partnerBName,
-    scenarioConfig,
-    customPrompt,
-    visualStyle,
-    selection,
-    selectedFeature,
-    selectedScenarioId,
-    selectedScenarioData,
-  } = state;
+  const { generate, isGenerating, progress } = useCoupleFutureGeneration<TResult>({
+    userId,
+    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);
+      });
+    },
+    onError: (error) => {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[CoupleFutureFlow] ❌ onError callback:", error);
+      }
+      actions.generationError(error);
+    },
+    processResult: processResult as never,
+    buildCreation: buildCreation as never,
+    alertMessages,
+  });
+
+  const { step, isProcessing, selectedFeature, selectedScenarioId, selectedScenarioData } = state;
 
   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) {
       hasStarted.current = false;
       return;
     }
-    if (!isProcessing || hasStarted.current) return;
+    if (!isProcessing || hasStarted.current) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[CoupleFutureFlow] ⚠️ Skipping generation:", {
+          reason: !isProcessing ? "isProcessing=false" : "already started",
+        });
+      }
+      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: partnerA as never,
-      partnerB: partnerB as never,
-      partnerAName,
-      partnerBName,
-      scenario: scenarioConfig as never,
-      customPrompt: customPrompt || undefined,
-      visualStyle: visualStyle || "",
+      partnerA: state.partnerA as never,
+      partnerB: state.partnerB as never,
+      partnerAName: state.partnerAName,
+      partnerBName: state.partnerBName,
+      scenario: state.scenarioConfig as never,
+      customPrompt: state.customPrompt || undefined,
+      visualStyle: state.visualStyle || "",
       defaultPartnerAName: generationConfig.defaultPartnerAName,
       defaultPartnerBName: generationConfig.defaultPartnerBName,
-      coupleFeatureSelection: selection as never,
+      coupleFeatureSelection: state.selection as never,
       visualStyles: generationConfig.visualStyleModifiers,
       customScenarioId: config.customScenarioId as string,
     });
-    if (input) generate(input);
-  }, [
-    step,
-    isProcessing,
-    partnerA,
-    partnerB,
-    partnerAName,
-    partnerBName,
-    scenarioConfig,
-    customPrompt,
-    visualStyle,
-    selection,
-    config.steps.GENERATING,
-    config.customScenarioId,
-    generationConfig.defaultPartnerAName,
-    generationConfig.defaultPartnerBName,
-    generationConfig.visualStyleModifiers,
-    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]);
 
   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);
     },
@@ -181,19 +157,13 @@ export const useCoupleFutureFlow = <TStep, TScenarioId, TResult>(
     } else {
       actions.setStep(config.steps.PARTNER_A);
     }
-  }, [
-    actions,
-    config.steps.COUPLE_FEATURE_SELECTOR,
-    config.steps.TEXT_INPUT,
-    config.steps.PARTNER_A,
-    config.customScenarioId,
-    selectedFeature,
-    selectedScenarioId,
-    selectedScenarioData,
-  ]);
+  }, [actions, config, selectedFeature, selectedScenarioId, 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);
@@ -202,22 +172,23 @@ export const useCoupleFutureFlow = <TStep, TScenarioId, TResult>(
   );
 
   const handlePartnerABack = useCallback(() => {
-    actions.setStep(
+    const targetStep =
       selectedScenarioId === config.customScenarioId
         ? config.steps.TEXT_INPUT
-        : config.steps.SCENARIO_PREVIEW,
-    );
-  }, [
-    actions,
-    config.customScenarioId,
-    config.steps.TEXT_INPUT,
-    config.steps.SCENARIO_PREVIEW,
-    selectedScenarioId,
-  ]);
+        : config.steps.SCENARIO_PREVIEW;
+    actions.setStep(targetStep);
+  }, [actions, config, 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();
@@ -233,6 +204,12 @@ export const useCoupleFutureFlow = <TStep, TScenarioId, TResult>(
 
   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) {
@@ -241,7 +218,7 @@ export const useCoupleFutureFlow = <TStep, TScenarioId, TResult>(
         actions.startGeneration();
       }
     },
-    [actions, config.customScenarioId, config.steps.PARTNER_A, selectedScenarioId],
+    [actions, config, selectedScenarioId],
   );
 
   const handleMagicPromptBack = useCallback(

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

@@ -14,6 +14,8 @@ 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;
@@ -24,33 +26,36 @@ export interface CoupleFutureConfig<TResult> {
   alertMessages: AlertMessages;
 }
 
-export const useCoupleFutureGeneration = <TResult>(
-  config: CoupleFutureConfig<TResult>,
-) => {
-  const {
-    userId,
-    processResult,
-    buildCreation,
-    onCreditsExhausted,
-    onSuccess,
-    onError,
-    alertMessages,
-  } = config;
+export const useCoupleFutureGeneration = <TResult>(config: CoupleFutureConfig<TResult>) => {
+  const { userId, processResult, buildCreation, onCreditsExhausted, onSuccess, onError, alertMessages } = config;
 
-  const repository = useMemo(
-    () => createCreationsRepository("creations"),
-    [],
-  );
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[CoupleFutureGeneration] Hook initialized:", {
+      userId,
+      hasBuildCreation: !!buildCreation,
+      hasOnSuccess: !!onSuccess,
+    });
+  }
 
-  // Store input for use in save callback
+  const repository = useMemo(() => createCreationsRepository("creations"), []);
   const lastInputRef = useRef<CoupleFutureInput | null>(null);
 
   const strategy: GenerationStrategy<CoupleFutureInput, TResult> = useMemo(
     () => ({
       execute: async (input, onProgress) => {
-        // Store input for save callback
+        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,
@@ -60,20 +65,44 @@ export const useCoupleFutureGeneration = <TResult>(
           { 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");
+                }
               }
             }
           }
@@ -84,16 +113,29 @@ export const useCoupleFutureGeneration = <TResult>(
 
   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: onSuccess as (result: unknown) => void,
+    onSuccess: handleSuccess,
     onError: handleError,
   });
 };

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

@@ -18,6 +18,8 @@ import type {
   UseGenerationOrchestratorReturn,
 } from "./types";
 
+declare const __DEV__: boolean;
+
 const INITIAL_STATE = {
   status: "idle" as const,
   isGenerating: false,
@@ -30,53 +32,109 @@ 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 } = config;
+
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[Orchestrator] Hook initialized:", { userId, hasAlertMessages: !!alertMessages });
+  }
 
   const [state, setState] = useState<GenerationState<TResult>>(INITIAL_STATE);
   const isGeneratingRef = useRef(false);
   const offlineStore = useOfflineStore();
   const { showError, showSuccess } = useAlert();
-  const { checkCredits, deductCredit } = useDeductCredit({
-    userId,
-    onCreditsExhausted,
-  });
+  const { checkCredits, deductCredit } = useDeductCredit({ userId, onCreditsExhausted });
 
   const generate = useCallback(
     async (input: TInput) => {
-      if (isGeneratingRef.current) return;
+      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) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[Orchestrator] ⚠️ Already generating, skipping");
+        }
+        return;
+      }
 
       isGeneratingRef.current = true;
       setState({ ...INITIAL_STATE, status: "checking", isGenerating: true });
 
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[Orchestrator] State set to: checking, isGenerating: true");
+      }
+
       try {
+        // 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
         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) {
-          // Open paywall instead of showing error
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.log("[Orchestrator] ❌ No credits, opening paywall");
+          }
           isGeneratingRef.current = false;
           setState(INITIAL_STATE);
           onCreditsExhausted?.();
           return;
         }
 
+        // Start generation
         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");
+          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);
+            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",
@@ -87,8 +145,13 @@ export const useGenerationOrchestrator = <TInput, TResult>(
 
         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,
@@ -97,6 +160,10 @@ export const useGenerationOrchestrator = <TInput, TResult>(
           error: null,
         });
 
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[Orchestrator] 🎉 Generation SUCCESS");
+        }
+
         if (alertMessages.success) {
           void showSuccess("Success", alertMessages.success);
         }
@@ -105,6 +172,10 @@ export const useGenerationOrchestrator = <TInput, TResult>(
       } catch (err) {
         const error = parseError(err);
 
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[Orchestrator] ❌ Generation ERROR:", error);
+        }
+
         setState({
           status: "error",
           isGenerating: false,
@@ -117,6 +188,9 @@ export const useGenerationOrchestrator = <TInput, TResult>(
         onError?.(error);
       } finally {
         isGeneratingRef.current = false;
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[Orchestrator] 🏁 generate() finished, isGeneratingRef reset to false");
+        }
       }
     },
     [
@@ -134,6 +208,9 @@ export const useGenerationOrchestrator = <TInput, TResult>(
   );
 
   const reset = useCallback(() => {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[Orchestrator] 🔄 reset() called");
+    }
     setState(INITIAL_STATE);
     isGeneratingRef.current = false;
   }, []);