@umituz/react-native-ai-generation-content 1.72.15 → 1.72.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.72.15",
+  "version": "1.72.17",
   "description": "Provider-agnostic AI generation orchestration for React Native with result preview components",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -39,6 +39,7 @@
     "url": "git+https://github.com/umituz/react-native-ai-generation-content.git"
   },
   "dependencies": {
+    "@umituz/react-native-ai-generation-content": "file:../../../../../../../../../tmp/package.tgz",
     "@umituz/react-native-auth": "latest"
   },
   "peerDependencies": {

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

@@ -0,0 +1,149 @@
+/**
+ * Video Generation Executor
+ * Handles the actual video generation execution
+ * Uses direct provider calls for text-to-video and image-to-video generation models
+ */
+
+import type { WizardVideoInput } from "./video-generation.types";
+import { GENERATION_TIMEOUT_MS, BASE64_IMAGE_PREFIX } from "./wizard-strategy.constants";
+
+declare const __DEV__: boolean;
+
+interface ExecutionResult {
+  success: boolean;
+  videoUrl?: string;
+  requestId?: string;
+  error?: string;
+}
+
+interface SubmissionResult {
+  success: boolean;
+  requestId?: string;
+  model?: string;
+  error?: string;
+}
+
+function formatBase64(base64: string): string {
+  return base64.startsWith("data:") ? base64 : `${BASE64_IMAGE_PREFIX}${base64}`;
+}
+
+/**
+ * Execute video generation using direct provider call
+ * For text-to-video and image-to-video generation models (NOT features)
+ */
+export async function executeVideoGeneration(
+  input: WizardVideoInput,
+  model: string,
+  onProgress?: (status: string) => void,
+): Promise<ExecutionResult> {
+  const { providerRegistry } = await import("../../../../../infrastructure/services/provider-registry.service");
+
+  const provider = providerRegistry.getActiveProvider();
+  if (!provider?.isInitialized()) {
+    return { success: false, error: "AI provider not initialized" };
+  }
+
+  try {
+    const sourceImage = formatBase64(input.sourceImageBase64);
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[VideoExecutor] Generation starting", {
+        model,
+        duration: input.duration,
+        aspectRatio: input.aspectRatio,
+        resolution: input.resolution,
+      });
+    }
+
+    const modelInput: Record<string, unknown> = {
+      prompt: input.prompt,
+    };
+
+    // Add image for image-to-video (Sora 2, etc.)
+    if (sourceImage) {
+      modelInput.image_url = sourceImage;
+    }
+
+    // Add optional parameters
+    if (input.duration) {
+      modelInput.duration = input.duration;
+    }
+    if (input.aspectRatio) {
+      modelInput.aspect_ratio = input.aspectRatio;
+    }
+    if (input.resolution) {
+      modelInput.resolution = input.resolution;
+    }
+
+    let lastStatus = "";
+    const result = await provider.subscribe(model, modelInput, {
+      timeoutMs: GENERATION_TIMEOUT_MS,
+      onQueueUpdate: (status) => {
+        if (status.status !== lastStatus) {
+          lastStatus = status.status;
+          onProgress?.(status.status);
+        }
+      },
+    });
+
+    const rawResult = result as Record<string, unknown>;
+    const data = (rawResult?.data ?? rawResult) as { video?: { url: string }; video_url?: string };
+    const videoUrl = data?.video?.url ?? data?.video_url;
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[VideoExecutor] Generation completed", { success: !!videoUrl });
+    }
+
+    return videoUrl
+      ? { success: true, videoUrl, requestId: (rawResult as { requestId?: string })?.requestId }
+      : { success: false, error: "No video generated" };
+  } catch (error) {
+    return { success: false, error: error instanceof Error ? error.message : "Generation failed" };
+  }
+}
+
+/**
+ * Submit video generation to queue
+ * For background processing of video generation
+ */
+export async function submitVideoGenerationToQueue(
+  input: WizardVideoInput,
+  model: string,
+): Promise<SubmissionResult> {
+  const { providerRegistry } = await import("../../../../../infrastructure/services/provider-registry.service");
+
+  const provider = providerRegistry.getActiveProvider();
+  if (!provider?.isInitialized()) {
+    return { success: false, error: "AI provider not initialized" };
+  }
+
+  try {
+    const sourceImage = formatBase64(input.sourceImageBase64);
+
+    const modelInput: Record<string, unknown> = {
+      prompt: input.prompt,
+    };
+
+    // Add image for image-to-video
+    if (sourceImage) {
+      modelInput.image_url = sourceImage;
+    }
+
+    // Add optional parameters
+    if (input.duration) {
+      modelInput.duration = input.duration;
+    }
+    if (input.aspectRatio) {
+      modelInput.aspect_ratio = input.aspectRatio;
+    }
+    if (input.resolution) {
+      modelInput.resolution = input.resolution;
+    }
+
+    const submission = await provider.submitJob(model, modelInput);
+
+    return { success: true, requestId: submission.requestId, model };
+  } catch (error) {
+    return { success: false, error: error instanceof Error ? error.message : "Queue submission failed" };
+  }
+}

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

