chatccc 0.2.251 → 0.2.253

package/deepccc-agent/src/__tests__/permissions.test.ts

@@ -1,199 +0,0 @@
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-const testHome = vi.hoisted(() => ({ dir: "" }));
-
-const aiMocks = vi.hoisted(() => ({
-  streamText: vi.fn(),
-  generateText: vi.fn(),
-}));
-
-vi.mock("node:os", async () => {
-  const actual = await vi.importActual<typeof import("node:os")>("node:os");
-  const [{ mkdtempSync }, { join }] = await Promise.all([import("node:fs"), import("node:path")]);
-  testHome.dir = mkdtempSync(join(actual.tmpdir(), "chatccc-builtin-perm-"));
-  return { ...actual, homedir: () => testHome.dir };
-});
-
-vi.mock("@ai-sdk/openai-compatible", () => ({
-  createOpenAICompatible: vi.fn(() => (modelId: string) => ({ modelId })),
-}));
-
-vi.mock("@ai-sdk/anthropic", () => ({
-  createAnthropic: vi.fn(() => (modelId: string) => ({ modelId })),
-}));
-
-vi.mock("ai", () => ({
-  streamText: aiMocks.streamText,
-  generateText: aiMocks.generateText,
-  isLoopFinished: vi.fn(() => ({ loopFinished: true })),
-  stepCountIs: vi.fn((count: number) => ({ count })),
-  jsonSchema: vi.fn((schema: unknown) => schema),
-  tool: vi.fn((definition: unknown) => definition),
-}));
-
-vi.mock("../raw-stream-log.js", () => ({
-  createRawStreamLog: vi.fn().mockResolvedValue(null),
-}));
-
-import {
-  PermissionGate,
-  getAllowRules,
-  isDangerousCommand,
-  matchRule,
-  reloadAllowRules,
-} from "../permissions.js";
-import { createBuiltinFileTools } from "../file-tools.js";
-import { ChatSession } from "../index.js";
-
-const streamTextMock = aiMocks.streamText;
-const generateTextMock = aiMocks.generateText;
-
-const ALLOW_FILE = () => join(testHome.dir, ".deepccc", "allow.json");
-
-async function collect(iterable: AsyncIterable<unknown>): Promise<unknown[]> {
-  const events: unknown[] = [];
-  for await (const event of iterable) events.push(event);
-  return events;
-}
-
-async function* textStream(...chunks: string[]): AsyncIterable<string> {
-  for (const chunk of chunks) yield chunk;
-}
-
-function lastRunCommandExecute(): (input: { command: string }, opts?: unknown) => Promise<unknown> {
-  const call = streamTextMock.mock.calls.at(-1)?.[0] as { tools?: Record<string, { execute?: unknown }> };
-  const execute = call?.tools?.run_command?.execute as ((input: { command: string }, opts?: unknown) => Promise<unknown>) | undefined;
-  if (!execute) throw new Error("streamText was not called with tools.run_command.execute");
-  return execute;
-}
-
-afterEach(() => {
-  try {
-    rmSync(ALLOW_FILE(), { force: true });
-  } catch {}
-  reloadAllowRules();
-  streamTextMock.mockReset();
-  generateTextMock.mockReset();
-});
-
-beforeEach(() => {
-  try {
-    rmSync(join(testHome.dir, ".deepccc"), { recursive: true, force: true });
-  } catch {}
-  mkdirSync(join(testHome.dir, ".deepccc"), { recursive: true });
-  reloadAllowRules();
-});
-
-describe("builtin permissions module", () => {
-  it("flags destructive commands and ignores normal ones", () => {
-    expect(isDangerousCommand("rm -rf node_modules")).toBe(true);
-    expect(isDangerousCommand("git push --force origin main")).toBe(true);
-    expect(isDangerousCommand("git status")).toBe(false);
-    expect(isDangerousCommand("npm test")).toBe(false);
-  });
-
-  it("matches allow/deny rules with wildcards and relative paths", () => {
-    expect(matchRule("run_command:git status*", "run_command:git status --short")).toBe(true);
-    expect(matchRule("edit_file:node_modules/**", "edit_file:node_modules/a/b.js")).toBe(true);
-    expect(matchRule("run_command:npm test", "run_command:npm test extra")).toBe(false);
-  });
-
-  it("returns empty rules when allow.json is missing", () => {
-    expect(getAllowRules()).toEqual({ allow: [], deny: [] });
-  });
-
-  it("loads rules from ~/.deepccc/allow.json", () => {
-    writeFileSync(ALLOW_FILE(), JSON.stringify({ deny: ["run_command:npm publish*"] }), "utf-8");
-    reloadAllowRules();
-    expect(getAllowRules().deny).toEqual(["run_command:npm publish*"]);
-  });
-});
-
-describe("builtin PermissionGate", () => {
-  it("bypass mode allows everything", async () => {
-    const gate = new PermissionGate("bypass");
-    expect(await gate.check({ tool: "run_command", action: "rm -rf /", reason: "high-risk", detail: "x" })).toBe("allow");
-  });
-
-  it("ask mode denies high-risk without resolver", async () => {
-    const gate = new PermissionGate("ask");
-    expect(await gate.check({ tool: "run_command", action: "rm -rf x", reason: "high-risk", detail: "x" })).toBe("deny");
-  });
-
-  it("ask mode allows non-high-risk operations without asking", async () => {
-    const resolver = vi.fn();
-    const gate = new PermissionGate("ask", resolver as never);
-    expect(await gate.check({ tool: "run_command", action: "npm test", reason: "rule", detail: "x" })).toBe("allow");
-    expect(await gate.check({ tool: "edit_file", action: "src/a.ts", reason: "rule", detail: "x" })).toBe("allow");
-    expect(resolver).not.toHaveBeenCalled();
-  });
-
-  it("follows resolver answer", async () => {
-    let answer: "allow" | "deny" = "allow";
-    const gate = new PermissionGate("ask", async () => answer);
-    expect(await gate.check({ tool: "run_command", action: "rm -rf x", reason: "high-risk", detail: "x" })).toBe("allow");
-    answer = "deny";
-    expect(await gate.check({ tool: "run_command", action: "rm -rf x", reason: "high-risk", detail: "x" })).toBe("deny");
-  });
-
-  it("deny rule wins over allow rule", async () => {
-    writeFileSync(
-      ALLOW_FILE(),
-      JSON.stringify({ allow: ["run_command:rm -rf /tmp*"], deny: ["run_command:rm -rf /tmp/forbidden*"] }),
-      "utf-8",
-    );
-    reloadAllowRules();
-    const gate = new PermissionGate("ask");
-    expect(await gate.check({ tool: "run_command", action: "rm -rf /tmp/forbidden/x", reason: "high-risk", detail: "x" })).toBe("deny");
-  });
-});
-
-describe("builtin file-tools permission integration", () => {
-  it("run_command high-risk is denied by default gate", async () => {
-    const tools = createBuiltinFileTools(testHome.dir, { permissionGate: new PermissionGate("ask") });
-    const tool = tools.run_command as unknown as {
-      execute: (input: { command: string }, opts?: unknown) => Promise<unknown>;
-    };
-    await expect(tool.execute({ command: "rm -rf node_modules" }, { abortSignal: undefined })).rejects.toThrow(/权限拒绝/);
-  });
-
-  it("no gate keeps original behavior", async () => {
-    const tools = createBuiltinFileTools(testHome.dir);
-    const tool = tools.run_command as unknown as {
-      execute: (input: { command: string }, opts?: unknown) => Promise<{ exitCode: number | null }>;
-    };
-    const result = await tool.execute({ command: "node -e \"console.log('ok')\"" }, { abortSignal: undefined });
-    expect(result.exitCode).toBe(0);
-  });
-});
-
-describe("builtin ChatSession permission integration", () => {
-  it("permissionMode bypass lets high-risk run_command execute", async () => {
-    const session = new ChatSession(
-      { apiKey: "sk-test" },
-      { sessionId: "perm-bypass", permissionMode: "bypass" },
-    );
-    streamTextMock.mockReturnValueOnce({ textStream: textStream("hi") });
-    await collect(session.chat("hi"));
-
-    const result = (await lastRunCommandExecute()({ command: "node -e \"console.log('ok')\"" }, { abortSignal: undefined })) as { exitCode: number };
-    expect(result.exitCode).toBe(0);
-  });
-
-  it("default ask mode without resolver denies high-risk run_command", async () => {
-    const session = new ChatSession(
-      { apiKey: "sk-test" },
-      { sessionId: "perm-ask" },
-    );
-    streamTextMock.mockReturnValueOnce({ textStream: textStream("hi") });
-    await collect(session.chat("hi"));
-
-    await expect(
-      lastRunCommandExecute()({ command: "rm -rf node_modules" }, { abortSignal: undefined }),
-    ).rejects.toThrow(/权限拒绝/);
-  });
-});

