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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@umituz/react-native-ai-gemini-provider",
-  "version": "1.16.0",
-  "description": "Google Gemini AI provider for React Native applications",
+  "version": "2.0.0",
+  "description": "Google Gemini AI text generation provider for React Native applications",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
   "scripts": {
@@ -19,11 +19,8 @@
     "ai",
     "gemini",
     "google",
-    "generation",
-    "llm",
-    "image-generation",
-    "video-generation",
-    "veo"
+    "text-generation",
+    "llm"
   ],
   "author": "umituz",
   "license": "MIT",
@@ -33,7 +30,6 @@
   },
   "peerDependencies": {
     "@google/generative-ai": ">=0.21.0",
-    "@umituz/react-native-ai-generation-content": ">=1.16.0",
     "react": ">=18.2.0",
     "react-native": ">=0.74.0"
   },
@@ -50,7 +46,6 @@
     "@types/react": "~19.1.10",
     "@typescript-eslint/eslint-plugin": "^7.0.0",
     "@typescript-eslint/parser": "^7.0.0",
-    "@umituz/react-native-ai-generation-content": "^1.58.3",
     "@umituz/react-native-design-system": "^2.8.7",
     "eslint": "^8.57.0",
     "expo-apple-authentication": "^8.0.8",

package/src/domain/constants/index.ts

@@ -2,14 +2,4 @@
  * Gemini Domain Constants
  */
 
-export {
-  GEMINI_IMAGE_FEATURE_MODELS,
-  GEMINI_VIDEO_FEATURE_MODELS,
-  getGeminiImageFeatureModel,
-  getGeminiVideoFeatureModel,
-  getAllFeatureModels,
-} from "./feature-models.constants";
-
-export type {
-  FeatureModelConfig,
-} from "./feature-models.constants";
+// No feature models needed for text-only provider

package/src/domain/entities/index.ts

@@ -5,4 +5,3 @@
 export * from "./gemini.types";
 export * from "./error.types";
 export * from "./models";
-export * from "./video.types";

package/src/index.ts

@@ -1,6 +1,7 @@
 /**
  * @umituz/react-native-ai-gemini-provider
  * Google Gemini AI provider for React Native applications
+ * Text generation only - for image/video use FAL Provider
  */
 
 // Domain Types
