@tyvm/knowhow 0.0.47 → 0.0.48

package/tests/processors/ToolResponseCache.test.ts

@@ -0,0 +1,688 @@
+import { Message } from "../../src/clients/types";
+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);
+      }
+    }
+    
+    // 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 .nullValue query for null value test
+    if (query === ".nullValue") {
+      if (data && data.nullValue !== undefined) {
+        return JSON.stringify(data.nullValue);
+      }
+    }
+    
+    // Handle .name query on {name: "test", data: [1, 2, 3]}
+    if (query === ".name") {
+      if (data && data.name) {
+        return JSON.stringify(data.name);
+      }
+    }
+    
+    // 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 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 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 "." 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 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);
+      }
+    }
+    
+    // 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");
+
+describe("ToolResponseCache", () => {
+  let cache: ToolResponseCache;
+  let mockToolsService: jest.Mocked<ToolsService>;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    
+    mockToolsService = {
+      addTool: jest.fn(),
+      addFunctions: jest.fn(),
+      getTool: jest.fn().mockReturnValue(undefined),
+      callTool: jest.fn(),
+    } as any;
+
+    cache = new ToolResponseCache(mockToolsService);
+  });
+
+  describe("constructor", () => {
+    it("should create an instance and register tool with ToolsService", () => {
+      expect(cache).toBeDefined();
+      expect(cache).toBeInstanceOf(ToolResponseCache);
+      expect(mockToolsService.addTool).toHaveBeenCalledWith(jqToolResponseDefinition);
+      expect(mockToolsService.addFunctions).toHaveBeenCalledWith({
+        jqToolResponse: expect.any(Function),
+      });
+    });
+
+    it("should not register 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);
+    });
+  });
+
+  describe("createProcessor", () => {
+    it("should create a message processor function", () => {
+      const processor = cache.createProcessor();
+      expect(typeof processor).toBe("function");
+    });
+
+    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}]}'
+        }
+      ];
+
+      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}]}');
+    });
+
+    it("should ignore non-tool messages", async () => {
+      const processor = cache.createProcessor();
+      
+      const messages: Message[] = [
+        {
+          role: "user",
+          content: "This is a user 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
+      ];
+
+      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
+        } as Message,
+        {
+          role: "tool", 
+          tool_call_id: "call_456",
+          content: undefined
+        } as Message,
+        {
+          role: "tool",
+          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"
+        },
+        {
+          role: "tool",
+          tool_call_id: "call_blocked",
+          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);
+    });
+  });
+
+  describe("storeToolResponse", () => {
+    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);
+      expect(metadata.originalLength).toBe(content.length);
+      expect(metadata.storedAt).toBeGreaterThan(0);
+    });
+  });
+  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");
+    });
+
+    it("should execute simple JQ queries successfully", async () => {
+      const result = await cache.queryToolResponse("call_123", ".name");
+      expect(result).toBe('"test"');
+    });
+
+    it("should execute array queries", async () => {
+      const result = await cache.queryToolResponse("call_123", ".data[]");
+      expect(result).toBe("1\n2\n3");
+    });
+
+    it("should execute complex JQ queries", async () => {
+      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 parsed = JSON.parse(result);
+      expect(parsed).toEqual([
+        {identifier: 1, content: "a"},
+        {identifier: 2, content: "b"}
+      ]);
+    });
+
+    it("should return error for missing tool call ID", async () => {
+      const result = await cache.queryToolResponse("missing_id", ".test");
+      expect(result).toContain("Error: No tool response found");
+      expect(result).toContain("missing_id");
+      expect(result).toContain("Available IDs:");
+    });
+
+    it("should handle invalid JQ queries with error message", async () => {
+      const result = await cache.queryToolResponse("call_123", ".invalid[");
+      expect(result).toContain("JQ Query Error:");
+    });
+
+    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\"");
+    });
+
+    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\":");
+    });
+
+    it("should handle nested JSON strings parsing", async () => {
+      const result = await cache.queryToolResponse("call_789", ".nested.inner");
+      expect(result).toBe('"value"');
+    });
+
+    it("should handle empty query results", async () => {
+      const result = await cache.queryToolResponse("call_456", 'map(select(.id > 10))');
+      expect(result).toBe("[]");
+    });
+  });
+
+  describe("parseNestedJsonStrings", () => {
+    it("should parse simple JSON strings", () => {
+      const input = '{"test": "value"}';
+      const result = cache.parseNestedJsonStrings(input);
+      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"}
+      });
+    });
+
+    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"}
+      ]);
+    });
+
+    it("should handle mixed nested structures", () => {
+      const input = {
+        stringField: '{"nested": "value"}',
+        arrayField: ['{"item": 1}', '{"item": 2}'],
+        objectField: {
+          deepString: '{"deep": "nested"}'
+        }
+      };
+      const result = cache.parseNestedJsonStrings(input);
+      expect(result).toEqual({
+        stringField: {nested: "value"},
+        arrayField: [{item: 1}, {item: 2}],
+        objectField: {
+          deepString: {deep: "nested"}
+        }
+      });
+    });
+
+    it("should leave non-JSON strings unchanged", () => {
+      const input = {
+        jsonString: '{"test": "value"}',
+        regularString: "just a string",
+        number: 42,
+        boolean: true
+      };
+      const result = cache.parseNestedJsonStrings(input);
+      expect(result).toEqual({
+        jsonString: {test: "value"},
+        regularString: "just a string", 
+        number: 42,
+        boolean: true
+      });
+    });
+
+    it("should handle malformed JSON strings gracefully", () => {
+      const input = '{"invalid": json}';
+      const result = cache.parseNestedJsonStrings(input);
+      expect(result).toBe(input); // Should return original string
+    });
+  });
+  describe("retrieveRawResponse", () => {
+    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);
+    });
+
+    it("should return null for missing tool call ID", () => {
+      const result = cache.retrieveRawResponse("missing_id");
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("clearStorage", () => {
+    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();
+      expect(cache.retrieveRawResponse("call_456")).toBeNull();
+    });
+  });
+
+  describe("getStorageKeys", () => {
+    it("should return empty array when no data stored", () => {
+      expect(cache.getStorageKeys()).toEqual([]);
+    });
+
+    it("should return all stored tool call IDs", () => {
+      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");
+      expect(keys).toContain("call_789");
+      expect(keys).toHaveLength(3);
+    });
+  });
+
+  describe("getStorageSize", () => {
+    it("should return 0 for empty storage", () => {
+      expect(cache.getStorageSize()).toBe(0);
+    });
+
+    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);
+    });
+  });
+
+  describe("registerTool", () => {
+    let mockToolsService: jest.Mocked<ToolsService>;
+
+    beforeEach(() => {
+      mockToolsService = {
+        getTool: jest.fn(),
+        addTool: 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.addFunctions).toHaveBeenCalledWith({
+        jqToolResponse: expect.any(Function)
+      });
+    });
+
+    it("should not register 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();
+    });
+
+    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"');
+    });
+  });
+
+  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`
+        }))
+      };
+      const largeContent = JSON.stringify(largeObject);
+      
+      cache.storeToolResponse(largeContent, "call_large");
+      
+      const result = await cache.queryToolResponse("call_large", ".data | length");
+      expect(result).toBe("1000");
+    });
+
+    it("should handle special characters in JSON", async () => {
+      const specialContent = JSON.stringify({
+        unicode: "Hello 世界 🌍",
+        escaped: "Line 1\nLine 2\tTabbed",
+        quotes: 'He said "Hello" to me'
+      });
+      
+      cache.storeToolResponse(specialContent, "call_special");
+      
+      const result = await cache.queryToolResponse("call_special", ".unicode");
+      expect(result).toBe('"Hello 世界 🌍"');
+    });
+
+    it("should handle empty strings and null values", async () => {
+      const content = JSON.stringify({
+        empty: "",
+        nullValue: null,
+        zero: 0,
+        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");
+      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}`))
+      );
+      
+      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")
+        )
+      );
+      
+      results.forEach((result, i) => {
+        expect(result).toBe(i.toString());
+      });
+    });
+
+    it("should handle deeply nested JSON structures", async () => {
+      const deepObject = {
+        level1: {
+          level2: {
+            level3: {
+              level4: {
+                level5: {
+                  deepValue: "found it!"
+                }
+              }
+            }
+          }
+        }
+      };
+      
+      cache.storeToolResponse(JSON.stringify(deepObject), "call_deep");
+      
+      const result = await cache.queryToolResponse("call_deep", ".level1.level2.level3.level4.level5.deepValue");
+      expect(result).toBe('"found it!"');
+    });
+  });
+
+  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"
+        },
+        {
+          role: "assistant", 
+          content: "Processing...",
+          tool_calls: [
+            {
+              id: "call_123",
+              type: "function",
+              function: {
+                name: "testTool",
+                arguments: "{}"
+              }
+            }
+          ]
+        },
+        {
+          role: "tool",
+          tool_call_id: "call_123",
+          content: JSON.stringify({
+            result: "success",
+            data: [1, 2, 3, 4, 5]
+          })
+        }
+      ];
+
+      await processor(messages, messages);
+      
+      expect(cache.getStorageSize()).toBe(1);
+      
+      const result = await cache.queryToolResponse("call_123", ".data | length");
+      expect(result).toBe("5");
+      
+      const sumResult = await cache.queryToolResponse("call_123", ".data | add");
+      expect(result).toBe("5");
+    });
+  });
+});