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

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

@@ -1,548 +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.TEXT_TO_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.TEXT_TO_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;
-  }
-
-  /**
-   * 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> {
-    this.validateInitialization();
-
-    const editModel = DEFAULT_MODELS.IMAGE_EDIT;
-    const apiKey = this.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 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(`Image edit API error (${res.status}): ${errorText}`);
-      }
-
-      return res.json();
-    });
-
-    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;
-  }
-
-  /**
-   * 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();