whale-code 6.5.5 → 6.5.7

package/dist/server/providers/__tests__/anthropic-streaming-betas.test.js

@@ -0,0 +1,247 @@
+/**
+ * Tests for AnthropicAdapter.handleStream — betas/citations and tool_choice mapping.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+// ---------------------------------------------------------------------------
+// Hoisted mocks
+// ---------------------------------------------------------------------------
+
+const {
+  mockMessagesCreate,
+  mockBetaMessagesCreate
+} = vi.hoisted(() => ({
+  mockMessagesCreate: vi.fn(),
+  mockBetaMessagesCreate: vi.fn()
+}));
+vi.mock("@anthropic-ai/sdk", () => {
+  class MockAnthropic {
+    messages = {
+      create: mockMessagesCreate
+    };
+    beta = {
+      messages: {
+        create: mockBetaMessagesCreate
+      }
+    };
+    constructor(_opts) {}
+  }
+  return {
+    default: MockAnthropic
+  };
+});
+vi.mock("../registry.js", () => ({
+  registerProvider: vi.fn()
+}));
+vi.mock("../shared.js", () => ({
+  jsonResponse: vi.fn(),
+  writeSSEHeaders: vi.fn()
+}));
+vi.mock("../../lib/provider-capabilities.js", () => ({
+  getCapabilities: vi.fn().mockReturnValue({
+    vision: true,
+    pdf: true,
+    computerUse: true,
+    codeExecution: false,
+    streaming: true,
+    batchApi: true,
+    citations: true,
+    thinking: true,
+    toolUse: true,
+    caching: true,
+    contextManagement: true,
+    maxContextTokens: 200_000,
+    maxOutputTokens: 128_000
+  })
+}));
+vi.mock("../../../shared/agent-core.js", () => ({
+  sanitizeError: vi.fn(e => String(e)),
+  AGENT_DEFAULTS: {
+    compactionTriggerTokens: 150_000,
+    compactionTotalBudget: 2_000_000
+  }
+}));
+
+// ---------------------------------------------------------------------------
+// Import after mocks
+// ---------------------------------------------------------------------------
+
+import { AnthropicAdapter } from "../anthropic.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeMockRes() {
+  const res = {
+    _written: [],
+    _ended: false,
+    headersSent: false,
+    writableEnded: false,
+    write: vi.fn(chunk => {
+      res._written.push(chunk);
+      return true;
+    }),
+    writeHead: vi.fn(() => {
+      res.headersSent = true;
+    }),
+    end: vi.fn(() => {
+      res._ended = true;
+      res.writableEnded = true;
+    }),
+    flushHeaders: vi.fn()
+  };
+  return res;
+}
+const corsHeaders = {
+  "Access-Control-Allow-Origin": "*"
+};
+async function* asyncIterableFrom(items) {
+  for (const item of items) yield item;
+}
+
+// ---------------------------------------------------------------------------
+// Tests — betas/citations and tool_choice
+// ---------------------------------------------------------------------------
+
+describe("AnthropicAdapter — betas & tool_choice", () => {
+  let adapter;
+  beforeEach(() => {
+    vi.clearAllMocks();
+    process.env.ANTHROPIC_API_KEY = "test-key-123";
+    adapter = new AnthropicAdapter();
+  });
+  afterEach(() => {
+    delete process.env.ANTHROPIC_API_KEY;
+  });
+  describe("handleStream (betas)", () => {
+    it("uses beta.messages.create when betas are provided", async () => {
+      mockBetaMessagesCreate.mockResolvedValue(asyncIterableFrom([]));
+      const res = makeMockRes();
+      await adapter.handleStream(res, {
+        model: "claude-sonnet-4-6",
+        messages: [],
+        system: null,
+        max_tokens: 1024,
+        stream: true,
+        betas: ["interleaved-thinking-2025-05-14"]
+      }, corsHeaders);
+      expect(mockBetaMessagesCreate).toHaveBeenCalled();
+      expect(mockMessagesCreate).not.toHaveBeenCalled();
+    });
+    it("adds citations beta when documents are provided", async () => {
+      mockBetaMessagesCreate.mockResolvedValue(asyncIterableFrom([]));
+      const docs = [{
+        type: "text",
+        text: "content",
+        source: {
+          type: "text"
+        }
+      }];
+      const res = makeMockRes();
+      await adapter.handleStream(res, {
+        model: "claude-sonnet-4-6",
+        messages: [],
+        system: null,
+        max_tokens: 1024,
+        stream: true,
+        documents: docs
+      }, corsHeaders);
+      const createCall = mockBetaMessagesCreate.mock.calls[0][0];
+      expect(createCall.betas).toContain("citations-2025-04-15");
+      expect(createCall.documents).toEqual(docs);
+    });
+    it("does not duplicate citations beta if already present", async () => {
+      mockBetaMessagesCreate.mockResolvedValue(asyncIterableFrom([]));
+      const res = makeMockRes();
+      await adapter.handleStream(res, {
+        model: "claude-sonnet-4-6",
+        messages: [],
+        system: null,
+        max_tokens: 1024,
+        stream: true,
+        betas: ["citations-2025-04-15"],
+        documents: [{
+          type: "text",
+          text: "content"
+        }]
+      }, corsHeaders);
+      const createCall = mockBetaMessagesCreate.mock.calls[0][0];
+      const citationCount = createCall.betas.filter(b => b === "citations-2025-04-15").length;
+      expect(citationCount).toBe(1);
+    });
+  });
+  describe("handleStream (tool_choice)", () => {
+    it('maps "auto" to { type: "auto" }', async () => {
+      mockMessagesCreate.mockResolvedValue(asyncIterableFrom([]));
+      const res = makeMockRes();
+      await adapter.handleStream(res, {
+        model: "claude-sonnet-4-6",
+        messages: [],
+        system: null,
+        max_tokens: 1024,
+        stream: true,
+        tool_choice: "auto"
+      }, corsHeaders);
+      const createCall = mockMessagesCreate.mock.calls[0][0];
+      expect(createCall.tool_choice).toEqual({
+        type: "auto"
+      });
+    });
+    it('maps "any" to { type: "any" }', async () => {
+      mockMessagesCreate.mockResolvedValue(asyncIterableFrom([]));
+      const res = makeMockRes();
+      await adapter.handleStream(res, {
+        model: "claude-sonnet-4-6",
+        messages: [],
+        system: null,
+        max_tokens: 1024,
+        stream: true,
+        tool_choice: "any"
+      }, corsHeaders);
+      const createCall = mockMessagesCreate.mock.calls[0][0];
+      expect(createCall.tool_choice).toEqual({
+        type: "any"
+      });
+    });
+    it('maps "none" by removing tools', async () => {
+      mockMessagesCreate.mockResolvedValue(asyncIterableFrom([]));
+      const res = makeMockRes();
+      await adapter.handleStream(res, {
+        model: "claude-sonnet-4-6",
+        messages: [],
+        system: null,
+        tools: [{
+          name: "t",
+          description: "d",
+          input_schema: {}
+        }],
+        max_tokens: 1024,
+        stream: true,
+        tool_choice: "none"
+      }, corsHeaders);
+      const createCall = mockMessagesCreate.mock.calls[0][0];
+      expect(createCall.tools).toBeUndefined();
+    });
+    it("maps specific tool choice", async () => {
+      mockMessagesCreate.mockResolvedValue(asyncIterableFrom([]));
+      const res = makeMockRes();
+      await adapter.handleStream(res, {
+        model: "claude-sonnet-4-6",
+        messages: [],
+        system: null,
+        max_tokens: 1024,
+        stream: true,
+        tool_choice: {
+          type: "tool",
+          name: "my_tool"
+        }
+      }, corsHeaders);
+      const createCall = mockMessagesCreate.mock.calls[0][0];
+      expect(createCall.tool_choice).toEqual({
+        type: "tool",
+        name: "my_tool"
+      });
+    });
+  });
+});

package/dist/server/providers/__tests__/anthropic-streaming-core.test.js

@@ -0,0 +1,275 @@
+/**
+ * Tests for AnthropicAdapter.handleStream — streaming mode
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+// ---------------------------------------------------------------------------
+// Hoisted mocks
+// ---------------------------------------------------------------------------
+
+const {
+  mockMessagesCreate,
+  mockBetaMessagesCreate
+} = vi.hoisted(() => ({
+  mockMessagesCreate: vi.fn(),
+  mockBetaMessagesCreate: vi.fn()
+}));
+vi.mock("@anthropic-ai/sdk", () => {
+  class MockAnthropic {
+    messages = {
+      create: mockMessagesCreate
+    };
+    beta = {
+      messages: {
+        create: mockBetaMessagesCreate
+      }
+    };
+    constructor(_opts) {}
+  }
+  return {
+    default: MockAnthropic
+  };
+});
+vi.mock("../registry.js", () => ({
+  registerProvider: vi.fn()
+}));
+vi.mock("../shared.js", () => ({
+  jsonResponse: vi.fn(),
+  writeSSEHeaders: vi.fn()
+}));
+vi.mock("../../lib/provider-capabilities.js", () => ({
+  getCapabilities: vi.fn().mockReturnValue({
+    vision: true,
+    pdf: true,
+    computerUse: true,
+    codeExecution: false,
+    streaming: true,
+    batchApi: true,
+    citations: true,
+    thinking: true,
+    toolUse: true,
+    caching: true,
+    contextManagement: true,
+    maxContextTokens: 200_000,
+    maxOutputTokens: 128_000
+  })
+}));
+vi.mock("../../../shared/agent-core.js", () => ({
+  sanitizeError: vi.fn(e => String(e)),
+  AGENT_DEFAULTS: {
+    compactionTriggerTokens: 150_000,
+    compactionTotalBudget: 2_000_000
+  }
+}));
+
+// ---------------------------------------------------------------------------
+// Import after mocks
+// ---------------------------------------------------------------------------
+
+import { AnthropicAdapter } from "../anthropic.js";
+import { writeSSEHeaders } from "../shared.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeMockRes() {
+  const res = {
+    _written: [],
+    _ended: false,
+    headersSent: false,
+    writableEnded: false,
+    write: vi.fn(chunk => {
+      res._written.push(chunk);
+      return true;
+    }),
+    writeHead: vi.fn(() => {
+      res.headersSent = true;
+    }),
+    end: vi.fn(() => {
+      res._ended = true;
+      res.writableEnded = true;
+    }),
+    flushHeaders: vi.fn()
+  };
+  return res;
+}
+const corsHeaders = {
+  "Access-Control-Allow-Origin": "*"
+};
+async function* asyncIterableFrom(items) {
+  for (const item of items) yield item;
+}
+
+// ---------------------------------------------------------------------------
+// Tests — streaming mode
+// ---------------------------------------------------------------------------
+
+describe("AnthropicAdapter — streaming", () => {
+  let adapter;
+  beforeEach(() => {
+    vi.clearAllMocks();
+    process.env.ANTHROPIC_API_KEY = "test-key-123";
+    adapter = new AnthropicAdapter();
+  });
+  afterEach(() => {
+    delete process.env.ANTHROPIC_API_KEY;
+  });
+  describe("handleStream (streaming)", () => {
+    it("streams events and writes [DONE] at end", async () => {
+      const events = [{
+        type: "message_start",
+        message: {
+          id: "msg_1",
+          role: "assistant"
+        }
+      }, {
+        type: "content_block_delta",
+        delta: {
+          type: "text_delta",
+          text: "Hello"
+        }
+      }, {
+        type: "message_stop"
+      }];
+      mockMessagesCreate.mockResolvedValue(asyncIterableFrom(events));
+      const res = makeMockRes();
+      await adapter.handleStream(res, {
+        model: "claude-sonnet-4-6",
+        messages: [{
+          role: "user",
+          content: "Hi"
+        }],
+        system: "You are helpful",
+        max_tokens: 1024,
+        stream: true
+      }, corsHeaders);
+      expect(writeSSEHeaders).toHaveBeenCalledWith(res, corsHeaders);
+      const written = res._written.join("");
+      expect(written).toContain('"type":"message_start"');
+      expect(written).toContain('"type":"content_block_delta"');
+      expect(written).toContain("data: [DONE]");
+      expect(res._ended).toBe(true);
+    });
+    it("converts string system prompt to cache_control block", async () => {
+      mockMessagesCreate.mockResolvedValue(asyncIterableFrom([]));
+      const res = makeMockRes();
+      await adapter.handleStream(res, {
+        model: "claude-sonnet-4-6",
+        messages: [],
+        system: "Be helpful",
+        max_tokens: 1024,
+        stream: true
+      }, corsHeaders);
+      const createCall = mockMessagesCreate.mock.calls[0][0];
+      expect(createCall.system).toEqual([{
+        type: "text",
+        text: "Be helpful",
+        cache_control: {
+          type: "ephemeral"
+        }
+      }]);
+    });
+    it("passes array system prompts as-is", async () => {
+      const systemBlocks = [{
+        type: "text",
+        text: "System instructions"
+      }];
+      mockMessagesCreate.mockResolvedValue(asyncIterableFrom([]));
+      const res = makeMockRes();
+      await adapter.handleStream(res, {
+        model: "claude-sonnet-4-6",
+        messages: [],
+        system: systemBlocks,
+        max_tokens: 1024,
+        stream: true
+      }, corsHeaders);
+      const createCall = mockMessagesCreate.mock.calls[0][0];
+      expect(createCall.system).toEqual(systemBlocks);
+    });
+    it("formats tools with name, description, input_schema", async () => {
+      mockMessagesCreate.mockResolvedValue(asyncIterableFrom([]));
+      const tools = [{
+        name: "my_tool",
+        description: "A test tool",
+        input_schema: {
+          type: "object",
+          properties: {
+            x: {
+              type: "string"
+            }
+          }
+        },
+        extra_field: "ignored"
+      }];
+      const res = makeMockRes();
+      await adapter.handleStream(res, {
+        model: "claude-sonnet-4-6",
+        messages: [],
+        system: null,
+        tools,
+        max_tokens: 1024,
+        stream: true
+      }, corsHeaders);
+      const createCall = mockMessagesCreate.mock.calls[0][0];
+      expect(createCall.tools).toEqual([{
+        name: "my_tool",
+        description: "A test tool",
+        input_schema: {
+          type: "object",
+          properties: {
+            x: {
+              type: "string"
+            }
+          }
+        }
+      }]);
+    });
+    it("truncates tool descriptions to 4096 chars", async () => {
+      mockMessagesCreate.mockResolvedValue(asyncIterableFrom([]));
+      const longDesc = "x".repeat(5000);
+      const res = makeMockRes();
+      await adapter.handleStream(res, {
+        model: "claude-sonnet-4-6",
+        messages: [],
+        system: null,
+        tools: [{
+          name: "t",
+          description: longDesc,
+          input_schema: {}
+        }],
+        max_tokens: 1024,
+        stream: true
+      }, corsHeaders);
+      const createCall = mockMessagesCreate.mock.calls[0][0];
+      expect(createCall.tools[0].description.length).toBe(4096);
+    });
+    it("includes temperature when provided", async () => {
+      mockMessagesCreate.mockResolvedValue(asyncIterableFrom([]));
+      const res = makeMockRes();
+      await adapter.handleStream(res, {
+        model: "claude-sonnet-4-6",
+        messages: [],
+        system: null,
+        max_tokens: 1024,
+        temperature: 0.7,
+        stream: true
+      }, corsHeaders);
+      const createCall = mockMessagesCreate.mock.calls[0][0];
+      expect(createCall.temperature).toBe(0.7);
+    });
+    it("omits temperature when not provided", async () => {
+      mockMessagesCreate.mockResolvedValue(asyncIterableFrom([]));
+      const res = makeMockRes();
+      await adapter.handleStream(res, {
+        model: "claude-sonnet-4-6",
+        messages: [],
+        system: null,
+        max_tokens: 1024,
+        stream: true
+      }, corsHeaders);
+      const createCall = mockMessagesCreate.mock.calls[0][0];
+      expect(createCall.temperature).toBeUndefined();
+    });
+  });
+});

package/dist/server/providers/__tests__/bedrock-config.test.js

@@ -0,0 +1,177 @@
+/**
+ * Tests for Bedrock Provider Adapter — config methods:
+ * getThinkingConfig, getMaxOutputTokens, getContextManagement, getCompactionConfig, getCapabilities
+ */
+
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// ---------------------------------------------------------------------------
+// Hoisted mocks — available to vi.mock factories
+// ---------------------------------------------------------------------------
+
+const {
+  mockSend,
+  mockResolveProviderCredentials
+} = vi.hoisted(() => ({
+  mockSend: vi.fn(),
+  mockResolveProviderCredentials: vi.fn()
+}));
+let lastBedrockClientArgs = null;
+vi.mock("@aws-sdk/client-bedrock-runtime", () => ({
+  BedrockRuntimeClient: class {
+    send = mockSend;
+    constructor(opts) {
+      lastBedrockClientArgs = opts;
+    }
+  },
+  InvokeModelWithResponseStreamCommand: class {
+    constructor(params) {
+      this.params = params;
+    }
+  }
+}));
+vi.mock("../registry.js", () => ({
+  registerProvider: vi.fn()
+}));
+vi.mock("../shared.js", () => ({
+  jsonResponse: vi.fn(),
+  writeSSEHeaders: vi.fn(),
+  resolveProviderCredentials: mockResolveProviderCredentials
+}));
+vi.mock("../../lib/provider-capabilities.js", () => ({
+  getCapabilities: vi.fn().mockReturnValue({
+    vision: true,
+    pdf: true,
+    computerUse: true,
+    codeExecution: false,
+    streaming: true,
+    batchApi: false,
+    citations: true,
+    thinking: true,
+    toolUse: true,
+    caching: false,
+    contextManagement: false,
+    maxContextTokens: 200_000,
+    maxOutputTokens: 64_000
+  })
+}));
+vi.mock("../../../shared/agent-core.js", () => ({
+  sanitizeError: vi.fn(e => String(e)),
+  AGENT_DEFAULTS: {
+    compactionTriggerTokens: 150_000,
+    compactionTotalBudget: 2_000_000
+  }
+}));
+
+// ---------------------------------------------------------------------------
+// Import after mocks
+// ---------------------------------------------------------------------------
+
+import { BedrockAdapter } from "../bedrock.js";
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("BedrockAdapter config", () => {
+  let adapter;
+  beforeEach(() => {
+    vi.clearAllMocks();
+    lastBedrockClientArgs = null;
+    mockResolveProviderCredentials.mockResolvedValue({
+      bedrock: {
+        accessKeyId: "AKIATEST",
+        secretAccessKey: "secret123",
+        region: "us-west-2"
+      }
+    });
+    adapter = new BedrockAdapter();
+  });
+  describe("getThinkingConfig", () => {
+    it("returns disabled when enabled=false", () => {
+      const result = adapter.getThinkingConfig("us.anthropic.claude-sonnet-4-5-20250929-v1:0", false);
+      expect(result.thinking.type).toBe("disabled");
+      expect(result.beta).toBe("");
+    });
+    it("returns adaptive for models containing opus-4-6", () => {
+      const result = adapter.getThinkingConfig("anthropic.claude-opus-4-6", true);
+      expect(result.thinking.type).toBe("adaptive");
+      expect(result.beta).toBe("adaptive-thinking-2026-01-28");
+    });
+    it("returns adaptive for models containing sonnet-4-6", () => {
+      const result = adapter.getThinkingConfig("anthropic.claude-sonnet-4-6", true);
+      expect(result.thinking.type).toBe("adaptive");
+      expect(result.beta).toBe("adaptive-thinking-2026-01-28");
+    });
+    it("returns enabled with budget_tokens for other Claude models", () => {
+      const result = adapter.getThinkingConfig("us.anthropic.claude-sonnet-4-5-20250929-v1:0", true);
+      expect(result.thinking.type).toBe("enabled");
+      expect(result.thinking.budget_tokens).toBe(10_000);
+      expect(result.beta).toBe("interleaved-thinking-2025-05-14");
+    });
+  });
+  describe("getMaxOutputTokens", () => {
+    it("returns default (16384) for known models when no agentMax", () => {
+      expect(adapter.getMaxOutputTokens("anthropic.claude-sonnet-4-6")).toBe(16384);
+    });
+    it("caps at model max when agentMax exceeds it", () => {
+      expect(adapter.getMaxOutputTokens("anthropic.claude-sonnet-4-6", 70000)).toBe(64000);
+    });
+    it("returns agentMax when below model max", () => {
+      expect(adapter.getMaxOutputTokens("anthropic.claude-sonnet-4-6", 8000)).toBe(8000);
+    });
+    it("returns default for unknown models", () => {
+      expect(adapter.getMaxOutputTokens("unknown-bedrock-model")).toBe(16384);
+    });
+  });
+  describe("getContextManagement", () => {
+    it("includes context-management beta", () => {
+      const result = adapter.getContextManagement("us.anthropic.claude-sonnet-4-5-20250929-v1:0");
+      expect(result.betas).toContain("context-management-2025-06-27");
+    });
+    it("includes clear_thinking edit first", () => {
+      const result = adapter.getContextManagement("us.anthropic.claude-sonnet-4-5-20250929-v1:0");
+      expect(result.config.edits[0]).toMatchObject({
+        type: "clear_thinking_20251015",
+        keep: {
+          type: "thinking_turns",
+          value: 2
+        }
+      });
+    });
+    it("includes compaction for sonnet-4-6 models", () => {
+      const result = adapter.getContextManagement("anthropic.claude-sonnet-4-6");
+      const compactEdit = result.config.edits.find(e => e.type === "compact_20260112");
+      expect(compactEdit).toBeDefined();
+      expect(result.betas).toContain("compact-2026-01-12");
+    });
+    it("does NOT include compaction for non-4.6 models", () => {
+      const result = adapter.getContextManagement("us.anthropic.claude-sonnet-4-5-20250929-v1:0");
+      const compactEdit = result.config.edits.find(e => e.type === "compact_20260112");
+      expect(compactEdit).toBeUndefined();
+    });
+    it("includes clear_tool_uses edit", () => {
+      const result = adapter.getContextManagement("us.anthropic.claude-sonnet-4-5-20250929-v1:0");
+      const clearToolEdit = result.config.edits.find(e => e.type === "clear_tool_uses_20250919");
+      expect(clearToolEdit).toBeDefined();
+    });
+  });
+  describe("getCompactionConfig", () => {
+    it("returns native compaction config", () => {
+      const result = adapter.getCompactionConfig("anthropic.claude-sonnet-4-6");
+      expect(result).toEqual({
+        triggerTokens: 150_000,
+        totalBudget: 2_000_000,
+        isNative: true
+      });
+    });
+  });
+  describe("getCapabilities", () => {
+    it("returns bedrock capabilities", () => {
+      const caps = adapter.getCapabilities();
+      expect(caps.vision).toBe(true);
+      expect(caps.computerUse).toBe(true);
+      expect(caps.caching).toBe(false);
+    });
+  });
+});