chatccc 0.2.3 → 0.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chatccc",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "Feishu bot bridge for Claude Code",
   "license": "Apache-2.0",
   "type": "module",
@@ -23,7 +23,9 @@
     "demo:create-group": "tsx --env-file=.env src/index.ts",
     "demo:create-group:local": "tsx --env-file=.env src/index.ts --local",
     "demo:permission-check": "tsx --env-file=.env demo/permission_check.ts",
-    "demo:claude-hi": "tsx --env-file=.env demo/claude_say_hi.ts"
+    "demo:claude-hi": "tsx --env-file=.env demo/claude_say_hi.ts",
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.2.133",
@@ -34,7 +36,8 @@
   "devDependencies": {
     "@types/node": "^20.0.0",
     "@types/ws": "^8.18.1",
-    "typescript": "^5.0.0"
+    "typescript": "^5.0.0",
+    "vitest": "^4.1.5"
   },
   "engines": {
     "node": ">=20"

package/src/__tests__/cards.test.ts

@@ -0,0 +1,297 @@
+import { describe, it, expect } from "vitest";
+import {
+  buildProgressCard,
+  buildHelpCard,
+  buildCdContent,
+  buildSessionsCard,
+  buildStatusCard,
+  buildButtons,
+  truncateContent,
+  getToolEmoji,
+} from "../cards.ts";
+
+// ---------------------------------------------------------------------------
+// truncateContent
+// ---------------------------------------------------------------------------
+
+describe("truncateContent", () => {
+  it("returns original text when under limits", () => {
+    expect(truncateContent("hello")).toBe("hello");
+  });
+
+  it("truncates lines when exceeding maxLines (default 20)", () => {
+    const lines = Array.from({ length: 25 }, (_, i) => `line ${i + 1}`);
+    const text = lines.join("\n");
+    const result = truncateContent(text);
+    const resultLines = result.split("\n");
+    expect(resultLines.length).toBe(21); // 1 first + 1 "..." + 19 last
+    expect(resultLines[0]).toBe("line 1");
+    expect(resultLines[1]).toBe("...");
+    expect(resultLines[2]).toBe("line 7");
+    expect(resultLines[20]).toBe("line 25");
+  });
+
+  it("truncates chars when exceeding maxChars", () => {
+    const long = "x".repeat(9000);
+    const result = truncateContent(long, 100, 500);
+    expect(result.length).toBeLessThanOrEqual(503); // "..." + 500 chars
+    expect(result.startsWith("...")).toBe(true);
+  });
+
+  it("returns empty string for empty input", () => {
+    expect(truncateContent("")).toBe("");
+  });
+
+  it("respects custom maxLines and maxChars", () => {
+    const lines = Array.from({ length: 10 }, (_, i) => `line ${i + 1}`);
+    const text = lines.join("\n");
+    const result = truncateContent(text, 5, 1000);
+    const resultLines = result.split("\n");
+    expect(resultLines[0]).toBe("line 1");
+    expect(resultLines[1]).toBe("...");
+    expect(resultLines[resultLines.length - 1]).toBe("line 10");
+    expect(resultLines.length).toBe(6); // 1 first + "..." + 4 last
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getToolEmoji
+// ---------------------------------------------------------------------------
+
+describe("getToolEmoji", () => {
+  it("returns correct emoji for each known tool name", () => {
+    expect(getToolEmoji("Read")).toBe("\u{1F4D6}");          // 📖
+    expect(getToolEmoji("Write")).toBe("\u{270D}\u{FE0F}");  // ✍️
+    expect(getToolEmoji("Edit")).toBe("\u{270F}\u{FE0F}");   // ✏️
+    expect(getToolEmoji("Grep")).toBe("\u{1F50E}");          // 🔎
+    expect(getToolEmoji("Glob")).toBe("\u{1F4C2}");          // 📂
+    expect(getToolEmoji("Bash")).toBe("\u{1F5A5}\u{FE0F}");  // 🖥️
+    expect(getToolEmoji("WebSearch")).toBe("\u{1F310}");     // 🌐
+    expect(getToolEmoji("WebFetch")).toBe("\u{1F4E5}");      // 📥
+    expect(getToolEmoji("TodoWrite")).toBe("\u{2705}");      // ✅
+    expect(getToolEmoji("Agent")).toBe("\u{1F916}");         // 🤖
+    expect(getToolEmoji("NotebookEdit")).toBe("\u{1F4D3}");  // 📓
+    expect(getToolEmoji("AskUserQuestion")).toBe("\u{2753}");// ❓
+  });
+
+  it("returns wrench for unknown tool names", () => {
+    expect(getToolEmoji("UnknownTool")).toBe("\u{1F527}");
+    expect(getToolEmoji("cat")).toBe("\u{1F527}");
+    expect(getToolEmoji("")).toBe("\u{1F527}");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// buildProgressCard
+// ---------------------------------------------------------------------------
+
+describe("buildProgressCard", () => {
+  it("returns valid JSON with correct schema", () => {
+    const card = buildProgressCard("test content");
+    const parsed = JSON.parse(card);
+    expect(parsed.schema).toBe("2.0");
+    expect(parsed.config.update_multi).toBe(true);
+    expect(parsed.config.streaming_mode).toBe(false);
+  });
+
+  it("uses default header title '生成中...'", () => {
+    const card = buildProgressCard("hello");
+    const parsed = JSON.parse(card);
+    expect(parsed.header.title.content).toBe("生成中...");
+    expect(parsed.header.template).toBe("blue");
+  });
+
+  it("includes stop button by default", () => {
+    const card = buildProgressCard("hello");
+    const parsed = JSON.parse(card);
+    const buttons = parsed.body.elements.filter((e: any) => e.tag === "button");
+    expect(buttons).toHaveLength(2);
+    expect(buttons[0].text.content).toBe("查看状态（/status）");
+    expect(buttons[1].text.content).toBe("停止生成（/stop）");
+  });
+
+  it("hides stop button when showStop is false", () => {
+    const card = buildProgressCard("hello", { showStop: false });
+    const parsed = JSON.parse(card);
+    const buttons = parsed.body.elements.filter((e: any) => e.tag === "button");
+    expect(buttons).toHaveLength(0);
+  });
+
+  it("uses custom header title and template", () => {
+    const card = buildProgressCard("hello", { headerTitle: "已完成", headerTemplate: "green" });
+    const parsed = JSON.parse(card);
+    expect(parsed.header.title.content).toBe("已完成");
+    expect(parsed.header.template).toBe("green");
+  });
+
+  it("includes markdown element with truncated content", () => {
+    const card = buildProgressCard("markdown text");
+    const parsed = JSON.parse(card);
+    const md = parsed.body.elements.find((e: any) => e.tag === "markdown");
+    expect(md).toBeDefined();
+    expect(md.element_id).toBe("main_content");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// buildHelpCard
+// ---------------------------------------------------------------------------
+
+describe("buildHelpCard", () => {
+  it("returns valid JSON with user text", () => {
+    const card = buildHelpCard("你好");
+    const parsed = JSON.parse(card);
+    expect(parsed.header.title.content).toBe("ChatCCC");
+    expect(parsed.elements[0].text.content).toContain("你好");
+  });
+
+  it("includes action buttons", () => {
+    const card = buildHelpCard("test");
+    const parsed = JSON.parse(card);
+    const action = parsed.elements[1];
+    expect(action.tag).toBe("action");
+    expect(action.actions).toHaveLength(3);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// buildCdContent
+// ---------------------------------------------------------------------------
+
+describe("buildCdContent", () => {
+  const entries = [
+    { name: "src", isDir: true },
+    { name: "README.md", isDir: false },
+    { name: "package.json", isDir: false },
+  ];
+
+  it("returns markdown with path and listing", () => {
+    const content = buildCdContent("/home/user/project", entries, false);
+    expect(content).toContain("/home/user/project");
+    expect(content).toContain("📁 src/");
+    expect(content).toContain("📄 README.md");
+    expect(content).toContain("📄 package.json");
+  });
+
+  it("shows 已切换 when isUpdate is true", () => {
+    const content = buildCdContent("/home/user/project", entries, true);
+    expect(content).toContain("（已切换）");
+  });
+
+  it("shows currentCwd when provided", () => {
+    const content = buildCdContent("/new/path", entries, false, "/old/path");
+    expect(content).toContain("当前会话工作路径");
+    expect(content).toContain("/old/path");
+  });
+
+  it("omits currentCwd line when not provided", () => {
+    const content = buildCdContent("/new/path", entries, false);
+    expect(content).not.toContain("当前会话工作路径");
+  });
+
+  it("caps listing at maxFiles", () => {
+    const many = Array.from({ length: 150 }, (_, i) => ({
+      name: `file${i}.txt`,
+      isDir: false,
+    }));
+    const content = buildCdContent("/path", many, false);
+    expect(content).toContain("仅显示前 100 个");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// buildSessionsCard
+// ---------------------------------------------------------------------------
+
+describe("buildSessionsCard", () => {
+  it("returns valid JSON for empty sessions", () => {
+    const card = buildSessionsCard([]);
+    const parsed = JSON.parse(card);
+    expect(parsed.elements[0].text.content).toContain("没有会话记录");
+  });
+
+  it("returns valid JSON with session listing", () => {
+    const card = buildSessionsCard([
+      { sessionId: "abc123", active: true, turnCount: 5, elapsedSeconds: 120, model: "Claude Opus 4.7" },
+    ]);
+    const parsed = JSON.parse(card);
+    expect(parsed.elements[0].text.content).toContain("共 **1** 个会话");
+    expect(parsed.elements[0].text.content).toContain("abc123");
+    expect(parsed.elements[0].text.content).toContain("🟢 活跃");
+  });
+
+  it("shows idle status for inactive sessions", () => {
+    const card = buildSessionsCard([
+      { sessionId: "xyz", active: false, turnCount: 0, elapsedSeconds: null, model: "Claude Sonnet 4.6" },
+    ]);
+    const parsed = JSON.parse(card);
+    expect(parsed.elements[0].text.content).toContain("⚪ 空闲");
+  });
+
+  it("shows elapsed time for active sessions", () => {
+    const card = buildSessionsCard([
+      { sessionId: "active123", active: true, turnCount: 3, elapsedSeconds: 95, model: "Claude Opus 4.7" },
+    ]);
+    const parsed = JSON.parse(card);
+    expect(parsed.elements[0].text.content).toContain("1分35秒");
+  });
+
+  it("includes close button", () => {
+    const card = buildSessionsCard([]);
+    const parsed = JSON.parse(card);
+    const action = parsed.elements[2];
+    expect(action.actions[0].text.content).toBe("收起");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// buildStatusCard
+// ---------------------------------------------------------------------------
+
+describe("buildStatusCard", () => {
+  it("returns valid JSON with status text", () => {
+    const card = buildStatusCard("一切正常");
+    const parsed = JSON.parse(card);
+    expect(parsed.header.title.content).toBe("会话状态");
+    expect(parsed.elements[0].text.content).toBe("一切正常");
+  });
+
+  it("uses custom template color", () => {
+    const card = buildStatusCard("警告", "red");
+    const parsed = JSON.parse(card);
+    expect(parsed.header.template).toBe("red");
+  });
+
+  it("includes close button", () => {
+    const card = buildStatusCard("test");
+    const parsed = JSON.parse(card);
+    const action = parsed.elements[2];
+    expect(action.actions[0].text.content).toBe("收起");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// buildButtons
+// ---------------------------------------------------------------------------
+
+describe("buildButtons", () => {
+  it("returns action with buttons", () => {
+    const result = buildButtons([
+      { text: "确认", value: "ok", type: "primary" },
+    ]);
+    const obj = result as any;
+    expect(obj.tag).toBe("action");
+    expect(obj.actions).toHaveLength(1);
+    expect(obj.actions[0].text.content).toBe("确认");
+    expect(obj.actions[0].type).toBe("primary");
+    expect(obj.actions[0].value).toBe("ok");
+  });
+
+  it("defaults button type to primary", () => {
+    const result = buildButtons([
+      { text: "取消", value: "cancel" },
+    ]);
+    const obj = result as any;
+    expect(obj.actions[0].type).toBe("primary");
+  });
+});

package/src/__tests__/session.test.ts

@@ -0,0 +1,151 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  chatSessionMap,
+  sessionInfoMap,
+  processedMessages,
+  MAX_PROCESSED,
+  resetState,
+  getSessionStatus,
+  getAllSessionsStatus,
+} from "../session.ts";
+
+// Helper to create a mock active session entry
+function mockActiveSession(chatId: string, overrides: Partial<{
+  accumulatedContent: string;
+  finalText: string;
+  stopped: boolean;
+}> = {}) {
+  chatSessionMap.set(chatId, {
+    gen: 1,
+    close: () => {},
+    cardId: null,
+    stopped: overrides.stopped ?? false,
+    accumulatedContent: overrides.accumulatedContent ?? "thinking...",
+    finalText: overrides.finalText ?? "",
+    spinnerTimer: null,
+    msgTimestamp: Date.now(),
+    sequence: 0,
+    cardBusy: false,
+  });
+}
+
+function mockSessionInfo(chatId: string, overrides: Partial<{
+  sessionId: string;
+  turnCount: number;
+  lastContextTokens: number;
+  startTime: number;
+}> = {}) {
+  sessionInfoMap.set(chatId, {
+    sessionId: overrides.sessionId ?? "test-session-id",
+    turnCount: overrides.turnCount ?? 3,
+    lastContextTokens: overrides.lastContextTokens ?? 50000,
+    startTime: overrides.startTime ?? Date.now(),
+    model: "Claude Opus 4.7",
+    effort: "high",
+  });
+}
+
+describe("resetState", () => {
+  it("clears all maps and sets", () => {
+    chatSessionMap.set("chat1", {
+      gen: 1, close: () => {}, cardId: null, stopped: false,
+      accumulatedContent: "", finalText: "", spinnerTimer: null,
+      msgTimestamp: 0, sequence: 0, cardBusy: false,
+    });
+    sessionInfoMap.set("chat1", {
+      sessionId: "s1", turnCount: 1, lastContextTokens: 0,
+      startTime: 0, model: "", effort: "",
+    });
+    processedMessages.add("msg1");
+
+    resetState();
+
+    expect(chatSessionMap.size).toBe(0);
+    expect(sessionInfoMap.size).toBe(0);
+    expect(processedMessages.size).toBe(0);
+  });
+});
+
+describe("getSessionStatus", () => {
+  beforeEach(() => {
+    chatSessionMap.clear();
+    sessionInfoMap.clear();
+  });
+
+  it("returns null for unknown chatId", () => {
+    expect(getSessionStatus("nonexistent")).toBeNull();
+  });
+
+  it("returns status for idle session (info exists, no active session)", () => {
+    mockSessionInfo("chat1");
+    const status = getSessionStatus("chat1");
+    expect(status).not.toBeNull();
+    expect(status!.sessionId).toBe("test-session-id");
+    expect(status!.running).toBe(false);
+    expect(status!.turnCount).toBe(3);
+    expect(status!.accumulatedLength).toBe(0);
+  });
+
+  it("returns running=true for active session", () => {
+    mockSessionInfo("chat1");
+    mockActiveSession("chat1", { accumulatedContent: "thinking...", finalText: "reply" });
+    const status = getSessionStatus("chat1");
+    expect(status!.running).toBe(true);
+    expect(status!.accumulatedLength).toBe(16); // "thinking..."(11) + "reply"(5)
+  });
+
+  it("returns running=false for stopped session", () => {
+    mockSessionInfo("chat1");
+    mockActiveSession("chat1", { stopped: true });
+    const status = getSessionStatus("chat1");
+    expect(status!.running).toBe(false);
+  });
+
+  it("returns correct turnCount and other info fields", () => {
+    mockSessionInfo("chat1", { turnCount: 7, lastContextTokens: 100000 });
+    const status = getSessionStatus("chat1");
+    expect(status!.turnCount).toBe(7);
+    expect(status!.lastContextTokens).toBe(100000);
+  });
+});
+
+describe("getAllSessionsStatus", () => {
+  beforeEach(() => {
+    chatSessionMap.clear();
+    sessionInfoMap.clear();
+  });
+
+  it("returns empty array when no sessions", () => {
+    expect(getAllSessionsStatus()).toEqual([]);
+  });
+
+  it("returns statuses for all recorded sessions", () => {
+    mockSessionInfo("chat1", { sessionId: "s1" });
+    mockSessionInfo("chat2", { sessionId: "s2" });
+    mockActiveSession("chat1");
+    const result = getAllSessionsStatus();
+    expect(result).toHaveLength(2);
+    expect(result.find(r => r.chatId === "chat1")!.active).toBe(true);
+    expect(result.find(r => r.chatId === "chat2")!.active).toBe(false);
+  });
+
+  it("marks stopped sessions as not active", () => {
+    mockSessionInfo("chat1");
+    mockActiveSession("chat1", { stopped: true });
+    const result = getAllSessionsStatus();
+    expect(result[0].active).toBe(false);
+  });
+});
+
+describe("processedMessages dedup", () => {
+  it("supports add/has semantics", () => {
+    processedMessages.clear();
+    processedMessages.add("msg_001");
+    expect(processedMessages.has("msg_001")).toBe(true);
+    expect(processedMessages.has("msg_002")).toBe(false);
+  });
+
+  it("MAX_PROCESSED is defined", () => {
+    expect(MAX_PROCESSED).toBe(5000);
+  });
+});

package/src/cards.ts

@@ -42,35 +42,37 @@ export function truncateContent(text: string, maxLines = 20, maxChars = 8000): s
   return displayText;
 }
 
+const TOOL_EMOJI_MAP: Record<string, string> = {
+  Read: "\u{1F4D6}",          // 📖
+  Write: "\u{270D}\u{FE0F}",  // ✍️
+  Edit: "\u{270F}\u{FE0F}",   // ✏️
+  Grep: "\u{1F50E}",          // 🔎
+  Glob: "\u{1F4C2}",          // 📂
+  Bash: "\u{1F5A5}\u{FE0F}",  // 🖥️
+  WebSearch: "\u{1F310}",     // 🌐
+  WebFetch: "\u{1F4E5}",      // 📥
+  TodoWrite: "\u{2705}",      // ✅
+  Agent: "\u{1F916}",         // 🤖
+  NotebookEdit: "\u{1F4D3}",  // 📓
+  AskUserQuestion: "\u{2753}",// ❓
+};
+
 export function getToolEmoji(name: string): string {
-  const n = name.toLowerCase();
-  if (n.includes("read") || n.includes("cat")) return "\u{1F4D6}";        // 📖
-  if (n.includes("write")) return "\u{270D}\u{FE0F}";                    // ✍️
-  if (n.includes("edit")) return "\u{270F}\u{FE0F}";                     // ✏️
-  if (n.includes("grep") || n.includes("search")) return "\u{1F50E}";    // 🔎
-  if (n.includes("glob") || n.includes("find") || n.includes("ls")) return "\u{1F4C2}"; // 📂
-  if (n.includes("bash") || n.includes("shell") || n.includes("exec")) return "\u{1F5A5}\u{FE0F}"; // 🖥️
-  if (n.includes("websearch") || n.includes("web_search")) return "\u{1F310}"; // 🌐
-  if (n.includes("webfetch") || n.includes("web_fetch") || n.includes("fetch")) return "\u{1F4E5}"; // 📥
-  if (n.includes("todo") || n.includes("task")) return "\u{2705}";       // ✅
-  if (n.includes("agent")) return "\u{1F916}";                           // 🤖
-  if (n.includes("notebook")) return "\u{1F4D3}";                        // 📓
-  if (n.includes("ask") || n.includes("question")) return "\u{2753}";    // ❓
-  return "\u{1F527}";                                                     // 🔧
+  return TOOL_EMOJI_MAP[name] ?? "\u{1F527}"; // 🔧
 }
 
 // ---------------------------------------------------------------------------
 // Card builders
 // ---------------------------------------------------------------------------
 
-// CardKit schema 2.0 思考卡片（带停止按钮，支持打字机流式更新）
-export function buildThinkingCardV2(
-  thinkingText: string,
+// CardKit schema 2.0 进度卡片（带停止按钮，支持流式更新）
+export function buildProgressCard(
+  text: string,
   opts: { showStop?: boolean; headerTitle?: string; headerTemplate?: string } = {}
 ): string {
-  const { showStop = true, headerTitle = "思考中...", headerTemplate = "blue" } = opts;
+  const { showStop = true, headerTitle = "生成中...", headerTemplate = "blue" } = opts;
   const elements: object[] = [
-    { tag: "markdown", content: truncateContent(thinkingText), element_id: "main_content" },
+    { tag: "markdown", content: truncateContent(text), element_id: "main_content" },
   ];
   if (showStop) {
     elements.push({ tag: "hr" });

package/src/index.ts

@@ -13,7 +13,7 @@
  * session ID, resumes the session via SDK, sends the user's text, and
  * streams the response to the session's jsonl file.
  *
- * Buttons: thinking cards have a 停止 button; help messages have /new and /restart buttons.
+ * Buttons: progress cards have a 停止 button; help messages have /new and /restart buttons.
  *
  * Usage:
  *   npm run dev
@@ -67,7 +67,7 @@ import {
   verifyAllPermissions,
   reportPermissionResults,
 } from "./feishu-api.ts";
-import { buildHelpCard, buildStatusCard, buildThinkingCardV2, buildCdContent, buildSessionsCard } from "./cards.ts";
+import { buildHelpCard, buildStatusCard, buildProgressCard, buildCdContent, buildSessionsCard } from "./cards.ts";
 import { updateCardKitCard } from "./cardkit.ts";
 import {
   MAX_PROCESSED,
@@ -420,9 +420,9 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
             await new Promise(r => setTimeout(r, 20));
           }
           const cardId = existing.cardId;
-          const thinking = existing.accumulatedThinking;
-          const interruptedCard = buildThinkingCardV2(
-            thinking || "新问题已提交，当前回复已中断。",
+          const currentContent = existing.accumulatedContent;
+          const interruptedCard = buildProgressCard(
+            currentContent || "新问题已提交，当前回复已中断。",
             { showStop: false, headerTitle: "已中断", headerTemplate: "yellow" }
           );
           let nextSeq = existing.sequence + 1;

package/src/session.ts

@@ -9,7 +9,7 @@ import {
   isSdkAnthropicDefault,
   ts,
 } from "./config.ts";
-import { buildThinkingCardV2, getToolEmoji, truncateContent } from "./cards.ts";
+import { buildProgressCard, getToolEmoji, truncateContent } from "./cards.ts";
 import {
   createCardKitCard,
   sendCardKitMessage,
@@ -30,7 +30,7 @@ export const chatSessionMap = new Map<string, {
   close: () => void;
   cardId: string | null;
   stopped: boolean;
-  accumulatedThinking: string;
+  accumulatedContent: string;
   finalText: string;
   spinnerTimer: ReturnType<typeof setInterval> | null;
   msgTimestamp: number;
@@ -132,7 +132,7 @@ export async function resumeAndPrompt(
     close: () => session.close(),
     cardId: null,
     stopped: false,
-    accumulatedThinking: "",
+    accumulatedContent: "",
     finalText: "",
     spinnerTimer: null,
     msgTimestamp,
@@ -155,7 +155,7 @@ export async function resumeAndPrompt(
 
   await session.send(userText);
 
-  cardId = await createCardKitCard(token, buildThinkingCardV2("", { showStop: true, headerTitle: "生成中..." })).catch((err) => {
+  cardId = await createCardKitCard(token, buildProgressCard("", { showStop: true, headerTitle: "生成中..." })).catch((err) => {
     console.error(`[${ts()}] [CARDIKT] createCard FAIL: chatId=${chatId} ${(err as Error).message}`);
     fileLog.flush();
     sendTextReply(token, chatId, "⚠️ 流式卡片创建失败（可能因限流），将使用文本回复。").catch(() => {});
@@ -178,8 +178,8 @@ export async function resumeAndPrompt(
 
   const stream = session.stream();
 
-  let thinkingCount = 0;
-  let accumulatedThinking = "";
+  let chunkCount = 0;
+  let accumulatedContent = "";
   let finalText = "";
 
   let cardCreatedAt = Date.now();
@@ -201,11 +201,11 @@ export async function resumeAndPrompt(
       try {
         // 1. 用当前累积内容更新旧卡片为静态版本
         const oldSeqBase = cEntry.sequence;
-        const oldDisplay = truncateContent(accumulatedThinking + finalText) || "处理中...";
-        const oldCard = buildThinkingCardV2(oldDisplay, { showStop: false, headerTitle: "生成中...（上轮）" });
+        const oldDisplay = truncateContent(accumulatedContent + finalText) || "处理中...";
+        const oldCard = buildProgressCard(oldDisplay, { showStop: false, headerTitle: "生成中...（上轮）" });
         await updateCardKitCard(token, oldCardId!, oldCard, oldSeqBase + 1).catch(() => {});
         // 2. 创建新卡片并发送
-        const newCardId = await createCardKitCard(token, buildThinkingCardV2("", { showStop: true, headerTitle: "生成中..." }));
+        const newCardId = await createCardKitCard(token, buildProgressCard("", { showStop: true, headerTitle: "生成中..." }));
         if (!newCardId) throw new Error("createCardKitCard returned empty");
         await sendCardKitMessage(token, chatId, newCardId);
         // 3. 切换到新卡片
@@ -225,21 +225,21 @@ export async function resumeAndPrompt(
     }
 
     dotCount = (dotCount % 9) + 1;
-    const content = truncateContent(accumulatedThinking + finalText + "\n" + "。".repeat(dotCount));
+    const content = truncateContent(accumulatedContent + finalText + "\n" + "。".repeat(dotCount));
     if (content === lastSentContent) return;
 
     lastSentContent = content;
     cEntry.cardBusy = true;
     const mySeq = cEntry.sequence + 1;
     try {
-      const card = buildThinkingCardV2(content, { showStop: true, headerTitle: "生成中..." });
+      const card = buildProgressCard(content, { showStop: true, headerTitle: "生成中..." });
       await updateCardKitCard(token, cardId!, card, mySeq);
       cEntry.sequence = mySeq;
-      cEntry.accumulatedThinking = accumulatedThinking;
+      cEntry.accumulatedContent = accumulatedContent;
       streamErrorNotified = false;
       healthLogTicks++;
       if (healthLogTicks % 10 === 0) {
-        console.log(`[${ts()}] [CARDIKT] update health: seq=${mySeq} thinking=${accumulatedThinking.length}chars text=${finalText.length}chars cardAge=${Math.round((Date.now() - cardCreatedAt) / 1000)}s`);
+        console.log(`[${ts()}] [CARDIKT] update health: seq=${mySeq} content=${accumulatedContent.length}chars text=${finalText.length}chars cardAge=${Math.round((Date.now() - cardCreatedAt) / 1000)}s`);
       }
     } catch (err) {
       console.error(`[${ts()}] CardKit update error: chatId=${chatId} cardId=${cardId} seq=${mySeq} ${(err as Error).message}`);
@@ -266,14 +266,14 @@ export async function resumeAndPrompt(
         for (const block of sdkMsg.message.content) {
 
           if (block.type === "thinking" && block.thinking) {
-            thinkingCount++;
-            accumulatedThinking += block.thinking;
+            chunkCount++;
+            accumulatedContent += block.thinking;
           } else if (block.type === "tool_use") {
             const toolName = (block as { name?: string }).name ?? "unknown";
             const toolInput = (block as { input?: unknown }).input;
             const inputStr = typeof toolInput === "object" ? JSON.stringify(toolInput) : String(toolInput ?? "");
             const shortInput = inputStr.length > 300 ? inputStr.slice(0, 300) + "..." : inputStr;
-            accumulatedThinking += `\n\n${getToolEmoji(toolName)} **${toolName}**\n\`${shortInput}\`\n`;
+            accumulatedContent += `\n\n${getToolEmoji(toolName)} **${toolName}**\n\`${shortInput}\`\n`;
           } else if (block.type === "tool_result") {
             const toolUseId = (block as { tool_use_id?: string }).tool_use_id ?? "";
             const resultContent = (block as { content?: unknown }).content;
@@ -288,12 +288,12 @@ export async function resumeAndPrompt(
             const shortResult = resultStr.length > 200 ? resultStr.slice(0, 200) + "..." : resultStr;
             const isError = (block as { is_error?: boolean }).is_error;
             const icon = isError ? "❌" : "✅";
-            accumulatedThinking += `${icon} *${toolUseId.slice(-6)}*: ${shortResult}\n`;
+            accumulatedContent += `${icon} *${toolUseId.slice(-6)}*: ${shortResult}\n`;
           } else if (block.type === "redacted_thinking") {
-            accumulatedThinking += "\n\n⚠️ 思考内容被安全过滤\n";
+            accumulatedContent += "\n\n⚠️ 内容被安全过滤\n";
           } else if (block.type === "search_result") {
             const searchQuery = (block as { query?: string }).query ?? "";
-            accumulatedThinking += `\n\n🔍 联网搜索: **${searchQuery}**\n`;
+            accumulatedContent += `\n\n🔍 联网搜索: **${searchQuery}**\n`;
           } else if (block.type === "text" && block.text) {
             finalText += block.text;
             const entry = chatSessionMap.get(chatId);
@@ -304,7 +304,7 @@ export async function resumeAndPrompt(
         const compactMeta = (sdkMsg as { compact_metadata?: { trigger?: string; pre_tokens?: number; post_tokens?: number } }).compact_metadata;
         if (compactMeta) {
           const triggerLabel = compactMeta.trigger === "manual" ? "手动" : "自动";
-          accumulatedThinking += `\n\n🔄 上下文压缩(${triggerLabel}): **${compactMeta.pre_tokens}** → **${compactMeta.post_tokens}** tokens\n`;
+          accumulatedContent += `\n\n🔄 上下文压缩(${triggerLabel}): **${compactMeta.pre_tokens}** → **${compactMeta.post_tokens}** tokens\n`;
           // 更新持久化上下文 token 数
           if (compactMeta.post_tokens) {
             const info = sessionInfoMap.get(chatId);
@@ -325,19 +325,19 @@ export async function resumeAndPrompt(
   const wasStopped = cEntry.stopped;
   chatSessionMap.delete(chatId);
 
-  if (cardId && accumulatedThinking) {
+  if (cardId && accumulatedContent) {
     while (cEntry.cardBusy) {
       await new Promise(r => setTimeout(r, 20));
     }
     const nextSeq = cEntry.sequence + 1;
     if (wasStopped) {
-      const stopCard = buildThinkingCardV2(accumulatedThinking || "已停止", { showStop: false, headerTitle: "已停止", headerTemplate: "red" });
+      const stopCard = buildProgressCard(accumulatedContent || "已停止", { showStop: false, headerTitle: "已停止", headerTemplate: "red" });
       await updateCardKitCard(token, cardId, stopCard, nextSeq).catch((err) => {
         console.error(`[${ts()}] CardKit finalize: chatId=${chatId} cardId=${cardId} ${(err as Error).message}`);
         fileLog.flush();
       });
     } else {
-      const doneCard = buildThinkingCardV2(accumulatedThinking, { showStop: false, headerTitle: "完成" });
+      const doneCard = buildProgressCard(accumulatedContent, { showStop: false, headerTitle: "完成" });
       await updateCardKitCard(token, cardId, doneCard, nextSeq).catch((err) => {
         console.error(`[${ts()}] CardKit finalize: chatId=${chatId} cardId=${cardId} ${(err as Error).message}`);
         fileLog.flush();
@@ -353,16 +353,16 @@ export async function resumeAndPrompt(
         console.error(`[${ts()}] Failed to send partial text: ${(err as Error).message}`)
       );
     }
-    console.log(`[${ts()}] Session ${sessionId} stopped by user (thinking chunks: ${thinkingCount})`);
+    console.log(`[${ts()}] Session ${sessionId} stopped by user (content chunks: ${chunkCount})`);
     return;
   }
 
   if (streamErrorNotified) {
     // CardKit streaming failed — send everything as text to ensure user sees the result
-    if (accumulatedThinking.trim()) {
-      const shortThinking = truncateContent(accumulatedThinking, 30, 4000);
-      await sendTextReply(token, chatId, `[思考过程]\n${shortThinking}`).catch((err) =>
-        console.error(`[${ts()}] Failed to send thinking fallback: ${(err as Error).message}`)
+    if (accumulatedContent.trim()) {
+      const shortContent = truncateContent(accumulatedContent, 30, 4000);
+      await sendTextReply(token, chatId, `[生成过程]\n${shortContent}`).catch((err) =>
+        console.error(`[${ts()}] Failed to send content fallback: ${(err as Error).message}`)
       );
     }
     if (finalText.trim()) {
@@ -376,15 +376,15 @@ export async function resumeAndPrompt(
       await sendTextReply(token, chatId, finalText.trim()).catch((err) =>
         console.error(`[${ts()}] Failed to send final text: ${(err as Error).message}`)
       );
-    } else if (!cardId && accumulatedThinking.trim()) {
-      const shortThinking = truncateContent(accumulatedThinking, 30, 4000);
-      await sendTextReply(token, chatId, `[思考过程]\n${shortThinking}`).catch((err) =>
-        console.error(`[${ts()}] Failed to send thinking text: ${(err as Error).message}`)
+    } else if (!cardId && accumulatedContent.trim()) {
+      const shortContent = truncateContent(accumulatedContent, 30, 4000);
+      await sendTextReply(token, chatId, `[生成过程]\n${shortContent}`).catch((err) =>
+        console.error(`[${ts()}] Failed to send content text: ${(err as Error).message}`)
       );
     }
   }
 
-  console.log(`[${ts()}] Session ${sessionId} stream complete (thinking chunks: ${thinkingCount})`);
+  console.log(`[${ts()}] Session ${sessionId} stream complete (content chunks: ${chunkCount})`);
 }
 
 // ---------------------------------------------------------------------------
@@ -415,7 +415,7 @@ export function getSessionStatus(chatId: string): SessionStatus | null {
     startTime: info.startTime,
     model: anthropicConfigDisplay(info.model),
     effort: anthropicConfigDisplay(info.effort),
-    accumulatedLength: active ? active.accumulatedThinking.length + active.finalText.length : 0,
+    accumulatedLength: active ? active.accumulatedContent.length + active.finalText.length : 0,
   };
 }