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

package/src/infrastructure/telemetry/TelemetryHooks.ts

@@ -1,110 +0,0 @@
-
-export interface TelemetryEvent {
-  type: "error";
-  timestamp: number;
-  model?: string;
-  feature?: string;
-  metadata?: Record<string, unknown>;
-}
-
-export type TelemetryListener = (event: TelemetryEvent) => void;
-
-class TelemetryHooks {
-  private listeners: TelemetryListener[] = [];
-  private failedListeners: Set<TelemetryListener> = new Set();
-  private readonly MAX_FAILURES = 3;
-  private listenerFailureCounts = new Map<TelemetryListener, number>();
-
-  /**
-   * Register a telemetry listener
-   *
-   * @returns Unsubscribe function - IMPORTANT: Call this when done listening to prevent memory leaks
-   *
-   * @example
-   * ```ts
-   * const unsubscribe = telemetryHooks.subscribe((event) => console.log(event));
-   * // ... later when done
-   * unsubscribe(); // Prevents memory leak
-   * ```
-   */
-  subscribe(listener: TelemetryListener): () => void {
-    this.listeners.push(listener);
-    // Remove from failed listeners on new subscription (in case it's being re-added)
-    this.failedListeners.delete(listener);
-    this.listenerFailureCounts.set(listener, 0);
-
-    return () => {
-      const index = this.listeners.indexOf(listener);
-      if (index > -1) {
-        this.listeners.splice(index, 1);
-      }
-      // Clean up failure tracking when listener is removed
-      this.failedListeners.delete(listener);
-      this.listenerFailureCounts.delete(listener);
-    };
-  }
-
-  /**
-   * Emit a telemetry event to all listeners
-   */
-  emit(event: TelemetryEvent): void {
-    // Snapshot to prevent mutation during iteration
-    const snapshot = [...this.listeners];
-    for (const listener of snapshot) {
-      // Skip listeners that have failed too many times
-      if (this.failedListeners.has(listener)) {
-        continue;
-      }
-
-      try {
-        listener(event);
-        // Reset failure count and remove from failed listeners on success
-        const previousFailures = this.listenerFailureCounts.get(listener) || 0;
-        if (previousFailures > 0) {
-          this.listenerFailureCounts.set(listener, 0);
-          this.failedListeners.delete(listener);
-        }
-      } catch (error) {
-        // Track failures
-        const failureCount = (this.listenerFailureCounts.get(listener) || 0) + 1;
-        this.listenerFailureCounts.set(listener, failureCount);
-
-        // If listener fails too many times, blacklist it
-        if (failureCount >= this.MAX_FAILURES) {
-          this.failedListeners.add(listener);
-        }
-      }
-    }
-  }
-
-  /**
-   * Log error
-   */
-  logError(model: string, error: Error, feature?: string): void {
-    this.emit({
-      type: "error",
-      timestamp: Date.now(),
-      model,
-      feature,
-      metadata: {
-        error: error.message,
-        errorType: error.name,
-      },
-    });
-  }
-
-  /**
-   * Remove a specific listener
-   */
-  unsubscribe(listener: TelemetryListener): void {
-    const index = this.listeners.indexOf(listener);
-    if (index > -1) {
-      this.listeners.splice(index, 1);
-    }
-    // Clean up failure tracking
-    this.failedListeners.delete(listener);
-    this.listenerFailureCounts.delete(listener);
-  }
-}
-
-export const telemetryHooks = new TelemetryHooks();

package/src/infrastructure/utils/async/execute-state.util.ts

