companionbot 0.8.0 → 0.8.2

package/dist/ai/claude.js

@@ -151,6 +151,9 @@ export async function chat(messages, systemPrompt, modelId = "sonnet") {
  * - 먼저 스트리밍으로 시도
  * - 도구 호출이 감지되면 (stop_reason === "tool_use") 기존 chat()으로 폴백
  * - 스트리밍은 최종 텍스트 응답에만 사용
+ *
+ * 주의: 스트리밍은 재시도하지 않음 (이미 전송된 청크를 되돌릴 수 없음)
+ * 스트리밍 중 에러 발생 시 적절한 에러 메시지를 반환하거나 예외를 전파함
  */
 export async function chatSmart(messages, systemPrompt, modelId, onChunk) {
     // 스트리밍 콜백이 없으면 그냥 일반 chat 사용
@@ -179,13 +182,12 @@ export async function chatSmart(messages, systemPrompt, modelId, onChunk) {
     // Thinking은 스트리밍에서 복잡해지므로 일단 비활성화
     // (도구 호출 폴백 시 chat()에서 thinking 사용됨)
     let accumulated = "";
-    let stopReason = null;
-    // 스트리밍에 withRetry 적용 - 실패 시 자동 재시도
-    return await withRetry(async () => {
-        accumulated = ""; // 재시도 시 초기화
+    let streamingStarted = false;
+    try {
         const stream = client.messages.stream(params);
         // 스트리밍 이벤트 처리
         stream.on("text", async (text) => {
+            streamingStarted = true;
             accumulated += text;
             try {
                 await onChunk(text, accumulated);
@@ -197,8 +199,9 @@ export async function chatSmart(messages, systemPrompt, modelId, onChunk) {
         });
         // 스트림 완료 대기
         const finalMessage = await stream.finalMessage();
-        stopReason = finalMessage.stop_reason;
+        const stopReason = finalMessage.stop_reason;
         // 도구 호출이 필요한 경우 - 일반 chat으로 폴백
+        // 주의: chat()은 내부에서 withRetry를 사용하므로 여기서 추가 재시도 불필요
         if (stopReason === "tool_use") {
             console.log("[Stream] Tool use detected, falling back to chat()");
             const text = await chat(messages, systemPrompt, modelId);
@@ -206,5 +209,32 @@ export async function chatSmart(messages, systemPrompt, modelId, onChunk) {
         }
         // 성공적으로 스트리밍 완료
         return { text: accumulated, usedTools: false };
-    });
+    }
+    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 사용 (스트리밍 대신)
+                    const text = await chat(messages, systemPrompt, modelId);
+                    return { text, usedTools: false };
+                });
+            }
+        }
+        // 스트리밍 중 에러 - 재시도 불가 (이미 청크가 전송됨)
+        if (streamingStarted) {
+            console.error("[Stream] Error during streaming (cannot retry):", error);
+            // 이미 일부 텍스트가 전송됐으므로, 에러 메시지를 추가하거나 부분 결과 반환
+            if (accumulated.length > 0) {
+                return {
+                    text: accumulated + "\n\n(응답 생성 중 오류 발생)",
+                    usedTools: false
+                };
+            }
+        }
+        // 그 외 에러는 전파
+        throw error;
+    }
 }

package/dist/session/state.js

@@ -3,7 +3,7 @@ import { estimateMessagesTokens } from "../utils/tokens.js";
 // 세션 설정
 const MAX_SESSIONS = 100;
 const SESSION_TTL_MS = 24 * 60 * 60 * 1000; // 24시간
-const MAX_HISTORY_TOKENS = 50000; // 시스템 프롬프트 + 응답 여유 남기고
+const MAX_HISTORY_TOKENS = 40000; // 시스템 프롬프트(~10k) + 응답(~8k) 여유 남기고
 // 세션별 상태 저장
 const sessions = new Map();
 // AsyncLocalStorage for chatId context
