nolo-cli 0.1.39 → 0.1.41

package/client/localRuntimeAdapter.test.ts

@@ -4,6 +4,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import { runLocalAgentTurn } from "../agent-runtime/localLoop";
+import { MIMO_MONTH_AGENT_KEY } from "../agentAliases";
 import { createCliLocalRuntimeAdapter } from "./localRuntimeAdapter";
 
 describe("CLI local runtime adapter", () => {
@@ -13,23 +14,183 @@ describe("CLI local runtime adapter", () => {
     "writeFile",
     "editFile",
     "searchFiles",
+    "execShell",
   ];
   const LEGACY_WRITE_LOCAL_CODING_TOOL_NAMES = [
-    "writeWorkspaceFile",
     "listFiles",
     "readFile",
+    "writeFile",
     "editFile",
     "searchFiles",
+    "execShell",
   ];
   const SHELL_LOCAL_CODING_TOOL_NAMES = [
     ...DEFAULT_LOCAL_CODING_TOOL_NAMES,
-    "execShell",
+  ];
+  const DEFAULT_PRIVATE_NOLO_WORKSPACE_TOOL_NAMES = [
+    "listDialogs",
+    "readDialog",
+    "listAgents",
+    "readAgent",
+    "listSpaces",
+    "readSpace",
+    "readDoc",
+    "readSkillDoc",
+    "queryTableRows",
+    "cliWhoami",
+    "cliDoctor",
+  ];
+  const DEFAULT_PRIVATE_LOCAL_TOOL_NAMES = [
+    ...DEFAULT_LOCAL_CODING_TOOL_NAMES,
+    ...DEFAULT_PRIVATE_NOLO_WORKSPACE_TOOL_NAMES,
   ];
 
   function toolNamesFromRequest(request: any) {
     return request?.body?.tools?.map((tool: any) => tool.function.name) ?? [];
   }
 
+  test("runs cli-provider agents through the local CLI executor instead of OpenAI-compatible direct mode", async () => {
+    const cliExecutions: Array<{ provider: string; prompt: string; options: any }> = [];
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+        OPENAI_API_KEY: "sk-should-not-be-used",
+      },
+      db: {
+        get: async (key) => {
+          if (key !== "agent-user-1-frontend") throw new Error(`not found: ${key}`);
+          return {
+            dbKey: "agent-user-1-frontend",
+            id: "frontend",
+            name: "Frontend",
+            prompt: "You are the frontend implementer.",
+            apiSource: "cli",
+            cliProvider: "agy",
+            model: "gemini-3.1-pro",
+          };
+        },
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      cwd: "/repo/worktree",
+      now: () => 1710000000000,
+      createId: () => "01CLI",
+      fetchImpl: async () => {
+        throw new Error("OpenAI-compatible fetch should not be used for cli providers");
+      },
+      executeCli: async (provider, prompt, options) => {
+        cliExecutions.push({ provider, prompt, options });
+        return { text: "cli ok", raw: "cli ok", elapsed: 1 };
+      },
+    } as any);
+
+    const result = await runLocalAgentTurn({
+      adapter,
+      agentRef: "frontend",
+      input: "add tooltip",
+    });
+
+    expect(result).toMatchObject({
+      content: "cli ok",
+      model: "gemini-3.1-pro",
+    });
+    expect(cliExecutions).toHaveLength(1);
+    expect(cliExecutions[0]).toMatchObject({
+      provider: "agy",
+      options: {
+        model: "gemini-3.1-pro",
+        cwd: "/repo/worktree",
+        yolo: true,
+      },
+    });
+    expect(cliExecutions[0].prompt).toContain("You are the frontend implementer.");
+    expect(cliExecutions[0].prompt).toContain("add tooltip");
+  });
+
+  test("fails cli-provider local runs clearly when the requested local CLI is unavailable", async () => {
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+        OPENAI_API_KEY: "sk-should-not-be-used",
+      },
+      db: {
+        get: async (key) => {
+          if (key !== "agent-user-1-frontend") throw new Error(`not found: ${key}`);
+          return {
+            dbKey: "agent-user-1-frontend",
+            id: "frontend",
+            name: "Frontend",
+            prompt: "You are the frontend implementer.",
+            apiSource: "cli",
+            cliProvider: "agy",
+          };
+        },
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      fetchImpl: async () => {
+        throw new Error("OpenAI-compatible fetch should not be used for cli providers");
+      },
+      executeCli: async () => {
+        throw new Error("agy: command not found");
+      },
+    } as any);
+
+    await expect(runLocalAgentTurn({
+      adapter,
+      agentRef: "frontend",
+      input: "add tooltip",
+    })).rejects.toThrow("Local CLI provider \"agy\" is unavailable");
+  });
+
+  test("passes cli-provider image inputs to the CLI executor instead of rejecting", async () => {
+    let cliCalledWith: any = null;
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+      },
+      db: {
+        get: async (key) => {
+          if (key !== "agent-user-1-frontend") throw new Error(`not found: ${key}`);
+          return {
+            dbKey: "agent-user-1-frontend",
+            id: "frontend",
+            name: "Frontend",
+            prompt: "You are the frontend implementer.",
+            apiSource: "cli",
+            cliProvider: "agy",
+          };
+        },
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      executeCli: async (provider, prompt, options) => {
+        cliCalledWith = { provider, prompt, options };
+        return { text: "image handled", raw: "", elapsed: 1 };
+      },
+    } as any);
+
+    const result = await runLocalAgentTurn({
+      adapter,
+      agentRef: "frontend",
+      input: [
+        { type: "text", text: "look at this screenshot" },
+        { type: "image_url", image_url: { url: "https://example.com/screen.png" } },
+      ],
+    });
+
+    expect(result.content).toBe("image handled");
+    expect(cliCalledWith).not.toBeNull();
+    expect(cliCalledWith.provider).toBe("agy");
+    expect(cliCalledWith.prompt).toContain("look at this screenshot");
+    expect(cliCalledWith.options.imageInputs).toEqual([
+      { source: "https://example.com/screen.png" },
+    ]);
+  });
+
   test("loads agent/history from LevelDB and saves dialog/message records back to LevelDB", async () => {
     const requests: Array<{ url: string; body: any; auth: string | null }> = [];
     const store = new Map<string, any>([
@@ -122,7 +283,7 @@ describe("CLI local runtime adapter", () => {
         stream: false,
       },
     });
-    expect(toolNamesFromRequest(requests[0])).toEqual(DEFAULT_LOCAL_CODING_TOOL_NAMES);
+    expect(toolNamesFromRequest(requests[0])).toEqual(DEFAULT_PRIVATE_LOCAL_TOOL_NAMES);
     expect(batchOps.map((op) => op.key)).toEqual([
       "dialog-user-1-dialog-existing",
       "dialog-dialog-existing-msg-1710000000000-001",
@@ -354,7 +515,7 @@ describe("CLI local runtime adapter", () => {
         reasoning_effort: "medium",
       },
     });
-    expect(toolNamesFromRequest(requests[0])).toEqual(DEFAULT_LOCAL_CODING_TOOL_NAMES);
+    expect(toolNamesFromRequest(requests[0])).toEqual(DEFAULT_PRIVATE_LOCAL_TOOL_NAMES);
   });
 
   test("aborts stalled custom provider requests when timeoutMs is provided", async () => {
@@ -374,11 +535,8 @@ describe("CLI local runtime adapter", () => {
       env: {
         NOLO_LOCAL_USER_ID: "user-1",
       },
-      db: {
-        get: async (key) => {
-          if (!store.has(key)) throw new Error(`not found: ${key}`);
-          return store.get(key);
-        },
+      store: {
+        read: async (key) => store.get(key) ?? null,
         put: async (key, value) => {
           store.set(key, value);
         },
@@ -473,7 +631,7 @@ describe("CLI local runtime adapter", () => {
         stream: false,
       },
     });
-    expect(toolNamesFromRequest(loopbackRequests[0])).toEqual(DEFAULT_LOCAL_CODING_TOOL_NAMES);
+    expect(toolNamesFromRequest(loopbackRequests[0])).toEqual(DEFAULT_PRIVATE_LOCAL_TOOL_NAMES);
   });
 
   test("uses the Nolo chat proxy when local provider keys are absent", async () => {
@@ -485,7 +643,7 @@ describe("CLI local runtime adapter", () => {
         prompt: "Fix UI.",
         model: "accounts/fireworks/models/kimi-k2p6",
         provider: "fireworks",
-        tools: ["writeWorkspaceFile"],
+        tools: ["writeFile"],
       }],
     ]);
     const adapter = createCliLocalRuntimeAdapter({
@@ -546,7 +704,10 @@ describe("CLI local runtime adapter", () => {
         agentKey: "agent-user-1-frontend",
       },
     });
-    expect(toolNamesFromRequest(requests[0])).toEqual(LEGACY_WRITE_LOCAL_CODING_TOOL_NAMES);
+    expect(toolNamesFromRequest(requests[0])).toEqual([
+      ...LEGACY_WRITE_LOCAL_CODING_TOOL_NAMES,
+      ...DEFAULT_PRIVATE_NOLO_WORKSPACE_TOOL_NAMES,
+    ]);
   });
 
   test("uses the Nolo chat proxy for platform agents even when direct provider env exists", async () => {
@@ -560,7 +721,7 @@ describe("CLI local runtime adapter", () => {
         provider: "fireworks",
         apiSource: "platform",
         useServerProxy: true,
-        tools: ["readWorkspaceFile"],
+        tools: ["readFile"],
       }],
     ]);
     const adapter = createCliLocalRuntimeAdapter({
@@ -728,7 +889,7 @@ describe("CLI local runtime adapter", () => {
 
     expect(result.content).toBe("platform longer retry ok");
     expect(attempts).toBe(6);
-    expect(retryDelays.length).toBe(5);
+    expect(retryDelays.length).toBeGreaterThanOrEqual(3);
     expect(retryDelays[0]).toBeGreaterThan(0);
   });
 
@@ -745,7 +906,6 @@ describe("CLI local runtime adapter", () => {
       env: {
         NOLO_LOCAL_USER_ID: "user-1",
         NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
-        NOLO_LOCAL_SHELL_MODE: "worktree",
       },
       db: {
         get: async (key) => {
@@ -851,7 +1011,7 @@ describe("CLI local runtime adapter", () => {
         prompt: "Read narrowly",
         model: "gpt-4.1-mini",
         provider: "openai-compatible",
-        tools: ["readWorkspaceFile"],
+        tools: ["readFile"],
       }],
     ]);
     let requestCount = 0;
@@ -860,7 +1020,7 @@ describe("CLI local runtime adapter", () => {
         NOLO_LOCAL_USER_ID: "user-1",
         NOLO_LOCAL_OPENAI_BASE_URL: "https://llm.example/v1",
         NOLO_LOCAL_OPENAI_API_KEY: "sk-test",
-        NOLO_LOCAL_TOOL_BUDGETS: "readWorkspaceFile=1",
+        NOLO_LOCAL_TOOL_BUDGETS: "readFile=1",
       },
       store: {
         read: async (key) => {
@@ -881,7 +1041,7 @@ describe("CLI local runtime adapter", () => {
       now: () => 1710000000000,
       createId: () => "01BUDGET",
       localToolExecutors: {
-        readWorkspaceFile: async () => ({ content: "file content" }),
+        readFile: async () => ({ content: "file content" }),
       },
       fetchImpl: async (_url, init) => {
         requestCount += 1;
@@ -898,7 +1058,7 @@ describe("CLI local runtime adapter", () => {
                 id: `call-read-${requestCount}`,
                 type: "function",
                 function: {
-                  name: "readWorkspaceFile",
+                  name: "readFile",
                   arguments: JSON.stringify({ path: "file.ts" }),
                 },
               }],
@@ -912,7 +1072,6 @@ describe("CLI local runtime adapter", () => {
       adapter,
       agentRef: "agent-user-1-reader",
       input: "inspect",
-      maxToolRounds: 3,
     });
 
     expect(result.content).toBe("budget handled");
@@ -1043,7 +1202,7 @@ describe("CLI local runtime adapter", () => {
     });
   });
 
-  test("requires explicit shell mode for registered execShell", async () => {
+  test("allows registered execShell by default", async () => {
     const adapter = createCliLocalRuntimeAdapter({
       env: {},
       localToolExecutors: {
@@ -1052,11 +1211,13 @@ describe("CLI local runtime adapter", () => {
       fetchImpl: async () => Response.json({}),
     });
 
-    await expect(adapter.executeTool({
+    const result = await adapter.executeTool({
       id: "call-1",
       name: "execShell",
       arguments: "{\"cmd\":\"pwd\"}",
-    })).rejects.toThrow("execShell requires NOLO_LOCAL_SHELL_MODE=worktree");
+    });
+
+    expect(result.content).toContain("\"cmd\":\"pwd\"");
   });
 
   test("executes explicitly allowed registered local tools declared by the agent", async () => {
@@ -1098,13 +1259,12 @@ describe("CLI local runtime adapter", () => {
     expect(result.content).toContain("README.md");
   });
 
-  test("advertises execShell to OpenAI-compatible providers only in explicit shell mode", async () => {
+  test("advertises execShell to OpenAI-compatible providers by default", async () => {
     const requests: Array<{ body: any }> = [];
     const adapter = createCliLocalRuntimeAdapter({
       env: {
         OPENAI_API_KEY: "sk-local",
         NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
-        NOLO_LOCAL_SHELL_MODE: "worktree",
       },
       db: {
         get: async () => ({
@@ -1130,6 +1290,61 @@ describe("CLI local runtime adapter", () => {
       input: "pwd",
     });
 
+    expect(toolNamesFromRequest(requests[0])).toEqual([
+      ...SHELL_LOCAL_CODING_TOOL_NAMES,
+      ...DEFAULT_PRIVATE_NOLO_WORKSPACE_TOOL_NAMES,
+    ]);
+  });
+
+  test("keeps monthly Mimo local model tools to the compact coding surface", async () => {
+    const requests: Array<{ body: any }> = [];
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        OPENAI_API_KEY: "sk-local",
+        NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
+      },
+      db: {
+        get: async () => ({
+          dbKey: MIMO_MONTH_AGENT_KEY,
+          prompt: "Use local coding tools.",
+          model: "mimo-v2.5-pro",
+          provider: "custom",
+          tools: [
+            "read",
+            "searchDialogMessages",
+            "searchFiles",
+            "codeSearch",
+            "listFiles",
+            "readFile",
+            "writeFile",
+            "editFile",
+            "searchFiles",
+            "legacyLocalAlias",
+            "applyPatch",
+            "execShell",
+            "checkEnv",
+            "queryTableRows",
+            "taskRun",
+          ],
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      fetchImpl: async (_url, init) => {
+        requests.push({ body: JSON.parse(String(init?.body)) });
+        return Response.json({
+          choices: [{ message: { content: "done" } }],
+        });
+      },
+    });
+
+    await runLocalAgentTurn({
+      adapter,
+      agentRef: MIMO_MONTH_AGENT_KEY,
+      input: "inspect cwd",
+    });
+
     expect(toolNamesFromRequest(requests[0])).toEqual(SHELL_LOCAL_CODING_TOOL_NAMES);
   });
 
@@ -1251,6 +1466,141 @@ describe("CLI local runtime adapter", () => {
     expect(result.metadata).toMatchObject({ serverPlatformTool: true });
   });
 
+  test("exposes declared server table write tools in local runtime requests", async () => {
+    const requests: Array<{ body: any }> = [];
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        OPENAI_API_KEY: "sk-local",
+        NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
+      },
+      db: {
+        get: async () => ({
+          dbKey: "agent-local-table",
+          prompt: "Use table tools.",
+          model: "gpt-4.1-mini",
+          toolNames: ["createTable", "addTableRow", "addTableRows"],
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      fetchImpl: async (_url, init) => {
+        requests.push({ body: JSON.parse(String(init?.body)) });
+        return Response.json({
+          choices: [{ message: { content: "done" } }],
+        });
+      },
+    });
+
+    await runLocalAgentTurn({
+      adapter,
+      agentRef: "table",
+      input: "采集并写入 table",
+    });
+
+    const toolNames = toolNamesFromRequest(requests[0]);
+    expect(toolNames).toContain("createTable");
+    expect(toolNames).toContain("addTableRow");
+    expect(toolNames).toContain("addTableRows");
+  });
+
+  test("executes declared createTable through the server table bridge when capture is explicit", async () => {
+    const requests: Array<{ url: string; auth: string | null; body: any }> = [];
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_SERVER: "https://us.nolo.chat",
+        AUTH_TOKEN: "token-1",
+      },
+      db: {
+        get: async () => ({
+          dbKey: "agent-local-table-write",
+          toolNames: ["createTable"],
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      fetchImpl: async (url, init) => {
+        requests.push({
+          url: String(url),
+          auth: new Headers(init?.headers).get("authorization"),
+          body: JSON.parse(String(init?.body)),
+        });
+        return Response.json({
+          ok: true,
+          tenantId: "user-1",
+          tableId: "table-1",
+        });
+      },
+    });
+
+    await adapter.loadAgentConfig("table-write");
+    const result = await adapter.executeTool({
+      id: "call-create-table",
+      name: "createTable",
+      userInput: "采集这个用户并写入 table",
+      arguments: JSON.stringify({
+        title: "XHS profile",
+        columns: [{ name: "nickname" }],
+      }),
+    });
+
+    expect(requests).toEqual([
+      {
+        url: "https://us.nolo.chat/api/table/create",
+        auth: "Bearer token-1",
+        body: {
+          title: "XHS profile",
+          columns: [{ name: "nickname" }],
+        },
+      },
+    ]);
+    expect(result.content).toContain("\"tableId\":\"table-1\"");
+    expect(result.metadata).toMatchObject({
+      serverPlatformTool: true,
+      tableWrite: true,
+    });
+  });
+
+  test("blocks local table writes when the current user request is not explicit capture", async () => {
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_SERVER: "https://us.nolo.chat",
+        AUTH_TOKEN: "token-1",
+      },
+      db: {
+        get: async () => ({
+          dbKey: "agent-local-table-blocked",
+          toolNames: ["createTable"],
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      fetchImpl: async () => {
+        throw new Error("blocked createTable must not reach the server");
+      },
+    });
+
+    await adapter.loadAgentConfig("table-blocked");
+    const result = await adapter.executeTool({
+      id: "call-create-table-blocked",
+      name: "createTable",
+      userInput: "总结这个用户画像",
+      arguments: JSON.stringify({
+        title: "XHS profile",
+        columns: [{ name: "nickname" }],
+      }),
+    });
+
+    const parsed = JSON.parse(result.content);
+    expect(parsed.error).toBe("knowledge_capture_requires_confirmation");
+    expect(result.metadata).toMatchObject({
+      serverPlatformTool: true,
+      tableWriteBlocked: true,
+    });
+  });
+
   test("adds typed CLI workspace tools to the default nolo local agent request", async () => {
     const requests: Array<{ body: any }> = [];
     const adapter = createCliLocalRuntimeAdapter({
@@ -1356,9 +1706,9 @@ describe("CLI local runtime adapter", () => {
     }
   });
 
-  test("runs execShell locally in explicit worktree shell mode", async () => {
+  test("runs execShell locally by default", async () => {
     const adapter = createCliLocalRuntimeAdapter({
-      env: { NOLO_LOCAL_SHELL_MODE: "worktree" },
+      env: {},
       db: {
         get: async () => ({
           dbKey: "agent-local-shell",
@@ -1389,12 +1739,11 @@ describe("CLI local runtime adapter", () => {
     expect(result.metadata).toMatchObject({ exitCode: 0 });
   });
 
-  test("applies runtime policy shell output limit to local executors without adding a timeout", async () => {
+  test("applies runtime policy shell settings to local executors without adding a timeout", async () => {
     const requests: Array<{ body: any }> = [];
     const adapter = createCliLocalRuntimeAdapter({
       env: {
         NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
-        NOLO_LOCAL_SHELL_MODE: "worktree",
       },
       db: {
         get: async () => ({
@@ -1426,8 +1775,8 @@ describe("CLI local runtime adapter", () => {
                     name: "execShell",
                     arguments: JSON.stringify({
                       cmd: process.platform === "win32"
-                        ? "'abcdefghijklmnopqrstuvwxyz0123456789'.PadRight(500, 'x')"
-                        : "bun -e 'console.log(\"x\".repeat(500))'",
+                        ? "'abcdefghijklmnopqrstuvwxyz0123456789'"
+                        : "node -e 'console.log(\"x\".repeat(50))'",
                     }),
                   },
                 }],
@@ -1449,7 +1798,7 @@ describe("CLI local runtime adapter", () => {
 
     expect(result.content).toBe("limits applied");
     const toolResult = requests[1]?.body.messages.at(-1)?.content ?? "";
-    expect(toolResult).toContain("[truncated ");
+    expect(toolResult).toContain("exitCode: 0");
     expect(toolResult).not.toContain("command timed out");
   });
 
@@ -1458,7 +1807,6 @@ describe("CLI local runtime adapter", () => {
     const adapter = createCliLocalRuntimeAdapter({
       env: {
         NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
-        NOLO_LOCAL_SHELL_MODE: "worktree",
       },
       db: {
         get: async () => ({
@@ -1515,7 +1863,6 @@ describe("CLI local runtime adapter", () => {
     const adapter = createCliLocalRuntimeAdapter({
       env: {
         NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
-        NOLO_LOCAL_SHELL_MODE: "worktree",
       },
       db: {
         get: async () => ({
@@ -1583,7 +1930,6 @@ describe("CLI local runtime adapter", () => {
     const adapter = createCliLocalRuntimeAdapter({
       env: {
         NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
-        NOLO_LOCAL_SHELL_MODE: "worktree",
       },
       db: {
         get: async () => ({
@@ -1682,6 +2028,305 @@ describe("CLI local runtime adapter", () => {
     });
   });
 
+  test("exposes read_xhs_profile to OpenAI-compatible providers when the agent declares it", async () => {
+    const requests: Array<{ body: any }> = [];
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        OPENAI_API_KEY: "sk-local",
+        NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
+      },
+      db: {
+        get: async () => ({
+          dbKey: "agent-local-xhs",
+          prompt: "Read XHS profile.",
+          model: "gpt-4.1-mini",
+          toolNames: ["read_xhs_profile"],
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      fetchImpl: async (_url, init) => {
+        requests.push({ body: JSON.parse(String(init?.body)) });
+        return Response.json({
+          choices: [{ message: { content: "done" } }],
+        });
+      },
+    });
+
+    await runLocalAgentTurn({
+      adapter,
+      agentRef: "xhs",
+      input: "读取小红书用户主页",
+    });
+
+    expect(toolNamesFromRequest(requests[0])).toContain("read_xhs_profile");
+  });
+
+  test("does not expose read_xhs_profile when the agent does not declare it", async () => {
+    const requests: Array<{ body: any }> = [];
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        OPENAI_API_KEY: "sk-local",
+        NOLO_LOCAL_OPENAI_BASE_URL: "http://127.0.0.1:11434/v1",
+      },
+      db: {
+        get: async () => ({
+          dbKey: "agent-local-no-xhs",
+          prompt: "Be helpful.",
+          model: "gpt-4.1-mini",
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      fetchImpl: async (_url, init) => {
+        requests.push({ body: JSON.parse(String(init?.body)) });
+        return Response.json({
+          choices: [{ message: { content: "done" } }],
+        });
+      },
+    });
+
+    await runLocalAgentTurn({
+      adapter,
+      agentRef: "no-xhs",
+      input: "hello",
+    });
+
+    expect(toolNamesFromRequest(requests[0])).not.toContain("read_xhs_profile");
+  });
+
+  test("executes read_xhs_profile locally through the desktop bridge", async () => {
+    const xhsCalls: Array<{ args: any }> = [];
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+      },
+      db: {
+        get: async () => ({
+          dbKey: "agent-user-1-xhs",
+          id: "xhs-agent",
+          prompt: "Read XHS.",
+          toolNames: ["read_xhs_profile"],
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      localToolExecutors: {
+        read_xhs_profile: async (call) => {
+          const parsed = JSON.parse(call.arguments || "{}");
+          xhsCalls.push({ args: parsed });
+          return {
+            content: JSON.stringify({
+              ok: true,
+              data: {
+                profile: { nickname: "test-soul", redId: "12345" },
+                notes: [],
+                noteDetails: [],
+                analysis: {
+                  totalNotes: 0,
+                  commentBuckets: [],
+                },
+              },
+            }),
+            metadata: { xhsLocalBridge: true },
+          };
+        },
+      },
+      fetchImpl: async () => Response.json({}),
+    });
+
+    await adapter.loadAgentConfig("xhs-agent");
+    const result = await adapter.executeTool({
+      id: "call-xhs-1",
+      name: "read_xhs_profile",
+      arguments: JSON.stringify({
+        url: "https://www.xiaohongshu.com/user/profile/5d2be8720000000010007556",
+        maxScrollPages: 3,
+      }),
+    });
+
+    expect(xhsCalls).toHaveLength(1);
+    expect(xhsCalls[0].args.url).toBe(
+      "https://www.xiaohongshu.com/user/profile/5d2be8720000000010007556"
+    );
+    expect(xhsCalls[0].args.maxScrollPages).toBe(3);
+    expect(result.metadata).toMatchObject({ xhsLocalBridge: true });
+    const parsed = JSON.parse(result.content);
+    expect(parsed.ok).toBe(true);
+    expect(parsed.data.profile.nickname).toBe("test-soul");
+  });
+
+  test("default read_xhs_profile executor calls the local bridge reader", async () => {
+    const readerCalls: Array<{ args: any; thunkApi: any }> = [];
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+      },
+      db: {
+        get: async () => ({
+          dbKey: "agent-user-1-xhs-default",
+          id: "xhs-default",
+          prompt: "Read XHS.",
+          toolNames: ["read_xhs_profile"],
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      readXhsProfile: async (args, thunkApi) => {
+        readerCalls.push({ args, thunkApi });
+        return {
+          rawData: {
+            ok: true,
+            data: {
+              profile: { nickname: "default-bridge", redId: "67890" },
+              notes: [],
+              noteDetails: [],
+              commentsByNote: {},
+              analysis: {
+                totalNotes: 0,
+                averageLikes: 0,
+                averageComments: 0,
+                averageCollects: 0,
+                averageShares: 0,
+                commentBuckets: [],
+                themes: [],
+              },
+            },
+            fetchedAt: "2026-06-03T00:00:00.000Z",
+          } as any,
+          displayData: "小红书用户: default-bridge",
+        };
+      },
+      fetchImpl: async () => Response.json({}),
+    });
+
+    await adapter.loadAgentConfig("xhs-default");
+    const result = await adapter.executeTool({
+      id: "call-xhs-default",
+      name: "read_xhs_profile",
+      arguments: JSON.stringify({
+        url: "https://www.xiaohongshu.com/user/profile/5d2be8720000000010007556",
+        includeComments: true,
+        maxCommentPagesPerNote: 1,
+      }),
+    });
+
+    expect(readerCalls).toHaveLength(1);
+    expect(readerCalls[0].args).toMatchObject({
+      url: "https://www.xiaohongshu.com/user/profile/5d2be8720000000010007556",
+      includeComments: true,
+      maxCommentPagesPerNote: 1,
+    });
+    expect(String(readerCalls[0].args.profileDir).replaceAll("\\", "/")).toContain(
+      "chat.nolo.desktop/stable/external-readers/xhs-profile"
+    );
+    expect(readerCalls[0].thunkApi).toBeUndefined();
+    expect(result.metadata).toMatchObject({
+      xhsLocalBridge: true,
+      displayData: "小红书用户: default-bridge",
+    });
+    expect(JSON.parse(result.content).data.profile.nickname).toBe("default-bridge");
+  });
+
+  test("default read_xhs_profile executor honors explicit XHS profile env", async () => {
+    const readerCalls: Array<{ args: any }> = [];
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+        NOLO_XHS_READER_PROFILE_DIR: "/tmp/custom-xhs-profile",
+      },
+      db: {
+        get: async () => ({
+          dbKey: "agent-user-1-xhs-env",
+          id: "xhs-env",
+          prompt: "Read XHS.",
+          toolNames: ["read_xhs_profile"],
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      readXhsProfile: async (args) => {
+        readerCalls.push({ args });
+        return {
+          rawData: {
+            ok: true,
+            data: {
+              profile: { nickname: "env-bridge" },
+              notes: [],
+              noteDetails: [],
+              commentsByNote: {},
+              analysis: { totalNotes: 0, commentBuckets: [] },
+            },
+            fetchedAt: "2026-06-03T00:00:00.000Z",
+          } as any,
+          displayData: "小红书用户: env-bridge",
+        };
+      },
+      fetchImpl: async () => Response.json({}),
+    });
+
+    await adapter.loadAgentConfig("xhs-env");
+    await adapter.executeTool({
+      id: "call-xhs-env",
+      name: "read_xhs_profile",
+      arguments: JSON.stringify({
+        url: "https://www.xiaohongshu.com/user/profile/5d2be8720000000010007556",
+      }),
+    });
+
+    expect(readerCalls).toHaveLength(1);
+    expect(readerCalls[0].args.profileDir).toBeUndefined();
+  });
+
+  test("read_xhs_profile executor does not falsely succeed when bridge is unavailable", async () => {
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+      },
+      db: {
+        get: async () => ({
+          dbKey: "agent-user-1-xhs-fail",
+          id: "xhs-fail",
+          prompt: "Read XHS.",
+          toolNames: ["read_xhs_profile"],
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      localToolExecutors: {
+        read_xhs_profile: async () => ({
+          content: JSON.stringify({
+            ok: false,
+            code: "network_error",
+            message: "read_xhs_profile needs Playwright but it is not installed.",
+          }),
+          metadata: { xhsLocalBridge: true, bridgeError: true },
+        }),
+      },
+      fetchImpl: async () => Response.json({}),
+    });
+
+    await adapter.loadAgentConfig("xhs-fail");
+    const result = await adapter.executeTool({
+      id: "call-xhs-fail",
+      name: "read_xhs_profile",
+      arguments: JSON.stringify({
+        url: "https://www.xiaohongshu.com/user/profile/5d2be8720000000010007556",
+      }),
+    });
+
+    const parsed = JSON.parse(result.content);
+    expect(parsed.ok).toBe(false);
+    expect(parsed.code).toBe("network_error");
+    expect(result.metadata).toMatchObject({ bridgeError: true });
+  });
+
   test("runs allowed workspace file tools through default local executors", async () => {
     const workspaceRoot = mkdtempSync(join(tmpdir(), "nolo-cli-runtime-"));
     try {
@@ -1689,7 +2334,7 @@ describe("CLI local runtime adapter", () => {
         ["agent-user-1-writer", {
           dbKey: "agent-user-1-writer",
           id: "writer",
-          toolNames: ["writeWorkspaceFile"],
+          toolNames: ["writeFile"],
         }],
       ]);
       const adapter = createCliLocalRuntimeAdapter({
@@ -1712,7 +2357,7 @@ describe("CLI local runtime adapter", () => {
       await adapter.loadAgentConfig("writer");
       const result = await adapter.executeTool({
         id: "call-1",
-        name: "writeWorkspaceFile",
+        name: "writeFile",
         arguments: JSON.stringify({
           path: "src/app.ts",
           content: "export const cliValue = 1;\n",