@vellumai/assistant 0.6.3 → 0.6.4

package/src/__tests__/anthropic-provider.test.ts

@@ -307,7 +307,10 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     // Turn-starting user message (first) keeps 1h
     const turnStart = sent[0];
     const turnStartLast = turnStart.content[turnStart.content.length - 1];
-    expect(turnStartLast.cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
+    expect(turnStartLast.cache_control).toEqual({
+      type: "ephemeral",
+      ttl: "1h",
+    });
 
     // Last message (tool_result) gets 5m advancing tail
     const lastMessage = sent[sent.length - 1];
@@ -398,7 +401,10 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     }>;
     const user = sent[0];
     expect(user.content[0].cache_control).toBeUndefined();
-    expect(user.content[1].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
+    expect(user.content[1].cache_control).toEqual({
+      type: "ephemeral",
+      ttl: "1h",
+    });
   });
 
   // -----------------------------------------------------------------------
@@ -442,7 +448,10 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     // Workspace block (first): no cache_control
     expect(user.content[0].cache_control).toBeUndefined();
     // User text (last): cache_control with 1h TTL
-    expect(user.content[1].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
+    expect(user.content[1].cache_control).toEqual({
+      type: "ephemeral",
+      ttl: "1h",
+    });
   });
 
   test("workspace + multi-block single user message: cache on last block only", async () => {
@@ -476,7 +485,10 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     // Only last block gets cache_control
     expect(user.content[0].cache_control).toBeUndefined();
     expect(user.content[1].cache_control).toBeUndefined();
-    expect(user.content[2].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
+    expect(user.content[2].cache_control).toEqual({
+      type: "ephemeral",
+      ttl: "1h",
+    });
   });
 
   // -----------------------------------------------------------------------
@@ -724,7 +736,8 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
   test("orphaned server_tool_use gets synthetic web_search_tool_result injected", async () => {
     // When stream is interrupted, server_tool_use may be stored without its
     // paired web_search_tool_result. repairOrphanedServerToolUse should inject
-    // a synthetic empty-content web_search_tool_result after the orphan.
+    // a synthetic error web_search_tool_result after the orphan so the model
+    // knows the search failed (rather than silently returning zero results).
     const messages: Message[] = [
       userMsg("Search for something"),
       {
@@ -757,7 +770,10 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     expect(sent[1].content[0].type).toBe("server_tool_use");
     expect(sent[1].content[1].type).toBe("web_search_tool_result");
     expect(sent[1].content[1].tool_use_id).toBe("srvtoolu_abc123");
-    expect(sent[1].content[1].content).toEqual([]);
+    expect(sent[1].content[1].content).toEqual({
+      type: "web_search_tool_result_error",
+      error_code: "unavailable",
+    });
     expect(sent[2].role).toBe("user");
     expect(sent[2].content[0].type).toBe("text");
   });
@@ -1037,7 +1053,10 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
         b.tool_use_id === "srvtoolu_interrupted",
     );
     expect(syntheticResults).toHaveLength(1);
-    expect(syntheticResults[0].content).toEqual([]);
+    expect(syntheticResults[0].content).toEqual({
+      type: "web_search_tool_result_error",
+      error_code: "unavailable",
+    });
   });
 
   test("paired server_tool_use is not modified by repair", async () => {
@@ -1408,7 +1427,10 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     // Last user message (turn 3): 1h cache on last block only
     const lastUser = userMsgs[userMsgs.length - 1];
     expect(lastUser.content[0].cache_control).toBeUndefined();
-    expect(lastUser.content[1].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
+    expect(lastUser.content[1].cache_control).toEqual({
+      type: "ephemeral",
+      ttl: "1h",
+    });
 
     // No top-level cache_control — breakpoints are set directly on blocks
     expect(
@@ -1437,14 +1459,19 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
 
     // First message is the turn-starting user text — gets 1h cache
     expect(sent[0].role).toBe("user");
-    expect(sent[0].content[0].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
+    expect(sent[0].content[0].cache_control).toEqual({
+      type: "ephemeral",
+      ttl: "1h",
+    });
 
     // Non-last tool result messages do NOT get cache_control
     const toolResultMsgs = sent.filter(
       (m) =>
         m.role === "user" &&
         Array.isArray(m.content) &&
-        m.content.every((b) => typeof b !== "string" && b.type === "tool_result"),
+        m.content.every(
+          (b) => typeof b !== "string" && b.type === "tool_result",
+        ),
     );
     expect(toolResultMsgs.length).toBeGreaterThan(0);
     for (const tr of toolResultMsgs.slice(0, -1)) {
@@ -1693,3 +1720,229 @@ describe("AnthropicProvider — Managed Proxy Fallback", () => {
     });
   });
 });
+
+// ---------------------------------------------------------------------------
+// Tests — Orphaned UTF-16 surrogate sanitization
+// ---------------------------------------------------------------------------
+
+describe("AnthropicProvider — surrogate sanitization", () => {
+  let provider: AnthropicProvider;
+
+  beforeEach(() => {
+    lastStreamParams = null;
+    provider = new AnthropicProvider("sk-ant-test", "claude-sonnet-4-6");
+  });
+
+  test("strips orphaned high surrogate from a tool result before sending", async () => {
+    // An orphaned high surrogate — the exact shape that triggers Anthropic's
+    // "no low surrogate in string" 400. The mock's JSON.parse(JSON.stringify)
+    // on line ~44 would throw if sanitization didn't happen.
+    const LONE_HIGH = "\uD83C";
+    const messages: Message[] = [
+      toolUseMsg("tu1", "bash"),
+      toolResultMsg("tu1", `shell output ${LONE_HIGH} more output`),
+      userMsg("what happened?"),
+    ];
+
+    await provider.sendMessage(messages);
+
+    const sent = lastStreamParams!.messages as Array<{
+      role: string;
+      content: Array<{ type: string; content?: string; text?: string }>;
+    }>;
+    // Find the tool_result block in the captured payload and assert no orphans.
+    const toolResult = sent
+      .flatMap((m) => m.content)
+      .find((b) => b.type === "tool_result");
+    expect(toolResult).toBeDefined();
+    expect(toolResult!.content).toBeDefined();
+    const content = toolResult!.content as string;
+    for (let i = 0; i < content.length; i++) {
+      const code = content.charCodeAt(i);
+      if (code >= 0xd800 && code <= 0xdbff) {
+        const next = i + 1 < content.length ? content.charCodeAt(i + 1) : 0;
+        expect(next >= 0xdc00 && next <= 0xdfff).toBe(true);
+        i++;
+      } else {
+        expect(code < 0xdc00 || code > 0xdfff).toBe(true);
+      }
+    }
+  });
+
+  test("clean payloads are not copied unnecessarily", async () => {
+    // When there are no orphans, the sanitizer should be a no-op. We can't
+    // easily assert reference equality through the mock boundary (the mock
+    // JSON-round-trips params for capture), but we can at least confirm the
+    // call succeeds without error on ordinary payloads containing valid
+    // surrogate pairs (emoji).
+    const EMOJI = "\uD83C\uDF89";
+    await provider.sendMessage([userMsg(`hello ${EMOJI} world`)]);
+    const sent = lastStreamParams!.messages as Array<{
+      content: Array<{ text?: string }>;
+    }>;
+    expect(sent[0].content[0].text).toContain(EMOJI);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Haiku model gating
+// ---------------------------------------------------------------------------
+
+describe("AnthropicProvider — Haiku Model Gating", () => {
+  let provider: AnthropicProvider;
+
+  beforeEach(() => {
+    lastStreamParams = null;
+    _lastStreamOptions = null;
+    lastConstructorArgs = null;
+    provider = new AnthropicProvider(
+      "sk-ant-test",
+      "claude-haiku-4-5-20251001",
+    );
+  });
+
+  test("max_tokens defaults to 8192 for Haiku", async () => {
+    await provider.sendMessage([userMsg("Hi")], undefined, "You are helpful.");
+
+    expect(lastStreamParams!.max_tokens).toBe(8192);
+  });
+
+  test("caller max_tokens is clamped to 8192 for Haiku", async () => {
+    await provider.sendMessage([userMsg("Hi")], undefined, "You are helpful.", {
+      config: { max_tokens: 64000 },
+    });
+
+    expect(lastStreamParams!.max_tokens).toBe(8192);
+  });
+
+  test("caller max_tokens below 8192 is preserved for Haiku", async () => {
+    await provider.sendMessage([userMsg("Hi")], undefined, "You are helpful.", {
+      config: { max_tokens: 128 },
+    });
+
+    expect(lastStreamParams!.max_tokens).toBe(128);
+  });
+
+  test("non-Haiku provider respects caller max_tokens without clamping", async () => {
+    const sonnetProvider = new AnthropicProvider(
+      "sk-ant-test",
+      "claude-sonnet-4-6",
+    );
+    await sonnetProvider.sendMessage(
+      [userMsg("Hi")],
+      undefined,
+      "You are helpful.",
+      { config: { max_tokens: 200 } },
+    );
+
+    expect(lastStreamParams!.max_tokens).toBe(200);
+  });
+
+  test("cache_control omits ttl for Haiku", async () => {
+    await provider.sendMessage([userMsg("Hi")], undefined, "You are helpful.");
+
+    const system = lastStreamParams!.system as Array<{
+      cache_control?: { type: string; ttl?: string };
+    }>;
+    expect(system[0].cache_control).toEqual({ type: "ephemeral" });
+    expect(system[0].cache_control).not.toHaveProperty("ttl");
+  });
+
+  test("betas array is empty for Haiku (no extended cache TTL or 1M context)", async () => {
+    await provider.sendMessage([userMsg("Hi")], undefined, "You are helpful.");
+
+    // When betas is empty, the non-beta stream path is used, so no betas
+    // field should appear in lastStreamParams.
+    expect(lastStreamParams!.betas).toBeUndefined();
+  });
+
+  test("effort is stripped for Haiku even when provided in config", async () => {
+    await provider.sendMessage([userMsg("Hi")], undefined, "You are helpful.", {
+      config: { effort: "high" },
+    });
+
+    expect(lastStreamParams!.output_config).toBeUndefined();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// OpenRouter routing Anthropic models through the Messages API
+// ---------------------------------------------------------------------------
+
+describe("OpenRouterProvider — Anthropic dispatch", () => {
+  beforeEach(() => {
+    lastStreamParams = null;
+    _lastStreamOptions = null;
+    lastConstructorArgs = null;
+  });
+
+  test("anthropic/ models are routed to Anthropic Messages API with Bearer auth", async () => {
+    const { OpenRouterProvider } = await import(
+      "../providers/openrouter/client.js"
+    );
+    const provider = new OpenRouterProvider(
+      "or-key",
+      "anthropic/claude-sonnet-4.6",
+    );
+    await provider.sendMessage([userMsg("hi")], undefined, "You are helpful.");
+
+    expect(lastConstructorArgs).toMatchObject({
+      apiKey: null,
+      authToken: "or-key",
+      baseURL: "https://openrouter.ai/api",
+    });
+    expect(lastStreamParams).toBeTruthy();
+    expect(lastStreamParams!.model).toBe("anthropic/claude-sonnet-4.6");
+  });
+
+  test("custom baseURL has trailing /v1 stripped for Messages API", async () => {
+    const { OpenRouterProvider } = await import(
+      "../providers/openrouter/client.js"
+    );
+    const provider = new OpenRouterProvider(
+      "ast-key",
+      "anthropic/claude-opus-4.6",
+      {
+        baseURL: "https://platform.example.com/v1/runtime-proxy/openrouter/v1",
+      },
+    );
+    await provider.sendMessage([userMsg("hi")]);
+
+    expect(lastConstructorArgs).toMatchObject({
+      baseURL: "https://platform.example.com/v1/runtime-proxy/openrouter",
+    });
+  });
+
+  test("thinking config flows through to Anthropic Messages API natively", async () => {
+    const { OpenRouterProvider } = await import(
+      "../providers/openrouter/client.js"
+    );
+    const provider = new OpenRouterProvider(
+      "or-key",
+      "anthropic/claude-sonnet-4.6",
+    );
+    await provider.sendMessage([userMsg("hi")], undefined, undefined, {
+      config: { thinking: { type: "adaptive" } },
+    });
+
+    expect(lastStreamParams!.thinking).toEqual({ type: "adaptive" });
+    // The OpenAI-compat `reasoning` parameter must NOT be sent on the
+    // native Messages API path.
+    expect(lastStreamParams!.reasoning).toBeUndefined();
+  });
+
+  test("per-request model override routes based on the overridden model", async () => {
+    const { OpenRouterProvider } = await import(
+      "../providers/openrouter/client.js"
+    );
+    // Default model is non-Anthropic, but the request overrides with an
+    // Anthropic model — dispatch must honour the request-level model.
+    const provider = new OpenRouterProvider("or-key", "x-ai/grok-4");
+    await provider.sendMessage([userMsg("hi")], undefined, undefined, {
+      config: { model: "anthropic/claude-haiku-4.5" },
+    });
+
+    expect(lastStreamParams).toBeTruthy();
+    expect(lastStreamParams!.model).toBe("anthropic/claude-haiku-4.5");
+  });
+});