nolo-cli 0.1.40 → 0.1.42

package/client/localRuntimeAdapter.test.ts

@@ -4,7 +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 { LOCAL_CODEX_AGENT_KEY, LOCAL_QODER_AGENT_KEY, MIMO_MONTH_AGENT_KEY } from "../agentAliases";
 import { createCliLocalRuntimeAdapter } from "./localRuntimeAdapter";
 
 describe("CLI local runtime adapter", () => {
@@ -13,6 +13,7 @@ describe("CLI local runtime adapter", () => {
     "readFile",
     "writeFile",
     "editFile",
+    "globFiles",
     "searchFiles",
     "execShell",
   ];
@@ -21,6 +22,7 @@ describe("CLI local runtime adapter", () => {
     "readFile",
     "writeFile",
     "editFile",
+    "globFiles",
     "searchFiles",
     "execShell",
   ];
@@ -36,6 +38,7 @@ describe("CLI local runtime adapter", () => {
     "readSpace",
     "readDoc",
     "readSkillDoc",
+    "listTables",
     "queryTableRows",
     "cliWhoami",
     "cliDoctor",
@@ -49,6 +52,87 @@ describe("CLI local runtime adapter", () => {
     return request?.body?.tools?.map((tool: any) => tool.function.name) ?? [];
   }
 
+  function publicSchemaKeys(schema: any) {
+    return Object.keys(schema.parameters.properties).filter((key) => key !== "_activity");
+  }
+
+  test("loads stored local CLI agent records before falling back to built-ins", async () => {
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "0e95801d90",
+      },
+      db: {
+        get: async (key) => {
+          if (key !== LOCAL_CODEX_AGENT_KEY) throw new Error(`not found: ${key}`);
+          return {
+            dbKey: LOCAL_CODEX_AGENT_KEY,
+            id: "01LOCALCODEXCLI000000NEW",
+            name: "User Edited Local Codex",
+            prompt: "User-owned local Codex prompt.",
+            apiSource: "cli",
+            provider: "cli",
+            cliProvider: "codex",
+            model: "gpt-5.4",
+          };
+        },
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      fetchImpl: async () => new Response("not found", { status: 404 }),
+    } as any);
+
+    await expect(adapter.loadAgentConfig(LOCAL_CODEX_AGENT_KEY)).resolves.toMatchObject({
+      key: LOCAL_CODEX_AGENT_KEY,
+      name: "User Edited Local Codex",
+      prompt: "User-owned local Codex prompt.",
+      apiSource: "cli",
+      provider: "cli",
+      cliProvider: "codex",
+      model: "gpt-5.4",
+    });
+  });
+
+  test("falls back to built-in local Codex and Qoder CLI agents without machine binding", async () => {
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+      },
+      db: {
+        get: async (key) => {
+          throw new Error(`not found: ${key}`);
+        },
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      fetchImpl: async () => new Response("not found", { status: 404 }),
+    } as any);
+
+    const codex = await adapter.loadAgentConfig(LOCAL_CODEX_AGENT_KEY);
+    const qoder = await adapter.loadAgentConfig(LOCAL_QODER_AGENT_KEY);
+
+    expect(codex).toMatchObject({
+      key: LOCAL_CODEX_AGENT_KEY,
+      name: "Local Codex",
+      apiSource: "cli",
+      provider: "cli",
+      cliProvider: "codex",
+    });
+    expect(qoder).toMatchObject({
+      key: LOCAL_QODER_AGENT_KEY,
+      name: "Local Qoder",
+      apiSource: "cli",
+      provider: "cli",
+      cliProvider: "qoder",
+      model: "Qwen3.7-Max",
+    });
+    expect((codex as any)?.runtimeBinding).toBeUndefined();
+    expect((qoder as any)?.runtimeBinding).toBeUndefined();
+    expect((codex as any)?.rawRecord?.runtimeBinding).toBeUndefined();
+    expect((qoder as any)?.rawRecord?.runtimeBinding).toBeUndefined();
+  });
+
   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({
@@ -535,11 +619,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);
         },
@@ -892,7 +973,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);
   });
 
@@ -1327,7 +1408,6 @@ describe("CLI local runtime adapter", () => {
             "execShell",
             "checkEnv",
             "queryTableRows",
-            "taskRun",
           ],
         }),
         put: async () => {},
