@tyvm/knowhow 0.0.48 → 0.0.50

package/tests/processors/ToolResponseCache.test.ts

@@ -1,135 +1,148 @@
 import { Message } from "../../src/clients/types";
-import { ToolResponseCache, jqToolResponseDefinition } from "../../src/processors/ToolResponseCache";
+import {
+  ToolResponseCache,
+  jqToolResponseDefinition,
+} from "../../src/processors/ToolResponseCache";
 import { ToolsService } from "../../src/services";
 
 // Mock node-jq
 jest.mock("node-jq", () => ({
-  run: jest.fn().mockImplementation(async (query: string, data: any, options: any) => {
-    // Simulate common JQ queries based on the test data
-    
-    // Handle .test query on {"test": "value"}
-    if (query === ".test") {
-      if (data && data.test !== undefined) {
-        return JSON.stringify(data.test);
+  run: jest
+    .fn()
+    .mockImplementation(async (query: string, data: any, options: any) => {
+      // Simulate common JQ queries based on the test data
+
+      // Handle .test query on {"test": "value"}
+      if (query === ".test") {
+        if (data && data.test !== undefined) {
+          return JSON.stringify(data.test);
+        }
+      }
+
+      // Handle .id query for extracting id values
+      if (query === ".id") {
+        return data && data.id !== undefined ? data.id.toString() : "null";
+      }
+
+      // Handle .data | length query for counting array elements
+      if (query === ".data | length") {
+        if (data && Array.isArray(data.data)) {
+          return data.data.length.toString();
+        }
+      }
+
+      // Handle .data | add query for summing array elements
+      if (query === ".data | add") {
+        if (data && Array.isArray(data.data)) {
+          const sum = data.data.reduce((a, b) => a + b, 0);
+          return sum.toString();
+        }
+      }
+
+      // Handle .unicode query for special characters test
+      if (query === ".unicode") {
+        if (data && data.unicode !== undefined) {
+          return JSON.stringify(data.unicode);
+        }
+      }
+
+      // Handle .empty query for empty string test
+      if (query === ".empty") {
+        if (data && data.empty !== undefined) {
+          return JSON.stringify(data.empty);
+        }
       }
-    }
-    
-    // Handle .id query for extracting id values
-    if (query === ".id") {
-      return data && data.id !== undefined ? data.id.toString() : "null";
-    }
-    
-    // Handle .data | length query for counting array elements
-    if (query === ".data | length") {
-      if (data && Array.isArray(data.data)) {
-        return data.data.length.toString();
+
+      // Handle .nullValue query for null value test
+      if (query === ".nullValue") {
+        if (data && data.nullValue !== undefined) {
+          return JSON.stringify(data.nullValue);
+        }
       }
-    }
-    
-    // Handle .data | add query for summing array elements
-    if (query === ".data | add") {
-      if (data && Array.isArray(data.data)) {
-        const sum = data.data.reduce((a, b) => a + b, 0);
-        return sum.toString();
+
+      // Handle .name query on {name: "test", data: [1, 2, 3]}
+      if (query === ".name") {
+        if (data && data.name) {
+          return JSON.stringify(data.name);
+        }
       }
-    }
-    
-    // Handle .unicode query for special characters test
-    if (query === ".unicode") {
-      if (data && data.unicode !== undefined) {
-        return JSON.stringify(data.unicode);
+
+      // Handle .data[] query on {name: "test", data: [1, 2, 3]}
+      if (query === ".data[]") {
+        if (data && Array.isArray(data.data)) {
+          return data.data.join("\n");
+        }
       }
-    }
-    
-    // Handle .empty query for empty string test
-    if (query === ".empty") {
-      if (data && data.empty !== undefined) {
-        return JSON.stringify(data.empty);
+
+      // Handle map(.value) on [{id: 1, value: "a"}, {id: 2, value: "b"}]
+      if (query === "map(.value)") {
+        if (Array.isArray(data)) {
+          const values = data.map((item) => item.value);
+          return JSON.stringify(values);
+        }
       }
-    }
-    
-    // Handle .nullValue query for null value test
-    if (query === ".nullValue") {
-      if (data && data.nullValue !== undefined) {
-        return JSON.stringify(data.nullValue);
+
+      // Handle map({identifier: .id, content: .value}) transformation
+      if (query === "map({identifier: .id, content: .value})") {
+        if (Array.isArray(data)) {
+          const transformed = data.map((item) => ({
+            identifier: item.id,
+            content: item.value,
+          }));
+          return JSON.stringify(transformed);
+        }
       }
-    }
-    
-    // Handle .name query on {name: "test", data: [1, 2, 3]}
-    if (query === ".name") {
-      if (data && data.name) {
-        return JSON.stringify(data.name);
+
+      // Handle "." query (return entire object, formatted)
+      if (query === ".") {
+        return JSON.stringify(data, null, 2);
       }
-    }
-    
-    // Handle .data[] query on {name: "test", data: [1, 2, 3]}
-    if (query === ".data[]") {
-      if (data && Array.isArray(data.data)) {
-        return data.data.join("\n");
+
+      // Handle .nested.inner query for nested JSON
+      if (query === ".nested.inner") {
+        if (data && data.nested && data.nested.inner) {
+          return JSON.stringify(data.nested.inner);
+        }
+      }
+
+      // Handle map(select(.id > 10)) - empty result
+      if (query === "map(select(.id > 10))") {
+        return JSON.stringify([]);
       }
-    }
-    
-    // Handle map(.value) on [{id: 1, value: "a"}, {id: 2, value: "b"}]
-    if (query === "map(.value)") {
-      if (Array.isArray(data)) {
-        const values = data.map(item => item.value);
-        return JSON.stringify(values);
+
+      // Handle invalid queries - throw error
+      if (query === ".invalid[") {
+        throw new Error("Invalid JQ query syntax");
       }
-    }
-    
-    // Handle map({identifier: .id, content: .value}) transformation
-    if (query === "map({identifier: .id, content: .value})") {
-      if (Array.isArray(data)) {
-        const transformed = data.map(item => ({
-          identifier: item.id,
-          content: item.value
-        }));
-        return JSON.stringify(transformed);
+
+      // Handle deep nested queries
+      if (query === ".level1.level2.level3.level4.level5.deepValue") {
+        if (
+          data &&
+          data.level1 &&
+          data.level1.level2 &&
+          data.level1.level2.level3 &&
+          data.level1.level2.level3.level4 &&
+          data.level1.level2.level3.level4.level5
+        ) {
+          return JSON.stringify(
+            data.level1.level2.level3.level4.level5.deepValue
+          );
+        }
       }
-    }
-    
-    // Handle "." query (return entire object, formatted)
-    if (query === ".") {
-      return JSON.stringify(data, null, 2);
-    }
-    
-    // Handle .nested.inner query for nested JSON
-    if (query === ".nested.inner") {
-      if (data && data.nested && data.nested.inner) {
-        return JSON.stringify(data.nested.inner);
+
+      // Handle queries on invalid JSON data
+      if (typeof data === "string" && data === "invalid json string") {
+        throw new Error("Invalid JSON input");
       }
-    }
-    
-    // Handle map(select(.id > 10)) - empty result
-    if (query === "map(select(.id > 10))") {
-      return JSON.stringify([]);
-    }
-    
-    // Handle invalid queries - throw error
-    if (query === ".invalid[") {
-      throw new Error("Invalid JQ query syntax");
-    }
-    
-    // Handle deep nested queries
-    if (query === ".level1.level2.level3.level4.level5.deepValue") {
-      if (data && data.level1 && data.level1.level2 && data.level1.level2.level3 && 
-          data.level1.level2.level3.level4 && data.level1.level2.level3.level4.level5) {
-        return JSON.stringify(data.level1.level2.level3.level4.level5.deepValue);
+
+      // Default fallback - return stringified data
+      try {
+        return JSON.stringify(data);
+      } catch (error) {
+        throw new Error(`JQ query failed: ${error}`);
       }
-    }
-    
-    // Handle queries on invalid JSON data
-    if (typeof data === "string" && data === "invalid json string") {
-      throw new Error("Invalid JSON input");
-    }
-    
-    // Default fallback - return stringified data
-    try {
-      return JSON.stringify(data);
-    } catch (error) {
-      throw new Error(`JQ query failed: ${error}`);
-    }
-  })
+    }),
 }));
 
 const mockJq = require("node-jq");
@@ -140,9 +153,9 @@ describe("ToolResponseCache", () => {
 
   beforeEach(() => {
     jest.clearAllMocks();
-    
+
     mockToolsService = {
-      addTool: jest.fn(),
+      addTools: jest.fn(),
       addFunctions: jest.fn(),
       getTool: jest.fn().mockReturnValue(undefined),
       callTool: jest.fn(),
@@ -155,18 +168,20 @@ describe("ToolResponseCache", () => {
     it("should create an instance and register tool with ToolsService", () => {
       expect(cache).toBeDefined();
       expect(cache).toBeInstanceOf(ToolResponseCache);
-      expect(mockToolsService.addTool).toHaveBeenCalledWith(jqToolResponseDefinition);
+      expect(mockToolsService.addTools).toHaveBeenCalledWith([
+        jqToolResponseDefinition,
+      ]);
       expect(mockToolsService.addFunctions).toHaveBeenCalledWith({
         jqToolResponse: expect.any(Function),
       });
     });
 
-    it("should not register tool if it already exists", () => {
+    it("should overwrite tool if it already exists", () => {
       mockToolsService.getTool.mockReturnValue(jqToolResponseDefinition);
       const newCache = new ToolResponseCache(mockToolsService);
-      
-      // Should only be called once from the first instance
-      expect(mockToolsService.addTool).toHaveBeenCalledTimes(1);
+
+      // Should be called each time
+      expect(mockToolsService.addTools).toHaveBeenCalledTimes(2);
     });
   });
 
@@ -178,100 +193,102 @@ describe("ToolResponseCache", () => {
 
     it("should process tool response messages", async () => {
       const processor = cache.createProcessor();
-      
+
       const messages: Message[] = [
         {
           role: "tool",
           tool_call_id: "call_123",
-          content: '{"data": [{"name": "test", "value": 42}]}'
-        }
+          content: '{"data": [{"name": "test", "value": 42}]}',
+        },
       ];
 
       await processor(messages, messages);
-      
+
       // Verify message was stored
       expect(cache.getStorageKeys()).toContain("call_123");
-      expect(cache.retrieveRawResponse("call_123")).toBe('{"data": [{"name": "test", "value": 42}]}');
+      expect(cache.retrieveRawResponse("call_123")).toBe(
+        '{"data": [{"name": "test", "value": 42}]}'
+      );
     });
 
     it("should ignore non-tool messages", async () => {
       const processor = cache.createProcessor();
-      
+
       const messages: Message[] = [
         {
           role: "user",
-          content: "This is a user message"
+          content: "This is a user message",
         },
         {
-          role: "assistant", 
-          content: "This is an assistant message"
-        }
+          role: "assistant",
+          content: "This is an assistant message",
+        },
       ];
 
       await processor(messages, messages);
-      
+
       expect(cache.getStorageSize()).toBe(0);
     });
     it("should ignore tool messages without tool_call_id", async () => {
       const processor = cache.createProcessor();
-      
+
       const messages: Message[] = [
         {
           role: "tool",
-          content: "Tool response without call ID"
-        } as Message
+          content: "Tool response without call ID",
+        } as Message,
       ];
 
       await processor(messages, messages);
-      
+
       expect(cache.getStorageSize()).toBe(0);
     });
 
     it("should ignore tool messages with non-string content", async () => {
       const processor = cache.createProcessor();
-      
+
       const messages: Message[] = [
         {
           role: "tool",
           tool_call_id: "call_123",
-          content: null
+          content: null,
         } as Message,
         {
-          role: "tool", 
+          role: "tool",
           tool_call_id: "call_456",
-          content: undefined
+          content: undefined,
         } as Message,
         {
           role: "tool",
-          tool_call_id: "call_789", 
-          content: 42 as any
-        } as Message
+          tool_call_id: "call_789",
+          content: 42 as any,
+        } as Message,
       ];
 
       await processor(messages, messages);
-      
+
       expect(cache.getStorageSize()).toBe(0);
     });
 
     it("should apply filter function when provided", async () => {
       const filterFn = (msg: Message) => msg.tool_call_id === "call_allowed";
       const processor = cache.createProcessor(filterFn);
-      
+
       const messages: Message[] = [
         {
           role: "tool",
           tool_call_id: "call_allowed",
-          content: "Allowed content"
+          content: "Allowed content",
         },
         {
           role: "tool",
           tool_call_id: "call_blocked",
-          content: "Blocked content"
-        }
+          content: "Blocked content",
+        },
       ];
 
       await processor(messages, messages);
-      
+
       expect(cache.getStorageKeys()).toContain("call_allowed");
       expect(cache.getStorageKeys()).not.toContain("call_blocked");
       expect(cache.getStorageSize()).toBe(1);
@@ -282,13 +299,13 @@ describe("ToolResponseCache", () => {
     it("should store tool response content with metadata", () => {
       const content = '{"test": "data"}';
       const toolCallId = "call_123";
-      
+
       // Access private method for testing
       (cache as any).storeToolResponse(content, toolCallId);
-      
+
       expect(cache.retrieveRawResponse(toolCallId)).toBe(content);
       expect(cache.getStorageKeys()).toContain(toolCallId);
-      
+
       // Check metadata
       const metadata = (cache as any).metadataStorage[toolCallId];
       expect(metadata.toolCallId).toBe(toolCallId);
@@ -299,10 +316,19 @@ describe("ToolResponseCache", () => {
   describe("queryToolResponse", () => {
     beforeEach(() => {
       // Store some test data
-      cache.storeToolResponse('{"name": "test", "data": [1, 2, 3]}', "call_123");
-      cache.storeToolResponse('[{"id": 1, "value": "a"}, {"id": 2, "value": "b"}]', "call_456");
-      cache.storeToolResponse('{"nested": "{\\"inner\\": \\"value\\"}"}', "call_789");
-      cache.storeToolResponse('invalid json string', "call_invalid");
+      cache.storeToolResponse(
+        '{"name": "test", "data": [1, 2, 3]}',
+        "call_123"
+      );
+      cache.storeToolResponse(
+        '[{"id": 1, "value": "a"}, {"id": 2, "value": "b"}]',
+        "call_456"
+      );
+      cache.storeToolResponse(
+        '{"nested": "{\\"inner\\": \\"value\\"}"}',
+        "call_789"
+      );
+      cache.storeToolResponse("invalid json string", "call_invalid");
     });
 
     it("should execute simple JQ queries successfully", async () => {
@@ -316,16 +342,19 @@ describe("ToolResponseCache", () => {
     });
 
     it("should execute complex JQ queries", async () => {
-      const result = await cache.queryToolResponse("call_456", 'map(.value)');
+      const result = await cache.queryToolResponse("call_456", "map(.value)");
       expect(result).toBe('["a","b"]');
     });
 
     it("should handle object transformation queries", async () => {
-      const result = await cache.queryToolResponse("call_456", 'map({identifier: .id, content: .value})');
+      const result = await cache.queryToolResponse(
+        "call_456",
+        "map({identifier: .id, content: .value})"
+      );
       const parsed = JSON.parse(result);
       expect(parsed).toEqual([
-        {identifier: 1, content: "a"},
-        {identifier: 2, content: "b"}
+        { identifier: 1, content: "a" },
+        { identifier: 2, content: "b" },
       ]);
     });
 
@@ -344,14 +373,14 @@ describe("ToolResponseCache", () => {
     it("should handle non-JSON data with helpful error", async () => {
       const result = await cache.queryToolResponse("call_invalid", ".test");
       expect(result).toContain("Error: Tool response data is not valid JSON");
-      expect(result).toContain("toolCallId \"call_invalid\"");
+      expect(result).toContain('toolCallId "call_invalid"');
     });
 
     it("should return formatted JSON for complex results", async () => {
       const result = await cache.queryToolResponse("call_456", ".");
       expect(result).toContain("[\n");
       expect(result).toContain("  {");
-      expect(result).toContain("    \"id\":");
+      expect(result).toContain('    "id":');
     });
 
     it("should handle nested JSON strings parsing", async () => {
@@ -360,7 +389,10 @@ describe("ToolResponseCache", () => {
     });
 
     it("should handle empty query results", async () => {
-      const result = await cache.queryToolResponse("call_456", 'map(select(.id > 10))');
+      const result = await cache.queryToolResponse(
+        "call_456",
+        "map(select(.id > 10))"
+      );
       expect(result).toBe("[]");
     });
   });
@@ -369,24 +401,21 @@ describe("ToolResponseCache", () => {
     it("should parse simple JSON strings", () => {
       const input = '{"test": "value"}';
       const result = cache.parseNestedJsonStrings(input);
-      expect(result).toEqual({test: "value"});
+      expect(result).toEqual({ test: "value" });
     });
 
     it("should parse nested JSON strings recursively", () => {
       const input = '{"outer": "{\\"inner\\": \\"value\\"}"}';
       const result = cache.parseNestedJsonStrings(input);
       expect(result).toEqual({
-        outer: {inner: "value"}
+        outer: { inner: "value" },
       });
     });
 
     it("should handle arrays with JSON strings", () => {
       const input = ['{"test": "value1"}', '{"test": "value2"}'];
       const result = cache.parseNestedJsonStrings(input);
-      expect(result).toEqual([
-        {test: "value1"},
-        {test: "value2"}
-      ]);
+      expect(result).toEqual([{ test: "value1" }, { test: "value2" }]);
     });
 
     it("should handle mixed nested structures", () => {
@@ -394,16 +423,16 @@ describe("ToolResponseCache", () => {
         stringField: '{"nested": "value"}',
         arrayField: ['{"item": 1}', '{"item": 2}'],
         objectField: {
-          deepString: '{"deep": "nested"}'
-        }
+          deepString: '{"deep": "nested"}',
+        },
       };
       const result = cache.parseNestedJsonStrings(input);
       expect(result).toEqual({
-        stringField: {nested: "value"},
-        arrayField: [{item: 1}, {item: 2}],
+        stringField: { nested: "value" },
+        arrayField: [{ item: 1 }, { item: 2 }],
         objectField: {
-          deepString: {deep: "nested"}
-        }
+          deepString: { deep: "nested" },
+        },
       });
     });
 
@@ -412,14 +441,14 @@ describe("ToolResponseCache", () => {
         jsonString: '{"test": "value"}',
         regularString: "just a string",
         number: 42,
-        boolean: true
+        boolean: true,
       };
       const result = cache.parseNestedJsonStrings(input);
       expect(result).toEqual({
-        jsonString: {test: "value"},
-        regularString: "just a string", 
+        jsonString: { test: "value" },
+        regularString: "just a string",
         number: 42,
-        boolean: true
+        boolean: true,
       });
     });
 
@@ -433,7 +462,7 @@ describe("ToolResponseCache", () => {
     it("should return stored raw content", () => {
       const content = '{"test": "data"}';
       cache.storeToolResponse(content, "call_123");
-      
+
       const result = cache.retrieveRawResponse("call_123");
       expect(result).toBe(content);
     });
@@ -448,11 +477,11 @@ describe("ToolResponseCache", () => {
     it("should clear all stored data and metadata", () => {
       cache.storeToolResponse('{"test": "data"}', "call_123");
       cache.storeToolResponse('{"more": "data"}', "call_456");
-      
+
       expect(cache.getStorageSize()).toBe(2);
-      
+
       cache.clearStorage();
-      
+
       expect(cache.getStorageSize()).toBe(0);
       expect(cache.getStorageKeys()).toEqual([]);
       expect(cache.retrieveRawResponse("call_123")).toBeNull();
@@ -469,7 +498,7 @@ describe("ToolResponseCache", () => {
       cache.storeToolResponse('{"test": "data1"}', "call_123");
       cache.storeToolResponse('{"test": "data2"}', "call_456");
       cache.storeToolResponse('{"test": "data3"}', "call_789");
-      
+
       const keys = cache.getStorageKeys();
       expect(keys).toContain("call_123");
       expect(keys).toContain("call_456");
@@ -485,13 +514,13 @@ describe("ToolResponseCache", () => {
 
     it("should return correct count after storing responses", () => {
       expect(cache.getStorageSize()).toBe(0);
-      
+
       cache.storeToolResponse('{"test": "data1"}', "call_123");
       expect(cache.getStorageSize()).toBe(1);
-      
+
       cache.storeToolResponse('{"test": "data2"}', "call_456");
       expect(cache.getStorageSize()).toBe(2);
-      
+
       cache.clearStorage();
       expect(cache.getStorageSize()).toBe(0);
     });
@@ -503,49 +532,49 @@ describe("ToolResponseCache", () => {
     beforeEach(() => {
       mockToolsService = {
         getTool: jest.fn(),
-        addTool: jest.fn(),
-        addFunctions: jest.fn()
+        addTools: jest.fn(),
+        addFunctions: jest.fn(),
       } as any;
     });
 
     it("should register tool when not already present", () => {
       mockToolsService.getTool.mockReturnValue(null);
-      
+
       cache.registerTool(mockToolsService);
-      
-      expect(mockToolsService.getTool).toHaveBeenCalledWith("jqToolResponse");
-      expect(mockToolsService.addTool).toHaveBeenCalledWith(expect.objectContaining({
-        type: "function",
-        function: expect.objectContaining({
-          name: "jqToolResponse"
-        })
-      }));
+
+      expect(mockToolsService.addTools).toHaveBeenCalledWith([
+        {
+          type: "function",
+          function: expect.objectContaining({
+            name: "jqToolResponse",
+          }),
+        },
+      ]);
       expect(mockToolsService.addFunctions).toHaveBeenCalledWith({
-        jqToolResponse: expect.any(Function)
+        jqToolResponse: expect.any(Function),
       });
     });
 
-    it("should not register tool when already present", () => {
+    it("should overwrite tool when already present", () => {
       mockToolsService.getTool.mockReturnValue({} as any);
-      
+
       cache.registerTool(mockToolsService);
-      
-      expect(mockToolsService.getTool).toHaveBeenCalledWith("jqToolResponse");
-      expect(mockToolsService.addTool).not.toHaveBeenCalled();
-      expect(mockToolsService.addFunctions).not.toHaveBeenCalled();
+
+      expect(mockToolsService.addTools).toHaveBeenCalled();
+      expect(mockToolsService.addFunctions).toHaveBeenCalled();
     });
 
     it("should register function that calls queryToolResponse", async () => {
       mockToolsService.getTool.mockReturnValue(null);
-      
+
       cache.registerTool(mockToolsService);
-      
+
       const addFunctionsCall = mockToolsService.addFunctions.mock.calls[0][0];
       const jqFunction = addFunctionsCall.jqToolResponse;
-      
+
       // Store test data
       cache.storeToolResponse('{"test": "value"}', "call_123");
-      
+
       // Test the registered function
       const result = await jqFunction("call_123", ".test");
       expect(result).toBe('"value"');
@@ -555,17 +584,22 @@ describe("ToolResponseCache", () => {
   describe("Edge Cases and Error Handling", () => {
     it("should handle very large JSON objects", async () => {
       const largeObject = {
-        data: Array(1000).fill(0).map((_, i) => ({
-          id: i,
-          name: `item_${i}`,
-          description: `This is item number ${i} with some additional text to make it larger`
-        }))
+        data: Array(1000)
+          .fill(0)
+          .map((_, i) => ({
+            id: i,
+            name: `item_${i}`,
+            description: `This is item number ${i} with some additional text to make it larger`,
+          })),
       };
       const largeContent = JSON.stringify(largeObject);
-      
+
       cache.storeToolResponse(largeContent, "call_large");
-      
-      const result = await cache.queryToolResponse("call_large", ".data | length");
+
+      const result = await cache.queryToolResponse(
+        "call_large",
+        ".data | length"
+      );
       expect(result).toBe("1000");
     });
 
@@ -573,11 +607,11 @@ describe("ToolResponseCache", () => {
       const specialContent = JSON.stringify({
         unicode: "Hello 世界 🌍",
         escaped: "Line 1\nLine 2\tTabbed",
-        quotes: 'He said "Hello" to me'
+        quotes: 'He said "Hello" to me',
       });
-      
+
       cache.storeToolResponse(specialContent, "call_special");
-      
+
       const result = await cache.queryToolResponse("call_special", ".unicode");
       expect(result).toBe('"Hello 世界 🌍"');
     });
@@ -587,33 +621,38 @@ describe("ToolResponseCache", () => {
         empty: "",
         nullValue: null,
         zero: 0,
-        false: false
+        false: false,
       });
-      
+
       cache.storeToolResponse(content, "call_empty");
-      
+
       const emptyResult = await cache.queryToolResponse("call_empty", ".empty");
       expect(emptyResult).toBe('""');
-      
-      const nullResult = await cache.queryToolResponse("call_empty", ".nullValue");
+
+      const nullResult = await cache.queryToolResponse(
+        "call_empty",
+        ".nullValue"
+      );
       expect(nullResult).toBe("null");
     });
 
     it("should handle concurrent storage operations", async () => {
-      const promises = Array(10).fill(0).map((_, i) =>
-        Promise.resolve(cache.storeToolResponse(`{"id": ${i}}`, `call_${i}`))
-      );
-      
+      const promises = Array(10)
+        .fill(0)
+        .map((_, i) =>
+          Promise.resolve(cache.storeToolResponse(`{"id": ${i}}`, `call_${i}`))
+        );
+
       await Promise.all(promises);
-      
+
       expect(cache.getStorageSize()).toBe(10);
-      
+
       const results = await Promise.all(
-        Array(10).fill(0).map((_, i) =>
-          cache.queryToolResponse(`call_${i}`, ".id")
-        )
+        Array(10)
+          .fill(0)
+          .map((_, i) => cache.queryToolResponse(`call_${i}`, ".id"))
       );
-      
+
       results.forEach((result, i) => {
         expect(result).toBe(i.toString());
       });
@@ -626,17 +665,20 @@ describe("ToolResponseCache", () => {
             level3: {
               level4: {
                 level5: {
-                  deepValue: "found it!"
-                }
-              }
-            }
-          }
-        }
+                  deepValue: "found it!",
+                },
+              },
+            },
+          },
+        },
       };
-      
+
       cache.storeToolResponse(JSON.stringify(deepObject), "call_deep");
-      
-      const result = await cache.queryToolResponse("call_deep", ".level1.level2.level3.level4.level5.deepValue");
+
+      const result = await cache.queryToolResponse(
+        "call_deep",
+        ".level1.level2.level3.level4.level5.deepValue"
+      );
       expect(result).toBe('"found it!"');
     });
   });
@@ -644,14 +686,14 @@ describe("ToolResponseCache", () => {
   describe("Integration with Message Processing", () => {
     it("should integrate with complete message processing workflow", async () => {
       const processor = cache.createProcessor();
-      
+
       const messages: Message[] = [
         {
           role: "user",
-          content: "Test request"
+          content: "Test request",
         },
         {
-          role: "assistant", 
+          role: "assistant",
           content: "Processing...",
           tool_calls: [
             {
@@ -659,30 +701,36 @@ describe("ToolResponseCache", () => {
               type: "function",
               function: {
                 name: "testTool",
-                arguments: "{}"
-              }
-            }
-          ]
+                arguments: "{}",
+              },
+            },
+          ],
         },
         {
           role: "tool",
           tool_call_id: "call_123",
           content: JSON.stringify({
             result: "success",
-            data: [1, 2, 3, 4, 5]
-          })
-        }
+            data: [1, 2, 3, 4, 5],
+          }),
+        },
       ];
 
       await processor(messages, messages);
-      
+
       expect(cache.getStorageSize()).toBe(1);
-      
-      const result = await cache.queryToolResponse("call_123", ".data | length");
+
+      const result = await cache.queryToolResponse(
+        "call_123",
+        ".data | length"
+      );
       expect(result).toBe("5");
-      
-      const sumResult = await cache.queryToolResponse("call_123", ".data | add");
+
+      const sumResult = await cache.queryToolResponse(
+        "call_123",
+        ".data | add"
+      );
       expect(result).toBe("5");
     });
   });
-});
+});