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

package/package.json

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

package/src/infrastructure/services/feature-input-builder.ts

@@ -0,0 +1,85 @@
+/**
+ * Feature Input Builder
+ * Builds Gemini API inputs for image and video features
+ */
+
+import type {
+  ImageFeatureType,
+  VideoFeatureType,
+  ImageFeatureInputData,
+  VideoFeatureInputData,
+} from "@umituz/react-native-ai-generation-content";
+import {
+  buildUpscaleInput,
+  buildPhotoRestoreInput,
+  buildFaceSwapInput,
+  buildAnimeSelfieInput,
+  buildRemoveBackgroundInput,
+  buildRemoveObjectInput,
+  buildReplaceBackgroundInput,
+  buildHDTouchUpInput,
+  buildVideoFromDualImagesInput,
+} from "../utils/input-builders.util";
+
+class FeatureInputBuilder {
+  /**
+   * Build input for an IMAGE feature
+   */
+  buildImageFeatureInput(
+    feature: ImageFeatureType,
+    data: ImageFeatureInputData,
+  ): Record<string, unknown> {
+    const { imageBase64, targetImageBase64, prompt, options } = data;
+
+    switch (feature) {
+      case "upscale":
+        return buildUpscaleInput(imageBase64, options);
+      case "photo-restore":
+        return buildPhotoRestoreInput(imageBase64, options);
+      case "face-swap":
+        if (!targetImageBase64) {
+          throw new Error("Face swap requires target image");
+        }
+        return buildFaceSwapInput(imageBase64, targetImageBase64, options);
+      case "anime-selfie":
+        return buildAnimeSelfieInput(imageBase64, options);
+      case "remove-background":
+        return buildRemoveBackgroundInput(imageBase64, options);
+      case "remove-object":
+        return buildRemoveObjectInput(imageBase64, { prompt, ...options });
+      case "hd-touch-up":
+        return buildHDTouchUpInput(imageBase64, options);
+      case "replace-background":
+        if (!prompt) {
+          throw new Error("Replace background requires prompt");
+        }
+        return buildReplaceBackgroundInput(imageBase64, { prompt });
+      default:
+        throw new Error(`Unknown image feature: ${String(feature)}`);
+    }
+  }
+
+  /**
+   * Build input for a VIDEO feature
+   */
+  buildVideoFeatureInput(
+    feature: VideoFeatureType,
+    data: VideoFeatureInputData,
+  ): Record<string, unknown> {
+    const { sourceImageBase64, targetImageBase64, prompt, options } = data;
+
+    switch (feature) {
+      case "ai-hug":
+      case "ai-kiss":
+        return buildVideoFromDualImagesInput(sourceImageBase64, {
+          target_image: targetImageBase64,
+          motion_prompt: prompt,
+          ...options,
+        });
+      default:
+        throw new Error(`Unknown video feature: ${String(feature)}`);
+    }
+  }
+}
+
+export const featureInputBuilder = new FeatureInputBuilder();

package/src/infrastructure/services/feature-model-selector.ts

@@ -0,0 +1,31 @@
+/**
+ * Feature Model Selector
+ * Returns the appropriate model ID for a given feature
+ */
+
+import type {
+  ImageFeatureType,
+  VideoFeatureType,
+} from "@umituz/react-native-ai-generation-content";
+import {
+  GEMINI_IMAGE_FEATURE_MODELS,
+  GEMINI_VIDEO_FEATURE_MODELS,
+} from "../../domain/constants/feature-models.constants";
+
+class FeatureModelSelector {
+  /**
+   * Get model ID for an IMAGE feature
+   */
+  getImageFeatureModel(feature: ImageFeatureType): string {
+    return GEMINI_IMAGE_FEATURE_MODELS[feature];
+  }
+
+  /**
+   * Get model ID for a VIDEO feature
+   */
+  getVideoFeatureModel(feature: VideoFeatureType): string {
+    return GEMINI_VIDEO_FEATURE_MODELS[feature];
+  }
+}
+
+export const featureModelSelector = new FeatureModelSelector();

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

