@umituz/react-native-ai-gemini-provider 3.0.41 → 3.0.42

package/package.json

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

package/src/application/builders/config-builder.ts

@@ -0,0 +1,102 @@
+/**
+ * Configuration Builder
+ * Fluent API for building Gemini configuration
+ */
+
+import { DEFAULT_MODELS } from "../../domain/entities";
+import type { GeminiConfig } from "../../domain/entities";
+
+export interface GeminiConfigOptions {
+  apiKey: string;
+  model?: string;
+  timeout?: number;
+  strategy?: "cost" | "quality";
+}
+
+export class GeminiConfigBuilder {
+  private apiKey?: string;
+  private model: string = DEFAULT_MODELS.TEXT;
+  private timeout = 30000;
+  private strategy?: "cost" | "quality";
+
+  /**
+   * Set API key (required)
+   */
+  withApiKey(apiKey: string): this {
+    if (!apiKey || typeof apiKey !== "string" || apiKey.trim().length === 0) {
+      throw new Error("API key must be a non-empty string");
+    }
+    this.apiKey = apiKey.trim();
+    return this;
+  }
+
+  /**
+   * Set model name
+   */
+  withModel(model: string): this {
+    if (!model || !model.startsWith("gemini-")) {
+      throw new Error("Invalid model name. Must start with 'gemini-'");
+    }
+    this.model = model;
+    return this;
+  }
+
+  /**
+   * Set request timeout (ms)
+   */
+  withTimeout(timeout: number): this {
+    if (timeout <= 0 || timeout > 300000) {
+      throw new Error("Timeout must be between 1ms and 300000ms (5 minutes)");
+    }
+    this.timeout = timeout;
+    return this;
+  }
+
+  /**
+   * Set strategy and apply preset timeout
+   */
+  withStrategy(strategy: "cost" | "quality"): this {
+    this.strategy = strategy;
+
+    // Apply strategy-based defaults
+    if (strategy === "quality") {
+      this.timeout = 60000; // 1 minute for quality
+    } else {
+      this.timeout = 30000; // 30 seconds for cost
+    }
+
+    return this;
+  }
+
+  /**
+   * Build final configuration
+   */
+  build(): GeminiConfig {
+    if (!this.apiKey) {
+      throw new Error("API key is required. Call withApiKey() before build()");
+    }
+
+    return {
+      apiKey: this.apiKey,
+      textModel: this.model,
+      defaultTimeoutMs: this.timeout,
+    };
+  }
+
+  /**
+   * Create a new builder instance
+   */
+  static create(): GeminiConfigBuilder {
+    return new GeminiConfigBuilder();
+  }
+
+  /**
+   * Create builder from existing config
+   */
+  static from(config: GeminiConfig): GeminiConfigBuilder {
+    return new GeminiConfigBuilder()
+      .withApiKey(config.apiKey)
+      .withModel(config.textModel || DEFAULT_MODELS.TEXT)
+      .withTimeout(config.defaultTimeoutMs || 30000);
+  }
+}

package/src/application/builders/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Application Builders
+ */
+
+export {
+  GeminiConfigBuilder,
+  type GeminiConfigOptions,
+} from "./config-builder";

package/src/application/dtos/generation-request.dto.ts

@@ -0,0 +1,89 @@
+/**
+ * Generation Request DTO
+ * Data transfer object for generation requests
+ */
+
+import type { GeminiContent, GeminiGenerationConfig } from "../../domain/entities";
+
+export class GenerationRequest {
+  constructor(
+    readonly model: string,
+    readonly contents: GeminiContent[],
+    readonly generationConfig?: GeminiGenerationConfig,
+    readonly signal?: AbortSignal
+  ) {}
+
+  /**
+   * Create a simple text generation request
+   */
+  static forText(
+    model: string,
+    prompt: string,
+    config?: GeminiGenerationConfig,
+    signal?: AbortSignal
+  ): GenerationRequest {
+    return new GenerationRequest(model, [], config, signal);
+  }
+
+  /**
+   * Create a streaming request
+   */
+  static forStream(
+    model: string,
+    prompt: string,
+    onChunk: (text: string) => void,
+    config?: GeminiGenerationConfig,
+    signal?: AbortSignal
+  ): GenerationRequest {
+    return new GenerationRequest(model, [], config, signal);
+  }
+
+  /**
+   * Check if request has abort signal
+   */
+  hasSignal(): boolean {
+    return this.signal !== undefined;
+  }
+
+  /**
+   * Check if request is aborted
+   */
+  isAborted(): boolean {
+    return this.signal?.aborted ?? false;
+  }
+}
+
+export class StructuredGenerationRequest {
+  constructor(
+    readonly model: string,
+    readonly prompt: string,
+    readonly schema: Record<string, unknown>,
+    readonly config?: Omit<GeminiGenerationConfig, "responseMimeType" | "responseSchema">,
+    readonly signal?: AbortSignal
+  ) {}
+
+  /**
+   * Get full generation config with JSON response settings
+   */
+  getConfig(): GeminiGenerationConfig {
+    return {
+      ...this.config,
+      responseMimeType: "application/json",
+      responseSchema: this.schema as any,
+    };
+  }
+
+  /**
+   * Check if request has abort signal
+   */
+  hasSignal(): boolean {
+    return this.signal !== undefined;
+  }
+
+  /**
+   * Check if request is aborted
+   */
+  isAborted(): boolean {
+    return this.signal?.aborted ?? false;
+  }
+}

