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

package/package.json

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

package/src/domain/entities/models.ts

@@ -16,11 +16,3 @@ export const DEFAULT_MODELS = {
   /** Default model for text generation */
   TEXT: GEMINI_MODELS.TEXT.FLASH_LITE,
 } as const;
-
-/**
- * Pricing information for Gemini models
- * Prices are per 1M tokens (USD)
- */
-export const MODEL_PRICING = {
-  [GEMINI_MODELS.TEXT.FLASH_LITE]: { input: 0.10, output: 0.40, freePerDay: 1000 },
-} as const;

package/src/infrastructure/services/index.ts

@@ -3,4 +3,3 @@ 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/telemetry/index.ts

@@ -3,4 +3,3 @@
  */
 
 export { telemetryHooks } from "./TelemetryHooks";
-export type { TelemetryEvent, TelemetryListener } from "./TelemetryHooks";

package/src/infrastructure/utils/async/index.ts

@@ -4,7 +4,5 @@
 
 export {
   executeWithState,
-  type AsyncStateCallbacks,
   type AsyncStateSetters,
-  type AsyncStateConfig,
 } from "./execute-state.util";

package/src/infrastructure/utils/content-mapper.util.ts

@@ -76,7 +76,7 @@ export function createTextContent(
 /**
  * Transform SDK candidate to domain format
  */
-export function transformCandidate(
+function transformCandidate(
   candidate: {
     content: { parts: Array<{ text?: string }>; role?: string };
     finishReason?: string;

package/src/infrastructure/utils/error-mapper.util.ts

@@ -87,7 +87,7 @@ function matchesPattern(message: string, patterns: string[]): boolean {
   });
 }
 
-export function mapGeminiError(error: unknown): GeminiErrorInfo {
+function mapGeminiError(error: unknown): GeminiErrorInfo {
   const message = error instanceof Error ? error.message : String(error);
   const statusCode = getStatusCode(error);
 
@@ -114,14 +114,6 @@ export function mapGeminiError(error: unknown): GeminiErrorInfo {
   };
 }
 
-export function isGeminiErrorRetryable(error: unknown): boolean {
-  return mapGeminiError(error).retryable;
-}
-
-export function categorizeGeminiError(error: unknown): GeminiErrorType {
-  return mapGeminiError(error).type;
-}
-
 export function createGeminiError(error: unknown): GeminiError {
   const errorInfo = mapGeminiError(error);
   return GeminiError.fromError(error, errorInfo);

package/src/infrastructure/utils/json-parser.util.ts

@@ -6,7 +6,7 @@
 /**
  * Clean JSON text by removing markdown code blocks and extra whitespace
  */
-export function cleanJsonText(text: string): string {
+function cleanJsonText(text: string): string {
   if (!text || typeof text !== "string") {
     return "";
   }
@@ -39,52 +39,3 @@ export function parseJsonResponse<T>(text: string): T {
   }
 }
 
-/**
- * Safely parse JSON with optional fallback value
- */
-export function safeParseJson<T>(
-  text: string,
-  fallback: T
-): T {
-  try {
-    return parseJsonResponse<T>(text);
-  } catch {
-    return fallback;
-  }
-}
-
-/**
- * Extract and parse JSON from a larger text response
- * Looks for JSON objects within markdown code blocks or standalone
- */
-export function extractJsonFromText<T>(text: string): T | null {
-  // Try to find JSON in code blocks first
-  const codeBlockMatch = text.match(/```json\s*([\s\S]*?)\s*```/);
-  if (codeBlockMatch) {
-    try {
-      return JSON.parse(codeBlockMatch[1].trim()) as T;
-    } catch {
-      // Continue to other methods
-    }
-  }
-
-  // Try to find JSON object boundaries
-  const firstBrace = text.indexOf("{");
-  const lastBrace = text.lastIndexOf("}");
-
-  if (firstBrace !== -1 && lastBrace !== -1 && lastBrace > firstBrace) {
-    try {
-      const jsonStr = text.substring(firstBrace, lastBrace + 1);
-      return JSON.parse(jsonStr) as T;
-    } catch {
-      // Continue to fallback
-    }
-  }
-
-  // Try parsing the whole text as JSON
-  try {
-    return parseJsonResponse<T>(text);
-  } catch {
-    return null;
-  }
-}

package/src/infrastructure/utils/stream-processor.util.ts

@@ -3,12 +3,12 @@
  * Reusable stream handling logic
  */
 
-export interface StreamChunk {
+interface StreamChunk {
   text: () => string;
 }
 
-export type ChunkCallback = (text: string) => void;
-export type ErrorLogger = (error: unknown, context?: string) => void;
+type ChunkCallback = (text: string) => void;
+type ErrorLogger = (error: unknown, context?: string) => void;
 
 /**
  * Process async stream with chunk callback
@@ -67,90 +67,3 @@ function logError(
   }
 }
 
-/**
- * Create a buffered stream processor
- * Accumulates chunks until a condition is met
- */
-export class BufferedStreamProcessor {
-  private buffer = "";
-  private fullText = "";
-
-  constructor(
-    private onFlush: (text: string) => void,
-    private flushCondition: (buffer: string) => boolean = () => false
-  ) {}
-
-  /**
-   * Process a single chunk
-   */
-  processChunk(chunk: StreamChunk): void {
-    try {
-      const chunkText = chunk.text();
-      if (!chunkText) return;
-
-      this.buffer += chunkText;
-      this.fullText += chunkText;
-
-      if (this.flushCondition(this.buffer)) {
-        this.flush();
-      }
-    } catch (error) {
-      // Ignore chunk errors
-    }
-  }
-
-  /**
-   * Flush buffer to callback
-   */
-  flush(): void {
-    if (this.buffer) {
-      try {
-        this.onFlush(this.buffer);
-        this.buffer = "";
-      } catch {
-        // Ignore callback errors
-      }
-    }
-  }
-
-  /**
-   * Get accumulated full text
-   */
-  getFullText(): string {
-    return this.fullText;
-  }
-
-  /**
-   * Process entire stream
-   */
-  async processStream(stream: AsyncIterable<StreamChunk>): Promise<string> {
-    for await (const chunk of stream) {
-      this.processChunk(chunk);
-    }
-
-    // Flush remaining buffer
-    this.flush();
-
-    return this.fullText;
-  }
-}
-
-/**
- * Common flush conditions
- */
-export const flushConditions = {
-  /**
-   * Flush on newline
-   */
-  onNewline: (buffer: string): boolean => buffer.includes("\n"),
-
-  /**
-   * Flush when buffer reaches size
-   */
-  onSize: (size: number) => (buffer: string): boolean => buffer.length >= size,
-
-  /**
-   * Flush on pattern match
-   */
-  onPattern: (pattern: RegExp) => (buffer: string): boolean => pattern.test(buffer),
-};

package/src/presentation/hooks/index.ts

@@ -1,2 +1 @@
-export { useOperationManager, type OperationManager } from "./useOperationManager";
 export { useGemini, type UseGeminiOptions, type UseGeminiReturn } from "./useGemini";

package/src/infrastructure/interceptors/BaseInterceptor.ts

@@ -1,78 +0,0 @@
-/**
- * Base Interceptor Class
- * Eliminates code duplication between Request and Response interceptors
- */
-
-import { telemetryHooks } from "../telemetry";
-
-export type InterceptorErrorStrategy = "fail" | "skip" | "log";
-
-export interface BaseContext {
-  model: string;
-  feature?: string;
-  timestamp: number;
-}
-
-export abstract class BaseInterceptor<TContext extends BaseContext> {
-  protected interceptors: Array<(context: TContext) => TContext | Promise<TContext>> = [];
-  protected errorStrategy: InterceptorErrorStrategy = "fail";
-
-  /**
-   * Register an interceptor
-   */
-  use(interceptor: (context: TContext) => TContext | Promise<TContext>): () => void {
-    this.interceptors.push(interceptor);
-
-    // Return unsubscribe function
-    return () => {
-      const index = this.interceptors.indexOf(interceptor);
-      if (index > -1) {
-        this.interceptors.splice(index, 1);
-      }
-    };
-  }
-
-  /**
-   * Set error handling strategy
-   */
-  setErrorStrategy(strategy: InterceptorErrorStrategy): void {
-    this.errorStrategy = strategy;
-  }
-
-  /**
-   * Clear all interceptors
-   */
-  clear(): void {
-    this.interceptors = [];
-  }
-
-  /**
-   * Get interceptor count
-   */
-  count(): number {
-    return this.interceptors.length;
-  }
-
-  /**
-   * Handle interceptor error based on strategy
-   */
-  protected handleError(context: TContext, error: unknown): void {
-    telemetryHooks.logError(
-      context.model,
-      error instanceof Error ? error : new Error(String(error)),
-      context.feature
-    );
-
-    if (this.errorStrategy === "fail") {
-      throw new Error(
-        `Interceptor failed: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-    // For "skip" and "log", we just continue (error already logged)
-  }
-
-  /**
-   * Apply interceptors - to be implemented by subclasses
-   */
-  abstract apply(context: TContext): Promise<TContext>;
-}

package/src/infrastructure/interceptors/RequestInterceptors.ts

@@ -1,30 +0,0 @@
-import { BaseInterceptor, type BaseContext } from "./BaseInterceptor";
-
-export interface RequestContext extends BaseContext {
-  payload: Record<string, unknown>;
-}
-
-export type RequestInterceptor = (context: RequestContext) => RequestContext | Promise<RequestContext>;
-
-class RequestInterceptors extends BaseInterceptor<RequestContext> {
-  /**
-   * Apply all interceptors to a request context
-   * Interceptors are called in order (first registered = first called)
-   */
-  async apply(context: RequestContext): Promise<RequestContext> {
-    let result = context;
-
-    for (const interceptor of this.interceptors) {
-      try {
-        result = await interceptor(result);
-      } catch (error) {
-        this.handleError(context, error);
-        // If we get here, strategy was "skip" or "log" - continue with previous result
-      }
-    }
-
-    return result;
-  }
-}
-
-export const requestInterceptors = new RequestInterceptors();

package/src/infrastructure/interceptors/ResponseInterceptors.ts

@@ -1,35 +0,0 @@
-import { BaseInterceptor, type BaseContext } from "./BaseInterceptor";
-
-export interface ResponseContext<T = unknown> extends BaseContext {
-  data: T;
-  duration: number;
-}
-
-export type ResponseInterceptor<T = unknown> = (
-  context: ResponseContext<T>,
-) => ResponseContext<T> | Promise<ResponseContext<T>>;
-
-class ResponseInterceptors extends BaseInterceptor<ResponseContext<unknown>> {
-  /**
-   * Apply all interceptors to a response context
-   * Interceptors are called in reverse order (last registered = first called)
-   */
-  async apply<T>(context: ResponseContext<T>): Promise<ResponseContext<T>> {
-    let result: ResponseContext<unknown> = context;
-
-    // Apply in reverse order (last added = first processed)
-    for (let i = this.interceptors.length - 1; i >= 0; i--) {
-      const interceptor = this.interceptors[i];
-      try {
-        result = await interceptor(result);
-      } catch (error) {
-        this.handleError(context, error);
-        // If we get here, strategy was "skip" or "log" - continue with previous result
-      }
-    }
-
-    return result as ResponseContext<T>;
-  }
-}
-
-export const responseInterceptors = new ResponseInterceptors();

package/src/infrastructure/interceptors/index.ts

@@ -1,12 +0,0 @@
-/**
- * Interceptors Module - Internal Use Only
- */
-
-export { BaseInterceptor } from "./BaseInterceptor";
-export type { BaseContext, InterceptorErrorStrategy } from "./BaseInterceptor";
-
-export { requestInterceptors } from "./RequestInterceptors";
-export type { RequestContext, RequestInterceptor } from "./RequestInterceptors";
-
-export { responseInterceptors } from "./ResponseInterceptors";
-export type { ResponseContext, ResponseInterceptor } from "./ResponseInterceptors";

package/src/infrastructure/utils/index.ts

@@ -1,41 +0,0 @@
-export {
-  mapGeminiError,
-  isGeminiErrorRetryable,
-  categorizeGeminiError,
-  createGeminiError
-} from "./error-mapper.util";
-
-export { extractTextFromResponse } from "./gemini-data-transformer.util";
-
-export {
-  cleanJsonText,
-  parseJsonResponse,
-  safeParseJson,
-  extractJsonFromText
-} from "./json-parser.util";
-
-export {
-  toSdkContent,
-  createTextContent,
-  transformCandidate,
-  transformResponse,
-  extractTextFromParts
-} from "./content-mapper.util";
-
-export {
-  validateModelName,
-  validateApiKey,
-  validateSchema,
-  validatePrompt,
-  validateOrThrow,
-  validators,
-  compose,
-  type ValidationRule,
-} from "./validation";
-
-export {
-  executeWithState,
-  type AsyncStateCallbacks,
-  type AsyncStateSetters,
-  type AsyncStateConfig
-} from "./async";

package/src/infrastructure/utils/validation.ts

@@ -1,175 +0,0 @@
-/**
- * Validation utilities
- */
-
-export type ValidationRule<T = unknown> = (value: T) => string | null;
-
-/**
- * Compose multiple validation rules into one
- */
-export function compose<T>(...rules: ValidationRule<T>[]): ValidationRule<T> {
-  return (value: T): string | null => {
-    for (const rule of rules) {
-      const error = rule(value);
-      if (error) return error;
-    }
-    return null;
-  };
-}
-
-/**
- * Validate that value is not empty
- */
-export function required(fieldName: string = "Field"): ValidationRule<string> {
-  return (value: string): string | null => {
-    if (!value || typeof value !== "string" || value.trim().length === 0) {
-      return `${fieldName} is required`;
-    }
-    return null;
-  };
-}
-
-/**
- * Validate minimum length
- */
-export function minLength(min: number, fieldName: string = "Field"): ValidationRule<string> {
-  return (value: string): string | null => {
-    if (value.trim().length < min) {
-      return `${fieldName} must be at least ${min} characters`;
-    }
-    return null;
-  };
-}
-
-/**
- * Validate maximum length
- */
-export function maxLength(max: number, fieldName: string = "Field"): ValidationRule<string> {
-  return (value: string): string | null => {
-    if (value.length > max) {
-      return `${fieldName} must be at most ${max} characters`;
-    }
-    return null;
-  };
-}
-
-/**
- * Validate string starts with prefix
- */
-export function startsWith(prefix: string, fieldName: string = "Field"): ValidationRule<string> {
-  return (value: string): string | null => {
-    if (!value.startsWith(prefix)) {
-      return `${fieldName} must start with "${prefix}"`;
-    }
-    return null;
-  };
-}
-
-/**
- * Validate number is in range
- */
-export function inRange(min: number, max: number, fieldName: string = "Value"): ValidationRule<number> {
-  return (value: number): string | null => {
-    if (typeof value !== "number" || value < min || value > max) {
-      return `${fieldName} must be between ${min} and ${max}`;
-    }
-    return null;
-  };
-}
-
-/**
- * Validate object has required properties
- */
-export function hasProperties(...props: string[]): ValidationRule<Record<string, unknown>> {
-  return (value: Record<string, unknown>): string | null => {
-    const missing = props.filter((prop) => !(prop in value) || value[prop] === undefined);
-    if (missing.length > 0) {
-      return `Missing required properties: ${missing.join(", ")}`;
-    }
-    return null;
-  };
-}
-
-/**
- * Validate object structure (for schemas)
- */
-export function isValidSchema(): ValidationRule<Record<string, unknown>> {
-  return compose(
-    (schema): string | null => {
-      if (!schema || typeof schema !== "object") {
-        return "Schema must be a non-empty object";
-      }
-      return null;
-    },
-    (schema): string | null => {
-      if (Object.keys(schema).length === 0) {
-        return "Schema must contain at least one property";
-      }
-      return null;
-    },
-    hasProperties("type"),
-    (schema): string | null => {
-      const schemaType = schema.type;
-      if (schemaType !== "object" && schemaType !== "array") {
-        return `Schema type must be "object" or "array", got "${String(schemaType)}"`;
-      }
-      return null;
-    },
-    (schema): string | null => {
-      if (schema.type === "object" && !("properties" in schema)) {
-        return 'Object schema must have a "properties" field';
-      }
-      return null;
-    }
-  );
-}
-
-/**
- * Helper to validate and throw on error
- */
-export function validateOrThrow<T>(value: T, rule: ValidationRule<T>): void {
-  const error = rule(value);
-  if (error) {
-    throw new Error(error);
-  }
-}
-
-/**
- * Pre-built composite validators
- */
-export const validators = {
-  apiKey: compose(
-    required("API key"),
-    minLength(10, "API key")
-  ),
-
-  modelName: compose(
-    required("Model name"),
-    startsWith("gemini-", "Model name")
-  ),
-
-  prompt: compose(
-    required("Prompt"),
-    minLength(3, "Prompt")
-  ),
-
-  timeout: inRange(1, 300000, "Timeout"),
-
-  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);
-}