@vellumai/assistant 0.8.4 → 0.8.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.8.4",
+  "version": "0.8.6",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/actor-token-service.test.ts

@@ -29,7 +29,7 @@ mock.module("../config/env.js", () => ({
   checkUnrecognizedEnvVars: () => {},
 }));
 
-import { getDb, resetDb } from "../memory/db-connection.js";
+import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { resetExternalAssistantIdCache } from "../runtime/auth/external-assistant-id.js";
 import { initAuthSigningKey } from "../runtime/auth/token-service.js";
@@ -37,6 +37,7 @@ import {
   resolveLocalAuthContext,
   resolveLocalTrustContext,
 } from "../runtime/local-actor-identity.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 
 // ---------------------------------------------------------------------------
 // Test signing key
@@ -50,7 +51,7 @@ initializeDb();
 beforeEach(() => {
   initAuthSigningKey(TEST_KEY);
   resetExternalAssistantIdCache();
-  resetDb();
+  resetDbForTesting();
   initializeDb();
 });
 

package/src/__tests__/agent-loop-exit-reason.test.ts

@@ -21,7 +21,7 @@ import type {
   CheckpointDecision,
   CheckpointInfo,
 } from "../agent/loop.js";
-import { AgentLoop } from "../agent/loop.js";
+import { AgentLoop, isMaxTokensStopReason } from "../agent/loop.js";
 import type {
   Message,
   Provider,
@@ -63,6 +63,18 @@ function textResponse(text: string): ProviderResponse {
   };
 }
 
