@umituz/react-native-ai-gemini-provider 3.0.28 → 3.0.30

package/dist/index.d.ts

@@ -5,12 +5,11 @@
 export type { GeminiConfig, GeminiGenerationConfig, GeminiHarmCategory, GeminiHarmBlockThreshold, GeminiContent, GeminiPart, GeminiInlineDataPart, GeminiMessagePart, GeminiSafetySetting, GeminiModelOptions, GeminiChatConfig, GeminiResponse, GeminiCandidate, GeminiFinishReason, GeminiSafetyRating, GeminiUsageMetadata, GeminiErrorInfo, GeminiApiError, } from "./domain/entities";
 export { GeminiErrorType, GeminiError, GEMINI_MODELS, DEFAULT_MODELS } from "./domain/entities";
 export { geminiClient } from "./infrastructure/services/GeminiClient";
-export { createChatSession, sendChatMessage, buildChatHistory, trimChatHistory, resolveAudioMimeType, resolveImageMimeType, type ChatSendResult, type ChatHistoryMessage, type SendChatMessageOptions, } from "./infrastructure/services/ChatSession";
+export { createChatSession, sendChatMessage, buildChatHistory, trimChatHistory, type ChatSendResult, type ChatHistoryMessage, type SendChatMessageOptions, } from "./infrastructure/services/ChatSession";
 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";
-export { useGemini } from "./presentation/hooks";
-export type { UseGeminiOptions, UseGeminiReturn } from "./presentation/hooks";
-export { ConfigBuilder, providerFactory } from "./providers";
-export type { ProviderConfig, ProviderFactoryOptions, } from "./providers";
+export { useGemini } from "./presentation/hooks/useGemini";
+export type { UseGeminiOptions, UseGeminiReturn } from "./presentation/hooks/useGemini";
+export { ConfigBuilder, providerFactory } from "./providers/ProviderFactory";
+export type { ProviderConfig, ProviderFactoryOptions, } from "./providers/ProviderFactory";

package/dist/infrastructure/services/BaseService.d.ts

@@ -1,5 +1,6 @@
 import type { GeminiContent, GeminiGenerationConfig } from "../../domain/entities";
 import type { GenerativeModel } from "@google/generative-ai";
+import type { Part } from "@google/generative-ai";
 export interface BaseRequestOptions {
     model: string;
     contents: GeminiContent[];
@@ -11,23 +12,17 @@ export declare abstract class BaseGeminiService {
         genModel: GenerativeModel;
         sdkContents: Array<{
             role: string;
-            parts: Array<{
-                text: string;
-            }>;
+            parts: Part[];
         }>;
     };
     protected handleError(error: unknown, abortMessage: string): never;
     protected createRequestOptions(sdkContents: Array<{
         role: string;
-        parts: Array<{
-            text: string;
-        }>;
+        parts: Part[];
     }>, generationConfig?: GeminiGenerationConfig): {
         contents: {
             role: string;
-            parts: Array<{
-                text: string;
-            }>;
+            parts: Part[];
         }[];
         generationConfig: import("@google/generative-ai").GenerationConfig | undefined;
     };

package/dist/infrastructure/services/ChatSession.d.ts

@@ -29,10 +29,6 @@ export interface SendChatMessageOptions {
     /** Min messages to always keep regardless of budget (default 4) */
     historyMinMessages?: number;
 }
-/** Resolve MIME type for an audio file extension */
-export declare function resolveAudioMimeType(extension: string): string;
-/** Resolve MIME type for an image file extension */
-export declare function resolveImageMimeType(extension: string): string;
 /**
  * Converts chat messages (user/assistant/system) to Gemini SDK content format.
  * Skips system messages, merges consecutive same-role messages.

package/dist/infrastructure/services/GeminiClient.d.ts

@@ -1,13 +1,10 @@
-import { GoogleGenerativeAI, type GenerativeModel } from "@google/generative-ai";
+import { type GenerativeModel } from "@google/generative-ai";
 import type { GeminiConfig, GeminiModelOptions } from "../../domain/entities";
 declare class GeminiClient {
     private client;
     private config;
     private initialized;
     initialize(config: GeminiConfig): void;
-    isInitialized(): boolean;
-    getConfig(): GeminiConfig | null;
-    getClient(): GoogleGenerativeAI | null;
     /**
      * Returns a GenerativeModel configured with optional safety settings and system instruction.
      * When no safety settings are provided, defaults to BLOCK_NONE for all categories.

package/dist/infrastructure/services/StructuredText.d.ts

@@ -1,7 +1,6 @@
 import type { GeminiGenerationConfig } from "../../domain/entities";
 declare class StructuredTextService {
     generateStructuredText<T>(model: string, prompt: string, schema: Record<string, unknown>, config?: Omit<GeminiGenerationConfig, "responseMimeType" | "responseSchema">, signal?: AbortSignal): Promise<T>;
-    private parseJSONResponse;
 }
 export declare const structuredText: StructuredTextService;
 export {};

package/dist/infrastructure/telemetry/TelemetryHooks.d.ts

@@ -1,9 +1,8 @@
 export interface TelemetryEvent {
-    type: "request" | "response" | "error" | "retry";
+    type: "error";
     timestamp: number;
     model?: string;
     feature?: string;
-    duration?: number;
     metadata?: Record<string, unknown>;
 }
 export type TelemetryListener = (event: TelemetryEvent) => void;
@@ -14,44 +13,29 @@ declare class TelemetryHooks {
     private listenerFailureCounts;
     /**
      * 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;
     /**
      * Emit a telemetry event to all listeners
      */
     emit(event: TelemetryEvent): void;
-    /**
-     * Log request start
-     */
-    logRequest(model: string, feature?: string): number;
-    /**
-     * Log response received
-     */
-    logResponse(model: string, startTime: number, feature?: string, metadata?: Record<string, unknown>): void;
     /**
      * Log error
      */
     logError(model: string, error: Error, feature?: string): void;
-    /**
-     * Log retry attempt
-     */
-    logRetry(model: string, attempt: number, feature?: string): void;
     /**
      * Remove a specific listener
      */
     unsubscribe(listener: TelemetryListener): void;
-    /**
-     * Reset failure counts for all listeners (clear blacklist)
-     */
-    resetFailures(): void;
-    /**
-     * Clear all listeners
-     */
-    clear(): void;
-    /**
-     * Get current listener count
-     */
-    getListenerCount(): number;
 }
 export declare const telemetryHooks: TelemetryHooks;
 export {};

