@umituz/react-native-ai-gemini-provider 1.14.36 → 1.14.38

package/package.json

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

package/src/domain/entities/models.ts

@@ -1,17 +1,24 @@
 /**
  * Gemini Model Constants
  * Centralized model configuration for all AI operations
+ * Updated: 2026-01 with latest pricing and free tier info
  */
 
 /**
  * Available Gemini models
- * Updated: 2025-12 with latest stable and preview 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
+  // Text generation models (ordered by cost: cheapest first)
   TEXT: {
-    FLASH: "gemini-2.5-flash",
+    /** 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",
   },
 
@@ -45,13 +52,24 @@ export const GEMINI_MODELS = {
 /**
  * Default models for each operation type
  * Optimized for cost-effectiveness while maintaining quality
+ * Using Flash-Lite as default for best free tier (1000 req/day)
  */
 export const DEFAULT_MODELS = {
-  TEXT: GEMINI_MODELS.TEXT.FLASH_LITE, // Most cost-effective for text
+  /** 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, // Uses gemini-2.5-flash-image (free tier)
+  IMAGE_EDIT: GEMINI_MODELS.IMAGE_EDIT.DEFAULT,
   VIDEO: GEMINI_MODELS.VIDEO.FLASH,
-  VIDEO_GENERATION: GEMINI_MODELS.VIDEO_GENERATION.DEFAULT, // veo-3.1-generate-preview
+  VIDEO_GENERATION: GEMINI_MODELS.VIDEO_GENERATION.DEFAULT,
+} as const;
+
+/**
+ * Model pricing information (per 1M tokens)
+ */
+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;
 
 /**

package/src/index.ts

@@ -36,7 +36,7 @@ export type {
   ResponseModality,
 } from "./domain/entities";
 
-export { GeminiErrorType, GeminiError, GEMINI_MODELS, DEFAULT_MODELS, RESPONSE_MODALITIES } from "./domain/entities";
+export { GeminiErrorType, GeminiError, GEMINI_MODELS, DEFAULT_MODELS, MODEL_PRICING, RESPONSE_MODALITIES } from "./domain/entities";
 
 // Feature Models
 export {
@@ -54,6 +54,7 @@ export {
   geminiClientCoreService,
   geminiRetryService,
   geminiTextGenerationService,
+  geminiStructuredTextService,
   geminiImageGenerationService,
   geminiImageEditService,
   geminiStreamingService,

package/src/infrastructure/services/index.ts

@@ -6,6 +6,7 @@
 export { geminiClientCoreService } from "./gemini-client-core.service";
 export { geminiRetryService } from "./gemini-retry.service";
 export { geminiTextGenerationService } 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";

package/src/presentation/hooks/use-gemini.ts

@@ -1,34 +1,52 @@
 /**
  * useGemini Hook
  * React hook for Gemini AI generation
+ * Supports text, structured JSON, and multimodal generation
  */
 
 import { useState, useCallback, useRef } from "react";
 import type { GeminiGenerationConfig } from "../../domain/entities";
+import { DEFAULT_MODELS } from "../../domain/entities";
 import { geminiTextGenerationService } from "../../infrastructure/services";
+import { geminiStructuredTextService } from "../../infrastructure/services";
 
 export interface UseGeminiOptions {
+  /** Model to use (default: gemini-2.5-flash-lite) */
   model?: string;
+  /** Generation configuration */
   generationConfig?: GeminiGenerationConfig;
+  /** Called on successful generation */
   onSuccess?: (result: string) => void;
+  /** Called on error */
   onError?: (error: string) => void;
 }
 
 export interface UseGeminiReturn {
+  /** Generate text from prompt */
   generate: (prompt: string) => Promise<void>;
+  /** Generate text with image input */
   generateWithImage: (
     prompt: string,
     imageBase64: string,
     mimeType: string,
   ) => Promise<void>;
+  /** Generate structured JSON response */
+  generateJSON: <T>(prompt: string, schema?: Record<string, unknown>) => Promise<T | null>;
+  /** Current result */
   result: string | null;
+  /** JSON result (when using generateJSON) */
+  jsonResult: unknown | null;
+  /** Loading state */
   isGenerating: boolean;
+  /** Error message */
   error: string | null;
+  /** Reset state */
   reset: () => void;
 }
 
 export function useGemini(options: UseGeminiOptions = {}): UseGeminiReturn {
   const [result, setResult] = useState<string | null>(null);
+  const [jsonResult, setJsonResult] = useState<unknown | null>(null);
   const [isGenerating, setIsGenerating] = useState(false);
   const [error, setError] = useState<string | null>(null);
 
@@ -40,9 +58,10 @@ export function useGemini(options: UseGeminiOptions = {}): UseGeminiReturn {
       setIsGenerating(true);
       setError(null);
       setResult(null);
+      setJsonResult(null);
 
       try {
-        const model = options.model ?? "gemini-1.5-flash";
+        const model = options.model ?? DEFAULT_MODELS.TEXT;
         const text = await geminiTextGenerationService.generateText(
           model,
           prompt,
@@ -69,15 +88,79 @@ export function useGemini(options: UseGeminiOptions = {}): UseGeminiReturn {
     [options],
   );
 
+  const generateJSON = useCallback(
+    async <T>(prompt: string, schema?: Record<string, unknown>): Promise<T | null> => {
+      abortRef.current = false;
+      setIsGenerating(true);
+      setError(null);
+      setResult(null);
+      setJsonResult(null);
+
+      try {
+        const model = options.model ?? DEFAULT_MODELS.TEXT;
+
+        let parsed: T;
+
+        if (schema) {
+          // Use structured text service with schema
+          parsed = await geminiStructuredTextService.generateStructuredText<T>(
+            model,
+            prompt,
+            schema,
+            options.generationConfig,
+          );
+        } else {
+          // Generate text and parse JSON manually
+          const text = await geminiTextGenerationService.generateText(
+            model,
+            prompt,
+            {
+              ...options.generationConfig,
+              responseMimeType: "application/json",
+            },
+          );
+
+          // Clean and parse JSON
+          const cleanedText = text
+            .replace(/```json\n?/g, "")
+            .replace(/```\n?/g, "")
+            .trim();
+          parsed = JSON.parse(cleanedText) as T;
+        }
+
+        if (abortRef.current) return null;
+
+        setJsonResult(parsed);
+        setResult(JSON.stringify(parsed, null, 2));
+        options.onSuccess?.(JSON.stringify(parsed));
+        return parsed;
+      } catch (err) {
+        if (abortRef.current) return null;
+
+        const errorMessage =
+          err instanceof Error ? err.message : "JSON generation failed";
+        setError(errorMessage);
+        options.onError?.(errorMessage);
+        return null;
+      } finally {
+        if (!abortRef.current) {
+          setIsGenerating(false);
+        }
+      }
+    },
+    [options],
+  );
+
   const generateWithImage = useCallback(
     async (prompt: string, imageBase64: string, mimeType: string) => {
       abortRef.current = false;
       setIsGenerating(true);
       setError(null);
       setResult(null);
+      setJsonResult(null);
 
       try {
-        const model = options.model ?? "gemini-1.5-flash";
+        const model = options.model ?? DEFAULT_MODELS.TEXT;
         const response = await geminiTextGenerationService.generateWithImages(
           model,
           prompt,
@@ -115,6 +198,7 @@ export function useGemini(options: UseGeminiOptions = {}): UseGeminiReturn {
   const reset = useCallback(() => {
     abortRef.current = true;
     setResult(null);
+    setJsonResult(null);
     setIsGenerating(false);
     setError(null);
   }, []);
@@ -122,7 +206,9 @@ export function useGemini(options: UseGeminiOptions = {}): UseGeminiReturn {
   return {
     generate,
     generateWithImage,
+    generateJSON,
     result,
+    jsonResult,
     isGenerating,
     error,
     reset,