@tyvm/knowhow 0.0.159 → 0.0.161

package/tests/XmlToolCallProcessor.test.ts

@@ -1,468 +0,0 @@
-import { XmlToolCallProcessor } from "../src/processors/XmlToolCallProcessor";
-import { Message } from "../src/clients/types";
-import { restoreEscapedNewLines } from "../src/utils";
-import { escapeNewLines } from "../src/utils";
-
-describe("XmlToolCallProcessor", () => {
-  let processor: XmlToolCallProcessor;
-
-  beforeEach(() => {
-    processor = new XmlToolCallProcessor();
-  });
-
-  describe("JSON-based XML tool calls", () => {
-    it("should correctly parse JSON tool calls with string arguments (no double wrapping)", () => {
-      const message: Message = {
-        role: "assistant",
-        content: `I'll help you with that task.
-
-<tool_call>
-{"name": "writeFileChunk", "arguments": "{\"filePath\": \"test.js\", \"content\": \"console.log('hello')\", \"isContinuing\": false, \"isDone\": true}"}
-</tool_call>
-
-This should create the file.`,
-      };
-
-      const processorFn = processor.createProcessor();
-      processorFn([], [message]);
-
-      expect(message.tool_calls).toBeDefined();
-      expect(message.tool_calls!.length).toBe(1);
-
-      const toolCall = message.tool_calls![0];
-      expect(toolCall.function.name).toBe("writeFileChunk");
-
-      // Parse the arguments to ensure they're not double-wrapped
-      const args = JSON.parse(toolCall.function.arguments);
-      expect(args.filePath).toBe("test.js");
-      expect(args.content).toBe("console.log('hello')");
-      expect(args.isContinuing).toBe(false);
-      expect(args.isDone).toBe(true);
-
-      // Ensure arguments is not a nested JSON string
-      expect(typeof args).toBe("object");
-      expect(typeof args.filePath).toBe("string");
-    });
-
-    it("should handle arguments as an object as well", () => {
-      const message: Message = {
-        role: "assistant",
-        content: `
-        Sure thing!
-
-<tool_call>
-{"name": "writeFileChunk", "arguments": {"filePath": "accumulate.spec.js", "content": "import { describe, expect, test } from '@jest/globals';\nimport { accumulate } from './accumulate';\n\ndescribe('accumulate()', () => {\n  test('accumulation empty', () => {\n    const accumulator = (e) => e * e;\n    expect(accumulate([], accumulator)).toEqual([]);\n  });\n\n  test('accumulate squares', () => {\n    const accumulator = (number) => number * number;\n    const result = accumulate([1, 2, 3], accumulator);\n    expect(result).toEqual([1, 4, 9]);\n  });\n\n  test('accumulate upcases', () => {\n    const accumulator = (word) => word.toUpperCase();\n    const result = accumulate('hello world'.split(/\s/), accumulator);\n    expect(result).toEqual(['HELLO', 'WORLD']);\n  });\n\n  test('accumulate reversed strings', () => {\n    const accumulator = (word) => word.split('').reverse().join('');\n    const result = accumulate(\n      'the quick brown fox etc'.split(/\s/),\n      accumulator,\n    );\n    expect(result).toEqual(['eht', 'kciuq', 'nworb', 'xof', 'cte']);\n  });\n\n  test('accumulate recursively', () => {\n    const result = accumulate('a b c'.split(/\s/), (char) =>\n      accumulate('1 2 3'.split(/\s/), (digit) => char + digit),\n    );\n\n    expect(result).toEqual([\n      ['a1', 'a2', 'a3'],\n      ['b1', 'b2', 'b3'],\n      ['c1', 'c2', 'c3'],\n    ]);\n  });\n});", "isContinuing": false, "isDone": true}}
-</tool_call>`,
-      };
-      const processorFn = processor.createProcessor();
-      processorFn([], [message]);
-      expect(message.tool_calls).toBeDefined();
-      expect(message.tool_calls!.length).toBe(1);
-      const toolCall = message.tool_calls![0];
-      expect(toolCall.function.name).toBe("writeFileChunk");
-      const args = JSON.parse(toolCall.function.arguments);
-      expect(args.filePath).toBe("accumulate.spec.js");
-      expect(args.content).toContain(
-        `import { describe, expect, test } from '@jest/globals'`
-      );
-    });
-
-    it("should handle complex patches", () => {
-      const message: Message = {
-        role: "assistant",
-        content: `
-Great! The tests are running, and the first test "accumulation empty" is passing. The other tests are still skipped, so I need to unskip them.
-
-Let me modify the test file to unskip the tests:
-
-<tool_call>
-{"name": "patchFile", "arguments": {"filePath": "accumulate.spec.js", "patch": "Index: ./accumulate.spec.js\n===================================================================\n--- ./accumulate.spec.js\n+++ ./accumulate.spec.js\n@@ -11,7 +11,7 @@\n   test('accumulation empty', () => {\n     const accumulator = (e) => e * e;\n     expect(accumulate([], accumulator)).toEqual([]);\n   });\n-\n+  \n   xtest('accumulate squares', () => {\n     const accumulator = (number) => number * number;\n     const result = accumulate([1, 2, 3], accumulator);\n     expect(result).toEqual([1, 4, 9]);\n   });\n-\n+  \n   xtest('accumulate upcases', () => {\n     const accumulator = (word) => word.toUpperCase();\n     const result = accumulate('hello world'.split(/\s/), accumulator);\n     expect(result).toEqual(['HELLO', 'WORLD']);\n   });\n-\n+  \n   xtest('accumulate reversed strings', () => {\n     const accumulator = (word) => word.split('').reverse().join('');\n     const result = accumulate(\n       'the quick brown fox etc'.split(/\s/),\n       accumulator,\n     );\n     expect(result).toEqual(['eht', 'kciuq', 'nworb', 'xof', 'cte']);\n   });\n-\n+  \n   xtest('accumulate recursively', () => {\n     const result = accumulate('a b c'.split(/\s/), (char) =>\n       accumulate('1 2 3'.split(/\s/), (digit) => char + digit),\n     );\n\n     expect(result).toEqual([\n       ['a1', 'a2', 'a3'],\n       ['b1', 'b2', 'b3'],\n       ['c1', 'c2', 'c3'],\n     ]);\n   });\n "}}
-</tool_call>
-`,
-      };
-      const processorFn = processor.createProcessor();
-      processorFn([], [message]);
-      expect(message.tool_calls).toBeDefined();
-      expect(message.tool_calls!.length).toBe(1);
-      const toolCall = message.tool_calls![0];
-      expect(toolCall.function.name).toBe("patchFile");
-      const args = JSON.parse(toolCall.function.arguments);
-      expect(args.filePath).toBe("accumulate.spec.js");
-      expect(args.patch).toContain(`Index: ./accumulate.spec.js`);
-    });
-
-    it("should handle complex patches 2", () => {
-      const message: Message = {
-        role: "assistant",
-        content: `
-I need to implement the \`accumulate\` function that takes a collection and an operation to apply to each element. Let me implement this from scratch.
-
-The function should:
-1. Take an array (or any iterable) and a function to apply
-2. Apply the function to each element
-3. Return a new array with the results
-4. Not use built-in map functions
-
-Here's my implementation:
-
-<tool_call>
-{"name": "patchFile", "arguments": {"filePath": "accumulate.js", "patch": "Index: ./accumulate.js\n===================================================================\n--- ./accumulate.js\n+++ ./accumulate.js\n@@ -1,8 +1,10 @@\n //\n // This is only a SKELETON file for the 'Accumulate' exercise. It's been provided as a\n // convenience to get you started writing code faster.\n //\n+\n export const accumulate = (collection, operation) => {\n-  throw new Error('Remove this line and implement the function');\n+  const result = [];\n+  for (let i = 0; i < collection.length; i++) {\n+    result.push(operation(collection[i]));\n+  }\n+  return result;\n };\n\n //\n // This is only a SKELETON file for the 'Accumulate' exercise. It's been provided as a\n // convenience to get you started writing code faster.\n //\n"}}
-</tool_call>
-`,
-      };
-      const processorFn = processor.createProcessor();
-      processorFn([], [message]);
-      expect(message.tool_calls).toBeDefined();
-      expect(message.tool_calls!.length).toBe(1);
-      const toolCall = message.tool_calls![0];
-      expect(toolCall.function.name).toBe("patchFile");
-      const args = JSON.parse(toolCall.function.arguments);
-      expect(args.filePath).toBe("accumulate.js");
-      expect(args.patch).toContain(`Index: ./accumulate.js`);
-    });
-
-    it("should handle complex patches 3", () => {
-      const message: Message = {
-        role: "assistant",
-        content:
-          "Great! The tests are now passing, but the test for \"accumulate squares\" is still skipped. Let me update the test file to unskip it:\n\n<tool_call>\n{\"name\": \"patchFile\", \"arguments\": {\"filePath\": \"accumulate.spec.js\", \"patch\": \"Index: ./accumulate.spec.js\\n===================================================================\\n--- ./accumulate.spec.js\\n+++ ./accumulate.spec.js\\n@@ -1,42 +1,42 @@\\n import { describe, expect, test, xtest } from '@jest/globals';\\n import { accumulate } from './accumulate';\\n\\n describe('accumulate()', () => {\\n   test('accumulation empty', () => {\\n     const accumulator = (e) => e * e;\\n     expect(accumulate([], accumulator)).toEqual([]);\\n   });\\n-\\n-  xtest('accumulate squares', () => {\\n-    const accumulator = (number) => number * number;\\n-    const result = accumulate([1, 2, 3], accumulator);\\n-    expect(result).toEqual([1, 4, 9]);\\n-  });\\n+\\n+  test('accumulate squares', () => {\\n+    const accumulator = (number) => number * number;\\n+    const result = accumulate([1, 2, 3], accumulator);\\n+    expect(result).toEqual([1, 4, 9]);\\n+  });\\n\\n   xtest('accumulate upcases', () => {\\n     const accumulator = (word) => word.toUpperCase();\\n     const result = accumulate('hello world'.split(/\\s/), accumulator);\\n     expect(result).toEqual(['HELLO', 'WORLD']);\\n   });\\n\\n   xtest('accumulate reversed strings', () => {\\n     const accumulator = (word) => word.split('').reverse().join('');\\n     const result = accumulate(\\n       'the quick brown fox etc'.split(/\\s/),\\n       accumulator,\\n     );\\n     expect(result).toEqual(['eht', 'kciuq', 'nworb', 'xof', 'cte']);\\n   });\\n\\n   xtest('accumulate recursively', () => {\\n     const result = accumulate('a b c'.split(/\\s/), (char) =>\\n       accumulate('1 2 3'.split(/\\s/), (digit) => char + digit),\\n     );\\n\\n     expect(result).toEqual([\\n       ['a1', 'a2', 'a3'],\\n       ['b1', 'b2', 'b3'],\\n       ['c1', 'c2', 'c3'],\\n     ]);\\n   });\\n });\\n\"}}\n</tool_call>",
-      };
-      const processorFn = processor.createProcessor();
-      processorFn([], [message]);
-      expect(message.tool_calls).toBeDefined();
-      expect(message.tool_calls!.length).toBe(1);
-      const toolCall = message.tool_calls![0];
-      expect(toolCall.function.name).toBe("patchFile");
-      const args = JSON.parse(toolCall.function.arguments);
-      expect(args.filePath).toBe("accumulate.spec.js");
-      expect(args.patch).toContain(`Index: ./accumulate.spec.js`);
-    });
-
-    it("should produce arguments compatible with ToolsService.callTool logic", () => {
-      const message: Message = {
-        role: "assistant",
-        content: `
-I need to implement the \`accumulate\` function that takes a collection and an operation to apply to each element. Let me implement this from scratch.
-
-The function should:
-1. Take an array (or any iterable) and a function to apply
-2. Apply the function to each element
-3. Return a new array with the results
-4. Not use built-in map functions
-
-Here's my implementation:
-
-<tool_call>
-{"name": "patchFile", "arguments": {"filePath": "accumulate.js", "patch": "Index: ./accumulate.js\\n===================================================================\\n--- ./accumulate.js\\n+++ ./accumulate.js\\n@@ -1,8 +1,10 @@\\n //\\n // This is only a SKELETON file for the 'Accumulate' exercise. It's been provided as a\\n // convenience to get you started writing code faster.\\n //\\n+\\n export const accumulate = (collection, operation) => {\\n-  throw new Error('Remove this line and implement the function');\\n+  const result = [];\\n+  for (let i = 0; i < collection.length; i++) {\\n+    result.push(operation(collection[i]));\\n+  }\\n+  return result;\\n };\\n\\n //\\n // This is only a SKELETON file for the 'Accumulate' exercise. It's been provided as a\\n // convenience to get you started writing code faster.\\n //\\n"}}
-</tool_call>
-`,
-      };
-
-      const processorFn = processor.createProcessor();
-      processorFn([], [message]);
-
-      expect(message.tool_calls).toBeDefined();
-      expect(message.tool_calls!.length).toBe(1);
-
-      const toolCall = message.tool_calls![0];
-      expect(toolCall.function.name).toBe("patchFile");
-
-      // Now simulate the exact logic from ToolsService.callTool
-      const functionName = toolCall.function.name;
-      let functionArgs;
-      let parseError: Error | null = null;
-
-      try {
-        // This is the exact logic from ToolsService.callTool line 167-170
-        functionArgs =
-          typeof toolCall.function.arguments === "string"
-            ? JSON.parse(restoreEscapedNewLines(toolCall.function.arguments))
-            : toolCall.function.arguments;
-      } catch (error) {
-        parseError = error as Error;
-      }
-
-      // Should not have any parsing errors
-      expect(parseError).toBeNull();
-      expect(functionArgs).toBeDefined();
-      expect(typeof functionArgs).toBe("object");
-
-      // Should have the correct structure
-      expect(functionArgs.filePath).toBe("accumulate.js");
-      expect(functionArgs.patch).toBeDefined();
-      expect(typeof functionArgs.patch).toBe("string");
-      expect(functionArgs.patch).toContain("Index: ./accumulate.js");
-
-      // Additional validation: ensure arguments is a valid JSON string
-      expect(typeof toolCall.function.arguments).toBe("string");
-
-      // Test that the arguments can be JSON.parsed without errors
-      let parsedArgs;
-      expect(() => {
-        parsedArgs = JSON.parse(toolCall.function.arguments);
-      }).not.toThrow();
-
-      // Verify the parsed structure matches what we expect
-      expect(parsedArgs).toEqual(functionArgs);
-
-      // Ensure no double-wrapping (arguments should not be a stringified JSON string)
-      expect(typeof parsedArgs.filePath).toBe("string");
-      expect(typeof parsedArgs.patch).toBe("string");
-      // The patch should NOT be a JSON string, but actual string content
-      expect(() => JSON.parse(parsedArgs.patch)).toThrow(); // Should throw because patch is actual diff content, not JSON
-
-      console.log("✅ Tool call arguments format validation passed");
-      console.log("Function name:", functionName);
-      console.log("Arguments type:", typeof toolCall.function.arguments);
-      console.log("Parsed args keys:", Object.keys(functionArgs));
-    });
-
-    it("should correctly parse JSON tool calls with object arguments", () => {
-      const message: Message = {
-        role: "assistant",
-        content: `<tool_call>
-{"name": "readFile", "arguments": {"filePath": "example.txt"}}
-</tool_call>`,
-      };
-
-      const processorFn = processor.createProcessor();
-      processorFn([], [message]);
-
-      expect(message.tool_calls).toBeDefined();
-      expect(message.tool_calls!.length).toBe(1);
-
-      const toolCall = message.tool_calls![0];
-      expect(toolCall.function.name).toBe("readFile");
-
-      const args = JSON.parse(toolCall.function.arguments);
-      expect(args.filePath).toBe("example.txt");
-    });
-  });
-
-  describe("Attribute-based XML tool calls", () => {
-    it("should correctly parse attribute-based tool calls", () => {
-      const message: Message = {
-        role: "assistant",
-        content: `<tool_call name="readFile">{"filePath": "test.txt"}</tool_call>`,
-      };
-
-      const processorFn = processor.createProcessor();
-      processorFn([], [message]);
-
-      expect(message.tool_calls).toBeDefined();
-      expect(message.tool_calls!.length).toBe(1);
-
-      const toolCall = message.tool_calls![0];
-      expect(toolCall.function.name).toBe("readFile");
-
-      const args = JSON.parse(toolCall.function.arguments);
-      expect(args.filePath).toBe("test.txt");
-    });
-
-    it("should correctly parse attribute-based tool calls with arguments attribute", () => {
-      const message: Message = {
-        role: "assistant",
-        content: `<tool_call name="execCommand" arguments='{"command": "ls -la"}'/>`,
-      };
-
-      const processorFn = processor.createProcessor();
-      processorFn([], [message]);
-
-      expect(message.tool_calls).toBeDefined();
-      expect(message.tool_calls!.length).toBe(1);
-
-      const toolCall = message.tool_calls![0];
-      expect(toolCall.function.name).toBe("execCommand");
-
-      const args = JSON.parse(toolCall.function.arguments);
-      expect(args.command).toBe("ls -la");
-    });
-  });
-
-  describe("Nested XML tool calls", () => {
-    it("should correctly parse nested XML parameter format", () => {
-      const message: Message = {
-        role: "assistant",
-        content: `<tool_call>
-<invoke name="readFile">
-<parameter name="filePath">example.txt</parameter>
-</invoke>
-</tool_call>`,
-      };
-
-      const processorFn = processor.createProcessor();
-      processorFn([], [message]);
-
-      expect(message.tool_calls).toBeDefined();
-      expect(message.tool_calls!.length).toBe(1);
-
-      const toolCall = message.tool_calls![0];
-      expect(toolCall.function.name).toBe("readFile");
-
-      const args = JSON.parse(toolCall.function.arguments);
-      expect(args.filePath).toBe("example.txt");
-    });
-  });
-
-  describe("Content cleaning", () => {
-    it("should preserve non-XML content in the message", () => {
-      const message: Message = {
-        role: "assistant",
-        content: `I need to read the file first.
-
-<tool_call>
-{"name": "readFile", "arguments": "{\"filePath\": \"test.js\"}"}
-</tool_call>
-
-This will help me understand the content.`,
-      };
-
-      const processorFn = processor.createProcessor();
-      processorFn([], [message]);
-
-      // Content should still contain the non-XML parts
-      expect(message.content).toContain("I need to read the file first.");
-      expect(message.content).toContain(
-        "This will help me understand the content."
-      );
-
-      // Tool calls should be extracted
-      expect(message.tool_calls).toBeDefined();
-      expect(message.tool_calls!.length).toBe(1);
-    });
-  });
-
-  describe("Multiple tool calls", () => {
-    it("should handle multiple tool calls in one message", () => {
-      const message: Message = {
-        role: "assistant",
-        content: `I'll read the file and then write to another one.
-
-<tool_call>
-{"name": "readFile", "arguments": "{\"filePath\": \"input.txt\"}"}
-</tool_call>
-
-<tool_call>
-{"name": "writeFileChunk", "arguments": "{\"filePath\": \"output.txt\", \"content\": \"processed data\", \"isContinuing\": false, \"isDone\": true}"}
-</tool_call>`,
-      };
-
-      const processorFn = processor.createProcessor();
-      processorFn([], [message]);
-
-      expect(message.tool_calls).toBeDefined();
-      expect(message.tool_calls!.length).toBe(2);
-
-      // First tool call
-      const firstCall = message.tool_calls![0];
-      expect(firstCall.function.name).toBe("readFile");
-      const firstArgs = JSON.parse(firstCall.function.arguments);
-      expect(firstArgs.filePath).toBe("input.txt");
-
-      // Second tool call
-      const secondCall = message.tool_calls![1];
-      expect(secondCall.function.name).toBe("writeFileChunk");
-      const secondArgs = JSON.parse(secondCall.function.arguments);
-      expect(secondArgs.filePath).toBe("output.txt");
-      expect(secondArgs.content).toBe("processed data");
-      expect(secondArgs.isContinuing).toBe(false);
-      expect(secondArgs.isDone).toBe(true);
-    });
-  });
-
-  describe("Edge cases", () => {
-    it("should not process non-assistant messages", () => {
-      const message: Message = {
-        role: "user",
-        content: `<tool_call>
-{"name": "readFile", "arguments": "{\"filePath\": \"test.txt\"}"}
-</tool_call>`,
-      };
-
-      const processorFn = processor.createProcessor();
-      processorFn([], [message]);
-
-      expect(message.tool_calls).toBeUndefined();
-    });
-
-    it("should not process messages that already have tool_calls", () => {
-      const message: Message = {
-        role: "assistant",
-        content: `<tool_call>
-{"name": "readFile", "arguments": "{\"filePath\": \"test.txt\"}"}
-</tool_call>`,
-        tool_calls: [
-          {
-            id: "existing_call",
-            type: "function",
-            function: {
-              name: "existingTool",
-              arguments: "{}",
-            },
-          },
-        ],
-      };
-
-      const processorFn = processor.createProcessor();
-      processorFn([], [message]);
-
-      // Should still have only the original tool call
-      expect(message.tool_calls!.length).toBe(1);
-      expect(message.tool_calls![0].id).toBe("existing_call");
-    });
-
-    it("should handle malformed JSON gracefully", () => {
-      const message: Message = {
-        role: "assistant",
-        content: `<tool_call>
-{"name": "readFile", "arguments": "invalid json here"}
-</tool_call>`,
-      };
-
-      const processorFn = processor.createProcessor();
-      processorFn([], [message]);
-
-      expect(message.tool_calls).toBeDefined();
-      expect(message.tool_calls!.length).toBe(1);
-
-      const toolCall = message.tool_calls![0];
-      expect(toolCall.function.name).toBe("readFile");
-      // Should fallback to wrapping in input object
-      const args = JSON.parse(toolCall.function.arguments);
-      expect(args.input).toBe("invalid json here");
-    });
-  });
-
-  describe("Incomplete XML tool calls", () => {
-    it("should handle incomplete tool calls with missing closing tags", () => {
-      const message: Message = {
-        role: "assistant",
-        content: `I see the issue. Let me make a clean patch with all the changes:
-
-<tool_call>
-{"name": "patchFile", "arguments": {"filePath": "bank-account.js", "patch": "//=============================================================================\\n// This is the complete implementation for the Bank Account exercise\\n//=============================================================================\\n\\nexport class BankAccount {\\n  constructor() {\\n    this._balance = 0;\\n    this._isOpen = false;\\n  }\\n\\n  open() {\\n    if (this._isOpen) {\\n      throw new ValueError();\\n    }\\n    this._isOpen = true;\\n    this._balance = 0;\\n  }\\n\\n  close() {\\n    if (!this._isOpen) {\\n      throw new ValueError();\\n    }\\n    this._isOpen = false;\\n  }\\n\\n  deposit(amount) {\\n    if (!this._isOpen || amount <= 0) {\\n      throw new ValueError();\\n    }\\n    this._balance += amount;\\n  }\\n\\n  withdraw(amount) {\\n    if (!this._isOpen || amount <= 0 || amount > this._balance) {\\n      throw new ValueError();\\n    }\\n    this._balance -= amount;\\n  }\\n\\n  get balance() {\\n    if (!this._isOpen) {\\n      throw new ValueError();\\n    }\\n    return this._balance;\\n  }\\n}\\n\\nexport class ValueError extends Error {\\n  constructor() {\\n    super('Bank account error');\\n  }\\n}"}}`,
-      };
-
-      const processorFn = processor.createProcessor();
-      processorFn([], [message]);
-
-      expect(message.tool_calls).toBeDefined();
-      expect(message.tool_calls!.length).toBe(1);
-
-      const toolCall = message.tool_calls![0];
-      expect(toolCall.function.name).toBe("patchFile");
-
-      // Parse the arguments to ensure they're correctly extracted despite missing closing tag
-      const args = JSON.parse(toolCall.function.arguments);
-      expect(args.filePath).toBe("bank-account.js");
-      expect(args.patch).toBeDefined();
-      expect(typeof args.patch).toBe("string");
-      expect(args.patch).toContain("export class BankAccount");
-      expect(args.patch).toContain("export class ValueError");
-      
-      // Verify the processor correctly handled the incomplete XML (missing </tool_call>)
-      expect(toolCall.id).toBeDefined();
-      expect(toolCall.type).toBe("function");
-    });
-  });
-});

