@umituz/react-native-ai-generation-content 1.26.1 → 1.26.4

package/src/infrastructure/executors/image-executor.ts

@@ -0,0 +1,133 @@
+/**
+ * Image Generation Executor
+ * Generic executor for all image generation features
+ */
+
+import type {
+  GenerationExecutor,
+  ImageGenerationInput,
+  ImageGenerationOutput,
+  GenerationOptions,
+  GenerationResult,
+} from "../../domains/generation/domain/generation.types";
+import { providerRegistry } from "../services/provider-registry.service";
+
+declare const __DEV__: boolean;
+
+export class ImageExecutor
+  implements GenerationExecutor<ImageGenerationInput, ImageGenerationOutput>
+{
+  async generate(
+    model: string,
+    input: ImageGenerationInput,
+    options?: GenerationOptions,
+  ): Promise<GenerationResult<ImageGenerationOutput>> {
+    try {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[ImageExecutor] Starting generation", {
+          model,
+          hasImages: !!input.imageUrls,
+          imageCount: input.imageUrls?.length || 0,
+          promptLength: input.prompt?.length || 0,
+        });
+      }
+
+      const provider = providerRegistry.getActiveProvider();
+
+      if (!provider?.isInitialized()) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.error("[ImageExecutor] Provider not initialized");
+        }
+        return { success: false, error: "AI provider not initialized" };
+      }
+
+      options?.onProgress?.(5);
+
+      const modelInput = this.buildModelInput(input);
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[ImageExecutor] Model input prepared", {
+          imageCount: modelInput.image_urls?.length || 0,
+          aspectRatio: modelInput.aspect_ratio,
+          outputFormat: modelInput.output_format,
+        });
+      }
+
+      options?.onProgress?.(10);
+
+      const result = await provider.subscribe(model, modelInput, {
+        timeoutMs: options?.timeoutMs ?? 300000,
+        onQueueUpdate: (status) => {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.log("[ImageExecutor] Queue status:", status.status);
+          }
+
+          if (status.status === "IN_QUEUE") {
+            options?.onProgress?.(20);
+          } else if (status.status === "IN_PROGRESS") {
+            options?.onProgress?.(50);
+          }
+        },
+      });
+
+      options?.onProgress?.(90);
+
+      const imageUrl = this.extractImageUrl(result);
+
+      if (!imageUrl) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.error("[ImageExecutor] No image URL in response");
+        }
+        return { success: false, error: "No image generated" };
+      }
+
+      options?.onProgress?.(100);
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[ImageExecutor] Generation successful", {
+          imageUrl: imageUrl.slice(0, 100),
+        });
+      }
+
+      return { success: true, data: { imageUrl } };
+    } catch (error) {
+      const message =
+        error instanceof Error ? error.message : "Generation failed";
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.error("[ImageExecutor] Generation error:", {
+          message,
+          error,
+        });
+      }
+
+      return { success: false, error: message };
+    }
+  }
+
+  private buildModelInput(input: ImageGenerationInput) {
+    const { imageUrls, prompt, aspectRatio, outputFormat } = input;
+
+    const formattedUrls = imageUrls?.map((url) =>
+      url.startsWith("data:") ? url : `data:image/jpeg;base64,${url}`,
+    );
+
+    return {
+      ...(formattedUrls && formattedUrls.length > 0
+        ? { image_urls: formattedUrls }
+        : {}),
+      prompt,
+      aspect_ratio: aspectRatio ?? "4:3",
+      output_format: outputFormat ?? "jpeg",
+      num_images: 1,
+    };
+  }
+
+  private extractImageUrl(result: unknown): string | undefined {
+    const rawResult = result as Record<string, unknown>;
+    const data = (rawResult?.data ?? rawResult) as {
+      images?: Array<{ url: string }>;
+    };
+    return data?.images?.[0]?.url;
+  }
+}

package/src/infrastructure/executors/video-executor.ts

