@umituz/react-native-ai-gemini-provider 1.9.3 → 1.10.1

package/package.json

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

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

@@ -10,9 +10,12 @@ export interface GeminiConfig {
   baseDelay?: number;
   maxDelay?: number;
   defaultTimeoutMs?: number;
-  defaultModel?: string;
-  /** Model used for image generation (default: gemini-2.0-flash-exp) */
-  imageModel?: string;
+  /** Model used for text generation (default: gemini-2.5-flash-lite) */
+  textModel?: string;
+  /** Model used for text-to-image generation (default: imagen-4.0-generate-001) */
+  textToImageModel?: string;
+  /** Model used for image editing/transformation (default: gemini-2.5-flash-image) */
+  imageEditModel?: string;
 }
 
 export interface GeminiGenerationConfig {

package/src/domain/entities/models.ts

@@ -21,10 +21,10 @@ export const GEMINI_MODELS = {
   },
 
   // Image editing models - transforms/edits images with input image + prompt
-  // gemini-3-pro-image-preview is the highest quality for identity preservation
+  // gemini-2.5-flash-image is the most cost-effective (500 images/day free tier)
   IMAGE_EDIT: {
-    DEFAULT: "gemini-3-pro-image-preview",
-    FAST: "gemini-2.5-flash-image",
+    DEFAULT: "gemini-2.5-flash-image",
+    HIGH_QUALITY: "gemini-3-pro-image-preview",
     LEGACY: "gemini-2.0-flash-preview-image-generation",
   },
 
@@ -36,11 +36,12 @@ export const GEMINI_MODELS = {
 
 /**
  * Default models for each operation type
+ * Optimized for cost-effectiveness while maintaining quality
  */
 export const DEFAULT_MODELS = {
-  TEXT: GEMINI_MODELS.TEXT.FLASH,
+  TEXT: GEMINI_MODELS.TEXT.FLASH_LITE, // Most cost-effective for text
   TEXT_TO_IMAGE: GEMINI_MODELS.TEXT_TO_IMAGE.DEFAULT,
-  IMAGE_EDIT: GEMINI_MODELS.IMAGE_EDIT.DEFAULT,
+  IMAGE_EDIT: GEMINI_MODELS.IMAGE_EDIT.DEFAULT, // Uses gemini-2.5-flash-image (free tier)
   VIDEO: GEMINI_MODELS.VIDEO.FLASH,
 } as const;
 

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/infrastructure/content/ContentBuilder.ts

@@ -0,0 +1,58 @@
+/**
+ * Content Builder
+ * Constructs Gemini API content from various input formats
+ */
+
+import type { GeminiContent, GeminiImageInput } from "../../domain/entities";
+import { extractBase64Data } from "../utils/gemini-data-transformer.util";
+
+export class ContentBuilder {
+  buildContents(input: Record<string, unknown>): GeminiContent[] {
+    const contents: GeminiContent[] = [];
+
+    if (typeof input.prompt === "string") {
+      const parts: GeminiContent["parts"] = [{ text: input.prompt }];
+
+      // Handle single image
+      if (input.image_url && typeof input.image_url === "string") {
+        const imageData = this.parseImageUrl(input.image_url);
+        if (imageData) {
+          parts.push({ inlineData: imageData });
+        }
+      }
+
+      // Handle multiple images
+      if (Array.isArray(input.images)) {
+        for (const img of input.images as GeminiImageInput[]) {
+          parts.push({
+            inlineData: {
+              mimeType: img.mimeType,
+              data: extractBase64Data(img.base64),
+            },
+          });
+        }
+      }
+
+      contents.push({ parts, role: "user" });
+    }
+
+    if (Array.isArray(input.contents)) {
+      contents.push(...(input.contents as GeminiContent[]));
+    }
+
+    return contents;
+  }
+
+  private parseImageUrl(
+    imageUrl: string,
+  ): { mimeType: string; data: string } | null {
+    const base64Match = imageUrl.match(/^data:([^;]+);base64,(.+)$/);
+    if (base64Match) {
+      return {
+        mimeType: base64Match[1],
+        data: base64Match[2],
+      };
+    }
+    return null;
+  }
+}

package/src/infrastructure/job/JobManager.ts

@@ -0,0 +1,120 @@
+/**
+ * Job Manager
+ * Handles async job submission, tracking, and status management
+ */
+
+declare const __DEV__: boolean;
+
+export interface JobSubmission {
+  requestId: string;
+  statusUrl?: string;
+  responseUrl?: string;
+}
+
+export interface JobStatus {
+  status: "IN_QUEUE" | "IN_PROGRESS" | "COMPLETED" | "FAILED";
+  logs?: Array<{ message: string; level: string; timestamp?: string }>;
+  queuePosition?: number;
+  eta?: number;
+}
+
+interface PendingJob {
+  model: string;
+  input: Record<string, unknown>;
+  status: JobStatus["status"];
+  result?: unknown;
+  error?: string;
+}
+
+export class JobManager {
+  private pendingJobs: Map<string, PendingJob> = new Map();
+  private jobCounter = 0;
+
+  submitJob(model: string, input: Record<string, unknown>): JobSubmission {
+    const requestId = this.generateRequestId();
+
+    this.pendingJobs.set(requestId, {
+      model,
+      input,
+      status: "IN_QUEUE",
+    });
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[JobManager] Job submitted:", { requestId, model });
+    }
+
+    return {
+      requestId,
+      statusUrl: undefined,
+      responseUrl: undefined,
+    };
+  }
+
+  getJobStatus(requestId: string): JobStatus {
+    const job = this.pendingJobs.get(requestId);
+
+    if (!job) {
+      return { status: "FAILED" };
+    }
+
+    return { status: job.status };
+  }
+
+  getJobResult<T = unknown>(requestId: string): T {
+    const job = this.pendingJobs.get(requestId);
+
+    if (!job) {
+      throw new Error(`Job ${requestId} not found`);
+    }
+
+    if (job.status !== "COMPLETED") {
+      throw new Error(`Job ${requestId} not completed`);
+    }
+
+    if (job.error) {
+      throw new Error(job.error);
+    }
+
+    this.pendingJobs.delete(requestId);
+
+    return job.result as T;
+  }
+
+  updateJobStatus(requestId: string, status: JobStatus["status"]): void {
+    const job = this.pendingJobs.get(requestId);
+    if (job) {
+      job.status = status;
+    }
+  }
+
+  setJobResult(requestId: string, result: unknown): void {
+    const job = this.pendingJobs.get(requestId);
+    if (job) {
+      job.result = result;
+      job.status = "COMPLETED";
+    }
+  }
+
+  setJobError(requestId: string, error: string): void {
+    const job = this.pendingJobs.get(requestId);
+    if (job) {
+      job.error = error;
+      job.status = "FAILED";
+    }
+  }
+
+  getJob(requestId: string): PendingJob | undefined {
+    return this.pendingJobs.get(requestId);
+  }
+
+  clear(): void {
+    this.pendingJobs.clear();
+    this.jobCounter = 0;
+  }
+
+  private generateRequestId(): string {
+    this.jobCounter++;
+    return `gemini-${Date.now()}-${this.jobCounter}`;
+  }
+}

package/src/infrastructure/response/ResponseFormatter.ts

@@ -0,0 +1,58 @@
+/**
+ * Response Formatter
+ * Formats Gemini API responses into consistent output structure
+ */
+
+declare const __DEV__: boolean;
+
+export class ResponseFormatter {
+  formatResponse<T>(
+    response: unknown,
+    input: Record<string, unknown>,
+  ): T {
+    const resp = response as {
+      candidates?: Array<{
+        content: {
+          parts: Array<{
+            text?: string;
+            inlineData?: { mimeType: string; data: string };
+          }>;
+        };
+      }>;
+    };
+
+    const candidate = resp.candidates?.[0];
+    const parts = candidate?.content.parts || [];
+
+    // Extract text
+    const text = parts.find((p) => p.text)?.text;
+
+    // Extract image if present
+    const imagePart = parts.find((p) => p.inlineData);
+    const imageData = imagePart?.inlineData;
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[ResponseFormatter] Formatting response:", {
+        hasText: !!text,
+        textLength: text?.length ?? 0,
+        hasImage: !!imageData,
+        outputFormat: input.outputFormat,
+      });
+    }
+
+    // Build result object - always return { text } for consistency
+    const result: Record<string, unknown> = {
+      text,
+      response,
+    };
+
+    if (imageData) {
+      result.imageUrl = `data:${imageData.mimeType};base64,${imageData.data}`;
+      result.imageBase64 = imageData.data;
+      result.mimeType = imageData.mimeType;
+    }
+
+    return result as T;
+  }
+}

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