package/deepccc-agent/src/__tests__/privacy.test.ts

@@ -1,318 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, afterAll, vi } from "vitest";
-import { mkdirSync, rmSync, writeFileSync, mkdtempSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-const privacyState = vi.hoisted(() => ({ dir: "" }));
-
-const aiMocks = vi.hoisted(() => ({
-  streamText: vi.fn(),
-  generateText: vi.fn(),
-}));
-
-vi.mock("../config.js", async () => {
-  const actual = await vi.importActual<typeof import("../config.js")>("../config.js");
-  const [{ mkdtempSync }, { tmpdir }, { join }] = await Promise.all([
-    import("node:fs"),
-    import("node:os"),
-    import("node:path"),
-  ]);
-  const dir = mkdtempSync(join(tmpdir(), "deepccc-privacy-test-"));
-  privacyState.dir = dir;
-  return {
-    ...actual,
-    DEEPCCC_HOME: dir,
-  };
-});
-
-vi.mock("@ai-sdk/openai-compatible", () => ({
-  createOpenAICompatible: vi.fn(() => (modelId: string) => ({ modelId })),
-}));
-
-vi.mock("@ai-sdk/anthropic", () => ({
-  createAnthropic: vi.fn(() => (modelId: string) => ({ modelId })),
-}));
-
-vi.mock("ai", () => ({
-  streamText: aiMocks.streamText,
-  generateText: aiMocks.generateText,
-  isLoopFinished: vi.fn(() => ({ loopFinished: true })),
-  stepCountIs: vi.fn((count: number) => ({ count })),
-  jsonSchema: vi.fn((schema: unknown) => schema),
-  tool: vi.fn((definition: unknown) => definition),
-}));
-
-vi.mock("../raw-stream-log.js", () => ({
-  createRawStreamLog: vi.fn().mockResolvedValue(null),
-}));
-
-import { config } from "../config.js";
-import {
-  applyPrivacy,
-  applyPrivacyToJson,
-  getPrivacyConfig,
-  getPrivacyRules,
-  reloadPrivacyRules,
-} from "../privacy.js";
-import { ChatSession } from "../index.js";
-
-const streamTextMock = aiMocks.streamText;
-const generateTextMock = aiMocks.generateText;
-
-const originalRawStreamLogs = structuredClone(config.rawStreamLogs);
-const originalStreaming = config.streaming;
-const PRIVACY_FILE = join(privacyState.dir, "privacy.json");
-
-function writePrivacy(content: string): void {
-  writeFileSync(PRIVACY_FILE, content, "utf-8");
-}
-
-async function collect(iterable: AsyncIterable<unknown>): Promise<unknown[]> {
-  const events: unknown[] = [];
-  for await (const event of iterable) events.push(event);
-  return events;
-}
-
-async function* fullStream(...parts: unknown[]): AsyncIterable<unknown> {
-  for (const part of parts) yield part;
-}
-
-beforeEach(() => {
-  try {
-    rmSync(PRIVACY_FILE, { force: true });
-  } catch {}
-  reloadPrivacyRules();
-  streamTextMock.mockReset();
-  generateTextMock.mockReset();
-  config.rawStreamLogs = structuredClone(originalRawStreamLogs);
-  config.streaming = true;
-});
-
-afterEach(() => {
-  try {
-    rmSync(PRIVACY_FILE, { force: true });
-  } catch {}
-  reloadPrivacyRules();
-  config.streaming = originalStreaming;
-});
-
-afterAll(() => {
-  try {
-    rmSync(privacyState.dir, { recursive: true, force: true });
-  } catch {}
-});
-
-describe("applyPrivacy", () => {
-  it("returns original text when privacy.json is missing", () => {
-    expect(applyPrivacy("hello weizhangjian")).toBe("hello weizhangjian");
-  });
-
-  it("supports legacy flat privacy rules", () => {
-    writePrivacy(JSON.stringify({ weizhangjian: "wzj", secret: "***" }));
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("hello weizhangjian")).toBe("hello wzj");
-    expect(applyPrivacy("my secret is safe")).toBe("my *** is safe");
-    expect(applyPrivacy("weizhangjian and secret")).toBe("wzj and ***");
-  });
-
-  it("supports privacy.json schema with enabled=false", () => {
-    writePrivacy(JSON.stringify({ enabled: false, rules: { weizhangjian: "wzj" } }));
-    reloadPrivacyRules();
-
-    expect(getPrivacyConfig()).toEqual({ enabled: false, rules: { weizhangjian: "wzj" } });
-    expect(getPrivacyRules()).toEqual({ weizhangjian: "wzj" });
-    expect(applyPrivacy("hello weizhangjian")).toBe("hello weizhangjian");
-  });
-
-  it("supports privacy.json schema with enabled=true", () => {
-    writePrivacy(JSON.stringify({ enabled: true, rules: { weizhangjian: "wzj" } }));
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("hello weizhangjian")).toBe("hello wzj");
-  });
-
-  it("accepts UTF-8 BOM in privacy.json", () => {
-    writePrivacy(`\uFEFF${JSON.stringify({ enabled: false, rules: { weizhangjian: "wzj" } })}`);
-    reloadPrivacyRules();
-
-    expect(getPrivacyConfig()).toEqual({ enabled: false, rules: { weizhangjian: "wzj" } });
-    expect(applyPrivacy("hello weizhangjian")).toBe("hello weizhangjian");
-  });
-
-  it("auto reloads privacy.json changes without explicit reload", () => {
-    writePrivacy(JSON.stringify({ weizhangjian: "wzj" }));
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("hello weizhangjian")).toBe("hello wzj");
-
-    writePrivacy(JSON.stringify({ enabled: false, rules: { weizhangjian: "wzj-disabled" } }));
-
-    expect(applyPrivacy("hello weizhangjian")).toBe("hello weizhangjian");
-    expect(getPrivacyConfig()).toEqual({ enabled: false, rules: { weizhangjian: "wzj-disabled" } });
-  });
-
-  it("replaces multiple rules and repeated occurrences", () => {
-    writePrivacy(JSON.stringify({ a: "A", b: "B" }));
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("a b a b")).toBe("A B A B");
-  });
-
-  it("returns empty text directly", () => {
-    writePrivacy(JSON.stringify({ x: "y" }));
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("")).toBe("");
-  });
-
-  it("treats special characters in rule keys literally", () => {
-    writePrivacy(JSON.stringify({ "a.b": "X", "(test)": "Y", "*star": "Z" }));
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("hello a.b world")).toBe("hello X world");
-    expect(applyPrivacy("text (test) here")).toBe("text Y here");
-    expect(applyPrivacy("a *star shines")).toBe("a Z shines");
-  });
-
-  it("reloadPrivacyRules forces a reload", () => {
-    writePrivacy(JSON.stringify({ old: "OLD" }));
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("old")).toBe("OLD");
-    expect(getPrivacyRules()).toEqual({ old: "OLD" });
-
-    writePrivacy(JSON.stringify({ new: "NEW" }));
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("new")).toBe("NEW");
-    expect(getPrivacyRules()).toEqual({ new: "NEW" });
-  });
-
-  it("returns original text for malformed JSON", () => {
-    writePrivacy("not json");
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("hello")).toBe("hello");
-  });
-
-  it("returns original text for array JSON", () => {
-    writePrivacy(JSON.stringify(["a", "b"]));
-    reloadPrivacyRules();
-
-    expect(applyPrivacy("hello")).toBe("hello");
-  });
-});
-
-describe("applyPrivacyToJson", () => {
-  it("recursively replaces string fields in nested objects and arrays", () => {
-    writePrivacy(JSON.stringify({ weizhangjian: "wzj" }));
-    reloadPrivacyRules();
-
-    expect(applyPrivacyToJson({ path: "C:\\Users\\weizhangjian\\repo", tags: ["a-weizhangjian"] })).toEqual({
-      path: "C:\\Users\\wzj\\repo",
-      tags: ["a-wzj"],
-    });
-  });
-
-  it("leaves non-string values unchanged", () => {
-    writePrivacy(JSON.stringify({ weizhangjian: "wzj" }));
-    reloadPrivacyRules();
-
-    expect(applyPrivacyToJson({ n: 1, ok: true, nil: null, obj: { n: 2 } })).toEqual({
-      n: 1,
-      ok: true,
-      nil: null,
-      obj: { n: 2 },
-    });
-  });
-
-  it("returns value unchanged when privacy is disabled", () => {
-    writePrivacy(JSON.stringify({ enabled: false, rules: { weizhangjian: "wzj" } }));
-    reloadPrivacyRules();
-
-    expect(applyPrivacyToJson({ path: "C:\\Users\\weizhangjian" })).toEqual({ path: "C:\\Users\\weizhangjian" });
-  });
-});
-
-describe("ChatSession privacy integration", () => {
-  it("replaces privacy tokens in text, done, tool_use and tool_result events", async () => {
-    writePrivacy(JSON.stringify({ enabled: true, rules: { weizhangjian: "wzj" } }));
-    reloadPrivacyRules();
-
-    const session = new ChatSession(
-      { apiKey: "sk-test" },
-      { sessionId: "privacy-integration" },
-    );
-
-    streamTextMock.mockReturnValueOnce({
-      fullStream: fullStream(
-        { type: "tool-call", toolCallId: "call-1", toolName: "read_file", input: { path: "C:\\Users\\weizhangjian\\repo\\a.txt" } },
-        { type: "tool-result", toolCallId: "call-1", toolName: "read_file", output: { content: "C:\\Users\\weizhangjian\\repo\\a.txt" } },
-        { type: "text-delta", text: "see " },
-        { type: "text-delta", text: "C:\\Users\\weizhangjian\\repo" },
-      ),
-    });
-
-    const events = await collect(session.chat("read the file"));
-
-    expect(events).toContainEqual({
-      type: "tool_use",
-      id: "call-1",
-      name: "read_file",
-      input: { path: "C:\\Users\\wzj\\repo\\a.txt" },
-    });
-    expect(events).toContainEqual({
-      type: "tool_result",
-      tool_use_id: "call-1",
-      name: "read_file",
-      content: { content: "C:\\Users\\wzj\\repo\\a.txt" },
-      is_error: false,
-    });
-    expect(events).toContainEqual({
-      type: "text",
-      text: "see ",
-      accumulated: "see ",
-    });
-    expect(events).toContainEqual({
-      type: "text",
-      text: "C:\\Users\\wzj\\repo",
-      accumulated: "see C:\\Users\\wzj\\repo",
-    });
-    expect(events).toContainEqual({
-      type: "done",
-      text: "see C:\\Users\\wzj\\repo",
-    });
-  });
-
-  it("keeps the original text in persisted history (display-only replacement)", async () => {
-    writePrivacy(JSON.stringify({ enabled: true, rules: { weizhangjian: "wzj" } }));
-    reloadPrivacyRules();
-
-    const session = new ChatSession(
-      { apiKey: "sk-test" },
-      { persist: true, sessionId: "privacy-history" },
-    );
-    streamTextMock.mockReturnValueOnce({ textStream: (async function* () { yield "C:\\Users\\weizhangjian\\repo"; })() });
-
-    await collect(session.chat("hi"));
-
-    expect(streamTextMock).toHaveBeenCalledOnce();
-    expect(session.history.map((m) => m.content).join("\n")).toContain("C:\\Users\\weizhangjian\\repo");
-  });
-
-  it("does not replace text when privacy is disabled", async () => {
-    writePrivacy(JSON.stringify({ enabled: false, rules: { weizhangjian: "wzj" } }));
-    reloadPrivacyRules();
-
-    const session = new ChatSession(
-      { apiKey: "sk-test" },
-      { sessionId: "privacy-disabled" },
-    );
-    streamTextMock.mockReturnValueOnce({ textStream: (async function* () { yield "C:\\Users\\weizhangjian\\repo"; })() });
-
-    const events = await collect(session.chat("hi"));
-
-    expect(events).toContainEqual({ type: "done", text: "C:\\Users\\weizhangjian\\repo" });
-  });
-});

