@umituz/react-native-ai-gemini-provider 1.8.3 → 1.9.1

package/package.json

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

package/src/domain/entities/models.ts

@@ -5,13 +5,14 @@
 
 /**
  * Available Gemini models
+ * Updated: 2025-12 with latest stable and preview models
  */
 export const GEMINI_MODELS = {
   // Text generation models
   TEXT: {
-    FLASH: "gemini-2.0-flash",
-    FLASH_LITE: "gemini-2.0-flash-lite",
-    PRO: "gemini-1.5-pro",
+    FLASH: "gemini-2.5-flash",
+    FLASH_LITE: "gemini-2.5-flash-lite",
+    PRO: "gemini-2.5-pro",
   },
 
   // Text-to-Image models (Imagen 4.0) - generates images from text only
@@ -19,14 +20,17 @@ export const GEMINI_MODELS = {
     DEFAULT: "imagen-4.0-generate-001",
   },
 
-  // Image editing models (Gemini) - transforms/edits images with input image + prompt
+  // Image editing models - transforms/edits images with input image + prompt
+  // gemini-3-pro-image-preview is the highest quality for identity preservation
   IMAGE_EDIT: {
-    DEFAULT: "gemini-2.0-flash-exp-image-generation",
+    DEFAULT: "gemini-3-pro-image-preview",
+    FAST: "gemini-2.5-flash-image",
+    LEGACY: "gemini-2.0-flash-preview-image-generation",
   },
 
   // Video understanding models
   VIDEO: {
-    FLASH: "gemini-2.0-flash",
+    FLASH: "gemini-2.5-flash",
   },
 } as const;
 
@@ -50,3 +54,5 @@ export const RESPONSE_MODALITIES = {
 } as const;
 
 export type ResponseModality = "TEXT" | "IMAGE";
+
+

package/src/index.ts

@@ -56,7 +56,12 @@ export type { ResponseModality } from "./domain/entities";
 // =============================================================================
 
 export {
-  geminiClientService,
+  geminiClientCoreService,
+  geminiRetryService,
+  geminiTextGenerationService,
+  geminiImageGenerationService,
+  geminiImageEditService,
+  geminiStreamingService,
   geminiProviderService,
   createGeminiProvider,
 } from "./infrastructure/services";

package/src/infrastructure/services/gemini-client-core.service.ts

@@ -0,0 +1,83 @@
+/**
+ * Gemini Client Core Service
+ * Handles client initialization, configuration, and validation
+ */
+
+import { GoogleGenerativeAI, type GenerativeModel } from "@google/generative-ai";
+import { DEFAULT_MODELS } from "../../domain/entities";
+import type { GeminiConfig } from "../../domain/entities";
+
+declare const __DEV__: boolean;
+
+const DEFAULT_CONFIG: Partial<GeminiConfig> = {
+  maxRetries: 3,
+  baseDelay: 1000,
+  maxDelay: 10000,
+  defaultTimeoutMs: 60000,
+  defaultModel: DEFAULT_MODELS.TEXT,
+  imageModel: DEFAULT_MODELS.TEXT_TO_IMAGE,
+};
+
+class GeminiClientCoreService {
+  private client: GoogleGenerativeAI | null = null;
+  private config: GeminiConfig | null = null;
+  private initialized = false;
+
+  initialize(config: GeminiConfig): void {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[GeminiClient] initialize() called", {
+        hasApiKey: !!config.apiKey,
+        defaultModel: config.defaultModel,
+        imageModel: config.imageModel,
+      });
+    }
+
+    this.client = new GoogleGenerativeAI(config.apiKey);
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.initialized = true;
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[GeminiClient] initialized successfully", {
+        defaultModel: this.config.defaultModel,
+        imageModel: this.config.imageModel,
+        maxRetries: this.config.maxRetries,
+      });
+    }
+  }
+
+  isInitialized(): boolean {
+    return this.initialized;
+  }
+
+  getConfig(): GeminiConfig | null {
+    return this.config;
+  }
+
+  getClient(): GoogleGenerativeAI | null {
+    return this.client;
+  }
+
+  validateInitialization(): void {
+    if (!this.client || !this.initialized) {
+      throw new Error(
+        "Gemini client not initialized. Call initialize() first.",
+      );
+    }
+  }
+
+  getModel(modelName?: string): GenerativeModel {
+    this.validateInitialization();
+    const effectiveModel = modelName || this.config?.defaultModel || "gemini-1.5-flash";
+    return this.client!.getGenerativeModel({ model: effectiveModel });
+  }
+
+  reset(): void {
+    this.client = null;
+    this.config = null;
+    this.initialized = false;
+  }
+}
+
+export const geminiClientCoreService = new GeminiClientCoreService();

