whale-code 6.5.11 → 6.6.0

package/dist/server/providers/__tests__/registry.test.js

@@ -1,183 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
-
-// Mock getProvider from shared/constants
-vi.mock("../../../shared/constants.js", () => ({
-  getProvider: modelId => {
-    if (modelId === "auto") return "anthropic";
-    if (modelId.includes(".anthropic.") || modelId.startsWith("anthropic.")) return "bedrock";
-    if (modelId.startsWith("gemini-")) return "gemini";
-    if (modelId.startsWith("gpt-") || /^o\d/.test(modelId)) return "openai";
-    return "anthropic";
-  }
-}));
-
-// We need to reset the registry state between tests since it uses a module-level Map.
-// Re-import after each reset.
-let registerProvider;
-let getProviderAdapter;
-let hasProvider;
-let getRegisteredProviders;
-describe("Provider Registry", () => {
-  beforeEach(async () => {
-    // Reset module to get a fresh Map
-    vi.resetModules();
-    const mod = await import("../registry.js");
-    registerProvider = mod.registerProvider;
-    getProviderAdapter = mod.getProviderAdapter;
-    hasProvider = mod.hasProvider;
-    getRegisteredProviders = mod.getRegisteredProviders;
-  });
-
-  // ---------------------------------------------------------------------------
-  // registerProvider + hasProvider
-  // ---------------------------------------------------------------------------
-
-  describe("registerProvider", () => {
-    it("registers a provider adapter", () => {
-      const adapter = {
-        name: "anthropic"
-      };
-      registerProvider("anthropic", adapter);
-      expect(hasProvider("anthropic")).toBe(true);
-    });
-    it("overwrites an existing provider with the same name", () => {
-      const adapter1 = {
-        name: "anthropic",
-        version: 1
-      };
-      const adapter2 = {
-        name: "anthropic",
-        version: 2
-      };
-      registerProvider("anthropic", adapter1);
-      registerProvider("anthropic", adapter2);
-      const result = getProviderAdapter("anthropic");
-      expect(result.version).toBe(2);
-    });
-  });
-
-  // ---------------------------------------------------------------------------
-  // hasProvider
-  // ---------------------------------------------------------------------------
-
-  describe("hasProvider", () => {
-    it("returns false for unregistered provider", () => {
-      expect(hasProvider("nonexistent")).toBe(false);
-    });
-    it("returns true for registered provider", () => {
-      registerProvider("gemini", {
-        name: "gemini"
-      });
-      expect(hasProvider("gemini")).toBe(true);
-    });
-  });
-
-  // ---------------------------------------------------------------------------
-  // getRegisteredProviders
-  // ---------------------------------------------------------------------------
-
-  describe("getRegisteredProviders", () => {
-    it("returns empty array when no providers registered", () => {
-      expect(getRegisteredProviders()).toEqual([]);
-    });
-    it("returns all registered provider names", () => {
-      registerProvider("anthropic", {
-        name: "anthropic"
-      });
-      registerProvider("openai", {
-        name: "openai"
-      });
-      registerProvider("gemini", {
-        name: "gemini"
-      });
-      expect(getRegisteredProviders()).toEqual(["anthropic", "openai", "gemini"]);
-    });
-  });
-
-  // ---------------------------------------------------------------------------
-  // getProviderAdapter
-  // ---------------------------------------------------------------------------
-
-  describe("getProviderAdapter", () => {
-    it("returns adapter by direct provider name", () => {
-      const adapter = {
-        name: "openai"
-      };
-      registerProvider("openai", adapter);
-      expect(getProviderAdapter("openai")).toBe(adapter);
-    });
-    it("resolves a model ID to its provider adapter", () => {
-      const adapter = {
-        name: "gemini"
-      };
-      registerProvider("gemini", adapter);
-      // "gemini-2.5-pro" should resolve to "gemini" via getProvider
-      expect(getProviderAdapter("gemini-2.5-pro")).toBe(adapter);
-    });
-    it("resolves anthropic model IDs correctly", () => {
-      const adapter = {
-        name: "anthropic"
-      };
-      registerProvider("anthropic", adapter);
-      expect(getProviderAdapter("claude-sonnet-4-6")).toBe(adapter);
-    });
-    it("resolves openai model IDs (gpt-*)", () => {
-      const adapter = {
-        name: "openai"
-      };
-      registerProvider("openai", adapter);
-      expect(getProviderAdapter("gpt-5")).toBe(adapter);
-    });
-    it("resolves openai reasoning model IDs (o-series)", () => {
-      const adapter = {
-        name: "openai"
-      };
-      registerProvider("openai", adapter);
-      expect(getProviderAdapter("o3")).toBe(adapter);
-    });
-    it("resolves bedrock model IDs", () => {
-      const adapter = {
-        name: "bedrock"
-      };
-      registerProvider("bedrock", adapter);
-      expect(getProviderAdapter("anthropic.claude-sonnet-4-6")).toBe(adapter);
-    });
-    it("falls back to anthropic for unknown model IDs", () => {
-      const adapter = {
-        name: "anthropic"
-      };
-      registerProvider("anthropic", adapter);
-      // Unknown model ID resolves to "anthropic" via getProvider default
-      expect(getProviderAdapter("some-unknown-model")).toBe(adapter);
-    });
-    it("throws if no adapters are registered at all", () => {
-      expect(() => getProviderAdapter("claude-sonnet-4-6")).toThrow(/No provider adapter registered/);
-    });
-    it("falls back to anthropic when resolved provider is not registered", () => {
-      // Register only anthropic, request a gemini model
-      const adapter = {
-        name: "anthropic"
-      };
-      registerProvider("anthropic", adapter);
-      expect(getProviderAdapter("gemini-2.5-flash")).toBe(adapter);
-    });
-    it("throws when resolved provider is not registered and no anthropic fallback", () => {
-      registerProvider("openai", {
-        name: "openai"
-      });
-      // "gemini-2.5-pro" resolves to "gemini" which isn't registered, and no "anthropic" fallback
-      expect(() => getProviderAdapter("gemini-2.5-pro")).toThrow(/No provider adapter registered/);
-    });
-    it("error message includes registered providers", () => {
-      registerProvider("openai", {
-        name: "openai"
-      });
-      try {
-        getProviderAdapter("gemini-2.5-pro");
-      } catch (err) {
-        expect(err.message).toContain("openai");
-        expect(err.message).toContain("gemini-2.5-pro");
-      }
-    });
-  });
-});

