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

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@umituz/react-native-ai-gemini-provider",
-  "version": "1.10.0",
+  "version": "1.10.2",
   "description": "Google Gemini AI provider for React Native applications",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
   "scripts": {
-    "typecheck": "echo 'TypeScript validation passed'",
-    "lint": "echo 'Lint passed'",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src --ext .ts,.tsx --max-warnings 0",
+    "lint:fix": "eslint src --ext .ts,.tsx --fix",
     "version:patch": "npm version patch -m 'chore: release v%s'",
     "version:minor": "npm version minor -m 'chore: release v%s'",
     "version:major": "npm version major -m 'chore: release v%s'"
@@ -33,10 +34,13 @@
   },
   "devDependencies": {
     "@google/generative-ai": "^0.21.0",
+    "@typescript-eslint/eslint-plugin": "^7.0.0",
+    "@typescript-eslint/parser": "^7.0.0",
+    "eslint": "^8.57.0",
     "@types/react": "~19.1.10",
     "react": "19.1.0",
     "react-native": "0.81.5",
-    "typescript": "~5.9.2"
+    "typescript": "^5.3.0"
   },
   "publishConfig": {
     "access": "public"

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/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/ProviderFactory.ts

@@ -15,7 +15,6 @@ import {
   getQualityOptimizedConfig,
 } from "./ProviderConfig";
 
-declare const __DEV__: boolean;
 
 export type OptimizationStrategy = "cost" | "quality" | "balanced";
 
@@ -49,32 +48,22 @@ class ProviderFactory {
 
     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,
-      });
-    }
+    this.currentConfig = config;
 
     // Initialize Gemini client with resolved config
     const geminiConfig: GeminiConfig = {
       apiKey: config.apiKey,
-      imageModel: config.imageEditModel,
+      imageEditModel: config.imageEditModel,
       maxRetries: config.maxRetries,
       baseDelay: config.baseDelay,
       maxDelay: config.maxDelay,
       defaultTimeoutMs: config.timeout,
-      defaultModel: config.textModel,
+      textModel: config.textModel,
     };
 
     geminiClientCoreService.initialize(geminiConfig);
 
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[ProviderFactory] Provider initialized successfully");
-    }
+    geminiClientCoreService.initialize(geminiConfig);
   }
 
   /**

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();
-}