@lukaplayground/aikit 1.0.1 → 1.1.0

package/dist/aikit.js

@@ -886,187 +886,58 @@ class OpenAIAdapter extends BaseAdapter {
     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
         };
     }
 }
@@ -1081,192 +952,74 @@ class ClaudeAdapter extends BaseAdapter {
     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);
     }
@@ -1282,269 +1035,54 @@ class GeminiAdapter extends BaseAdapter {
     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
         };
     }