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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-gemini-provider",
-  "version": "1.1.0",
+  "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

@@ -129,39 +129,58 @@ class GeminiClientService {
       }),
     }));
 
-    const result = await this.executeWithRetry(() =>
-      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;
+    }
   }
 
   /**

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

@@ -165,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;
   }
 
   /**
@@ -233,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,
@@ -327,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,