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

package/package.json

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

package/README.md

@@ -1,191 +0,0 @@
-# @umituz/react-native-ai-gemini-provider
-
-Production-ready Google Gemini AI provider for React Native applications with built-in error handling, rate limiting, and caching.
-
-## Features
-
-- ✅ **Production Ready** - Real API integration with proper error handling
-- ✅ **Type-Safe** - Full TypeScript support with structured output
-- ✅ **Cost Optimized** - Uses `gemini-2.5-flash-lite` by default (1000 free requests/day)
-- ✅ **Rate Limiting** - Built-in rate limiter to prevent API throttling
-- ✅ **Caching** - LRU cache with TTL for performance optimization
-- ✅ **Retry Logic** - Exponential backoff with jitter for resilient API calls
-- ✅ **No Mock Data** - Production-grade implementation
-
-## Installation
-
-```bash
-npm install @umituz/react-native-ai-gemini-provider
-npm install @google/generative-ai
-```
-
-## Configuration
-
-### 1. Get API Key
-
-Visit [Google AI Studio](https://aistudio.google.com/apikey) and create an API key.
-
-### 2. Environment Setup
-
-Create `.env` file:
-
-```env
-EXPO_PUBLIC_GEMINI_API_KEY=your_api_key_here
-```
-
-### 3. Initialize Provider
-
-```typescript
-import { geminiClientCoreService } from '@umituz/react-native-ai-gemini-provider';
-
-geminiClientCoreService.initialize({
-  apiKey: process.env.EXPO_PUBLIC_GEMINI_API_KEY,
-  textModel: 'gemini-2.5-flash-lite',
-  maxRetries: 3,
-  baseDelay: 1000,
-  maxDelay: 10000,
-});
-```
-
-## Usage
-
-### Simple Text Generation
-
-```typescript
-import { geminiTextService } from '@umituz/react-native-ai-gemini-provider';
-
-const response = await geminiTextService.generateText(
-  'gemini-2.5-flash-lite',
-  'Write a short greeting in Turkish'
-);
-console.log(response); // "Merhaba! Bugün size nasıl yardımcı olabilirim?"
-```
-
-### Structured Output (JSON)
-
-```typescript
-import { geminiStructuredTextService } from '@umituz/react-native-ai-gemini-provider';
-
-interface AnalysisResult {
-  score: number;
-  feedback: string;
-  suggestions: string[];
-}
-
-const schema = {
-  type: 'object',
-  properties: {
-    score: { type: 'number' },
-    feedback: { type: 'string' },
-    suggestions: { type: 'array', items: { type: 'string' } },
-  },
-  required: ['score', 'feedback', 'suggestions'],
-};
-
-const result = await geminiStructuredTextService.generateStructuredText<AnalysisResult>(
-  'gemini-2.5-flash-lite',
-  'Analyze this text',
-  schema
-);
-
-console.log(result.score); // 85
-console.log(result.feedback); // "Good quality overall..."
-```
-
-### With Rate Limiting & Caching
-
-```typescript
-import { 
-  geminiTextService, 
-  rateLimiter,
-  SimpleCache 
-} from '@umituz/react-native-ai-gemini-provider';
-
-const cache = new SimpleCache<string, string>({ 
-  maxSize: 50, 
-  ttl: 60000 // 1 minute 
-});
-
-const cacheKey = `text_${prompt}`;
-const cached = cache.get(cacheKey);
-
-if (cached) {
-  return cached;
-}
-
-const response = await rateLimiter.execute(() =>
-  geminiTextService.generateText('gemini-2.5-flash-lite', prompt)
-);
-
-cache.set(cacheKey, response);
-return response;
-```
-
-## Production Example
-
-See `examples/prod-ai-service.ts` for a complete production-ready implementation with:
-
-- ✅ Content analysis
-- ✅ Motivation letter analysis
-- ✅ Chat assistant
-- ✅ Text summarization
-- ✅ Batch processing
-- ✅ Error handling with retry
-
-## Models
-
-| Model | Input | Output | Free/Day | Best For |
-|-------|-------|--------|-----------|----------|
-| `gemini-2.5-flash-lite` | $0.10 | $0.40 | 1000 | High volume, simple tasks |
-| `gemini-2.5-flash` | $0.15 | $0.60 | 20 | Balanced speed/quality |
-| `gemini-2.5-pro` | $1.25 | $10.00 | 25 | Complex reasoning |
-
-**Recommendation:** Use `gemini-2.5-flash-lite` for most use cases.
-
-## API Reference
-
-### Services
-
-- `geminiClientCoreService` - Client initialization and configuration
-- `geminiTextService` - Text generation (alias: `geminiTextGenerationService`)
-- `geminiStructuredTextService` - JSON structured output
-- `geminiRetryService` - Retry logic with exponential backoff
-
-### Utilities
-
-- `rateLimiter` - Request rate limiting
-- `SimpleCache` - LRU cache with TTL
-- `measureAsync` / `measureSync` - Performance measurement
-
-## Error Handling
-
-```typescript
-try {
-  const result = await geminiTextService.generateText('gemini-2.5-flash-lite', prompt);
-} catch (error) {
-  if (error instanceof Error) {
-    if (error.message.includes('API key')) {
-      // Handle missing/invalid API key
-    } else if (error.message.includes('429') || error.message.includes('quota')) {
-      // Handle rate limit - wait and retry
-    }
-  }
-}
-```
-
-## Best Practices
-
-1. **Always initialize** the client before making requests
-2. **Use rate limiting** to prevent API throttling
-3. **Implement caching** for frequently used prompts
-4. **Handle errors** gracefully with retry logic
-5. **Use structured output** for consistent JSON responses
-6. **Choose the right model** based on complexity and cost
-
-## License
-
-MIT
-
-## Support
-
-For detailed integration guide, see: [factory/templates/docs/ai/GEMINI_AI_PROVIDER.md](https://github.com/umituz/react-native-app-factory/blob/main/factory/templates/docs/ai/GEMINI_AI_PROVIDER.md)

package/dist/domain/entities/error.types.d.ts

@@ -1,96 +0,0 @@
-/**
- * Categories of errors that can occur with Gemini API
- */
-export declare enum GeminiErrorType {
-    /** Network connectivity issues */
-    NETWORK = "NETWORK",
-    /** API rate limit exceeded */
-    RATE_LIMIT = "RATE_LIMIT",
-    /** Authentication/authorization failures */
-    AUTHENTICATION = "AUTHENTICATION",
-    /** Invalid input data or parameters */
-    VALIDATION = "VALIDATION",
-    /** Content blocked by safety filters */
-    SAFETY = "SAFETY",
-    /** Server-side errors */
-    SERVER = "SERVER",
-    /** Request timeout */
-    TIMEOUT = "TIMEOUT",
-    /** API quota exceeded */
-    QUOTA_EXCEEDED = "QUOTA_EXCEEDED",
-    /** Requested model not found */
-    MODEL_NOT_FOUND = "MODEL_NOT_FOUND",
-    /** Unknown/unclassified error */
-    UNKNOWN = "UNKNOWN"
-}
-/**
- * Detailed error information for Gemini API errors
- */
-export interface GeminiErrorInfo {
-    /** Category of the error */
-    type: GeminiErrorType;
-    /** Message key for i18n translation */
-    messageKey: string;
-    /** Whether the request can be retried */
-    retryable: boolean;
-    /** Original error that caused this error */
-    originalError?: unknown;
-    /** HTTP status code if applicable */
-    statusCode?: number;
-}
-/**
- * Structure of Gemini API error responses
- */
-export interface GeminiApiError {
-    error?: {
-        /** Error code */
-        code?: number;
-        /** Error message */
-        message?: string;
-        /** Error status */
-        status?: string;
-        /** Additional error details */
-        details?: Array<{
-            "@type"?: string;
-            reason?: string;
-            domain?: string;
-            metadata?: Record<string, string>;
-        }>;
-    };
-}
-/**
- * Custom error class for Gemini API errors
- * Provides structured error information and retry capability
- */
-export declare class GeminiError extends Error {
-    /** Error category */
-    readonly type: GeminiErrorType;
-    /** Whether the operation can be retried */
-    readonly retryable: boolean;
-    /** HTTP status code if applicable */
-    readonly statusCode?: number;
-    /** Original error that caused this error */
-    readonly originalError?: unknown;
-    /**
-     * Create a new GeminiError
-     * @param info - Error information
-     */
-    constructor(info: GeminiErrorInfo);
-    /**
-     * Check if this error is retryable
-     * @returns true if the operation can be retried
-     */
-    isRetryable(): boolean;
-    /**
-     * Get the error type
-     * @returns The error category
-     */
-    getErrorType(): GeminiErrorType;
-    /**
-     * Create a GeminiError from an unknown error
-     * @param error - The original error
-     * @param info - Error information
-     * @returns A new GeminiError instance
-     */
-    static fromError(error: unknown, info: GeminiErrorInfo): GeminiError;
-}

package/dist/domain/entities/gemini.types.d.ts

@@ -1,90 +0,0 @@
-import type { GenerationConfig } from "@google/generative-ai";
-/**
- * Configuration for Gemini AI client initialization
- */
-export interface GeminiConfig {
-    /** API key for authentication */
-    apiKey: string;
-    /** Optional base URL for API requests */
-    baseUrl?: string;
-    /** Default timeout in milliseconds */
-    defaultTimeoutMs?: number;
-    /** Default model to use for text generation */
-    textModel?: string;
-}
-/**
- * Generation configuration for AI requests
- * Extends the SDK's GenerationConfig with proper schema typing
- */
-export type GeminiGenerationConfig = Omit<GenerationConfig, "responseSchema"> & {
-    responseSchema?: GenerationConfig["responseSchema"];
-};
-/**
- * Harm categories for content safety filtering
- */
-export type GeminiHarmCategory = "HARM_CATEGORY_HARASSMENT" | "HARM_CATEGORY_HATE_SPEECH" | "HARM_CATEGORY_SEXUALLY_EXPLICIT" | "HARM_CATEGORY_DANGEROUS_CONTENT";
-/**
- * Threshold levels for blocking harmful content
- */
-export type GeminiHarmBlockThreshold = "BLOCK_NONE" | "BLOCK_LOW_AND_ABOVE" | "BLOCK_MEDIUM_AND_ABOVE" | "BLOCK_ONLY_HIGH";
-/**
- * Content structure for Gemini API requests
- */
-export interface GeminiContent {
-    /** Array of content parts (text, images, etc.) */
-    parts: GeminiPart[];
-    /** Role of the content creator (user or model) */
-    role?: "user" | "model";
-}
-/**
- * Individual content part
- */
-export type GeminiPart = {
-    text: string;
-};
-/**
- * Response structure from Gemini API
- */
-export interface GeminiResponse {
-    /** Array of response candidates */
-    candidates?: GeminiCandidate[];
-    /** Token usage information */
-    usageMetadata?: GeminiUsageMetadata;
-}
-/**
- * Individual response candidate
- */
-export interface GeminiCandidate {
-    /** Generated content */
-    content: GeminiContent;
-    /** Reason for generation completion */
-    finishReason?: GeminiFinishReason;
-    /** Safety ratings for the content */
-    safetyRatings?: GeminiSafetyRating[];
-}
-/**
- * Reasons why generation finished
- */
-export type GeminiFinishReason = "FINISH_REASON_UNSPECIFIED" | "STOP" | "MAX_TOKENS" | "SAFETY" | "RECITATION" | "OTHER";
-/**
- * Safety rating for generated content
- */
-export interface GeminiSafetyRating {
-    /** Category of safety check */
-    category: GeminiHarmCategory;
-    /** Probability of content being unsafe */
-    probability: "NEGLIGIBLE" | "LOW" | "MEDIUM" | "HIGH";
-    /** Whether the content was blocked */
-    blocked?: boolean;
-}
-/**
- * Token usage metadata for the request
- */
-export interface GeminiUsageMetadata {
-    /** Number of tokens in the prompt */
-    promptTokenCount?: number;
-    /** Number of tokens in the response candidates */
-    candidatesTokenCount?: number;
-    /** Total number of tokens used */
-    totalTokenCount?: number;
-}

package/dist/domain/entities/index.d.ts

@@ -1,6 +0,0 @@
-/**
- * Domain Entities
- */
-export * from "./gemini.types";
-export * from "./error.types";
-export * from "./models";

package/dist/domain/entities/models.d.ts

@@ -1,17 +0,0 @@
-/**
- * Available Gemini AI models
- */
-export declare const GEMINI_MODELS: {
-    /** Text generation models */
-    readonly TEXT: {
-        /** Lightweight flash model for fast text generation */
-        readonly FLASH_LITE: "gemini-2.5-flash-lite";
-    };
-};
-/**
- * Default models to use for each category
- */
-export declare const DEFAULT_MODELS: {
-    /** Default model for text generation */
-    readonly TEXT: "gemini-2.5-flash-lite";
-};

package/dist/index.d.ts

@@ -1,15 +0,0 @@
-/**
- * @umituz/react-native-ai-gemini-provider
- * Google Gemini AI provider for React Native applications
- */
-export type { GeminiConfig, GeminiGenerationConfig, GeminiHarmCategory, GeminiHarmBlockThreshold, GeminiContent, GeminiPart, 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 { 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";

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

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

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

@@ -1,15 +0,0 @@
-import { GoogleGenerativeAI, type GenerativeModel } from "@google/generative-ai";
-import type { GeminiConfig } from "../../domain/entities";
-declare class GeminiClient {
-    private client;
-    private config;
-    private initialized;
-    initialize(config: GeminiConfig): void;
-    isInitialized(): boolean;
-    getConfig(): GeminiConfig | null;
-    getClient(): GoogleGenerativeAI | null;
-    getModel(modelName?: string): GenerativeModel;
-    reset(): void;
-}
-export declare const geminiClient: GeminiClient;
-export {};

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

@@ -1,10 +0,0 @@
-import type { GeminiConfig } from "../../domain/entities";
-export declare class GeminiProvider {
-    readonly providerId = "gemini";
-    readonly providerName = "Google Gemini";
-    initialize(config: GeminiConfig): void;
-    isInitialized(): boolean;
-    reset(): void;
-    generateStructuredText<T>(prompt: string, schema: Record<string, unknown>, model: string): Promise<T>;
-}
-export declare const geminiProvider: GeminiProvider;

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

@@ -1,7 +0,0 @@
-import { BaseGeminiService } from "./BaseService";
-import type { GeminiContent, GeminiGenerationConfig } from "../../domain/entities";
-declare class StreamingService extends BaseGeminiService {
-    streamContent(model: string, contents: GeminiContent[], onChunk: (text: string) => void, generationConfig?: GeminiGenerationConfig, signal?: AbortSignal): Promise<string>;
-}
-export declare const streaming: StreamingService;
-export {};

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

@@ -1,7 +0,0 @@
-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/services/TextGeneration.d.ts

@@ -1,8 +0,0 @@
-import { BaseGeminiService } from "./BaseService";
-import type { GeminiContent, GeminiGenerationConfig, GeminiResponse } from "../../domain/entities";
-declare class TextGenerationService extends BaseGeminiService {
-    generateContent(model: string, contents: GeminiContent[], generationConfig?: GeminiGenerationConfig, signal?: AbortSignal): Promise<GeminiResponse>;
-    generateText(model: string, prompt: string, config?: GeminiGenerationConfig, signal?: AbortSignal): Promise<string>;
-}
-export declare const textGeneration: TextGenerationService;
-export {};

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

@@ -1,5 +0,0 @@
-export { geminiClient } from "./GeminiClient";
-export { textGeneration } from "./TextGeneration";
-export { structuredText } from "./StructuredText";
-export { streaming } from "./Streaming";
-export { geminiProvider, GeminiProvider } from "./GeminiProvider";

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

@@ -1,57 +0,0 @@
-export interface TelemetryEvent {
-    type: "request" | "response" | "error" | "retry";
-    timestamp: number;
-    model?: string;
-    feature?: string;
-    duration?: number;
-    metadata?: Record<string, unknown>;
-}
-export type TelemetryListener = (event: TelemetryEvent) => void;
-declare class TelemetryHooks {
-    private listeners;
-    private failedListeners;
-    private readonly MAX_FAILURES;
-    private listenerFailureCounts;
-    /**
-     * Register a telemetry listener
-     */
-    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/telemetry/index.d.ts

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

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

@@ -1,50 +0,0 @@
-/**
- * Async State Execution Utilities
- * Utilities for managing asynchronous operation state
- */
-/**
- * Callbacks for async operation outcomes
- */
-export interface AsyncStateCallbacks<T = string> {
-    onSuccess?: (result: T) => void;
-    onError?: (error: string) => void;
-}
-/**
- * Setter functions for updating state
- */
-export interface AsyncStateSetters<T = string, U = unknown> {
-    setIsLoading: (value: boolean) => void;
-    setError: (value: string | null) => void;
-    setResult: (value: T | null) => void;
-    setSecondaryResult?: (value: U | null) => void;
-}
-/**
- * Configuration for executeWithState
- */
-export interface AsyncStateConfig<T = string> {
-    resetState?: boolean;
-    throwOnError?: boolean;
-    transformResult?: (result: T) => T;
-}
-/**
- * Execute an async operation with automatic state management
- *
- * @param setters - State setter functions
- * @param callbacks - Optional callbacks for success/error
- * @param execute - The async operation to execute
- * @param onResult - Function to handle successful result
- * @param config - Optional configuration
- *
- * @returns The result or null if failed/aborted
- *
- * @example
- * ```ts
- * const result = await executeWithState(
- *   { setIsLoading, setError, setResult },
- *   { onSuccess: console.log },
- *   () => apiCall(),
- *   (data) => setResult(data)
- * );
- * ```
- */
-export declare function executeWithState<T, U = unknown>(setters: AsyncStateSetters<T, U>, callbacks: AsyncStateCallbacks<T>, execute: () => Promise<T>, onResult: (result: T) => void, config?: AsyncStateConfig<T>): Promise<T | null>;

package/dist/infrastructure/utils/async/index.d.ts

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

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

@@ -1,45 +0,0 @@
-/**
- * Content Mapper Utilities
- * Handles transformation between domain content and SDK format
- */
-import type { GeminiContent, GeminiPart, GeminiResponse } from "../../domain/entities";
-/**
- * Convert domain content to SDK format
- */
-export declare function toSdkContent(contents: GeminiContent[]): Array<{
-    role: string;
-    parts: Array<{
-        text: string;
-    }>;
-}>;
-/**
- * Create a simple text content
- */
-export declare function createTextContent(text: string, role?: "user" | "model"): GeminiContent;
-/**
- * Transform SDK response to domain format
- */
-export declare function transformResponse(response: {
-    candidates?: Array<{
-        content: {
-            parts: Array<{
-                text?: string;
-            }>;
-            role?: string;
-        };
-        finishReason?: string;
-        safetyRatings?: Array<{
-            category: string;
-            probability: string;
-        }>;
-    }>;
-    usageMetadata?: {
-        promptTokenCount?: number;
-        candidatesTokenCount?: number;
-        totalTokenCount?: number;
-    };
-}): GeminiResponse;
-/**
- * Extract text from content parts
- */
-export declare function extractTextFromParts(parts: GeminiPart[]): string;

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

@@ -1,2 +0,0 @@
-import { GeminiError } from "../../domain/entities";
-export declare function createGeminiError(error: unknown): GeminiError;

package/dist/infrastructure/utils/gemini-data-transformer.util.d.ts

@@ -1,2 +0,0 @@
-import type { GeminiResponse } from "../../domain/entities";
-export declare function extractTextFromResponse(response: GeminiResponse): string;

package/dist/infrastructure/utils/json-parser.util.d.ts

@@ -1,9 +0,0 @@
-/**
- * JSON Parser Utilities
- * Handles cleaning and parsing JSON responses from AI models
- */
-/**
- * Parse JSON response with error handling
- * @throws Error if parsing fails with detailed error message
- */
-export declare function parseJsonResponse<T>(text: string): T;

package/dist/infrastructure/utils/stream-processor.util.d.ts

@@ -1,14 +0,0 @@
-/**
- * Stream Processing Utilities
- * Reusable stream handling logic
- */
-interface StreamChunk {
-    text: () => string;
-}
-type ChunkCallback = (text: string) => void;
-type ErrorLogger = (error: unknown, context?: string) => void;
-/**
- * Process async stream with chunk callback
- */
-export declare function processStream(stream: AsyncIterable<StreamChunk>, onChunk: ChunkCallback, onError?: ErrorLogger): Promise<string>;
-export {};

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

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

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

@@ -1,17 +0,0 @@
-import type { GeminiGenerationConfig } from "../../domain/entities";
-export interface UseGeminiOptions {
-    model?: string;
-    generationConfig?: GeminiGenerationConfig;
-    onSuccess?: (result: string) => void;
-    onError?: (error: string) => void;
-}
-export interface UseGeminiReturn {
-    generate: (prompt: string) => Promise<void>;
-    generateJSON: <T>(prompt: string, schema?: Record<string, unknown>) => Promise<T | null>;
-    result: string | null;
-    jsonResult: unknown;
-    isGenerating: boolean;
-    error: string | null;
-    reset: () => void;
-}
-export declare function useGemini(options?: UseGeminiOptions): UseGeminiReturn;

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

@@ -1,23 +0,0 @@
-/**
- * Operation Manager Hook
- * Reusable abort controller and operation ID management
- * Eliminates code duplication in hooks
- */
-export interface OperationManager {
-    /**
-     * Execute an operation with abort support and operation ID tracking
-     */
-    executeOperation: <T>(operation: (signal: AbortSignal, operationId: number) => Promise<T>) => Promise<T>;
-    /**
-     * Abort current operation
-     */
-    abort: () => void;
-    /**
-     * Check if current operation is active
-     */
-    isOperationActive: (operationId: number) => boolean;
-}
-/**
- * Hook for managing operations with abort control
- */
-export declare function useOperationManager(): OperationManager;

package/dist/providers/ConfigBuilder.d.ts

@@ -1,50 +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;
-    /**
-     * Create from existing config (for updates)
-     */
-    static from(config: Partial<ProviderConfig>): ConfigBuilder;
-}

package/dist/providers/ProviderFactory.d.ts

@@ -1,31 +0,0 @@
-import { type ProviderConfig } from "./ConfigBuilder";
-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;
-    private builder;
-    /**
-     * Initialize provider with configuration
-     */
-    initialize(options: ProviderFactoryOptions): void;
-    /**
-     * Get current configuration
-     */
-    getConfig(): ProviderConfig | null;
-    /**
-     * 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";