@@ -1,93 +0,0 @@
-/**
- * Async State Execution Utilities
- * Utilities for managing asynchronous operation state
- */
-
-/**
- * Callbacks for async operation outcomes
- */
-export interface AsyncStateCallbacks<T = string> {
-  onSuccess?: (result: T) => void;
-  onError?: (error: string) => void;
-}
-
-/**
- * Setter functions for updating state
- */
-export interface AsyncStateSetters<T = string, U = unknown> {
-  setIsLoading: (value: boolean) => void;
-  setError: (value: string | null) => void;
-  setResult: (value: T | null) => void;
-  setSecondaryResult?: (value: U | null) => void;
-}
-
-/**
- * Configuration for executeWithState
- */
-export interface AsyncStateConfig<T = string> {
-  resetState?: boolean;
-  transformResult?: (result: T) => T;
-}
-
-/**
- * Execute an async operation with automatic state management
- *
- * @param setters - State setter functions
- * @param callbacks - Optional callbacks for success/error
- * @param execute - The async operation to execute
- * @param onResult - Function to handle successful result
- * @param config - Optional configuration
- *
- * @returns The result or null if failed/aborted
- *
- * @example
- * ```ts
- * const result = await executeWithState(
- *   { setIsLoading, setError, setResult },
- *   { onSuccess: console.log },
- *   () => apiCall(),
- *   (data) => setResult(data)
- * );
- * ```
- */
-export async function executeWithState<T, U = unknown>(
-  setters: AsyncStateSetters<T, U>,
-  callbacks: AsyncStateCallbacks<T>,
-  execute: () => Promise<T>,
-  onResult: (result: T) => void,
-  config: AsyncStateConfig<T> = {},
-): Promise<T | null> {
-  const {
-    resetState = true,
-    transformResult,
-  } = config;
-
-  if (resetState) {
-    setters.setError(null);
-    setters.setResult(null);
-    setters.setSecondaryResult?.(null);
-  }
-
-  setters.setIsLoading(true);
-
-  try {
-    const result = await execute();
-
-    // Apply transformation if provided
-    const finalResult = transformResult ? transformResult(result) : result;
-
-    onResult(finalResult);
-    callbacks.onSuccess?.(finalResult);
-
-    return finalResult;
-  } catch (err) {
-    const errorMessage = err instanceof Error ? err.message : "Operation failed";
-
-    setters.setError(errorMessage);
-    callbacks.onError?.(errorMessage);
-
-    return null;
-  } finally {
-    setters.setIsLoading(false);
-  }
-}

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

