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

package/dist/providers/ConfigBuilder.d.ts

@@ -1,46 +0,0 @@
-/**
- * Config Builder Pattern
- * Fluent API for building provider configuration
- */
-import type { GeminiConfig } from "../domain/entities";
-export interface ProviderConfig {
-    apiKey: string;
-    textModel: string;
-    timeout: number;
-    strategy?: "cost" | "quality";
-}
-/**
- * Builder for constructing provider configuration
- * Provides a fluent API with validation and defaults
- */
-export declare class ConfigBuilder {
-    private config;
-    /**
-     * Set API key (required)
-     */
-    withApiKey(apiKey: string): this;
-    /**
-     * Set text model
-     */
-    withTextModel(model: string): this;
-    /**
-     * Set request timeout (ms)
-     */
-    withTimeout(timeout: number): this;
-    /**
-     * Set strategy (applies preset timeout)
-     */
-    withStrategy(strategy: "cost" | "quality"): this;
-    /**
-     * Build final configuration
-     */
-    build(): ProviderConfig;
-    /**
-     * Convert to GeminiConfig format
-     */
-    toGeminiConfig(): GeminiConfig;
-    /**
-     * Create a new builder instance
-     */
-    static create(): ConfigBuilder;
-}

package/dist/providers/ProviderFactory.d.ts

@@ -1,25 +0,0 @@
-export { ConfigBuilder } from "./ConfigBuilder";
-export type { ProviderConfig } from "./ConfigBuilder";
-export interface ProviderFactoryOptions {
-    apiKey: string;
-    timeout?: number;
-    textModel?: string;
-    strategy?: "cost" | "quality";
-}
-declare class ProviderFactory {
-    private currentConfig;
-    /**
-     * Initialize provider with configuration
-     */
-    initialize(options: ProviderFactoryOptions): void;
-    /**
-     * Check if provider is initialized
-     */
-    isInitialized(): boolean;
-    /**
-     * Update configuration
-     * API key changes require re-initialization
-     */
-    updateConfig(updates: Partial<ProviderFactoryOptions>): void;
-}
-export declare const providerFactory: ProviderFactory;

package/dist/providers/index.d.ts

@@ -1,7 +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";

package/src/infrastructure/services/BaseService.ts

@@ -1,53 +0,0 @@
-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";
-import type { Part } from "@google/generative-ai";
-
-export interface BaseRequestOptions {
-  model: string;
-  contents: GeminiContent[];
-  generationConfig?: GeminiGenerationConfig;
-  signal?: AbortSignal;
-}
-
-export abstract class BaseGeminiService {
-  protected validateAndPrepare(options: BaseRequestOptions): {
-    genModel: GenerativeModel;
-    sdkContents: Array<{ role: string; parts: Part[] }>;
-  } {
-    if (!options.contents || options.contents.length === 0) {
-      throw new Error("Contents array cannot be empty");
-    }
-
-    if (options.signal?.aborted) {
-      throw new Error("Request was aborted");
-    }
-
-    const genModel = geminiClient.getModel(options.model);
-    const sdkContents = toSdkContent(options.contents);
-
-    return { genModel, sdkContents };
-  }
-
-  protected handleError(error: unknown, abortMessage: string): never {
-    if (error instanceof GeminiError) {
-      throw error;
-    }
-
-    if (error instanceof Error && error.name === "AbortError") {
-      throw new Error(abortMessage);
-    }
-
-    throw createGeminiError(error);
-  }
-
-  protected createRequestOptions(
-    sdkContents: Array<{ role: string; parts: Part[] }>,
-    generationConfig?: GeminiGenerationConfig
-  ) {
-    return { contents: sdkContents, generationConfig };
-  }
-}

package/src/infrastructure/services/ChatSession.ts

