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

package/package.json

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

package/src/domain/entities/gemini.types.ts

@@ -21,6 +21,8 @@ export interface GeminiGenerationConfig {
   topP?: number;
   maxOutputTokens?: number;
   stopSequences?: string[];
+  /** Response modalities for multimodal output (TEXT, IMAGE) */
+  responseModalities?: Array<"TEXT" | "IMAGE">;
 }
 
 export interface GeminiSafetySettings {

package/src/domain/entities/index.ts

@@ -4,3 +4,4 @@
 
 export * from "./gemini.types";
 export * from "./error.types";
+export * from "./models";

package/src/domain/entities/models.ts

@@ -0,0 +1,47 @@
+/**
+ * Gemini Model Constants
+ * Centralized model configuration for all AI operations
+ */
+
+/**
+ * Available Gemini 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",
+  },
+
+  // Image generation models
+  IMAGE: {
+    FLASH: "gemini-2.5-flash-preview-image-generation",
+    FLASH_STABLE: "gemini-2.0-flash-preview-image-generation",
+  },
+
+  // Video understanding models
+  VIDEO: {
+    FLASH: "gemini-2.0-flash",
+  },
+} as const;
+
+/**
+ * Default models for each operation type
+ */
+export const DEFAULT_MODELS = {
+  TEXT: GEMINI_MODELS.TEXT.FLASH,
+  IMAGE: GEMINI_MODELS.IMAGE.FLASH,
+  VIDEO: GEMINI_MODELS.VIDEO.FLASH,
+} as const;
+
+/**
+ * Response modalities for different generation types
+ */
+export const RESPONSE_MODALITIES = {
+  TEXT_ONLY: ["TEXT"] as const,
+  IMAGE_ONLY: ["IMAGE"] as const,
+  TEXT_AND_IMAGE: ["TEXT", "IMAGE"] as const,
+} as const;
+
+export type ResponseModality = "TEXT" | "IMAGE";

package/src/index.ts

@@ -42,6 +42,15 @@ export type {
   GeminiApiError,
 } from "./domain/entities";
 
+// Model Constants
+export {
+  GEMINI_MODELS,
+  DEFAULT_MODELS,
+  RESPONSE_MODALITIES,
+} from "./domain/entities";
+
+export type { ResponseModality } from "./domain/entities";
+
 // =============================================================================
 // INFRASTRUCTURE LAYER - Services
 // =============================================================================

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

@@ -4,6 +4,10 @@
  */
 
 import { GoogleGenerativeAI, type GenerativeModel } from "@google/generative-ai";
+import {
+  DEFAULT_MODELS,
+  RESPONSE_MODALITIES,
+} from "../../domain/entities";
 import type {
   GeminiConfig,
   GeminiContent,
@@ -21,8 +25,8 @@ const DEFAULT_CONFIG: Partial<GeminiConfig> = {
   baseDelay: 1000,
   maxDelay: 10000,
   defaultTimeoutMs: 60000,
-  defaultModel: "gemini-2.0-flash",
-  imageModel: "gemini-2.0-flash-preview-image-generation",
+  defaultModel: DEFAULT_MODELS.TEXT,
+  imageModel: DEFAULT_MODELS.IMAGE,
 };
 
 const RETRYABLE_ERROR_PATTERNS = [
@@ -62,13 +66,26 @@ class GeminiClientService {
   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("[Gemini] Client initialized with official SDK");
+      console.log("[GeminiClient] initialized successfully", {
+        defaultModel: this.config.defaultModel,
+        imageModel: this.config.imageModel,
+        maxRetries: this.config.maxRetries,
+      });
     }
   }
 
@@ -208,6 +225,16 @@ class GeminiClientService {
     images: Array<{ base64: string; mimeType: string }>,
     config?: GeminiGenerationConfig,
   ): Promise<GeminiResponse> {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[GeminiClient] generateWithImages() called", {
+        model,
+        promptLength: prompt.length,
+        imagesCount: images.length,
+        imageMimeTypes: images.map(i => i.mimeType),
+      });
+    }
+
     const parts: GeminiContent["parts"] = [{ text: prompt }];
 
     for (const image of images) {
@@ -221,23 +248,33 @@ class GeminiClientService {
 
     const contents: GeminiContent[] = [{ parts, role: "user" }];
 
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[GeminiClient] generateWithImages() → calling generateContent()");
+    }
+
     return this.generateContent(model, contents, config);
   }
 
   /**
    * Generate image from prompt and/or input images
-   * Uses Gemini 2.0 Flash with image generation capability
+   * Uses centralized model config with responseModalities for image output
    */
   async generateImage(
     prompt: string,
     images?: Array<{ base64: string; mimeType: string }>,
     config?: GeminiGenerationConfig,
   ): Promise<GeminiImageGenerationResult> {
-    const imageModel = this.config?.imageModel || "gemini-2.0-flash-preview-image-generation";
+    const imageModel = this.config?.imageModel || DEFAULT_MODELS.IMAGE;
 
     if (typeof __DEV__ !== "undefined" && __DEV__) {
       // eslint-disable-next-line no-console
-      console.log("[Gemini] Generate image:", { model: imageModel, hasInputImages: !!images?.length });
+      console.log("[GeminiClient] generateImage() called", {
+        model: imageModel,
+        promptLength: prompt.length,
+        hasInputImages: !!images?.length,
+        inputImagesCount: images?.length ?? 0,
+      });
     }
 
     const parts: GeminiContent["parts"] = [{ text: prompt }];
@@ -259,7 +296,14 @@ class GeminiClientService {
     }
 
     const contents: GeminiContent[] = [{ parts, role: "user" }];
-    const response = await this.generateContent(imageModel, contents, config);
+
+    // Image generation requires responseModalities to include IMAGE
+    const imageConfig: GeminiGenerationConfig = {
+      ...config,
+      responseModalities: [...RESPONSE_MODALITIES.TEXT_AND_IMAGE],
+    };
+
+    const response = await this.generateContent(imageModel, contents, imageConfig);
 
     // Extract generated image from response
     const result: GeminiImageGenerationResult = {
@@ -284,6 +328,16 @@ class GeminiClientService {
       }
     }
 
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[GeminiClient] generateImage() completed", {
+        hasText: !!result.text,
+        hasImage: !!result.imageBase64,
+        mimeType: result.mimeType,
+        imageDataLength: result.imageBase64?.length ?? 0,
+      });
+    }
+
     return result;
   }
 

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

