@umituz/react-native-ai-gemini-provider 2.1.12 → 3.0.0

package/package.json

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

package/src/index.ts

@@ -27,13 +27,12 @@ export {
   DEFAULT_MODELS
 } from "./domain/entities";
 
-// Main Service
-export {
-  geminiProviderService,
-  GeminiProvider,
-} from "./infrastructure/services";
-
-export type { GeminiProviderConfig } from "./infrastructure/services";
+// Services
+export { geminiClient } from "./infrastructure/services/GeminiClient";
+export { textGeneration } from "./infrastructure/services/TextGeneration";
+export { structuredText } from "./infrastructure/services/StructuredText";
+export { streaming } from "./infrastructure/services/Streaming";
+export { geminiProvider, GeminiProvider } from "./infrastructure/services/GeminiProvider";
 
 // React Hook
 export { useGemini } from "./presentation/hooks";

package/src/infrastructure/services/{base-gemini.service.ts → BaseService.ts}

@@ -1,17 +1,9 @@
-/**
- * Base Gemini Service
- * Common functionality for all Gemini services to eliminate code duplication
- */
-
-import { geminiClientCoreService } from "./gemini-client-core.service";
+import { geminiClient } from "./GeminiClient";
 import { toSdkContent } from "../utils/content-mapper.util";
 import { createGeminiError } from "../utils/error-mapper.util";
 import type { GeminiContent, GeminiGenerationConfig } from "../../domain/entities";
 import type { GenerativeModel } from "@google/generative-ai";
 
