@umituz/react-native-ai-generation-content 1.37.12 → 1.37.14

package/package.json

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

@@ -3,8 +3,7 @@
  * Handles the actual image generation execution
  */
 
-import { buildFacePreservationPrompt } from "../../../../prompts/infrastructure/builders/face-preservation-builder";
-import { buildInteractionStylePrompt } from "../../../../prompts/infrastructure/builders/interaction-style-builder";
+import { buildUnifiedPrompt } from "./shared/unified-prompt-builder";
 import type { WizardImageInput } from "./image-generation.types";
 import {
   GENERATION_TIMEOUT_MS,
@@ -21,31 +20,19 @@ interface ExecutionResult {
   error?: string;
 }
 
-/**
- * Formats base64 string with proper data URI prefix
- */
 function formatBase64(base64: string): string {
   return base64.startsWith("data:") ? base64 : `${BASE64_IMAGE_PREFIX}${base64}`;
 }
 
-/**
- * Builds the final prompt based on input type (photo-based or text-to-image)
- */
 function buildFinalPrompt(input: WizardImageInput, imageUrls: string[]): string {
   const hasPhotos = imageUrls.length > 0;
 
   if (hasPhotos) {
-    const facePrompt = buildFacePreservationPrompt({
-      scenarioPrompt: input.prompt,
-      personCount: imageUrls.length,
+    return buildUnifiedPrompt({
+      basePrompt: input.prompt,
+      photoCount: imageUrls.length,
+      interactionStyle: input.interactionStyle,
     });
-
-    const interactionPrompt = buildInteractionStylePrompt({
-      style: input.interactionStyle ?? "romantic",
-      personCount: imageUrls.length,
-    });
-
-    return interactionPrompt ? `${facePrompt}\n\n${interactionPrompt}` : facePrompt;
   }
 
   // Text-to-image with optional style
@@ -56,9 +43,6 @@ function buildFinalPrompt(input: WizardImageInput, imageUrls: string[]): string
   return input.prompt;
 }
 
-/**
- * Executes image generation using the AI provider
- */
 export async function executeImageGeneration(
   input: WizardImageInput,
   model: string,

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

@@ -80,11 +80,14 @@ function applyStyleEnhancements(prompt: string, wizardData: Record<string, unkno
 // Strategy Factory
 // ============================================================================
 
+declare const __DEV__: boolean;
+
 export function createImageStrategy(options: CreateImageStrategyOptions): WizardStrategy {
   const { scenario, collectionName = "creations" } = options;
   const repository = createCreationsRepository(collectionName);
 
   let lastInputRef: WizardImageInput | null = null;
+  let processingCreationId: string | null = null;
 
   return {
     execute: async (input: unknown) => {
@@ -106,28 +109,63 @@ export function createImageStrategy(options: CreateImageStrategyOptions): Wizard
 
     getCreditCost: () => 1,
 
-    save: async (result: unknown, uid) => {
-      const input = lastInputRef;
-      const imageResult = result as { imageUrl?: string };
-      if (!input || !scenario?.id || !imageResult.imageUrl) return;
+    saveAsProcessing: async (uid: string, input: unknown) => {
+      const imageInput = input as WizardImageInput;
+      const creationId = `${scenario.id}_${Date.now()}`;
+      processingCreationId = creationId;
 
-      const creation = {
-        id: `${scenario.id}_${Date.now()}`,
-        uri: imageResult.imageUrl,
+      await repository.create(uid, {
+        id: creationId,
+        uri: "",
         type: scenario.id,
-        prompt: input.prompt,
-        status: "completed" as const,
+        prompt: imageInput.prompt,
+        status: "processing" as const,
         createdAt: new Date(),
         isShared: false,
         isFavorite: false,
-        metadata: {
-          scenarioId: scenario.id,
-          scenarioTitle: scenario.title,
-        },
-        output: { imageUrl: imageResult.imageUrl },
-      };
-
-      await repository.create(uid, creation);
+        metadata: { scenarioId: scenario.id, scenarioTitle: scenario.title },
+      });
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[ImageStrategy] Saved as processing", { creationId });
+      }
+
+      return creationId;
+    },
+
+    save: async (result: unknown, uid: string, creationId?: string) => {
+      const input = lastInputRef;
+      const imageResult = result as { imageUrl?: string };
+      if (!input || !scenario?.id || !imageResult.imageUrl) return;
+
+      const idToUpdate = creationId || processingCreationId;
+
+      if (idToUpdate) {
+        // Update existing processing creation to completed
+        await repository.update(uid, idToUpdate, {
+          uri: imageResult.imageUrl,
+          status: "completed" as const,
+          output: { imageUrl: imageResult.imageUrl },
+        });
+
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[ImageStrategy] Updated to completed", { creationId: idToUpdate });
+        }
+      } else {
+        // Fallback: create new (shouldn't happen normally)
+        await repository.create(uid, {
+          id: `${scenario.id}_${Date.now()}`,
+          uri: imageResult.imageUrl,
+          type: scenario.id,
+          prompt: input.prompt,
+          status: "completed" as const,
+          createdAt: new Date(),
+          isShared: false,
+          isFavorite: false,
+          metadata: { scenarioId: scenario.id, scenarioTitle: scenario.title },
+          output: { imageUrl: imageResult.imageUrl },
+        });
+      }
     },
   };
 }

package/src/domains/generation/wizard/infrastructure/strategies/shared/unified-prompt-builder.ts

@@ -0,0 +1,46 @@
+/**
+ * Unified Prompt Builder
+ * Single prompt building logic for ALL generation types (image & video)
+ * Uses MultiPersonPromptStructure for photo-based scenarios
+ * Uses createEnhancedPrompt for text-only scenarios
+ */
+
+import { createMultiPersonPrompt } from "../../../../../prompts/domain/entities/MultiPersonPromptStructure";
+import { createEnhancedPrompt } from "../../../../../prompts/domain/entities/BasePromptStructure";
+
+export interface BuildPromptOptions {
+  /** Base scenario prompt (aiPrompt from scenario config) */
+  readonly basePrompt: string;
+  /** Number of photos/people in generation */
+  readonly photoCount: number;
+  /** Interaction style from scenario (optional - only if scenario specifies it) */
+  readonly interactionStyle?: string;
+}
+
+/**
+ * Build unified prompt for any generation type
+ * - Photo-based: Uses createMultiPersonPrompt with @image1, @image2 references
+ * - Text-only: Uses createEnhancedPrompt with identity preservation
+ */
+export function buildUnifiedPrompt(options: BuildPromptOptions): string {
+  const { basePrompt, photoCount, interactionStyle } = options;
+
+  // Text-only generation (no photos)
+  if (photoCount === 0) {
+    return createEnhancedPrompt(basePrompt, {
+      includeIdentityPreservation: false,
+      includePhotoRealism: true,
+      includePoseGuidelines: true,
+    });
+  }
+
+  // Photo-based generation - use multi-person prompt with @imageN references
+  let finalPrompt = createMultiPersonPrompt(basePrompt, photoCount);
+
+  // Add interaction style if specified by scenario (no defaults)
+  if (interactionStyle) {
+    finalPrompt = `${finalPrompt}\n\nINTERACTION STYLE: ${interactionStyle}`;
+  }
+
+  return finalPrompt;
+}

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

@@ -5,54 +5,20 @@
 
 import { executeVideoFeature } from "../../../../../infrastructure/services/video-feature-executor.service";
 import { createCreationsRepository } from "../../../../creations/infrastructure/adapters";
+import { buildUnifiedPrompt } from "./shared/unified-prompt-builder";
 import type { WizardScenarioData } from "../../presentation/hooks/useWizardGeneration";
-import type { ScenarioInputType } from "../../../../scenarios/domain/Scenario";
 import type { WizardStrategy } from "./wizard-strategy.types";
 import { VIDEO_PROCESSING_PROMPTS } from "./wizard-strategy.constants";
 import { extractPrompt, extractDuration, extractAspectRatio, extractResolution } from "../utils";
 import { extractPhotosAsBase64 } from "./shared/photo-extraction.utils";
 import { getVideoFeatureType } from "./video-generation.utils";
 import type { WizardVideoInput, CreateVideoStrategyOptions } from "./video-generation.types";
+import { validatePhotoCount } from "./video-generation.types";
 
 declare const __DEV__: boolean;
 
 export type { WizardVideoInput, WizardVideoResult, CreateVideoStrategyOptions } from "./video-generation.types";
 
-interface PhotoValidationResult {
-  isValid: boolean;
-  errorKey?: string;
-}
-
-function validatePhotoCount(
-  photoCount: number,
-  inputType: ScenarioInputType | undefined,
-): PhotoValidationResult {
-  const effectiveInputType = inputType ?? "single";
-
-  switch (effectiveInputType) {
-    case "dual":
-      if (photoCount < 2) {
-        return {
-          isValid: false,
-          errorKey: "error.generation.dualPhotosRequired",
-        };
-      }
-      break;
-    case "single":
-      if (photoCount < 1) {
-        return {
-          isValid: false,
-          errorKey: "error.generation.photoRequired",
-        };
-      }
-      break;
-    case "text":
-      break;
-  }
-
-  return { isValid: true };
-}
-
 export async function buildVideoInput(
   wizardData: Record<string, unknown>,
   scenario: WizardScenarioData,
@@ -65,62 +31,52 @@ export async function buildVideoInput(
 
   const validation = validatePhotoCount(photos.length, scenario.inputType);
   if (!validation.isValid) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[VideoStrategy] Validation failed", {
-        scenarioId: scenario.id,
-        inputType: scenario.inputType,
-        photoCount: photos.length,
-        errorKey: validation.errorKey,
-      });
-    }
     throw new Error(validation.errorKey ?? "error.generation.invalidInput");
   }
 
-  let prompt = extractPrompt(wizardData, scenario.aiPrompt);
+  let basePrompt = extractPrompt(wizardData, scenario.aiPrompt);
 
-  if (!prompt) {
+  if (!basePrompt) {
     const defaultPrompt = VIDEO_PROCESSING_PROMPTS[scenario.id];
     if (defaultPrompt) {
-      prompt = defaultPrompt;
+      basePrompt = defaultPrompt;
     } else {
       throw new Error("error.generation.promptRequired");
     }
   }
 
-  const input: WizardVideoInput = {
+  // Build unified prompt with face preservation
+  const finalPrompt = buildUnifiedPrompt({
+    basePrompt,
+    photoCount: photos.length,
+    interactionStyle: scenario.interactionStyle as string | undefined,
+  });
+
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[VideoStrategy] Prompt built", {
+      baseLength: basePrompt.length,
+      finalLength: finalPrompt.length,
+      photoCount: photos.length,
+    });
+  }
+
+  return {
     sourceImageBase64: photos[0],
     targetImageBase64: photos[1] || photos[0],
-    prompt,
+    prompt: finalPrompt,
     duration: extractDuration(wizardData),
     aspectRatio: extractAspectRatio(wizardData),
     resolution: extractResolution(wizardData),
   };
-
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[VideoStrategy] Input built", {
-      hasSource: !!input.sourceImageBase64,
-      hasTarget: !!input.targetImageBase64,
-      duration: input.duration,
-    });
-  }
-
-  return input;
 }
 