@@ -0,0 +1,130 @@
+/**
+ * Video Generation Executor
+ * Generic executor for all video generation features
+ */
+
+import type {
+  GenerationExecutor,
+  VideoGenerationInput,
+  VideoGenerationOutput,
+  GenerationOptions,
+  GenerationResult,
+} from "../../domains/generation/domain/generation.types";
+import { providerRegistry } from "../services/provider-registry.service";
+
+declare const __DEV__: boolean;
+
+export class VideoExecutor
+  implements GenerationExecutor<VideoGenerationInput, VideoGenerationOutput>
+{
+  async generate(
+    model: string,
+    input: VideoGenerationInput,
+    options?: GenerationOptions,
+  ): Promise<GenerationResult<VideoGenerationOutput>> {
+    try {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[VideoExecutor] Starting generation", {
+          model,
+          hasSourceImage: !!input.sourceImageBase64,
+          hasTargetImage: !!input.targetImageBase64,
+          hasPrompt: !!input.prompt,
+        });
+      }
+
+      const provider = providerRegistry.getActiveProvider();
+
+      if (!provider?.isInitialized()) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.error("[VideoExecutor] Provider not initialized");
+        }
+        return { success: false, error: "AI provider not initialized" };
+      }
+
+      options?.onProgress?.(5);
+
+      const modelInput = this.buildModelInput(input);
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[VideoExecutor] Model input prepared");
+      }
+
+      options?.onProgress?.(10);
+
+      const result = await provider.subscribe(model, modelInput, {
+        timeoutMs: options?.timeoutMs ?? 300000,
+        onQueueUpdate: (status) => {
+          if (typeof __DEV__ !== "undefined" && __DEV__) {
+            console.log("[VideoExecutor] Queue status:", status.status);
+          }
+
+          if (status.status === "IN_QUEUE") {
+            options?.onProgress?.(20);
+          } else if (status.status === "IN_PROGRESS") {
+            options?.onProgress?.(50);
+          }
+        },
+      });
+
+      options?.onProgress?.(90);
+
+      const videoUrl = this.extractVideoUrl(result);
+
+      if (!videoUrl) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.error("[VideoExecutor] No video URL in response");
+        }
+        return { success: false, error: "No video generated" };
+      }
+
+      options?.onProgress?.(100);
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[VideoExecutor] Generation successful", {
+          videoUrl: videoUrl.slice(0, 100),
+        });
+      }
+
+      return { success: true, data: { videoUrl } };
+    } catch (error) {
+      const message =
+        error instanceof Error ? error.message : "Generation failed";
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.error("[VideoExecutor] Generation error:", {
+          message,
+          error,
+        });
+      }
+
+      return { success: false, error: message };
+    }
+  }
+
+  private buildModelInput(input: VideoGenerationInput) {
+    const { sourceImageBase64, targetImageBase64, prompt } = input;
+
+    const formatBase64 = (base64: string): string => {
+      if (!base64) return "";
+      return base64.startsWith("data:")
+        ? base64
+        : `data:image/jpeg;base64,${base64}`;
+    };
+
+    return {
+      image_url: formatBase64(sourceImageBase64),
+      ...(targetImageBase64
+        ? { driver_image_url: formatBase64(targetImageBase64) }
+        : {}),
+      ...(prompt ? { prompt } : {}),
+    };
+  }
+
+  private extractVideoUrl(result: unknown): string | undefined {
+    const rawResult = result as Record<string, unknown>;
+    const data = (rawResult?.data ?? rawResult) as {
+      video?: { url: string };
+    };
+    return data?.video?.url;
+  }
+}

package/src/infrastructure/providers/generation-config.provider.tsx

@@ -14,13 +14,13 @@ declare const __DEV__: boolean;
 
 export interface GenerationModels {
   /** Image generation with face identity preservation (couple photos) */
-  readonly imageCoupleMultiRef: string;
+  readonly imageCoupleMultiRef?: string;
   /** Text-to-image generation */
-  readonly imageTextToImage: string;
+  readonly imageTextToImage?: string;
   /** Image-to-video generation */
-  readonly imageToVideo: string;
+  readonly imageToVideo?: string;
   /** Text-to-video generation */
-  readonly textToVideo: string;
+  readonly textToVideo?: string;
   /** AI Kiss video */
   readonly aiKiss?: string;
   /** AI Hug video */
@@ -62,19 +62,30 @@ export const GenerationConfigProvider: React.FC<GenerationConfigProviderProps> =
   models,
 }) => {
   if (typeof __DEV__ !== "undefined" && __DEV__) {
+    const configuredModels = Object.entries(models)
+      .filter(([, value]) => !!value)
+      .map(([key]) => key);
+
     console.log("[GenerationConfigProvider] Initialized with models:", {
-      imageCoupleMultiRef: models.imageCoupleMultiRef,
-      imageTextToImage: models.imageTextToImage,
-      imageToVideo: models.imageToVideo,
-      textToVideo: models.textToVideo,
+      configured: configuredModels,
+      imageCoupleMultiRef: models.imageCoupleMultiRef || "not configured",
+      imageTextToImage: models.imageTextToImage || "not configured",
+      imageToVideo: models.imageToVideo || "not configured",
+      textToVideo: models.textToVideo || "not configured",
     });
   }
 
   const getModel = (featureType: keyof GenerationModels): string => {
     const model = models[featureType];
     if (!model) {
+      const availableModels = Object.keys(models).filter(
+        (key) => models[key as keyof GenerationModels]
+      );
+
       throw new Error(
-        `Model not configured for feature: ${featureType}. Please configure in app's GenerationConfigProvider.`
+        `Model not configured for feature: ${featureType}.\n\n` +
+        `This app only supports: ${availableModels.join(", ") || "none"}.\n` +
+        `Please configure '${featureType}' in your GenerationConfigProvider if you need it.`
       );
     }
     return model;