@umituz/react-native-ai-gemini-provider 2.1.4 → 2.1.6

package/package.json

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

package/src/index.ts

@@ -1,7 +1,6 @@
 /**
  * @umituz/react-native-ai-gemini-provider
  * Google Gemini AI provider for React Native applications
- * Text generation only - for image/video use FAL Provider
  */
 
 // Domain Types
@@ -21,120 +20,28 @@ export type {
   GeminiApiError,
 } from "./domain/entities";
 
-export { GeminiErrorType, GeminiError, GEMINI_MODELS, DEFAULT_MODELS, MODEL_PRICING } from "./domain/entities";
+export {
+  GeminiErrorType,
+  GeminiError,
+  GEMINI_MODELS,
+  DEFAULT_MODELS
+} from "./domain/entities";
 
-// Services
+// Main Service
 export {
-  geminiClientCoreService,
-  geminiTextGenerationService,
-  geminiStructuredTextService,
-  geminiStreamingService,
   geminiProviderService,
   GeminiProvider,
 } from "./infrastructure/services";
 
 export type { GeminiProviderConfig } from "./infrastructure/services";
 
-// Utils
-export {
-  // Error handling
-  mapGeminiError,
-  isGeminiErrorRetryable,
-  categorizeGeminiError,
-  createGeminiError,
-  // Data transformation
-  extractTextFromResponse,
-  cleanJsonText,
-  parseJsonResponse,
-  safeParseJson,
-  extractJsonFromText,
-  toSdkContent,
-  createTextContent,
-  transformCandidate,
-  transformResponse,
-  extractTextFromParts,
-  // Performance
-  measureAsync,
-  measureSync,
-  debounce,
-  throttle,
-  PerformanceTimer,
-  // Rate limiting
-  RateLimiter,
-  // Retry logic
-  retryWithBackoff,
-  retryIf,
-  retryWithFixedDelay,
-  shouldRetryNetworkError,
-  createRetryPredicate,
-  // Validation
-  validateModelName,
-  validateApiKey,
-  validateSchema,
-  validatePrompt,
-  validateTimeout,
-  isValidObject,
-  validateRequiredFields,
-  // Environment
-  getRequiredEnv,
-  getOptionalEnv,
-  getEnvNumber,
-  getEnvBoolean,
-  loadGeminiEnv,
-  getApiKeyFromEnv,
-  isDevelopment,
-  isDebugEnabled,
-  validateEnv,
-  getGeminiConfigFromEnv,
-  // Async state management
-  executeWithState,
-  createDebouncedAsync,
-  createMemoizedAsync,
-} from "./infrastructure/utils";
-
-export type {
-  PerformanceMetrics,
-  RateLimiterOptions,
-  RetryOptions,
-  RetryResult,
-  EnvConfig,
-  AsyncStateCallbacks,
-  AsyncStateSetters,
-  AsyncStateConfig,
-} from "./infrastructure/utils";
-
-// Hooks
+// React Hook
 export { useGemini } from "./presentation/hooks";
-
 export type { UseGeminiOptions, UseGeminiReturn } from "./presentation/hooks";
 
-// Telemetry
-export { telemetryHooks } from "./infrastructure/telemetry";
-export type { TelemetryEvent, TelemetryListener } from "./infrastructure/telemetry";
-
-// Interceptors
-export { requestInterceptors, responseInterceptors } from "./infrastructure/interceptors";
-
-export type {
-  RequestContext,
-  RequestInterceptor,
-  InterceptorErrorStrategy,
-} from "./infrastructure/interceptors";
-
-export type {
-  ResponseContext,
-  ResponseInterceptor,
-} from "./infrastructure/interceptors/ResponseInterceptors";
-
-// Provider Config
-export {
-  providerFactory,
-  resolveProviderConfig,
-} from "./providers";
-
+// Provider Configuration & Factory
+export { ConfigBuilder, providerFactory } from "./providers";
 export type {
-  ProviderPreferences,
-  ProviderConfigInput,
-  ResolvedProviderConfig,
+  ProviderConfig,
   ProviderFactoryOptions,
 } from "./providers";

package/src/infrastructure/interceptors/BaseInterceptor.ts

