@matthew.ngo/ai-toolkit/dist/react/index.d.cts

A comprehensive AI toolkit with multi-provider support

import { z } from 'zod';

type AIProviderType = 'openai' | 'anthropic' | 'google' | 'cohere' | 'huggingface' | 'replicate' | 'stability' | 'elevenlabs' | 'whisper' | 'custom' | 'local' | 'mock';
declare const AIConfigSchema: z.ZodObject<{
    provider: z.ZodType<AIProviderType, z.ZodTypeDef, AIProviderType>;
    apiKey: z.ZodOptional<z.ZodString>;
    apiKeys: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    model: z.ZodOptional<z.ZodString>;
    models: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    baseUrl: z.ZodOptional<z.ZodString>;
    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    maxRetries: z.ZodOptional<z.ZodNumber>;
    timeout: z.ZodOptional<z.ZodNumber>;
    cache: z.ZodOptional<z.ZodObject<{
        enabled: z.ZodDefault<z.ZodBoolean>;
        ttl: z.ZodDefault<z.ZodNumber>;
        maxSize: z.ZodDefault<z.ZodNumber>;
        strategy: z.ZodDefault<z.ZodEnum<["lru", "fifo", "lfu"]>>;
    }, "strip", z.ZodTypeAny, {
        strategy: "lru" | "fifo" | "lfu";
        enabled: boolean;
        ttl: number;
        maxSize: number;
    }, {
        strategy?: "lru" | "fifo" | "lfu" | undefined;
        enabled?: boolean | undefined;
        ttl?: number | undefined;
        maxSize?: number | undefined;
    }>>;
    rateLimit: z.ZodOptional<z.ZodObject<{
        requestsPerMinute: z.ZodOptional<z.ZodNumber>;
        tokensPerMinute: z.ZodOptional<z.ZodNumber>;
        requestsPerHour: z.ZodOptional<z.ZodNumber>;
        tokensPerHour: z.ZodOptional<z.ZodNumber>;
        concurrent: z.ZodDefault<z.ZodNumber>;
        strategy: z.ZodDefault<z.ZodEnum<["fixed-window", "sliding-window", "token-bucket"]>>;
    }, "strip", z.ZodTypeAny, {
        concurrent: number;
        strategy: "fixed-window" | "sliding-window" | "token-bucket";
        requestsPerMinute?: number | undefined;
        tokensPerMinute?: number | undefined;
        requestsPerHour?: number | undefined;
        tokensPerHour?: number | undefined;
    }, {
        requestsPerMinute?: number | undefined;
        tokensPerMinute?: number | undefined;
        requestsPerHour?: number | undefined;
        tokensPerHour?: number | undefined;
        concurrent?: number | undefined;
        strategy?: "fixed-window" | "sliding-window" | "token-bucket" | undefined;
    }>>;
    retry: z.ZodOptional<z.ZodObject<{
        maxAttempts: z.ZodDefault<z.ZodNumber>;
        baseDelay: z.ZodDefault<z.ZodNumber>;
        maxDelay: z.ZodDefault<z.ZodNumber>;
        backoff: z.ZodDefault<z.ZodEnum<["exponential", "linear", "fixed"]>>;
    }, "strip", z.ZodTypeAny, {
        maxAttempts: number;
        baseDelay: number;
        maxDelay: number;
        backoff: "exponential" | "linear" | "fixed";
    }, {
        maxAttempts?: number | undefined;
        baseDelay?: number | undefined;
        maxDelay?: number | undefined;
        backoff?: "exponential" | "linear" | "fixed" | undefined;
    }>>;
    fallbackProviders: z.ZodOptional<z.ZodArray<z.ZodType<AIProviderType, z.ZodTypeDef, AIProviderType>, "many">>;
}, "strip", z.ZodTypeAny, {
    provider: AIProviderType;
    apiKey?: string | undefined;
    apiKeys?: Record<string, string> | undefined;
    model?: string | undefined;
    models?: Record<string, string> | undefined;
    baseUrl?: string | undefined;
    headers?: Record<string, string> | undefined;
    maxRetries?: number | undefined;
    timeout?: number | undefined;
    cache?: {
        strategy: "lru" | "fifo" | "lfu";
        enabled: boolean;
        ttl: number;
        maxSize: number;
    } | undefined;
    rateLimit?: {
        concurrent: number;
        strategy: "fixed-window" | "sliding-window" | "token-bucket";
        requestsPerMinute?: number | undefined;
        tokensPerMinute?: number | undefined;
        requestsPerHour?: number | undefined;
        tokensPerHour?: number | undefined;
    } | undefined;
    retry?: {
        maxAttempts: number;
        baseDelay: number;
        maxDelay: number;
        backoff: "exponential" | "linear" | "fixed";
    } | undefined;
    fallbackProviders?: AIProviderType[] | undefined;
}, {
    provider: AIProviderType;
    apiKey?: string | undefined;
    apiKeys?: Record<string, string> | undefined;
    model?: string | undefined;
    models?: Record<string, string> | undefined;
    baseUrl?: string | undefined;
    headers?: Record<string, string> | undefined;
    maxRetries?: number | undefined;
    timeout?: number | undefined;
    cache?: {
        strategy?: "lru" | "fifo" | "lfu" | undefined;
        enabled?: boolean | undefined;
        ttl?: number | undefined;
        maxSize?: number | undefined;
    } | undefined;
    rateLimit?: {
        requestsPerMinute?: number | undefined;
        tokensPerMinute?: number | undefined;
        requestsPerHour?: number | undefined;
        tokensPerHour?: number | undefined;
        concurrent?: number | undefined;
        strategy?: "fixed-window" | "sliding-window" | "token-bucket" | undefined;
    } | undefined;
    retry?: {
        maxAttempts?: number | undefined;
        baseDelay?: number | undefined;
        maxDelay?: number | undefined;
        backoff?: "exponential" | "linear" | "fixed" | undefined;
    } | undefined;
    fallbackProviders?: AIProviderType[] | undefined;
}>;
type AIConfig = z.infer<typeof AIConfigSchema>;
interface GenerateOptions {
    maxTokens?: number;
    temperature?: number;
    topP?: number;
    topK?: number;
    frequencyPenalty?: number;
    presencePenalty?: number;
    stopSequences?: string[];
    systemPrompt?: string;
    stream?: boolean;
    format?: 'text' | 'json' | 'markdown';
    seed?: number;
    logitBias?: Record<string, number>;
    functions?: FunctionDefinition[];
    responseFormat?: ResponseFormat;
}
interface FunctionDefinition {
    name: string;
    description: string;
    parameters: Record<string, any>;
}
interface ResponseFormat {
    type: 'text' | 'json_object';
    schema?: Record<string, any>;
}
interface Classification {
    label: string;
    confidence: number;
    scores: Record<string, number>;
}
interface SummarizeOptions {
    maxLength?: number;
    minLength?: number;
    style?: 'bullet' | 'paragraph' | 'tldr' | 'key-points' | 'executive';
    language?: string;
    extractive?: boolean;
}
interface ImageGenerationOptions {
    size?: '256x256' | '512x512' | '1024x1024' | '1792x1024' | '1024x1792';
    style?: 'realistic' | 'artistic' | 'cartoon' | 'photographic';
    quality?: 'standard' | 'hd';
    n?: number;
    negativePrompt?: string;
    seed?: number;
    steps?: number;
    guidanceScale?: number;
}
interface ImageResult {
    url?: string;
    base64?: string;
    revisedPrompt?: string;
    metadata?: Record<string, any>;
}
interface TranscriptionOptions {
    language?: string;
    translateTo?: string;
    format?: 'text' | 'srt' | 'vtt' | 'json';
    timestamps?: boolean;
    speakerDiarization?: boolean;
}
interface TranscriptionResult {
    text: string;
    language?: string;
    duration?: number;
    words?: WordTimestamp[];
    speakers?: SpeakerSegment[];
}
interface WordTimestamp {
    word: string;
    start: number;
    end: number;
    confidence?: number;
}
interface SpeakerSegment {
    speaker: string;
    start: number;
    end: number;
    text: string;
}
interface SpeechOptions {
    voice?: string;
    speed?: number;
    pitch?: number;
    volume?: number;
    format?: 'mp3' | 'wav' | 'ogg';
    language?: string;
    emotion?: string;
}
interface CodeGenerationOptions {
    language?: string;
    framework?: string;
    style?: 'concise' | 'verbose' | 'documented';
    includeTests?: boolean;
    includeComments?: boolean;
}
interface CodeResult {
    code: string;
    language: string;
    explanation?: string;
    tests?: string;
    dependencies?: string[];
}

