@umituz/react-native-ai-gemini-provider 1.14.22 → 1.14.23

package/src/infrastructure/services/veo-http-client.service.ts

@@ -0,0 +1,70 @@
+/**
+ * Veo HTTP Client
+ * Handles HTTP requests to Google Veo API
+ */
+
+import { createVideoError } from "./gemini-video-error";
+import type { VeoOperation } from "../../domain/entities";
+
+const VEO_API_BASE = "https://generativelanguage.googleapis.com/v1beta";
+
+class VeoHttpClient {
+  /**
+   * Start a text-to-video operation
+   */
+  async startOperation(
+    model: string,
+    apiKey: string,
+    instances: Record<string, unknown>[],
+    parameters: Record<string, unknown>,
+  ): Promise<VeoOperation> {
+    const url = `${VEO_API_BASE}/models/${model}:predictLongRunning`;
+    const body = { instances, parameters };
+
+    return this.postRequest(url, body, apiKey);
+  }
+
+  /**
+   * Fetch operation status
+   */
+  async fetchOperationStatus(operationName: string, apiKey: string): Promise<VeoOperation> {
+    const url = `${VEO_API_BASE}/${operationName}`;
+
+    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>;
+  }
+
+  /**
+   * Generic POST request
+   */
+  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 (!res.ok) {
+      throw createVideoError("OPERATION_FAILED", `Veo API error: ${await res.text()}`, res.status);
+    }
+
+    return res.json() as Promise<VeoOperation>;
+  }
+}
+
+export const veoHttpClient = new VeoHttpClient();

package/src/infrastructure/services/veo-polling.service.ts

@@ -0,0 +1,119 @@
+/**
+ * Veo Polling Service
+ * Handles polling logic for long-running video generation operations
+ */
+
+import { veoHttpClient } from "./veo-http-client.service";
+import { downloadVideoFromVeo } from "./gemini-video-downloader";
+import { extractVideoUrl } from "./gemini-video-url-extractor";
+import { createVideoError } from "./gemini-video-error";
+import type {
+  VideoGenerationResult,
+  VideoGenerationProgress,
+  VeoOperation,
+} from "../../domain/entities";
+
+declare const __DEV__: boolean;
+
+const POLL_INTERVAL = 10000;
+const MAX_POLL_DURATION = 300000;
+const MAX_POLL_ATTEMPTS = Math.floor(MAX_POLL_DURATION / POLL_INTERVAL);
+
+/** Calculate polling progress (10-95% range) */
+function calculateProgress(attempt: number, maxAttempts: number): number {
+  return Math.round(10 + (attempt / maxAttempts) * 85);
+}
+
+class VeoPollingService {
+  /**
+   * Poll an operation until completion
+   */
+  async pollOperation(
+    operationName: string,
+    apiKey: string,
+    model: string,
+    onProgress?: (progress: VideoGenerationProgress) => void,
+  ): Promise<VideoGenerationResult> {
+    let attempts = 0;
+    onProgress?.({ status: "processing", progress: 10 });
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[VeoPolling] Starting polling...", { operationName, maxAttempts: MAX_POLL_ATTEMPTS });
+    }
+
+    while (attempts < MAX_POLL_ATTEMPTS) {
+      await this.delay(POLL_INTERVAL);
+      attempts++;
+      const progress = calculateProgress(attempts, MAX_POLL_ATTEMPTS);
+      onProgress?.({ status: "processing", progress });
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        // eslint-disable-next-line no-console
+        console.log("[VeoPolling] Poll attempt:", { attempts, progress });
+      }
+
+      const operation = await veoHttpClient.fetchOperationStatus(operationName, apiKey);
+
+      if (operation.error) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          // eslint-disable-next-line no-console
+          console.error("[VeoPolling] Operation error:", operation.error);
+        }
+        throw createVideoError("OPERATION_FAILED", operation.error.message, operation.error.code);
+      }
+
+      if (operation.done) {
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          // eslint-disable-next-line no-console
+          console.log("[VeoPolling] Operation completed!");
+        }
+
+        return this.handleCompletedOperation(operation, apiKey, model, onProgress);
+      }
+    }
+
+    throw createVideoError("TIMEOUT", `Operation timed out after ${MAX_POLL_DURATION / 1000}s`);
+  }
+
+  /**
+   * Handle completed operation and download video
+   */
+  private async handleCompletedOperation(
+    operation: VeoOperation,
+    apiKey: string,
+    model: string,
+    onProgress?: (progress: VideoGenerationProgress) => void,
+  ): Promise<VideoGenerationResult> {
+    const rawVideoUrl = extractVideoUrl(operation);
+
+    if (!rawVideoUrl) {
+      throw createVideoError("OPERATION_FAILED", "No video URL in response");
+    }
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[VeoPolling] Downloading video...");
+    }
+
+    const result = await downloadVideoFromVeo(rawVideoUrl, apiKey);
+    onProgress?.({ status: "completed", progress: 100 });
+
+    return {
+      videoUrl: result.base64DataUri,
+      metadata: {
+        duration: 8,
+        resolution: "720p",
+        aspectRatio: "16:9",
+        model,
+        operationName: operation.name,
+      },
+    };
+  }
+
+  private delay(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}
+
+export const veoPollingService = new VeoPollingService();

