@umituz/react-native-ai-generation-content 1.26.67 → 1.26.69

package/package.json

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

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

@@ -15,6 +15,7 @@ import {
   MODEL_INPUT_DEFAULTS,
 } from "./wizard-strategy.constants";
 import { buildFacePreservationPrompt } from "../../../../prompts/infrastructure/builders/face-preservation-builder";
+import { buildInteractionStylePrompt, type InteractionStyle } from "../../../../prompts/infrastructure/builders/interaction-style-builder";
 
 declare const __DEV__: boolean;
 
@@ -25,6 +26,8 @@ declare const __DEV__: boolean;
 export interface ImageGenerationInput {
   readonly photos: readonly string[];
   readonly prompt: string;
+  /** Optional interaction style for multi-person images */
+  readonly interactionStyle?: InteractionStyle;
 }
 
 export interface ImageGenerationResult {
@@ -88,13 +91,26 @@ async function executeImageGeneration(
     }
 
     // Build face preservation prompt dynamically based on number of people
-    const enhancedPrompt = buildFacePreservationPrompt({
+    const facePrompt = buildFacePreservationPrompt({
       scenarioPrompt: input.prompt,
       personCount: imageUrls.length,
     });
 
+    // Build interaction style prompt for multi-person images
+    const interactionPrompt = buildInteractionStylePrompt({
+      style: input.interactionStyle ?? "romantic",
+      personCount: imageUrls.length,
+    });
+
+    // Combine prompts: face preservation + interaction style
+    const enhancedPrompt = interactionPrompt
+      ? `${facePrompt}\n\n${interactionPrompt}`
+      : facePrompt;
+
     if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[ImageStrategy] Face preservation prompt for", imageUrls.length, "person(s)");
+      console.log("[ImageStrategy] Prompt built for", imageUrls.length, "person(s)", {
+        interactionStyle: input.interactionStyle ?? "romantic",
+      });
     }
 
     const modelInput = {
@@ -164,7 +180,10 @@ export async function buildImageInput(
     prompt = `${prompt}. ${styleEnhancements.join(", ")}`;
   }
 
-  return { photos, prompt };
+  // Get interaction style from scenario (default: romantic for couple apps)
+  const interactionStyle = (scenario.interactionStyle as InteractionStyle) ?? "romantic";
+
+  return { photos, prompt, interactionStyle };
 }
 
 // ============================================================================

package/src/domains/generation/wizard/presentation/components/GenericWizardFlow.tsx

@@ -1,15 +1,6 @@
 /**
  * Generic Wizard Flow Component
- * ONE wizard to rule them all!
- *
- * Works for:
- * - Couple features (romantic-kiss, ai-hug, etc.)
- * - Face swap
- * - Image-to-video
- * - Text-to-video
- * - ANY future feature!
- *
- * NO feature-specific code here - everything driven by configuration!
+ * Config-driven wizard for AI generation features
  */
 
 import React, { useMemo, useCallback, useEffect, useRef, useState } from "react";
@@ -28,6 +19,8 @@ import { validateScenario } from "../utilities/validateScenario";
 import { WizardStepRenderer } from "./WizardStepRenderer";
 import { StarRatingPicker } from "../../../../result-preview/presentation/components/StarRatingPicker";
 
+declare const __DEV__: boolean;
+
 export interface GenericWizardFlowProps {
   readonly featureConfig: WizardFeatureConfig;
   readonly scenario?: WizardScenarioData;
@@ -38,9 +31,6 @@ export interface GenericWizardFlowProps {
   readonly onGenerationComplete?: (result: unknown) => void;
   readonly onGenerationError?: (error: string) => void;
   readonly onCreditsExhausted?: () => void;
-  /** Auth check - orchestrator will check auth BEFORE credits */
-  readonly isAuthenticated?: () => boolean;
-  readonly onAuthRequired?: () => void;
   readonly onRate?: (creationId: string, rating: number, description: string) => Promise<boolean>;
   readonly onBack?: () => void;
   readonly onTryAgain?: () => void;
@@ -61,8 +51,6 @@ export const GenericWizardFlow: React.FC<GenericWizardFlowProps> = ({
   onGenerationComplete,
   onGenerationError,
   onCreditsExhausted,
-  isAuthenticated,
-  onAuthRequired,
   onRate,
   onBack,
   onTryAgain,
@@ -130,8 +118,6 @@ export const GenericWizardFlow: React.FC<GenericWizardFlowProps> = ({
     onError: onGenerationError,
     onProgressChange: handleProgressChange,
     onCreditsExhausted,
-    isAuthenticated,
-    onAuthRequired,
   });
 
   useEffect(() => {
@@ -174,9 +160,7 @@ export const GenericWizardFlow: React.FC<GenericWizardFlowProps> = ({
   const handleSubmitRating = useCallback(async (rating: number, description: string) => {
     if (!currentCreation?.id || !onRate) return;
     const success = await onRate(currentCreation.id, rating, description);
-    if (success) {
-      setHasRated(true);
-    }
+    if (success) setHasRated(true);
     setShowRatingPicker(false);
   }, [currentCreation, onRate]);
 

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

@@ -10,17 +10,13 @@ import { createWizardStrategy, buildWizardInput } from "../../infrastructure/str
 
 declare const __DEV__: boolean;
 
-// ============================================================================
-// Types
-// ============================================================================
-
 export type WizardOutputType = "image" | "video";
 
 export interface WizardScenarioData {
   readonly id: string;
   readonly aiPrompt: string;
   readonly outputType?: WizardOutputType;
-  readonly model?: string; // AI model from app config
+  readonly model?: string;
   readonly title?: string;
   readonly description?: string;
   [key: string]: unknown;
@@ -36,9 +32,6 @@ export interface UseWizardGenerationProps {
   readonly onError?: (error: string) => void;
   readonly onProgressChange?: (progress: number) => void;
   readonly onCreditsExhausted?: () => void;
-  /** Auth check - if user not authenticated, onAuthRequired will be called */
-  readonly isAuthenticated?: () => boolean;
-  readonly onAuthRequired?: () => void;
 }
 
 export interface UseWizardGenerationReturn {
@@ -46,10 +39,6 @@ export interface UseWizardGenerationReturn {
   readonly progress: number;
 }
 
-// ============================================================================
-// Hook
-// ============================================================================
-
 export const useWizardGeneration = (
   props: UseWizardGenerationProps,
 ): UseWizardGenerationReturn => {
@@ -63,24 +52,19 @@ export const useWizardGeneration = (
     onError,
     onProgressChange,
     onCreditsExhausted,
-    isAuthenticated,
-    onAuthRequired,
   } = props;
 
   const hasStarted = useRef(false);
 
-  // Log output type on mount
   useEffect(() => {
     if (typeof __DEV__ !== "undefined" && __DEV__) {
       console.log("[useWizardGeneration] Initialized", {
         scenarioId: scenario.id,
         outputType: scenario.outputType || "video",
-        hasOutputType: !!scenario.outputType,
       });
     }
   }, [scenario.id, scenario.outputType]);
 
-  // Create strategy using factory
   const strategy = useMemo(() => {
     return createWizardStrategy({
       scenario,
@@ -89,7 +73,6 @@ export const useWizardGeneration = (
     });
   }, [scenario, wizardData]);
 
-  // Use orchestrator with strategy
   const { generate, isGenerating, progress } = useGenerationOrchestrator(
     strategy,
     {
@@ -102,10 +85,6 @@ export const useWizardGeneration = (
         unknown: "An error occurred",
       },
       onCreditsExhausted,
-      // Auth config - check auth BEFORE credits
-      auth: isAuthenticated && onAuthRequired
-        ? { isAuthenticated, onAuthRequired }
-        : undefined,
       onSuccess: (result) => {
         if (typeof __DEV__ !== "undefined" && __DEV__) {
           console.log("[useWizardGeneration] Success");
@@ -121,14 +100,10 @@ export const useWizardGeneration = (
     },
   );
 
-  // Sync progress to parent
   useEffect(() => {
-    if (onProgressChange) {
-      onProgressChange(progress);
-    }
+    if (onProgressChange) onProgressChange(progress);
   }, [progress, onProgressChange]);
 
-  // Auto-start generation when entering generating step
   useEffect(() => {
     if (isGeneratingStep && !hasStarted.current && !isGenerating) {
       if (typeof __DEV__ !== "undefined" && __DEV__) {
@@ -138,37 +113,30 @@ export const useWizardGeneration = (
         });
       }
 
-      // Build input and start generation
+      hasStarted.current = true;
+
       buildWizardInput(wizardData, scenario)
         .then((input) => {
           if (!input) {
-            const error = "Failed to build generation input";
-            if (typeof __DEV__ !== "undefined" && __DEV__) {
-              console.error("[useWizardGeneration]", error);
-            }
-            onError?.(error);
+            hasStarted.current = false;
+            onError?.("Failed to build generation input");
             return;
           }
-
           generate(input);
-          hasStarted.current = true;
         })
         .catch((error) => {
           if (typeof __DEV__ !== "undefined" && __DEV__) {
             console.error("[useWizardGeneration] Input build error:", error);
           }
+          hasStarted.current = false;
           onError?.(error.message || "Failed to prepare generation");
         });
     }
 
-    // Reset hasStarted when leaving generating step
     if (!isGeneratingStep && hasStarted.current) {
       hasStarted.current = false;
     }
   }, [isGeneratingStep, scenario, wizardData, isGenerating, generate, onError]);
 
-  return {
-    isGenerating,
-    progress,
-  };
+  return { isGenerating, progress };
 };

package/src/domains/prompts/index.ts

@@ -102,3 +102,11 @@ export {
   buildMinimalFacePreservationPrompt,
 } from './infrastructure/builders/face-preservation-builder';
 export type { FacePreservationOptions } from './infrastructure/builders/face-preservation-builder';
+
+export {
+  buildInteractionStylePrompt,
+  buildMinimalInteractionStylePrompt,
+  getInteractionRules,
+  getInteractionForbidden,
+} from './infrastructure/builders/interaction-style-builder';
+export type { InteractionStyle, InteractionStyleOptions } from './infrastructure/builders/interaction-style-builder';

package/src/domains/prompts/infrastructure/builders/face-preservation-builder.ts

@@ -1,29 +1,25 @@
 /**
  * Face Preservation Prompt Builder
  * Dynamic prompt builder for AI image generation with strict face identity preservation
- * Supports any number of people (1, 2, 3, N) and interaction styles
+ * Supports any number of people (1, 2, 3, N)
  *
- * Based on best practices:
+ * SINGLE RESPONSIBILITY: Face identity preservation ONLY
  * - Face identity lock techniques
  * - @imageN reference anchors
- * - Interaction style rules (romantic, friendly, etc.)
  * - Explicit preservation and negative constraints
+ *
+ * For interaction/positioning rules, use interaction-style-builder.ts
  */
 
 // =============================================================================
 // Types
 // =============================================================================
 
-/** Interaction style between people in the image */
-export type InteractionStyle = "romantic" | "friendly" | "professional" | "neutral";
-
 export interface FacePreservationOptions {
   /** The scenario/scene description */
   scenarioPrompt: string;
   /** Number of people in the generation */
   personCount: number;
-  /** Interaction style between people (default: neutral) */
-  interactionStyle?: InteractionStyle;
   /** Optional custom preservation rules from main app */
   customRules?: string[];
   /** Optional custom forbidden actions from main app */
@@ -49,48 +45,6 @@ const FORBIDDEN_ACTIONS = [
   "Do NOT change eye color or shape",
 ] as const;
 
-/** Interaction style rules - what TO DO for each style */
-const INTERACTION_RULES: Record<InteractionStyle, readonly string[]> = {
-  romantic: [
-    "Close physical proximity - touching, holding hands, arms around each other",
-    "Warm, genuine, loving smiles showing happiness",
-    "Affectionate eye contact or looking at camera together happily",
-    "Natural romantic body language - leaning into each other",
-    "Intimate connection visible between the two people",
-  ],
-  friendly: [
-    "Casual comfortable proximity",
-    "Genuine friendly smiles",
-    "Relaxed natural poses",
-    "Warm friendly body language",
-  ],
-  professional: [
-    "Appropriate professional distance",
-    "Confident pleasant expressions",
-    "Professional posture and positioning",
-  ],
-  neutral: [],
-};
-
-/** Interaction style forbidden - what NOT to do for each style */
-const INTERACTION_FORBIDDEN: Record<InteractionStyle, readonly string[]> = {
-  romantic: [
-    "Do NOT position people far apart or distant from each other",
-    "Do NOT use cold, serious, stern, or angry expressions",
-    "Do NOT create stiff, awkward, or unnatural poses",
-    "Do NOT have people looking away from each other coldly",
-    "Do NOT show disconnection or emotional distance between people",
-  ],
-  friendly: [
-    "Do NOT use cold or unfriendly expressions",
-    "Do NOT create awkward distancing",
-  ],
-  professional: [
-    "Do NOT use overly casual or intimate positioning",
-  ],
-  neutral: [],
-};
-
 // =============================================================================
 // Builder Functions
 // =============================================================================

package/src/domains/prompts/infrastructure/builders/interaction-style-builder.ts

@@ -0,0 +1,163 @@
+/**
+ * Interaction Style Prompt Builder
+ * Dynamic prompt builder for AI image generation with interaction/positioning rules
+ * Supports any number of people (1, 2, 3, N) and interaction styles
+ *
+ * Separate from face preservation - this handles:
+ * - Body positioning and proximity
+ * - Emotional expressions
+ * - Body language and poses
+ * - Interaction rules between people
+ */
+
+// =============================================================================
+// Types
+// =============================================================================
+
+/** Interaction style between people in the image */
+export type InteractionStyle =
+  | "romantic"
+  | "friendly"
+  | "professional"
+  | "neutral";
+
+export interface InteractionStyleOptions {
+  /** Interaction style between people */
+  style: InteractionStyle;
+  /** Number of people in the generation */
+  personCount: number;
+  /** Optional custom rules from main app */
+  customRules?: string[];
+  /** Optional custom forbidden actions from main app */
+  customForbidden?: string[];
+}
+
+// =============================================================================
+// Constants
+// =============================================================================
+
+/** Interaction style rules - what TO DO for each style */
+const INTERACTION_RULES: Record<InteractionStyle, readonly string[]> = {
+  romantic: [
+    "Close physical proximity - touching, holding hands, arms around each other",
+    "Warm, genuine, loving smiles showing happiness",
+    "Affectionate eye contact or looking at camera together happily",
+    "Natural romantic body language - leaning into each other",
+    "Intimate connection visible between the two people",
+    "Comfortable and relaxed together, natural poses",
+  ],
+  friendly: [
+    "Casual comfortable proximity",
+    "Genuine friendly smiles",
+    "Relaxed natural poses",
+    "Warm friendly body language",
+    "Standing or sitting close to each other comfortably",
+  ],
+  professional: [
+    "Appropriate professional distance",
+    "Confident pleasant expressions",
+    "Professional posture and positioning",
+    "Formal but friendly body language",
+  ],
+  neutral: [],
+};
+
+/** Interaction style forbidden - what NOT to do for each style */
+const INTERACTION_FORBIDDEN: Record<InteractionStyle, readonly string[]> = {
+  romantic: [
+    "Do NOT position people far apart or distant from each other",
+    "Do NOT use cold, serious, stern, or angry expressions",
+    "Do NOT create stiff, awkward, or unnatural poses",
+    "Do NOT have people looking away from each other coldly",
+    "Do NOT show disconnection or emotional distance between people",
+    "Do NOT make poses look forced or uncomfortable",
+  ],
+  friendly: [
+    "Do NOT use cold or unfriendly expressions",
+    "Do NOT create awkward distancing",
+    "Do NOT make poses stiff or formal",
+  ],
+  professional: [
+    "Do NOT use overly casual or intimate positioning",
+    "Do NOT use sloppy or unprofessional poses",
+  ],
+  neutral: [],
+};
+
+// =============================================================================
+// Builder Functions
+// =============================================================================
+
+/**
+ * Get interaction rules for a given style
+ */
+export function getInteractionRules(style: InteractionStyle): readonly string[] {
+  return INTERACTION_RULES[style];
+}
+
+/**
+ * Get forbidden actions for a given style
+ */
+export function getInteractionForbidden(style: InteractionStyle): readonly string[] {
+  return INTERACTION_FORBIDDEN[style];
+}
+
+/**
+ * Build interaction style prompt section
+ * Can be appended to any prompt (face preservation, scenario, etc.)
+ */
+export function buildInteractionStylePrompt(
+  options: InteractionStyleOptions,
+): string {
+  const { style, personCount, customRules, customForbidden } = options;
+
+  // No rules for neutral or single person
+  if (style === "neutral" || personCount < 2) {
+    return "";
+  }
+
+  const rules = [...INTERACTION_RULES[style], ...(customRules ?? [])];
+  const forbidden = [...INTERACTION_FORBIDDEN[style], ...(customForbidden ?? [])];
+
+  if (rules.length === 0 && forbidden.length === 0) {
+    return "";
+  }
+
+  const sections: string[] = [];
+
+  sections.push(`INTERACTION STYLE: ${style.toUpperCase()}`);
+
+  if (rules.length > 0) {
+    sections.push(`POSITIONING RULES:\n${rules.map((r) => `- ${r}`).join("\n")}`);
+  }
+
+  if (forbidden.length > 0) {
+    sections.push(
+      `POSITIONING FORBIDDEN:\n${forbidden.map((f) => `- ${f}`).join("\n")}`,
+    );
+  }
+
+  return sections.join("\n\n");
+}
+
+/**
+ * Build a minimal interaction style prompt (for API character limits)
+ */
+export function buildMinimalInteractionStylePrompt(
+  options: InteractionStyleOptions,
+): string {
+  const { style, personCount } = options;
+
+  if (style === "neutral" || personCount < 2) {
+    return "";
+  }
+
+  const styleDescriptions: Record<InteractionStyle, string> = {
+    romantic: "close, touching, warm smiles, loving connection",
+    friendly: "casual proximity, friendly smiles, relaxed poses",
+    professional: "appropriate distance, confident expressions",
+    neutral: "",
+  };
+
+  return `STYLE: ${style} - ${styleDescriptions[style]}`;
+}

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

@@ -1,13 +1,14 @@
 /**
  * Generation Orchestrator
- * Feature-agnostic hook for AI generation with centralized:
- * - Auth checking (optional)
+ * Feature-agnostic hook for AI generation with:
+ * - Network check (via design system's useOfflineStore)
  * - Content moderation (optional)
- * - Credit management
- * - Error handling
- * - Alert display
+ * - Credit management (via subscription package)
+ * - Error handling & alerts
  * - Progress tracking
- * - Lifecycle management (navigation, cleanup)
+ * - Lifecycle management
+ *
+ * NOTE: Auth is handled by useFeatureGate before generation starts
  */
 
 import { useState, useCallback, useRef, useEffect } from "react";
@@ -45,7 +46,6 @@ export const useGenerationOrchestrator = <TInput, TResult>(
     onCreditsExhausted,
     onSuccess,
     onError,
-    auth,
     moderation,
     credits,
     lifecycle,
@@ -54,7 +54,6 @@ export const useGenerationOrchestrator = <TInput, TResult>(
   if (typeof __DEV__ !== "undefined" && __DEV__) {
     console.log("[Orchestrator] 🎬 Hook initialized:", {
       userId,
-      hasAuth: !!auth,
       hasModeration: !!moderation,
       hasCreditsCallbacks: !!credits,
       hasLifecycle: !!lifecycle,
@@ -72,84 +71,48 @@ export const useGenerationOrchestrator = <TInput, TResult>(
   const { showError, showSuccess } = useAlert();
   const creditHook = useDeductCredit({ userId, onCreditsExhausted });
 
-  // Wrap credit hook to match expected interface
   const defaultCredits = {
     checkCredits: creditHook.checkCredits,
     deductCredit: async (amount: number): Promise<boolean> => {
       return creditHook.deductCredit(amount);
-    }
+    },
   };
 
-  // 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;
 
-  // Cleanup on unmount
   useEffect(() => {
     isMountedRef.current = true;
     return () => {
       isMountedRef.current = false;
-      if (completeTimeoutRef.current) {
-        clearTimeout(completeTimeoutRef.current);
-        completeTimeoutRef.current = null;
-      }
-      if (resetTimeoutRef.current) {
-        clearTimeout(resetTimeoutRef.current);
-        resetTimeoutRef.current = null;
-      }
+      if (completeTimeoutRef.current) clearTimeout(completeTimeoutRef.current);
+      if (resetTimeoutRef.current) clearTimeout(resetTimeoutRef.current);
       if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[Orchestrator] 🧹 Cleanup: cleared all timeouts");
+        console.log("[Orchestrator] 🧹 Cleanup");
       }
     };
   }, []);
 
-  // Handle lifecycle completion
   const handleLifecycleComplete = useCallback(
     (status: "success" | "error", result?: TResult, error?: GenerationError) => {
       if (!lifecycle?.onComplete) return;
 
       const delay = lifecycle.completeDelay ?? DEFAULT_COMPLETE_DELAY;
 
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[Orchestrator] ⏱️ Scheduling lifecycle.onComplete:", { status, delay });
-      }
-
-      // Clear any existing timeout
-      if (completeTimeoutRef.current) {
-        clearTimeout(completeTimeoutRef.current);
-      }
+      if (completeTimeoutRef.current) clearTimeout(completeTimeoutRef.current);
 
       completeTimeoutRef.current = setTimeout(() => {
-        if (!isMountedRef.current) {
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.log("[Orchestrator] ⚠️ Component unmounted, skipping onComplete");
-          }
-          return;
-        }
-
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[Orchestrator] 📍 Calling lifecycle.onComplete:", status);
-        }
+        if (!isMountedRef.current) return;
 
         lifecycle.onComplete?.(status, result, error);
 
-        // Auto-reset if configured
         if (lifecycle.autoReset) {
           const resetDelay = lifecycle.resetDelay ?? DEFAULT_RESET_DELAY;
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.log("[Orchestrator] 🔄 Scheduling auto-reset in:", resetDelay);
-          }
-
-          if (resetTimeoutRef.current) {
-            clearTimeout(resetTimeoutRef.current);
-          }
+          if (resetTimeoutRef.current) clearTimeout(resetTimeoutRef.current);
 
           resetTimeoutRef.current = setTimeout(() => {
             if (isMountedRef.current) {
-              if (typeof __DEV__ !== "undefined" && __DEV__) {
-                console.log("[Orchestrator] 🔄 Auto-reset triggered");
-              }
               setState(INITIAL_STATE);
               isGeneratingRef.current = false;
             }
@@ -160,74 +123,41 @@ export const useGenerationOrchestrator = <TInput, TResult>(
     [lifecycle],
   );
 
-  // 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()");
+        console.log("[Orchestrator] 🎨 Starting generation");
       }
 
       const result = await strategy.execute(input, (progress) => {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[Orchestrator] 📊 Progress update:", progress);
-        }
-        if (isMountedRef.current) {
-          setState((prev) => ({ ...prev, progress }));
-        }
+        if (isMountedRef.current) setState((prev) => ({ ...prev, progress }));
       });
 
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[Orchestrator] ✅ strategy.execute() completed");
-      }
+      if (isMountedRef.current) setState((prev) => ({ ...prev, progress: 70 }));
 
-      if (isMountedRef.current) {
-        setState((prev) => ({ ...prev, progress: 70 }));
-      }
-
-      // Save result
       if (strategy.save && userId) {
-        if (isMountedRef.current) {
-          setState((prev) => ({ ...prev, status: "saving" }));
-        }
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[Orchestrator] 💾 Saving result...");
-        }
+        if (isMountedRef.current) setState((prev) => ({ ...prev, status: "saving" }));
         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);
+          throw createGenerationError(
+            "save",
+            "Failed to save",
+            saveErr instanceof Error ? saveErr : undefined,
+          );
         }
       }
 
-      if (isMountedRef.current) {
-        setState((prev) => ({ ...prev, progress: 90 }));
-      }
+      if (isMountedRef.current) setState((prev) => ({ ...prev, progress: 90 }));
 
-      // Deduct credit
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[Orchestrator] 💳 Deducting credit:", creditCost);
-      }
       const creditDeducted = await deductCredit(creditCost);
       if (!creditDeducted) {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[Orchestrator] ❌ Credit deduction failed");
-        }
         throw createGenerationError("credits", "Failed to deduct credits");
       }
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[Orchestrator] ✅ Credit deducted successfully");
-      }
 
-      // Success
       if (isMountedRef.current) {
         setState({ status: "success", isGenerating: false, progress: 100, result, error: null });
       }
@@ -236,14 +166,8 @@ export const useGenerationOrchestrator = <TInput, TResult>(
         console.log("[Orchestrator] 🎉 Generation SUCCESS");
       }
 
-      if (alertMessages.success) {
-        void showSuccess("Success", alertMessages.success);
-      }
-
-      // Call onSuccess callback
+      if (alertMessages.success) void showSuccess("Success", alertMessages.success);
       onSuccess?.(result);
-
-      // Handle lifecycle completion
       handleLifecycleComplete("success", result);
 
       return result;
@@ -255,105 +179,41 @@ export const useGenerationOrchestrator = <TInput, TResult>(
     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));
       }
 
-      if (isGeneratingRef.current) {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[Orchestrator] ⚠️ Already generating, skipping");
-        }
-        return;
-      }
+      if (isGeneratingRef.current) return;
 
       isGeneratingRef.current = true;
       pendingInputRef.current = input;
       setState({ ...INITIAL_STATE, status: "checking", isGenerating: true });
 
       try {
-        // 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");
-        }
 
-        // 3. Credit check
         const creditCost = strategy.getCreditCost();
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[Orchestrator] 💳 Credit cost:", creditCost);
-        }
-
         const hasCredits = await checkCredits(creditCost);
         if (!hasCredits) {
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.log("[Orchestrator] ❌ No credits, opening paywall");
-          }
           isGeneratingRef.current = false;
           setState(INITIAL_STATE);
           handleCreditsExhausted?.();
           return;
         }
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[Orchestrator] ✅ Credit check passed");
-        }
 
-        // 4. Content moderation (optional)
         if (moderation) {
           setState((prev) => ({ ...prev, status: "moderating" }));
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.log("[Orchestrator] 🛡️ Checking content moderation...");
-          }
-
           const moderationResult = await moderation.checkContent(input);
-          if (!moderationResult.allowed && moderationResult.warnings.length > 0) {
-            if (typeof __DEV__ !== "undefined" && __DEV__) {
-              console.log("[Orchestrator] ⚠️ Moderation warnings:", moderationResult.warnings);
-            }
 
+          if (!moderationResult.allowed && moderationResult.warnings.length > 0) {
             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;
-                  if (isMountedRef.current) {
-                    setState(INITIAL_STATE);
-                  }
+                  if (isMountedRef.current) 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) {
@@ -369,41 +229,30 @@ export const useGenerationOrchestrator = <TInput, TResult>(
                   }
                 },
               );
-              return; // Exit here - callback will handle the rest
+              return;
             }
-            // No warning handler - block the request
             throw createGenerationError("policy", "Content policy violation");
           }
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            console.log("[Orchestrator] ✅ Moderation passed");
-          }
         }
 
-        // 5. Execute generation
         return await executeGeneration(input);
       } catch (err) {
         const error = parseError(err);
         if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[Orchestrator] ❌ Generation ERROR:", error);
+          console.log("[Orchestrator] ❌ Error:", error);
         }
         if (isMountedRef.current) {
           setState({ status: "error", isGenerating: false, progress: 0, result: null, error });
         }
         void showError("Error", getAlertMessage(error, alertMessages));
         onError?.(error);
-
-        // Handle lifecycle completion for errors
         handleLifecycleComplete("error", undefined, error);
-        throw error; // Re-throw so caller knows it failed
+        throw error;
       } finally {
         isGeneratingRef.current = false;
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[Orchestrator] 🏁 generate() finished");
-        }
       }
     },
     [
-      auth,
       moderation,
       strategy,
       alertMessages,
@@ -418,9 +267,6 @@ export const useGenerationOrchestrator = <TInput, TResult>(
   );
 
   const reset = useCallback(() => {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[Orchestrator] 🔄 reset() called");
-    }
     setState(INITIAL_STATE);
     isGeneratingRef.current = false;
   }, []);

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

