@umituz/react-native-ai-gemini-provider 2.0.16 → 2.0.17

package/package.json

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

package/src/index.ts

@@ -30,7 +30,6 @@ export {
   geminiStructuredTextService,
   geminiStreamingService,
   geminiProviderService,
-  createGeminiProvider,
   GeminiProvider,
 } from "./infrastructure/services";
 
@@ -42,6 +41,7 @@ export {
   isGeminiErrorRetryable,
   categorizeGeminiError,
   createGeminiError,
+  extractTextFromResponse,
   measureAsync,
   measureSync,
   debounce,
@@ -71,7 +71,7 @@ export type {
   RequestContext,
   RequestInterceptor,
   InterceptorErrorStrategy,
-} from "./infrastructure/interceptors/RequestInterceptors";
+} from "./infrastructure/interceptors";
 
 export type {
   ResponseContext,

package/src/infrastructure/interceptors/RequestInterceptors.ts

@@ -1,4 +1,6 @@
 
+import { telemetryHooks } from "../telemetry";
+
 export interface RequestContext {
   model: string;
   feature?: string;
@@ -47,6 +49,9 @@ class RequestInterceptors {
       try {
         result = await interceptor(result);
       } catch (error) {
+        // Log to telemetry
+        telemetryHooks.logError(context.model, error instanceof Error ? error : new Error(String(error)), context.feature);
+
         switch (this.errorStrategy) {
           case "fail":
             throw new Error(`Request interceptor failed: ${error instanceof Error ? error.message : String(error)}`);
@@ -54,7 +59,7 @@ class RequestInterceptors {
             // Skip this interceptor and continue with previous result
             break;
           case "log":
-            // Silently ignore but continue
+            // Error already logged, continue with previous result
             break;
         }
       }

package/src/infrastructure/interceptors/ResponseInterceptors.ts

@@ -1,4 +1,7 @@
 
+import type { InterceptorErrorStrategy } from "./RequestInterceptors";
+import { telemetryHooks } from "../telemetry";
+
 export interface ResponseContext<T = unknown> {
   model: string;
   feature?: string;
@@ -11,8 +14,6 @@ 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";
@@ -52,6 +53,9 @@ class ResponseInterceptors {
       try {
         result = await interceptor(result);
       } catch (error) {
+        // Log to telemetry
+        telemetryHooks.logError(context.model, error instanceof Error ? error : new Error(String(error)), context.feature);
+
         switch (this.errorStrategy) {
           case "fail":
             throw new Error(`Response interceptor failed: ${error instanceof Error ? error.message : String(error)}`);
@@ -59,7 +63,7 @@ class ResponseInterceptors {
             // Skip this interceptor and continue with previous result
             break;
           case "log":
-            // Silently ignore but continue
+            // Error already logged, continue with previous result
             break;
         }
       }

package/src/infrastructure/interceptors/index.ts

@@ -9,6 +9,7 @@ export { responseInterceptors } from "./ResponseInterceptors";
 export type {
   RequestContext,
   RequestInterceptor,
+  InterceptorErrorStrategy,
 } from "./RequestInterceptors";
 
 export type {

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

@@ -1,5 +1,5 @@
 import { GoogleGenerativeAI, type GenerativeModel } from "@google/generative-ai";
-import { DEFAULT_MODELS, GEMINI_MODELS } from "../../domain/entities";
+import { DEFAULT_MODELS } from "../../domain/entities";
 import type { GeminiConfig } from "../../domain/entities";
 
 const DEFAULT_CONFIG: Partial<GeminiConfig> = {
@@ -40,14 +40,16 @@ class GeminiClientCoreService {
   }
 
   /**
-   * Validate model name against known models
+   * Validate model name format (allows any valid model string)
    */
   private validateModel(modelName: string): void {
-    const knownModels = Object.values(GEMINI_MODELS.TEXT);
-    const isValid = knownModels.some((model) => model === modelName);
+    if (!modelName || typeof modelName !== "string" || modelName.trim().length === 0) {
+      throw new Error(`Invalid model name: "${modelName}". Model name must be a non-empty string.`);
+    }
 
-    if (!isValid) {
-      throw new Error(`Unknown model: "${modelName}". Known models: ${knownModels.join(", ")}`);
+    // Check for valid model format (starts with gemini-)
+    if (!modelName.startsWith("gemini-")) {
+      throw new Error(`Invalid model name: "${modelName}". Gemini models should start with "gemini-".`);
     }
   }
 
@@ -60,7 +62,7 @@ class GeminiClientCoreService {
 
     const effectiveModel = modelName || this.config?.textModel || DEFAULT_MODELS.TEXT;
 
-    // Validate model name
+    // Validate model name format (not against hardcoded list)
     this.validateModel(effectiveModel);
 
     return this.client.getGenerativeModel({ model: effectiveModel });

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

@@ -1,7 +1,6 @@
 
 import type { GeminiConfig } from "../../domain/entities";
 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;
@@ -25,15 +24,6 @@ export class GeminiProvider {
     geminiClientCoreService.reset();
   }
 
-  /**
-   * Generate text from prompt
-   */
-  async generateText(prompt: string, model: string): Promise<string> {
-    const contents = [{ parts: [{ text: prompt }], role: "user" as const }];
-    const response = await geminiTextGenerationService.generateContent(model, contents);
-    return this.extractTextFromResponse(response);
-  }
-
   /**
    * Generate structured JSON response
    */
@@ -44,28 +34,6 @@ export class GeminiProvider {
   ): Promise<T> {
     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("") || "";
-  }
 }
 
 export const geminiProviderService = new GeminiProvider();
-
-export function createGeminiProvider(): GeminiProvider {
-  return new GeminiProvider();
-}

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

@@ -14,6 +14,7 @@ class GeminiStreamingService {
     contents: GeminiContent[],
     onChunk: (text: string) => void,
     generationConfig?: GeminiGenerationConfig,
+    signal?: AbortSignal,
   ): Promise<string> {
     const genModel = geminiClientCoreService.getModel(model);
 
@@ -22,10 +23,14 @@ class GeminiStreamingService {
       parts: content.parts.map((part) => ({ text: part.text })),
     }));
 
-    const result = await genModel.generateContentStream({
+    const requestOptions = {
       contents: sdkContents as Parameters<typeof genModel.generateContentStream>[0] extends { contents: infer C } ? C : never,
       generationConfig,
-    });
+    };
+
+    const result = signal
+      ? await genModel.generateContentStream(requestOptions, { signal })
+      : await genModel.generateContentStream(requestOptions);
 
     let fullText = "";
 

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

@@ -4,6 +4,7 @@ import type { GenerationConfig } from "@google/generative-ai";
 import type {
   GeminiContent,
   GeminiGenerationConfig,
+  GeminiResponse,
 } from "../../domain/entities";
 
 
@@ -16,6 +17,7 @@ class GeminiStructuredTextService {
     prompt: string,
     schema: Record<string, unknown>,
     config?: Omit<GeminiGenerationConfig, "responseMimeType" | "responseSchema">,
+    signal?: AbortSignal,
   ): Promise<T> {
     // Validate schema structure before passing to SDK
     if (!schema || typeof schema !== "object" || Object.keys(schema).length === 0) {
@@ -37,6 +39,7 @@ class GeminiStructuredTextService {
       model,
       contents,
       generationConfig,
+      signal,
     );
 
     return this.parseJSONResponse<T>(response);
@@ -45,24 +48,32 @@ class GeminiStructuredTextService {
   /**
    * Parse JSON response from Gemini
    */
-  private parseJSONResponse<T>(response: unknown): T {
-    const candidates = (response as { candidates?: Array<{ content: { parts: Array<{ text?: string }> } }> }).candidates;
+  private parseJSONResponse<T>(response: GeminiResponse): T {
+    const candidates = response.candidates;
+
+    if (!candidates || candidates.length === 0) {
+      throw new Error("No candidates in response");
+    }
 
     let text = "";
 
-    if (candidates?.[0]?.content?.parts) {
+    if (candidates[0]?.content?.parts) {
       text = candidates[0].content.parts
-        .map((part) => part.text || "")
+        .map((part) => "text" in part ? (part.text || "") : "")
         .join("");
     }
 
+    if (!text || text.trim().length === 0) {
+      throw new Error("Empty response received from Gemini");
+    }
+
     // Clean and parse JSON (remove markdown code blocks if present)
     const cleanedText = text.replace(/```json\n?/g, "").replace(/```\n?/g, "").trim();
 
     try {
       return JSON.parse(cleanedText) as T;
     } catch (error) {
-      throw new Error(`Failed to parse structured response: ${error instanceof Error ? error.message : String(error)}`);
+      throw new Error(`Failed to parse structured response: ${error instanceof Error ? error.message : String(error)}. Cleaned text: ${cleanedText.substring(0, 200)}...`);
     }
   }
 }

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

@@ -6,6 +6,8 @@ import type {
   GeminiGenerationConfig,
   GeminiResponse,
   GeminiPart,
+  GeminiFinishReason,
+  GeminiSafetyRating,
 } from "../../domain/entities";
 
 class GeminiTextGenerationService {
@@ -16,6 +18,7 @@ class GeminiTextGenerationService {
     model: string,
     contents: GeminiContent[],
     generationConfig?: GeminiGenerationConfig,
+    signal?: AbortSignal,
   ): Promise<GeminiResponse> {
     const genModel = geminiClientCoreService.getModel(model);
 
@@ -24,12 +27,20 @@ class GeminiTextGenerationService {
       parts: content.parts,
     }));
 
-    const result = await genModel.generateContent({
+    const requestOptions = {
       contents: sdkContents as Parameters<typeof genModel.generateContent>[0] extends { contents: infer C } ? C : never,
       generationConfig,
-    });
+    };
+
+    const result = signal
+      ? await genModel.generateContent(requestOptions, { signal })
+      : await genModel.generateContent(requestOptions);
 
-    const response = (result as { response: GeminiResponse }).response;
+    const response = result.response;
+
+    if (!response) {
+      throw new Error("No response received from Gemini API");
+    }
 
     return {
       candidates: response.candidates?.map((candidate) => {
@@ -41,14 +52,33 @@ class GeminiTextGenerationService {
           // Ignore unsupported part types (inlineData, etc.)
         }
 
+        // Map SDK finish reason to our domain type
+        const finishReason: GeminiFinishReason | undefined = candidate.finishReason
+          ? (candidate.finishReason as GeminiFinishReason)
+          : undefined;
+
+        // Map safety ratings
+        const safetyRatings: GeminiSafetyRating[] | undefined = candidate.safetyRatings
+          ? candidate.safetyRatings.map((rating) => ({
+              category: rating.category as GeminiSafetyRating["category"],
+              probability: rating.probability as GeminiSafetyRating["probability"],
+            }))
+          : undefined;
+
         return {
           content: {
             parts: transformedParts,
-            role: (candidate.content.role || "model"),
+            role: (candidate.content.role || "model") as "user" | "model",
           },
-          finishReason: candidate.finishReason,
+          finishReason,
+          safetyRatings,
         };
       }),
+      usageMetadata: response.usageMetadata ? {
+        promptTokenCount: response.usageMetadata.promptTokenCount,
+        candidatesTokenCount: response.usageMetadata.candidatesTokenCount,
+        totalTokenCount: response.usageMetadata.totalTokenCount,
+      } : undefined,
     };
   }
 
@@ -59,18 +89,15 @@ class GeminiTextGenerationService {
     model: string,
     prompt: string,
     config?: GeminiGenerationConfig,
+    signal?: AbortSignal,
   ): Promise<string> {
     const contents: GeminiContent[] = [
       { parts: [{ text: prompt }], role: "user" },
     ];
 
-    const response = await this.generateContent(model, contents, config);
+    const response = await this.generateContent(model, contents, config, signal);
     return extractTextFromResponse(response);
   }
-
-  /**
-   * Generate content with images (multimodal)
-   */
 }
 
 export const geminiTextGenerationService = new GeminiTextGenerationService();

package/src/infrastructure/services/index.ts

@@ -12,7 +12,6 @@ export { geminiStreamingService } from "./gemini-streaming.service";
 // Provider
 export {
   geminiProviderService,
-  createGeminiProvider,
   GeminiProvider,
 } from "./gemini-provider";
 export type { GeminiProviderConfig } from "./gemini-provider";

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

@@ -1,4 +1,3 @@
-
 export interface AsyncStateCallbacks {
   onSuccess?: (result: string) => void;
   onError?: (error: string) => void;

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

@@ -3,12 +3,12 @@ import type { GeminiResponse } from "../../domain/entities";
 
 
 export function extractTextFromResponse(response: GeminiResponse): string {
-  const candidate = response.candidates?.[0];
-
-  if (!candidate) {
+  if (!response.candidates || response.candidates.length === 0) {
     throw new Error("No response candidates");
   }
 
+  const candidate = response.candidates[0];
+
   // Handle all finish reasons appropriately
   switch (candidate.finishReason) {
     case "SAFETY":
@@ -19,6 +19,7 @@ export function extractTextFromResponse(response: GeminiResponse): string {
     case "FINISH_REASON_UNSPECIFIED":
     case "OTHER":
     case "STOP":
+    case undefined:
       // Continue to extract text
       break;
   }

package/src/infrastructure/utils/index.ts

@@ -1,5 +1,6 @@
-export * from "./async-state.util";
-export * from "./error-mapper.util";
-export * from "./gemini-data-transformer.util";
-export * from "./performance.util";
-export * from "./rate-limiter.util";
+export { mapGeminiError, isGeminiErrorRetryable, categorizeGeminiError, createGeminiError } from "./error-mapper.util";
+export { extractTextFromResponse } from "./gemini-data-transformer.util";
+export { measureAsync, measureSync, debounce, throttle, PerformanceTimer } from "./performance.util";
+export { RateLimiter } from "./rate-limiter.util";
+export type { PerformanceMetrics } from "./performance.util";
+export type { RateLimiterOptions } from "./rate-limiter.util";

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

@@ -10,7 +10,6 @@ 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
@@ -32,36 +31,37 @@ export class RateLimiter {
         }
       });
 
-      // 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;
-        });
-      }
+      // Start queue processing if not already running
+      this.processQueue().catch(() => {
+        // Individual task errors are handled above, ignore queue processing errors
+      });
     });
   }
 
-  private async processQueue() {
-    if (this.processing || this.queue.length === 0) return;
+  private async processQueue(): Promise<void> {
+    // Only one processQueue can run at a time
+    if (this.processing) {
+      return;
+    }
+
     this.processing = true;
 
-    while (this.queue.length > 0) {
-      const elapsed = Date.now() - this.lastRequest;
-      if (elapsed < this.minInterval) {
-        await new Promise((r) => setTimeout(r, this.minInterval - elapsed));
-      }
+    try {
+      while (this.queue.length > 0) {
+        const elapsed = Date.now() - this.lastRequest;
+        if (elapsed < this.minInterval) {
+          await new Promise((r) => setTimeout(r, this.minInterval - elapsed));
+        }
 
-      const task = this.queue.shift();
-      if (task) {
-        this.lastRequest = Date.now();
-        await task();
+        const task = this.queue.shift();
+        if (task) {
+          this.lastRequest = Date.now();
+          await task();
+        }
       }
+    } finally {
+      this.processing = false;
     }
-
-    this.processing = false;
   }
 
   getQueueSize(): number {

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

@@ -3,7 +3,7 @@ import { useState, useCallback, useRef, useMemo, useEffect } from "react";
 import type { GeminiGenerationConfig } from "../../domain/entities";
 import { DEFAULT_MODELS } from "../../domain/entities";
 import { geminiTextGenerationService, geminiStructuredTextService } from "../../infrastructure/services";
-import { executeWithState } from "../../infrastructure/utils";
+import { executeWithState } from "../../infrastructure/utils/async-state.util";
 
 export interface UseGeminiOptions {
   model?: string;
@@ -41,6 +41,11 @@ export function useGemini(options: UseGeminiOptions = {}): UseGeminiReturn {
   const model = options.model ?? DEFAULT_MODELS.TEXT;
 
   const generate = useCallback(async (prompt: string) => {
+    // Abort previous operation if still running
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+    }
+
     // Create new abort controller for this operation
     const controller = new AbortController();
     abortControllerRef.current = controller;
@@ -54,11 +59,12 @@ export function useGemini(options: UseGeminiOptions = {}): UseGeminiReturn {
         async () => {
           // Check if this operation is still the latest one
           if (currentOpId !== operationIdRef.current) {
+            controller.abort();
             throw new Error("Operation cancelled by newer request");
           }
-          return geminiTextGenerationService.generateText(model, prompt, options.generationConfig);
+          return geminiTextGenerationService.generateText(model, prompt, options.generationConfig, controller.signal);
         },
-        (text) => {
+        (text: string) => {
           // Only update if this is still the latest operation
           if (currentOpId === operationIdRef.current) {
             setResult(text);
@@ -75,6 +81,11 @@ export function useGemini(options: UseGeminiOptions = {}): UseGeminiReturn {
   }, [model, options.generationConfig, setters, callbacks, options.onSuccess]);
 
   const generateJSON = useCallback(async <T>(prompt: string, schema?: Record<string, unknown>): Promise<T | null> => {
+    // Abort previous operation if still running
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+    }
+
     // Create new abort controller for this operation
     const controller = new AbortController();
     abortControllerRef.current = controller;
@@ -88,14 +99,15 @@ export function useGemini(options: UseGeminiOptions = {}): UseGeminiReturn {
         async () => {
           // Check if this operation is still the latest one
           if (currentOpId !== operationIdRef.current) {
+            controller.abort();
             throw new Error("Operation cancelled by newer request");
           }
 
           if (schema) {
-            return geminiStructuredTextService.generateStructuredText<T>(model, prompt, schema, options.generationConfig);
+            return geminiStructuredTextService.generateStructuredText<T>(model, prompt, schema, options.generationConfig, controller.signal);
           }
 
-          const text = await geminiTextGenerationService.generateText(model, prompt, { ...options.generationConfig, responseMimeType: "application/json" });
+          const text = await geminiTextGenerationService.generateText(model, prompt, { ...options.generationConfig, responseMimeType: "application/json" }, controller.signal);
           const cleanedText = cleanJsonResponse(text);
 
           try {
@@ -104,7 +116,7 @@ export function useGemini(options: UseGeminiOptions = {}): UseGeminiReturn {
             throw new Error(`Failed to parse JSON response: ${parseError instanceof Error ? parseError.message : String(parseError)}. Response: ${cleanedText.substring(0, 200)}...`);
           }
         },
-        (parsed) => {
+        (parsed: unknown) => {
           // Only update if this is still the latest operation
           if (currentOpId === operationIdRef.current) {
             setJsonResult(parsed);

package/src/providers/ProviderFactory.ts

@@ -14,6 +14,7 @@ export interface ProviderFactoryOptions extends ProviderConfigInput {
 
 class ProviderFactory {
   private currentConfig: ResolvedProviderConfig | null = null;
+  private currentOptions: ProviderFactoryOptions | null = null;
 
   /**
    * Initialize provider with configuration
@@ -27,6 +28,7 @@ class ProviderFactory {
     }
 
     this.currentConfig = config;
+    this.currentOptions = options;
 
     // Initialize Gemini client with resolved config
     const geminiConfig: GeminiConfig = {
@@ -57,25 +59,33 @@ class ProviderFactory {
    * Note: Changing apiKey requires full re-initialization
    */
   updateConfig(updates: Partial<ProviderConfigInput>): void {
-    if (!this.currentConfig) {
+    if (!this.currentConfig || !this.currentOptions) {
       throw new Error("Provider not initialized. Call initialize() first.");
     }
 
     // If API key is changing, we need to re-initialize
     if (updates.apiKey && updates.apiKey !== this.currentConfig.apiKey) {
-      const newInput: ProviderConfigInput = {
+      const newInput: ProviderFactoryOptions = {
         apiKey: updates.apiKey,
-        preferences: updates.preferences || {},
+        preferences: updates.preferences || this.currentOptions.preferences,
+        strategy: this.currentOptions.strategy,
       };
       this.initialize(newInput);
       return;
     }
 
     // For other updates, merge with current config
-    this.currentConfig = {
-      ...this.currentConfig,
+    const mergedPreferences = {
+      ...this.currentOptions.preferences,
       ...updates.preferences,
-      timeout: updates.preferences?.timeout ?? this.currentConfig.timeout,
+    };
+
+    this.currentOptions.preferences = mergedPreferences;
+
+    this.currentConfig = {
+      apiKey: this.currentConfig.apiKey,
+      textModel: this.currentConfig.textModel,
+      timeout: mergedPreferences.timeout ?? this.currentConfig.timeout,
     };
   }
 }