package/src/application/dtos/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Application DTOs
+ */
+
+export {
+  GenerationRequest,
+  StructuredGenerationRequest,
+} from "./generation-request.dto";

package/src/application/index.ts

@@ -0,0 +1,16 @@
+/**
+ * Application Layer
+ * Use cases and orchestration
+ */
+
+// DTOs
+export * from "./dtos";
+
+// Use Cases
+export * from "./use-cases";
+
+// Builders
+export * from "./builders";
+
+// Providers
+export * from "./providers";

package/src/application/providers/gemini-provider.ts

@@ -0,0 +1,135 @@
+/**
+ * Gemini Provider
+ * Main provider for dependency injection
+ */
+
+import { ValidationService } from "../../domain/services/validation.service";
+import { ContentMapper, ResponseMapper } from "../../infrastructure/mappers";
+import {
+  GeminiTextRepository,
+  GeminiStreamingRepository,
+  GeminiStructuredTextRepository,
+} from "../../infrastructure/repositories";
+import { geminiClient } from "../../infrastructure/external/gemini-client.singleton";
+import type { GeminiConfig } from "../../domain/entities";
+import type {
+  ITextGenerationRepository,
+  IStreamingRepository,
+  IStructuredTextRepository,
+} from "../../domain/repositories";
+
+export class GeminiProviderClass {
+  private static instance: GeminiProviderClass | null = null;
+  static resetCalled = false;
+
+  readonly _validator: ValidationService;
+  readonly _contentMapper: ContentMapper;
+  readonly _responseMapper: ResponseMapper;
+
+  private readonly textRepository: ITextGenerationRepository;
+  private readonly streamingRepository: IStreamingRepository;
+  private readonly structuredTextRepository: IStructuredTextRepository;
+
+  private constructor() {
+    this._validator = new ValidationService();
+    this._contentMapper = new ContentMapper();
+    this._responseMapper = new ResponseMapper();
+
+    // Initialize repositories
+    const getModel = (name: string) => geminiClient.getModel(name);
+
+    this.textRepository = new GeminiTextRepository(
+      getModel,
+      this._validator,
+      this._contentMapper,
+      this._responseMapper
+    );
+
+    this.streamingRepository = new GeminiStreamingRepository(
+      getModel,
+      this._validator,
+      this._contentMapper
+    );
+
+    this.structuredTextRepository = new GeminiStructuredTextRepository(
+      getModel,
+      this._validator,
+      this._contentMapper,
+      this._responseMapper
+    );
+  }
+
+  /**
+   * Get singleton instance
+   */
+  static getInstance(): GeminiProviderClass {
+    if (!GeminiProviderClass.instance) {
+      GeminiProviderClass.instance = new GeminiProviderClass();
+    }
+    return GeminiProviderClass.instance;
+  }
+
+  /**
+   * Initialize with configuration
+   */
+  initialize(config: GeminiConfig): void {
+    geminiClient.initialize(config.apiKey);
+  }
+
+  /**
+   * Get validation service (public for use cases)
+   */
+  getValidator(): ValidationService {
+    return this._validator;
+  }
+
+  /**
+   * Get content mapper (public for use cases)
+   */
+  getContentMapper(): ContentMapper {
+    return this._contentMapper;
+  }
+
+  /**
+   * Get text generation repository
+   */
+  getTextRepository(): ITextGenerationRepository {
+    return this.textRepository;
+  }
+
+  /**
+   * Get streaming repository
+   */
+  getStreamingRepository(): IStreamingRepository {
+    return this.streamingRepository;
+  }
+
+  /**
+   * Get structured text repository
+   */
+  getStructuredTextRepository(): IStructuredTextRepository {
+    return this.structuredTextRepository;
+  }
+
+  /**
+   * Reset provider (for testing)
+   */
+  static reset(): void {
+    GeminiProviderClass.instance = null;
+    geminiClient.reset();
+    // Also expose globally for React components
+    if (typeof global !== 'undefined') {
+      (global as any).__geminiProviderReset = true;
+    }
+  }
+}
+
+/**
+ * Export singleton instance
+ */
+export const geminiProvider = GeminiProviderClass.getInstance();
+
+/**
+ * Type alias for cleaner API
+ */
+export type GeminiProvider = GeminiProviderClass;

