chatccc 0.2.252 → 0.2.254

package/dist/src/adapters/jsonl-stream.js

@@ -0,0 +1,104 @@
+import { createInterface } from "node:readline";
+export const DEFAULT_BAD_JSON_IDLE_TIMEOUT_MS = 120_000;
+export const BAD_JSON_IDLE_TIMEOUT_CODE = "BAD_JSON_IDLE_TIMEOUT";
+export class BadJsonIdleTimeoutError extends Error {
+    code = BAD_JSON_IDLE_TIMEOUT_CODE;
+    tool;
+    tag;
+    timeoutMs;
+    lineNumber;
+    lineExcerpt;
+    parseError;
+    constructor(args) {
+        super(`${args.tool} stream stopped after invalid JSON for ${args.timeoutMs}ms ` +
+            `(tag=${args.tag}, line=${args.lineNumber}): ${args.lineExcerpt}`);
+        this.name = "BadJsonIdleTimeoutError";
+        this.tool = args.tool;
+        this.tag = args.tag;
+        this.timeoutMs = args.timeoutMs;
+        this.lineNumber = args.lineNumber;
+        this.lineExcerpt = args.lineExcerpt;
+        this.parseError = args.parseError;
+    }
+}
+function isJsonLike(line) {
+    return line.startsWith("{") || line.startsWith("[");
+}
+function lineExcerpt(line) {
+    const max = 500;
+    return line.length <= max ? line : `${line.slice(0, max)}...`;
+}
+function parseErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export async function* readJsonLinesWithBadJsonIdleWatchdog({ input, tool, tag = tool, signal, rawLog, idleTimeoutMs = DEFAULT_BAD_JSON_IDLE_TIMEOUT_MS, parse = (line) => JSON.parse(line), onRawLine, onParsedLine, onDone, }) {
+    const rl = createInterface({ input, crlfDelay: Infinity });
+    let lineCount = 0;
+    let protocolError = null;
+    let badJsonIdleTimer = null;
+    const clearBadJsonIdleTimer = () => {
+        if (!badJsonIdleTimer)
+            return;
+        clearTimeout(badJsonIdleTimer);
+        badJsonIdleTimer = null;
+    };
+    const armBadJsonIdleTimer = (line, lineNumber, error) => {
+        if (idleTimeoutMs <= 0)
+            return;
+        clearBadJsonIdleTimer();
+        badJsonIdleTimer = setTimeout(() => {
+            protocolError = new BadJsonIdleTimeoutError({
+                tool,
+                tag,
+                timeoutMs: idleTimeoutMs,
+                lineNumber,
+                lineExcerpt: lineExcerpt(line),
+                parseError: parseErrorMessage(error),
+            });
+            rl.close();
+        }, idleTimeoutMs);
+        const timerWithUnref = badJsonIdleTimer;
+        timerWithUnref.unref?.();
+    };
+    const onAbort = () => {
+        clearBadJsonIdleTimer();
+        rl.close();
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    try {
+        for await (const line of rl) {
+            if (signal?.aborted)
+                break;
+            lineCount++;
+            onRawLine?.(line, lineCount);
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            clearBadJsonIdleTimer();
+            rawLog?.writeLine(trimmed);
+            try {
+                const parsed = parse(trimmed);
+                onParsedLine?.(parsed, trimmed, lineCount);
+                yield parsed;
+            }
+            catch (error) {
+                if (isJsonLike(trimmed)) {
+                    armBadJsonIdleTimer(trimmed, lineCount, error);
+                }
+            }
+        }
+        if (protocolError && !signal?.aborted) {
+            throw protocolError;
+        }
+    }
+    finally {
+        signal?.removeEventListener("abort", onAbort);
+        clearBadJsonIdleTimer();
+        rl.close();
+        onDone?.({
+            lineCount,
+            signalAborted: signal?.aborted ?? false,
+            protocolError,
+        });
+    }
+}

package/{src/adapters/proc-tree-kill.ts → dist/src/adapters/proc-tree-kill.js}

@@ -1,97 +1,94 @@
-// =============================================================================
-// proc-tree-kill.ts — 跨平台进程树强杀工具
-// =============================================================================
-// 背景：codex / cursor adapter 通过 `spawn(cmd, args, { shell: true })` 启动 CLI
-// 时，Node 拿到的 proc.pid 是最外层 cmd.exe（Windows）或 /bin/sh（其它）的
-// PID。真正干活的是它再 spawn 出来的：
-//
-//     cmd.exe              ← proc.kill() 只能杀到这一层
-//       └─ node codex.js   ← Codex CLI 入口
-//            └─ codex.exe  ← 实际 Rust 二进制（继续烧 token）
-//
-// 单纯 proc.kill() 在 Windows 上等价于 TerminateProcess 顶层壳，孙子进程不会
-// 收到任何信号、继续运行，导致用户 /stop 看似生效（adapter 标记 stopped）但
-// 实际 codex 仍在后台跑、stream-state 一直停在 "running"。
-//
-// 解决方案：abort 时不要走 proc.kill()，而是用本工具按 pid 杀掉整棵进程树。
-//   - Windows: `taskkill /pid <pid> /T /F`（/T = 递归子进程, /F = 强制）
-//   - 其它：`process.kill(-pgid, "SIGTERM")` + 兜底 SIGKILL（adapter spawn 时
-//           需配合 detached:true 让子进程拥有独立 process group）
-// =============================================================================
-
-import { spawn } from "node:child_process";
-
-/** 异步杀掉以 pid 为根的整棵进程树。
- *
- * 设计目标：永不抛错、永不阻塞调用者。
- * - pid 不存在、参数缺失 → 静默返回
- * - 子进程 spawn 失败 → console.warn 但不 reject
- * - Windows 上 taskkill 异步执行，不阻塞 event loop
- *
- * 调用方约定：返回的 Promise 在 kill 命令发出后立即 resolve。
- * 真正的进程退出由 OS 异步完成，调用方如果需要确认"已死透"，应自己再轮询
- * `process.kill(pid, 0)`。
- */
-export async function killProcessTree(pid: number | undefined): Promise<void> {
-  if (pid == null || !Number.isFinite(pid) || pid <= 0) return;
-  if (process.platform === "win32") {
-    await killWindowsTree(pid);
-    return;
-  }
-  await killPosixTree(pid);
-}
-
-// ---------------------------------------------------------------------------
-// Windows: taskkill /T /F
-// ---------------------------------------------------------------------------
-
-function killWindowsTree(pid: number): Promise<void> {
-  return new Promise<void>((resolve) => {
-    let resolved = false;
-    const done = () => {
-      if (resolved) return;
-      resolved = true;
-      resolve();
-    };
-    try {
-      const proc = spawn("taskkill", ["/pid", String(pid), "/T", "/F"], {
-        stdio: "ignore",
-        windowsHide: true,
-        // taskkill 本身很快（<200ms），不需要 detached
-      });
-      proc.once("error", (err) => {
-        console.warn(`[killProcessTree] taskkill spawn error for pid=${pid}: ${(err as Error).message}`);
-        done();
-      });
-      proc.once("close", () => { done(); });
-      // 兜底超时：3 秒后强制 resolve，避免极端情况下 hang 住调用方
-      setTimeout(done, 3000).unref();
-    } catch (err) {
-      console.warn(`[killProcessTree] taskkill failed for pid=${pid}: ${(err as Error).message}`);
-      done();
-    }
-  });
-}
-
-// ---------------------------------------------------------------------------
-// POSIX: 优先按 process group 杀，回退到按 pid 杀
-// ---------------------------------------------------------------------------
-
-async function killPosixTree(pid: number): Promise<void> {
-  // 第一次尝试：按 process group 发 SIGTERM。要求 spawn 时 detached:true。
-  trySignal(-pid, "SIGTERM");
-  trySignal(pid, "SIGTERM");
-  // 给进程 1 秒优雅退出机会
-  await new Promise((r) => setTimeout(r, 1000));
-  // 兜底：SIGKILL
-  trySignal(-pid, "SIGKILL");
-  trySignal(pid, "SIGKILL");
-}
-
-function trySignal(target: number, signal: NodeJS.Signals): void {
-  try {
-    process.kill(target, signal);
-  } catch {
-    // 进程已不存在或权限不足，忽略
-  }
-}
+// =============================================================================
+// proc-tree-kill.ts — 跨平台进程树强杀工具
+// =============================================================================
+// 背景：codex / cursor adapter 通过 `spawn(cmd, args, { shell: true })` 启动 CLI
+// 时，Node 拿到的 proc.pid 是最外层 cmd.exe（Windows）或 /bin/sh（其它）的
+// PID。真正干活的是它再 spawn 出来的：
+//
+//     cmd.exe              ← proc.kill() 只能杀到这一层
+//       └─ node codex.js   ← Codex CLI 入口
+//            └─ codex.exe  ← 实际 Rust 二进制（继续烧 token）
+//
+// 单纯 proc.kill() 在 Windows 上等价于 TerminateProcess 顶层壳，孙子进程不会
+// 收到任何信号、继续运行，导致用户 /stop 看似生效（adapter 标记 stopped）但
+// 实际 codex 仍在后台跑、stream-state 一直停在 "running"。
+//
+// 解决方案：abort 时不要走 proc.kill()，而是用本工具按 pid 杀掉整棵进程树。
+//   - Windows: `taskkill /pid <pid> /T /F`（/T = 递归子进程, /F = 强制）
+//   - 其它：`process.kill(-pgid, "SIGTERM")` + 兜底 SIGKILL（adapter spawn 时
+//           需配合 detached:true 让子进程拥有独立 process group）
+// =============================================================================
+import { spawn } from "node:child_process";
+/** 异步杀掉以 pid 为根的整棵进程树。
+ *
+ * 设计目标：永不抛错、永不阻塞调用者。
+ * - pid 不存在、参数缺失 → 静默返回
+ * - 子进程 spawn 失败 → console.warn 但不 reject
+ * - Windows 上 taskkill 异步执行，不阻塞 event loop
+ *
+ * 调用方约定：返回的 Promise 在 kill 命令发出后立即 resolve。
+ * 真正的进程退出由 OS 异步完成，调用方如果需要确认"已死透"，应自己再轮询
+ * `process.kill(pid, 0)`。
+ */
+export async function killProcessTree(pid) {
+    if (pid == null || !Number.isFinite(pid) || pid <= 0)
+        return;
+    if (process.platform === "win32") {
+        await killWindowsTree(pid);
+        return;
+    }
+    await killPosixTree(pid);
+}
+// ---------------------------------------------------------------------------
+// Windows: taskkill /T /F
+// ---------------------------------------------------------------------------
+function killWindowsTree(pid) {
+    return new Promise((resolve) => {
+        let resolved = false;
+        const done = () => {
+            if (resolved)
+                return;
+            resolved = true;
+            resolve();
+        };
+        try {
+            const proc = spawn("taskkill", ["/pid", String(pid), "/T", "/F"], {
+                stdio: "ignore",
+                windowsHide: true,
+                // taskkill 本身很快（<200ms），不需要 detached
+            });
+            proc.once("error", (err) => {
+                console.warn(`[killProcessTree] taskkill spawn error for pid=${pid}: ${err.message}`);
+                done();
+            });
+            proc.once("close", () => { done(); });
+            // 兜底超时：3 秒后强制 resolve，避免极端情况下 hang 住调用方
+            setTimeout(done, 3000).unref();
+        }
+        catch (err) {
+            console.warn(`[killProcessTree] taskkill failed for pid=${pid}: ${err.message}`);
+            done();
+        }
+    });
+}
+// ---------------------------------------------------------------------------
+// POSIX: 优先按 process group 杀，回退到按 pid 杀
+// ---------------------------------------------------------------------------
+async function killPosixTree(pid) {
+    // 第一次尝试：按 process group 发 SIGTERM。要求 spawn 时 detached:true。
+    trySignal(-pid, "SIGTERM");
+    trySignal(pid, "SIGTERM");
+    // 给进程 1 秒优雅退出机会
+    await new Promise((r) => setTimeout(r, 1000));
+    // 兜底：SIGKILL
+    trySignal(-pid, "SIGKILL");
+    trySignal(pid, "SIGKILL");
+}
+function trySignal(target, signal) {
+    try {
+        process.kill(target, signal);
+    }
+    catch {
+        // 进程已不存在或权限不足，忽略
+    }
+}

package/dist/src/adapters/raw-stream-log.js

@@ -0,0 +1,106 @@
+import { createWriteStream } from "node:fs";
+import { mkdir, readdir, rm, stat, unlink } from "node:fs/promises";
+import { once } from "node:events";
+import { join } from "node:path";
+import { createGzip } from "node:zlib";
+export function sanitizeLogPathSegment(value) {
+    const safe = value.replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/^[._]+|_+$/g, "");
+    return safe || "unknown";
+}
+async function cleanupOldRawStreamLogs(rootDir, retentionDays) {
+    if (!Number.isFinite(retentionDays) || retentionDays <= 0)
+        return;
+    const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1000;
+    const visit = async (dir) => {
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        await Promise.all(entries.map(async (entry) => {
+            const path = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await visit(path);
+                try {
+                    await rm(path, { recursive: false });
+                }
+                catch {
+                    // Directory is not empty or already gone.
+                }
+                return;
+            }
+            if (!entry.isFile())
+                return;
+            try {
+                const info = await stat(path);
+                if (info.mtimeMs < cutoff)
+                    await rm(path, { force: true });
+            }
+            catch {
+                // Best-effort cleanup only.
+            }
+        }));
+    };
+    await visit(rootDir);
+}
+export async function createRawStreamLog(options) {
+    if (!options.enabled)
+        return null;
+    const maxBytes = Math.max(0, Math.floor(options.maxBytesPerTurn));
+    const tool = sanitizeLogPathSegment(options.tool);
+    const session = sanitizeLogPathSegment(options.sessionId);
+    const label = sanitizeLogPathSegment(options.label);
+    const dir = join(options.rootDir, tool, session);
+    await mkdir(dir, { recursive: true });
+    void cleanupOldRawStreamLogs(join(options.rootDir, tool), options.retentionDays);
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const filePath = join(dir, `${timestamp}-${label}.jsonl.gz`);
+    const output = createWriteStream(filePath);
+    const gzip = createGzip();
+    gzip.pipe(output);
+    let bytes = 0;
+    let truncated = false;
+    let ended = false;
+    const writeLine = (line) => {
+        if (ended || truncated)
+            return;
+        const payload = `${line}\n`;
+        const payloadBytes = Buffer.byteLength(payload, "utf-8");
+        if (maxBytes > 0 && bytes + payloadBytes > maxBytes) {
+            const marker = JSON.stringify({
+                type: "chatccc_raw_stream_log_truncated",
+                reason: "max_bytes_per_turn_exceeded",
+                maxBytesPerTurn: maxBytes,
+                writtenBytes: bytes,
+            });
+            gzip.write(`${marker}\n`);
+            truncated = true;
+            return;
+        }
+        bytes += payloadBytes;
+        gzip.write(payload);
+    };
+    const close = async ({ keep }) => {
+        if (ended)
+            return;
+        ended = true;
+        gzip.end();
+        try {
+            await once(output, "finish");
+        }
+        catch {
+            // Ignore close errors; caller cannot recover from debug log failures.
+        }
+        if (!keep) {
+            try {
+                await unlink(filePath);
+            }
+            catch {
+                // Best-effort cleanup only.
+            }
+        }
+    };
+    return { filePath, writeLine, close };
+}

