@umituz/react-native-ai-gemini-provider 1.16.0 → 2.0.0

package/src/infrastructure/services/index.ts

@@ -1,5 +1,6 @@
 /**
  * Infrastructure Services
+ * Text-only Gemini services
  */
 
 // Core services (low-level SDK wrappers)
@@ -8,16 +9,12 @@ export { geminiRetryService } from "./gemini-retry.service";
 export { geminiTextGenerationService } from "./gemini-text-generation.service";
 export { geminiTextService } from "./gemini-text-generation.service";
 export { geminiStructuredTextService } from "./gemini-structured-text.service";
-export { geminiImageGenerationService } from "./gemini-image-generation.service";
-export { geminiImageEditService } from "./gemini-image-edit.service";
 export { geminiStreamingService } from "./gemini-streaming.service";
-export { geminiVideoGenerationService } from "./gemini-video-generation.service";
 
 // Modular services
 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 {
@@ -27,7 +24,6 @@ export {
 } from "./gemini-provider";
 
 export type { GeminiProviderConfig } from "./gemini-provider";
-export type { GeminiProviderConfig as AIProviderConfig } from "./provider-initializer";
 
 // Generation executor types
 export type {
@@ -38,12 +34,3 @@ export type {
 
 // Retry service types
 export type { RetryOptions } from "./gemini-retry.service";
-
-// Re-export types from generation-content/core for convenience
-export type {
-  IAIProvider,
-  JobSubmission,
-  JobStatus,
-  SubscribeOptions,
-  AIJobStatusType,
-} from "@umituz/react-native-ai-generation-content/core";

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

@@ -1,6 +1,6 @@
 /**
  * Job Processor
- * Handles async job processing
+ * Handles async job processing for text generation
  */
 
 import { JobManager } from "../job/JobManager";
@@ -10,53 +10,53 @@ import { generationExecutor } from "./generation-executor";
 declare const __DEV__: boolean;
 
 export class JobProcessor {
-    private jobManager = new JobManager();
-
-    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);
-        }
+  private jobManager = new JobManager();
+
+  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);
+      }
+    });
+
+    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);
     }
+  }
 
-    clear(): void {
-        this.jobManager.clear();
-    }
+  clear(): void {
+    this.jobManager.clear();
+  }
 
-    private async processJobAsync(requestId: string): Promise<void> {
-        const job = this.jobManager.getJob(requestId);
-        if (!job) return;
+  private async processJobAsync(requestId: string): Promise<void> {
+    const job = this.jobManager.getJob(requestId);
+    if (!job) return;
 
-        this.jobManager.updateJobStatus(requestId, "IN_PROGRESS");
+    this.jobManager.updateJobStatus(requestId, "IN_PROGRESS");
 
-        try {
-            const result = await generationExecutor.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);
-        }
+    try {
+      const prompt = String(job.input.prompt ?? "");
+      const result = await generationExecutor.executeTextGeneration(prompt, job.model);
+      this.jobManager.setJobResult(requestId, result);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.jobManager.setJobError(requestId, errorMessage);
     }
+  }
 }
 
 export const jobProcessor = new JobProcessor();

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

@@ -3,50 +3,36 @@
  * Handles initialization logic for Gemini Provider
  */
 
-import type { AIProviderConfig } from "@umituz/react-native-ai-generation-content/core";
 import type { GeminiConfig } from "../../domain/entities";
 import { geminiClientCoreService } from "./gemini-client-core.service";
 
 declare const __DEV__: boolean;
 
-export type GeminiProviderConfig = AIProviderConfig;
+export type GeminiProviderConfig = GeminiConfig;
 
 export class ProviderInitializer {
-    initialize(config: GeminiProviderConfig): void {
-        if (geminiClientCoreService.isInitialized()) {
-            if (typeof __DEV__ !== "undefined" && __DEV__) {
-                // eslint-disable-next-line no-console
-                console.log("[GeminiProvider] Already initialized, skipping");
-            }
-            return;
-        }
-
-        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);
+  initialize(config: GeminiProviderConfig): void {
+    if (geminiClientCoreService.isInitialized()) {
+      if (typeof __DEV__ !== "undefined" && __DEV__) {
+        console.log("[GeminiProvider] Already initialized, skipping");
+      }
+      return;
     }
 
-    isInitialized(): boolean {
-        return geminiClientCoreService.isInitialized();
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[GeminiProvider] Initializing...");
     }
 
-    reset(): void {
-        geminiClientCoreService.reset();
-    }
+    geminiClientCoreService.initialize(config);
+  }
+
+  isInitialized(): boolean {
+    return geminiClientCoreService.isInitialized();
+  }
+
+  reset(): void {
+    geminiClientCoreService.reset();
+  }
 }
 
 export const providerInitializer = new ProviderInitializer();

