@umituz/react-native-ai-gemini-provider 3.0.18 → 3.0.19

package/package.json

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

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

@@ -111,3 +111,48 @@ export interface GeminiUsageMetadata {
   /** Total number of tokens used */
   totalTokenCount?: number;
 }
+
+/**
+ * Safety setting for a single harm category
+ */
+export interface GeminiSafetySetting {
+  category: GeminiHarmCategory;
+  threshold: GeminiHarmBlockThreshold;
+}
+
+/**
+ * Inline data part for binary content (images, audio)
+ */
+export interface GeminiInlineDataPart {
+  inlineData: { mimeType: string; data: string };
+}
+
+/**
+ * A message part that can be text or inline data
+ */
+export type GeminiMessagePart = GeminiPart | GeminiInlineDataPart;
+
+/**
+ * Options for creating a generative model instance
+ */
+export interface GeminiModelOptions {
+  model?: string;
+  systemInstruction?: string;
+  safetySettings?: GeminiSafetySetting[];
+}
+
+/**
+ * Configuration for a chat session
+ */
+export interface GeminiChatConfig {
+  /** Model name override */
+  model?: string;
+  /** System instruction for the model */
+  systemInstruction?: string;
+  /** Safety settings (defaults to BLOCK_NONE for all categories) */
+  safetySettings?: GeminiSafetySetting[];
+  /** Generation config (temperature, maxOutputTokens, etc.) */
+  generationConfig?: GeminiGenerationConfig;
+  /** Initial conversation history */
+  history?: GeminiContent[];
+}

package/src/domain/entities/models.ts

@@ -6,6 +6,10 @@ export const GEMINI_MODELS = {
   TEXT: {
     /** Lightweight flash model for fast text generation */
     FLASH_LITE: "gemini-2.5-flash-lite",
+    /** Balanced flash model for general use */
+    FLASH: "gemini-2.5-flash",
+    /** Premium model for complex tasks */
+    PRO: "gemini-2.5-pro",
   },
 } as const;
 
@@ -15,4 +19,6 @@ export const GEMINI_MODELS = {
 export const DEFAULT_MODELS = {
   /** Default model for text generation */
   TEXT: GEMINI_MODELS.TEXT.FLASH_LITE,
+  /** Default model for chat sessions */
+  CHAT: GEMINI_MODELS.TEXT.FLASH,
 } as const;

package/src/index.ts

@@ -11,6 +11,11 @@ export type {
   GeminiHarmBlockThreshold,
   GeminiContent,
   GeminiPart,
+  GeminiInlineDataPart,
+  GeminiMessagePart,
+  GeminiSafetySetting,
+  GeminiModelOptions,
+  GeminiChatConfig,
   GeminiResponse,
   GeminiCandidate,
   GeminiFinishReason,
@@ -29,6 +34,7 @@ export {
 
 // Services
 export { geminiClient } from "./infrastructure/services/GeminiClient";
+export { createChatSession } from "./infrastructure/services/ChatSession";
 export { textGeneration } from "./infrastructure/services/TextGeneration";
 export { structuredText } from "./infrastructure/services/StructuredText";
 export { streaming } from "./infrastructure/services/Streaming";

package/src/infrastructure/services/ChatSession.ts

@@ -0,0 +1,54 @@
+import type { ChatSession as SdkChatSession, Part } from "@google/generative-ai";
+import { geminiClient } from "./GeminiClient";
+import { DEFAULT_MODELS } from "../../domain/entities";
+import type {
+  GeminiChatConfig,
+  GeminiContent,
+  GeminiMessagePart,
+} from "../../domain/entities";
+
+/**
+ * Creates a Gemini chat session with full support for system instructions,
+ * safety settings, generation config, and multi-turn conversation history.
+ *
+ * Usage:
+ * ```ts
+ * const session = createChatSession({
+ *   model: "gemini-2.5-flash",
+ *   systemInstruction: "You are a helpful assistant.",
+ *   generationConfig: { temperature: 0.7, maxOutputTokens: 512 },
+ *   history: geminiHistory,
+ * });
+ *
+ * const text = await session.send([{ text: "Hello" }]);
+ * ```
+ */
+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 {
+    /**
+     * Send a message and return the full response text.
+     * Accepts text parts and/or inline data parts (images, audio).
+     */
+    async send(parts: GeminiMessagePart[]): Promise<string> {
+      const result = await chat.sendMessage(parts as Part[]);
+      if (!result.response) throw new Error("No response from Gemini SDK");
+      return result.response.text();
+    },
+  };
+}

package/src/infrastructure/services/GeminiClient.ts

@@ -1,11 +1,25 @@
-import { GoogleGenerativeAI, type GenerativeModel } from "@google/generative-ai";
+import {
+  GoogleGenerativeAI,
+  HarmCategory,
+  HarmBlockThreshold,
+  type GenerativeModel,
+  type SafetySetting,
+} from "@google/generative-ai";
 import { DEFAULT_MODELS } from "../../domain/entities";
-import type { GeminiConfig } 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;
@@ -35,18 +49,40 @@ class GeminiClient {
     return this.client;
   }
 
-  getModel(modelName?: string): GenerativeModel {
+  /**
+   * 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.");
     }
 
-    const effectiveModel = modelName || this.config?.textModel || DEFAULT_MODELS.TEXT;
+    // 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-"');
     }
 
-    return this.client.getGenerativeModel({ model: effectiveModel });
+    // 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,
+        }))
+      : PERMISSIVE_SAFETY;
+
+    return this.client.getGenerativeModel({
+      model: effectiveModel,
+      ...(opts.systemInstruction && { systemInstruction: opts.systemInstruction }),
+      safetySettings: sdkSafety,
+    });
   }
 
   reset(): void {

package/src/infrastructure/services/index.ts

@@ -3,3 +3,4 @@ export { textGeneration } from "./TextGeneration";
 export { structuredText } from "./StructuredText";
 export { streaming } from "./Streaming";
 export { geminiProvider, GeminiProvider } from "./GeminiProvider";
+export { createChatSession } from "./ChatSession";