resig.js/build/module/streaming/ai-transformer.d.ts

Universal reactive signal library with complete platform features: signals, animations, CRDTs, scheduling, DOM integration. Works identically across React, SolidJS, Svelte, Vue, and Qwik.

/**
 * AI Transformer Interface
 * Streaming AI integration with confidence tracking and token management
 */
import { Signal } from '../core/signal';
import { StreamingSignal } from './coalgebra';
export type AIModelType = 'gpt-4' | 'claude-3' | 'llama-3' | 'gemini' | 'custom';
export interface TokenUsage {
    input: number;
    output: number;
    total: number;
    cost?: number;
}
export interface AITransformer<I, O> {
    transform(input: StreamingSignal<I>): StreamingSignal<O>;
    confidence(): Signal<number>;
    tokens(): Signal<TokenUsage>;
    isProcessing(): Signal<boolean>;
    getModel(): AIModelType;
    setConfig(config: Partial<AIConfig>): void;
}
export interface AIConfig {
    model: AIModelType;
    apiKey?: string;
    baseURL?: string;
    maxTokens: number;
    temperature: number;
    streaming: boolean;
    timeout: number;
    retryAttempts: number;
    rateLimitDelay: number;
}
export interface AIResponse<T> {
    data: T;
    confidence: number;
    tokens: TokenUsage;
    processingTime: number;
    model: string;
    timestamp: number;
}
interface RateLimitState {
    requestCount: number;
    windowStart: number;
    maxRequests: number;
    windowSize: number;
}
export declare abstract class BaseAITransformer<I, O> implements AITransformer<I, O> {
    protected config: AIConfig;
    protected confidenceSignal: import("../core/signal").MutableSignal<number> & {
        _set: (value: number) => void;
    };
    protected tokensSignal: import("../core/signal").MutableSignal<TokenUsage> & {
        _set: (value: TokenUsage) => void;
    };
    protected processingSignal: import("../core/signal").MutableSignal<boolean> & {
        _set: (value: boolean) => void;
    };
    protected rateLimitState: RateLimitState;
    constructor(config: AIConfig);
    abstract processRequest(input: I): Promise<AIResponse<O>>;
    transform(input: StreamingSignal<I>): StreamingSignal<O>;
    private checkRateLimit;
    confidence(): Signal<number>;
    tokens(): Signal<TokenUsage>;
    isProcessing(): Signal<boolean>;
    getModel(): AIModelType;
    setConfig(config: Partial<AIConfig>): void;
}
export declare class OpenAITransformer extends BaseAITransformer<string, string> {
    processRequest(input: string): Promise<AIResponse<string>>;
    private calculateConfidence;
}
export declare class MockAITransformer extends BaseAITransformer<string, string> {
    processRequest(input: string): Promise<AIResponse<string>>;
}
export declare class MultiModalTransformer extends BaseAITransformer<{
    text?: string;
    image?: string;
}, string> {
    processRequest(input: {
        text?: string;
        image?: string;
    }): Promise<AIResponse<string>>;
}
export declare const createLLMTransformer: (model: AIModelType, config?: Partial<AIConfig>) => AITransformer<string, string>;
export declare const createVisionModel: (_model: string, config?: Partial<AIConfig>) => AITransformer<{
    text?: string;
    image?: string;
}, string>;
export declare const composeAITransformers: <I, M, O>(first: AITransformer<I, M>, second: AITransformer<M, O>) => AITransformer<I, O>;
export declare const createBatchAITransformer: <I, O>(baseTransformer: AITransformer<I[], O[]>, batchSize?: number) => AITransformer<I, O>;
export {};