@vellumai/assistant 0.6.6 → 0.7.1

package/src/__tests__/agent-wake-override-profile.test.ts

@@ -0,0 +1,283 @@
+/**
+ * Regression test for the wake-driven override-profile gap.
+ *
+ * `wakeAgentForOpportunity` invokes `agentLoop.run(...)` directly, bypassing
+ * `runAgentLoopImpl`. Without an explicit row read, scheduled-task wakes and
+ * other opportunity wakes targeting a user conversation with a pinned profile
+ * would execute under workspace defaults — silently violating the user's
+ * pinned preference.
+ *
+ * The wake also has to pass `callSite: "mainAgent"` explicitly. The agent loop
+ * threads `callSite` and `overrideProfile` onto the per-call provider config,
+ * but `RetryProvider.normalizeSendMessageOptions` only invokes
+ * `resolveCallSiteConfig` when `config.callSite !== undefined` and
+ * `CallSiteRoutingProvider.selectProvider` short-circuits to the default
+ * provider when `callSite` is absent. So a wake that only set
+ * `overrideProfile` (with `callSite: undefined`) would still execute under
+ * workspace defaults — the pinned profile would be silently dropped.
+ *
+ * This file pins `getConversationOverrideProfile` to a fixed profile name and
+ * asserts that:
+ *   1. The wake forwards `overrideProfile` to `agentLoop.run`.
+ *   2. The wake forwards `callSite: "mainAgent"` to `agentLoop.run`.
+ *   3. The wake resolves and forwards the effective max input token budget.
+ *   4. With both routing keys set, `RetryProvider.normalizeSendMessageOptions` actually
+ *      invokes the resolver and replaces workspace defaults with the
+ *      pinned-profile values.
+ */
+
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+let mockOverrideProfile: string | undefined = undefined;
+
+mock.module("../memory/conversation-crud.js", () => ({
+  getConversationOverrideProfile: (_id: string) => mockOverrideProfile,
+}));
+
+// Mutable stub for `getConfig().llm` consumed by `RetryProvider`'s
+// resolver path in the integration-style assertion below. Defined ahead of
+// import so the module-level `getConfig()` reference inside `retry.ts`
+// closes over our mutable holder.
+let mockLlmConfig: Record<string, unknown> = {};
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    llm: mockLlmConfig,
+    services: { inference: { mode: "your-own" } },
+  }),
+}));
+
+import type { AgentEvent } from "../agent/loop.js";
+import { LLMSchema } from "../config/schemas/llm.js";
+import { RetryProvider } from "../providers/retry.js";
+import type {
+  Message,
+  Provider,
+  ProviderResponse,
+  SendMessageOptions,
+} from "../providers/types.js";
+import {
+  __resetWakeChainForTests,
+  wakeAgentForOpportunity,
+  type WakeTarget,
+} from "../runtime/agent-wake.js";
+
+interface RunArgs {
+  messages: Message[];
+  signal: AbortSignal | undefined;
+  requestId: string | undefined;
+  onCheckpoint: unknown;
+  callSite: unknown;
+  turnContext: unknown;
+  overrideProfile: string | undefined;
+  effectiveMaxInputTokens: number | undefined;
+}
+
+function makeTarget(): {
+  target: WakeTarget;
+  runArgs: RunArgs[];
+} {
+  const runArgs: RunArgs[] = [];
+  const history: Message[] = [
+    { role: "user", content: [{ type: "text", text: "hi" }] },
+  ];
+  let processing = false;
+
+  const target: WakeTarget = {
+    conversationId: "conv-wake-override",
+    agentLoop: {
+      run: (async (
+        messages: Message[],
+        _onEvent: (event: AgentEvent) => void | Promise<void>,
+        signal?: AbortSignal,
+        requestId?: string,
+        onCheckpoint?: unknown,
+        callSite?: unknown,
+        turnContext?: unknown,
+        overrideProfile?: string,
+        effectiveMaxInputTokens?: number,
+      ) => {
+        runArgs.push({
+          messages: [...messages],
+          signal,
+          requestId,
+          onCheckpoint,
+          callSite,
+          turnContext,
+          overrideProfile,
+          effectiveMaxInputTokens,
+        });
+        // Return the input verbatim → silent no-op (no assistant tail).
+        return messages;
+      }) as WakeTarget["agentLoop"]["run"],
+    },
+    getMessages: () => history,
+    pushMessage: (msg) => {
+      history.push(msg);
+    },
+    emitAgentEvent: () => {},
+    isProcessing: () => processing,
+    markProcessing: (on) => {
+      processing = on;
+    },
+    persistTailMessage: async () => {},
+  };
+  return { target, runArgs };
+}
+
+beforeEach(() => {
+  __resetWakeChainForTests();
+  mockLlmConfig = LLMSchema.parse({}) as Record<string, unknown>;
+});
+
+afterEach(() => {
+  mockOverrideProfile = undefined;
+});
+
+describe("wakeAgentForOpportunity — overrideProfile forwarding", () => {
+  test("forwards the conversation's pinned overrideProfile + mainAgent callSite to agentLoop.run", async () => {
+    mockOverrideProfile = "frontier";
+    mockLlmConfig = LLMSchema.parse({
+      default: {
+        provider: "anthropic",
+        model: "claude-sonnet-4-6",
+        maxTokens: 64000,
+        contextWindow: { maxInputTokens: 200000 },
+      },
+      profiles: {
+        frontier: {
+          contextWindow: { maxInputTokens: 150000 },
+        },
+      },
+      callSites: {
+        mainAgent: {},
+      },
+    }) as Record<string, unknown>;
+    const { target, runArgs } = makeTarget();
+
+    const result = await wakeAgentForOpportunity(
+      {
+        conversationId: target.conversationId,
+        hint: "test hint",
+        source: "scheduler",
+      },
+      { resolveTarget: async () => target },
+    );
+
+    expect(result.invoked).toBe(true);
+    expect(runArgs).toHaveLength(1);
+    // The 8th positional argument (after messages, onEvent, signal,
+    // requestId, onCheckpoint, callSite, turnContext) is overrideProfile.
+    expect(runArgs[0]!.overrideProfile).toBe("frontier");
+    // The 6th positional argument is callSite. Wakes resume a user-facing
+    // conversation, so route through the same `mainAgent` call site as a
+    // normal user turn — without it the resolver and routing layers would
+    // short-circuit and silently drop both the call-site config and the
+    // pinned override profile.
+    expect(runArgs[0]!.callSite).toBe("mainAgent");
+    expect(runArgs[0]!.effectiveMaxInputTokens).toBe(150000);
+    // Sanity: the wake-source tag still propagates as requestId.
+    expect(runArgs[0]!.requestId).toBe("wake:scheduler");
+  });
+
+  test("passes undefined overrideProfile when the conversation has no pinned profile, but still forwards mainAgent callSite", async () => {
+    mockOverrideProfile = undefined;
+    const { target, runArgs } = makeTarget();
+
+    await wakeAgentForOpportunity(
+      {
+        conversationId: target.conversationId,
+        hint: "test hint",
+        source: "unit-test",
+      },
+      { resolveTarget: async () => target },
+    );
+
+    expect(runArgs).toHaveLength(1);
+    expect(runArgs[0]!.overrideProfile).toBeUndefined();
+    // Even without an override profile, we still need callSite="mainAgent"
+    // so the resolver picks up `llm.callSites.mainAgent` config (model,
+    // maxTokens, effort, etc.). Otherwise the wake silently runs under
+    // workspace defaults regardless of any per-call-site configuration.
+    expect(runArgs[0]!.callSite).toBe("mainAgent");
+    expect(runArgs[0]!.effectiveMaxInputTokens).toBeGreaterThan(0);
+  });
+});
+
+describe("wakeAgentForOpportunity — resolver actually engages", () => {
+  // The unit tests above only assert positional argument forwarding. They
+  // do not exercise the real provider chain, which is exactly the gap that
+  // let the original bug ship: the wake forwarded `overrideProfile` but
+  // passed `callSite: undefined`, and `RetryProvider.normalizeSendMessageOptions`
+  // only invokes `resolveCallSiteConfig` when `config.callSite !== undefined`.
+  // This test wires the same `(callSite, overrideProfile)` pair the wake now
+  // produces into a real `RetryProvider.sendMessage` call to confirm the
+  // resolver fires and the pinned-profile values replace workspace defaults.
+
+  function makeProvider(
+    name: string,
+    onCall: (options: SendMessageOptions | undefined) => void,
+  ): Provider {
+    return {
+      name,
+      async sendMessage(_messages, _tools, _systemPrompt, options) {
+        onCall(options);
+        const response: ProviderResponse = {
+          content: [{ type: "text", text: "ok" }],
+          model: "stub",
+          usage: { inputTokens: 1, outputTokens: 1 },
+          stopReason: "end_turn",
+        };
+        return response;
+      },
+    };
+  }
+
+  test("with callSite='mainAgent' + overrideProfile, RetryProvider resolves the pinned-profile model/maxTokens", async () => {
+    // Workspace defaults intentionally differ from the pinned-profile values
+    // so we can detect whether the resolver engaged. If `callSite` were
+    // undefined (the original bug), the retry layer would skip the resolver
+    // entirely and the downstream provider would see only the wire defaults.
+    mockLlmConfig = LLMSchema.parse({
+      default: {
+        provider: "anthropic",
+        model: "claude-sonnet-4-6",
+        maxTokens: 64000,
+      },
+      profiles: {
+        frontier: {
+          model: "claude-opus-4-7",
+          maxTokens: 32000,
+        },
+      },
+      callSites: {
+        mainAgent: {},
+      },
+    }) as Record<string, unknown>;
+
+    let seen: SendMessageOptions | undefined;
+    const wrapped = new RetryProvider(
+      makeProvider("anthropic", (options) => {
+        seen = options;
+      }),
+    );
+
+    // Mirror exactly what `agentLoop.run` puts on `providerConfig` when
+    // `callSite` and `overrideProfile` are both set (see `agent/loop.ts`).
+    await wrapped.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+      undefined,
+      undefined,
+      { config: { callSite: "mainAgent", overrideProfile: "frontier" } },
+    );
+
+    const config = seen?.config as Record<string, unknown>;
+    // Resolver engaged → pinned-profile values applied.
+    expect(config.model).toBe("claude-opus-4-7");
+    expect(config.max_tokens).toBe(32000);
+    // Both routing keys are stripped before delegating downstream so they
+    // never leak into provider request bodies.
+    expect(config.callSite).toBeUndefined();
+    expect(config.overrideProfile).toBeUndefined();
+  });
+});

