@neuroequality/neuroadapt-ai/dist/providers/base-provider.d.ts

AI-powered accessibility personalization for neurodivergent users

import { EventEmitter } from 'eventemitter3';
import { AIProviderConfig, ModelCapabilities, StreamChunk, AdaptationSuggestion } from '../types/common.js';

/**
 * Events emitted by AI providers
 */
export interface AIProviderEvents {
    'stream-chunk': (chunk: StreamChunk) => void;
    'stream-complete': (result: string) => void;
    'stream-error': (error: Error) => void;
    'rate-limit': (retryAfter: number) => void;
    'error': (error: Error) => void;
}
/**
 * Request parameters for AI providers
 */
export interface AIRequest {
    prompt: string;
    system?: string;
    context?: Record<string, unknown>;
    maxTokens?: number;
    temperature?: number;
    stream?: boolean;
    functions?: AIFunction[];
}
/**
 * AI function definition for function calling
 */
export interface AIFunction {
    name: string;
    description: string;
    parameters: {
        type: 'object';
        properties: Record<string, {
            type: string;
            description: string;
            enum?: string[];
        }>;
        required?: string[];
    };
}
/**
 * AI response structure
 */
export interface AIResponse {
    content: string;
    usage?: {
        promptTokens: number;
        completionTokens: number;
        totalTokens: number;
    };
    functionCall?: {
        name: string;
        arguments: Record<string, unknown>;
    };
    finishReason: 'stop' | 'length' | 'function_call' | 'content_filter';
    metadata?: Record<string, unknown>;
}
/**
 * Provider status information
 */
export interface ProviderStatus {
    isAvailable: boolean;
    isConfigured: boolean;
    lastError?: string;
    rateLimitRemaining?: number;
    rateLimitReset?: number;
}
/**
 * Abstract base class for AI providers
 */
export declare abstract class BaseAIProvider extends EventEmitter<AIProviderEvents> {
    protected config: AIProviderConfig;
    protected capabilities: ModelCapabilities;
    protected status: ProviderStatus;
    constructor(config: AIProviderConfig);
    /**
     * Get provider capabilities
     */
    abstract getCapabilities(): ModelCapabilities;
    /**
     * Get provider name
     */
    abstract getProviderName(): string;
    /**
     * Get available models
     */
    abstract getAvailableModels(): string[];
    /**
     * Generate text completion
     */
    abstract generate(request: AIRequest): Promise<AIResponse>;
    /**
     * Generate streaming text completion
     */
    abstract generateStream(request: AIRequest): AsyncGenerator<StreamChunk, void, unknown>;
    /**
     * Analyze content for accessibility adaptations
     */
    abstract analyzeAccessibility(content: string, currentPreferences: Record<string, unknown>, context?: Record<string, unknown>): Promise<AdaptationSuggestion[]>;
    /**
     * Simplify content for cognitive accessibility
     */
    abstract simplifyContent(content: string, targetLevel: 'simple' | 'intermediate' | 'advanced', context?: Record<string, unknown>): Promise<string>;
    /**
     * Update provider configuration
     */
    updateConfig(newConfig: Partial<AIProviderConfig>): void;
    /**
     * Get current provider status
     */
    getStatus(): ProviderStatus;
    /**
     * Test provider availability
     */
    testConnection(): Promise<boolean>;
    /**
     * Get estimated cost for request
     */
    estimateCost(request: AIRequest): number;
    /**
     * Check if provider supports a specific capability
     */
    supportsCapability(capability: keyof ModelCapabilities): boolean;
    /**
     * Get rate limit information
     */
    getRateLimitInfo(): {
        remaining?: number;
        reset?: number;
    };
    /**
     * Validate provider configuration
     */
    protected isConfigValid(): boolean;
    /**
     * Check provider availability
     */
    protected checkAvailability(): Promise<void>;
    /**
     * Handle rate limiting
     */
    protected handleRateLimit(retryAfter: number): void;
    /**
     * Update rate limit status
     */
    protected updateRateLimit(remaining: number, reset: number): void;
    /**
     * Create standard error response
     */
    protected createErrorResponse(error: Error): never;
    /**
     * Validate request parameters
     */
    protected validateRequest(request: AIRequest): void;
    /**
     * Create accessibility analysis prompt
     */
    protected createAccessibilityPrompt(content: string, currentPreferences: Record<string, unknown>): string;
    /**
     * Create content simplification prompt
     */
    protected createSimplificationPrompt(content: string, targetLevel: string): string;
    /**
     * Parse adaptation suggestions from AI response
     */
    protected parseAdaptationSuggestions(response: string): AdaptationSuggestion[];
}
//# sourceMappingURL=base-provider.d.ts.map