@@ -11,8 +11,8 @@ const chatIdStorage = new AsyncLocalStorage();
 function getSession(chatId) {
     // chatId 유효성 검사
     if (chatId == null || isNaN(chatId)) {
-        console.warn(`[Session] Invalid chatId: ${chatId}, using fallback session`);
-        // 임시 세션 반환 (저장하지 않음)
+        console.error(`[Session] BUG: Invalid chatId: ${chatId} - history will NOT persist!`);
+        // 임시 세션 반환 (저장하지 않음) - 이건 버그 상황
         return {
             history: [],
             model: "sonnet",
@@ -23,6 +23,7 @@ function getSession(chatId) {
     const now = Date.now();
     if (existing) {
         existing.lastAccessedAt = now;
+        console.log(`[Session] Returning existing session for chatId=${chatId}, history length=${existing.history?.length ?? 0}`);
         return existing;
     }
     // 새 세션 생성 전 정리
@@ -33,6 +34,7 @@ function getSession(chatId) {
         lastAccessedAt: now,
     };
     sessions.set(chatId, session);
+    console.log(`[Session] Created new session for chatId=${chatId}, total sessions=${sessions.size}`);
     return session;
 }
 function cleanupSessions() {
@@ -55,9 +57,12 @@ function cleanupSessions() {
 }
 export function getHistory(chatId) {
     const session = getSession(chatId);
+    // history가 없으면 초기화하고 세션에 저장
+    if (!session.history) {
+        session.history = [];
+    }
     // 참조 반환 (외부 수정 허용 - 의도적)
-    // 필요시 [...session.history]로 복사본 반환 가능
-    return session.history ?? [];
+    return session.history;
 }
 /**
  * 히스토리를 토큰 기반으로 트리밍한다.

package/dist/telegram/handlers/commands.js

@@ -141,17 +141,35 @@ export function registerCommands(bot) {
     bot.command("compact", async (ctx) => {
         const chatId = ctx.chat.id;
         const history = getHistory(chatId);
-        if (history.length <= 4) {
+        // 메시지가 1개 이하면 요약 불가
+        if (history.length <= 1) {
             await ctx.reply("아직 정리할 대화가 별로 없어!");
             return;
         }
         // 현재 토큰 수 계산
         const currentTokens = estimateMessagesTokens(history);
+        // 메시지 개수가 적고 토큰도 적으면 스킵 (5000 토큰 = 약 한글 3000자)
+        // 단, 토큰이 많으면 메시지 개수와 관계없이 compact 허용
+        if (history.length <= 4 && currentTokens < 5000) {
+            await ctx.reply(`현재 ${history.length}개 메시지, ~${currentTokens} 토큰이라 충분히 짧아!`);
+            return;
+        }
         await ctx.replyWithChatAction("typing");
         await ctx.reply(`📊 현재: ${history.length}개 메시지, ~${currentTokens} 토큰\n요약 생성 중...`);
         // 요약할 메시지와 유지할 최근 메시지 분리
-        const recentMessages = history.slice(-4);
-        const oldMessages = history.slice(0, -4);
+        // 메시지가 4개 이하면 (토큰이 많아서 여기 온 경우) 전체 요약 후 마지막만 유지
+        let recentMessages;
+        let oldMessages;
+        if (history.length <= 4) {
+            // 토큰이 많아서 compact 진입한 경우: 전체 요약 → 마지막 1개만 유지
+            recentMessages = history.slice(-1);
+            oldMessages = history.slice(0, -1);
+        }
+        else {
+            // 일반 경우: 마지막 4개 유지
+            recentMessages = history.slice(-4);
+            oldMessages = history.slice(0, -4);
+        }
         // 요약 생성
         const summary = await generateSummary(oldMessages);
         // 히스토리 교체: 요약 + 최근 4개

package/dist/telegram/handlers/messages.js

@@ -5,7 +5,7 @@ import { updateLastMessageTime } from "../../heartbeat/index.js";
 import { extractUrls, fetchWebContent, buildSystemPrompt, } from "../utils/index.js";
 import { estimateMessagesTokens } from "../../utils/tokens.js";
 const MAX_CONTEXT_TOKENS = 100000; // Claude 컨텍스트
-const COMPACTION_THRESHOLD = 0.6; // 60%
+const COMPACTION_THRESHOLD = 0.35; // 35% (35,000 토큰) - MAX_HISTORY_TOKENS(50k)보다 먼저 트리거되도록
 /**
  * 토큰 사용량이 임계치를 넘으면 자동으로 히스토리 압축
  * 실패해도 메시지 처리에 영향 없도록 에러를 조용히 처리
@@ -49,41 +49,53 @@ async function sendStreamingResponse(ctx, messages, systemPrompt, modelId) {
     let lastUpdate = Date.now();
     const UPDATE_INTERVAL = 500; // 0.5초마다 업데이트 (Telegram rate limit 고려)
     let lastText = "";
-    const result = await chatSmart(messages, systemPrompt, modelId, async (_chunk, accumulated) => {
-        const now = Date.now();
-        // 0.5초마다 또는 충분히 변경되었을 때 업데이트
-        if (now - lastUpdate > UPDATE_INTERVAL && accumulated !== lastText) {
+    try {
+        const result = await chatSmart(messages, systemPrompt, modelId, async (_chunk, accumulated) => {
+            const now = Date.now();
+            // 0.5초마다 또는 충분히 변경되었을 때 업데이트
+            if (now - lastUpdate > UPDATE_INTERVAL && accumulated !== lastText) {
+                try {
+                    await ctx.api.editMessageText(chatId, messageId, accumulated + " ▌");
+                    lastUpdate = now;
+                    lastText = accumulated;
+                }
+                catch {
+                    // rate limit 등 무시
+                }
+            }
+        });
+        // 도구를 사용한 경우 스트리밍이 안됐으므로 새 응답 전송
+        if (result.usedTools) {
+            // placeholder 메시지를 최종 결과로 교체
             try {
-                await ctx.api.editMessageText(chatId, messageId, accumulated + " ▌");
-                lastUpdate = now;
-                lastText = accumulated;
+                await ctx.api.editMessageText(chatId, messageId, result.text);
             }
             catch {
-                // rate limit 등 무시
+                // 실패시 새 메시지로 전송
+                await ctx.api.deleteMessage(chatId, messageId);
+                await ctx.reply(result.text);
             }
+            return result.text;
         }
-    });
-    // 도구를 사용한 경우 스트리밍이 안됐으므로 새 응답 전송
-    if (result.usedTools) {
-        // placeholder 메시지를 최종 결과로 교체
+        // 최종 메시지 업데이트 (커서 제거)
         try {
             await ctx.api.editMessageText(chatId, messageId, result.text);
         }
         catch {
-            // 실패시 새 메시지로 전송
-            await ctx.api.deleteMessage(chatId, messageId);
-            await ctx.reply(result.text);
+            // 이미 동일 텍스트면 에러 발생 가능 - 무시
         }
         return result.text;
     }
-    // 최종 메시지 업데이트 (커서 제거)
-    try {
-        await ctx.api.editMessageText(chatId, messageId, result.text);
-    }
-    catch {
-        // 이미 동일 텍스트면 에러 발생 가능 - 무시
+    catch (error) {
+        // 에러 발생 시 placeholder 삭제
+        try {
+            await ctx.api.deleteMessage(chatId, messageId);
+        }
+        catch {
+            // 삭제 실패해도 계속 진행
+        }
+        throw error; // 에러 재전파
     }
-    return result.text;
 }
 /**
  * 메시지 핸들러들을 봇에 등록합니다.
@@ -143,16 +155,31 @@ export function registerMessageHandlers(bot) {
                     await ctx.reply(result);
                 }
                 catch (innerError) {
-                    // 에러 시 방금 추가한 사용자 메시지 롤백 (히스토리 오염 방지)
-                    history.pop();
-                    throw innerError;
+                    // 에러 발생해도 사용자 메시지는 보존 (대화 컨텍스트 유지)
+                    // 에러 응답을 assistant로 기록해서 role 교대 유지
+                    const errorMsg = innerError instanceof Error ? innerError.message : String(innerError);
+                    let userErrorMsg;
+                    if (errorMsg.includes("rate limit") || errorMsg.includes("429")) {
+                        userErrorMsg = "지금 요청이 많아서 사진을 분석할 수 없어. 잠시 후 다시 보내줄래?";
+                    }
+                    else if (errorMsg.includes("timeout")) {
+                        userErrorMsg = "사진 분석이 너무 오래 걸렸어. 다시 보내줄래?";
+                    }
+                    else {
+                        userErrorMsg = "사진을 분석하다가 문제가 생겼어. 다시 보내줄래?";
+                    }
+                    history.push({ role: "assistant", content: `[응답 실패] ${userErrorMsg}` });
+                    recordError();
+                    console.error(`[Photo] chatId=${chatId} error:`, errorMsg);
+                    await ctx.reply(userErrorMsg);
+                    return;
                 }
             }
             catch (error) {
+                // 이미지 다운로드 등 history.push() 전 에러는 그냥 응답만
                 recordError();
                 const errorMsg = error instanceof Error ? error.message : String(error);
                 console.error(`[Photo] chatId=${chatId} error:`, errorMsg);
-                // 사용자 친화적 에러 메시지
                 if (errorMsg.includes("rate limit") || errorMsg.includes("429")) {
                     await ctx.reply("지금 요청이 많아서 사진을 분석할 수 없어. 잠시 후 다시 보내줄래?");
                 }
@@ -210,25 +237,28 @@ export function registerMessageHandlers(bot) {
                 await autoCompactIfNeeded(ctx, history);
             }
             catch (error) {
-                // 에러 시 방금 추가한 사용자 메시지 롤백 (히스토리 오염 방지)
-                history.pop();
                 recordError();
                 // 구체적인 에러 로깅
                 const errorMsg = error instanceof Error ? error.message : String(error);
                 console.error(`[Chat] chatId=${chatId} error:`, errorMsg);
-                // 사용자 친화적 에러 메시지
+                // 에러 응답을 assistant로 기록 (사용자 메시지 보존 + role 교대 유지)
+                // 이렇게 하면 에러 발생해도 대화 컨텍스트 유지됨
+                let userErrorMsg;
                 if (errorMsg.includes("rate limit") || errorMsg.includes("429")) {
-                    await ctx.reply("지금 요청이 많아서 잠깐 쉬어야 해. 30초 후에 다시 시도해줄래?");
+                    userErrorMsg = "지금 요청이 많아서 잠깐 쉬어야 해. 30초 후에 다시 시도해줄래?";
                 }
                 else if (errorMsg.includes("timeout") || errorMsg.includes("ETIMEDOUT")) {
-                    await ctx.reply("응답이 너무 오래 걸려서 중단됐어. 다시 시도해줄래?");
+                    userErrorMsg = "응답이 너무 오래 걸려서 중단됐어. 다시 시도해줄래?";
                 }
-                else if (errorMsg.includes("context") || errorMsg.includes("token")) {
-                    await ctx.reply("대화가 너무 길어졌어. /compact 로 정리하고 다시 시도해줘!");
+                else if (errorMsg.includes("context_length") || errorMsg.includes("too many tokens") || errorMsg.includes("maximum context")) {
+                    userErrorMsg = "대화가 너무 길어졌어. /compact 로 정리하고 다시 시도해줘!";
                 }
                 else {
-                    await ctx.reply("메시지 처리 중 문제가 생겼어. 다시 시도해줄래?");
+                    userErrorMsg = `문제가 생겼어: ${errorMsg.slice(0, 100)}`;
                 }
+                // 에러 메시지를 assistant 응답으로 기록 (히스토리 컨텍스트 유지)
+                history.push({ role: "assistant", content: `[응답 실패] ${userErrorMsg}` });
+                await ctx.reply(userErrorMsg);
             }
         });
     });

package/package.json

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