@umituz/react-native-ai-gemini-provider 1.9.2 → 1.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-gemini-provider",
-  "version": "1.9.2",
+  "version": "1.10.0",
   "description": "Google Gemini AI provider for React Native applications",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -46,4 +46,4 @@
     "README.md",
     "LICENSE"
   ]
-}
+}

package/src/index.ts

@@ -93,3 +93,24 @@ export type {
   UseGeminiOptions,
   UseGeminiReturn,
 } from "./presentation/hooks";
+
+// =============================================================================
+// PROVIDER CONFIGURATION - Tier-based Setup
+// =============================================================================
+
+export {
+  providerFactory,
+  resolveProviderConfig,
+  getCostOptimizedConfig,
+  getQualityOptimizedConfig,
+} from "./providers";
+
+export type {
+  SubscriptionTier,
+  QualityPreference,
+  ProviderPreferences,
+  ProviderConfigInput,
+  ResolvedProviderConfig,
+  OptimizationStrategy,
+  ProviderFactoryOptions,
+} from "./providers";

package/src/providers/ProviderConfig.ts

@@ -0,0 +1,137 @@
+/**
+ * Provider Configuration
+ * Centralized configuration for AI provider with tier-based settings
+ */
+
+export type SubscriptionTier = "free" | "premium";
+
+export type QualityPreference = "fast" | "balanced" | "high";
+
+export interface ProviderPreferences {
+  /** Quality preference (fast = Flash, balanced = Flash, high = Pro) */
+  quality?: QualityPreference;
+  /** Maximum retry attempts for failed requests */
+  maxRetries?: number;
+  /** Base delay for retry backoff (ms) */
+  baseDelay?: number;
+  /** Maximum delay for retry backoff (ms) */
+  maxDelay?: number;
+  /** Request timeout (ms) */
+  timeout?: number;
+}
+
+export interface ProviderConfigInput {
+  /** API key for authentication */
+  apiKey: string;
+  /** Subscription tier (determines default models and limits) */
+  subscriptionTier: SubscriptionTier;
+  /** Optional user preferences (overrides tier defaults) */
+  preferences?: ProviderPreferences;
+}
+
+export interface ResolvedProviderConfig {
+  apiKey: string;
+  subscriptionTier: SubscriptionTier;
+  textModel: string;
+  imageGenerationModel: string;
+  imageEditModel: string;
+  maxRetries: number;
+  baseDelay: number;
+  maxDelay: number;
+  timeout: number;
+}
+
+/**
+ * Default configurations per subscription tier
+ */
+const TIER_DEFAULTS: Record<
+  SubscriptionTier,
+  Omit<ResolvedProviderConfig, "apiKey" | "subscriptionTier">
+> = {
+  free: {
+    textModel: "gemini-2.5-flash",
+    imageGenerationModel: "imagen-4.0-generate-001",
+    imageEditModel: "gemini-2.5-flash-image", // Fast model for free tier
+    maxRetries: 1, // Limited retries for free tier
+    baseDelay: 1000,
+    maxDelay: 5000,
+    timeout: 30000, // 30 seconds
+  },
+  premium: {
+    textModel: "gemini-2.5-flash",
+    imageGenerationModel: "imagen-4.0-generate-001",
+    imageEditModel: "gemini-3-pro-image-preview", // High quality for premium
+    maxRetries: 2, // More retries for premium
+    baseDelay: 1000,
+    maxDelay: 10000,
+    timeout: 60000, // 60 seconds
+  },
+};
+
+/**
+ * Quality preference to model mapping
+ */
+const QUALITY_TO_MODEL: Record<QualityPreference, string> = {
+  fast: "gemini-2.5-flash-image",
+  balanced: "gemini-2.5-flash-image",
+  high: "gemini-3-pro-image-preview",
+};
+
+/**
+ * Resolve provider configuration based on tier and preferences
+ */
+export function resolveProviderConfig(
+  input: ProviderConfigInput,
+): ResolvedProviderConfig {
+  const tierDefaults = TIER_DEFAULTS[input.subscriptionTier];
+  const preferences = input.preferences || {};
+
+  // Override image edit model if quality preference is provided
+  let imageEditModel = tierDefaults.imageEditModel;
+  if (preferences.quality) {
+    imageEditModel = QUALITY_TO_MODEL[preferences.quality];
+  }
+
+  return {
+    apiKey: input.apiKey,
+    subscriptionTier: input.subscriptionTier,
+    textModel: tierDefaults.textModel,
+    imageGenerationModel: tierDefaults.imageGenerationModel,
+    imageEditModel,
+    maxRetries: preferences.maxRetries ?? tierDefaults.maxRetries,
+    baseDelay: preferences.baseDelay ?? tierDefaults.baseDelay,
+    maxDelay: preferences.maxDelay ?? tierDefaults.maxDelay,
+    timeout: preferences.timeout ?? tierDefaults.timeout,
+  };
+}
+
+/**
+ * Get cost-optimized config (always use fastest/cheapest models)
+ * Useful for development or cost-sensitive scenarios
+ */
+export function getCostOptimizedConfig(
+  input: ProviderConfigInput,
+): ResolvedProviderConfig {
+  const resolved = resolveProviderConfig(input);
+  return {
+    ...resolved,
+    imageEditModel: "gemini-2.5-flash-image", // Always use fast model
+    maxRetries: 0, // No retries to minimize cost
+  };
+}
+
+/**
+ * Get quality-optimized config (always use best models)
+ * Useful for production or quality-critical scenarios
+ */
+export function getQualityOptimizedConfig(
+  input: ProviderConfigInput,
+): ResolvedProviderConfig {
+  const resolved = resolveProviderConfig(input);
+  return {
+    ...resolved,
+    imageEditModel: "gemini-3-pro-image-preview", // Always use pro model
+    maxRetries: 2, // More retries for reliability
+    timeout: 60000, // Longer timeout
+  };
+}

