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

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 { createStreamingSignal } from './coalgebra';
// Base AI transformer implementation
export class BaseAITransformer {
    constructor(config) {
        this.confidenceSignal = signal(0);
        this.tokensSignal = signal({
            input: 0,
            output: 0,
            total: 0,
        });
        this.processingSignal = signal(false);
        this.config = { ...config };
        this.rateLimitState = {
            requestCount: 0,
            windowStart: Date.now(),
            maxRequests: 60, // Default: 60 requests per minute
            windowSize: 60000,
        };
    }
    transform(input) {
        const output = createStreamingSignal(null);
        input.subscribe(async (inputValue) => {
            if (inputValue === null || inputValue === undefined)
                return;
            try {
                this.processingSignal._set(true);
                // Check rate limiting
                await this.checkRateLimit();
                // Process the request
                const response = await this.processRequest(inputValue);
                // Update signals
                this.confidenceSignal._set(response.confidence);
                this.tokensSignal._set(response.tokens);
                output._set(response.data);
            }
            catch (error) {
                console.error('AI transformer error:', error);
                this.confidenceSignal._set(0);
            }
            finally {
                this.processingSignal._set(false);
            }
        });
        return output;
    }
    async checkRateLimit() {
        const now = Date.now();
        // Reset window if needed
        if (now - this.rateLimitState.windowStart >=
            this.rateLimitState.windowSize) {
            this.rateLimitState.requestCount = 0;
            this.rateLimitState.windowStart = now;
        }
        // Check if we've exceeded the limit
        if (this.rateLimitState.requestCount >= this.rateLimitState.maxRequests) {
            const waitTime = this.rateLimitState.windowSize -
                (now - this.rateLimitState.windowStart);
            await new Promise((resolve) => setTimeout(resolve, waitTime));
            return this.checkRateLimit();
        }
        this.rateLimitState.requestCount++;
    }
    confidence() {
        return this.confidenceSignal;
    }
    tokens() {
        return this.tokensSignal;
    }
    isProcessing() {
        return this.processingSignal;
    }
    getModel() {
        return this.config.model;
    }
    setConfig(config) {
        this.config = { ...this.config, ...config };
    }
}
// OpenAI GPT transformer
export class OpenAITransformer extends BaseAITransformer {
    async processRequest(input) {
        const startTime = Date.now();
        try {
            const response = await fetch(`${this.config.baseURL || 'https://api.openai.com/v1'}/chat/completions`, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                    Authorization: `Bearer ${this.config.apiKey}`,
                },
                body: JSON.stringify({
                    model: this.config.model === 'gpt-4' ? 'gpt-4' : 'gpt-3.5-turbo',
                    messages: [{ role: 'user', content: input }],
                    max_tokens: this.config.maxTokens,
                    temperature: this.config.temperature,
                    stream: this.config.streaming,
                }),
            });
            if (!response.ok) {
                throw new Error(`OpenAI API error: ${response.status}`);
            }
            const data = await response.json();
            const choice = data.choices[0];
            const usage = data.usage;
            return {
                data: choice.message.content,
                confidence: this.calculateConfidence(choice),
                tokens: {
                    input: usage.prompt_tokens,
                    output: usage.completion_tokens,
                    total: usage.total_tokens,
                },
                processingTime: Date.now() - startTime,
                model: data.model,
                timestamp: Date.now(),
            };
        }
        catch (error) {
            throw new Error(`OpenAI processing failed: ${error}`);
        }
    }
    calculateConfidence(choice) {
        // Simple confidence calculation based on finish_reason and logprobs
        if (choice.finish_reason === 'stop')
            return 0.9;
        if (choice.finish_reason === 'length')
            return 0.7;
        return 0.5;
    }
}
// Mock AI transformer for testing
export class MockAITransformer extends BaseAITransformer {
    async processRequest(input) {
        const startTime = Date.now();
        // Simulate processing delay
        await new Promise((resolve) => setTimeout(resolve, 100 + Math.random() * 500));
        const output = `AI response to: "${input}"`;
        const inputTokens = Math.ceil(input.length / 4); // Rough token estimation
        const outputTokens = Math.ceil(output.length / 4);
        return {
            data: output,
            confidence: 0.8 + Math.random() * 0.2,
            tokens: {
                input: inputTokens,
                output: outputTokens,
                total: inputTokens + outputTokens,
            },
            processingTime: Date.now() - startTime,
            model: 'mock-ai',
            timestamp: Date.now(),
        };
    }
}
// Multi-modal AI transformer for vision + language
export class MultiModalTransformer extends BaseAITransformer {
    async processRequest(input) {
        const startTime = Date.now();
        // Simulate multi-modal processing
        await new Promise((resolve) => setTimeout(resolve, 200 + Math.random() * 800));
        let response = '';
        if (input.text)
            response += `Text analysis: ${input.text}. `;
        if (input.image)
            response += `Image analysis: [Image content description]. `;
        const inputTokens = (input.text?.length || 0) / 4 + (input.image ? 100 : 0); // Images cost more tokens
        const outputTokens = response.length / 4;
        return {
            data: response.trim(),
            confidence: 0.75 + Math.random() * 0.25,
            tokens: {
                input: Math.ceil(inputTokens),
                output: Math.ceil(outputTokens),
                total: Math.ceil(inputTokens + outputTokens),
            },
            processingTime: Date.now() - startTime,
            model: 'multimodal-ai',
            timestamp: Date.now(),
        };
    }
}
// Factory functions for creating AI transformers
export const createLLMTransformer = (model, config = {}) => {
    const fullConfig = {
        model,
        maxTokens: 4000,
        temperature: 0.7,
        streaming: false,
        timeout: 30000,
        retryAttempts: 3,
        rateLimitDelay: 1000,
        ...config,
    };
    switch (model) {
        case 'gpt-4':
            return new OpenAITransformer(fullConfig);
        case 'custom':
            return new MockAITransformer(fullConfig);
        default:
            return new MockAITransformer(fullConfig);
    }
};
export const createVisionModel = (_model, config = {}) => {
    const fullConfig = {
        model: 'custom',
        maxTokens: 2000,
        temperature: 0.5,
        streaming: false,
        timeout: 45000,
        retryAttempts: 2,
        rateLimitDelay: 2000,
        ...config,
    };
    return new MultiModalTransformer(fullConfig);
};
// AI agent composition utilities
export const composeAITransformers = (first, second) => {
    return {
        transform: (input) => {
            const intermediate = first.transform(input);
            return second.transform(intermediate);
        },
        confidence: () => {
            // Combined confidence is the minimum of both
            const conf1 = first.confidence().value();
            const conf2 = second.confidence().value();
            return signal(Math.min(conf1, conf2));
        },
        tokens: () => {
            // Combined token usage
            const tokens1 = first.tokens().value();
            const tokens2 = second.tokens().value();
            return signal({
                input: tokens1.input,
                output: tokens2.output,
                total: tokens1.total + tokens2.total,
            });
        },
        isProcessing: () => {
            // Either transformer is processing
            const proc1 = first.isProcessing().value();
            const proc2 = second.isProcessing().value();
            return signal(proc1 || proc2);
        },
        getModel: () => 'composed',
        setConfig: (config) => {
            first.setConfig(config);
            second.setConfig(config);
        },
    };
};
// Batch processing for multiple inputs
export const createBatchAITransformer = (baseTransformer, batchSize = 10) => {
    return {
        transform: (input) => {
            const batched = input.buffer(batchSize);
            const batchOutput = baseTransformer.transform(batched);
            // Flatten batch output back to individual items
            const output = createStreamingSignal(null);
            batchOutput.subscribe((batch) => {
                if (batch && Array.isArray(batch)) {
                    batch.forEach((item) => output._set(item));
                }
            });
            return output;
        },
        confidence: baseTransformer.confidence,
        tokens: baseTransformer.tokens,
        isProcessing: baseTransformer.isProcessing,
        getModel: baseTransformer.getModel,
        setConfig: baseTransformer.setConfig,
    };
};
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ai-transformer.js","sourceRoot":"","sources":["../../../src/streaming/ai-transformer.ts"],"names":[],"mappings":"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"}