@@ -1351,6 +1431,308 @@ describe("CLI local runtime adapter", () => {
     expect(toolNamesFromRequest(requests[0])).toEqual(SHELL_LOCAL_CODING_TOOL_NAMES);
   });
 
+  test("can expose only declared local workspace tools for tool ablations", 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_WORKSPACE_TOOLSET: "declared-only",
+      },
+      db: {
+        get: async () => ({
+          dbKey: MIMO_MONTH_AGENT_KEY,
+          prompt: "Use exactly the declared local tools.",
+          model: "mimo-v2.5-pro",
+          provider: "custom",
+          tools: ["listFiles", "readFile", "execShell"],
+        }),
+        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(["listFiles", "readFile", "execShell"]);
+  });
+
+  test("defaults local workspace tools to strategy descriptions and rich parameters", 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_WORKSPACE_TOOLSET: "declared-only",
+      },
+      db: {
+        get: async () => ({
+          dbKey: MIMO_MONTH_AGENT_KEY,
+          prompt: "Use local coding tools.",
+          model: "mimo-v2.5-pro",
+          provider: "custom",
+          tools: ["listFiles", "readFile", "globFiles", "searchFiles"],
+        }),
+        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",
+    });
+
+    const tools = new Map(
+      requests[0]?.body.tools.map((tool: any) => [tool.function.name, tool.function]),
+    );
+    const listFiles = tools.get("listFiles") as any;
+    const readFile = tools.get("readFile") as any;
+    const globFiles = tools.get("globFiles") as any;
+    const searchFiles = tools.get("searchFiles") as any;
+
+    expect(listFiles.description).toContain("not for path-pattern discovery across the repo");
+    expect(publicSchemaKeys(listFiles)).toEqual([
+      "path",
+      "maxDepth",
+      "maxResults",
+      "entryType",
+    ]);
+    expect(readFile.description).toContain("Use line ranges");
+    expect(publicSchemaKeys(readFile)).toEqual([
+      "path",
+      "startLine",
+      "endLine",
+      "maxLines",
+      "tailLines",
+    ]);
+    expect(globFiles.description).toContain("any file discovery task");
+    expect(publicSchemaKeys(globFiles)).toEqual([
+      "pattern",
+      "path",
+      "exclude",
+      "includeIgnored",
+      "maxResults",
+    ]);
+    expect(searchFiles.description).toContain("using ripgrep when available");
+    expect(publicSchemaKeys(searchFiles)).toEqual([
+      "query",
+      "path",
+      "exclude",
+      "includeIgnored",
+      "maxResults",
+      "literal",
+      "caseSensitive",
+      "contextLines",
+    ]);
+  });
+
+  test("can vary globFiles schema through local runtime env", 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_GLOBFILES_DESCRIPTION_VARIANT: "antiShell",
+        NOLO_GLOBFILES_PARAMETER_VARIANT: "rich",
+      },
+      db: {
+        get: async () => ({
+          dbKey: MIMO_MONTH_AGENT_KEY,
+          prompt: "Use local coding tools.",
+          model: "mimo-v2.5-pro",
+          provider: "custom",
+          tools: ["globFiles"],
+        }),
+        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: "find tests",
+    });
+
+    const globFiles = requests[0]?.body.tools.find((tool: any) => tool.function.name === "globFiles")?.function;
+    expect(globFiles.description).toContain("Do not use execShell or listFiles for path discovery");
+    expect(publicSchemaKeys(globFiles)).toEqual([
+      "pattern",
+      "path",
+      "exclude",
+      "includeIgnored",
+      "maxResults",
+    ]);
+  });
+
+  test("can vary listFiles schema through local runtime env", 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_LISTFILES_DESCRIPTION_VARIANT: "antiShell",
+        NOLO_LISTFILES_PARAMETER_VARIANT: "rich",
+      },
+      db: {
+        get: async () => ({
+          dbKey: MIMO_MONTH_AGENT_KEY,
+          prompt: "Use local coding tools.",
+          model: "mimo-v2.5-pro",
+          provider: "custom",
+          tools: ["listFiles"],
+        }),
+        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: "list directories",
+    });
+
+    const listFiles = requests[0]?.body.tools.find((tool: any) => tool.function.name === "listFiles")?.function;
+    expect(listFiles.description).toContain("Do not use execShell with ls/find/tree");
+    expect(publicSchemaKeys(listFiles)).toEqual([
+      "path",
+      "maxDepth",
+      "maxResults",
+      "entryType",
+    ]);
+  });
+
+  test("can vary readFile schema through local runtime env", 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_READFILE_DESCRIPTION_VARIANT: "strategy",
+        NOLO_READFILE_PARAMETER_VARIANT: "rich",
+      },
+      db: {
+        get: async () => ({
+          dbKey: MIMO_MONTH_AGENT_KEY,
+          prompt: "Use local coding tools.",
+          model: "mimo-v2.5-pro",
+          provider: "custom",
+          tools: ["readFile"],
+        }),
+        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: "read a file range",
+    });
+
+    const readFile = requests[0]?.body.tools.find((tool: any) => tool.function.name === "readFile")?.function;
+    expect(readFile.description).toContain("Use line ranges");
+    expect(readFile.parameters.properties.maxLines.description).toContain("each readFile preview consumes one budget slot");
+    expect(publicSchemaKeys(readFile)).toEqual([
+      "path",
+      "startLine",
+      "endLine",
+      "maxLines",
+      "tailLines",
+    ]);
+  });
+
+  test("can vary searchFiles schema through local runtime env", 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_SEARCHFILES_DESCRIPTION_VARIANT: "antiShell",
+        NOLO_SEARCHFILES_PARAMETER_VARIANT: "rich",
+      },
+      db: {
+        get: async () => ({
+          dbKey: MIMO_MONTH_AGENT_KEY,
+          prompt: "Use local coding tools.",
+          model: "mimo-v2.5-pro",
+          provider: "custom",
+          tools: ["searchFiles"],
+        }),
+        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: "find TODO",
+    });
+
+    const searchFiles = requests[0]?.body.tools.find((tool: any) => tool.function.name === "searchFiles")?.function;
+    expect(searchFiles.description).toContain("Do not use execShell for content search");
+    expect(publicSchemaKeys(searchFiles)).toEqual([
+      "query",
+      "path",
+      "exclude",
+      "includeIgnored",
+      "maxResults",
+      "literal",
+      "caseSensitive",
+      "contextLines",
+    ]);
+  });
+
   test("allows default semantic workspace tools without legacy agent tool declarations", async () => {
     const workspaceRoot = mkdtempSync(join(tmpdir(), "nolo-cli-runtime-"));
     try {
@@ -1384,7 +1766,7 @@ describe("CLI local runtime adapter", () => {
     }
   });
 
-  test("exposes declared taskRun as a platform tool in local runtime requests", async () => {
+  test("exposes declared server table write tools in local runtime requests", async () => {
     const requests: Array<{ body: any }> = [];
     const adapter = createCliLocalRuntimeAdapter({
       env: {
@@ -1393,10 +1775,10 @@ describe("CLI local runtime adapter", () => {
       },
       db: {
         get: async () => ({
-          dbKey: "agent-local-taskrun",
-          prompt: "Use taskRun.",
+          dbKey: "agent-local-table",
+          prompt: "Use table tools.",
           model: "gpt-4.1-mini",
-          toolNames: ["taskRun"],
+          toolNames: ["createTable", "addTableRow", "addTableRows"],
         }),
         put: async () => {},
         batch: async () => {},
@@ -1412,24 +1794,27 @@ describe("CLI local runtime adapter", () => {
 
     await runLocalAgentTurn({
       adapter,
-      agentRef: "taskrun",
-      input: "read task context",
+      agentRef: "table",
+      input: "采集并写入 table",
     });
 
-    expect(toolNamesFromRequest(requests[0])).toContain("taskRun");
+    const toolNames = toolNamesFromRequest(requests[0]);
+    expect(toolNames).toContain("createTable");
+    expect(toolNames).toContain("addTableRow");
+    expect(toolNames).toContain("addTableRows");
   });
 
-  test("executes declared taskRun through the server task-run bridge", async () => {
+  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: {
-        BASE_URL: "https://us.nolo.chat",
-        AUTH_TOKEN: "machine-token",
+        NOLO_SERVER: "https://us.nolo.chat",
+        AUTH_TOKEN: "token-1",
       },
       db: {
         get: async () => ({
-          dbKey: "agent-local-taskrun",
-          toolNames: ["taskRun"],
+          dbKey: "agent-local-table-write",
+          toolNames: ["createTable"],
         }),
         put: async () => {},
         batch: async () => {},
@@ -1441,32 +1826,81 @@ describe("CLI local runtime adapter", () => {
           auth: new Headers(init?.headers).get("authorization"),
           body: JSON.parse(String(init?.body)),
         });
-        return Response.json({ ok: true, row: { rowId: "task-1" } });
+        return Response.json({
+          ok: true,
+          tenantId: "user-1",
+          tableId: "table-1",
+        });
       },
     });
 
-    await adapter.loadAgentConfig("taskrun");
+    await adapter.loadAgentConfig("table-write");
     const result = await adapter.executeTool({
-      id: "call-taskrun",
-      name: "taskRun",
+      id: "call-create-table",
+      name: "createTable",
+      userInput: "采集这个用户并写入 table",
       arguments: JSON.stringify({
-        action: "readTaskContext",
-        dbKey: "row-user-NOLOTASKBOARD-task-1",
+        title: "XHS profile",
+        purpose: "agent_eval_workbench",
+        columns: [{ name: "nickname" }],
       }),
     });
 
     expect(requests).toEqual([
       {
-        url: "https://us.nolo.chat/api/task-run",
-        auth: "Bearer machine-token",
+        url: "https://us.nolo.chat/api/table/create",
+        auth: "Bearer token-1",
         body: {
-          action: "readTaskContext",
-          dbKey: "row-user-NOLOTASKBOARD-task-1",
+          title: "XHS profile",
+          purpose: "agent_eval_workbench",
+          columns: [{ name: "nickname" }],
         },
       },
     ]);
-    expect(result.content).toContain("\"ok\":true");
-    expect(result.metadata).toMatchObject({ serverPlatformTool: true });
+    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 () => {
@@ -1896,6 +2330,434 @@ 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("exposes read_x_post 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-x-post",
+          prompt: "Read X posts.",
+          model: "gpt-4.1-mini",
+          toolNames: ["read_x_post"],
+        }),
+        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: "x-post",
+      input: "读取 X 帖子",
+    });
+
+    expect(toolNamesFromRequest(requests[0])).toContain("read_x_post");
+  });
+
+  test("adds read_x_post to local web-capable agent tool 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: "agent-local-web-reader",
+          prompt: "Read web pages.",
+          model: "gpt-4.1-mini",
+          toolNames: ["fetchWebpage"],
+        }),
+        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: "web-reader",
+      input: "读取 X 帖子",
+    });
+
+    expect(toolNamesFromRequest(requests[0])).toContain("read_x_post");
+  });
+
+  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_x_post executor calls the local bridge reader", async () => {
+    const readerCalls: Array<{ args: any }> = [];
+    const adapter = createCliLocalRuntimeAdapter({
+      env: {
+        NOLO_LOCAL_USER_ID: "user-1",
+      },
+      db: {
+        get: async () => ({
+          dbKey: "agent-user-1-x-post-default",
+          id: "x-post-default",
+          prompt: "Read X posts.",
+          toolNames: ["read_x_post"],
+        }),
+        put: async () => {},
+        batch: async () => {},
+        iterator: () => (async function* () {})(),
+      },
+      readXPost: async (args) => {
+        readerCalls.push({ args });
+        return {
+          rawData: {
+            ok: true,
+            backend: "desktop_local_browser",
+            fetchedAt: "2026-06-08T00:00:00.000Z",
+            data: {
+              id: "2063842222307704944",
+              url: "https://x.com/BohuTANG/status/2063842222307704944",
+              text: "mock x post",
+              author: {
+                handle: "BohuTANG",
+                displayName: "Bohu",
+              },
+            },
+          } as any,
+          displayData: "已读取 X 帖子：@BohuTANG",
+        };
+      },
+      fetchImpl: async () => Response.json({}),
+    });
+
+    await adapter.loadAgentConfig("x-post-default");
+    const result = await adapter.executeTool({
+      id: "call-x-post-default",
+      name: "read_x_post",
+      arguments: JSON.stringify({
+        url: "https://x.com/BohuTANG/status/2063842222307704944",
+        keepOpen: true,
+      }),
+    });
+
+    expect(readerCalls).toHaveLength(1);
+    expect(readerCalls[0].args).toMatchObject({
+      url: "https://x.com/BohuTANG/status/2063842222307704944",
+      keepOpen: true,
+    });
+    expect(result.metadata).toMatchObject({ xPostLocalBridge: true });
+    const parsed = JSON.parse(result.content);
+    expect(parsed.ok).toBe(true);
+    expect(parsed.data.text).toBe("mock x post");
+  });
+
+  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(readerCalls[0].args.profileDir).toBeUndefined();
+    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 ignores 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 {