package/src/providers/ProviderFactory.ts

@@ -0,0 +1,118 @@
+/**
+ * Provider Factory
+ * Creates and configures AI provider instances with tier-based settings
+ */
+
+import { geminiClientCoreService } from "../infrastructure/services/gemini-client-core.service";
+import type { GeminiConfig } from "../domain/entities";
+import type {
+  ProviderConfigInput,
+  ResolvedProviderConfig,
+} from "./ProviderConfig";
+import {
+  resolveProviderConfig,
+  getCostOptimizedConfig,
+  getQualityOptimizedConfig,
+} from "./ProviderConfig";
+
+declare const __DEV__: boolean;
+
+export type OptimizationStrategy = "cost" | "quality" | "balanced";
+
+export interface ProviderFactoryOptions extends ProviderConfigInput {
+  /** Optimization strategy (overrides tier defaults) */
+  strategy?: OptimizationStrategy;
+}
+
+class ProviderFactory {
+  private currentConfig: ResolvedProviderConfig | null = null;
+
+  /**
+   * Initialize provider with tier-based configuration
+   */
+  initialize(options: ProviderFactoryOptions): void {
+    let config: ResolvedProviderConfig;
+
+    // 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;
+    }
+
+    this.currentConfig = config;
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[ProviderFactory] Initializing with config:", {
+        tier: config.subscriptionTier,
+        strategy: options.strategy || "balanced",
+        textModel: config.textModel,
+        imageEditModel: config.imageEditModel,
+        maxRetries: config.maxRetries,
+      });
+    }
+
+    // Initialize Gemini client with resolved config
+    const geminiConfig: GeminiConfig = {
+      apiKey: config.apiKey,
+      imageModel: config.imageEditModel,
+      maxRetries: config.maxRetries,
+      baseDelay: config.baseDelay,
+      maxDelay: config.maxDelay,
+      defaultTimeoutMs: config.timeout,
+      defaultModel: config.textModel,
+    };
+
+    geminiClientCoreService.initialize(geminiConfig);
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[ProviderFactory] Provider initialized successfully");
+    }
+  }
+
+  /**
+   * Get current resolved configuration
+   */
+  getConfig(): ResolvedProviderConfig | null {
+    return this.currentConfig;
+  }
+
+  /**
+   * Check if provider is initialized
+   */
+  isInitialized(): boolean {
+    return this.currentConfig !== null;
+  }
+
+  /**
+   * Update configuration without re-initializing
+   * Useful for switching models or adjusting settings
+   */
+  updateConfig(updates: Partial<ProviderConfigInput>): void {
+    if (!this.currentConfig) {
+      throw new Error(
+        "Provider not initialized. Call initialize() first.",
+      );
+    }
+
+    const newInput: ProviderConfigInput = {
+      apiKey: updates.apiKey || this.currentConfig.apiKey,
+      subscriptionTier:
+        updates.subscriptionTier || this.currentConfig.subscriptionTier,
+      preferences: {
+        ...updates.preferences,
+      },
+    };
+
+    this.initialize(newInput);
+  }
+}
+
+export const providerFactory = new ProviderFactory();

package/src/providers/index.ts

@@ -0,0 +1,25 @@
+/**
+ * Provider Configuration & Factory
+ * Centralized configuration system for tier-based AI provider setup
+ */
+
+export {
+  resolveProviderConfig,
+  getCostOptimizedConfig,
+  getQualityOptimizedConfig,
+} from "./ProviderConfig";
+
+export type {
+  SubscriptionTier,
+  QualityPreference,
+  ProviderPreferences,
+  ProviderConfigInput,
+  ResolvedProviderConfig,
+} from "./ProviderConfig";
+
+export { providerFactory } from "./ProviderFactory";
+
+export type {
+  OptimizationStrategy,
+  ProviderFactoryOptions,
+} from "./ProviderFactory";