package/src/infrastructure/utils/base-input-builders.util.ts

@@ -0,0 +1,49 @@
+/**
+ * Base Input Builders
+ * Provides core input construction functions
+ */
+
+/**
+ * Build Gemini single image input format
+ */
+export function buildSingleImageInput(
+  base64: string,
+  prompt: string,
+): Record<string, unknown> {
+  const cleanBase64 = base64.replace(/^data:image\/\w+;base64,/, "");
+
+  return {
+    contents: [
+      {
+        parts: [
+          { text: prompt },
+          { inlineData: { mimeType: "image/jpeg", data: cleanBase64 } },
+        ],
+      },
+    ],
+  };
+}
+
+/**
+ * Build Gemini dual image input format
+ */
+export function buildDualImageInput(
+  sourceBase64: string,
+  targetBase64: string,
+  prompt: string,
+): Record<string, unknown> {
+  const cleanSource = sourceBase64.replace(/^data:image\/\w+;base64,/, "");
+  const cleanTarget = targetBase64.replace(/^data:image\/\w+;base64,/, "");
+
+  return {
+    contents: [
+      {
+        parts: [
+          { text: prompt },
+          { inlineData: { mimeType: "image/jpeg", data: cleanSource } },
+          { inlineData: { mimeType: "image/jpeg", data: cleanTarget } },
+        ],
+      },
+    ],
+  };
+}

package/src/infrastructure/utils/image-feature-builders.util.ts