@@ -1,199 +0,0 @@
-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,
-  GeminiContent,
-  GeminiInlineDataPart,
-  GeminiMessagePart,
-  GeminiSafetySetting,
-} from "../../domain/entities";
-
-// ─── Types ───────────────────────────────────────────────────────────────────
-
-export interface ChatSendResult {
-  text: string;
-  finishReason?: string;
-}
-
-/** A simple chat message (user/assistant/system) */
-export interface ChatHistoryMessage {
-  readonly role: "user" | "assistant" | "system";
-  readonly content: string;
-}
-
-/** Options for the high-level sendChatMessage() */
-export interface SendChatMessageOptions {
-  /** Conversation history */
-  history: ChatHistoryMessage[];
-  /** Current user message text */
-  message: string;
-  /** System instruction for the model */
-  systemPrompt?: string;
-  /** Model name (defaults to gemini-2.5-flash) */
-  model?: string;
-  /** Generation config (temperature, maxOutputTokens, etc.) */
-  generationConfig?: GeminiGenerationConfig;
-  /** Safety settings (defaults to BLOCK_NONE for all) */
-  safetySettings?: GeminiSafetySetting[];
-  /** Pre-built attachments (base64 inline data parts for images/audio) */
-  attachments?: GeminiInlineDataPart[];
-  /** Max character budget for history trimming (default 12000) */
-  historyMaxChars?: number;
-  /** Min messages to always keep regardless of budget (default 4) */
-  historyMinMessages?: number;
-}
-
-// ─── History Utilities ───────────────────────────────────────────────────────
-
-/**
- * Converts chat messages (user/assistant/system) to Gemini SDK content format.
- * Skips system messages, merges consecutive same-role messages.
- */
-export function buildChatHistory(
-  history: readonly ChatHistoryMessage[],
-): GeminiContent[] {
-  const result: GeminiContent[] = [];
-  let seenUser = false;
-
-  for (const m of history) {
-    if (m.role === "system") continue;
-    if (!seenUser && m.role !== "user") continue;
-    seenUser = true;
-
-    const role = m.role === "assistant" ? "model" : "user";
-    const last = result[result.length - 1];
-
-    if (last && last.role === role) {
-      // Merge by extracting all text from existing parts and appending new content
-      // 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 }] });
-    }
-  }
-
-  return result;
-}
-
-/**
- * Trims conversation history to fit within a character budget.
- * Keeps at least `minMessages` entries regardless of budget.
- */
-export function trimChatHistory(
-  history: ChatHistoryMessage[],
-  maxChars = 12000,
-  minMessages = 4,
-): ChatHistoryMessage[] {
-  return trimArrayByCharBudget(
-    history,
-    (m) => m.content.length,
-    maxChars,
-    minMessages,
-  );
-}
-
-// ─── Low-level: createChatSession ────────────────────────────────────────────
-
-/**
- * Creates a Gemini chat session with full support for system instructions,
- * safety settings, generation config, and multi-turn conversation history.
- */
-export function createChatSession(config: GeminiChatConfig = {}) {
-  const model = geminiClient.getModel({
-    model: config.model ?? DEFAULT_MODELS.CHAT,
-    systemInstruction: config.systemInstruction,
-    safetySettings: config.safetySettings,
-  });
-
-  const historyForChat = (config.history ?? []).map((turn) => ({
-    role: turn.role === "model" ? ("model" as const) : ("user" as const),
-    parts: turn.parts as Part[],
-  }));
-
-  const chat: SdkChatSession = model.startChat({
-    history: historyForChat,
-    ...(config.generationConfig && { generationConfig: config.generationConfig }),
-  });
-
-  return {
-    async send(parts: GeminiMessagePart[]): Promise<ChatSendResult> {
-      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];
-
-      // 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");
-      }
-
-      return {
-        text,
-        finishReason: candidate?.finishReason,
-      };
-    },
-  };
-}
-
-// ─── High-level: sendChatMessage ─────────────────────────────────────────────
-
-/**
- * All-in-one: trims history, builds session, sends message, handles safety.
- * Returns the AI response text.
- *
- * ```ts
- * const text = await sendChatMessage({
- *   history: messages,
- *   message: "hello",
- *   systemPrompt: "You are Aria...",
- *   model: GEMINI_MODELS.TEXT.FLASH,
- *   generationConfig: { temperature: 0.7, maxOutputTokens: 512 },
- * });
- * ```
- */
-export async function sendChatMessage(
-  opts: SendChatMessageOptions,
-): Promise<string> {
-  if (!opts.message || opts.message.trim().length === 0) {
-    throw new Error("Message cannot be empty");
-  }
-
-  const trimmed = trimChatHistory(
-    opts.history,
-    opts.historyMaxChars,
-    opts.historyMinMessages,
-  );
-
-  const geminiHistory = buildChatHistory(trimmed);
-
-  const session = createChatSession({
-    model: opts.model ?? DEFAULT_MODELS.CHAT,
-    systemInstruction: opts.systemPrompt,
-    safetySettings: opts.safetySettings,
-    generationConfig: opts.generationConfig,
-    history: geminiHistory,
-  });
-
-  const parts: GeminiMessagePart[] = [{ text: opts.message }];
-  if (opts.attachments) {
-    parts.push(...opts.attachments);
-  }
-
-  const result = await session.send(parts);
-
-  if (result.finishReason === "SAFETY") {
-    if (result.text.trim()) return result.text;
-    throw new Error("Response blocked by safety filter.");
-  }
-
-  return result.text;
-}

