@umituz/react-native-ai-gemini-provider 2.0.13 → 2.0.14

package/package.json

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

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

@@ -1,8 +1,3 @@
-/**
- * Gemini Error Types
- * Error classification for Gemini API
- */
-
 export enum GeminiErrorType {
   NETWORK = "NETWORK",
   RATE_LIMIT = "RATE_LIMIT",
@@ -38,9 +33,6 @@ export interface GeminiApiError {
   };
 }
 
-/**
- * Custom error class for Gemini API errors
- */
 export class GeminiError extends Error {
   readonly type: GeminiErrorType;
   readonly retryable: boolean;
@@ -61,23 +53,14 @@ export class GeminiError extends Error {
     }
   }
 
-  /**
-   * Check if error is retryable
-   */
   isRetryable(): boolean {
     return this.retryable;
   }
 
-  /**
-   * Get error type
-   */
   getErrorType(): GeminiErrorType {
     return this.type;
   }
 
-  /**
-   * Create GeminiError from unknown error
-   */
   static fromError(_error: unknown, info: GeminiErrorInfo): GeminiError {
     return new GeminiError(info);
   }

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

@@ -1,28 +1,16 @@
-/**
- * Gemini Provider Types
- * Configuration and response types for Google Gemini AI
- */
-
 import type { GenerationConfig } from "@google/generative-ai";
 
 export interface GeminiConfig {
   apiKey: string;
   baseUrl?: string;
   defaultTimeoutMs?: number;
-  /** Model used for text generation (default: gemini-2.5-flash-lite) */
   textModel?: string;
 }
 
 export type GeminiGenerationConfig = Omit<GenerationConfig, "responseSchema"> & {
-  /** Response schema for structured JSON output - compatible with Google SDK */
   responseSchema?: GenerationConfig["responseSchema"];
 };
 
-export interface GeminiSafetySettings {
-  category: GeminiHarmCategory;
-  threshold: GeminiHarmBlockThreshold;
-}
-
 export type GeminiHarmCategory =
   | "HARM_CATEGORY_HARASSMENT"
   | "HARM_CATEGORY_HATE_SPEECH"
@@ -40,18 +28,10 @@ export interface GeminiContent {
   role?: "user" | "model";
 }
 
-export type GeminiPart =
-  | { text: string };
-
-export interface GeminiRequest {
-  contents: GeminiContent[];
-  generationConfig?: GeminiGenerationConfig;
-  safetySettings?: GeminiSafetySettings[];
-}
+export type GeminiPart = { text: string };
 
 export interface GeminiResponse {
   candidates?: GeminiCandidate[];
-  promptFeedback?: GeminiPromptFeedback;
   usageMetadata?: GeminiUsageMetadata;
 }
 
@@ -59,7 +39,6 @@ export interface GeminiCandidate {
   content: GeminiContent;
   finishReason?: GeminiFinishReason;
   safetyRatings?: GeminiSafetyRating[];
-  index?: number;
 }
 
 export type GeminiFinishReason =
@@ -76,24 +55,9 @@ export interface GeminiSafetyRating {
   blocked?: boolean;
 }
 
-export interface GeminiPromptFeedback {
-  blockReason?: "BLOCK_REASON_UNSPECIFIED" | "SAFETY" | "OTHER";
-  safetyRatings?: GeminiSafetyRating[];
-}
-
 export interface GeminiUsageMetadata {
   promptTokenCount?: number;
   candidatesTokenCount?: number;
   totalTokenCount?: number;
 }
 
-export interface GeminiModel {
-  id: string;
-  name: string;
-  displayName: string;
-  description?: string;
-  inputTokenLimit?: number;
-  outputTokenLimit?: number;
-  supportedCapabilities?: string[];
-}
-

package/src/domain/entities/models.ts

@@ -1,44 +1,13 @@
-/**
- * Gemini Model Constants
- * Centralized model configuration for all AI operations
- * Updated: 2026-01 with latest pricing and free tier info
- */
-
-/**
- * Available Gemini models
- * Pricing (per 1M tokens):
- * - Flash-Lite: $0.10 input / $0.40 output (FREE: 1000 req/day)
- */
 export const GEMINI_MODELS = {
-  // Text generation models (ordered by cost: cheapest first)
   TEXT: {
-    /** Most cost-effective, 1000 free requests/day */
     FLASH_LITE: "gemini-2.5-flash-lite",
   },
 } as const;
 
