chatccc 0.2.252 → 0.2.253

package/src/platform-adapter.ts

@@ -1,70 +0,0 @@
-/**
- * platform-adapter.ts — IM 平台适配器接口
- *
- * 独立于 orchestrator.ts，避免 orchestrator ↔ session 循环依赖。
- * 每个方法内部自行管理认证，消费者不感知 token 等认证细节。
- */
-
-import type { CursorUsageSummary } from "./cursor-usage.ts";
-import type { CodexUsageSummary } from "./feishu-api.ts";
-
-export interface ChatAvatarUsageHints {
-  codexUsage?: CodexUsageSummary | null;
-  cursorUsage?: CursorUsageSummary | null;
-  fastMode?: boolean;
-}
-
-export interface PlatformAdapter {
-  /** 平台标识，用于区分不同平台的行为（如 wechat、feishu 等） */
-  kind?: string;
-
-  /** 发送纯文本回复 */
-  sendText(chatId: string, text: string): Promise<boolean>;
-
-  /** 发送卡片回复（标题 + 内容 + 颜色模板） */
-  sendCard(
-    chatId: string,
-    title: string,
-    content: string,
-    template: string,
-  ): Promise<boolean>;
-
-  /** 发送原始卡片 JSON */
-  sendRawCard(chatId: string, cardJson: string): Promise<boolean>;
-
-  /** 创建群聊，返回新群 ID */
-  createGroup(name: string, userIds: string[]): Promise<string>;
-
-  /** 更新群名称和描述 */
-  updateChatInfo(
-    chatId: string,
-    name: string,
-    description: string,
-  ): Promise<void>;
-
-  /** 获取群信息 */
-  getChatInfo(chatId: string): Promise<{ name: string; description: string }>;
-
-  /** 解散群聊 */
-  disbandChat(chatId: string): Promise<void>;
-
-  /** 设置群头像 */
-  setChatAvatar(chatId: string, tool: string, status: string, usageHints?: ChatAvatarUsageHints): Promise<void>;
-
-  /** 从群描述中提取 session 信息 */
-  extractSessionInfo(
-    description: string,
-  ): { sessionId: string; tool: string } | null;
-
-  // ---- 进度展示（display loop 使用） ----
-  // 不同平台能力不同：飞书用 CardKit 实时卡片，微信降级为纯文本。
-
-  /** 创建进度展示实体，返回唯一标识；不支持进度展示的平台返回 null */
-  cardCreate(cardJson: string): Promise<string | null>;
-
-  /** 将进度展示发送到指定会话，返回 message_id */
-  cardSend(chatId: string, cardId: string): Promise<string>;
-
-  /** 更新已发送的进度展示，sequence 保证有序 */
-  cardUpdate(cardId: string, cardJson: string, sequence: number): Promise<void>;
-}

package/src/platform-startup.ts

@@ -1,16 +0,0 @@
-export interface PlatformStartupPlanInput {
-  feishuEnabled: boolean;
-  ilinkEnabled: boolean;
-}
-
-export interface PlatformStartupPlan {
-  startFeishu: boolean;
-  startIlink: boolean;
-}
-
-export function buildPlatformStartupPlan(input: PlatformStartupPlanInput): PlatformStartupPlan {
-  return {
-    startFeishu: input.feishuEnabled,
-    startIlink: input.ilinkEnabled,
-  };
-}

package/src/privacy.ts

