skyloom 1.16.0 → 1.16.2

package/src/core/tool.ts

@@ -37,9 +37,26 @@ export interface ToolDefinition {
   retryDelay?: number;
   dangerous?: boolean;
   cacheable?: boolean;
+  /**
+   * Pure read-only tool with no side effects: two identical calls in the same
+   * round always return the same thing. Enables within-round dedup (the second
+   * identical call is skipped and shares the first result), which avoids
+   * duplicate file reads / network searches the model often emits in parallel.
+   * Unlike `cacheable`, it does NOT cache across rounds (the world may change).
+   */
+  idempotent?: boolean;
   timeout?: number;
 }
 
+/** Order-stable JSON key so {a,b} and {b,a} hash to the same cache/dedup key. */
+export function stableStringify(value: unknown): string {
+  return JSON.stringify(value, (_k, v) =>
+    v && typeof v === "object" && !Array.isArray(v)
+      ? Object.keys(v).sort().reduce((acc: Record<string, unknown>, key) => { acc[key] = v[key]; return acc; }, {})
+      : v,
+  );
+}
+
 /**
  * Tool execution result
  */
@@ -301,7 +318,7 @@ export class ToolRegistry extends EventEmitter {
 
     // Check cache
     if (tool.cacheable) {
-      const cacheKey = JSON.stringify(params);
+      const cacheKey = stableStringify(params);
       const cached = resultStore.get(toolName, cacheKey);
       if (cached) {
         log.debug("Tool cache hit", { tool: toolName });
@@ -343,19 +360,26 @@ export class ToolRegistry extends EventEmitter {
 
         const startTime = Date.now();
 
-        // Execute with timeout
-        const promise = tool.handler(params);
-        const timeoutPromise = new Promise<string>((_, reject) =>
-          setTimeout(() => reject(new Error("Tool execution timeout")), timeout)
-        );
-
-        const result = await Promise.race([promise, timeoutPromise]);
+        // Execute with a timeout that we always clear. The previous
+        // Promise.race left the timeout's setTimeout pending whenever the
+        // handler won — a dangling 30s timer per tool call that kept the event
+        // loop alive (delaying process exit) and accumulated under load.
+        let timer: ReturnType<typeof setTimeout> | undefined;
+        const timeoutPromise = new Promise<string>((_, reject) => {
+          timer = setTimeout(() => reject(new Error("Tool execution timeout")), timeout);
+        });
+        let result: string;
+        try {
+          result = await Promise.race([tool.handler(params), timeoutPromise]);
+        } finally {
+          if (timer) clearTimeout(timer);
+        }
 
         const duration = Date.now() - startTime;
 
         // Cache result
         if (tool.cacheable) {
-          const cacheKey = JSON.stringify(params);
+          const cacheKey = stableStringify(params);
           resultStore.set(toolName, cacheKey, result);
         }
 

package/src/tools/builtin.ts

@@ -27,6 +27,7 @@ export function registerBuiltinTools(registry: ToolRegistry): void {
 
   registry.register({
     name: 'read_file',
+    idempotent: true,
     description: 'Read the contents of a file. Large files are paged: pass offset (1-based start line) and limit (line count) to read further sections; use grep to locate the right offset first.',
     parameters: [
       { name: 'path', type: 'string', description: 'Absolute or relative path to the file', required: true },
@@ -123,6 +124,7 @@ export function registerBuiltinTools(registry: ToolRegistry): void {
 
   registry.register({
     name: 'list_directory',
+    idempotent: true,
     description: 'List files and directories at the given path.',
     parameters: [
       { name: 'path', type: 'string', description: 'Path to list', required: true },
@@ -145,6 +147,7 @@ export function registerBuiltinTools(registry: ToolRegistry): void {
 
   registry.register({
     name: 'file_search',
+    idempotent: true,
     description: 'Search for files matching a glob pattern.',
     parameters: [
       { name: 'pattern', type: 'string', description: 'Glob pattern to match (e.g. "**/*.ts")', required: true },
@@ -190,6 +193,7 @@ export function registerBuiltinTools(registry: ToolRegistry): void {
 
   registry.register({
     name: 'http_get',
+    idempotent: true,
     description: 'Make an HTTP GET request to a URL.',
     parameters: [
       { name: 'url', type: 'string', description: 'URL to fetch', required: true },
@@ -224,6 +228,7 @@ export function registerBuiltinTools(registry: ToolRegistry): void {
 
   registry.register({
     name: 'web_search',
+    idempotent: true,
     description:
       'Search the live web and return titles, URLs, and snippets (plus a direct answer when available). ' +
       'USE THIS whenever the answer depends on current or real-time information — today\'s news and hot topics, ' +
@@ -253,6 +258,7 @@ export function registerBuiltinTools(registry: ToolRegistry): void {
 
   registry.register({
     name: 'read_url',
+    idempotent: true,
     description:
       'Fetch a web page as clean, readable text (markdown), with boilerplate (nav/ads) stripped. ' +
       'Use after web_search to read a result in full, or to read any known URL. Prefer this over http_get for articles/pages.',
@@ -372,6 +378,7 @@ export function registerBuiltinTools(registry: ToolRegistry): void {
 
   registry.register({
     name: 'grep',
+    idempotent: true,
     description: 'Search for a pattern in files using ripgrep or grep.',
     parameters: [
       { name: 'pattern', type: 'string', description: 'Regex pattern to search for', required: true },
@@ -406,6 +413,7 @@ export function registerBuiltinTools(registry: ToolRegistry): void {
 
   registry.register({
     name: 'tree',
+    idempotent: true,
     description: 'Display directory tree structure.',
     parameters: [
       { name: 'directory', type: 'string', description: 'Directory to show tree for', required: false },

package/tests/agent.test.ts

@@ -40,9 +40,9 @@ class MockLLM {
   setLogger() { /* noop */ }
 }
 
-function makeAgent(turns: Turn[], tools: { name: string; handler: (a: any) => Promise<string> }[] = []) {
+function makeAgent(turns: Turn[], tools: { name: string; handler: (a: any) => Promise<string>; idempotent?: boolean }[] = []) {
   const reg = new ToolRegistry();
-  for (const t of tools) reg.register({ name: t.name, description: t.name, handler: t.handler });
+  for (const t of tools) reg.register({ name: t.name, description: t.name, handler: t.handler, idempotent: t.idempotent });
   const config = { agents: { fog: {} }, llm: { language: "zh" }, memory: { shortTermLimit: 100, dbPath: "/tmp/sky-test" } };
   const agent = new FogAgent(config as any, new MockLLM(turns) as any, new MessageBus(), reg, new SkillRegistry());
   return agent;
@@ -209,3 +209,36 @@ describe("agent · run tracing", () => {
     expect(trace!.spans.every((s: any) => s.endMs !== null)).toBe(true);
   });
 });
+
+describe("agent · within-round dedup of read-only tools", () => {
+  it("runs an idempotent tool once when the model emits it twice with identical args", async () => {
+    let runs = 0;
+    const agent = makeAgent(
+      [{ content: "looking", toolCalls: [{ name: "rd", args: { p: "x" } }, { name: "rd", args: { p: "x" } }] }, { content: "done" }],
+      [{ name: "rd", idempotent: true, handler: async () => { runs++; return "content-x"; } }],
+    );
+    const evs = await collect(agent.chatStream("go"));
+    expect(runs).toBe(1); // deduped — handler ran once
+    // both tool calls still get a result (the duplicate shares the original's)
+    const done = evs.filter((e) => e.type === "tool_done" && e.tool_name === "rd");
+    expect(done.length).toBe(2);
+    expect(done.every((e) => e.success)).toBe(true);
+  });
+
+  it("does NOT dedup different args, nor non-idempotent tools", async () => {
+    let rdRuns = 0, wrRuns = 0;
+    const agent = makeAgent(
+      [{ content: "x", toolCalls: [
+        { name: "rd", args: { p: "a" } }, { name: "rd", args: { p: "b" } }, // different args → both run
+        { name: "wr", args: { p: "a" } }, { name: "wr", args: { p: "a" } }, // not idempotent → both run
+      ] }, { content: "done" }],
+      [
+        { name: "rd", idempotent: true, handler: async () => { rdRuns++; return "r"; } },
+        { name: "wr", handler: async () => { wrRuns++; return "w"; } },
+      ],
+    );
+    await collect(agent.chatStream("go"));
+    expect(rdRuns).toBe(2);
+    expect(wrRuns).toBe(2);
+  });
+});

package/tests/commands.test.ts

@@ -88,6 +88,29 @@ describe("registry ↔ TUI wiring", () => {
   });
 });
 
+describe("registry renderHelp", () => {
+  const lines = registry.renderHelp("zh");
+  const text = lines.join("\n");
+
+  it("groups commands under category section headers", () => {
+    expect(lines.some((l) => l.startsWith("§"))).toBe(true);
+    expect(text).toContain("§ Agent 切换");
+    expect(text).toContain("§ 系统");
+  });
+
+  it("lists real commands with their zh labels and omits hidden ones", () => {
+    expect(text).toContain("/trace");
+    expect(text).toContain("/apikey");
+    expect(text).not.toContain("/share");   // hidden
+    expect(text).not.toContain("/unshare");
+  });
+
+  it("marks argument-required commands", () => {
+    expect(lines.some((l) => l.includes("/resume …"))).toBe(true);
+    expect(lines.some((l) => l.includes("/task …"))).toBe(true);
+  });
+});
+
 describe("registry search / listing", () => {
   it("search matches on name, label, and alias", () => {
     expect(registry.search("trace").some(c => c.name === "trace")).toBe(true);

package/tests/loom.test.ts

@@ -321,6 +321,48 @@ describe("argument wizard (cascading ↑↓ selection)", () => {
   });
 });
 
+describe("approval modal (allow once / always / deny)", () => {
+  function key(ui: any, name: string, opts: Record<string, any> = {}) { ui.onKey(opts.str ?? "", { name, ...opts }); }
+
+  it("confirmApproval resolves 'once' / 'always' / 'deny' by key", async () => {
+    for (const [k, expected] of [["y", "once"], ["a", "always"], ["n", "deny"]] as const) {
+      const ui = makeUI() as any;
+      const p = ui.confirmApproval("run_bash (危险等级 3)");
+      ui.onKey(k, { name: k, str: k });
+      expect(await p).toBe(expected);
+    }
+  });
+
+  it("Enter takes the safe default (deny); Esc cancels (deny)", async () => {
+    const ui = makeUI() as any;
+    const p1 = ui.confirmApproval("x");
+    key(ui, "return");
+    expect(await p1).toBe("deny");
+
+    const p2 = ui.confirmApproval("x");
+    key(ui, "escape");
+    expect(await p2).toBe("deny");
+  });
+
+  it("confirm() stays a boolean y/N", async () => {
+    const uiY = makeUI() as any; const py = uiY.confirm("ok?"); uiY.onKey("y", { name: "y", str: "y" });
+    expect(await py).toBe(true);
+    const uiN = makeUI() as any; const pn = uiN.confirm("ok?"); key(uiN, "return"); // default n
+    expect(await pn).toBe(false);
+  });
+
+  it("renders the choice keys and keeps the frame full width", () => {
+    const ui = makeUI() as any;
+    ui.confirmApproval("delete_file (危险等级 4)");
+    const frame = ui.paint();
+    const text = frame.map((r: string) => r.replace(/\x1b\[[0-9;]*m/g, "")).join("\n");
+    expect(text).toContain("允许一次");
+    expect(text).toContain("本会话总是");
+    expect(text).toContain("拒绝");
+    for (const row of frame) expect(visualWidth(row)).toBe(80);
+  });
+});
+
 describe("mouse wheel scrolling", () => {
   // Replay an SGR mouse sequence the way Node's keypress parser fragments it:
   // ESC[< as one event, then every remaining char separately.

package/tests/tool.test.ts

@@ -12,6 +12,7 @@ function makeTool(overrides: Partial<ToolDefinition> & { name: string }): ToolDe
     handler: overrides.handler ?? vi.fn().mockResolvedValue('ok'),
     dangerous: overrides.dangerous,
     cacheable: overrides.cacheable,
+    idempotent: overrides.idempotent,
     maxRetries: overrides.maxRetries,
     retryDelay: overrides.retryDelay,
     timeout: overrides.timeout,
@@ -106,3 +107,42 @@ describe('ToolRegistry', () => {
     expect(handler).not.toHaveBeenCalled();
   });
 });
+
+describe('stableStringify', () => {
+  it('produces an order-independent key for objects', async () => {
+    const { stableStringify } = await import('../src/core/tool');
+    expect(stableStringify({ a: 1, b: 2 })).toBe(stableStringify({ b: 2, a: 1 }));
+    expect(stableStringify({ a: { y: 1, x: 2 } })).toBe(stableStringify({ a: { x: 2, y: 1 } }));
+    expect(stableStringify([3, 1, 2])).toBe('[3,1,2]'); // arrays keep order
+  });
+});
+
+describe('execute · timeout timer is always cleared (no leak)', () => {
+  it('clears the timeout timer when the handler resolves first', async () => {
+    vi.useFakeTimers();
+    try {
+      const registry = new ToolRegistry();
+      registry.register(makeTool({ name: 'fast', handler: async () => 'done' }));
+      const before = vi.getTimerCount();
+      const res = await registry.execute('fast', {});
+      expect(res.success).toBe(true);
+      // The only timer execute() arms is the timeout guard; it must be cleared.
+      expect(vi.getTimerCount()).toBe(before);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('still enforces the timeout when a handler hangs', async () => {
+    const registry = new ToolRegistry();
+    registry.register(makeTool({
+      name: 'slow',
+      timeout: 20,
+      maxRetries: 0,
+      handler: () => new Promise<string>(() => { /* never resolves */ }),
+    }));
+    const res = await registry.execute('slow', {});
+    expect(res.success).toBe(false);
+    expect(res.error).toContain('timeout');
+  });
+});