@umituz/react-native-ai-gemini-provider 1.14.24 → 1.14.25

package/package.json

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

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

@@ -37,3 +37,48 @@ export interface GeminiApiError {
     }>;
   };
 }
+
+/**
+ * Custom error class for Gemini API errors
+ */
+export class GeminiError extends Error {
+  readonly type: GeminiErrorType;
+  readonly retryable: boolean;
+  readonly statusCode?: number;
+  readonly originalError?: unknown;
+
+  constructor(info: GeminiErrorInfo) {
+    super(info.messageKey);
+    this.name = "GeminiError";
+    this.type = info.type;
+    this.retryable = info.retryable;
+    this.statusCode = info.statusCode;
+    this.originalError = info.originalError;
+
+    // Maintains proper stack trace (only available on V8)
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, GeminiError);
+    }
+  }
+
+  /**
+   * Check if error is retryable
+   */
+  isRetryable(): boolean {
+    return this.retryable;
+  }
+
+  /**
+   * Get error type
+   */
+  getErrorType(): GeminiErrorType {
+    return this.type;
+  }
+
+  /**
+   * Create GeminiError from unknown error
+   */
+  static fromError(_error: unknown, info: GeminiErrorInfo): GeminiError {
+    return new GeminiError(info);
+  }
+}

package/src/index.ts

@@ -51,6 +51,8 @@ export type {
   GeminiApiError,
 } from "./domain/entities";
 