package/deepccc-agent/src/__tests__/progress-reducer.test.ts

@@ -1,121 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import type { ChatEvent } from "../index.js";
-import { reduceProgress, summarizeToolInput, summarizeToolResult } from "../progress/reducer.js";
-import { progressView } from "../progress/view.js";
-
-function feed(events: ChatEvent[]) {
-  return events.reduce(reduceProgress, progressView({ headerTitle: "生成中..." }));
-}
-
-describe("reduceProgress", () => {
-  it("renders explicit compaction and generation phases", () => {
-    const compacting = reduceProgress(
-      progressView({ headerTitle: "Generating..." }),
-      { type: "status", phase: "compacting" },
-    );
-    expect(compacting.headerTitle).toBe("压缩上下文中...");
-
-    const generating = reduceProgress(compacting, { type: "status", phase: "generating" });
-    expect(generating.headerTitle).toBe("生成回复中...");
-  });
-
-  it("accumulates text via accumulated field", () => {
-    const view = feed([
-      { type: "text", text: "Hello", accumulated: "Hello" },
-      { type: "text", text: " world", accumulated: "Hello world" },
-    ]);
-    expect(view.text).toBe("Hello world");
-    expect(view.status).toBe("generating");
-    expect(view.showStop).toBe(true);
-  });
-
-  it("appends tool_use as running and resolves status on tool_result", () => {
-    const view = feed([
-      { type: "tool_use", id: "t1", name: "edit_file", input: { path: "a.ts" } },
-      { type: "tool_result", tool_use_id: "t1", name: "edit_file", content: "ok", is_error: false },
-    ]);
-    expect(view.tools).toHaveLength(1);
-    expect(view.tools[0]).toMatchObject({
-      id: "t1",
-      name: "edit_file",
-      status: "ok",
-      summary: "ok",
-    });
-  });
-
-  it("marks tool as error when is_error is true", () => {
-    const view = feed([
-      { type: "tool_use", id: "t2", name: "run_command", input: { command: "npm test" } },
-      { type: "tool_result", tool_use_id: "t2", name: "run_command", content: "boom", is_error: true },
-    ]);
-    expect(view.tools[0].status).toBe("error");
-    expect(view.tools[0].summary).toBe("boom");
-  });
-
-  it("falls back to last running tool when tool_use_id mismatches", () => {
-    const view = feed([
-      { type: "tool_use", id: undefined, name: "list_dir", input: {} },
-      { type: "tool_result", tool_use_id: "unknown-id", name: "list_dir", content: "ok", is_error: false },
-    ]);
-    expect(view.tools[0].status).toBe("ok");
-  });
-
-  it("keeps multiple tool calls independently", () => {
-    const view = feed([
-      { type: "tool_use", id: "a", name: "read_file", input: { path: "a" } },
-      { type: "tool_use", id: "b", name: "read_file", input: { path: "b" } },
-      { type: "tool_result", tool_use_id: "b", name: "read_file", content: "bb", is_error: false },
-    ]);
-    expect(view.tools[0].status).toBe("running");
-    expect(view.tools[1].status).toBe("ok");
-  });
-
-  it("marks done: status done, showStop false, text finalized", () => {
-    const view = feed([
-      { type: "text", text: "part", accumulated: "part" },
-      { type: "done", text: "final answer" },
-    ]);
-    expect(view.status).toBe("done");
-    expect(view.showStop).toBe(false);
-    expect(view.text).toBe("final answer");
-  });
-
-  it("marks error status and keeps text", () => {
-    const view = feed([
-      { type: "text", text: "x", accumulated: "x" },
-      { type: "error", message: "boom" },
-    ]);
-    expect(view.status).toBe("error");
-    expect(view.showStop).toBe(false);
-    expect(view.text).toBe("x");
-  });
-
-  it("ignores compact events without changing the view identity", () => {
-    const base = progressView({ headerTitle: "生成中..." });
-    const result = reduceProgress(base, { type: "compact", compactedMessages: 5 });
-    expect(result).toBe(base);
-  });
-
-  it("does not mutate the previous view (immutable updates)", () => {
-    const base = progressView({ headerTitle: "生成中..." });
-    const next = reduceProgress(base, { type: "text", text: "hi", accumulated: "hi" });
-    expect(base.text).toBe("");
-    expect(next.text).toBe("hi");
-    expect(next).not.toBe(base);
-  });
-});
-
-describe("summarizeToolInput / summarizeToolResult", () => {
-  it("flattens multiline input to one line", () => {
-    const s = summarizeToolInput({ path: "a\nb", big: "x".repeat(200) });
-    expect(s).not.toContain("\n");
-    expect(s.length).toBeLessThanOrEqual(121);
-    expect(s.endsWith("…")).toBe(true);
-  });
-
-  it("takes first line of result content", () => {
-    expect(summarizeToolResult("line1\nline2\n")).toBe("line1");
-    expect(summarizeToolResult({ ok: true })).toBe('{"ok":true}');
-  });
-});