@@ -14,8 +14,9 @@ const DEFAULT_CONFIG: Partial<GeminiConfig> = {
   baseDelay: 1000,
   maxDelay: 10000,
   defaultTimeoutMs: 60000,
-  defaultModel: DEFAULT_MODELS.TEXT,
-  imageModel: DEFAULT_MODELS.TEXT_TO_IMAGE,
+  textModel: DEFAULT_MODELS.TEXT,
+  textToImageModel: DEFAULT_MODELS.TEXT_TO_IMAGE,
+  imageEditModel: DEFAULT_MODELS.IMAGE_EDIT,
 };
 
 class GeminiClientCoreService {
@@ -28,8 +29,9 @@ class GeminiClientCoreService {
       // eslint-disable-next-line no-console
       console.log("[GeminiClient] initialize() called", {
         hasApiKey: !!config.apiKey,
-        defaultModel: config.defaultModel,
-        imageModel: config.imageModel,
+        textModel: config.textModel,
+        textToImageModel: config.textToImageModel,
+        imageEditModel: config.imageEditModel,
       });
     }
 
@@ -40,8 +42,9 @@ class GeminiClientCoreService {
     if (typeof __DEV__ !== "undefined" && __DEV__) {
       // eslint-disable-next-line no-console
       console.log("[GeminiClient] initialized successfully", {
-        defaultModel: this.config.defaultModel,
-        imageModel: this.config.imageModel,
+        textModel: this.config.textModel,
+        textToImageModel: this.config.textToImageModel,
+        imageEditModel: this.config.imageEditModel,
         maxRetries: this.config.maxRetries,
       });
     }
@@ -69,7 +72,7 @@ class GeminiClientCoreService {
 
   getModel(modelName?: string): GenerativeModel {
     this.validateInitialization();
-    const effectiveModel = modelName || this.config?.defaultModel || "gemini-1.5-flash";
+    const effectiveModel = modelName || this.config?.textModel || DEFAULT_MODELS.TEXT;
     return this.client!.getGenerativeModel({ model: effectiveModel });
   }
 

package/src/infrastructure/services/gemini-image-edit.service.ts

@@ -37,7 +37,7 @@ class GeminiImageEditService {
     geminiClientCoreService.validateInitialization();
 
     const config = geminiClientCoreService.getConfig();
-    const editModel = DEFAULT_MODELS.IMAGE_EDIT;
+    const editModel = config?.imageEditModel || DEFAULT_MODELS.IMAGE_EDIT;
     const apiKey = config?.apiKey;
 
     if (typeof __DEV__ !== "undefined" && __DEV__) {

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

@@ -34,7 +34,7 @@ class GeminiImageGenerationService {
     geminiClientCoreService.validateInitialization();
 
     const config = geminiClientCoreService.getConfig();
-    const imageModel = config?.imageModel || DEFAULT_MODELS.TEXT_TO_IMAGE;
+    const imageModel = config?.textToImageModel || DEFAULT_MODELS.TEXT_TO_IMAGE;
     const apiKey = config?.apiKey;
 
     if (typeof __DEV__ !== "undefined" && __DEV__) {

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

@@ -0,0 +1,201 @@
+/**
+ * Gemini Provider
+ * Main AI provider implementation for Google Gemini
+ */
+
+import type {
+  GeminiConfig,
+  GeminiImageInput,
+  GeminiImageGenerationResult,
+} from "../../domain/entities";
+import { geminiClientCoreService } from "./gemini-client-core.service";
+import { geminiTextGenerationService } from "./gemini-text-generation.service";
+import { geminiImageGenerationService } from "./gemini-image-generation.service";
+import { geminiImageEditService } from "./gemini-image-edit.service";
+import { JobManager } from "../job/JobManager";
+import { ContentBuilder } from "../content/ContentBuilder";
+import { ResponseFormatter } from "../response/ResponseFormatter";
+import type { JobSubmission, JobStatus } from "../job/JobManager";
+
+declare const __DEV__: boolean;
+
+export interface AIProviderConfig {
+  apiKey: string;
+  maxRetries?: number;
+  baseDelay?: number;
+  maxDelay?: number;
+  defaultTimeoutMs?: number;
+  textModel?: string;
+  textToImageModel?: string;
+  imageEditModel?: string;
+}
+
+export interface SubscribeOptions<T = unknown> {
+  timeoutMs?: number;
+  onQueueUpdate?: (status: JobStatus) => void;
+  onProgress?: (progress: number) => void;
+  onResult?: (result: T) => void;
+}
+
+export class GeminiProvider {
+  readonly providerId = "gemini";
+  readonly providerName = "Google Gemini";
+
+  private jobManager = new JobManager();
+  private contentBuilder = new ContentBuilder();
+  private responseFormatter = new ResponseFormatter();
+
+  initialize(config: AIProviderConfig): void {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[GeminiProvider] Initializing...");
+    }
+
+    const geminiConfig: GeminiConfig = {
+      apiKey: config.apiKey,
+      maxRetries: config.maxRetries,
+      baseDelay: config.baseDelay,
+      maxDelay: config.maxDelay,
+      defaultTimeoutMs: config.defaultTimeoutMs,
+      textModel: config.textModel,
+      textToImageModel: config.textToImageModel,
+      imageEditModel: config.imageEditModel,
+    };
+
+    geminiClientCoreService.initialize(geminiConfig);
+  }
+
+  isInitialized(): boolean {
+    return geminiClientCoreService.isInitialized();
+  }
+
+  submitJob(model: string, input: Record<string, unknown>): Promise<JobSubmission> {
+    const submission = this.jobManager.submitJob(model, input);
+
+    this.processJobAsync(submission.requestId).catch((error) => {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        // eslint-disable-next-line no-console
+        console.error("[GeminiProvider] Job failed:", error);
+      }
+    });
+
+    return Promise.resolve(submission);
+  }
+
+  getJobStatus(_model: string, requestId: string): Promise<JobStatus> {
+    const status = this.jobManager.getJobStatus(requestId);
+    return Promise.resolve(status);
+  }
+
+  getJobResult<T = unknown>(_model: string, requestId: string): Promise<T> {
+    try {
+      const result = this.jobManager.getJobResult<T>(requestId);
+      return Promise.resolve(result);
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  }
+
+  async subscribe<T = unknown>(
+    model: string,
+    input: Record<string, unknown>,
+    options?: SubscribeOptions<T>,
+  ): Promise<T> {
+    options?.onQueueUpdate?.({ status: "IN_QUEUE" });
+    options?.onProgress?.(10);
+
+    const result = await this.executeGeneration<T>(model, input);
+
+    options?.onProgress?.(100);
+    options?.onQueueUpdate?.({ status: "COMPLETED" });
+    options?.onResult?.(result);
+
+    return result;
+  }
+
+  async run<T = unknown>(
+    model: string,
+    input: Record<string, unknown>,
+  ): Promise<T> {
+    return this.executeGeneration<T>(model, input);
+  }
+
+  async generateImage(prompt: string): Promise<GeminiImageGenerationResult> {
+    return geminiImageGenerationService.generateImage(prompt);
+  }
+
+  async editImage(
+    prompt: string,
+    images: GeminiImageInput[],
+  ): Promise<GeminiImageGenerationResult> {
+    return geminiImageEditService.editImage(prompt, images);
+  }
+
+  async generateWithImages(
+    model: string,
+    prompt: string,
+    images: GeminiImageInput[],
+  ): Promise<{ text: string; response: unknown }> {
+    const response = await geminiTextGenerationService.generateWithImages(
+      model,
+      prompt,
+      images,
+    );
+
+    const text = response.candidates?.[0]?.content.parts
+      .filter((p): p is { text: string } => "text" in p)
+      .map((p) => p.text)
+      .join("") || "";
+
+    return { text, response };
+  }
+
+  reset(): void {
+    geminiClientCoreService.reset();
+    this.jobManager.clear();
+  }
+
+  private async processJobAsync(requestId: string): Promise<void> {
+    const job = this.jobManager.getJob(requestId);
+    if (!job) return;
+
+    this.jobManager.updateJobStatus(requestId, "IN_PROGRESS");
+
+    try {
+      const result = await this.executeGeneration(job.model, job.input);
+      this.jobManager.setJobResult(requestId, result);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.jobManager.setJobError(requestId, errorMessage);
+    }
+  }
+
+  private async executeGeneration<T>(
+    model: string,
+    input: Record<string, unknown>,
+  ): Promise<T> {
+    const isImageGeneration = input.generateImage === true || input.type === "image";
+
+    if (isImageGeneration) {
+      const prompt = String(input.prompt || "");
+      const images = input.images as GeminiImageInput[] | undefined;
+      const result = await geminiImageGenerationService.generateImage(prompt, images);
+      return result as T;
+    }
+
+    const contents = this.contentBuilder.buildContents(input);
+    const response = await geminiTextGenerationService.generateContent(
+      model,
+      contents,
+      input.generationConfig as undefined,
+    );
+
+    return this.responseFormatter.formatResponse<T>(response, input);
+  }
+}
+
+export const geminiProviderService = new GeminiProvider();
+
+export function createGeminiProvider(): GeminiProvider {
+  return new GeminiProvider();
+}

package/src/infrastructure/services/index.ts

@@ -14,10 +14,12 @@ export { geminiStreamingService } from "./gemini-streaming.service";
 export {
   geminiProviderService,
   createGeminiProvider,
-} from "./gemini-provider.service";
+  GeminiProvider,
+} from "./gemini-provider";
+
 export type {
   AIProviderConfig,
-  JobSubmission,
-  JobStatus,
   SubscribeOptions,
-} from "./gemini-provider.service";
+} from "./gemini-provider";
+
+export type { JobSubmission, JobStatus } from "../job/JobManager";

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,
+      imageEditModel: config.imageEditModel,
+      maxRetries: config.maxRetries,
+      baseDelay: config.baseDelay,
+      maxDelay: config.maxDelay,
+      defaultTimeoutMs: config.timeout,
+      textModel: 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";

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

@@ -1,426 +0,0 @@
-/**
- * Gemini Provider Service
- * IAIProvider implementation for Google Gemini
- */
-
-import type {
-  GeminiConfig,
-  GeminiContent,
-  GeminiImageInput,
-  GeminiImageGenerationResult,
-} from "../../domain/entities";
-import { geminiClientCoreService } from "./gemini-client-core.service";
-import { geminiTextGenerationService } from "./gemini-text-generation.service";
-import { geminiImageGenerationService } from "./gemini-image-generation.service";
-import { geminiImageEditService } from "./gemini-image-edit.service";
-import { extractBase64Data } from "../utils/gemini-data-transformer.util";
-
-declare const __DEV__: boolean;
-
-export interface AIProviderConfig {
-  apiKey: string;
-  maxRetries?: number;
-  baseDelay?: number;
-  maxDelay?: number;
-  defaultTimeoutMs?: number;
-  /** Model used for image generation */
-  imageModel?: string;
-}
-
-export interface JobSubmission {
-  requestId: string;
-  statusUrl?: string;
-  responseUrl?: string;
-}
-
-export interface JobStatus {
-  status: "IN_QUEUE" | "IN_PROGRESS" | "COMPLETED" | "FAILED";
-  logs?: Array<{ message: string; level: string; timestamp?: string }>;
-  queuePosition?: number;
-  eta?: number;
-}
-
-export interface SubscribeOptions<T = unknown> {
-  timeoutMs?: number;
-  onQueueUpdate?: (status: JobStatus) => void;
-  onProgress?: (progress: number) => void;
-  onResult?: (result: T) => void;
-}
-
-interface PendingJob {
-  model: string;
-  input: Record<string, unknown>;
-  status: JobStatus["status"];
-  result?: unknown;
-  error?: string;
-}
-
-class GeminiProviderService {
-  readonly providerId = "gemini";
-  readonly providerName = "Google Gemini";
-
-  private pendingJobs: Map<string, PendingJob> = new Map();
-  private jobCounter = 0;
-
-  initialize(config: AIProviderConfig): void {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[GeminiProvider] initialize() called", {
-        hasApiKey: !!config.apiKey,
-        imageModel: config.imageModel,
-      });
-    }
-
-    const geminiConfig: GeminiConfig = {
-      apiKey: config.apiKey,
-      maxRetries: config.maxRetries,
-      baseDelay: config.baseDelay,
-      maxDelay: config.maxDelay,
-      defaultTimeoutMs: config.defaultTimeoutMs,
-      imageModel: config.imageModel,
-    };
-
-    geminiClientCoreService.initialize(geminiConfig);
-
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[GeminiProvider] initialized successfully");
-    }
-  }
-
-  isInitialized(): boolean {
-    return geminiClientCoreService.isInitialized();
-  }
-
-  submitJob(
-    model: string,
-    input: Record<string, unknown>,
-  ): Promise<JobSubmission> {
-    const requestId = this.generateRequestId();
-
-    this.pendingJobs.set(requestId, {
-      model,
-      input,
-      status: "IN_QUEUE",
-    });
-
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[GeminiProvider] Job submitted:", { requestId, model });
-    }
-
-    this.processJobAsync(requestId).catch((error) => {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        // eslint-disable-next-line no-console
-        console.error("[GeminiProvider] Job failed:", error);
-      }
-    });
-
-    return Promise.resolve({
-      requestId,
-      statusUrl: undefined,
-      responseUrl: undefined,
-    });
-  }
-
-  getJobStatus(_model: string, requestId: string): Promise<JobStatus> {
-    const job = this.pendingJobs.get(requestId);
-
-    if (!job) {
-      return Promise.resolve({ status: "FAILED" });
-    }
-
-    return Promise.resolve({ status: job.status });
-  }
-
-  getJobResult<T = unknown>(_model: string, requestId: string): Promise<T> {
-    const job = this.pendingJobs.get(requestId);
-
-    if (!job) {
-      return Promise.reject(new Error(`Job ${requestId} not found`));
-    }
-
-    if (job.status !== "COMPLETED") {
-      return Promise.reject(new Error(`Job ${requestId} not completed`));
-    }
-
-    if (job.error) {
-      return Promise.reject(new Error(job.error));
-    }
-
-    this.pendingJobs.delete(requestId);
-
-    return Promise.resolve(job.result as T);
-  }
-
-  async subscribe<T = unknown>(
-    model: string,
-    input: Record<string, unknown>,
-    options?: SubscribeOptions<T>,
-  ): Promise<T> {
-    options?.onQueueUpdate?.({ status: "IN_QUEUE" });
-    options?.onProgress?.(10);
-
-    const result = await this.executeGeneration<T>(model, input);
-
-    options?.onProgress?.(100);
-    options?.onQueueUpdate?.({ status: "COMPLETED" });
-    options?.onResult?.(result);
-
-    return result;
-  }
-
-  async run<T = unknown>(
-    model: string,
-    input: Record<string, unknown>,
-  ): Promise<T> {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[GeminiProvider] Run started:", {
-        model,
-        hasPrompt: !!input.prompt,
-        outputFormat: input.outputFormat,
-      });
-    }
-
-    const result = await this.executeGeneration<T>(model, input);
-
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[GeminiProvider] Run completed:", {
-        model,
-        hasResult: !!result,
-      });
-    }
-
-    return result;
-  }
-
-  /**
-   * Generate image from text only (Imagen API)
-   * Use for text-to-image generation without input images
-   */
-  async generateImage(
-    prompt: string,
-  ): Promise<GeminiImageGenerationResult> {
-    return geminiImageGenerationService.generateImage(prompt);
-  }
-
-  /**
-   * Edit/transform image using input image + prompt (Gemini API)
-   * Use for image editing, transformation, style transfer
-   */
-  async editImage(
-    prompt: string,
-    images: GeminiImageInput[],
-  ): Promise<GeminiImageGenerationResult> {
-    return geminiImageEditService.editImage(prompt, images);
-  }
-
-  /**
-   * Generate content with images (multimodal)
-   */
-  async generateWithImages(
-    model: string,
-    prompt: string,
-    images: GeminiImageInput[],
-  ): Promise<{ text: string; response: unknown }> {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[GeminiProvider] generateWithImages() called", {
-        model,
-        promptLength: prompt.length,
-        imagesCount: images.length,
-      });
-    }
-
-    const response = await geminiTextGenerationService.generateWithImages(
-      model,
-      prompt,
-      images,
-    );
-
-    const text = response.candidates?.[0]?.content.parts
-      .filter((p): p is { text: string } => "text" in p)
-      .map((p) => p.text)
-      .join("") || "";
-
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[GeminiProvider] generateWithImages() completed", {
-        hasText: !!text,
-        textLength: text.length,
-      });
-    }
-
-    return { text, response };
-  }
-
-  reset(): void {
-    geminiClientCoreService.reset();
-    this.pendingJobs.clear();
-    this.jobCounter = 0;
-  }
-
-  private generateRequestId(): string {
-    this.jobCounter++;
-    return `gemini-${Date.now()}-${this.jobCounter}`;
-  }
-
-  private async processJobAsync(requestId: string): Promise<void> {
-    const job = this.pendingJobs.get(requestId);
-
-    if (!job) return;
-
-    job.status = "IN_PROGRESS";
-
-    try {
-      const result = await this.executeGeneration(job.model, job.input);
-      job.result = result;
-      job.status = "COMPLETED";
-    } catch (error) {
-      job.status = "FAILED";
-      job.error = error instanceof Error ? error.message : String(error);
-    }
-  }
-
-  private async executeGeneration<T>(
-    model: string,
-    input: Record<string, unknown>,
-  ): Promise<T> {
-    const isImageGeneration = input.generateImage === true || input.type === "image";
-
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[GeminiProvider] Execute generation:", {
-        model,
-        isImageGeneration,
-        promptLength: String(input.prompt || "").length,
-      });
-    }
-
-    if (isImageGeneration) {
-      const prompt = String(input.prompt || "");
-      const images = input.images as GeminiImageInput[] | undefined;
-      const result = await geminiImageGenerationService.generateImage(prompt, images);
-      return result as T;
-    }
-
-    const contents = this.buildContents(input);
-    const response = await geminiTextGenerationService.generateContent(
-      model,
-      contents,
-      input.generationConfig as undefined,
-    );
-
-    return this.formatResponse<T>(response, input);
-  }
-
-  private buildContents(input: Record<string, unknown>): GeminiContent[] {
-    const contents: GeminiContent[] = [];
-
-    if (typeof input.prompt === "string") {
-      const parts: GeminiContent["parts"] = [{ text: input.prompt }];
-
-      // Handle single image
-      if (input.image_url && typeof input.image_url === "string") {
-        const imageData = this.parseImageUrl(input.image_url);
-        if (imageData) {
-          parts.push({ inlineData: imageData });
-        }
-      }
-
-      // Handle multiple images
-      if (Array.isArray(input.images)) {
-        for (const img of input.images as GeminiImageInput[]) {
-          parts.push({
-            inlineData: {
-              mimeType: img.mimeType,
-              data: extractBase64Data(img.base64),
-            },
-          });
-        }
-      }
-
-      contents.push({ parts, role: "user" });
-    }
-
-    if (Array.isArray(input.contents)) {
-      contents.push(...(input.contents as GeminiContent[]));
-    }
-
-    return contents;
-  }
-
-  private parseImageUrl(
-    imageUrl: string,
-  ): { mimeType: string; data: string } | null {
-    const base64Match = imageUrl.match(/^data:([^;]+);base64,(.+)$/);
-    if (base64Match) {
-      return {
-        mimeType: base64Match[1],
-        data: base64Match[2],
-      };
-    }
-    return null;
-  }
-
-  private formatResponse<T>(
-    response: unknown,
-    input: Record<string, unknown>,
-  ): T {
-    const resp = response as {
-      candidates?: Array<{
-        content: {
-          parts: Array<{
-            text?: string;
-            inlineData?: { mimeType: string; data: string };
-          }>;
-        };
-      }>;
-    };
-
-    const candidate = resp.candidates?.[0];
-    const parts = candidate?.content.parts || [];
-
-    // Extract text
-    const text = parts.find((p) => p.text)?.text;
-
-    // Extract image if present
-    const imagePart = parts.find((p) => p.inlineData);
-    const imageData = imagePart?.inlineData;
-
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[GeminiProvider] Format response:", {
-        hasText: !!text,
-        textLength: text?.length ?? 0,
-        hasImage: !!imageData,
-        outputFormat: input.outputFormat,
-      });
-    }
-
-    // Build result object - always return { text } for consistency
-    const result: Record<string, unknown> = {
-      text,
-      response,
-    };
-
-    if (imageData) {
-      result.imageUrl = `data:${imageData.mimeType};base64,${imageData.data}`;
-      result.imageBase64 = imageData.data;
-      result.mimeType = imageData.mimeType;
-    }
-
-    return result as T;
-  }
-}
-
-export const geminiProviderService = new GeminiProviderService();
-
-/**
- * Factory function to create a new Gemini provider instance
- */
-export function createGeminiProvider(): GeminiProviderService {
-  return new GeminiProviderService();
-}