@@ -1,118 +0,0 @@
-import { existsSync, readFileSync, statSync } from "node:fs";
-import { join } from "node:path";
-import { USER_DATA_DIR } from "./config.ts";
-
-interface PrivacyRules {
-  [key: string]: string;
-}
-
-interface PrivacyConfig {
-  enabled: boolean;
-  rules: PrivacyRules;
-}
-
-let config: PrivacyConfig | null = null;
-let loadedStamp: string | null | undefined;
-
-function privacyFilePath(): string {
-  return join(USER_DATA_DIR, "privacy.json");
-}
-
-function privacyFileStamp(): string | null {
-  const filePath = privacyFilePath();
-  if (!existsSync(filePath)) return null;
-  try {
-    const s = statSync(filePath);
-    return `${s.mtimeMs}:${s.size}`;
-  } catch {
-    return null;
-  }
-}
-
-function sanitizeRules(raw: Record<string, unknown>): PrivacyRules {
-  const result: PrivacyRules = {};
-  for (const [from, to] of Object.entries(raw)) {
-    if (!from) {
-      console.error("[PRIVACY] privacy.json rule key cannot be empty, skipped");
-      continue;
-    }
-    if (typeof to !== "string") {
-      console.error(`[PRIVACY] privacy.json value must be a string, skipped "${from}"`);
-      continue;
-    }
-    result[from] = to;
-  }
-  return result;
-}
-
-function normalizeConfig(parsed: Record<string, unknown>): PrivacyConfig {
-  const hasNewSchema = Object.prototype.hasOwnProperty.call(parsed, "enabled") ||
-    Object.prototype.hasOwnProperty.call(parsed, "rules");
-
-  if (!hasNewSchema) {
-    return { enabled: true, rules: sanitizeRules(parsed) };
-  }
-
-  const enabledRaw = parsed.enabled;
-  const enabled = enabledRaw === undefined ? true : enabledRaw !== false;
-  if (enabledRaw !== undefined && typeof enabledRaw !== "boolean") {
-    console.error("[PRIVACY] privacy.json enabled must be a boolean, using true");
-  }
-
-  const rulesRaw = parsed.rules;
-  if (rulesRaw === undefined) return { enabled, rules: {} };
-  if (typeof rulesRaw !== "object" || rulesRaw === null || Array.isArray(rulesRaw)) {
-    console.error("[PRIVACY] privacy.json rules must be an object");
-    return { enabled, rules: {} };
-  }
-  return { enabled, rules: sanitizeRules(rulesRaw as Record<string, unknown>) };
-}
-
-function loadConfig(): PrivacyConfig {
-  const filePath = privacyFilePath();
-  if (!existsSync(filePath)) {
-    return { enabled: true, rules: {} };
-  }
-  try {
-    const raw = readFileSync(filePath, "utf-8").replace(/^\uFEFF/, "");
-    const parsed = JSON.parse(raw);
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-      console.error("[PRIVACY] privacy.json must be an object");
-      return { enabled: true, rules: {} };
-    }
-    return normalizeConfig(parsed as Record<string, unknown>);
-  } catch (err) {
-    console.error(`[PRIVACY] failed to read privacy.json: ${(err as Error).message}`);
-    return { enabled: true, rules: {} };
-  }
-}
-
-export function getPrivacyConfig(): PrivacyConfig {
-  const stamp = privacyFileStamp();
-  if (!config || stamp !== loadedStamp) {
-    config = loadConfig();
-    loadedStamp = stamp;
-  }
-  return config;
-}
-
-export function getPrivacyRules(): PrivacyRules {
-  return getPrivacyConfig().rules;
-}
-
-export function reloadPrivacyRules(): void {
-  config = null;
-  loadedStamp = undefined;
-}
-
-export function applyPrivacy(text: string): string {
-  const { enabled, rules } = getPrivacyConfig();
-  if (!enabled || Object.keys(rules).length === 0 || !text) return text;
-
-  let result = text;
-  for (const [from, to] of Object.entries(rules)) {
-    // Use split+join instead of regex replacement so rule keys stay literal.
-    result = result.split(from).join(to);
-  }
-  return result;
-}

package/src/progress/reducer.ts