package/src/__tests__/always-loaded-tools-guard.test.ts

@@ -28,7 +28,7 @@ afterAll(() => {
 });
 
 describe("always-loaded tool count", () => {
-  test("should be exactly 11 (no-client baseline excludes host tools)", async () => {
+  test("should be exactly 11 with recall occupying the existing slot", async () => {
     await initializeTools();
     const allDefs = buildToolDefinitions();
 
@@ -65,6 +65,7 @@ describe("always-loaded tool count", () => {
     ].sort();
 
     expect(activeNames).toEqual(expectedNames);
+    expect(activeNames.filter((name) => name === "recall")).toHaveLength(1);
     expect(activeTools.length).toBe(11);
   });
 });

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

@@ -196,6 +196,14 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     expect(lastStreamParams!.system).toBeUndefined();
   });
 
+  test("sends disabled thinking config natively", async () => {
+    await provider.sendMessage([userMsg("Hi")], undefined, undefined, {
+      config: { thinking: { type: "disabled" } },
+    });
+
+    expect(lastStreamParams!.thinking).toEqual({ type: "disabled" });
+  });
+
   test("splits system prompt into two cache blocks on boundary marker", async () => {
     const staticBlock = "You are a helpful assistant.";
     const dynamicBlock = "User workspace files here.";
@@ -366,17 +374,53 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     }>;
 
     const userMessages = sent.filter((m) => m.role === "user");
-    // Only the last user message (turn-starting) gets cache_control
-    for (const user of userMessages.slice(0, -1)) {
-      for (const block of user.content) {
-        expect(block.cache_control).toBeUndefined();
-      }
+    // Oldest user message (Turn 1) has no cache_control
+    for (const block of userMessages[0].content) {
+      expect(block.cache_control).toBeUndefined();
     }
+    // Previous-turn anchor (Turn 2) gets 1h cache on its last block to
+    // preserve the cached prefix across turn transitions
+    const prevTurn = userMessages[userMessages.length - 2];
+    const prevTurnLast = prevTurn.content[prevTurn.content.length - 1];
+    expect(prevTurnLast.cache_control).toEqual({
+      type: "ephemeral",
+      ttl: "1h",
+    });
+    // Current-turn anchor (Turn 3) gets 1h cache on its last block
     const lastUser = userMessages[userMessages.length - 1];
     const lastBlock = lastUser.content[lastUser.content.length - 1];
     expect(lastBlock.cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
   });
 
+  test("previous-turn anchor is NOT applied during a tool-use loop", async () => {
+    // When the request is mid tool-use (last msg is a tool_result), the
+    // turn-start anchor already covers the long prefix, so we must not
+    // place a second anchor on the prior turn — that would push us over
+    // the 4-breakpoint budget without adding cache value.
+    const messages: Message[] = [
+      userMsg("Turn 1"),
+      assistantMsg("Response 1"),
+      userMsg("Turn 2"),
+      toolUseMsg("tu_1", "bash"),
+      toolResultMsg("tu_1", "output"),
+    ];
+    await provider.sendMessage(messages);
+
+    const sent = lastStreamParams!.messages as Array<{
+      role: string;
+      content: Array<{
+        type: string;
+        cache_control?: { type: string; ttl?: string };
+      }>;
+    }>;
+    // Turn 1 user message must have no cache_control (would be the
+    // prev-turn-anchor if we applied it, which we shouldn't here)
+    const turn1 = sent[0];
+    for (const block of turn1.content) {
+      expect(block.cache_control).toBeUndefined();
+    }
+  });
+
   // -----------------------------------------------------------------------
   // Negative: assistant messages never get cache_control
   // -----------------------------------------------------------------------
@@ -1282,6 +1326,83 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     }
   });
 
