@umituz/react-native-ai-generation-content 1.90.1 → 1.90.3

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

@@ -0,0 +1,88 @@
+/**
+ * Image Generation Strategy - Data Extraction
+ *
+ * Handles photo and prompt extraction from wizard data
+ */
+
+import type { WizardScenarioData } from "../../presentation/hooks/useWizardGeneration";
+import { IMAGE_PROCESSING_PROMPTS } from "./wizard-strategy.constants";
+import { extractPrompt } from "../utils";
+import { extractPhotosAsBase64, extractPhotoUris } from "./shared/photo-extraction.utils";
+
+export interface ImageExtractionResult {
+  photoUris: string[];
+  photos: string[];
+  prompt: string;
+}
+
+/**
+ * Extract photos and prompt from wizard data
+ */
+export async function extractImageData(
+  wizardData: Record<string, unknown>,
+  scenario: WizardScenarioData,
+): Promise<ImageExtractionResult> {
+  const DEV = typeof __DEV__ !== "undefined" && __DEV__;
+
+  if (DEV) {
+    console.log("[ImageStrategy] ===== EXTRACTION START =====");
+    console.log("[ImageStrategy] Scenario ID:", scenario.id);
+    console.log("[ImageStrategy] ===== WIZARD DATA KEYS =====");
+    const wizardKeys = Object.keys(wizardData);
+    console.log("[ImageStrategy] Total keys:", wizardKeys.length);
+    console.log("[ImageStrategy] Keys:", wizardKeys.slice(0, 20).join(", ") + (wizardKeys.length > 20 ? "..." : ""));
+
+    // Log photo-related keys
+    const photoKeys = wizardKeys.filter(k => k.includes("photo"));
+    if (photoKeys.length > 0) {
+      console.log("[ImageStrategy] Photo-related keys:", photoKeys.join(", "));
+    }
+
+    // Log selection/style keys
+    const selectionKeys = wizardKeys.filter(k => k.includes("selection") || k.includes("style"));
+    if (selectionKeys.length > 0) {
+      console.log("[ImageStrategy] Selection/style keys:", selectionKeys.join(", "));
+    }
+  }
+
+  // Extract photo URIs first (for couple refinement)
+  const photoUris = extractPhotoUris(wizardData);
+  const photos = await extractPhotosAsBase64(wizardData, DEV);
+
+  if (DEV) {
+    console.log("[ImageStrategy] ===== EXTRACTION COMPLETE =====");
+    console.log("[ImageStrategy] Photo URIs count:", photoUris.length);
+    console.log("[ImageStrategy] Base64 photos count:", photos.length);
+  }
+
+  // Extract prompt with fallback to default
+  let prompt = extractPrompt(wizardData, scenario.aiPrompt);
+
+  if (DEV) {
+    console.log("[ImageStrategy] ===== PROMPT EXTRACTION =====");
+    console.log("[ImageStrategy] Scenario aiPrompt type:", typeof scenario.aiPrompt);
+    console.log("[ImageStrategy] Scenario aiPrompt length:", typeof scenario.aiPrompt === "string" ? scenario.aiPrompt.length : "N/A");
+    if (typeof scenario.aiPrompt === "string") {
+      console.log("[ImageStrategy] Scenario aiPrompt preview:", scenario.aiPrompt.substring(0, 200) + "...");
+    }
+    console.log("[ImageStrategy] Extracted prompt type:", typeof prompt);
+    console.log("[ImageStrategy] Extracted prompt length:", prompt?.length ?? 0);
+    if (prompt) {
+      console.log("[ImageStrategy] Extracted prompt preview:", prompt.substring(0, 200) + "...");
+    }
+  }
+
+  if (!prompt) {
+    const defaultPrompt = IMAGE_PROCESSING_PROMPTS[scenario.id];
+    if (defaultPrompt) {
+      prompt = defaultPrompt;
+      if (DEV) {
+        console.log("[ImageStrategy] Using default prompt for scenario:", scenario.id);
+      }
+    } else {
+      throw new Error("Prompt is required for image generation");
+    }
+  }
+
+  return { photoUris, photos, prompt };
+}

