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

package/src/infrastructure/services/index.ts

@@ -3,31 +3,17 @@
  * Text-only Gemini services
  */
 
-// Core services (low-level SDK wrappers)
+// Core services
 export { geminiClientCoreService } from "./gemini-client-core.service";
 export { geminiTextGenerationService } from "./gemini-text-generation.service";
-export { geminiTextService } from "./gemini-text-generation.service";
 export { geminiStructuredTextService } from "./gemini-structured-text.service";
 export { geminiStreamingService } from "./gemini-streaming.service";
 
-// Modular services
-export { providerInitializer } from "./provider-initializer";
-export { jobProcessor } from "./job-processor";
-export { generationExecutor } from "./generation-executor";
-
-// Public provider API
+// Provider
 export {
   geminiProviderService,
   createGeminiProvider,
   GeminiProvider,
 } from "./gemini-provider";
-
 export type { GeminiProviderConfig } from "./gemini-provider";
 
-// Generation executor types
-export type {
-  GenerationInput,
-  GenerationResult,
-  ExecutionOptions,
-} from "./generation-executor";
-

package/src/infrastructure/telemetry/TelemetryHooks.ts

@@ -1,9 +1,3 @@
-/**
- * Telemetry Hooks
- * Allows applications to monitor and log AI operations
- */
-
-declare const __DEV__: boolean;
 
 export interface TelemetryEvent {
   type: "request" | "response" | "error" | "retry";
@@ -18,18 +12,25 @@ export type TelemetryListener = (event: TelemetryEvent) => void;
 
 class TelemetryHooks {
   private listeners: TelemetryListener[] = [];
+  private failedListeners: Set<TelemetryListener> = new Set();
+  private readonly MAX_FAILURES = 3;
+  private listenerFailureCounts = new Map<TelemetryListener, number>();
 
   /**
    * Register a telemetry listener
    */
   subscribe(listener: TelemetryListener): () => void {
     this.listeners.push(listener);
+    this.failedListeners.delete(listener);
+    this.listenerFailureCounts.set(listener, 0);
 
     return () => {
       const index = this.listeners.indexOf(listener);
       if (index > -1) {
         this.listeners.splice(index, 1);
       }
+      this.failedListeners.delete(listener);
+      this.listenerFailureCounts.delete(listener);
     };
   }
 
@@ -38,13 +39,23 @@ class TelemetryHooks {
    */
   emit(event: TelemetryEvent): void {
     for (const listener of this.listeners) {
+      // Skip listeners that have failed too many times
+      if (this.failedListeners.has(listener)) {
+        continue;
+      }
+
       try {
         listener(event);
+        // Reset failure count on success
+        this.listenerFailureCounts.set(listener, 0);
       } catch (error) {
-        // Prevent telemetry errors from breaking the app
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          // eslint-disable-next-line no-console
-          console.error("[Telemetry] Listener error:", error);
+        // Track failures
+        const failureCount = (this.listenerFailureCounts.get(listener) || 0) + 1;
+        this.listenerFailureCounts.set(listener, failureCount);
+
+        // If listener fails too many times, blacklist it
+        if (failureCount >= this.MAX_FAILURES) {
+          this.failedListeners.add(listener);
         }
       }
     }
@@ -112,6 +123,8 @@ class TelemetryHooks {
    */
   clear(): void {
     this.listeners = [];
+    this.failedListeners.clear();
+    this.listenerFailureCounts.clear();
   }
 
   /**

package/src/infrastructure/utils/async-state.util.ts

@@ -1,7 +1,3 @@
-/**
- * Async State Utility
- * Common async execution pattern with state management
- */
 
 export interface AsyncStateCallbacks {
   onSuccess?: (result: string) => void;
@@ -15,9 +11,6 @@ export interface AsyncStateSetters {
   setJsonResult: (value: unknown) => void;
 }
 
-/**
- * Execute an async operation with common state management
- */
 export async function executeWithState<T>(
   abortRef: React.MutableRefObject<boolean>,
   setters: AsyncStateSetters,

package/src/infrastructure/utils/error-mapper.util.ts

@@ -1,7 +1,3 @@
-/**
- * Gemini Error Mapper
- * Maps Gemini API errors to standardized format
- */
 
 import {
   GeminiErrorType,
@@ -76,7 +72,19 @@ function getStatusCode(error: unknown): number | undefined {
 
 function matchesPattern(message: string, patterns: string[]): boolean {
   const lower = message.toLowerCase();
-  return patterns.some((p) => lower.includes(p.toLowerCase()));
+
+  return patterns.some((pattern) => {
+    const lowerPattern = pattern.toLowerCase();
+
+    // Use word boundary matching for better accuracy
+    // This prevents "invalid" from matching "valid"
+    const words = lowerPattern.split(/\s+/);
+    return words.every((word) => {
+      // Check if the word appears as a whole word or with common punctuation
+      const regex = new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'i');
+      return regex.test(lower) || lower.includes(word);
+    });
+  });
 }
 
 export function mapGeminiError(error: unknown): GeminiErrorInfo {
@@ -114,9 +122,6 @@ export function categorizeGeminiError(error: unknown): GeminiErrorType {
   return mapGeminiError(error).type;
 }
 
-/**
- * Create a GeminiError instance from an unknown error
- */
 export function createGeminiError(error: unknown): GeminiError {
   const errorInfo = mapGeminiError(error);
   return GeminiError.fromError(error, errorInfo);

package/src/infrastructure/utils/gemini-data-transformer.util.ts

@@ -1,14 +1,7 @@
-/**
- * Gemini Data Transformer Utility
- * Handles data extraction and response parsing
- */
 
 import type { GeminiResponse } from "../../domain/entities";
 
 
-/**
- * Extract text from Gemini response
- */
 export function extractTextFromResponse(response: GeminiResponse): string {
   const candidate = response.candidates?.[0];
 
@@ -16,8 +9,18 @@ export function extractTextFromResponse(response: GeminiResponse): string {
     throw new Error("No response candidates");
   }
 
-  if (candidate.finishReason === "SAFETY") {
-    throw new Error("Content blocked by safety filters");
+  // Handle all finish reasons appropriately
+  switch (candidate.finishReason) {
+    case "SAFETY":
+      throw new Error("Content blocked by safety filters");
+    case "RECITATION":
+      throw new Error("Content blocked due to recitation concerns");
+    case "MAX_TOKENS":
+    case "FINISH_REASON_UNSPECIFIED":
+    case "OTHER":
+    case "STOP":
+      // Continue to extract text
+      break;
   }
 
   const textPart = candidate.content.parts.find(

package/src/infrastructure/utils/performance.util.ts

@@ -1,9 +1,3 @@
-/**
- * Performance Utilities
- * Tools for measuring and optimizing performance
- */
-
-declare const __DEV__: boolean;
 
 export interface PerformanceMetrics {
   duration: number;
@@ -47,12 +41,8 @@ export async function measureAsync<T>(
   const timer = new PerformanceTimer(metadata);
   try {
     const result = await operation();
-    const duration = timer.stop();
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[Performance] Operation completed:", { duration: `${duration}ms`, metadata });
-    }
-    return { result, duration };
+    timer.stop();
+    return { result, duration: timer.duration };
   } catch (error) {
     timer.stop();
     throw error;
@@ -66,12 +56,8 @@ export function measureSync<T>(
   const timer = new PerformanceTimer(metadata);
   try {
     const result = operation();
-    const duration = timer.stop();
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[Performance] Operation completed:", { duration: `${duration}ms`, metadata });
-    }
-    return { result, duration };
+    timer.stop();
+    return { result, duration: timer.duration };
   } catch (error) {
     timer.stop();
     throw error;
@@ -107,39 +93,3 @@ export function throttle<T extends (...args: never[]) => unknown>(
   };
 }
 
-export class PerformanceTracker {
-  private metrics = new Map<string, number[]>();
-
-  record(operation: string, duration: number): void {
-    if (!this.metrics.has(operation)) {
-      this.metrics.set(operation, []);
-    }
-    this.metrics.get(operation)!.push(duration);
-  }
-
-  getStats(operation: string): { count: number; avg: number; min: number; max: number } | null {
-    const durations = this.metrics.get(operation);
-    if (!durations || durations.length === 0) return null;
-    return {
-      count: durations.length,
-      avg: durations.reduce((a, b) => a + b, 0) / durations.length,
-      min: Math.min(...durations),
-      max: Math.max(...durations),
-    };
-  }
-
-  getAllStats(): Record<string, ReturnType<PerformanceTracker["getStats"]>> {
-    const stats: Record<string, ReturnType<PerformanceTracker["getStats"]>> = {};
-    for (const operation of this.metrics.keys()) {
-      stats[operation] = this.getStats(operation);
-    }
-    return stats;
-  }
-
-  clear(): void {
-    this.metrics.clear();
-  }
-}
-
-export const performanceTracker = new PerformanceTracker();
-

package/src/infrastructure/utils/rate-limiter.util.ts

@@ -1,7 +1,3 @@
-/**
- * Rate Limiter
- * Prevents API rate limit errors by controlling request frequency
- */
 
 export interface RateLimiterOptions {
   minInterval?: number; // Minimum milliseconds between requests
@@ -14,6 +10,7 @@ export class RateLimiter {
   private lastRequest = 0;
   private minInterval: number;
   private maxQueueSize: number;
+  private processQueuePromise: Promise<void> | null = null;
 
   constructor(options: RateLimiterOptions = {}) {
     this.minInterval = options.minInterval ?? 100; // 100ms minimum interval
@@ -22,7 +19,7 @@ export class RateLimiter {
 
   async execute<T>(fn: () => Promise<T>): Promise<T> {
     if (this.queue.length >= this.maxQueueSize) {
-      throw new Error("Rate limiter queue is full");
+      throw new Error(`Rate limiter queue is full (${this.maxQueueSize} requests pending). Please wait before retrying.`);
     }
 
     return new Promise((resolve, reject) => {
@@ -34,7 +31,16 @@ export class RateLimiter {
           reject(error);
         }
       });
-      void this.processQueue();
+
+      // Ensure queue processing is running (wait for it to avoid race condition)
+      if (!this.processQueuePromise) {
+        this.processQueuePromise = this.processQueue();
+        this.processQueuePromise.then(() => {
+          this.processQueuePromise = null;
+        }).catch(() => {
+          this.processQueuePromise = null;
+        });
+      }
     });
   }
 
@@ -72,5 +78,3 @@ export class RateLimiter {
     this.lastRequest = 0;
   }
 }
-
-export const rateLimiter = new RateLimiter();

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

@@ -1,8 +1,3 @@
-/**
- * useGemini Hook
- * React hook for Gemini AI generation
- * Supports text, structured JSON, and multimodal generation
- */
 
 import { useState, useCallback, useRef, useMemo, useEffect } from "react";
 import type { GeminiGenerationConfig } from "../../domain/entities";
@@ -37,39 +32,105 @@ export function useGemini(options: UseGeminiOptions = {}): UseGeminiReturn {
   const [jsonResult, setJsonResult] = useState<unknown>(null);
   const [isGenerating, setIsGenerating] = useState(false);
   const [error, setError] = useState<string | null>(null);
-  const abortRef = useRef(false);
+  // Use a ref to store the abort controller for the current operation
+  const abortControllerRef = useRef<AbortController | null>(null);
+  const operationIdRef = useRef(0);
 
   const setters = useMemo(() => ({ setIsGenerating, setError, setResult, setJsonResult }), []);
   const callbacks = useMemo(() => ({ onSuccess: options.onSuccess, onError: options.onError }), [options.onSuccess, options.onError]);
   const model = options.model ?? DEFAULT_MODELS.TEXT;
 
   const generate = useCallback(async (prompt: string) => {
-    await executeWithState(abortRef, setters, callbacks,
-      () => geminiTextGenerationService.generateText(model, prompt, options.generationConfig),
-      (text) => { setResult(text); options.onSuccess?.(text); }
-    );
+    // Create new abort controller for this operation
+    const controller = new AbortController();
+    abortControllerRef.current = controller;
+    const currentOpId = ++operationIdRef.current;
+
+    try {
+      await executeWithState(
+        { current: false }, // We'll use operation ID instead
+        setters,
+        callbacks,
+        async () => {
+          // Check if this operation is still the latest one
+          if (currentOpId !== operationIdRef.current) {
+            throw new Error("Operation cancelled by newer request");
+          }
+          return geminiTextGenerationService.generateText(model, prompt, options.generationConfig);
+        },
+        (text) => {
+          // Only update if this is still the latest operation
+          if (currentOpId === operationIdRef.current) {
+            setResult(text);
+            options.onSuccess?.(text);
+          }
+        }
+      );
+    } finally {
+      // Clean up abort controller if this was the latest operation
+      if (currentOpId === operationIdRef.current) {
+        abortControllerRef.current = null;
+      }
+    }
   }, [model, options.generationConfig, setters, callbacks, options.onSuccess]);
 
   const generateJSON = useCallback(async <T>(prompt: string, schema?: Record<string, unknown>): Promise<T | null> => {
-    return executeWithState(abortRef, setters, callbacks,
-      async () => {
-        if (schema) {
-          return geminiStructuredTextService.generateStructuredText<T>(model, prompt, schema, options.generationConfig);
+    // Create new abort controller for this operation
+    const controller = new AbortController();
+    abortControllerRef.current = controller;
+    const currentOpId = ++operationIdRef.current;
+
+    try {
+      return await executeWithState(
+        { current: false }, // We'll use operation ID instead
+        setters,
+        callbacks,
+        async () => {
+          // Check if this operation is still the latest one
+          if (currentOpId !== operationIdRef.current) {
+            throw new Error("Operation cancelled by newer request");
+          }
+
+          if (schema) {
+            return geminiStructuredTextService.generateStructuredText<T>(model, prompt, schema, options.generationConfig);
+          }
+
+          const text = await geminiTextGenerationService.generateText(model, prompt, { ...options.generationConfig, responseMimeType: "application/json" });
+          const cleanedText = cleanJsonResponse(text);
+
+          try {
+            return JSON.parse(cleanedText) as T;
+          } catch (parseError) {
+            throw new Error(`Failed to parse JSON response: ${parseError instanceof Error ? parseError.message : String(parseError)}. Response: ${cleanedText.substring(0, 200)}...`);
+          }
+        },
+        (parsed) => {
+          // Only update if this is still the latest operation
+          if (currentOpId === operationIdRef.current) {
+            setJsonResult(parsed);
+            setResult(JSON.stringify(parsed, null, 2));
+            options.onSuccess?.(JSON.stringify(parsed));
+          }
         }
-        const text = await geminiTextGenerationService.generateText(model, prompt, { ...options.generationConfig, responseMimeType: "application/json" });
-        return JSON.parse(cleanJsonResponse(text)) as T;
-      },
-      (parsed) => {
-        setJsonResult(parsed);
-        setResult(JSON.stringify(parsed, null, 2));
-        options.onSuccess?.(JSON.stringify(parsed));
+      );
+    } finally {
+      // Clean up abort controller if this was the latest operation
+      if (currentOpId === operationIdRef.current) {
+        abortControllerRef.current = null;
       }
-    );
+    }
   }, [model, options.generationConfig, setters, callbacks, options.onSuccess]);
 
 
   const reset = useCallback(() => {
-    abortRef.current = true;
+    // Abort any ongoing operation
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+      abortControllerRef.current = null;
+    }
+    // Increment operation ID to cancel any pending operations
+    operationIdRef.current++;
+
     setResult(null);
     setJsonResult(null);
     setIsGenerating(false);
@@ -77,7 +138,13 @@ export function useGemini(options: UseGeminiOptions = {}): UseGeminiReturn {
   }, []);
 
   useEffect(() => {
-    return () => { abortRef.current = true; };
+    return () => {
+      // Cleanup on unmount
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+      }
+      operationIdRef.current++;
+    };
   }, []);
 
   return { generate, generateJSON, result, jsonResult, isGenerating, error, reset };

package/src/providers/ProviderConfig.ts

@@ -1,7 +1,3 @@
-/**
- * Provider Configuration
- * Centralized configuration for AI provider with simplified settings
- */
 
 import { DEFAULT_MODELS } from "../domain/entities";
 
@@ -27,16 +23,10 @@ export interface ResolvedProviderConfig {
   timeout: number;
 }
 
-/**
- * Default configuration values
- */
 const DEFAULTS = {
   timeout: 30000,
 };
 
-/**
- * Resolve provider configuration based on preferences
- */
 export function resolveProviderConfig(
   input: ProviderConfigInput,
 ): ResolvedProviderConfig {
@@ -48,25 +38,3 @@ export function resolveProviderConfig(
     timeout: preferences.timeout ?? DEFAULTS.timeout,
   };
 }
-
-/**
- * Get cost-optimized config
- */
-export function getCostOptimizedConfig(
-  input: ProviderConfigInput,
-): ResolvedProviderConfig {
-  return resolveProviderConfig(input);
-}
-
-/**
- * Get quality-optimized config
- */
-export function getQualityOptimizedConfig(
-  input: ProviderConfigInput,
-): ResolvedProviderConfig {
-  const resolved = resolveProviderConfig(input);
-  return {
-    ...resolved,
-    timeout: 60000, // Longer timeout
-  };
-}

package/src/providers/ProviderFactory.ts

@@ -1,7 +1,3 @@
-/**
- * Provider Factory
- * Creates and configures AI provider instances with simplified settings
- */
 
 import { geminiClientCoreService } from "../infrastructure/services/gemini-client-core.service";
 import type { GeminiConfig } from "../domain/entities";
@@ -9,17 +5,11 @@ import type {
   ProviderConfigInput,
   ResolvedProviderConfig,
 } from "./ProviderConfig";
-import {
-  resolveProviderConfig,
-  getCostOptimizedConfig,
-  getQualityOptimizedConfig,
-} from "./ProviderConfig";
-
-export type OptimizationStrategy = "cost" | "quality" | "balanced";
+import { resolveProviderConfig } from "./ProviderConfig";
 
 export interface ProviderFactoryOptions extends ProviderConfigInput {
-  /** Optimization strategy */
-  strategy?: OptimizationStrategy;
+  /** Quality preference strategy */
+  strategy?: "cost" | "quality";
 }
 
 class ProviderFactory {
@@ -29,20 +19,11 @@ class ProviderFactory {
    * Initialize provider with configuration
    */
   initialize(options: ProviderFactoryOptions): void {
-    let config: ResolvedProviderConfig;
+    const config = resolveProviderConfig(options);
 
-    // Apply optimization strategy
-    switch (options.strategy) {
-      case "cost":
-        config = getCostOptimizedConfig(options);
-        break;
-      case "quality":
-        config = getQualityOptimizedConfig(options);
-        break;
-      case "balanced":
-      default:
-        config = resolveProviderConfig(options);
-        break;
+    // Apply strategy-based adjustments
+    if (options.strategy === "quality") {
+      config.timeout = 60000; // Longer timeout for quality
     }
 
     this.currentConfig = config;
@@ -73,23 +54,29 @@ class ProviderFactory {
 
   /**
    * Update configuration without re-initializing
-   * Useful for switching models or adjusting settings
+   * Note: Changing apiKey requires full re-initialization
    */
   updateConfig(updates: Partial<ProviderConfigInput>): void {
     if (!this.currentConfig) {
-      throw new Error(
-        "Provider not initialized. Call initialize() first.",
-      );
+      throw new Error("Provider not initialized. Call initialize() first.");
     }
 
-    const newInput: ProviderConfigInput = {
-      apiKey: updates.apiKey || this.currentConfig.apiKey,
-      preferences: {
-        ...updates.preferences,
-      },
-    };
+    // If API key is changing, we need to re-initialize
+    if (updates.apiKey && updates.apiKey !== this.currentConfig.apiKey) {
+      const newInput: ProviderConfigInput = {
+        apiKey: updates.apiKey,
+        preferences: updates.preferences || {},
+      };
+      this.initialize(newInput);
+      return;
+    }
 
-    this.initialize(newInput);
+    // For other updates, merge with current config
+    this.currentConfig = {
+      ...this.currentConfig,
+      ...updates.preferences,
+      timeout: updates.preferences?.timeout ?? this.currentConfig.timeout,
+    };
   }
 }
 

package/src/providers/index.ts

@@ -1,13 +1,9 @@
 /**
  * Provider Configuration & Factory
- * Centralized configuration system for tier-based AI provider setup
+ * Centralized configuration system for AI provider setup
  */
 
-export {
-  resolveProviderConfig,
-  getCostOptimizedConfig,
-  getQualityOptimizedConfig,
-} from "./ProviderConfig";
+export { resolveProviderConfig } from "./ProviderConfig";
 
 export type {
   QualityPreference,
@@ -19,6 +15,5 @@ export type {
 export { providerFactory } from "./ProviderFactory";
 
 export type {
-  OptimizationStrategy,
   ProviderFactoryOptions,
 } from "./ProviderFactory";