@umituz/react-native-ai-gemini-provider 2.1.13 → 3.0.1

package/package.json

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

package/src/domain/entities/models.ts

@@ -16,11 +16,3 @@ export const DEFAULT_MODELS = {
   /** Default model for text generation */
   TEXT: GEMINI_MODELS.TEXT.FLASH_LITE,
 } as const;
-
-/**
- * Pricing information for Gemini models
- * Prices are per 1M tokens (USD)
- */
-export const MODEL_PRICING = {
-  [GEMINI_MODELS.TEXT.FLASH_LITE]: { input: 0.10, output: 0.40, freePerDay: 1000 },
-} as const;

package/src/index.ts

@@ -27,13 +27,12 @@ export {
   DEFAULT_MODELS
 } from "./domain/entities";
 
-// Main Service
-export {
-  geminiProviderService,
-  GeminiProvider,
-} from "./infrastructure/services";
-
-export type { GeminiProviderConfig } from "./infrastructure/services";
+// Services
+export { geminiClient } from "./infrastructure/services/GeminiClient";
+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";
 
 // React Hook
 export { useGemini } from "./presentation/hooks";

package/src/infrastructure/services/{base-gemini.service.ts → BaseService.ts}

@@ -1,17 +1,9 @@
-/**
- * Base Gemini Service
- * Common functionality for all Gemini services to eliminate code duplication
- */
-
-import { geminiClientCoreService } from "./gemini-client-core.service";
+import { geminiClient } from "./GeminiClient";
 import { toSdkContent } from "../utils/content-mapper.util";
 import { createGeminiError } from "../utils/error-mapper.util";
 import type { GeminiContent, GeminiGenerationConfig } from "../../domain/entities";
 import type { GenerativeModel } from "@google/generative-ai";
 