package/src/domains/generation/wizard/infrastructure/strategies/image-input-prompt-builder.ts

@@ -0,0 +1,75 @@
+/**
+ * Image Generation Strategy - Prompt Building
+ *
+ * Handles prompt enhancement and photorealistic prompt creation
+ */
+
+import { enhancePromptWithAnalysis } from "../../../infrastructure/appearance-analysis";
+import { createPhotorealisticPrompt } from "../../../../prompts/domain/base/creators";
+import { applyStyleEnhancements } from "./image-input-style-enhancements";
+
+export interface PromptBuildContext {
+  photos: string[];
+  photoUris: string[];
+  prompt: string;
+  wizardData: Record<string, unknown>;
+}
+
+/**
+ * Build final prompt with enhancements and photorealistic styling
+ */
+export async function buildImagePrompt(
+  context: PromptBuildContext,
+): Promise<string> {
+  const { photos, photoUris, prompt, wizardData } = context;
+  const DEV = typeof __DEV__ !== "undefined" && __DEV__;
+
+  // Apply style enhancements for photo-based generation
+  if (photos.length === 0) {
+    return prompt;
+  }
+
+  const isCoupleMode = photos.length >= 2;
+  const styleEnhanced = applyStyleEnhancements(prompt, wizardData);
+
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[ImageStrategy] ===== STRATEGY START =====");
+    console.log("[ImageStrategy] ===== PROMPT FLOW =====");
+    console.log("[ImageStrategy] [1/5] Original scenario prompt:");
+    console.log("[ImageStrategy]   Length:", prompt.length);
+    console.log("[ImageStrategy]   Preview:", prompt.substring(0, 150) + "...");
+    console.log("[ImageStrategy] [2/5] Style enhancements applied:", styleEnhanced !== prompt);
+    if (styleEnhanced !== prompt) {
+      console.log("[ImageStrategy]   Enhanced preview:", styleEnhanced.substring(0, 150) + "...");
+    }
+    console.log("[ImageStrategy] [3/5] Couple mode:", isCoupleMode);
+    console.log("[ImageStrategy]   Photo count:", photos.length);
+    console.log("[ImageStrategy] [4/5] Calling enhancePromptWithAnalysis...");
+  }
+
+  const refinedPrompt = await enhancePromptWithAnalysis(styleEnhanced, photoUris, isCoupleMode);
+
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[ImageStrategy] After enhancePromptWithAnalysis:");
+    console.log("[ImageStrategy]   Length:", refinedPrompt.length);
+    console.log("[ImageStrategy]   Preview:", refinedPrompt.substring(0, 200) + "...");
+    console.log("[ImageStrategy] [5/5] Calling createPhotorealisticPrompt (Wardrobe style)...");
+  }
+
+  const finalPrompt = createPhotorealisticPrompt(refinedPrompt, {
+    isCouple: isCoupleMode,
+    customInstructions: undefined,
+  });
+
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[ImageStrategy] ===== STRATEGY END =====");
+    console.log("[ImageStrategy] Final prompt length:", finalPrompt.length);
+    console.log("[ImageStrategy] Final prompt preview:");
+    console.log(finalPrompt.substring(0, 600) + "...");
+    console.log("[ImageStrategy] ===== OUTPUT =====");
+    console.log("[ImageStrategy] Photo count:", photos.length);
+    console.log("[ImageStrategy] Photo sizes:", photos.map((p, i) => `Photo ${i + 1}: ${(p.length / 1024).toFixed(2)}KB`));
+  }
+
+  return finalPrompt;
+}

package/src/domains/generation/wizard/infrastructure/strategies/image-input-style-enhancements.ts

