chatccc 0.2.226 → 0.2.227

package/src/__tests__/builtin-chat-session.test.ts

@@ -1,350 +1,350 @@
-import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-import { config } from "../builtin/config.ts";
-
-const streamTextMock = vi.fn();
-const generateTextMock = vi.fn();
-const createRawStreamLogMock = vi.fn();
-const rawLogWriteLineMock = vi.fn();
-const rawLogCloseMock = vi.fn();
-const originalRawStreamLogs = structuredClone(config.rawStreamLogs);
-
-vi.mock("@ai-sdk/openai-compatible", () => ({
-  createOpenAICompatible: vi.fn(() => (modelId: string) => ({ modelId })),
-}));
-
-vi.mock("ai", () => ({
-  streamText: streamTextMock,
-  generateText: generateTextMock,
-  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("../builtin/raw-stream-log.ts", () => ({
-  createRawStreamLog: createRawStreamLogMock,
-}));
-
-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;
-}
-
-async function* fullStream(...parts: unknown[]): AsyncIterable<unknown> {
-  for (const part of parts) yield part;
-}
-
-afterEach(() => {
-  streamTextMock.mockReset();
-  generateTextMock.mockReset();
-  createRawStreamLogMock.mockReset();
-  rawLogWriteLineMock.mockReset();
-  rawLogCloseMock.mockReset();
-  config.rawStreamLogs = structuredClone(originalRawStreamLogs);
-});
-
-describe("ChatSession codex-style skills", () => {
-  it("injects skill index into system prompt from skillsDirs", async () => {
-    const { ChatSession } = await import("../builtin/index.ts");
-    const dir = await mkdtemp(join(tmpdir(), "chatccc-session-skills-"));
-    const skillsDir = join(dir, ".codex", "skills");
-    await mkdir(join(skillsDir, "demo-skill"), { recursive: true });
-    await writeFile(
-      join(skillsDir, "demo-skill", "SKILL.md"),
-      "---\nname: demo-skill\ndescription: 演示技能\n---\n\n# 演示",
-      "utf-8",
-    );
-    streamTextMock.mockReturnValueOnce({ textStream: textStream() });
-
-    const session = new ChatSession(
-      { apiKey: "sk-test" },
-      { cwd: dir, sessionId: "skill-index", skillsDirs: [skillsDir] },
-    );
-    await collect(session.chat("hi"));
-
-    const system = streamTextMock.mock.calls.at(-1)?.[0].system as string;
-    expect(system).toContain("## Available Skills");
-    expect(system).toContain("demo-skill");
-    expect(system).toContain("演示技能");
-  });
-
-  it("skips skill injection when no skills are found", async () => {
-    const { ChatSession } = await import("../builtin/index.ts");
-    const dir = await mkdtemp(join(tmpdir(), "chatccc-session-no-skills-"));
-    streamTextMock.mockReturnValueOnce({ textStream: textStream() });
-
-    const session = new ChatSession(
-      { apiKey: "sk-test" },
-      { cwd: dir, sessionId: "no-skills", skillsDirs: [join(dir, "missing")] },
-    );
-    await collect(session.chat("hi"));
-
-    const system = streamTextMock.mock.calls.at(-1)?.[0].system as string;
-    expect(system).not.toContain("## Available Skills");
-  });
-});
-describe("ChatSession context management", () => {
-  it("injects cwd project instruction files before runtime workspace details", async () => {
-    const { ChatSession } = await import("../builtin/index.ts");
-    const dir = await mkdtemp(join(tmpdir(), "chatccc-session-instructions-"));
-    await writeFile(join(dir, "AGENTS.md"), "agents root guidance", "utf-8");
-    await writeFile(join(dir, "AGENTS.local.md"), "agents local guidance", "utf-8");
-    await writeFile(join(dir, "CLAUDE.md"), "claude root guidance", "utf-8");
-    await writeFile(join(dir, "CLAUDE.local.md"), "claude local guidance", "utf-8");
-    streamTextMock.mockReturnValueOnce({ textStream: textStream() });
-
-    const session = new ChatSession(
-      { apiKey: "sk-test" },
-      {
-        cwd: dir,
-        sessionId: "project-instructions",
-      },
-    );
-    await collect(session.chat("hi"));
-
-    const system = streamTextMock.mock.calls.at(-1)?.[0].system as string;
-    expect(system).toContain("## Project Instructions");
-    expect(system).toContain("### AGENTS.md");
-    expect(system).toContain("agents root guidance");
-    expect(system).toContain("### AGENTS.local.md");
-    expect(system).toContain("agents local guidance");
-    expect(system).toContain("### CLAUDE.md");
-    expect(system).toContain("claude root guidance");
-    expect(system).toContain("### CLAUDE.local.md");
-    expect(system).toContain("claude local guidance");
-
-    expect(system.indexOf("agents root guidance")).toBeLessThan(system.indexOf("agents local guidance"));
-    expect(system.indexOf("agents local guidance")).toBeLessThan(system.indexOf("claude root guidance"));
-    expect(system.indexOf("claude root guidance")).toBeLessThan(system.indexOf("claude local guidance"));
-    expect(system.indexOf("claude local guidance")).toBeLessThan(system.indexOf(dir));
-  });
-
-  it("does not read project instruction files from parent directories", async () => {
-    const { ChatSession } = await import("../builtin/index.ts");
-    const parent = await mkdtemp(join(tmpdir(), "chatccc-session-parent-instructions-"));
-    const child = join(parent, "child");
-    await mkdir(child);
-    await writeFile(join(parent, "AGENTS.md"), "parent-only guidance", "utf-8");
-    streamTextMock.mockReturnValueOnce({ textStream: textStream() });
-
-    const session = new ChatSession(
-      { apiKey: "sk-test" },
-      {
-        cwd: child,
-        sessionId: "no-parent-instructions",
-      },
-    );
-    await collect(session.chat("hi"));
-
-    const system = streamTextMock.mock.calls.at(-1)?.[0].system as string;
-    expect(system).not.toContain("parent-only guidance");
-  });
-
-  it("uses loop-finished stopping by default", async () => {
-    const { ChatSession } = await import("../builtin/index.ts");
-    const dir = await mkdtemp(join(tmpdir(), "chatccc-session-unlimited-"));
-    streamTextMock.mockReturnValueOnce({ textStream: textStream("done") });
-
-    const session = new ChatSession(
-      { apiKey: "sk-test" },
-      {
-        cwd: dir,
-        sessionId: "unlimited-steps",
-      },
-    );
-    await collect(session.chat("run a multi-stage workflow"));
-
-    expect(streamTextMock).toHaveBeenLastCalledWith(expect.objectContaining({
-      stopWhen: { loopFinished: true },
-    }));
-  });
-
-  it("uses a configured tool step limit when provided", async () => {
-    const { ChatSession } = await import("../builtin/index.ts");
-    const dir = await mkdtemp(join(tmpdir(), "chatccc-session-step-budget-"));
-    streamTextMock.mockReturnValueOnce({ textStream: textStream("done") });
-
-    const session = new ChatSession(
-      { apiKey: "sk-test" },
-      {
-        cwd: dir,
-        sessionId: "step-budget",
-        maxSteps: 7,
-      },
-    );
-    await collect(session.chat("run a bounded workflow"));
-
-    expect(streamTextMock).toHaveBeenLastCalledWith(expect.objectContaining({
-      stopWhen: { count: 7 },
-    }));
-  });
-
-  it("loads persisted context, compacts older messages, and persists the new assistant reply", async () => {
-    const { ChatSession } = await import("../builtin/index.ts");
-    const dir = await mkdtemp(join(tmpdir(), "chatccc-session-context-"));
-
-    const seed = new ChatSession(
-      { apiKey: "sk-test" },
-      {
-        persist: true,
-        contextDir: dir,
-        sessionId: "integration",
-        compactAtTokens: 10_000,
-      },
-    );
-    streamTextMock.mockReturnValueOnce({ textStream: textStream("old answer") });
-    await collect(seed.chat("old question"));
-
-    generateTextMock.mockResolvedValueOnce({ text: "## 当前任务状态\n- 旧问题已总结" });
-    streamTextMock.mockReturnValueOnce({ textStream: textStream("new answer") });
-
-    const restored = new ChatSession(
-      { apiKey: "sk-test" },
-      {
-        persist: true,
-        contextDir: dir,
-        sessionId: "integration",
-        compactAtTokens: 1,
-        keepRecentMessages: 1,
-      },
-    );
-    const events = await collect(restored.chat("new question"));
-
-    expect(generateTextMock).toHaveBeenCalledOnce();
-    expect(streamTextMock).toHaveBeenLastCalledWith(expect.objectContaining({
-      messages: expect.arrayContaining([
-        expect.objectContaining({ content: expect.stringContaining("旧问题已总结") }),
-        expect.objectContaining({ role: "user", content: "new question" }),
-      ]),
-    }));
-    expect(events).toContainEqual({ type: "compact", compactedMessages: 2 });
-    expect(restored.history.map((m) => m.content).join("\n")).toContain("new answer");
-  });
-
-  it("streams tool calls and tool results from fullStream", async () => {
-    const { ChatSession } = await import("../builtin/index.ts");
-    const dir = await mkdtemp(join(tmpdir(), "chatccc-session-tools-"));
-    const session = new ChatSession(
-      { apiKey: "sk-test" },
-      {
-        persist: true,
-        contextDir: dir,
-        sessionId: "tools",
-      },
-    );
-
-    streamTextMock.mockReturnValueOnce({
-      fullStream: fullStream(
-        { type: "tool-call", toolCallId: "call-1", toolName: "read_file", input: { path: "package.json" } },
-        { type: "tool-result", toolCallId: "call-1", toolName: "read_file", output: { content: "{}" } },
-        { type: "text-delta", text: "done" },
-      ),
-    });
-
-    const events = await collect(session.chat("read package"));
-
-    expect(events).toContainEqual({
-      type: "tool_use",
-      id: "call-1",
-      name: "read_file",
-      input: { path: "package.json" },
-    });
-    expect(events).toContainEqual({
-      type: "tool_result",
-      tool_use_id: "call-1",
-      name: "read_file",
-      content: { content: "{}" },
-      is_error: false,
-    });
-    expect(events).toContainEqual({ type: "text", text: "done", accumulated: "done" });
-  });
-
-  it("writes raw CCC fullStream parts when raw stream logs are enabled", async () => {
-    const { ChatSession } = await import("../builtin/index.ts");
-    config.rawStreamLogs = {
-      enabled: true,
-      maxBytesPerTurn: 4096,
-      retentionDays: 3,
-      keepCompleted: true,
-    };
-    createRawStreamLogMock.mockResolvedValueOnce({
-      filePath: "raw.jsonl.gz",
-      writeLine: rawLogWriteLineMock,
-      close: rawLogCloseMock,
-    });
-    const session = new ChatSession(
-      { apiKey: "sk-test" },
-      {
-        sessionId: "raw-log-session",
-      },
-    );
-    const textPart = { type: "text-delta", text: "hello" };
-    const toolPart = {
-      type: "tool-call",
-      toolCallId: "call-1",
-      toolName: "read_file",
-      input: { path: "package.json" },
-    };
-
-    streamTextMock.mockReturnValueOnce({
-      fullStream: fullStream(textPart, toolPart),
-    });
-
-    await collect(session.chat("hi"));
-
-    expect(createRawStreamLogMock).toHaveBeenCalledWith(expect.objectContaining({
-      enabled: true,
-      tool: "deepccc",
-      sessionId: "raw-log-session",
-      label: "prompt",
-      maxBytesPerTurn: 4096,
-      retentionDays: 3,
-    }));
-    expect(rawLogWriteLineMock).toHaveBeenNthCalledWith(1, JSON.stringify(textPart));
-    expect(rawLogWriteLineMock).toHaveBeenNthCalledWith(2, JSON.stringify(toolPart));
-    expect(rawLogCloseMock).toHaveBeenCalledWith({ keep: true });
-  });
-});
-
-describe("ChatSession effort passthrough", () => {
-  it("passes reasoningEffort via providerOptions when effort is configured", async () => {
-    const { ChatSession } = await import("../builtin/index.ts");
-    const dir = await mkdtemp(join(tmpdir(), "chatccc-session-effort-high-"));
-    streamTextMock.mockReturnValueOnce({ textStream: textStream("done") });
-
-    const session = new ChatSession(
-      { apiKey: "sk-test", effort: "high" },
-      { cwd: dir, sessionId: "effort-high" },
-    );
-    await collect(session.chat("hi"));
-
-    expect(streamTextMock).toHaveBeenLastCalledWith(expect.objectContaining({
-      providerOptions: { deepseek: { reasoningEffort: "high" } },
-    }));
-  });
-
-  it("omits providerOptions when effort is not set", async () => {
-    const { ChatSession } = await import("../builtin/index.ts");
-    const dir = await mkdtemp(join(tmpdir(), "chatccc-session-effort-none-"));
-    streamTextMock.mockReturnValueOnce({ textStream: textStream("done") });
-
-    const session = new ChatSession(
-      { apiKey: "sk-test", effort: "" },
-      { cwd: dir, sessionId: "effort-none" },
-    );
-    await collect(session.chat("hi"));
-
-    const lastCall = streamTextMock.mock.calls.at(-1)?.[0] as Record<string, unknown>;
-    expect(lastCall.providerOptions).toBeUndefined();
-  });
-});
+import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { config } from "../builtin/config.ts";
+
+const streamTextMock = vi.fn();
+const generateTextMock = vi.fn();
+const createRawStreamLogMock = vi.fn();
+const rawLogWriteLineMock = vi.fn();
+const rawLogCloseMock = vi.fn();
+const originalRawStreamLogs = structuredClone(config.rawStreamLogs);
+
+vi.mock("@ai-sdk/openai-compatible", () => ({
+  createOpenAICompatible: vi.fn(() => (modelId: string) => ({ modelId })),
+}));
+
+vi.mock("ai", () => ({
+  streamText: streamTextMock,
+  generateText: generateTextMock,
+  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("../builtin/raw-stream-log.ts", () => ({
+  createRawStreamLog: createRawStreamLogMock,
+}));
+
+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;
+}
+
+async function* fullStream(...parts: unknown[]): AsyncIterable<unknown> {
+  for (const part of parts) yield part;
+}
+
+afterEach(() => {
+  streamTextMock.mockReset();
+  generateTextMock.mockReset();
+  createRawStreamLogMock.mockReset();
+  rawLogWriteLineMock.mockReset();
+  rawLogCloseMock.mockReset();
+  config.rawStreamLogs = structuredClone(originalRawStreamLogs);
+});
+
+describe("ChatSession codex-style skills", () => {
+  it("injects skill index into system prompt from skillsDirs", async () => {
+    const { ChatSession } = await import("../builtin/index.ts");
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-session-skills-"));
+    const skillsDir = join(dir, ".codex", "skills");
+    await mkdir(join(skillsDir, "demo-skill"), { recursive: true });
+    await writeFile(
+      join(skillsDir, "demo-skill", "SKILL.md"),
+      "---\nname: demo-skill\ndescription: 演示技能\n---\n\n# 演示",
+      "utf-8",
+    );
+    streamTextMock.mockReturnValueOnce({ textStream: textStream() });
+
+    const session = new ChatSession(
+      { apiKey: "sk-test" },
+      { cwd: dir, sessionId: "skill-index", skillsDirs: [skillsDir] },
+    );
+    await collect(session.chat("hi"));
+
+    const system = streamTextMock.mock.calls.at(-1)?.[0].system as string;
+    expect(system).toContain("## Available Skills");
+    expect(system).toContain("demo-skill");
+    expect(system).toContain("演示技能");
+  });
+
+  it("skips skill injection when no skills are found", async () => {
+    const { ChatSession } = await import("../builtin/index.ts");
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-session-no-skills-"));
+    streamTextMock.mockReturnValueOnce({ textStream: textStream() });
+
+    const session = new ChatSession(
+      { apiKey: "sk-test" },
+      { cwd: dir, sessionId: "no-skills", skillsDirs: [join(dir, "missing")] },
+    );
+    await collect(session.chat("hi"));
+
+    const system = streamTextMock.mock.calls.at(-1)?.[0].system as string;
+    expect(system).not.toContain("## Available Skills");
+  });
+});
+describe("ChatSession context management", () => {
+  it("injects cwd project instruction files before runtime workspace details", async () => {
+    const { ChatSession } = await import("../builtin/index.ts");
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-session-instructions-"));
+    await writeFile(join(dir, "AGENTS.md"), "agents root guidance", "utf-8");
+    await writeFile(join(dir, "AGENTS.local.md"), "agents local guidance", "utf-8");
+    await writeFile(join(dir, "CLAUDE.md"), "claude root guidance", "utf-8");
+    await writeFile(join(dir, "CLAUDE.local.md"), "claude local guidance", "utf-8");
+    streamTextMock.mockReturnValueOnce({ textStream: textStream() });
+
+    const session = new ChatSession(
+      { apiKey: "sk-test" },
+      {
+        cwd: dir,
+        sessionId: "project-instructions",
+      },
+    );
+    await collect(session.chat("hi"));
+
+    const system = streamTextMock.mock.calls.at(-1)?.[0].system as string;
+    expect(system).toContain("## Project Instructions");
+    expect(system).toContain("### AGENTS.md");
+    expect(system).toContain("agents root guidance");
+    expect(system).toContain("### AGENTS.local.md");
+    expect(system).toContain("agents local guidance");
+    expect(system).toContain("### CLAUDE.md");
+    expect(system).toContain("claude root guidance");
+    expect(system).toContain("### CLAUDE.local.md");
+    expect(system).toContain("claude local guidance");
+
+    expect(system.indexOf("agents root guidance")).toBeLessThan(system.indexOf("agents local guidance"));
+    expect(system.indexOf("agents local guidance")).toBeLessThan(system.indexOf("claude root guidance"));
+    expect(system.indexOf("claude root guidance")).toBeLessThan(system.indexOf("claude local guidance"));
+    expect(system.indexOf("claude local guidance")).toBeLessThan(system.indexOf(dir));
+  });
+
+  it("does not read project instruction files from parent directories", async () => {
+    const { ChatSession } = await import("../builtin/index.ts");
+    const parent = await mkdtemp(join(tmpdir(), "chatccc-session-parent-instructions-"));
+    const child = join(parent, "child");
+    await mkdir(child);
+    await writeFile(join(parent, "AGENTS.md"), "parent-only guidance", "utf-8");
+    streamTextMock.mockReturnValueOnce({ textStream: textStream() });
+
+    const session = new ChatSession(
+      { apiKey: "sk-test" },
+      {
+        cwd: child,
+        sessionId: "no-parent-instructions",
+      },
+    );
+    await collect(session.chat("hi"));
+
+    const system = streamTextMock.mock.calls.at(-1)?.[0].system as string;
+    expect(system).not.toContain("parent-only guidance");
+  });
+
+  it("uses loop-finished stopping by default", async () => {
+    const { ChatSession } = await import("../builtin/index.ts");
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-session-unlimited-"));
+    streamTextMock.mockReturnValueOnce({ textStream: textStream("done") });
+
+    const session = new ChatSession(
+      { apiKey: "sk-test" },
+      {
+        cwd: dir,
+        sessionId: "unlimited-steps",
+      },
+    );
+    await collect(session.chat("run a multi-stage workflow"));
+
+    expect(streamTextMock).toHaveBeenLastCalledWith(expect.objectContaining({
+      stopWhen: { loopFinished: true },
+    }));
+  });
+
+  it("uses a configured tool step limit when provided", async () => {
+    const { ChatSession } = await import("../builtin/index.ts");
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-session-step-budget-"));
+    streamTextMock.mockReturnValueOnce({ textStream: textStream("done") });
+
+    const session = new ChatSession(
+      { apiKey: "sk-test" },
+      {
+        cwd: dir,
+        sessionId: "step-budget",
+        maxSteps: 7,
+      },
+    );
+    await collect(session.chat("run a bounded workflow"));
+
+    expect(streamTextMock).toHaveBeenLastCalledWith(expect.objectContaining({
+      stopWhen: { count: 7 },
+    }));
+  });
+
+  it("loads persisted context, compacts older messages, and persists the new assistant reply", async () => {
+    const { ChatSession } = await import("../builtin/index.ts");
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-session-context-"));
+
+    const seed = new ChatSession(
+      { apiKey: "sk-test" },
+      {
+        persist: true,
+        contextDir: dir,
+        sessionId: "integration",
+        compactAtTokens: 10_000,
+      },
+    );
+    streamTextMock.mockReturnValueOnce({ textStream: textStream("old answer") });
+    await collect(seed.chat("old question"));
+
+    generateTextMock.mockResolvedValueOnce({ text: "## 当前任务状态\n- 旧问题已总结" });
+    streamTextMock.mockReturnValueOnce({ textStream: textStream("new answer") });
+
+    const restored = new ChatSession(
+      { apiKey: "sk-test" },
+      {
+        persist: true,
+        contextDir: dir,
+        sessionId: "integration",
+        compactAtTokens: 1,
+        keepRecentMessages: 1,
+      },
+    );
+    const events = await collect(restored.chat("new question"));
+
+    expect(generateTextMock).toHaveBeenCalledOnce();
+    expect(streamTextMock).toHaveBeenLastCalledWith(expect.objectContaining({
+      messages: expect.arrayContaining([
+        expect.objectContaining({ content: expect.stringContaining("旧问题已总结") }),
+        expect.objectContaining({ role: "user", content: "new question" }),
+      ]),
+    }));
+    expect(events).toContainEqual({ type: "compact", compactedMessages: 2 });
+    expect(restored.history.map((m) => m.content).join("\n")).toContain("new answer");
+  });
+
+  it("streams tool calls and tool results from fullStream", async () => {
+    const { ChatSession } = await import("../builtin/index.ts");
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-session-tools-"));
+    const session = new ChatSession(
+      { apiKey: "sk-test" },
+      {
+        persist: true,
+        contextDir: dir,
+        sessionId: "tools",
+      },
+    );
+
+    streamTextMock.mockReturnValueOnce({
+      fullStream: fullStream(
+        { type: "tool-call", toolCallId: "call-1", toolName: "read_file", input: { path: "package.json" } },
+        { type: "tool-result", toolCallId: "call-1", toolName: "read_file", output: { content: "{}" } },
+        { type: "text-delta", text: "done" },
+      ),
+    });
+
+    const events = await collect(session.chat("read package"));
+
+    expect(events).toContainEqual({
+      type: "tool_use",
+      id: "call-1",
+      name: "read_file",
+      input: { path: "package.json" },
+    });
+    expect(events).toContainEqual({
+      type: "tool_result",
+      tool_use_id: "call-1",
+      name: "read_file",
+      content: { content: "{}" },
+      is_error: false,
+    });
+    expect(events).toContainEqual({ type: "text", text: "done", accumulated: "done" });
+  });
+
+  it("writes raw CCC fullStream parts when raw stream logs are enabled", async () => {
+    const { ChatSession } = await import("../builtin/index.ts");
+    config.rawStreamLogs = {
+      enabled: true,
+      maxBytesPerTurn: 4096,
+      retentionDays: 3,
+      keepCompleted: true,
+    };
+    createRawStreamLogMock.mockResolvedValueOnce({
+      filePath: "raw.jsonl.gz",
+      writeLine: rawLogWriteLineMock,
+      close: rawLogCloseMock,
+    });
+    const session = new ChatSession(
+      { apiKey: "sk-test" },
+      {
+        sessionId: "raw-log-session",
+      },
+    );
+    const textPart = { type: "text-delta", text: "hello" };
+    const toolPart = {
+      type: "tool-call",
+      toolCallId: "call-1",
+      toolName: "read_file",
+      input: { path: "package.json" },
+    };
+
+    streamTextMock.mockReturnValueOnce({
+      fullStream: fullStream(textPart, toolPart),
+    });
+
+    await collect(session.chat("hi"));
+
+    expect(createRawStreamLogMock).toHaveBeenCalledWith(expect.objectContaining({
+      enabled: true,
+      tool: "deepccc",
+      sessionId: "raw-log-session",
+      label: "prompt",
+      maxBytesPerTurn: 4096,
+      retentionDays: 3,
+    }));
+    expect(rawLogWriteLineMock).toHaveBeenNthCalledWith(1, JSON.stringify(textPart));
+    expect(rawLogWriteLineMock).toHaveBeenNthCalledWith(2, JSON.stringify(toolPart));
+    expect(rawLogCloseMock).toHaveBeenCalledWith({ keep: true });
+  });
+});
+
+describe("ChatSession effort passthrough", () => {
+  it("passes reasoningEffort via providerOptions when effort is configured", async () => {
+    const { ChatSession } = await import("../builtin/index.ts");
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-session-effort-high-"));
+    streamTextMock.mockReturnValueOnce({ textStream: textStream("done") });
+
+    const session = new ChatSession(
+      { apiKey: "sk-test", effort: "high" },
+      { cwd: dir, sessionId: "effort-high" },
+    );
+    await collect(session.chat("hi"));
+
+    expect(streamTextMock).toHaveBeenLastCalledWith(expect.objectContaining({
+      providerOptions: { deepseek: { reasoningEffort: "high" } },
+    }));
+  });
+
+  it("omits providerOptions when effort is not set", async () => {
+    const { ChatSession } = await import("../builtin/index.ts");
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-session-effort-none-"));
+    streamTextMock.mockReturnValueOnce({ textStream: textStream("done") });
+
+    const session = new ChatSession(
+      { apiKey: "sk-test", effort: "" },
+      { cwd: dir, sessionId: "effort-none" },
+    );
+    await collect(session.chat("hi"));
+
+    const lastCall = streamTextMock.mock.calls.at(-1)?.[0] as Record<string, unknown>;
+    expect(lastCall.providerOptions).toBeUndefined();
+  });
+});