chatccc 0.2.252 → 0.2.253

package/src/simplify.ts

@@ -1,120 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { resolve as resolvePath } from "node:path";
-import { PROJECT_ROOT } from "./config.ts";
-
-// ---------------------------------------------------------------------------
-// 消息简化规则 —— 数据驱动，在 simplify.json 中配置
-// ---------------------------------------------------------------------------
-
-interface ToolRule {
-  template: string;
-  maxLength: number;
-}
-
-interface SimplifyConfig {
-  tool_use?: Record<string, ToolRule>;
-  tool_result?: Record<string, ToolRule>;
-}
-
-let config: SimplifyConfig | null = null;
-let loaded = false;
-
-function loadConfig(): SimplifyConfig {
-  const filePath = resolvePath(PROJECT_ROOT, "simplify.json");
-  if (!existsSync(filePath)) return {};
-  try {
-    const raw = readFileSync(filePath, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-      console.error("[SIMPLIFY] simplify.json 格式错误：应为对象");
-      return {};
-    }
-    return parsed as SimplifyConfig;
-  } catch (err) {
-    console.error(`[SIMPLIFY] 读取 simplify.json 失败: ${(err as Error).message}`);
-    return {};
-  }
-}
-
-function getConfig(): SimplifyConfig {
-  if (!loaded) {
-    config = loadConfig();
-    loaded = true;
-  }
-  return config!;
-}
-
-/** 热重载 */
-export function reloadSimplifyConfig(): void {
-  loaded = false;
-  config = null;
-}
-
-/**
- * 对模板字符串中的 {field} 占位符做替换。
- * fields 为可用字段映射，extra 是额外的上下文（如 tool_use_id 的 id）。
- */
-function resolveTemplate(template: string, fields: Record<string, unknown>, extra?: Record<string, string>): string {
-  let result = template;
-  if (extra) {
-    for (const [k, v] of Object.entries(extra)) {
-      result = result.split(`{${k}}`).join(v);
-    }
-  }
-  for (const [k, v] of Object.entries(fields)) {
-    const strVal = typeof v === "string" ? v : JSON.stringify(v);
-    result = result.split(`{${k}}`).join(strVal);
-  }
-  return result;
-}
-
-/**
- * 简化 tool_use 展示。
- * 返回 null 表示无规则，调用方应回退到默认格式化。
- */
-export function simplifyToolUse(name: string, input: unknown): string | null {
-  const cfg = getConfig();
-  const rules = cfg.tool_use;
-  if (!rules) return null;
-  const rule = rules[name];
-  if (!rule) return null;
-
-  const fields = typeof input === "object" && input !== null
-    ? input as Record<string, unknown>
-    : {};
-  let result = resolveTemplate(rule.template, fields);
-  if (result.length > rule.maxLength) {
-    result = result.slice(0, rule.maxLength) + "...";
-  }
-  return result;
-}
-
-/**
- * 简化 tool_result 展示。
- * 返回 null 表示无规则，调用方应回退到默认格式化。
- * toolCallInput 为对应的 tool_use 输入（可选），用于在 result 模板中引用输入字段。
- */
-export function simplifyToolResult(
-  name: string,
-  toolUseId: string,
-  isError: boolean,
-  toolCallInput?: unknown,
-): string | null {
-  const cfg = getConfig();
-  const rules = cfg.tool_result;
-  if (!rules) return null;
-  const rule = rules[name];
-  if (!rule) return null;
-
-  const id = toolUseId.slice(-6);
-  const extra = { id };
-  const fields = toolCallInput && typeof toolCallInput === "object"
-    ? toolCallInput as Record<string, unknown>
-    : {};
-  let result = resolveTemplate(rule.template, fields, extra);
-  if (isError) result = "❌ " + result;
-  if (result.length > rule.maxLength) {
-    result = result.slice(0, rule.maxLength) + "...";
-  }
-  return result;
-}

package/src/startup-lifecycle.ts

