@umituz/react-native-ai-gemini-provider 3.0.26 → 3.0.27

package/package.json

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

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

@@ -118,9 +118,9 @@ export class GeminiError extends Error {
   static fromError(error: unknown, info: GeminiErrorInfo): GeminiError {
     const geminiError = new GeminiError(info);
 
-    // If original error was an Error, preserve its stack trace
-    if (error instanceof Error && error.stack && !geminiError.stack) {
-      geminiError.stack = error.stack;
+    // Preserve original error's stack trace for better debugging
+    if (error instanceof Error && error.stack) {
+      geminiError.stack = `${geminiError.stack}\nCaused by: ${error.stack}`;
     }
 
     return geminiError;

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

@@ -6,9 +6,7 @@ import type { GenerationConfig } from "@google/generative-ai";
 export interface GeminiConfig {
   /** API key for authentication */
   apiKey: string;
-  /** Optional base URL for API requests */
-  baseUrl?: string;
-  /** Default timeout in milliseconds */
+  /** Default timeout in milliseconds (used by external consumers for timeout logic) */
   defaultTimeoutMs?: number;
   /** Default model to use for text generation */
   textModel?: string;
@@ -16,11 +14,8 @@ export interface GeminiConfig {
 
 /**
  * Generation configuration for AI requests
- * Extends the SDK's GenerationConfig with proper schema typing
  */
-export type GeminiGenerationConfig = Omit<GenerationConfig, "responseSchema"> & {
-  responseSchema?: GenerationConfig["responseSchema"];
-};
+export type GeminiGenerationConfig = GenerationConfig;
 
 /**
  * Harm categories for content safety filtering

package/src/infrastructure/services/BaseService.ts

@@ -1,6 +1,7 @@
 import { geminiClient } from "./GeminiClient";
 import { toSdkContent } from "../utils/content-mapper.util";
 import { createGeminiError } from "../utils/error-mapper.util";
+import { GeminiError } from "../../domain/entities";
 import type { GeminiContent, GeminiGenerationConfig } from "../../domain/entities";
 import type { GenerativeModel } from "@google/generative-ai";
 
@@ -31,7 +32,7 @@ export abstract class BaseGeminiService {
   }
 
   protected handleError(error: unknown, abortMessage: string): never {
-    if (error instanceof Error && error.name === "GeminiError") {
+    if (error instanceof GeminiError) {
       throw error;
     }
 

package/src/infrastructure/services/ChatSession.ts

@@ -64,9 +64,20 @@ export function resolveAudioMimeType(extension: string): string {
   return AUDIO_MIME[extension.toLowerCase()] ?? "audio/mp4";
 }
 
+const IMAGE_MIME: Record<string, string> = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  webp: "image/webp",
+  gif: "image/gif",
+  heic: "image/heic",
+  heif: "image/heif",
+  bmp: "image/bmp",
+};
+
 /** Resolve MIME type for an image file extension */
 export function resolveImageMimeType(extension: string): string {
-  return extension.toLowerCase() === "png" ? "image/png" : "image/jpeg";
+  return IMAGE_MIME[extension.toLowerCase()] ?? "image/jpeg";
 }
 
 // ─── History Utilities ───────────────────────────────────────────────────────
@@ -90,9 +101,12 @@ export function buildChatHistory(
     const last = result[result.length - 1];
 
     if (last && last.role === role) {
-      const existingText =
-        "text" in last.parts[0] ? (last.parts[0].text ?? "") : "";
-      last.parts[0] = { text: existingText + "\n" + m.content };
+      // Merge by extracting all text from existing parts and appending new content
+      const existingText = last.parts
+        .map((p) => ("text" in p ? (p.text ?? "") : ""))
+        .filter(Boolean)
+        .join("");
+      last.parts = [{ text: existingText + "\n" + m.content }];
     } else {
       result.push({ role, parts: [{ text: m.content }] });
     }
@@ -162,7 +176,17 @@ export function createChatSession(config: GeminiChatConfig = {}) {
       const result = await chat.sendMessage(parts as Part[]);
       if (!result.response) throw new Error("No response from Gemini SDK");
       const candidate = result.response.candidates?.[0];
-      const text = result.response.text();
+
+      // SDK's text() throws on safety-blocked responses with no text
+      let text: string;
+      try {
+        text = result.response.text();
+      } catch {
+        if (String(candidate?.finishReason) === "SAFETY") {
+          throw new Error("Response blocked by safety filter.");
+        }
+        throw new Error("No text content in response");
+      }
 
       if (__DEV__) {
         console.log("[ChatSession.send] <<< GEMINI SDK RESPONSE");
@@ -175,7 +199,7 @@ export function createChatSession(config: GeminiChatConfig = {}) {
 
       return {
         text,
-        finishReason: candidate?.finishReason ?? undefined,
+        finishReason: candidate?.finishReason,
       };
     },
   };
@@ -200,6 +224,10 @@ export function createChatSession(config: GeminiChatConfig = {}) {
 export async function sendChatMessage(
   opts: SendChatMessageOptions,
 ): Promise<string> {
+  if (!opts.message || opts.message.trim().length === 0) {
+    throw new Error("Message cannot be empty");
+  }
+
   if (__DEV__) {
     console.log("═══════════════════════════════════════════════════");
     console.log("[sendChatMessage] >>> START");

package/src/infrastructure/services/GeminiClient.ts

@@ -26,12 +26,11 @@ class GeminiClient {
   private initialized = false;
 
   initialize(config: GeminiConfig): void {
-    if (this.initialized) return;
-
     if (!config.apiKey || config.apiKey.trim().length < 10) {
       throw new Error("API key is required and must be at least 10 characters");
     }
 
+    // Allow re-initialization with new config (e.g. API key change)
     this.client = new GoogleGenerativeAI(config.apiKey);
     this.config = { ...DEFAULT_CONFIG, ...config };
     this.initialized = true;

package/src/infrastructure/services/StructuredText.ts

@@ -16,6 +16,10 @@ class StructuredTextService {
     config?: Omit<GeminiGenerationConfig, "responseMimeType" | "responseSchema">,
     signal?: AbortSignal,
   ): Promise<T> {
+    if (!prompt || prompt.trim().length < 3) {
+      throw new Error("Prompt must be at least 3 characters");
+    }
+
     if (!schema || typeof schema !== "object" || Object.keys(schema).length === 0) {
       throw new Error("Schema must be a non-empty object");
     }
@@ -47,7 +51,7 @@ class StructuredTextService {
       throw new Error("No candidates in response");
     }
 
-    const text = extractTextFromParts(candidates[0].content.parts);
+    const text = extractTextFromParts(candidates[0]?.content?.parts);
 
     if (!text || text.trim().length === 0) {
       throw new Error("Empty response received from Gemini");

package/src/infrastructure/telemetry/TelemetryHooks.ts

@@ -40,7 +40,9 @@ class TelemetryHooks {
    * Emit a telemetry event to all listeners
    */
   emit(event: TelemetryEvent): void {
-    for (const listener of this.listeners) {
+    // 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;
@@ -85,12 +87,13 @@ class TelemetryHooks {
    * Log response received
    */
   logResponse(model: string, startTime: number, feature?: string, metadata?: Record<string, unknown>): void {
+    const now = Date.now();
     this.emit({
       type: "response",
-      timestamp: Date.now(),
+      timestamp: now,
       model,
       feature,
-      duration: Date.now() - startTime,
+      duration: now - startTime,
       metadata,
     });
   }

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

@@ -159,7 +159,8 @@ export function transformResponse(
 /**
  * Extract text from content parts
  */
-export function extractTextFromParts(parts: GeminiPart[]): string {
+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

@@ -27,7 +27,7 @@ const ERROR_PATTERNS: Array<{
     retryable: false,
   },
   {
-    pattern: ["safety", "blocked", "harmful"],
+    pattern: ["safety", "safety filter", "harmful", "blocked by safety"],
     type: GeminiErrorType.SAFETY,
     retryable: false,
   },
@@ -76,21 +76,46 @@ function matchesPattern(message: string, patterns: string[]): boolean {
   return patterns.some((pattern) => {
     const lowerPattern = pattern.toLowerCase();
 
-    // Use word boundary matching for better accuracy
+    // Use word boundary matching for accuracy
     // This prevents "invalid" from matching "valid"
     const words = lowerPattern.split(/\s+/);
     return words.every((word) => {
-      // Check if the word appears as a whole word or with common punctuation
-      const regex = new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'i');
-      return regex.test(lower) || lower.includes(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];
 

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

@@ -24,6 +24,10 @@ export function extractTextFromResponse(response: GeminiResponse): string {
       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",
   );

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

@@ -21,14 +21,12 @@ export async function processStream(
   let fullText = "";
 
   for await (const chunk of stream) {
-    try {
-      const chunkText = chunk.text();
-      if (chunkText) {
-        fullText += chunkText;
-        safeCallChunk(onChunk, chunkText, onError);
-      }
-    } catch (chunkError) {
-      logError(onError, chunkError, "stream-chunk");
+    // chunk.text() errors are critical (e.g. safety blocks mid-stream)
+    // and must propagate, unlike callback errors which are safe to swallow
+    const chunkText = chunk.text();
+    if (chunkText) {
+      fullText += chunkText;
+      safeCallChunk(onChunk, chunkText, onError);
     }
   }
 

package/src/providers/ConfigBuilder.ts

@@ -117,8 +117,9 @@ export class ConfigBuilder {
     const builder = new ConfigBuilder();
     if (config.apiKey) builder.withApiKey(config.apiKey);
     if (config.textModel) builder.withTextModel(config.textModel);
-    if (config.timeout) builder.withTimeout(config.timeout);
+    // Apply strategy first (sets default timeout), then explicit timeout overrides it
     if (config.strategy) builder.withStrategy(config.strategy);
+    if (config.timeout != null && config.timeout > 0) builder.withTimeout(config.timeout);
     return builder;
   }
 }

package/src/providers/ProviderFactory.ts

@@ -66,15 +66,8 @@ class ProviderFactory {
       throw new Error("Provider not initialized. Call initialize() first.");
     }
 
-    // If API key changes, re-initialize
-    if (updates.apiKey && updates.apiKey !== this.currentConfig.apiKey) {
-      this.initialize({ ...this.currentConfig, ...updates });
-      return;
-    }
-
-    // Otherwise, update using builder
-    this.builder = ConfigBuilder.from({ ...this.currentConfig, ...updates });
-    this.currentConfig = this.builder.build();
+    // Re-initialize with merged config to ensure GeminiClient is updated
+    this.initialize({ ...this.currentConfig, ...updates });
   }
 }
 

package/src/infrastructure/services/GeminiProvider.ts

@@ -1,38 +0,0 @@
-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/index.ts

@@ -1,16 +0,0 @@
-export { geminiClient } from "./GeminiClient";
-export { textGeneration } from "./TextGeneration";
-export { structuredText } from "./StructuredText";
-export { streaming } from "./Streaming";
-export { geminiProvider, GeminiProvider } from "./GeminiProvider";
-export {
-  createChatSession,
-  sendChatMessage,
-  buildChatHistory,
-  trimChatHistory,
-  resolveAudioMimeType,
-  resolveImageMimeType,
-  type ChatSendResult,
-  type ChatHistoryMessage,
-  type SendChatMessageOptions,
-} from "./ChatSession";

package/src/infrastructure/telemetry/index.ts

@@ -1,5 +0,0 @@
-/**
- * Telemetry Module
- */
-
-export { telemetryHooks } from "./TelemetryHooks";

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

@@ -1,8 +0,0 @@
-/**
- * Async State Management - Internal Use Only
- */
-
-export {
-  executeWithState,
-  type AsyncStateSetters,
-} from "./execute-state.util";

package/src/presentation/hooks/index.ts

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

package/src/providers/index.ts

@@ -1,9 +0,0 @@
-/**
- * Provider Configuration & Factory - Public API
- */
-
-export { ConfigBuilder } from "./ConfigBuilder";
-export type { ProviderConfig } from "./ConfigBuilder";
-
-export { providerFactory } from "./ProviderFactory";
-export type { ProviderFactoryOptions } from "./ProviderFactory";