+  test("consecutive real assistant messages are merged into one", async () => {
+    // When two non-placeholder assistant messages appear consecutively
+    // (e.g. history reconstruction artifacts), the provider must merge
+    // their content blocks to satisfy Anthropic's strict role alternation.
+    const messages: Message[] = [
+      userMsg("Start"),
+      assistantMsg("First response"),
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "Second thought" }],
+      },
+    ];
+    await provider.sendMessage(messages);
+
+    const sent = lastStreamParams!.messages as Array<{
+      role: string;
+      content: Array<{ type: string; text?: string }>;
+    }>;
+
+    // Should be merged into 2 messages: user + single merged assistant
+    expect(sent).toHaveLength(2);
+    expect(sent[0].role).toBe("user");
+    expect(sent[1].role).toBe("assistant");
+    expect(sent[1].content).toHaveLength(2);
+    expect(sent[1].content[0].text).toBe("First response");
+    expect(sent[1].content[1].text).toBe("Second thought");
+  });
+
+  test("consecutive real user messages are merged into one", async () => {
+    // Same as above but for user messages — ensures the merge logic
+    // handles both roles, not just assistant.
+    const messages: Message[] = [
+      userMsg("First question"),
+      userMsg("Actually, also this"),
+      assistantMsg("Response"),
+    ];
+    await provider.sendMessage(messages);
+
+    const sent = lastStreamParams!.messages as Array<{
+      role: string;
+      content: Array<{ type: string; text?: string }>;
+    }>;
+
+    expect(sent).toHaveLength(2);
+    expect(sent[0].role).toBe("user");
+    expect(sent[0].content).toHaveLength(2);
+    expect(sent[0].content[0].text).toBe("First question");
+    expect(sent[0].content[1].text).toBe("Actually, also this");
+    expect(sent[1].role).toBe("assistant");
+  });
+
+  test("three consecutive text-only assistant messages are all merged into one", async () => {
+    // Regression test: after merging messages[i-1] and messages[i], the
+    // element formerly at i+1 shifts to i, forming a new same-role pair.
+    // The while loop must recheck that position rather than walking past it.
+    const messages: Message[] = [
+      userMsg("Start"),
+      assistantMsg("Response A"),
+      assistantMsg("Hint B"),
+      assistantMsg("Hint C"),
+    ];
+    await provider.sendMessage(messages);
+
+    const sent = lastStreamParams!.messages as Array<{
+      role: string;
+      content: Array<{ type: string; text?: string }>;
+    }>;
+
+    expect(sent).toHaveLength(2);
+    expect(sent[0].role).toBe("user");
+    expect(sent[1].role).toBe("assistant");
+    expect(sent[1].content).toHaveLength(3);
+    expect(sent[1].content[0].text).toBe("Response A");
+    expect(sent[1].content[1].text).toBe("Hint B");
+    expect(sent[1].content[2].text).toBe("Hint C");
+  });
+
   test("streams normal text through without delay when text is not a sentinel prefix", async () => {
     scriptedStream = [
       { kind: "blockStart" },
@@ -1417,9 +1538,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     expect(isPlaceholderSentinelText("")).toBe(false);
     expect(isPlaceholderSentinelText("__PLACEHOLDER__")).toBe(false);
     expect(
-      isPlaceholderSentinelText(
-        "prefix __PLACEHOLDER__[empty assistant turn]",
-      ),
+      isPlaceholderSentinelText("prefix __PLACEHOLDER__[empty assistant turn]"),
     ).toBe(false);
   });
 
@@ -1538,7 +1657,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     expect(sent[4].content[0].text).toBe("Follow-up question");
   });
 
