whale-code 6.5.11 → 6.6.0

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

@@ -1,319 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-
-// ---------------------------------------------------------------------------
-// Mocks
-// ---------------------------------------------------------------------------
-
-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";
-import { isRetryableError } from "../../../shared/agent-core.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 — abort conditions, API errors, max turns
-// ---------------------------------------------------------------------------
-
-describe("server-subagent — abort & errors", () => {
-  describe("abort conditions", () => {
-    it("aborts when client disconnects", async () => {
-      const anthropic = makeAnthropicMock([{
-        content: [{
-          type: "text",
-          text: "Never reached"
-        }]
-      }]);
-      const opts = makeOptions({
-        anthropic: anthropic,
-        clientDisconnected: {
-          value: true
-        }
-      });
-      const result = await runServerSubagent(opts);
-      expect(result.success).toBe(false);
-      expect(result.output).toBe("Client disconnected");
-    });
-    it("aborts when parent request times out", async () => {
-      const anthropic = makeAnthropicMock([{
-        content: [{
-          type: "text",
-          text: "Never reached"
-        }]
-      }]);
-      const opts = makeOptions({
-        anthropic: anthropic,
-        startedAt: Date.now() - 400_000,
-        maxDurationMs: 300_000
-      });
-      const result = await runServerSubagent(opts);
-      expect(result.success).toBe(false);
-      expect(result.output).toBe("Parent request timeout");
-    });
-  });
-  describe("API error handling", () => {
-    it("returns error on API failure", async () => {
-      const anthropic = {
-        beta: {
-          messages: {
-            create: vi.fn(async () => {
-              throw new Error("Server overloaded");
-            })
-          }
-        }
-      };
-      const opts = makeOptions({
-        anthropic: anthropic
-      });
-      const result = await runServerSubagent(opts);
-      expect(result.success).toBe(false);
-      expect(result.output).toContain("API error");
-      expect(result.output).toContain("Server overloaded");
-    });
-    it("retries on retryable errors", async () => {
-      const mockedIsRetryable = vi.mocked(isRetryableError);
-      mockedIsRetryable.mockReturnValueOnce(true);
-      let callCount = 0;
-      const anthropic = {
-        beta: {
-          messages: {
-            create: vi.fn(async () => {
-              callCount++;
-              if (callCount === 1) throw new Error("Overloaded");
-              return {
-                content: [{
-                  type: "text",
-                  text: "Retried successfully"
-                }],
-                usage: {
-                  input_tokens: 10,
-                  output_tokens: 5
-                }
-              };
-            })
-          }
-        }
-      };
-      const opts = makeOptions({
-        anthropic: anthropic
-      });
-      const result = await runServerSubagent(opts);
-      expect(result.success).toBe(true);
-      expect(result.output).toBe("Retried successfully");
-    });
-  });
-  describe("max turns", () => {
-    it("stops after maxTurns and returns last text", async () => {
-      const anthropic = {
-        beta: {
-          messages: {
-            create: vi.fn(async () => ({
-              content: [{
-                type: "text",
-                text: "Processing..."
-              }, {
-                type: "tool_use",
-                id: "tu-1",
-                name: "inventory",
-                input: {}
-              }],
-              usage: {
-                input_tokens: 5,
-                output_tokens: 3
-              }
-            }))
-          }
-        }
-      };
-      const executeTool = vi.fn(async () => ({
-        success: true,
-        data: {}
-      }));
-      const opts = makeOptions({
-        anthropic: anthropic,
-        executeTool,
-        maxTurns: 3
-      });
-      const result = await runServerSubagent(opts);
-      expect(result.turnCount).toBe(3);
-      expect(result.success).toBe(true);
-    });
-    it("returns fallback text when maxTurns exhausted without text", async () => {
-      const anthropic = {
-        beta: {
-          messages: {
-            create: vi.fn(async () => ({
-              content: [{
-                type: "tool_use",
-                id: "tu-1",
-                name: "inventory",
-                input: {}
-              }],
-              usage: {
-                input_tokens: 5,
-                output_tokens: 3
-              }
-            }))
-          }
-        }
-      };
-      const executeTool = vi.fn(async () => ({
-        success: true,
-        data: {}
-      }));
-      const opts = makeOptions({
-        anthropic: anthropic,
-        executeTool,
-        maxTurns: 2
-      });
-      const result = await runServerSubagent(opts);
-      expect(result.output).toContain("subagent completed without text response");
-    });
-  });
-});