package/src/infrastructure/services/gemini-image-edit.service.ts

@@ -0,0 +1,134 @@
+/**
+ * Gemini Image Edit Service
+ * Handles image editing/transformation using Gemini API
+ */
+
+import { geminiClientCoreService } from "./gemini-client-core.service";
+import { geminiRetryService } from "./gemini-retry.service";
+import { extractBase64Data } from "../utils/gemini-data-transformer.util";
+import { DEFAULT_MODELS } from "../../domain/entities";
+import type { GeminiImageGenerationResult } from "../../domain/entities";
+
+declare const __DEV__: boolean;
+
+interface GeminiContentResponse {
+  candidates?: Array<{
+    content?: {
+      parts?: Array<{
+        text?: string;
+        inlineData?: {
+          data?: string;
+          mimeType?: string;
+        };
+      }>;
+    };
+  }>;
+}
+
+class GeminiImageEditService {
+  /**
+   * Edit/transform image using Gemini generateContent API
+   * Takes input image + prompt and generates new image
+   */
+  async editImage(
+    prompt: string,
+    images: Array<{ base64: string; mimeType: string }>,
+  ): Promise<GeminiImageGenerationResult> {
+    geminiClientCoreService.validateInitialization();
+
+    const config = geminiClientCoreService.getConfig();
+    const editModel = DEFAULT_MODELS.IMAGE_EDIT;
+    const apiKey = config?.apiKey;
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[GeminiClient] editImage() called", {
+        model: editModel,
+        promptLength: prompt.length,
+        imagesCount: images.length,
+      });
+    }
+
+    const url = `https://generativelanguage.googleapis.com/v1beta/models/${editModel}:generateContent`;
+
+    const parts: Array<Record<string, unknown>> = [];
+
+    for (const image of images) {
+      parts.push({
+        inlineData: {
+          mimeType: image.mimeType,
+          data: extractBase64Data(image.base64),
+        },
+      });
+    }
+
+    parts.push({ text: prompt });
+
+    const requestBody = {
+      contents: [{ parts }],
+      generationConfig: {
+        responseModalities: ["TEXT", "IMAGE"],
+      },
+    };
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[GeminiClient] editImage() request", {
+        url,
+        partsCount: parts.length,
+      });
+    }
+
+    const response = 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 new Error(`Image edit API error (${res.status}): ${errorText}`);
+      }
+
+      return res.json() as Promise<GeminiContentResponse>;
+    });
+
+    const result: GeminiImageGenerationResult = {
+      text: undefined,
+      imageUrl: undefined,
+      imageBase64: undefined,
+      mimeType: "image/png",
+    };
+
+    const candidate = response.candidates?.[0];
+    const responseParts = candidate?.content?.parts || [];
+
+    for (const part of responseParts) {
+      if (part.text) {
+        result.text = part.text;
+      }
+      if (part.inlineData) {
+        result.imageBase64 = part.inlineData.data;
+        result.mimeType = part.inlineData.mimeType || "image/png";
+        result.imageUrl = `data:${result.mimeType};base64,${result.imageBase64}`;
+      }
+    }
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[GeminiClient] editImage() completed", {
+        hasImage: !!result.imageBase64,
+        hasText: !!result.text,
+        imageDataLength: result.imageBase64?.length ?? 0,
+      });
+    }
+
+    return result;
+  }
+}
+
+export const geminiImageEditService = new GeminiImageEditService();

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