-// ============================================================================
-// Strategy Factory
-// ============================================================================
-
 export function createVideoStrategy(options: CreateVideoStrategyOptions): WizardStrategy {
   const { scenario, collectionName = "creations" } = options;
   const repository = createCreationsRepository(collectionName);
   const videoFeatureType = getVideoFeatureType(scenario.id);
 
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[VideoStrategy] Created", { scenarioId: scenario.id, videoFeatureType });
-  }
-
   let lastInputRef: WizardVideoInput | null = null;
+  let processingCreationId: string | null = null;
 
   return {
     execute: async (input: unknown) => {
@@ -147,28 +103,63 @@ export function createVideoStrategy(options: CreateVideoStrategyOptions): Wizard
 
     getCreditCost: () => 1,
 
-    save: async (result: unknown, uid) => {
-      const input = lastInputRef;
-      const videoResult = result as { videoUrl?: string };
-      if (!input || !scenario?.id || !videoResult.videoUrl) return;
+    saveAsProcessing: async (uid: string, input: unknown) => {
+      const videoInput = input as WizardVideoInput;
+      const creationId = `${scenario.id}_${Date.now()}`;
+      processingCreationId = creationId;
 
-      const creation = {
-        id: `${scenario.id}_${Date.now()}`,
-        uri: videoResult.videoUrl,
+      await repository.create(uid, {
+        id: creationId,
+        uri: "",
         type: scenario.id,
-        prompt: input.prompt,
-        status: "completed" as const,
+        prompt: videoInput.prompt,
+        status: "processing" as const,
         createdAt: new Date(),
         isShared: false,
         isFavorite: false,
-        metadata: {
-          scenarioId: scenario.id,
-          scenarioTitle: scenario.title,
-        },
-        output: { videoUrl: videoResult.videoUrl },
-      };
+        metadata: { scenarioId: scenario.id, scenarioTitle: scenario.title },
+      });
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[VideoStrategy] Saved as processing", { creationId });
+      }
+
+      return creationId;
+    },
 
-      await repository.create(uid, creation);
+    save: async (result: unknown, uid: string, creationId?: string) => {
+      const input = lastInputRef;
+      const videoResult = result as { videoUrl?: string };
+      if (!input || !scenario?.id || !videoResult.videoUrl) return;
+
+      const idToUpdate = creationId || processingCreationId;
+
+      if (idToUpdate) {
+        // Update existing processing creation to completed
+        await repository.update(uid, idToUpdate, {
+          uri: videoResult.videoUrl,
+          status: "completed" as const,
+          output: { videoUrl: videoResult.videoUrl },
+        });
+
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.log("[VideoStrategy] Updated to completed", { creationId: idToUpdate });
+        }
+      } else {
+        // Fallback: create new (shouldn't happen normally)
+        await repository.create(uid, {
+          id: `${scenario.id}_${Date.now()}`,
+          uri: videoResult.videoUrl,
+          type: scenario.id,
+          prompt: input.prompt,
+          status: "completed" as const,
+          createdAt: new Date(),
+          isShared: false,
+          isFavorite: false,
+          metadata: { scenarioId: scenario.id, scenarioTitle: scenario.title },
+          output: { videoUrl: videoResult.videoUrl },
+        });
+      }
     },
   };
 }