package/dist/server/lib/__tests__/session-checkpoint-load.test.js

@@ -1,275 +0,0 @@
-import { describe, it, expect, vi, afterEach } from "vitest";
-import { saveCheckpoint, loadCheckpoint, markOrphaned } from "../session-checkpoint.js";
-import { HAS_TEST_DB, getTestClient, seedTracked, cleanup, RUN_PREFIX } from "../../handlers/__test-utils__/test-db.js";
-import { randomUUID } from "node:crypto";
-const sb = getTestClient();
-async function createConversation() {
-  const convId = randomUUID();
-  await seedTracked("ai_conversations", [{
-    id: convId,
-    title: `test_${RUN_PREFIX}_${convId.slice(0, 6)}`
-  }]);
-  return convId;
-}
-
-// ============================================================================
-// loadCheckpoint
-// ============================================================================
-
-describe.skipIf(!HAS_TEST_DB)("loadCheckpoint", () => {
-  afterEach(async () => {
-    await cleanup();
-  });
-  it("loads a checkpoint successfully", async () => {
-    const convId = await createConversation();
-    await saveCheckpoint(sb, convId, 10, [{
-      role: "user",
-      content: "hello"
-    }], {
-      input: 100,
-      output: 50,
-      cacheRead: 0,
-      cacheCreation: 0
-    }, 0.05, ["read_file"]);
-    const result = await loadCheckpoint(sb, convId);
-    expect(result).not.toBeNull();
-    expect(result.conversation_id).toBe(convId);
-    expect(result.turn).toBe(10);
-    expect(result.cost_so_far).toBe(0.05);
-    expect(result.tools_used).toEqual(["read_file"]);
-    await sb.from("ai_conversation_checkpoints").delete().eq("conversation_id", convId);
-  });
-  it("returns null when no checkpoint exists", async () => {
-    const convId = await createConversation();
-    const result = await loadCheckpoint(sb, convId);
-    expect(result).toBeNull();
-  });
-  it("returns null and logs warning on non-zero-rows error", async () => {
-    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
-    const mockSingle = vi.fn().mockResolvedValue({
-      data: null,
-      error: {
-        message: "permission denied"
-      }
-    });
-    const mockLimit = vi.fn(() => ({
-      single: mockSingle
-    }));
-    const mockOrder = vi.fn(() => ({
-      limit: mockLimit
-    }));
-    const mockEq = vi.fn(() => ({
-      order: mockOrder
-    }));
-    const mockSelect = vi.fn(() => ({
-      eq: mockEq
-    }));
-    const mockClient = {
-      from: vi.fn(() => ({
-        select: mockSelect
-      }))
-    };
-    const result = await loadCheckpoint(mockClient, "conv-1");
-    expect(result).toBeNull();
-    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("permission denied"));
-    warnSpy.mockRestore();
-  });
-  it("handles unexpected exceptions gracefully", async () => {
-    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
-    const mockClient = {
-      from: vi.fn(() => {
-        throw new Error("connection lost");
-      })
-    };
-    const result = await loadCheckpoint(mockClient, "conv-1");
-    expect(result).toBeNull();
-    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("connection lost"));
-    warnSpy.mockRestore();
-  });
-  it("defaults tools_used to empty array when null", async () => {
-    const mockSingle = vi.fn().mockResolvedValue({
-      data: {
-        conversation_id: "mock-conv-id",
-        turn: 5,
-        messages: "[]",
-        tokens_used: {
-          input: 0,
-          output: 0,
-          cacheRead: 0,
-          cacheCreation: 0
-        },
-        cost_so_far: 0,
-        tools_used: null,
-        created_at: new Date().toISOString()
-      },
-      error: null
-    });
-    const mockLimit = vi.fn(() => ({
-      single: mockSingle
-    }));
-    const mockOrder = vi.fn(() => ({
-      limit: mockLimit
-    }));
-    const mockEq = vi.fn(() => ({
-      order: mockOrder
-    }));
-    const mockSelect = vi.fn(() => ({
-      eq: mockEq
-    }));
-    const mockClient = {
-      from: vi.fn(() => ({
-        select: mockSelect
-      }))
-    };
-    const result = await loadCheckpoint(mockClient, "mock-conv-id");
-    expect(result).not.toBeNull();
-    expect(result.tools_used).toEqual([]);
-  });
-});
-
-// ============================================================================
-// markOrphaned
-// ============================================================================
-
-describe.skipIf(!HAS_TEST_DB)("markOrphaned", () => {
-  afterEach(async () => {
-    await cleanup();
-  });
-  it("marks orphaned conversations as resumable", async () => {
-    const mockIn = vi.fn().mockResolvedValue({
-      error: null
-    });
-    const mockUpdate = vi.fn(() => ({
-      in: mockIn
-    }));
-    const mockLt = vi.fn().mockResolvedValue({
-      data: [{
-        conversation_id: "conv-1",
-        turn: 10,
-        created_at: "2026-02-22T09:00:00Z"
-      }, {
-        conversation_id: "conv-2",
-        turn: 5,
-        created_at: "2026-02-22T09:30:00Z"
-      }],
-      error: null
-    });
-    const mockSelect = vi.fn(() => ({
-      lt: mockLt
-    }));
-    const mockClient = {
-      from: vi.fn(table => {
-        if (table === "ai_conversation_checkpoints") return {
-          select: mockSelect
-        };
-        if (table === "ai_conversations") return {
-          update: mockUpdate
-        };
-        return {};
-      })
-    };
-    const count = await markOrphaned(mockClient, new Date("2026-02-22T10:00:00Z"));
-    expect(count).toBe(2);
-    expect(mockIn).toHaveBeenCalledWith("id", ["conv-1", "conv-2"]);
-  });
-  it("returns 0 when no orphans found", async () => {
-    const mockLt = vi.fn().mockResolvedValue({
-      data: [],
-      error: null
-    });
-    const mockSelect = vi.fn(() => ({
-      lt: mockLt
-    }));
-    const mockClient = {
-      from: vi.fn(() => ({
-        select: mockSelect
-      }))
-    };
-    const count = await markOrphaned(mockClient, new Date());
-    expect(count).toBe(0);
-  });
-  it("returns 0 when select fails", async () => {
-    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
-    const mockLt = vi.fn().mockResolvedValue({
-      data: null,
-      error: {
-        message: "table not found"
-      }
-    });
-    const mockSelect = vi.fn(() => ({
-      lt: mockLt
-    }));
-    const mockClient = {
-      from: vi.fn(() => ({
-        select: mockSelect
-      }))
-    };
-    const count = await markOrphaned(mockClient, new Date());
-    expect(count).toBe(0);
-    warnSpy.mockRestore();
-  });
-  it("returns 0 when update fails", async () => {
-    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
-    const mockIn = vi.fn().mockResolvedValue({
-      error: {
-        message: "update failed"
-      }
-    });
-    const mockUpdate = vi.fn(() => ({
-      in: mockIn
-    }));
-    const mockLt = vi.fn().mockResolvedValue({
-      data: [{
-        conversation_id: "conv-1",
-        turn: 5,
-        created_at: "2026-02-22T09:00:00Z"
-      }],
-      error: null
-    });
-    const mockSelect = vi.fn(() => ({
-      lt: mockLt
-    }));
-    const mockClient = {
-      from: vi.fn(table => {
-        if (table === "ai_conversation_checkpoints") return {
-          select: mockSelect
-        };
-        if (table === "ai_conversations") return {
-          update: mockUpdate
-        };
-        return {};
-      })
-    };
-    const count = await markOrphaned(mockClient, new Date("2026-02-22T10:00:00Z"));
-    expect(count).toBe(0);
-    warnSpy.mockRestore();
-  });
-  it("handles unexpected exceptions gracefully", async () => {
-    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
-    const mockClient = {
-      from: vi.fn(() => {
-        throw new Error("catastrophic failure");
-      })
-    };
-    const count = await markOrphaned(mockClient, new Date());
-    expect(count).toBe(0);
-    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("catastrophic failure"));
-    warnSpy.mockRestore();
-  });
-  it("returns 0 when orphans data is null", async () => {
-    const mockLt = vi.fn().mockResolvedValue({
-      data: null,
-      error: null
-    });
-    const mockSelect = vi.fn(() => ({
-      lt: mockLt
-    }));
-    const mockClient = {
-      from: vi.fn(() => ({
-        select: mockSelect
-      }))
-    };
-    const count = await markOrphaned(mockClient, new Date());
-    expect(count).toBe(0);
-  });
-});