@@ -0,0 +1,113 @@
+/**
+ * Gemini Image Generation Service
+ * Handles image generation using Imagen API
+ */
+
+import { geminiClientCoreService } from "./gemini-client-core.service";
+import { geminiRetryService } from "./gemini-retry.service";
+import { DEFAULT_MODELS } from "../../domain/entities";
+import type {
+  GeminiGenerationConfig,
+  GeminiImageGenerationResult,
+} from "../../domain/entities";
+
+declare const __DEV__: boolean;
+
+interface ImagenApiResponse {
+  generatedImages?: Array<{
+    image?: {
+      imageBytes?: string;
+    };
+  }>;
+}
+
+class GeminiImageGenerationService {
+  /**
+   * Generate image from prompt using Imagen API
+   * Uses REST API endpoint: /v1beta/models/{model}:predict
+   */
+  async generateImage(
+    prompt: string,
+    _images?: Array<{ base64: string; mimeType: string }>,
+    _config?: GeminiGenerationConfig,
+  ): Promise<GeminiImageGenerationResult> {
+    geminiClientCoreService.validateInitialization();
+
+    const config = geminiClientCoreService.getConfig();
+    const imageModel = config?.imageModel || DEFAULT_MODELS.TEXT_TO_IMAGE;
+    const apiKey = config?.apiKey;
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[GeminiClient] generateImage() called (Imagen API)", {
+        model: imageModel,
+        promptLength: prompt.length,
+      });
+    }
+
+    const url = `https://generativelanguage.googleapis.com/v1beta/models/${imageModel}:predict`;
+
+    const requestBody = {
+      instances: [{ prompt }],
+      parameters: {
+        sampleCount: 1,
+        aspectRatio: "1:1",
+      },
+    };
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[GeminiClient] Imagen API request", {
+        url,
+        prompt: prompt.substring(0, 100) + "...",
+      });
+    }
+
+    const response = 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 new Error(`Imagen API error (${res.status}): ${errorText}`);
+      }
+
+      return res.json() as Promise<ImagenApiResponse>;
+    });
+
+    const result: GeminiImageGenerationResult = {
+      text: undefined,
+      imageUrl: undefined,
+      imageBase64: undefined,
+      mimeType: "image/png",
+    };
+
+    if (response.generatedImages && response.generatedImages.length > 0) {
+      const generatedImage = response.generatedImages[0];
+      const imageBytes = generatedImage.image?.imageBytes;
+
+      if (imageBytes) {
+        result.imageBase64 = imageBytes;
+        result.imageUrl = `data:image/png;base64,${imageBytes}`;
+      }
+    }
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[GeminiClient] generateImage() completed (Imagen)", {
+        hasImage: !!result.imageBase64,
+        imageDataLength: result.imageBase64?.length ?? 0,
+      });
+    }
+
+    return result;
+  }
+}
+
+export const geminiImageGenerationService = new GeminiImageGenerationService();

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

@@ -9,18 +9,14 @@ import type {
   GeminiImageInput,
   GeminiImageGenerationResult,
 } from "../../domain/entities";
-import { geminiClientService } from "./gemini-client.service";
+import { geminiClientCoreService } from "./gemini-client-core.service";
+import { geminiTextGenerationService } from "./gemini-text-generation.service";
+import { geminiImageGenerationService } from "./gemini-image-generation.service";
+import { geminiImageEditService } from "./gemini-image-edit.service";
+import { extractBase64Data } from "../utils/gemini-data-transformer.util";
 
 declare const __DEV__: boolean;
 