@@ -1,21 +1,17 @@
 /**
  * Video Generation Strategy
  * Handles video-specific generation logic (execution only)
- * Uses clean prompts for Sora 2 - no complex identity preservation text
+ * Uses direct provider calls for generation models (text-to-video, image-to-video)
  */
 
-import {
-  executeVideoFeature,
-  submitVideoFeatureToQueue,
-} from "../../../../../infrastructure/services/video-feature-executor.service";
 import type { WizardScenarioData } from "../../presentation/hooks/useWizardGeneration";
 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, validateWizardVideoInput } from "./video-generation.types";
+import { executeVideoGeneration, submitVideoGenerationToQueue } from "./video-generation.executor";
 
 declare const __DEV__: boolean;
 
@@ -51,10 +47,10 @@ export async function buildVideoInput(
     }
   }
 
-  // For video generation with Sora 2, use clean prompt directly
-  // No need for complex identity preservation text - Sora 2 handles this natively
+  // For video generation, use clean prompt directly
+  // Modern models handle context natively
   if (typeof __DEV__ !== "undefined" && __DEV__) {
-    console.log("[VideoStrategy] Using clean prompt for Sora 2", {
+    console.log("[VideoStrategy] Using clean prompt for video generation", {
       promptLength: finalPrompt.length,
       photoCount: photos.length,
     });
@@ -72,23 +68,20 @@ export async function buildVideoInput(
 
 export function createVideoStrategy(options: CreateVideoStrategyOptions): WizardStrategy {
   const { scenario, creditCost } = options;
-  const videoFeatureType = getVideoFeatureType(scenario);
+
+  // Validate model early - fail fast
+  if (!scenario.model) {
+    throw new Error("Model is required for video generation");
+  }
+
+  const model = scenario.model;
 
   return {
     execute: async (input: unknown) => {
       // Runtime validation with descriptive errors
       const videoInput = validateWizardVideoInput(input);
 
-      const result = await executeVideoFeature(videoFeatureType, {
-        sourceImageBase64: videoInput.sourceImageBase64,
-        targetImageBase64: videoInput.targetImageBase64,
-        prompt: videoInput.prompt,
-        options: {
-          duration: videoInput.duration,
-          aspect_ratio: videoInput.aspectRatio,
-          resolution: videoInput.resolution,
-        },
-      });
+      const result = await executeVideoGeneration(videoInput, model);
 
       if (!result.success || !result.videoUrl) {
         throw new Error(result.error || "Video generation failed");
@@ -101,16 +94,7 @@ export function createVideoStrategy(options: CreateVideoStrategyOptions): Wizard
       // Runtime validation with descriptive errors
       const videoInput = validateWizardVideoInput(input);
 
-      const result = await submitVideoFeatureToQueue(videoFeatureType, {
-        sourceImageBase64: videoInput.sourceImageBase64,
-        targetImageBase64: videoInput.targetImageBase64,
-        prompt: videoInput.prompt,
-        options: {
-          duration: videoInput.duration,
-          aspect_ratio: videoInput.aspectRatio,
-          resolution: videoInput.resolution,
-        },
-      });
+      const result = await submitVideoGenerationToQueue(videoInput, model);
 
       return {
         success: result.success,