@lukaplayground/aikit 1.0.0 → 1.0.1

package/dist/aikit.umd.js

@@ -0,0 +1,1851 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+    typeof define === 'function' && define.amd ? define(factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.AIKit = factory());
+})(this, (function () { 'use strict';
+
+    /**
+     * CacheManager - LocalStorage based caching system
+     * @class
+     */
+    class CacheManager {
+        constructor(options = {}) {
+            this.prefix = options.prefix || 'aikit_cache_';
+            this.maxAge = options.maxAge || 3600000; // 1 hour default
+            this.maxSize = options.maxSize || 100; // Maximum cache entries
+            
+            this.storage = typeof window !== 'undefined' && window.localStorage 
+                ? window.localStorage 
+                : new MemoryStorage();
+        }
+
+        /**
+         * Generate cache key from message and options
+         */
+        generateKey(message, options = {}) {
+            const normalized = {
+                message: message.trim().toLowerCase(),
+                ...options
+            };
+            
+            const str = JSON.stringify(normalized);
+            return this.prefix + this.hashCode(str);
+        }
+
+        /**
+         * Simple hash function
+         * @private
+         */
+        hashCode(str) {
+            let hash = 0;
+            for (let i = 0; i < str.length; i++) {
+                const char = str.charCodeAt(i);
+                hash = ((hash << 5) - hash) + char;
+                hash = hash & hash; // Convert to 32bit integer
+            }
+            return Math.abs(hash).toString(36);
+        }
+
+        /**
+         * Get cached item
+         */
+        get(key) {
+            try {
+                const item = this.storage.getItem(key);
+                if (!item) return null;
+
+                const parsed = JSON.parse(item);
+                const now = Date.now();
+
+                // Check expiration
+                if (now - parsed.timestamp > this.maxAge) {
+                    this.storage.removeItem(key);
+                    return null;
+                }
+
+                return parsed.data;
+            } catch (error) {
+                console.warn('AIKit CacheManager: Error reading cache', error);
+                return null;
+            }
+        }
+
+        /**
+         * Set cache item
+         */
+        set(key, data) {
+            try {
+                // Check size limit
+                this.enforceMaxSize();
+
+                const item = {
+                    data,
+                    timestamp: Date.now()
+                };
+
+                this.storage.setItem(key, JSON.stringify(item));
+                return true;
+            } catch (error) {
+                console.warn('AIKit CacheManager: Error writing cache', error);
+                return false;
+            }
+        }
+
+        /**
+         * Enforce maximum cache size
+         * @private
+         */
+        enforceMaxSize() {
+            const keys = this.getKeys();
+            
+            if (keys.length >= this.maxSize) {
+                // Remove oldest entries
+                const entries = keys.map(key => {
+                    const item = this.storage.getItem(key);
+                    const parsed = JSON.parse(item);
+                    return { key, timestamp: parsed.timestamp };
+                });
+
+                entries.sort((a, b) => a.timestamp - b.timestamp);
+
+                // Remove oldest 20%
+                const toRemove = Math.ceil(this.maxSize * 0.2);
+                for (let i = 0; i < toRemove; i++) {
+                    this.storage.removeItem(entries[i].key);
+                }
+            }
+        }
+
+        /**
+         * Get all cache keys
+         * @private
+         */
+        getKeys() {
+            const keys = [];
+            for (let i = 0; i < this.storage.length; i++) {
+                const key = this.storage.key(i);
+                if (key && key.startsWith(this.prefix)) {
+                    keys.push(key);
+                }
+            }
+            return keys;
+        }
+
+        /**
+         * Clear all cache
+         */
+        clear() {
+            const keys = this.getKeys();
+            keys.forEach(key => this.storage.removeItem(key));
+        }
+
+        /**
+         * Get cache statistics
+         */
+        getStats() {
+            const keys = this.getKeys();
+            const now = Date.now();
+            
+            let totalSize = 0;
+            let validEntries = 0;
+            
+            keys.forEach(key => {
+                const item = this.storage.getItem(key);
+                if (item) {
+                    totalSize += item.length;
+                    const parsed = JSON.parse(item);
+                    if (now - parsed.timestamp <= this.maxAge) {
+                        validEntries++;
+                    }
+                }
+            });
+
+            return {
+                totalEntries: keys.length,
+                validEntries,
+                expiredEntries: keys.length - validEntries,
+                totalSize,
+                maxAge: this.maxAge,
+                maxSize: this.maxSize
+            };
+        }
+    }
+
+    /**
+     * Memory-based storage fallback (for Node.js or browsers without localStorage)
+     * @class
+     */
+    class MemoryStorage {
+        constructor() {
+            this.storage = new Map();
+        }
+
+        getItem(key) {
+            return this.storage.get(key) || null;
+        }
+
+        setItem(key, value) {
+            this.storage.set(key, value);
+        }
+
+        removeItem(key) {
+            this.storage.delete(key);
+        }
+
+        key(index) {
+            return Array.from(this.storage.keys())[index];
+        }
+
+        get length() {
+            return this.storage.size;
+        }
+
+        clear() {
+            this.storage.clear();
+        }
+    }
+
+    /**
+     * CostTracker - Track API usage costs
+     * @class
+     */
+    class CostTracker {
+        constructor(options = {}) {
+            this.storageKey = options.storageKey || 'aikit_cost_tracker';
+            this.storage = typeof window !== 'undefined' && window.localStorage 
+                ? window.localStorage 
+                : new Map();
+            
+            // 토큰당 가격 (USD) - 2024년 기준 근사치
+            this.pricing = {
+                openai: {
+                    'gpt-4': { input: 0.03 / 1000, output: 0.06 / 1000 },
+                    'gpt-4-turbo': { input: 0.01 / 1000, output: 0.03 / 1000 },
+                    'gpt-3.5-turbo': { input: 0.0005 / 1000, output: 0.0015 / 1000 }
+                },
+                claude: {
+                    'claude-3-opus': { input: 0.015 / 1000, output: 0.075 / 1000 },
+                    'claude-3-sonnet': { input: 0.003 / 1000, output: 0.015 / 1000 },
+                    'claude-3-haiku': { input: 0.00025 / 1000, output: 0.00125 / 1000 }
+                },
+                gemini: {
+                    'gemini-pro': { input: 0.00025 / 1000, output: 0.0005 / 1000 },
+                    'gemini-ultra': { input: 0.0005 / 1000, output: 0.001 / 1000 }
+                }
+            };
+
+            this.loadData();
+        }
+
+        /**
+         * Load existing tracking data
+         * @private
+         */
+        loadData() {
+            try {
+                if (this.storage instanceof Map) {
+                    this.data = this.storage.get(this.storageKey) || this.initializeData();
+                } else {
+                    const stored = this.storage.getItem(this.storageKey);
+                    this.data = stored ? JSON.parse(stored) : this.initializeData();
+                }
+            } catch (error) {
+                console.warn('AIKit CostTracker: Error loading data', error);
+                this.data = this.initializeData();
+            }
+        }
+
+        /**
+         * Initialize empty data structure
+         * @private
+         */
+        initializeData() {
+            return {
+                total: 0,
+                byProvider: {},
+                byModel: {},
+                requests: [],
+                startDate: new Date().toISOString()
+            };
+        }
+
+        /**
+         * Save tracking data
+         * @private
+         */
+        saveData() {
+            try {
+                if (this.storage instanceof Map) {
+                    this.storage.set(this.storageKey, this.data);
+                } else {
+                    this.storage.setItem(this.storageKey, JSON.stringify(this.data));
+                }
+            } catch (error) {
+                console.warn('AIKit CostTracker: Error saving data', error);
+            }
+        }
+
+        /**
+         * Track a request
+         * @param {Object} request
+         */
+        track(request) {
+            const { provider, model, tokens = {}, timestamp } = request;
+            
+            // Calculate cost
+            const cost = this.calculateCost(provider, model, tokens);
+            
+            // Update totals
+            this.data.total += cost;
+            
+            // Update by provider
+            if (!this.data.byProvider[provider]) {
+                this.data.byProvider[provider] = 0;
+            }
+            this.data.byProvider[provider] += cost;
+            
+            // Update by model
+            const modelKey = `${provider}:${model || 'default'}`;
+            if (!this.data.byModel[modelKey]) {
+                this.data.byModel[modelKey] = 0;
+            }
+            this.data.byModel[modelKey] += cost;
+            
+            // Add to request history (keep last 100)
+            this.data.requests.push({
+                provider,
+                model,
+                tokens,
+                cost,
+                timestamp: timestamp || new Date().toISOString()
+            });
+            
+            if (this.data.requests.length > 100) {
+                this.data.requests.shift();
+            }
+            
+            this.saveData();
+            
+            return cost;
+        }
+
+        /**
+         * Calculate cost for a request
+         * @private
+         */
+        calculateCost(provider, model, tokens) {
+            const providerPricing = this.pricing[provider.toLowerCase()];
+            if (!providerPricing) {
+                console.warn(`AIKit CostTracker: Unknown provider '${provider}'`);
+                return 0;
+            }
+
+            // Find matching model pricing
+            let modelPricing;
+            if (model) {
+                const modelKey = Object.keys(providerPricing).find(key => 
+                    model.toLowerCase().includes(key)
+                );
+                modelPricing = providerPricing[modelKey];
+            }
+            
+            // Fallback to first available pricing
+            if (!modelPricing) {
+                modelPricing = Object.values(providerPricing)[0];
+            }
+
+            const inputCost = (tokens.input || tokens.prompt_tokens || 0) * modelPricing.input;
+            const outputCost = (tokens.output || tokens.completion_tokens || 0) * modelPricing.output;
+            
+            return inputCost + outputCost;
+        }
+
+        /**
+         * Get cost report
+         */
+        getReport() {
+            const daysSinceStart = Math.ceil(
+                (new Date() - new Date(this.data.startDate)) / (1000 * 60 * 60 * 24)
+            );
+
+            return {
+                total: this.data.total.toFixed(4),
+                totalUSD: `$${this.data.total.toFixed(4)}`,
+                byProvider: Object.entries(this.data.byProvider).reduce((acc, [key, value]) => {
+                    acc[key] = `$${value.toFixed(4)}`;
+                    return acc;
+                }, {}),
+                byModel: Object.entries(this.data.byModel).reduce((acc, [key, value]) => {
+                    acc[key] = `$${value.toFixed(4)}`;
+                    return acc;
+                }, {}),
+                totalRequests: this.data.requests.length,
+                averageCostPerRequest: this.data.requests.length > 0 
+                    ? `$${(this.data.total / this.data.requests.length).toFixed(6)}`
+                    : '$0',
+                dailyAverage: `$${(this.data.total / Math.max(daysSinceStart, 1)).toFixed(4)}`,
+                startDate: this.data.startDate,
+                lastRequest: this.data.requests.length > 0 
+                    ? this.data.requests[this.data.requests.length - 1].timestamp
+                    : null
+            };
+        }
+
+        /**
+         * Get recent requests
+         */
+        getRecentRequests(limit = 10) {
+            return this.data.requests.slice(-limit).reverse();
+        }
+
+        /**
+         * Reset all tracking data
+         */
+        reset() {
+            this.data = this.initializeData();
+            this.saveData();
+        }
+
+        /**
+         * Update pricing for a provider/model
+         */
+        updatePricing(provider, model, inputPrice, outputPrice) {
+            if (!this.pricing[provider]) {
+                this.pricing[provider] = {};
+            }
+            
+            this.pricing[provider][model] = {
+                input: inputPrice,
+                output: outputPrice
+            };
+        }
+
+        /**
+         * Export data as JSON
+         */
+        exportData() {
+            return JSON.stringify(this.data, null, 2);
+        }
+
+        /**
+         * Import data from JSON
+         */
+        importData(jsonString) {
+            try {
+                this.data = JSON.parse(jsonString);
+                this.saveData();
+                return true;
+            } catch (error) {
+                console.error('AIKit CostTracker: Error importing data', error);
+                return false;
+            }
+        }
+    }
+
+    /**
+     * ResponseValidator - Validate AI responses based on rules
+     * QA-focused validation layer
+     * @class
+     */
+    class ResponseValidator {
+        constructor() {
+            this.rules = new Map();
+            this.loadDefaultRules();
+        }
+
+        /**
+         * Load default validation rules
+         * @private
+         */
+        loadDefaultRules() {
+            // Length validation
+            this.addRule('maxLength', (response, limit) => {
+                const text = this.extractText(response);
+                if (text.length > limit) {
+                    return {
+                        valid: false,
+                        error: `Response exceeds maximum length (${text.length} > ${limit})`
+                    };
+                }
+                return { valid: true };
+            });
+
+            this.addRule('minLength', (response, limit) => {
+                const text = this.extractText(response);
+                if (text.length < limit) {
+                    return {
+                        valid: false,
+                        error: `Response below minimum length (${text.length} < ${limit})`
+                    };
+                }
+                return { valid: true };
+            });
+
+            // Content validation
+            this.addRule('mustInclude', (response, keywords) => {
+                const text = this.extractText(response).toLowerCase();
+                const missing = keywords.filter(kw => !text.includes(kw.toLowerCase()));
+                
+                if (missing.length > 0) {
+                    return {
+                        valid: false,
+                        error: `Response missing required keywords: ${missing.join(', ')}`
+                    };
+                }
+                return { valid: true };
+            });
+
+            this.addRule('mustNotInclude', (response, keywords) => {
+                const text = this.extractText(response).toLowerCase();
+                const found = keywords.filter(kw => text.includes(kw.toLowerCase()));
+                
+                if (found.length > 0) {
+                    return {
+                        valid: false,
+                        error: `Response contains forbidden keywords: ${found.join(', ')}`
+                    };
+                }
+                return { valid: true };
+            });
+
+            // Format validation
+            this.addRule('format', (response, format) => {
+                const text = this.extractText(response);
+                
+                const formats = {
+                    json: () => {
+                        try {
+                            JSON.parse(text);
+                            return { valid: true };
+                        } catch (e) {
+                            return { valid: false, error: 'Response is not valid JSON' };
+                        }
+                    },
+                    email: () => {
+                        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+                        const hasEmail = emailRegex.test(text);
+                        return hasEmail 
+                            ? { valid: true }
+                            : { valid: false, error: 'Response does not contain valid email' };
+                    },
+                    url: () => {
+                        const urlRegex = /(https?:\/\/[^\s]+)/g;
+                        const hasUrl = urlRegex.test(text);
+                        return hasUrl 
+                            ? { valid: true }
+                            : { valid: false, error: 'Response does not contain valid URL' };
+                    },
+                    number: () => {
+                        const hasNumber = /\d+/.test(text);
+                        return hasNumber 
+                            ? { valid: true }
+                            : { valid: false, error: 'Response does not contain numbers' };
+                    },
+                    markdown: () => {
+                        const hasMarkdown = /[#*_`\[\]]/.test(text);
+                        return hasMarkdown 
+                            ? { valid: true }
+                            : { valid: false, error: 'Response does not contain markdown formatting' };
+                    }
+                };
+
+                const validator = formats[format.toLowerCase()];
+                if (!validator) {
+                    return { valid: false, error: `Unknown format: ${format}` };
+                }
+
+                return validator();
+            });
+
+            // Language validation
+            this.addRule('language', (response, lang) => {
+                const text = this.extractText(response);
+                
+                const patterns = {
+                    korean: /[가-힣]/,
+                    english: /[a-zA-Z]/,
+                    japanese: /[ぁ-んァ-ン]/,
+                    chinese: /[\u4e00-\u9fff]/,
+                    numbers: /\d/
+                };
+
+                const pattern = patterns[lang.toLowerCase()];
+                if (!pattern) {
+                    return { valid: false, error: `Unknown language: ${lang}` };
+                }
+
+                if (!pattern.test(text)) {
+                    return {
+                        valid: false,
+                        error: `Response does not contain ${lang} characters`
+                    };
+                }
+
+                return { valid: true };
+            });
+
+            // Sentiment validation
+            this.addRule('sentiment', (response, expectedSentiment) => {
+                const text = this.extractText(response).toLowerCase();
+                
+                const sentimentWords = {
+                    positive: ['good', 'great', 'excellent', 'amazing', 'wonderful', 'fantastic', '좋', '훌륭', '멋진'],
+                    negative: ['bad', 'poor', 'terrible', 'awful', 'horrible', '나쁜', '끔찍', '최악'],
+                    neutral: ['okay', 'fine', 'acceptable', '괜찮', '무난']
+                };
+
+                const words = sentimentWords[expectedSentiment.toLowerCase()] || [];
+                const hasSentiment = words.some(word => text.includes(word));
+
+                if (!hasSentiment) {
+                    return {
+                        valid: false,
+                        error: `Response does not match expected sentiment: ${expectedSentiment}`
+                    };
+                }
+
+                return { valid: true };
+            });
+
+            // Custom regex validation
+            this.addRule('regex', (response, pattern) => {
+                const text = this.extractText(response);
+                const regex = new RegExp(pattern);
+                
+                if (!regex.test(text)) {
+                    return {
+                        valid: false,
+                        error: `Response does not match pattern: ${pattern}`
+                    };
+                }
+                
+                return { valid: true };
+            });
+        }
+
+        /**
+         * Extract text from response object
+         * @private
+         */
+        extractText(response) {
+            if (typeof response === 'string') {
+                return response;
+            }
+            
+            if (response.text) return response.text;
+            if (response.content) return response.content;
+            if (response.message) return response.message;
+            
+            return JSON.stringify(response);
+        }
+
+        /**
+         * Add custom validation rule
+         */
+        addRule(name, validator) {
+            this.rules.set(name, validator);
+        }
+
+        /**
+         * Remove validation rule
+         */
+        removeRule(name) {
+            this.rules.delete(name);
+        }
+
+        /**
+         * Validate response against rules
+         */
+        validate(response, validationConfig) {
+            const errors = [];
+            
+            for (const [ruleName, ruleValue] of Object.entries(validationConfig)) {
+                const validator = this.rules.get(ruleName);
+                
+                if (!validator) {
+                    console.warn(`AIKit Validator: Unknown rule '${ruleName}'`);
+                    continue;
+                }
+
+                const result = validator(response, ruleValue);
+                
+                if (!result.valid) {
+                    errors.push(result.error);
+                }
+            }
+
+            return {
+                isValid: errors.length === 0,
+                errors,
+                validatedAt: new Date().toISOString()
+            };
+        }
+
+        /**
+         * Validate with custom function
+         */
+        validateCustom(response, customFn) {
+            try {
+                const result = customFn(response);
+                return {
+                    isValid: result === true || (result && result.valid === true),
+                    errors: result.errors || (result === false ? ['Custom validation failed'] : []),
+                    validatedAt: new Date().toISOString()
+                };
+            } catch (error) {
+                return {
+                    isValid: false,
+                    errors: [`Custom validation error: ${error.message}`],
+                    validatedAt: new Date().toISOString()
+                };
+            }
+        }
+
+        /**
+         * Get available validation rules
+         */
+        getAvailableRules() {
+            return Array.from(this.rules.keys());
+        }
+    }
+
+    /**
+     * BaseAdapter - Base class for all AI provider adapters
+     * Defines the interface that all adapters must implement
+     * @class
+     */
+    class BaseAdapter {
+        constructor() {
+            if (new.target === BaseAdapter) {
+                throw new Error('BaseAdapter is an abstract class and cannot be instantiated directly');
+            }
+        }
+
+        /**
+         * Send chat request to AI provider
+         * Must be implemented by subclasses
+         * @abstract
+         * @param {Object} request - Request object
+         * @param {string} request.message - User message
+         * @param {string} request.apiKey - API key
+         * @param {Object} request.options - Additional options
+         * @returns {Promise<Object>} Normalized response
+         */
+        async chat(request) {
+            throw new Error('chat() must be implemented by subclass');
+        }
+
+        /**
+         * Normalize response to standard format
+         * @protected
+         * @param {Object} rawResponse - Raw API response
+         * @returns {Object} Normalized response
+         */
+        normalizeResponse(rawResponse) {
+            return {
+                text: this.extractText(rawResponse),
+                raw: rawResponse,
+                usage: this.extractUsage(rawResponse),
+                model: this.extractModel(rawResponse),
+                finishReason: this.extractFinishReason(rawResponse)
+            };
+        }
+
+        /**
+         * Extract text from raw response
+         * @abstract
+         * @protected
+         */
+        extractText(rawResponse) {
+            throw new Error('extractText() must be implemented by subclass');
+        }
+
+        /**
+         * Extract usage information from raw response
+         * @abstract
+         * @protected
+         */
+        extractUsage(rawResponse) {
+            throw new Error('extractUsage() must be implemented by subclass');
+        }
+
+        /**
+         * Extract model name from raw response
+         * @abstract
+         * @protected
+         */
+        extractModel(rawResponse) {
+            throw new Error('extractModel() must be implemented by subclass');
+        }
+
+        /**
+         * Extract finish reason from raw response
+         * @abstract
+         * @protected
+         */
+        extractFinishReason(rawResponse) {
+            throw new Error('extractFinishReason() must be implemented by subclass');
+        }
+
+        /**
+         * Build request headers
+         * @protected
+         * @param {string} apiKey - API key
+         * @returns {Object} Headers object
+         */
+        buildHeaders(apiKey) {
+            return {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${apiKey}`
+            };
+        }
+
+        /**
+         * Make HTTP request
+         * @protected
+         * @param {string} url - API endpoint URL
+         * @param {Object} options - Fetch options
+         * @returns {Promise<Object>} Response data
+         */
+        async makeRequest(url, options) {
+            try {
+                const response = await fetch(url, options);
+
+                if (!response.ok) {
+                    const errorData = await response.json().catch(() => ({}));
+                    throw new Error(
+                        `HTTP ${response.status}: ${errorData.error?.message || response.statusText}`
+                    );
+                }
+
+                return await response.json();
+            } catch (error) {
+                if (error.name === 'TypeError' && error.message.includes('fetch')) {
+                    throw new Error('Network error: Unable to reach API endpoint');
+                }
+                throw error;
+            }
+        }
+
+        /**
+         * Validate request parameters
+         * @protected
+         * @param {Object} request - Request object
+         */
+        validateRequest(request) {
+            if (!request.message || typeof request.message !== 'string') {
+                throw new Error('Message is required and must be a string');
+            }
+
+            if (!request.apiKey || typeof request.apiKey !== 'string') {
+                throw new Error('API key is required and must be a string');
+            }
+
+            if (request.message.trim().length === 0) {
+                throw new Error('Message cannot be empty');
+            }
+        }
+
+        /**
+         * Handle rate limiting with exponential backoff
+         * @protected
+         * @param {Function} fn - Function to retry
+         * @param {number} maxRetries - Maximum retry attempts
+         * @returns {Promise<any>} Function result
+         */
+        async withRetry(fn, maxRetries = 3) {
+            for (let i = 0; i < maxRetries; i++) {
+                try {
+                    return await fn();
+                } catch (error) {
+                    if (i === maxRetries - 1) throw error;
+                    
+                    // Check if it's a rate limit error
+                    const isRateLimit = error.message.includes('429') || 
+                                       error.message.includes('rate limit');
+                    
+                    if (!isRateLimit) throw error;
+
+                    // Exponential backoff
+                    const delay = Math.pow(2, i) * 1000;
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                }
+            }
+        }
+
+        /**
+         * Get provider name
+         * @returns {string} Provider name
+         */
+        getProviderName() {
+            return this.constructor.name.replace('Adapter', '').toLowerCase();
+        }
+    }
+
+    /**
+     * OpenAIAdapter - Adapter for OpenAI API
+     * @class
+     * @extends BaseAdapter
+     */
+
+    class OpenAIAdapter extends BaseAdapter {
+        constructor() {
+            super();
+            this.baseURL = 'https://api.openai.com/v1';
+            this.defaultModel = 'gpt-3.5-turbo';
+        }
+
+        /**
+         * Send chat request to OpenAI
+         * @override
+         */
+        async chat(request) {
+            this.validateRequest(request);
+
+            const { message, apiKey, options = {} } = request;
+
+            const requestBody = {
+                model: options.model || this.defaultModel,
+                messages: this.buildMessages(message, options),
+                temperature: options.temperature ?? 0.7,
+                max_tokens: options.maxTokens || options.max_tokens,
+                top_p: options.topP || options.top_p,
+                frequency_penalty: options.frequencyPenalty || options.frequency_penalty,
+                presence_penalty: options.presencePenalty || options.presence_penalty,
+                stream: false
+            };
+
+            // Remove undefined values
+            Object.keys(requestBody).forEach(key => {
+                if (requestBody[key] === undefined) {
+                    delete requestBody[key];
+                }
+            });
+
+            const fetchOptions = {
+                method: 'POST',
+                headers: this.buildHeaders(apiKey),
+                body: JSON.stringify(requestBody)
+            };
+
+            const rawResponse = await this.withRetry(() => 
+                this.makeRequest(`${this.baseURL}/chat/completions`, fetchOptions)
+            );
+
+            return this.normalizeResponse(rawResponse);
+        }
+
+        /**
+         * Build messages array from user message
+         * @private
+         */
+        buildMessages(message, options) {
+            const messages = [];
+
+            // Add system message if provided
+            if (options.systemMessage) {
+                messages.push({
+                    role: 'system',
+                    content: options.systemMessage
+                });
+            }
+
+            // Add conversation history if provided
+            if (options.history && Array.isArray(options.history)) {
+                messages.push(...options.history);
+            }
+
+            // Add current user message
+            messages.push({
+                role: 'user',
+                content: message
+            });
+
+            return messages;
+        }
+
+        /**
+         * Extract text from OpenAI response
+         * @override
+         */
+        extractText(rawResponse) {
+            if (!rawResponse.choices || rawResponse.choices.length === 0) {
+                throw new Error('Invalid OpenAI response: no choices returned');
+            }
+
+            const firstChoice = rawResponse.choices[0];
+            return firstChoice.message?.content || '';
+        }
+
+        /**
+         * Extract usage information
+         * @override
+         */
+        extractUsage(rawResponse) {
+            const usage = rawResponse.usage || {};
+            
+            return {
+                promptTokens: usage.prompt_tokens || 0,
+                completionTokens: usage.completion_tokens || 0,
+                totalTokens: usage.total_tokens || 0,
+                // Normalized names for compatibility
+                input: usage.prompt_tokens || 0,
+                output: usage.completion_tokens || 0,
+                total: usage.total_tokens || 0
+            };
+        }
+
+        /**
+         * Extract model name
+         * @override
+         */
+        extractModel(rawResponse) {
+            return rawResponse.model || this.defaultModel;
+        }
+
+        /**
+         * Extract finish reason
+         * @override
+         */
+        extractFinishReason(rawResponse) {
+            if (!rawResponse.choices || rawResponse.choices.length === 0) {
+                return 'unknown';
+            }
+
+            return rawResponse.choices[0].finish_reason || 'unknown';
+        }
+
+        /**
+         * Stream chat (for future implementation)
+         * @param {Object} request - Request object
+         * @param {Function} onChunk - Callback for each chunk
+         */
+        async streamChat(request, onChunk) {
+            // TODO: Implement streaming support
+            throw new Error('Streaming is not yet implemented for OpenAI adapter');
+        }
+
+        /**
+         * List available models
+         * @param {string} apiKey - API key
+         */
+        async listModels(apiKey) {
+            const fetchOptions = {
+                method: 'GET',
+                headers: this.buildHeaders(apiKey)
+            };
+
+            const response = await this.makeRequest(`${this.baseURL}/models`, fetchOptions);
+            
+            // Filter to chat models only
+            const chatModels = response.data.filter(model => 
+                model.id.includes('gpt') || model.id.includes('turbo')
+            );
+
+            return chatModels.map(model => ({
+                id: model.id,
+                created: model.created,
+                ownedBy: model.owned_by
+            }));
+        }
+
+        /**
+         * Generate embeddings
+         * @param {string} text - Text to embed
+         * @param {string} apiKey - API key
+         * @param {Object} options - Options
+         */
+        async createEmbedding(text, apiKey, options = {}) {
+            const requestBody = {
+                model: options.model || 'text-embedding-ada-002',
+                input: text
+            };
+
+            const fetchOptions = {
+                method: 'POST',
+                headers: this.buildHeaders(apiKey),
+                body: JSON.stringify(requestBody)
+            };
+
+            const response = await this.makeRequest(`${this.baseURL}/embeddings`, fetchOptions);
+            
+            return {
+                embedding: response.data[0].embedding,
+                model: response.model,
+                usage: response.usage
+            };
+        }
+    }
+
+    /**
+     * ClaudeAdapter - Adapter for Anthropic Claude API
+     * @class
+     * @extends BaseAdapter
+     */
+
+    class ClaudeAdapter extends BaseAdapter {
+        constructor() {
+            super();
+            this.baseURL = 'https://api.anthropic.com/v1';
+            this.defaultModel = 'claude-3-sonnet-20240229';
+            this.apiVersion = '2023-06-01';
+        }
+
+        /**
+         * Send chat request to Claude
+         * @override
+         */
+        async chat(request) {
+            this.validateRequest(request);
+
+            const { message, apiKey, options = {} } = request;
+
+            const requestBody = {
+                model: options.model || this.defaultModel,
+                messages: this.buildMessages(message, options),
+                max_tokens: options.maxTokens || options.max_tokens || 1024,
+                temperature: options.temperature ?? 1.0,
+                top_p: options.topP || options.top_p,
+                top_k: options.topK || options.top_k,
+                stream: false
+            };
+
+            // Add system message if provided
+            if (options.systemMessage) {
+                requestBody.system = options.systemMessage;
+            }
+
+            // Remove undefined values
+            Object.keys(requestBody).forEach(key => {
+                if (requestBody[key] === undefined) {
+                    delete requestBody[key];
+                }
+            });
+
+            const fetchOptions = {
+                method: 'POST',
+                headers: this.buildHeaders(apiKey),
+                body: JSON.stringify(requestBody)
+            };
+
+            const rawResponse = await this.withRetry(() => 
+                this.makeRequest(`${this.baseURL}/messages`, fetchOptions)
+            );
+
+            return this.normalizeResponse(rawResponse);
+        }
+
+        /**
+         * Build headers for Claude API
+         * @override
+         */
+        buildHeaders(apiKey) {
+            return {
+                'Content-Type': 'application/json',
+                'x-api-key': apiKey,
+                'anthropic-version': this.apiVersion
+            };
+        }
+
+        /**
+         * Build messages array from user message
+         * @private
+         */
+        buildMessages(message, options) {
+            const messages = [];
+
+            // Add conversation history if provided
+            if (options.history && Array.isArray(options.history)) {
+                // Claude uses 'user' and 'assistant' roles
+                messages.push(...options.history.map(msg => ({
+                    role: msg.role === 'system' ? 'user' : msg.role,
+                    content: msg.content
+                })));
+            }
+
+            // Add current user message
+            messages.push({
+                role: 'user',
+                content: message
+            });
+
+            return messages;
+        }
+
+        /**
+         * Extract text from Claude response
+         * @override
+         */
+        extractText(rawResponse) {
+            if (!rawResponse.content || rawResponse.content.length === 0) {
+                throw new Error('Invalid Claude response: no content returned');
+            }
+
+            // Claude can return multiple content blocks
+            const textBlocks = rawResponse.content
+                .filter(block => block.type === 'text')
+                .map(block => block.text);
+
+            return textBlocks.join('\n');
+        }
+
+        /**
+         * Extract usage information
+         * @override
+         */
+        extractUsage(rawResponse) {
+            const usage = rawResponse.usage || {};
+            
+            return {
+                promptTokens: usage.input_tokens || 0,
+                completionTokens: usage.output_tokens || 0,
+                totalTokens: (usage.input_tokens || 0) + (usage.output_tokens || 0),
+                // Normalized names for compatibility
+                input: usage.input_tokens || 0,
+                output: usage.output_tokens || 0,
+                total: (usage.input_tokens || 0) + (usage.output_tokens || 0)
+            };
+        }
+
+        /**
+         * Extract model name
+         * @override
+         */
+        extractModel(rawResponse) {
+            return rawResponse.model || this.defaultModel;
+        }
+
+        /**
+         * Extract finish reason
+         * @override
+         */
+        extractFinishReason(rawResponse) {
+            return rawResponse.stop_reason || 'unknown';
+        }
+
+        /**
+         * Stream chat (for future implementation)
+         * @param {Object} request - Request object
+         * @param {Function} onChunk - Callback for each chunk
+         */
+        async streamChat(request, onChunk) {
+            // TODO: Implement streaming support
+            throw new Error('Streaming is not yet implemented for Claude adapter');
+        }
+
+        /**
+         * Get model information
+         */
+        getAvailableModels() {
+            return [
+                {
+                    id: 'claude-3-opus-20240229',
+                    name: 'Claude 3 Opus',
+                    description: 'Most powerful model, best for complex tasks',
+                    maxTokens: 4096
+                },
+                {
+                    id: 'claude-3-sonnet-20240229',
+                    name: 'Claude 3 Sonnet',
+                    description: 'Balanced performance and speed',
+                    maxTokens: 4096
+                },
+                {
+                    id: 'claude-3-haiku-20240307',
+                    name: 'Claude 3 Haiku',
+                    description: 'Fastest model, best for simple tasks',
+                    maxTokens: 4096
+                },
+                {
+                    id: 'claude-2.1',
+                    name: 'Claude 2.1',
+                    description: 'Previous generation model',
+                    maxTokens: 4096
+                }
+            ];
+        }
+
+        /**
+         * Count tokens (approximate)
+         * Claude's tokenization is similar to GPT but not identical
+         * This is a rough estimate
+         */
+        estimateTokens(text) {
+            // Rough estimate: ~4 characters per token for English
+            // ~2 characters per token for code
+            const avgCharsPerToken = text.match(/[a-zA-Z0-9_]/g) ? 4 : 3;
+            return Math.ceil(text.length / avgCharsPerToken);
+        }
+    }
+
+    /**
+     * GeminiAdapter - Adapter for Google Gemini API
+     * @class
+     * @extends BaseAdapter
+     */
+
+    class GeminiAdapter extends BaseAdapter {
+        constructor() {
+            super();
+            this.baseURL = 'https://generativelanguage.googleapis.com/v1beta';
+            this.defaultModel = 'gemini-pro';
+        }
+
+        /**
+         * Send chat request to Gemini
+         * @override
+         */
+        async chat(request) {
+            this.validateRequest(request);
+
+            const { message, apiKey, options = {} } = request;
+            const model = options.model || this.defaultModel;
+
+            const requestBody = {
+                contents: this.buildContents(message, options),
+                generationConfig: {
+                    temperature: options.temperature ?? 0.9,
+                    topK: options.topK || options.top_k,
+                    topP: (options.topP || options.top_p) ?? 1,
+                    maxOutputTokens: options.maxTokens || options.max_tokens || options.maxOutputTokens,
+                    stopSequences: options.stopSequences || options.stop
+                }
+            };
+
+            // Add safety settings if provided
+            if (options.safetySettings) {
+                requestBody.safetySettings = options.safetySettings;
+            }
+
+            // Remove undefined values
+            if (requestBody.generationConfig) {
+                Object.keys(requestBody.generationConfig).forEach(key => {
+                    if (requestBody.generationConfig[key] === undefined) {
+                        delete requestBody.generationConfig[key];
+                    }
+                });
+            }
+
+            const url = `${this.baseURL}/models/${model}:generateContent?key=${apiKey}`;
+
+            const fetchOptions = {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(requestBody)
+            };
+
+            const rawResponse = await this.withRetry(() => 
+                this.makeRequest(url, fetchOptions)
+            );
+
+            return this.normalizeResponse(rawResponse);
+        }
+
+        /**
+         * Build contents array from user message
+         * @private
+         */
+        buildContents(message, options) {
+            const contents = [];
+
+            // Add conversation history if provided
+            if (options.history && Array.isArray(options.history)) {
+                options.history.forEach(msg => {
+                    contents.push({
+                        role: msg.role === 'assistant' ? 'model' : 'user',
+                        parts: [{ text: msg.content }]
+                    });
+                });
+            }
+
+            // Add current user message
+            contents.push({
+                role: 'user',
+                parts: [{ text: message }]
+            });
+
+            return contents;
+        }
+
+        /**
+         * Extract text from Gemini response
+         * @override
+         */
+        extractText(rawResponse) {
+            if (!rawResponse.candidates || rawResponse.candidates.length === 0) {
+                throw new Error('Invalid Gemini response: no candidates returned');
+            }
+
+            const candidate = rawResponse.candidates[0];
+            
+            if (!candidate.content || !candidate.content.parts) {
+                throw new Error('Invalid Gemini response: no content parts');
+            }
+
+            // Combine all text parts
+            const textParts = candidate.content.parts
+                .filter(part => part.text)
+                .map(part => part.text);
+
+            return textParts.join('\n');
+        }
+
+        /**
+         * Extract usage information
+         * @override
+         */
+        extractUsage(rawResponse) {
+            const metadata = rawResponse.usageMetadata || {};
+            
+            return {
+                promptTokens: metadata.promptTokenCount || 0,
+                completionTokens: metadata.candidatesTokenCount || 0,
+                totalTokens: metadata.totalTokenCount || 0,
+                // Normalized names for compatibility
+                input: metadata.promptTokenCount || 0,
+                output: metadata.candidatesTokenCount || 0,
+                total: metadata.totalTokenCount || 0
+            };
+        }
+
+        /**
+         * Extract model name
+         * @override
+         */
+        extractModel(rawResponse) {
+            return rawResponse.modelVersion || this.defaultModel;
+        }
+
+        /**
+         * Extract finish reason
+         * @override
+         */
+        extractFinishReason(rawResponse) {
+            if (!rawResponse.candidates || rawResponse.candidates.length === 0) {
+                return 'unknown';
+            }
+
+            return rawResponse.candidates[0].finishReason || 'STOP';
+        }
+
+        /**
+         * Stream chat (for future implementation)
+         * @param {Object} request - Request object
+         * @param {Function} onChunk - Callback for each chunk
+         */
+        async streamChat(request, onChunk) {
+            // TODO: Implement streaming support
+            throw new Error('Streaming is not yet implemented for Gemini adapter');
+        }
+
+        /**
+         * Get available models
+         */
+        getAvailableModels() {
+            return [
+                {
+                    id: 'gemini-pro',
+                    name: 'Gemini Pro',
+                    description: 'Best for text generation',
+                    maxTokens: 8192
+                },
+                {
+                    id: 'gemini-pro-vision',
+                    name: 'Gemini Pro Vision',
+                    description: 'Multimodal model for text and images',
+                    maxTokens: 4096
+                },
+                {
+                    id: 'gemini-ultra',
+                    name: 'Gemini Ultra',
+                    description: 'Most capable model (limited access)',
+                    maxTokens: 8192
+                }
+            ];
+        }
+
+        /**
+         * List models via API
+         * @param {string} apiKey - API key
+         */
+        async listModels(apiKey) {
+            const url = `${this.baseURL}/models?key=${apiKey}`;
+
+            const fetchOptions = {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            };
+
+            const response = await this.makeRequest(url, fetchOptions);
+            
+            return response.models
+                .filter(model => model.supportedGenerationMethods?.includes('generateContent'))
+                .map(model => ({
+                    id: model.name.replace('models/', ''),
+                    displayName: model.displayName,
+                    description: model.description,
+                    inputTokenLimit: model.inputTokenLimit,
+                    outputTokenLimit: model.outputTokenLimit
+                }));
+        }
+
+        /**
+         * Count tokens
+         * @param {string} text - Text to count tokens for
+         * @param {string} apiKey - API key
+         * @param {string} model - Model name
+         */
+        async countTokens(text, apiKey, model = this.defaultModel) {
+            const url = `${this.baseURL}/models/${model}:countTokens?key=${apiKey}`;
+
+            const requestBody = {
+                contents: [{
+                    role: 'user',
+                    parts: [{ text }]
+                }]
+            };
+
+            const fetchOptions = {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(requestBody)
+            };
+
+            const response = await this.makeRequest(url, fetchOptions);
+            
+            return {
+                totalTokens: response.totalTokens || 0
+            };
+        }
+
+        /**
+         * Generate embeddings
+         * @param {string} text - Text to embed
+         * @param {string} apiKey - API key
+         */
+        async createEmbedding(text, apiKey) {
+            const model = 'embedding-001';
+            const url = `${this.baseURL}/models/${model}:embedContent?key=${apiKey}`;
+
+            const requestBody = {
+                content: {
+                    parts: [{ text }]
+                }
+            };
+
+            const fetchOptions = {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(requestBody)
+            };
+
+            const response = await this.makeRequest(url, fetchOptions);
+            
+            return {
+                embedding: response.embedding.values,
+                model: model
+            };
+        }
+    }
+
+    /**
+     * AIKit - Universal AI API Client
+     * @class
+     */
+
+    class AIKit {
+        /**
+         * @param {Object} config - Configuration object
+         * @param {string} config.provider - AI provider name ('openai', 'claude', 'gemini')
+         * @param {string} config.apiKey - API key for the provider
+         * @param {Object} [config.options] - Additional options
+         */
+        constructor(config) {
+            this.validateConfig(config);
+            
+            this.config = {
+                provider: config.provider,
+                apiKey: config.apiKey,
+                options: config.options || {},
+                autoFallback: config.autoFallback || false,
+                enableCache: config.enableCache !== false,
+                enableCostTracking: config.enableCostTracking !== false,
+                maxRetries: config.maxRetries || 3,
+                timeout: config.timeout || 30000
+            };
+
+            // 멀티 프로바이더 설정
+            this.providers = config.providers || [
+                { name: config.provider, apiKey: config.apiKey, priority: 1 }
+            ];
+
+            this.currentProviderIndex = 0;
+            
+            // 모듈 초기화
+            this.adapter = this.loadAdapter(this.config.provider);
+            this.cache = this.config.enableCache ? new CacheManager() : null;
+            this.costTracker = this.config.enableCostTracking ? new CostTracker() : null;
+            this.validator = new ResponseValidator();
+            
+            // 통계
+            this.stats = {
+                totalRequests: 0,
+                successfulRequests: 0,
+                failedRequests: 0,
+                cachedResponses: 0
+            };
+        }
+
+        /**
+         * 설정 유효성 검사
+         * @private
+         */
+        validateConfig(config) {
+            if (!config) {
+                throw new Error('AIKit: Configuration is required');
+            }
+
+            if (config.providers) {
+                // 멀티 프로바이더 모드
+                if (!Array.isArray(config.providers) || config.providers.length === 0) {
+                    throw new Error('AIKit: providers must be a non-empty array');
+                }
+                
+                config.providers.forEach((p, i) => {
+                    if (!p.name || !p.apiKey) {
+                        throw new Error(`AIKit: Provider at index ${i} must have 'name' and 'apiKey'`);
+                    }
+                });
+            } else {
+                // 싱글 프로바이더 모드
+                if (!config.provider) {
+                    throw new Error('AIKit: provider is required');
+                }
+
+                if (!config.apiKey) {
+                    throw new Error('AIKit: apiKey is required');
+                }
+            }
+        }
+
+        /**
+         * 프로바이더 어댑터 로드
+         * @private
+         */
+        loadAdapter(provider) {
+            const adapterMap = {
+                'openai': OpenAIAdapter,
+                'claude': ClaudeAdapter,
+                'gemini': GeminiAdapter
+            };
+
+            const AdapterClass = adapterMap[provider.toLowerCase()];
+            if (!AdapterClass) {
+                throw new Error(`Unknown provider: ${provider}`);
+            }
+            
+            return new AdapterClass();
+        }
+
+        /**
+         * AI 채팅 요청
+         * @param {string} message - User message
+         * @param {Object} [options] - Request options
+         * @returns {Promise<Object>} Response object
+         */
+        async chat(message, options = {}) {
+            this.stats.totalRequests++;
+
+            // 캐시 체크
+            if (this.cache && !options.skipCache) {
+                const cacheKey = this.cache.generateKey(message, options);
+                const cached = this.cache.get(cacheKey);
+                
+                if (cached) {
+                    this.stats.cachedResponses++;
+                    return {
+                        ...cached,
+                        fromCache: true,
+                        timestamp: new Date().toISOString()
+                    };
+                }
+            }
+
+            // 검증 옵션 추출
+            const validation = options.validate || {};
+            delete options.validate;
+
+            // 재시도 로직
+            let lastError;
+            for (let attempt = 0; attempt < this.config.maxRetries; attempt++) {
+                try {
+                    const response = await this.makeRequest(message, options);
+                    
+                    // 응답 검증
+                    if (Object.keys(validation).length > 0) {
+                        const validationResult = this.validator.validate(response, validation);
+                        if (!validationResult.isValid) {
+                            throw new Error(`Validation failed: ${validationResult.errors.join(', ')}`);
+                        }
+                    }
+
+                    // 캐시 저장
+                    if (this.cache && !options.skipCache) {
+                        const cacheKey = this.cache.generateKey(message, options);
+                        this.cache.set(cacheKey, response);
+                    }
+
+                    // 비용 추적
+                    if (this.costTracker) {
+                        this.costTracker.track({
+                            provider: this.config.provider,
+                            tokens: response.usage || {},
+                            timestamp: new Date().toISOString()
+                        });
+                    }
+
+                    this.stats.successfulRequests++;
+                    
+                    return {
+                        ...response,
+                        fromCache: false,
+                        timestamp: new Date().toISOString()
+                    };
+
+                } catch (error) {
+                    lastError = error;
+                    console.warn(`AIKit: Attempt ${attempt + 1} failed:`, error.message);
+                    
+                    // Auto fallback to next provider
+                    if (this.config.autoFallback && this.providers.length > 1) {
+                        const switched = await this.switchToNextProvider();
+                        if (!switched) break;
+                    } else {
+                        // Wait before retry
+                        if (attempt < this.config.maxRetries - 1) {
+                            await this.sleep(Math.pow(2, attempt) * 1000);
+                        }
+                    }
+                }
+            }
+
+            this.stats.failedRequests++;
+            throw new Error(`AIKit: All attempts failed. Last error: ${lastError.message}`);
+        }
+
+        /**
+         * API 요청 실행
+         * @private
+         */
+        async makeRequest(message, options) {
+            const provider = this.providers[this.currentProviderIndex];
+            
+            const requestData = {
+                message,
+                apiKey: provider.apiKey,
+                options: {
+                    ...this.config.options,
+                    ...options
+                }
+            };
+
+            return await this.adapter.chat(requestData);
+        }
+
+        /**
+         * 다음 프로바이더로 전환
+         * @private
+         */
+        async switchToNextProvider() {
+            this.currentProviderIndex++;
+            
+            if (this.currentProviderIndex >= this.providers.length) {
+                this.currentProviderIndex = 0;
+                return false; // 모든 프로바이더 시도 완료
+            }
+
+            const nextProvider = this.providers[this.currentProviderIndex];
+            console.log(`AIKit: Switching to provider '${nextProvider.name}'`);
+            
+            this.adapter = this.loadAdapter(nextProvider.name);
+            this.config.provider = nextProvider.name;
+            
+            return true;
+        }
+
+        /**
+         * Sleep utility
+         * @private
+         */
+        sleep(ms) {
+            return new Promise(resolve => setTimeout(resolve, ms));
+        }
+
+        /**
+         * 비용 리포트 가져오기
+         */
+        getCostReport() {
+            if (!this.costTracker) {
+                return { error: 'Cost tracking is disabled' };
+            }
+            return this.costTracker.getReport();
+        }
+
+        /**
+         * 통계 가져오기
+         */
+        getStats() {
+            return { ...this.stats };
+        }
+
+        /**
+         * 캐시 초기화
+         */
+        clearCache() {
+            if (this.cache) {
+                this.cache.clear();
+                return true;
+            }
+            return false;
+        }
+
+        /**
+         * 설정 업데이트
+         */
+        updateConfig(newConfig) {
+            Object.assign(this.config, newConfig);
+            
+            if (newConfig.provider && newConfig.provider !== this.config.provider) {
+                this.adapter = this.loadAdapter(newConfig.provider);
+            }
+        }
+    }
+
+    // Import all modules
+
+    // Attach utilities to AIKit for easy access
+    AIKit.CacheManager = CacheManager;
+    AIKit.CostTracker = CostTracker;
+    AIKit.ResponseValidator = ResponseValidator;
+    AIKit.BaseAdapter = BaseAdapter;
+    AIKit.OpenAIAdapter = OpenAIAdapter;
+    AIKit.ClaudeAdapter = ClaudeAdapter;
+    AIKit.GeminiAdapter = GeminiAdapter;
+
+    // Attach to global for browser usage
+    if (typeof window !== 'undefined') {
+        window.AIKit = AIKit;
+    }
+
+    return AIKit;
+
+}));
+//# sourceMappingURL=aikit.umd.js.map