@umituz/react-native-ai-gemini-provider 1.0.3 → 1.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-gemini-provider",
-  "version": "1.0.3",
+  "version": "1.0.6",
   "description": "Google Gemini AI provider for React Native applications",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -18,7 +18,8 @@
     "gemini",
     "google",
     "generation",
-    "llm"
+    "llm",
+    "image-generation"
   ],
   "author": "umituz",
   "license": "MIT",
@@ -27,9 +28,11 @@
     "url": "git+https://github.com/umituz/react-native-ai-gemini-provider.git"
   },
   "peerDependencies": {
-    "react": ">=18.0.0"
+    "react": ">=18.0.0",
+    "@google/generative-ai": ">=0.21.0"
   },
   "devDependencies": {
+    "@google/generative-ai": "^0.21.0",
     "@types/react": "^19.0.0",
     "@typescript-eslint/eslint-plugin": "^7.0.0",
     "@typescript-eslint/parser": "^7.0.0",

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

@@ -11,6 +11,8 @@ export interface GeminiConfig {
   maxDelay?: number;
   defaultTimeoutMs?: number;
   defaultModel?: string;
+  /** Model used for image generation (default: gemini-2.0-flash-exp) */
+  imageModel?: string;
 }
 
 export interface GeminiGenerationConfig {
@@ -101,3 +103,27 @@ export interface GeminiModel {
   outputTokenLimit?: number;
   supportedCapabilities?: string[];
 }
+
+/**
+ * Result from image generation
+ */
+export interface GeminiImageGenerationResult {
+  /** Generated text (story, caption, etc.) */
+  text?: string;
+  /** Data URL of the generated image (data:image/png;base64,...) */
+  imageUrl?: string;
+  /** Raw base64 image data */
+  imageBase64?: string;
+  /** MIME type of the generated image */
+  mimeType?: string;
+}
+
+/**
+ * Input for image generation
+ */
+export interface GeminiImageInput {
+  /** Base64 encoded image data (with or without data URL prefix) */
+  base64: string;
+  /** MIME type (e.g., "image/png", "image/jpeg") */
+  mimeType: string;
+}

package/src/index.ts

@@ -31,6 +31,8 @@ export type {
   GeminiPromptFeedback,
   GeminiUsageMetadata,
   GeminiModel,
+  GeminiImageGenerationResult,
+  GeminiImageInput,
 } from "./domain/entities";
 
 export { GeminiErrorType } from "./domain/entities";
@@ -47,6 +49,7 @@ export type {
 export {
   geminiClientService,
   geminiProviderService,
+  createGeminiProvider,
 } from "./infrastructure/services";
 
 export type {

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

@@ -1,40 +1,43 @@
 /**
  * Gemini Client Service
- * Google Gemini AI client wrapper
+ * Google Gemini AI client using official SDK
  */
 
+import { GoogleGenerativeAI, type GenerativeModel } from "@google/generative-ai";
 import type {
   GeminiConfig,
-  GeminiRequest,
-  GeminiResponse,
   GeminiContent,
   GeminiGenerationConfig,
+  GeminiResponse,
+  GeminiImageGenerationResult,
+  GeminiPart,
+  GeminiFinishReason,
 } from "../../domain/entities";
 
 declare const __DEV__: boolean;
 
 const DEFAULT_CONFIG: Partial<GeminiConfig> = {
-  baseUrl: "https://generativelanguage.googleapis.com/v1beta",
   maxRetries: 3,
   baseDelay: 1000,
   maxDelay: 10000,
   defaultTimeoutMs: 60000,
   defaultModel: "gemini-1.5-flash",
+  imageModel: "gemini-2.0-flash-exp",
 };
 
 class GeminiClientService {
-  private apiKey: string | null = null;
+  private client: GoogleGenerativeAI | null = null;
   private config: GeminiConfig | null = null;
   private initialized = false;
 
   initialize(config: GeminiConfig): void {
-    this.apiKey = config.apiKey;
+    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");
+      console.log("[Gemini] Client initialized with official SDK");
     }
   }
 
@@ -47,81 +50,90 @@ class GeminiClientService {
   }
 
   private validateInitialization(): void {
-    if (!this.apiKey || !this.initialized) {
+    if (!this.client || !this.initialized) {
       throw new Error(
         "Gemini client not initialized. Call initialize() first.",
       );
     }
   }
 
-  private getEndpoint(model: string, action: string): string {
-    const baseUrl = this.config?.baseUrl ?? DEFAULT_CONFIG.baseUrl;
-    return `${baseUrl}/models/${model}:${action}?key=${this.apiKey}`;
-  }
-
-  private async request<T>(
-    endpoint: string,
-    body: unknown,
-    timeoutMs?: number,
-  ): Promise<T> {
-    const timeout = timeoutMs ?? this.config?.defaultTimeoutMs ?? 60000;
-
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeout);
-
-    try {
-      const response = await fetch(endpoint, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-        },
-        body: JSON.stringify(body),
-        signal: controller.signal,
-      });
-
-      if (!response.ok) {
-        let errorData: { error?: { message?: string } } = {};
-        try {
-          errorData = (await response.json()) as { error?: { message?: string } };
-        } catch {
-          // Ignore JSON parse errors for error responses
-        }
-        const errorMessage = errorData?.error?.message ?? `HTTP ${response.status}`;
-        const error = new Error(errorMessage);
-        (error as unknown as Record<string, unknown>).status = response.status;
-        (error as unknown as Record<string, unknown>).response = errorData;
-        throw error;
-      }
-
-      return response.json() as Promise<T>;
-    } finally {
-      clearTimeout(timeoutId);
-    }
+  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> {
-    this.validateInitialization();
-
-    const effectiveModel = model || this.config?.defaultModel || "gemini-1.5-flash";
-    const endpoint = this.getEndpoint(effectiveModel, "generateContent");
-
-    const body: GeminiRequest = {
-      contents,
-      generationConfig,
-    };
+    const genModel = this.getModel(model);
 
     if (typeof __DEV__ !== "undefined" && __DEV__) {
       // eslint-disable-next-line no-console
-      console.log("[Gemini] Generate content:", { model: effectiveModel });
+      console.log("[Gemini] Generate content:", { model });
     }
 
-    return this.request<GeminiResponse>(endpoint, body);
+    // 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;
+      }),
+    }));
+
+    const result = await 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,
+      })),
+    };
   }
 