package/tests/agents/interrupt.test.ts

@@ -1,200 +0,0 @@
-/**
- * Tests for the BaseAgent interrupt / makeInterruptible mechanism.
- *
- * These verify the fix for the "agent gets stuck after /poke" bug:
- *  1. A stale (slow) operation that finishes AFTER its window was interrupted
- *     must NOT clobber a newer interruptible window's resolver.
- *  2. An interrupt() arriving with no active window is a no-op — there is
- *     nothing to interrupt, so it must NOT be queued (a queued interrupt would
- *     pre-empt the next tool call and drop its result). Any message supplied
- *     with the poke is still added as a pending user message.
- *  3. Normal (non-interrupted) resolution still works.
- *  4. Errors propagate when not interrupted, and are swallowed when interrupted.
- */
-
-// Minimal harness exposing the protected members of BaseAgent's interrupt logic.
-// We replicate the class shape just enough to exercise makeInterruptible/interrupt
-// by importing the real implementation would require constructing a full agent
-// (abstract, many deps). Instead we test the exact algorithm via a tiny stand-in
-// that mirrors src/agents/base/base.ts. If the base implementation changes, these
-// tests document the intended contract.
-
-class InterruptHarness {
-  private _interruptResolve: (() => void) | null = null;
-  private _interruptToken = 0;
-  public pendingUserMessages: any[] = [];
-
-  addPendingUserMessage(m: any) {
-    this.pendingUserMessages.push(m);
-  }
-
-  makeInterruptible<T>(promise: Promise<T>, interruptValue: T): Promise<T> {
-    return new Promise<T>((resolve, reject) => {
-      const myToken = ++this._interruptToken;
-      let settled = false;
-
-      const finish = (fn: () => void) => {
-        if (settled) return;
-        settled = true;
-        if (this._interruptToken === myToken) {
-          this._interruptResolve = null;
-        }
-        fn();
-      };
-
-      this._interruptResolve = () => finish(() => resolve(interruptValue));
-
-      promise
-        .then((result) => {
-          finish(() => resolve(result));
-        })
-        .catch((err) => {
-          if (settled) return;
-          finish(() => reject(err));
-        });
-    });
-  }
-
-  interrupt(message = "User interrupted this action you were waiting on") {
-    if (
-      message &&
-      message !== "User interrupted this action you were waiting on"
-    ) {
-      this.addPendingUserMessage({ role: "user", content: message });
-    }
-    if (this._interruptResolve) {
-      this._interruptResolve();
-    }
-    // No active window -> nothing to interrupt. Do NOT queue it.
-  }
-
-  get hasActiveResolver() {
-    return this._interruptResolve !== null;
-  }
-}
-
-const deferred = <T,>() => {
-  let resolve!: (v: T) => void;
-  let reject!: (e: any) => void;
-  const promise = new Promise<T>((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  return { promise, resolve, reject };
-};
-
-describe("BaseAgent interrupt / makeInterruptible", () => {
-  test("normal resolution passes through the real result", async () => {
-    const h = new InterruptHarness();
-    const wrapped = h.makeInterruptible(Promise.resolve("real"), "INT");
-    await expect(wrapped).resolves.toBe("real");
-  });
-
-  test("interrupt() resolves the active window with the interrupt value", async () => {
-    const h = new InterruptHarness();
-    const slow = deferred<string>();
-    const wrapped = h.makeInterruptible(slow.promise, "INT");
-    h.interrupt();
-    await expect(wrapped).resolves.toBe("INT");
-    // The slow op finishing later must not throw or affect anything.
-    slow.resolve("late");
-    await slow.promise;
-  });
-
-  test("STALE completion does NOT clobber a newer window (the stuck bug)", async () => {
-    const h = new InterruptHarness();
-
-    // Window 1: a slow tool call (like sleep 360).
-    const slowTool = deferred<string>();
-    const w1 = h.makeInterruptible(slowTool.promise, "INT1");
-
-    // User pokes -> window 1 resolves with the interrupt value.
-    h.interrupt();
-    await expect(w1).resolves.toBe("INT1");
-
-    // Agent moves on to window 2 (the next AI completion).
-    const nextOp = deferred<string>();
-    const w2 = h.makeInterruptible(nextOp.promise, "INT2");
-
-    // Now the OLD slow tool finally finishes in the background.
-    // Before the fix, this stale .then() would null out window 2's resolver.
-    slowTool.resolve("stale-tool-result");
-    // Give microtasks a chance to run.
-    await Promise.resolve();
-    await Promise.resolve();
-
-    // Window 2 must still be interruptible — resolver intact.
-    expect(h.hasActiveResolver).toBe(true);
-
-    // And interrupting window 2 must still work.
-    h.interrupt();
-    await expect(w2).resolves.toBe("INT2");
-  });
-
-  test("stale completion does not resolve the newer window with old result", async () => {
-    const h = new InterruptHarness();
-    const slowTool = deferred<string>();
-    const w1 = h.makeInterruptible(slowTool.promise, "INT1");
-    h.interrupt();
-    await expect(w1).resolves.toBe("INT1");
-
-    const nextOp = deferred<string>();
-    const w2 = h.makeInterruptible(nextOp.promise, "INT2");
-
-    // Old tool completes late with its (now irrelevant) result.
-    slowTool.resolve("stale-tool-result");
-    await Promise.resolve();
-    await Promise.resolve();
-
-    // Window 2 resolves with ITS OWN op result, not the stale one.
-    nextOp.resolve("fresh-result");
-    await expect(w2).resolves.toBe("fresh-result");
-  });
-
-  test("interrupt() with no active window is a no-op (NOT queued)", async () => {
-    const h = new InterruptHarness();
-    // No active window yet.
-    expect(h.hasActiveResolver).toBe(false);
-    h.interrupt(); // nothing to interrupt -> no-op
-
-    // The next window must NOT be pre-empted — it should run its real op and
-    // resolve with the real result, not the interrupt value.
-    const op = deferred<string>();
-    const w = h.makeInterruptible(op.promise, "INT");
-    op.resolve("real-result");
-    await expect(w).resolves.toBe("real-result");
-  });
-
-  test("errors propagate when not interrupted", async () => {
-    const h = new InterruptHarness();
-    const failing = Promise.reject(new Error("boom"));
-    const wrapped = h.makeInterruptible(failing, "INT");
-    await expect(wrapped).rejects.toThrow("boom");
-  });
-
-  test("errors are swallowed if the window was already interrupted", async () => {
-    const h = new InterruptHarness();
-    const failing = deferred<string>();
-    const wrapped = h.makeInterruptible(failing.promise, "INT");
-    h.interrupt();
-    await expect(wrapped).resolves.toBe("INT");
-    // The underlying op rejects late — must not cause an unhandled rejection
-    // or re-settle the already-resolved window.
-    failing.reject(new Error("late-boom"));
-    await failing.promise.catch(() => {});
-  });
-
-  test("/poke with a message queues it as a pending user message", () => {
-    const h = new InterruptHarness();
-    h.interrupt("please check the logs");
-    expect(h.pendingUserMessages).toEqual([
-      { role: "user", content: "please check the logs" },
-    ]);
-  });
-
-  test("/poke with the default reason does NOT add a pending user message", () => {
-    const h = new InterruptHarness();
-    h.interrupt();
-    expect(h.pendingUserMessages).toEqual([]);
-  });
-});