-  test("multi-turn with workspace injection: only last user message gets 1h cache", async () => {
+  test("multi-turn with workspace injection: prev-turn + last user message get 1h cache", async () => {
     const messages: Message[] = [
       {
         role: "user",
@@ -1586,14 +1705,21 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     const userMsgs = sent.filter((m) => m.role === "user");
     expect(userMsgs).toHaveLength(3);
 
-    // Earlier user messages: no cache_control
-    for (const user of userMsgs.slice(0, -1)) {
-      for (const block of user.content) {
-        expect(block.cache_control).toBeUndefined();
-      }
+    // Oldest user message (turn 1): no cache_control
+    for (const block of userMsgs[0].content) {
+      expect(block.cache_control).toBeUndefined();
     }
 
-    // Last user message (turn 3): 1h cache on last block only
+    // Previous-turn anchor (turn 2): 1h cache on last block to preserve the
+    // cached prefix across turn transitions
+    const prevTurn = userMsgs[userMsgs.length - 2];
+    expect(prevTurn.content[0].cache_control).toBeUndefined();
+    expect(prevTurn.content[1].cache_control).toEqual({
+      type: "ephemeral",
+      ttl: "1h",
+    });
+
+    // Current-turn anchor (turn 3): 1h cache on last block
     const lastUser = userMsgs[userMsgs.length - 1];
     expect(lastUser.content[0].cache_control).toBeUndefined();
     expect(lastUser.content[1].cache_control).toEqual({
@@ -2017,7 +2143,7 @@ describe("AnthropicProvider — Haiku Model Gating", () => {
     expect(system[0].cache_control).not.toHaveProperty("ttl");
   });
 
-  test("betas array is empty for Haiku (no extended cache TTL or 1M context)", async () => {
+  test("betas array is empty for Haiku (no extended cache TTL)", async () => {
     await provider.sendMessage([userMsg("Hi")], undefined, "You are helpful.");
 
     // When betas is empty, the non-beta stream path is used, so no betas
@@ -2032,6 +2158,24 @@ describe("AnthropicProvider — Haiku Model Gating", () => {
 
     expect(lastStreamParams!.output_config).toBeUndefined();
   });
+
+  test('effort: "none" omits output_config.effort on non-Haiku models', async () => {
+    const sonnetProvider = new AnthropicProvider(
+      "sk-ant-test",
+      "claude-sonnet-4-6",
+    );
+    await sonnetProvider.sendMessage(
+      [userMsg("Hi")],
+      undefined,
+      "You are helpful.",
+      { config: { effort: "none" } },
+    );
+
+    // mergedOutputConfig is empty when effort is "none" and no other
+    // output_config fields were supplied, so output_config is not attached
+    // to the request at all.
+    expect(lastStreamParams!.output_config).toBeUndefined();
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -2046,9 +2190,8 @@ describe("OpenRouterProvider — Anthropic dispatch", () => {
   });
 
   test("anthropic/ models are routed to Anthropic Messages API with Bearer auth", async () => {
-    const { OpenRouterProvider } = await import(
-      "../providers/openrouter/client.js"
-    );
+    const { OpenRouterProvider } =
+      await import("../providers/openrouter/client.js");
     const provider = new OpenRouterProvider(
       "or-key",
       "anthropic/claude-sonnet-4.6",
@@ -2065,9 +2208,8 @@ describe("OpenRouterProvider — Anthropic dispatch", () => {
   });
 
   test("custom baseURL has trailing /v1 stripped for Messages API", async () => {
-    const { OpenRouterProvider } = await import(
-      "../providers/openrouter/client.js"
-    );
+    const { OpenRouterProvider } =
+      await import("../providers/openrouter/client.js");
     const provider = new OpenRouterProvider(
       "ast-key",
       "anthropic/claude-opus-4.6",
@@ -2083,9 +2225,8 @@ describe("OpenRouterProvider — Anthropic dispatch", () => {
   });
 
   test("thinking config flows through to Anthropic Messages API natively", async () => {
-    const { OpenRouterProvider } = await import(
-      "../providers/openrouter/client.js"
-    );
+    const { OpenRouterProvider } =
+      await import("../providers/openrouter/client.js");
     const provider = new OpenRouterProvider(
       "or-key",
       "anthropic/claude-sonnet-4.6",
@@ -2100,10 +2241,24 @@ describe("OpenRouterProvider — Anthropic dispatch", () => {
     expect(lastStreamParams!.reasoning).toBeUndefined();
   });
 
-  test("per-request model override routes based on the overridden model", async () => {
-    const { OpenRouterProvider } = await import(
-      "../providers/openrouter/client.js"
+  test("disabled 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: "disabled" } },
+    });
+
+    expect(lastStreamParams!.thinking).toEqual({ type: "disabled" });
+    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");