companionbot 0.13.1 → 0.14.0

package/dist/ai/claude.js

@@ -23,7 +23,7 @@ function getClient() {
     }
     return anthropic;
 }
-// Thinking 레벨별 설정 (비율 및 최대값)
+// Thinking 레벨별 설정
 export const THINKING_CONFIGS = {
     off: { ratio: 0, maxBudget: 0 },
     low: { ratio: 0.3, maxBudget: 5000 },
@@ -36,7 +36,7 @@ export const MODELS = {
         id: "claude-haiku-3-5-20241022",
         name: "Claude Haiku 3.5",
         contextWindow: 200000,
-        supportsThinking: false, // Haiku는 thinking 미지원
+        supportsThinking: false,
     },
     sonnet: {
         id: "claude-sonnet-4-20250514",
@@ -51,59 +51,47 @@ export const MODELS = {
         supportsThinking: true,
     },
 };
-// 동적 토큰 계산을 위한 설정
-const MIN_OUTPUT_TOKENS = 4096; // 최소 출력 토큰
-const OUTPUT_BUFFER_RATIO = 0.3; // 컨텍스트의 30%를 출력용으로 예약
+// 동적 토큰 계산 설정
+const MIN_OUTPUT_TOKENS = 4096;
+const OUTPUT_BUFFER_RATIO = 0.3;
 /**
  * 동적으로 max_tokens와 thinking budget 계산
- *
- * @param modelId 모델 ID
- * @param thinkingLevel thinking 레벨
- * @param inputTokens 현재 입력 토큰 수 (시스템 프롬프트 + 히스토리)
- * @returns { maxTokens, thinkingBudget }
  */
 export function calculateTokenBudgets(modelId, thinkingLevel, inputTokens) {
     const model = MODELS[modelId];
     const thinkingConfig = THINKING_CONFIGS[thinkingLevel];
-    // Thinking 미지원 모델이거나 off인 경우
     if (!model.supportsThinking || thinkingLevel === "off") {
-        // 간단히 고정 max_tokens 사용
         return { maxTokens: 8192, thinkingBudget: 0 };
     }
-    // 사용 가능한 출력 토큰 계산
-    // 컨텍스트 윈도우 - 입력 토큰 = 출력 가능 토큰
     const availableOutputTokens = model.contextWindow - inputTokens;
-    // 최소 출력 토큰 보장
     const maxTokens = Math.max(MIN_OUTPUT_TOKENS, Math.floor(availableOutputTokens * OUTPUT_BUFFER_RATIO));
-    // thinking budget 계산: min(레벨별 최대값, max_tokens * 비율)
-    // API 조건: max_tokens > budget_tokens 이므로 max_tokens - 1024 로 상한 설정
     const calculatedBudget = Math.floor(maxTokens * thinkingConfig.ratio);
-    const thinkingBudget = Math.min(thinkingConfig.maxBudget, calculatedBudget, maxTokens - 1024 // max_tokens > budget_tokens 조건 충족
-    );
-    // budget이 1024 미만이면 thinking 비활성화 (의미 없음)
+    const thinkingBudget = Math.min(thinkingConfig.maxBudget, calculatedBudget, maxTokens - 1024);
     if (thinkingBudget < 1024) {
         return { maxTokens, thinkingBudget: 0 };
     }
     return { maxTokens, thinkingBudget };
 }
-export async function chat(messages, systemPrompt, modelId = "sonnet", _thinkingLevel // 사용 안 함 (non-streaming에서 에러 발생)
-) {
+/**
+ * Claude API 호출 (스트리밍 내부 사용, thinking 지원)
+ * - 스트리밍으로 호출하되 최종 응답만 반환 (사용자에게 중간 메시지 안 보냄)
+ * - thinking 활성화 가능
+ * - 도구 사용 시에는 non-streaming으로 폴백 (thinking off)
+ */
+export async function chat(messages, systemPrompt, modelId = "sonnet", thinkingLevel = "medium") {
     const client = getClient();
     const modelConfig = MODELS[modelId];
     const toolsUsed = [];
-    // 메시지를 API 형식으로 변환
     const apiMessages = messages.map((m) => ({
         role: m.role,
         content: m.content,
     }));
-    // 입력 토큰 추정 (대략적)
+    // 입력 토큰 추정
     const estimateInputTokens = () => {
         let total = 0;
-        // 시스템 프롬프트
         if (systemPrompt) {
-            total += Math.ceil(systemPrompt.length / 3); // 대략 3자당 1토큰
+            total += Math.ceil(systemPrompt.length / 3);
         }
-        // 메시지들
         for (const msg of apiMessages) {
             const content = typeof msg.content === "string"
                 ? msg.content
@@ -112,37 +100,65 @@ export async function chat(messages, systemPrompt, modelId = "sonnet", _thinking
         }
         return total;
     };
-    // 토큰 계산 (thinking 비활성화 - non-streaming에서 에러 발생)
     const inputTokens = estimateInputTokens();
-    const maxTokens = 8192;
-    console.log(`[Chat] model=${modelId}, input~${inputTokens}, maxTokens=${maxTokens}`);
-    // API 요청 파라미터 빌드 (도구 루프에서도 동일하게 사용)
-    const buildRequestParams = () => {
+    const { maxTokens, thinkingBudget } = calculateTokenBudgets(modelId, thinkingLevel, inputTokens);
+    console.log(`[Chat] model=${modelId}, thinking=${thinkingLevel}, input~${inputTokens}, maxTokens=${maxTokens}, budget=${thinkingBudget}`);
+    // 스트리밍 호출 (thinking 사용 가능)
+    const streamRequest = async () => {
         const params = {
             model: modelConfig.id,
             max_tokens: maxTokens,
             messages: apiMessages,
             tools: tools,
+            stream: true,
+        };
+        if (systemPrompt) {
+            params.system = systemPrompt;
+        }
+        // thinking 활성화
+        if (thinkingBudget > 0) {
+            params.thinking = {
+                type: "enabled",
+                budget_tokens: thinkingBudget,
+            };
+        }
+        // 스트리밍하되 최종 메시지만 반환
+        const stream = client.messages.stream(params);
+        return await stream.finalMessage();
+    };
+    // Non-streaming 호출 (도구 사용 루프용, thinking off)
+    const nonStreamRequest = async () => {
+        const params = {
+            model: modelConfig.id,
+            max_tokens: 8192,
+            messages: apiMessages,
+            tools: tools,
         };
         if (systemPrompt) {
             params.system = systemPrompt;
         }
-        return params;
+        return await client.messages.create(params);
     };
+    // 첫 번째 호출은 스트리밍 (thinking 사용)
     let response;
-    response = await withRetry(() => withTimeout(() => client.messages.create(buildRequestParams()), API_TIMEOUT_MS, "API 응답 시간 초과"), API_RETRY_OPTIONS);
-    // Tool use 루프 - Claude가 도구 사용을 멈출 때까지 반복
+    try {
+        response = await withRetry(() => withTimeout(streamRequest, API_TIMEOUT_MS, "API 응답 시간 초과"), API_RETRY_OPTIONS);
+    }
+    catch (error) {
+        // 스트리밍 실패 시 non-streaming 폴백
+        console.log("[Chat] Streaming failed, falling back to non-streaming");
+        response = await withRetry(() => withTimeout(nonStreamRequest, API_TIMEOUT_MS, "API 응답 시간 초과"), API_RETRY_OPTIONS);
+    }
+    // Tool use 루프 (non-streaming, thinking off)
     let iterations = 0;
     while (response.stop_reason === "tool_use" && iterations < MAX_TOOL_ITERATIONS) {
         iterations++;
         const toolUseBlocks = response.content.filter((block) => block.type === "tool_use");
-        // 도구 병렬 실행 (성능 최적화)
         console.log(`[Tool] Executing ${toolUseBlocks.length} tool(s) in parallel`);
         const toolExecutions = await Promise.all(toolUseBlocks.map(async (toolUse) => {
             const startTime = Date.now();
-            console.log(`[Tool] ${toolUse.name}:`, JSON.stringify(toolUse.input).slice(0, 200));
+            console.log(`[Tool] ${toolUse.name}:`, JSON.stringify(toolUse.input).slice(0, TOOL_INPUT_SUMMARY_LENGTH));
             try {
-                // 도구별 타임아웃 적용
                 const timeout = getToolTimeout(toolUse.name);
                 const result = await Promise.race([
                     executeTool(toolUse.name, toolUse.input),
@@ -150,32 +166,17 @@ export async function chat(messages, systemPrompt, modelId = "sonnet", _thinking
                 ]);
                 const elapsed = Date.now() - startTime;
                 console.log(`[Tool] ${toolUse.name} completed in ${elapsed}ms`);
-                // 스마트 결과 압축
                 const compressedResult = compressToolResult(toolUse.name, result);
-                return {
-                    toolUse,
-                    result: compressedResult,
-                    success: true,
-                };
+                return { toolUse, result: compressedResult, success: true };
             }
             catch (error) {
                 const elapsed = Date.now() - startTime;
                 const errorMsg = error instanceof Error ? error.message : String(error);
                 console.error(`[Tool] ${toolUse.name} failed after ${elapsed}ms:`, errorMsg);
-                return {
-                    toolUse,
-                    result: `Error: ${errorMsg}`,
-                    success: false,
-                };
+                return { toolUse, result: `Error: ${errorMsg}`, success: false };
             }
         }));
-        // 결과 수집
-        const toolResults = toolExecutions.map((exec) => ({
-            type: "tool_result",
-            tool_use_id: exec.toolUse.id,
-            content: exec.result,
-        }));
-        // 도구 사용 기록
+        // 도구 결과 기록
         for (const exec of toolExecutions) {
             toolsUsed.push({
                 name: exec.toolUse.name,
@@ -183,34 +184,30 @@ export async function chat(messages, systemPrompt, modelId = "sonnet", _thinking
                 output: exec.result.slice(0, TOOL_OUTPUT_SUMMARY_LENGTH),
             });
         }
-        // 어시스턴트 메시지와 도구 결과 추가
+        // 어시스턴트 메시지 추가 (도구 호출)
         apiMessages.push({
             role: "assistant",
             content: response.content,
         });
+        // 도구 결과 메시지 추가
         apiMessages.push({
             role: "user",
-            content: toolResults,
+            content: toolExecutions.map((exec) => ({
+                type: "tool_result",
+                tool_use_id: exec.toolUse.id,
+                content: exec.result,
+            })),
         });
-        // 다음 응답 요청 (도구 루프에서도 thinking 유지)
-        response = await withRetry(() => withTimeout(() => client.messages.create(buildRequestParams()), API_TIMEOUT_MS, "API 응답 시간 초과"), API_RETRY_OPTIONS);
-    }
-    // 반복 횟수 초과 시 경고
-    if (iterations >= MAX_TOOL_ITERATIONS) {
-        console.warn(`[Warning] Tool use loop reached max iterations (${MAX_TOOL_ITERATIONS})`);
-        return { text: "도구 실행이 너무 많이 반복됐어. 다시 시도해줄래?", toolsUsed };
+        // 다음 API 호출 (non-streaming, thinking off - 도구 결과 처리)
+        response = await withRetry(() => withTimeout(nonStreamRequest, API_TIMEOUT_MS, "API 응답 시간 초과"), API_RETRY_OPTIONS);
     }
-    // 최종 텍스트 응답 추출
-    const textBlock = response.content.find((block) => block.type === "text");
-    return {
-        text: textBlock?.text ?? "응답을 생성하지 못했어. 다시 시도해줄래?",
-        toolsUsed
-    };
+    // 최종 텍스트 추출
+    const textBlocks = response.content.filter((block) => block.type === "text");
+    const text = textBlocks.map((b) => b.text).join("\n");
+    return { text, toolsUsed };
 }
 /**
- * 스마트 채팅 - chat()의 단순 래퍼
- *
- * 도구 사용 여부를 별도로 반환하여 호출자가 구분할 수 있게 함
+ * chat()의 간단한 래퍼 - 도구 사용 여부 반환
  */
 export async function chatSmart(messages, systemPrompt, modelId, thinkingLevel = "medium") {
     const result = await chat(messages, systemPrompt, modelId, thinkingLevel);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "companionbot",
-  "version": "0.13.1",
+  "version": "0.14.0",
   "description": "AI 친구 텔레그램 봇 - Claude API 기반 개인화된 대화 상대",
   "keywords": [
     "telegram",