@tyvm/knowhow 0.0.159 → 0.0.161

package/tests/processors/TokenCompressor.test.ts

@@ -1,674 +0,0 @@
-import { Message } from "../../src/clients/types";
-import { TokenCompressor } from "../../src/processors/TokenCompressor";
-import { ToolsService } from "../../src/services";
-
-describe("TokenCompressor", () => {
-  let tokenCompressor: TokenCompressor;
-  let mockToolsService: jest.Mocked<ToolsService>;
-
-  beforeEach(() => {
-    mockToolsService = {
-      addTools: jest.fn(),
-      addFunctions: jest.fn(),
-      getTool: jest.fn(),
-    } as any;
-
-    tokenCompressor = new TokenCompressor(mockToolsService);
-  });
-
-  afterEach(() => {
-    tokenCompressor.clearStorage();
-  });
-
-  describe("constructor", () => {
-    it("should register expandTokens tool with ToolsService", () => {
-      expect(mockToolsService.addTools).toHaveBeenCalled();
-      expect(mockToolsService.addFunctions).toHaveBeenCalled();
-    });
-
-    it("should overwrite tool if already exists", () => {
-      mockToolsService.getTool.mockReturnValue({ type: "function", function: { name: "expandTokens" } } as any);
-      const newCompressor = new TokenCompressor(mockToolsService);
-
-      // Should only be called once from the first instance
-      expect(mockToolsService.addTools).toHaveBeenCalledTimes(2);
-    });
-
-    it("should work without ToolsService", () => {
-      expect(() => new TokenCompressor()).not.toThrow();
-    });
-  });
-
-  describe("compressContent", () => {
-    it("should return original content if below threshold", () => {
-      const shortContent = "This is short content";
-      const result = tokenCompressor.compressContent(shortContent);
-      expect(result).toBe(shortContent);
-    });
-
-    it("should compress long strings using chunking", () => {
-      const longContent = "x".repeat(40000); // Well above threshold (40k chars = 10k tokens > 8k maxTokens)
-      const result = tokenCompressor.compressContent(longContent);
-
-      expect(result).toContain("[COMPRESSED_STRING");
-      expect(result).toContain("Key:");
-      expect(result).toContain("expandTokens");
-      expect(result).toContain("Preview:");
-    });
-
-    it("should compress JSON objects by properties", () => {
-      const largeJson = {
-        data: "x".repeat(40000), // 40k chars = 10k tokens, above threshold
-        metadata: { id: 1, name: "test" }
-      };
-      const content = JSON.stringify(largeJson);
-      const result = tokenCompressor.compressContent(content);
-
-      // Should be parsed and compressed as JSON
-      const parsed = JSON.parse(result);
-      expect(typeof parsed.data).toBe("string");
-      expect(parsed.data).toContain("[COMPRESSED_JSON_PROPERTY");
-    });
-
-    it("should handle mixed JSON compression strategies", () => {
-      const complexJson = {
-        smallProp: "small",
-        largeProp: "x".repeat(40000), // 40k chars = 10k tokens, above threshold
-        array: new Array(2000).fill({ item: "data".repeat(50) }) // Larger array to trigger compression
-      };
-      const content = JSON.stringify(complexJson);
-      const result = tokenCompressor.compressContent(content);
-
-      const parsed = JSON.parse(result);
-      expect(parsed.smallProp).toBe("small"); // Should remain unchanged
-      expect(parsed.largeProp).toContain("[COMPRESSED_JSON_PROPERTY"); // Should be compressed
-    });
-
-    it("should compress large content that merely CONTAINS a compression marker deep inside (regression)", () => {
-      // Regression for the false-positive in isAlreadyCompressed(): a large
-      // payload (e.g. a usage.json / message-history dump) whose body contains
-      // the substring "[COMPRESSED_STRING" deep inside its nested data was
-      // incorrectly treated as already-compressed and returned uncompressed,
-      // letting 1MB+ raw tool responses flow into createCompletion untouched.
-      const nestedMarker =
-        '[COMPRESSED_STRING - 10155 tokens in 3 chunks]\\nKey: compressed_abc123';
-      // Build a big JSON array whose entries embed the marker far from the start.
-      const entry = JSON.stringify({
-        role: "tool",
-        name: "readFile",
-        content: nestedMarker,
-        filler: "z".repeat(500),
-      });
-      const bigContent = "[" + new Array(200).fill(entry).join(",") + "]";
-
-      // Sanity: the raw content contains the marker but is NOT at the start.
-      expect(bigContent.includes("[COMPRESSED_STRING")).toBe(true);
-      expect(bigContent.trimStart().startsWith("[COMPRESSED_STRING")).toBe(false);
-
-      const result = tokenCompressor.compressContent(bigContent);
-
-      // It MUST actually get compressed, not returned untouched.
-      expect(result.length).toBeLessThan(bigContent.length);
-    });
-
-    it("should NOT recompress content that genuinely starts with a compression marker", () => {
-      // Idempotency: real compressor output begins with "[COMPRESSED_STRING".
-      const alreadyCompressed =
-        "[COMPRESSED_STRING - 999 tokens in 2 chunks]\nKey: compressed_xyz\nPath: \nPreview: ...";
-      const result = tokenCompressor.compressContent(alreadyCompressed);
-      expect(result).toBe(alreadyCompressed);
-    });
-
-    it("should NOT recompress JSON whose top-level _schema_key marks it compressed", () => {
-      // Idempotency: JSON-compressed output carries a top-level _schema_key.
-      const compressedJson = JSON.stringify({
-        _schema_key: "compressed_schema_1",
-        data: "x".repeat(40000),
-      });
-      const result = tokenCompressor.compressContent(compressedJson);
-      expect(result).toBe(compressedJson);
-    });
-  });
-
-  describe("compressStringInChunks", () => {
-    it("should return original string if below limit", () => {
-      const content = "short string";
-      const result = tokenCompressor.compressStringInChunks(content);
-      expect(result).toBe(content);
-    });
-
-    it("should create chunked compression for large strings", () => {
-      const content = "x".repeat(20000);
-      const result = tokenCompressor.compressStringInChunks(content);
-
-      expect(result).toContain("[COMPRESSED_STRING");
-      expect(result).toContain("chunks");
-      expect(result).toContain("Key:");
-
-      // Should have stored chunks in storage
-      expect(tokenCompressor.getStorageSize()).toBeGreaterThan(0);
-    });
-
-    it("should create chain of NEXT_CHUNK_KEY references", () => {
-      // Large enough to require multiple full-size chunks even after the
-      // minimum-chunk-size merge (characterLimit is 16000, minChunk is 8000).
-      const content = "a".repeat(40000);
-      tokenCompressor.compressStringInChunks(content);
-
-      const keys = tokenCompressor.getStorageKeys();
-      expect(keys.length).toBeGreaterThan(1);
-
-      // Check that chunks are linked
-      const firstChunk = tokenCompressor.retrieveString(keys[0]);
-      expect(firstChunk).toContain("NEXT_CHUNK_KEY");
-    });
-
-    it("should merge a small leftover chunk so no tiny chunks are emitted", () => {
-      // characterLimit is 16000; a 20000-char input would naively split into a
-      // 16000-char chunk and a tiny 4000-char leading chunk. The leftover is
-      // below the minimum chunk size, so it should be merged into a single chunk.
-      const content = "a".repeat(20000);
-      tokenCompressor.compressStringInChunks(content);
-
-      const keys = tokenCompressor.getStorageKeys();
-      expect(keys.length).toBe(1);
-
-      const onlyChunk = tokenCompressor.retrieveString(keys[0]);
-      expect(onlyChunk).not.toContain("NEXT_CHUNK_KEY");
-      // The full content should be retrievable from the single chunk.
-      expect(tokenCompressor.retrieveFullString(keys[0])).toBe(content);
-    });
-  });
-
-  describe("compressJsonProperties", () => {
-    it("should compress large array elements", () => {
-      // Create array that will definitely create chunks > 4000 chars (50 elements × 200 chars = 10k+ chars per potential chunk)
-      const largeArray = new Array(15).fill("x".repeat(2200));
-      const result = tokenCompressor.compressJsonProperties(largeArray);
-
-      // Should contain compression markers
-      expect(JSON.stringify(result)).toContain("[COMPRESSED_JSON_ARRAY_CHUNK");
-    });
-
-    it("should compress nested JSON objects", () => {
-      const nestedObj = {
-        level1: {
-          level2: {
-            data: "x".repeat(40000) // 40k chars = ~10k tokens, above 8k threshold
-          }
-        }
-      };
-
-      const result = tokenCompressor.compressJsonProperties(nestedObj);
-      expect(JSON.stringify(result)).toContain("[COMPRESSED_JSON");
-    });
-
-    it("should handle arrays with mixed content sizes", () => {
-      const mixedArray = [
-        "small",
-        "x".repeat(5000), // Large item
-        { data: "y".repeat(5000) }, // Large object
-        "another small item"
-      ];
-
-      const result = tokenCompressor.compressJsonProperties(mixedArray);
-      expect(Array.isArray(result)).toBe(true);
-    });
-
-    it("should preserve small objects unchanged", () => {
-      const smallObj = { id: 1, name: "test", active: true };
-      const result = tokenCompressor.compressJsonProperties(smallObj);
-      expect(result).toEqual(smallObj);
-    });
-  });
-
-  describe("compressMessage", () => {
-    it("should compress string content in messages", async () => {
-      const message: Message = {
-        role: "user",
-        content: "x".repeat(20000)
-      };
-
-      await tokenCompressor.compressMessage(message);
-
-      expect(message.content).toContain("[COMPRESSED_STRING");
-    });
-
-    it("should compress text in multimodal content", async () => {
-      const message: Message = {
-        role: "user",
-        content: [
-          { type: "text", text: "x".repeat(20000) },
-          { type: "image_url", image_url: { url: "http://example.com/img.jpg" } }
-        ]
-      };
-
-      await tokenCompressor.compressMessage(message);
-
-      const textContent = message.content[0] as { type: string; text: string };
-      expect(textContent.text).toContain("[COMPRESSED_STRING");
-
-      // Non-text content should remain unchanged
-      const imageContent = message.content[1] as { type: string; image_url: { url: string } };
-      expect(imageContent.image_url.url).toBe("http://example.com/img.jpg");
-    });
-
-    it("should handle messages with no content", async () => {
-      const message: Message = { role: "user" } as any;
-      await expect(tokenCompressor.compressMessage(message)).resolves.not.toThrow();
-    });
-  });
-
-  describe("createProcessor", () => {
-    it("should create processor that compresses all messages", async () => {
-      const processor = tokenCompressor.createProcessor();
-      const messages: Message[] = [
-        { role: "user", content: "x".repeat(20000) },
-        { role: "assistant", content: "short response" }
-      ];
-
-      await processor([], messages);
-
-      expect(messages[0].content).toContain("[COMPRESSED_STRING");
-      expect(messages[1].content).toBe("short response"); // Should remain short
-    });
-
-    it("should create processor with filter function", async () => {
-      const processor = tokenCompressor.createProcessor(
-        (msg) => msg.role === "user"
-      );
-      const messages: Message[] = [
-        { role: "user", content: "x".repeat(20000) },
-        { role: "assistant", content: "x".repeat(20000) }
-      ];
-
-      await processor([], messages);
-
-      expect(messages[0].content).toContain("[COMPRESSED_STRING");
-      expect(messages[1].content).not.toContain("[COMPRESSED_STRING");
-    });
-
-    it("should skip compression for responses from compression-related tools", async () => {
-      const processor = tokenCompressor.createProcessor();
-      const largeContent = "x".repeat(20000);
-      const messages: Message[] = [
-        { role: "assistant", content: "calling tools", tool_calls: [] },
-        { role: "tool", name: "expandTokens", content: largeContent, tool_call_id: "call_1" } as any,
-        { role: "tool", name: "grepToolResponse", content: largeContent, tool_call_id: "call_2" } as any,
-        { role: "tool", name: "jqToolResponse", content: largeContent, tool_call_id: "call_3" } as any,
-        { role: "tool", name: "tailToolResponse", content: largeContent, tool_call_id: "call_4" } as any,
-        { role: "tool", name: "listStoredToolResponses", content: largeContent, tool_call_id: "call_5" } as any,
-        { role: "tool", name: "someOtherTool", content: largeContent, tool_call_id: "call_6" } as any,
-      ];
-
-      await processor([], messages);
-
-      // Compression-related tools should NOT be compressed
-      expect(messages[1].content).toBe(largeContent);
-      expect(messages[2].content).toBe(largeContent);
-      expect(messages[3].content).toBe(largeContent);
-      expect(messages[4].content).toBe(largeContent);
-      expect(messages[5].content).toBe(largeContent);
-
-      // A regular tool SHOULD be compressed
-      expect(messages[6].content).toContain("[COMPRESSED_STRING");
-    });
-
-    it("should only compress tool messages from the last batch (after last assistant message)", async () => {
-      const processor = tokenCompressor.createProcessor();
-      const largeContent = "x".repeat(20000);
-
-      // Historical tool message (before last assistant message) should NOT be compressed
-      // Current tool message (after last assistant message) SHOULD be compressed
-      const messages: Message[] = [
-        { role: "user", content: "first user message" },
-        { role: "assistant", content: "first assistant response", tool_calls: [] },
-        { role: "tool", name: "someTool", content: largeContent, tool_call_id: "call_historical" } as any,
-        { role: "assistant", content: "second assistant response", tool_calls: [] },
-        { role: "tool", name: "someTool", content: largeContent, tool_call_id: "call_current" } as any,
-      ];
-
-      await processor([], messages);
-
-      // Historical tool message (index 2, before last assistant at index 3) should NOT be compressed
-      expect(messages[2].content).toBe(largeContent);
-
-      // Current tool message (index 4, after last assistant at index 3) SHOULD be compressed
-      expect(messages[4].content).toContain("[COMPRESSED_STRING");
-    });
-
-    it("should compress all tool messages when there is no assistant message", async () => {
-      const processor = tokenCompressor.createProcessor();
-      const largeContent = "x".repeat(20000);
-
-      const messages: Message[] = [
-        { role: "user", content: "user message" },
-        { role: "tool", name: "someTool", content: largeContent, tool_call_id: "call_1" } as any,
-        { role: "tool", name: "anotherTool", content: largeContent, tool_call_id: "call_2" } as any,
-      ];
-
-      await processor([], messages);
-
-      // With no assistant message (lastAssistantIndex = -1), all tool messages at index >= 0 should be compressed
-      expect(messages[1].content).toContain("[COMPRESSED_STRING");
-      expect(messages[2].content).toContain("[COMPRESSED_STRING");
-    });
-  });
-
-  describe("storage operations", () => {
-    it("should store and retrieve strings", () => {
-      const key = "test_key";
-      const value = "test_value";
-
-      tokenCompressor.storeString(key, value);
-      const retrieved = tokenCompressor.retrieveString(key);
-
-      expect(retrieved).toBe(value);
-    });
-
-    it("should return null for non-existent keys", () => {
-      const result = tokenCompressor.retrieveString("non_existent");
-      expect(result).toBeNull();
-    });
-
-    it("should clear all storage", () => {
-      tokenCompressor.storeString("key1", "value1");
-      tokenCompressor.storeString("key2", "value2");
-
-      expect(tokenCompressor.getStorageSize()).toBe(2);
-
-      tokenCompressor.clearStorage();
-      expect(tokenCompressor.getStorageSize()).toBe(0);
-    });
-
-    it("should return storage keys", () => {
-      tokenCompressor.storeString("key1", "value1");
-      tokenCompressor.storeString("key2", "value2");
-
-      const keys = tokenCompressor.getStorageKeys();
-      expect(keys).toContain("key1");
-      expect(keys).toContain("key2");
-    });
-  });
-
-  describe("configuration", () => {
-    it("should allow setting compression threshold", () => {
-      tokenCompressor.setCompressionThreshold(1000);
-
-      const content = "x".repeat(5000); // Above new threshold (5000 chars = 1250 tokens > 1000)
-      const result = tokenCompressor.compressContent(content);
-
-      expect(result).toContain("[COMPRESSED_STRING");
-    });
-
-    it("should adjust character limit with threshold", () => {
-      const originalThreshold = 4000;
-      const newThreshold = 2000;
-
-      tokenCompressor.setCompressionThreshold(newThreshold);
-
-      // Should compress at lower threshold
-      const content = "x".repeat(9000); // Above new threshold (9000 chars = 2250 tokens > 2000)
-      const result = tokenCompressor.compressContent(content);
-
-      expect(result).toContain("[COMPRESSED_STRING");
-    });
-  });
-
-  describe("image content compression", () => {
-    it("keeps image URLs intact when expanded", () => {
-      const imageUrl = `data:image/png;base64,${"A".repeat(20_000)}`;
-      const content = JSON.stringify({
-        type: "image_url",
-        image_url: { url: imageUrl, detail: "high" },
-      });
-
-      const compressed = tokenCompressor.compressContent(content);
-      const key = compressed.match(/Key:\s*(\S+)/)?.[1];
-
-      expect(key).toBeDefined();
-      const expanded = tokenCompressor.retrieveFullString(key!);
-      expect(expanded).toBe(content);
-      expect(expanded).not.toContain("[COMPRESSED_JSON_PROPERTY");
-    });
-  });
-
-  describe("tool function integration", () => {
-    it("should register expandTokens function correctly", () => {
-      const toolsServiceCalls = mockToolsService.addFunctions.mock.calls;
-      expect(toolsServiceCalls.length).toBe(1);
-
-      const functions = toolsServiceCalls[0][0];
-      expect(functions.expandTokens).toBeDefined();
-      expect(typeof functions.expandTokens).toBe("function");
-    });
-
-    it("should return stored data when expandTokens is called", () => {
-      const key = "test_key";
-      const value = "test_value";
-      tokenCompressor.storeString(key, value);
-
-      const toolsServiceCalls = mockToolsService.addFunctions.mock.calls;
-      const functions = toolsServiceCalls[0][0];
-      const result = functions.expandTokens(key);
-
-      expect(result).toBe(value);
-    });
-
-    it("should return error message for non-existent keys", () => {
-      const toolsServiceCalls = mockToolsService.addFunctions.mock.calls;
-      const functions = toolsServiceCalls[0][0];
-      const result = functions.expandTokens("non_existent");
-
-      expect(result).toContain("Error: No data found for key");
-      expect(result).toContain("Available keys:");
-    });
-
-    it("should auto-stitch and paginate a multi-chunk chain", () => {
-      // Force a multi-chunk compression then expand the first key.
-      const content = "a".repeat(40000);
-      const placeholder = tokenCompressor.compressStringInChunks(content);
-      const firstKey = placeholder.match(/Key:\s*(\S+)/)[1];
-
-      const toolsServiceCalls = mockToolsService.addFunctions.mock.calls;
-      const functions = toolsServiceCalls[0][0];
-      const result = functions.expandTokens(firstKey);
-
-      expect(result.length).toBeLessThanOrEqual(20_000);
-      expect(result).toContain("Repeat with characterOffset=");
-      expect(result).not.toContain("NEXT_CHUNK_KEY");
-
-      const pages = [result];
-      let offsetMatch = result.match(/characterOffset=(\d+)/);
-      while (offsetMatch) {
-        const page = functions.expandTokens(
-          firstKey,
-          undefined,
-          undefined,
-          Number(offsetMatch[1])
-        );
-        pages.push(page);
-        offsetMatch = page.match(/Repeat with characterOffset=(\d+)/);
-      }
-      expect(pages.reduce((sum, page) => sum + (page.match(/^a+/)?.[0].length || 0), 0)).toBe(content.length);
-    });
-
-    it("should support a ranged read with real line numbers", () => {
-      const key = "ranged_key";
-      const value = ["line one", "line two", "line three", "line four"].join(
-        "\n"
-      );
-      tokenCompressor.storeString(key, value);
-
-      const toolsServiceCalls = mockToolsService.addFunctions.mock.calls;
-      const functions = toolsServiceCalls[0][0];
-      const result = functions.expandTokens(key, 2, 3);
-
-      expect(result).toBe("2: line two\n3: line three");
-    });
-
-    it("should error on an invalid line range", () => {
-      const key = "bad_range_key";
-      tokenCompressor.storeString(key, "a\nb\nc");
-
-      const toolsServiceCalls = mockToolsService.addFunctions.mock.calls;
-      const functions = toolsServiceCalls[0][0];
-      const result = functions.expandTokens(key, 5, 2);
-
-      expect(result).toContain("Error: Invalid line range");
-    });
-  });
-
-  describe("edge cases", () => {
-    it("should handle empty strings", () => {
-      const result = tokenCompressor.compressContent("");
-      expect(result).toBe("");
-    });
-
-    it("should handle malformed JSON gracefully", () => {
-      const malformedJson = '{"incomplete": "json"'; // Missing closing brace
-      const result = tokenCompressor.compressContent(malformedJson);
-
-      // Should treat as string, not JSON
-      if (result.length > malformedJson.length) {
-        expect(result).toContain("[COMPRESSED_STRING");
-      } else {
-        expect(result).toBe(malformedJson);
-      }
-    });
-
-    it("should handle very large objects without stack overflow", () => {
-      const deepObject = { level: 0 } as any;
-      let current = deepObject;
-
-      // Create deeply nested object
-      for (let i = 1; i < 100; i++) {
-        current.next = { level: i, data: "x".repeat(100) };
-        current = current.next;
-      }
-
-      expect(() => {
-        tokenCompressor.compressJsonProperties(deepObject);
-      }).not.toThrow();
-    });
-
-    it("should handle circular references in JSON", () => {
-      const obj: any = { name: "test" };
-      obj.self = obj; // Create circular reference
-
-      expect(() => {
-        JSON.stringify(obj); // This should throw
-      }).toThrow();
-
-      // Our compressor should handle this gracefully by not receiving circular JSON
-      const safeObj = { name: "test", data: "x".repeat(10000) };
-      expect(() => {
-        tokenCompressor.compressJsonProperties(safeObj);
-      }).not.toThrow();
-    });
-  });
-
-  describe("performance characteristics", () => {
-    it("should handle large arrays efficiently", () => {
-      const largeArray = new Array(1000).fill("x".repeat(100));
-      const startTime = Date.now();
-
-      tokenCompressor.compressJsonProperties(largeArray);
-
-      const duration = Date.now() - startTime;
-      expect(duration).toBeLessThan(5000); // Should complete within 5 seconds
-    });
-
-    it("should not compress already small content multiple times", () => {
-      const content = "small content";
-      const result1 = tokenCompressor.compressContent(content);
-      const result2 = tokenCompressor.compressContent(result1);
-
-      expect(result1).toBe(content);
-      expect(result2).toBe(content);
-    });
-  });
-
-  describe("multi-task storage isolation", () => {
-    it("should not leak storage between tasks when reusing agent with new TokenCompressor instances", async () => {
-      // This test simulates the AgentModule scenario where:
-      // 1. Same agent instance is reused for multiple tasks
-      // 2. But a NEW TokenCompressor is created for each task
-      // 3. Old compressed keys from previous task should not cause errors
-      
-      const consoleLogSpy = jest.spyOn(console, 'log');
-      
-      // === FIRST TASK ===
-      // Create first TokenCompressor instance for first task
-      const firstCompressor = new TokenCompressor(mockToolsService);
-      const firstProcessor = firstCompressor.createProcessor((msg) =>
-        Boolean(msg.role === "tool" && msg.tool_call_id)
-      );
-      
-      const firstTaskMessages: Message[] = [
-        { 
-          role: "tool", 
-          content: "x".repeat(20000),
-          tool_call_id: "call_1" 
-        }
-      ];
-      
-      await firstProcessor([], firstTaskMessages);
-      
-      // Verify compression happened
-      expect(firstTaskMessages[0].content).toContain("[COMPRESSED_STRING");
-      
-      // Extract the key that was used
-      const firstContent = firstTaskMessages[0].content as string;
-      const keyMatch = firstContent.match(/Key: (compressed_[^\s]+)/);
-      expect(keyMatch).not.toBeNull();
-      const firstTaskKey = keyMatch![1];
-      
-      // Verify the key exists in first compressor's storage
-      expect(firstCompressor.retrieveString(firstTaskKey)).not.toBeNull();
-      
-      // === SECOND TASK ===
-      // Simulate agent.newTask() being called, which clears agent state
-      // But in AgentModule, a NEW TokenCompressor is created (line 711)
-      // This new compressor doesn't have the old keys from first task
-      const secondCompressor = new TokenCompressor(mockToolsService);
-      const secondProcessor = secondCompressor.createProcessor((msg) =>
-        Boolean(msg.role === "tool" && msg.tool_call_id)
-      );
-      
-      // Now simulate the second task receiving messages that might reference old keys
-      // The agent's message history was cleared by newTask(), so this shouldn't happen
-      // But if it does, the new compressor won't have the old keys
-      const secondTaskMessages: Message[] = [
-        { 
-          role: "tool", 
-          content: "y".repeat(20000),
-          tool_call_id: "call_2" 
-        }
-      ];
-      
-      await secondProcessor([], secondTaskMessages);
-      
-      // Verify compression happened for second task
-      expect(secondTaskMessages[0].content).toContain("[COMPRESSED_STRING");
-      
-      // The old key from first task should NOT exist in second compressor
-      expect(secondCompressor.retrieveString(firstTaskKey)).toBeNull();
-      
-      // Extract the key from second task
-      const secondContent = secondTaskMessages[0].content as string;
-      const secondKeyMatch = secondContent.match(/Key: (compressed_[^\s]+)/);
-      expect(secondKeyMatch).not.toBeNull();
-      const secondTaskKey = secondKeyMatch![1];
-      
-      // The second key should exist in second compressor
-      expect(secondCompressor.retrieveString(secondTaskKey)).not.toBeNull();
-      
-      // Clean up both compressors
-      firstCompressor.clearStorage();
-      secondCompressor.clearStorage();
-      
-      consoleLogSpy.mockRestore();
-    });
-  });
-});