@umituz/react-native-ai-gemini-provider 2.0.9 → 2.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-gemini-provider",
-  "version": "2.0.9",
+  "version": "2.0.11",
   "description": "Google Gemini AI text generation provider for React Native applications",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -8,8 +8,6 @@
     "typecheck": "tsc --noEmit",
     "lint": "eslint src --ext .ts,.tsx --max-warnings 0",
     "lint:fix": "eslint src --ext .ts,.tsx --fix",
-    "content-check": "node scripts/content-check.js",
-    "prepublishOnly": "npm run content-check",
     "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'"

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

@@ -14,12 +14,6 @@ export interface GeminiConfig {
   defaultTimeoutMs?: number;
   /** 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;
-  /** Model used for video generation (default: veo-3.1-fast-generate-preview) */
-  videoGenerationModel?: string;
 }
 
 export type GeminiGenerationConfig = Omit<GenerationConfig, "responseSchema"> & {
@@ -50,9 +44,7 @@ export interface GeminiContent {
 }
 
 export type GeminiPart =
-  | { text: string }
-  | { inlineData: { mimeType: string; data: string } }
-  | { fileData: { mimeType: string; fileUri: string } };
+  | { text: string };
 
 export interface GeminiRequest {
   contents: GeminiContent[];
@@ -108,26 +100,3 @@ export interface GeminiModel {
   supportedCapabilities?: string[];
 }
 
-/**
- * Result from image generation
- */
-export interface GeminiImageGenerationResult {
-  /** Generated text (story, caption, etc.) */
-  text?: string;
-  /** Data URL of the generated image (data:image/png;base64,...) */
-  imageUrl?: string;
-  /** Raw base64 image data */
-  imageBase64?: string;
-  /** MIME type of the generated image */
-  mimeType?: string;
-}
-
-/**
- * Input for image generation
- */
-export interface GeminiImageInput {
-  /** Base64 encoded image data (with or without data URL prefix) */
-  base64: string;
-  /** MIME type (e.g., "image/png", "image/jpeg") */
-  mimeType: string;
-}

package/src/domain/entities/models.ts

@@ -8,44 +8,12 @@
  * Available Gemini models
  * Pricing (per 1M tokens):
  * - Flash-Lite: $0.10 input / $0.40 output (FREE: 1000 req/day)
- * - Flash: $0.15 input / $0.60 output (FREE: 20 req/day)
- * - Pro: $1.25 input / $10.00 output (FREE: 25 req/day)
  */
 export const GEMINI_MODELS = {
   // Text generation models (ordered by cost: cheapest first)
   TEXT: {
     /** Most cost-effective, 1000 free requests/day */
     FLASH_LITE: "gemini-2.5-flash-lite",
-    /** Good balance of speed and quality */
-    FLASH: "gemini-2.5-flash",
-    /** Highest quality, best for complex reasoning */
-    PRO: "gemini-2.5-pro",
-  },
-
-  // Text-to-Image models (Imagen 4.0) - generates images from text only
-  TEXT_TO_IMAGE: {
-    DEFAULT: "imagen-4.0-generate-001",
-  },
-
-  // Image editing models - transforms/edits images with input image + prompt
-  // gemini-2.5-flash-image is the most cost-effective (500 images/day free tier)
-  IMAGE_EDIT: {
-    DEFAULT: "gemini-2.5-flash-image",
-    HIGH_QUALITY: "gemini-3-pro-image-preview",
-    LEGACY: "gemini-2.0-flash-preview-image-generation",
-  },
-
-  // Video understanding models (analysis only)
-  VIDEO: {
-    FLASH: "gemini-2.5-flash",
-  },
-
-  // Video generation models (Google Veo)
-  // See: https://ai.google.dev/gemini-api/docs/video
-  VIDEO_GENERATION: {
-    DEFAULT: "veo-3.1-generate-preview",
-    VEO_3: "veo-3-generate-preview",
-    VEO_2: "veo-2-generate",
   },
 } as const;
 
@@ -57,10 +25,6 @@ export const GEMINI_MODELS = {
 export const DEFAULT_MODELS = {
   /** Flash-Lite: Cheapest & highest free tier (1000/day) */
   TEXT: GEMINI_MODELS.TEXT.FLASH_LITE,
-  TEXT_TO_IMAGE: GEMINI_MODELS.TEXT_TO_IMAGE.DEFAULT,
-  IMAGE_EDIT: GEMINI_MODELS.IMAGE_EDIT.DEFAULT,
-  VIDEO: GEMINI_MODELS.VIDEO.FLASH,
-  VIDEO_GENERATION: GEMINI_MODELS.VIDEO_GENERATION.DEFAULT,
 } as const;
 
 /**
@@ -68,8 +32,6 @@ export const DEFAULT_MODELS = {
  */
 export const MODEL_PRICING = {
   [GEMINI_MODELS.TEXT.FLASH_LITE]: { input: 0.10, output: 0.40, freePerDay: 1000 },
-  [GEMINI_MODELS.TEXT.FLASH]: { input: 0.15, output: 0.60, freePerDay: 20 },
-  [GEMINI_MODELS.TEXT.PRO]: { input: 1.25, output: 10.00, freePerDay: 25 },
 } as const;
 
 /**
@@ -77,11 +39,6 @@ export const MODEL_PRICING = {
  */
 export const RESPONSE_MODALITIES = {
   TEXT_ONLY: ["TEXT"] as const,
-  IMAGE_ONLY: ["IMAGE"] as const,
-  VIDEO_ONLY: ["VIDEO"] as const,
-  TEXT_AND_IMAGE: ["TEXT", "IMAGE"] as const,
 } as const;
 
-export type ResponseModality = "TEXT" | "IMAGE" | "VIDEO";
-
-
+export type ResponseModality = "TEXT";

package/src/index.ts

@@ -21,7 +21,6 @@ export type {
   GeminiPromptFeedback,
   GeminiUsageMetadata,
   GeminiModel,
-  GeminiImageInput,
   GeminiErrorInfo,
   GeminiApiError,
   ResponseModality,
@@ -56,12 +55,6 @@ export {
   isGeminiErrorRetryable,
   categorizeGeminiError,
   createGeminiError,
-  isValidModel,
-  validateModel,
-  getSafeModel,
-  isTextModel,
-  getModelCategory,
-  getAllValidModels,
   measureAsync,
   measureSync,
   debounce,

package/src/infrastructure/content/ContentBuilder.ts

@@ -3,36 +3,15 @@
  * Constructs Gemini API content from various input formats
  */
 
-import type { GeminiContent, GeminiImageInput } from "../../domain/entities";
-import { extractBase64Data } from "../utils/gemini-data-transformer.util";
+import type { GeminiContent } from "../../domain/entities";
 
 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),
-            },
-          });
-        }
-      }
-
+      // Create parts array properly typed as GeminiPart[]
+      const parts = [{ text: input.prompt }];
       contents.push({ parts, role: "user" });
     }
 