package/src/infrastructure/services/GeminiClient.ts

@@ -1,112 +0,0 @@
-import {
-  GoogleGenerativeAI,
-  HarmCategory,
-  HarmBlockThreshold,
-  type GenerativeModel,
-  type SafetySetting,
-} from "@google/generative-ai";
-import { DEFAULT_MODELS } from "../../domain/entities";
-import type { GeminiConfig, GeminiModelOptions } from "../../domain/entities";
-
-const DEFAULT_CONFIG: Partial<GeminiConfig> = {
-  textModel: DEFAULT_MODELS.TEXT,
-};
-
-/** All categories set to BLOCK_NONE */
-const PERMISSIVE_SAFETY: SafetySetting[] = [
-  { category: HarmCategory.HARM_CATEGORY_HARASSMENT, threshold: HarmBlockThreshold.BLOCK_NONE },
-  { category: HarmCategory.HARM_CATEGORY_HATE_SPEECH, threshold: HarmBlockThreshold.BLOCK_NONE },
-  { category: HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT, threshold: HarmBlockThreshold.BLOCK_NONE },
-  { category: HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT, threshold: HarmBlockThreshold.BLOCK_NONE },
-];
-
-class GeminiClient {
-  private client: GoogleGenerativeAI | null = null;
-  private config: GeminiConfig | null = null;
-  private initialized = false;
-
-  initialize(config: GeminiConfig): void {
-    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(apiKey);
-    this.config = { ...DEFAULT_CONFIG, ...config, apiKey };
-    this.initialized = true;
-  }
-
-  /**
-   * Returns a GenerativeModel configured with optional safety settings and system instruction.
-   * When no safety settings are provided, defaults to BLOCK_NONE for all categories.
-   */
-  getModel(modelNameOrOptions?: string | GeminiModelOptions): GenerativeModel {
-    if (!this.client || !this.initialized) {
-      throw new Error("Gemini client not initialized. Call initialize() first.");
-    }
-
-    // Normalize args
-    const opts: GeminiModelOptions =
-      typeof modelNameOrOptions === "string"
-        ? { model: modelNameOrOptions }
-        : modelNameOrOptions ?? {};
-
-    const effectiveModel = opts.model || this.config?.textModel || DEFAULT_MODELS.TEXT;
-
-    if (!effectiveModel.startsWith("gemini-")) {
-      throw new Error('Model name must start with "gemini-"');
-    }
-
-    // Map package safety settings to SDK format
-    const sdkSafety: SafetySetting[] = opts.safetySettings
-      ? 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;
-
-    return this.client.getGenerativeModel({
-      model: effectiveModel,
-      ...(opts.systemInstruction && { systemInstruction: opts.systemInstruction }),
-      safetySettings: sdkSafety,
-    });
-  }
-
-  reset(): void {
-    this.client = null;
-    this.config = null;
-    this.initialized = false;
-  }
-}
-
-export const geminiClient = new GeminiClient();

package/src/infrastructure/services/Streaming.ts

