@umituz/react-native-ai-gemini-provider 1.8.2 → 1.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-gemini-provider",
-  "version": "1.8.2",
+  "version": "1.9.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,11 +14,16 @@ export const GEMINI_MODELS = {
     PRO: "gemini-1.5-pro",
   },
 
-  // Image generation models (Imagen 4.0)
-  IMAGE: {
+  // Text-to-Image models (Imagen 4.0) - generates images from text only
+  TEXT_TO_IMAGE: {
     DEFAULT: "imagen-4.0-generate-001",
   },
 
+  // Image editing models (Gemini) - transforms/edits images with input image + prompt
+  IMAGE_EDIT: {
+    DEFAULT: "gemini-2.0-flash-exp-image-generation",
+  },
+
   // Video understanding models
   VIDEO: {
     FLASH: "gemini-2.0-flash",
@@ -30,7 +35,8 @@ export const GEMINI_MODELS = {
  */
 export const DEFAULT_MODELS = {
   TEXT: GEMINI_MODELS.TEXT.FLASH,
-  IMAGE: GEMINI_MODELS.IMAGE.DEFAULT,
+  TEXT_TO_IMAGE: GEMINI_MODELS.TEXT_TO_IMAGE.DEFAULT,
+  IMAGE_EDIT: GEMINI_MODELS.IMAGE_EDIT.DEFAULT,
   VIDEO: GEMINI_MODELS.VIDEO.FLASH,
 } as const;
 

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(
@@ -201,14 +197,24 @@ class GeminiProviderService {
   }
 
   /**
-   * Generate image with optional input images
-   * Convenience method for image generation
+   * Generate image from text only (Imagen API)
+   * Use for text-to-image generation without input images
    */
   async generateImage(
     prompt: string,
-    images?: GeminiImageInput[],
   ): Promise<GeminiImageGenerationResult> {
-    return geminiClientService.generateImage(prompt, images);
+    return geminiImageGenerationService.generateImage(prompt);
+  }
+
+  /**
+   * Edit/transform image using input image + prompt (Gemini API)
+   * Use for image editing, transformation, style transfer
+   */
+  async editImage(
+    prompt: string,
+    images: GeminiImageInput[],
+  ): Promise<GeminiImageGenerationResult> {
+    return geminiImageEditService.editImage(prompt, images);
   }
 
   /**
@@ -228,7 +234,7 @@ class GeminiProviderService {
       });
     }
 
-    const response = await geminiClientService.generateWithImages(
+    const response = await geminiTextGenerationService.generateWithImages(
       model,
       prompt,
       images,
@@ -251,7 +257,7 @@ class GeminiProviderService {
   }
 
   reset(): void {
-    geminiClientService.reset();
+    geminiClientCoreService.reset();
     this.pendingJobs.clear();
     this.jobCounter = 0;
   }
@@ -296,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();

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

@@ -0,0 +1,164 @@
+/**
+ * Gemini Text Generation Service
+ * Handles text and multimodal content generation
+ */
+
+import { geminiClientCoreService } from "./gemini-client-core.service";
+import { geminiRetryService } from "./gemini-retry.service";
+import { extractBase64Data, extractTextFromResponse } from "../utils/gemini-data-transformer.util";
+import type {
+  GeminiContent,
+  GeminiGenerationConfig,
+  GeminiResponse,
+  GeminiPart,
+  GeminiFinishReason,
+} from "../../domain/entities";
+
+declare const __DEV__: boolean;
+
+class GeminiTextGenerationService {
+  /**
+   * Generate content (text, with optional images)
+   */
+  async generateContent(
+    model: string,
+    contents: GeminiContent[],
+    generationConfig?: GeminiGenerationConfig,
+  ): Promise<GeminiResponse> {
+    const genModel = geminiClientCoreService.getModel(model);
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[Gemini] Generate content:", { 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;
+      }),
+    }));
+
+    try {
+      const result = await geminiRetryService.executeWithRetry(() =>
+        genModel.generateContent({
+          contents: sdkContents as Parameters<typeof genModel.generateContent>[0] extends { contents: infer C } ? C : never,
+          generationConfig,
+        }),
+      );
+
+      const response = result.response;
+
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        // eslint-disable-next-line no-console
+        console.log("[Gemini] Content generated:", {
+          candidatesCount: response.candidates?.length ?? 0,
+          finishReason: response.candidates?.[0]?.finishReason,
+        });
+      }
+
+      return {
+        candidates: response.candidates?.map((candidate) => ({
+          content: {
+            parts: candidate.content.parts
+              .map((part): GeminiPart | null => {
+                if ("text" in part && part.text !== undefined) {
+                  return { text: part.text };
+                }
+                if ("inlineData" in part && part.inlineData) {
+                  return {
+                    inlineData: {
+                      mimeType: part.inlineData.mimeType,
+                      data: part.inlineData.data,
+                    },
+                  };
+                }
+                return null;
+              })
+              .filter((p): p is GeminiPart => p !== null),
+            role: (candidate.content.role || "model") as "user" | "model",
+          },
+          finishReason: candidate.finishReason as GeminiFinishReason | undefined,
+        })),
+      };
+    } catch (error) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        // eslint-disable-next-line no-console
+        console.error("[Gemini] Content generation failed:", {
+          model,
+          error: error instanceof Error ? error.message : String(error),
+        });
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Generate text from prompt
+   */
+  async generateText(
+    model: string,
+    prompt: string,
+    config?: GeminiGenerationConfig,
+  ): Promise<string> {
+    const contents: GeminiContent[] = [
+      { parts: [{ text: prompt }], role: "user" },
+    ];
+
+    const response = await this.generateContent(model, contents, config);
+    return extractTextFromResponse(response);
+  }
+
+  /**
+   * Generate content with images (multimodal)
+   */
+  async generateWithImages(
+    model: string,
+    prompt: string,
+    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) {
+      parts.push({
+        inlineData: {
+          mimeType: image.mimeType,
+          data: extractBase64Data(image.base64),
+        },
+      });
+    }
+
+    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);
+  }
+}
+
+export const geminiTextGenerationService = new GeminiTextGenerationService();