@@ -1,250 +0,0 @@
-import { spawn, type ChildProcess } from "node:child_process";
-
-const DEFAULT_SERVICE_HEALTH_INTERVAL_MS = 10_000;
-
-interface RefTimer {
-  ref?: () => unknown;
-}
-
-export interface ServiceLifecycleServer {
-  listening: boolean;
-  address: () => unknown;
-  ref: () => unknown;
-}
-
-interface ServiceLifecycleGuardOptions {
-  intervalMs?: number;
-  setIntervalImpl?: (callback: () => void, delayMs: number) => RefTimer;
-  clearIntervalImpl?: (timer: RefTimer) => void;
-  tracer?: (message: string, extra?: Record<string, unknown>) => void;
-  getActiveResourcesInfo?: () => string[];
-}
-
-export interface ServiceLifecycleGuard {
-  start: () => void;
-  attachServer: (
-    server: ServiceLifecycleServer,
-    recoverServer?: () => void | Promise<void>,
-  ) => void;
-  checkNow: () => Promise<void>;
-  handleBeforeExit: (code: number) => void;
-  beginShutdown: (reason: string) => void;
-}
-
-/**
- * 为 ChatCCC 这种常驻服务建立一个明确的进程生命周期锚点。
- *
- * 正常情况下，正在 listen 的 HTTP Server 自己就足以维持事件循环；额外的
- * referenced timer 是最后一道保险，避免某个依赖升级或异常 close/unref 让进程在
- * 没有信号、异常或退出码的情况下静默消失。定时检查同时会重新 ref Server，并在
- * Server 确实停止监听时串行触发恢复，避免只把一个失去服务能力的僵尸进程留下来。
- */
-export function createServiceLifecycleGuard(
-  options: ServiceLifecycleGuardOptions = {},
-): ServiceLifecycleGuard {
-  const intervalMs = options.intervalMs ?? DEFAULT_SERVICE_HEALTH_INTERVAL_MS;
-  const setIntervalImpl = options.setIntervalImpl
-    ?? ((callback, delayMs) => setInterval(callback, delayMs));
-  const clearIntervalImpl = options.clearIntervalImpl
-    ?? ((timer) => clearInterval(timer as NodeJS.Timeout));
-  const tracer = options.tracer ?? (() => {});
-  const getActiveResourcesInfo = options.getActiveResourcesInfo
-    ?? (() => process.getActiveResourcesInfo());
-
-  let timer: RefTimer | null = null;
-  let server: ServiceLifecycleServer | null = null;
-  let recoverServer: (() => void | Promise<void>) | undefined;
-  let recoveryPromise: Promise<void> | null = null;
-  let shuttingDown = false;
-
-  const trace = (message: string, extra?: Record<string, unknown>): void => {
-    try { tracer(message, extra); } catch { /* 诊断路径不能反过来打断服务 */ }
-  };
-
-  const serverAddress = (): unknown => {
-    try { return server?.address() ?? null; } catch { return null; }
-  };
-
-  const activeResources = (): string[] => {
-    try { return getActiveResourcesInfo(); } catch { return []; }
-  };
-
-  const diagnostics = (extra: Record<string, unknown> = {}): Record<string, unknown> => ({
-    ...extra,
-    uptimeSeconds: Math.floor(process.uptime()),
-    activeResources: activeResources(),
-    serverAttached: server !== null,
-    serverListening: server?.listening ?? false,
-    serverAddress: serverAddress(),
-  });
-
-  const start = (): void => {
-    if (shuttingDown || timer) return;
-    timer = setIntervalImpl(() => { void checkNow(); }, intervalMs);
-    // Node 的 Timeout 默认就是 ref 状态；显式 ref 让常驻服务契约不会依赖默认值。
-    try { timer.ref?.(); } catch { /* ignore */ }
-    trace("service-lifecycle: guard started", { intervalMs });
-  };
-
-  const checkNow = async (): Promise<void> => {
-    if (shuttingDown || !server) return;
-    if (server.listening) {
-      try { server.ref(); } catch (err) {
-        trace("service-lifecycle: HTTP server ref failed", diagnostics({
-          error: (err as Error).message,
-        }));
-      }
-      return;
-    }
-
-    if (recoveryPromise) return recoveryPromise;
-    trace("service-lifecycle: HTTP server inactive", diagnostics());
-    if (!recoverServer) return;
-
-    recoveryPromise = Promise.resolve()
-      .then(() => recoverServer?.())
-      .then(() => {
-        if (server?.listening) {
-          try { server.ref(); } catch { /* 下一轮健康检查会再次尝试 */ }
-          trace("service-lifecycle: HTTP server recovered", diagnostics());
-        } else {
-          trace("service-lifecycle: HTTP recovery completed without listening", diagnostics());
-        }
-      })
-      .catch((err: unknown) => {
-        trace("service-lifecycle: HTTP server recovery failed", diagnostics({
-          error: err instanceof Error ? err.message : String(err),
-        }));
-      })
-      .finally(() => {
-        recoveryPromise = null;
-      });
-    return recoveryPromise;
-  };
-
-  const attachServer = (
-    nextServer: ServiceLifecycleServer,
-    nextRecoverServer?: () => void | Promise<void>,
-  ): void => {
-    server = nextServer;
-    recoverServer = nextRecoverServer;
-    if (server.listening) {
-      try { server.ref(); } catch { /* 下一轮健康检查会记录 */ }
-    }
-    trace("service-lifecycle: HTTP server attached", diagnostics());
-  };
-
-  const handleBeforeExit = (code: number): void => {
-    if (shuttingDown) return;
-    trace("service-lifecycle: unexpected beforeExit", diagnostics({ code }));
-    start();
-    void checkNow();
-  };
-
-  const beginShutdown = (reason: string): void => {
-    if (shuttingDown) return;
-    shuttingDown = true;
-    if (timer) {
-      try { clearIntervalImpl(timer); } catch { /* process 即将退出 */ }
-      timer = null;
-    }
-    trace("service-lifecycle: shutdown requested", { reason });
-  };
-
-  return { start, attachServer, checkNow, handleBeforeExit, beginShutdown };
-}
-
-/**
- * ChatCCC 自己拉起替代进程时使用的内部标记。
- *
- * 不能用“是否已有配置”判断是否打开控制台：首次配置和日常直接启动都应该
- * 打开，而 `/restart`、`/update` 和 Web UI 重启都不应该打扰用户。环境变量
- * 会自然穿过 cmd/bash/npx 这几层启动器，因此也适用于 Windows 与 Linux。
- */
-export const INTERNAL_RESTART_ENV_VAR = "CHATCCC_INTERNAL_RESTART";
-
-type Environment = Record<string, string | undefined>;
-
-export function createInternalRestartEnv(
-  inherited: Environment = process.env,
-): NodeJS.ProcessEnv {
-  return {
-    ...inherited,
-    [INTERNAL_RESTART_ENV_VAR]: "1",
-  };
-}
-
-/** 用户直接启动时打开；ChatCCC 内部重启产生的替代进程不打开。 */
-interface AutoOpenWebUiOptions {
-  env?: Environment;
-  openOnStart?: boolean;
-}
-
-export function shouldAutoOpenWebUi(options: AutoOpenWebUiOptions = {}): boolean {
-  const env = options.env ?? process.env;
-  return options.openOnStart !== false && env[INTERNAL_RESTART_ENV_VAR] !== "1";
-}
-
-/** Web UI 始终使用 localhost，并跟随实际配置端口。 */
-export function buildWebUiUrl(port: number): string {
-  return `http://localhost:${port}/`;
-}
-
-interface OpenBrowserDeps {
-  platform?: NodeJS.Platform;
-  env?: Environment;
-  spawnImpl?: typeof spawn;
-  onError?: (message: string) => void;
-  onInfo?: (message: string) => void;
-}
-
-/**
- * 调用操作系统默认浏览器打开 Web UI，与 Chrome CDP 守护功能完全独立。
- * 返回值仅表示打开请求是否成功发起；浏览器是否复用标签页由系统浏览器决定。
- */
-export function openWebUiInDefaultBrowser(
-  port: number,
-  deps: OpenBrowserDeps = {},
-): boolean {
-  const url = buildWebUiUrl(port);
-  const platform = deps.platform ?? process.platform;
-  const env = deps.env ?? process.env;
-  const spawnImpl = deps.spawnImpl ?? spawn;
-  const onError = deps.onError ?? ((message: string) => console.error(message));
-  const onInfo = deps.onInfo ?? ((message: string) => console.log(message));
-
-  // Linux 服务器通常没有图形会话。此时调用 xdg-open 只会制造噪音；
-  // 直接给出可复制的 SSH 隧道命令，让用户从自己的电脑访问本地 Web UI。
-  if (platform === "linux" && !env.DISPLAY && !env.WAYLAND_DISPLAY) {
-    onInfo(
-      `[WEB-UI] 未检测到 Linux 图形桌面，跳过自动打开浏览器。` +
-      `可在本机执行 ssh -L ${port}:127.0.0.1:${port} <user>@<server>，` +
-      `然后访问 ${url}`,
-    );
-    return false;
-  }
-
-  try {
-    let child: ChildProcess;
-    if (platform === "win32") {
-      // `start` 会把第一个带引号的参数当窗口标题，空字符串是必要占位符。
-      child = spawnImpl("cmd.exe", ["/c", "start", "", url], {
-        detached: true,
-        stdio: "ignore",
-        windowsHide: true,
-      });
-    } else if (platform === "darwin") {
-      child = spawnImpl("open", [url], { detached: true, stdio: "ignore" });
-    } else {
-      child = spawnImpl("xdg-open", [url], { detached: true, stdio: "ignore" });
-    }
-    child.on("error", (err) => {
-      onError(`[WEB-UI] 自动打开浏览器失败: ${err.message}`);
-    });
-    child.unref();
-    return true;
-  } catch (err) {
-    onError(`[WEB-UI] 自动打开浏览器失败: ${(err as Error).message}`);
-    return false;
-  }
-}