@@ -0,0 +1,78 @@
+/**
+ * Base Interceptor Class
+ * Eliminates code duplication between Request and Response interceptors
+ */
+
+import { telemetryHooks } from "../telemetry";
+
+export type InterceptorErrorStrategy = "fail" | "skip" | "log";
+
+export interface BaseContext {
+  model: string;
+  feature?: string;
+  timestamp: number;
+}
+
+export abstract class BaseInterceptor<TContext extends BaseContext> {
+  protected interceptors: Array<(context: TContext) => TContext | Promise<TContext>> = [];
+  protected errorStrategy: InterceptorErrorStrategy = "fail";
+
+  /**
+   * Register an interceptor
+   */
+  use(interceptor: (context: TContext) => TContext | Promise<TContext>): () => void {
+    this.interceptors.push(interceptor);
+
+    // Return unsubscribe function
+    return () => {
+      const index = this.interceptors.indexOf(interceptor);
+      if (index > -1) {
+        this.interceptors.splice(index, 1);
+      }
+    };
+  }
+
+  /**
+   * Set error handling strategy
+   */
+  setErrorStrategy(strategy: InterceptorErrorStrategy): void {
+    this.errorStrategy = strategy;
+  }
+
+  /**
+   * Clear all interceptors
+   */
+  clear(): void {
+    this.interceptors = [];
+  }
+
+  /**
+   * Get interceptor count
+   */
+  count(): number {
+    return this.interceptors.length;
+  }
+
+  /**
+   * Handle interceptor error based on strategy
+   */
+  protected handleError(context: TContext, error: unknown): void {
+    telemetryHooks.logError(
+      context.model,
+      error instanceof Error ? error : new Error(String(error)),
+      context.feature
+    );
+
+    if (this.errorStrategy === "fail") {
+      throw new Error(
+        `Interceptor failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    // For "skip" and "log", we just continue (error already logged)
+  }
+
+  /**
+   * Apply interceptors - to be implemented by subclasses
+   */
+  abstract apply(context: TContext): Promise<TContext>;
+}

package/src/infrastructure/interceptors/RequestInterceptors.ts

@@ -1,46 +1,15 @@
+import { BaseInterceptor, type BaseContext } from "./BaseInterceptor";
 
-import { telemetryHooks } from "../telemetry";
-
-export interface RequestContext {
-  model: string;
-  feature?: string;
+export interface RequestContext extends BaseContext {
   payload: Record<string, unknown>;
-  timestamp: number;
 }
 
 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
-   * Interceptors are called in order (first registered = first called)
-   */
-  use(interceptor: RequestInterceptor): () => void {
-    this.interceptors.push(interceptor);
-
-    // Return unsubscribe function
-    return () => {
-      const index = this.interceptors.indexOf(interceptor);
-      if (index > -1) {
-        this.interceptors.splice(index, 1);
-      }
-    };
-  }
-
-  /**
-   * Set error handling strategy for interceptors
-   */
-  setErrorStrategy(strategy: InterceptorErrorStrategy): void {
-    this.errorStrategy = strategy;
-  }
-
+class RequestInterceptors extends BaseInterceptor<RequestContext> {
   /**
    * Apply all interceptors to a request context
+   * Interceptors are called in order (first registered = first called)
    */
   async apply(context: RequestContext): Promise<RequestContext> {
     let result = context;
@@ -49,38 +18,13 @@ 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)}`);
-          case "skip":
-            // Skip this interceptor and continue with previous result
-            break;
-          case "log":
-            // Error already logged, continue with previous result
-            break;
-        }
+        this.handleError(context, error);
+        // If we get here, strategy was "skip" or "log" - continue with previous result
       }
     }
 
     return result;
   }
-
-  /**
-   * Clear all interceptors
-   */
-  clear(): void {
-    this.interceptors = [];
-  }
-
-  /**
-   * Get interceptor count
-   */
-  count(): number {
-    return this.interceptors.length;
-  }
 }
 
 export const requestInterceptors = new RequestInterceptors();

package/src/infrastructure/interceptors/ResponseInterceptors.ts

@@ -1,48 +1,18 @@
+import { BaseInterceptor, type BaseContext } from "./BaseInterceptor";
 