@@ -20,17 +21,7 @@ export type {
   GeminiPromptFeedback,
   GeminiUsageMetadata,
   GeminiModel,
-  GeminiImageGenerationResult,
   GeminiImageInput,
-  VideoGenerationInput,
-  VideoGenerationResult,
-  VideoGenerationProgress,
-  VideoGenerationOptions,
-  VideoGenerationError,
-  VideoAspectRatio,
-  VideoResolution,
-  VideoOperationStatus,
-  VeoOperation,
   GeminiErrorInfo,
   GeminiApiError,
   ResponseModality,
@@ -38,17 +29,6 @@ export type {
 
 export { GeminiErrorType, GeminiError, GEMINI_MODELS, DEFAULT_MODELS, MODEL_PRICING, RESPONSE_MODALITIES } from "./domain/entities";
 
-// Feature Models
-export {
-  GEMINI_IMAGE_FEATURE_MODELS,
-  GEMINI_VIDEO_FEATURE_MODELS,
-  getGeminiImageFeatureModel,
-  getGeminiVideoFeatureModel,
-  getAllFeatureModels,
-} from "./domain/constants";
-
-export type { FeatureModelConfig } from "./domain/constants";
-
 // Services
 export {
   geminiClientCoreService,
@@ -56,23 +36,14 @@ export {
   geminiTextGenerationService,
   geminiTextService,
   geminiStructuredTextService,
-  geminiImageGenerationService,
-  geminiImageEditService,
   geminiStreamingService,
-  geminiVideoGenerationService,
   geminiProviderService,
   createGeminiProvider,
-  featureModelSelector,
+  GeminiProvider,
 } from "./infrastructure/services";
 
 export type {
-  AIProviderConfig,
   GeminiProviderConfig,
-  IAIProvider,
-  JobSubmission,
-  JobStatus,
-  SubscribeOptions,
-  AIJobStatusType,
   GenerationInput,
   GenerationResult,
   ExecutionOptions,
@@ -89,9 +60,6 @@ export {
   validateModel,
   getSafeModel,
   isTextModel,
-  isImageModel,
-  isImageEditModel,
-  isVideoGenerationModel,
   getModelCategory,
   getAllValidModels,
   measureAsync,
@@ -101,31 +69,11 @@ export {
   PerformanceTimer,
   PerformanceTracker,
   performanceTracker,
-  buildSingleImageInput,
-  buildDualImageInput,
-  buildUpscaleInput,
-  buildPhotoRestoreInput,
-  buildFaceSwapInput,
-  buildAnimeSelfieInput,
-  buildRemoveBackgroundInput,
-  buildRemoveObjectInput,
-  buildReplaceBackgroundInput,
-  buildHDTouchUpInput,
-  buildVideoFromDualImagesInput,
   RateLimiter,
   rateLimiter,
 } from "./infrastructure/utils";
 
 export type {
-  PreparedImage,
-  UpscaleOptions,
-  PhotoRestoreOptions,
-  FaceSwapOptions,
-  AnimeSelfieOptions,
-  RemoveBackgroundOptions,
-  RemoveObjectOptions,
-  ReplaceBackgroundOptions,
-  VideoFromImageOptions,
   PerformanceMetrics,
   RateLimiterOptions,
 } from "./infrastructure/utils";

package/src/infrastructure/job/JobManager.ts

@@ -3,15 +3,19 @@
  * Handles async job submission, tracking, and status management
  */
 
-import type {
-  JobSubmission,
-  JobStatus,
-  AIJobStatusType,
-} from "@umituz/react-native-ai-generation-content/core";
+declare const __DEV__: boolean;
 
-export type { JobSubmission, JobStatus };
+export type AIJobStatusType = "IN_QUEUE" | "IN_PROGRESS" | "COMPLETED" | "FAILED";
 
-declare const __DEV__: boolean;
+export interface JobSubmission {
+  requestId: string;
+  statusUrl?: string;
+  responseUrl?: string;
+}
+
+export interface JobStatus {
+  status: AIJobStatusType;
+}
 
 interface PendingJob {
   model: string;
@@ -35,7 +39,6 @@ export class JobManager {
     });
 
     if (typeof __DEV__ !== "undefined" && __DEV__) {
-      // eslint-disable-next-line no-console
       console.log("[JobManager] Job submitted:", { requestId, model });
     }
 

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

@@ -1,66 +1,23 @@
 /**
  * Gemini Provider
- * Main AI provider implementation for Google Gemini
- * Implements IAIProvider for unified orchestration
+ * Text-only AI provider for Google Gemini
  */
 
-import type {
-  IAIProvider,
-  AIProviderConfig,
-  JobSubmission,
-  JobStatus,
-  SubscribeOptions,
-  ImageFeatureType,
-  VideoFeatureType,
-  ImageFeatureInputData,
-  VideoFeatureInputData,
-  ProviderCapabilities,
-  RunOptions,
-} from "@umituz/react-native-ai-generation-content/core";
-import type {
-  GeminiImageInput,
-  GeminiImageGenerationResult,
-} from "../../domain/entities";
-import { geminiImageGenerationService } from "./gemini-image-generation.service";
-import { geminiImageEditService } from "./gemini-image-edit.service";
-import {
-  providerInitializer,
-  type GeminiProviderConfig,
-} from "./provider-initializer";
-import { jobProcessor } from "./job-processor";
+import type { GeminiConfig, GeminiImageInput } from "../../domain/entities";
+import { providerInitializer } from "./provider-initializer";
 import { generationExecutor } from "./generation-executor";
-import { featureInputBuilder } from "./feature-input-builder";
-import { featureModelSelector } from "./feature-model-selector";
 
-export type { GeminiProviderConfig };
+export type GeminiProviderConfig = GeminiConfig;
 
 /**
- * Gemini provider capabilities
+ * Gemini Provider - Text Generation Only
+ * For image/video generation, use FAL Provider instead
  */
-const GEMINI_CAPABILITIES: ProviderCapabilities = {
-  imageFeatures: [
-    "upscale",
-    "photo-restore",
-    "face-swap",
-    "anime-selfie",
-    "remove-background",
-    "remove-object",
-    "hd-touch-up",
-    "replace-background",
-  ] as const,
-  videoFeatures: ["image-to-video", "text-to-video"] as const,
-  textToImage: true,
-  textToVideo: true,
-  imageToVideo: true,
-  textToVoice: false,
-  textToText: true,
-};
-
-export class GeminiProvider implements IAIProvider {
+export class GeminiProvider {
   readonly providerId = "gemini";
   readonly providerName = "Google Gemini";
 
-  initialize(config: AIProviderConfig): void {
+  initialize(config: GeminiProviderConfig): void {
     providerInitializer.initialize(config);
   }
 
@@ -68,121 +25,43 @@ export class GeminiProvider implements IAIProvider {
     return providerInitializer.isInitialized();
   }
 
-  getCapabilities(): ProviderCapabilities {
-    return GEMINI_CAPABILITIES;
-  }
-
-  isFeatureSupported(feature: ImageFeatureType | VideoFeatureType): boolean {
-    const capabilities = this.getCapabilities();
-    return (
-      capabilities.imageFeatures.includes(feature as ImageFeatureType) ||
-      capabilities.videoFeatures.includes(feature as VideoFeatureType)
-    );
-  }
-
-  submitJob(
-    model: string,
-    input: Record<string, unknown>,
-  ): Promise<JobSubmission> {
-    return jobProcessor.submitJob(model, input);
-  }
-
-  getJobStatus(_model: string, requestId: string): Promise<JobStatus> {
-    return jobProcessor.getJobStatus(_model, requestId);
-  }
-
-  getJobResult<T = unknown>(_model: string, requestId: string): Promise<T> {
-    return jobProcessor.getJobResult<T>(_model, requestId);
-  }
-
-  async subscribe<T = unknown>(
-    model: string,
-    input: Record<string, unknown>,
-    options?: SubscribeOptions<T>,
-  ): Promise<T> {
-    options?.onQueueUpdate?.({ status: "IN_QUEUE" });
-
-    const result = await generationExecutor.executeGeneration<T>(model, input, {
-      onProgress: (progress: number) => {
-        options?.onProgress?.({ progress, status: "IN_PROGRESS" });
-      },
-    });
-
-    options?.onProgress?.({ progress: 100, status: "COMPLETED" });
-    options?.onQueueUpdate?.({ status: "COMPLETED" });
-    options?.onResult?.(result);
-
-    return result;
-  }
-
-  async run<T = unknown>(
-    model: string,
-    input: Record<string, unknown>,
-    options?: RunOptions,
-  ): Promise<T> {
-    return generationExecutor.executeGeneration<T>(model, input, {
-      onProgress: (progress: number) => {
-        options?.onProgress?.({ progress, status: "IN_PROGRESS" });
-      },
-    });
-  }
-
-  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 }> {
-    return generationExecutor.generateWithImages(model, prompt, images);
-  }
-
   reset(): void {
     providerInitializer.reset();
-    jobProcessor.clear();
-  }
-
-  /**
-   * Get model ID for an IMAGE feature
-   */
-  getImageFeatureModel(feature: ImageFeatureType): string {
-    return featureModelSelector.getImageFeatureModel(feature);
   }
 
   /**
-   * Build input for an IMAGE feature
+   * Generate text from prompt
    */
-  buildImageFeatureInput(
-    feature: ImageFeatureType,
-    data: ImageFeatureInputData,
-  ): Record<string, unknown> {
-    return featureInputBuilder.buildImageFeatureInput(feature, data);
+  async generateText(prompt: string, model?: string): Promise<string> {
+    return generationExecutor.executeTextGeneration(prompt, model);
   }
 
   /**
-   * Get model ID for a VIDEO feature
+   * Generate text with images (multimodal)
+   * Useful for "describe this image" scenarios
    */
-  getVideoFeatureModel(feature: VideoFeatureType): string {
-    return featureModelSelector.getVideoFeatureModel(feature);
+  async generateTextWithImages(
+    prompt: string,
+    images: GeminiImageInput[],
+    model?: string,
+  ): Promise<string> {
+    const result = await generationExecutor.generateWithImages(
+      model ?? "gemini-2.0-flash",
+      prompt,
+      images,
+    );
+    return result.text;
   }
 
   /**
-   * Build input for a VIDEO feature
+   * Generate structured JSON response
    */
-  buildVideoFeatureInput(
-    feature: VideoFeatureType,
-    data: VideoFeatureInputData,
-  ): Record<string, unknown> {
-    return featureInputBuilder.buildVideoFeatureInput(feature, data);
+  async generateStructuredText<T>(
+    prompt: string,
+    schema: Record<string, unknown>,
+    model?: string,
+  ): Promise<T> {
+    return generationExecutor.executeStructuredGeneration<T>(prompt, schema, model);
   }
 }
 

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

@@ -1,162 +1,101 @@
 /**
  * Generation Executor
- * Handles execution of different generation types
+ * Handles execution of text generation
  */
 
-import type {
-    GeminiImageInput,
-    GeminiImageGenerationResult,
-    VideoGenerationInput,
-    VideoGenerationResult,
-    VideoGenerationProgress,
-} from "../../domain/entities";
+import type { GeminiImageInput } from "../../domain/entities";
 import { geminiTextGenerationService } from "./gemini-text-generation.service";
-import { geminiImageGenerationService } from "./gemini-image-generation.service";
-import { geminiVideoGenerationService } from "./gemini-video-generation.service";
-import { ContentBuilder } from "../content/ContentBuilder";
-import { ResponseFormatter } from "../response/ResponseFormatter";
+import { geminiStructuredTextService } from "./gemini-structured-text.service";
 
 declare const __DEV__: boolean;
 
 export interface ExecutionOptions {
-    onProgress?: (progress: number) => void;
+  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 interface GenerationInput {
+  prompt?: string;
+  images?: GeminiImageInput[];
+  generationConfig?: unknown;
+}
+
+export type GenerationResult = string;
 
 export class GenerationExecutor {
-    private contentBuilder = new ContentBuilder();
-    private responseFormatter = new ResponseFormatter();
-
-    async executeGeneration<T = GenerationResult>(
-        model: string,
-        input: GenerationInput,
-        options?: ExecutionOptions,
-    ): Promise<T> {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-            // eslint-disable-next-line no-console
-            console.log("[GenerationExecutor] executeGeneration() called", { model, inputType: input.type });
-        }
-
-        const isImageGeneration = input.generateImage === true || input.type === "image";
-        const isVideoGeneration = this.isVideoModel(model) || input.type === "video";
-
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-            // eslint-disable-next-line no-console
-            console.log("[GenerationExecutor] Generation type:", { isImageGeneration, isVideoGeneration });
-        }
-
-        if (isVideoGeneration) {
-            return this.executeVideoGeneration(input, options) as T;
-        }
-
-        if (isImageGeneration) {
-            const prompt = String(input.prompt ?? "");
-            const images = input.images;
-            return geminiImageGenerationService.generateImage(prompt, images) 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);
+  /**
+   * Execute text generation
+   */
+  async executeTextGeneration(prompt: string, model?: string): Promise<string> {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[GenerationExecutor] executeTextGeneration() called", { model });
     }
 
-    /**
-     * Check if model is a video generation model (Veo)
-     */
-    private isVideoModel(model: string): boolean {
-        return model.toLowerCase().includes("veo");
+    const response = await geminiTextGenerationService.generateContent(
+      model ?? "gemini-2.0-flash",
+      [{ parts: [{ text: prompt }], role: "user" }],
+    );
+
+    return this.extractTextFromResponse(response);
+  }
+
+  /**
+   * Execute structured text generation (JSON output)
+   */
+  async executeStructuredGeneration<T>(
+    prompt: string,
+    schema: Record<string, unknown>,
+    model?: string,
+  ): Promise<T> {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log("[GenerationExecutor] executeStructuredGeneration() called", { model });
     }
 
-    /**
-     * Execute video generation using Veo API
-     */
-    private async executeVideoGeneration(
-        input: GenerationInput,
-        options?: ExecutionOptions,
-    ): 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,
-            negativePrompt: input.negativePrompt,
-            options: {
-                aspectRatio: this.normalizeAspectRatio(input.aspect_ratio),
-            },
+    return geminiStructuredTextService.generateStructuredContent<T>(
+      model ?? "gemini-2.0-flash",
+      prompt,
+      schema,
+    );
+  }
+
+  /**
+   * 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
+   */
+  private extractTextFromResponse(response: unknown): string {
+    const resp = response as {
+      candidates?: Array<{
+        content: {
+          parts: Array<{ text?: string }>;
         };
-
-        const onProgress = options?.onProgress
-            ? (p: VideoGenerationProgress) => {
-                if (typeof __DEV__ !== "undefined" && __DEV__) {
-                    // eslint-disable-next-line no-console
-                    console.log("[GenerationExecutor] Progress update:", p.progress);
-                }
-                options.onProgress?.(p.progress);
-            }
-            : undefined;
-
-        const result = await geminiVideoGenerationService.generateVideo(videoInput, onProgress);
-
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-            // eslint-disable-next-line no-console
-            console.log("[GenerationExecutor] Video generation completed");
-        }
-
-        return {
-            videoUrl: result.videoUrl,
-            metadata: result.metadata,
-        };
-    }
-
-    /**
-     * Normalize aspect ratio format (e.g., "16:9" stays, others default)
-     */
-    private normalizeAspectRatio(ratio: string | undefined): "16:9" | "9:16" | "1:1" {
-        if (ratio === "9:16" || ratio === "1:1") return ratio;
-        return "16:9";
-    }
-
-    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 };
-    }
+      }>;
+    };
+
+    return resp.candidates?.[0]?.content.parts
+      .filter((p): p is { text: string } => "text" in p && typeof p.text === "string")
+      .map((p) => p.text)
+      .join("") || "";
+  }
 }
 
 export const generationExecutor = new GenerationExecutor();