@@ -6,7 +6,6 @@
 export type OrchestratorStatus =
   | "idle"
   | "checking"
-  | "authenticating"
   | "moderating"
   | "generating"
   | "saving"
@@ -14,14 +13,8 @@ export type OrchestratorStatus =
   | "error";
 
 export interface GenerationStrategy<TInput, TResult> {
-  /** Execute the generation */
-  execute: (
-    input: TInput,
-    onProgress?: (progress: number) => void,
-  ) => Promise<TResult>;
-  /** Credit cost for this generation */
+  execute: (input: TInput, onProgress?: (progress: number) => void) => Promise<TResult>;
   getCreditCost: () => number;
-  /** Optional: Save result to storage */
   save?: (result: TResult, userId: string) => Promise<void>;
 }
 
@@ -32,61 +25,28 @@ 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;
+  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 - returns true if successful */
   deductCredits: (cost: number) => Promise<boolean>;
-  /** Called when credits are exhausted */
   onCreditsExhausted?: () => void;
 }
 
-/**
- * Lifecycle configuration for generation flow
- * Centralizes post-generation behavior (navigation, cleanup, etc.)
- */
 export interface LifecycleConfig {
-  /** Callback after generation completes (success or error) - for navigation, state updates */
-  onComplete?: (
-    status: "success" | "error",
-    result?: unknown,
-    error?: GenerationError,
-  ) => void;
-  /** Delay before calling onComplete (ms) - allows UI to show success state */
+  onComplete?: (status: "success" | "error", result?: unknown, error?: GenerationError) => void;
   completeDelay?: number;
-  /** Auto-reset state after completion */
   autoReset?: boolean;
-  /** Delay before auto-reset (ms) */
   resetDelay?: number;
 }
 
@@ -96,13 +56,8 @@ 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;
-  /** Lifecycle configuration for post-generation behavior */
   lifecycle?: LifecycleConfig;
 }
 
@@ -120,12 +75,7 @@ export interface GenerationError {
   originalError?: Error;
 }
 
-export type GenerationErrorType =
-  | "network"
-  | "credits"
-  | "policy"
-  | "save"
-  | "unknown";
+export type GenerationErrorType = "network" | "credits" | "policy" | "save" | "unknown";
 
 export interface UseGenerationOrchestratorReturn<TInput, TResult> {
   generate: (input: TInput) => Promise<TResult | void>;
@@ -137,22 +87,15 @@ export interface UseGenerationOrchestratorReturn<TInput, TResult> {
   error: GenerationError | null;
 }
 
-/**
- * Generation error UI configuration
- */
 export interface GenerationErrorConfig {
   readonly showCreditInfo?: boolean;
   readonly iconName?: string;
   readonly iconSize?: number;
 }
 
-/**
- * Generation error UI translations
- */
 export interface GenerationErrorTranslations {
   readonly title: string;
   readonly tryAgain: string;
   readonly chooseAnother: string;
   readonly noCreditCharged: string;
 }
-