hanseol-dev 4.4.0-dev.1 → 4.5.0-dev.0

package/dist/core/llm/llm-client.js

@@ -36,14 +36,33 @@ export class LLMClient {
         });
     }
     preprocessMessages(messages, modelId) {
-        return messages.map((msg) => {
+        let lastAssistantIdx = -1;
+        for (let i = messages.length - 1; i >= 0; i--) {
+            if (messages[i].role === 'assistant') {
+                lastAssistantIdx = i;
+                break;
+            }
+        }
+        return messages.map((msg, index) => {
             if (msg.role !== 'assistant') {
                 return msg;
             }
             const msgAny = msg;
-            let processedMsg = { ...msg };
-            if (msgAny.reasoning_content && (!msg.content || msg.content.trim() === '')) {
-                processedMsg.content = msgAny.reasoning_content;
+            const processedMsg = { ...msg };
+            const isLatestAssistant = index === lastAssistantIdx;
+            if (!isLatestAssistant) {
+                if (msgAny.reasoning_content) {
+                    delete processedMsg.reasoning_content;
+                }
+                if (msgAny.reasoning) {
+                    delete processedMsg.reasoning;
+                }
+                if (processedMsg.content) {
+                    processedMsg.content = processedMsg.content.replace(/<think>[\s\S]*?<\/think>/g, '').trim();
+                }
+            }
+            if (msgAny.reasoning_content && (!processedMsg.content || processedMsg.content.trim() === '')) {
+                processedMsg.content = isLatestAssistant ? msgAny.reasoning_content : '';
                 delete processedMsg.reasoning_content;
             }
             if (/^gpt-oss-(120b|20b)$/i.test(modelId)) {
@@ -110,7 +129,7 @@ export class LLMClient {
             const elapsed = logger.endTimer('llm-api-call');
             logger.flow('API 응답 수신 완료');
             if (!response.data.choices || !Array.isArray(response.data.choices)) {
-                logger.error('Invalid response structure - missing choices array', response.data);
+                logger.errorSilent('Invalid response structure - missing choices array', response.data);
                 throw new Error('LLM 응답 형식이 올바르지 않습니다. choices 배열이 없습니다.');
             }
             logger.httpResponse(response.status, response.statusText, {
@@ -169,7 +188,7 @@ export class LLMClient {
             }
             logger.flow('API 호출 실패 - 에러 처리');
             if (currentAttempt > 1) {
-                logger.error(`LLM 호출 ${maxRetries}번 재시도 후 최종 실패`, {
+                logger.errorSilent(`LLM 호출 ${maxRetries}번 재시도 후 최종 실패`, {
                     error: error.message,
                     attempts: currentAttempt
                 });
@@ -180,7 +199,7 @@ export class LLMClient {
                 url,
                 body: options,
             });
-            reportError(handled, { type: 'llm', method: 'chatCompletion', endpoint: url }).catch(() => { });
+            reportError(handled, { type: 'llm', method: 'chatCompletion', endpoint: url, modelId: this.model, modelName: this.modelName }).catch(() => { });
             throw handled;
         }
     }
@@ -317,7 +336,7 @@ export class LLMClient {
                 url,
                 body: options,
             });
-            reportError(handled, { type: 'llm', method: 'chatCompletionStream', endpoint: url }).catch(() => { });
+            reportError(handled, { type: 'llm', method: 'chatCompletionStream', endpoint: url, modelId: this.model, modelName: this.modelName }).catch(() => { });
             throw handled;
         }
     }
@@ -380,24 +399,60 @@ export class LLMClient {
     }
     async chatCompletionWithTools(messages, tools, options) {
         let workingMessages = [...messages];
+        const toolLoopMessages = [];
         const toolCallHistory = [];
         let iterations = 0;
         let contextLengthRecoveryAttempted = false;
         let noToolCallRetries = 0;
         let finalResponseFailures = 0;
+        let consecutiveParseFailures = 0;
         const MAX_NO_TOOL_CALL_RETRIES = 3;
         const MAX_FINAL_RESPONSE_FAILURES = 3;
+        const MAX_CONSECUTIVE_PARSE_FAILURES = 3;
+        const parseFailureToolCallIds = new Set();
+        const stripParseFailures = (msgs) => {
+            if (parseFailureToolCallIds.size === 0)
+                return msgs;
+            return msgs.filter(msg => {
+                if (msg.role === 'tool' && msg.tool_call_id && parseFailureToolCallIds.has(msg.tool_call_id))
+                    return false;
+                if (msg.role === 'assistant' && msg.tool_calls && msg.tool_calls.length > 0 &&
+                    msg.tool_calls.every(tc => parseFailureToolCallIds.has(tc.id)))
+                    return false;
+                return true;
+            });
+        };
+        const addMessage = (msg) => {
+            workingMessages.push(msg);
+            if (options?.rebuildMessages) {
+                toolLoopMessages.push(msg);
+            }
+        };
+        const getAllMessages = () => {
+            return options?.rebuildMessages
+                ? stripParseFailures(toolLoopMessages)
+                : stripParseFailures(workingMessages);
+        };
         while (true) {
             if (this.isInterrupted) {
                 logger.flow('Interrupt detected - stopping tool loop');
                 throw new Error('INTERRUPTED');
             }
             iterations++;
+            if (options?.rebuildMessages) {
+                workingMessages = options.rebuildMessages(toolLoopMessages);
+            }
             if (options?.getPendingMessage && options?.clearPendingMessage) {
                 const pendingMsg = options.getPendingMessage();
                 if (pendingMsg) {
                     logger.flow('Injecting pending user message into conversation');
-                    workingMessages.push({ role: 'user', content: pendingMsg });
+                    if (options?.rebuildMessages) {
+                        toolLoopMessages.push({ role: 'user', content: pendingMsg });
+                        workingMessages = options.rebuildMessages(toolLoopMessages);
+                    }
+                    else {
+                        workingMessages.push({ role: 'user', content: pendingMsg });
+                    }
                     options.clearPendingMessage();
                 }
             }
@@ -412,7 +467,19 @@ export class LLMClient {
             catch (error) {
                 if (error instanceof ContextLengthError && !contextLengthRecoveryAttempted) {
                     contextLengthRecoveryAttempted = true;
-                    logger.flow('ContextLengthError detected - attempting recovery with compact');
+                    logger.flow('ContextLengthError detected - attempting recovery');
+                    if (options?.rebuildMessages) {
+                        let rollbackIdx = toolLoopMessages.length - 1;
+                        while (rollbackIdx >= 0 && toolLoopMessages[rollbackIdx]?.role === 'tool') {
+                            rollbackIdx--;
+                        }
+                        if (rollbackIdx >= 0 && toolLoopMessages[rollbackIdx]?.tool_calls) {
+                            toolLoopMessages.length = rollbackIdx;
+                            logger.debug('Rolled back toolLoopMessages', { newLength: toolLoopMessages.length });
+                        }
+                        continue;
+                    }
+                    logger.flow('Attempting recovery with compact');
                     let rollbackIdx = workingMessages.length - 1;
                     while (rollbackIdx >= 0 && workingMessages[rollbackIdx]?.role === 'tool') {
                         rollbackIdx--;
@@ -441,7 +508,7 @@ export class LLMClient {
                         continue;
                     }
                     else {
-                        logger.error('Compact failed during recovery', { error: compactResult.error });
+                        logger.errorSilent('Compact failed during recovery', { error: compactResult.error });
                         throw error;
                     }
                 }
@@ -456,7 +523,7 @@ export class LLMClient {
                 throw new Error('응답에서 choice를 찾을 수 없습니다.');
             }
             const assistantMessage = choice.message;
-            workingMessages.push(assistantMessage);
+            addMessage(assistantMessage);
             if (assistantMessage.tool_calls && assistantMessage.tool_calls.length > 0) {
                 if (assistantMessage.tool_calls.length > 1) {
                     const toolNames = assistantMessage.tool_calls.map(tc => tc.function.name).join(', ');
@@ -464,18 +531,86 @@ export class LLMClient {
                     assistantMessage.tool_calls = [assistantMessage.tool_calls[0]];
                 }
                 for (const toolCall of assistantMessage.tool_calls) {
-                    const toolName = toolCall.function.name;
+                    const rawToolName = toolCall.function.name;
+                    const toolName = rawToolName.replace(/<\|.*$/, '').replace(/[^a-zA-Z0-9_-]+$/, '').trim() || rawToolName;
+                    if (toolName !== rawToolName) {
+                        logger.warn('Tool name sanitized (model leaked special tokens)', {
+                            original: rawToolName,
+                            sanitized: toolName,
+                            model: this.model,
+                        });
+                        toolCall.function.name = toolName;
+                        reportError(new Error(`Tool name contaminated: ${rawToolName}`), {
+                            type: 'toolNameContamination',
+                            original: rawToolName,
+                            sanitized: toolName,
+                            modelId: this.model,
+                            modelName: this.modelName,
+                        }).catch(() => { });
+                    }
                     let toolArgs;
                     try {
                         toolArgs = JSON.parse(toolCall.function.arguments);
                     }
                     catch (parseError) {
-                        const errorMsg = `Tool argument parsing failed for ${toolName}`;
-                        logger.error(errorMsg, parseError);
+                        consecutiveParseFailures++;
+                        parseFailureToolCallIds.add(toolCall.id);
+                        const errorMsg = `Tool argument parsing failed for ${toolName}: ${parseError instanceof Error ? parseError.message : 'Unknown error'}`;
+                        logger.errorSilent('Tool argument parse error', {
+                            toolName,
+                            error: errorMsg,
+                            consecutiveFailures: consecutiveParseFailures,
+                        });
                         logger.debug('Raw arguments', { raw: toolCall.function.arguments });
-                        workingMessages.push({
+                        reportError(parseError, {
+                            type: 'toolArgParsing',
+                            tool: toolName,
+                            consecutiveFailures: consecutiveParseFailures,
+                            modelId: this.model,
+                            modelName: this.modelName,
+                            rawArguments: typeof toolCall.function.arguments === 'string' ? toolCall.function.arguments.substring(0, 500) : undefined,
+                        }).catch(() => { });
+                        if (consecutiveParseFailures >= MAX_CONSECUTIVE_PARSE_FAILURES) {
+                            logger.errorSilent('[ABORT] Tool argument parse failed 3 times consecutively. Model may not support JSON function calling.');
+                            const abortMsg = 'I cannot generate valid JSON tool arguments. Please try a different model that supports JSON function calling.';
+                            addMessage({
+                                role: 'tool',
+                                content: errorMsg,
+                                tool_call_id: toolCall.id,
+                            });
+                            return {
+                                message: { role: 'assistant', content: abortMsg },
+                                toolCalls: toolCallHistory,
+                                allMessages: getAllMessages(),
+                            };
+                        }
+                        const rawArgs = toolCall.function.arguments;
+                        const rawPreview = typeof rawArgs === 'string' ? rawArgs.substring(0, 300) : String(rawArgs);
+                        const hintMsg = `Error: Failed to parse tool arguments for "${toolName}".
+
+Parse error: ${parseError instanceof Error ? parseError.message : 'Unknown error'}
+
+Your raw input was:
+\`\`\`
+${rawPreview}
+\`\`\`
+
+Fix the following issues:
+1. Arguments MUST be valid JSON (not XML, not plain text)
+2. All strings must use double quotes ("), not single quotes (')
+3. No trailing commas after the last property
+4. No comments inside JSON
+5. Escape special characters in strings (\\n, \\", \\\\)
+
+Correct format example:
+\`\`\`json
+{"reason": "description", "file_path": "src/index.ts"}
+\`\`\`
+
+Do NOT use XML tags like <arg_key> or <arg_value>. Retry with valid JSON.`;
+                        addMessage({
                             role: 'tool',
-                            content: `Error: Failed to parse tool arguments - ${parseError instanceof Error ? parseError.message : 'Unknown error'}`,
+                            content: hintMsg,
                             tool_call_id: toolCall.id,
                         });
                         toolCallHistory.push({
@@ -485,6 +620,59 @@ export class LLMClient {
                         });
                         continue;
                     }
+                    const toolDef = tools.find(t => t.function.name === toolName);
+                    if (toolDef?.function.parameters) {
+                        const schema = toolDef.function.parameters;
+                        const schemaErrors = [];
+                        if (schema.required) {
+                            for (const req of schema.required) {
+                                if (toolArgs[req] === undefined || toolArgs[req] === null) {
+                                    const propDef = schema.properties[req];
+                                    schemaErrors.push(`Missing required parameter: "${req}" (expected: ${propDef?.type || 'unknown'})`);
+                                }
+                            }
+                        }
+                        for (const [key, value] of Object.entries(toolArgs)) {
+                            const propDef = schema.properties[key];
+                            if (propDef?.type && value !== null && value !== undefined) {
+                                const actualType = Array.isArray(value) ? 'array' : typeof value;
+                                if (actualType !== propDef.type) {
+                                    schemaErrors.push(`"${key}": expected ${propDef.type}, got ${actualType} (${JSON.stringify(value).substring(0, 50)})`);
+                                }
+                            }
+                        }
+                        if (schemaErrors.length > 0) {
+                            consecutiveParseFailures++;
+                            parseFailureToolCallIds.add(toolCall.id);
+                            if (consecutiveParseFailures >= MAX_CONSECUTIVE_PARSE_FAILURES) {
+                                const abortMsg = 'Cannot generate valid tool arguments. Please try a different model.';
+                                addMessage({ role: 'tool', content: schemaErrors.join('\n'), tool_call_id: toolCall.id });
+                                return {
+                                    message: { role: 'assistant', content: abortMsg },
+                                    toolCalls: toolCallHistory,
+                                    allMessages: getAllMessages(),
+                                };
+                            }
+                            const requiredList = (schema.required || [])
+                                .map(r => {
+                                const p = schema.properties[r];
+                                return `  "${r}": ${p?.type || 'unknown'}`;
+                            })
+                                .join('\n');
+                            const hintMsg = `Error: Schema validation failed for "${toolName}".
+
+${schemaErrors.join('\n')}
+
+Required parameters:
+${requiredList}
+
+Retry with correct parameter names and types.`;
+                            addMessage({ role: 'tool', content: hintMsg, tool_call_id: toolCall.id });
+                            toolCallHistory.push({ tool: toolName, args: toolArgs, result: 'Error: Schema validation failed' });
+                            continue;
+                        }
+                    }
+                    consecutiveParseFailures = 0;
                     const { executeFileTool, requestToolApproval } = await import('../../tools/llm/simple/file-tools.js');
                     const approvalResult = await requestToolApproval(toolName, toolArgs);
                     if (approvalResult && typeof approvalResult === 'object' && approvalResult.reject) {
@@ -492,7 +680,7 @@ export class LLMClient {
                         const rejectMessage = approvalResult.comment
                             ? `Tool execution rejected by user. Reason: ${approvalResult.comment}`
                             : 'Tool execution rejected by user.';
-                        workingMessages.push({
+                        addMessage({
                             role: 'tool',
                             content: rejectMessage,
                             tool_call_id: toolCall.id,
@@ -515,7 +703,7 @@ export class LLMClient {
                         if (toolName === 'final_response') {
                             if (result.success && result.metadata?.['isFinalResponse']) {
                                 logger.flow('final_response tool executed successfully - returning');
-                                workingMessages.push({
+                                addMessage({
                                     role: 'tool',
                                     content: result.result || '',
                                     tool_call_id: toolCall.id,
@@ -531,7 +719,7 @@ export class LLMClient {
                                         content: result.result || '',
                                     },
                                     toolCalls: toolCallHistory,
-                                    allMessages: workingMessages,
+                                    allMessages: getAllMessages(),
                                 };
                             }
                             else {
@@ -545,7 +733,7 @@ export class LLMClient {
                                     return {
                                         message: { role: 'assistant', content: fallbackMessage },
                                         toolCalls: toolCallHistory,
-                                        allMessages: workingMessages,
+                                        allMessages: getAllMessages(),
                                     };
                                 }
                             }
@@ -553,6 +741,7 @@ export class LLMClient {
                     }
                     catch (toolError) {
                         logger.toolExecution(toolName, toolArgs, undefined, toolError);
+                        reportError(toolError, { type: 'toolExecution', tool: toolName, modelId: this.model, modelName: this.modelName, toolArgs }).catch(() => { });
                         if (isLLMLogEnabled()) {
                             const errorMsg = toolError instanceof Error ? toolError.message : String(toolError);
                             logger.llmToolResult(toolName, `Error: ${errorMsg}`, false);
@@ -562,7 +751,7 @@ export class LLMClient {
                             error: toolError instanceof Error ? toolError.message : String(toolError),
                         };
                     }
-                    workingMessages.push({
+                    addMessage({
                         role: 'tool',
                         content: result.success ? result.result || '' : `Error: ${result.error}`,
                         tool_call_id: toolCall.id,
@@ -577,6 +766,9 @@ export class LLMClient {
                         throw new Error('INTERRUPTED');
                     }
                 }
+                if (options?.onAfterToolExecution) {
+                    await options.onAfterToolExecution(toolLoopMessages);
+                }
                 continue;
             }
             else {
@@ -590,7 +782,7 @@ export class LLMClient {
                     return {
                         message: { role: 'assistant', content: fallbackContent },
                         toolCalls: toolCallHistory,
-                        allMessages: workingMessages,
+                        allMessages: getAllMessages(),
                     };
                 }
                 const hasMalformedToolCall = assistantMessage.content &&
@@ -602,7 +794,7 @@ export class LLMClient {
                 const retryMessage = hasMalformedToolCall
                     ? 'Your previous response contained a malformed tool call (XML tags in content). You MUST use the proper tool_calls API format. Use final_response tool to deliver your message to the user.'
                     : 'You must use tools for all actions. Use final_response tool to deliver your final message to the user after completing all tasks.';
-                workingMessages.push({
+                addMessage({
                     role: 'user',
                     content: retryMessage,
                 });
@@ -618,14 +810,14 @@ export class LLMClient {
         };
     }
     handleError(error, requestContext) {
-        logger.error('LLM Client Error', error);
+        logger.errorSilent('LLM Client Error', error);
         if (requestContext) {
             logger.debug('Request Context', requestContext);
         }
         if (axios.isAxiosError(error)) {
             const axiosError = error;
             if (axiosError.code === 'ECONNABORTED' || axiosError.message.includes('timeout')) {
-                logger.error('Request Timeout', {
+                logger.errorSilent('Request Timeout', {
                     timeout: this.axiosInstance.defaults.timeout,
                     endpoint: this.baseUrl,
                 });
@@ -644,7 +836,7 @@ export class LLMClient {
                 const errorMessage = data?.error?.message || data?.message || axiosError.message;
                 const errorType = data?.error?.type || 'unknown';
                 const errorCode = data?.error?.code || data?.code;
-                logger.error('=== API ERROR DETAILS ===', {
+                logger.errorSilent('=== API ERROR DETAILS ===', {
                     status,
                     statusText: axiosError.response.statusText,
                     endpoint: this.baseUrl,
@@ -666,7 +858,7 @@ export class LLMClient {
                         errorMessage.includes('maximum context length') ||
                         errorCode === 'context_length_exceeded')) {
                     const maxLength = data?.error?.param?.max_tokens || 'unknown';
-                    logger.error('Context Length Exceeded', {
+                    logger.errorSilent('Context Length Exceeded', {
                         maxLength,
                         errorMessage,
                         model: this.model,
@@ -683,7 +875,7 @@ export class LLMClient {
                 }
                 if (errorMessage.includes('token') &&
                     (errorMessage.includes('limit') || errorMessage.includes('exceeded'))) {
-                    logger.error('Token Limit Error', {
+                    logger.errorSilent('Token Limit Error', {
                         errorMessage,
                         model: this.model,
                     });
@@ -699,7 +891,7 @@ export class LLMClient {
                 }
                 if (status === 429) {
                     if (errorType === 'quota_exceeded' && data?.error?.quota) {
-                        logger.error('Quota Exceeded', {
+                        logger.errorSilent('Quota Exceeded', {
                             period: data.error.quota.period,
                             weekly: data.error.quota.weekly,
                         });
@@ -707,7 +899,7 @@ export class LLMClient {
                     }
                     const retryAfter = axiosError.response.headers['retry-after'];
                     const retrySeconds = retryAfter ? parseInt(retryAfter) : undefined;
-                    logger.error('Rate Limit Exceeded', {
+                    logger.errorSilent('Rate Limit Exceeded', {
                         retryAfter: retrySeconds,
                         errorMessage,
                     });
@@ -721,7 +913,7 @@ export class LLMClient {
                     });
                 }
                 if (status === 401) {
-                    logger.error('Authentication Failed', {
+                    logger.errorSilent('Authentication Failed', {
                         endpoint: this.baseUrl,
                         errorMessage,
                     });
@@ -737,7 +929,7 @@ export class LLMClient {
                     });
                 }
                 if (status === 403) {
-                    logger.error('Access Forbidden', {
+                    logger.errorSilent('Access Forbidden', {
                         endpoint: this.baseUrl,
                         errorMessage,
                     });
@@ -750,7 +942,7 @@ export class LLMClient {
                     });
                 }
                 if (status === 404) {
-                    logger.error('Endpoint Not Found', {
+                    logger.errorSilent('Endpoint Not Found', {
                         endpoint: this.baseUrl,
                         url: requestContext?.url,
                         errorMessage,
@@ -766,7 +958,7 @@ export class LLMClient {
                     });
                 }
                 if (status >= 500) {
-                    logger.error('Server Error', {
+                    logger.errorSilent('Server Error', {
                         status,
                         endpoint: this.baseUrl,
                         errorMessage,
@@ -779,7 +971,7 @@ export class LLMClient {
                         isRecoverable: true,
                     });
                 }
-                logger.error('API Error', {
+                logger.errorSilent('API Error', {
                     status,
                     endpoint: this.baseUrl,
                     errorMessage,
@@ -798,7 +990,7 @@ export class LLMClient {
             }
             else if (axiosError.request) {
                 const errorCode = axiosError.code;
-                logger.error('Network Error - No Response', {
+                logger.errorSilent('Network Error - No Response', {
                     code: errorCode,
                     endpoint: this.baseUrl,
                     message: axiosError.message,
@@ -825,7 +1017,7 @@ export class LLMClient {
                     userMessage: `네트워크 연결 실패.\n엔드포인트: ${this.baseUrl}\n에러: ${axiosError.message}`,
                 });
             }
-            logger.error('Axios Error', {
+            logger.errorSilent('Axios Error', {
                 code: axiosError.code,
                 message: axiosError.message,
             });
@@ -837,13 +1029,13 @@ export class LLMClient {
             });
         }
         if (error instanceof Error) {
-            logger.error('Unexpected Error', error);
+            logger.errorSilent('Unexpected Error', error);
             return new LLMError(`예상치 못한 에러: ${error.message}`, {
                 cause: error,
                 userMessage: `오류가 발생했습니다:\n${error.message}\n\n스택:\n${error.stack}`,
             });
         }
-        logger.error('Unknown Error Type', { error });
+        logger.errorSilent('Unknown Error Type', { error });
         return new LLMError('알 수 없는 에러가 발생했습니다.', {
             details: { unknownError: error },
         });