+function maxTokensResponse(
+  text: string,
+  stopReason: string = "max_tokens",
+): ProviderResponse {
+  return {
+    content: [{ type: "text", text }],
+    model: "mock-model",
+    usage: { inputTokens: 10, outputTokens: 5 },
+    stopReason,
+  };
+}
+
 function toolUseResponse(
   id: string,
   name: string,
@@ -107,6 +119,15 @@ function countExitEvents(events: AgentEvent[]): number {
 // ---------------------------------------------------------------------------
 
 describe("AgentLoop exit-reason instrumentation", () => {
+  test("recognizes provider output-token stop reasons", () => {
+    expect(isMaxTokensStopReason("max_tokens")).toBe(true);
+    expect(isMaxTokensStopReason("MAX_TOKENS")).toBe(true);
+    expect(isMaxTokensStopReason("length")).toBe(true);
+    expect(isMaxTokensStopReason("max_output_tokens")).toBe(true);
+    expect(isMaxTokensStopReason("end_turn")).toBe(false);
+    expect(isMaxTokensStopReason(undefined)).toBe(false);
+  });
+
   test("emits exit event exactly once with 'no_tool_calls' on plain text response", async () => {
     const { provider } = createMockProvider([textResponse("Hi there!")]);
     const loop = new AgentLoop(provider, "system prompt");
@@ -134,6 +155,59 @@ describe("AgentLoop exit-reason instrumentation", () => {
     expect(events[events.length - 1].type).toBe("agent_loop_exit");
   });
 
+  test("emits continuation surface event and exits on max_tokens", async () => {
+    const { provider } = createMockProvider([
+      maxTokensResponse("Partial answer"),
+    ]);
+    const loop = new AgentLoop(provider, "system prompt");
+
+    const events: AgentEvent[] = [];
+    await loop.run([userMessage], (e) => {
+      events.push(e);
+    });
+
+    expect(events.map((e) => e.type)).toEqual([
+      "llm_call_started",
+      "usage",
+      "max_tokens_reached",
+      "message_complete",
+      "agent_loop_exit",
+    ]);
+    expect(countExitEvents(events)).toBe(1);
+    expect(lastExitEvent(events)?.reason).toBe("max_tokens_reached");
+  });
+
+  test("does not persist unexecuted tool_use blocks when max_tokens stops output", async () => {
+    const { provider } = createMockProvider([
+      {
+        content: [
+          { type: "text", text: "I need to check that." },
+          {
+            type: "tool_use",
+            id: "tool-1",
+            name: "read_file",
+            input: { path: "/tmp/example.txt" },
+          },
+        ],
+        model: "mock-model",
+        usage: { inputTokens: 10, outputTokens: 5 },
+        stopReason: "max_tokens",
+      },
+    ]);
+    const loop = new AgentLoop(provider, "system prompt", {}, dummyTools);
+
+    const events: AgentEvent[] = [];
+    const result = await loop.run([userMessage], (e) => {
+      events.push(e);
+    });
+
+    expect(events.some((e) => e.type === "tool_use")).toBe(false);
+    expect(lastExitEvent(events)?.reason).toBe("max_tokens_reached");
+    expect(result[result.length - 1]!.content).toEqual([
+      { type: "text", text: "I need to check that." },
+    ]);
+  });
+
   test("emits 'aborted_pre_call' when signal is already aborted at run start", async () => {
     const { provider } = createMockProvider([textResponse("never sent")]);
     const loop = new AgentLoop(provider, "system prompt");
@@ -142,7 +216,13 @@ describe("AgentLoop exit-reason instrumentation", () => {
     controller.abort();
 
     const events: AgentEvent[] = [];
-    await loop.run([userMessage], (e) => { events.push(e); }, controller.signal);
+    await loop.run(
+      [userMessage],
+      (e) => {
+        events.push(e);
+      },
+      controller.signal,
+    );
 
     expect(countExitEvents(events)).toBe(1);
     expect(lastExitEvent(events)?.reason).toBe("aborted_pre_call");
@@ -166,7 +246,9 @@ describe("AgentLoop exit-reason instrumentation", () => {
     );
 
     const events: AgentEvent[] = [];
-    await loop.run([userMessage], (e) => { events.push(e); });
+    await loop.run([userMessage], (e) => {
+      events.push(e);
+    });
 
     expect(countExitEvents(events)).toBe(1);
     expect(lastExitEvent(events)?.reason).toBe("yield_to_user");
@@ -186,13 +268,14 @@ describe("AgentLoop exit-reason instrumentation", () => {
       toolExecutor,
     );
 
-    const onCheckpoint = (_info: CheckpointInfo): CheckpointDecision =>
-      "yield";
+    const onCheckpoint = (_info: CheckpointInfo): CheckpointDecision => "yield";
 
     const events: AgentEvent[] = [];
     await loop.run(
       [userMessage],
-      (e) => { events.push(e); },
+      (e) => {
+        events.push(e);
+      },
       undefined,
       undefined,
       onCheckpoint,
@@ -211,7 +294,9 @@ describe("AgentLoop exit-reason instrumentation", () => {
     const loop = new AgentLoop(provider, "system prompt");
 
     const events: AgentEvent[] = [];
-    await loop.run([userMessage], (e) => { events.push(e); });
+    await loop.run([userMessage], (e) => {
+      events.push(e);
+    });
 
     expect(countExitEvents(events)).toBe(1);
     expect(lastExitEvent(events)?.reason).toBe("error");
@@ -238,7 +323,9 @@ describe("AgentLoop exit-reason instrumentation", () => {
     );
 
     const events: AgentEvent[] = [];
-    await loop.run([userMessage], (e) => { events.push(e); });
+    await loop.run([userMessage], (e) => {
+      events.push(e);
+    });
 
     expect(countExitEvents(events)).toBe(1);
   });
@@ -263,7 +350,13 @@ describe("AgentLoop exit-reason instrumentation", () => {
     );
 
     const events: AgentEvent[] = [];
-    await loop.run([userMessage], (e) => { events.push(e); }, controller.signal);
+    await loop.run(
+      [userMessage],
+      (e) => {
+        events.push(e);
+      },
+      controller.signal,
+    );
 
     expect(countExitEvents(events)).toBe(1);
     expect(lastExitEvent(events)?.reason).toBe("aborted_during_tools");

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

@@ -223,7 +223,7 @@ class FakeConversation {
     return Promise.resolve();
   }
   persistUserMessage() {
-    return Promise.resolve("msg-id");
+    return Promise.resolve({ id: "msg-id", deduplicated: false });
   }
   runAgentLoop(
     _content: string,
@@ -353,6 +353,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   // Always return undefined for the row read so the test fails fast unless
   // executeSubagentSpawn reads from context.overrideProfile first.
   getConversationOverrideProfile: () => undefined,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 import { getSubagentManager } from "../subagent/index.js";

package/src/__tests__/agent-wake-disk-pressure-callsite.test.ts

@@ -22,6 +22,7 @@ import type { Message } from "../providers/types.js";
 
 mock.module("../memory/conversation-crud.js", () => ({
   getConversationOverrideProfile: () => undefined,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../config/loader.js", () => ({

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

@@ -32,6 +32,7 @@ let mockOverrideProfile: string | undefined = undefined;
 
 mock.module("../memory/conversation-crud.js", () => ({
   getConversationOverrideProfile: (_id: string) => mockOverrideProfile,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 // Mutable stub for `getConfig().llm` consumed by `RetryProvider`'s

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

@@ -14,12 +14,12 @@
 import { afterAll, describe, expect, test } from "bun:test";
 
 import {
-  buildToolDefinitions,
   isToolActiveForContext,
   type SkillProjectionContext,
 } from "../daemon/conversation-tool-setup.js";
 import {
   __resetRegistryForTesting,
+  getAllToolDefinitions,
   initializeTools,
 } from "../tools/registry.js";
 
@@ -30,7 +30,7 @@ afterAll(() => {
 describe("always-loaded tool count", () => {
   test("should be exactly 11 with recall occupying the existing slot", async () => {
     await initializeTools();
-    const allDefs = buildToolDefinitions();
+    const allDefs = getAllToolDefinitions();
 
     // Minimal context: no client, no capabilities
     const minimalContext: SkillProjectionContext = {

package/src/__tests__/annotate-risk-options.test.ts

@@ -57,6 +57,7 @@ mock.module("../memory/conversation-crud.js", () => ({
     updates.push({ id, content });
   },
   provenanceFromTrustContext: () => ({}),
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/llm-request-log-store.js", () => ({

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

@@ -102,7 +102,6 @@ mock.module("@anthropic-ai/sdk", () => ({
 }));
 
 // Import after mocking
-import { SYSTEM_PROMPT_CACHE_BOUNDARY } from "../prompts/system-prompt.js";
 import {
   AnthropicProvider,
   isPlaceholderSentinelText,
@@ -228,28 +227,8 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     expect(assistant?.content).toEqual([{ type: "text", text: "I can help." }]);
   });
 
-  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.";
-    const prompt = staticBlock + SYSTEM_PROMPT_CACHE_BOUNDARY + dynamicBlock;
-
-    await provider.sendMessage([userMsg("Hi")], undefined, prompt);
-
-    const system = lastStreamParams!.system as Array<{
-      type: string;
-      text: string;
-      cache_control?: { type: string; ttl?: string };
-    }>;
-    expect(system).toHaveLength(2);
-    expect(system[0].text).toBe(staticBlock);
-    expect(system[0].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
-    expect(system[1].text).toBe(dynamicBlock);
-    expect(system[1].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
-  });
-
-  test("omits empty dynamic system block after cache boundary", async () => {
-    const staticBlock = "You are a helpful assistant.";
-    const prompt = staticBlock + SYSTEM_PROMPT_CACHE_BOUNDARY;
+  test("renders the system prompt as a single 1h-cached block", async () => {
+    const prompt = "You are a helpful assistant.";
 
     await provider.sendMessage([userMsg("Hi")], undefined, prompt);
 
@@ -259,16 +238,14 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
       cache_control?: { type: string; ttl?: string };
     }>;
     expect(system).toHaveLength(1);
-    expect(system[0].text).toBe(staticBlock);
+    expect(system[0].text).toBe(prompt);
     expect(system[0].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
   });
 
-  test("drops static system block cache_control when total would exceed 4", async () => {
-    const staticBlock = "You are a helpful assistant.";
-    const dynamicBlock = "User workspace files here.";
-    const prompt = staticBlock + SYSTEM_PROMPT_CACHE_BOUNDARY + dynamicBlock;
-
-    // Boundary (2 system) + tools (1) + turn-start (1) + tail (1) = 5 → must cap at 4
+  test("applies the standard 4-breakpoint cache layout in a tool-use loop", async () => {
+    // system(1) + tools(1) + turn-start(1) + tail(1) = 4, the Anthropic
+    // per-request cap.  All four breakpoints should be present.
+    const prompt = "You are a helpful assistant.";
     const messages: Message[] = [
       userMsg("Do something"),
       toolUseMsg("tu_1", "bash"),
@@ -281,13 +258,9 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
       text: string;
       cache_control?: { type: string; ttl?: string };
     }>;
-    expect(system).toHaveLength(2);
-    // Static block's cache_control dropped (small, cheap to re-read)
-    expect(system[0].cache_control).toBeUndefined();
-    // Dynamic block keeps its cache_control
-    expect(system[1].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
+    expect(system).toHaveLength(1);
+    expect(system[0].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
 
-    // Tools breakpoint still present
     const tools = lastStreamParams!.tools as Array<{
       cache_control?: { type: string; ttl?: string };
     }>;
@@ -296,7 +269,6 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
       ttl: "1h",
     });
 
-    // Turn-start + tail breakpoints still present
     const sent = lastStreamParams!.messages as Array<{
       role: string;
       content: Array<{
@@ -432,6 +404,31 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     expect(lastBlock.cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
   });
 
+  test("disableTurnStartCache suppresses the 1h breakpoint on the turn-starting user message", async () => {
+    // One-shot callers (e.g. the memory router) send a single user message
+    // per call with content that changes every time. Caching the turn-start
+    // block would create unused entries — `disableTurnStartCache: true`
+    // opts out.
+    await provider.sendMessage(
+      [userMsg("Pick relevant pages")],
+      undefined,
+      undefined,
+      {
+        config: { disableTurnStartCache: true },
+      },
+    );
+
+    const sent = lastStreamParams!.messages as Array<{
+      role: string;
+      content: Array<{
+        type: string;
+        cache_control?: { type: string; ttl?: string };
+      }>;
+    }>;
+    const lastBlock = sent[0].content[sent[0].content.length - 1];
+    expect(lastBlock.cache_control).toBeUndefined();
+  });
+
   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

package/src/__tests__/approval-cascade.test.ts

@@ -151,6 +151,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   addMessage: () => ({ id: `msg-${Date.now()}` }),
   updateConversationUsage: () => {},
   updateConversationTitle: () => {},
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({

package/src/__tests__/approval-routes-http.test.ts

@@ -154,13 +154,9 @@ function makeIdleSession(opts?: {
   let processing = false;
   return {
     isProcessing: () => processing,
-    persistUserMessage: (
-      _content: string,
-      _attachments: unknown[],
-      requestId?: string,
-    ) => {
+    persistUserMessage: (options: { requestId?: string }) => {
       processing = true;
-      return requestId ?? "msg-1";
+      return { id: options.requestId ?? "msg-1", deduplicated: false };
     },
     memoryPolicy: {
       scopeId: "default",
@@ -223,13 +219,9 @@ function makeConfirmationEmittingSession(opts?: {
   const tool = opts?.toolName ?? "shell_command";
   return {
     isProcessing: () => processing,
-    persistUserMessage: (
-      _content: string,
-      _attachments: unknown[],
-      requestId?: string,
-    ) => {
+    persistUserMessage: (options: { requestId?: string }) => {
       processing = true;
-      return requestId ?? "msg-1";
+      return { id: options.requestId ?? "msg-1", deduplicated: false };
     },
     memoryPolicy: {
       scopeId: "default",
@@ -266,7 +258,11 @@ function makeConfirmationEmittingSession(opts?: {
           input: { command: "ls" },
           riskLevel: "medium",
           allowlistOptions: [
-            { label: "Allow ls", description: "Allow ls command", pattern: "ls" },
+            {
+              label: "Allow ls",
+              description: "Allow ls command",
+              pattern: "ls",
+            },
           ],
           scopeOptions: [{ label: "This conversation", scope: "session" }],
           persistentDecisionsAllowed: true,

package/src/__tests__/assert-not-live-db.ts

@@ -0,0 +1,79 @@
+/**
+ * Test-only utilities for safely interacting with on-disk DB files.
+ *
+ * Two exports:
+ *
+ * - `assertNotLiveDb(dbPath)` — per-callsite guard. Throws unless the
+ *   path resolves under `os.tmpdir()`. Use it before any custom
+ *   destructive operation not covered by `removeTestDbFiles`.
+ * - `removeTestDbFiles(dbPath)` — guarded `rmSync` of the DB file and
+ *   its sibling `-shm` / `-wal` files. The standard way to clear a
+ *   test DB between migrations.
+ *
+ * Defence-in-depth complement to the test-preload-verifier
+ * (`os.tmpdir()` containment check during preload). If a future bug
+ * lets a test see a non-tmpdir path despite the preload guard, every
+ * destructive call still has its own line of defence.
+ *
+ * Positive assertion: the path MUST resolve under `os.tmpdir()`. Same
+ * shape as the preload verifier — no enumeration of "real" paths,
+ * works across every deployment.
+ *
+ * No source-module imports — only node stdlib. Helpers in `__tests__/`
+ * must not import from `src/` (see assistant/AGENTS.md). Callers pass
+ * the resolved `dbPath` in so this file stays decoupled from
+ * `src/util/platform.ts`.
+ */
+
+import { realpathSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, sep } from "node:path";
+
+function canonicalize(p: string): string {
+  try {
+    return realpathSync(p);
+  } catch {
+    // realpathSync throws if the path doesn't exist. Fall back to the
+    // parent directory — which must exist for any rmSync target that's
+    // about to be touched. Returning the parent path here lets the
+    // containment check succeed in the common "file already deleted"
+    // case (rmSync with `force: true`) without falsely failing.
+    try {
+      return realpathSync(dirname(p));
+    } catch {
+      return p;
+    }
+  }
+}
+
+export function assertNotLiveDb(dbPath: string): void {
+  const resolved = canonicalize(dbPath);
+  const tmpRoot = canonicalize(tmpdir());
+  if (resolved !== tmpRoot && !resolved.startsWith(tmpRoot + sep)) {
+    throw new Error(
+      [
+        `assertNotLiveDb refused: ${dbPath} resolves to ${resolved}, which is not under ${tmpRoot}.`,
+        "",
+        "Test code must never destructively touch a DB path outside the",
+        "process temp directory. If you're seeing this in a passing test,",
+        "the test-preload likely didn't run (the verifier should have",
+        "caught that already — investigate why it didn't).",
+      ].join("\n"),
+    );
+  }
+}
+
+/**
+ * Remove a SQLite DB file and its sibling `-shm` / `-wal` files. Always
+ * `force: true` (no error if the file doesn't exist yet). Guarded by
+ * `assertNotLiveDb` so a test can never destroy a non-tmpdir path.
+ *
+ * Caller passes `dbPath` (typically `getDbPath()` from the test file)
+ * to keep this helper free of source-module imports.
+ */
+export function removeTestDbFiles(dbPath: string): void {
+  assertNotLiveDb(dbPath);
+  rmSync(dbPath, { force: true });
+  rmSync(`${dbPath}-shm`, { force: true });
+  rmSync(`${dbPath}-wal`, { force: true });
+}