@@ -26,21 +26,8 @@ import { geminiImageEditService } from "./gemini-image-edit.service";
 import { providerInitializer, type GeminiProviderConfig } from "./provider-initializer";
 import { jobProcessor } from "./job-processor";
 import { generationExecutor } from "./generation-executor";
-import {
-  GEMINI_IMAGE_FEATURE_MODELS,
-  GEMINI_VIDEO_FEATURE_MODELS,
-} from "../../domain/constants/feature-models.constants";
-import {
-  buildUpscaleInput,
-  buildPhotoRestoreInput,
-  buildFaceSwapInput,
-  buildAnimeSelfieInput,
-  buildRemoveBackgroundInput,
-  buildRemoveObjectInput,
-  buildReplaceBackgroundInput,
-  buildHDTouchUpInput,
-  buildVideoFromDualImagesInput,
-} from "../utils/input-builders.util";
+import { featureInputBuilder } from "./feature-input-builder";
+import { featureModelSelector } from "./feature-model-selector";
 
 export type { GeminiProviderConfig };
 
@@ -63,7 +50,6 @@ const GEMINI_CAPABILITIES: ProviderCapabilities = {
   textToVideo: true,
   imageToVideo: true,
   textToVoice: false,
-  textToText: true,
 };
 
 export class GeminiProvider implements IAIProvider {
@@ -162,7 +148,7 @@ export class GeminiProvider implements IAIProvider {
    * Get model ID for an IMAGE feature
    */
   getImageFeatureModel(feature: ImageFeatureType): string {
-    return GEMINI_IMAGE_FEATURE_MODELS[feature];
+    return featureModelSelector.getImageFeatureModel(feature);
   }
 
   /**
@@ -172,41 +158,14 @@ export class GeminiProvider implements IAIProvider {
     feature: ImageFeatureType,
     data: ImageFeatureInputData,
   ): Record<string, unknown> {
-    const { imageBase64, targetImageBase64, prompt, options } = data;
-
-    switch (feature) {
-      case "upscale":
-        return buildUpscaleInput(imageBase64, options);
-      case "photo-restore":
-        return buildPhotoRestoreInput(imageBase64, options);
-      case "face-swap":
-        if (!targetImageBase64) {
-          throw new Error("Face swap requires target image");
-        }
-        return buildFaceSwapInput(imageBase64, targetImageBase64, options);
-      case "anime-selfie":
-        return buildAnimeSelfieInput(imageBase64, options);
-      case "remove-background":
-        return buildRemoveBackgroundInput(imageBase64, options);
-      case "remove-object":
-        return buildRemoveObjectInput(imageBase64, { prompt, ...options });
-      case "hd-touch-up":
-        return buildHDTouchUpInput(imageBase64, options);
-      case "replace-background":
-        if (!prompt) {
-          throw new Error("Replace background requires prompt");
-        }
-        return buildReplaceBackgroundInput(imageBase64, { prompt });
-      default:
-        throw new Error(`Unknown image feature: ${String(feature)}`);
-    }
+    return featureInputBuilder.buildImageFeatureInput(feature, data);
   }
 
   /**
    * Get model ID for a VIDEO feature
    */
   getVideoFeatureModel(feature: VideoFeatureType): string {
-    return GEMINI_VIDEO_FEATURE_MODELS[feature];
+    return featureModelSelector.getVideoFeatureModel(feature);
   }
 
   /**
@@ -216,19 +175,7 @@ export class GeminiProvider implements IAIProvider {
     feature: VideoFeatureType,
     data: VideoFeatureInputData,
   ): Record<string, unknown> {
-    const { sourceImageBase64, targetImageBase64, prompt, options } = data;
-
-    switch (feature) {
-      case "ai-hug":
-      case "ai-kiss":
-        return buildVideoFromDualImagesInput(sourceImageBase64, {
-          target_image: targetImageBase64,
-          motion_prompt: prompt,
-          ...options,
-        });
-      default:
-        throw new Error(`Unknown video feature: ${String(feature)}`);
-    }
+    return featureInputBuilder.buildVideoFeatureInput(feature, data);
   }
 }
 

package/src/infrastructure/services/gemini-structured-text.service.ts

@@ -0,0 +1,113 @@
+/**
+ * Gemini Structured Text Service
+ * Handles structured JSON response generation with schema validation
+ */
+
+import { geminiTextGenerationService } from "./gemini-text-generation.service";
+import type {
+  GeminiContent,
+  GeminiGenerationConfig,
+} from "../../domain/entities";
+
+declare const __DEV__: boolean;
+
+class GeminiStructuredTextService {
+  /**
+   * Generate structured JSON response with schema
+   */
+  async generateStructuredText<T>(
+    model: string,
+    prompt: string,
+    schema: Record<string, unknown>,
+    config?: Omit<GeminiGenerationConfig, "responseMimeType" | "responseSchema">,
+  ): Promise<T> {
+    const generationConfig: GeminiGenerationConfig = {
+      ...config,
+      responseMimeType: "application/json",
+      responseSchema: schema as unknown as undefined,
+    };
+
+    const contents: GeminiContent[] = [
+      { parts: [{ text: prompt }], role: "user" },
+    ];
+
+    const response = await geminiTextGenerationService.generateContent(
+      model,
+      contents,
+      generationConfig,
+    );
+
+    return this.parseJSONResponse<T>(response);
+  }
+
+  /**
+   * Generate structured JSON response with images and schema
+   */
+  async generateStructuredTextWithImages<T>(
+    model: string,
+    prompt: string,
+    images: Array<{ base64: string; mimeType: string }>,
+    schema: Record<string, unknown>,
+    config?: Omit<GeminiGenerationConfig, "responseMimeType" | "responseSchema">,
+  ): Promise<T> {
+    const generationConfig: GeminiGenerationConfig = {
+      ...config,
+      responseMimeType: "application/json",
+      responseSchema: schema as unknown as undefined,
+    };
+
+    const parts: GeminiContent["parts"] = [{ text: prompt }];
+
+    for (const image of images) {
+      parts.push({
+        inlineData: {
+          mimeType: image.mimeType,
+          data: image.base64,
+        },
+      });
+    }
+
+    const contents: GeminiContent[] = [{ parts, role: "user" }];
+
+    const response = await geminiTextGenerationService.generateContent(
+      model,
+      contents,
+      generationConfig,
+    );
+
+    return this.parseJSONResponse<T>(response);
+  }
+
+  /**
+   * Parse JSON response from Gemini
+   */
+  private parseJSONResponse<T>(response: unknown): T {
+    const candidates = (response as { candidates?: Array<{ content: { parts: Array<{ text?: string }> } }> }).candidates;
+
+    let text = "";
+
+    if (candidates?.[0]?.content?.parts) {
+      text = candidates[0].content.parts
+        .map((part) => part.text || "")
+        .join("");
+    }
+
+    // Clean and parse JSON (remove markdown code blocks if present)
+    const cleanedText = text.replace(/```json\n?/g, "").replace(/```\n?/g, "").trim();
+
+    try {
+      return JSON.parse(cleanedText) as T;
+    } catch (error) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        // eslint-disable-next-line no-console
+        console.error("[Gemini] Failed to parse structured response:", {
+          text: cleanedText.substring(0, 200),
+          error: error instanceof Error ? error.message : String(error),
+        });
+      }
+      throw new Error(`Failed to parse structured response: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+}
+
+export const geminiStructuredTextService = new GeminiStructuredTextService();

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

@@ -11,7 +11,6 @@ import type {
   GeminiGenerationConfig,
   GeminiResponse,
   GeminiPart,
-  GeminiFinishReason,
 } from "../../domain/entities";
 
 declare const __DEV__: boolean;
@@ -69,10 +68,10 @@ class GeminiTextGenerationService {
       }
 
       return {
-        candidates: response.candidates?.map((candidate: any) => ({
+        candidates: response.candidates?.map((candidate) => ({
           content: {
             parts: candidate.content.parts
-              .map((part: any): GeminiPart | null => {
+              .map((part): GeminiPart | null => {
                 if ("text" in part && part.text !== undefined) {
                   return { text: part.text };
                 }
@@ -86,10 +85,10 @@ class GeminiTextGenerationService {
                 }
                 return null;
               })
-              .filter((p: any): p is GeminiPart => p !== null),
-            role: (candidate.content.role || "model") as "user" | "model",
+              .filter((p): p is GeminiPart => p !== null),
+            role: (candidate.content.role || "model"),
           },
-          finishReason: candidate.finishReason as GeminiFinishReason | undefined,
+          finishReason: candidate.finishReason,
         })),
       };
     } catch (error) {
@@ -159,94 +158,6 @@ class GeminiTextGenerationService {
 
     return this.generateContent(model, contents, config);
   }
-
-  /**
-   * Generate structured JSON response with schema
-   */
-  async generateStructuredText<T>(
-    model: string,
-    prompt: string,
-    schema: Record<string, unknown>,
-    config?: Omit<GeminiGenerationConfig, "responseMimeType" | "responseSchema">,
-  ): Promise<T> {
-    const generationConfig: GeminiGenerationConfig = {
-      ...config,
-      responseMimeType: "application/json",
-      responseSchema: schema as unknown as undefined,
-    };
-
-    const contents: GeminiContent[] = [
-      { parts: [{ text: prompt }], role: "user" },
-    ];
-
-    const response = await this.generateContent(model, contents, generationConfig);
-    const text = extractTextFromResponse(response);
-
-    // Clean and parse JSON (remove markdown code blocks if present)
-    const cleanedText = text.replace(/```json\n?/g, "").replace(/```\n?/g, "").trim();
-
-    try {
-      return JSON.parse(cleanedText) as T;
-    } catch (error) {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        // eslint-disable-next-line no-console
-        console.error("[Gemini] Failed to parse structured response:", {
-          text: cleanedText.substring(0, 200),
-          error: error instanceof Error ? error.message : String(error),
-        });
-      }
-      throw new Error(`Failed to parse structured response: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-
-  /**
-   * Generate structured JSON response with images and schema
-   */
-  async generateStructuredTextWithImages<T>(
-    model: string,
-    prompt: string,
-    images: Array<{ base64: string; mimeType: string }>,
-    schema: Record<string, unknown>,
-    config?: Omit<GeminiGenerationConfig, "responseMimeType" | "responseSchema">,
-  ): Promise<T> {
-    const generationConfig: GeminiGenerationConfig = {
-      ...config,
-      responseMimeType: "application/json",
-      responseSchema: schema as unknown as undefined,
-    };
-
-    const parts: GeminiContent["parts"] = [{ text: prompt }];
-
-    for (const image of images) {
-      parts.push({
-        inlineData: {
-          mimeType: image.mimeType,
-          data: extractBase64Data(image.base64),
-        },
-      });
-    }
-
-    const contents: GeminiContent[] = [{ parts, role: "user" }];
-
-    const response = await this.generateContent(model, contents, generationConfig);
-    const text = extractTextFromResponse(response);
-
-    // Clean and parse JSON
-    const cleanedText = text.replace(/```json\n?/g, "").replace(/```\n?/g, "").trim();
-
-    try {
-      return JSON.parse(cleanedText) as T;
-    } catch (error) {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        // eslint-disable-next-line no-console
-        console.error("[Gemini] Failed to parse structured response:", {
-          text: cleanedText.substring(0, 200),
-          error: error instanceof Error ? error.message : String(error),
-        });
-      }
-      throw new Error(`Failed to parse structured response: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
 }
 
 export const geminiTextGenerationService = new GeminiTextGenerationService();

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

@@ -6,30 +6,19 @@
 
 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 { veoHttpClient } from "./veo-http-client.service";
+import { veoPollingService } from "./veo-polling.service";
 import { createVideoError } from "./gemini-video-error";
 import { DEFAULT_MODELS } from "../../domain/entities";
 import type {
   VideoGenerationInput,
   VideoGenerationResult,
   VideoGenerationProgress,
-  VeoOperation,
   TextToVideoInput,
 } 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);
-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 {
   async generateTextToVideo(
     input: TextToVideoInput,
@@ -53,14 +42,24 @@ class GeminiVideoGenerationService {
       console.log("[GeminiVideoGeneration] Starting operation with model:", model);
     }
 
-    const operation = await this.startOperation(input, model, apiKey, onProgress);
+    const instances = [{ prompt: input.prompt }];
+    const parameters = {
+      aspectRatio: input.options?.aspectRatio || "16:9",
+      ...(input.negativePrompt && { negativePrompt: input.negativePrompt }),
+    };
+
+    onProgress?.({ status: "queued", progress: 5 });
+
+    const operation = await geminiRetryService.executeWithRetry(() =>
+      veoHttpClient.startOperation(model, apiKey, instances, parameters),
+    );
 
     if (typeof __DEV__ !== "undefined" && __DEV__) {
       // eslint-disable-next-line no-console
       console.log("[GeminiVideoGeneration] Operation started:", operation.name);
     }
 
-    return this.pollOperation(operation.name, apiKey, model, onProgress);
+    return veoPollingService.pollOperation(operation.name, apiKey, model, onProgress);
   }
 
   async generateVideo(
@@ -77,131 +76,28 @@ class GeminiVideoGenerationService {
     const apiKey = config?.apiKey;
     if (!apiKey) throw createVideoError("INVALID_INPUT", "API key is required");
 
-    const operation = await this.startImageToVideoOperation(input, model, apiKey, onProgress);
-    return this.pollOperation(operation.name, apiKey, model, onProgress);
-  }
-
-  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 }),
-      },
+    const instances = [{
+      prompt: input.prompt,
+      image: { bytesBase64Encoded: input.image },
+    }];
+    const 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));
-  }
 
-  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));
-  }
-
-  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>;
-  }
 
-  private async pollOperation(
-    operationName: string,
-    apiKey: string,
-    model: string,
-    onProgress?: (progress: VideoGenerationProgress) => void,
-  ): Promise<VideoGenerationResult> {
-    const url = `${VEO_API_BASE}/${operationName}`;
-    let attempts = 0;
-    onProgress?.({ status: "processing", progress: 10 });
+    const operation = await geminiRetryService.executeWithRetry(() =>
+      veoHttpClient.startOperation(model, apiKey, instances, parameters),
+    );
 
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[GeminiVideoGeneration] 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("[GeminiVideoGeneration] Poll attempt:", { attempts, progress });
-      }
-
-      const operation = await this.fetchOperationStatus(url, apiKey);
-      if (operation.error) {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          // eslint-disable-next-line no-console
-          console.error("[GeminiVideoGeneration] 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("[GeminiVideoGeneration] Operation completed!");
-        }
-        const rawVideoUrl = extractVideoUrl(operation);
-        if (rawVideoUrl) {
-          if (typeof __DEV__ !== "undefined" && __DEV__) {
-            // eslint-disable-next-line no-console
-            console.log("[GeminiVideoGeneration] 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 },
-          };
-        }
-      }
-    }
-    throw createVideoError("TIMEOUT", `Operation timed out after ${MAX_POLL_DURATION / 1000}s`);
-  }
-
-  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>;
-    });
+    return veoPollingService.pollOperation(operation.name, apiKey, model, onProgress);
   }
 
   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");
   }
-
-  private delay(ms: number): Promise<void> {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
 }
 
 export const geminiVideoGenerationService = new GeminiVideoGenerationService();