package/dist/infrastructure/utils/async/execute-state.util.d.ts

@@ -23,7 +23,6 @@ export interface AsyncStateSetters<T = string, U = unknown> {
  */
 export interface AsyncStateConfig<T = string> {
     resetState?: boolean;
-    throwOnError?: boolean;
     transformResult?: (result: T) => T;
 }
 /**

package/dist/infrastructure/utils/content-mapper.util.d.ts

@@ -2,15 +2,15 @@
  * Content Mapper Utilities
  * Handles transformation between domain content and SDK format
  */
+import type { Part } from "@google/generative-ai";
 import type { GeminiContent, GeminiPart, GeminiResponse } from "../../domain/entities";
 /**
  * Convert domain content to SDK format
+ * Preserves both text and inlineData parts
  */
 export declare function toSdkContent(contents: GeminiContent[]): Array<{
     role: string;
-    parts: Array<{
-        text: string;
-    }>;
+    parts: Part[];
 }>;
 /**
  * Create a simple text content

package/dist/presentation/hooks/useGemini.d.ts

@@ -7,7 +7,7 @@ export interface UseGeminiOptions {
 }
 export interface UseGeminiReturn {
     generate: (prompt: string) => Promise<void>;
-    generateJSON: <T>(prompt: string, schema?: Record<string, unknown>) => Promise<T | null>;
+    generateJSON: <T>(prompt: string, schema: Record<string, unknown>) => Promise<T | null>;
     result: string | null;
     jsonResult: unknown;
     isGenerating: boolean;

package/dist/providers/ConfigBuilder.d.ts

@@ -43,8 +43,4 @@ export declare class ConfigBuilder {
      * Create a new builder instance
      */
     static create(): ConfigBuilder;
-    /**
-     * Create from existing config (for updates)
-     */
-    static from(config: Partial<ProviderConfig>): ConfigBuilder;
 }

package/dist/providers/ProviderFactory.d.ts