package/src/stream-state.ts

@@ -1,177 +0,0 @@
-import { readFile, writeFile, mkdir, rename, unlink } from "node:fs/promises";
-import { dirname, join } from "node:path";
-
-import { USER_DATA_DIR, ts } from "./config.ts";
-import { createAgentActivityTracker } from "./agent-activity.ts";
-import type { AgentActivity } from "./agent-activity.ts";
-import type { TerminalErrorInfo } from "./terminal-error.ts";
-
-// ---------------------------------------------------------------------------
-// stream-state.json — 每个 session 的流式输出持久化文件
-// ---------------------------------------------------------------------------
-
-export const STREAMS_DIR = join(USER_DATA_DIR, "state", "streams");
-
-export interface StreamState {
-  sessionId: string;
-  status: "running" | "done" | "stopped" | "error" | "auto_ended";
-  accumulatedContent: string;
-  /** 本轮会话中 LLM 输出的全部文本内容（所有 text block 的累加）。
-   *  命名含 "final" 但实为"全部累积文本"，并非仅"最终一段回复"。
-   *  参见 session.ts 的 AccumulatorState 注释。 */
-  finalReply: string;
-  /** Current user-visible work phase for running progress cards. */
-  activity?: AgentActivity;
-  /** The turn whose terminal text reply has already been delivered to IM. */
-  finalReplySentTurn?: number;
-  finalReplySentAt?: number;
-  chunkCount: number;
-  turnCount: number;
-  contextTokens: number;
-  updatedAt: number;
-  cwd: string;
-  tool: string;
-  /** Set by stop-stuck-loop to prevent the session from being resumed.
-   *  The orchestrator checks this before resuming and creates a new session instead. */
-  stuckAt?: number;
-  /** Set when the shared response watchdog ends a turn after three minutes without new characters. */
-  autoEndedAt?: number;
-  /** 脱敏后的用户可见根因；完整原始异常只保留在运行日志中。 */
-  terminalError?: TerminalErrorInfo;
-}
-
-function getStreamStatePath(sessionId: string): string {
-  return join(STREAMS_DIR, `${sessionId}.json`);
-}
-
-export async function readStreamState(sessionId: string): Promise<StreamState | null> {
-  try {
-    const raw = await readFile(getStreamStatePath(sessionId), "utf-8");
-    const parsed = JSON.parse(raw) as StreamState;
-    if (parsed && typeof parsed.sessionId === "string") return parsed;
-    return null;
-  } catch {
-    return null;
-  }
-}
-
-// rename 的可注入实现——仅供测试模拟"Windows EPERM 降级"路径。
-// 生产代码使用 node:fs/promises.rename。
-let renameImpl: typeof rename = rename;
-
-/**
- * 仅供单测：注入自定义 rename 实现以验证降级分支。
- * 调用方负责测试结束后用 _resetRenameForTest 还原。
- */
-export function _setRenameForTest(impl: typeof rename): void {
-  renameImpl = impl;
-}
-
-export function _resetRenameForTest(): void {
-  renameImpl = rename;
-}
-
-/**
- * 把 StreamState 持久化到磁盘——尽量原子地写。
- *
- * 为什么需要原子写：display loop 每 3 秒读一次 stream-state.json,而
- * runAgentSession 每 2 秒写一次。如果用 `writeFile(filePath, ...)` 直接
- * 覆盖,reader 在写入过程中读会拿到半截 JSON,JSON.parse 报错——虽然
- * readStreamState 包了 try/catch 返回 null 不会崩,但相当于"丢一帧"。
- *
- * 实现：
- *   1) 先把内容写到 `<filePath>.tmp`（reader 不会读 .tmp）
- *   2) 再用 `rename` 把 .tmp 替换成正式文件——`rename` 在 POSIX 上是真原子
- *      操作,reader 任何时刻读到的都是某个完整的旧/新版本
- *
- * Windows 兼容性：Windows 上 `rename` 偶尔会因为目标文件正被 reader 打开
- * 抛 EPERM/EBUSY（实测罕见,但非零概率）。降级方案：直接 writeFile 覆盖
- * 真文件,这一帧可能被 reader 读到半截,但 readStreamState 的 try/catch 兜底
- * 会让 loop 跳过这一帧,2 秒后下次 write 大概率成功——比写盘失败丢数据好。
- */
-export async function writeStreamState(state: StreamState): Promise<void> {
-  const filePath = getStreamStatePath(state.sessionId);
-  const payload = JSON.stringify(state, null, 2);
-  try {
-    await mkdir(dirname(filePath), { recursive: true });
-    const tmpPath = filePath + ".tmp";
-    await writeFile(tmpPath, payload, "utf-8");
-    try {
-      await renameImpl(tmpPath, filePath);
-    } catch (renameErr) {
-      // Windows 偶发 EPERM/EBUSY：rename 失败时降级为直接覆盖写。
-      // 此次写入失去原子性（reader 可能读到半截 JSON,但 readStreamState
-      // 的 try/catch 会兜底返回 null,只是丢一帧 display 更新）。
-      console.warn(
-        `[${ts()}] [STREAM-STATE] rename failed for ${state.sessionId}, ` +
-          `fallback to overwrite: ${(renameErr as Error).message}`,
-      );
-      await writeFile(filePath, payload, "utf-8");
-      // 尽力清理 .tmp,失败也无所谓——下次 write 会覆盖它
-      await unlink(tmpPath).catch(() => {});
-    }
-  } catch (err) {
-    console.error(`[${ts()}] Failed to write stream-state for ${state.sessionId}: ${(err as Error).message}`);
-  }
-}
-
-export function isFinalReplySentForTurn(state: Pick<StreamState, "turnCount" | "finalReplySentTurn">): boolean {
-  return state.finalReplySentTurn === state.turnCount;
-}
-
-export async function markFinalReplySent(sessionId: string, turnCount: number, sentAt = Date.now()): Promise<void> {
-  const state = await readStreamState(sessionId);
-  if (!state) return;
-  if (state.turnCount !== turnCount) return;
-  if (state.status === "running") return;
-
-  state.finalReplySentTurn = turnCount;
-  state.finalReplySentAt = sentAt;
-  state.updatedAt = Date.now();
-  await writeStreamState(state);
-}
-
-export function createEmptyStreamState(sessionId: string, cwd: string, tool: string, turnCount: number): StreamState {
-  const now = Date.now();
-  return {
-    sessionId,
-    status: "running",
-    accumulatedContent: "",
-    finalReply: "",
-    activity: createAgentActivityTracker(now).activity,
-    chunkCount: 0,
-    turnCount,
-    contextTokens: 0,
-    updatedAt: now,
-    cwd,
-    tool,
-  };
-}
-
-/** 进程重启时修正虚假的 "running" 状态 */
-export async function fixStaleStreamStates(): Promise<void> {
-  // 启动时将残留的 running 标记为 error
-  // 实际 agent 进程已不存在，下次 prompt 时会自然覆盖
-  try {
-    const { readdir } = await import("node:fs/promises");
-    let entries: string[];
-    try {
-      entries = await readdir(STREAMS_DIR);
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      if (!entry.endsWith(".json")) continue;
-      const state = await readStreamState(entry.replace(".json", ""));
-      if (state && state.status === "running") {
-        state.status = "error";
-        state.accumulatedContent += "\n\n⚠️ 进程重启，流式输出中断。";
-        state.updatedAt = Date.now();
-        await writeStreamState(state);
-        console.log(`[${ts()}] [STREAM-STATE] marked stale running as error: ${state.sessionId}`);
-      }
-    }
-  } catch (err) {
-    console.error(`[${ts()}] [STREAM-STATE] fixStaleStreamStates failed: ${(err as Error).message}`);
-  }
-}

