@umituz/react-native-ai-gemini-provider 1.6.0 → 1.8.0

package/package.json

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

package/src/domain/entities/models.ts

@@ -14,10 +14,9 @@ export const GEMINI_MODELS = {
     PRO: "gemini-1.5-pro",
   },
 
-  // Image generation models
+  // Image generation models (Imagen 4.0)
   IMAGE: {
-    FLASH: "gemini-2.5-flash-preview-image-generation",
-    FLASH_STABLE: "gemini-2.0-flash-preview-image-generation",
+    DEFAULT: "imagen-4.0-generate-001",
   },
 
   // Video understanding models
@@ -31,7 +30,7 @@ export const GEMINI_MODELS = {
  */
 export const DEFAULT_MODELS = {
   TEXT: GEMINI_MODELS.TEXT.FLASH,
-  IMAGE: GEMINI_MODELS.IMAGE.FLASH,
+  IMAGE: GEMINI_MODELS.IMAGE.DEFAULT,
   VIDEO: GEMINI_MODELS.VIDEO.FLASH,
 } as const;
 

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

@@ -4,10 +4,7 @@
  */
 
 import { GoogleGenerativeAI, type GenerativeModel } from "@google/generative-ai";
-import {
-  DEFAULT_MODELS,
-  RESPONSE_MODALITIES,
-} from "../../domain/entities";
+import { DEFAULT_MODELS } from "../../domain/entities";
 import type {
   GeminiConfig,
   GeminiContent,
@@ -257,83 +254,84 @@ class GeminiClientService {
   }
 
   /**
-   * Generate image from prompt and/or input images
-   * Uses centralized model config with responseModalities for image output
+   * 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,
+    _images?: Array<{ base64: string; mimeType: string }>,
+    _config?: GeminiGenerationConfig,
   ): Promise<GeminiImageGenerationResult> {
+    this.validateInitialization();
+
     const imageModel = this.config?.imageModel || DEFAULT_MODELS.IMAGE;
+    const apiKey = this.config?.apiKey;
 
     if (typeof __DEV__ !== "undefined" && __DEV__) {
       // eslint-disable-next-line no-console
-      console.log("[GeminiClient] generateImage() called", {
+      console.log("[GeminiClient] generateImage() called (Imagen API)", {
         model: imageModel,
         promptLength: prompt.length,
-        hasInputImages: !!images?.length,
-        inputImagesCount: images?.length ?? 0,
       });
     }
 
-    const parts: GeminiContent["parts"] = [{ text: prompt }];
+    const url = `https://generativelanguage.googleapis.com/v1beta/models/${imageModel}:predict`;
 
-    // Add input images if provided (for image-to-image generation)
-    if (images && images.length > 0) {
-      for (const image of images) {
-        const base64Data = image.base64.includes(",")
-          ? image.base64.split(",")[1]
-          : image.base64;
-
-        parts.push({
-          inlineData: {
-            mimeType: image.mimeType,
-            data: base64Data,
-          },
-        });
-      }
+    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 contents: GeminiContent[] = [{ parts, role: "user" }];
+    const response = await this.executeWithRetry(async () => {
+      const res = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-goog-api-key": apiKey!,
+        },
+        body: JSON.stringify(requestBody),
+      });
 
-    // Image generation requires responseModalities to include IMAGE
-    const imageConfig: GeminiGenerationConfig = {
-      ...config,
-      responseModalities: [...RESPONSE_MODALITIES.TEXT_AND_IMAGE],
-    };
+      if (!res.ok) {
+        const errorText = await res.text();
+        throw new Error(`Imagen API error (${res.status}): ${errorText}`);
+      }
 
-    const response = await this.generateContent(imageModel, contents, imageConfig);
+      return res.json();
+    });
 
-    // Extract generated image from response
     const result: GeminiImageGenerationResult = {
       text: undefined,
       imageUrl: undefined,
       imageBase64: undefined,
-      mimeType: undefined,
+      mimeType: "image/png",
     };
 
-    if (response.candidates && response.candidates.length > 0) {
-      const candidate = response.candidates[0];
+    if (response.generatedImages && response.generatedImages.length > 0) {
+      const generatedImage = response.generatedImages[0];
+      const imageBytes = generatedImage.image?.imageBytes;
 
-      for (const part of candidate.content.parts) {
-        if ("text" in part && part.text) {
-          result.text = part.text;
-        }
-        if ("inlineData" in part && part.inlineData) {
-          result.imageBase64 = part.inlineData.data;
-          result.mimeType = part.inlineData.mimeType;
-          result.imageUrl = `data:${part.inlineData.mimeType};base64,${part.inlineData.data}`;
-        }
+      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", {
-        hasText: !!result.text,
+      console.log("[GeminiClient] generateImage() completed (Imagen)", {
         hasImage: !!result.imageBase64,
-        mimeType: result.mimeType,
         imageDataLength: result.imageBase64?.length ?? 0,
       });
     }