@umituz/react-native-ai-generation-content 1.61.0 → 1.61.2

package/package.json

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

package/src/infrastructure/services/image-feature-executor.service.ts

@@ -4,25 +4,16 @@
  * Output: image URL
  */
 
-import { providerRegistry } from "./provider-registry.service";
-import { cleanBase64, extractErrorMessage } from "../utils";
+import { extractErrorMessage, validateProvider, prepareImageInputData } from "../utils";
 import { extractImageResult } from "../utils/url-extractor";
 import type { ImageResultExtractor } from "../utils/url-extractor";
-import type { ImageFeatureType, ImageFeatureInputData } from "../../domain/interfaces";
+import type { ImageFeatureType } from "../../domain/interfaces";
 
-declare const __DEV__: boolean;
-
-/**
- * Execution options
- */
 export interface ExecuteImageFeatureOptions {
   extractResult?: ImageResultExtractor;
   onProgress?: (progress: number) => void;
 }
 
-/**
- * Execution result
- */
 export interface ImageFeatureResult {
   success: boolean;
   imageUrl?: string;
@@ -30,9 +21,6 @@ export interface ImageFeatureResult {
   requestId?: string;
 }
 
-/**
- * Request data for image features
- */
 export interface ImageFeatureRequest {
   imageBase64?: string;
   targetImageBase64?: string;
@@ -48,41 +36,26 @@ export async function executeImageFeature(
   request: ImageFeatureRequest,
   options?: ExecuteImageFeatureOptions,
 ): Promise<ImageFeatureResult> {
-  const provider = providerRegistry.getActiveProvider();
-
-  if (!provider) {
-    return { success: false, error: "No AI provider configured" };
-  }
-
-  if (!provider.isInitialized()) {
-    return { success: false, error: "AI provider not initialized" };
+  const validation = validateProvider(`Image:${featureType}`);
+  if (!validation.success) {
+    return { success: false, error: validation.error };
   }
 
+  const { provider } = validation;
   const { extractResult, onProgress } = options ?? {};
-
   const model = provider.getImageFeatureModel(featureType);
 
-  if (__DEV__) {
-     
-    console.log(`[Image:${featureType}] Provider: ${provider.providerId}, Model: ${model}`);
-  }
-
   try {
-    const inputData: ImageFeatureInputData = {
-      imageBase64: request.imageBase64 ? cleanBase64(request.imageBase64) : "",
-      targetImageBase64: request.targetImageBase64
-        ? cleanBase64(request.targetImageBase64)
-        : undefined,
-      prompt: request.prompt,
-      options: request.options,
-    };
-
+    const inputData = prepareImageInputData(
+      request.imageBase64 ?? "",
+      request.targetImageBase64,
+      request.prompt,
+      request.options,
+    );
     const input = provider.buildImageFeatureInput(featureType, inputData);
     const result = await provider.run(model, input);
 
-    const extractor = extractResult ?? extractImageResult;
-    const imageUrl = extractor(result);
-
+    const imageUrl = (extractResult ?? extractImageResult)(result);
     onProgress?.(100);
 
     if (!imageUrl) {
@@ -104,6 +77,5 @@ export async function executeImageFeature(
  * Check if image features are supported
  */
 export function hasImageFeatureSupport(): boolean {
-  const provider = providerRegistry.getActiveProvider();
-  return provider !== null && provider.isInitialized();
+  return validateProvider("ImageFeatureSupport").success;
 }

package/src/infrastructure/services/video-feature-executor.service.ts

@@ -4,137 +4,53 @@
  * Output: video URL
  */
 
-import { providerRegistry } from "./provider-registry.service";
-import { cleanBase64, extractErrorMessage, checkFalApiError } from "../utils";
+import { extractErrorMessage, checkFalApiError, validateProvider, prepareVideoInputData } from "../utils";
 import { extractVideoResult } from "../utils/url-extractor";
 import { VIDEO_TIMEOUT_MS } from "../constants";
-import type { VideoFeatureType, VideoFeatureInputData } from "../../domain/interfaces";
-import type {
-  ExecuteVideoFeatureOptions,
-  VideoFeatureResult,
-  VideoFeatureRequest,
-} from "./video-feature-executor.types";
+import type { VideoFeatureType } from "../../domain/interfaces";
+import type { ExecuteVideoFeatureOptions, VideoFeatureResult, VideoFeatureRequest } from "./video-feature-executor.types";
 
 declare const __DEV__: boolean;
 
 /**
  * Execute any video feature using the active provider
- * Uses subscribe for video features to handle long-running generation with progress updates
  */
 export async function executeVideoFeature(
   featureType: VideoFeatureType,
   request: VideoFeatureRequest,
   options?: ExecuteVideoFeatureOptions,
 ): Promise<VideoFeatureResult> {
-  if (__DEV__) {
-    console.log(`[VideoExecutor:${featureType}] START`, {
-      hasSource: !!request.sourceImageBase64,
-      hasTarget: !!request.targetImageBase64,
-      promptLength: request.prompt?.length ?? 0,
-      options: request.options,
-    });
-  }
-
-  const provider = providerRegistry.getActiveProvider();
-
-  if (!provider) {
-    if (__DEV__) {
-      console.log(`[VideoExecutor:${featureType}] ERROR: No provider`);
-    }
-    return { success: false, error: "No AI provider configured" };
-  }
-
-  if (!provider.isInitialized()) {
-    if (__DEV__) {
-      console.log(`[VideoExecutor:${featureType}] ERROR: Provider not initialized`);
-    }
-    return { success: false, error: "AI provider not initialized" };
+  const validation = validateProvider(`VideoExecutor:${featureType}`);
+  if (!validation.success) {
+    return { success: false, error: validation.error };
   }
 
+  const { provider } = validation;
   const { extractResult, onStatusChange } = options ?? {};
-
   const model = provider.getVideoFeatureModel(featureType);
 
-  if (__DEV__) {
-    console.log(`[VideoExecutor:${featureType}] Provider: ${provider.providerId}, Model: ${model}`);
-  }
-
   try {
-    const inputData: VideoFeatureInputData = {
-      sourceImageBase64: cleanBase64(request.sourceImageBase64),
-      targetImageBase64: cleanBase64(request.targetImageBase64),
-      prompt: request.prompt,
-      options: request.options,
-    };
-
-    if (__DEV__) {
-      console.log(`[VideoExecutor:${featureType}] InputData prepared`, {
-        sourceSize: inputData.sourceImageBase64 ? `${(inputData.sourceImageBase64.length / 1024).toFixed(1)}KB` : "N/A",
-        targetSize: inputData.targetImageBase64 ? `${(inputData.targetImageBase64.length / 1024).toFixed(1)}KB` : "N/A",
-        prompt: inputData.prompt?.substring(0, 50) + "...",
-      });
-    }
-
+    const inputData = prepareVideoInputData(
+      request.sourceImageBase64,
+      request.targetImageBase64,
+      request.prompt,
+      request.options,
+    );
     const input = provider.buildVideoFeatureInput(featureType, inputData);
 
-    if (__DEV__) {
-      console.log(`[VideoExecutor:${featureType}] Built input for API`, {
-        inputKeys: Object.keys(input),
-        hasImageUrl: !!(input as Record<string, unknown>).image_url,
-        hasPrompt: !!(input as Record<string, unknown>).prompt,
-      });
-    }
-
-    let statusCount = 0;
     const result = await provider.subscribe(model, input, {
       timeoutMs: VIDEO_TIMEOUT_MS,
-      onQueueUpdate: (status) => {
-        statusCount++;
-        // Log every 10th status update to avoid spam
-        if (__DEV__ && statusCount % 10 === 1) {
-          console.log(`[VideoExecutor:${featureType}] Queue #${statusCount}:`, status.status);
-        }
-        onStatusChange?.(status.status);
-      },
+      onQueueUpdate: (status) => onStatusChange?.(status.status),
     });
 
-    if (__DEV__) {
-      console.log(`[VideoExecutor:${featureType}] API Response received`, {
-        totalStatusUpdates: statusCount,
-        resultKeys: result ? Object.keys(result as object) : "null",
-        resultType: typeof result,
-      });
-    }
-
-    // Check for FAL API error in result (may return with COMPLETED status)
     checkFalApiError(result);
 
-    const extractor = extractResult ?? extractVideoResult;
-    const videoUrl = extractor(result);
-
-    if (__DEV__) {
-      console.log(`[VideoExecutor:${featureType}] Extracted video URL`, {
-        hasVideoUrl: !!videoUrl,
-        urlPreview: videoUrl ? videoUrl.substring(0, 80) + "..." : "N/A",
-      });
-    }
+    const videoUrl = (extractResult ?? extractVideoResult)(result);
 
     if (!videoUrl) {
-      if (__DEV__) {
-        console.log(`[VideoExecutor:${featureType}] FAILED: No video URL`, {
-          result: JSON.stringify(result).substring(0, 500),
-        });
-      }
       return { success: false, error: "No video in response" };
     }
 
-    if (__DEV__) {
-      console.log(`[VideoExecutor:${featureType}] SUCCESS`, {
-        videoUrl: videoUrl.substring(0, 80) + "...",
-        requestId: (result as { requestId?: string })?.requestId,
-      });
-    }
-
     return {
       success: true,
       videoUrl,
@@ -142,12 +58,6 @@ export async function executeVideoFeature(
     };
   } catch (error) {
     const message = extractErrorMessage(error, "Processing failed", `Video:${featureType}`);
-    if (__DEV__) {
-      console.log(`[VideoExecutor:${featureType}] EXCEPTION`, {
-        error: message,
-        originalError: error instanceof Error ? error.message : String(error),
-      });
-    }
     return { success: false, error: message };
   }
 }
@@ -156,67 +66,38 @@ export async function executeVideoFeature(
  * Check if video features are supported
  */
 export function hasVideoFeatureSupport(): boolean {
-  const provider = providerRegistry.getActiveProvider();
-  return provider !== null && provider.isInitialized();
+  const validation = validateProvider("VideoFeatureSupport");
+  return validation.success;
 }
 
 /**
  * Submit a video feature to the queue for background processing
- * Returns immediately with requestId and model for later status polling
  */
 export async function submitVideoFeatureToQueue(
   featureType: VideoFeatureType,
   request: VideoFeatureRequest,
 ): Promise<{ success: boolean; requestId?: string; model?: string; error?: string }> {
-  if (__DEV__) {
-    console.log(`[VideoExecutor:${featureType}] QUEUE SUBMIT`, {
-      hasSource: !!request.sourceImageBase64,
-      hasTarget: !!request.targetImageBase64,
-      promptLength: request.prompt?.length ?? 0,
-    });
-  }
-
-  const provider = providerRegistry.getActiveProvider();
-
-  if (!provider) {
-    return { success: false, error: "No AI provider configured" };
-  }
-
-  if (!provider.isInitialized()) {
-    return { success: false, error: "AI provider not initialized" };
+  const validation = validateProvider(`VideoExecutor:${featureType}`);
+  if (!validation.success) {
+    return { success: false, error: validation.error };
   }
 
+  const { provider } = validation;
   const model = provider.getVideoFeatureModel(featureType);
 
   try {
-    const inputData: VideoFeatureInputData = {
-      sourceImageBase64: cleanBase64(request.sourceImageBase64),
-      targetImageBase64: cleanBase64(request.targetImageBase64),
-      prompt: request.prompt,
-      options: request.options,
-    };
-
+    const inputData = prepareVideoInputData(
+      request.sourceImageBase64,
+      request.targetImageBase64,
+      request.prompt,
+      request.options,
+    );
     const input = provider.buildVideoFeatureInput(featureType, inputData);
-
     const submission = await provider.submitJob(model, input);
 
-    if (__DEV__) {
-      console.log(`[VideoExecutor:${featureType}] QUEUE SUBMITTED`, {
-        requestId: submission.requestId,
-        model,
-      });
-    }
-
-    return {
-      success: true,
-      requestId: submission.requestId,
-      model,
-    };
+    return { success: true, requestId: submission.requestId, model };
   } catch (error) {
     const message = extractErrorMessage(error, "Queue submission failed", `Video:${featureType}`);
-    if (__DEV__) {
-      console.error(`[VideoExecutor:${featureType}] QUEUE EXCEPTION`, { error: message });
-    }
     return { success: false, error: message };
   }
 }

package/src/infrastructure/utils/index.ts

@@ -13,3 +13,4 @@ export * from "./photo-generation";
 export * from "./feature-utils";
 export * from "./video-helpers";
 export * from "./media-actions.util";
+export * from "./provider-validator.util";

package/src/infrastructure/utils/provider-validator.util.ts

@@ -0,0 +1,71 @@
+/**
+ * Provider Validator Utility
+ * Validates provider state and prepares feature inputs
+ */
+
+import { providerRegistry } from "../services/provider-registry.service";
+import { cleanBase64 } from "./index";
+import type { IAIProvider, VideoFeatureInputData, ImageFeatureInputData } from "../../domain/interfaces";
+
+declare const __DEV__: boolean;
+
+export type ProviderValidationResult =
+  | { success: true; provider: IAIProvider }
+  | { success: false; error: string };
+
+/**
+ * Validate provider is available and initialized
+ */
+export function validateProvider(context: string): ProviderValidationResult {
+  const provider = providerRegistry.getActiveProvider();
+
+  if (!provider) {
+    if (__DEV__) {
+      console.log(`[${context}] ERROR: No provider`);
+    }
+    return { success: false, error: "No AI provider configured" };
+  }
+
+  if (!provider.isInitialized()) {
+    if (__DEV__) {
+      console.log(`[${context}] ERROR: Provider not initialized`);
+    }
+    return { success: false, error: "AI provider not initialized" };
+  }
+
+  return { success: true, provider };
+}
+
+/**
+ * Prepare video feature input data
+ */
+export function prepareVideoInputData(
+  sourceImageBase64?: string,
+  targetImageBase64?: string,
+  prompt?: string,
+  options?: Record<string, unknown>,
+): VideoFeatureInputData {
+  return {
+    sourceImageBase64: cleanBase64(sourceImageBase64),
+    targetImageBase64: cleanBase64(targetImageBase64),
+    prompt,
+    options,
+  };
+}
+
+/**
+ * Prepare image feature input data
+ */
+export function prepareImageInputData(
+  imageBase64: string,
+  targetImageBase64?: string,
+  prompt?: string,
+  options?: Record<string, unknown>,
+): ImageFeatureInputData {
+  return {
+    imageBase64: cleanBase64(imageBase64) ?? "",
+    targetImageBase64: cleanBase64(targetImageBase64),
+    prompt,
+    options,
+  };
+}