@@ -1,4 +1,3 @@
-import { type ProviderConfig } from "./ConfigBuilder";
 export { ConfigBuilder } from "./ConfigBuilder";
 export type { ProviderConfig } from "./ConfigBuilder";
 export interface ProviderFactoryOptions {
@@ -9,15 +8,10 @@ export interface ProviderFactoryOptions {
 }
 declare class ProviderFactory {
     private currentConfig;
-    private builder;
     /**
      * Initialize provider with configuration
      */
     initialize(options: ProviderFactoryOptions): void;
-    /**
-     * Get current configuration
-     */
-    getConfig(): ProviderConfig | null;
     /**
      * Check if provider is initialized
      */

package/package.json

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

package/src/index.ts

@@ -39,8 +39,6 @@ export {
   sendChatMessage,
   buildChatHistory,
   trimChatHistory,
-  resolveAudioMimeType,
-  resolveImageMimeType,
   type ChatSendResult,
   type ChatHistoryMessage,
   type SendChatMessageOptions,

package/src/infrastructure/services/BaseService.ts

@@ -4,6 +4,7 @@ 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";
+import type { Part } from "@google/generative-ai";
 
 export interface BaseRequestOptions {
   model: string;
@@ -15,7 +16,7 @@ export interface BaseRequestOptions {
 export abstract class BaseGeminiService {
   protected validateAndPrepare(options: BaseRequestOptions): {
     genModel: GenerativeModel;
-    sdkContents: Array<{ role: string; parts: Array<{ text: string }> }>;
+    sdkContents: Array<{ role: string; parts: Part[] }>;
   } {
     if (!options.contents || options.contents.length === 0) {
       throw new Error("Contents array cannot be empty");
@@ -44,7 +45,7 @@ export abstract class BaseGeminiService {
   }
 
   protected createRequestOptions(
-    sdkContents: Array<{ role: string; parts: Array<{ text: string }> }>,
+    sdkContents: Array<{ role: string; parts: Part[] }>,
     generationConfig?: GeminiGenerationConfig
   ) {
     return { contents: sdkContents, generationConfig };

package/src/infrastructure/services/ChatSession.ts

@@ -1,6 +1,7 @@
 import type { ChatSession as SdkChatSession, Part } from "@google/generative-ai";
 import { geminiClient } from "./GeminiClient";
 import { DEFAULT_MODELS } from "../../domain/entities";
+import { trimArrayByCharBudget } from "../utils/text-calculations.util";
 import type {
   GeminiChatConfig,
   GeminiGenerationConfig,
@@ -45,41 +46,6 @@ export interface SendChatMessageOptions {
   historyMinMessages?: number;
 }
 
-// ─── MIME Utilities ──────────────────────────────────────────────────────────
-
-const AUDIO_MIME: Record<string, string> = {
-  mp3: "audio/mpeg",
-  wav: "audio/wav",
-  ogg: "audio/ogg",
-  flac: "audio/flac",
-  aac: "audio/aac",
-  mp4: "audio/mp4",
-  m4a: "audio/mp4",
-  caf: "audio/mp4",
-  "3gp": "audio/3gpp",
-};
-
-/** Resolve MIME type for an audio file extension */
-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 IMAGE_MIME[extension.toLowerCase()] ?? "image/jpeg";
-}
-
 // ─── History Utilities ───────────────────────────────────────────────────────
 
 /**
@@ -102,10 +68,8 @@ export function buildChatHistory(
 
     if (last && last.role === role) {
       // 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("");
+      // Optimized: reduce instead of map + filter + join
+      const existingText = last.parts.reduce((acc, p) => acc + ("text" in p ? p.text : ""), "");
       last.parts = [{ text: existingText + "\n" + m.content }];
     } else {
       result.push({ role, parts: [{ text: m.content }] });
@@ -124,19 +88,12 @@ export function trimChatHistory(
   maxChars = 12000,
   minMessages = 4,
 ): ChatHistoryMessage[] {
-  if (history.length <= minMessages) return history;
-
-  let totalChars = 0;
-  const trimmed: ChatHistoryMessage[] = [];
-
-  for (let i = history.length - 1; i >= 0; i--) {
-    const chars = history[i].content.length;
-    if (trimmed.length >= minMessages && totalChars + chars > maxChars) break;
-    trimmed.unshift(history[i]);
-    totalChars += chars;
-  }
-
-  return trimmed;
+  return trimArrayByCharBudget(
+    history,
+    (m) => m.content.length,
+    maxChars,
+    minMessages,
+  );
 }
 
 // ─── Low-level: createChatSession ────────────────────────────────────────────
@@ -164,15 +121,6 @@ export function createChatSession(config: GeminiChatConfig = {}) {
 
   return {
     async send(parts: GeminiMessagePart[]): Promise<ChatSendResult> {
-      if (__DEV__) {
-        console.log("[ChatSession.send] >>> SENDING TO GEMINI SDK");
-        console.log("[ChatSession.send] parts count:", parts.length);
-        parts.forEach((p, i) => {
-          if ("text" in p) console.log(`[ChatSession.send] part[${i}] text:`, (p.text ?? "").substring(0, 200));
-          if ("inlineData" in p) console.log(`[ChatSession.send] part[${i}] inlineData: mime=${(p as GeminiInlineDataPart).inlineData.mimeType}, size=${(p as GeminiInlineDataPart).inlineData.data.length}`);
-        });
-      }
-
       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];
@@ -188,15 +136,6 @@ export function createChatSession(config: GeminiChatConfig = {}) {
         throw new Error("No text content in response");
       }
 
-      if (__DEV__) {
-        console.log("[ChatSession.send] <<< GEMINI SDK RESPONSE");
-        console.log("[ChatSession.send] finishReason:", candidate?.finishReason ?? "N/A");
-        console.log("[ChatSession.send] safetyRatings:", JSON.stringify(candidate?.safetyRatings ?? []));
-        console.log("[ChatSession.send] response text length:", text.length);
-        console.log("[ChatSession.send] response text:", text.substring(0, 500));
-        console.log("[ChatSession.send] response FULL text:", text);
-      }
-
       return {
         text,
         finishReason: candidate?.finishReason,
@@ -228,40 +167,14 @@ export async function sendChatMessage(
     throw new Error("Message cannot be empty");
   }
 
-  if (__DEV__) {
-    console.log("═══════════════════════════════════════════════════");
-    console.log("[sendChatMessage] >>> START");
-    console.log("[sendChatMessage] model:", opts.model ?? DEFAULT_MODELS.CHAT);
-    console.log("[sendChatMessage] message:", opts.message.substring(0, 200));
-    console.log("[sendChatMessage] history count:", opts.history.length);
-    console.log("[sendChatMessage] systemPrompt length:", opts.systemPrompt?.length ?? 0);
-    console.log("[sendChatMessage] systemPrompt (first 500):", opts.systemPrompt?.substring(0, 500));
-    console.log("[sendChatMessage] generationConfig:", JSON.stringify(opts.generationConfig));
-    console.log("[sendChatMessage] safetySettings:", opts.safetySettings ? JSON.stringify(opts.safetySettings) : "USING DEFAULT (BLOCK_NONE)");
-    console.log("[sendChatMessage] attachments:", opts.attachments?.length ?? 0);
-  }
-
   const trimmed = trimChatHistory(
     opts.history,
     opts.historyMaxChars,
     opts.historyMinMessages,
   );
 
-  if (__DEV__) {
-    console.log("[sendChatMessage] history after trim:", trimmed.length, "messages");
-    trimmed.forEach((m, i) => console.log(`[sendChatMessage] history[${i}]: role=${m.role}, content=${m.content.substring(0, 100)}`));
-  }
-
   const geminiHistory = buildChatHistory(trimmed);
 
-  if (__DEV__) {
-    console.log("[sendChatMessage] geminiHistory (SDK format):", geminiHistory.length, "turns");
-    geminiHistory.forEach((h, i) => {
-      const text = "text" in h.parts[0] ? (h.parts[0] as { text: string }).text : "[non-text]";
-      console.log(`[sendChatMessage] geminiHistory[${i}]: role=${h.role}, text=${text.substring(0, 100)}`);
-    });
-  }
-
   const session = createChatSession({
     model: opts.model ?? DEFAULT_MODELS.CHAT,
     systemInstruction: opts.systemPrompt,
@@ -277,16 +190,7 @@ export async function sendChatMessage(
 
   const result = await session.send(parts);
 
-  if (__DEV__) {
-    console.log("[sendChatMessage] finishReason:", result.finishReason);
-    console.log("[sendChatMessage] response text length:", result.text.length);
-    console.log("[sendChatMessage] response FULL:", result.text);
-    console.log("[sendChatMessage] <<< END");
-    console.log("═══════════════════════════════════════════════════");
-  }
-
   if (result.finishReason === "SAFETY") {
-    if (__DEV__) console.warn("[sendChatMessage] ⚠️ SAFETY FILTER TRIGGERED but has text, returning partial");
     if (result.text.trim()) return result.text;
     throw new Error("Response blocked by safety filter.");
   }

package/src/infrastructure/services/GeminiClient.ts

@@ -26,28 +26,23 @@ class GeminiClient {
   private initialized = false;
 
   initialize(config: GeminiConfig): void {
-    if (!config.apiKey || config.apiKey.trim().length < 10) {
+    const apiKey = config.apiKey?.trim();
+
+    if (!apiKey || apiKey.length < 10) {
       throw new Error("API key is required and must be at least 10 characters");
     }
 
+    // Basic format validation for Google AI API keys (starts with "AIza")
+    if (!apiKey.startsWith("AIza")) {
+      throw new Error('Invalid API key format. Google AI API keys should start with "AIza"');
+    }
+
     // Allow re-initialization with new config (e.g. API key change)
-    this.client = new GoogleGenerativeAI(config.apiKey);
-    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.client = new GoogleGenerativeAI(apiKey);
+    this.config = { ...DEFAULT_CONFIG, ...config, apiKey };
     this.initialized = true;
   }
 
-  isInitialized(): boolean {
-    return this.initialized;
-  }
-
-  getConfig(): GeminiConfig | null {
-    return this.config;
-  }
-
-  getClient(): GoogleGenerativeAI | null {
-    return this.client;
-  }
-
   /**
    * Returns a GenerativeModel configured with optional safety settings and system instruction.
    * When no safety settings are provided, defaults to BLOCK_NONE for all categories.
@@ -71,18 +66,35 @@ class GeminiClient {
 
     // Map package safety settings to SDK format
     const sdkSafety: SafetySetting[] = opts.safetySettings
-      ? opts.safetySettings.map((s) => ({
-          category: s.category as unknown as HarmCategory,
-          threshold: s.threshold as unknown as HarmBlockThreshold,
-        }))
+      ? opts.safetySettings.map((s) => {
+          // Validate safety settings to prevent runtime errors
+          const validCategories = [
+            HarmCategory.HARM_CATEGORY_HARASSMENT,
+            HarmCategory.HARM_CATEGORY_HATE_SPEECH,
+            HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
+            HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
+          ];
+
+          const validThresholds = [
+            HarmBlockThreshold.BLOCK_NONE,
+            HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
+            HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
+            HarmBlockThreshold.BLOCK_ONLY_HIGH,
+          ];
+
+          // Check if category and threshold are valid enum values
+          const category = validCategories.includes(s.category as unknown as HarmCategory)
+            ? (s.category as unknown as HarmCategory)
+            : HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT; // Fallback to safest
+
+          const threshold = validThresholds.includes(s.threshold as unknown as HarmBlockThreshold)
+            ? (s.threshold as unknown as HarmBlockThreshold)
+            : HarmBlockThreshold.BLOCK_NONE; // Fallback to most permissive
+
+          return { category, threshold };
+        })
       : PERMISSIVE_SAFETY;
 
-    if (__DEV__) {
-      console.log("[GeminiClient.getModel] model:", effectiveModel);
-      console.log("[GeminiClient.getModel] systemInstruction length:", opts.systemInstruction?.length ?? 0);
-      console.log("[GeminiClient.getModel] safetySettings:", JSON.stringify(sdkSafety.map(s => ({ category: s.category, threshold: s.threshold }))));
-    }
-
     return this.client.getGenerativeModel({
       model: effectiveModel,
       ...(opts.systemInstruction && { systemInstruction: opts.systemInstruction }),

package/src/infrastructure/services/StructuredText.ts

@@ -5,7 +5,6 @@ import type { GenerationConfig } from "@google/generative-ai";
 import type {
   GeminiContent,
   GeminiGenerationConfig,
-  GeminiResponse,
 } from "../../domain/entities";
 
 class StructuredTextService {
@@ -41,18 +40,12 @@ class StructuredTextService {
       signal,
     );
 
-    return this.parseJSONResponse<T>(response);
-  }
-
-  private parseJSONResponse<T>(response: GeminiResponse): T {
     const candidates = response.candidates;
-
     if (!candidates || candidates.length === 0) {
       throw new Error("No candidates in response");
     }
 
     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

@@ -1,10 +1,9 @@
 
 export interface TelemetryEvent {
-  type: "request" | "response" | "error" | "retry";
+  type: "error";
   timestamp: number;
   model?: string;
   feature?: string;
-  duration?: number;
   metadata?: Record<string, unknown>;
 }
 
@@ -18,6 +17,15 @@ class TelemetryHooks {
 
   /**
    * 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);
@@ -69,35 +77,6 @@ class TelemetryHooks {
     }
   }
 
-  /**
-   * Log request start
-   */
-  logRequest(model: string, feature?: string): number {
-    const timestamp = Date.now();
-    this.emit({
-      type: "request",
-      timestamp,
-      model,
-      feature,
-    });
-    return timestamp;
-  }
-
-  /**
-   * Log response received
-   */
-  logResponse(model: string, startTime: number, feature?: string, metadata?: Record<string, unknown>): void {
-    const now = Date.now();
-    this.emit({
-      type: "response",
-      timestamp: now,
-      model,
-      feature,
-      duration: now - startTime,
-      metadata,
-    });
-  }
-
   /**
    * Log error
    */
@@ -114,19 +93,6 @@ class TelemetryHooks {
     });
   }
 
-  /**
-   * Log retry attempt
-   */
-  logRetry(model: string, attempt: number, feature?: string): void {
-    this.emit({
-      type: "retry",
-      timestamp: Date.now(),
-      model,
-      feature,
-      metadata: { attempt },
-    });
-  }
-
   /**
    * Remove a specific listener
    */
@@ -139,32 +105,6 @@ class TelemetryHooks {
     this.failedListeners.delete(listener);
     this.listenerFailureCounts.delete(listener);
   }
-
-  /**
-   * Reset failure counts for all listeners (clear blacklist)
-   */
-  resetFailures(): void {
-    this.failedListeners.clear();
-    for (const listener of this.listeners) {
-      this.listenerFailureCounts.set(listener, 0);
-    }
-  }
-
-  /**
-   * Clear all listeners
-   */
-  clear(): void {
-    this.listeners = [];
-    this.failedListeners.clear();
-    this.listenerFailureCounts.clear();
-  }
-
-  /**
-   * Get current listener count
-   */
-  getListenerCount(): number {
-    return this.listeners.length;
-  }
 }
 
 export const telemetryHooks = new TelemetryHooks();

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

@@ -26,7 +26,6 @@ export interface AsyncStateSetters<T = string, U = unknown> {
  */
 export interface AsyncStateConfig<T = string> {
   resetState?: boolean;
-  throwOnError?: boolean;
   transformResult?: (result: T) => T;
 }
 
@@ -60,7 +59,6 @@ export async function executeWithState<T, U = unknown>(
 ): Promise<T | null> {
   const {
     resetState = true,
-    throwOnError = false,
     transformResult,
   } = config;
 
@@ -88,10 +86,6 @@ export async function executeWithState<T, U = unknown>(
     setters.setError(errorMessage);
     callbacks.onError?.(errorMessage);
 
-    if (throwOnError) {
-      throw err;
-    }
-
     return null;
   } finally {
     setters.setIsLoading(false);

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

@@ -3,6 +3,7 @@
  * Handles transformation between domain content and SDK format
  */
 
+import type { Part } from "@google/generative-ai";
 import type {
   GeminiContent,
   GeminiPart,
@@ -49,14 +50,21 @@ function isValidProbability(value: string): value is GeminiSafetyRating["probabi
 
 /**
  * Convert domain content to SDK format
+ * Preserves both text and inlineData parts
  */
 export function toSdkContent(contents: GeminiContent[]): Array<{
   role: string;
-  parts: Array<{ text: string }>;
+  parts: Part[];
 }> {
   return contents.map((content) => ({
     role: content.role || "user",
-    parts: content.parts.map((part) => ({ text: part.text })),
+    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;
+    }),
   }));
 }
 

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

@@ -21,12 +21,18 @@ export async function processStream(
   let fullText = "";
 
   for await (const chunk of stream) {
-    // 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);
+    try {
+      // chunk.text() can throw critical errors (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);
+      }
+    } catch (chunkError) {
+      // Log chunk error but re-throw to properly fail the stream
+      logError(onError, chunkError, "stream-chunk");
+      throw chunkError;
     }
   }
 

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

@@ -0,0 +1,70 @@
+/**
+ * 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;
+}

package/src/presentation/hooks/useGemini.ts

@@ -4,7 +4,6 @@ import { DEFAULT_MODELS } from "../../domain/entities";
 import { textGeneration } from "../../infrastructure/services/TextGeneration";
 import { structuredText } from "../../infrastructure/services/StructuredText";
 import { executeWithState, type AsyncStateSetters } from "../../infrastructure/utils/async/execute-state.util";
-import { parseJsonResponse } from "../../infrastructure/utils/json-parser.util";
 import { useOperationManager } from "./useOperationManager";
 
 export interface UseGeminiOptions {
@@ -16,7 +15,7 @@ export interface UseGeminiOptions {
 
 export interface UseGeminiReturn {
   generate: (prompt: string) => Promise<void>;
-  generateJSON: <T>(prompt: string, schema?: Record<string, unknown>) => Promise<T | null>;
+  generateJSON: <T>(prompt: string, schema: Record<string, unknown>) => Promise<T | null>;
   result: string | null;
   jsonResult: unknown;
   isGenerating: boolean;
@@ -65,7 +64,6 @@ export function useGemini(options: UseGeminiOptions = {}): UseGeminiReturn {
           },
           (text: string) => {
             setResult(text);
-            // onSuccess is called by executeWithState via callbacks - do not call here again
           }
         );
       });
@@ -74,7 +72,7 @@ export function useGemini(options: UseGeminiOptions = {}): UseGeminiReturn {
   );
 
   const generateJSON = useCallback(
-    async <T>(prompt: string, schema?: Record<string, unknown>): Promise<T | null> => {
+    async <T>(prompt: string, schema: Record<string, unknown>): Promise<T | null> => {
       return executeOperation(async (signal, _operationId) => {
         const jsonSetters: AsyncStateSetters<unknown, unknown> = {
           setIsLoading: setIsGenerating,
@@ -95,24 +93,13 @@ export function useGemini(options: UseGeminiOptions = {}): UseGeminiReturn {
           jsonSetters,
           jsonCallbacks,
           async () => {
-            if (schema) {
-              return structuredText.generateStructuredText<T>(
-                model,
-                prompt,
-                schema,
-                options.generationConfig,
-                signal
-              );
-            }
-
-            const text = await textGeneration.generateText(
+            return structuredText.generateStructuredText<T>(
               model,
               prompt,
-              { ...options.generationConfig, responseMimeType: "application/json" },
+              schema,
+              options.generationConfig,
               signal
             );
-
-            return parseJsonResponse<T>(text);
           },
           (parsed: unknown) => {
             setJsonResult(parsed);

package/src/providers/ConfigBuilder.ts

@@ -109,17 +109,4 @@ export class ConfigBuilder {
   static create(): ConfigBuilder {
     return new ConfigBuilder();
   }
-
-  /**
-   * Create from existing config (for updates)
-   */
-  static from(config: Partial<ProviderConfig>): ConfigBuilder {
-    const builder = new ConfigBuilder();
-    if (config.apiKey) builder.withApiKey(config.apiKey);
-    if (config.textModel) builder.withTextModel(config.textModel);
-    // 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

@@ -14,42 +14,33 @@ export interface ProviderFactoryOptions {
 
 class ProviderFactory {
   private currentConfig: ProviderConfig | null = null;
-  private builder: ConfigBuilder | null = null;
 
   /**
    * Initialize provider with configuration
    */
   initialize(options: ProviderFactoryOptions): void {
-    // Build configuration using builder pattern
-    this.builder = ConfigBuilder.create()
-      .withApiKey(options.apiKey);
+    // Build configuration using builder pattern (inline, no state needed)
+    const builder = ConfigBuilder.create().withApiKey(options.apiKey);
 
     if (options.strategy) {
-      this.builder.withStrategy(options.strategy);
+      builder.withStrategy(options.strategy);
     }
 
     if (options.textModel) {
-      this.builder.withTextModel(options.textModel);
+      builder.withTextModel(options.textModel);
     }
 
     if (options.timeout) {
-      this.builder.withTimeout(options.timeout);
+      builder.withTimeout(options.timeout);
     }
 
-    this.currentConfig = this.builder.build();
+    this.currentConfig = builder.build();
 
     // Initialize Gemini client
-    const geminiConfig = this.builder.toGeminiConfig();
+    const geminiConfig = builder.toGeminiConfig();
     geminiClient.initialize(geminiConfig);
   }
 
-  /**
-   * Get current configuration
-   */
-  getConfig(): ProviderConfig | null {
-    return this.currentConfig;
-  }
-
   /**
    * Check if provider is initialized
    */

package/src/global.d.ts

@@ -1 +0,0 @@
-declare const __DEV__: boolean;