+  /**
+   * Generate text from prompt
+   */
   async generateText(
     model: string,
     prompt: string,
@@ -135,139 +147,170 @@ class GeminiClientService {
     return this.extractTextFromResponse(response);
   }
 
-  async generateWithImage(
+  /**
+   * Generate content with images (multimodal)
+   */
+  async generateWithImages(
     model: string,
     prompt: string,
-    imageBase64: string,
-    mimeType: string,
+    images: Array<{ base64: string; mimeType: string }>,
     config?: GeminiGenerationConfig,
-  ): Promise<string> {
-    const contents: GeminiContent[] = [
-      {
-        parts: [
-          { text: prompt },
-          { inlineData: { mimeType, data: imageBase64 } },
-        ],
-        role: "user",
-      },
-    ];
+  ): Promise<GeminiResponse> {
+    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,
+        },
+      });
+    }
 
-    const response = await this.generateContent(model, contents, config);
-    return this.extractTextFromResponse(response);
+    const contents: GeminiContent[] = [{ parts, role: "user" }];
+
+    return this.generateContent(model, contents, config);
   }
 
-  private extractTextFromResponse(response: GeminiResponse): string {
-    const candidate = response.candidates?.[0];
+  /**
+   * Generate image from prompt and/or input images
+   * Uses Gemini 2.0 Flash with image generation capability
+   */
+  async generateImage(
+    prompt: string,
+    images?: Array<{ base64: string; mimeType: string }>,
+    config?: GeminiGenerationConfig,
+  ): Promise<GeminiImageGenerationResult> {
+    const imageModel = this.config?.imageModel || "gemini-2.0-flash-exp";
 
-    if (!candidate) {
-      throw new Error("No response candidates");
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[Gemini] Generate image:", { model: imageModel, hasInputImages: !!images?.length });
     }
 
-    if (candidate.finishReason === "SAFETY") {
-      throw new Error("Content blocked by safety filters");
+    const parts: GeminiContent["parts"] = [{ text: prompt }];
+
+    // Add input images if provided (for image-to-image generation)
+    if (images && images.length > 0) {
+      for (const image of images) {
+        const base64Data = image.base64.includes(",")
+          ? image.base64.split(",")[1]
+          : image.base64;
+
+        parts.push({
+          inlineData: {
+            mimeType: image.mimeType,
+            data: base64Data,
+          },
+        });
+      }
     }
 
-    const textPart = candidate.content.parts.find(
-      (p): p is { text: string } => "text" in p,
-    );
+    const contents: GeminiContent[] = [{ parts, role: "user" }];
+    const response = await this.generateContent(imageModel, contents, config);
 
-    if (!textPart) {
-      throw new Error("No text in response");
+    // Extract generated image from response
+    const result: GeminiImageGenerationResult = {
+      text: undefined,
+      imageUrl: undefined,
+      imageBase64: undefined,
+      mimeType: undefined,
+    };
+
+    if (response.candidates && response.candidates.length > 0) {
+      const candidate = response.candidates[0];
+
+      for (const part of candidate.content.parts) {
+        if ("text" in part && part.text) {
+          result.text = part.text;
+        }
+        if ("inlineData" in part && part.inlineData) {
+          result.imageBase64 = part.inlineData.data;
+          result.mimeType = part.inlineData.mimeType;
+          result.imageUrl = `data:${part.inlineData.mimeType};base64,${part.inlineData.data}`;
+        }
+      }
     }
 
-    return textPart.text;
+    return result;
   }
 
+  /**
+   * Stream content generation
+   */
   async streamContent(
     model: string,
     contents: GeminiContent[],
     onChunk: (text: string) => void,
     generationConfig?: GeminiGenerationConfig,
   ): Promise<string> {
-    this.validateInitialization();
+    const genModel = this.getModel(model);
 
-    const effectiveModel = model || this.config?.defaultModel || "gemini-1.5-flash";
-    const endpoint = this.getEndpoint(effectiveModel, "streamGenerateContent");
+    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 body: GeminiRequest = {
-      contents,
+    const result = await genModel.generateContentStream({
+      contents: sdkContents as Parameters<typeof genModel.generateContentStream>[0] extends { contents: infer C } ? C : never,
       generationConfig,
-    };
+    });
 
-    const timeout = this.config?.defaultTimeoutMs ?? 60000;
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    let fullText = "";
 
-    try {
-      const response = await fetch(endpoint, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(body),
-        signal: controller.signal,
-      });
-
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}`);
-      }
-
-      const reader = response.body?.getReader();
-      if (!reader) {
-        throw new Error("No response body");
+    for await (const chunk of result.stream) {
+      const chunkText = chunk.text();
+      if (chunkText) {
+        fullText += chunkText;
+        onChunk(chunkText);
       }
+    }
 
-      const decoder = new TextDecoder();
-      let fullText = "";
-      let reading = true;
-
-      while (reading) {
-        const { done, value } = await reader.read();
-
-        if (done) {
-          reading = false;
-          continue;
-        }
+    return fullText;
+  }
 
-        const chunk = decoder.decode(value, { stream: true });
-        const text = this.parseStreamChunk(chunk);
+  private extractTextFromResponse(response: GeminiResponse): string {
+    const candidate = response.candidates?.[0];
 
-        if (text) {
-          fullText += text;
-          onChunk(text);
-        }
-      }
+    if (!candidate) {
+      throw new Error("No response candidates");
+    }
 
-      return fullText;
-    } finally {
-      clearTimeout(timeoutId);
+    if (candidate.finishReason === "SAFETY") {
+      throw new Error("Content blocked by safety filters");
     }
-  }
 
-  private parseStreamChunk(chunk: string): string {
-    try {
-      const lines = chunk.split("\n").filter((l) => l.trim());
-      let text = "";
-
-      for (const line of lines) {
-        if (line.startsWith("data: ")) {
-          const data = JSON.parse(line.slice(6)) as GeminiResponse;
-          const candidate = data.candidates?.[0];
-          const textPart = candidate?.content.parts.find(
-            (p): p is { text: string } => "text" in p,
-          );
-          if (textPart) {
-            text += textPart.text;
-          }
-        }
-      }
+    const textPart = candidate.content.parts.find(
+      (p): p is { text: string } => "text" in p && typeof p.text === "string",
+    );
 
-      return text;
-    } catch {
-      return "";
+    if (!textPart) {
+      throw new Error("No text in response");
     }
+
+    return textPart.text;
   }
 
   reset(): void {
-    this.apiKey = null;
+    this.client = null;
     this.config = null;
     this.initialized = false;
   }

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

@@ -3,7 +3,12 @@
  * IAIProvider implementation for Google Gemini
  */
 
-import type { GeminiConfig, GeminiContent } from "../../domain/entities";
+import type {
+  GeminiConfig,
+  GeminiContent,
+  GeminiImageInput,
+  GeminiImageGenerationResult,
+} from "../../domain/entities";
 import { geminiClientService } from "./gemini-client.service";
 
 declare const __DEV__: boolean;
@@ -14,6 +19,8 @@ export interface AIProviderConfig {
   baseDelay?: number;
   maxDelay?: number;
   defaultTimeoutMs?: number;
+  /** Model used for image generation */
+  imageModel?: string;
 }
 
 export interface JobSubmission {
@@ -58,6 +65,7 @@ class GeminiProviderService {
       baseDelay: config.baseDelay,
       maxDelay: config.maxDelay,
       defaultTimeoutMs: config.defaultTimeoutMs,
+      imageModel: config.imageModel,
     };
 
     geminiClientService.initialize(geminiConfig);
@@ -134,9 +142,11 @@ class GeminiProviderService {
     options?: SubscribeOptions<T>,
   ): Promise<T> {
     options?.onQueueUpdate?.({ status: "IN_QUEUE" });
+    options?.onProgress?.(10);
 
     const result = await this.executeGeneration<T>(model, input);
 
+    options?.onProgress?.(100);
     options?.onQueueUpdate?.({ status: "COMPLETED" });
     options?.onResult?.(result);
 
@@ -150,6 +160,39 @@ class GeminiProviderService {
     return this.executeGeneration<T>(model, input);
   }
 
+  /**
+   * Generate image with optional input images
+   * Convenience method for image generation
+   */
+  async generateImage(
+    prompt: string,
+    images?: GeminiImageInput[],
+  ): Promise<GeminiImageGenerationResult> {
+    return geminiClientService.generateImage(prompt, images);
+  }
+
+  /**
+   * Generate content with images (multimodal)
+   */
+  async generateWithImages(
+    model: string,
+    prompt: string,
+    images: GeminiImageInput[],
+  ): Promise<{ text: string; response: unknown }> {
+    const response = await geminiClientService.generateWithImages(
+      model,
+      prompt,
+      images,
+    );
+
+    const text = response.candidates?.[0]?.content.parts
+      .filter((p): p is { text: string } => "text" in p)
+      .map((p) => p.text)
+      .join("") || "";
+
+    return { text, response };
+  }
+
   reset(): void {
     geminiClientService.reset();
     this.pendingJobs.clear();
@@ -182,6 +225,15 @@ 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 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(
@@ -199,16 +251,24 @@ class GeminiProviderService {
     if (typeof input.prompt === "string") {
       const parts: GeminiContent["parts"] = [{ text: input.prompt }];
 
+      // Handle single image
       if (input.image_url && typeof input.image_url === "string") {
-        const base64Match = input.image_url.match(
-          /^data:([^;]+);base64,(.+)$/,
-        );
+        const imageData = this.parseImageUrl(input.image_url);
+        if (imageData) {
+          parts.push({ inlineData: imageData });
+        }
+      }
 
-        if (base64Match) {
+      // 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: base64Match[1],
-              data: base64Match[2],
+              mimeType: img.mimeType,
+              data: base64Data,
             },
           });
         }
@@ -224,27 +284,69 @@ class GeminiProviderService {
     return contents;
   }
 
+  private parseImageUrl(
+    imageUrl: string,
+  ): { mimeType: string; data: string } | null {
+    const base64Match = imageUrl.match(/^data:([^;]+);base64,(.+)$/);
+    if (base64Match) {
+      return {
+        mimeType: base64Match[1],
+        data: base64Match[2],
+      };
+    }
+    return null;
+  }
+
   private formatResponse<T>(
     response: unknown,
     input: Record<string, unknown>,
   ): T {
     const resp = response as {
       candidates?: Array<{
-        content: { parts: Array<{ text?: string }> };
+        content: {
+          parts: Array<{
+            text?: string;
+            inlineData?: { mimeType: string; data: string };
+          }>;
+        };
       }>;
     };
 
-    const text = resp.candidates?.[0]?.content.parts.find((p) => p.text)?.text;
+    const candidate = resp.candidates?.[0];
+    const parts = candidate?.content.parts || [];
+
+    // Extract text
+    const text = parts.find((p) => p.text)?.text;
+
+    // Extract image if present
+    const imagePart = parts.find((p) => p.inlineData);
+    const imageData = imagePart?.inlineData;
 
     if (input.outputFormat === "text") {
       return text as T;
     }
 
-    return {
+    // Return full result with image data if available
+    const result: Record<string, unknown> = {
       text,
       response,
-    } as T;
+    };
+
+    if (imageData) {
+      result.imageUrl = `data:${imageData.mimeType};base64,${imageData.data}`;
+      result.imageBase64 = imageData.data;
+      result.mimeType = imageData.mimeType;
+    }
+
+    return result as T;
   }
 }
 
 export const geminiProviderService = new GeminiProviderService();
+
+/**
+ * Factory function to create a new Gemini provider instance
+ */
+export function createGeminiProvider(): GeminiProviderService {
+  return new GeminiProviderService();
+}

package/src/infrastructure/services/index.ts

@@ -3,7 +3,10 @@
  */
 
 export { geminiClientService } from "./gemini-client.service";
-export { geminiProviderService } from "./gemini-provider.service";
+export {
+  geminiProviderService,
+  createGeminiProvider,
+} from "./gemini-provider.service";
 export type {
   AIProviderConfig,
   JobSubmission,

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

@@ -78,16 +78,22 @@ export function useGemini(options: UseGeminiOptions = {}): UseGeminiReturn {
 
       try {
         const model = options.model ?? "gemini-1.5-flash";
-        const text = await geminiClientService.generateWithImage(
+        const response = await geminiClientService.generateWithImages(
           model,
           prompt,
-          imageBase64,
-          mimeType,
+          [{ base64: imageBase64, mimeType }],
           options.generationConfig,
         );
 
         if (abortRef.current) return;
 
+        // Extract text from response
+        const text =
+          response.candidates?.[0]?.content.parts
+            .filter((p): p is { text: string } => "text" in p)
+            .map((p) => p.text)
+            .join("") || "";
+
         setResult(text);
         options.onSuccess?.(text);
       } catch (err) {