-/**
- * Default models for each operation type
- * Optimized for cost-effectiveness while maintaining quality
- * Using Flash-Lite as default for best free tier (1000 req/day)
- */
 export const DEFAULT_MODELS = {
-  /** Flash-Lite: Cheapest & highest free tier (1000/day) */
   TEXT: GEMINI_MODELS.TEXT.FLASH_LITE,
 } as const;
 
-/**
- * Model pricing information (per 1M tokens)
- */
 export const MODEL_PRICING = {
   [GEMINI_MODELS.TEXT.FLASH_LITE]: { input: 0.10, output: 0.40, freePerDay: 1000 },
 } as const;
-
-/**
- * Response modalities for different generation types
- */
-export const RESPONSE_MODALITIES = {
-  TEXT_ONLY: ["TEXT"] as const,
-} as const;
-
-export type ResponseModality = "TEXT";

package/src/index.ts

@@ -8,31 +8,25 @@
 export type {
   GeminiConfig,
   GeminiGenerationConfig,
-  GeminiSafetySettings,
   GeminiHarmCategory,
   GeminiHarmBlockThreshold,
   GeminiContent,
   GeminiPart,
-  GeminiRequest,
   GeminiResponse,
   GeminiCandidate,
   GeminiFinishReason,
   GeminiSafetyRating,
-  GeminiPromptFeedback,
   GeminiUsageMetadata,
-  GeminiModel,
   GeminiErrorInfo,
   GeminiApiError,
-  ResponseModality,
 } from "./domain/entities";
 
