@lukaplayground/aikit 1.0.1 → 1.1.0

package/dist/aikit.umd.js

@@ -892,187 +892,58 @@
         constructor() {
             super();
             this.baseURL = 'https://api.openai.com/v1';
-            this.defaultModel = 'gpt-3.5-turbo';
+            this.defaultModel = 'gpt-4o-mini';  // ← 변경: gpt-3.5-turbo에서
+            
+            // 사용 가능한 모델 목록
+            this.availableModels = [
+                'gpt-4o',
+                'gpt-4o-mini',
+                'gpt-4-turbo',
+                '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
-                });
-            }
+        async chat(message, options = {}) {
+            const model = options.model || this.defaultModel;
+            const apiKey = options.apiKey || this.apiKey;
 
-            // Add conversation history if provided
-            if (options.history && Array.isArray(options.history)) {
-                messages.push(...options.history);
+            if (!apiKey) {
+                throw new Error('OpenAI API key is required');
             }
 
-            // Add current user message
-            messages.push({
-                role: 'user',
-                content: message
+            const response = await fetch(`${this.baseURL}/chat/completions`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${apiKey}`
+                },
+                body: JSON.stringify({
+                    model: model,
+                    messages: [
+                        {
+                            role: 'user',
+                            content: message
+                        }
+                    ],
+                    ...options
+                })
             });
 
-            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');
+            if (!response.ok) {
+                const error = await response.text();
+                throw new Error(`HTTP ${response.status}: ${error}`);
             }
 
-            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
-            }));
-        }
+            const data = await response.json();
 
-        /**
-         * 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
+                content: data.choices[0].message.content,
+                model: data.model,
+                usage: data.usage
             };
         }
     }
@@ -1087,192 +958,74 @@
         constructor() {
             super();
             this.baseURL = 'https://api.anthropic.com/v1';
-            this.defaultModel = 'claude-3-sonnet-20240229';
+            this.defaultModel = 'claude-3-5-sonnet-20241022';  // ← 변경
             this.apiVersion = '2023-06-01';
+            
+            // 사용 가능한 모델 목록
+            this.availableModels = [
+                'claude-3-5-sonnet-20241022',
+                'claude-3-5-haiku-20241022',
+                'claude-3-opus-20240229',
+                'claude-3-sonnet-20240229',
+                'claude-3-haiku-20240307'
+            ];
         }
 
         /**
          * 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
-            };
+        async chat(message, options = {}) {
+            const model = options.model || this.defaultModel;
+            const apiKey = options.apiKey || this.apiKey;
+            const maxTokens = options.maxTokens || 1024;
 
-            // Add system message if provided
-            if (options.systemMessage) {
-                requestBody.system = options.systemMessage;
+            if (!apiKey) {
+                throw new Error('Claude API key is required');
             }
 
-            // Remove undefined values
-            Object.keys(requestBody).forEach(key => {
-                if (requestBody[key] === undefined) {
-                    delete requestBody[key];
-                }
-            });
-
-            const fetchOptions = {
+            const response = await fetch(`${this.baseURL}/messages`, {
                 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
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': apiKey,
+                    'anthropic-version': this.apiVersion
+                },
+                body: JSON.stringify({
+                    model: model,
+                    max_tokens: maxTokens,
+                    messages: [
+                        {
+                            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');
+            if (!response.ok) {
+                const error = await response.text();
+                throw new Error(`HTTP ${response.status}: ${error}`);
             }
 
-            // Claude can return multiple content blocks
-            const textBlocks = rawResponse.content
-                .filter(block => block.type === 'text')
-                .map(block => block.text);
-
-            return textBlocks.join('\n');
-        }
+            const data = await response.json();
 
-        /**
-         * 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
+                content: data.content[0].text,
+                model: data.model,
+                usage: {
+                    input_tokens: data.usage.input_tokens,
+                    output_tokens: data.usage.output_tokens
                 }
-            ];
+            };
         }
 
         /**
-         * Count tokens (approximate)
-         * Claude's tokenization is similar to GPT but not identical
-         * This is a rough estimate
+         * Estimate token count (Claude uses characters)
+         * @private
          */
         estimateTokens(text) {
-            // Rough estimate: ~4 characters per token for English
-            // ~2 characters per token for code
+            // Claude roughly: 1 token ≈ 4 characters for English
             const avgCharsPerToken = text.match(/[a-zA-Z0-9_]/g) ? 4 : 3;
             return Math.ceil(text.length / avgCharsPerToken);
         }
@@ -1288,269 +1041,54 @@
         constructor() {
             super();
             this.baseURL = 'https://generativelanguage.googleapis.com/v1beta';
-            this.defaultModel = 'gemini-pro';
+            this.defaultModel = 'gemini-1.5-flash';  // ← 변경
+            
+            // 사용 가능한 모델 목록
+            this.availableModels = [
+                'gemini-1.5-flash',
+                'gemini-1.5-flash-8b',
+                'gemini-1.5-pro',
+                'gemini-2.0-flash-exp'
+            ];
         }
 
         /**
          * Send chat request to Gemini
          * @override
          */
-        async chat(request) {
-            this.validateRequest(request);
-
-            const { message, apiKey, options = {} } = request;
+        async chat(message, options = {}) {
             const model = options.model || this.defaultModel;
+            const apiKey = options.apiKey || this.apiKey;
 
-            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];
-                    }
-                });
+            if (!apiKey) {
+                throw new Error('Gemini API key is required');
             }
 
             const url = `${this.baseURL}/models/${model}:generateContent?key=${apiKey}`;
 
-            const fetchOptions = {
+            const response = await fetch(url, {
                 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 }]
+                body: JSON.stringify({
+                    contents: [{
+                        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');
+            if (!response.ok) {
+                const error = await response.text();
+                throw new Error(`HTTP ${response.status}: ${error}`);
             }
 
-            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);
+            const data = await response.json();
             
             return {
-                embedding: response.embedding.values,
+                content: data.candidates[0].content.parts[0].text,
                 model: model
             };
         }