whale-code 6.5.11 → 6.6.0

package/dist/cli/services/__tests__/subagent-edge.test.js

@@ -1,545 +0,0 @@
-/**
- * Tests for subagent.ts — context compaction, cache tokens, taskContext, retries, stop conditions, continuation
- */
-
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-// ============================================================================
-// MOCKS
-// ============================================================================
-
-vi.mock("fs", () => ({
-  existsSync: vi.fn(),
-  readFileSync: vi.fn(),
-  writeFileSync: vi.fn(),
-  mkdirSync: vi.fn(),
-  appendFileSync: vi.fn()
-}));
-vi.mock("os", () => ({
-  homedir: vi.fn(() => "/mock-home"),
-  tmpdir: vi.fn(() => "/mock-tmp")
-}));
-vi.mock("../local-tools.js", () => ({
-  LOCAL_TOOL_DEFINITIONS: [{
-    name: "read_file",
-    description: "Read a file",
-    input_schema: {
-      type: "object",
-      properties: {}
-    }
-  }, {
-    name: "glob",
-    description: "Find files",
-    input_schema: {
-      type: "object",
-      properties: {}
-    }
-  }, {
-    name: "grep",
-    description: "Search files",
-    input_schema: {
-      type: "object",
-      properties: {}
-    }
-  }, {
-    name: "write_file",
-    description: "Write a file",
-    input_schema: {
-      type: "object",
-      properties: {}
-    }
-  }, {
-    name: "list_directory",
-    description: "List directory",
-    input_schema: {
-      type: "object",
-      properties: {}
-    }
-  }, {
-    name: "run_command",
-    description: "Run command",
-    input_schema: {
-      type: "object",
-      properties: {}
-    }
-  }, {
-    name: "edit_file",
-    description: "Edit a file",
-    input_schema: {
-      type: "object",
-      properties: {}
-    }
-  }, {
-    name: "search_files",
-    description: "Search files",
-    input_schema: {
-      type: "object",
-      properties: {}
-    }
-  }, {
-    name: "search_content",
-    description: "Search content",
-    input_schema: {
-      type: "object",
-      properties: {}
-    }
-  }, {
-    name: "web_fetch",
-    description: "Fetch web content",
-    input_schema: {
-      type: "object",
-      properties: {}
-    }
-  }, {
-    name: "notebook_edit",
-    description: "Edit notebook",
-    input_schema: {
-      type: "object",
-      properties: {}
-    }
-  }, {
-    name: "tasks",
-    description: "Manage tasks",
-    input_schema: {
-      type: "object",
-      properties: {}
-    }
-  }]
-}));
-vi.mock("../../../shared/compaction.js", () => ({
-  preCompact: vi.fn(messages => ({
-    messages,
-    bytesRemoved: 0
-  }))
-}));
-vi.mock("../../../shared/agent-core.js", () => {
-  class MockLoopDetector {
-    check = vi.fn(() => ({
-      blocked: false
-    }));
-    record = vi.fn();
-  }
-  return {
-    LoopDetector: MockLoopDetector,
-    estimateCostUsd: vi.fn(() => 0.005),
-    AGENT_DEFAULTS: {
-      maxTurns: 200,
-      temperature: 1.0,
-      maxConcurrentTools: 7,
-      enableDelegation: true,
-      maxDurationMs: 900_000,
-      maxDurationMsWorkflow: 120_000,
-      enableModelRouting: true,
-      subagentMaxTokens: 32000,
-      subagentMaxTurns: 25,
-      subagentTemperature: 1.0,
-      subagentMaxRetries: 3,
-      maxContinuations: 10,
-      subagentMaxContinuations: 5,
-      maxMessageChars: 100_000,
-      maxHistoryChars: 400_000,
-      maxToolResultChars: 2048,
-      compactionTriggerTokens: 167_000,
-      compactionTotalBudget: 2_000_000,
-      sessionCostBudgetUsd: 25.00,
-      teammateMaxTotalTurns: 50,
-      teamTimeoutMs: 600_000,
-      workerStallMs: 180_000,
-      teamReviewMaxTokens: 1024,
-      apiTimeoutMs: 90_000,
-      toolTimeoutMs: 60_000,
-      toolResultTruncateChars: 500_000
-    },
-    resolveAgentLoopConfig: vi.fn(() => ({
-      maxTurns: 200,
-      temperature: 1.0,
-      maxTokens: 32000,
-      maxConcurrentTools: 7,
-      enableDelegation: true,
-      maxDurationMs: 900_000,
-      enableModelRouting: true,
-      maxMessageChars: 100_000,
-      maxHistoryChars: 400_000,
-      contextOverrides: {},
-      subagentMaxTokens: 32000,
-      subagentMaxTurns: 25,
-      subagentTemperature: 1.0,
-      maxContinuations: 10,
-      subagentMaxContinuations: 5,
-      subagentMaxRetries: 3,
-      maxToolResultChars: 2048,
-      defaultsUsed: []
-    })),
-    demoteSubagentModel: vi.fn(() => "haiku")
-  };
-});
-vi.mock("../agent-config.js", () => ({
-  loadCLIAgentConfig: vi.fn(async () => null),
-  resetAgentConfigCache: vi.fn()
-}));
-vi.mock("../../../shared/constants.js", () => ({
-  MODEL_MAP: {
-    opus: "claude-opus-4-6",
-    sonnet: "claude-sonnet-4-6",
-    haiku: "claude-haiku-4-5-20251001"
-  }
-}));
-vi.mock("../server-tools.js", () => ({
-  loadServerToolDefinitions: vi.fn(async () => [])
-}));
-vi.mock("../telemetry.js", () => ({
-  logSpan: vi.fn(),
-  generateSpanId: vi.fn(() => "span-abc"),
-  generateTraceId: vi.fn(() => "trace-abc"),
-  PKG_VERSION: "0.0.0-test"
-}));
-const mockLoadClaudeMd = vi.fn();
-vi.mock("../agent-loop.js", () => ({
-  loadClaudeMd: (...args) => mockLoadClaudeMd(...args),
-  getModel: vi.fn(() => "claude-sonnet-4-6")
-}));
-const mockEmitter = {
-  emitSubagentStart: vi.fn(),
-  emitSubagentProgress: vi.fn(),
-  emitSubagentDone: vi.fn(),
-  emitSubagentToolStart: vi.fn(),
-  emitSubagentToolEnd: vi.fn()
-};
-vi.mock("../agent-events.js", () => ({
-  getGlobalEmitter: vi.fn(() => mockEmitter)
-}));
-vi.mock("../agent-definitions.js", () => ({
-  getAgentDefinition: vi.fn(() => undefined)
-}));
-const mockCallAgentAPI = vi.fn();
-const mockExecuteToolBlocks = vi.fn();
-const mockExtractTextBlocks = vi.fn();
-const mockExtractToolUseBlocks = vi.fn();
-const mockGetResponseText = vi.fn();
-vi.mock("../agent-worker-base.js", () => ({
-  callAgentAPI: (...args) => mockCallAgentAPI(...args),
-  executeToolBlocks: (...args) => mockExecuteToolBlocks(...args),
-  extractTextBlocks: (...args) => mockExtractTextBlocks(...args),
-  extractToolUseBlocks: (...args) => mockExtractToolUseBlocks(...args),
-  getResponseText: (...args) => mockGetResponseText(...args),
-  yieldToEventLoop: vi.fn(async () => {}),
-  yieldForRender: vi.fn(async () => {}),
-  deduplicateTools: vi.fn(tools => tools),
-  assertUniqueToolNames: vi.fn()
-}));
-vi.mock("../background-processes.js", () => ({
-  registerBackgroundAgent: vi.fn(),
-  markAgentDone: vi.fn()
-}));
-import { runSubagent } from "../subagent.js";
-import { existsSync, writeFileSync } from "fs";
-vi.mocked(existsSync).mockReturnValue(false);
-vi.mocked(writeFileSync).mockImplementation(() => {});
-function makeAPIResponse(text, toolUse = false) {
-  const content = [{
-    type: "text",
-    text
-  }];
-  if (toolUse) content.push({
-    type: "tool_use",
-    id: "tool-1",
-    name: "read_file",
-    input: {
-      path: "test.ts"
-    }
-  });
-  return {
-    content,
-    usage: {
-      input_tokens: 100,
-      output_tokens: 50,
-      cache_read_tokens: 0,
-      cache_creation_tokens: 0
-    },
-    stop_reason: toolUse ? "tool_use" : "end_turn"
-  };
-}
-beforeEach(() => {
-  vi.clearAllMocks();
-  vi.mocked(existsSync).mockReturnValue(false);
-  vi.mocked(writeFileSync).mockImplementation(() => {});
-  mockLoadClaudeMd.mockReturnValue(null);
-  mockExtractTextBlocks.mockReturnValue([]);
-  mockExtractToolUseBlocks.mockReturnValue([]);
-  mockGetResponseText.mockReturnValue("");
-  mockExecuteToolBlocks.mockResolvedValue({
-    toolResults: [],
-    toolsUsed: []
-  });
-});
-describe("subagent — edge cases", () => {
-  describe("runSubagent — context compaction", () => {
-    it("should call preCompact after tool execution", async () => {
-      const {
-        preCompact: mockPreCompact
-      } = await import("../../../shared/compaction.js");
-      mockCallAgentAPI.mockResolvedValueOnce(makeAPIResponse("Using tool", true)).mockResolvedValueOnce(makeAPIResponse("Done."));
-      mockExtractTextBlocks.mockReturnValueOnce([]).mockReturnValueOnce([{
-        type: "text",
-        text: "Done."
-      }]);
-      mockExtractToolUseBlocks.mockReturnValueOnce([{
-        type: "tool_use",
-        id: "t1",
-        name: "read_file",
-        input: {}
-      }]).mockReturnValueOnce([]);
-      mockGetResponseText.mockReturnValue("Done.");
-      mockExecuteToolBlocks.mockResolvedValue({
-        toolResults: [{
-          type: "tool_result",
-          tool_use_id: "t1",
-          content: "big file contents"
-        }],
-        toolsUsed: ["read_file"]
-      });
-      await runSubagent({
-        prompt: "Read and analyze",
-        subagent_type: "explore"
-      });
-      expect(mockPreCompact).toHaveBeenCalledTimes(1);
-    });
-    it("should NOT call preCompact when there are no tool calls", async () => {
-      const {
-        preCompact: mockPreCompact
-      } = await import("../../../shared/compaction.js");
-      vi.mocked(mockPreCompact).mockClear();
-      mockCallAgentAPI.mockResolvedValue(makeAPIResponse("Direct answer."));
-      mockExtractTextBlocks.mockReturnValue([{
-        type: "text",
-        text: "Direct answer."
-      }]);
-      mockExtractToolUseBlocks.mockReturnValue([]);
-      mockGetResponseText.mockReturnValue("Direct answer.");
-      await runSubagent({
-        prompt: "Simple question",
-        subagent_type: "explore"
-      });
-      expect(mockPreCompact).not.toHaveBeenCalled();
-    });
-  });
-  describe("runSubagent — cache token tracking", () => {
-    it("should accumulate cache tokens across turns", async () => {
-      mockCallAgentAPI.mockResolvedValueOnce({
-        content: [{
-          type: "text",
-          text: "Using tool"
-        }, {
-          type: "tool_use",
-          id: "t1",
-          name: "glob",
-          input: {}
-        }],
-        usage: {
-          input_tokens: 200,
-          output_tokens: 100,
-          cache_read_tokens: 150,
-          cache_creation_tokens: 50
-        },
-        stop_reason: "tool_use"
-      }).mockResolvedValueOnce({
-        content: [{
-          type: "text",
-          text: "Done"
-        }],
-        usage: {
-          input_tokens: 300,
-          output_tokens: 80,
-          cache_read_tokens: 250,
-          cache_creation_tokens: 0
-        },
-        stop_reason: "end_turn"
-      });
-      mockExtractTextBlocks.mockReturnValueOnce([]).mockReturnValueOnce([{
-        type: "text",
-        text: "Done"
-      }]);
-      mockExtractToolUseBlocks.mockReturnValueOnce([{
-        type: "tool_use",
-        id: "t1",
-        name: "glob",
-        input: {}
-      }]).mockReturnValueOnce([]);
-      mockGetResponseText.mockReturnValue("Done");
-      mockExecuteToolBlocks.mockResolvedValue({
-        toolResults: [{
-          type: "tool_result",
-          tool_use_id: "t1",
-          content: "ok"
-        }],
-        toolsUsed: ["glob"]
-      });
-      const result = await runSubagent({
-        prompt: "Find files",
-        subagent_type: "explore"
-      });
-      expect(result.tokensUsed.input).toBe(500);
-      expect(result.tokensUsed.output).toBe(180);
-    });
-  });
-  describe("runSubagent — taskContext dedup", () => {
-    it("should include taskContext in system prompt", async () => {
-      mockCallAgentAPI.mockResolvedValue(makeAPIResponse("Done"));
-      mockExtractTextBlocks.mockReturnValue([{
-        type: "text",
-        text: "Done"
-      }]);
-      mockGetResponseText.mockReturnValue("Done");
-      await runSubagent({
-        prompt: "Research topic A",
-        subagent_type: "research",
-        taskContext: "Other agents: Agent-1 researching topic B, Agent-2 researching topic C"
-      });
-      const opts = mockCallAgentAPI.mock.calls[0][0];
-      expect(opts.systemPrompt).toContain("Other agents:");
-      expect(opts.systemPrompt).toContain("Do NOT duplicate research");
-    });
-  });
-  describe("runSubagent — configurable retries", () => {
-    it("should retry up to maxRetries (default 3) times on retryable errors", async () => {
-      mockCallAgentAPI.mockRejectedValue(Object.assign(new Error("Rate limited"), {
-        status: 429
-      }));
-      const result = await runSubagent({
-        prompt: "Test",
-        subagent_type: "explore"
-      });
-      expect(result.success).toBe(false);
-      expect(mockCallAgentAPI).toHaveBeenCalledTimes(3);
-    });
-    it("should succeed after transient failure and resume normally", async () => {
-      mockCallAgentAPI.mockRejectedValueOnce(Object.assign(new Error("Server error"), {
-        status: 500
-      })).mockResolvedValueOnce(makeAPIResponse("Recovered"));
-      mockExtractTextBlocks.mockReturnValue([{
-        type: "text",
-        text: "Recovered"
-      }]);
-      mockExtractToolUseBlocks.mockReturnValue([]);
-      mockGetResponseText.mockReturnValue("Recovered");
-      const result = await runSubagent({
-        prompt: "Test",
-        subagent_type: "explore"
-      });
-      expect(result.success).toBe(true);
-      expect(result.output).toBe("Recovered");
-    });
-  });
-  describe("runSubagent — stop conditions", () => {
-    it("should stop when stop_reason is end_turn even if tool blocks exist", async () => {
-      mockCallAgentAPI.mockResolvedValue({
-        content: [{
-          type: "text",
-          text: "Here's the answer"
-        }, {
-          type: "tool_use",
-          id: "t1",
-          name: "glob",
-          input: {}
-        }],
-        usage: {
-          input_tokens: 100,
-          output_tokens: 50,
-          cache_read_tokens: 0,
-          cache_creation_tokens: 0
-        },
-        stop_reason: "end_turn"
-      });
-      mockExtractTextBlocks.mockReturnValue([{
-        type: "text",
-        text: "Here's the answer"
-      }]);
-      mockExtractToolUseBlocks.mockReturnValue([{
-        type: "tool_use",
-        id: "t1",
-        name: "glob",
-        input: {}
-      }]);
-      mockGetResponseText.mockReturnValue("Here's the answer");
-      const result = await runSubagent({
-        prompt: "Test",
-        subagent_type: "explore"
-      });
-      expect(mockCallAgentAPI).toHaveBeenCalledTimes(1);
-      expect(result.success).toBe(true);
-    });
-  });
-  describe("runSubagent — max_tokens continuation", () => {
-    it("should continue once on max_tokens then finish on end_turn", async () => {
-      let callCount = 0;
-      mockCallAgentAPI.mockImplementation(async () => {
-        callCount++;
-        if (callCount === 1) return {
-          content: [{
-            type: "text",
-            text: "Partial..."
-          }],
-          usage: {
-            input_tokens: 100,
-            output_tokens: 50,
-            cache_read_tokens: 0,
-            cache_creation_tokens: 0
-          },
-          stop_reason: "max_tokens"
-        };
-        return {
-          content: [{
-            type: "text",
-            text: "...finished."
-          }],
-          usage: {
-            input_tokens: 200,
-            output_tokens: 60,
-            cache_read_tokens: 0,
-            cache_creation_tokens: 0
-          },
-          stop_reason: "end_turn"
-        };
-      });
-      mockExtractTextBlocks.mockReturnValue([{
-        type: "text",
-        text: "text"
-      }]);
-      mockExtractToolUseBlocks.mockReturnValue([]);
-      mockGetResponseText.mockReturnValue("...finished.");
-      const result = await runSubagent({
-        prompt: "Write long text",
-        subagent_type: "code"
-      });
-      expect(mockCallAgentAPI).toHaveBeenCalledTimes(2);
-      expect(result.success).toBe(true);
-    });
-    it("should stop after subagentMaxContinuations even if always truncated", async () => {
-      mockCallAgentAPI.mockImplementation(async () => ({
-        content: [{
-          type: "text",
-          text: "Still generating..."
-        }],
-        usage: {
-          input_tokens: 100,
-          output_tokens: 50,
-          cache_read_tokens: 0,
-          cache_creation_tokens: 0
-        },
-        stop_reason: "max_tokens"
-      }));
-      mockExtractTextBlocks.mockReturnValue([{
-        type: "text",
-        text: "text"
-      }]);
-      mockExtractToolUseBlocks.mockReturnValue([]);
-      mockGetResponseText.mockReturnValue("Still generating...");
-      const result = await runSubagent({
-        prompt: "Generate huge output",
-        subagent_type: "code"
-      });
-      expect(mockCallAgentAPI).toHaveBeenCalledTimes(6);
-      expect(result.success).toBe(true);
-    });
-  });
-});