@lukaplayground/aikit 1.0.0

package/dist/aikit.js

@@ -0,0 +1,1967 @@
+/*!
+ * AIKit v0.1.0
+ * Universal AI API Client Framework
+ * (c) 2025 Luka (lukaPlayground)
+ * Released under the MIT License
+ */
+(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';
+
+	function getDefaultExportFromCjs (x) {
+		return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+	}
+
+	var src = {exports: {}};
+
+	var CacheManager$1 = {exports: {}};
+
+	/**
+	 * CacheManager - LocalStorage based caching system
+	 * @class
+	 */
+
+	(function (module) {
+		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();
+		    }
+		}
+
+		// Export
+		if (module.exports) {
+		    module.exports = CacheManager;
+		} 
+	} (CacheManager$1));
+
+	var CacheManagerExports = CacheManager$1.exports;
+
+	var CostTracker$1 = {exports: {}};
+
+	/**
+	 * CostTracker - Track API usage costs
+	 * @class
+	 */
+
+	(function (module) {
+		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;
+		        }
+		    }
+		}
+
+		// Export
+		if (module.exports) {
+		    module.exports = CostTracker;
+		} 
+	} (CostTracker$1));
+
+	var CostTrackerExports = CostTracker$1.exports;
+
+	var ResponseValidator$1 = {exports: {}};
+
+	/**
+	 * ResponseValidator - Validate AI responses based on rules
+	 * QA-focused validation layer
+	 * @class
+	 */
+
+	(function (module) {
+		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());
+		    }
+		}
+
+		// Export
+		if (module.exports) {
+		    module.exports = ResponseValidator;
+		} 
+	} (ResponseValidator$1));
+
+	var ResponseValidatorExports = ResponseValidator$1.exports;
+
+	var BaseAdapter$1 = {exports: {}};
+
+	/**
+	 * BaseAdapter - Base class for all AI provider adapters
+	 * Defines the interface that all adapters must implement
+	 * @class
+	 */
+
+	(function (module) {
+		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();
+		    }
+		}
+
+		// Export
+		if (module.exports) {
+		    module.exports = BaseAdapter;
+		} 
+	} (BaseAdapter$1));
+
+	var BaseAdapterExports = BaseAdapter$1.exports;
+
+	var OpenAIAdapter$1 = {exports: {}};
+
+	/**
+	 * OpenAIAdapter - Adapter for OpenAI API
+	 * @class
+	 * @extends BaseAdapter
+	 */
+
+	(function (module) {
+		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
+		        };
+		    }
+		}
+
+		// Export
+		if (module.exports) {
+		    module.exports = OpenAIAdapter;
+		} 
+	} (OpenAIAdapter$1));
+
+	var OpenAIAdapterExports = OpenAIAdapter$1.exports;
+
+	var ClaudeAdapter$1 = {exports: {}};
+
+	/**
+	 * ClaudeAdapter - Adapter for Anthropic Claude API
+	 * @class
+	 * @extends BaseAdapter
+	 */
+
+	(function (module) {
+		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);
+		    }
+		}
+
+		// Export
+		if (module.exports) {
+		    module.exports = ClaudeAdapter;
+		} 
+	} (ClaudeAdapter$1));
+
+	var ClaudeAdapterExports = ClaudeAdapter$1.exports;
+
+	var GeminiAdapter$1 = {exports: {}};
+
+	/**
+	 * GeminiAdapter - Adapter for Google Gemini API
+	 * @class
+	 * @extends BaseAdapter
+	 */
+
+	(function (module) {
+		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
+		        };
+		    }
+		}
+
+		// Export
+		if (module.exports) {
+		    module.exports = GeminiAdapter;
+		} 
+	} (GeminiAdapter$1));
+
+	var GeminiAdapterExports = GeminiAdapter$1.exports;
+
+	var AIKit = {exports: {}};
+
+	/**
+	 * AIKit - Universal AI API Client
+	 * @class
+	 */
+
+	(function (module) {
+		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(`AIKit: Unsupported provider '${provider}'. Supported: ${Object.keys(adapterMap).join(', ')}`);
+		        }
+
+		        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);
+		        }
+		    }
+		}
+
+		// Export for different module systems
+		if (module.exports) {
+		    module.exports = AIKit;
+		} 
+	} (AIKit));
+
+	var AIKitExports = AIKit.exports;
+
+	(function (module) {
+		// Import all modules
+		const modules = {
+		    CacheManager: CacheManagerExports,
+		    CostTracker: CostTrackerExports,
+		    ResponseValidator: ResponseValidatorExports,
+		    BaseAdapter: BaseAdapterExports,
+		    OpenAIAdapter: OpenAIAdapterExports,
+		    ClaudeAdapter: ClaudeAdapterExports,
+		    GeminiAdapter: GeminiAdapterExports,
+		    AIKit: AIKitExports
+		};
+
+		// Attach to global for browser usage
+		if (typeof window !== 'undefined') {
+		    Object.assign(window, modules);
+		}
+
+		// Export for module systems
+		module.exports = modules.AIKit;
+		module.exports.default = modules.AIKit;
+		Object.assign(module.exports, modules); 
+	} (src));
+
+	var srcExports = src.exports;
+	var index = /*@__PURE__*/getDefaultExportFromCjs(srcExports);
+
+	return index;
+
+}));
+//# sourceMappingURL=aikit.js.map