@vellumai/assistant 0.8.6 → 0.8.7-dev.202606052118.34cd356

package/src/providers/openrouter/client.ts

@@ -10,7 +10,6 @@ import type {
   Message,
   ProviderResponse,
   SendMessageOptions,
-  ToolDefinition,
 } from "../types.js";
 import { ContextOverflowError, isContextOverflowError } from "../types.js";
 
@@ -123,6 +122,7 @@ export class OpenRouterProvider extends OpenAIChatCompletionsProvider {
       streamTimeoutMs: options.streamTimeoutMs,
       requestHeaders: OPENROUTER_APP_ATTRIBUTION_HEADERS,
       assistantReasoningField: "reasoning",
+      backfillEmptyAssistantContent: true,
     });
     this.openRouterApiKey = apiKey;
     this.defaultModel = model;
@@ -142,8 +142,6 @@ export class OpenRouterProvider extends OpenAIChatCompletionsProvider {
 
   override async sendMessage(
     messages: Message[],
-    tools?: ToolDefinition[],
-    systemPrompt?: string,
     options?: SendMessageOptions,
   ): Promise<ProviderResponse> {
     const effectiveModel = this.resolveEffectiveModel(options);
@@ -151,12 +149,10 @@ export class OpenRouterProvider extends OpenAIChatCompletionsProvider {
       if (isAnthropicModel(effectiveModel)) {
         return await this.getAnthropicInner().sendMessage(
           messages,
-          tools,
-          systemPrompt,
           withOpenRouterBodyExtras(options),
         );
       }
-      return await super.sendMessage(messages, tools, systemPrompt, options);
+      return await super.sendMessage(messages, options);
     } catch (error) {
       // Re-tag delegate-thrown ContextOverflowError so the outer provider name
       // matches the configured provider ("openrouter"). This keeps downstream

package/src/providers/placeholder-sentinels.ts

@@ -0,0 +1,35 @@
+// Internal placeholder sentinels injected as assistant-message content when a
+// turn would otherwise serialize with neither text nor tool calls. Provider
+// request bodies must keep a non-empty content slot (Anthropic to preserve
+// role alternation; strict OpenAI-compatible backends to satisfy the
+// "content or tool_calls must be set" constraint), but these markers must
+// never be persisted or rendered to users.
+//
+// The null-byte prefix makes the prefixed form impossible to produce via
+// normal model output or user input, preventing false positives. Some
+// OpenAI-compatible backends reject control characters in message content, so
+// the OpenAI path emits the bare (prefix-stripped) form, which
+// `isPlaceholderSentinelText` still recognizes.
+export const PLACEHOLDER_EMPTY_TURN =
+  "\x00__PLACEHOLDER__[empty assistant turn]";
+export const PLACEHOLDER_BLOCKS_OMITTED =
+  "\x00__PLACEHOLDER__[internal blocks omitted]";
+
+// Compared against the payload with any leading `\x00` stripped, so the check
+// matches both the prefixed sentinel we emit and any bare variant that lost
+// the null byte in transit (e.g. the model echoing the text back without
+// reproducing the control character).
+const PLACEHOLDER_SENTINEL_BARE: ReadonlySet<string> = new Set([
+  PLACEHOLDER_EMPTY_TURN.slice(1),
+  PLACEHOLDER_BLOCKS_OMITTED.slice(1),
+]);
+
+/**
+ * True when the text is one of the internal alternation-preserving sentinels,
+ * with or without the null-byte prefix. These must never be persisted or
+ * rendered to users — they exist only in outbound provider request bodies.
+ */
+export function isPlaceholderSentinelText(text: string): boolean {
+  const normalized = text.startsWith("\x00") ? text.slice(1) : text;
+  return PLACEHOLDER_SENTINEL_BARE.has(normalized);
+}

package/src/providers/provider-send-message.ts

@@ -22,7 +22,6 @@ import type {
   Provider,
   ProviderResponse,
   SendMessageOptions,
-  ToolDefinition,
   ToolUseContent,
 } from "./types.js";
 
@@ -56,16 +55,14 @@ export class CallSiteConfiguredProvider implements Provider {
 
   sendMessage(
     messages: Message[],
-    tools?: ToolDefinition[],
-    systemPrompt?: string,
     options?: SendMessageOptions,
   ): Promise<ProviderResponse> {
     const config = options?.config;
     if (config?.callSite) {
-      return this.inner.sendMessage(messages, tools, systemPrompt, options);
+      return this.inner.sendMessage(messages, options);
     }
 
-    return this.inner.sendMessage(messages, tools, systemPrompt, {
+    return this.inner.sendMessage(messages, {
       ...options,
       config: {
         ...config,
@@ -141,7 +138,10 @@ export async function resolveConfiguredProvider(
             resolved.model,
           );
           if (incompatMsg) {
-            log.warn({ callSite, inferenceProvider, model: resolved.model }, incompatMsg);
+            log.warn(
+              { callSite, inferenceProvider, model: resolved.model },
+              incompatMsg,
+            );
           }
         }
       } catch {

package/src/providers/ratelimit.ts

@@ -6,7 +6,6 @@ import type {
   Provider,
   ProviderResponse,
   SendMessageOptions,
-  ToolDefinition,
 } from "./types.js";
 
 const log = getLogger("rate-limit");
@@ -36,8 +35,6 @@ export class RateLimitProvider implements Provider {
 
   async sendMessage(
     messages: Message[],
-    tools?: ToolDefinition[],
-    systemPrompt?: string,
     options?: SendMessageOptions,
   ): Promise<ProviderResponse> {
     this.enforceRequestRate();
@@ -46,12 +43,7 @@ export class RateLimitProvider implements Provider {
     // calls from bypassing the rate limit during the async gap.
     this.recordRequest();
 
-    const response = await this.inner.sendMessage(
-      messages,
-      tools,
-      systemPrompt,
-      options,
-    );
+    const response = await this.inner.sendMessage(messages, options);
 
     return response;
   }

package/src/providers/retry.ts

@@ -23,7 +23,6 @@ import {
   type Provider,
   type ProviderResponse,
   type SendMessageOptions,
-  type ToolDefinition,
 } from "./types.js";
 
 const log = getLogger("retry");
@@ -525,8 +524,6 @@ export class RetryProvider implements Provider {
 
   async sendMessage(
     messages: Message[],
-    tools?: ToolDefinition[],
-    systemPrompt?: string,
     options?: SendMessageOptions,
   ): Promise<ProviderResponse> {
     let lastError: unknown;
@@ -541,8 +538,6 @@ export class RetryProvider implements Provider {
       try {
         const result = await this.inner.sendMessage(
           messages,
-          tools,
-          systemPrompt,
           normalizedOptions,
         );
         return result;

package/src/providers/types.ts

@@ -207,10 +207,21 @@ export interface SendMessageConfig {
   effort?: "none" | "low" | "medium" | "high" | "xhigh" | "max";
   speed?: "standard" | "fast";
   verbosity?: "low" | "medium" | "high";
+  /**
+   * When true, the most recent user message's content varies across
+   * otherwise-identical turns (e.g. a per-turn memory block was injected into
+   * it). The provider places the primary long-TTL cache breakpoint on the most
+   * recent *stable* user message instead of the volatile latest one, so the
+   * cached prefix stays reusable across turns. Default false — existing
+   * behavior.
+   */
+  mutableLatestUserMessage?: boolean;
   [key: string]: unknown;
 }
 
 export interface SendMessageOptions {
+  tools?: ToolDefinition[];
+  systemPrompt?: string;
   config?: SendMessageConfig;
   onEvent?: (event: ProviderEvent) => void;
   signal?: AbortSignal;
@@ -229,8 +240,6 @@ export interface Provider {
   tokenEstimationProvider?: string;
   sendMessage(
     messages: Message[],
-    tools?: ToolDefinition[],
-    systemPrompt?: string,
     options?: SendMessageOptions,
   ): Promise<ProviderResponse>;
 }

package/src/providers/usage-tracking.ts

@@ -11,7 +11,6 @@ import type {
   Provider,
   ProviderResponse,
   SendMessageOptions,
-  ToolDefinition,
 } from "./types.js";
 
 const log = getLogger("provider-usage-tracking");
@@ -27,16 +26,9 @@ export class UsageTrackingProvider implements Provider {
 
   async sendMessage(
     messages: Message[],
-    tools?: ToolDefinition[],
-    systemPrompt?: string,
     options?: SendMessageOptions,
   ): Promise<ProviderResponse> {
-    const response = await this.inner.sendMessage(
-      messages,
-      tools,
-      systemPrompt,
-      options,
-    );
+    const response = await this.inner.sendMessage(messages, options);
     this.recordUsage(response, options);
     return response;
   }

package/src/runtime/__tests__/agent-wake.test.ts

@@ -117,7 +117,11 @@ mock.module("../../memory/llm-request-log-store.js", () => ({
   backfillMessageIdOnLogs: () => {},
 }));
 
-import type { AgentEvent } from "../../agent/loop.js";
+import type {
+  AgentEvent,
+  AgentLoopRunOptions,
+  AgentLoopRunResult,
+} from "../../agent/loop.js";
 import type { Message } from "../../providers/types.js";
 import {
   __resetWakeChainForTests,
@@ -127,6 +131,17 @@ import {
 
 // ── Test helpers ─────────────────────────────────────────────────────
 
+// Wake runs never pause at a checkpoint — their onCheckpoint always returns
+// "continue" — so the loop result always carries a null pause-reason.
+const runResult = (history: Message[]): AgentLoopRunResult => ({
+  history,
+  exitReason: null,
+  appendedNewMessages: true,
+  // The wake path slices its own new-message boundary off the returned
+  // history (it never destructures `newMessages`), so this is type-only.
+  newMessages: [],
+});
+
 interface MockTarget extends WakeTarget {
   emittedEvents: AgentEvent[];
   pushedMessages: Message[];
@@ -134,6 +149,7 @@ interface MockTarget extends WakeTarget {
     input: Message[];
     requestId?: string;
     turnContext?: unknown;
+    allowedTools?: string[];
   }>;
   processingToggles: boolean[];
   /** Tail messages handed to `persistTailMessage`, in call order. */
@@ -152,6 +168,11 @@ interface MockTarget extends WakeTarget {
    * just inferring it from the order of recorded toggles.
    */
   processingDuringDrain: boolean[];
+  /**
+   * Tool allowlist snapshots captured whenever the wake applies/restores a
+   * scope. `undefined` means unrestricted.
+   */
+  allowedToolSnapshots: Array<string[] | undefined>;
 }
 
 function makeTarget(options: {
@@ -164,6 +185,7 @@ function makeTarget(options: {
   isProcessing?: boolean;
   /** When true, omit `drainQueue` so we can verify the wake handles its absence. */
   omitDrainQueue?: boolean;
+  initialAllowedTools?: Set<string>;
 }): MockTarget {
   const emittedEvents: AgentEvent[] = [];
   const pushedMessages: Message[] = [];
@@ -171,14 +193,19 @@ function makeTarget(options: {
     input: Message[];
     requestId?: string;
     turnContext?: unknown;
+    allowedTools?: string[];
   }> = [];
   const processingToggles: boolean[] = [];
   const persistedTailCalls: Message[] = [];
   const callSequence: string[] = [];
   const processingDuringDrain: boolean[] = [];
+  const allowedToolSnapshots: Array<string[] | undefined> = [];
   const history: Message[] = [...(options.baseline ?? [])];
   let processing = options.isProcessing ?? false;
   let drainQueueCalls = 0;
+  let activeAllowedTools = options.initialAllowedTools;
+  const snapshotAllowedTools = (): string[] | undefined =>
+    activeAllowedTools ? [...activeAllowedTools].sort() : undefined;
 
   const target: MockTarget = {
     conversationId: options.conversationId ?? "conv-test",
@@ -189,6 +216,7 @@ function makeTarget(options: {
     persistedTailCalls,
     callSequence,
     processingDuringDrain,
+    allowedToolSnapshots,
     get drainQueueCalls() {
       return drainQueueCalls;
     },
@@ -196,13 +224,14 @@ function makeTarget(options: {
       run: async (
         input: Message[],
         onEvent: (event: AgentEvent) => void | Promise<void>,
-        _signal?: AbortSignal,
-        requestId?: string,
-        _onCheckpoint?: unknown,
-        _callSite?: unknown,
-        turnContext?: unknown,
+        runOptions?: AgentLoopRunOptions,
       ) => {
-        runCalls.push({ input: [...input], requestId, turnContext });
+        runCalls.push({
+          input: [...input],
+          requestId: runOptions?.requestId,
+          turnContext: runOptions?.turnContext,
+          allowedTools: snapshotAllowedTools(),
+        });
         // Emit any scripted events the test wanted us to produce.
         for (const ev of options.scriptedEvents ?? []) {
           await onEvent(ev);
@@ -221,7 +250,7 @@ function makeTarget(options: {
             next.push(tailMsg);
           }
         }
-        return next;
+        return runResult(next);
       },
     },
     getMessages: () => history,
@@ -243,6 +272,19 @@ function makeTarget(options: {
       persistedTailCalls.push(msg);
       callSequence.push("persist");
     },
+    setWakeAllowedTools: (tools: ReadonlySet<string>) => {
+      const previous = activeAllowedTools;
+      activeAllowedTools = new Set(tools);
+      allowedToolSnapshots.push(snapshotAllowedTools());
+      callSequence.push(`tools:${snapshotAllowedTools()?.join(",") ?? "all"}`);
+      return () => {
+        activeAllowedTools = previous;
+        allowedToolSnapshots.push(snapshotAllowedTools());
+        callSequence.push(
+          `tools:${snapshotAllowedTools()?.join(",") ?? "all"}`,
+        );
+      };
+    },
     ...(options.omitDrainQueue
       ? {}
       : {
@@ -390,7 +432,7 @@ describe("wakeAgentForOpportunity", () => {
     expect(target.runCalls).toHaveLength(0);
   });
 
-  test("threads cleanup-mode injection context for explicit local-owner wakes", async () => {
+  test("builds a guardian turn context for explicit local-owner cleanup-mode wakes", async () => {
     mockDiskPressureStatus = {
       enabled: true,
       state: "critical",
@@ -421,11 +463,11 @@ describe("wakeAgentForOpportunity", () => {
 
     expect(result).toEqual({ invoked: true, producedToolCalls: false });
     expect(target.runCalls).toHaveLength(1);
-    expect(target.runCalls[0]!.turnContext).toMatchObject({
+    expect(target.runCalls[0]!.turnContext).toEqual({
+      requestId: "wake:local-cleanup",
       conversationId: target.conversationId,
-      injectionInputs: {
-        diskPressureContext: { cleanupModeActive: true },
-      },
+      turnIndex: 0,
+      trust: { sourceChannel: "vellum", trustClass: "guardian" },
     });
   });
 
@@ -491,6 +533,69 @@ describe("wakeAgentForOpportunity", () => {
     });
   });
 
+  test("scopes allowed tools during the wake and restores before queued messages drain", async () => {
+    const target = makeTarget({
+      initialAllowedTools: new Set(["bash"]),
+      scriptedAssistant: {
+        role: "assistant",
+        content: [{ type: "text", text: "Saved." }],
+      },
+    });
+
+    const result = await wakeAgentForOpportunity(
+      {
+        conversationId: target.conversationId,
+        hint: "review for memories",
+        source: "memory-retrospective",
+        allowedTools: ["remember"],
+      },
+      { resolveTarget: async () => target },
+    );
+
+    expect(result).toEqual({ invoked: true, producedToolCalls: false });
+    expect(target.runCalls[0]!.allowedTools).toEqual(["remember"]);
+    expect(target.allowedToolSnapshots).toEqual([["remember"], ["bash"]]);
+
+    const restoreIndex = target.callSequence.indexOf("tools:bash");
+    const processingFalseIndex =
+      target.callSequence.indexOf("processing:false");
+    const drainIndex = target.callSequence.indexOf("drain");
+    expect(restoreIndex).toBeGreaterThan(-1);
+    expect(restoreIndex).toBeLessThan(processingFalseIndex);
+    expect(processingFalseIndex).toBeLessThan(drainIndex);
+  });
+
+  test("restores allowed tools before drain when the wake is a silent no-op", async () => {
+    const target = makeTarget({
+      scriptedAssistant: {
+        role: "assistant",
+        content: [{ type: "text", text: "" }],
+      },
+    });
+
+    const result = await wakeAgentForOpportunity(
+      {
+        conversationId: target.conversationId,
+        hint: "review for memories",
+        source: "memory-retrospective",
+        allowedTools: ["remember"],
+      },
+      { resolveTarget: async () => target },
+    );
+
+    expect(result).toEqual({ invoked: true, producedToolCalls: false });
+    expect(target.runCalls[0]!.allowedTools).toEqual(["remember"]);
+    expect(target.allowedToolSnapshots).toEqual([["remember"], undefined]);
+
+    const restoreIndex = target.callSequence.indexOf("tools:all");
+    const processingFalseIndex =
+      target.callSequence.indexOf("processing:false");
+    const drainIndex = target.callSequence.indexOf("drain");
+    expect(restoreIndex).toBeGreaterThan(-1);
+    expect(restoreIndex).toBeLessThan(processingFalseIndex);
+    expect(processingFalseIndex).toBeLessThan(drainIndex);
+  });
+
   test("produces tool calls when LLM emits a tool_use block", async () => {
     const assistantMessage: Message = {
       role: "assistant",
@@ -605,9 +710,13 @@ describe("wakeAgentForOpportunity", () => {
     // hold the processing flag while agentLoop.run executes.
     const observedDuringRun: boolean[] = [];
     const originalRun = target.agentLoop.run;
-    target.agentLoop.run = async (input, onEvent, signal, requestId) => {
+    target.agentLoop.run = async (
+      input: Message[],
+      onEvent: (event: AgentEvent) => void | Promise<void>,
+      runOptions?: AgentLoopRunOptions,
+    ) => {
       observedDuringRun.push(target.isProcessing());
-      return originalRun(input, onEvent, signal, requestId);
+      return originalRun(input, onEvent, runOptions);
     };
 
     await wakeAgentForOpportunity(
@@ -677,7 +786,7 @@ describe("wakeAgentForOpportunity", () => {
       agentLoop: {
         run: async (input) => {
           runCalls.push(callOrder++);
-          return [...input];
+          return runResult([...input]);
         },
       },
       getMessages: () => history,
@@ -720,7 +829,7 @@ describe("wakeAgentForOpportunity", () => {
     const target: WakeTarget = {
       conversationId: "conv-no-trust",
       agentLoop: {
-        run: async (input) => [...input],
+        run: async (input) => runResult([...input]),
       },
       getMessages: () => history,
       pushMessage: () => {},
@@ -772,7 +881,7 @@ describe("wakeAgentForOpportunity", () => {
             await gate2.promise;
           }
           runCompleteOrder.push(myIndex);
-          return input; // no assistant message → silent no-op
+          return runResult(input); // no assistant message → silent no-op
         },
       },
       getMessages: () => history,
@@ -820,7 +929,7 @@ describe("wakeAgentForOpportunity", () => {
     const target: WakeTarget & { setProcessing: (v: boolean) => void } = {
       conversationId: "conv-user-turn",
       agentLoop: {
-        run: async (input) => input,
+        run: async (input) => runResult(input),
       },
       getMessages: () => history,
       pushMessage: (msg) => {
@@ -886,7 +995,7 @@ describe("wakeAgentForOpportunity", () => {
     const history: Message[] = [];
     const target: WakeTarget = {
       conversationId: "conv-busy",
-      agentLoop: { run: async () => history },
+      agentLoop: { run: async () => runResult(history) },
       getMessages: () => history,
       pushMessage: () => {},
       emitAgentEvent: () => {},
@@ -972,7 +1081,7 @@ describe("wakeAgentForOpportunity", () => {
     expect(target.drainQueueCalls).toBe(1);
     // Critical ordering invariant: drain runs after processing=false.
     // If drain ran while processing was still true,
-    // `enqueueMessage`'s `if (!ctx.processing) return ...` gate would
+    // `enqueueMessage`'s `if (!ctx.isProcessing()) return ...` gate would
     // see processing=true and the drained item would itself just
     // re-enqueue — no progress. Snapshot the live flag *inside* drain
     // (rather than inferring from toggle order) so a future regression
@@ -1296,7 +1405,7 @@ describe("wakeAgentForOpportunity", () => {
       const target: WakeTarget = {
         conversationId: "conv-stream",
         agentLoop: {
-          run: async (_input, onEvent, _signal, _requestId, onCheckpoint) => {
+          run: async (_input, onEvent, runOptions) => {
             // Preamble + assistant hint + postamble (mirrors what the
             // wake injects). The agent-wake helper expects these three
             // hint messages in the input it hands to run().
@@ -1311,7 +1420,7 @@ describe("wakeAgentForOpportunity", () => {
               message: turn1Assistant,
             });
             runHistory.push(turn1ToolResult);
-            const dec1 = await onCheckpoint!({
+            const dec1 = await runOptions!.onCheckpoint!({
               turnIndex: 0,
               toolCount: 1,
               hasToolUse: true,
@@ -1328,7 +1437,7 @@ describe("wakeAgentForOpportunity", () => {
               message: turn2Assistant,
             });
             runHistory.push(turn2ToolResult);
-            const dec2 = await onCheckpoint!({
+            const dec2 = await runOptions!.onCheckpoint!({
               turnIndex: 1,
               toolCount: 1,
               hasToolUse: true,
@@ -1345,7 +1454,7 @@ describe("wakeAgentForOpportunity", () => {
               type: "message_complete",
               message: finalAssistant,
             });
-            return runHistory;
+            return runResult(runHistory);
           },
         },
         getMessages: () => history,
@@ -1432,17 +1541,17 @@ describe("wakeAgentForOpportunity", () => {
       const target: WakeTarget = {
         conversationId: "conv-card",
         agentLoop: {
-          run: async (_input, _onEvent, _signal, _requestId, onCheckpoint) => {
+          run: async (_input, _onEvent, runOptions) => {
             const runHistory: Message[] = [..._input];
             runHistory.push(firstAssistant);
             runHistory.push(toolResult);
-            await onCheckpoint!({
+            await runOptions!.onCheckpoint!({
               turnIndex: 0,
               toolCount: 1,
               hasToolUse: true,
               history: runHistory,
             });
-            return runHistory;
+            return runResult(runHistory);
           },
         },
         getMessages: () => history,
@@ -1627,7 +1736,7 @@ describe("wakeAgentForOpportunity", () => {
     let processing = false;
     return {
       conversationId,
-      agentLoop: { run: async (input) => input },
+      agentLoop: { run: async (input) => runResult(input) },
       getMessages: () => history,
       pushMessage: () => {},
       emitAgentEvent: () => {},
@@ -1704,17 +1813,17 @@ describe("wakeAgentForOpportunity", () => {
       const target: WakeTarget = {
         conversationId: "conv-suppress-surface",
         agentLoop: {
-          run: async (_input, _onEvent, _signal, _requestId, onCheckpoint) => {
+          run: async (_input, _onEvent, runOptions) => {
             const runHistory: Message[] = [..._input];
             runHistory.push(firstAssistant);
             runHistory.push(toolResult);
-            await onCheckpoint!({
+            await runOptions!.onCheckpoint!({
               turnIndex: 0,
               toolCount: 1,
               hasToolUse: true,
               history: runHistory,
             });
-            return runHistory;
+            return runResult(runHistory);
           },
         },
         getMessages: () => history,

package/src/runtime/__tests__/background-job-runner.test.ts

@@ -46,7 +46,6 @@ mock.module("../../memory/conversation-crud.js", () => ({
 let processMessageImpl: (
   conversationId: string,
   content: string,
-  attachmentIds: string[] | undefined,
   options: Record<string, unknown> | undefined,
 ) => Promise<{ messageId: string }> = async () => ({ messageId: "msg-1" });
 const processMessageCalls: Array<{
@@ -59,11 +58,10 @@ mock.module("../../daemon/process-message.js", () => ({
   processMessage: async (
     conversationId: string,
     content: string,
-    attachmentIds: string[] | undefined,
     options: Record<string, unknown> | undefined,
   ) => {
     processMessageCalls.push({ conversationId, content, options });
-    return processMessageImpl(conversationId, content, attachmentIds, options);
+    return processMessageImpl(conversationId, content, options);
   },
 }));
 

package/src/runtime/__tests__/interactive-ui.test.ts

@@ -50,7 +50,7 @@ let surfaceCalls: Array<{
   surfaceId: string;
 }> = [];
 
-mock.module("../../daemon/conversation-store.js", () => ({
+mock.module("../../daemon/conversation-registry.js", () => ({
   findConversation: (_conversationId: string) => {
     return mockConversation ?? undefined;
   },