@umituz/react-native-ai-generation-content 1.77.0 → 1.79.0

package/package.json

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

package/src/domain/interfaces/index.ts

@@ -13,3 +13,6 @@ export type { IAIProviderJobManager } from "../../domains/background/domain/inte
 export type { IAIProviderExecutor } from "./provider-executor.interface";
 export type { IAIProviderImageFeatures } from "./provider-image-features.interface";
 export type { IAIProviderVideoFeatures } from "./provider-video-features.interface";
+
+// Video Model Configuration
+export type { VideoModelConfig, ModelCapabilityOption } from "./video-model-config.types";

package/src/domain/interfaces/video-model-config.types.ts

@@ -0,0 +1,52 @@
+/**
+ * VideoModelConfig - Model-Agnostic Configuration Interface
+ * Encapsulates ALL model-specific behavior in a single config object.
+ * Adding a new model = creating one config file. No other changes needed.
+ */
+
+export interface ModelCapabilityOption {
+  readonly id: string;
+  readonly label: string;
+  readonly value: string | number;
+}
+
+export interface VideoModelConfig {
+  /** Fal.ai model endpoint (e.g., "fal-ai/minimax/hailuo-02/standard/image-to-video") */
+  readonly modelId: string;
+
+  /** Human-readable display name */
+  readonly displayName: string;
+
+  /** What this model supports (drives wizard UI) */
+  readonly capabilities: {
+    readonly resolutions: ReadonlyArray<ModelCapabilityOption>;
+    readonly durations: ReadonlyArray<ModelCapabilityOption>;
+    readonly aspectRatios?: ReadonlyArray<ModelCapabilityOption>;
+    readonly defaults: {
+      readonly resolution: string;
+      readonly duration: number;
+      readonly aspectRatio?: string;
+    };
+  };
+
+  /**
+   * Maps generic WizardVideoInput to model-specific API parameters.
+   * This is the core adapter function - eliminates all model-specific if/else checks.
+   */
+  readonly buildInput: (input: {
+    readonly prompt: string;
+    readonly sourceImageBase64?: string;
+    readonly targetImageBase64?: string;
+    readonly duration?: number;
+    readonly aspectRatio?: string;
+    readonly resolution?: string;
+  }) => Record<string, unknown>;
+
+  /**
+   * Pricing data for credit calculation.
+   * Keys are resolution IDs matching capabilities.resolutions[].id
+   */
+  readonly pricing: {
+    readonly costPerSecond: Record<string, number>;
+  };
+}

package/src/domains/generation/wizard/infrastructure/strategies/shared/photo-extraction.utils.ts

@@ -4,10 +4,57 @@
  */
 
 import { readFileAsBase64 } from "@umituz/react-native-design-system";
+import { manipulateAsync, SaveFormat } from "expo-image-manipulator";
+import { Image } from "react-native";
 import { PHOTO_KEY_PREFIX } from "../wizard-strategy.constants";
 
 declare const __DEV__: boolean;
 
+const MIN_IMAGE_DIMENSION = 300;
+
+/**
+ * Get image dimensions from URI
+ */
+function getImageSize(uri: string): Promise<{ width: number; height: number }> {
+  return new Promise((resolve, reject) => {
+    Image.getSize(uri, (width, height) => resolve({ width, height }), reject);
+  });
+}
+
+/**
+ * Ensure image meets minimum dimensions (300x300) required by AI providers.
+ * Returns the original URI if already large enough, or a resized URI.
+ */
+async function ensureMinimumSize(uri: string): Promise<string> {
+  try {
+    const { width, height } = await getImageSize(uri);
+
+    if (width >= MIN_IMAGE_DIMENSION && height >= MIN_IMAGE_DIMENSION) {
+      return uri;
+    }
+
+    const scale = Math.max(MIN_IMAGE_DIMENSION / width, MIN_IMAGE_DIMENSION / height);
+    const newWidth = Math.ceil(width * scale);
+    const newHeight = Math.ceil(height * scale);
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[PhotoExtraction] Resizing small image", {
+        from: `${width}x${height}`,
+        to: `${newWidth}x${newHeight}`,
+      });
+    }
+
+    const result = await manipulateAsync(uri, [{ resize: { width: newWidth, height: newHeight } }], {
+      format: SaveFormat.JPEG,
+      compress: 0.9,
+    });
+
+    return result.uri;
+  } catch {
+    return uri;
+  }
+}
+
 /**
  * Extracts photo URIs from wizard data
  */