package/dist/src/adapters/resource-monitor.js

@@ -0,0 +1,113 @@
+// =============================================================================
+// resource-monitor.ts — CLI 进程资源监控（CPU + 内存）
+// =============================================================================
+// 对所有 chatccc 启动的 CLI 进程持续监控 CPU 和内存占用。
+// 若连续 3 分钟两项指标均无变化，判定为僵死，发出 "stuck" 事件。
+// =============================================================================
+import { exec } from "node:child_process";
+import { EventEmitter } from "node:events";
+const CHECK_INTERVAL_MS = 30_000; // 30 秒检查一次
+const STUCK_THRESHOLD = 6; // 连续 6 次无变化 = 3 分钟
+export const resourceMonitor = new EventEmitter();
+const tracked = new Map();
+let timer = null;
+function startIfNeeded() {
+    if (timer)
+        return;
+    timer = setInterval(checkAll, CHECK_INTERVAL_MS);
+    timer.unref?.();
+}
+function stopIfIdle() {
+    if (tracked.size > 0)
+        return;
+    if (timer) {
+        clearInterval(timer);
+        timer = null;
+    }
+}
+export function registerProcess(pid, sessionId) {
+    tracked.set(pid, { pid, sessionId, snapshot: { cpu: -1, memory: -1, unchangedCount: 0 } });
+    startIfNeeded();
+}
+export function unregisterProcess(pid) {
+    tracked.delete(pid);
+    stopIfIdle();
+}
+// ---------------------------------------------------------------------------
+// 批量查询进程指标（Windows PowerShell）
+// ---------------------------------------------------------------------------
+function execPowerShell(script, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        exec(`powershell -NoProfile -Command "${script}"`, { timeout: timeoutMs, windowsHide: true }, (err, stdout) => {
+            if (err)
+                reject(err);
+            else
+                resolve(stdout);
+        });
+    });
+}
+async function getProcessMetrics(pids) {
+    const result = new Map();
+    if (pids.length === 0)
+        return result;
+    const psScript = `Get-Process -Id ${pids.join(",")} -ErrorAction SilentlyContinue | ForEach-Object { "$($_.Id)|$($_.CPU)|$($_.WorkingSet64)" }`;
+    try {
+        const stdout = await execPowerShell(psScript, 10_000);
+        for (const line of stdout.trim().split(/\r?\n/)) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            const [idStr, cpuStr, memStr] = trimmed.split("|");
+            const id = parseInt(idStr, 10);
+            const cpu = parseFloat(cpuStr);
+            const memory = parseInt(memStr, 10);
+            if (!isNaN(id) && !isNaN(cpu) && !isNaN(memory)) {
+                result.set(id, { cpu, memory });
+            }
+        }
+    }
+    catch {
+        // PowerShell 查询失败时跳过本轮，下次重试
+    }
+    return result;
+}
+// ---------------------------------------------------------------------------
+// 定时检查
+// ---------------------------------------------------------------------------
+async function checkAll() {
+    if (tracked.size === 0)
+        return;
+    const pids = [...tracked.keys()];
+    const metrics = await getProcessMetrics(pids);
+    for (const [pid, tp] of tracked) {
+        const m = metrics.get(pid);
+        if (!m) {
+            // 进程已不存在，停止追踪
+            tracked.delete(pid);
+            continue;
+        }
+        const prev = tp.snapshot;
+        const cpuChanged = m.cpu !== prev.cpu;
+        // 内存允许 ±1% 波动，避免正常抖动触发误判
+        const memTolerance = prev.memory > 0 ? Math.max(prev.memory * 0.01, 1024 * 1024) : 1024 * 1024;
+        const memChanged = Math.abs(m.memory - prev.memory) > memTolerance;
+        if (!cpuChanged && !memChanged) {
+            tp.snapshot.unchangedCount++;
+            if (tp.snapshot.unchangedCount >= STUCK_THRESHOLD) {
+                const idleMinutes = Math.round((tp.snapshot.unchangedCount * CHECK_INTERVAL_MS) / 60_000);
+                resourceMonitor.emit("stuck", {
+                    pid: tp.pid,
+                    sessionId: tp.sessionId,
+                    idleMinutes,
+                });
+                tracked.delete(pid);
+            }
+        }
+        else {
+            tp.snapshot.unchangedCount = 0;
+        }
+        tp.snapshot.cpu = m.cpu;
+        tp.snapshot.memory = m.memory;
+    }
+    stopIfIdle();
+}