package/src/infrastructure/utils/index.ts

@@ -1,5 +1,6 @@
 /**
  * Infrastructure Utils
+ * Text-only utilities
  */
 
 export {
@@ -14,21 +15,11 @@ export {
   extractTextFromResponse,
 } from "./gemini-data-transformer.util";
 
-export {
-  prepareImageFromUri,
-  prepareImage,
-  isValidBase64,
-} from "./image-preparer.util";
-export type { PreparedImage } from "./image-preparer.util";
-
 export {
   isValidModel,
   validateModel,
   getSafeModel,
   isTextModel,
-  isImageModel,
-  isImageEditModel,
-  isVideoGenerationModel,
   getModelCategory,
   getAllValidModels,
 } from "./model-validation.util";
@@ -49,30 +40,3 @@ export {
   rateLimiter,
 } from "./rate-limiter.util";
 export type { RateLimiterOptions } from "./rate-limiter.util";
-
-// Input builders
-export {
-  buildSingleImageInput,
-  buildDualImageInput,
-  buildUpscaleInput,
-  buildPhotoRestoreInput,
-  buildFaceSwapInput,
-  buildAnimeSelfieInput,
-  buildRemoveBackgroundInput,
-  buildRemoveObjectInput,
-  buildReplaceBackgroundInput,
-  buildHDTouchUpInput,
-  buildVideoFromDualImagesInput,
-} from "./input-builders.util";
-
-export type {
-  UpscaleOptions,
-  PhotoRestoreOptions,
-  FaceSwapOptions,
-  AnimeSelfieOptions,
-  RemoveBackgroundOptions,
-  RemoveObjectOptions,
-  ReplaceBackgroundOptions,
-  VideoFromImageOptions,
-  VideoFromDualImageOptions,
-} from "./input-builders.util";

package/src/infrastructure/utils/model-validation.util.ts

@@ -1,6 +1,6 @@
 /**
  * Model Validation Utilities
- * Validates model IDs and configurations
+ * Validates model IDs for text generation
  */
 
 import { GEMINI_MODELS, DEFAULT_MODELS } from "../../domain/entities";
@@ -8,10 +8,10 @@ import { GEMINI_MODELS, DEFAULT_MODELS } from "../../domain/entities";
 declare const __DEV__: boolean;
 
 /**
- * Known valid model IDs
+ * Known valid model IDs (text models only)
  */
 const VALID_MODELS = new Set<string>(
-  Object.values(GEMINI_MODELS).flatMap((category) => Object.values(category)),
+  Object.values(GEMINI_MODELS.TEXT),
 );
 
 /**
@@ -36,7 +36,6 @@ export function validateModel(model: string): void {
   }
 
   if (typeof __DEV__ !== "undefined" && __DEV__) {
-    // eslint-disable-next-line no-console
     console.log("[ModelValidation] Model validated:", model);
   }
 }
@@ -51,7 +50,6 @@ export function getSafeModel(model: string | undefined, defaultType: keyof typeo
 
   if (!isValidModel(model)) {
     if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
       console.warn(`[ModelValidation] Invalid model "${model}", falling back to ${DEFAULT_MODELS[defaultType]}`);
     }
     return DEFAULT_MODELS[defaultType];
@@ -67,35 +65,11 @@ export function isTextModel(model: string): boolean {
   return Object.values(GEMINI_MODELS.TEXT).includes(model as (typeof GEMINI_MODELS.TEXT)[keyof typeof GEMINI_MODELS.TEXT]);
 }
 
-/**
- * Check if model is an image generation model
- */
-export function isImageModel(model: string): boolean {
-  return Object.values(GEMINI_MODELS.TEXT_TO_IMAGE).includes(model as (typeof GEMINI_MODELS.TEXT_TO_IMAGE)[keyof typeof GEMINI_MODELS.TEXT_TO_IMAGE]);
-}
-
-/**
- * Check if model is an image editing model
- */
-export function isImageEditModel(model: string): boolean {
-  return Object.values(GEMINI_MODELS.IMAGE_EDIT).includes(model as (typeof GEMINI_MODELS.IMAGE_EDIT)[keyof typeof GEMINI_MODELS.IMAGE_EDIT]);
-}
-
-/**
- * Check if model is a video generation model
- */
-export function isVideoGenerationModel(model: string): boolean {
-  return Object.values(GEMINI_MODELS.VIDEO_GENERATION).includes(model as (typeof GEMINI_MODELS.VIDEO_GENERATION)[keyof typeof GEMINI_MODELS.VIDEO_GENERATION]);
-}
-
 /**
  * Get model category
  */
 export function getModelCategory(model: string): string | null {
   if (isTextModel(model)) return "text";
-  if (isImageModel(model)) return "text-to-image";
-  if (isImageEditModel(model)) return "image-edit";
-  if (isVideoGenerationModel(model)) return "video-generation";
   return null;
 }
 

package/src/domain/constants/feature-models.constants.ts

@@ -1,70 +0,0 @@
-/**
- * Gemini Feature Models Catalog
- * Provider-specific model IDs for image and video processing features
- */
-
-import type {
-  ImageFeatureType,
-  VideoFeatureType,
-} from "@umituz/react-native-ai-generation-content/core";
-
-export interface FeatureModelConfig {
-  id: string;
-  feature: ImageFeatureType | VideoFeatureType;
-  description?: string;
-}
-
-/**
- * Gemini model IDs for IMAGE processing features
- * Using gemini-2.0-flash-exp for image editing capabilities
- */
-export const GEMINI_IMAGE_FEATURE_MODELS: Record<ImageFeatureType, string> = {
-  "upscale": "gemini-2.0-flash-exp",
-  "photo-restore": "gemini-2.0-flash-exp",
-  "face-swap": "gemini-2.0-flash-exp",
-  "anime-selfie": "gemini-2.0-flash-exp",
-  "remove-background": "gemini-2.0-flash-exp",
-  "remove-object": "gemini-2.0-flash-exp",
-  "hd-touch-up": "gemini-2.0-flash-exp",
-  "replace-background": "gemini-2.0-flash-exp",
-};
-
-/**
- * Gemini model IDs for VIDEO generation features
- * Using gemini-2.0-flash-exp for video generation capabilities
- */
-export const GEMINI_VIDEO_FEATURE_MODELS: Record<VideoFeatureType, string> = {
-  "image-to-video": "gemini-2.0-flash-exp",
-  "text-to-video": "gemini-2.0-flash-exp",
-};
-
-/**
- * Get Gemini model ID for an image feature
- */
-export function getGeminiImageFeatureModel(feature: ImageFeatureType): string {
-  return GEMINI_IMAGE_FEATURE_MODELS[feature];
-}
-
-/**
- * Get Gemini model ID for a video feature
- */
-export function getGeminiVideoFeatureModel(feature: VideoFeatureType): string {
-  return GEMINI_VIDEO_FEATURE_MODELS[feature];
-}
-
-/**
- * Get all feature model configs
- */
-export function getAllFeatureModels(): FeatureModelConfig[] {
-  const imageModels = Object.entries(GEMINI_IMAGE_FEATURE_MODELS).map(([feature, id]) => ({
-    id,
-    feature: feature as ImageFeatureType,
-  }));
-
-  const videoModels = Object.entries(GEMINI_VIDEO_FEATURE_MODELS).map(([feature, id]) => ({
-    id,
-    feature: feature as VideoFeatureType,
-  }));
-
-  return [...imageModels, ...videoModels];
-}

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

@@ -1,149 +0,0 @@
-/**
- * Video Generation Types
- * Type definitions for Google Veo video generation
- */
-
-/**
- * Video aspect ratio options
- */
-export type VideoAspectRatio = "9:16" | "16:9" | "1:1";
-
-/**
- * Video resolution options
- */
-export type VideoResolution = "720p" | "1080p" | "4K";
-
-/**
- * Video generation operation status
- */
-export type VideoOperationStatus =
-  | "queued"
-  | "processing"
-  | "completed"
-  | "failed";
-
-/**
- * Video generation configuration options
- */
-export interface VideoGenerationOptions {
-  numberOfVideos?: number;
-  aspectRatio?: VideoAspectRatio;
-  resolution?: VideoResolution;
-  duration?: number;
-}
-
-/**
- * Input for text-to-video generation
- */
-export interface TextToVideoInput {
-  prompt: string;
-  negativePrompt?: string;
-  options?: VideoGenerationOptions;
-}
-
-/**
- * Input for image-to-video generation
- */
-export interface ImageToVideoInput {
-  prompt: string;
-  image: string;
-  negativePrompt?: string;
-  options?: VideoGenerationOptions;
-}
-
-/**
- * Input for video generation (supports both text-to-video and image-to-video)
- */
-export interface VideoGenerationInput {
-  prompt: string;
-  image?: string;
-  negativePrompt?: string;
-  options?: VideoGenerationOptions;
-}
-
-/**
- * Progress information during video generation
- */
-export interface VideoGenerationProgress {
-  status: VideoOperationStatus;
-  progress: number;
-  estimatedTimeRemaining?: number;
-  message?: string;
-}
-
-/**
- * Video generation result metadata
- */
-export interface VideoGenerationMetadata {
-  duration: number;
-  resolution: string;
-  aspectRatio: string;
-  model: string;
-  operationName: string;
-}
-
-/**
- * Video generation result
- */
-export interface VideoGenerationResult {
-  videoUrl: string;
-  metadata: VideoGenerationMetadata;
-}
-
-/**
- * Video generation error types
- */
-export type VideoGenerationErrorType =
-  | "QUOTA_EXCEEDED"
-  | "POLICY_VIOLATION"
-  | "TIMEOUT"
-  | "NETWORK"
-  | "INVALID_INPUT"
-  | "OPERATION_FAILED";
-
-/**
- * Video generation error
- */
-export interface VideoGenerationError extends Error {
-  type: VideoGenerationErrorType;
-  statusCode?: number;
-  retryable: boolean;
-}
-
-/**
- * Generated video from Veo API
- */
-export interface VeoGeneratedVideo {
-  video: {
-    uri?: string;
-    url?: string;
-  };
-}
-
-/**
- * Operation response from Veo API
- */
-export interface VeoOperation {
-  name: string;
-  done: boolean;
-  metadata?: Record<string, unknown>;
-  response?: {
-    generatedVideos?: VeoGeneratedVideo[];
-    candidates?: Array<{
-      uri?: string;
-      [key: string]: unknown;
-    }>;
-    generateVideoResponse?: {
-      generatedSamples?: Array<{
-        video?: {
-          uri?: string;
-        };
-      }>;
-    };
-  };
-  error?: {
-    code: number;
-    message: string;
-    status: string;
-  };
-}

package/src/infrastructure/services/feature-input-builder.ts

@@ -1,89 +0,0 @@
-/**
- * Feature Input Builder
- * Builds Gemini API inputs for image and video features
- */
-
-import type {
-  ImageFeatureType,
-  VideoFeatureType,
-  ImageFeatureInputData,
-  VideoFeatureInputData,
-} from "@umituz/react-native-ai-generation-content/core";
-import {
-  buildUpscaleInput,
-  buildPhotoRestoreInput,
-  buildFaceSwapInput,
-  buildAnimeSelfieInput,
-  buildRemoveBackgroundInput,
-  buildRemoveObjectInput,
-  buildReplaceBackgroundInput,
-  buildHDTouchUpInput,
-  buildVideoFromDualImagesInput,
-} from "../utils/input-builders.util";
-
-class FeatureInputBuilder {
-  /**
-   * Build input for an IMAGE feature
-   */
-  buildImageFeatureInput(
-    feature: ImageFeatureType,
-    data: ImageFeatureInputData,
-  ): Record<string, unknown> {
-    const { imageBase64, targetImageBase64, prompt, options } = data;
-
-    switch (feature) {
-      case "upscale":
-        return buildUpscaleInput(imageBase64, options);
-      case "photo-restore":
-        return buildPhotoRestoreInput(imageBase64, options);
-      case "face-swap":
-        if (!targetImageBase64) {
-          throw new Error("Face swap requires target image");
-        }
-        return buildFaceSwapInput(imageBase64, targetImageBase64, options);
-      case "anime-selfie":
-        return buildAnimeSelfieInput(imageBase64, options);
-      case "remove-background":
-        return buildRemoveBackgroundInput(imageBase64, options);
-      case "remove-object":
-        return buildRemoveObjectInput(imageBase64, { prompt, ...options });
-      case "hd-touch-up":
-        return buildHDTouchUpInput(imageBase64, options);
-      case "replace-background":
-        if (!prompt) {
-          throw new Error("Replace background requires prompt");
-        }
-        return buildReplaceBackgroundInput(imageBase64, { prompt });
-      default:
-        throw new Error(`Unknown image feature: ${String(feature)}`);
-    }
-  }
-
-  /**
-   * Build input for a VIDEO feature
-   */
-  buildVideoFeatureInput(
-    feature: VideoFeatureType,
-    data: VideoFeatureInputData,
-  ): Record<string, unknown> {
-    const { sourceImageBase64, targetImageBase64, prompt, options } = data;
-
-    switch (feature) {
-      case "image-to-video":
-        return buildVideoFromDualImagesInput(sourceImageBase64, {
-          target_image: targetImageBase64,
-          motion_prompt: prompt,
-          ...options,
-        });
-      case "text-to-video":
-        return buildVideoFromDualImagesInput(sourceImageBase64 || "", {
-          motion_prompt: prompt,
-          ...options,
-        });
-      default:
-        throw new Error(`Unknown video feature: ${String(feature)}`);
-    }
-  }
-}
-
-export const featureInputBuilder = new FeatureInputBuilder();