whale-code 6.5.11 → 6.6.0

package/dist/server/lib/__tests__/server-agent-loop-features-edges.test.js

@@ -1,512 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-// ============================================================================
-// Mocks — must be declared before imports
-// ============================================================================
-
-vi.mock("../../../shared/agent-core.js", () => {
-  class MockLoopDetector {
-    resetTurn = vi.fn();
-    getSessionStats = vi.fn(() => ({
-      totalErrors: 0,
-      failedStrategies: 0,
-      consecutiveFailedTurns: 0
-    }));
-  }
-  return {
-    LoopDetector: MockLoopDetector,
-    getContextManagement: vi.fn(() => ({
-      betas: ["context-management-2025-06-27"],
-      config: {
-        edits: []
-      }
-    })),
-    getMaxOutputTokens: vi.fn(() => 16384),
-    getThinkingConfig: vi.fn(() => ({
-      thinking: {
-        type: "disabled"
-      },
-      beta: null
-    })),
-    addPromptCaching: vi.fn((tools, msgs) => ({
-      tools,
-      messages: msgs
-    })),
-    estimateCostUsd: vi.fn(() => 0.001),
-    isRetryableError: vi.fn(() => false),
-    sanitizeError: err => err instanceof Error ? err.message : String(err),
-    routeModel: vi.fn((text, model) => model),
-    resolveToolChoice: vi.fn(() => "auto"),
-    COMPACTION_TRIGGER_TOKENS: 167_000,
-    COMPACTION_TOTAL_BUDGET: 2_000_000,
-    DEFAULT_SESSION_COST_BUDGET_USD: 25,
-    emitCostWarningIfNeeded: vi.fn(),
-    demoteSubagentModel: vi.fn(() => "haiku"),
-    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
-    }
-  };
-});
-vi.mock("../../../shared/sse-parser.js", () => ({
-  processStreamWithCallbacks: vi.fn(async () => ({
-    text: "Test response",
-    toolUseBlocks: [],
-    thinkingBlocks: [],
-    thinkingTokens: 0,
-    citations: [],
-    usage: {
-      inputTokens: 100,
-      outputTokens: 50,
-      cacheCreationTokens: 0,
-      cacheReadTokens: 0
-    },
-    compactionContent: null,
-    contextManagementApplied: false,
-    stopReason: "end_turn"
-  }))
-}));
-vi.mock("../../../shared/constants.js", () => ({
-  MODELS: {
-    HAIKU: "claude-haiku-4-5-20251001",
-    SONNET: "claude-sonnet-4-6",
-    OPUS: "claude-opus-4-6"
-  },
-  getProvider: vi.fn(() => "anthropic")
-}));
-vi.mock("../../../shared/tool-dispatch.js", () => ({
-  dispatchTools: vi.fn(async (blocks, executor, _opts) => {
-    const results = [];
-    for (const block of blocks) {
-      const res = await executor(block.name, block.input);
-      results.push({
-        type: "tool_result",
-        tool_use_id: block.id,
-        content: res.output,
-        is_error: !res.success
-      });
-    }
-    return {
-      results,
-      bailOut: false,
-      bailMessage: undefined
-    };
-  }),
-  buildAssistantContent: vi.fn(({
-    text,
-    toolUseBlocks
-  }) => {
-    const blocks = [];
-    if (text) blocks.push({
-      type: "text",
-      text
-    });
-    if (toolUseBlocks) for (const t of toolUseBlocks) blocks.push({
-      type: "tool_use",
-      id: t.id,
-      name: t.name,
-      input: t.input
-    });
-    return blocks;
-  })
-}));
-vi.mock("../../tool-router.js", () => ({
-  getCachedToolDefs: vi.fn(tools => tools.map(t => ({
-    name: t.name,
-    description: t.description,
-    input_schema: t.input_schema
-  }))),
-  getFullToolSchemas: vi.fn(() => [])
-}));
-vi.mock("../server-subagent.js", () => ({
-  DELEGATE_TASK_TOOL_DEF: {
-    name: "delegate_task",
-    description: "Delegate",
-    input_schema: {
-      type: "object",
-      properties: {
-        prompt: {
-          type: "string"
-        }
-      },
-      required: ["prompt"]
-    }
-  },
-  runServerSubagent: vi.fn(async () => ({
-    success: true,
-    output: "ok",
-    turnCount: 1,
-    toolsUsed: [],
-    tokensUsed: {
-      input: 50,
-      output: 25
-    },
-    costUsd: 0.0005
-  }))
-}));
-vi.mock("../../handlers/transcription.js", () => ({
-  handleTranscribe: vi.fn(async () => ({
-    success: true,
-    transcript: "Transcribed text"
-  }))
-}));
-vi.mock("../compaction-service.js", () => ({
-  preCompact: vi.fn(msgs => ({
-    messages: msgs,
-    bytesRemoved: 0
-  }))
-}));
-vi.mock("../provider-failover.js", () => ({
-  providerFailover: {
-    getActiveProvider: vi.fn(model => ({
-      provider: "anthropic",
-      model,
-      failedOver: false,
-      originalProvider: "anthropic"
-    })),
-    recordSuccess: vi.fn(),
-    recordFailure: vi.fn()
-  }
-}));
-vi.mock("../session-checkpoint.js", () => ({
-  saveCheckpoint: vi.fn(async () => {})
-}));
-vi.mock("../logger.js", () => ({
-  createLogger: vi.fn(() => ({
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-    debug: vi.fn()
-  }))
-}));
-
-// ============================================================================
-// Imports
-// ============================================================================
-
-import { runServerAgentLoop } from "../server-agent-loop.js";
-import { processStreamWithCallbacks } from "../../../shared/sse-parser.js";
-import { estimateCostUsd, isRetryableError, routeModel } from "../../../shared/agent-core.js";
-import { preCompact } from "../compaction-service.js";
-import { providerFailover } from "../provider-failover.js";
-
-// ============================================================================
-// Helpers
-// ============================================================================
-
-function makeTool(name) {
-  return {
-    name,
-    description: `Tool: ${name}`,
-    input_schema: {
-      type: "object",
-      properties: {}
-    }
-  };
-}
-function makeAnthropicMock() {
-  return {
-    beta: {
-      messages: {
-        create: vi.fn(async () => async function* () {}())
-      }
-    }
-  };
-}
-function makeSupabaseMock() {
-  return {
-    from: vi.fn(() => ({
-      insert: vi.fn(async () => ({
-        error: null
-      })),
-      select: vi.fn(() => ({
-        data: [],
-        error: null
-      }))
-    }))
-  };
-}
-function makeOpts(overrides = {}) {
-  return {
-    anthropic: makeAnthropicMock(),
-    supabase: makeSupabaseMock(),
-    model: "claude-sonnet-4-6",
-    systemPrompt: "You are a helpful assistant.",
-    messages: [{
-      role: "user",
-      content: "Hello"
-    }],
-    tools: [makeTool("test_tool")],
-    maxTurns: 10,
-    temperature: 0.7,
-    executeTool: vi.fn(async () => ({
-      success: true,
-      data: {
-        result: "ok"
-      }
-    })),
-    enableStreaming: true,
-    ...overrides
-  };
-}
-
-// ============================================================================
-// TESTS — discover_tools, edge cases
-// ============================================================================
-
-describe("server-agent-loop — discover_tools & edge cases", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    vi.mocked(processStreamWithCallbacks).mockReset();
-    vi.mocked(processStreamWithCallbacks).mockResolvedValue({
-      text: "Test response",
-      toolUseBlocks: [],
-      thinkingBlocks: [],
-      thinkingTokens: 0,
-      citations: [],
-      usage: {
-        inputTokens: 100,
-        outputTokens: 50,
-        cacheCreationTokens: 0,
-        cacheReadTokens: 0
-      },
-      compactionContent: null,
-      contextManagementApplied: false,
-      stopReason: "end_turn"
-    });
-    vi.mocked(estimateCostUsd).mockReturnValue(0.001);
-    vi.mocked(isRetryableError).mockReturnValue(false);
-    vi.mocked(routeModel).mockImplementation((_text, model) => model);
-    vi.mocked(preCompact).mockImplementation(msgs => ({
-      messages: msgs,
-      bytesRemoved: 0
-    }));
-    vi.mocked(providerFailover.getActiveProvider).mockImplementation(model => ({
-      provider: "anthropic",
-      model,
-      failedOver: false,
-      originalProvider: "anthropic"
-    }));
-  });
-  describe("discover_tools", () => {
-    it("activates discovered tools", async () => {
-      const executeTool = vi.fn(async name => {
-        if (name === "discover_tools") return {
-          success: true,
-          data: {
-            tools: [{
-              name: "new_tool",
-              description: "New",
-              input_schema: {
-                type: "object"
-              }
-            }]
-          }
-        };
-        return {
-          success: true,
-          data: {}
-        };
-      });
-      let callCount = 0;
-      vi.mocked(processStreamWithCallbacks).mockImplementation(async () => {
-        callCount++;
-        if (callCount === 1) {
-          return {
-            text: "",
-            toolUseBlocks: [{
-              id: "tu-1",
-              name: "discover_tools",
-              input: {}
-            }],
-            thinkingBlocks: [],
-            thinkingTokens: 0,
-            citations: [],
-            usage: {
-              inputTokens: 100,
-              outputTokens: 50,
-              cacheCreationTokens: 0,
-              cacheReadTokens: 0
-            },
-            compactionContent: null,
-            contextManagementApplied: false,
-            stopReason: "tool_use"
-          };
-        }
-        return {
-          text: "Done",
-          toolUseBlocks: [],
-          thinkingBlocks: [],
-          thinkingTokens: 0,
-          citations: [],
-          usage: {
-            inputTokens: 50,
-            outputTokens: 20,
-            cacheCreationTokens: 0,
-            cacheReadTokens: 0
-          },
-          compactionContent: null,
-          contextManagementApplied: false,
-          stopReason: "end_turn"
-        };
-      });
-      const result = await runServerAgentLoop(makeOpts({
-        executeTool
-      }));
-      expect(result.toolsUsed).toContain("discover_tools");
-    });
-  });
-  describe("edge cases", () => {
-    it("handles empty text responses", async () => {
-      vi.mocked(processStreamWithCallbacks).mockResolvedValue({
-        text: "",
-        toolUseBlocks: [],
-        thinkingBlocks: [],
-        thinkingTokens: 0,
-        citations: [],
-        usage: {
-          inputTokens: 10,
-          outputTokens: 5,
-          cacheCreationTokens: 0,
-          cacheReadTokens: 0
-        },
-        compactionContent: null,
-        contextManagementApplied: false,
-        stopReason: "end_turn"
-      });
-      const result = await runServerAgentLoop(makeOpts());
-      expect(result.finalText).toBe("");
-      expect(result.turnCount).toBe(1);
-    });
-    it("deduplicates tools in toolsUsed", async () => {
-      let callCount = 0;
-      vi.mocked(processStreamWithCallbacks).mockImplementation(async () => {
-        callCount++;
-        if (callCount <= 2) {
-          return {
-            text: "",
-            toolUseBlocks: [{
-              id: `tu-${callCount}`,
-              name: "test_tool",
-              input: {}
-            }],
-            thinkingBlocks: [],
-            thinkingTokens: 0,
-            citations: [],
-            usage: {
-              inputTokens: 50,
-              outputTokens: 20,
-              cacheCreationTokens: 0,
-              cacheReadTokens: 0
-            },
-            compactionContent: null,
-            contextManagementApplied: false,
-            stopReason: "tool_use"
-          };
-        }
-        return {
-          text: "Done",
-          toolUseBlocks: [],
-          thinkingBlocks: [],
-          thinkingTokens: 0,
-          citations: [],
-          usage: {
-            inputTokens: 50,
-            outputTokens: 20,
-            cacheCreationTokens: 0,
-            cacheReadTokens: 0
-          },
-          compactionContent: null,
-          contextManagementApplied: false,
-          stopReason: "end_turn"
-        };
-      });
-      vi.mocked(estimateCostUsd).mockReturnValue(0);
-      const result = await runServerAgentLoop(makeOpts());
-      expect(result.toolsUsed.filter(t => t === "test_tool").length).toBe(1);
-    });
-    it("accumulates citations across multiple turns", async () => {
-      let callCount = 0;
-      vi.mocked(processStreamWithCallbacks).mockImplementation(async () => {
-        callCount++;
-        if (callCount === 1) {
-          return {
-            text: "First",
-            toolUseBlocks: [{
-              id: "tu-1",
-              name: "test_tool",
-              input: {}
-            }],
-            thinkingBlocks: [],
-            thinkingTokens: 0,
-            citations: [{
-              type: "cite",
-              cited_text: "cite1",
-              document_index: 0,
-              start_char_index: 0,
-              end_char_index: 5
-            }],
-            usage: {
-              inputTokens: 100,
-              outputTokens: 50,
-              cacheCreationTokens: 0,
-              cacheReadTokens: 0
-            },
-            compactionContent: null,
-            contextManagementApplied: false,
-            stopReason: "tool_use"
-          };
-        }
-        return {
-          text: "Second",
-          toolUseBlocks: [],
-          thinkingBlocks: [],
-          thinkingTokens: 0,
-          citations: [{
-            type: "cite",
-            cited_text: "cite2",
-            document_index: 1,
-            start_char_index: 0,
-            end_char_index: 5
-          }],
-          usage: {
-            inputTokens: 50,
-            outputTokens: 20,
-            cacheCreationTokens: 0,
-            cacheReadTokens: 0
-          },
-          compactionContent: null,
-          contextManagementApplied: false,
-          stopReason: "end_turn"
-        };
-      });
-      vi.mocked(estimateCostUsd).mockReturnValue(0);
-      const result = await runServerAgentLoop(makeOpts());
-      expect(result.citations.length).toBe(2);
-    });
-  });
-});

