companionbot 0.12.2 → 0.13.1

package/dist/ai/claude.js

@@ -1,4 +1,4 @@
-import Anthropic, { APIError } from "@anthropic-ai/sdk";
+import Anthropic from "@anthropic-ai/sdk";
 import { tools, executeTool } from "../tools/index.js";
 import { MAX_TOOL_ITERATIONS, TOOL_INPUT_SUMMARY_LENGTH, TOOL_OUTPUT_SUMMARY_LENGTH, } from "../utils/constants.js";
 import { withRetry, withTimeout, } from "../utils/retry.js";
@@ -86,7 +86,8 @@ export function calculateTokenBudgets(modelId, thinkingLevel, inputTokens) {
     }
     return { maxTokens, thinkingBudget };
 }
-export async function chat(messages, systemPrompt, modelId = "sonnet", thinkingLevel = "medium") {
+export async function chat(messages, systemPrompt, modelId = "sonnet", _thinkingLevel // 사용 안 함 (non-streaming에서 에러 발생)
+) {
     const client = getClient();
     const modelConfig = MODELS[modelId];
     const toolsUsed = [];
@@ -111,10 +112,10 @@ export async function chat(messages, systemPrompt, modelId = "sonnet", thinkingL
         }
         return total;
     };
-    // 동적 토큰 budget 계산
+    // 토큰 계산 (thinking 비활성화 - non-streaming에서 에러 발생)
     const inputTokens = estimateInputTokens();
-    const { maxTokens, thinkingBudget } = calculateTokenBudgets(modelId, thinkingLevel, inputTokens);
-    console.log(`[Chat] model=${modelId}, thinking=${thinkingLevel}, input~${inputTokens}, maxTokens=${maxTokens}, budget=${thinkingBudget}`);
+    const maxTokens = 8192;
+    console.log(`[Chat] model=${modelId}, input~${inputTokens}, maxTokens=${maxTokens}`);
     // API 요청 파라미터 빌드 (도구 루프에서도 동일하게 사용)
     const buildRequestParams = () => {
         const params = {
@@ -126,13 +127,6 @@ export async function chat(messages, systemPrompt, modelId = "sonnet", thinkingL
         if (systemPrompt) {
             params.system = systemPrompt;
         }
-        // thinking 활성화 (budget > 0인 경우)
-        if (thinkingBudget > 0) {
-            params.thinking = {
-                type: "enabled",
-                budget_tokens: thinkingBudget,
-            };
-        }
         return params;
     };
     let response;
@@ -214,132 +208,15 @@ export async function chat(messages, systemPrompt, modelId = "sonnet", thinkingL
     };
 }
 /**
- * 스마트 채팅 - 가능하면 스트리밍, 도구 필요하면 일반 호출
- *
- * 전략:
- * - 먼저 스트리밍으로 시도
- * - 도구 호출이 감지되면 (stop_reason === "tool_use") 기존 chat()으로 폴백
- * - 스트리밍은 최종 텍스트 응답에만 사용
+ * 스마트 채팅 - chat()의 단순 래퍼
  *
- * 주의: 스트리밍은 재시도하지 않음 (이미 전송된 청크를 되돌릴 수 없음)
- * 스트리밍 중 에러 발생 시 적절한 에러 메시지를 반환하거나 예외를 전파함
+ * 도구 사용 여부를 별도로 반환하여 호출자가 구분할 수 있게 함
  */
-export async function chatSmart(messages, systemPrompt, modelId, thinkingLevel = "medium", onChunk) {
-    // 콜백 정규화
-    const callbacks = typeof onChunk === 'function'
-        ? { onChunk }
-        : (onChunk ?? {});
-    // 스트리밍 콜백이 없으면 그냥 일반 chat 사용
-    if (!callbacks.onChunk) {
-        const result = await chat(messages, systemPrompt, modelId, thinkingLevel);
-        return { text: result.text, usedTools: result.toolsUsed.length > 0, toolsUsed: result.toolsUsed };
-    }
-    const client = getClient();
-    const modelConfig = MODELS[modelId];
-    // 메시지를 API 형식으로 변환
-    const apiMessages = messages.map((m) => ({
-        role: m.role,
-        content: m.content,
-    }));
-    // 입력 토큰 추정
-    let inputTokens = 0;
-    if (systemPrompt) {
-        inputTokens += Math.ceil(systemPrompt.length / 3);
-    }
-    for (const msg of apiMessages) {
-        const content = typeof msg.content === "string"
-            ? msg.content
-            : JSON.stringify(msg.content);
-        inputTokens += Math.ceil(content.length / 3);
-    }
-    // 동적 토큰 budget 계산
-    const { maxTokens, thinkingBudget } = calculateTokenBudgets(modelId, thinkingLevel, inputTokens);
-    console.log(`[ChatSmart] model=${modelId}, thinking=${thinkingLevel}, input~${inputTokens}, maxTokens=${maxTokens}, budget=${thinkingBudget}`);
-    // 스트리밍 요청 파라미터
-    const params = {
-        model: modelConfig.id,
-        max_tokens: maxTokens,
-        messages: apiMessages,
-        tools: tools,
-        stream: true,
+export async function chatSmart(messages, systemPrompt, modelId, thinkingLevel = "medium") {
+    const result = await chat(messages, systemPrompt, modelId, thinkingLevel);
+    return {
+        text: result.text,
+        usedTools: result.toolsUsed.length > 0,
+        toolsUsed: result.toolsUsed
     };
-    if (systemPrompt) {
-        params.system = systemPrompt;
-    }
-    // Thinking 활성화 (스트리밍에서도 지원)
-    if (thinkingBudget > 0) {
-        params.thinking = {
-            type: "enabled",
-            budget_tokens: thinkingBudget,
-        };
-    }
-    let accumulated = "";
-    let streamingStarted = false;
-    try {
-        const stream = client.messages.stream(params);
-        // 스트리밍 이벤트 처리
-        stream.on("text", async (text) => {
-            streamingStarted = true;
-            accumulated += text;
-            try {
-                await callbacks.onChunk(text, accumulated);
-            }
-            catch (err) {
-                // editMessageText 실패 등은 무시하고 계속
-                console.warn("[Stream] Chunk callback error (ignored):", err);
-            }
-        });
-        // 스트림 완료 대기
-        const finalMessage = await stream.finalMessage();
-        const stopReason = finalMessage.stop_reason;
-        // 도구 호출이 필요한 경우 - 일반 chat으로 폴백
-        // 주의: chat()은 내부에서 withRetry를 사용하므로 여기서 추가 재시도 불필요
-        if (stopReason === "tool_use") {
-            console.log("[Stream] Tool use detected, falling back to chat()");
-            // 도구 이름 추출하여 콜백 호출
-            const toolUseBlocks = finalMessage.content.filter((block) => block.type === "tool_use");
-            const toolNames = toolUseBlocks.map(t => t.name);
-            if (callbacks.onToolStart && toolNames.length > 0) {
-                try {
-                    await callbacks.onToolStart(toolNames);
-                }
-                catch (err) {
-                    console.warn("[Stream] Tool start callback error (ignored):", err);
-                }
-            }
-            // 도구 사용 시 thinking 비활성화 (API 에러 방지)
-            const result = await chat(messages, systemPrompt, modelId, "off");
-            return { text: result.text, usedTools: true, toolsUsed: result.toolsUsed };
-        }
-        // 성공적으로 스트리밍 완료
-        return { text: accumulated, usedTools: false, toolsUsed: [] };
-    }
-    catch (error) {
-        // 스트리밍 시작 전 에러 (연결 실패 등) - 재시도 가능
-        if (!streamingStarted && error instanceof APIError) {
-            // Rate limit 또는 서버 에러는 withRetry로 재시도
-            if (error.status === 429 || error.status >= 500) {
-                console.log(`[Stream] Pre-stream error (${error.status}), retrying with withRetry...`);
-                return await withRetry(async () => {
-                    // 재시도 시 일반 chat 사용 (스트리밍 대신, thinking 비활성화)
-                    const result = await chat(messages, systemPrompt, modelId, "off");
-                    return { text: result.text, usedTools: false, toolsUsed: result.toolsUsed };
-                });
-            }
-        }
-        // 스트리밍 중 에러 - 재시도 불가 (이미 청크가 전송됨)
-        if (streamingStarted) {
-            console.error("[Stream] Error during streaming (cannot retry):", error);
-            // 이미 일부 텍스트가 전송됐으므로, 에러 메시지를 추가하거나 부분 결과 반환
-            if (accumulated.length > 0) {
-                return {
-                    text: accumulated + "\n\n(응답 생성 중 오류 발생)",
-                    usedTools: false,
-                    toolsUsed: []
-                };
-            }
-        }
-        // 그 외 에러는 전파
-        throw error;
-    }
 }

package/dist/config/constants.js

@@ -70,19 +70,6 @@ export const MEMORY = {
 // 텔레그램/UI 관련 설정
 // ============================================
 export const TELEGRAM = {
-    /** 스트리밍 업데이트 간격 - 적응형 (밀리초) */
-    STREAM_UPDATE_INTERVAL_MS: 500, // 레거시 호환용
-    /** 스트리밍 적응형 간격 설정 */
-    STREAM_INTERVAL: {
-        /** 첫 번째 업데이트 (즉시) */
-        FIRST_MS: 0,
-        /** 초기 빠른 업데이트 (처음 5회) */
-        FAST_MS: 200,
-        /** 이후 일반 간격 */
-        NORMAL_MS: 400,
-        /** 빠른 업데이트 횟수 */
-        FAST_COUNT: 5,
-    },
     /** 텔레그램 메시지 최대 길이 */
     MAX_MESSAGE_LENGTH: 4096,
     /** 최대 이미지 크기 (바이트) - 10MB */
@@ -91,60 +78,8 @@ export const TELEGRAM = {
     MAX_URL_FETCH: 3,
     /** 캘린더 미리보기 이벤트 수 */
     CALENDAR_PREVIEW_COUNT: 3,
-    /** 스트리밍 UI 아이콘 */
-    STREAM_ICONS: {
-        THINKING: "💭",
-        TYPING: "▌",
-        TOOL: "🔧",
-        DONE: "",
-    },
     /** Typing indicator 자동 갱신 간격 (밀리초) - 텔레그램은 5초 후 만료 */
     TYPING_REFRESH_MS: 4000,
-    /** 도구별 친화적 상태 메시지 */
-    TOOL_STATUS_MESSAGES: {
-        // 검색/정보 조회
-        web_search: { icon: "🔍", text: "웹에서 검색하는 중", estimate: "5-10초" },
-        web_fetch: { icon: "📄", text: "웹페이지 읽는 중", estimate: "3-5초" },
-        get_weather: { icon: "🌤️", text: "날씨 확인 중", estimate: "2-3초" },
-        memory_search: { icon: "🧠", text: "기억 검색 중", estimate: "1-2초" },
-        memory_reindex: { icon: "🧠", text: "기억 재색인 중", estimate: "10-30초" },
-        // 파일 작업
-        read_file: { icon: "📖", text: "파일 읽는 중", estimate: "1초" },
-        write_file: { icon: "✍️", text: "파일 쓰는 중", estimate: "1초" },
-        edit_file: { icon: "✏️", text: "파일 수정 중", estimate: "1초" },
-        list_directory: { icon: "📁", text: "폴더 살펴보는 중", estimate: "1초" },
-        // 명령어 실행
-        run_command: { icon: "⚡", text: "명령어 실행 중", estimate: "변동" },
-        list_sessions: { icon: "📋", text: "세션 목록 확인 중", estimate: "1초" },
-        get_session_log: { icon: "📜", text: "로그 가져오는 중", estimate: "1초" },
-        kill_session: { icon: "🛑", text: "세션 종료 중", estimate: "1초" },
-        // 일정/리마인더
-        get_calendar_events: { icon: "📅", text: "일정 확인 중", estimate: "2-3초" },
-        add_calendar_event: { icon: "📅", text: "일정 추가 중", estimate: "2-3초" },
-        delete_calendar_event: { icon: "📅", text: "일정 삭제 중", estimate: "2초" },
-        set_reminder: { icon: "⏰", text: "알림 설정 중", estimate: "1초" },
-        list_reminders: { icon: "⏰", text: "알림 목록 확인 중", estimate: "1초" },
-        cancel_reminder: { icon: "⏰", text: "알림 취소 중", estimate: "1초" },
-        // 브리핑/하트비트
-        control_briefing: { icon: "☀️", text: "브리핑 설정 중", estimate: "1초" },
-        send_briefing_now: { icon: "☀️", text: "브리핑 준비 중", estimate: "5-10초" },
-        control_heartbeat: { icon: "💓", text: "하트비트 설정 중", estimate: "1초" },
-        run_heartbeat_check: { icon: "💓", text: "체크 실행 중", estimate: "3-5초" },
-        // 서브에이전트
-        spawn_agent: { icon: "🤖", text: "서브에이전트 생성 중", estimate: "2-3초" },
-        list_agents: { icon: "🤖", text: "에이전트 목록 확인 중", estimate: "1초" },
-        cancel_agent: { icon: "🤖", text: "에이전트 취소 중", estimate: "1초" },
-        // Cron
-        add_cron: { icon: "🕐", text: "예약 작업 추가 중", estimate: "1초" },
-        list_crons: { icon: "🕐", text: "예약 작업 확인 중", estimate: "1초" },
-        remove_cron: { icon: "🕐", text: "예약 작업 삭제 중", estimate: "1초" },
-        toggle_cron: { icon: "🕐", text: "예약 작업 설정 중", estimate: "1초" },
-        run_cron: { icon: "🕐", text: "예약 작업 실행 중", estimate: "변동" },
-        // 기타
-        change_model: { icon: "🔄", text: "모델 변경 중", estimate: "1초" },
-        save_memory: { icon: "💾", text: "기억 저장 중", estimate: "1초" },
-        save_persona: { icon: "✨", text: "페르소나 저장 중", estimate: "2초" },
-    },
 };
 // ============================================
 // 보안/토큰 관련 설정

package/dist/telegram/handlers/messages.js

@@ -7,29 +7,6 @@ import { extractUrls, fetchWebContent, formatUrlContent, buildSystemPrompt, } fr
 import { estimateMessagesTokens } from "../../utils/tokens.js";
 import { TOKENS, TELEGRAM } from "../../config/constants.js";
 import { toUserFriendlyError } from "../../utils/retry.js";
-/**
- * 도구 이름을 친화적인 상태 메시지로 변환
- */
-function getToolStatusMessage(toolName) {
-    const messages = TELEGRAM.TOOL_STATUS_MESSAGES;
-    return messages[toolName] || { icon: "🔧", text: toolName, estimate: "" };
-}
-/**
- * 여러 도구의 상태를 친화적인 메시지로 포맷
- */
-function formatToolsStatus(toolNames) {
-    if (toolNames.length === 0)
-        return "";
-    if (toolNames.length === 1) {
-        const status = getToolStatusMessage(toolNames[0]);
-        const estimateText = status.estimate ? ` (약 ${status.estimate})` : "";
-        return `${status.icon} ${status.text}...${estimateText}`;
-    }
-    // 여러 도구: 아이콘만 모아서 표시 + 첫 번째 도구 텍스트
-    const icons = toolNames.map(t => getToolStatusMessage(t).icon).join(" ");
-    const firstStatus = getToolStatusMessage(toolNames[0]);
-    return `${icons} ${firstStatus.text} 외 ${toolNames.length - 1}개...`;
-}
 /**
  * Typing indicator를 주기적으로 갱신하는 클래스
  * 텔레그램은 5초 후 typing 상태가 자동 해제되므로, 긴 작업 중 유지 필요
@@ -134,161 +111,12 @@ function splitLongMessage(text, maxLength = TELEGRAM.MAX_MESSAGE_LENGTH) {
     return parts;
 }
 /**
- * 스트리밍 응답 전송 (Telegram 메시지 실시간 업데이트)
- *
- * 개선사항:
- * - 적응형 업데이트 간격 (첫 응답 빠르게, 이후 안정화)
- * - 도구 사용 시 친화적인 상태 메시지 표시
- * - 긴 응답 자동 분할
- * - thinking 상태 표시
- * - 진행 단계 표시 (생각 중 → 도구 사용 → 응답 작성)
+ * 응답을 전송 (긴 응답은 분할)
  */
-async function sendStreamingResponse(ctx, messages, systemPrompt, modelId, thinkingLevel) {
-    const { STREAM_INTERVAL, STREAM_ICONS, MAX_MESSAGE_LENGTH } = TELEGRAM;
-    // 1. thinking 표시로 시작 + 단계 안내
-    const initialText = thinkingLevel !== "off"
-        ? `${STREAM_ICONS.THINKING} 생각하는 중...`
-        : `${STREAM_ICONS.THINKING} 응답 준비 중...`;
-    const placeholder = await ctx.reply(initialText);
-    const chatId = ctx.chat.id;
-    const messageId = placeholder.message_id;
-    let lastUpdate = 0; // 첫 업데이트는 즉시
-    let updateCount = 0;
-    let lastText = "";
-    let currentPhase = "thinking";
-    let toolStartTime = 0;
-    let currentToolNames = [];
-    // 적응형 간격 계산
-    const getInterval = () => {
-        if (updateCount === 0)
-            return STREAM_INTERVAL.FIRST_MS;
-        if (updateCount <= STREAM_INTERVAL.FAST_COUNT)
-            return STREAM_INTERVAL.FAST_MS;
-        return STREAM_INTERVAL.NORMAL_MS;
-    };
-    // 도구 실행 시간이 길어지면 추가 피드백
-    let toolTimeoutId = null;
-    const startToolTimeout = async () => {
-        toolTimeoutId = setTimeout(async () => {
-            if (currentPhase === "tools" && currentToolNames.length > 0) {
-                const elapsed = Math.round((Date.now() - toolStartTime) / 1000);
-                const statusMsg = formatToolsStatus(currentToolNames);
-                try {
-                    await ctx.api.editMessageText(chatId, messageId, `${statusMsg}\n⏳ ${elapsed}초 경과... 조금만 기다려줘!`);
-                }
-                catch {
-                    // 무시
-                }
-            }
-        }, 5000); // 5초 후 추가 피드백
-    };
-    const clearToolTimeout = () => {
-        if (toolTimeoutId) {
-            clearTimeout(toolTimeoutId);
-            toolTimeoutId = null;
-        }
-    };
-    try {
-        const streamCallbacks = {
-            onChunk: async (_chunk, accumulated) => {
-                // 첫 청크 도착 시 thinking → generating 단계 전환
-                if (currentPhase === "thinking" && accumulated.length > 0) {
-                    currentPhase = "generating";
-                }
-                const now = Date.now();
-                const interval = getInterval();
-                // 간격 체크 + 실제 변경 있을 때만 업데이트
-                if (now - lastUpdate >= interval && accumulated !== lastText) {
-                    // 텔레그램 제한 초과 시 잘라서 표시
-                    const displayText = accumulated.length > MAX_MESSAGE_LENGTH - 10
-                        ? accumulated.slice(0, MAX_MESSAGE_LENGTH - 20) + "\n…(계속)"
-                        : accumulated;
-                    try {
-                        await ctx.api.editMessageText(chatId, messageId, displayText + " " + STREAM_ICONS.TYPING);
-                        lastUpdate = now;
-                        lastText = accumulated;
-                        updateCount++;
-                    }
-                    catch {
-                        // rate limit 등 무시 - 다음 chunk에서 재시도
-                    }
-                }
-            },
-            onToolStart: async (toolNames) => {
-                currentPhase = "tools";
-                currentToolNames = toolNames;
-                toolStartTime = Date.now();
-                // 친화적인 도구 상태 메시지 생성
-                const statusMsg = formatToolsStatus(toolNames);
-                try {
-                    await ctx.api.editMessageText(chatId, messageId, statusMsg);
-                }
-                catch {
-                    // 무시
-                }
-                // 5초 후 추가 피드백 예약
-                startToolTimeout();
-            },
-        };
-        const result = await chatSmart(messages, systemPrompt, modelId, thinkingLevel, streamCallbacks);
-        // 도구 타임아웃 정리
-        clearToolTimeout();
-        // 도구를 사용한 경우 
-        if (result.usedTools) {
-            // 도구 사용 정보를 친화적으로 표시
-            const toolSummary = result.toolsUsed.map(t => {
-                const status = getToolStatusMessage(t.name);
-                return `${status.icon} ${status.text}`;
-            }).join("\n");
-            const toolIndicator = `${toolSummary}\n\n`;
-            const finalText = toolIndicator + result.text;
-            // 긴 응답 분할 처리
-            const parts = splitLongMessage(finalText);
-            try {
-                // 첫 번째 파트로 placeholder 교체
-                await ctx.api.editMessageText(chatId, messageId, parts[0]);
-                // 추가 파트가 있으면 새 메시지로 전송
-                for (let i = 1; i < parts.length; i++) {
-                    await ctx.reply(parts[i]);
-                }
-            }
-            catch {
-                // 실패시 placeholder 삭제 후 새로 전송
-                try {
-                    await ctx.api.deleteMessage(chatId, messageId);
-                }
-                catch { }
-                for (const part of parts) {
-                    await ctx.reply(part);
-                }
-            }
-            return result.text;
-        }
-        // 최종 메시지 업데이트 (커서 제거) + 긴 응답 분할
-        const parts = splitLongMessage(result.text);
-        try {
-            await ctx.api.editMessageText(chatId, messageId, parts[0]);
-            // 추가 파트 전송
-            for (let i = 1; i < parts.length; i++) {
-                await ctx.reply(parts[i]);
-            }
-        }
-        catch {
-            // 이미 동일 텍스트면 에러 발생 가능 - 무시
-        }
-        return result.text;
-    }
-    catch (error) {
-        // 도구 타임아웃 정리
-        clearToolTimeout();
-        // 에러 발생 시 placeholder 삭제
-        try {
-            await ctx.api.deleteMessage(chatId, messageId);
-        }
-        catch {
-            // 삭제 실패해도 계속 진행
-        }
-        throw error; // 에러 재전파
+async function sendResponse(ctx, text) {
+    const parts = splitLongMessage(text);
+    for (const part of parts) {
+        await ctx.reply(part);
     }
 }
 /**
@@ -437,6 +265,9 @@ export function registerMessageHandlers(bot) {
             }
             // 히스토리에는 간략 버전 저장 + JSONL에 영구 저장
             addMessage(chatId, "user", messageForHistory);
+            // Typing indicator 시작 (긴 작업 동안 유지)
+            const typingIndicator = new TypingIndicator(ctx);
+            typingIndicator.start();
             try {
                 const systemPrompt = await buildSystemPrompt(modelId, history);
                 // API 호출용 메시지 준비 (URL 전체 내용 포함)
@@ -452,11 +283,13 @@ export function registerMessageHandlers(bot) {
                         };
                     }
                 }
-                // 스트리밍 응답 사용 (실시간 업데이트)
-                const response = await sendStreamingResponse(ctx, messagesForApi, // URL 내용이 포함된 버전
-                systemPrompt, modelId, thinkingLevel);
+                // AI 응답 생성 (typing indicator 동안)
+                const result = await chatSmart(messagesForApi, systemPrompt, modelId, thinkingLevel);
+                typingIndicator.stop();
+                // 응답 전송 (긴 응답은 분할)
+                await sendResponse(ctx, result.text);
                 // 메모리 + JSONL에 영구 저장
-                addMessage(chatId, "assistant", response);
+                addMessage(chatId, "assistant", result.text);
                 // 스마트 트리밍 (요약 포함) - autoCompactIfNeeded 대체
                 const summarizeFn = async (messages) => {
                     const summaryPrompt = "다음 대화를 핵심만 3-4문장으로 요약해. 중요한 정보(이름, 선호도, 약속 등)는 반드시 포함:\n\n" +
@@ -473,6 +306,7 @@ export function registerMessageHandlers(bot) {
                 }
             }
             catch (error) {
+                typingIndicator.stop();
                 recordError();
                 // 에러를 사용자 친화적 메시지로 변환
                 const friendlyError = toUserFriendlyError(error);

package/package.json

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