package/dist/src/agent-activity.js

@@ -0,0 +1,133 @@
+export function createAgentActivityTracker(now = Date.now()) {
+    return {
+        activity: { kind: "starting", startedAt: now },
+        activeTools: new Map(),
+        nextAnonymousToolId: 1,
+    };
+}
+function sameVisibleActivity(left, right) {
+    return left.kind === right.kind
+        && left.toolName === right.toolName
+        && left.toolCount === right.toolCount;
+}
+function setActivity(tracker, next) {
+    if (sameVisibleActivity(tracker.activity, next))
+        return false;
+    tracker.activity = next;
+    return true;
+}
+function refreshToolActivity(tracker) {
+    const tools = [...tracker.activeTools.values()];
+    const first = tools[0];
+    if (!first)
+        return false;
+    return setActivity(tracker, {
+        kind: "tool",
+        startedAt: first.startedAt,
+        toolName: first.name,
+        toolCount: tools.length,
+    });
+}
+function removeCompletedTool(tracker, toolUseId) {
+    if (toolUseId && tracker.activeTools.delete(toolUseId))
+        return;
+    // Older adapters did not always include a tool ID. Prefer an anonymous entry;
+    // if there is only one active call, it is still safe to match that result.
+    const anonymousId = [...tracker.activeTools.keys()].find((id) => id.startsWith("anonymous:"));
+    if (anonymousId) {
+        tracker.activeTools.delete(anonymousId);
+    }
+    else if (tracker.activeTools.size === 1) {
+        const onlyId = tracker.activeTools.keys().next().value;
+        if (onlyId)
+            tracker.activeTools.delete(onlyId);
+    }
+}
+/**
+ * Applies one normalized Agent event and returns whether the persisted activity
+ * changed. Tool activity takes precedence while a tool call is still active.
+ */
+export function updateAgentActivity(tracker, block, now = Date.now()) {
+    if (block.type === "tool_use") {
+        const id = block.id || `anonymous:${tracker.nextAnonymousToolId++}`;
+        const existing = tracker.activeTools.get(id);
+        tracker.activeTools.set(id, {
+            id,
+            name: block.name || "未知工具",
+            startedAt: existing?.startedAt ?? now,
+        });
+        return refreshToolActivity(tracker);
+    }
+    if (block.type === "tool_result") {
+        removeCompletedTool(tracker, block.tool_use_id);
+        if (tracker.activeTools.size > 0)
+            return refreshToolActivity(tracker);
+        return setActivity(tracker, { kind: "processing", startedAt: now });
+    }
+    if (tracker.activeTools.size > 0)
+        return false;
+    switch (block.type) {
+        case "agent_status":
+            return setActivity(tracker, {
+                kind: block.status === "compacting" ? "compacting" : "responding",
+                startedAt: now,
+            });
+        case "thinking":
+        case "redacted_thinking":
+            return setActivity(tracker, { kind: "thinking", startedAt: now });
+        case "text":
+        case "text_final":
+            return setActivity(tracker, { kind: "responding", startedAt: now });
+        case "search_result":
+            return setActivity(tracker, { kind: "searching", startedAt: now });
+        case "compact_boundary":
+            return setActivity(tracker, { kind: "compacting", startedAt: now });
+    }
+}
+function formatElapsed(startedAt, now) {
+    const totalSeconds = Math.max(0, Math.floor((now - startedAt) / 1000));
+    if (totalSeconds < 60)
+        return `${totalSeconds}秒`;
+    const totalMinutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    if (totalMinutes < 60)
+        return `${totalMinutes}分${seconds}秒`;
+    const hours = Math.floor(totalMinutes / 60);
+    const minutes = totalMinutes % 60;
+    return `${hours}小时${minutes}分`;
+}
+function displayToolName(name) {
+    const normalized = (name || "未知工具").replace(/\s+/g, " ").trim();
+    return normalized.length > 24 ? `${normalized.slice(0, 23)}…` : normalized;
+}
+export function formatAgentActivityTitle(activity, now = Date.now()) {
+    if (!activity)
+        return "正在处理";
+    let label;
+    switch (activity.kind) {
+        case "starting":
+            label = "正在启动 Agent";
+            break;
+        case "thinking":
+            label = "思考中";
+            break;
+        case "tool": {
+            const count = Math.max(1, activity.toolCount ?? 1);
+            label = `正在执行 ${displayToolName(activity.toolName)}${count > 1 ? ` 等 ${count} 项` : ""}`;
+            break;
+        }
+        case "processing":
+            label = "正在处理工具结果";
+            break;
+        case "responding":
+            label = "正在生成回复";
+            break;
+        case "searching":
+            label = "正在处理搜索结果";
+            break;
+        case "compacting":
+            label = "正在整理上下文";
+            break;
+    }
+    return `${label} · ${formatElapsed(activity.startedAt, now)}`;
+}