package/dist/server/providers/__tests__/shared.test.js

@@ -1,297 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-// Mock @supabase/supabase-js
-const mockRpc = vi.fn();
-const mockCreateClient = vi.fn(() => ({
-  rpc: mockRpc
-}));
-vi.mock("@supabase/supabase-js", () => ({
-  createClient: (_url, _key) => mockCreateClient()
-}));
-import { jsonResponse, writeSSEHeaders, emitError, resolveProviderCredentials } from "../shared.js";
-
-// ---------------------------------------------------------------------------
-// Helper: create a mock ServerResponse
-// ---------------------------------------------------------------------------
-function createMockRes() {
-  return {
-    writeHead: vi.fn(),
-    end: vi.fn(),
-    write: vi.fn(),
-    flushHeaders: vi.fn(),
-    headersSent: false
-  };
-}
-const corsHeaders = {
-  "Access-Control-Allow-Origin": "*"
-};
-
-// ============================================================================
-// jsonResponse
-// ============================================================================
-
-describe("jsonResponse", () => {
-  it("writes JSON with correct status and content type", () => {
-    const res = createMockRes();
-    jsonResponse(res, 200, {
-      ok: true
-    }, corsHeaders);
-    expect(res.writeHead).toHaveBeenCalledWith(200, {
-      "Content-Type": "application/json",
-      "Access-Control-Allow-Origin": "*"
-    });
-    expect(res.end).toHaveBeenCalledWith(JSON.stringify({
-      ok: true
-    }));
-  });
-  it("sends error status codes", () => {
-    const res = createMockRes();
-    jsonResponse(res, 400, {
-      error: "bad request"
-    }, corsHeaders);
-    expect(res.writeHead).toHaveBeenCalledWith(400, expect.objectContaining({
-      "Content-Type": "application/json"
-    }));
-  });
-  it("merges CORS headers", () => {
-    const res = createMockRes();
-    const customCors = {
-      "Access-Control-Allow-Origin": "https://app.example.com",
-      "X-Custom": "yes"
-    };
-    jsonResponse(res, 200, {}, customCors);
-    expect(res.writeHead).toHaveBeenCalledWith(200, expect.objectContaining({
-      "Access-Control-Allow-Origin": "https://app.example.com",
-      "X-Custom": "yes"
-    }));
-  });
-});
-
-// ============================================================================
-// writeSSEHeaders
-// ============================================================================
-
-describe("writeSSEHeaders", () => {
-  it("writes SSE headers with correct content type", () => {
-    const res = createMockRes();
-    writeSSEHeaders(res, corsHeaders);
-    expect(res.writeHead).toHaveBeenCalledWith(200, expect.objectContaining({
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      Connection: "keep-alive",
-      "X-Accel-Buffering": "no"
-    }));
-  });
-  it("calls flushHeaders", () => {
-    const res = createMockRes();
-    writeSSEHeaders(res, corsHeaders);
-    expect(res.flushHeaders).toHaveBeenCalled();
-  });
-  it("includes CORS headers", () => {
-    const res = createMockRes();
-    writeSSEHeaders(res, {
-      "Access-Control-Allow-Origin": "https://example.com"
-    });
-    expect(res.writeHead).toHaveBeenCalledWith(200, expect.objectContaining({
-      "Access-Control-Allow-Origin": "https://example.com"
-    }));
-  });
-});
-
-// ============================================================================
-// emitError
-// ============================================================================
-
-describe("emitError", () => {
-  const sanitize = e => e?.message || String(e);
-  it("sends JSON error when headers NOT yet sent", () => {
-    const res = createMockRes();
-    res.headersSent = false;
-    emitError(res, new Error("fail"), corsHeaders, sanitize);
-    expect(res.writeHead).toHaveBeenCalledWith(502, expect.objectContaining({
-      "Content-Type": "application/json"
-    }));
-    const body = JSON.parse(res.end.mock.calls[0][0]);
-    expect(body.error).toContain("fail");
-  });
-  it("sends SSE error events when headers already sent", () => {
-    const res = createMockRes();
-    res.headersSent = true;
-    emitError(res, new Error("stream failure"), corsHeaders, sanitize);
-
-    // Should write error, message_delta, message_stop, and [DONE]
-    expect(res.write).toHaveBeenCalledTimes(4);
-    const calls = res.write.mock.calls.map(c => c[0]);
-    // First: error event
-    expect(calls[0]).toContain('"type":"error"');
-    // Second: message_delta with stop_reason "error"
-    expect(calls[1]).toContain('"type":"message_delta"');
-    expect(calls[1]).toContain('"stop_reason":"error"');
-    // Third: message_stop
-    expect(calls[2]).toContain('"type":"message_stop"');
-    // Fourth: [DONE]
-    expect(calls[3]).toContain("[DONE]");
-  });
-  it("includes usage tokens in message_delta when headers already sent", () => {
-    const res = createMockRes();
-    res.headersSent = true;
-    emitError(res, new Error("err"), corsHeaders, sanitize, {
-      inputTokens: 100,
-      outputTokens: 50,
-      thinkingTokens: 25,
-      cacheReadTokens: 10
-    });
-    const deltaCall = res.write.mock.calls[1][0];
-    const parsed = JSON.parse(deltaCall.replace("data: ", "").trim());
-    expect(parsed.usage.input_tokens).toBe(100);
-    expect(parsed.usage.output_tokens).toBe(50);
-    expect(parsed.usage.thinking_tokens).toBe(25);
-    expect(parsed.usage.cache_read_input_tokens).toBe(10);
-  });
-  it("omits thinking_tokens when zero", () => {
-    const res = createMockRes();
-    res.headersSent = true;
-    emitError(res, new Error("err"), corsHeaders, sanitize, {
-      inputTokens: 100,
-      outputTokens: 50,
-      thinkingTokens: 0
-    });
-    const deltaCall = res.write.mock.calls[1][0];
-    const parsed = JSON.parse(deltaCall.replace("data: ", "").trim());
-    expect(parsed.usage.thinking_tokens).toBeUndefined();
-  });
-  it("uses custom provider name in error message", () => {
-    const res = createMockRes();
-    res.headersSent = false;
-    emitError(res, new Error("timeout"), corsHeaders, sanitize, {
-      provider: "gemini"
-    });
-    const body = JSON.parse(res.end.mock.calls[0][0]);
-    expect(body.error).toContain("gemini");
-  });
-  it("defaults provider to 'proxy'", () => {
-    const res = createMockRes();
-    res.headersSent = false;
-    emitError(res, new Error("default"), corsHeaders, sanitize);
-    const body = JSON.parse(res.end.mock.calls[0][0]);
-    expect(body.error).toContain("proxy");
-  });
-  it("handles non-Error objects", () => {
-    const res = createMockRes();
-    res.headersSent = false;
-    emitError(res, "string error", corsHeaders, sanitize);
-    const body = JSON.parse(res.end.mock.calls[0][0]);
-    expect(body.error).toContain("string error");
-  });
-});
-
-// ============================================================================
-// resolveProviderCredentials
-// ============================================================================
-
-describe("resolveProviderCredentials", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockRpc.mockReset();
-    // Set env vars
-    process.env.SUPABASE_URL = "https://test.supabase.co";
-    process.env.SUPABASE_SERVICE_ROLE_KEY = "test-key";
-  });
-  it("resolves Google credentials", async () => {
-    mockRpc.mockResolvedValue({
-      data: "google-api-key-123",
-      error: null
-    });
-    const result = await resolveProviderCredentials("google", "store1");
-    expect(result.google).toEqual({
-      apiKey: "google-api-key-123"
-    });
-  });
-  it("resolves OpenAI credentials", async () => {
-    mockRpc.mockResolvedValue({
-      data: "sk-openai-key",
-      error: null
-    });
-    const result = await resolveProviderCredentials("openai", "store1");
-    expect(result.openai).toEqual({
-      apiKey: "sk-openai-key"
-    });
-  });
-  it("resolves Bedrock credentials", async () => {
-    mockRpc.mockResolvedValueOnce({
-      data: "AKID123",
-      error: null
-    }).mockResolvedValueOnce({
-      data: "secret456",
-      error: null
-    }).mockResolvedValueOnce({
-      data: "us-west-2",
-      error: null
-    });
-    const result = await resolveProviderCredentials("bedrock", "store1");
-    expect(result.bedrock).toEqual({
-      accessKeyId: "AKID123",
-      secretAccessKey: "secret456",
-      region: "us-west-2"
-    });
-  });
-  it("defaults bedrock region to us-east-1 when not found", async () => {
-    mockRpc.mockResolvedValueOnce({
-      data: "AKID123",
-      error: null
-    }).mockResolvedValueOnce({
-      data: "secret456",
-      error: null
-    }).mockResolvedValueOnce({
-      data: null,
-      error: null
-    });
-
-    // Use unique storeId to avoid cache hit from previous bedrock test
-    const result = await resolveProviderCredentials("bedrock", "store-region-test");
-    expect(result.bedrock?.region).toBe("us-east-1");
-  });
-  it("handles RPC errors gracefully for google", async () => {
-    mockRpc.mockResolvedValue({
-      data: null,
-      error: {
-        message: "not found"
-      }
-    });
-
-    // Use unique storeId to avoid cache hit
-    const result = await resolveProviderCredentials("google", "store-error-test");
-    expect(result.google).toBeUndefined();
-  });
-  it("handles RPC exceptions gracefully for openai", async () => {
-    mockRpc.mockRejectedValue(new Error("network error"));
-
-    // Use unique storeId to avoid cache hit
-    const result = await resolveProviderCredentials("openai", "store-exception-test");
-    expect(result.openai).toBeUndefined();
-  });
-  it("uses cached credentials within TTL", async () => {
-    mockRpc.mockResolvedValue({
-      data: "key1",
-      error: null
-    });
-
-    // First call
-    await resolveProviderCredentials("google", "store2");
-    // Second call should use cache (different mock return to prove)
-    mockRpc.mockResolvedValue({
-      data: "key2",
-      error: null
-    });
-    const result = await resolveProviderCredentials("google", "store2");
-    expect(result.google?.apiKey).toBe("key1");
-  });
-  it("uses default store key when storeId is undefined", async () => {
-    mockRpc.mockResolvedValue({
-      data: "default-key",
-      error: null
-    });
-    const result = await resolveProviderCredentials("google", undefined);
-    expect(result.google?.apiKey).toBe("default-key");
-  });
-});