package/src/domains/generation/wizard/infrastructure/strategies/video-generation.types.ts

@@ -4,6 +4,7 @@
  */
 
 import type { WizardScenarioData } from "../../presentation/hooks/useWizardGeneration";
+import type { ScenarioInputType } from "../../../../scenarios/domain/Scenario";
 
 export interface WizardVideoInput {
   /** Source image (optional for text-to-video) */
@@ -27,3 +28,32 @@ export interface CreateVideoStrategyOptions {
   readonly scenario: WizardScenarioData;
   readonly collectionName?: string;
 }
+
+export interface PhotoValidationResult {
+  isValid: boolean;
+  errorKey?: string;
+}
+
+export function validatePhotoCount(
+  photoCount: number,
+  inputType: ScenarioInputType | undefined,
+): PhotoValidationResult {
+  const effectiveInputType = inputType ?? "single";
+
+  switch (effectiveInputType) {
+    case "dual":
+      if (photoCount < 2) {
+        return { isValid: false, errorKey: "error.generation.dualPhotosRequired" };
+      }
+      break;
+    case "single":
+      if (photoCount < 1) {
+        return { isValid: false, errorKey: "error.generation.photoRequired" };
+      }
+      break;
+    case "text":
+      break;
+  }
+
+  return { isValid: true };
+}

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

@@ -6,5 +6,8 @@
 export interface WizardStrategy {
   execute: (input: unknown) => Promise<{ imageUrl?: string; videoUrl?: string }>;
   getCreditCost: () => number;
-  save?: (result: unknown, userId: string) => Promise<void>;
+  /** Save as processing when generation starts - returns creation ID */
+  saveAsProcessing?: (userId: string, input: unknown) => Promise<string>;
+  /** Update to completed when generation finishes */
+  save?: (result: unknown, userId: string, creationId?: string) => Promise<void>;
 }

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

@@ -1,12 +1,11 @@
 /**
  * useWizardGeneration Hook
  * Wizard generation using orchestrator + strategy factory pattern
- * Includes background job tracking for CreationsGallery display
+ * Saves to Firestore with status="processing" at start for gallery display
  */
 
 import { useEffect, useRef, useMemo, useCallback } from "react";
 import { useGenerationOrchestrator } from "../../../../../presentation/hooks/generation";
-import { usePendingJobs } from "../../../../../presentation/hooks/use-pending-jobs";
 import { createWizardStrategy, buildWizardInput } from "../../infrastructure/strategies";
 import type {
   UseWizardGenerationProps,
@@ -34,23 +33,19 @@ export const useWizardGeneration = (
     onSuccess,
     onError,
     onCreditsExhausted,
-    trackAsBackgroundJob = true,
   } = props;
 
   const hasStarted = useRef(false);
-  const currentJobIdRef = useRef<string | null>(null);
-
-  const { addJob, updateJob, removeJob } = usePendingJobs();
+  const currentCreationIdRef = useRef<string | null>(null);
 
   useEffect(() => {
     if (typeof __DEV__ !== "undefined" && __DEV__) {
       console.log("[useWizardGeneration] Initialized", {
         scenarioId: scenario.id,
         outputType: scenario.outputType,
-        trackAsBackgroundJob,
       });
     }
-  }, [scenario.id, scenario.outputType, trackAsBackgroundJob]);
+  }, [scenario.id, scenario.outputType]);
 
   const strategy = useMemo(() => {
     return createWizardStrategy({
@@ -62,17 +57,14 @@ export const useWizardGeneration = (
   const handleSuccess = useCallback(
     (result: unknown) => {
       if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[useWizardGeneration] Success");
-      }
-
-      if (trackAsBackgroundJob && currentJobIdRef.current) {
-        removeJob(currentJobIdRef.current);
-        currentJobIdRef.current = null;
+        console.log("[useWizardGeneration] Success", {
+          creationId: currentCreationIdRef.current,
+        });
       }
-
+      currentCreationIdRef.current = null;
       onSuccess?.(result);
     },
-    [trackAsBackgroundJob, removeJob, onSuccess],
+    [onSuccess],
   );
 
   const handleError = useCallback(
@@ -80,17 +72,11 @@ export const useWizardGeneration = (
       if (typeof __DEV__ !== "undefined" && __DEV__) {
         console.log("[useWizardGeneration] Error:", err.message);
       }
-
-      if (trackAsBackgroundJob && currentJobIdRef.current) {
-        updateJob({
-          id: currentJobIdRef.current,
-          updates: { status: "failed", error: err.message, progress: 0 },
-        });
-      }
-
+      // Note: Failed status update is handled by orchestrator via strategy
+      currentCreationIdRef.current = null;
       onError?.(err.message);
     },
-    [trackAsBackgroundJob, updateJob, onError],
+    [onError],
   );
 
   const { generate, isGenerating } = useGenerationOrchestrator(strategy, {
@@ -113,31 +99,27 @@ export const useWizardGeneration = (
       hasStarted.current = true;
 
       buildWizardInput(wizardData, scenario)
-        .then((input) => {
+        .then(async (input) => {
           if (!input) {
             hasStarted.current = false;
             onError?.("Failed to build generation input");
             return;
           }
 
-          if (trackAsBackgroundJob && scenario.outputType) {
-            const jobId = `wizard-${scenario.id}-${Date.now()}`;
-            currentJobIdRef.current = jobId;
-
-            addJob({
-              id: jobId,
-              input: {
-                scenarioId: scenario.id,
-                scenarioTitle: scenario.title,
-                outputType: scenario.outputType,
-              },
-              type: scenario.outputType,
-              status: "processing",
-              progress: 10,
-            });
-
-            if (typeof __DEV__ !== "undefined" && __DEV__) {
-              console.log("[useWizardGeneration] Created background job:", jobId);
+          // Save to Firestore with status="processing" BEFORE starting generation
+          if (strategy.saveAsProcessing && userId) {
+            try {
+              const creationId = await strategy.saveAsProcessing(userId, input);
+              currentCreationIdRef.current = creationId;
+
+              if (typeof __DEV__ !== "undefined" && __DEV__) {
+                console.log("[useWizardGeneration] Saved as processing:", creationId);
+              }
+            } catch (err) {
+              if (typeof __DEV__ !== "undefined" && __DEV__) {
+                console.error("[useWizardGeneration] saveAsProcessing error:", err);
+              }
+              // Continue with generation even if save fails
             }
           }
 
@@ -162,8 +144,8 @@ export const useWizardGeneration = (
     isGenerating,
     generate,
     onError,
-    trackAsBackgroundJob,
-    addJob,
+    strategy,
+    userId,
   ]);
 
   return { isGenerating };