@@ -42,17 +21,4 @@ export class ContentBuilder {
 
     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

@@ -3,7 +3,6 @@
  * Handles async job submission, tracking, and status management
  */
 
-declare const __DEV__: boolean;
 
 export type AIJobStatusType = "IN_QUEUE" | "IN_PROGRESS" | "COMPLETED" | "FAILED";
 
@@ -38,9 +37,6 @@ export class JobManager {
       status: "IN_QUEUE",
     });
 
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[JobManager] Job submitted:", { requestId, model });
-    }
 
     return {
       requestId,

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

@@ -15,8 +15,6 @@ const DEFAULT_CONFIG: Partial<GeminiConfig> = {
   maxDelay: 10000,
   defaultTimeoutMs: 60000,
   textModel: DEFAULT_MODELS.TEXT,
-  textToImageModel: DEFAULT_MODELS.TEXT_TO_IMAGE,
-  imageEditModel: DEFAULT_MODELS.IMAGE_EDIT,
 };
 
 class GeminiClientCoreService {
@@ -38,8 +36,6 @@ class GeminiClientCoreService {
       console.log("[GeminiClient] initialize() called", {
         hasApiKey: !!config.apiKey,
         textModel: config.textModel,
-        textToImageModel: config.textToImageModel,
-        imageEditModel: config.imageEditModel,
       });
     }
 
@@ -51,8 +47,6 @@ class GeminiClientCoreService {
       // eslint-disable-next-line no-console
       console.log("[GeminiClient] initialized successfully", {
         textModel: this.config.textModel,
-        textToImageModel: this.config.textToImageModel,
-        imageEditModel: this.config.imageEditModel,
         maxRetries: this.config.maxRetries,
       });
     }

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

@@ -3,7 +3,7 @@
  * Text-only AI provider for Google Gemini
  */
 
-import type { GeminiConfig, GeminiImageInput } from "../../domain/entities";
+import type { GeminiConfig } from "../../domain/entities";
 import { providerInitializer } from "./provider-initializer";
 import { generationExecutor } from "./generation-executor";
 
@@ -36,23 +36,6 @@ export class GeminiProvider {
     return generationExecutor.executeTextGeneration(prompt, model);
   }
 
-  /**
-   * Generate text with images (multimodal)
-   * Useful for "describe this image" scenarios
-   */
-  async generateTextWithImages(
-    prompt: string,
-    images: GeminiImageInput[],
-    model: string,
-  ): Promise<string> {
-    const result = await generationExecutor.generateWithImages(
-      model,
-      prompt,
-      images,
-    );
-    return result.text;
-  }
-
   /**
    * Generate structured JSON response
    */

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

@@ -23,20 +23,7 @@ class GeminiStreamingService {
 
     const sdkContents = contents.map((content) => ({
       role: content.role || "user",
-      parts: content.parts.map((part) => {
-        if ("text" in part) {
-          return { text: part.text };
-        }
-        if ("inlineData" in part) {
-          return {
-            inlineData: {
-              mimeType: part.inlineData.mimeType,
-              data: part.inlineData.data,
-            },
-          };
-        }
-        return part;
-      }),
+      parts: content.parts.map((part) => ({ text: part.text })),
     }));
 
     const result = await genModel.generateContentStream({

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

@@ -40,44 +40,6 @@ class GeminiStructuredTextService {
     return this.parseJSONResponse<T>(response);
   }
 
-  /**
-   * Generate structured JSON response with images and schema
-   */
-  async generateStructuredTextWithImages<T>(
-    model: string,
-    prompt: string,
-    images: Array<{ base64: string; mimeType: string }>,
-    schema: Record<string, unknown>,
-    config?: Omit<GeminiGenerationConfig, "responseMimeType" | "responseSchema">,
-  ): Promise<T> {
-    const generationConfig: GeminiGenerationConfig = {
-      ...config,
-      responseMimeType: "application/json",
-      responseSchema: schema as unknown as undefined,
-    };
-
-    const parts: GeminiContent["parts"] = [{ text: prompt }];
-
-    for (const image of images) {
-      parts.push({
-        inlineData: {
-          mimeType: image.mimeType,
-          data: image.base64,
-        },
-      });
-    }
-
-    const contents: GeminiContent[] = [{ parts, role: "user" }];
-
-    const response = await geminiTextGenerationService.generateContent(
-      model,
-      contents,
-      generationConfig,
-    );
-
-    return this.parseJSONResponse<T>(response);
-  }
-
   /**
    * Parse JSON response from Gemini
    */
@@ -98,13 +60,6 @@ class GeminiStructuredTextService {
     try {
       return JSON.parse(cleanedText) as T;
     } catch (error) {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        // eslint-disable-next-line no-console
-        console.error("[Gemini] Failed to parse structured response:", {
-          text: cleanedText.substring(0, 200),
-          error: error instanceof Error ? error.message : String(error),
-        });
-      }
       throw new Error(`Failed to parse structured response: ${error instanceof Error ? error.message : String(error)}`);
     }
   }

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

@@ -5,7 +5,7 @@
 
 import { geminiClientCoreService } from "./gemini-client-core.service";
 import { geminiRetryService } from "./gemini-retry.service";
-import { extractBase64Data, extractTextFromResponse } from "../utils/gemini-data-transformer.util";
+import { extractTextFromResponse } from "../utils/gemini-data-transformer.util";
 import type {
   GeminiContent,
   GeminiGenerationConfig,
@@ -34,17 +34,6 @@ class GeminiTextGenerationService {
     const sdkContents = contents.map((content) => ({
       role: content.role || "user",
       parts: content.parts.map((part) => {
-        if ("text" in part) {
-          return { text: part.text };
-        }
-        if ("inlineData" in part) {
-          return {
-            inlineData: {
-              mimeType: part.inlineData.mimeType,
-              data: part.inlineData.data,
-            },
-          };
-        }
         return part;
       }),
     }));
@@ -75,14 +64,6 @@ class GeminiTextGenerationService {
                 if ("text" in part && part.text !== undefined) {
                   return { text: part.text };
                 }
-                if ("inlineData" in part && part.inlineData) {
-                  return {
-                    inlineData: {
-                      mimeType: part.inlineData.mimeType,
-                      data: part.inlineData.data,
-                    },
-                  };
-                }
                 return null;
               })
               .filter((p): p is GeminiPart => p !== null),
@@ -122,42 +103,6 @@ class GeminiTextGenerationService {
   /**
    * Generate content with images (multimodal)
    */
-  async generateWithImages(
-    model: string,
-    prompt: string,
-    images: Array<{ base64: string; mimeType: string }>,
-    config?: GeminiGenerationConfig,
-  ): Promise<GeminiResponse> {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[GeminiClient] generateWithImages() called", {
-        model,
-        promptLength: prompt.length,
-        imagesCount: images.length,
-        imageMimeTypes: images.map(i => i.mimeType),
-      });
-    }
-
-    const parts: GeminiContent["parts"] = [{ text: prompt }];
-
-    for (const image of images) {
-      parts.push({
-        inlineData: {
-          mimeType: image.mimeType,
-          data: extractBase64Data(image.base64),
-        },
-      });
-    }
-
-    const contents: GeminiContent[] = [{ parts, role: "user" }];
-
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.log("[GeminiClient] generateWithImages() → calling generateContent()");
-    }
-
-    return this.generateContent(model, contents, config);
-  }
 }
 
 export const geminiTextGenerationService = new GeminiTextGenerationService();

package/src/infrastructure/services/generation-executor.ts

@@ -3,11 +3,9 @@
  * Handles execution of text generation
  */
 
-import type { GeminiImageInput } from "../../domain/entities";
 import { geminiTextGenerationService } from "./gemini-text-generation.service";
 import { geminiStructuredTextService } from "./gemini-structured-text.service";
 
-declare const __DEV__: boolean;
 
 export interface ExecutionOptions {
   onProgress?: (progress: number) => void;
@@ -15,7 +13,6 @@ export interface ExecutionOptions {
 
 export interface GenerationInput {
   prompt?: string;
-  images?: GeminiImageInput[];
   generationConfig?: unknown;
 }
 
@@ -26,9 +23,6 @@ export class GenerationExecutor {
    * Execute text generation
    */
   async executeTextGeneration(prompt: string, model: string): Promise<string> {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[GenerationExecutor] executeTextGeneration() called", { model });
-    }
 
     const response = await geminiTextGenerationService.generateContent(
       model,
@@ -46,9 +40,6 @@ export class GenerationExecutor {
     schema: Record<string, unknown>,
     model: string,
   ): Promise<T> {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[GenerationExecutor] executeStructuredGeneration() called", { model });
-    }
 
     return geminiStructuredTextService.generateStructuredText<T>(
       model,
@@ -57,27 +48,6 @@ export class GenerationExecutor {
     );
   }
 
-  /**
-   * Generate text with images (multimodal)
-   */
-  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 };
-  }
 
   /**
    * Extract text from Gemini response

package/src/infrastructure/services/job-processor.ts

@@ -7,7 +7,6 @@ import { JobManager } from "../job/JobManager";
 import type { JobSubmission, JobStatus } from "../job/JobManager";
 import { generationExecutor } from "./generation-executor";
 
-declare const __DEV__: boolean;
 
 export class JobProcessor {
   private jobManager = new JobManager();
@@ -15,10 +14,7 @@ export class JobProcessor {
   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__) {
-        console.error("[GeminiProvider] Job failed:", error);
-      }
+    this.processJobAsync(submission.requestId).catch(() => {
     });
 
     return Promise.resolve(submission);

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

@@ -6,22 +6,15 @@
 import type { GeminiConfig } from "../../domain/entities";
 import { geminiClientCoreService } from "./gemini-client-core.service";
 
-declare const __DEV__: boolean;
 
 export type GeminiProviderConfig = GeminiConfig;
 
 export class ProviderInitializer {
   initialize(config: GeminiProviderConfig): void {
     if (geminiClientCoreService.isInitialized()) {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[GeminiProvider] Already initialized, skipping");
-      }
       return;
     }
 
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[GeminiProvider] Initializing...");
-    }
 
     geminiClientCoreService.initialize(config);
   }

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

@@ -12,7 +12,7 @@ export interface AsyncStateSetters {
   setIsGenerating: (value: boolean) => void;
   setError: (value: string | null) => void;
   setResult: (value: string | null) => void;
-  setJsonResult: (value: unknown | null) => void;
+  setJsonResult: (value: unknown) => void;
 }
 
 /**

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

@@ -5,16 +5,6 @@
 
 import type { GeminiResponse } from "../../domain/entities";
 
-/**
- * Extract base64 data from data URL or return as-is
- */
-export function extractBase64Data(base64String: string): string {
-  if (!base64String.includes(",")) {
-    return base64String;
-  }
-  const parts = base64String.split(",");
-  return parts[1] ?? parts[0] ?? base64String;
-}
 
 /**
  * Extract text from Gemini response

package/src/infrastructure/utils/index.ts

@@ -1,45 +1,5 @@
-/**
- * Infrastructure Utils
- * Text-only utilities
- */
-
-export {
-  mapGeminiError,
-  isGeminiErrorRetryable,
-  categorizeGeminiError,
-  createGeminiError,
-} from "./error-mapper.util";
-
-export {
-  extractBase64Data,
-  extractTextFromResponse,
-} from "./gemini-data-transformer.util";
-
-export {
-  isValidModel,
-  validateModel,
-  getSafeModel,
-  isTextModel,
-  getModelCategory,
-  getAllValidModels,
-} from "./model-validation.util";
-
-export {
-  measureAsync,
-  measureSync,
-  debounce,
-  throttle,
-  PerformanceTimer,
-  PerformanceTracker,
-  performanceTracker,
-} from "./performance.util";
-export type { PerformanceMetrics } from "./performance.util";
-
-export {
-  RateLimiter,
-  rateLimiter,
-} from "./rate-limiter.util";
-export type { RateLimiterOptions } from "./rate-limiter.util";
-
-export { executeWithState } from "./async-state.util";
-export type { AsyncStateCallbacks, AsyncStateSetters } from "./async-state.util";
+export * from "./async-state.util";
+export * from "./error-mapper.util";
+export * from "./gemini-data-transformer.util";
+export * from "./performance.util";
+export * from "./rate-limiter.util";

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

@@ -3,8 +3,6 @@
  * Prevents API rate limit errors by controlling request frequency
  */
 
-declare const __DEV__: boolean;
-
 export interface RateLimiterOptions {
   minInterval?: number; // Minimum milliseconds between requests
   maxQueueSize?: number; // Maximum number of pending requests
@@ -36,7 +34,7 @@ export class RateLimiter {
           reject(error);
         }
       });
-      this.processQueue();
+      void this.processQueue();
     });
   }