@@ -1,113 +0,0 @@
-/**
- * progress/reducer.ts — ChatEvent 事件流 → ProgressView 的增量合并
- *
- * 这是飞书与终端共享的唯一一份"事件 → 过程视图"公共逻辑：
- * 终端 REPL 直接消费 ChatSession.chat() 的事件流，逐条 reduce；
- * 飞书侧 display loop 若未来接入事件流，同样使用本 reducer，保证两端
- * 看到的过程状态（正文累积、工具调用、终态判定）完全一致。
- */
-
-import type { ChatEvent } from "../../deepccc-agent/src/index.ts";
-import {
-  withProgressView,
-  type ProgressToolCall,
-  type ProgressView,
-} from "./view.ts";
-
-/** 工具调用 input 单行摘要（终端折叠行展示用） */
-export function summarizeToolInput(input: unknown, maxChars = 120): string {
-  let raw: string;
-  if (typeof input === "string") {
-    raw = input;
-  } else {
-    try {
-      raw = JSON.stringify(input);
-    } catch {
-      raw = String(input);
-    }
-  }
-  const oneLine = raw.replace(/\s+/g, " ").trim();
-  return oneLine.length > maxChars ? oneLine.slice(0, maxChars) + "…" : oneLine;
-}
-
-/** 工具结果单行摘要（成功/失败各取首行） */
-export function summarizeToolResult(content: unknown, maxChars = 120): string {
-  let raw: string;
-  if (typeof content === "string") {
-    raw = content;
-  } else if (content instanceof Error) {
-    raw = content.message;
-  } else {
-    try {
-      raw = JSON.stringify(content);
-    } catch {
-      raw = String(content);
-    }
-  }
-  const firstLine = raw.split("\n")[0] ?? "";
-  return firstLine.length > maxChars ? firstLine.slice(0, maxChars) + "…" : firstLine;
-}
-
-/**
- * 把一条 ChatEvent 合并进 ProgressView，返回新视图（不可变更新）。
- * 未识别的/不影响展示的事件（如 compact）返回原视图。
- */
-export function reduceProgress(prev: ProgressView, event: ChatEvent): ProgressView {
-  switch (event.type) {
-    case "status":
-      return withProgressView(prev, {
-        headerTitle: event.phase === "compacting" ? "压缩上下文中..." : "生成回复中...",
-      });
-
-    case "text":
-      // accumulated 是全文累积，直接全量替换，天然幂等
-      return withProgressView(prev, { text: event.accumulated });
-
-    case "tool_use": {
-      const tool: ProgressToolCall = {
-        id: event.id ?? `tool-${prev.tools.length + 1}`,
-        name: event.name,
-        status: "running",
-        detail: summarizeToolInput(event.input),
-      };
-      return withProgressView(prev, { tools: [...prev.tools, tool] });
-    }
-
-    case "tool_result": {
-      const nextStatus = event.is_error ? ("error" as const) : ("ok" as const);
-      const summary = summarizeToolResult(event.content);
-      let matched = false;
-      const tools = prev.tools.map((t) => {
-        if (matched || t.id !== event.tool_use_id) return t;
-        matched = true;
-        return { ...t, status: nextStatus, summary };
-      });
-      if (!matched) {
-        // id 缺失或失配：兜底更新最后一个 running 工具，避免状态悬挂
-        const lastRunning = [...prev.tools].reverse().findIndex((t) => t.status === "running");
-        if (lastRunning >= 0) {
-          const idx = prev.tools.length - 1 - lastRunning;
-          const updated = prev.tools.map((t, i) =>
-            i === idx ? { ...t, status: nextStatus, summary } : t,
-          );
-          return withProgressView(prev, { tools: updated });
-        }
-      }
-      return withProgressView(prev, { tools });
-    }
-
-    case "done":
-      return withProgressView(prev, {
-        status: "done",
-        showStop: false,
-        text: event.text,
-      });
-
-    case "error":
-      return withProgressView(prev, { status: "error", showStop: false });
-
-    case "compact":
-      // 旧上下文压缩不影响当前过程展示
-      return prev;
-  }
-}

package/src/progress/terminal-renderer.ts

