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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.37.12",
+  "version": "1.37.13",
   "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/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,61 +31,50 @@ 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;
 
   return {
@@ -152,7 +107,7 @@ export function createVideoStrategy(options: CreateVideoStrategyOptions): Wizard
       const videoResult = result as { videoUrl?: string };
       if (!input || !scenario?.id || !videoResult.videoUrl) return;
 
-      const creation = {
+      await repository.create(uid, {
         id: `${scenario.id}_${Date.now()}`,
         uri: videoResult.videoUrl,
         type: scenario.id,
@@ -161,14 +116,9 @@ export function createVideoStrategy(options: CreateVideoStrategyOptions): Wizard
         createdAt: new Date(),
         isShared: false,
         isFavorite: false,
-        metadata: {
-          scenarioId: scenario.id,
-          scenarioTitle: scenario.title,
-        },
+        metadata: { scenarioId: scenario.id, scenarioTitle: scenario.title },
         output: { videoUrl: videoResult.videoUrl },
-      };
-
-      await repository.create(uid, creation);
+      });
     },
   };
 }

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 };
+}