package/src/infrastructure/services/index.ts

@@ -2,7 +2,15 @@
  * Infrastructure Services
  */
 
-export { geminiClientService } from "./gemini-client.service";
+// Core services
+export { geminiClientCoreService } from "./gemini-client-core.service";
+export { geminiRetryService } from "./gemini-retry.service";
+export { geminiTextGenerationService } from "./gemini-text-generation.service";
+export { geminiImageGenerationService } from "./gemini-image-generation.service";
+export { geminiImageEditService } from "./gemini-image-edit.service";
+export { geminiStreamingService } from "./gemini-streaming.service";
+
+// Public provider API
 export {
   geminiProviderService,
   createGeminiProvider,

package/src/infrastructure/utils/gemini-data-transformer.util.ts

@@ -0,0 +1,42 @@
+/**
+ * Gemini Data Transformer Utility
+ * Handles data extraction and response parsing
+ */
+
+import type { GeminiResponse } from "../../domain/entities";
+
+/**
+ * Extract base64 data from data URL or return as-is
+ */
+export function extractBase64Data(base64String: string): string {
+  if (!base64String.includes(",")) {
+    return base64String;
+  }
+  const parts = base64String.split(",");
+  return parts[1] ?? parts[0] ?? base64String;
+}
+
+/**
+ * Extract text from Gemini response
+ */
+export function extractTextFromResponse(response: GeminiResponse): string {
+  const candidate = response.candidates?.[0];
+
+  if (!candidate) {
+    throw new Error("No response candidates");
+  }
+
+  if (candidate.finishReason === "SAFETY") {
+    throw new Error("Content blocked by safety filters");
+  }
+
+  const textPart = candidate.content.parts.find(
+    (p): p is { text: string } => "text" in p && typeof p.text === "string",
+  );
+
+  if (!textPart) {
+    throw new Error("No text in response");
+  }
+
+  return textPart.text;
+}

package/src/infrastructure/utils/index.ts

@@ -7,3 +7,8 @@ export {
   isGeminiErrorRetryable,
   categorizeGeminiError,
 } from "./error-mapper.util";
+
+export {
+  extractBase64Data,
+  extractTextFromResponse,
+} from "./gemini-data-transformer.util";

package/src/presentation/hooks/use-gemini.ts

@@ -5,7 +5,7 @@
 
 import { useState, useCallback, useRef } from "react";
 import type { GeminiGenerationConfig } from "../../domain/entities";
-import { geminiClientService } from "../../infrastructure/services";
+import { geminiTextGenerationService } from "../../infrastructure/services";
 
 export interface UseGeminiOptions {
   model?: string;
@@ -43,7 +43,7 @@ export function useGemini(options: UseGeminiOptions = {}): UseGeminiReturn {
 
       try {
         const model = options.model ?? "gemini-1.5-flash";
-        const text = await geminiClientService.generateText(
+        const text = await geminiTextGenerationService.generateText(
           model,
           prompt,
           options.generationConfig,
@@ -78,7 +78,7 @@ export function useGemini(options: UseGeminiOptions = {}): UseGeminiReturn {
 
       try {
         const model = options.model ?? "gemini-1.5-flash";
-        const response = await geminiClientService.generateWithImages(
+        const response = await geminiTextGenerationService.generateWithImages(
           model,
           prompt,
           [{ base64: imageBase64, mimeType }],
@@ -91,7 +91,7 @@ export function useGemini(options: UseGeminiOptions = {}): UseGeminiReturn {
         const text =
           response.candidates?.[0]?.content.parts
             .filter((p): p is { text: string } => "text" in p)
-            .map((p) => p.text)
+            .map((p: { text: string }) => p.text)
             .join("") || "";
 
         setResult(text);

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

@@ -1,445 +0,0 @@
-/**
- * Gemini Client Service
- * Google Gemini AI client using official SDK
- */
-
-import { GoogleGenerativeAI, type GenerativeModel } from "@google/generative-ai";
-import { DEFAULT_MODELS } from "../../domain/entities";
-import type {
-  GeminiConfig,
-  GeminiContent,
-  GeminiGenerationConfig,
-  GeminiResponse,
-  GeminiImageGenerationResult,
-  GeminiPart,
-  GeminiFinishReason,
-} 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.IMAGE,
-};
-
-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));
-}
-
-function extractBase64Data(base64String: string): string {
-  if (!base64String.includes(",")) {
-    return base64String;
-  }
-  const parts = base64String.split(",");
-  return parts[1] ?? parts[0] ?? base64String;
-}
-
-class GeminiClientService {
-  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;
-  }
-
-  private validateInitialization(): void {
-    if (!this.client || !this.initialized) {
-      throw new Error(
-        "Gemini client not initialized. Call initialize() first.",
-      );
-    }
-  }
-
-  private getModel(modelName?: string): GenerativeModel {
-    this.validateInitialization();
-    const effectiveModel = modelName || this.config?.defaultModel || "gemini-1.5-flash";
-    return this.client!.getGenerativeModel({ model: effectiveModel });
-  }
-
-  /**
-   * Generate content (text, with optional images)
-   */
-  async generateContent(
-    model: string,
-    contents: GeminiContent[],
-    generationConfig?: GeminiGenerationConfig,
-  ): Promise<GeminiResponse> {
-    const genModel = this.getModel(model);
-
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[Gemini] Generate content:", { model });
-    }
-
-    // Convert our content format to SDK format
-    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,
-            },
-          };
-        }
-        // fileData parts
-        return part;
-      }),
-    }));
-
-    try {
-      const result = await this.executeWithRetry(() =>
-        genModel.generateContent({
-          contents: sdkContents as Parameters<typeof genModel.generateContent>[0] extends { contents: infer C } ? C : never,
-          generationConfig,
-        }),
-      );
-
-      const response = result.response;
-
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        // eslint-disable-next-line no-console
-        console.log("[Gemini] Content generated:", {
-          candidatesCount: response.candidates?.length ?? 0,
-          finishReason: response.candidates?.[0]?.finishReason,
-        });
-      }
-
-      return {
-        candidates: response.candidates?.map((candidate) => ({
-          content: {
-            parts: candidate.content.parts
-              .map((part): GeminiPart | null => {
-                if ("text" in part && part.text !== undefined) {
-                  return { text: part.text };
-                }
-                if ("inlineData" in part && part.inlineData) {
-                  return {
-                    inlineData: {
-                      mimeType: part.inlineData.mimeType,
-                      data: part.inlineData.data,
-                    },
-                  };
-                }
-                return null;
-              })
-              .filter((p): p is GeminiPart => p !== null),
-            role: (candidate.content.role || "model") as "user" | "model",
-          },
-          finishReason: candidate.finishReason as GeminiFinishReason | undefined,
-        })),
-      };
-    } catch (error) {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        // eslint-disable-next-line no-console
-        console.error("[Gemini] Content generation failed:", {
-          model,
-          error: error instanceof Error ? error.message : String(error),
-        });
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Generate text from prompt
-   */
-  async generateText(
-    model: string,
-    prompt: string,
-    config?: GeminiGenerationConfig,
-  ): Promise<string> {
-    const contents: GeminiContent[] = [
-      { parts: [{ text: prompt }], role: "user" },
-    ];
-
-    const response = await this.generateContent(model, contents, config);
-    return this.extractTextFromResponse(response);
-  }
-
-  /**
-   * Generate content with images (multimodal)
-   */
-  async generateWithImages(
-    model: string,
-    prompt: string,
-    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) {
-      parts.push({
-        inlineData: {
-          mimeType: image.mimeType,
-          data: extractBase64Data(image.base64),
-        },
-      });
-    }
-
-    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 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> {
-    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 (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 this.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();
-    });
-
-    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;
-  }
-
-  /**
-   * Stream content generation
-   */
-  async streamContent(
-    model: string,
-    contents: GeminiContent[],
-    onChunk: (text: string) => void,
-    generationConfig?: GeminiGenerationConfig,
-  ): Promise<string> {
-    const genModel = this.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;
-  }
-
-  private async executeWithRetry<T>(
-    operation: () => Promise<T>,
-    retryCount = 0,
-  ): Promise<T> {
-    const maxRetries = this.config?.maxRetries ?? 3;
-    const baseDelay = this.config?.baseDelay ?? 1000;
-    const maxDelay = this.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);
-    }
-  }
-
-  private extractTextFromResponse(response: GeminiResponse): string {
-    const candidate = response.candidates?.[0];
-
-    if (!candidate) {
-      throw new Error("No response candidates");
-    }
-
-    if (candidate.finishReason === "SAFETY") {
-      throw new Error("Content blocked by safety filters");
-    }
-
-    const textPart = candidate.content.parts.find(
-      (p): p is { text: string } => "text" in p && typeof p.text === "string",
-    );
-
-    if (!textPart) {
-      throw new Error("No text in response");
-    }
-
-    return textPart.text;
-  }
-
-  reset(): void {
-    this.client = null;
-    this.config = null;
-    this.initialized = false;
-  }
-}
-
-export const geminiClientService = new GeminiClientService();