-/**
- * Base request options structure
- */
 export interface BaseRequestOptions {
   model: string;
   contents: GeminiContent[];
@@ -19,64 +11,41 @@ export interface BaseRequestOptions {
   signal?: AbortSignal;
 }
 
-/**
- * Abstract base service with common patterns
- */
 export abstract class BaseGeminiService {
-  /**
-   * Validate and prepare request
-   * Eliminates duplicate validation and abort checks
-   */
   protected validateAndPrepare(options: BaseRequestOptions): {
     genModel: GenerativeModel;
     sdkContents: Array<{ role: string; parts: Array<{ text: string }> }>;
   } {
-    // Validate contents
     if (!options.contents || options.contents.length === 0) {
       throw new Error("Contents array cannot be empty");
     }
 
-    // Check for early abort
     if (options.signal?.aborted) {
       throw new Error("Request was aborted");
     }
 
-    const genModel = geminiClientCoreService.getModel(options.model);
+    const genModel = geminiClient.getModel(options.model);
     const sdkContents = toSdkContent(options.contents);
 
     return { genModel, sdkContents };
   }
 
-  /**
-   * Handle errors uniformly across all services
-   * Eliminates duplicate error handling logic
-   */
   protected handleError(error: unknown, abortMessage: string): never {
-    // Re-throw as GeminiError if it's already an API error
     if (error instanceof Error && error.name === "GeminiError") {
       throw error;
     }
 
-    // Check for abort error
     if (error instanceof Error && error.name === "AbortError") {
       throw new Error(abortMessage);
     }
 
-    // Wrap other errors
     throw createGeminiError(error);
   }
 
-  /**
-   * Create typed request options for SDK
-   * Type-safe request creation
-   */
   protected createRequestOptions(
     sdkContents: Array<{ role: string; parts: Array<{ text: string }> }>,
     generationConfig?: GeminiGenerationConfig
   ) {
-    return {
-      contents: sdkContents,
-      generationConfig,
-    };
+    return { contents: sdkContents, generationConfig };
   }
 }

package/src/infrastructure/services/{gemini-client-core.service.ts → GeminiClient.ts}

@@ -1,29 +1,22 @@
 import { GoogleGenerativeAI, type GenerativeModel } from "@google/generative-ai";
 import { DEFAULT_MODELS } from "../../domain/entities";
 import type { GeminiConfig } from "../../domain/entities";
-import { validateModelName, validateApiKey } from "../utils/validation.util";
 
 const DEFAULT_CONFIG: Partial<GeminiConfig> = {
   textModel: DEFAULT_MODELS.TEXT,
 };
 
-class GeminiClientCoreService {
+class GeminiClient {
   private client: GoogleGenerativeAI | null = null;
   private config: GeminiConfig | null = null;
   private initialized = false;
 
-  /**
-   * Initialize the Gemini client with configuration
-   *
-   * @throws {Error} If already initialized or API key is invalid
-   */
   initialize(config: GeminiConfig): void {
-    if (this.initialized) {
-      throw new Error("Gemini client already initialized. Call reset() before re-initializing with new config.");
-    }
+    if (this.initialized) return;
 
-    // Validate API key
-    validateApiKey(config.apiKey);
+    if (!config.apiKey || config.apiKey.trim().length < 10) {
+      throw new Error("API key is required and must be at least 10 characters");
+    }
 
     this.client = new GoogleGenerativeAI(config.apiKey);
     this.config = { ...DEFAULT_CONFIG, ...config };
@@ -42,24 +35,16 @@ class GeminiClientCoreService {
     return this.client;
   }
 
-  validateInitialization(): void {
+  getModel(modelName?: string): GenerativeModel {
     if (!this.client || !this.initialized) {
       throw new Error("Gemini client not initialized. Call initialize() first.");
     }
-  }
-
-
-  getModel(modelName?: string): GenerativeModel {
-    this.validateInitialization();
-
-    if (!this.client) {
-      throw new Error("Gemini client not available");
-    }
 
     const effectiveModel = modelName || this.config?.textModel || DEFAULT_MODELS.TEXT;
 
-    // Validate model name format
-    validateModelName(effectiveModel);
+    if (!effectiveModel.startsWith("gemini-")) {
+      throw new Error('Model name must start with "gemini-"');
+    }
 
     return this.client.getGenerativeModel({ model: effectiveModel });
   }
@@ -71,4 +56,4 @@ class GeminiClientCoreService {
   }
 }
 
-export const geminiClientCoreService = new GeminiClientCoreService();
+export const geminiClient = new GeminiClient();

package/src/infrastructure/services/GeminiProvider.ts

@@ -0,0 +1,38 @@
+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/{gemini-streaming.service.ts → Streaming.ts}

@@ -1,4 +1,4 @@
-import { BaseGeminiService } from "./base-gemini.service";
+import { BaseGeminiService } from "./BaseService";
 import { telemetryHooks } from "../telemetry";
 import { processStream } from "../utils/stream-processor.util";
 import type {
@@ -6,22 +6,7 @@ import type {
   GeminiGenerationConfig,
 } from "../../domain/entities";
 
-class GeminiStreamingService extends BaseGeminiService {
-  /**
-   * Stream content generation
-   *
-   * @throws {GeminiError} For API-specific errors
-   * @throws {Error} For validation or network errors
-   *
-   * @example
-   * ```ts
-   * const fullText = await streamContent(
-   *   "gemini-2.5-flash-lite",
-   *   [{ parts: [{ text: "Hello" }], role: "user" }],
-   *   (chunk) => console.log(chunk)
-   * );
-   * ```
-   */
+class StreamingService extends BaseGeminiService {
   async streamContent(
     model: string,
     contents: GeminiContent[],
@@ -29,7 +14,6 @@ class GeminiStreamingService extends BaseGeminiService {
     generationConfig?: GeminiGenerationConfig,
     signal?: AbortSignal,
   ): Promise<string> {
-    // Validate callback
     if (typeof onChunk !== "function") {
       throw new Error("onChunk must be a function");
     }
@@ -51,27 +35,22 @@ class GeminiStreamingService extends BaseGeminiService {
       return await processStream(
         result.stream,
         onChunk,
-        (error, context) => this.logStreamError(model, error, context)
+        (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");
     }
   }
-
-  /**
-   * Log stream errors via telemetry
-   */
-  private logStreamError(model: string, error: unknown, context?: string): void {
-    try {
-      telemetryHooks.logError(
-        model,
-        error instanceof Error ? error : new Error(String(error)),
-        context
-      );
-    } catch {
-      // Silently ignore telemetry errors
-    }
-  }
 }
 
-export const geminiStreamingService = new GeminiStreamingService();
+export const streaming = new StreamingService();

package/src/infrastructure/services/{gemini-structured-text.service.ts → StructuredText.ts}

@@ -1,8 +1,6 @@
-
-import { geminiTextGenerationService } from "./gemini-text-generation.service";
+import { textGeneration } from "./TextGeneration";
 import { parseJsonResponse } from "../utils/json-parser.util";
 import { extractTextFromParts } from "../utils/content-mapper.util";
-import { validateSchema } from "../utils/validation.util";
 import type { GenerationConfig } from "@google/generative-ai";
 import type {
   GeminiContent,
@@ -10,11 +8,7 @@ import type {
   GeminiResponse,
 } from "../../domain/entities";
 
-
-class GeminiStructuredTextService {
-  /**
-   * Generate structured JSON response with schema
-   */
+class StructuredTextService {
   async generateStructuredText<T>(
     model: string,
     prompt: string,
@@ -22,7 +16,9 @@ class GeminiStructuredTextService {
     config?: Omit<GeminiGenerationConfig, "responseMimeType" | "responseSchema">,
     signal?: AbortSignal,
   ): Promise<T> {
-    validateSchema(schema);
+    if (!schema || typeof schema !== "object" || Object.keys(schema).length === 0) {
+      throw new Error("Schema must be a non-empty object");
+    }
 
     const generationConfig: GeminiGenerationConfig = {
       ...config,
@@ -34,7 +30,7 @@ class GeminiStructuredTextService {
       { parts: [{ text: prompt }], role: "user" },
     ];
 
-    const response = await geminiTextGenerationService.generateContent(
+    const response = await textGeneration.generateContent(
       model,
       contents,
       generationConfig,
@@ -44,9 +40,6 @@ class GeminiStructuredTextService {
     return this.parseJSONResponse<T>(response);
   }
 
-  /**
-   * Parse JSON response from Gemini
-   */
   private parseJSONResponse<T>(response: GeminiResponse): T {
     const candidates = response.candidates;
 
@@ -64,4 +57,4 @@ class GeminiStructuredTextService {
   }
 }
 
-export const geminiStructuredTextService = new GeminiStructuredTextService();
+export const structuredText = new StructuredTextService();

package/src/infrastructure/services/{gemini-text-generation.service.ts → TextGeneration.ts}

@@ -1,20 +1,13 @@
-import { BaseGeminiService } from "./base-gemini.service";
+import { BaseGeminiService } from "./BaseService";
 import { extractTextFromResponse } from "../utils/gemini-data-transformer.util";
 import { transformResponse, createTextContent } from "../utils/content-mapper.util";
-import { validatePrompt } from "../utils/validation.util";
 import type {
   GeminiContent,
   GeminiGenerationConfig,
   GeminiResponse,
 } from "../../domain/entities";
 
-class GeminiTextGenerationService extends BaseGeminiService {
-  /**
-   * Generate content (text, with optional images)
-   *
-   * @throws {GeminiError} For API-specific errors
-   * @throws {Error} For validation or network errors
-   */
+class TextGenerationService extends BaseGeminiService {
   async generateContent(
     model: string,
     contents: GeminiContent[],
@@ -35,38 +28,30 @@ class GeminiTextGenerationService extends BaseGeminiService {
         ? await genModel.generateContent(requestOptions, { signal })
         : await genModel.generateContent(requestOptions);
 
-      const response = result.response;
-
-      if (!response) {
+      if (!result.response) {
         throw new Error("No response received from Gemini API");
       }
 
-      return transformResponse(response);
+      return transformResponse(result.response);
     } catch (error) {
       return this.handleError(error, "Request was aborted");
     }
   }
 
-  /**
-   * Generate text from prompt
-   *
-   * @throws {GeminiError} For API-specific errors
-   * @throws {Error} For validation or network errors
-   */
   async generateText(
     model: string,
     prompt: string,
     config?: GeminiGenerationConfig,
     signal?: AbortSignal,
   ): Promise<string> {
-    // Validate prompt
-    validatePrompt(prompt);
+    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 geminiTextGenerationService = new GeminiTextGenerationService();
+export const textGeneration = new TextGenerationService();

package/src/infrastructure/services/index.ts

@@ -1,21 +1,5 @@
-/**
- * Infrastructure Services - Internal Use Only
- */
-
-// Internal base classes
-export { BaseGeminiService } from "./base-gemini.service";
-export type { BaseRequestOptions } from "./base-gemini.service";
-
-// Internal services
-export { geminiClientCoreService } from "./gemini-client-core.service";
-export { geminiTextGenerationService } from "./gemini-text-generation.service";
-export { geminiStructuredTextService } from "./gemini-structured-text.service";
-export { geminiStreamingService } from "./gemini-streaming.service";
-
-// Main Provider - Public API
-export {
-  geminiProviderService,
-  GeminiProvider,
-} from "./gemini-provider";
-export type { GeminiProviderConfig } from "./gemini-provider";
-
+export { geminiClient } from "./GeminiClient";
+export { textGeneration } from "./TextGeneration";
+export { structuredText } from "./StructuredText";
+export { streaming } from "./Streaming";
+export { geminiProvider, GeminiProvider } from "./GeminiProvider";

package/src/infrastructure/telemetry/index.ts

@@ -3,4 +3,3 @@
  */
 
 export { telemetryHooks } from "./TelemetryHooks";
-export type { TelemetryEvent, TelemetryListener } from "./TelemetryHooks";

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

@@ -4,7 +4,5 @@
 
 export {
   executeWithState,
-  type AsyncStateCallbacks,
   type AsyncStateSetters,
-  type AsyncStateConfig,
 } from "./execute-state.util";

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

@@ -76,7 +76,7 @@ export function createTextContent(
 /**
  * Transform SDK candidate to domain format
  */
-export function transformCandidate(
+function transformCandidate(
   candidate: {
     content: { parts: Array<{ text?: string }>; role?: string };
     finishReason?: string;

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

@@ -87,7 +87,7 @@ function matchesPattern(message: string, patterns: string[]): boolean {
   });
 }
 
-export function mapGeminiError(error: unknown): GeminiErrorInfo {
+function mapGeminiError(error: unknown): GeminiErrorInfo {
   const message = error instanceof Error ? error.message : String(error);
   const statusCode = getStatusCode(error);
 
@@ -114,14 +114,6 @@ export function mapGeminiError(error: unknown): GeminiErrorInfo {
   };
 }
 
-export function isGeminiErrorRetryable(error: unknown): boolean {
-  return mapGeminiError(error).retryable;
-}
-
-export function categorizeGeminiError(error: unknown): GeminiErrorType {
-  return mapGeminiError(error).type;
-}
-
 export function createGeminiError(error: unknown): GeminiError {
   const errorInfo = mapGeminiError(error);
   return GeminiError.fromError(error, errorInfo);

package/src/infrastructure/utils/json-parser.util.ts

@@ -6,7 +6,7 @@
 /**
  * Clean JSON text by removing markdown code blocks and extra whitespace
  */
-export function cleanJsonText(text: string): string {
+function cleanJsonText(text: string): string {
   if (!text || typeof text !== "string") {
     return "";
   }
@@ -39,52 +39,3 @@ export function parseJsonResponse<T>(text: string): T {
   }
 }
 
-/**
- * Safely parse JSON with optional fallback value
- */
-export function safeParseJson<T>(
-  text: string,
-  fallback: T
-): T {
-  try {
-    return parseJsonResponse<T>(text);
-  } catch {
-    return fallback;
-  }
-}
-
-/**
- * Extract and parse JSON from a larger text response
- * Looks for JSON objects within markdown code blocks or standalone
- */
-export function extractJsonFromText<T>(text: string): T | null {
-  // Try to find JSON in code blocks first
-  const codeBlockMatch = text.match(/```json\s*([\s\S]*?)\s*```/);
-  if (codeBlockMatch) {
-    try {
-      return JSON.parse(codeBlockMatch[1].trim()) as T;
-    } catch {
-      // Continue to other methods
-    }
-  }
-
-  // Try to find JSON object boundaries
-  const firstBrace = text.indexOf("{");
-  const lastBrace = text.lastIndexOf("}");
-
-  if (firstBrace !== -1 && lastBrace !== -1 && lastBrace > firstBrace) {
-    try {
-      const jsonStr = text.substring(firstBrace, lastBrace + 1);
-      return JSON.parse(jsonStr) as T;
-    } catch {
-      // Continue to fallback
-    }
-  }
-
-  // Try parsing the whole text as JSON
-  try {
-    return parseJsonResponse<T>(text);
-  } catch {
-    return null;
-  }
-}

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

@@ -3,12 +3,12 @@
  * Reusable stream handling logic
  */
 
-export interface StreamChunk {
+interface StreamChunk {
   text: () => string;
 }
 
-export type ChunkCallback = (text: string) => void;
-export type ErrorLogger = (error: unknown, context?: string) => void;
+type ChunkCallback = (text: string) => void;
+type ErrorLogger = (error: unknown, context?: string) => void;
 
 /**
  * Process async stream with chunk callback
@@ -67,90 +67,3 @@ function logError(
   }
 }
 
-/**
- * Create a buffered stream processor
- * Accumulates chunks until a condition is met
- */
-export class BufferedStreamProcessor {
-  private buffer = "";
-  private fullText = "";
-
-  constructor(
-    private onFlush: (text: string) => void,
-    private flushCondition: (buffer: string) => boolean = () => false
-  ) {}
-
-  /**
-   * Process a single chunk
-   */
-  processChunk(chunk: StreamChunk): void {
-    try {
-      const chunkText = chunk.text();
-      if (!chunkText) return;
-
-      this.buffer += chunkText;
-      this.fullText += chunkText;
-
-      if (this.flushCondition(this.buffer)) {
-        this.flush();
-      }
-    } catch (error) {
-      // Ignore chunk errors
-    }
-  }
-
-  /**
-   * Flush buffer to callback
-   */
-  flush(): void {
-    if (this.buffer) {
-      try {
-        this.onFlush(this.buffer);
-        this.buffer = "";
-      } catch {
-        // Ignore callback errors
-      }
-    }
-  }
-
-  /**
-   * Get accumulated full text
-   */
-  getFullText(): string {
-    return this.fullText;
-  }
-
-  /**
-   * Process entire stream
-   */
-  async processStream(stream: AsyncIterable<StreamChunk>): Promise<string> {
-    for await (const chunk of stream) {
-      this.processChunk(chunk);
-    }
-
-    // Flush remaining buffer
-    this.flush();
-
-    return this.fullText;
-  }
-}
-
-/**
- * Common flush conditions
- */
-export const flushConditions = {
-  /**
-   * Flush on newline
-   */
-  onNewline: (buffer: string): boolean => buffer.includes("\n"),
-
-  /**
-   * Flush when buffer reaches size
-   */
-  onSize: (size: number) => (buffer: string): boolean => buffer.length >= size,
-
-  /**
-   * Flush on pattern match
-   */
-  onPattern: (pattern: RegExp) => (buffer: string): boolean => pattern.test(buffer),
-};

package/src/presentation/hooks/index.ts

@@ -1,11 +1 @@
-/**
- * React Hooks - Public API
- */
-
-// Internal - not exported from main index
-export { useOperationManager } from "./use-operation-manager";
-export type { OperationManager } from "./use-operation-manager";
-
-// Public API
-export { useGemini } from "./use-gemini";
-export type { UseGeminiOptions, UseGeminiReturn } from "./use-gemini";
+export { useGemini, type UseGeminiOptions, type UseGeminiReturn } from "./useGemini";

package/src/presentation/hooks/{use-gemini.ts → useGemini.ts}

@@ -1,10 +1,10 @@
 import { useState, useCallback, useMemo } from "react";
 import type { GeminiGenerationConfig } from "../../domain/entities";
 import { DEFAULT_MODELS } from "../../domain/entities";
-import { geminiTextGenerationService, geminiStructuredTextService } from "../../infrastructure/services";
+import { textGeneration, structuredText } from "../../infrastructure/services";
 import { executeWithState, type AsyncStateSetters } from "../../infrastructure/utils/async";
 import { parseJsonResponse } from "../../infrastructure/utils/json-parser.util";
-import { useOperationManager } from "./use-operation-manager";
+import { useOperationManager } from "./useOperationManager";
 
 export interface UseGeminiOptions {
   model?: string;
@@ -55,7 +55,7 @@ export function useGemini(options: UseGeminiOptions = {}): UseGeminiReturn {
           setters,
           callbacks,
           async () => {
-            return geminiTextGenerationService.generateText(
+            return textGeneration.generateText(
               model,
               prompt,
               options.generationConfig,
@@ -95,7 +95,7 @@ export function useGemini(options: UseGeminiOptions = {}): UseGeminiReturn {
           jsonCallbacks,
           async () => {
             if (schema) {
-              return geminiStructuredTextService.generateStructuredText<T>(
+              return structuredText.generateStructuredText<T>(
                 model,
                 prompt,
                 schema,
@@ -104,7 +104,7 @@ export function useGemini(options: UseGeminiOptions = {}): UseGeminiReturn {
               );
             }
 
-            const text = await geminiTextGenerationService.generateText(
+            const text = await textGeneration.generateText(
               model,
               prompt,
               { ...options.generationConfig, responseMimeType: "application/json" },

package/src/providers/ProviderFactory.ts

@@ -1,4 +1,4 @@
-import { geminiClientCoreService } from "../infrastructure/services/gemini-client-core.service";
+import { geminiClient } from "../infrastructure/services/GeminiClient";
 import { ConfigBuilder, type ProviderConfig } from "./ConfigBuilder";
 
 // Re-export for public API
@@ -40,7 +40,7 @@ class ProviderFactory {
 
     // Initialize Gemini client
     const geminiConfig = this.builder.toGeminiConfig();
-    geminiClientCoreService.initialize(geminiConfig);
+    geminiClient.initialize(geminiConfig);
   }
 
   /**

package/src/infrastructure/interceptors/BaseInterceptor.ts

@@ -1,78 +0,0 @@
-/**
- * Base Interceptor Class
- * Eliminates code duplication between Request and Response interceptors
- */
-
-import { telemetryHooks } from "../telemetry";
-
-export type InterceptorErrorStrategy = "fail" | "skip" | "log";
-
-export interface BaseContext {
-  model: string;
-  feature?: string;
-  timestamp: number;
-}
-
-export abstract class BaseInterceptor<TContext extends BaseContext> {
-  protected interceptors: Array<(context: TContext) => TContext | Promise<TContext>> = [];
-  protected errorStrategy: InterceptorErrorStrategy = "fail";
-
-  /**
-   * Register an interceptor
-   */
-  use(interceptor: (context: TContext) => TContext | Promise<TContext>): () => void {
-    this.interceptors.push(interceptor);
-
-    // Return unsubscribe function
-    return () => {
-      const index = this.interceptors.indexOf(interceptor);
-      if (index > -1) {
-        this.interceptors.splice(index, 1);
-      }
-    };
-  }
-
-  /**
-   * Set error handling strategy
-   */
-  setErrorStrategy(strategy: InterceptorErrorStrategy): void {
-    this.errorStrategy = strategy;
-  }
-
-  /**
-   * Clear all interceptors
-   */
-  clear(): void {
-    this.interceptors = [];
-  }
-
-  /**
-   * Get interceptor count
-   */
-  count(): number {
-    return this.interceptors.length;
-  }
-
-  /**
-   * Handle interceptor error based on strategy
-   */
-  protected handleError(context: TContext, error: unknown): void {
-    telemetryHooks.logError(
-      context.model,
-      error instanceof Error ? error : new Error(String(error)),
-      context.feature
-    );
-
-    if (this.errorStrategy === "fail") {
-      throw new Error(
-        `Interceptor failed: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-    // For "skip" and "log", we just continue (error already logged)
-  }
-
-  /**
-   * Apply interceptors - to be implemented by subclasses
-   */
-  abstract apply(context: TContext): Promise<TContext>;
-}

package/src/infrastructure/interceptors/RequestInterceptors.ts

@@ -1,30 +0,0 @@
-import { BaseInterceptor, type BaseContext } from "./BaseInterceptor";
-
-export interface RequestContext extends BaseContext {
-  payload: Record<string, unknown>;
-}
-
-export type RequestInterceptor = (context: RequestContext) => RequestContext | Promise<RequestContext>;
-
-class RequestInterceptors extends BaseInterceptor<RequestContext> {
-  /**
-   * Apply all interceptors to a request context
-   * Interceptors are called in order (first registered = first called)
-   */
-  async apply(context: RequestContext): Promise<RequestContext> {
-    let result = context;
-
-    for (const interceptor of this.interceptors) {
-      try {
-        result = await interceptor(result);
-      } catch (error) {
-        this.handleError(context, error);
-        // If we get here, strategy was "skip" or "log" - continue with previous result
-      }
-    }
-
-    return result;
-  }
-}
-
-export const requestInterceptors = new RequestInterceptors();

package/src/infrastructure/interceptors/ResponseInterceptors.ts

@@ -1,35 +0,0 @@
-import { BaseInterceptor, type BaseContext } from "./BaseInterceptor";
-
-export interface ResponseContext<T = unknown> extends BaseContext {
-  data: T;
-  duration: number;
-}
-
-export type ResponseInterceptor<T = unknown> = (
-  context: ResponseContext<T>,
-) => ResponseContext<T> | Promise<ResponseContext<T>>;
-
-class ResponseInterceptors extends BaseInterceptor<ResponseContext<unknown>> {
-  /**
-   * Apply all interceptors to a response context
-   * Interceptors are called in reverse order (last registered = first called)
-   */
-  async apply<T>(context: ResponseContext<T>): Promise<ResponseContext<T>> {
-    let result: ResponseContext<unknown> = context;
-
-    // Apply in reverse order (last added = first processed)
-    for (let i = this.interceptors.length - 1; i >= 0; i--) {
-      const interceptor = this.interceptors[i];
-      try {
-        result = await interceptor(result);
-      } catch (error) {
-        this.handleError(context, error);
-        // If we get here, strategy was "skip" or "log" - continue with previous result
-      }
-    }
-
-    return result as ResponseContext<T>;
-  }
-}
-
-export const responseInterceptors = new ResponseInterceptors();

package/src/infrastructure/interceptors/index.ts

@@ -1,12 +0,0 @@
-/**
- * Interceptors Module - Internal Use Only
- */
-
-export { BaseInterceptor } from "./BaseInterceptor";
-export type { BaseContext, InterceptorErrorStrategy } from "./BaseInterceptor";
-
-export { requestInterceptors } from "./RequestInterceptors";
-export type { RequestContext, RequestInterceptor } from "./RequestInterceptors";
-
-export { responseInterceptors } from "./ResponseInterceptors";
-export type { ResponseContext, ResponseInterceptor } from "./ResponseInterceptors";

package/src/infrastructure/services/gemini-provider.ts

@@ -1,62 +0,0 @@
-
-import type { GeminiConfig } from "../../domain/entities";
-import { geminiClientCoreService } from "./gemini-client-core.service";
-import { geminiStructuredTextService } from "./gemini-structured-text.service";
-import { validatePrompt } from "../utils/validation.util";
-
-export type GeminiProviderConfig = GeminiConfig;
-
-export class GeminiProvider {
-  readonly providerId = "gemini";
-  readonly providerName = "Google Gemini";
-
-  /**
-   * Initialize the Gemini provider
-   *
-   * @throws {Error} If already initialized or configuration is invalid
-   */
-  initialize(config: GeminiProviderConfig): void {
-    if (geminiClientCoreService.isInitialized()) {
-      throw new Error("Provider already initialized. Call reset() before re-initializing with new config.");
-    }
-    geminiClientCoreService.initialize(config);
-  }
-
-  /**
-   * Check if provider is initialized
-   */
-  isInitialized(): boolean {
-    return geminiClientCoreService.isInitialized();
-  }
-
-  /**
-   * Reset the provider to uninitialized state
-   */
-  reset(): void {
-    geminiClientCoreService.reset();
-  }
-
-  /**
-   * Generate structured JSON response
-   *
-   * @throws {GeminiError} For API-specific errors
-   * @throws {Error} For validation or network errors
-   */
-  async generateStructuredText<T>(
-    prompt: string,
-    schema: Record<string, unknown>,
-    model: string,
-  ): Promise<T> {
-    // Validate inputs
-    validatePrompt(prompt);
-
-    // Check if initialized
-    if (!this.isInitialized()) {
-      throw new Error("Provider not initialized. Call initialize() first.");
-    }
-
-    return geminiStructuredTextService.generateStructuredText<T>(model, prompt, schema);
-  }
-}
-
-export const geminiProviderService = new GeminiProvider();

package/src/infrastructure/utils/index.ts

@@ -1,47 +0,0 @@
-/**
- * Utility Functions - Internal Use Only
- * These are internal implementation details and should not be used directly by consumers
- */
-
-// Error handling (internal)
-export {
-  mapGeminiError,
-  isGeminiErrorRetryable,
-  categorizeGeminiError,
-  createGeminiError
-} from "./error-mapper.util";
-
-// Data transformation (internal)
-export { extractTextFromResponse } from "./gemini-data-transformer.util";
-export {
-  cleanJsonText,
-  parseJsonResponse,
-  safeParseJson,
-  extractJsonFromText
-} from "./json-parser.util";
-export {
-  toSdkContent,
-  createTextContent,
-  transformCandidate,
-  transformResponse,
-  extractTextFromParts
-} from "./content-mapper.util";
-
-// Validation (internal)
-export {
-  validateModelName,
-  validateApiKey,
-  validateSchema,
-  validatePrompt,
-  validateTimeout,
-  isValidObject,
-  validateRequiredFields
-} from "./validation.util";
-
-// Async state management (internal)
-export {
-  executeWithState,
-  type AsyncStateCallbacks,
-  type AsyncStateSetters,
-  type AsyncStateConfig
-} from "./async";

package/src/infrastructure/utils/validation-composer.util.ts

@@ -1,160 +0,0 @@
-/**
- * Validation Composers
- * Composable validation rules for clean, reusable validation
- */
-
-export type ValidationRule<T = unknown> = (value: T) => string | null;
-
-/**
- * Compose multiple validation rules into one
- */
-export function compose<T>(...rules: ValidationRule<T>[]): ValidationRule<T> {
-  return (value: T): string | null => {
-    for (const rule of rules) {
-      const error = rule(value);
-      if (error) return error;
-    }
-    return null;
-  };
-}
-
-/**
- * Validate that value is not empty
- */
-export function required(fieldName: string = "Field"): ValidationRule<string> {
-  return (value: string): string | null => {
-    if (!value || typeof value !== "string" || value.trim().length === 0) {
-      return `${fieldName} is required`;
-    }
-    return null;
-  };
-}
-
-/**
- * Validate minimum length
- */
-export function minLength(min: number, fieldName: string = "Field"): ValidationRule<string> {
-  return (value: string): string | null => {
-    if (value.trim().length < min) {
-      return `${fieldName} must be at least ${min} characters`;
-    }
-    return null;
-  };
-}
-
-/**
- * Validate maximum length
- */
-export function maxLength(max: number, fieldName: string = "Field"): ValidationRule<string> {
-  return (value: string): string | null => {
-    if (value.length > max) {
-      return `${fieldName} must be at most ${max} characters`;
-    }
-    return null;
-  };
-}
-
-/**
- * Validate string starts with prefix
- */
-export function startsWith(prefix: string, fieldName: string = "Field"): ValidationRule<string> {
-  return (value: string): string | null => {
-    if (!value.startsWith(prefix)) {
-      return `${fieldName} must start with "${prefix}"`;
-    }
-    return null;
-  };
-}
-
-/**
- * Validate number is in range
- */
-export function inRange(min: number, max: number, fieldName: string = "Value"): ValidationRule<number> {
-  return (value: number): string | null => {
-    if (typeof value !== "number" || value < min || value > max) {
-      return `${fieldName} must be between ${min} and ${max}`;
-    }
-    return null;
-  };
-}
-
-/**
- * Validate object has required properties
- */
-export function hasProperties(...props: string[]): ValidationRule<Record<string, unknown>> {
-  return (value: Record<string, unknown>): string | null => {
-    const missing = props.filter((prop) => !(prop in value) || value[prop] === undefined);
-    if (missing.length > 0) {
-      return `Missing required properties: ${missing.join(", ")}`;
-    }
-    return null;
-  };
-}
-
-/**
- * Validate object structure (for schemas)
- */
-export function isValidSchema(): ValidationRule<Record<string, unknown>> {
-  return compose(
-    (schema): string | null => {
-      if (!schema || typeof schema !== "object") {
-        return "Schema must be a non-empty object";
-      }
-      return null;
-    },
-    (schema): string | null => {
-      if (Object.keys(schema).length === 0) {
-        return "Schema must contain at least one property";
-      }
-      return null;
-    },
-    hasProperties("type"),
-    (schema): string | null => {
-      const schemaType = schema.type;
-      if (schemaType !== "object" && schemaType !== "array") {
-        return `Schema type must be "object" or "array", got "${String(schemaType)}"`;
-      }
-      return null;
-    },
-    (schema): string | null => {
-      if (schema.type === "object" && !("properties" in schema)) {
-        return 'Object schema must have a "properties" field';
-      }
-      return null;
-    }
-  );
-}
-
-/**
- * Helper to validate and throw on error
- */
-export function validateOrThrow<T>(value: T, rule: ValidationRule<T>): void {
-  const error = rule(value);
-  if (error) {
-    throw new Error(error);
-  }
-}
-
-/**
- * Pre-built composite validators
- */
-export const validators = {
-  apiKey: compose(
-    required("API key"),
-    minLength(10, "API key")
-  ),
-
-  modelName: compose(
-    required("Model name"),
-    startsWith("gemini-", "Model name")
-  ),
-
-  prompt: compose(
-    required("Prompt"),
-    minLength(3, "Prompt")
-  ),
-
-  timeout: inRange(1, 300000, "Timeout"),
-
-  schema: isValidSchema(),
-};

package/src/infrastructure/utils/validation.util.ts

@@ -1,73 +0,0 @@
-/**
- * Validation Utilities (Legacy)
- * Maintained for backward compatibility
- * New code should use validation-composer.util.ts
- */
-
-import { validateOrThrow, validators } from "./validation-composer.util";
-
-/**
- * Validate model name format
- * @throws Error if model name is invalid
- */
-export function validateModelName(modelName: string): void {
-  validateOrThrow(modelName, validators.modelName);
-}
-
-/**
- * Validate API key format
- * @throws Error if API key is invalid
- */
-export function validateApiKey(apiKey: string): void {
-  validateOrThrow(apiKey, validators.apiKey);
-}
-
-/**
- * Validate schema object for structured generation
- * @throws Error if schema is invalid
- */
-export function validateSchema(schema: Record<string, unknown>): void {
-  validateOrThrow(schema, validators.schema);
-}
-
-/**
- * Validate prompt text
- * @throws Error if prompt is invalid
- */
-export function validatePrompt(prompt: string): void {
-  validateOrThrow(prompt, validators.prompt);
-}
-
-/**
- * Validate timeout value
- * @throws Error if timeout is invalid
- */
-export function validateTimeout(timeout: number): void {
-  validateOrThrow(timeout, validators.timeout);
-}
-
-/**
- * Check if a value is a valid object
- */
-export function isValidObject(value: unknown): value is Record<string, unknown> {
-  return (
-    value !== null &&
-    typeof value === "object" &&
-    !Array.isArray(value) &&
-    Object.keys(value).length > 0
-  );
-}
-
-/**
- * Validate required fields in an object
- */
-export function validateRequiredFields(
-  obj: Record<string, unknown>,
-  requiredFields: string[]
-): void {
-  const missing = requiredFields.filter((field) => !(field in obj) || obj[field] === undefined);
-
-  if (missing.length > 0) {
-    throw new Error(`Missing required fields: ${missing.join(", ")}`);
-  }
-}