whale-code 6.5.5 → 6.5.7

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

@@ -0,0 +1,489 @@
+/**
+ * Tests for subagent.ts — TASK_TOOL_DEFINITION, basic execution, tool execution, error handling
+ */
+
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// ============================================================================
+// MOCKS — must be defined before any imports from the module under test
+// ============================================================================
+
+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,
+      teammateMaxTotalTurns: 50,
+      teamTimeoutMs: 600_000,
+      workerStallMs: 180_000,
+      teamReviewMaxTokens: 1024,
+      apiTimeoutMs: 90_000,
+      toolTimeoutMs: 60_000,
+      toolResultTruncateChars: 500_000,
+      defaultsUsed: []
+    })),
+    demoteSubagentModel: vi.fn((requested, agentType) => {
+      if (agentType === "explore" || agentType === "research") return "haiku";
+      if (agentType === "general-purpose" || agentType === "plan") {
+        if (requested === "opus") return "opus";
+        if (requested === "sonnet") return "sonnet";
+        return "sonnet";
+      }
+      if (!requested) return "haiku";
+      return requested === "opus" ? "sonnet" : requested === "sonnet" ? "sonnet" : "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"
+  }
+}));
+const mockLoadServerToolDefinitions = vi.fn(async () => []);
+vi.mock("../server-tools.js", () => ({
+  loadServerToolDefinitions: (...args) => mockLoadServerToolDefinitions(...args)
+}));
+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();
+const mockGetModel = vi.fn(() => "claude-sonnet-4-6");
+vi.mock("../agent-loop.js", () => ({
+  loadClaudeMd: (...args) => mockLoadClaudeMd(...args),
+  getModel: (...args) => mockGetModel(...args)
+}));
+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)
+}));
+const mockGetAgentDefinition = vi.fn(() => undefined);
+vi.mock("../agent-definitions.js", () => ({
+  getAgentDefinition: (...args) => mockGetAgentDefinition(...args)
+}));
+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, TASK_TOOL_DEFINITION } from "../subagent.js";
+import { existsSync, writeFileSync } from "fs";
+const mockExistsSync = vi.mocked(existsSync);
+const mockWriteFileSync = vi.mocked(writeFileSync);
+
+// ============================================================================
+// HELPERS
+// ============================================================================
+
+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"
+  };
+}
+
+// ============================================================================
+// TESTS
+// ============================================================================
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mockExistsSync.mockReturnValue(false);
+  mockWriteFileSync.mockImplementation(() => {});
+  mockLoadClaudeMd.mockReturnValue(null);
+  mockExtractTextBlocks.mockReturnValue([]);
+  mockExtractToolUseBlocks.mockReturnValue([]);
+  mockGetResponseText.mockReturnValue("");
+  mockExecuteToolBlocks.mockResolvedValue({
+    toolResults: [],
+    toolsUsed: []
+  });
+});
+describe("subagent — basic", () => {
+  describe("TASK_TOOL_DEFINITION", () => {
+    it("should define the task tool with correct name", () => {
+      expect(TASK_TOOL_DEFINITION.name).toBe("task");
+    });
+    it("should have a description", () => {
+      expect(TASK_TOOL_DEFINITION.description).toBeTruthy();
+      expect(TASK_TOOL_DEFINITION.description.length).toBeGreaterThan(10);
+    });
+    it("should require prompt and subagent_type", () => {
+      const schema = TASK_TOOL_DEFINITION.input_schema;
+      expect(schema.required).toContain("prompt");
+      expect(schema.required).toContain("subagent_type");
+    });
+    it("should define subagent_type enum with all builtin types", () => {
+      const schema = TASK_TOOL_DEFINITION.input_schema;
+      const subtypes = schema.properties.subagent_type.enum;
+      expect(subtypes).toContain("explore");
+      expect(subtypes).toContain("plan");
+      expect(subtypes).toContain("general-purpose");
+      expect(subtypes).toContain("research");
+    });
+    it("should define optional model enum (no opus)", () => {
+      const schema = TASK_TOOL_DEFINITION.input_schema;
+      const models = schema.properties.model.enum;
+      expect(models).toContain("sonnet");
+      expect(models).toContain("haiku");
+      expect(models).not.toContain("opus");
+    });
+    it("should define optional resume field", () => {
+      const schema = TASK_TOOL_DEFINITION.input_schema;
+      expect(schema.properties.resume).toBeDefined();
+      expect(schema.properties.resume.type).toBe("string");
+    });
+  });
+  describe("runSubagent — basic execution", () => {
+    it("should return successful result with text output", async () => {
+      mockCallAgentAPI.mockResolvedValue(makeAPIResponse("Here is the answer."));
+      mockExtractTextBlocks.mockReturnValue([{
+        type: "text",
+        text: "Here is the answer."
+      }]);
+      mockExtractToolUseBlocks.mockReturnValue([]);
+      mockGetResponseText.mockReturnValue("Here is the answer.");
+      const result = await runSubagent({
+        prompt: "Find the main function",
+        subagent_type: "explore"
+      });
+      expect(result.success).toBe(true);
+      expect(result.output).toBe("Here is the answer.");
+      expect(result.agentId).toMatch(/^agent-/);
+    });
+    it("should track tokens used", async () => {
+      mockCallAgentAPI.mockResolvedValue(makeAPIResponse("Done"));
+      mockExtractTextBlocks.mockReturnValue([{
+        type: "text",
+        text: "Done"
+      }]);
+      mockGetResponseText.mockReturnValue("Done");
+      const result = await runSubagent({
+        prompt: "Test",
+        subagent_type: "explore"
+      });
+      expect(result.tokensUsed.input).toBe(100);
+      expect(result.tokensUsed.output).toBe(50);
+    });
+    it("should use specified model", async () => {
+      mockCallAgentAPI.mockResolvedValue(makeAPIResponse("Done"));
+      mockExtractTextBlocks.mockReturnValue([{
+        type: "text",
+        text: "Done"
+      }]);
+      mockGetResponseText.mockReturnValue("Done");
+      await runSubagent({
+        prompt: "Test",
+        subagent_type: "explore",
+        model: "haiku"
+      });
+      const opts = mockCallAgentAPI.mock.calls[0][0];
+      expect(opts.modelId).toBe("claude-haiku-4-5-20251001");
+    });
+    it("should return (No output from agent) when no text generated", async () => {
+      mockCallAgentAPI.mockResolvedValue(makeAPIResponse(""));
+      mockExtractTextBlocks.mockReturnValue([]);
+      mockGetResponseText.mockReturnValue("");
+      const result = await runSubagent({
+        prompt: "Test",
+        subagent_type: "explore"
+      });
+      expect(result.output).toBe("(No output from agent)");
+    });
+  });
+  describe("runSubagent — tool execution", () => {
+    it("should execute tools and continue loop", async () => {
+      mockCallAgentAPI.mockResolvedValueOnce(makeAPIResponse("Let me check...", true)).mockResolvedValueOnce(makeAPIResponse("Found it."));
+      mockExtractTextBlocks.mockReturnValueOnce([{
+        type: "text",
+        text: "Let me check..."
+      }]).mockReturnValueOnce([{
+        type: "text",
+        text: "Found it."
+      }]);
+      mockExtractToolUseBlocks.mockReturnValueOnce([{
+        type: "tool_use",
+        id: "t1",
+        name: "read_file",
+        input: {}
+      }]).mockReturnValueOnce([]);
+      mockGetResponseText.mockReturnValueOnce("Let me check...").mockReturnValueOnce("Found it.");
+      mockExecuteToolBlocks.mockResolvedValue({
+        toolResults: [{
+          type: "tool_result",
+          tool_use_id: "t1",
+          content: "file contents"
+        }],
+        toolsUsed: ["read_file"]
+      });
+      const result = await runSubagent({
+        prompt: "Read test.ts",
+        subagent_type: "explore"
+      });
+      expect(result.success).toBe(true);
+      expect(mockCallAgentAPI).toHaveBeenCalledTimes(2);
+    });
+  });
+  describe("runSubagent — error handling", () => {
+    it("should return error result on API failure", async () => {
+      mockCallAgentAPI.mockRejectedValue(new Error("API down"));
+      const result = await runSubagent({
+        prompt: "Test",
+        subagent_type: "explore"
+      });
+      expect(result.success).toBe(false);
+      expect(result.output).toContain("API down");
+    });
+    it("should retry on 429 rate limit errors", async () => {
+      const err429 = Object.assign(new Error("Rate limited"), {
+        status: 429
+      });
+      mockCallAgentAPI.mockRejectedValueOnce(err429).mockResolvedValueOnce(makeAPIResponse("Recovered"));
+      mockExtractTextBlocks.mockReturnValue([{
+        type: "text",
+        text: "Recovered"
+      }]);
+      mockGetResponseText.mockReturnValue("Recovered");
+      const result = await runSubagent({
+        prompt: "Test",
+        subagent_type: "explore"
+      });
+      expect(result.success).toBe(true);
+      expect(mockCallAgentAPI).toHaveBeenCalledTimes(2);
+    });
+    it("should not retry on non-retryable errors", async () => {
+      const err400 = Object.assign(new Error("Bad request"), {
+        status: 400
+      });
+      mockCallAgentAPI.mockRejectedValue(err400);
+      const result = await runSubagent({
+        prompt: "Test",
+        subagent_type: "explore"
+      });
+      expect(result.success).toBe(false);
+      expect(mockCallAgentAPI).toHaveBeenCalledTimes(1);
+    });
+    it("should fail after 3 retry attempts", async () => {
+      const err429 = Object.assign(new Error("Rate limited"), {
+        status: 429
+      });
+      mockCallAgentAPI.mockRejectedValue(err429);
+      const result = await runSubagent({
+        prompt: "Test",
+        subagent_type: "explore"
+      });
+      expect(result.success).toBe(false);
+      expect(mockCallAgentAPI).toHaveBeenCalledTimes(3);
+    });
+    it("should emit done event on error", async () => {
+      mockCallAgentAPI.mockRejectedValue(new Error("Fail"));
+      await runSubagent({
+        prompt: "Test",
+        subagent_type: "explore"
+      });
+      expect(mockEmitter.emitSubagentDone).toHaveBeenCalledWith(expect.any(String), "explore", false, expect.stringContaining("Fail"), expect.any(Object), expect.any(Array), expect.any(Number));
+    });
+  });
+});