@@ -1,294 +0,0 @@
-/**
- * progress/terminal-renderer.ts — 终端"过程区块"渲染器
- *
- * 把 ProgressView 渲染为终端里的一块固定区域（对应飞书过程卡片）：
- *   - 状态行：生成中 / 完成 / 已停止 / 异常结束
- *   - 工具行：每个工具调用一行（emoji + 名称 + ✓/✗ + 摘要），不再滚屏刷 JSON
- *   - 正文行：模型流式输出，原地更新不滚动
- *
- * 实现要点：
- *   - 隐藏光标（\x1b[?25l）→ 每帧整块重绘（\x1b[{n}A 上移 + \x1b[2K 清行 + \x1b[J 清下方）
- *   - 帧节流合并重绘，避免高频文本增量导致闪烁
- *   - 每行按显示宽度截断（CJK/emoji 算 2 列），保证永不折行：一旦折行，
- *     实际占用的屏幕行数会超过 blockLines 计数，下次重绘上移行数不足，
- *     会清掉区块上方的历史内容（用户输入的问题被"吃掉"）。
- *   - end() 时把终态区块定型留在屏幕上（与飞书完成卡片留在消息流语义一致），恢复光标
- */
-
-import { getToolEmoji, truncateContent } from "../cards.ts";
-import { progressView, type ProgressToolCall, type ProgressView } from "./view.ts";
-
-const RESET = "\x1b[0m";
-const DIM = "\x1b[2m";
-const BOLD = "\x1b[1m";
-const GREEN = "\x1b[32m";
-const YELLOW = "\x1b[33m";
-const RED = "\x1b[31m";
-
-const HIDE_CURSOR = "\x1b[?25l";
-const SHOW_CURSOR = "\x1b[?25h";
-
-/** 生成中标题后的心跳点号动画帧（1 → 2 → 3 → 2 循环，避免跳变感） */
-const ANIM_FRAMES = ["·", "··", "···", "··"];
-
-const ANSI_TOKEN = /\x1b\[[0-9;]*m/;
-
-/** 单个字符在终端里的显示列宽：CJK/emoji 占 2 列，控制符/ZWJ/变体选择符占 0 列 */
-export function charWidth(ch: string): number {
-  const code = ch.codePointAt(0)!;
-  if (code < 32 || (code >= 0x7f && code <= 0xa0)) return 0; // 控制字符
-  if (code === 0x200d || code === 0xfe0e || code === 0xfe0f) return 0; // ZWJ / VS15 / VS16
-  if (
-    (code >= 0x1100 && code <= 0x115f) || // 谚文 Jamo
-    (code >= 0x2e80 && code <= 0x303f) || // CJK 部首 / 标点
-    (code >= 0x3040 && code <= 0xa4cf) || // 假名 / 汉字 / 谚文 / 彝文
-    (code >= 0xac00 && code <= 0xd7a3) || // 谚文音节
-    (code >= 0xf900 && code <= 0xfaff) || // CJK 兼容汉字
-    (code >= 0xfe30 && code <= 0xfe6f) || // CJK 兼容形式
-    (code >= 0xff00 && code <= 0xff60) || // 全角形式
-    (code >= 0xffe0 && code <= 0xffe6) || // 全角符号
-    (code >= 0x2600 && code <= 0x27bf) || // 杂项符号 + Dingbats（emoji 呈现 2 列）
-    (code >= 0x1f000 && code <= 0x1faff)  // emoji 补充区
-  ) {
-    return 2;
-  }
-  return 1;
-}
-
-/**
- * 按终端显示宽度截断一行（CJK/emoji 计 2 列），ANSI 序列零宽且永不截断。
- * 截断位置若处于未闭合的颜色状态，自动补 \x1b[0m，避免颜色泄漏到后续输出。
- */
-export function clipToWidth(s: string, maxCols: number): string {
-  if (maxCols <= 0) return "";
-  let out = "";
-  let visible = 0;
-  let colorOpen = false;
-  let i = 0;
-  while (i < s.length) {
-    if (s.charCodeAt(i) === 0x1b) {
-      const m = ANSI_TOKEN.exec(s.slice(i));
-      if (m && m.index === 0) {
-        out += m[0];
-        colorOpen = m[0] !== "\x1b[0m";
-        i += m[0].length;
-        continue;
-      }
-    }
-    const cp = s.codePointAt(i)!;
-    const ch = String.fromCodePoint(cp);
-    const w = charWidth(ch);
-    if (visible + w > maxCols) break;
-    out += ch;
-    visible += w;
-    i += ch.length;
-  }
-  if (colorOpen) out += "\x1b[0m";
-  return out;
-}
-
-export interface TerminalRendererOptions {
-  /** 输出流，默认 process.stdout */
-  out?: NodeJS.WritableStream & { columns?: number };
-  /** 帧节流毫秒数，默认 66（约 15fps） */
-  frameMs?: number;
-  /** 生成中心跳动画毫秒数，默认 300；<=0 禁用动画 */
-  animMs?: number;
-  /** 正文最大行数（超出截断，保留首行+末段） */
-  maxBodyLines?: number;
-  /** 正文最大字符数 */
-  maxBodyChars?: number;
-}
-
-function buildStatusLine(view: ProgressView): string {
-  switch (view.status) {
-    case "done":
-      return `${BOLD}${GREEN}✅ 完成${RESET}`;
-    case "stopped":
-      return `${YELLOW}⏹ 已停止${RESET}`;
-    case "error":
-      return `${RED}❌ 异常结束${RESET}`;
-    case "generating": {
-      const hint = view.showStop ? `${DIM}  ·  Ctrl+C 停止${RESET}` : "";
-      return `⏳ ${view.headerTitle}${hint}`;
-    }
-  }
-}
-
-function buildToolLine(tool: ProgressToolCall): string {
-  const emoji = getToolEmoji(tool.name);
-  const mark =
-    tool.status === "running"
-      ? "…"
-      : tool.status === "ok"
-        ? `${GREEN}✓${RESET}`
-        : `${RED}✗${RESET}`;
-  const info = tool.status === "running" ? (tool.detail ?? "") : (tool.summary ?? "");
-  // 摘要/详情用正常色：最终区块里不出现浅色文字（可读性优先）
-  return `  ${emoji} ${tool.name} ${mark} ${info}`;
-}
-
-/**
- * 把 ProgressView 展开为区块的完整行列表（不含 ANSI 定位序列，只含内容与颜色）。
- * 单独导出便于单元测试；每行按终端宽度截断，避免长行折行导致行数计数失准。
- */
-export function buildBlockLines(
-  view: ProgressView,
-  width: number,
-  maxBodyLines = 30,
-  maxBodyChars = 12000,
-): string[] {
-  const clip = (s: string) => clipToWidth(s, width);
-  const lines: string[] = [];
-  lines.push(clip(buildStatusLine(view)));
-  for (const tool of view.tools) {
-    lines.push(clip(buildToolLine(tool)));
-  }
-  const body = truncateContent(view.text, maxBodyLines, maxBodyChars);
-  if (body.trim()) {
-    for (const line of body.split("\n")) {
-      lines.push(clip(line));
-    }
-  } else {
-    lines.push(`${DIM}等待 Agent 输出...${RESET}`);
-  }
-  return lines;
-}
-
-export class TerminalProgressRenderer {
-  private readonly out: NodeJS.WritableStream & { columns?: number };
-  private readonly frameMs: number;
-  private readonly animMs: number;
-  private readonly maxBodyLines: number;
-  private readonly maxBodyChars: number;
-  private view: ProgressView;
-  private blockLines = 0;
-  private dirty = false;
-  private timer: NodeJS.Timeout | null = null;
-  private ended = false;
-  private animFrame = 0;
-  private animTimer: NodeJS.Timeout | null = null;
-
-  constructor(opts: TerminalRendererOptions = {}) {
-    this.out = opts.out ?? process.stdout;
-    this.frameMs = opts.frameMs ?? 66;
-    this.animMs = opts.animMs ?? 300;
-    this.maxBodyLines = opts.maxBodyLines ?? 30;
-    this.maxBodyChars = opts.maxBodyChars ?? 12000;
-    this.view = progressView();
-  }
-
-  /** 开始一轮区块：隐藏光标并渲染首帧，随后启动生成中心跳动画 */
-  begin(view: ProgressView): void {
-    this.view = view;
-    this.out.write(HIDE_CURSOR);
-    this.renderNow(view);
-    this.startAnimation();
-  }
-
-  /** 标记视图已更新，按帧节流合并重绘（高频增量不闪烁） */
-  render(view: ProgressView): void {
-    this.view = view;
-    if (this.ended) return;
-    this.dirty = true;
-    if (this.timer) return;
-    this.timer = setTimeout(() => {
-      this.timer = null;
-      if (this.dirty && !this.ended) {
-        this.dirty = false;
-        this.renderNow(this.view);
-      }
-    }, this.frameMs);
-  }
-
-  /** 强制立即重绘（工具结果、终态等低频率但需及时反馈的事件） */
-  flush(): void {
-    if (this.timer) {
-      clearTimeout(this.timer);
-      this.timer = null;
-    }
-    if (this.ended) return;
-    this.dirty = false;
-    this.renderNow(this.view);
-  }
-
-  /** 结束一轮：定型终态区块（留在屏幕上），恢复光标，停止动画 */
-  end(view: ProgressView): void {
-    if (this.timer) {
-      clearTimeout(this.timer);
-      this.timer = null;
-    }
-    this.stopAnimation();
-    this.ended = true;
-    this.renderNow(view);
-    this.out.write(SHOW_CURSOR);
-  }
-
-  /** 兜底清理：清除未决定时器并恢复光标 */
-  dispose(): void {
-    if (this.timer) {
-      clearTimeout(this.timer);
-      this.timer = null;
-    }
-    this.stopAnimation();
-    if (!this.ended) {
-      this.out.write(SHOW_CURSOR);
-    }
-  }
-
-  private startAnimation(): void {
-    if (this.animMs <= 0 || this.animTimer) return;
-    this.animTimer = setInterval(() => {
-      this.animFrame++;
-      // 终态（done/stopped/error）由 end() 停止；此处兜底跳过，避免结束后还在重绘
-      if (this.ended || this.view.status !== "generating") return;
-      // 无新事件也持续重绘，点号动画让静止期（思考/工具运行中）也有动态感
-      this.renderNow(this.view);
-    }, this.animMs);
-    this.animTimer.unref?.();
-  }
-
-  private stopAnimation(): void {
-    if (this.animTimer) {
-      clearInterval(this.animTimer);
-      this.animTimer = null;
-    }
-  }
-
-  private renderNow(view: ProgressView): void {
-    const width = this.out.columns && this.out.columns > 0 ? this.out.columns : 80;
-    const lines = buildBlockLines(this.applyAnimation(view), width, this.maxBodyLines, this.maxBodyChars);
-    const newLines = lines.length;
-
-    if (this.blockLines > 0) {
-      // 关键：光标此刻停在区块【最后一行】行尾，回到区块第一行只需上移
-      // blockLines - 1 行。上移 blockLines 行会每帧多上移 1 行，把区块上方
-      // 的历史内容逐行"吃掉"（用户看到的"一行一行往上吃"）。
-      this.out.write(`\x1b[${this.blockLines - 1}A`);
-      this.out.write("\r");
-    }
-    for (let i = 0; i < lines.length; i++) {
-      this.out.write(`\r\x1b[2K${lines[i]}`);
-      if (i < lines.length - 1) {
-        this.out.write("\n");
-      }
-    }
-    if (newLines < this.blockLines) {
-      // 新区块比旧区块短：清掉下方多出的行
-      this.out.write("\n");
-      for (let i = 0; i < this.blockLines - newLines; i++) {
-        this.out.write("\x1b[2K\n");
-      }
-    }
-    this.out.write("\x1b[J");
-    this.blockLines = newLines;
-  }
-
-  /** 生成中阶段在标题后叠加心跳点号动画；终态原样返回（buildBlockLines 保持纯函数可测） */
-  private applyAnimation(view: ProgressView): ProgressView {
-    if (view.status !== "generating") return view;
-    const base = view.headerTitle.replace(/\.\.\.\s*$/, "").trim();
-    const dots = ANIM_FRAMES[this.animFrame % ANIM_FRAMES.length];
-    return { ...view, headerTitle: `${base} ${dots}` };
-  }
-}

package/src/progress/view.ts

@@ -1,77 +0,0 @@
-/**
- * progress/view.ts — 平台无关的"过程进度"视图模型
- *
- * 这是飞书过程卡片与终端过程区块共享的唯一数据模型：
- *  - 飞书：buildProgressCard(view) 把 ProgressView 渲染为卡片 JSON
- *  - 终端：TerminalProgressRenderer 把 ProgressView 渲染为 ANSI 区块
- *  - 事件流：reduceProgress(prev, event) 把 ChatEvent 增量合并进 ProgressView
- *
- * 语义与飞书卡片对齐：
- *  - headerTitle 是"生成中"阶段展示的标题（如"正在启动 Agent · 0秒"）
- *  - status 决定终态外观（完成 / 已停止 / 异常结束）
- *  - text 是正文累积（对应卡片 main_content / 终端区块正文）
- *  - tools 是本轮工具调用列表（飞书卡片暂不展示，终端折叠为单行）
- */
-
-export type ProgressStatus = "generating" | "done" | "stopped" | "error";
-
-export type ProgressToolStatus = "running" | "ok" | "error";
-
-export interface ProgressToolCall {
-  /** 工具调用 ID（ChatEvent.tool_use.id，可能缺失） */
-  id: string;
-  /** 工具名，如 edit_file */
-  name: string;
-  status: ProgressToolStatus;
-  /** 工具输入摘要（终端折叠行展示，截断保存） */
-  detail?: string;
-  /** 工具结果摘要（成功/失败，截断保存） */
-  summary?: string;
-}
-
-export interface ProgressView {
-  /** 当前阶段状态，决定终态外观 */
-  status: ProgressStatus;
-  /** 生成中阶段的头部标题（对应飞书卡片 header title） */
-  headerTitle: string;
-  /** 卡片头部颜色模板（飞书用），终端忽略 */
-  headerTemplate: string;
-  /** 正文累积内容 */
-  text: string;
-  /** 本轮工具调用列表 */
-  tools: ProgressToolCall[];
-  /** 是否展示停止按钮 / 停止提示 */
-  showStop: boolean;
-  /** 最近一次更新时间戳 */
-  updatedAt: number;
-}
-
-export interface ProgressViewInit {
-  status?: ProgressStatus;
-  headerTitle?: string;
-  headerTemplate?: string;
-  text?: string;
-  tools?: ProgressToolCall[];
-  showStop?: boolean;
-}
-
-/** 创建 ProgressView，未提供的字段使用与飞书 buildProgressCard 一致的默认值 */
-export function progressView(init: ProgressViewInit = {}): ProgressView {
-  return {
-    status: init.status ?? "generating",
-    headerTitle: init.headerTitle ?? "生成中...",
-    headerTemplate: init.headerTemplate ?? "blue",
-    text: init.text ?? "",
-    tools: init.tools ?? [],
-    showStop: init.showStop ?? true,
-    updatedAt: Date.now(),
-  };
-}
-
-/** 只读浅拷贝并覆盖部分字段，返回新视图（reducer 的不可变更新用） */
-export function withProgressView(
-  prev: ProgressView,
-  patch: Partial<ProgressView>,
-): ProgressView {
-  return { ...prev, ...patch, updatedAt: Date.now() };
-}