package/src/application/providers/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Application Providers
+ */
+
+export { geminiProvider, GeminiProviderClass } from "./gemini-provider";
+export type { GeminiProvider } from "./gemini-provider";

package/src/application/use-cases/generate-json.use-case.ts

@@ -0,0 +1,73 @@
+/**
+ * Generate JSON Use Case
+ * Orchestrates structured JSON generation flow
+ */
+
+import type { GeminiGenerationConfig } from "../../domain/entities";
+import type { IStructuredTextRepository } from "../../domain/repositories/structured-text.repository";
+import { ValidationService } from "../../domain/services/validation.service";
+import { StructuredGenerationRequest } from "../dtos/generation-request.dto";
+
+export interface GenerateJSONOptions<T> {
+  model: string;
+  prompt: string;
+  schema: Record<string, unknown>;
+  config?: Omit<GeminiGenerationConfig, "responseMimeType" | "responseSchema">;
+  signal?: AbortSignal;
+}
+
+export interface GenerateJSONResult<T> {
+  data: T;
+  text: string; // Pretty-printed JSON
+}
+
+export class GenerateJSONUseCase {
+  constructor(
+    private readonly repository: IStructuredTextRepository,
+    private readonly validator: ValidationService
+  ) {}
+
+  /**
+   * Execute structured JSON generation
+   */
+  async execute<T>(
+    options: GenerateJSONOptions<T>
+  ): Promise<GenerateJSONResult<T>> {
+    // Validate inputs
+    this.validator.validatePrompt(options.prompt);
+    this.validator.validateSchema(options.schema);
+    this.validator.validateModelName(options.model);
+    this.validator.validateConfig(options.config);
+
+    // Create request
+    const request = new StructuredGenerationRequest(
+      options.model,
+      options.prompt,
+      options.schema,
+      options.config,
+      options.signal
+    );
+
+    // Execute
+    const data = await this.repository.generateStructured<T>({
+      model: request.model,
+      prompt: request.prompt,
+      schema: request.schema,
+      config: request.config,
+      signal: request.signal,
+    });
+
+    return {
+      data,
+      text: JSON.stringify(data, null, 2),
+    };
+  }
+
+  /**
+   * Execute simple JSON generation (returns only data)
+   */
+  async executeSimple<T>(options: GenerateJSONOptions<T>): Promise<T> {
+    const result = await this.execute<T>(options);
+    return result.data;
+  }
+}

package/src/application/use-cases/generate-text.use-case.ts

@@ -0,0 +1,81 @@
+/**
+ * Generate Text Use Case
+ * Orchestrates text generation flow
+ */
+
+import type { GeminiGenerationConfig, GeminiResponse } from "../../domain/entities";
+import type { ITextGenerationRepository } from "../../domain/repositories/text-generation.repository";
+import { ValidationService } from "../../domain/services/validation.service";
+import { GenerationRequest } from "../dtos/generation-request.dto";
+import { ContentMapper } from "../../infrastructure/mappers/content.mapper";
+
+export interface GenerateTextOptions {
+  model: string;
+  prompt: string;
+  config?: GeminiGenerationConfig;
+  signal?: AbortSignal;
+}
+
+export interface GenerateTextResult {
+  text: string;
+  response?: GeminiResponse;
+}
+
+export class GenerateTextUseCase {
+  constructor(
+    private readonly repository: ITextGenerationRepository,
+    private readonly validator: ValidationService,
+    private readonly contentMapper: ContentMapper
+  ) {}
+
+  /**
+   * Execute text generation
+   */
+  async execute(options: GenerateTextOptions): Promise<GenerateTextResult> {
+    // Validate inputs
+    this.validator.validatePrompt(options.prompt);
+    this.validator.validateModelName(options.model);
+    this.validator.validateConfig(options.config);
+
+    // Create request
+    const contents = [
+      this.contentMapper.createTextContent(options.prompt, "user"),
+    ];
+
+    const request = new GenerationRequest(
+      options.model,
+      contents,
+      options.config,
+      options.signal
+    );
+
+    // Execute
+    const response = await this.repository.generate({
+      model: request.model,
+      contents: request.contents,
+      generationConfig: request.generationConfig,
+      signal: request.signal,
+    });
+
+    // Extract text
+    const text = await this.repository.generateText(
+      options.model,
+      options.prompt,
+      options.config,
+      options.signal
+    );
+
+    return {
+      text,
+      response,
+    };
+  }
+
+  /**
+   * Execute simple text generation (returns only text)
+   */
+  async executeSimple(options: GenerateTextOptions): Promise<string> {
+    const result = await this.execute(options);
+    return result.text;
+  }
+}