@@ -1,175 +0,0 @@
-/**
- * Content Mapper Utilities
- * Handles transformation between domain content and SDK format
- */
-
-import type { Part } from "@google/generative-ai";
-import type {
-  GeminiContent,
-  GeminiPart,
-  GeminiFinishReason,
-  GeminiSafetyRating,
-  GeminiResponse,
-  GeminiHarmCategory,
-} from "../../domain/entities";
-
-const VALID_FINISH_REASONS: readonly string[] = [
-  "FINISH_REASON_UNSPECIFIED",
-  "STOP",
-  "MAX_TOKENS",
-  "SAFETY",
-  "RECITATION",
-  "OTHER",
-] as const;
-
-const VALID_HARM_CATEGORIES: readonly string[] = [
-  "HARM_CATEGORY_HARASSMENT",
-  "HARM_CATEGORY_HATE_SPEECH",
-  "HARM_CATEGORY_SEXUALLY_EXPLICIT",
-  "HARM_CATEGORY_DANGEROUS_CONTENT",
-] as const;
-
-const VALID_PROBABILITIES: readonly string[] = [
-  "NEGLIGIBLE",
-  "LOW",
-  "MEDIUM",
-  "HIGH",
-] as const;
-
-function isValidFinishReason(value: string): value is GeminiFinishReason {
-  return VALID_FINISH_REASONS.includes(value);
-}
-
-function isValidHarmCategory(value: string): value is GeminiHarmCategory {
-  return VALID_HARM_CATEGORIES.includes(value);
-}
-
-function isValidProbability(value: string): value is GeminiSafetyRating["probability"] {
-  return VALID_PROBABILITIES.includes(value);
-}
-
-/**
- * Convert domain content to SDK format
- * Preserves both text and inlineData parts
- */
-export function toSdkContent(contents: GeminiContent[]): Array<{
-  role: string;
-  parts: Part[];
-}> {
-  return contents.map((content) => ({
-    role: content.role || "user",
-    parts: content.parts.map((part) => {
-      if ("text" in part) {
-        return { text: part.text } as Part;
-      }
-      // For inlineData and other part types, cast to SDK Part type
-      return part as Part;
-    }),
-  }));
-}
-
-/**
- * Create a simple text content
- */
-export function createTextContent(
-  text: string,
-  role: "user" | "model" = "user"
-): GeminiContent {
-  return {
-    parts: [{ text }],
-    role,
-  };
-}
-
-/**
- * Transform SDK candidate to domain format
- */
-function transformCandidate(
-  candidate: {
-    content: { parts: Array<{ text?: string }>; role?: string };
-    finishReason?: string;
-    safetyRatings?: Array<{
-      category: string;
-      probability: string;
-    }>;
-  }
-): {
-  content: GeminiContent;
-  finishReason?: GeminiFinishReason;
-  safetyRatings?: GeminiSafetyRating[];
-} {
-  const transformedParts: GeminiPart[] = [];
-
-  for (const part of candidate.content.parts) {
-    if ("text" in part && typeof part.text === "string") {
-      transformedParts.push({ text: part.text });
-    }
-  }
-
-  const finishReason: GeminiFinishReason | undefined =
-    candidate.finishReason && isValidFinishReason(candidate.finishReason)
-      ? candidate.finishReason
-      : undefined;
-
-  const safetyRatings: GeminiSafetyRating[] | undefined = candidate.safetyRatings
-    ? candidate.safetyRatings
-        .filter((rating) => isValidHarmCategory(rating.category) && isValidProbability(rating.probability))
-        .map((rating) => ({
-          category: rating.category as GeminiHarmCategory,
-          probability: rating.probability as GeminiSafetyRating["probability"],
-        }))
-    : undefined;
-
-  const role = candidate.content.role === "user" || candidate.content.role === "model"
-    ? candidate.content.role
-    : "model";
-
-  return {
-    content: {
-      parts: transformedParts,
-      role,
-    },
-    finishReason,
-    safetyRatings,
-  };
-}
-
-/**
- * Transform SDK response to domain format
- */
-export function transformResponse(
-  response: {
-    candidates?: Array<{
-      content: { parts: Array<{ text?: string }>; role?: string };
-      finishReason?: string;
-      safetyRatings?: Array<{
-        category: string;
-        probability: string;
-      }>;
-    }>;
-    usageMetadata?: {
-      promptTokenCount?: number;
-      candidatesTokenCount?: number;
-      totalTokenCount?: number;
-    };
-  }
-): GeminiResponse {
-  return {
-    candidates: response.candidates?.map(transformCandidate),
-    usageMetadata: response.usageMetadata ? {
-      promptTokenCount: response.usageMetadata.promptTokenCount,
-      candidatesTokenCount: response.usageMetadata.candidatesTokenCount,
-      totalTokenCount: response.usageMetadata.totalTokenCount,
-    } : undefined,
-  };
-}
-
-/**
- * Extract text from content parts
- */
-export function extractTextFromParts(parts: GeminiPart[] | undefined): string {
-  if (!parts || parts.length === 0) return "";
-  return parts
-    .map((part) => ("text" in part ? (part.text || "") : ""))
-    .join("");
-}

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