-export { GeminiErrorType, GeminiError, GEMINI_MODELS, DEFAULT_MODELS, MODEL_PRICING, RESPONSE_MODALITIES } from "./domain/entities";
+export { GeminiErrorType, GeminiError, GEMINI_MODELS, DEFAULT_MODELS, MODEL_PRICING } from "./domain/entities";
 
 // Services
 export {
   geminiClientCoreService,
   geminiTextGenerationService,
-  geminiTextService,
   geminiStructuredTextService,
   geminiStreamingService,
   geminiProviderService,
@@ -40,12 +34,7 @@ export {
   GeminiProvider,
 } from "./infrastructure/services";
 
-export type {
-  GeminiProviderConfig,
-  GenerationInput,
-  GenerationResult,
-  ExecutionOptions,
-} from "./infrastructure/services";
+export type { GeminiProviderConfig } from "./infrastructure/services";
 
 // Utils
 export {
@@ -58,10 +47,7 @@ export {
   debounce,
   throttle,
   PerformanceTimer,
-  PerformanceTracker,
-  performanceTracker,
   RateLimiter,
-  rateLimiter,
 } from "./infrastructure/utils";
 
 export type {
@@ -80,23 +66,22 @@ export type { TelemetryEvent, TelemetryListener } from "./infrastructure/telemet
 
 // Interceptors
 export { requestInterceptors, responseInterceptors } from "./infrastructure/interceptors";
+
 export type {
   RequestContext,
   RequestInterceptor,
+  InterceptorErrorStrategy,
+} from "./infrastructure/interceptors/RequestInterceptors";
+
+export type {
   ResponseContext,
   ResponseInterceptor,
-} from "./infrastructure/interceptors";
-
-// Cache
-export { SimpleCache, modelSelectionCache } from "./infrastructure/cache";
-export type { CacheOptions } from "./infrastructure/cache";
+} from "./infrastructure/interceptors/ResponseInterceptors";
 
 // Provider Config
 export {
   providerFactory,
   resolveProviderConfig,
-  getCostOptimizedConfig,
-  getQualityOptimizedConfig,
 } from "./providers";
 
 export type {
@@ -104,6 +89,5 @@ export type {
   ProviderPreferences,
   ProviderConfigInput,
   ResolvedProviderConfig,
-  OptimizationStrategy,
   ProviderFactoryOptions,
 } from "./providers";

package/src/infrastructure/interceptors/RequestInterceptors.ts

@@ -1,7 +1,3 @@
-/**
- * Request Interceptors
- * Allows applications to modify requests before they're sent
- */
 
 export interface RequestContext {
   model: string;
@@ -12,8 +8,11 @@ export interface RequestContext {
 
 export type RequestInterceptor = (context: RequestContext) => RequestContext | Promise<RequestContext>;
 
+export type InterceptorErrorStrategy = "fail" | "skip" | "log";
+
 class RequestInterceptors {
   private interceptors: RequestInterceptor[] = [];
+  private errorStrategy: InterceptorErrorStrategy = "fail";
 
   /**
    * Register a request interceptor
@@ -31,6 +30,13 @@ class RequestInterceptors {
     };
   }
 
+  /**
+   * Set error handling strategy for interceptors
+   */
+  setErrorStrategy(strategy: InterceptorErrorStrategy): void {
+    this.errorStrategy = strategy;
+  }
+
   /**
    * Apply all interceptors to a request context
    */
@@ -41,8 +47,16 @@ class RequestInterceptors {
       try {
         result = await interceptor(result);
       } catch (error) {
-        // Interceptor error should fail the request
-        throw new Error(`Request interceptor failed: ${error instanceof Error ? error.message : String(error)}`);
+        switch (this.errorStrategy) {
+          case "fail":
+            throw new Error(`Request interceptor failed: ${error instanceof Error ? error.message : String(error)}`);
+          case "skip":
+            // Skip this interceptor and continue with previous result
+            break;
+          case "log":
+            // Silently ignore but continue
+            break;
+        }
       }
     }
 

package/src/infrastructure/interceptors/ResponseInterceptors.ts

@@ -1,7 +1,3 @@
-/**
- * Response Interceptors
- * Allows applications to modify responses after they're received
- */
 
 export interface ResponseContext<T = unknown> {
   model: string;
@@ -15,8 +11,11 @@ export type ResponseInterceptor<T = unknown> = (
   context: ResponseContext<T>,
 ) => ResponseContext<T> | Promise<ResponseContext<T>>;
 
+export type InterceptorErrorStrategy = "fail" | "skip" | "log";
+
 class ResponseInterceptors {
   private interceptors: Array<ResponseInterceptor<unknown>> = [];
+  private errorStrategy: InterceptorErrorStrategy = "fail";
 
   /**
    * Register a response interceptor
@@ -34,6 +33,13 @@ class ResponseInterceptors {
     };
   }
 
+  /**
+   * Set error handling strategy for interceptors
+   */
+  setErrorStrategy(strategy: InterceptorErrorStrategy): void {
+    this.errorStrategy = strategy;
+  }
+
   /**
    * Apply all interceptors to a response context
    */
@@ -46,8 +52,16 @@ class ResponseInterceptors {
       try {
         result = await interceptor(result);
       } catch (error) {
-        // Interceptor error should fail the response processing
-        throw new Error(`Response interceptor failed: ${error instanceof Error ? error.message : String(error)}`);
+        switch (this.errorStrategy) {
+          case "fail":
+            throw new Error(`Response interceptor failed: ${error instanceof Error ? error.message : String(error)}`);
+          case "skip":
+            // Skip this interceptor and continue with previous result
+            break;
+          case "log":
+            // Silently ignore but continue
+            break;
+        }
       }
     }
 

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

@@ -1,14 +1,7 @@
-/**
- * Gemini Client Core Service
- * Handles client initialization, configuration, and validation
- */
-
 import { GoogleGenerativeAI, type GenerativeModel } from "@google/generative-ai";
-import { DEFAULT_MODELS } from "../../domain/entities";
+import { DEFAULT_MODELS, GEMINI_MODELS } from "../../domain/entities";
 import type { GeminiConfig } from "../../domain/entities";
 
-declare const __DEV__: boolean;
-
 const DEFAULT_CONFIG: Partial<GeminiConfig> = {
   textModel: DEFAULT_MODELS.TEXT,
 };
@@ -20,31 +13,12 @@ class GeminiClientCoreService {
 
   initialize(config: GeminiConfig): void {
     if (this.initialized) {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        // eslint-disable-next-line no-console
-        console.log("[GeminiClient] Already initialized, skipping");
-      }
-      return;
-    }
-
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[GeminiClient] initialize() called", {
-        hasApiKey: !!config.apiKey,
-        textModel: config.textModel,
-      });
+      throw new Error("Gemini client already initialized. Call reset() before re-initializing with new config.");
     }
 
     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", {
-        textModel: this.config.textModel,
-      });
-    }
   }
 
   isInitialized(): boolean {
@@ -61,16 +35,35 @@ class GeminiClientCoreService {
 
   validateInitialization(): void {
     if (!this.client || !this.initialized) {
-      throw new Error(
-        "Gemini client not initialized. Call initialize() first.",
-      );
+      throw new Error("Gemini client not initialized. Call initialize() first.");
+    }
+  }
+
+  /**
+   * Validate model name against known models
+   */
+  private validateModel(modelName: string): void {
+    const knownModels = Object.values(GEMINI_MODELS.TEXT);
+    const isValid = knownModels.some((model) => model === modelName);
+
+    if (!isValid) {
+      throw new Error(`Unknown model: "${modelName}". Known models: ${knownModels.join(", ")}`);
     }
   }
 
   getModel(modelName?: string): GenerativeModel {
     this.validateInitialization();
+
+    if (!this.client) {
+      throw new Error("Gemini client not available");
+    }
+
     const effectiveModel = modelName || this.config?.textModel || DEFAULT_MODELS.TEXT;
-    return this.client!.getGenerativeModel({ model: effectiveModel });
+
+    // Validate model name
+    this.validateModel(effectiveModel);
+
+    return this.client.getGenerativeModel({ model: effectiveModel });
   }
 
   reset(): void {

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

@@ -1,39 +1,37 @@
-/**
- * Gemini Provider
- * Text-only AI provider for Google Gemini
- */
 
 import type { GeminiConfig } from "../../domain/entities";
-import { providerInitializer } from "./provider-initializer";
-import { generationExecutor } from "./generation-executor";
+import { geminiClientCoreService } from "./gemini-client-core.service";
+import { geminiTextGenerationService } from "./gemini-text-generation.service";
+import { geminiStructuredTextService } from "./gemini-structured-text.service";
 
 export type GeminiProviderConfig = GeminiConfig;
 
-/**
- * Gemini Provider - Text Generation Only
- * For image/video generation, use FAL Provider instead
- */
 export class GeminiProvider {
   readonly providerId = "gemini";
   readonly providerName = "Google Gemini";
 
   initialize(config: GeminiProviderConfig): void {
-    providerInitializer.initialize(config);
+    if (geminiClientCoreService.isInitialized()) {
+      throw new Error("Provider already initialized. Call reset() before re-initializing with new config.");
+    }
+    geminiClientCoreService.initialize(config);
   }
 
   isInitialized(): boolean {
-    return providerInitializer.isInitialized();
+    return geminiClientCoreService.isInitialized();
   }
 
   reset(): void {
-    providerInitializer.reset();
+    geminiClientCoreService.reset();
   }
 
   /**
    * Generate text from prompt
    */
   async generateText(prompt: string, model: string): Promise<string> {
-    return generationExecutor.executeTextGeneration(prompt, model);
+    const contents = [{ parts: [{ text: prompt }], role: "user" as const }];
+    const response = await geminiTextGenerationService.generateContent(model, contents);
+    return this.extractTextFromResponse(response);
   }
 
   /**
@@ -44,7 +42,25 @@ export class GeminiProvider {
     schema: Record<string, unknown>,
     model: string,
   ): Promise<T> {
-    return generationExecutor.executeStructuredGeneration<T>(prompt, schema, model);
+    return geminiStructuredTextService.generateStructuredText<T>(model, prompt, schema);
+  }
+
+  /**
+   * Extract text from Gemini response
+   */
+  private extractTextFromResponse(response: unknown): string {
+    const resp = response as {
+      candidates?: Array<{
+        content: {
+          parts: Array<{ text?: string }>;
+        };
+      }>;
+    };
+
+    return resp.candidates?.[0]?.content.parts
+      .filter((p): p is { text: string } => "text" in p && typeof p.text === "string")
+      .map((p) => p.text)
+      .join("") || "";
   }
 }
 

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

@@ -1,7 +1,3 @@
-/**
- * Gemini Streaming Service
- * Handles streaming content generation
- */
 
 import { geminiClientCoreService } from "./gemini-client-core.service";
 import type {

package/src/infrastructure/services/gemini-structured-text.service.ts

@@ -1,9 +1,6 @@
-/**
- * Gemini Structured Text Service
- * Handles structured JSON response generation with schema validation
- */
 
 import { geminiTextGenerationService } from "./gemini-text-generation.service";
+import type { GenerationConfig } from "@google/generative-ai";
 import type {
   GeminiContent,
   GeminiGenerationConfig,
@@ -20,10 +17,16 @@ class GeminiStructuredTextService {
     schema: Record<string, unknown>,
     config?: Omit<GeminiGenerationConfig, "responseMimeType" | "responseSchema">,
   ): Promise<T> {
+    // Validate schema structure before passing to SDK
+    if (!schema || typeof schema !== "object" || Object.keys(schema).length === 0) {
+      throw new Error("Schema must be a non-empty object");
+    }
+
     const generationConfig: GeminiGenerationConfig = {
       ...config,
       responseMimeType: "application/json",
-      responseSchema: schema as unknown as undefined,
+      // Pass schema directly - Google SDK will validate it
+      responseSchema: schema as GenerationConfig["responseSchema"],
     };
 
     const contents: GeminiContent[] = [

package/src/infrastructure/services/gemini-text-generation.service.ts

@@ -1,7 +1,3 @@
-/**
- * Gemini Text Generation Service
- * Handles text and multimodal content generation
- */
 
 import { geminiClientCoreService } from "./gemini-client-core.service";
 import { extractTextFromResponse } from "../utils/gemini-data-transformer.util";
@@ -12,8 +8,6 @@ import type {
   GeminiPart,
 } from "../../domain/entities";
 
-declare const __DEV__: boolean;
-
 class GeminiTextGenerationService {
   /**
    * Generate content (text, with optional images)
@@ -25,60 +19,37 @@ class GeminiTextGenerationService {
   ): 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) => {
-        return part;
-      }),
+      parts: content.parts,
     }));
 
-    try {
-      const result = await genModel.generateContent({
-          contents: sdkContents as Parameters<typeof genModel.generateContent>[0] extends { contents: infer C } ? C : never,
-          generationConfig,
-        });
+    const result = await genModel.generateContent({
+      contents: sdkContents as Parameters<typeof genModel.generateContent>[0] extends { contents: infer C } ? C : never,
+      generationConfig,
+    });
 
-      const response = (result as { response: GeminiResponse }).response;
+    const response = (result as { response: GeminiResponse }).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) => {
+        const transformedParts: GeminiPart[] = [];
+        for (const part of candidate.content.parts) {
+          if ("text" in part && typeof part.text === "string") {
+            transformedParts.push({ text: part.text });
+          }
+          // Ignore unsupported part types (inlineData, etc.)
+        }
 
-      return {
-        candidates: response.candidates?.map((candidate) => ({
+        return {
           content: {
-            parts: candidate.content.parts
-              .map((part): GeminiPart | null => {
-                if ("text" in part && part.text !== undefined) {
-                  return { text: part.text };
-                }
-                return null;
-              })
-              .filter((p): p is GeminiPart => p !== null),
+            parts: transformedParts,
             role: (candidate.content.role || "model"),
           },
           finishReason: candidate.finishReason,
-        })),
-      };
-    } 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;
-    }
+        };
+      }),
+    };
   }
 
   /**
@@ -103,5 +74,3 @@ class GeminiTextGenerationService {
 }
 
 export const geminiTextGenerationService = new GeminiTextGenerationService();
-
-export const geminiTextService = geminiTextGenerationService;