nolo-cli 0.1.38 → 0.1.40

package/client/agentRun.test.ts

@@ -6,7 +6,8 @@ import {
   findServerPlatformTools,
   runAgentTurn,
 } from "./agentRun";
-import { NOLO_PROJECT_MANAGER_AGENT_KEY } from "../agentAliases";
+import { BUILTIN_NOLO_AGENT_KEY } from "./localRuntimeAdapter";
+import { MIMO_MONTH_AGENT_KEY, NOLO_PROJECT_MANAGER_AGENT_KEY } from "../agentAliases";
 
 class CaptureOutput extends Writable {
   chunks: string[] = [];
@@ -34,11 +35,11 @@ describe("cli agent run client", () => {
   });
 
   test("identifies server platform tools that local runtime cannot provide", () => {
-    expect(findServerPlatformTools(["readWorkspaceFile", "queryTableRows", "updateTableRow"])).toEqual([
+    expect(findServerPlatformTools(["readFile", "queryTableRows", "updateTableRow"])).toEqual([
       "queryTableRows",
       "updateTableRow",
     ]);
-    expect(findServerPlatformTools(["readWorkspaceFile", "execShell"])).toEqual([]);
+    expect(findServerPlatformTools(["readFile", "execShell"])).toEqual([]);
   });
 
   test("calls the Nolo HTTP API directly when AUTH_TOKEN is present", async () => {
@@ -93,6 +94,34 @@ describe("cli agent run client", () => {
     expect(output.text()).not.toContain("tokens=");
   });
 
+  test("prints agent run error details from failed HTTP responses", async () => {
+    const output = new CaptureOutput();
+
+    const result = await runAgentTurn({
+      agentName: "win-codex",
+      agentKey: "agent-win-codex",
+      serverUrl: "https://nolo.chat",
+      message: "restart connector",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      fetchImpl: async () =>
+        Response.json({
+          error: "Connector execution failed",
+          reason: "connector_execution_failed",
+          code: "connector_disconnected_mid_run",
+          message: "Connector disconnected for machine: machine-win",
+        }, { status: 502 }),
+    });
+
+    expect(result).toEqual({ exitCode: 1 });
+    expect(output.text()).toContain("[nolo] Agent request failed: HTTP 502");
+    expect(output.text()).toContain("Connector execution failed");
+    expect(output.text()).toContain("Connector disconnected for machine: machine-win");
+    expect(output.text()).toContain("code=connector_disconnected_mid_run");
+    expect(output.text()).toContain("reason=connector_execution_failed");
+  });
+
   test("prepends task-run context for HTTP agent runs", async () => {
     const output = new CaptureOutput();
     const requests: Array<{ body: any }> = [];
@@ -210,7 +239,6 @@ describe("cli agent run client", () => {
       parentDialogId: "dialog-2",
       background: true,
       noStream: true,
-      maxToolRounds: 12,
       timeoutMs: 600000,
       scriptDir: "C:/missing/scripts",
       env: { AUTH_TOKEN: "token-123" },
@@ -230,7 +258,6 @@ describe("cli agent run client", () => {
       inheritedFromDialogKey: "dialog-user-1-dialog-2",
       parentDialogId: "dialog-2",
       background: true,
-      maxRounds: 12,
       timeoutMs: 600000,
       stream: false,
     });
@@ -316,72 +343,75 @@ describe("cli agent run client", () => {
     expect(output.text()).toContain("frontend > local:polish notifications");
   });
 
-  test("increases local max tool rounds when a forced local run exhausts them", async () => {
+  test("continues forced local tool loops until the provider returns final text", async () => {
     const output = new CaptureOutput();
     let completeCalls = 0;
+    let toolCalls = 0;
+
     const result = await runAgentTurn({
       agentName: "frontend",
       agentKey: "frontend-local",
       serverUrl: "https://nolo.chat",
-      message: "polish notifications",
+      message: "make screenshots",
       scriptDir: "C:/missing/scripts",
-      env: { AUTH_TOKEN: "token-123", NOLO_LOCAL_MAX_TOOL_ROUNDS_LIMIT: "1" },
+      env: { AUTH_TOKEN: "token-123" },
       output,
       runtimeMode: "local",
-      maxToolRounds: 0,
       localRuntimeAdapter: {
         host: "cli",
-        capabilities: ["local-provider", "local-persistence"],
+        capabilities: ["local-provider", "local-persistence", "local-tools"],
         loadAgentConfig: async (agentRef) => ({
           key: agentRef,
           name: "Frontend",
           prompt: "Fix UI",
           model: "fake-local",
+          toolNames: ["readFile"],
         }),
         loadDialogHistory: async () => [],
-        saveTurn: async () => ({ dialogId: "dialog-local" }),
+        saveTurn: async () => ({ dialogId: "dialog-local-retry" }),
         resolveProvider: async () => ({
           model: "fake-local",
           complete: async () => {
             completeCalls += 1;
-            return {
-              content: "",
-              model: "fake-local",
-              tool_calls: [{
-                id: `call-${completeCalls}`,
-                type: "function",
-                function: { name: "readWorkspaceFile", arguments: "{}" },
-              }],
-            };
+            if (completeCalls <= 3) {
+              return {
+                content: "",
+                model: "fake-local",
+                tool_calls: [{
+                  id: `call-${completeCalls}`,
+                  type: "function",
+                  function: { name: "readFile", arguments: "{}" },
+                }],
+              };
+            }
+            return { content: "done after retry", model: "fake-local" };
           },
         }),
-        executeTool: async () => ({ content: "ok" }),
-      },
-      fetchImpl: async () => {
-        throw new Error("HTTP should not be called for forced local runs");
+        executeTool: async () => {
+          toolCalls += 1;
+          return { content: "ok" };
+        },
       },
     });
 
-    expect(result).toMatchObject({ exitCode: 1 });
-    expect(output.text()).toContain("Local agent used all 0 tool rounds; retrying with 1.");
-    expect(output.text()).toContain("Local agent exceeded max tool rounds: 1");
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-local-retry" });
+    expect(toolCalls).toBe(3);
+    expect(output.text()).toContain("frontend > done after retry");
   });
 
-  test("completes a forced local run after automatically increasing tool rounds", async () => {
+  test("prints compact local tool trace by default", async () => {
     const output = new CaptureOutput();
     let completeCalls = 0;
-    let toolCalls = 0;
 
     const result = await runAgentTurn({
       agentName: "frontend",
       agentKey: "frontend-local",
       serverUrl: "https://nolo.chat",
-      message: "make screenshots",
+      message: "inspect repo",
       scriptDir: "C:/missing/scripts",
       env: { AUTH_TOKEN: "token-123" },
       output,
       runtimeMode: "local",
-      maxToolRounds: 1,
       localRuntimeAdapter: {
         host: "cli",
         capabilities: ["local-provider", "local-persistence", "local-tools"],
@@ -390,42 +420,39 @@ describe("cli agent run client", () => {
           name: "Frontend",
           prompt: "Fix UI",
           model: "fake-local",
-          toolNames: ["readWorkspaceFile"],
+          toolNames: ["readFile"],
         }),
         loadDialogHistory: async () => [],
-        saveTurn: async () => ({ dialogId: "dialog-local-retry" }),
+        saveTurn: async () => ({ dialogId: "dialog-local" }),
         resolveProvider: async () => ({
           model: "fake-local",
           complete: async () => {
             completeCalls += 1;
-            if (completeCalls <= 3) {
+            if (completeCalls === 1) {
               return {
                 content: "",
                 model: "fake-local",
                 tool_calls: [{
-                  id: `call-${completeCalls}`,
+                  id: "call-read",
                   type: "function",
-                  function: { name: "readWorkspaceFile", arguments: "{}" },
+                  function: { name: "readFile", arguments: JSON.stringify({ path: "README.md" }) },
                 }],
               };
             }
-            return { content: "done after retry", model: "fake-local" };
+            return { content: "done", model: "fake-local" };
           },
         }),
-        executeTool: async () => {
-          toolCalls += 1;
-          return { content: "ok" };
-        },
+        executeTool: async () => ({ content: "clean" }),
       },
     });
 
-    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-local-retry" });
-    expect(toolCalls).toBe(2);
-    expect(output.text()).toContain("Local agent used all 1 tool rounds; retrying with 2.");
-    expect(output.text()).toContain("frontend > done after retry");
+    expect(result).toMatchObject({ exitCode: 0, dialogId: "dialog-local" });
+    expect(output.text()).toContain("[nolo:tool] #1 -> readFile README.md");
+    expect(output.text()).toContain("[nolo:tool] #1 <- readFile");
+    expect(output.text()).toContain("1 line");
   });
 
-  test("prints local tool trace when requested", async () => {
+  test("does not print local tool trace when disabled by env", async () => {
     const output = new CaptureOutput();
     let completeCalls = 0;
 
@@ -435,10 +462,9 @@ describe("cli agent run client", () => {
       serverUrl: "https://nolo.chat",
       message: "inspect repo",
       scriptDir: "C:/missing/scripts",
-      env: { AUTH_TOKEN: "token-123" },
+      env: { AUTH_TOKEN: "token-123", NOLO_TRACE_TOOLS: "0" },
       output,
       runtimeMode: "local",
-      traceTools: true,
       localRuntimeAdapter: {
         host: "cli",
         capabilities: ["local-provider", "local-persistence", "local-tools"],
@@ -447,10 +473,10 @@ describe("cli agent run client", () => {
           name: "Frontend",
           prompt: "Fix UI",
           model: "fake-local",
-          toolNames: ["readWorkspaceFile"],
+          toolNames: ["readFile"],
         }),
         loadDialogHistory: async () => [],
-        saveTurn: async () => ({ dialogId: "dialog-local" }),
+        saveTurn: async () => ({ dialogId: "dialog-local-no-trace" }),
         resolveProvider: async () => ({
           model: "fake-local",
           complete: async () => {
@@ -462,7 +488,7 @@ describe("cli agent run client", () => {
                 tool_calls: [{
                   id: "call-read",
                   type: "function",
-                  function: { name: "readWorkspaceFile", arguments: JSON.stringify({ path: "README.md" }) },
+                  function: { name: "readFile", arguments: JSON.stringify({ path: "README.md" }) },
                 }],
               };
             }
@@ -473,9 +499,79 @@ describe("cli agent run client", () => {
       },
     });
 
-    expect(result).toMatchObject({ exitCode: 0, dialogId: "dialog-local" });
-    expect(output.text()).toContain("[nolo:tool] round 1 -> readWorkspaceFile (call-read)");
-    expect(output.text()).toContain("[nolo:tool] round 1 <- readWorkspaceFile (call-read)");
+    expect(result).toMatchObject({ exitCode: 0, dialogId: "dialog-local-no-trace" });
+    expect(output.text()).not.toContain("[nolo:tool]");
+  });
+
+  test("prints local tool events as jsonl when requested", async () => {
+    const output = new CaptureOutput();
+    let completeCalls = 0;
+
+    const result = await runAgentTurn({
+      agentName: "frontend",
+      agentKey: "frontend-local",
+      serverUrl: "https://nolo.chat",
+      message: "inspect repo",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      runtimeMode: "local",
+      eventsMode: "jsonl",
+      localRuntimeAdapter: {
+        host: "cli",
+        capabilities: ["local-provider", "local-persistence", "local-tools"],
+        loadAgentConfig: async (agentRef) => ({
+          key: agentRef,
+          name: "Frontend",
+          prompt: "Fix UI",
+          model: "fake-local",
+          toolNames: ["execShell"],
+        }),
+        loadDialogHistory: async () => [],
+        saveTurn: async () => ({ dialogId: "dialog-local-jsonl" }),
+        resolveProvider: async () => ({
+          model: "fake-local",
+          complete: async () => {
+            completeCalls += 1;
+            if (completeCalls === 1) {
+              return {
+                content: "",
+                model: "fake-local",
+                tool_calls: [{
+                  id: "call-shell",
+                  type: "function",
+                  function: { name: "execShell", arguments: JSON.stringify({ command: "git status --short" }) },
+                }],
+              };
+            }
+            return { content: "done", model: "fake-local" };
+          },
+        }),
+        executeTool: async () => ({ content: "stdout:\nclean\n\nexitCode: 0", metadata: { exitCode: 0 } }),
+      },
+    });
+
+    expect(result).toMatchObject({ exitCode: 0, dialogId: "dialog-local-jsonl" });
+    const events = output.text()
+      .split(/\r?\n/)
+      .filter((line) => line.startsWith("{"))
+      .map((line) => JSON.parse(line))
+      .filter((event) => typeof event.type === "string" && event.type.startsWith("tool-"));
+    expect(events).toHaveLength(2);
+    expect(events[0]).toMatchObject({
+      schemaVersion: 1,
+      type: "tool-call",
+      round: 1,
+      tool: "execShell",
+      argsPreview: "git status --short",
+    });
+    expect(events[1]).toMatchObject({
+      schemaVersion: 1,
+      type: "tool-result",
+      round: 1,
+      tool: "execShell",
+      summary: expect.stringContaining("exit=0"),
+    });
   });
 
   test("passes local tool evidence to task-run writeback", async () => {
@@ -507,7 +603,7 @@ describe("cli agent run client", () => {
           name: "Frontend",
           prompt: "Fix UI",
           model: "fake-local",
-          toolNames: ["readWorkspaceFile"],
+          toolNames: ["readFile"],
         }),
         loadDialogHistory: async () => [],
         saveTurn: async () => ({ dialogId: "dialog-local" }),
@@ -522,7 +618,7 @@ describe("cli agent run client", () => {
                 tool_calls: [{
                   id: "call-read",
                   type: "function",
-                  function: { name: "readWorkspaceFile", arguments: JSON.stringify({ path: "README.md" }) },
+                  function: { name: "readFile", arguments: JSON.stringify({ path: "README.md" }) },
                 }],
               };
             }
@@ -536,7 +632,7 @@ describe("cli agent run client", () => {
     expect(result).toMatchObject({ exitCode: 0, dialogId: "dialog-local" });
     expect(writebacks).toHaveLength(1);
     expect(writebacks[0].toolEvidence).toEqual({
-      toolsUsed: ["readWorkspaceFile"],
+      toolsUsed: ["readFile"],
       summary: {
         callCount: 1,
         resultCount: 1,
@@ -791,6 +887,160 @@ describe("cli agent run client", () => {
     expect(output.text()).toContain("pm > server ok");
   });
 
+  test("auto mode does not skip monthly Mimo when a local shell cwd is already bound", async () => {
+    const output = new CaptureOutput();
+    const httpCalls: string[] = [];
+    let providerCalled = false;
+
+    const result = await runAgentTurn({
+      agentName: MIMO_MONTH_AGENT_KEY,
+      agentKey: MIMO_MONTH_AGENT_KEY,
+      serverUrl: "https://us.nolo.chat",
+      message: "fix tests and commit",
+      scriptDir: "C:/missing/scripts",
+      env: {
+        AUTH_TOKEN: "token-123",
+      },
+      output,
+      runtimeMode: "auto",
+      localRuntimeCwd: "/repo/.worktrees/nolo-agent-mimo",
+      localRuntimeAdapter: {
+        host: "cli",
+        capabilities: ["leveldb-agent-config", "local-provider", "local-tools"],
+        loadAgentConfig: async (agentRef) => ({
+          key: agentRef,
+          name: "包月 Mimo",
+          prompt: "Implement backend tasks.",
+          provider: "custom",
+          model: "mimo-v2.5-pro",
+          toolNames: ["queryTableRows"],
+        }),
+        loadDialogHistory: async () => [],
+        saveTurn: async () => ({ dialogId: "dialog-mimo-local" }),
+        resolveProvider: async () => ({
+          model: "mimo-v2.5-pro",
+          complete: async () => {
+            providerCalled = true;
+            return { content: "local mimo ok", model: "mimo-v2.5-pro" };
+          },
+        }),
+        executeTool: async () => ({ content: "ok" }),
+      },
+      fetchImpl: async (url) => {
+        httpCalls.push(String(url));
+        return Response.json({ content: "server" });
+      },
+    });
+
+    expect(providerCalled).toBe(true);
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-mimo-local" });
+    expect(httpCalls).toEqual([]);
+    expect(output.text()).not.toContain("skipping local runtime");
+    expect(output.text()).toContain(`${MIMO_MONTH_AGENT_KEY} -> working locally`);
+  });
+
+  test("auto mode skips local runtime for machine-bound localhost custom providers", async () => {
+    const output = new CaptureOutput();
+    const httpCalls: Array<{ url: string; body: any }> = [];
+
+    const result = await runAgentTurn({
+      agentName: "win-qwen",
+      agentKey: "agent-win-qwen",
+      serverUrl: "https://nolo.chat",
+      message: "run on the bound Windows machine",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123", OPENAI_API_KEY: "local-provider-present" },
+      output,
+      runtimeMode: "auto",
+      localRuntimeAdapter: {
+        host: "cli",
+        capabilities: ["leveldb-agent-config", "local-provider", "local-tools"],
+        loadAgentConfig: async (agentRef) => ({
+          key: agentRef,
+          name: "Win Qwen",
+          prompt: "Windows local model",
+          provider: "custom",
+          model: "qwen",
+          customProviderUrl: "http://127.0.0.1:8080/v1/chat/completions",
+          runtimeBinding: {
+            machineId: "machine-win",
+            ownerUserId: "user-1",
+            connectorSurface: "cli",
+          },
+        }),
+        loadDialogHistory: async () => [],
+        saveTurn: async () => {
+          throw new Error("local runtime should be skipped");
+        },
+        resolveProvider: async () => {
+          throw new Error("local provider should be skipped");
+        },
+        executeTool: async () => {
+          throw new Error("local tools should be skipped");
+        },
+      },
+      fetchImpl: async (url, init) => {
+        httpCalls.push({ url: String(url), body: JSON.parse(String(init?.body)) });
+        return Response.json({ content: "server connector ok", dialogId: "dialog-win" });
+      },
+    });
+
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-win" });
+    expect(httpCalls).toHaveLength(1);
+    expect(httpCalls[0]?.body.agentKey).toBe("agent-win-qwen");
+    expect(output.text()).toContain("auto runtime: skipping local runtime");
+    expect(output.text()).toContain("machine-bound localhost custom provider");
+    expect(output.text()).not.toContain("win-qwen -> working locally");
+  });
+
+  test("auto mode keeps builtin nolo on local runtime so CLI workspace tools are available", async () => {
+    const output = new CaptureOutput();
+    const httpCalls: string[] = [];
+    let providerCalled = false;
+
+    const result = await runAgentTurn({
+      agentName: "nolo",
+      agentKey: BUILTIN_NOLO_AGENT_KEY,
+      serverUrl: "https://nolo.chat",
+      message: "帮我总结最近 10 个对话",
+      scriptDir: "C:/missing/scripts",
+      env: { AUTH_TOKEN: "token-123" },
+      output,
+      runtimeMode: "auto",
+      localRuntimeAdapter: {
+        host: "cli",
+        capabilities: ["leveldb-agent-config", "local-provider", "local-tools"],
+        loadAgentConfig: async () => ({
+          key: BUILTIN_NOLO_AGENT_KEY,
+          name: "nolo",
+          prompt: "Use workspace tools.",
+          model: "fake-local",
+          toolNames: ["queryTableRows", "addTableRow", "updateTableRow"],
+        }),
+        loadDialogHistory: async () => [],
+        saveTurn: async () => ({ dialogId: "dialog-builtin-nolo-local" }),
+        resolveProvider: async () => ({
+          model: "fake-local",
+          complete: async () => {
+            providerCalled = true;
+            return { content: "local nolo with tools", model: "fake-local" };
+          },
+        }),
+        executeTool: async () => ({ content: "[]" }),
+      },
+      fetchImpl: async (url) => {
+        httpCalls.push(String(url));
+        return Response.json({ content: "server" });
+      },
+    });
+
+    expect(providerCalled).toBe(true);
+    expect(result).toEqual({ exitCode: 0, dialogId: "dialog-builtin-nolo-local" });
+    expect(httpCalls).toEqual([]);
+    expect(output.text()).not.toContain("skipping local runtime");
+    expect(output.text()).toContain("nolo -> working locally");
+  });
+
   test("auto mode skips local runtime for server platform tools declared by runtime policy", async () => {
     const output = new CaptureOutput();
     const httpCalls: Array<{ url: string; body: any }> = [];