@@ -1,145 +0,0 @@
-
-import {
-  GeminiErrorType,
-  type GeminiErrorInfo,
-  type GeminiApiError,
-  GeminiError,
-} from "../../domain/entities";
-
-const ERROR_PATTERNS: Array<{
-  pattern: RegExp | string[];
-  type: GeminiErrorType;
-  retryable: boolean;
-}> = [
-  {
-    pattern: ["quota", "resource exhausted", "429"],
-    type: GeminiErrorType.QUOTA_EXCEEDED,
-    retryable: true,
-  },
-  {
-    pattern: ["rate limit", "too many requests"],
-    type: GeminiErrorType.RATE_LIMIT,
-    retryable: true,
-  },
-  {
-    pattern: ["unauthorized", "invalid api key", "401", "403", "permission"],
-    type: GeminiErrorType.AUTHENTICATION,
-    retryable: false,
-  },
-  {
-    pattern: ["safety", "safety filter", "harmful", "blocked by safety"],
-    type: GeminiErrorType.SAFETY,
-    retryable: false,
-  },
-  {
-    pattern: ["model not found", "404", "not found"],
-    type: GeminiErrorType.MODEL_NOT_FOUND,
-    retryable: false,
-  },
-  {
-    pattern: ["network", "fetch failed", "connection", "socket"],
-    type: GeminiErrorType.NETWORK,
-    retryable: true,
-  },
-  {
-    pattern: ["timeout", "timed out"],
-    type: GeminiErrorType.TIMEOUT,
-    retryable: true,
-  },
-  {
-    pattern: ["500", "502", "503", "504", "internal server", "unavailable"],
-    type: GeminiErrorType.SERVER,
-    retryable: true,
-  },
-  {
-    pattern: ["invalid", "bad request", "400"],
-    type: GeminiErrorType.VALIDATION,
-    retryable: false,
-  },
-];
-
-function getStatusCode(error: unknown): number | undefined {
-  if (error && typeof error === "object") {
-    const err = error as Record<string, unknown>;
-    if (typeof err.status === "number") return err.status;
-    if (typeof err.statusCode === "number") return err.statusCode;
-
-    const response = err.response as GeminiApiError | undefined;
-    if (response?.error?.code) return response.error.code;
-  }
-  return undefined;
-}
-
-function matchesPattern(message: string, patterns: string[]): boolean {
-  const lower = message.toLowerCase();
-
-  return patterns.some((pattern) => {
-    const lowerPattern = pattern.toLowerCase();
-
-    // Use word boundary matching for accuracy
-    // This prevents "invalid" from matching "valid"
-    const words = lowerPattern.split(/\s+/);
-    return words.every((word) => {
-      const escaped = word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-      return new RegExp(`\\b${escaped}\\b`, 'i').test(lower);
-    });
-  });
-}
-
-/** Map HTTP status codes to error types as a primary classification signal */
-const STATUS_CODE_MAP: Record<number, { type: GeminiErrorType; retryable: boolean }> = {
-  400: { type: GeminiErrorType.VALIDATION, retryable: false },
-  401: { type: GeminiErrorType.AUTHENTICATION, retryable: false },
-  403: { type: GeminiErrorType.AUTHENTICATION, retryable: false },
-  404: { type: GeminiErrorType.MODEL_NOT_FOUND, retryable: false },
-  429: { type: GeminiErrorType.RATE_LIMIT, retryable: true },
-  500: { type: GeminiErrorType.SERVER, retryable: true },
-  502: { type: GeminiErrorType.SERVER, retryable: true },
-  503: { type: GeminiErrorType.SERVER, retryable: true },
-  504: { type: GeminiErrorType.SERVER, retryable: true },
-};
-
-function mapGeminiError(error: unknown): GeminiErrorInfo {
-  const message = error instanceof Error ? error.message : String(error);
-  const statusCode = getStatusCode(error);
-
-  // Primary: classify by HTTP status code when available
-  if (statusCode && STATUS_CODE_MAP[statusCode]) {
-    const { type, retryable } = STATUS_CODE_MAP[statusCode];
-    return {
-      type,
-      messageKey: `error.gemini.${type.toLowerCase()}`,
-      retryable,
-      originalError: error,
-      statusCode,
-    };
-  }
-
-  // Secondary: classify by error message pattern
-  for (const { pattern, type, retryable } of ERROR_PATTERNS) {
-    const patterns = Array.isArray(pattern) ? pattern : [pattern.source];
-
-    if (matchesPattern(message, patterns)) {
-      return {
-        type,
-        messageKey: `error.gemini.${type.toLowerCase()}`,
-        retryable,
-        originalError: error,
-        statusCode,
-      };
-    }
-  }
-
-  return {
-    type: GeminiErrorType.UNKNOWN,
-    messageKey: "error.gemini.unknown",
-    retryable: false,
-    originalError: error,
-    statusCode,
-  };
-}
-
-export function createGeminiError(error: unknown): GeminiError {
-  const errorInfo = mapGeminiError(error);
-  return GeminiError.fromError(error, errorInfo);
-}

