whale-code 6.5.6 → 6.5.8

package/dist/shared/api-client.test.js

@@ -0,0 +1,228 @@
+import { describe, it, expect } from "vitest";
+import { buildAPIRequest } from "./api-client.js";
+
+// ============================================================================
+// buildAPIRequest
+// ============================================================================
+
+describe("buildAPIRequest", () => {
+  // ---------- main profile ----------
+
+  describe("main profile", () => {
+    it("returns compact + clear betas for opus-4-6", () => {
+      const config = buildAPIRequest({
+        model: "claude-opus-4-6",
+        contextProfile: "main"
+      });
+      expect(config.betas).toContain("context-management-2025-06-27");
+      expect(config.betas).toContain("compact-2026-01-12");
+    });
+    it("returns compact + clear betas for sonnet-4-6", () => {
+      const config = buildAPIRequest({
+        model: "claude-sonnet-4-6",
+        contextProfile: "main"
+      });
+      expect(config.betas).toContain("context-management-2025-06-27");
+      expect(config.betas).toContain("compact-2026-01-12");
+    });
+    it("includes compact edit at 167K and clear edit at 100K for opus-4-6", () => {
+      const config = buildAPIRequest({
+        model: "claude-opus-4-6",
+        contextProfile: "main"
+      });
+      const compactEdit = config.contextManagement.edits.find(e => e.type === "compact_20260112");
+      const clearEdit = config.contextManagement.edits.find(e => e.type === "clear_tool_uses_20250919");
+      expect(compactEdit).toBeDefined();
+      expect(compactEdit.trigger.value).toBe(167_000);
+      expect(clearEdit).toBeDefined();
+      expect(clearEdit.trigger.value).toBe(100_000);
+      expect(clearEdit.keep.value).toBe(3);
+    });
+    it("includes compact + clear_tool_uses edits for sonnet-4-6 (thinking disabled)", () => {
+      const config = buildAPIRequest({
+        model: "claude-sonnet-4-6",
+        contextProfile: "main"
+      });
+      // With thinking disabled, clear_thinking is filtered out, leaving compact + clear_tool_uses
+      expect(config.contextManagement.edits).toHaveLength(2);
+      expect(config.contextManagement.edits[0].type).toBe("compact_20260112");
+      expect(config.contextManagement.edits[1].type).toBe("clear_tool_uses_20250919");
+    });
+    it("defaults maxTokens to 32000", () => {
+      const config = buildAPIRequest({
+        model: "claude-opus-4-6",
+        contextProfile: "main"
+      });
+      expect(config.maxTokens).toBe(32000);
+    });
+    it("respects maxOutputTokens override", () => {
+      const config = buildAPIRequest({
+        model: "claude-opus-4-6",
+        contextProfile: "main",
+        maxOutputTokens: 4096
+      });
+      expect(config.maxTokens).toBe(4096);
+    });
+    it("caps maxOutputTokens at model maximum", () => {
+      const config = buildAPIRequest({
+        model: "claude-opus-4-6",
+        contextProfile: "main",
+        maxOutputTokens: 200000
+      });
+      // 200000 exceeds opus model max of 128000, so capped
+      expect(config.maxTokens).toBe(128000);
+    });
+  });
+
+  // ---------- subagent profile ----------
+
+  describe("subagent profile", () => {
+    it("uses clear at 60K/keep 2 for Anthropic models", () => {
+      const config = buildAPIRequest({
+        model: "claude-sonnet-4-6",
+        contextProfile: "subagent"
+      });
+      // Subagent profile now includes clear_thinking + clear_tool_uses (+ compact for supported models)
+      expect(config.contextManagement.edits.length).toBeGreaterThanOrEqual(2);
+      const edit = config.contextManagement.edits.find(e => e.type === "clear_tool_uses_20250919");
+      expect(edit).toBeDefined();
+      expect(edit.trigger.value).toBe(60_000);
+      expect(edit.keep.value).toBe(2);
+    });
+    it("defaults maxTokens to 32000 (subagent cap)", () => {
+      const config = buildAPIRequest({
+        model: "claude-sonnet-4-6",
+        contextProfile: "subagent"
+      });
+      expect(config.maxTokens).toBe(32000);
+    });
+    it("allows explicit maxOutputTokens to override subagent default", () => {
+      const config = buildAPIRequest({
+        model: "claude-sonnet-4-6",
+        contextProfile: "subagent",
+        maxOutputTokens: 4096
+      });
+      expect(config.maxTokens).toBe(4096);
+    });
+    it("has context-management beta for Anthropic models", () => {
+      const config = buildAPIRequest({
+        model: "claude-sonnet-4-6",
+        contextProfile: "subagent"
+      });
+      expect(config.betas).toContain("context-management-2025-06-27");
+    });
+  });
+
+  // ---------- teammate profile ----------
+
+  describe("teammate profile", () => {
+    it("uses same context management as main for opus-4-6", () => {
+      const main = buildAPIRequest({
+        model: "claude-opus-4-6",
+        contextProfile: "main"
+      });
+      const teammate = buildAPIRequest({
+        model: "claude-opus-4-6",
+        contextProfile: "teammate"
+      });
+      expect(teammate.betas).toEqual(main.betas);
+      expect(teammate.contextManagement.edits).toEqual(main.contextManagement.edits);
+    });
+    it("defaults maxTokens to 32000 (not subagent cap)", () => {
+      const config = buildAPIRequest({
+        model: "claude-sonnet-4-6",
+        contextProfile: "teammate"
+      });
+      expect(config.maxTokens).toBe(32000);
+    });
+  });
+
+  // ---------- thinking config ----------
+
+  describe("thinking integration", () => {
+    it("does not include thinking when disabled", () => {
+      const config = buildAPIRequest({
+        model: "claude-opus-4-6",
+        contextProfile: "main",
+        thinkingEnabled: false
+      });
+      expect(config.thinking).toBeUndefined();
+    });
+    it("defaults thinkingEnabled to false", () => {
+      const config = buildAPIRequest({
+        model: "claude-opus-4-6",
+        contextProfile: "main"
+      });
+      expect(config.thinking).toBeUndefined();
+    });
+    it("includes adaptive thinking beta for opus-4-6 when enabled", () => {
+      const config = buildAPIRequest({
+        model: "claude-opus-4-6",
+        contextProfile: "main",
+        thinkingEnabled: true
+      });
+      expect(config.betas).toContain("adaptive-thinking-2026-01-28");
+      expect(config.thinking).toBeDefined();
+      expect(config.thinking.type).toBe("adaptive");
+      expect(config.thinking.budget_tokens).toBeUndefined();
+    });
+    it("includes adaptive thinking beta for sonnet-4-6 when enabled", () => {
+      const config = buildAPIRequest({
+        model: "claude-sonnet-4-6",
+        contextProfile: "main",
+        thinkingEnabled: true
+      });
+      expect(config.betas).toContain("adaptive-thinking-2026-01-28");
+      expect(config.thinking).toBeDefined();
+      expect(config.thinking.type).toBe("adaptive");
+      expect(config.thinking.budget_tokens).toBeUndefined();
+    });
+    it("uses fixed budget thinking for older sonnet models", () => {
+      const config = buildAPIRequest({
+        model: "claude-sonnet-4-20250514",
+        contextProfile: "main",
+        thinkingEnabled: true
+      });
+      // Older sonnet uses fixed budget, not adaptive
+      expect(config.thinking).toBeDefined();
+      expect(config.thinking.type).toBe("enabled");
+      expect(config.thinking.budget_tokens).toBeDefined();
+      expect(config.thinking.budget_tokens).toBeLessThan(config.maxTokens);
+    });
+  });
+
+  // ---------- Gemini (non-Anthropic) models ----------
+
+  describe("non-Anthropic models (Gemini)", () => {
+    it("returns empty betas for gemini models on main profile", () => {
+      const config = buildAPIRequest({
+        model: "gemini-3-pro-preview",
+        contextProfile: "main"
+      });
+      expect(config.betas).toEqual([]);
+    });
+    it("returns empty edits for gemini models on main profile", () => {
+      const config = buildAPIRequest({
+        model: "gemini-3-pro-preview",
+        contextProfile: "main"
+      });
+      expect(config.contextManagement.edits).toEqual([]);
+    });
+    it("returns empty betas for gemini models on subagent profile", () => {
+      const config = buildAPIRequest({
+        model: "gemini-2.5-flash",
+        contextProfile: "subagent"
+      });
+      expect(config.betas).toEqual([]);
+      expect(config.contextManagement.edits).toEqual([]);
+    });
+    it("disables thinking for gemini models even when enabled", () => {
+      const config = buildAPIRequest({
+        model: "gemini-3-pro-preview",
+        contextProfile: "main",
+        thinkingEnabled: true
+      });
+      expect(config.thinking).toBeUndefined();
+    });
+  });
+});