package/dist/server/lib/__tests__/server-subagent-bailout.test.js

@@ -1,194 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-
-// ---------------------------------------------------------------------------
-// Mocks (duplicated from server-subagent-errors.test.ts)
-// ---------------------------------------------------------------------------
-
-vi.mock("../../../shared/agent-core.js", () => {
-  class MockLoopDetector {
-    resetTurn = vi.fn();
-  }
-  return {
-    LoopDetector: MockLoopDetector,
-    estimateCostUsd: vi.fn(() => 0.001),
-    sanitizeError: err => err instanceof Error ? err.message : String(err),
-    isRetryableError: vi.fn(() => false),
-    addPromptCaching: (tools, messages) => ({
-      tools,
-      messages
-    }),
-    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";
-    }),
-    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
-    }
-  };
-});
-vi.mock("../../../shared/api-client.js", () => ({
-  buildAPIRequest: vi.fn(() => ({
-    maxTokens: 8192,
-    betas: [],
-    contextManagement: undefined,
-    thinking: undefined
-  }))
-}));
-vi.mock("../../../shared/constants.js", () => ({
-  MODELS: {
-    HAIKU: "claude-haiku-4-5-20251001"
-  },
-  MODEL_MAP: {
-    haiku: "claude-haiku-4-5-20251001",
-    sonnet: "claude-sonnet-4-6",
-    opus: "claude-opus-4-6"
-  }
-}));
-vi.mock("../../../shared/tool-dispatch.js", () => ({
-  dispatchTools: vi.fn(async (toolUseBlocks, executor) => {
-    const results = [];
-    for (const block of toolUseBlocks) {
-      const res = await executor(block.name, block.input);
-      results.push({
-        type: "tool_result",
-        tool_use_id: block.id,
-        content: res.output,
-        is_error: !res.success
-      });
-    }
-    return {
-      results,
-      bailOut: false,
-      bailMessage: undefined
-    };
-  })
-}));
-import { runServerSubagent } from "../server-subagent.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeAnthropicMock(responses) {
-  let callIndex = 0;
-  return {
-    beta: {
-      messages: {
-        create: vi.fn(async () => {
-          const resp = responses[callIndex++];
-          if (!resp) throw new Error("No more mock responses");
-          return {
-            content: resp.content,
-            usage: resp.usage || {
-              input_tokens: 10,
-              output_tokens: 5
-            },
-            stop_reason: resp.stop_reason || "end_turn"
-          };
-        })
-      }
-    }
-  };
-}
-function makeOptions(overrides = {}) {
-  return {
-    anthropic: makeAnthropicMock([{
-      content: [{
-        type: "text",
-        text: "Done!"
-      }]
-    }]),
-    supabase: {},
-    storeId: "store-123",
-    prompt: "Look up the inventory",
-    model: "haiku",
-    maxTurns: 6,
-    tools: [{
-      name: "inventory",
-      description: "Inventory tool",
-      input_schema: {
-        type: "object"
-      }
-    }],
-    executeTool: vi.fn(async () => ({
-      success: true,
-      data: {
-        items: []
-      }
-    })),
-    clientDisconnected: {
-      value: false
-    },
-    startedAt: Date.now(),
-    maxDurationMs: 300_000,
-    ...overrides
-  };
-}
-
-// ---------------------------------------------------------------------------
-// TESTS — bail-out from tool dispatch
-// ---------------------------------------------------------------------------
-
-describe("server-subagent — bail-out from tool dispatch", () => {
-  it("returns error when tool dispatch bails out", async () => {
-    const {
-      dispatchTools
-    } = await import("../../../shared/tool-dispatch.js");
-    vi.mocked(dispatchTools).mockResolvedValueOnce({
-      results: [],
-      bailOut: true,
-      bailMessage: "Too many consecutive errors"
-    });
-    const anthropic = makeAnthropicMock([{
-      content: [{
-        type: "tool_use",
-        id: "tu-1",
-        name: "inventory",
-        input: {}
-      }]
-    }]);
-    const events = [];
-    const opts = makeOptions({
-      anthropic: anthropic,
-      executeTool: vi.fn(async () => ({
-        success: false,
-        error: "fail"
-      })),
-      onProgress: evt => events.push(evt)
-    });
-    const result = await runServerSubagent(opts);
-    expect(result.success).toBe(false);
-    expect(result.output).toContain("Too many consecutive errors");
-  });
-});