-import type { InterceptorErrorStrategy } from "./RequestInterceptors";
-import { telemetryHooks } from "../telemetry";
-
-export interface ResponseContext<T = unknown> {
-  model: string;
-  feature?: string;
+export interface ResponseContext<T = unknown> extends BaseContext {
   data: T;
   duration: number;
-  timestamp: number;
 }
 
 export type ResponseInterceptor<T = unknown> = (
   context: ResponseContext<T>,
 ) => ResponseContext<T> | Promise<ResponseContext<T>>;
 
-class ResponseInterceptors {
-  private interceptors: Array<ResponseInterceptor<unknown>> = [];
-  private errorStrategy: InterceptorErrorStrategy = "fail";
-
-  /**
-   * Register a response interceptor
-   * Interceptors are called in reverse order (last registered = first called)
-   */
-  use<T = unknown>(interceptor: ResponseInterceptor<T>): () => void {
-    this.interceptors.push(interceptor as ResponseInterceptor<unknown>);
-
-    // Return unsubscribe function
-    return () => {
-      const index = this.interceptors.indexOf(interceptor as ResponseInterceptor<unknown>);
-      if (index > -1) {
-        this.interceptors.splice(index, 1);
-      }
-    };
-  }
-
-  /**
-   * Set error handling strategy for interceptors
-   */
-  setErrorStrategy(strategy: InterceptorErrorStrategy): void {
-    this.errorStrategy = strategy;
-  }
-
+class ResponseInterceptors extends BaseInterceptor<ResponseContext<unknown>> {
   /**
    * Apply all interceptors to a response context
+   * Interceptors are called in reverse order (last registered = first called)
    */
   async apply<T>(context: ResponseContext<T>): Promise<ResponseContext<T>> {
     let result: ResponseContext<unknown> = context;
@@ -53,38 +23,13 @@ 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)}`);
-          case "skip":
-            // Skip this interceptor and continue with previous result
-            break;
-          case "log":
-            // Error already logged, continue with previous result
-            break;
-        }
+        this.handleError(context, error);
+        // If we get here, strategy was "skip" or "log" - continue with previous result
       }
     }
 
     return result as ResponseContext<T>;
   }
-
-  /**
-   * Clear all interceptors
-   */
-  clear(): void {
-    this.interceptors = [];
-  }
-
-  /**
-   * Get interceptor count
-   */
-  count(): number {
-    return this.interceptors.length;
-  }
 }
 
 export const responseInterceptors = new ResponseInterceptors();

package/src/infrastructure/interceptors/index.ts

@@ -1,18 +1,12 @@
 /**
- * Interceptors Module
- * Allows applications to modify requests and responses
+ * Interceptors Module - Internal Use Only
  */
 
-export { requestInterceptors } from "./RequestInterceptors";
-export { responseInterceptors } from "./ResponseInterceptors";
+export { BaseInterceptor } from "./BaseInterceptor";
+export type { BaseContext, InterceptorErrorStrategy } from "./BaseInterceptor";
 
-export type {
-  RequestContext,
-  RequestInterceptor,
-  InterceptorErrorStrategy,
-} from "./RequestInterceptors";
+export { requestInterceptors } from "./RequestInterceptors";
+export type { RequestContext, RequestInterceptor } from "./RequestInterceptors";
 
-export type {
-  ResponseContext,
-  ResponseInterceptor,
-} from "./ResponseInterceptors";
+export { responseInterceptors } from "./ResponseInterceptors";
+export type { ResponseContext, ResponseInterceptor } from "./ResponseInterceptors";

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

@@ -0,0 +1,82 @@
+/**
+ * Base Gemini Service
+ * Common functionality for all Gemini services to eliminate code duplication
+ */
+
+import { geminiClientCoreService } from "./gemini-client-core.service";
+import { toSdkContent } from "../utils/content-mapper.util";
+import { createGeminiError } from "../utils/error-mapper.util";
+import type { GeminiContent, GeminiGenerationConfig } from "../../domain/entities";
+import type { GenerativeModel } from "@google/generative-ai";
+
+/**
+ * Base request options structure
+ */
+export interface BaseRequestOptions {
+  model: string;
+  contents: GeminiContent[];
+  generationConfig?: GeminiGenerationConfig;
+  signal?: AbortSignal;
+}
+
+/**
+ * Abstract base service with common patterns
+ */
+export abstract class BaseGeminiService {
+  /**
+   * Validate and prepare request
+   * Eliminates duplicate validation and abort checks
+   */
+  protected validateAndPrepare(options: BaseRequestOptions): {
+    genModel: GenerativeModel;
+    sdkContents: Array<{ role: string; parts: Array<{ text: string }> }>;
+  } {
+    // Validate contents
+    if (!options.contents || options.contents.length === 0) {
+      throw new Error("Contents array cannot be empty");
+    }
+
+    // Check for early abort
+    if (options.signal?.aborted) {
+      throw new Error("Request was aborted");
+    }
+
+    const genModel = geminiClientCoreService.getModel(options.model);
+    const sdkContents = toSdkContent(options.contents);
+
+    return { genModel, sdkContents };
+  }
+
+  /**
+   * Handle errors uniformly across all services
+   * Eliminates duplicate error handling logic
+   */
+  protected handleError(error: unknown, abortMessage: string): never {
+    // Re-throw as GeminiError if it's already an API error
+    if (error instanceof Error && error.name === "GeminiError") {
+      throw error;
+    }
+
+    // Check for abort error
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new Error(abortMessage);
+    }
+
+    // Wrap other errors
+    throw createGeminiError(error);
+  }
+
+  /**
+   * Create typed request options for SDK
+   * Type-safe request creation
+   */
+  protected createRequestOptions(
+    sdkContents: Array<{ role: string; parts: Array<{ text: string }> }>,
+    generationConfig?: GeminiGenerationConfig
+  ) {
+    return {
+      contents: sdkContents,
+      generationConfig,
+    };
+  }
+}

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

@@ -1,14 +1,12 @@
-
-import { geminiClientCoreService } from "./gemini-client-core.service";
-import { toSdkContent } from "../utils/content-mapper.util";
-import { createGeminiError } from "../utils/error-mapper.util";
+import { BaseGeminiService } from "./base-gemini.service";
 import { telemetryHooks } from "../telemetry";
+import { processStream } from "../utils/stream-processor.util";
 import type {
   GeminiContent,
   GeminiGenerationConfig,
 } from "../../domain/entities";
 
-class GeminiStreamingService {
+class GeminiStreamingService extends BaseGeminiService {
   /**
    * Stream content generation
    *
@@ -31,75 +29,47 @@ class GeminiStreamingService {
     generationConfig?: GeminiGenerationConfig,
     signal?: AbortSignal,
   ): Promise<string> {
-    // Validate input
-    if (!contents || contents.length === 0) {
-      throw new Error("Contents array cannot be empty");
-    }
-
+    // Validate callback
     if (typeof onChunk !== "function") {
       throw new Error("onChunk must be a function");
     }
 
-    // Check for early abort
-    if (signal?.aborted) {
-      throw new Error("Stream generation was aborted");
-    }
-
     try {
-      const genModel = geminiClientCoreService.getModel(model);
-      const sdkContents = toSdkContent(contents);
-
-      const requestOptions = {
-        contents: sdkContents as Parameters<typeof genModel.generateContentStream>[0] extends { contents: infer C } ? C : never,
+      const { genModel, sdkContents } = this.validateAndPrepare({
+        model,
+        contents,
         generationConfig,
-      };
+        signal,
+      });
+
+      const requestOptions = this.createRequestOptions(sdkContents, generationConfig);
 
       const result = signal
         ? await genModel.generateContentStream(requestOptions, { signal })
         : await genModel.generateContentStream(requestOptions);
 
-      let fullText = "";
-
-      for await (const chunk of result.stream) {
-        try {
-          const chunkText = chunk.text();
-          if (chunkText) {
-            fullText += chunkText;
-            // Safely call onChunk - errors in callback won't break the stream
-            try {
-              onChunk(chunkText);
-            } catch (callbackError) {
-              try {
-                telemetryHooks.logError(model, callbackError instanceof Error ? callbackError : new Error(String(callbackError)), "stream-callback");
-              } catch {
-                // Silently ignore telemetry errors to prevent breaking the stream
-              }
-            }
-          }
-        } catch (chunkError) {
-          // Log chunk error via telemetry, but don't let telemetry errors break the stream
-          try {
-            telemetryHooks.logError(model, chunkError instanceof Error ? chunkError : new Error(String(chunkError)), "stream-chunk");
-          } catch {
-            // Silently ignore telemetry errors
-          }
-        }
-      }
-
-      return fullText;
+      return await processStream(
+        result.stream,
+        onChunk,
+        (error, context) => this.logStreamError(model, error, context)
+      );
     } catch (error) {
-      // Re-throw as GeminiError if it's an API error
-      if (error instanceof Error && error.name === "GeminiError") {
-        throw error;
-      }
-
-      // Check for abort error
-      if (error instanceof Error && error.name === "AbortError") {
-        throw new Error("Stream generation was aborted");
-      }
+      return this.handleError(error, "Stream generation was aborted");
+    }
+  }
 
-      // Wrap other errors
-      throw createGeminiError(error);
+  /**
+   * Log stream errors via telemetry
+   */
+  private logStreamError(model: string, error: unknown, context?: string): void {
+    try {
+      telemetryHooks.logError(
+        model,
+        error instanceof Error ? error : new Error(String(error)),
+        context
+      );
+    } catch {
+      // Silently ignore telemetry errors
     }
   }
 }