interface UseAIOptions {
    config?: Partial<AIConfig>;
    onError?: (error: Error) => void;
    debug?: boolean;
}
interface UseAIReturn {
    generateText: (prompt: string, options?: GenerateOptions) => Promise<string>;
    generateStream: (prompt: string, options?: GenerateOptions) => AsyncGenerator<string>;
    summarize: (text: string, options?: SummarizeOptions) => Promise<string>;
    classifyText: (text: string, labels: string[]) => Promise<Classification>;
    generateEmbedding: (text: string) => Promise<number[]>;
    generateImage: (prompt: string, options?: ImageGenerationOptions) => Promise<ImageResult>;
    transcribeAudio: (audio: Blob, options?: TranscriptionOptions) => Promise<TranscriptionResult>;
    generateSpeech: (text: string, options?: SpeechOptions) => Promise<Blob>;
    generateCode: (prompt: string, options?: CodeGenerationOptions) => Promise<CodeResult>;
    loading: boolean;
    error: Error | null;
    stats: any;
    updateConfig: (config: Partial<AIConfig>) => Promise<void>;
    reset: () => Promise<void>;
}
declare function useAI(options?: UseAIOptions): UseAIReturn;
declare function useAIChat(systemPrompt?: string): {
    messages: {
        id: string;
        role: "user" | "assistant" | "system";
        content: string;
        timestamp: Date;
    }[];
    sendMessage: (content: string) => Promise<string>;
    clearMessages: () => void;
    loading: boolean;
    error: Error | null;
};
declare function useAIEmbeddings(): {
    generateEmbedding: (text: string) => Promise<number[]>;
    findSimilar: (query: string, items: Array<{
        id: string;
        text: string;
    }>, topK?: number) => Promise<{
        similarity: number;
        id: string;
        text: string;
    }[]>;
};

export { useAI, useAIChat, useAIEmbeddings };