@@ -0,0 +1,35 @@
+/**
+ * Image Generation Strategy - Style Enhancements
+ *
+ * Applies style enhancements to the prompt
+ */
+
+import { DEFAULT_STYLE_VALUE } from "./wizard-strategy.constants";
+import { extractSelection } from "../utils";
+
+/**
+ * Applies style enhancements to the prompt
+ */
+export function applyStyleEnhancements(
+  prompt: string,
+  wizardData: Record<string, unknown>
+): string {
+  const enhancements: string[] = [];
+
+  const moodSelections = extractSelection(wizardData.selection_mood);
+  if (Array.isArray(moodSelections) && moodSelections.length > 0) {
+    enhancements.push(`Mood: ${moodSelections.join(", ")}`);
+  }
+
+  const artStyle = extractSelection(wizardData.selection_art_style);
+  if (typeof artStyle === "string" && artStyle !== DEFAULT_STYLE_VALUE) {
+    enhancements.push(`Art style: ${artStyle}`);
+  }
+
+  const artist = extractSelection(wizardData.selection_artist_style);
+  if (typeof artist === "string" && artist !== DEFAULT_STYLE_VALUE) {
+    enhancements.push(`Artist style: ${artist}`);
+  }
+
+  return enhancements.length > 0 ? `${prompt}. ${enhancements.join(", ")}` : prompt;
+}

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

@@ -0,0 +1,42 @@
+/**
+ * Image Generation Strategy - Strategy Factory
+ */
+
+import type { WizardScenarioData } from "../../presentation/hooks/useWizardGeneration";
+import type { WizardStrategy } from "./wizard-strategy.types";
+import type { CreateImageStrategyOptions } from "./image-generation.types";
+import { executeImageGeneration } from "./image-generation.executor";
+import type { WizardImageInput } from "./image-generation.types";
+
+/**
+ * Create image generation strategy
+ */
+export function createImageStrategy(options: CreateImageStrategyOptions): WizardStrategy {
+  const { scenario } = options;
+
+  // Validate model early - fail fast
+  if (!scenario.model) {
+    throw new Error("Model is required for image generation");
+  }
+
+  const model = scenario.model;
+  const providerId = scenario.providerId;
+
+  return {
+    execute: async (input: unknown) => {
+      if (!input || typeof input !== "object") {
+        throw new Error("Invalid input: expected WizardImageInput object");
+      }
+      const imageInput = input as WizardImageInput;
+      const result = await executeImageGeneration(imageInput, model, undefined, providerId);
+
+      if (!result.success || !result.imageUrl) {
+        const error = new Error(result.error || "Image generation failed");
+        (error as Error & { logSessionId?: string }).logSessionId = result.logSessionId;
+        throw error;
+      }
+
+      return { imageUrl: result.imageUrl, logSessionId: result.logSessionId };
+    },
+  };
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Video Generation Executor
+ * Handles the actual video generation execution.
+ * Model-agnostic: uses VideoModelConfig.buildInput() for model-specific parameters.
+ * Fallback: generic input builder when no modelConfig is provided.
+ */
+
+export { executeVideoGeneration } from "./video-generation-executor";
+export { submitVideoGenerationToQueue } from "./video-generation-submission";
+export { buildGenericInput } from "./video-generation-input-builder";
+export type { ExecutionResult, SubmissionResult } from "./video-generation-result-types";

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

@@ -0,0 +1,76 @@
+/**
+ * Video Generation Executor - Execution Functions
+ */
+
+import type { WizardVideoInput } from "./video-generation.types";
+import type { VideoModelConfig } from "../../../../../domain/interfaces/video-model-config.types";
+import { VIDEO_GENERATION_TIMEOUT_MS } from "./wizard-strategy.constants";
+import { createGenerationError, GenerationErrorType } from "../../../../../infrastructure/utils/error-factory";
+import type { ExecutionResult } from "./video-generation.types";
+import { buildGenericInput } from "./video-generation-input-builder";
+
+/**
+ * Execute video generation using direct provider call
+ */
+export async function executeVideoGeneration(
+  input: WizardVideoInput,
+  model: string,
+  onProgress?: (status: string) => void,
+  modelConfig?: VideoModelConfig,
+  providerId?: string,
+): Promise<ExecutionResult> {
+  const { resolveProvider } = await import("../../../../../infrastructure/services/provider-resolver");
+
+  let provider;
+  try {
+    provider = resolveProvider(providerId);
+  } catch {
+    const error = createGenerationError(
+      GenerationErrorType.VALIDATION,
+      "AI provider is not initialized. Please check your configuration."
+    );
+    return { success: false, error: error.message };
+  }
+
+  try {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[VideoExecutor] Generation starting", {
+        model,
+        hasModelConfig: !!modelConfig,
+        duration: input.duration,
+        resolution: input.resolution,
+      });
+    }
+
+    // Use modelConfig.buildInput() if available, otherwise generic fallback
+    const modelInput = modelConfig
+      ? modelConfig.buildInput(input)
+      : buildGenericInput(input);
+
+    let lastStatus = "";
+    const result = await provider.subscribe(model, modelInput, {
+      timeoutMs: VIDEO_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; url?: string };
+    // FAL returns { video: { url } }, Pruna returns { url }, some return { video_url }
+    const videoUrl = data?.video?.url ?? data?.video_url ?? data?.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" };
+  }
+}

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