package/src/terminal-error.ts

@@ -1,129 +0,0 @@
-/** 用户可见的终态错误。这里只保存脱敏摘要；完整原始异常继续只写运行日志。 */
-export type TerminalErrorKind =
-  | "network_timeout"
-  | "network"
-  | "authentication"
-  | "rate_limit"
-  | "provider"
-  | "process"
-  | "resource"
-  | "unknown";
-
-export interface TerminalErrorInfo {
-  kind: TerminalErrorKind;
-  title: string;
-  message: string;
-  occurredAt: number;
-}
-
-const MAX_UNKNOWN_ERROR_LENGTH = 300;
-
-function errorMessage(error: unknown): string {
-  if (error instanceof Error) return error.message;
-  if (typeof error === "string") return error;
-  try {
-    return JSON.stringify(error);
-  } catch {
-    return String(error);
-  }
-}
-
-/**
- * 未分类错误仍应给出可诊断线索，但不能把常见凭据带进群聊或持久化状态。
- * 已分类错误使用固定文案，不复述地址、请求体或 provider 原始响应。
- */
-export function sanitizeTerminalErrorDetail(raw: string): string {
-  return raw
-    .replace(/\bBearer\s+[^\s,;]+/gi, "Bearer [已脱敏]")
-    .replace(/\b(api[_-]?key|access[_-]?token|token|secret)\s*[:=]\s*[^\s,;]+/gi, "$1=[已脱敏]")
-    .replace(/\bsk-[A-Za-z0-9._-]{6,}\b/g, "sk-[已脱敏]")
-    .replace(/([?&](?:api[_-]?key|access[_-]?token|token|secret)=)[^&\s]+/gi, "$1[已脱敏]")
-    .slice(0, MAX_UNKNOWN_ERROR_LENGTH);
-}
-
-function parsePositiveInt(message: string, pattern: RegExp): number | undefined {
-  const value = Number.parseInt(message.match(pattern)?.[1] ?? "", 10);
-  return Number.isFinite(value) && value > 0 ? value : undefined;
-}
-
-function formatSeconds(milliseconds: number): string {
-  if (milliseconds % 1000 === 0) return `${milliseconds / 1000} 秒`;
-  return `${milliseconds} 毫秒`;
-}
-
-export function classifyTerminalError(error: unknown, occurredAt = Date.now()): TerminalErrorInfo {
-  const raw = errorMessage(error);
-  const lower = raw.toLowerCase();
-  const attempts = parsePositiveInt(raw, /\bafter\s+(\d+)\s+attempts?\b/i);
-  const timeoutMs = parsePositiveInt(raw, /\btimeout\s*:\s*(\d+)\s*ms\b/i);
-
-  if (/\b429\b|rate[ _-]?limit|too many requests/.test(lower)) {
-    return {
-      kind: "rate_limit",
-      title: "请求受到限流",
-      message: "模型服务请求受到限流，请稍后重试。",
-      occurredAt,
-    };
-  }
-
-  if (/\b401\b|\b403\b|unauthori[sz]ed|forbidden|invalid api key|authentication/.test(lower)) {
-    return {
-      kind: "authentication",
-      title: "模型服务鉴权失败",
-      message: "模型服务拒绝了当前凭据，请检查 API Key、账号权限或凭据是否过期。",
-      occurredAt,
-    };
-  }
-
-  if (
-    /connect timeout|connection timed out|etimedout|und_err_connect_timeout/.test(lower)
-    || (lower.includes("cannot connect") && lower.includes("timeout"))
-  ) {
-    const retryText = attempts ? `，已重试 ${attempts} 次` : "";
-    const timeoutText = timeoutMs ? `，单次连接等待 ${formatSeconds(timeoutMs)}` : "";
-    return {
-      kind: "network_timeout",
-      title: "网络连接超时",
-      message: `连接模型服务失败${retryText}${timeoutText}。请检查网络、VPN或模型服务状态后重试。`,
-      occurredAt,
-    };
-  }
-
-  if (/econnrefused|econnreset|enotfound|eai_again|socket hang up|network error|cannot connect/.test(lower)) {
-    return {
-      kind: "network",
-      title: "无法连接模型服务",
-      message: "与模型服务的网络连接失败，请检查网络、VPN、DNS或服务状态后重试。",
-      occurredAt,
-    };
-  }
-
-  const httpStatus = raw.match(/\b(?:HTTP\s*)?(5\d\d)\b/i)?.[1];
-  if (httpStatus || /service unavailable|bad gateway|gateway timeout|provider error/.test(lower)) {
-    return {
-      kind: "provider",
-      title: "模型服务暂时不可用",
-      message: `模型服务返回异常${httpStatus ? `（HTTP ${httpStatus}）` : ""}，请稍后重试。`,
-      occurredAt,
-    };
-  }
-
-  const safeDetail = sanitizeTerminalErrorDetail(raw).trim() || "未提供错误详情";
-  return {
-    kind: "unknown",
-    title: "Agent 执行错误",
-    message: `发生未分类错误：${safeDetail}`,
-    occurredAt,
-  };
-}
-
-export function formatTerminalErrorReason(error: TerminalErrorInfo): string {
-  return `⚠️ 异常结束：${error.title}\n${error.message}`;
-}
-
-export function formatTerminalErrorNotice(error: TerminalErrorInfo, finalReply = ""): string {
-  const reason = formatTerminalErrorReason(error);
-  return finalReply.trim()
-    ? `${reason}\n\n以下回复可能不完整：\n\n${finalReply.trim()}`
-    : reason;
-}