@@ -0,0 +1,123 @@
+/**
+ * Image Feature Input Builders
+ * Constructs Gemini API inputs for image processing features
+ */
+
+import { buildSingleImageInput, buildDualImageInput } from "./base-input-builders.util";
+import type {
+  UpscaleOptions,
+  PhotoRestoreOptions,
+  FaceSwapOptions,
+  AnimeSelfieOptions,
+  RemoveBackgroundOptions,
+  RemoveObjectOptions,
+  ReplaceBackgroundOptions,
+} from "./input-builder.types";
+
+/**
+ * Build upscale input for Gemini
+ */
+export function buildUpscaleInput(
+  base64: string,
+  options?: UpscaleOptions,
+): Record<string, unknown> {
+  const scale = options?.scaleFactor || 2;
+  const faceEnhance = options?.enhanceFaces
+    ? " Enhance facial features."
+    : "";
+
+  const prompt = `Upscale this image by ${scale}x. Preserve all details, colors and enhance clarity.${faceEnhance}`;
+
+  return buildSingleImageInput(base64, prompt);
+}
+
+/**
+ * Build photo restore input for Gemini
+ */
+export function buildPhotoRestoreInput(
+  base64: string,
+  options?: PhotoRestoreOptions,
+): Record<string, unknown> {
+  const faceEnhance = options?.enhanceFaces !== false
+    ? " Enhance facial features and expressions."
+    : "";
+
+  const prompt = `Restore this photo. Remove noise, scratches, and damage while preserving original content.${faceEnhance}`;
+
+  return buildSingleImageInput(base64, prompt);
+}
+
+/**
+ * Build face swap input for Gemini
+ */
+export function buildFaceSwapInput(
+  sourceBase64: string,
+  targetBase64: string,
+  _options?: FaceSwapOptions,
+): Record<string, unknown> {
+  const prompt = "Swap the face from the first image onto the person in the second image. Preserve lighting, expression, and natural appearance.";
+
+  return buildDualImageInput(sourceBase64, targetBase64, prompt);
+}
+
+/**
+ * Build anime selfie input for Gemini
+ */
+export function buildAnimeSelfieInput(
+  base64: string,
+  options?: AnimeSelfieOptions,
+): Record<string, unknown> {
+  const style = options?.style || "anime";
+
+  const prompt = `Convert this photo into ${style} style. Preserve facial features and expression while applying artistic transformation.`;
+
+  return buildSingleImageInput(base64, prompt);
+}
+
+/**
+ * Build remove background input for Gemini
+ */
+export function buildRemoveBackgroundInput(
+  base64: string,
+  _options?: RemoveBackgroundOptions,
+): Record<string, unknown> {
+  const prompt = "Remove the background from this image. Keep only the main subject with transparent background.";
+
+  return buildSingleImageInput(base64, prompt);
+}
+
+/**
+ * Build remove object (inpaint) input for Gemini
+ */
+export function buildRemoveObjectInput(
+  base64: string,
+  options?: RemoveObjectOptions,
+): Record<string, unknown> {
+  const objectDescription = options?.prompt || "the unwanted object";
+
+  const prompt = `Remove ${objectDescription} from this image and fill the area naturally with the surrounding background.`;
+
+  return buildSingleImageInput(base64, prompt);
+}
+
+/**
+ * Build replace background input for Gemini
+ */
+export function buildReplaceBackgroundInput(
+  base64: string,
+  options: ReplaceBackgroundOptions,
+): Record<string, unknown> {
+  const prompt = `Replace the background with: ${options.prompt}. Keep the main subject intact and blend naturally.`;
+
+  return buildSingleImageInput(base64, prompt);
+}
+
+/**
+ * Build HD touch up input (same as upscale with face enhancement)
+ */
+export function buildHDTouchUpInput(
+  base64: string,
+  options?: UpscaleOptions,
+): Record<string, unknown> {
+  return buildUpscaleInput(base64, { ...options, enhanceFaces: true });
+}

package/src/infrastructure/utils/input-builder.types.ts

@@ -0,0 +1,44 @@
+/**
+ * Input Builder Types
+ */
+
+export interface UpscaleOptions {
+  scaleFactor?: number;
+  enhanceFaces?: boolean;
+}
+
+export interface PhotoRestoreOptions {
+  enhanceFaces?: boolean;
+}
+
+export interface FaceSwapOptions {
+  // No additional options
+}
+
+export interface AnimeSelfieOptions {
+  style?: string;
+}
+
+export interface RemoveBackgroundOptions {
+  // No additional options
+}
+
+export interface RemoveObjectOptions {
+  mask?: string;
+  prompt?: string;
+}
+
+export interface ReplaceBackgroundOptions {
+  prompt: string;
+}
+
+export interface VideoFromImageOptions {
+  motion_prompt?: string;
+  duration?: number;
+}
+
+export interface VideoFromDualImageOptions {
+  target_image?: string;
+  motion_prompt?: string;
+  duration?: number;
+}