@umituz/react-native-ai-gemini-provider 1.14.12 → 1.14.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-gemini-provider",
-  "version": "1.14.12",
+  "version": "1.14.13",
   "description": "Google Gemini AI provider for React Native applications",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/infrastructure/services/gemini-provider.ts

@@ -10,12 +10,12 @@ import type {
   JobSubmission,
   JobStatus,
   SubscribeOptions,
-  RunOptions,
   ImageFeatureType,
   VideoFeatureType,
   ImageFeatureInputData,
   VideoFeatureInputData,
 } from "@umituz/react-native-ai-generation-content";
+import type { ExecutionOptions } from "./generation-executor";
 import type {
   GeminiImageInput,
   GeminiImageGenerationResult,
@@ -88,11 +88,9 @@ export class GeminiProvider implements IAIProvider {
   async run<T = unknown>(
     model: string,
     input: Record<string, unknown>,
-    options?: RunOptions,
+    options?: ExecutionOptions,
   ): Promise<T> {
-    return generationExecutor.executeGeneration<T>(model, input, {
-      onProgress: options?.onProgress,
-    });
+    return generationExecutor.executeGeneration<T>(model, input, options);
   }
 
   async generateImage(prompt: string): Promise<GeminiImageGenerationResult> {

package/src/infrastructure/services/gemini-video-downloader.ts

@@ -0,0 +1,77 @@
+/**
+ * Gemini Video Downloader
+ * Single Responsibility: Download video from Veo URL and convert to base64
+ * Required because Veo URLs need x-goog-api-key authentication
+ */
+
+declare const __DEV__: boolean;
+
+export interface VideoDownloadResult {
+  base64DataUri: string;
+  sizeInMB: number;
+  mimeType: string;
+}
+
+/**
+ * Download video from authenticated Veo URL
+ */
+export async function downloadVideoFromVeo(
+  videoUrl: string,
+  apiKey: string,
+): Promise<VideoDownloadResult> {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    // eslint-disable-next-line no-console
+    console.log("[GeminiVideoDownloader] Downloading video from Veo...");
+  }
+
+  const response = await fetch(videoUrl, {
+    method: "GET",
+    headers: {
+      "x-goog-api-key": apiKey,
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to download video: ${response.status}`);
+  }
+
+  const blob = await response.blob();
+  const sizeInMB = blob.size / 1024 / 1024;
+
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    // eslint-disable-next-line no-console
+    console.log("[GeminiVideoDownloader] Video downloaded", {
+      size: `${sizeInMB.toFixed(2)} MB`,
+      type: blob.type,
+    });
+  }
+
+  const base64DataUri = await convertBlobToBase64(blob);
+
+  return {
+    base64DataUri,
+    sizeInMB,
+    mimeType: blob.type || "video/mp4",
+  };
+}
+
+/**
+ * Convert blob to base64 data URI
+ */
+function convertBlobToBase64(blob: Blob): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onloadend = () => {
+      const base64 = reader.result as string;
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        // eslint-disable-next-line no-console
+        console.log("[GeminiVideoDownloader] Video converted to base64", {
+          length: base64.length,
+        });
+      }
+      resolve(base64);
+    };
+    reader.onerror = () => reject(new Error("Failed to convert video to base64"));
+    reader.readAsDataURL(blob);
+  });
+}

package/src/infrastructure/services/gemini-video-error.ts

@@ -0,0 +1,21 @@
+/**
+ * Gemini Video Error Factory
+ * Single Responsibility: Create typed video generation errors
+ */
+
+import type { VideoGenerationError } from "../../domain/entities";
+
+/**
+ * Create a typed video generation error
+ */
+export function createVideoError(
+  type: VideoGenerationError["type"],
+  message: string,
+  statusCode?: number,
+): VideoGenerationError {
+  const error = new Error(message) as VideoGenerationError;
+  error.type = type;
+  error.statusCode = statusCode;
+  error.retryable = type === "NETWORK" || type === "TIMEOUT";
+  return error;
+}

package/src/infrastructure/services/gemini-video-generation.service.ts

@@ -1,190 +1,123 @@
 /**
  * Gemini Video Generation Service
- * Handles video generation using Google Veo REST API (predictLongRunning)
+ * Orchestrates video generation using Google Veo REST API
  * @see https://ai.google.dev/gemini-api/docs/video
  */
 
-import { calculatePollingProgress } from "@umituz/react-native-ai-generation-content";
 import { geminiClientCoreService } from "./gemini-client-core.service";
 import { geminiRetryService } from "./gemini-retry.service";
+import { downloadVideoFromVeo } from "./gemini-video-downloader";
+import { extractVideoUrl } from "./gemini-video-url-extractor";
+import { createVideoError } from "./gemini-video-error";
 import { DEFAULT_MODELS } from "../../domain/entities";
 import type {
   VideoGenerationInput,
   VideoGenerationResult,
   VideoGenerationProgress,
   VeoOperation,
-  VideoGenerationError,
   TextToVideoInput,
 } from "../../domain/entities";
 
 declare const __DEV__: boolean;
 
-const DEFAULT_POLL_INTERVAL = 10000; // 10 seconds
-const MAX_POLL_DURATION = 300000; // 5 minutes
-const MAX_POLL_ATTEMPTS = Math.floor(MAX_POLL_DURATION / DEFAULT_POLL_INTERVAL);
+const POLL_INTERVAL = 10000;
+const MAX_POLL_DURATION = 300000;
+const MAX_POLL_ATTEMPTS = Math.floor(MAX_POLL_DURATION / POLL_INTERVAL);
 const VEO_API_BASE = "https://generativelanguage.googleapis.com/v1beta";
 
+/** Calculate polling progress (10-95% range) */
+function calculateProgress(attempt: number, maxAttempts: number): number {
+  return Math.round(10 + (attempt / maxAttempts) * 85);
+}
+
 class GeminiVideoGenerationService {
-  /**
-   * Generate video from text prompt using Veo REST API (text-to-video)
-   * Uses predictLongRunning endpoint with instances/parameters format
-   */
   async generateTextToVideo(
     input: TextToVideoInput,
     onProgress?: (progress: VideoGenerationProgress) => void,
   ): Promise<VideoGenerationResult> {
     geminiClientCoreService.validateInitialization();
-    this.validateTextInput(input);
+    this.validatePrompt(input.prompt);
 
     const config = geminiClientCoreService.getConfig();
-    const videoModel = config?.videoGenerationModel || DEFAULT_MODELS.VIDEO_GENERATION;
+    const model = config?.videoGenerationModel || DEFAULT_MODELS.VIDEO_GENERATION;
     const apiKey = config?.apiKey;
+    if (!apiKey) throw createVideoError("INVALID_INPUT", "API key is required");
 
     if (typeof __DEV__ !== "undefined" && __DEV__) {
       // eslint-disable-next-line no-console
-      console.log("[GeminiVideoGeneration] generateTextToVideo() called", {
-        model: videoModel,
-        promptLength: input.prompt.length,
-      });
-    }
-
-    // REST API uses predictLongRunning endpoint
-    const url = `${VEO_API_BASE}/models/${videoModel}:predictLongRunning`;
-
-    // REST API format: instances array with parameters object
-    const requestBody = {
-      instances: [{ prompt: input.prompt }],
-      parameters: {
-        aspectRatio: input.options?.aspectRatio || "16:9",
-        ...(input.negativePrompt && { negativePrompt: input.negativePrompt }),
-      },
-    };
-
-    onProgress?.({ status: "queued", progress: 5 });
-
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[GeminiVideoGeneration] Request URL:", url);
-      // eslint-disable-next-line no-console
-      console.log("[GeminiVideoGeneration] Request body:", JSON.stringify(requestBody, null, 2));
-    }
-
-    const operation = await geminiRetryService.executeWithRetry(async () => {
-      const res = await fetch(url, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "x-goog-api-key": apiKey!,
-        },
-        body: JSON.stringify(requestBody),
-      });
-
-      if (!res.ok) {
-        const errorText = await res.text();
-        throw this.createError("OPERATION_FAILED", `Veo API error (${res.status}): ${errorText}`, res.status);
-      }
-
-      return res.json() as Promise<VeoOperation>;
-    });
-
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[GeminiVideoGeneration] Operation started", {
-        operationName: operation.name,
-      });
+      console.log("[GeminiVideoGeneration] generateTextToVideo()", { model });
     }
 
-    onProgress?.({ status: "processing", progress: 10 });
-
-    return this.pollOperation(operation.name, apiKey!, videoModel, onProgress);
+    const operation = await this.startOperation(input, model, apiKey, onProgress);
+    return this.pollOperation(operation.name, apiKey, model, onProgress);
   }
 
-  /**
-   * Generate video from image and prompt using Veo REST API (image-to-video)
-   * Uses predictLongRunning endpoint with image in instances
-   */
   async generateVideo(
     input: VideoGenerationInput,
     onProgress?: (progress: VideoGenerationProgress) => void,
   ): Promise<VideoGenerationResult> {
-    // If no image provided, use text-to-video
-    if (!input.image) {
-      return this.generateTextToVideo(input, onProgress);
-    }
+    if (!input.image) return this.generateTextToVideo(input, onProgress);
 
     geminiClientCoreService.validateInitialization();
-    this.validateInput(input);
+    this.validatePrompt(input.prompt);
 
     const config = geminiClientCoreService.getConfig();
-    const videoModel = config?.videoGenerationModel || DEFAULT_MODELS.VIDEO_GENERATION;
+    const model = config?.videoGenerationModel || DEFAULT_MODELS.VIDEO_GENERATION;
     const apiKey = config?.apiKey;
+    if (!apiKey) throw createVideoError("INVALID_INPUT", "API key is required");
 
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[GeminiVideoGeneration] generateVideo() called", {
-        model: videoModel,
-        promptLength: input.prompt.length,
-        hasImage: !!input.image,
-      });
-    }
-
-    // REST API uses predictLongRunning endpoint
-    const url = `${VEO_API_BASE}/models/${videoModel}:predictLongRunning`;
+    const operation = await this.startImageToVideoOperation(input, model, apiKey, onProgress);
+    return this.pollOperation(operation.name, apiKey, model, onProgress);
+  }
 
-    // REST API format with image for image-to-video
-    const requestBody = {
-      instances: [{
-        prompt: input.prompt,
-        image: {
-          bytesBase64Encoded: input.image,
-        },
-      }],
+  private async startOperation(
+    input: TextToVideoInput,
+    model: string,
+    apiKey: string,
+    onProgress?: (progress: VideoGenerationProgress) => void,
+  ): Promise<VeoOperation> {
+    const url = `${VEO_API_BASE}/models/${model}:predictLongRunning`;
+    const body = {
+      instances: [{ prompt: input.prompt }],
       parameters: {
         aspectRatio: input.options?.aspectRatio || "16:9",
         ...(input.negativePrompt && { negativePrompt: input.negativePrompt }),
       },
     };
-
     onProgress?.({ status: "queued", progress: 5 });
+    return geminiRetryService.executeWithRetry(() => this.postRequest(url, body, apiKey));
+  }
 
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[GeminiVideoGeneration] Request URL:", url);
-    }
-
-    const operation = await geminiRetryService.executeWithRetry(async () => {
-      const res = await fetch(url, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "x-goog-api-key": apiKey!,
-        },
-        body: JSON.stringify(requestBody),
-      });
-
-      if (!res.ok) {
-        const errorText = await res.text();
-        throw this.createError("OPERATION_FAILED", `Veo API error (${res.status}): ${errorText}`, res.status);
-      }
+  private async startImageToVideoOperation(
+    input: VideoGenerationInput,
+    model: string,
+    apiKey: string,
+    onProgress?: (progress: VideoGenerationProgress) => void,
+  ): Promise<VeoOperation> {
+    const url = `${VEO_API_BASE}/models/${model}:predictLongRunning`;
+    const body = {
+      instances: [{ prompt: input.prompt, image: { bytesBase64Encoded: input.image } }],
+      parameters: {
+        aspectRatio: input.options?.aspectRatio || "16:9",
+        ...(input.negativePrompt && { negativePrompt: input.negativePrompt }),
+      },
+    };
+    onProgress?.({ status: "queued", progress: 5 });
+    return geminiRetryService.executeWithRetry(() => this.postRequest(url, body, apiKey));
+  }
 
-      return res.json() as Promise<VeoOperation>;
+  private async postRequest(url: string, body: Record<string, unknown>, apiKey: string): Promise<VeoOperation> {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "x-goog-api-key": apiKey },
+      body: JSON.stringify(body),
     });
-
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[GeminiVideoGeneration] Operation started", {
-        operationName: operation.name,
-      });
+    if (!res.ok) {
+      throw createVideoError("OPERATION_FAILED", `Veo API error: ${await res.text()}`, res.status);
     }
-
-    onProgress?.({ status: "processing", progress: 10 });
-
-    return this.pollOperation(operation.name, apiKey!, videoModel, onProgress);
+    return res.json() as Promise<VeoOperation>;
   }
 
-  /**
-   * Poll operation status until completion
-   */
   private async pollOperation(
     operationName: string,
     apiKey: string,
@@ -193,142 +126,45 @@ class GeminiVideoGenerationService {
   ): Promise<VideoGenerationResult> {
     const url = `${VEO_API_BASE}/${operationName}`;
     let attempts = 0;
+    onProgress?.({ status: "processing", progress: 10 });
 
     while (attempts < MAX_POLL_ATTEMPTS) {
-      await this.delay(DEFAULT_POLL_INTERVAL);
+      await this.delay(POLL_INTERVAL);
       attempts++;
+      onProgress?.({ status: "processing", progress: calculateProgress(attempts, MAX_POLL_ATTEMPTS) });
 
-      const progress = calculatePollingProgress(attempts, MAX_POLL_ATTEMPTS);
-
-      onProgress?.({
-        status: "processing",
-        progress,
-        estimatedTimeRemaining: (MAX_POLL_ATTEMPTS - attempts) * (DEFAULT_POLL_INTERVAL / 1000),
-      });
-
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        // eslint-disable-next-line no-console
-        console.log("[GeminiVideoGeneration] Polling operation", {
-          attempt: attempts,
-          progress: `${progress.toFixed(0)}%`,
-        });
-      }
-
-      const operation = await geminiRetryService.executeWithRetry(async () => {
-        const res = await fetch(url, {
-          method: "GET",
-          headers: {
-            "x-goog-api-key": apiKey,
-          },
-        });
-
-        if (!res.ok) {
-          const errorText = await res.text();
-          throw this.createError("NETWORK", `Polling error (${res.status}): ${errorText}`, res.status);
-        }
-
-        return res.json() as Promise<VeoOperation>;
-      });
-
+      const operation = await this.fetchOperationStatus(url, apiKey);
       if (operation.error) {
-        throw this.createError("OPERATION_FAILED", operation.error.message, operation.error.code);
+        throw createVideoError("OPERATION_FAILED", operation.error.message, operation.error.code);
       }
-
       if (operation.done) {
-        const videoUrl = this.extractVideoUrl(operation);
-
-        if (videoUrl) {
+        const rawVideoUrl = extractVideoUrl(operation);
+        if (rawVideoUrl) {
+          const result = await downloadVideoFromVeo(rawVideoUrl, apiKey);
           onProgress?.({ status: "completed", progress: 100 });
-
           return {
-            videoUrl,
-            metadata: {
-              duration: 8,
-              resolution: "720p",
-              aspectRatio: "16:9",
-              model,
-              operationName,
-            },
+            videoUrl: result.base64DataUri,
+            metadata: { duration: 8, resolution: "720p", aspectRatio: "16:9", model, operationName },
           };
         }
       }
     }
-
-    throw this.createError("TIMEOUT", `Operation timed out after ${MAX_POLL_DURATION / 1000} seconds`);
-  }
-
-  /**
-   * Extract video URL from operation response (handles multiple response formats)
-   */
-  private extractVideoUrl(operation: VeoOperation): string | null {
-    const response = operation.response;
-    if (!response) return null;
-
-    // Format 1: generatedVideos[].video.uri (new SDK format)
-    if (response.generatedVideos?.[0]?.video?.uri) {
-      return response.generatedVideos[0].video.uri;
-    }
-
-    // Format 2: generatedVideos[].video.url
-    if (response.generatedVideos?.[0]?.video?.url) {
-      return response.generatedVideos[0].video.url;
-    }
-
-    // Format 3: candidates[].uri (legacy format)
-    if (response.candidates?.[0]?.uri) {
-      return response.candidates[0].uri;
-    }
-
-    // Format 4: generateVideoResponse.generatedSamples[].video.uri (REST API format)
-    if (response.generateVideoResponse?.generatedSamples?.[0]?.video?.uri) {
-      return response.generateVideoResponse.generatedSamples[0].video.uri;
-    }
-
-    return null;
-  }
-
-  /**
-   * Validate text-to-video input parameters
-   */
-  private validateTextInput(input: TextToVideoInput): void {
-    if (!input.prompt || input.prompt.trim().length === 0) {
-      throw this.createError("INVALID_INPUT", "Prompt is required");
-    }
-
-    if (input.prompt.length > 2000) {
-      throw this.createError("INVALID_INPUT", "Prompt exceeds 2000 characters");
-    }
+    throw createVideoError("TIMEOUT", `Operation timed out after ${MAX_POLL_DURATION / 1000}s`);
   }
 
-  /**
-   * Validate image-to-video input parameters
-   */
-  private validateInput(input: VideoGenerationInput): void {
-    this.validateTextInput(input);
-
-    if (!input.image || input.image.length === 0) {
-      throw this.createError("INVALID_INPUT", "Image is required for image-to-video");
-    }
+  private async fetchOperationStatus(url: string, apiKey: string): Promise<VeoOperation> {
+    return geminiRetryService.executeWithRetry(async () => {
+      const res = await fetch(url, { method: "GET", headers: { "x-goog-api-key": apiKey } });
+      if (!res.ok) throw createVideoError("NETWORK", `Polling error: ${await res.text()}`, res.status);
+      return res.json() as Promise<VeoOperation>;
+    });
   }
 
-  /**
-   * Create typed error
-   */
-  private createError(
-    type: VideoGenerationError["type"],
-    message: string,
-    statusCode?: number,
-  ): VideoGenerationError {
-    const error = new Error(message) as VideoGenerationError;
-    error.type = type;
-    error.statusCode = statusCode;
-    error.retryable = type === "NETWORK" || type === "TIMEOUT";
-    return error;
+  private validatePrompt(prompt: string): void {
+    if (!prompt?.trim()) throw createVideoError("INVALID_INPUT", "Prompt is required");
+    if (prompt.length > 2000) throw createVideoError("INVALID_INPUT", "Prompt exceeds 2000 characters");
   }
 
-  /**
-   * Delay helper
-   */
   private delay(ms: number): Promise<void> {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }

package/src/infrastructure/services/gemini-video-url-extractor.ts

@@ -0,0 +1,45 @@
+/**
+ * Gemini Video URL Extractor
+ * Single Responsibility: Extract video URL from Veo operation response
+ * Handles multiple response formats from Veo API
+ */
+
+import type { VeoOperation } from "../../domain/entities";
+
+declare const __DEV__: boolean;
+
+/**
+ * Extract video URL from Veo operation response
+ * Handles multiple response formats from different Veo API versions
+ */
+export function extractVideoUrl(operation: VeoOperation): string | null {
+  const response = operation.response;
+  if (!response) return null;
+
+  // Format 1: generatedVideos[].video.uri (new SDK format)
+  if (response.generatedVideos?.[0]?.video?.uri) {
+    return response.generatedVideos[0].video.uri;
+  }
+
+  // Format 2: generatedVideos[].video.url
+  if (response.generatedVideos?.[0]?.video?.url) {
+    return response.generatedVideos[0].video.url;
+  }
+
+  // Format 3: candidates[].uri (legacy format)
+  if (response.candidates?.[0]?.uri) {
+    return response.candidates[0].uri;
+  }
+
+  // Format 4: generateVideoResponse.generatedSamples[].video.uri (REST API format)
+  if (response.generateVideoResponse?.generatedSamples?.[0]?.video?.uri) {
+    return response.generateVideoResponse.generatedSamples[0].video.uri;
+  }
+
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    // eslint-disable-next-line no-console
+    console.warn("[GeminiVideoUrlExtractor] No video URL found in response");
+  }
+
+  return null;
+}