package/src/infrastructure/utils/gemini-data-transformer.util.ts

@@ -1,40 +0,0 @@
-
-import type { GeminiResponse } from "../../domain/entities";
-
-
-export function extractTextFromResponse(response: GeminiResponse): string {
-  if (!response.candidates || response.candidates.length === 0) {
-    throw new Error("No response candidates");
-  }
-
-  const candidate = response.candidates[0];
-
-  // Handle all finish reasons appropriately
-  switch (candidate.finishReason) {
-    case "SAFETY":
-      throw new Error("Content blocked by safety filters");
-    case "RECITATION":
-      throw new Error("Content blocked due to recitation concerns");
-    case "MAX_TOKENS":
-    case "FINISH_REASON_UNSPECIFIED":
-    case "OTHER":
-    case "STOP":
-    case undefined:
-      // Continue to extract text
-      break;
-  }
-
-  if (!candidate.content?.parts) {
-    throw new Error("No content in response candidate");
-  }
-
-  const textPart = candidate.content.parts.find(
-    (p): p is { text: string } => "text" in p && typeof p.text === "string",
-  );
-
-  if (!textPart) {
-    throw new Error("No text in response");
-  }
-
-  return textPart.text;
-}

package/src/infrastructure/utils/text-calculations.util.ts

@@ -1,70 +0,0 @@
-/**
- * Text Calculation Utilities
- * Reusable functions for text length and character budget calculations
- */
-
-/**
- * Calculate total character count in an array of text objects
- * @param items - Array of objects with text content
- * @param getText - Function to extract text from each item
- * @returns Total character count
- */
-export function calculateTotalChars<T>(
-  items: readonly T[],
-  getItemLength: (item: T) => number
-): number {
-  return items.reduce((sum, item) => sum + getItemLength(item), 0);
-}
-
-/**
- * Check if adding an item would exceed the character budget
- * @param currentTotal - Current total character count
- * @param itemLength - Length of item to add
- * @param maxBudget - Maximum allowed budget
- * @returns true if within budget, false otherwise
- */
-export function fitsWithinBudget(
-  currentTotal: number,
-  itemLength: number,
-  maxBudget: number
-): boolean {
-  return currentTotal + itemLength <= maxBudget;
-}
-
-/**
- * Trim array to fit within character budget while keeping minimum items
- * Keeps the last `minItems` regardless of budget, then adds as many as possible from the end
- *
- * @param items - Array to trim
- * @param getItemLength - Function to get length of each item
- * @param maxBudget - Maximum total length allowed
- * @param minItems - Minimum number of items to keep (from the end)
- * @returns Trimmed array
- */
-export function trimArrayByCharBudget<T>(
-  items: readonly T[],
-  getItemLength: (item: T) => number,
-  maxBudget: number,
-  minItems: number
-): T[] {
-  if (items.length <= minItems) return [...items];
-
-  // First, guarantee minimum items (from the end)
-  const guaranteedMin = items.slice(-minItems);
-  const remaining = items.slice(0, -minItems);
-
-  // Calculate current total
-  let totalChars = calculateTotalChars(guaranteedMin, getItemLength);
-  const trimmed: T[] = [...guaranteedMin];
-
-  // Add older items in reverse order until budget is exceeded
-  for (let i = remaining.length - 1; i >= 0; i--) {
-    const itemLength = getItemLength(remaining[i]);
-    if (!fitsWithinBudget(totalChars, itemLength, maxBudget)) break;
-
-    trimmed.unshift(remaining[i]);
-    totalChars += itemLength;
-  }
-
-  return trimmed;
-}