@@ -1,56 +0,0 @@
-import { BaseGeminiService } from "./BaseService";
-import { telemetryHooks } from "../telemetry/TelemetryHooks";
-import { processStream } from "../utils/stream-processor.util";
-import type {
-  GeminiContent,
-  GeminiGenerationConfig,
-} from "../../domain/entities";
-
-class StreamingService extends BaseGeminiService {
-  async streamContent(
-    model: string,
-    contents: GeminiContent[],
-    onChunk: (text: string) => void,
-    generationConfig?: GeminiGenerationConfig,
-    signal?: AbortSignal,
-  ): Promise<string> {
-    if (typeof onChunk !== "function") {
-      throw new Error("onChunk must be a function");
-    }
-
-    try {
-      const { genModel, sdkContents } = this.validateAndPrepare({
-        model,
-        contents,
-        generationConfig,
-        signal,
-      });
-
-      const requestOptions = this.createRequestOptions(sdkContents, generationConfig);
-
-      const result = signal
-        ? await genModel.generateContentStream(requestOptions, { signal })
-        : await genModel.generateContentStream(requestOptions);
-
-      return await processStream(
-        result.stream,
-        onChunk,
-        (error, context) => {
-          try {
-            telemetryHooks.logError(
-              model,
-              error instanceof Error ? error : new Error(String(error)),
-              context
-            );
-          } catch {
-            // Silently ignore telemetry errors
-          }
-        }
-      );
-    } catch (error) {
-      return this.handleError(error, "Stream generation was aborted");
-    }
-  }
-}
-
-export const streaming = new StreamingService();

package/src/infrastructure/services/StructuredText.ts

@@ -1,57 +0,0 @@
-import { textGeneration } from "./TextGeneration";
-import { parseJsonResponse } from "../utils/json-parser.util";
-import { extractTextFromParts } from "../utils/content-mapper.util";
-import type { GenerationConfig } from "@google/generative-ai";
-import type {
-  GeminiContent,
-  GeminiGenerationConfig,
-} from "../../domain/entities";
-
-class StructuredTextService {
-  async generateStructuredText<T>(
-    model: string,
-    prompt: string,
-    schema: Record<string, unknown>,
-    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");
-    }
-
-    const generationConfig: GeminiGenerationConfig = {
-      ...config,
-      responseMimeType: "application/json",
-      responseSchema: schema as unknown as GenerationConfig["responseSchema"],
-    };
-
-    const contents: GeminiContent[] = [
-      { parts: [{ text: prompt }], role: "user" },
-    ];
-
-    const response = await textGeneration.generateContent(
-      model,
-      contents,
-      generationConfig,
-      signal,
-    );
-
-    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");
-    }
-
-    return parseJsonResponse<T>(text);
-  }
-}
-
-export const structuredText = new StructuredTextService();

package/src/infrastructure/services/TextGeneration.ts

@@ -1,57 +0,0 @@
-import { BaseGeminiService } from "./BaseService";
-import { extractTextFromResponse } from "../utils/gemini-data-transformer.util";
-import { transformResponse, createTextContent } from "../utils/content-mapper.util";
-import type {
-  GeminiContent,
-  GeminiGenerationConfig,
-  GeminiResponse,
-} from "../../domain/entities";
-
-class TextGenerationService extends BaseGeminiService {
-  async generateContent(
-    model: string,
-    contents: GeminiContent[],
-    generationConfig?: GeminiGenerationConfig,
-    signal?: AbortSignal,
-  ): Promise<GeminiResponse> {
-    try {
-      const { genModel, sdkContents } = this.validateAndPrepare({
-        model,
-        contents,
-        generationConfig,
-        signal,
-      });
-
-      const requestOptions = this.createRequestOptions(sdkContents, generationConfig);
-
-      const result = signal
-        ? await genModel.generateContent(requestOptions, { signal })
-        : await genModel.generateContent(requestOptions);
-
-      if (!result.response) {
-        throw new Error("No response received from Gemini API");
-      }
-
-      return transformResponse(result.response);
-    } catch (error) {
-      return this.handleError(error, "Request was aborted");
-    }
-  }
-
-  async generateText(
-    model: string,
-    prompt: string,
-    config?: GeminiGenerationConfig,
-    signal?: AbortSignal,
-  ): Promise<string> {
-    if (!prompt || prompt.trim().length < 3) {
-      throw new Error("Prompt must be at least 3 characters");
-    }
-
-    const contents: GeminiContent[] = [createTextContent(prompt, "user")];
-    const response = await this.generateContent(model, contents, config, signal);
-    return extractTextFromResponse(response);
-  }
-}
-
-export const textGeneration = new TextGenerationService();