@@ -0,0 +1,46 @@
+/**
+ * Video Generation Executor - Input Builder
+ */
+
+import type { WizardVideoInput } from "./video-generation.types";
+import { BASE64_IMAGE_PREFIX } from "./wizard-strategy.constants";
+
+/**
+ * Format base64 string with data URI prefix if needed
+ */
+function formatBase64(base64: string | undefined): string | undefined {
+  if (!base64) return undefined;
+  return base64.startsWith("data:") ? base64 : `${BASE64_IMAGE_PREFIX}${base64}`;
+}
+
+/**
+ * Generic input builder - used when no modelConfig is provided.
+ * Sends standard parameters without model-specific logic.
+ */
+export function buildGenericInput(input: WizardVideoInput): Record<string, unknown> {
+  const modelInput: Record<string, unknown> = { prompt: input.prompt };
+  const sourceImage = formatBase64(input.sourceImageBase64);
+
+  if (sourceImage && sourceImage.length > 0) {
+    modelInput.image_url = sourceImage;
+  }
+  if (input.duration) {
+    modelInput.duration = input.duration;
+  }
+  if (input.aspectRatio) {
+    modelInput.aspect_ratio = input.aspectRatio;
+  }
+  if (input.resolution) {
+    modelInput.resolution = input.resolution;
+  }
+  if (input.audioUrl) {
+    modelInput.audio = input.audioUrl;
+  }
+
+  // Quality mode: "draft" → draft=true (faster, cheaper), "normal" → draft=false (higher quality)
+  if (input.qualityMode === "draft" || input.qualityMode === "normal") {
+    modelInput.draft = input.qualityMode === "draft";
+  }
+
+  return modelInput;
+}

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

@@ -0,0 +1,17 @@
+/**
+ * Video Generation Executor - Type Definitions
+ */
+
+export interface ExecutionResult {
+  success: boolean;
+  videoUrl?: string;
+  requestId?: string;
+  error?: string;
+}
+
+export interface SubmissionResult {
+  success: boolean;
+  requestId?: string;
+  model?: string;
+  error?: string;
+}

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