@@ -67,6 +67,14 @@ class GeminiProviderService {
   private jobCounter = 0;
 
   initialize(config: AIProviderConfig): void {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[GeminiProvider] initialize() called", {
+        hasApiKey: !!config.apiKey,
+        imageModel: config.imageModel,
+      });
+    }
+
     const geminiConfig: GeminiConfig = {
       apiKey: config.apiKey,
       maxRetries: config.maxRetries,
@@ -77,6 +85,11 @@ class GeminiProviderService {
     };
 
     geminiClientService.initialize(geminiConfig);
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[GeminiProvider] initialized successfully");
+    }
   }
 
   isInitialized(): boolean {
@@ -206,6 +219,15 @@ class GeminiProviderService {
     prompt: string,
     images: GeminiImageInput[],
   ): Promise<{ text: string; response: unknown }> {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[GeminiProvider] generateWithImages() called", {
+        model,
+        promptLength: prompt.length,
+        imagesCount: images.length,
+      });
+    }
+
     const response = await geminiClientService.generateWithImages(
       model,
       prompt,
@@ -217,6 +239,14 @@ class GeminiProviderService {
       .map((p) => p.text)
       .join("") || "";
 
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[GeminiProvider] generateWithImages() completed", {
+        hasText: !!text,
+        textLength: text.length,
+      });
+    }
+
     return { text, response };
   }