+export { GeminiError } from "./domain/entities";
+
 // Model Constants
 export {
   GEMINI_MODELS,
@@ -90,6 +92,7 @@ export {
   geminiVideoGenerationService,
   geminiProviderService,
   createGeminiProvider,
+  featureModelSelector,
 } from "./infrastructure/services";
 
 export type {
@@ -100,6 +103,9 @@ export type {
   JobStatus,
   SubscribeOptions,
   AIJobStatusType,
+  GenerationInput,
+  GenerationResult,
+  ExecutionOptions,
 } from "./infrastructure/services";
 
 // =============================================================================
@@ -110,6 +116,7 @@ export {
   mapGeminiError,
   isGeminiErrorRetryable,
   categorizeGeminiError,
+  createGeminiError,
   // Input builders
   buildSingleImageInput,
   buildDualImageInput,

package/src/infrastructure/services/feature-model-selector.ts

@@ -1,6 +1,7 @@
 /**
  * Feature Model Selector
  * Returns the appropriate model ID for a given feature
+ * Supports runtime model overrides for flexibility
  */
 
 import type {
@@ -12,19 +13,64 @@ import {
   GEMINI_VIDEO_FEATURE_MODELS,
 } from "../../domain/constants/feature-models.constants";
 
+declare const __DEV__: boolean;
+
+type ModelOverrideMap = Partial<Record<ImageFeatureType | VideoFeatureType, string>>;
+
 class FeatureModelSelector {
+  private overrides: ModelOverrideMap = {};
+
+  /**
+   * Set model override for a specific feature
+   * This allows runtime configuration without modifying constants
+   */
+  setModelOverride(feature: ImageFeatureType | VideoFeatureType, model: string): void {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[FeatureModelSelector] Model override set:", { feature, model });
+    }
+    this.overrides[feature] = model;
+  }
+
+  /**
+   * Clear all model overrides
+   */
+  clearOverrides(): void {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      // eslint-disable-next-line no-console
+      console.log("[FeatureModelSelector] All model overrides cleared");
+    }
+    this.overrides = {};
+  }
+
   /**
    * Get model ID for an IMAGE feature
+   * Returns override if set, otherwise returns default model
    */
   getImageFeatureModel(feature: ImageFeatureType): string {
-    return GEMINI_IMAGE_FEATURE_MODELS[feature];
+    return this.overrides[feature] ?? GEMINI_IMAGE_FEATURE_MODELS[feature];
   }
 
   /**
    * Get model ID for a VIDEO feature
+   * Returns override if set, otherwise returns default model
    */
   getVideoFeatureModel(feature: VideoFeatureType): string {
-    return GEMINI_VIDEO_FEATURE_MODELS[feature];
+    return this.overrides[feature] ?? GEMINI_VIDEO_FEATURE_MODELS[feature];
+  }
+
+  /**
+   * Check if a feature has a custom override
+   */
+  hasOverride(feature: ImageFeatureType | VideoFeatureType): boolean {
+    return feature in this.overrides;
+  }
+
+  /**
+   * Get all current overrides
+   */
+  getOverrides(): ModelOverrideMap {
+    return { ...this.overrides };
   }
 }
 

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

@@ -5,7 +5,9 @@
 
 import type {
     GeminiImageInput,
+    GeminiImageGenerationResult,
     VideoGenerationInput,
+    VideoGenerationResult,
     VideoGenerationProgress,
 } from "../../domain/entities";
 import { geminiTextGenerationService } from "./gemini-text-generation.service";
@@ -20,13 +22,29 @@ export interface ExecutionOptions {
     onProgress?: (progress: number) => void;
 }
 
+export type GenerationInput = {
+    type?: "text" | "image" | "video";
+    generateImage?: boolean;
+    prompt?: string;
+    images?: GeminiImageInput[];
+    generationConfig?: unknown;
+    image?: string;
+    negativePrompt?: string;
+    aspect_ratio?: string;
+};
+
+export type GenerationResult =
+    | string
+    | GeminiImageGenerationResult
+    | VideoGenerationResult;
+
 export class GenerationExecutor {
     private contentBuilder = new ContentBuilder();
     private responseFormatter = new ResponseFormatter();
 
-    async executeGeneration<T>(
+    async executeGeneration<T = GenerationResult>(
         model: string,
-        input: Record<string, unknown>,
+        input: GenerationInput,
         options?: ExecutionOptions,
     ): Promise<T> {
         if (typeof __DEV__ !== "undefined" && __DEV__) {
@@ -43,14 +61,13 @@ export class GenerationExecutor {
         }
 
         if (isVideoGeneration) {
-            return this.executeVideoGeneration<T>(input, options);
+            return this.executeVideoGeneration(input, options) as T;
         }
 
         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 prompt = String(input.prompt ?? "");
+            const images = input.images;
+            return geminiImageGenerationService.generateImage(prompt, images) as T;
         }
 
         const contents = this.contentBuilder.buildContents(input);
@@ -73,21 +90,21 @@ export class GenerationExecutor {
     /**
      * Execute video generation using Veo API
      */
-    private async executeVideoGeneration<T>(
-        input: Record<string, unknown>,
+    private async executeVideoGeneration(
+        input: GenerationInput,
         options?: ExecutionOptions,
-    ): Promise<T> {
+    ): Promise<VideoGenerationResult> {
         if (typeof __DEV__ !== "undefined" && __DEV__) {
             // eslint-disable-next-line no-console
             console.log("[GenerationExecutor] executeVideoGeneration() called");
         }
 
         const videoInput: VideoGenerationInput = {
-            prompt: String(input.prompt || ""),
-            image: input.image as string | undefined,
-            negativePrompt: input.negativePrompt as string | undefined,
+            prompt: String(input.prompt ?? ""),
+            image: input.image,
+            negativePrompt: input.negativePrompt,
             options: {
-                aspectRatio: this.normalizeAspectRatio(input.aspect_ratio as string),
+                aspectRatio: this.normalizeAspectRatio(input.aspect_ratio),
             },
         };
 
@@ -109,10 +126,9 @@ export class GenerationExecutor {
         }
 
         return {
-            video: { url: result.videoUrl },
             videoUrl: result.videoUrl,
             metadata: result.metadata,
-        } as T;
+        };
     }
 
     /**

package/src/infrastructure/services/index.ts

@@ -15,6 +15,7 @@ export { geminiVideoGenerationService } from "./gemini-video-generation.service"
 export { providerInitializer } from "./provider-initializer";
 export { jobProcessor } from "./job-processor";
 export { generationExecutor } from "./generation-executor";
+export { featureModelSelector } from "./feature-model-selector";
 
 // Public provider API
 export {
@@ -26,6 +27,13 @@ export {
 export type { GeminiProviderConfig } from "./gemini-provider";
 export type { GeminiProviderConfig as AIProviderConfig } from "./provider-initializer";
 
+// Generation executor types
+export type {
+  GenerationInput,
+  GenerationResult,
+  ExecutionOptions,
+} from "./generation-executor";
+
 // Re-export types from generation-content for convenience
 export type {
   IAIProvider,

package/src/infrastructure/utils/error-mapper.util.ts

@@ -7,6 +7,7 @@ import {
   GeminiErrorType,
   type GeminiErrorInfo,
   type GeminiApiError,
+  GeminiError,
 } from "../../domain/entities";
 
 const ERROR_PATTERNS: Array<{
@@ -112,3 +113,11 @@ export function isGeminiErrorRetryable(error: unknown): boolean {
 export function categorizeGeminiError(error: unknown): GeminiErrorType {
   return mapGeminiError(error).type;
 }
+
+/**
+ * Create a GeminiError instance from an unknown error
+ */
+export function createGeminiError(error: unknown): GeminiError {
+  const errorInfo = mapGeminiError(error);
+  return GeminiError.fromError(error, errorInfo);
+}

package/src/infrastructure/utils/index.ts

@@ -6,6 +6,7 @@ export {
   mapGeminiError,
   isGeminiErrorRetryable,
   categorizeGeminiError,
+  createGeminiError,
 } from "./error-mapper.util";
 
 export {