@@ -0,0 +1,62 @@
+/**
+ * Video Generation Executor - Queue Submission
+ */
+
+import type { WizardVideoInput } from "./video-generation.types";
+import type { VideoModelConfig } from "../../../../../domain/interfaces/video-model-config.types";
+import { createGenerationError, GenerationErrorType } from "../../../../../infrastructure/utils/error-factory";
+import type { SubmissionResult } from "./video-generation.types";
+import { buildGenericInput } from "./video-generation-input-builder";
+
+/**
+ * Submit video generation to queue
+ * For background processing of video generation
+ */
+export async function submitVideoGenerationToQueue(
+  input: WizardVideoInput,
+  model: string,
+  modelConfig?: VideoModelConfig,
+  providerId?: string,
+): Promise<SubmissionResult> {
+  const { resolveProvider } = await import("../../../../../infrastructure/services/provider-resolver");
+
+  let provider;
+  try {
+    provider = resolveProvider(providerId);
+  } catch {
+    const error = createGenerationError(
+      GenerationErrorType.VALIDATION,
+      "AI provider is not initialized. Please check your configuration."
+    );
+    return { success: false, error: error.message };
+  }
+
+  try {
+    // Use modelConfig.buildInput() if available, otherwise generic fallback
+    const modelInput = modelConfig
+      ? modelConfig.buildInput(input)
+      : buildGenericInput(input);
+
+    const submission = await provider.submitJob(model, modelInput);
+
+    return { success: true, requestId: submission.requestId, model };
+  } catch (error) {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.error("[VideoExecutor] Queue submission error:", error);
+    }
+
+    let errorMessage = "Failed to submit video generation to queue. Please try again.";
+
+    if (error instanceof Error) {
+      const message = error.message.toLowerCase();
+
+      if (message.includes("network") || message.includes("connection")) {
+        errorMessage = "Network error. Please check your internet connection and try again.";
+      } else {
+        errorMessage = `Queue submission failed: ${error.message}`;
+      }
+    }
+
+    return { success: false, error: errorMessage };
+  }
+}

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

@@ -0,0 +1,27 @@
+/**
+ * Video Generation Strategy - Audio Extractor
+ * Extracts audio from wizard data for video generation
+ */
+
+import { readFileAsBase64 } from "@umituz/react-native-design-system/filesystem";
+
+/**
+ * Extract audio from wizardData and read as base64.
+ * Audio step stores data as { uri: "file:///..." }.
+ */
+export async function extractAudioAsBase64(wizardData: Record<string, unknown>): Promise<string | undefined> {
+  const audioData = wizardData.background_audio as { uri?: string } | undefined;
+  if (!audioData?.uri) return undefined;
+
+  try {
+    const base64 = await readFileAsBase64(audioData.uri);
+    if (!base64) return undefined;
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[VideoStrategy] Audio extracted as base64", { length: base64.length });
+    }
+    return base64;
+  } catch (error) {
+    console.warn("[VideoStrategy] Failed to read audio file:", error);
+    return undefined;
+  }
+}

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

@@ -5,178 +5,5 @@
  * Fallback: generic input builder when no modelConfig is provided.
  */
 