-function extractBase64Data(base64String: string): string {
-  if (!base64String.includes(",")) {
-    return base64String;
-  }
-  const parts = base64String.split(",");
-  return parts[1] ?? parts[0] ?? base64String;
-}
-
 export interface AIProviderConfig {
   apiKey: string;
   maxRetries?: number;
@@ -84,7 +80,7 @@ class GeminiProviderService {
       imageModel: config.imageModel,
     };
 
-    geminiClientService.initialize(geminiConfig);
+    geminiClientCoreService.initialize(geminiConfig);
 
     if (typeof __DEV__ !== "undefined" && __DEV__) {
       // eslint-disable-next-line no-console
@@ -93,7 +89,7 @@ class GeminiProviderService {
   }
 
   isInitialized(): boolean {
-    return geminiClientService.isInitialized();
+    return geminiClientCoreService.isInitialized();
   }
 
   submitJob(
@@ -207,7 +203,7 @@ class GeminiProviderService {
   async generateImage(
     prompt: string,
   ): Promise<GeminiImageGenerationResult> {
-    return geminiClientService.generateImage(prompt);
+    return geminiImageGenerationService.generateImage(prompt);
   }
 
   /**
@@ -218,7 +214,7 @@ class GeminiProviderService {
     prompt: string,
     images: GeminiImageInput[],
   ): Promise<GeminiImageGenerationResult> {
-    return geminiClientService.editImage(prompt, images);
+    return geminiImageEditService.editImage(prompt, images);
   }
 
   /**
@@ -238,7 +234,7 @@ class GeminiProviderService {
       });
     }
 
-    const response = await geminiClientService.generateWithImages(
+    const response = await geminiTextGenerationService.generateWithImages(
       model,
       prompt,
       images,
@@ -261,7 +257,7 @@ class GeminiProviderService {
   }
 
   reset(): void {
-    geminiClientService.reset();
+    geminiClientCoreService.reset();
     this.pendingJobs.clear();
     this.jobCounter = 0;
   }
@@ -306,12 +302,12 @@ class GeminiProviderService {
     if (isImageGeneration) {
       const prompt = String(input.prompt || "");
       const images = input.images as GeminiImageInput[] | undefined;
-      const result = await geminiClientService.generateImage(prompt, images);
+      const result = await geminiImageGenerationService.generateImage(prompt, images);
       return result as T;
     }
 
     const contents = this.buildContents(input);
-    const response = await geminiClientService.generateContent(
+    const response = await geminiTextGenerationService.generateContent(
       model,
       contents,
       input.generationConfig as undefined,

package/src/infrastructure/services/gemini-retry.service.ts

@@ -0,0 +1,63 @@
+/**
+ * Gemini Retry Service
+ * Handles retry logic with exponential backoff
+ */
+
+import { geminiClientCoreService } from "./gemini-client-core.service";
+
+declare const __DEV__: boolean;
+
+const RETRYABLE_ERROR_PATTERNS = [
+  "rate limit",
+  "too many requests",
+  "429",
+  "500",
+  "502",
+  "503",
+  "504",
+  "timeout",
+  "network",
+  "econnrefused",
+  "fetch failed",
+];
+
+function isRetryableError(error: unknown): boolean {
+  const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+  return RETRYABLE_ERROR_PATTERNS.some((pattern) => message.includes(pattern));
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+class GeminiRetryService {
+  async executeWithRetry<T>(
+    operation: () => Promise<T>,
+    retryCount = 0,
+  ): Promise<T> {
+    const config = geminiClientCoreService.getConfig();
+    const maxRetries = config?.maxRetries ?? 3;
+    const baseDelay = config?.baseDelay ?? 1000;
+    const maxDelay = config?.maxDelay ?? 10000;
+
+    try {
+      return await operation();
+    } catch (error) {
+      if (!isRetryableError(error) || retryCount >= maxRetries) {
+        throw error;
+      }
+
+      const delay = Math.min(baseDelay * Math.pow(2, retryCount), maxDelay);
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        // eslint-disable-next-line no-console
+        console.log(`[Gemini] Retry ${retryCount + 1}/${maxRetries} after ${delay}ms`);
+      }
+
+      await sleep(delay);
+      return this.executeWithRetry(operation, retryCount + 1);
+    }
+  }
+}
+
+export const geminiRetryService = new GeminiRetryService();

package/src/infrastructure/services/gemini-streaming.service.ts

@@ -0,0 +1,61 @@
+/**
+ * Gemini Streaming Service
+ * Handles streaming content generation
+ */
+
+import { geminiClientCoreService } from "./gemini-client-core.service";
+import type {
+  GeminiContent,
+  GeminiGenerationConfig,
+} from "../../domain/entities";
+
+class GeminiStreamingService {
+  /**
+   * Stream content generation
+   */
+  async streamContent(
+    model: string,
+    contents: GeminiContent[],
+    onChunk: (text: string) => void,
+    generationConfig?: GeminiGenerationConfig,
+  ): Promise<string> {
+    const genModel = geminiClientCoreService.getModel(model);
+
+    const sdkContents = contents.map((content) => ({
+      role: content.role || "user",
+      parts: content.parts.map((part) => {
+        if ("text" in part) {
+          return { text: part.text };
+        }
+        if ("inlineData" in part) {
+          return {
+            inlineData: {
+              mimeType: part.inlineData.mimeType,
+              data: part.inlineData.data,
+            },
+          };
+        }
+        return part;
+      }),
+    }));
+
+    const result = await genModel.generateContentStream({
+      contents: sdkContents as Parameters<typeof genModel.generateContentStream>[0] extends { contents: infer C } ? C : never,
+      generationConfig,
+    });
+
+    let fullText = "";
+
+    for await (const chunk of result.stream) {
+      const chunkText = chunk.text();
+      if (chunkText) {
+        fullText += chunkText;
+        onChunk(chunkText);
+      }
+    }
+
+    return fullText;
+  }
+}
+
+export const geminiStreamingService = new GeminiStreamingService();