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

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);