-import type { WizardVideoInput } from "./video-generation.types";
-import type { VideoModelConfig } from "../../../../../domain/interfaces/video-model-config.types";
-import { VIDEO_GENERATION_TIMEOUT_MS, BASE64_IMAGE_PREFIX } from "./wizard-strategy.constants";
-import { createGenerationError, GenerationErrorType } from "../../../../../infrastructure/utils/error-factory";
-
-
-interface ExecutionResult {
-  success: boolean;
-  videoUrl?: string;
-  requestId?: string;
-  error?: string;
-}
-
-interface SubmissionResult {
-  success: boolean;
-  requestId?: string;
-  model?: string;
-  error?: string;
-}
-
-function formatBase64(base64: string | undefined): string | undefined {
-  if (!base64) return undefined;
-  return base64.startsWith("data:") ? base64 : `${BASE64_IMAGE_PREFIX}${base64}`;
-}
-
-/**
- * Generic input builder - used when no modelConfig is provided.
- * Sends standard parameters without model-specific logic.
- */
-function buildGenericInput(input: WizardVideoInput): Record<string, unknown> {
-  const modelInput: Record<string, unknown> = { prompt: input.prompt };
-  const sourceImage = formatBase64(input.sourceImageBase64);
-
-  if (sourceImage && sourceImage.length > 0) {
-    modelInput.image_url = sourceImage;
-  }
-  if (input.duration) {
-    modelInput.duration = input.duration;
-  }
-  if (input.aspectRatio) {
-    modelInput.aspect_ratio = input.aspectRatio;
-  }
-  if (input.resolution) {
-    modelInput.resolution = input.resolution;
-  }
-  if (input.audioUrl) {
-    modelInput.audio = input.audioUrl;
-  }
-
-  // Quality mode: "draft" → draft=true (faster, cheaper), "normal" → draft=false (higher quality)
-  if (input.qualityMode === "draft" || input.qualityMode === "normal") {
-    modelInput.draft = input.qualityMode === "draft";
-  }
-
-  return modelInput;
-}
-
-/**
- * Execute video generation using direct provider call
- */
-export async function executeVideoGeneration(
-  input: WizardVideoInput,
-  model: string,
-  onProgress?: (status: string) => void,
-  modelConfig?: VideoModelConfig,
-  providerId?: string,
-): Promise<ExecutionResult> {
-  const { resolveProvider } = await import("../../../../../infrastructure/services/provider-resolver");
-
-  let provider;
-  try {
-    provider = resolveProvider(providerId);
-  } catch {
-    const error = createGenerationError(
-      GenerationErrorType.VALIDATION,
-      "AI provider is not initialized. Please check your configuration."
-    );
-    return { success: false, error: error.message };
-  }
-
-  try {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[VideoExecutor] Generation starting", {
-        model,
-        hasModelConfig: !!modelConfig,
-        duration: input.duration,
-        resolution: input.resolution,
-      });
-    }
-
-    // Use modelConfig.buildInput() if available, otherwise generic fallback
-    const modelInput = modelConfig
-      ? modelConfig.buildInput(input)
-      : buildGenericInput(input);
-
-    let lastStatus = "";
-    const result = await provider.subscribe(model, modelInput, {
-      timeoutMs: VIDEO_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; url?: string };
-    // FAL returns { video: { url } }, Pruna returns { url }, some return { video_url }
-    const videoUrl = data?.video?.url ?? data?.video_url ?? data?.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,
-  modelConfig?: VideoModelConfig,
-  providerId?: string,
-): Promise<SubmissionResult> {
-  const { resolveProvider } = await import("../../../../../infrastructure/services/provider-resolver");
-
-  let provider;
-  try {
-    provider = resolveProvider(providerId);
-  } catch {
-    const error = createGenerationError(
-      GenerationErrorType.VALIDATION,
-      "AI provider is not initialized. Please check your configuration."
-    );
-    return { success: false, error: error.message };
-  }
-
-  try {
-    // Use modelConfig.buildInput() if available, otherwise generic fallback
-    const modelInput = modelConfig
-      ? modelConfig.buildInput(input)
-      : buildGenericInput(input);
-
-    const submission = await provider.submitJob(model, modelInput);
-
-    return { success: true, requestId: submission.requestId, model };
-  } catch (error) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.error("[VideoExecutor] Queue submission error:", error);
-    }
-
-    let errorMessage = "Failed to submit video generation to queue. Please try again.";
-
-    if (error instanceof Error) {
-      const message = error.message.toLowerCase();
-
-      if (message.includes("network") || message.includes("connection")) {
-        errorMessage = "Network error. Please check your internet connection and try again.";
-      } else {
-        errorMessage = `Queue submission failed: ${error.message}`;
-      }
-    }
-
-    return { success: false, error: errorMessage };
-  }
-}
+export { executeVideoGeneration, submitVideoGenerationToQueue, buildGenericInput } from "./video-generation-executor-index";
+export type { ExecutionResult, SubmissionResult } from "./video-generation-executor-index";