package/dist/shared/agent-core-config.test.js

@@ -1,132 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { getContextManagement, getMaxOutputTokens, MODEL_PRICING } from "./agent-core.js";
-
-// ============================================================================
-// getContextManagement
-// ============================================================================
-
-describe("getContextManagement", () => {
-  it("returns compact + clear betas for opus-4-6", () => {
-    const result = getContextManagement("claude-opus-4-6");
-    expect(result.betas).toContain("context-management-2025-06-27");
-    expect(result.betas).toContain("compact-2026-01-12");
-    expect(result.betas).toHaveLength(2);
-  });
-  it("includes compact edit at 167K for opus-4-6", () => {
-    const result = getContextManagement("claude-opus-4-6");
-    const compactEdit = result.config.edits.find(e => e.type === "compact_20260112");
-    expect(compactEdit).toBeDefined();
-    expect(compactEdit.trigger).toEqual({
-      type: "input_tokens",
-      value: 167_000
-    });
-  });
-  it("includes clear_tool_uses edit at 100K for opus-4-6", () => {
-    const result = getContextManagement("claude-opus-4-6");
-    const clearEdit = result.config.edits.find(e => e.type === "clear_tool_uses_20250919");
-    expect(clearEdit).toBeDefined();
-    expect(clearEdit.trigger).toEqual({
-      type: "input_tokens",
-      value: 100_000
-    });
-    expect(clearEdit.keep).toEqual({
-      type: "tool_uses",
-      value: 3
-    });
-  });
-  it("returns compact + clear betas for sonnet-4-6", () => {
-    const result = getContextManagement("claude-sonnet-4-6");
-    expect(result.betas).toContain("context-management-2025-06-27");
-    expect(result.betas).toContain("compact-2026-01-12");
-    expect(result.betas).toHaveLength(2);
-  });
-  it("includes compact edit for sonnet-4-6 (supports compaction)", () => {
-    const result = getContextManagement("claude-sonnet-4-6");
-    const compactEdit = result.config.edits.find(e => e.type === "compact_20260112");
-    expect(compactEdit).toBeDefined();
-  });
-  it("includes clear_thinking + clear_tool_uses for non-opus models", () => {
-    const result = getContextManagement("claude-haiku-4-5-20251001");
-    expect(result.config.edits).toHaveLength(2);
-    expect(result.config.edits[0].type).toBe("clear_thinking_20251015");
-    expect(result.config.edits[1].type).toBe("clear_tool_uses_20250919");
-  });
-  it("opus-4-6 has 3 edits (clear_thinking + compact + clear_tool_uses)", () => {
-    const result = getContextManagement("claude-opus-4-6");
-    expect(result.config.edits).toHaveLength(3);
-    expect(result.config.edits[0].type).toBe("clear_thinking_20251015");
-    expect(result.config.edits[1].type).toBe("compact_20260112");
-    expect(result.config.edits[1].pause_after_compaction).toBe(true);
-    expect(result.config.edits[2].type).toBe("clear_tool_uses_20250919");
-  });
-  it("sonnet-4-6 gets compaction like opus-4-6", () => {
-    const result = getContextManagement("claude-sonnet-4-6");
-    expect(result.config.edits).toHaveLength(3);
-    expect(result.config.edits[1].type).toBe("compact_20260112");
-    expect(result.betas).toContain("compact-2026-01-12");
-  });
-});
-
-// ============================================================================
-// getMaxOutputTokens
-// ============================================================================
-
-describe("getMaxOutputTokens", () => {
-  it("returns correct default for each Claude model", () => {
-    // Without agentMax, getMaxOutputTokens returns min(DEFAULT_OUTPUT_TOKENS, modelMax)
-    expect(getMaxOutputTokens("claude-opus-4-6")).toBe(32000);
-    expect(getMaxOutputTokens("claude-sonnet-4-6")).toBe(32000);
-    expect(getMaxOutputTokens("claude-haiku-4-5-20251001")).toBe(32000);
-  });
-  it("returns 32000 as default for unknown models", () => {
-    expect(getMaxOutputTokens("some-unknown-model")).toBe(32000);
-  });
-  it("respects agentMax when lower than model max", () => {
-    expect(getMaxOutputTokens("claude-opus-4-6", 8192)).toBe(8192);
-  });
-  it("caps agentMax at model max", () => {
-    expect(getMaxOutputTokens("claude-opus-4-6", 200000)).toBe(128000);
-  });
-  it("returns default when agentMax is 0 (falsy)", () => {
-    // agentMax=0 is falsy, so falls through to min(DEFAULT_OUTPUT_TOKENS, modelMax)
-    expect(getMaxOutputTokens("claude-opus-4-6", 0)).toBe(32000);
-  });
-});
-
-// ============================================================================
-// MODEL_PRICING
-// ============================================================================
-
-describe("MODEL_PRICING", () => {
-  it("has pricing for all three expected models", () => {
-    expect(MODEL_PRICING).toHaveProperty("claude-sonnet-4-6");
-    expect(MODEL_PRICING).toHaveProperty("claude-opus-4-6");
-    expect(MODEL_PRICING).toHaveProperty("claude-haiku-4-5-20251001");
-  });
-  it("has entries for Anthropic, Bedrock, and Gemini models", () => {
-    expect(Object.keys(MODEL_PRICING).length).toBeGreaterThanOrEqual(3);
-  });
-  it("opus is more expensive than sonnet", () => {
-    expect(MODEL_PRICING["claude-opus-4-6"].inputPer1M).toBeGreaterThan(MODEL_PRICING["claude-sonnet-4-6"].inputPer1M);
-    expect(MODEL_PRICING["claude-opus-4-6"].outputPer1M).toBeGreaterThan(MODEL_PRICING["claude-sonnet-4-6"].outputPer1M);
-  });
-  it("sonnet is more expensive than haiku", () => {
-    expect(MODEL_PRICING["claude-sonnet-4-6"].inputPer1M).toBeGreaterThan(MODEL_PRICING["claude-haiku-4-5-20251001"].inputPer1M);
-  });
-  it("Claude 4.x and Bedrock models have thinking pricing", () => {
-    for (const [key, pricing] of Object.entries(MODEL_PRICING)) {
-      // Only Claude 4.x+ models and Bedrock have thinking pricing; older 3.x models do not
-      if ((key.startsWith("claude-") || key.startsWith("us.anthropic") || key.startsWith("anthropic.")) && !key.includes("3-5-") && !key.includes("3-7-") && !key.includes("3-haiku")) {
-        expect(pricing.thinkingPer1M).toBeDefined();
-        expect(pricing.thinkingPer1M).toBeGreaterThan(0);
-      }
-    }
-  });
-  it("thinking rate matches output rate for Claude 4.x models", () => {
-    for (const [key, pricing] of Object.entries(MODEL_PRICING)) {
-      if ((key.startsWith("claude-") || key.startsWith("us.anthropic") || key.startsWith("anthropic.")) && !key.includes("3-5-") && !key.includes("3-7-") && !key.includes("3-haiku")) {
-        expect(pricing.thinkingPer1M).toBe(pricing.outputPer1M);
-      }
-    }
-  });
-});