@umituz/react-native-ai-gemini-provider 1.0.7 → 1.2.0

package/package.json

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

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

@@ -25,6 +25,37 @@ const DEFAULT_CONFIG: Partial<GeminiConfig> = {
   imageModel: "gemini-2.0-flash-exp",
 };
 
+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;
@@ -98,37 +129,58 @@ class GeminiClientService {
       }),
     }));
 
-    const result = await genModel.generateContent({
-      contents: sdkContents as Parameters<typeof genModel.generateContent>[0] extends { contents: infer C } ? C : never,
-      generationConfig,
-    });
+    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;
-
-    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,
-      })),
-    };
+      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;
+    }
   }
 
   /**
@@ -159,15 +211,10 @@ class GeminiClientService {
     const parts: GeminiContent["parts"] = [{ text: prompt }];
 
     for (const image of images) {
-      // Remove data URL prefix if present
-      const base64Data = image.base64.includes(",")
-        ? image.base64.split(",")[1]
-        : image.base64;
-
       parts.push({
         inlineData: {
           mimeType: image.mimeType,
-          data: base64Data,
+          data: extractBase64Data(image.base64),
         },
       });
     }
@@ -287,6 +334,33 @@ class GeminiClientService {
     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];
 

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

@@ -13,6 +13,14 @@ import { geminiClientService } from "./gemini-client.service";
 
 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;
@@ -157,7 +165,26 @@ class GeminiProviderService {
     model: string,
     input: Record<string, unknown>,
   ): Promise<T> {
-    return this.executeGeneration<T>(model, input);
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[GeminiProvider] Run started:", {
+        model,
+        hasPrompt: !!input.prompt,
+        outputFormat: input.outputFormat,
+      });
+    }
+
+    const result = await this.executeGeneration<T>(model, input);
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[GeminiProvider] Run completed:", {
+        model,
+        hasResult: !!result,
+      });
+    }
+
+    return result;
   }
 
   /**
@@ -225,17 +252,25 @@ class GeminiProviderService {
     model: string,
     input: Record<string, unknown>,
   ): Promise<T> {
-    // Check if this is an image generation request
-    if (input.generateImage === true || input.type === "image") {
+    const isImageGeneration = input.generateImage === true || input.type === "image";
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[GeminiProvider] Execute generation:", {
+        model,
+        isImageGeneration,
+        promptLength: String(input.prompt || "").length,
+      });
+    }
+
+    if (isImageGeneration) {
       const prompt = String(input.prompt || "");
       const images = input.images as GeminiImageInput[] | undefined;
       const result = await geminiClientService.generateImage(prompt, images);
       return result as T;
     }
 
-    // Regular content generation
     const contents = this.buildContents(input);
-
     const response = await geminiClientService.generateContent(
       model,
       contents,
@@ -262,13 +297,10 @@ class GeminiProviderService {
       // Handle multiple images
       if (Array.isArray(input.images)) {
         for (const img of input.images as GeminiImageInput[]) {
-          const base64Data = img.base64.includes(",")
-            ? img.base64.split(",")[1]
-            : img.base64;
           parts.push({
             inlineData: {
               mimeType: img.mimeType,
-              data: base64Data,
+              data: extractBase64Data(img.base64),
             },
           });
         }
@@ -322,11 +354,17 @@ class GeminiProviderService {
     const imagePart = parts.find((p) => p.inlineData);
     const imageData = imagePart?.inlineData;
 
-    if (input.outputFormat === "text") {
-      return text as T;
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[GeminiProvider] Format response:", {
+        hasText: !!text,
+        textLength: text?.length ?? 0,
+        hasImage: !!imageData,
+        outputFormat: input.outputFormat,
+      });
     }
 
-    // Return full result with image data if available
+    // Build result object - always return { text } for consistency
     const result: Record<string, unknown> = {
       text,
       response,