aiexecode 1.0.90 → 1.0.92

package/src/frontend/components/ModelListView.js

@@ -6,101 +6,44 @@ import React from 'react';
 import { Box, Text } from 'ink';
 import { theme } from '../design/themeColors.js';
 
-export function ModelListView({ openaiModels }) {
+export function ModelListView({ modelsByProvider }) {
     const sections = [
-        // Header
-        React.createElement(Box, {
+        React.createElement(Text, {
             key: 'header',
-            borderStyle: 'double',
-            borderColor: 'gray',
-            paddingX: 2,
-            paddingY: 0,
-            justifyContent: 'center'
-        },
-            React.createElement(Text, {
-                bold: true,
-                color: 'whiteBright'
-            }, 'Available AI Models')
-        ),
-
-        React.createElement(Text, { key: 'spacer1' }, null),
-
-        // OpenAI Section
-        React.createElement(Box, {
-            key: 'openai-section',
-            flexDirection: 'column',
-            borderStyle: 'round',
-            borderColor: 'gray',
-            paddingX: 2,
-            paddingY: 1
-        },
-            React.createElement(Box, { flexDirection: 'column' },
-                React.createElement(Text, {
-                    bold: true,
-                    color: 'cyan'
-                }, '🤖 OpenAI Models'),
-                React.createElement(Text, {
-                    dimColor: true,
-                    italic: true
-                }, 'GPT-5 Series (Latest generation, recommended)'),
-                React.createElement(Text, null)
-            ),
+            bold: true,
+            color: 'whiteBright'
+        }, 'Available AI Models'),
 
-            openaiModels.map((model, index) =>
-                React.createElement(Box, {
-                    key: model.id,
-                    flexDirection: 'column',
-                    marginBottom: index < openaiModels.length - 1 ? 1 : 0
-                },
-                    React.createElement(Box, { flexDirection: 'row', gap: 1 },
-                        React.createElement(Text, { color: 'green', bold: true }, '•'),
-                        React.createElement(Text, {
-                            color: 'white',
-                            bold: true
-                        }, model.id)
-                    ),
-                    React.createElement(Box, {
-                        flexDirection: 'column',
-                        marginLeft: 2,
-                        gap: 0
-                    },
-                        React.createElement(Text, {
-                            color: theme.text.secondary
-                        }, `${model.name} - ${model.description}`),
-                        React.createElement(Text, {
-                            dimColor: true,
-                            italic: true
-                        }, `💰 $${model.pricing.input}/$${model.pricing.output} (input/output per 1M tokens)`)
-                    )
-                )
-            )
-        )
+        React.createElement(Text, { key: 'spacer1' }, null)
     ];
 
-    sections.push(
-        React.createElement(Text, { key: 'spacer4' }, null),
+    // 모든 모델을 하나의 리스트로 통합
+    const allModels = [];
+    Object.keys(modelsByProvider).forEach(provider => {
+        const models = modelsByProvider[provider];
+        models.forEach(model => {
+            allModels.push(model);
+        });
+    });
+
+    // 모델 리스트 추가
+    allModels.forEach((model, index) => {
+        sections.push(
+            React.createElement(Text, {
+                key: model.id,
+                color: 'white'
+            }, `  • ${model.id}`)
+        );
+    });
 
-        // Footer
-        React.createElement(Box, {
-            key: 'footer',
-            flexDirection: 'column',
-            borderStyle: 'single',
-            borderColor: 'gray',
-            paddingX: 2,
-            paddingY: 1
-        },
-            React.createElement(Text, { bold: true }, '📖 Usage'),
-            React.createElement(Text, null, '  /model <model-id>'),
-            React.createElement(Text, { dimColor: true }, '  Example: /model gpt-5'),
-            React.createElement(Text, null),
-            React.createElement(Text, { bold: true }, '🔗 More Info'),
-            React.createElement(Text, { color: theme.text.link }, '  OpenAI: https://platform.openai.com/docs/pricing')
-        )
+    sections.push(
+        React.createElement(Text, { key: 'spacer2' }, null),
+        React.createElement(Text, { key: 'usage', bold: true }, 'Usage:'),
+        React.createElement(Text, { key: 'usage-cmd' }, '  /model <model-id>'),
+        React.createElement(Text, { key: 'usage-example', dimColor: true }, '  Example: /model gpt-5')
     );
 
     return React.createElement(Box, {
-        flexDirection: 'column',
-        paddingX: 2,
-        paddingY: 1
+        flexDirection: 'column'
     }, ...sections);
 }

package/src/frontend/components/ModelUpdatedView.js

@@ -7,151 +7,16 @@ import { Box, Text } from 'ink';
 import { theme } from '../design/themeColors.js';
 
 export function ModelUpdatedView({ provider, modelId, modelInfo, settingsFile, warning }) {
-    const providerColors = {
-        openai: 'cyan'
-    };
-
-    const providerEmojis = {
-        openai: '🤖'
-    };
-
     return React.createElement(Box, {
-        flexDirection: 'column',
-        paddingX: 2,
-        paddingY: 1
+        flexDirection: 'column'
     },
-        // Header
-        React.createElement(Box, {
-            borderStyle: 'double',
-            borderColor: 'gray',
-            paddingX: 2,
-            paddingY: 0,
-            justifyContent: 'center'
-        },
-            React.createElement(Text, {
-                bold: true,
-                color: 'whiteBright'
-            }, '✓ Model Updated Successfully')
-        ),
-
-        React.createElement(Text, null),
-
-        // Main Content
-        React.createElement(Box, {
-            flexDirection: 'column',
-            borderStyle: 'round',
-            borderColor: 'gray',
-            paddingX: 2,
-            paddingY: 1
-        },
-            // Provider
-            React.createElement(Box, { flexDirection: 'row', gap: 1 },
-                React.createElement(Text, {
-                    bold: true,
-                    color: theme.text.secondary
-                }, 'Provider:'),
-                React.createElement(Text, {
-                    color: providerColors[provider] || 'white',
-                    bold: true
-                }, `${providerEmojis[provider] || ''} ${provider.toUpperCase()}`)
-            ),
-
-            React.createElement(Text, null),
-
-            // Model ID
-            React.createElement(Box, { flexDirection: 'row', gap: 1 },
-                React.createElement(Text, {
-                    bold: true,
-                    color: theme.text.secondary
-                }, 'Model ID:'),
-                React.createElement(Text, {
-                    color: 'white',
-                    bold: true
-                }, modelId)
-            ),
-
-            React.createElement(Text, null),
-
-            // Name
-            React.createElement(Box, { flexDirection: 'row', gap: 1 },
-                React.createElement(Text, {
-                    bold: true,
-                    color: theme.text.secondary
-                }, 'Name:'),
-                React.createElement(Text, {
-                    color: 'white'
-                }, modelInfo.name)
-            ),
-
-            React.createElement(Text, null),
-
-            // Description
-            React.createElement(Box, { flexDirection: 'column' },
-                React.createElement(Text, {
-                    bold: true,
-                    color: theme.text.secondary
-                }, 'Description:'),
-                React.createElement(Text, {
-                    color: theme.text.secondary,
-                    dimColor: true
-                }, `  ${modelInfo.description}`)
-            ),
-
-            modelInfo.pricing && React.createElement(React.Fragment, null,
-                React.createElement(Text, null),
-
-                // Pricing
-                React.createElement(Box, { flexDirection: 'row', gap: 1 },
-                    React.createElement(Text, {
-                        bold: true,
-                        color: theme.text.secondary
-                    }, 'Pricing:'),
-                    React.createElement(Text, {
-                        color: 'green'
-                    }, `💰 $${modelInfo.pricing.input}/$${modelInfo.pricing.output}`),
-                    React.createElement(Text, {
-                        dimColor: true,
-                        italic: true
-                    }, '(input/output per 1M tokens)')
-                )
-            ),
-
-            React.createElement(Text, null),
-
-            // Saved to
-            React.createElement(Box, { flexDirection: 'row', gap: 1 },
-                React.createElement(Text, {
-                    dimColor: true,
-                    italic: true
-                }, '📁 Saved to:'),
-                React.createElement(Text, {
-                    dimColor: true,
-                    italic: true
-                }, settingsFile)
-            )
-        ),
+        React.createElement(Text, {
+            color: 'green'
+        }, `Model updated: ${modelId}`),
 
         // Warning if API key not configured
-        warning && React.createElement(React.Fragment, null,
-            React.createElement(Text, null),
-            React.createElement(Box, {
-                flexDirection: 'column',
-                borderStyle: 'round',
-                borderColor: 'gray',
-                paddingX: 2,
-                paddingY: 1
-            },
-                React.createElement(Text, {
-                    bold: true,
-                    color: 'yellow'
-                }, '⚠ Warning'),
-                React.createElement(Text, null),
-                React.createElement(Text, { color: theme.text.secondary }, warning.message),
-                React.createElement(Text, {
-                    dimColor: true,
-                    italic: true
-                }, warning.hint)
-            )
-        )
+        warning && React.createElement(Text, {
+            color: 'yellow'
+        }, `Warning: ${warning.message} ${warning.hint}`)
     );
 }

package/src/frontend/components/SetupWizard.js

@@ -5,29 +5,28 @@
 import React, { useState, useRef } from 'react';
 import { Box, Text, useInput } from 'ink';
 import { theme } from '../design/themeColors.js';
-import { OPENAI_MODELS, getGPT5Models, DEFAULT_OPENAI_MODEL } from '../../config/openai_models.js';
+import { AI_MODELS, getAllModelIds, DEFAULT_MODEL } from '../../config/ai_models.js';
 
 const STEPS = {
-    OPENAI_KEY: 'openai_key',
-    OPENAI_MODEL: 'openai_model',
-    OPENAI_EFFORT: 'openai_effort'
+    API_KEY: 'api_key',
+    MODEL: 'model',
+    REASONING_EFFORT: 'reasoning_effort'
 };
 
 export function SetupWizard({ onComplete, onCancel }) {
-    const [step, setStep] = useState(STEPS.OPENAI_KEY);
+    const [step, setStep] = useState(STEPS.API_KEY);
     const [selectedIndex, setSelectedIndex] = useState(0);
     const [textInput, setTextInput] = useState('');
 
     // settings를 ref로 관리하여 stale closure 문제 방지
     const settingsRef = useRef({
-        AI_PROVIDER: 'openai',
-        OPENAI_API_KEY: '',
-        OPENAI_MODEL: DEFAULT_OPENAI_MODEL,
-        OPENAI_REASONING_EFFORT: 'medium'
+        API_KEY: '',
+        MODEL: DEFAULT_MODEL,
+        REASONING_EFFORT: 'medium'
     });
 
     // 현재 스텝이 텍스트 입력인지 선택지인지 판단
-    const isTextInputStep = step === STEPS.OPENAI_KEY;
+    const isTextInputStep = step === STEPS.API_KEY;
 
     const completeSetup = () => {
         if (onComplete) {
@@ -38,29 +37,35 @@ export function SetupWizard({ onComplete, onCancel }) {
 
     const handleStepComplete = () => {
         switch (step) {
-            case STEPS.OPENAI_KEY:
+            case STEPS.API_KEY:
                 if (!textInput.trim()) {
                     return;
                 }
-                settingsRef.current.OPENAI_API_KEY = textInput.trim();
-                setStep(STEPS.OPENAI_MODEL);
+                settingsRef.current.API_KEY = textInput.trim();
+                setStep(STEPS.MODEL);
                 setTextInput('');
                 setSelectedIndex(0);
                 break;
 
-            case STEPS.OPENAI_MODEL:
-                const models = getGPT5Models();
+            case STEPS.MODEL:
+                const models = getAllModelIds();
                 const selectedModel = models[selectedIndex];
-                settingsRef.current.OPENAI_MODEL = selectedModel;
-
-                // gpt-5 모델은 모두 reasoning effort 설정 필요
-                setStep(STEPS.OPENAI_EFFORT);
-                setSelectedIndex(2); // default to 'medium'
+                settingsRef.current.MODEL = selectedModel;
+
+                // reasoning을 지원하는 모델만 reasoning effort 설정
+                const modelInfo = AI_MODELS[selectedModel];
+                if (modelInfo && modelInfo.supportsReasoning) {
+                    setStep(STEPS.REASONING_EFFORT);
+                    setSelectedIndex(2); // default to 'medium'
+                } else {
+                    // reasoning을 지원하지 않으면 바로 완료
+                    completeSetup();
+                }
                 break;
 
-            case STEPS.OPENAI_EFFORT:
+            case STEPS.REASONING_EFFORT:
                 const efforts = ['minimal', 'low', 'medium', 'high'];
-                settingsRef.current.OPENAI_REASONING_EFFORT = efforts[selectedIndex];
+                settingsRef.current.REASONING_EFFORT = efforts[selectedIndex];
                 // 완료
                 completeSetup();
                 break;
@@ -112,9 +117,9 @@ export function SetupWizard({ onComplete, onCancel }) {
 
     const getMaxIndexForStep = (currentStep) => {
         switch (currentStep) {
-            case STEPS.OPENAI_MODEL:
-                return getGPT5Models().length - 1;
-            case STEPS.OPENAI_EFFORT:
+            case STEPS.MODEL:
+                return getAllModelIds().length - 1;
+            case STEPS.REASONING_EFFORT:
                 return 3; // 4 options
             default:
                 return 0;
@@ -137,10 +142,10 @@ export function SetupWizard({ onComplete, onCancel }) {
 
     const renderStep = () => {
         switch (step) {
-            case STEPS.OPENAI_KEY:
+            case STEPS.API_KEY:
                 return React.createElement(Box, { flexDirection: 'column' },
-                    React.createElement(Text, { bold: true, color: theme.text.accent }, '1. OpenAI API Key:'),
-                    React.createElement(Text, { color: theme.text.secondary }, '   Get your API key from: https://platform.openai.com/account/api-keys'),
+                    React.createElement(Text, { bold: true, color: theme.text.accent }, '1. API Key:'),
+                    React.createElement(Text, { color: theme.text.secondary }, '   Get your API key from: https://platform.openai.com/account/api-keys or https://console.anthropic.com/settings/keys'),
                     React.createElement(Text, null),
                     React.createElement(Box, {
                         borderStyle: 'round',
@@ -153,13 +158,13 @@ export function SetupWizard({ onComplete, onCancel }) {
                     React.createElement(Text, { dimColor: true }, 'Type your API key and press Enter')
                 );
 
-            case STEPS.OPENAI_MODEL:
+            case STEPS.MODEL:
                 return React.createElement(Box, { flexDirection: 'column' },
                     React.createElement(Text, { bold: true, color: theme.text.accent }, '2. Choose Model:'),
                     React.createElement(Text, null),
                     renderOptions(
-                        getGPT5Models().map(modelId => {
-                            const model = OPENAI_MODELS[modelId];
+                        getAllModelIds().map(modelId => {
+                            const model = AI_MODELS[modelId];
                             return `${modelId} (${model.name})`;
                         })
                     ),
@@ -167,7 +172,7 @@ export function SetupWizard({ onComplete, onCancel }) {
                     React.createElement(Text, { dimColor: true }, '↑↓: Navigate  Enter: Confirm')
                 );
 
-            case STEPS.OPENAI_EFFORT:
+            case STEPS.REASONING_EFFORT:
                 return React.createElement(Box, { flexDirection: 'column' },
                     React.createElement(Text, { bold: true, color: theme.text.accent }, '3. Reasoning Effort:'),
                     React.createElement(Text, null),

package/src/system/ai_request.js

@@ -1,12 +1,12 @@
-import OpenAI from "openai";
 import dotenv from "dotenv";
 import path from 'path';
 import { safeWriteFile } from '../util/safe_fs.js';
 import { logger } from "./log.js";
-import { ensureConfigDirectory, loadSettings, SETTINGS_FILE } from "../util/config.js";
-import { getReasoningModels, supportsReasoningEffort, DEFAULT_OPENAI_MODEL } from "../config/openai_models.js";
+import { ensureConfigDirectory, loadSettings, SETTINGS_FILE, PAYLOAD_LLM_LOG_DIR } from "../util/config.js";
+import { getReasoningModels, supportsReasoningEffort, DEFAULT_MODEL, getModelInfo } from "../config/ai_models.js";
 import { createDebugLogger } from "../util/debug_log.js";
 import { formatReadFileStdout } from "../util/output_formatter.js";
+import { UnifiedLLMClient } from "../LLMClient/index.js";
 
 const debugLog = createDebugLogger('ai_request.log', 'ai_request');
 
@@ -14,70 +14,81 @@ const debugLog = createDebugLogger('ai_request.log', 'ai_request');
 dotenv.config({ quiet: true });
 
 // AI 클라이언트를 초기화합니다.
-let openaiClient = null;
+let llmClient = null;
 let currentAbortController = null;
 
-async function getOpenAIClient() {
-    debugLog('[getOpenAIClient] Called');
-    if (openaiClient) {
-        debugLog('[getOpenAIClient] Using cached client');
-        return openaiClient;
+async function getLLMClient() {
+    debugLog('[getLLMClient] Called');
+    if (llmClient) {
+        debugLog('[getLLMClient] Using cached client');
+        return llmClient;
     }
 
-    debugLog('[getOpenAIClient] Creating new client');
+    debugLog('[getLLMClient] Creating new client');
     // Settings 로드 및 환경변수 설정
     await ensureConfigDirectory();
     const settings = await loadSettings();
-    debugLog(`[getOpenAIClient] Settings loaded: AI_PROVIDER=${settings?.AI_PROVIDER}, OPENAI_MODEL=${settings?.OPENAI_MODEL}, OPENAI_REASONING_EFFORT=${settings?.OPENAI_REASONING_EFFORT}`);
+    debugLog(`[getLLMClient] Settings loaded: MODEL=${settings?.MODEL}, REASONING_EFFORT=${settings?.REASONING_EFFORT}`);
 
-    if (!process.env.OPENAI_API_KEY && settings?.OPENAI_API_KEY) {
-        process.env.OPENAI_API_KEY = settings.OPENAI_API_KEY;
-        debugLog('[getOpenAIClient] OPENAI_API_KEY loaded from settings');
+    if (!process.env.API_KEY && settings?.API_KEY) {
+        process.env.API_KEY = settings.API_KEY;
+        debugLog('[getLLMClient] API_KEY loaded from settings');
     }
 
     // 모델 설정도 환경변수에 로드
-    if (!process.env.OPENAI_MODEL && settings?.OPENAI_MODEL) {
-        process.env.OPENAI_MODEL = settings.OPENAI_MODEL;
-        debugLog(`[getOpenAIClient] OPENAI_MODEL set to: ${settings.OPENAI_MODEL}`);
+    if (!process.env.MODEL && settings?.MODEL) {
+        process.env.MODEL = settings.MODEL;
+        debugLog(`[getLLMClient] MODEL set to: ${settings.MODEL}`);
     }
 
     // reasoning_effort 설정도 환경변수에 로드
-    if (!process.env.OPENAI_REASONING_EFFORT && settings?.OPENAI_REASONING_EFFORT) {
-        process.env.OPENAI_REASONING_EFFORT = settings.OPENAI_REASONING_EFFORT;
-        debugLog(`[getOpenAIClient] OPENAI_REASONING_EFFORT set to: ${settings.OPENAI_REASONING_EFFORT}`);
+    if (!process.env.REASONING_EFFORT && settings?.REASONING_EFFORT) {
+        process.env.REASONING_EFFORT = settings.REASONING_EFFORT;
+        debugLog(`[getLLMClient] REASONING_EFFORT set to: ${settings.REASONING_EFFORT}`);
     }
 
-    if (!process.env.OPENAI_API_KEY) {
-        debugLog('[getOpenAIClient] ERROR: OPENAI_API_KEY not configured');
-        throw new Error(`OPENAI_API_KEY is not configured. Please update ${SETTINGS_FILE}.`);
+    if (!process.env.API_KEY) {
+        debugLog('[getLLMClient] ERROR: API_KEY not configured');
+        throw new Error(`API_KEY is not configured. Please update ${SETTINGS_FILE}.`);
     }
 
-    debugLog('[getOpenAIClient] Initializing OpenAI client with API key (first 10 chars): ' + process.env.OPENAI_API_KEY.substring(0, 10) + '...');
-    openaiClient = new OpenAI({
-        apiKey: process.env.OPENAI_API_KEY
+    const currentModel = process.env.MODEL || settings?.MODEL || DEFAULT_MODEL;
+    const modelInfo = getModelInfo(currentModel);
+    const provider = modelInfo?.provider || 'openai';
+
+    debugLog('[getLLMClient] Initializing UnifiedLLMClient with API key (first 10 chars): ' + process.env.API_KEY.substring(0, 10) + '...');
+    debugLog(`[getLLMClient] Model: ${currentModel}, Provider: ${provider}`);
+    llmClient = new UnifiedLLMClient({
+        apiKey: process.env.API_KEY,
+        model: currentModel,
+        provider: provider,
+        logDir: PAYLOAD_LLM_LOG_DIR
     });
 
-    debugLog('[getOpenAIClient] Client created successfully');
-    return openaiClient;
+    debugLog('[getLLMClient] Client created successfully');
+    return llmClient;
 }
 
 async function getCurrentProvider() {
-    return 'openai';
+    const settings = await loadSettings();
+    const currentModel = process.env.MODEL || settings?.MODEL || DEFAULT_MODEL;
+    const modelInfo = getModelInfo(currentModel);
+    return modelInfo?.provider || 'openai';
 }
 
 // Provider에 맞는 모델 이름 가져오기
 async function getModelForProvider() {
     debugLog('[getModelForProvider] Called');
     const settings = await loadSettings();
-    const model = process.env.OPENAI_MODEL || settings?.OPENAI_MODEL || DEFAULT_OPENAI_MODEL;
-    debugLog(`[getModelForProvider] Model: ${model} (from: ${process.env.OPENAI_MODEL ? 'env' : settings?.OPENAI_MODEL ? 'settings' : 'default'})`);
+    const model = process.env.MODEL || settings?.MODEL || DEFAULT_MODEL;
+    debugLog(`[getModelForProvider] Model: ${model} (from: ${process.env.MODEL ? 'env' : settings?.MODEL ? 'settings' : 'default'})`);
     return model;
 }
 
 // 클라이언트 및 캐시 리셋 함수 (모델 변경 시 사용)
 export function resetAIClients() {
     debugLog('[resetAIClients] Resetting AI client cache');
-    openaiClient = null;
+    llmClient = null;
     currentAbortController = null;
     debugLog('[resetAIClients] Client cache cleared');
 }
@@ -431,18 +442,18 @@ export async function request(taskName, requestPayload) {
     currentAbortController = new AbortController();
 
     try {
-        // OpenAI API 사용
-        debugLog('[request] Getting OpenAI client');
-        const openai = await getOpenAIClient();
+        // UnifiedLLMClient 사용
+        debugLog('[request] Getting LLM client');
+        const client = await getLLMClient();
 
         // reasoning 설정 추가 (OpenAI 추론 모델용)
         const settings = await loadSettings();
-        const reasoningEffort = settings?.OPENAI_REASONING_EFFORT || process.env.OPENAI_REASONING_EFFORT || 'medium';
+        const reasoningEffort = settings?.REASONING_EFFORT || process.env.REASONING_EFFORT || 'medium';
         debugLog(`[request] Reasoning effort: ${reasoningEffort}`);
 
         // reasoning을 지원하는 모델인지 확인
         const reasoningModels = getReasoningModels();
-        const currentModel = payloadCopy.model || settings?.OPENAI_MODEL || DEFAULT_OPENAI_MODEL;
+        const currentModel = payloadCopy.model || settings?.MODEL || DEFAULT_MODEL;
         debugLog(`[request] Current model: ${currentModel}`);
 
         if (reasoningModels.some(m => currentModel.startsWith(m))) {
@@ -481,16 +492,20 @@ export async function request(taskName, requestPayload) {
             debugLog(`[request] Model does not support reasoning`);
         }
 
-        originalRequest = JSON.parse(JSON.stringify(payloadCopy)); // 원본 OpenAI 요청
+        originalRequest = JSON.parse(JSON.stringify(payloadCopy)); // 원본 요청
         debugLog(`[request] Request prepared - logging to file`);
 
-        // 로그는 원본 OpenAI 포맷으로 저장 (API 호출 전)
+        // 로그는 원본 포맷으로 저장 (API 호출 전)
         await logger(`${taskName}_REQ`, originalRequest, provider);
-        debugLog(`[request] Request logged - calling OpenAI API`);
+        debugLog(`[request] Request logged - calling LLM API`);
 
-        response = await openai.responses.create(originalRequest, {
+        // AbortController의 signal을 options로 전달
+        const requestOptions = {
             signal: currentAbortController.signal
-        });
+        };
+        debugLog(`[request] Calling client.response with abort signal`);
+
+        response = await client.response(originalRequest, requestOptions);
         debugLog(`[request] Response received - id: ${response?.id}, status: ${response?.status}, output items: ${response?.output?.length || 0}`);
 
         // 원본 응답을 깊은 복사로 보존 (이후 수정으로부터 보호)

package/src/util/config.js

@@ -3,7 +3,7 @@ import { homedir } from 'os';
 import { join, dirname } from 'path';
 import { safeReadFile, safeWriteFile, safeMkdir, safeReaddir, safeStat, safeCopyFile } from './safe_fs.js';
 import { fileURLToPath } from 'url';
-import { DEFAULT_OPENAI_MODEL } from '../config/openai_models.js';
+import { DEFAULT_MODEL } from '../config/ai_models.js';
 
 // Get project root directory (this file is in src/util/, so go up 2 levels)
 const __filename = fileURLToPath(import.meta.url);
@@ -38,12 +38,13 @@ export const CONFIG_DIR = join(getHomeDirectory(), '.aiexe');
 export const SETTINGS_FILE = join(CONFIG_DIR, 'settings.json');
 export const MCP_CONFIG_FILE = join(CONFIG_DIR, 'mcp_config.json');
 export const PAYLOAD_LOG_DIR = join(CONFIG_DIR, 'payload_log');
+export const PAYLOAD_LLM_LOG_DIR = join(CONFIG_DIR, 'payload_LLM_log');
 export const DEBUG_LOG_DIR = join(CONFIG_DIR, 'debuglog');
 export const DEBUG_LOG_FILE = join(CONFIG_DIR, 'debug.txt'); // Deprecated: 호환성을 위해 유지
 const DEFAULT_SETTINGS = {
-    OPENAI_API_KEY: '',
-    OPENAI_MODEL: DEFAULT_OPENAI_MODEL,
-    OPENAI_REASONING_EFFORT: 'medium', // 'minimal', 'low', 'medium', 'high'
+    API_KEY: '',
+    MODEL: DEFAULT_MODEL,
+    REASONING_EFFORT: 'medium', // 'minimal', 'low', 'medium', 'high'
     // 도구 활성화 옵션
     TOOLS_ENABLED: {
         edit_file_range: false,  // 기본적으로 비활성화 (edit_file_replace 사용 권장)
@@ -126,3 +127,24 @@ export async function saveSettings(settings) {
         throw error;
     }
 }
+
+/**
+ * API 키의 접두어를 기반으로 발급처를 판단합니다.
+ * @param {string} apiKey - API 키 문자열
+ * @returns {string|null} 발급처 이름 ("Google", "OpenAI", "Anthropic") 또는 null (알 수 없는 경우)
+ */
+export function APIKeyIssuedFrom(apiKey) {
+    if (!apiKey || typeof apiKey !== 'string') {
+        return null;
+    }
+
+    if (apiKey.startsWith('AIzaSy')) {
+        return 'Google';
+    } else if (apiKey.startsWith('sk-proj-')) {
+        return 'OpenAI';
+    } else if (apiKey.startsWith('sk-ant-')) {
+        return 'Anthropic';
+    }
+
+    return null;
+}