package/dist/shared/compaction-thinking.test.js

@@ -0,0 +1,315 @@
+/**
+ * Tests for shared/compaction.ts — thinking stripping, combined scenarios, bytesRemoved
+ *
+ * Covers:
+ * - Thinking block stripping
+ * - Combined real-world scenarios
+ * - bytesRemoved accuracy tracking
+ */
+
+import { describe, it, expect } from "vitest";
+import { preCompact } from "./compaction.js";
+
+// ============================================================================
+// HELPERS
+// ============================================================================
+
+/** Build a user message with a tool_result block */
+function toolResultMsg(toolUseId, content) {
+  return {
+    role: "user",
+    content: [{
+      type: "tool_result",
+      tool_use_id: toolUseId,
+      content
+    }]
+  };
+}
+
+/** Build an assistant message with text */
+function assistantMsg(text) {
+  return {
+    role: "assistant",
+    content: [{
+      type: "text",
+      text
+    }]
+  };
+}
+
+/** Build an assistant message with thinking + text */
+function assistantWithThinking(text, thinking) {
+  return {
+    role: "assistant",
+    content: [{
+      type: "thinking",
+      thinking,
+      signature: "sig"
+    }, {
+      type: "text",
+      text
+    }]
+  };
+}
+
+/** Generate a string of N characters */
+function bigStr(n) {
+  return "x".repeat(n);
+}
+
+// ============================================================================
+// TESTS
+// ============================================================================
+
+describe("preCompact", () => {
+  // --------------------------------------------------------------------------
+  // Thinking block stripping
+  // --------------------------------------------------------------------------
+  describe("thinking block stripping", () => {
+    it("strips thinking blocks older than 3 turns from end", () => {
+      const msgs = [assistantWithThinking("old answer", "old thinking"),
+      // msg 0
+      {
+        role: "user",
+        content: "q1"
+      },
+      // msg 1
+      assistantWithThinking("middle answer", "mid thinking"),
+      // msg 2
+      {
+        role: "user",
+        content: "q2"
+      },
+      // msg 3
+      assistantWithThinking("recent1", "recent-think-1"),
+      // msg 4
+      {
+        role: "user",
+        content: "q3"
+      },
+      // msg 5
+      assistantWithThinking("recent2", "recent-think-2"),
+      // msg 6
+      {
+        role: "user",
+        content: "q4"
+      } // msg 7
+      ];
+      // 8 messages: cutoff = max(0, 8-6) = 2. Messages 0-1 are in "old" zone.
+      const {
+        messages,
+        bytesRemoved
+      } = preCompact(msgs);
+
+      // msg 0 (assistant) — thinking should be stripped
+      const msg0Content = messages[0].content;
+      expect(msg0Content.some(b => b.type === "thinking")).toBe(false);
+      expect(msg0Content.some(b => b.type === "text")).toBe(true);
+
+      // msg 2 (assistant at idx >= cutoff=2) — thinking preserved
+      const msg2Content = messages[2].content;
+      expect(msg2Content.some(b => b.type === "thinking")).toBe(true);
+      expect(bytesRemoved).toBeGreaterThan(0);
+    });
+    it("preserves thinking blocks when stripThinking is false", () => {
+      const msgs = [assistantWithThinking("old", "think-old"), {
+        role: "user",
+        content: "q"
+      }, assistantWithThinking("new", "think-new"), {
+        role: "user",
+        content: "q2"
+      }, assistantWithThinking("newest", "think-newest"), {
+        role: "user",
+        content: "q3"
+      }, assistantWithThinking("end", "think-end"), {
+        role: "user",
+        content: "q4"
+      }];
+      const {
+        messages,
+        bytesRemoved
+      } = preCompact(msgs, {
+        stripThinking: false
+      });
+      // All thinking blocks should be preserved
+      for (const msg of messages) {
+        if (msg.role === "assistant" && Array.isArray(msg.content)) {
+          const hasThinking = msg.content.some(b => b.type === "thinking");
+          expect(hasThinking).toBe(true);
+        }
+      }
+      // bytesRemoved might still be >0 from other passes, but thinking not counted
+    });
+    it("preserves assistant message even if all content is thinking (no empty messages)", () => {
+      const msgs = [{
+        role: "assistant",
+        content: [{
+          type: "thinking",
+          thinking: "only thinking",
+          signature: "sig"
+        }]
+      }, {
+        role: "user",
+        content: "q"
+      }, assistantMsg("recent1"), {
+        role: "user",
+        content: "q2"
+      }, assistantMsg("recent2"), {
+        role: "user",
+        content: "q3"
+      }, assistantMsg("recent3"), {
+        role: "user",
+        content: "q4"
+      }];
+      const {
+        messages
+      } = preCompact(msgs);
+      // msg 0 is in the old zone (cutoff = 2), but has only thinking
+      // Should keep the message as-is (the `filtered.length === 0` guard)
+      expect(messages[0].content).toBeTruthy();
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // Combined scenarios (real-world patterns)
+  // --------------------------------------------------------------------------
+  describe("combined scenarios", () => {
+    it("handles a realistic 5-turn subagent conversation", () => {
+      const fileContent = bigStr(10000); // Large file read
+      const msgs = [
+      // Turn 1: glob + read
+      {
+        role: "user",
+        content: [{
+          type: "tool_result",
+          tool_use_id: "glob-1",
+          content: JSON.stringify(["a.ts", "b.ts"])
+        }, {
+          type: "tool_result",
+          tool_use_id: "read-1",
+          content: fileContent
+        }]
+      }, assistantWithThinking("Found the file", "Let me analyze..."),
+      // Turn 2: grep
+      {
+        role: "user",
+        content: [{
+          type: "tool_result",
+          tool_use_id: "grep-1",
+          content: bigStr(3000)
+        }]
+      }, assistantWithThinking("Found matches", "Grep found..."),
+      // Turn 3: read same file again (duplicate)
+      {
+        role: "user",
+        content: [{
+          type: "tool_result",
+          tool_use_id: "read-2",
+          content: fileContent
+        }]
+      }, assistantMsg("Checking again..."),
+      // Turn 4: edit
+      {
+        role: "user",
+        content: [{
+          type: "tool_result",
+          tool_use_id: "edit-1",
+          content: "File edited successfully"
+        }]
+      }, assistantMsg("Done")];
+      const {
+        messages,
+        bytesRemoved
+      } = preCompact(msgs);
+
+      // Large file read in turn 1 should be trimmed (has followup)
+      const turn1 = messages[0].content;
+      const readBlock = turn1.find(b => b.tool_use_id === "read-1");
+      expect(readBlock.content).toContain("[Tool result:");
+
+      // Duplicate file read in turn 3 should show "Duplicate"
+      const turn3 = messages[4].content;
+      // It was already trimmed (>2048) AND is a duplicate — trimming happens first
+      expect(turn3[0].content).toContain("[Tool result:");
+
+      // Old thinking (turn 1, msg idx 1) should be stripped
+      // cutoff = max(0, 8 - 6) = 2. Msg 1 is at idx 1 < 2.
+      const turn1Assistant = messages[1].content;
+      expect(turn1Assistant.some(b => b.type === "thinking")).toBe(false);
+
+      // Recent thinking (turn 2, msg idx 3) should be preserved (idx 3 >= cutoff 2)
+      const turn2Assistant = messages[3].content;
+      expect(turn2Assistant.some(b => b.type === "thinking")).toBe(true);
+
+      // Small edit result should be untouched
+      const turn4 = messages[6].content;
+      expect(turn4[0].content).toBe("File edited successfully");
+
+      // Should have removed significant bytes
+      expect(bytesRemoved).toBeGreaterThan(10000);
+    });
+    it("stress test: 20 turns with mixed large/small results", () => {
+      const msgs = [];
+      for (let i = 0; i < 20; i++) {
+        msgs.push({
+          role: "user",
+          content: [{
+            type: "tool_result",
+            tool_use_id: `t${i}`,
+            content: i % 3 === 0 ? bigStr(5000) : bigStr(100)
+          }]
+        });
+        msgs.push(assistantMsg(`Turn ${i} done`));
+      }
+      const {
+        messages,
+        bytesRemoved
+      } = preCompact(msgs);
+      expect(messages).toHaveLength(40);
+      expect(bytesRemoved).toBeGreaterThan(0);
+
+      // All large results (except possibly the very last) should be trimmed
+      for (let i = 0; i < 19; i++) {
+        if (i % 3 === 0) {
+          const block = messages[i * 2].content[0];
+          expect(block.content).toContain("[Tool result:");
+        }
+      }
+    });
+  });
+
+  // --------------------------------------------------------------------------
+  // bytesRemoved accuracy
+  // --------------------------------------------------------------------------
+  describe("bytesRemoved tracking", () => {
+    it("accurately tracks bytes removed from large tool results", () => {
+      const size = 5000;
+      const msgs = [toolResultMsg("t1", bigStr(size)), assistantMsg("ok")];
+      const {
+        bytesRemoved
+      } = preCompact(msgs);
+      // Should be approximately size - 100 (the placeholder is ~100 chars shorter)
+      expect(bytesRemoved).toBe(size - 100);
+    });
+    it("accumulates bytes from multiple sources", () => {
+      const msgs = [toolResultMsg("t1", bigStr(3000)),
+      // trimmed: ~2900 removed
+      assistantWithThinking("old", bigStr(500)),
+      // thinking stripped: 500 removed
+      toolResultMsg("t2", bigStr(4000)),
+      // trimmed: ~3900 removed
+      assistantMsg("mid"), assistantMsg("recent1"), {
+        role: "user",
+        content: "q"
+      }, assistantMsg("recent2"), {
+        role: "user",
+        content: "q2"
+      }];
+      const {
+        bytesRemoved
+      } = preCompact(msgs);
+      // Should include both tool result trimming and thinking stripping
+      expect(bytesRemoved).toBeGreaterThan(5000);
+    });
+  });
+});