package/src/application/use-cases/index.ts

@@ -0,0 +1,20 @@
+/**
+ * Application Use Cases
+ */
+
+export {
+  GenerateTextUseCase,
+  type GenerateTextOptions,
+  type GenerateTextResult,
+} from "./generate-text.use-case";
+
+export {
+  StreamContentUseCase,
+  type StreamContentOptions,
+} from "./stream-content.use-case";
+
+export {
+  GenerateJSONUseCase,
+  type GenerateJSONOptions,
+  type GenerateJSONResult,
+} from "./generate-json.use-case";

package/src/application/use-cases/stream-content.use-case.ts

@@ -0,0 +1,46 @@
+/**
+ * Stream Content Use Case
+ * Orchestrates streaming flow
+ */
+
+import type { GeminiGenerationConfig } from "../../domain/entities";
+import type { IStreamingRepository } from "../../domain/repositories/streaming.repository";
+import { ValidationService } from "../../domain/services/validation.service";
+import { GenerationRequest } from "../dtos/generation-request.dto";
+import { ContentMapper } from "../../infrastructure/mappers/content.mapper";
+
+export interface StreamContentOptions {
+  model: string;
+  prompt: string;
+  onChunk: (text: string) => void;
+  config?: GeminiGenerationConfig;
+  signal?: AbortSignal;
+}
+
+export class StreamContentUseCase {
+  constructor(
+    private readonly repository: IStreamingRepository,
+    private readonly validator: ValidationService,
+    private readonly contentMapper: ContentMapper
+  ) {}
+
+  /**
+   * Execute streaming
+   */
+  async execute(options: StreamContentOptions): Promise<string> {
+    // Validate inputs
+    this.validator.validatePrompt(options.prompt);
+    this.validator.validateModelName(options.model);
+    this.validator.validateCallback(options.onChunk, "onChunk");
+    this.validator.validateConfig(options.config);
+
+    // Execute
+    return this.repository.streamText(
+      options.model,
+      options.prompt,
+      options.onChunk,
+      options.config,
+      options.signal
+    );
+  }
+}

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

@@ -86,11 +86,6 @@ export class GeminiError extends Error {
     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);
-    }
   }
 
   /**

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

@@ -48,7 +48,9 @@ export interface GeminiContent {
 /**
  * Individual content part
  */
-export type GeminiPart = { text: string };
+export type GeminiPart =
+  | { text: string }
+  | { inlineData: { mimeType: string; data: string } };
 
 /**
  * Response structure from Gemini API

package/src/domain/index.ts

@@ -0,0 +1,16 @@
+/**
+ * Domain Layer
+ * Core business logic and contracts
+ */
+
+// Entities (re-export from existing)
+export * from "./entities";
+
+// Value Objects
+export * from "./value-objects";
+
+// Repository Interfaces
+export * from "./repositories";
+
+// Services
+export { ValidationService, ValidationError } from "./services/validation.service";

package/src/domain/repositories/index.ts

@@ -0,0 +1,19 @@
+/**
+ * Domain Repository Interfaces
+ * Contracts for infrastructure implementations
+ */
+
+export type {
+  ITextGenerationRepository,
+  TextGenerationRequest,
+} from "./text-generation.repository";
+
+export type {
+  IStreamingRepository,
+  StreamingRequest,
+} from "./streaming.repository";
+
+export type {
+  IStructuredTextRepository,
+  StructuredGenerationRequest,
+} from "./structured-text.repository";