@@ -59,7 +106,8 @@ export async function extractPhotosAsBase64(
   const results = await Promise.allSettled(
     photoUris.map(async (uri, index) => {
       try {
-        return await readFileAsBase64(uri);
+        const resizedUri = await ensureMinimumSize(uri);
+        return await readFileAsBase64(resizedUri);
       } catch (error) {
         if (typeof __DEV__ !== "undefined" && __DEV__) {
           console.error(`[PhotoExtraction] Failed to read photo ${index}:`, error);

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

@@ -1,10 +1,12 @@
 /**
  * Video Generation Executor
- * Handles the actual video generation execution
- * Uses direct provider calls for text-to-video and image-to-video generation models
+ * Handles the actual video generation execution.
+ * Model-agnostic: uses VideoModelConfig.buildInput() for model-specific parameters.
+ * 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 { GENERATION_TIMEOUT_MS, BASE64_IMAGE_PREFIX } from "./wizard-strategy.constants";
 import { createGenerationError, GenerationErrorType } from "../../../../../infrastructure/utils/error-factory";
 
@@ -29,14 +31,38 @@ function formatBase64(base64: string | undefined): string | 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;
+  }
+
+  return modelInput;
+}
+
 /**
  * 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,
+  modelConfig?: VideoModelConfig,
 ): Promise<ExecutionResult> {
   const { providerRegistry } = await import("../../../../../infrastructure/services/provider-registry.service");
 
@@ -50,47 +76,19 @@ export async function executeVideoGeneration(
   }
 
   try {
-    const sourceImage = formatBase64(input.sourceImageBase64);
-
     if (typeof __DEV__ !== "undefined" && __DEV__) {
       console.log("[VideoExecutor] Generation starting", {
         model,
+        hasModelConfig: !!modelConfig,
         duration: input.duration,
-        aspectRatio: input.aspectRatio,
         resolution: input.resolution,
       });
     }
 
-    // Detect Minimax subject reference model
-    const isSubjectReference = model.includes("minimax") || model.includes("hailuo");
-
-    const modelInput: Record<string, unknown> = {
-      prompt: input.prompt,
-    };
-
-    if (sourceImage && sourceImage.length > 0) {
-      modelInput.image_url = sourceImage;
-    }
-
-    if (isSubjectReference) {
-      modelInput.prompt_optimizer = true;
-      if (input.duration) {
-        modelInput.duration = String(input.duration);
-      }
-      if (input.resolution) {
-        modelInput.resolution = input.resolution;
-      }
-    } else {
-      if (input.duration) {
-        modelInput.duration = input.duration;
-      }
-      if (input.aspectRatio) {
-        modelInput.aspect_ratio = input.aspectRatio;
-      }
-      if (input.resolution) {
-        modelInput.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, {
@@ -126,6 +124,7 @@ export async function executeVideoGeneration(
 export async function submitVideoGenerationToQueue(
   input: WizardVideoInput,
   model: string,
+  modelConfig?: VideoModelConfig,
 ): Promise<SubmissionResult> {
   const { providerRegistry } = await import("../../../../../infrastructure/services/provider-registry.service");
 
@@ -139,37 +138,10 @@ export async function submitVideoGenerationToQueue(
   }
 
   try {
-    const sourceImage = formatBase64(input.sourceImageBase64);
-
-    const isSubjectReference = model.includes("minimax") || model.includes("hailuo");
-
-    const modelInput: Record<string, unknown> = {
-      prompt: input.prompt,
-    };
-
-    if (sourceImage && sourceImage.length > 0) {
-      modelInput.image_url = sourceImage;
-    }
-
-    if (isSubjectReference) {
-      modelInput.prompt_optimizer = true;
-      if (input.duration) {
-        modelInput.duration = String(input.duration);
-      }
-      if (input.resolution) {
-        modelInput.resolution = input.resolution;
-      }
-    } else {
-      if (input.duration) {
-        modelInput.duration = input.duration;
-      }
-      if (input.aspectRatio) {
-        modelInput.aspect_ratio = input.aspectRatio;
-      }
-      if (input.resolution) {
-        modelInput.resolution = input.resolution;
-      }
-    }
+    // Use modelConfig.buildInput() if available, otherwise generic fallback
+    const modelInput = modelConfig
+      ? modelConfig.buildInput(input)
+      : buildGenericInput(input);
 
     const submission = await provider.submitJob(model, modelInput);
 

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

@@ -67,7 +67,7 @@ export async function buildVideoInput(
 }
 
 export function createVideoStrategy(options: CreateVideoStrategyOptions): WizardStrategy {
-  const { scenario, creditCost } = options;
+  const { scenario, modelConfig, creditCost } = options;
 
   // Validate model early - fail fast
   if (!scenario.model) {
@@ -78,10 +78,9 @@ export function createVideoStrategy(options: CreateVideoStrategyOptions): Wizard
 
   return {
     execute: async (input: unknown) => {
-      // Runtime validation with descriptive errors
       const videoInput = validateWizardVideoInput(input);
 
-      const result = await executeVideoGeneration(videoInput, model);
+      const result = await executeVideoGeneration(videoInput, model, undefined, modelConfig);
 
       if (!result.success || !result.videoUrl) {
         throw new Error(result.error || "Video generation failed");
@@ -91,10 +90,9 @@ export function createVideoStrategy(options: CreateVideoStrategyOptions): Wizard
     },
 
     submitToQueue: async (input: unknown) => {
-      // Runtime validation with descriptive errors
       const videoInput = validateWizardVideoInput(input);
 
-      const result = await submitVideoGenerationToQueue(videoInput, model);
+      const result = await submitVideoGenerationToQueue(videoInput, model, modelConfig);
 
       return {
         success: result.success,

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

@@ -5,6 +5,7 @@
 
 import type { WizardScenarioData } from "../../presentation/hooks/useWizardGeneration";
 import type { ScenarioInputType } from "../../../../scenarios/domain/Scenario";
+import type { VideoModelConfig } from "../../../../../domain/interfaces/video-model-config.types";
 
 export interface WizardVideoInput {
   /** Source image (optional for text-to-video) */
@@ -26,6 +27,8 @@ export interface WizardVideoResult {
 
 export interface CreateVideoStrategyOptions {
   readonly scenario: WizardScenarioData;
+  /** Model configuration - encapsulates all model-specific behavior */
+  readonly modelConfig?: VideoModelConfig;
   readonly collectionName?: string;
   /** Credit cost for this generation - REQUIRED, determined by the app */
   readonly creditCost: number;

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

@@ -6,6 +6,7 @@
 
 import type { WizardScenarioData } from "../../presentation/hooks/useWizardGeneration";
 import type { WizardStrategy } from "./wizard-strategy.types";
+import type { VideoModelConfig } from "../../../../../domain/interfaces/video-model-config.types";
 import { createImageStrategy, buildImageInput } from "./image-generation.strategy";
 import { createVideoStrategy, buildVideoInput } from "./video-generation.strategy";
 
@@ -17,6 +18,8 @@ export type { WizardStrategy } from "./wizard-strategy.types";
 
 export interface CreateWizardStrategyOptions {
   readonly scenario: WizardScenarioData;
+  /** Model configuration - encapsulates all model-specific behavior */
+  readonly modelConfig?: VideoModelConfig;
   readonly collectionName?: string;
   /** Credit cost for this generation - REQUIRED, determined by the app */
   readonly creditCost: number;
@@ -27,14 +30,14 @@ export interface CreateWizardStrategyOptions {
 // ============================================================================
 
 export function createWizardStrategy(options: CreateWizardStrategyOptions): WizardStrategy {
-  const { scenario, collectionName, creditCost } = options;
+  const { scenario, modelConfig, collectionName, creditCost } = options;
 
   if (scenario.outputType === "image") {
     return createImageStrategy({ scenario, collectionName, creditCost });
   }
 
   // Default to video strategy for video outputType or undefined
-  return createVideoStrategy({ scenario, collectionName, creditCost });
+  return createVideoStrategy({ scenario, modelConfig, collectionName, creditCost });
 }
 
 // ============================================================================

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

@@ -11,6 +11,7 @@ import type { WizardScenarioData } from "../hooks/useWizardGeneration";
 import type { AlertMessages } from "../../../../../presentation/hooks/generation/types";
 import type { GenerationErrorInfo } from "./WizardFlow.types";
 import type { CreditCalculatorFn } from "../../domain/types/credit-calculation.types";
+import type { VideoModelConfig } from "../../../../../domain/interfaces/video-model-config.types";
 import { validateScenario } from "../utilities/validateScenario";
 import { WizardFlowContent } from "./WizardFlowContent";
 import {
@@ -24,6 +25,8 @@ export interface GenericWizardFlowProps {
   readonly featureConfig: WizardFeatureConfig;
   readonly scenario?: WizardScenarioData;
   readonly scenarioId?: string;
+  /** Model configuration - encapsulates all model-specific behavior */
+  readonly modelConfig?: VideoModelConfig;
   readonly userId?: string;
   readonly alertMessages: AlertMessages;
   /** Credit cost for this generation - REQUIRED, determined by the app */
@@ -54,6 +57,7 @@ export const GenericWizardFlow: React.FC<GenericWizardFlowProps> = (props) => {
     featureConfig,
     scenario: scenarioProp,
     scenarioId,
+    modelConfig,
     userId,
     alertMessages,
     creditCost,
@@ -111,6 +115,7 @@ export const GenericWizardFlow: React.FC<GenericWizardFlowProps> = (props) => {
       featureConfig={featureConfig}
       scenario={scenario}
       validatedScenario={validatedScenario}
+      modelConfig={modelConfig}
       userId={userId}
       alertMessages={alertMessages}
       creditCost={creditCost}

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

@@ -20,11 +20,14 @@ import { extractDuration, extractResolution } from "../../infrastructure/utils/c
 import { WizardStepRenderer } from "./WizardStepRenderer";
 import { StarRatingPicker } from "../../../../result-preview/presentation/components/StarRatingPicker";
 import type { CreditCalculatorFn } from "../../domain/types/credit-calculation.types";
+import type { VideoModelConfig } from "../../../../../domain/interfaces/video-model-config.types";
 
 export interface WizardFlowContentProps {
   readonly featureConfig: WizardFeatureConfig;
   readonly scenario?: WizardScenarioData;
   readonly validatedScenario: WizardScenarioData;
+  /** Model configuration - encapsulates all model-specific behavior */
+  readonly modelConfig?: VideoModelConfig;
   readonly userId?: string;
   readonly alertMessages: AlertMessages;
   /** Credit cost for this generation - REQUIRED, determined by the app */
@@ -54,6 +57,7 @@ export const WizardFlowContent: React.FC<WizardFlowContentProps> = (props) => {
     featureConfig,
     scenario,
     validatedScenario,
+    modelConfig,
     userId,
     alertMessages,
     creditCost, // Still needed for initial feature gate in parent
@@ -174,6 +178,7 @@ export const WizardFlowContent: React.FC<WizardFlowContentProps> = (props) => {
 
   useWizardGeneration({
     scenario: validatedScenario,
+    modelConfig,
     wizardData: customData,
     userId,
     isGeneratingStep: currentStep?.type === StepType.GENERATING,

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

@@ -22,6 +22,7 @@ export type {
 export const useWizardGeneration = (props: UseWizardGenerationProps): UseWizardGenerationReturn => {
   const {
     scenario,
+    modelConfig,
     wizardData,
     userId,
     isGeneratingStep,
@@ -43,7 +44,7 @@ export const useWizardGeneration = (props: UseWizardGenerationProps): UseWizardG
   }, []);
 
   const persistence = useMemo(() => createCreationPersistence(), []);
-  const strategy = useMemo(() => createWizardStrategy({ scenario, creditCost }), [scenario, creditCost]);
+  const strategy = useMemo(() => createWizardStrategy({ scenario, modelConfig, creditCost }), [scenario, modelConfig, creditCost]);
   const isVideoMode = scenario.outputType === "video" && !!strategy.submitToQueue;
 
   const videoGeneration = useVideoQueueGeneration({

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

@@ -7,6 +7,39 @@ declare const __DEV__: boolean;
 /** Max consecutive transient errors before aborting */
 const MAX_CONSECUTIVE_ERRORS = 5;
 
+/**
+ * Extract meaningful error message from various error formats.
+ * Fal AI client throws ValidationError with empty .message but details in .body/.detail
+ */
+function extractErrorMessage(err: unknown): string {
+  if (!err) return "Generation failed";
+
+  // Standard Error with message
+  if (err instanceof Error && err.message && err.message.length > 0) {
+    return err.message;
+  }
+
+  // Fal AI ValidationError - has .body.detail array
+  const errObj = err as Record<string, unknown>;
+  if (errObj.body && typeof errObj.body === "object") {
+    const body = errObj.body as Record<string, unknown>;
+    if (Array.isArray(body.detail) && body.detail.length > 0) {
+      const first = body.detail[0] as { msg?: string; type?: string } | undefined;
+      if (first?.msg) return first.msg;
+    }
+  }
+
+  // Direct .detail array on error object
+  if (Array.isArray(errObj.detail) && errObj.detail.length > 0) {
+    const first = errObj.detail[0] as { msg?: string } | undefined;
+    if (first?.msg) return first.msg;
+  }
+
+  // Fallback to string conversion
+  const str = String(err);
+  return str.length > 0 && str !== "[object Object]" ? str : "Generation failed";
+}
+
 interface PollParams {
   requestId: string;
   model: string;
@@ -56,7 +89,7 @@ export const pollQueueStatus = async (params: PollParams): Promise<void> => {
           }
           await onComplete(urls);
         } catch (resultErr) {
-          const errorMessage = resultErr instanceof Error ? resultErr.message : "Generation failed";
+          const errorMessage = extractErrorMessage(resultErr);
           if (__DEV__) {
             console.error("[VideoQueueGeneration] ❌ Result error:", errorMessage);
             console.error("[VideoQueueGeneration] ❌ Full error:", resultErr);

package/src/domains/generation/wizard/presentation/hooks/wizard-generation.types.ts

@@ -5,6 +5,7 @@
 
 import type { AlertMessages } from "../../../../../presentation/hooks/generation/types";
 import type { ScenarioInputType, ScenarioPromptType } from "../../../../scenarios/domain/Scenario";
+import type { VideoModelConfig } from "../../../../../domain/interfaces/video-model-config.types";
 
 export type WizardOutputType = "image" | "video";
 
@@ -26,6 +27,8 @@ export interface WizardScenarioData {
 
 export interface UseWizardGenerationProps {
   readonly scenario: WizardScenarioData;
+  /** Model configuration - encapsulates all model-specific behavior */
+  readonly modelConfig?: VideoModelConfig;
   readonly wizardData: Record<string, unknown>;
   readonly userId?: string;
   readonly isGeneratingStep: boolean;

package/src/domains/generation/wizard/utilities/build-wizard-config.ts

@@ -0,0 +1,76 @@
+/**
+ * Build Wizard Config from VideoModelConfig
+ * Generates wizard step configuration from model capabilities.
+ * No hardcoded model-specific values - everything comes from config.
+ */
+
+import type { VideoModelConfig } from "../../../../domain/interfaces/video-model-config.types";
+import type { WizardFeatureConfig } from "../domain/entities/wizard-feature-config.types";
+import type { WizardStepConfig } from "../domain/entities/wizard-step.types";
+
+/**
+ * Builds a WizardFeatureConfig from a VideoModelConfig + input steps.
+ * Input steps (photo upload, text input) come from the caller.
+ * Resolution/duration/aspectRatio steps are auto-generated from model capabilities.
+ */
+export function buildWizardConfigFromModelConfig(
+  modelConfig: VideoModelConfig,
+  inputSteps: readonly WizardStepConfig[],
+): WizardFeatureConfig {
+  const steps: WizardStepConfig[] = [...inputSteps];
+
+  if (modelConfig.capabilities.resolutions.length > 0) {
+    steps.push({
+      id: "resolution",
+      type: "selection" as const,
+      titleKey: "generation.resolution.title",
+      selectionType: "resolution" as const,
+      options: modelConfig.capabilities.resolutions.map((r) => ({
+        id: r.id,
+        label: r.label,
+        value: r.value,
+      })),
+      required: true,
+      defaultValue: modelConfig.capabilities.defaults.resolution,
+    });
+  }
+
+  if (modelConfig.capabilities.aspectRatios && modelConfig.capabilities.aspectRatios.length > 0) {
+    steps.push({
+      id: "aspect_ratio",
+      type: "selection" as const,
+      titleKey: "generation.aspectRatio.title",
+      selectionType: "aspect_ratio" as const,
+      options: modelConfig.capabilities.aspectRatios.map((a) => ({
+        id: a.id,
+        label: a.label,
+        value: a.value,
+      })),
+      required: true,
+      defaultValue: modelConfig.capabilities.defaults.aspectRatio,
+    });
+  }
+
+  if (modelConfig.capabilities.durations.length > 0) {
+    steps.push({
+      id: "duration",
+      type: "selection" as const,
+      titleKey: "generation.duration.title",
+      selectionType: "duration" as const,
+      layout: "list" as const,
+      options: modelConfig.capabilities.durations.map((d) => ({
+        id: d.id,
+        label: d.label,
+        value: d.value,
+      })),
+      required: true,
+      defaultValue: modelConfig.capabilities.defaults.duration,
+    });
+  }
+
+  return {
+    id: modelConfig.modelId,
+    name: modelConfig.displayName,
+    steps,
+  };
+}

package/src/index.ts

@@ -40,3 +40,9 @@ export {
   getCreditConfig,
 } from "./domains/generation/wizard";
 export type { ValidationResult, CreditCalculatorFn } from "./domains/generation/wizard";
+
+// Video Model Config (for app-side model definitions)
+export type { VideoModelConfig, ModelCapabilityOption } from "./domain/interfaces";
+
+// Wizard Config Builder (generates wizard steps from VideoModelConfig)
+export { buildWizardConfigFromModelConfig } from "./domains/generation/wizard/utilities/build-wizard-config";