chatccc 0.2.50 → 0.2.52

package/src/__tests__/session.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { mkdtemp, rm } from "node:fs/promises";
+import { mkdtemp, rm, readFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 
@@ -29,6 +29,8 @@ import {
   saveSessionTool,
   accumulateBlockContent,
   pickFinalReply,
+  switchChatBinding,
+  rebuildBindingsFromRegistry,
   UNKNOWN_MODEL_PLACEHOLDER,
   _setSessionRegistryFileForTest,
   _resetSessionRegistryFileForTest,
@@ -36,6 +38,9 @@ import {
   _resetSessionToolsFileForTest,
   _setAdapterForToolForTest,
   _clearAdapterCacheForTest,
+  setSessionPlatform,
+  recordChatPlatform,
+  _getPlatformForChatForTest,
 } from "../session.ts";
 import {
   activePrompts,
@@ -45,9 +50,12 @@ import {
   getLastActiveChat,
   pickDisplayChat,
   resetBindingState,
+  getChatsForSession,
+  displayCards,
 } from "../session-chat-binding.ts";
 import type { AccumulatorState } from "../session.ts";
 import type { ToolAdapter, UnifiedBlock, SessionInfo } from "../adapters/adapter-interface.ts";
+import type { PlatformAdapter } from "../platform-adapter.ts";
 
 // Helper to create a mock active session entry
 function mockActiveSession(chatId: string, overrides: Partial<{
@@ -112,6 +120,23 @@ function mockAdapter(getInfo: (sid: string) => SessionInfo | undefined): ToolAda
   };
 }
 
+function mockPlatform(name: string): PlatformAdapter {
+  return {
+    sendText: vi.fn(async () => true),
+    sendCard: vi.fn(async () => true),
+    sendRawCard: vi.fn(async () => true),
+    createGroup: vi.fn(async () => `${name}-group`),
+    updateChatInfo: vi.fn(async () => {}),
+    getChatInfo: vi.fn(async () => ({ name, description: "" })),
+    disbandChat: vi.fn(async () => {}),
+    setChatAvatar: vi.fn(async () => {}),
+    extractSessionInfo: vi.fn(() => null),
+    cardCreate: vi.fn(async () => `${name}-card`),
+    cardSend: vi.fn(async () => `${name}-message`),
+    cardUpdate: vi.fn(async () => {}),
+  };
+}
+
 describe("resetState", () => {
   it("clears all maps and sets", () => {
     chatSessionMap.set("chat1", {
@@ -133,6 +158,111 @@ describe("resetState", () => {
   });
 });
 
+describe("chat platform routing", () => {
+  beforeEach(() => {
+    resetState();
+  });
+
+  it("uses the platform recorded for the chat before falling back to the default platform", () => {
+    const feishu = mockPlatform("feishu");
+    const wechat = mockPlatform("wechat");
+
+    setSessionPlatform(feishu);
+    recordChatPlatform("wx-chat", wechat);
+
+    expect(_getPlatformForChatForTest("wx-chat")).toBe(wechat);
+    expect(_getPlatformForChatForTest("feishu-chat")).toBe(feishu);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// rebuildBindingsFromRegistry — SDK 重连/启动时只重建只读映射,不动运行时状态
+//
+// 这是 onReady/onReconnected 应当调用的函数(替代之前错误调用的 resetState)。
+// 关键不变量:重建映射后,原有的 activePrompts、sessionInfoMap、displayCards、
+// processedMessages 全部保留——SDK 重连不应当影响后台 prompt 的执行。
+// ---------------------------------------------------------------------------
+
+describe("rebuildBindingsFromRegistry", () => {
+  let registryFile = "";
+
+  beforeEach(async () => {
+    chatSessionMap.clear();
+    sessionInfoMap.clear();
+    activePrompts.clear();
+    processedMessages.clear();
+    resetBindingState();
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-rebuild-"));
+    registryFile = join(dir, "session-registry.json");
+    _setSessionRegistryFileForTest(registryFile);
+  });
+
+  afterEach(async () => {
+    _resetSessionRegistryFileForTest();
+    if (registryFile) {
+      await rm(dirname(registryFile), { recursive: true, force: true });
+    }
+  });
+
+  it("不清空 activePrompts:后台 prompt 在 SDK 重连后必须继续被识别为活跃", async () => {
+    // 模拟有一个后台 prompt 正在跑
+    const controller = new AbortController();
+    activePrompts.set("session-running", { controller, stopped: false, startTime: Date.now() });
+    await recordSessionRegistry({
+      chatId: "chat-A",
+      sessionId: "session-running",
+      tool: "claude",
+      updatedAt: 100,
+    });
+
+    await rebuildBindingsFromRegistry();
+
+    // 关键不变量:重连后 activePrompts 必须保留,否则后台 generator 会变孤儿
+    expect(activePrompts.has("session-running")).toBe(true);
+    expect(activePrompts.get("session-running")?.controller).toBe(controller);
+  });
+
+  it("不清空 sessionInfoMap:轮数计数在重连后保留", async () => {
+    sessionInfoMap.set("chat-A", {
+      sessionId: "sid-A", turnCount: 7, lastContextTokens: 50000,
+      startTime: 1000, tool: "claude",
+    });
+    await recordSessionRegistry({
+      chatId: "chat-A", sessionId: "sid-A", tool: "claude", updatedAt: 100,
+    });
+
+    await rebuildBindingsFromRegistry();
+
+    expect(sessionInfoMap.get("chat-A")?.turnCount).toBe(7);
+    expect(sessionInfoMap.get("chat-A")?.lastContextTokens).toBe(50000);
+  });
+
+  it("不清空 processedMessages:重连后 SDK 重推消息仍能去重", async () => {
+    processedMessages.add("msg-id-1");
+    processedMessages.add("msg-id-2");
+
+    await rebuildBindingsFromRegistry();
+
+    expect(processedMessages.has("msg-id-1")).toBe(true);
+    expect(processedMessages.has("msg-id-2")).toBe(true);
+  });
+
+  it("从 registry 重建 sessionId → chatId 映射(沿用 rebuildSessionChatsFromRegistry 行为)", async () => {
+    await recordSessionRegistry({
+      chatId: "chat-A", sessionId: "sid-X", tool: "claude", updatedAt: 100,
+    });
+    await recordSessionRegistry({
+      chatId: "chat-B", sessionId: "sid-X", tool: "claude", updatedAt: 200,
+    });
+
+    await rebuildBindingsFromRegistry();
+
+    // 同一 sessionId 被两个 chatId 共享时,两个都应在映射中
+    bindChatToSession("sid-X", "chat-A"); // 验证幂等(再次调用不会出错)
+    expect(true).toBe(true); // 真正的断言由 sessionChatsMap 通过 pickDisplayChat 等间接验证
+  });
+});
+
 describe("getSessionStatus", () => {
   beforeEach(() => {
     chatSessionMap.clear();
@@ -752,3 +882,218 @@ describe("unbindChatFromSession 同步清理 lastActiveChatMap", () => {
     expect(getLastActiveChat("sid-A")).toBe("chat_X");
   });
 });
+
+// ---------------------------------------------------------------------------
+// switchChatBinding — 事务式 chat→session 切换（/newh、/session N 复用）
+//
+// 关键不变量：
+//   1. p2p chatType 不调 updateChatInfo（私聊飞书 API 会直接抛错）
+//   2. updateChatInfo 失败时,内存绑定/sessionInfoMap/displayCards 完全不动,
+//      且 description 还是旧值,下次消息按旧 sessionId 路由不会乱
+//   3. 成功时按 unbind 旧 → bind 新 → recordLastActiveChat 顺序原子切换
+//   4. 持久化 registry + sessions.json
+// ---------------------------------------------------------------------------
+
+describe("switchChatBinding", () => {
+  let registryFile = "";
+  let sessionsFile = "";
+
+  beforeEach(async () => {
+    resetBindingState();
+    sessionInfoMap.clear();
+    const dir = await mkdtemp(join(tmpdir(), "chatccc-switch-binding-"));
+    registryFile = join(dir, "session-registry.json");
+    sessionsFile = join(dir, "sessions.json");
+    _setSessionRegistryFileForTest(registryFile);
+    _setSessionToolsFileForTest(sessionsFile);
+  });
+
+  afterEach(async () => {
+    _resetSessionRegistryFileForTest();
+    _resetSessionToolsFileForTest();
+    if (registryFile) {
+      await rm(dirname(registryFile), { recursive: true, force: true });
+    }
+  });
+
+  it("群聊场景：API 成功后内存切换 + 持久化", async () => {
+    const calls: Array<{ chatId: string; name: string; desc: string }> = [];
+    const updateChatInfoFn = async (chatId: string, name: string, desc: string) => {
+      calls.push({ chatId, name, desc });
+    };
+
+    bindChatToSession("old-sid", "chat-1");
+    sessionInfoMap.set("chat-1", {
+      sessionId: "old-sid", turnCount: 5, lastContextTokens: 100,
+      startTime: 0, tool: "claude",
+    });
+    displayCards.set("chat-1", {
+      cardId: "c1", sequence: 1, cardBusy: false,
+      cardCreatedAt: 0, lastSentContent: "", streamErrorNotified: false,
+    });
+
+    const result = await switchChatBinding({
+      chatId: "chat-1",
+      chatType: "group",
+      oldSessionId: "old-sid",
+      newSessionId: "new-sid",
+      tool: "claude",
+      chatName: "新会话-test",
+      newDescription: "Claude Code Session: new-sid",
+      updateChatInfoFn,
+    });
+
+    expect(result.ok).toBe(true);
+    expect(calls).toHaveLength(1);
+    expect(calls[0]).toEqual({
+      chatId: "chat-1",
+      name: "新会话-test",
+      desc: "Claude Code Session: new-sid",
+    });
+    // 旧 session 已解绑,新 session 已绑
+    expect(getChatsForSession("old-sid")).toEqual([]);
+    expect(getChatsForSession("new-sid")).toEqual(["chat-1"]);
+    // displayCards 已清
+    expect(displayCards.has("chat-1")).toBe(false);
+    // sessionInfoMap 指向新 sessionId
+    expect(sessionInfoMap.get("chat-1")?.sessionId).toBe("new-sid");
+    // lastActiveChat 指向当前 chat
+    expect(getLastActiveChat("new-sid")).toBe("chat-1");
+  });
+
+  it("私聊场景：完全跳过 updateChatInfo,仍完成内存切换", async () => {
+    let called = false;
+    const updateChatInfoFn = async () => {
+      called = true;
+      throw new Error("p2p chat API would fail");
+    };
+
+    const result = await switchChatBinding({
+      chatId: "p2p-chat",
+      chatType: "p2p",
+      oldSessionId: null,
+      newSessionId: "new-sid-p2p",
+      tool: "claude",
+      chatName: "新会话-p2p",
+      newDescription: "Claude Code Session: new-sid-p2p",
+      updateChatInfoFn,
+    });
+
+    expect(result.ok).toBe(true);
+    expect(called).toBe(false); // 私聊跳过 API 调用
+    expect(getChatsForSession("new-sid-p2p")).toEqual(["p2p-chat"]);
+    expect(sessionInfoMap.get("p2p-chat")?.sessionId).toBe("new-sid-p2p");
+  });
+
+  it("群聊 + updateChatInfo 抛错：内存完全不动 + 返回 error", async () => {
+    bindChatToSession("old-sid", "chat-1");
+    sessionInfoMap.set("chat-1", {
+      sessionId: "old-sid", turnCount: 5, lastContextTokens: 100,
+      startTime: 0, tool: "claude",
+    });
+    const oldDisplay = {
+      cardId: "c1", sequence: 1, cardBusy: false,
+      cardCreatedAt: 0, lastSentContent: "", streamErrorNotified: false,
+    };
+    displayCards.set("chat-1", oldDisplay);
+
+    const updateChatInfoFn = async () => {
+      throw new Error("network timeout");
+    };
+
+    const result = await switchChatBinding({
+      chatId: "chat-1",
+      chatType: "group",
+      oldSessionId: "old-sid",
+      newSessionId: "new-sid",
+      tool: "claude",
+      chatName: "新会话-failed",
+      newDescription: "Claude Code Session: new-sid",
+      updateChatInfoFn,
+    });
+
+    expect(result.ok).toBe(false);
+    expect(result.error?.message).toBe("network timeout");
+    // 内存绑定保持旧状态
+    expect(getChatsForSession("old-sid")).toEqual(["chat-1"]);
+    expect(getChatsForSession("new-sid")).toEqual([]);
+    expect(displayCards.get("chat-1")).toBe(oldDisplay);
+    expect(sessionInfoMap.get("chat-1")?.sessionId).toBe("old-sid");
+    expect(sessionInfoMap.get("chat-1")?.turnCount).toBe(5);
+  });
+
+  it("oldSessionId 为 null 时不调 unbind(适用于私聊首次绑定)", async () => {
+    const updateChatInfoFn = async () => {};
+
+    const result = await switchChatBinding({
+      chatId: "fresh-chat",
+      chatType: "p2p",
+      oldSessionId: null,
+      newSessionId: "fresh-sid",
+      tool: "claude",
+      chatName: "首次会话",
+      newDescription: "Claude Code Session: fresh-sid",
+      updateChatInfoFn,
+    });
+
+    expect(result.ok).toBe(true);
+    expect(getChatsForSession("fresh-sid")).toEqual(["fresh-chat"]);
+  });
+
+  it("API 成功后,registry 持久化记录可被重新加载", async () => {
+    const updateChatInfoFn = async () => {};
+
+    await switchChatBinding({
+      chatId: "chat-persist",
+      chatType: "group",
+      oldSessionId: null,
+      newSessionId: "persist-sid",
+      tool: "cursor",
+      chatName: "persist-name",
+      newDescription: "Cursor Session: persist-sid",
+      initialTurnCount: 3,
+      initialContextTokens: 500,
+      updateChatInfoFn,
+    });
+
+    // 验证 registry 文件已写入
+    const raw = await readFile(registryFile, "utf-8");
+    const parsed = JSON.parse(raw);
+    expect(parsed["chat-persist"]).toMatchObject({
+      chatId: "chat-persist",
+      sessionId: "persist-sid",
+      tool: "cursor",
+      chatName: "persist-name",
+      turnCount: 3,
+      lastContextTokens: 500,
+      running: false,
+    });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// resetState 调用契约：仅供测试 + 进程首次启动。
+// 不应在 SDK onReady/onReconnected 中调用——会清空 activePrompts 让正在跑
+// 的后台 prompt 变成"孤儿 generator"（Map 删了但 controller 没 abort,
+// 导致同一 sessionId 双开 prompt）。
+// ---------------------------------------------------------------------------
+
+describe("resetState 契约：清空所有运行时状态", () => {
+  it("清空 activePrompts 但不 abort controller(只能由进程首次启动调用)", () => {
+    const controller = new AbortController();
+    let aborted = false;
+    controller.signal.addEventListener("abort", () => { aborted = true; });
+    activePrompts.set("sid-running", {
+      controller, stopped: false, startTime: 0,
+    });
+
+    resetState();
+
+    expect(activePrompts.size).toBe(0);
+    // 注意：resetState 不主动 abort——所以如果生产代码在 prompt 跑过程中
+    // 误调 resetState,后台 generator 仍会继续跑直到自然结束,但 activePrompts
+    // 已经空了,下条消息会双开 prompt。这是 resetState 仅适用于"启动时"
+    // (Map 本就是空的)的根本原因。
+    expect(aborted).toBe(false);
+  });
+});

package/src/__tests__/stream-state.test.ts

@@ -0,0 +1,134 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { mkdtemp, rm, readFile, readdir, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+// 在 import stream-state 之前先 mock config，让 USER_DATA_DIR 指向临时目录
+const TEST_DATA_DIR = await mkdtemp(join(tmpdir(), "chatccc-stream-state-test-"));
+vi.mock("../config.ts", async () => {
+  const actual = await vi.importActual<typeof import("../config.ts")>("../config.ts");
+  return {
+    ...actual,
+    USER_DATA_DIR: TEST_DATA_DIR,
+    ts: () => "test-ts",
+  };
+});
+
+const {
+  writeStreamState,
+  readStreamState,
+  createEmptyStreamState,
+  STREAMS_DIR,
+  _setRenameForTest,
+  _resetRenameForTest,
+} = await import("../stream-state.ts");
+
+describe("writeStreamState — atomic rename", () => {
+  beforeEach(async () => {
+    // 清空测试目录
+    try {
+      const entries = await readdir(STREAMS_DIR);
+      for (const e of entries) await rm(join(STREAMS_DIR, e), { force: true });
+    } catch { /* dir not yet exist */ }
+  });
+
+  afterEach(async () => {
+    vi.restoreAllMocks();
+  });
+
+  it("writeStreamState 写完后 readStreamState 能读到完整内容", async () => {
+    const state = createEmptyStreamState("sid-1", "/tmp", "claude", 1);
+    state.accumulatedContent = "hello";
+    state.finalReply = "world";
+
+    await writeStreamState(state);
+
+    const got = await readStreamState("sid-1");
+    expect(got).not.toBeNull();
+    expect(got!.accumulatedContent).toBe("hello");
+    expect(got!.finalReply).toBe("world");
+  });
+
+  it("写入完成后,临时 .tmp 文件不应残留(rename 成功路径)", async () => {
+    const state = createEmptyStreamState("sid-2", "/tmp", "claude", 1);
+    await writeStreamState(state);
+
+    const entries = await readdir(STREAMS_DIR);
+    // 只应有 sid-2.json,没有 sid-2.json.tmp
+    expect(entries).toContain("sid-2.json");
+    expect(entries.some((e) => e.endsWith(".tmp"))).toBe(false);
+  });
+
+  it("覆盖写入时,reader 永远只读到完整 JSON(不读到半截)", async () => {
+    // 此测试验证：先写一个版本,再写第二个版本,reader 中间读取必然是某个完整版本
+    const state1 = createEmptyStreamState("sid-3", "/tmp", "claude", 1);
+    state1.accumulatedContent = "v1";
+    await writeStreamState(state1);
+
+    // 直接读原始字节,确认是完整 JSON
+    const raw1 = await readFile(join(STREAMS_DIR, "sid-3.json"), "utf-8");
+    expect(() => JSON.parse(raw1)).not.toThrow();
+    expect(JSON.parse(raw1).accumulatedContent).toBe("v1");
+
+    const state2 = createEmptyStreamState("sid-3", "/tmp", "claude", 2);
+    state2.accumulatedContent = "v2";
+    await writeStreamState(state2);
+
+    const raw2 = await readFile(join(STREAMS_DIR, "sid-3.json"), "utf-8");
+    expect(() => JSON.parse(raw2)).not.toThrow();
+    expect(JSON.parse(raw2).accumulatedContent).toBe("v2");
+  });
+
+  it("rename 失败时降级为直接覆盖写,不抛错 + 数据仍写入", async () => {
+    let renameCalls = 0;
+    _setRenameForTest(async () => {
+      renameCalls++;
+      throw Object.assign(new Error("EPERM mocked"), { code: "EPERM" });
+    });
+
+    try {
+      const state = createEmptyStreamState("sid-fallback", "/tmp", "claude", 1);
+      state.accumulatedContent = "fallback-content";
+
+      // 不应抛错
+      await expect(writeStreamState(state)).resolves.toBeUndefined();
+
+      // 数据仍应写入(降级路径走 writeFile 覆盖)
+      const got = await readStreamState("sid-fallback");
+      expect(got).not.toBeNull();
+      expect(got!.accumulatedContent).toBe("fallback-content");
+
+      expect(renameCalls).toBe(1);
+    } finally {
+      _resetRenameForTest();
+    }
+  });
+
+  it("readStreamState 对损坏的 JSON 返回 null(reader 兜底契约)", async () => {
+    // 直接写一段半截 JSON 到目标路径
+    const filePath = join(STREAMS_DIR, "sid-broken.json");
+    await writeFile(filePath, '{"sessionId":"sid-broken","accum', "utf-8");
+
+    const got = await readStreamState("sid-broken");
+    expect(got).toBeNull();
+  });
+
+  it("readStreamState 对不存在文件返回 null", async () => {
+    const got = await readStreamState("never-existed");
+    expect(got).toBeNull();
+  });
+});
+
+describe("createEmptyStreamState", () => {
+  it("生成的 state 字段正确且 status=running", () => {
+    const s = createEmptyStreamState("sid-X", "/cwd", "cursor", 5);
+    expect(s.sessionId).toBe("sid-X");
+    expect(s.cwd).toBe("/cwd");
+    expect(s.tool).toBe("cursor");
+    expect(s.turnCount).toBe(5);
+    expect(s.status).toBe("running");
+    expect(s.accumulatedContent).toBe("");
+    expect(s.finalReply).toBe("");
+    expect(s.chunkCount).toBe(0);
+  });
+});

package/src/__tests__/wechat-platform.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { buildHelpCard } from "../cards.ts";
+import { createWechatAdapter } from "../wechat-platform.ts";
+
+describe("createWechatAdapter", () => {
+  it("degrades raw cards to plain text messages", async () => {
+    const wire = {
+      push: vi.fn(async (_chatId: string, _text: string) => "msg-id"),
+      sendText: vi.fn(
+        async (_chatId: string, _text: string, _contextToken?: string) =>
+          "msg-id",
+      ),
+    };
+    const log = vi.fn();
+    const platform = createWechatAdapter({
+      getWire: () => wire,
+      log,
+    });
+
+    const ok = await platform.sendRawCard("wx-chat-help", buildHelpCard("Hello"));
+
+    expect(ok).toBe(true);
+    expect(wire.push).toHaveBeenCalledTimes(1);
+    expect(wire.sendText).not.toHaveBeenCalled();
+    const [, text] = wire.push.mock.calls[0];
+    expect(text).toContain("# ChatCCC");
+    expect(text).toContain("Hello");
+    expect(text).toContain("/new");
+    expect(log).toHaveBeenCalledWith("[WECHAT] sendRawCard degraded to text");
+  });
+});

package/src/adapters/claude-adapter.ts

@@ -89,11 +89,32 @@ function buildSdkEnv(
   if (!apiKeyTrim && !baseUrlTrim) return undefined;
 
   const env: Record<string, string | undefined> = { ...process.env };
+  // ChatCCC's Claude API config is authoritative when present. Remove Claude
+  // Code/user settings env that can silently override gateway/auth/model choice.
+  delete env.ANTHROPIC_AUTH_TOKEN;
+  delete env.CLAUDE_CODE_OAUTH_TOKEN;
+  delete env.ANTHROPIC_MODEL;
+  delete env.ANTHROPIC_DEFAULT_OPUS_MODEL;
+  delete env.ANTHROPIC_DEFAULT_SONNET_MODEL;
+  delete env.ANTHROPIC_DEFAULT_HAIKU_MODEL;
+  delete env.CLAUDE_CODE_SUBAGENT_MODEL;
+  delete env.CLAUDE_CODE_EFFORT_LEVEL;
+
   if (apiKeyTrim) env.ANTHROPIC_API_KEY = apiKeyTrim;
   if (baseUrlTrim) env.ANTHROPIC_BASE_URL = baseUrlTrim;
+  else delete env.ANTHROPIC_BASE_URL;
   return env;
 }
 
+function resolveSettingSources(
+  _apiKey: string | undefined,
+  _baseUrl: string | undefined,
+): Array<"project" | "local"> {
+  // CLAUDE.md / CLAUDE.local.md 是 Agent 指令文件，与 API 来源无关，
+  // 无论使用官方 Anthropic 还是第三方网关都应加载。
+  return ["project", "local"];
+}
+
 // ---------------------------------------------------------------------------
 // buildSessionOptions — 还原 claudeSdkSessionOptions 的精确行为
 // ---------------------------------------------------------------------------
@@ -111,7 +132,7 @@ function buildSessionOptions(
     permissionMode: "bypassPermissions",
     allowDangerouslySkipPermissions: true,
     autoCompactEnabled: true,
-    settingSources: ["project", "local"],
+    settingSources: resolveSettingSources(apiKey, baseUrl),
   };
   if (!isEmpty(model)) o.model = model;
   if (!isEmpty(effort)) o.effort = effort;
@@ -304,4 +325,4 @@ export function createClaudeAdapter(
   options: ClaudeAdapterOptions,
 ): ToolAdapter {
   return new ClaudeAdapter(options);
-}
+}