-/**
- * Base request options structure
- */
 export interface BaseRequestOptions {
   model: string;
   contents: GeminiContent[];
@@ -19,64 +11,41 @@ export interface BaseRequestOptions {
   signal?: AbortSignal;
 }
 
-/**
- * Abstract base service with common patterns
- */
 export abstract class BaseGeminiService {
-  /**
-   * Validate and prepare request
-   * Eliminates duplicate validation and abort checks
-   */
   protected validateAndPrepare(options: BaseRequestOptions): {
     genModel: GenerativeModel;
     sdkContents: Array<{ role: string; parts: Array<{ text: string }> }>;
   } {
-    // Validate contents
     if (!options.contents || options.contents.length === 0) {
       throw new Error("Contents array cannot be empty");
     }
 
-    // Check for early abort
     if (options.signal?.aborted) {
       throw new Error("Request was aborted");
     }
 
-    const genModel = geminiClientCoreService.getModel(options.model);
+    const genModel = geminiClient.getModel(options.model);
     const sdkContents = toSdkContent(options.contents);
 
     return { genModel, sdkContents };
   }
 
-  /**
-   * Handle errors uniformly across all services
-   * Eliminates duplicate error handling logic
-   */
   protected handleError(error: unknown, abortMessage: string): never {
-    // Re-throw as GeminiError if it's already an API error
     if (error instanceof Error && error.name === "GeminiError") {
       throw error;
     }
 
-    // Check for abort error
     if (error instanceof Error && error.name === "AbortError") {
       throw new Error(abortMessage);
     }
 
-    // Wrap other errors
     throw createGeminiError(error);
   }
 
-  /**
-   * Create typed request options for SDK
-   * Type-safe request creation
-   */
   protected createRequestOptions(
     sdkContents: Array<{ role: string; parts: Array<{ text: string }> }>,
     generationConfig?: GeminiGenerationConfig
   ) {
-    return {
-      contents: sdkContents,
-      generationConfig,
-    };
+    return { contents: sdkContents, generationConfig };
   }
 }

package/src/infrastructure/services/{gemini-client-core.service.ts → GeminiClient.ts}

@@ -1,29 +1,22 @@
 import { GoogleGenerativeAI, type GenerativeModel } from "@google/generative-ai";
 import { DEFAULT_MODELS } from "../../domain/entities";
 import type { GeminiConfig } from "../../domain/entities";
-import { validateModelName, validateApiKey } from "../utils/validation.util";
 
 const DEFAULT_CONFIG: Partial<GeminiConfig> = {
   textModel: DEFAULT_MODELS.TEXT,
 };
 
-class GeminiClientCoreService {
+class GeminiClient {
   private client: GoogleGenerativeAI | null = null;
   private config: GeminiConfig | null = null;
   private initialized = false;
 
-  /**
-   * Initialize the Gemini client with configuration
-   *
-   * @throws {Error} If already initialized or API key is invalid
-   */
   initialize(config: GeminiConfig): void {
-    if (this.initialized) {
-      throw new Error("Gemini client already initialized. Call reset() before re-initializing with new config.");
-    }
+    if (this.initialized) return;
 
-    // Validate API key
-    validateApiKey(config.apiKey);
+    if (!config.apiKey || config.apiKey.trim().length < 10) {
+      throw new Error("API key is required and must be at least 10 characters");
+    }
 
     this.client = new GoogleGenerativeAI(config.apiKey);
     this.config = { ...DEFAULT_CONFIG, ...config };
@@ -42,24 +35,16 @@ class GeminiClientCoreService {
     return this.client;
   }
 
-  validateInitialization(): void {
+  getModel(modelName?: string): GenerativeModel {
     if (!this.client || !this.initialized) {
       throw new Error("Gemini client not initialized. Call initialize() first.");
     }
-  }
-
-
-  getModel(modelName?: string): GenerativeModel {
-    this.validateInitialization();
-
-    if (!this.client) {
-      throw new Error("Gemini client not available");
-    }
 
     const effectiveModel = modelName || this.config?.textModel || DEFAULT_MODELS.TEXT;
 
-    // Validate model name format
-    validateModelName(effectiveModel);
+    if (!effectiveModel.startsWith("gemini-")) {
+      throw new Error('Model name must start with "gemini-"');
+    }
 
     return this.client.getGenerativeModel({ model: effectiveModel });
   }
@@ -71,4 +56,4 @@ class GeminiClientCoreService {
   }
 }
 
-export const geminiClientCoreService = new GeminiClientCoreService();
+export const geminiClient = new GeminiClient();

package/src/infrastructure/services/GeminiProvider.ts

@@ -0,0 +1,38 @@
+import type { GeminiConfig } from "../../domain/entities";
+import { geminiClient } from "./GeminiClient";
+import { structuredText } from "./StructuredText";
+
+export class GeminiProvider {
+  readonly providerId = "gemini";
+  readonly providerName = "Google Gemini";
+
+  initialize(config: GeminiConfig): void {
+    geminiClient.initialize(config);
+  }
+
+  isInitialized(): boolean {
+    return geminiClient.isInitialized();
+  }
+
+  reset(): void {
+    geminiClient.reset();
+  }
+
+  async generateStructuredText<T>(
+    prompt: string,
+    schema: Record<string, unknown>,
+    model: string,
+  ): Promise<T> {
+    if (!prompt || prompt.trim().length < 3) {
+      throw new Error("Prompt must be at least 3 characters");
+    }
+
+    if (!this.isInitialized()) {
+      throw new Error("Provider not initialized. Call initialize() first.");
+    }
+
+    return structuredText.generateStructuredText<T>(model, prompt, schema);
+  }
+}
+
+export const geminiProvider = new GeminiProvider();

package/src/infrastructure/services/{gemini-streaming.service.ts → Streaming.ts}

@@ -1,4 +1,4 @@
-import { BaseGeminiService } from "./base-gemini.service";
+import { BaseGeminiService } from "./BaseService";
 import { telemetryHooks } from "../telemetry";
 import { processStream } from "../utils/stream-processor.util";
 import type {
@@ -6,22 +6,7 @@ import type {
   GeminiGenerationConfig,
 } from "../../domain/entities";
 
-class GeminiStreamingService extends BaseGeminiService {
-  /**
-   * Stream content generation
-   *
-   * @throws {GeminiError} For API-specific errors
-   * @throws {Error} For validation or network errors
-   *
-   * @example
-   * ```ts
-   * const fullText = await streamContent(
-   *   "gemini-2.5-flash-lite",
-   *   [{ parts: [{ text: "Hello" }], role: "user" }],
-   *   (chunk) => console.log(chunk)
-   * );
-   * ```
-   */
+class StreamingService extends BaseGeminiService {
   async streamContent(
     model: string,
     contents: GeminiContent[],
@@ -29,7 +14,6 @@ class GeminiStreamingService extends BaseGeminiService {
     generationConfig?: GeminiGenerationConfig,
     signal?: AbortSignal,
   ): Promise<string> {
-    // Validate callback
     if (typeof onChunk !== "function") {
       throw new Error("onChunk must be a function");
     }
@@ -51,27 +35,22 @@ class GeminiStreamingService extends BaseGeminiService {
       return await processStream(
         result.stream,
         onChunk,
-        (error, context) => this.logStreamError(model, error, context)
+        (error, context) => {
+          try {
+            telemetryHooks.logError(
+              model,
+              error instanceof Error ? error : new Error(String(error)),
+              context
+            );
+          } catch {
+            // Silently ignore telemetry errors
+          }
+        }
       );
     } catch (error) {
       return this.handleError(error, "Stream generation was aborted");
     }
   }
-
-  /**
-   * Log stream errors via telemetry
-   */
-  private logStreamError(model: string, error: unknown, context?: string): void {
-    try {
-      telemetryHooks.logError(
-        model,
-        error instanceof Error ? error : new Error(String(error)),
-        context
-      );
-    } catch {
-      // Silently ignore telemetry errors
-    }
-  }
 }
 
-export const geminiStreamingService = new GeminiStreamingService();
+export const streaming = new StreamingService();

package/src/infrastructure/services/{gemini-structured-text.service.ts → StructuredText.ts}

@@ -1,8 +1,6 @@
-
-import { geminiTextGenerationService } from "./gemini-text-generation.service";
+import { textGeneration } from "./TextGeneration";
 import { parseJsonResponse } from "../utils/json-parser.util";
 import { extractTextFromParts } from "../utils/content-mapper.util";
-import { validateSchema } from "../utils/validation.util";
 import type { GenerationConfig } from "@google/generative-ai";
 import type {
   GeminiContent,
@@ -10,11 +8,7 @@ import type {
   GeminiResponse,
 } from "../../domain/entities";
 
-
-class GeminiStructuredTextService {
-  /**
-   * Generate structured JSON response with schema
-   */
+class StructuredTextService {
   async generateStructuredText<T>(
     model: string,
     prompt: string,
@@ -22,7 +16,9 @@ class GeminiStructuredTextService {
     config?: Omit<GeminiGenerationConfig, "responseMimeType" | "responseSchema">,
     signal?: AbortSignal,
   ): Promise<T> {
-    validateSchema(schema);
+    if (!schema || typeof schema !== "object" || Object.keys(schema).length === 0) {
+      throw new Error("Schema must be a non-empty object");
+    }
 
     const generationConfig: GeminiGenerationConfig = {
       ...config,
@@ -34,7 +30,7 @@ class GeminiStructuredTextService {
       { parts: [{ text: prompt }], role: "user" },
     ];
 
-    const response = await geminiTextGenerationService.generateContent(
+    const response = await textGeneration.generateContent(
       model,
       contents,
       generationConfig,
@@ -44,9 +40,6 @@ class GeminiStructuredTextService {
     return this.parseJSONResponse<T>(response);
   }
 
-  /**
-   * Parse JSON response from Gemini
-   */
   private parseJSONResponse<T>(response: GeminiResponse): T {
     const candidates = response.candidates;
 
@@ -64,4 +57,4 @@ class GeminiStructuredTextService {
   }
 }
 
-export const geminiStructuredTextService = new GeminiStructuredTextService();
+export const structuredText = new StructuredTextService();

package/src/infrastructure/services/{gemini-text-generation.service.ts → TextGeneration.ts}

@@ -1,20 +1,13 @@
-import { BaseGeminiService } from "./base-gemini.service";
+import { BaseGeminiService } from "./BaseService";
 import { extractTextFromResponse } from "../utils/gemini-data-transformer.util";
 import { transformResponse, createTextContent } from "../utils/content-mapper.util";
-import { validatePrompt } from "../utils/validation.util";
 import type {
   GeminiContent,
   GeminiGenerationConfig,
   GeminiResponse,
 } from "../../domain/entities";
 
-class GeminiTextGenerationService extends BaseGeminiService {
-  /**
-   * Generate content (text, with optional images)
-   *
-   * @throws {GeminiError} For API-specific errors
-   * @throws {Error} For validation or network errors
-   */
+class TextGenerationService extends BaseGeminiService {
   async generateContent(
     model: string,
     contents: GeminiContent[],
@@ -35,38 +28,30 @@ class GeminiTextGenerationService extends BaseGeminiService {
         ? await genModel.generateContent(requestOptions, { signal })
         : await genModel.generateContent(requestOptions);
 
-      const response = result.response;
-
-      if (!response) {
+      if (!result.response) {
         throw new Error("No response received from Gemini API");
       }
 
-      return transformResponse(response);
+      return transformResponse(result.response);
     } catch (error) {
       return this.handleError(error, "Request was aborted");
     }
   }
 
-  /**
-   * Generate text from prompt
-   *
-   * @throws {GeminiError} For API-specific errors
-   * @throws {Error} For validation or network errors
-   */
   async generateText(
     model: string,
     prompt: string,
     config?: GeminiGenerationConfig,
     signal?: AbortSignal,
   ): Promise<string> {
-    // Validate prompt
-    validatePrompt(prompt);
+    if (!prompt || prompt.trim().length < 3) {
+      throw new Error("Prompt must be at least 3 characters");
+    }
 
     const contents: GeminiContent[] = [createTextContent(prompt, "user")];
-
     const response = await this.generateContent(model, contents, config, signal);
     return extractTextFromResponse(response);
   }
 }
 
-export const geminiTextGenerationService = new GeminiTextGenerationService();
+export const textGeneration = new TextGenerationService();

package/src/infrastructure/services/index.ts

@@ -1,21 +1,6 @@
-/**
- * Infrastructure Services - Internal Use Only
- */
-
-// Internal base classes
-export { BaseGeminiService } from "./base-gemini.service";
-export type { BaseRequestOptions } from "./base-gemini.service";
-
-// Internal services
-export { geminiClientCoreService } from "./gemini-client-core.service";
-export { geminiTextGenerationService } from "./gemini-text-generation.service";
-export { geminiStructuredTextService } from "./gemini-structured-text.service";
-export { geminiStreamingService } from "./gemini-streaming.service";
-
-// Main Provider - Public API
-export {
-  geminiProviderService,
-  GeminiProvider,
-} from "./gemini-provider";
-export type { GeminiProviderConfig } from "./gemini-provider";
-
+export { geminiClient } from "./GeminiClient";
+export { textGeneration } from "./TextGeneration";
+export { structuredText } from "./StructuredText";
+export { streaming } from "./Streaming";
+export { geminiProvider, GeminiProvider } from "./GeminiProvider";
+export { BaseGeminiService, type BaseRequestOptions } from "./BaseService";

package/src/infrastructure/utils/index.ts

@@ -1,9 +1,3 @@
-/**
- * Utility Functions - Internal Use Only
- * These are internal implementation details and should not be used directly by consumers
- */
-
-// Error handling (internal)
 export {
   mapGeminiError,
   isGeminiErrorRetryable,
@@ -11,14 +5,15 @@ export {
   createGeminiError
 } from "./error-mapper.util";
 
-// Data transformation (internal)
 export { extractTextFromResponse } from "./gemini-data-transformer.util";
+
 export {
   cleanJsonText,
   parseJsonResponse,
   safeParseJson,
   extractJsonFromText
 } from "./json-parser.util";
+
 export {
   toSdkContent,
   createTextContent,
@@ -27,18 +22,17 @@ export {
   extractTextFromParts
 } from "./content-mapper.util";
 
-// Validation (internal)
 export {
   validateModelName,
   validateApiKey,
   validateSchema,
   validatePrompt,
-  validateTimeout,
-  isValidObject,
-  validateRequiredFields
-} from "./validation.util";
+  validateOrThrow,
+  validators,
+  compose,
+  type ValidationRule,
+} from "./validation";
 
-// Async state management (internal)
 export {
   executeWithState,
   type AsyncStateCallbacks,

package/src/infrastructure/utils/{validation-composer.util.ts → validation.ts}

@@ -1,6 +1,5 @@
 /**
- * Validation Composers
- * Composable validation rules for clean, reusable validation
+ * Validation utilities
  */
 
 export type ValidationRule<T = unknown> = (value: T) => string | null;
@@ -158,3 +157,19 @@ export const validators = {
 
   schema: isValidSchema(),
 };
+
+export function validateModelName(modelName: string): void {
+  validateOrThrow(modelName, validators.modelName);
+}
+
+export function validateApiKey(apiKey: string): void {
+  validateOrThrow(apiKey, validators.apiKey);
+}
+
+export function validateSchema(schema: Record<string, unknown>): void {
+  validateOrThrow(schema, validators.schema);
+}
+
+export function validatePrompt(prompt: string): void {
+  validateOrThrow(prompt, validators.prompt);
+}

package/src/presentation/hooks/index.ts

@@ -1,11 +1,2 @@
-/**
- * React Hooks - Public API
- */
-
-// Internal - not exported from main index
-export { useOperationManager } from "./use-operation-manager";
-export type { OperationManager } from "./use-operation-manager";
-
-// Public API
-export { useGemini } from "./use-gemini";
-export type { UseGeminiOptions, UseGeminiReturn } from "./use-gemini";
+export { useOperationManager, type OperationManager } from "./useOperationManager";
+export { useGemini, type UseGeminiOptions, type UseGeminiReturn } from "./useGemini";

package/src/presentation/hooks/{use-gemini.ts → useGemini.ts}

@@ -1,10 +1,10 @@
 import { useState, useCallback, useMemo } from "react";
 import type { GeminiGenerationConfig } from "../../domain/entities";
 import { DEFAULT_MODELS } from "../../domain/entities";
-import { geminiTextGenerationService, geminiStructuredTextService } from "../../infrastructure/services";
+import { textGeneration, structuredText } from "../../infrastructure/services";
 import { executeWithState, type AsyncStateSetters } from "../../infrastructure/utils/async";
 import { parseJsonResponse } from "../../infrastructure/utils/json-parser.util";
-import { useOperationManager } from "./use-operation-manager";
+import { useOperationManager } from "./useOperationManager";
 
 export interface UseGeminiOptions {
   model?: string;
@@ -55,7 +55,7 @@ export function useGemini(options: UseGeminiOptions = {}): UseGeminiReturn {
           setters,
           callbacks,
           async () => {
-            return geminiTextGenerationService.generateText(
+            return textGeneration.generateText(
               model,
               prompt,
               options.generationConfig,
@@ -95,7 +95,7 @@ export function useGemini(options: UseGeminiOptions = {}): UseGeminiReturn {
           jsonCallbacks,
           async () => {
             if (schema) {
-              return geminiStructuredTextService.generateStructuredText<T>(
+              return structuredText.generateStructuredText<T>(
                 model,
                 prompt,
                 schema,
@@ -104,7 +104,7 @@ export function useGemini(options: UseGeminiOptions = {}): UseGeminiReturn {
               );
             }
 
-            const text = await geminiTextGenerationService.generateText(
+            const text = await textGeneration.generateText(
               model,
               prompt,
               { ...options.generationConfig, responseMimeType: "application/json" },

package/src/providers/ProviderFactory.ts

@@ -1,4 +1,4 @@
-import { geminiClientCoreService } from "../infrastructure/services/gemini-client-core.service";
+import { geminiClient } from "../infrastructure/services/GeminiClient";
 import { ConfigBuilder, type ProviderConfig } from "./ConfigBuilder";
 
 // Re-export for public API
@@ -40,7 +40,7 @@ class ProviderFactory {
 
     // Initialize Gemini client
     const geminiConfig = this.builder.toGeminiConfig();
-    geminiClientCoreService.initialize(geminiConfig);
+    geminiClient.initialize(geminiConfig);
   }
 
   /**

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

@@ -1,62 +0,0 @@
-
-import type { GeminiConfig } from "../../domain/entities";
-import { geminiClientCoreService } from "./gemini-client-core.service";
-import { geminiStructuredTextService } from "./gemini-structured-text.service";
-import { validatePrompt } from "../utils/validation.util";
-
-export type GeminiProviderConfig = GeminiConfig;
-
-export class GeminiProvider {
-  readonly providerId = "gemini";
-  readonly providerName = "Google Gemini";
-
-  /**
-   * Initialize the Gemini provider
-   *
-   * @throws {Error} If already initialized or configuration is invalid
-   */
-  initialize(config: GeminiProviderConfig): void {
-    if (geminiClientCoreService.isInitialized()) {
-      throw new Error("Provider already initialized. Call reset() before re-initializing with new config.");
-    }
-    geminiClientCoreService.initialize(config);
-  }
-
-  /**
-   * Check if provider is initialized
-   */
-  isInitialized(): boolean {
-    return geminiClientCoreService.isInitialized();
-  }
-
-  /**
-   * Reset the provider to uninitialized state
-   */
-  reset(): void {
-    geminiClientCoreService.reset();
-  }
-
-  /**
-   * Generate structured JSON response
-   *
-   * @throws {GeminiError} For API-specific errors
-   * @throws {Error} For validation or network errors
-   */
-  async generateStructuredText<T>(
-    prompt: string,
-    schema: Record<string, unknown>,
-    model: string,
-  ): Promise<T> {
-    // Validate inputs
-    validatePrompt(prompt);
-
-    // Check if initialized
-    if (!this.isInitialized()) {
-      throw new Error("Provider not initialized. Call initialize() first.");
-    }
-
-    return geminiStructuredTextService.generateStructuredText<T>(model, prompt, schema);
-  }
-}
-
-export const geminiProviderService = new GeminiProvider();

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

@@ -1,73 +0,0 @@
-/**
- * Validation Utilities (Legacy)
- * Maintained for backward compatibility
- * New code should use validation-composer.util.ts
- */
-
-import { validateOrThrow, validators } from "./validation-composer.util";
-
-/**
- * Validate model name format
- * @throws Error if model name is invalid
- */
-export function validateModelName(modelName: string): void {
-  validateOrThrow(modelName, validators.modelName);
-}
-
-/**
- * Validate API key format
- * @throws Error if API key is invalid
- */
-export function validateApiKey(apiKey: string): void {
-  validateOrThrow(apiKey, validators.apiKey);
-}
-
-/**
- * Validate schema object for structured generation
- * @throws Error if schema is invalid
- */
-export function validateSchema(schema: Record<string, unknown>): void {
-  validateOrThrow(schema, validators.schema);
-}
-
-/**
- * Validate prompt text
- * @throws Error if prompt is invalid
- */
-export function validatePrompt(prompt: string): void {
-  validateOrThrow(prompt, validators.prompt);
-}
-
-/**
- * Validate timeout value
- * @throws Error if timeout is invalid
- */
-export function validateTimeout(timeout: number): void {
-  validateOrThrow(timeout, validators.timeout);
-}
-
-/**
- * Check if a value is a valid object
- */
-export function isValidObject(value: unknown): value is Record<string, unknown> {
-  return (
-    value !== null &&
-    typeof value === "object" &&
-    !Array.isArray(value) &&
-    Object.keys(value).length > 0
-  );
-}
-
-/**
- * Validate required fields in an object
- */
-export function validateRequiredFields(
-  obj: Record<string, unknown>,
-  requiredFields: string[]
-): void {
-  const missing = requiredFields.filter((field) => !(field in obj) || obj[field] === undefined);
-
-  if (missing.length > 0) {
-    throw new Error(`Missing required fields: ${missing.join(", ")}`);
-  }
-}