@vellumai/assistant 0.8.5 → 0.8.7

package/src/__tests__/conversation-inference-profile-list.test.ts

@@ -42,9 +42,10 @@ import {
   createConversation,
   setConversationInferenceProfile,
 } from "../memory/conversation-crud.js";
-import { getDb, resetDb } from "../memory/db-connection.js";
+import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { RuntimeHttpServer } from "../runtime/http-server.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 
 initializeDb();
 
@@ -65,7 +66,7 @@ describe("conversation HTTP responses include inferenceProfile", () => {
 
   afterAll(async () => {
     await server?.stop();
-    resetDb();
+    resetDbForTesting();
   });
 
   test("GET /v1/conversations includes inferenceProfile for pinned conversations and omits it when unset", async () => {

package/src/__tests__/conversation-inference-profile-route.test.ts

@@ -30,11 +30,12 @@ import {
   createConversation,
   getConversation,
 } from "../memory/conversation-crud.js";
-import { getDb, resetDb } from "../memory/db-connection.js";
+import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { ROUTES } from "../runtime/routes/conversation-management-routes.js";
 import { BadRequestError, NotFoundError } from "../runtime/routes/errors.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 
 initializeDb();
 
@@ -57,7 +58,7 @@ describe("PUT /v1/conversations/:id/inference-profile", () => {
   });
 
   afterAll(() => {
-    resetDb();
+    resetDbForTesting();
     mock.restore();
   });
 

package/src/__tests__/conversation-init.benchmark.test.ts

@@ -345,9 +345,9 @@ describe("End-to-end session creation benchmark", () => {
       "bench-warmup-0",
       mockProvider,
       systemPrompt,
-      64000,
       noop,
       testDir,
+      { maxTokens: 64000 },
     );
     await warmup.loadFromDb();
     warmup.dispose();
@@ -360,9 +360,9 @@ describe("End-to-end session creation benchmark", () => {
         id,
         mockProvider,
         systemPrompt,
-        64000,
         noop,
         testDir,
+        { maxTokens: 64000 },
       );
       await session.loadFromDb();
       timings.push(performance.now() - start);
@@ -388,9 +388,9 @@ describe("End-to-end session creation benchmark", () => {
       "bench-warmup-s",
       mockProvider,
       systemPrompt,
-      64000,
       noop,
       testDir,
+      { maxTokens: 64000 },
     );
     warmup.preactivatedSkillIds = testSkillIds;
     await warmup.loadFromDb();
@@ -410,9 +410,9 @@ describe("End-to-end session creation benchmark", () => {
         id,
         mockProvider,
         systemPrompt,
-        64000,
         noop,
         testDir,
+        { maxTokens: 64000 },
       );
       session.preactivatedSkillIds = testSkillIds;
       await session.loadFromDb();
@@ -446,9 +446,9 @@ describe("End-to-end session creation benchmark", () => {
       "bench-events-w",
       mockProvider,
       systemPrompt,
-      64000,
       noop,
       testDir,
+      { maxTokens: 64000 },
     );
     warmup.dispose();
 
@@ -459,9 +459,9 @@ describe("End-to-end session creation benchmark", () => {
         `bench-events-${i}`,
         mockProvider,
         systemPrompt,
-        64000,
         noop,
         testDir,
+        { maxTokens: 64000 },
       );
       timings.push(performance.now() - start);
 

package/src/__tests__/conversation-lifecycle.test.ts

@@ -89,8 +89,9 @@ mock.module("../memory/conversation-crud.js", () => ({
     _conversationId: string,
     role: string,
     content: string,
-    metadata?: Record<string, unknown>,
+    options?: { metadata?: Record<string, unknown> },
   ) => {
+    const metadata = options?.metadata;
     const id = `persisted-${nextMockMessageId++}`;
     mockDbMessages.push({
       id,
@@ -102,6 +103,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   },
   setConversationOriginChannelIfUnset: () => {},
   setConversationOriginInterfaceIfUnset: () => {},
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({
@@ -124,9 +126,9 @@ function makeConversation(): Conversation {
     "conv-1",
     provider,
     "system prompt",
-    4096,
     () => {},
     "/tmp",
+    { maxTokens: 4096 },
   );
   // Default to guardian trust so tests load all messages.
   conv.setTrustContext({ trustClass: "guardian", sourceChannel: "vellum" });

package/src/__tests__/conversation-list-source.test.ts

@@ -44,9 +44,10 @@ mock.module("../config/loader.js", () => ({
 }));
 
 import { createConversation } from "../memory/conversation-crud.js";
-import { getDb, resetDb } from "../memory/db-connection.js";
+import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { RuntimeHttpServer } from "../runtime/http-server.js";
+import { resetDbForTesting } from "./db-test-helpers.js";
 
 initializeDb();
 
@@ -68,7 +69,7 @@ describe("GET /v1/conversations includes source discriminator", () => {
 
   afterAll(async () => {
     await server?.stop();
-    resetDb();
+    resetDbForTesting();
   });
 
   test("returns source for every listed conversation", async () => {

package/src/__tests__/conversation-load-history-repair.test.ts

@@ -91,8 +91,9 @@ mock.module("../memory/conversation-crud.js", () => ({
     _conversationId: string,
     role: string,
     content: string,
-    metadata?: Record<string, unknown>,
+    options?: { metadata?: Record<string, unknown> },
   ) => {
+    const metadata = options?.metadata;
     const id = `persisted-${nextMockMessageId++}`;
     mockDbMessages.push({
       id,
@@ -104,6 +105,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   },
   setConversationOriginChannelIfUnset: () => {},
   setConversationOriginInterfaceIfUnset: () => {},
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({
@@ -126,9 +128,9 @@ function makeConversation(): Conversation {
     "conv-1",
     provider,
     "system prompt",
-    4096,
     () => {},
     "/tmp",
+    { maxTokens: 4096 },
   );
   // Default to guardian trust so history repair tests load all messages.
   // Tests that exercise untrusted-actor filtering override this explicitly.
@@ -535,7 +537,7 @@ describe("loadFromDb history repair", () => {
       trustClass: "guardian",
       sourceChannel: "telegram",
     });
-    await conversation.persistUserMessage("Guardian follow-up", []);
+    await conversation.persistUserMessage({ content: "Guardian follow-up" });
     const messagesAfterPersist = conversation.getMessages();
 
     expect(messagesAfterPersist).toHaveLength(5);

package/src/__tests__/conversation-load-history-stripped.test.ts

@@ -87,6 +87,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   setConversationHistoryStrippedAt: () => {},
   setConversationOriginChannelIfUnset: () => {},
   setConversationOriginInterfaceIfUnset: () => {},
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({
@@ -109,9 +110,9 @@ function makeConversation(): Conversation {
     "conv-1",
     provider,
     "system prompt",
-    4096,
     () => {},
     "/tmp",
+    { maxTokens: 4096 },
   );
   conv.setTrustContext({ trustClass: "guardian", sourceChannel: "vellum" });
   return conv;

package/src/__tests__/conversation-message-sync-tags.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, test } from "bun:test";
 
 import {
   conversationMessagesSyncTag,
-  type SyncChangedMessage,
+  type SyncChangedEvent,
 } from "../daemon/message-types/sync.js";
 import type { AssistantEvent } from "../runtime/assistant-event.js";
 import {
@@ -34,12 +34,11 @@ async function captureEvents(
   }
 }
 
-function syncMessages(events: AssistantEvent[]): SyncChangedMessage[] {
+function syncMessages(events: AssistantEvent[]): SyncChangedEvent[] {
   return events
     .map((event) => event.message)
     .filter(
-      (message): message is SyncChangedMessage =>
-        message.type === "sync_changed",
+      (message): message is SyncChangedEvent => message.type === "sync_changed",
     );
 }
 

package/src/__tests__/conversation-pairing.test.ts

@@ -39,8 +39,7 @@ const addMessageMock = mock(
     _conversationId: string,
     _role: string,
     _content: string,
-    _metadata?: unknown,
-    _opts?: unknown,
+    _options?: unknown,
   ) => {
     if (addMessageShouldThrow) throw new Error("DB write failed");
     return { id: mockMessageId };
@@ -67,6 +66,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   createConversation: createConversationMock,
   addMessage: addMessageMock,
   getConversation: getConversationMock,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 /** Simulated bindings for external-conversation-store mock. */
@@ -103,6 +103,7 @@ import type {
   NotificationChannel,
   RenderedChannelCopy,
 } from "../notifications/types.js";
+import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 
 // ── Test helpers ────────────────────────────────────────────────────────
 
@@ -122,6 +123,11 @@ function makeSignal(
       isAsyncBackground: true,
       visibleInSourceNow: false,
     },
+    // Most existing pairing tests pre-date the passive-by-default gate and
+    // exercise the conversation-creation path. Default to the opt-in flag so
+    // they continue to assert creation semantics; the dedicated passive-gate
+    // test below explicitly omits it to cover the new default.
+    requiresConversation: true,
     ...overrides,
   };
 }
@@ -149,6 +155,10 @@ describe("pairDeliveryWithConversation", () => {
     addMessageShouldThrow = false;
     mockExistingConversations = {};
     mockBindings = {};
+    // The passive-suppression gate requires the home-page flag; default it on
+    // so the existing creation/suppression expectations hold. The dedicated
+    // flag-off test below overrides this to assert the create fallback.
+    setOverridesForTesting({ "home-page": true });
   });
 
   // ── start_new_conversation (vellum) ─────────────────────────────────
@@ -286,8 +296,11 @@ describe("pairDeliveryWithConversation", () => {
       copy,
     );
 
-    const optsArg = addMessageMock.mock.calls[0]![4] as Record<string, unknown>;
-    expect(optsArg.skipIndexing).toBe(true);
+    const optionsArg = addMessageMock.mock.calls[0]![3] as Record<
+      string,
+      unknown
+    >;
+    expect(optionsArg.skipIndexing).toBe(true);
   });
 
   // ── continue_existing_conversation (telegram) ─────────────────────
@@ -815,6 +828,76 @@ describe("pairDeliveryWithConversation", () => {
     expect(getBindingByChannelChatMock).not.toHaveBeenCalled();
   });
 
+  // ── Passive default: vellum no-creates without opt-in ─────────────
+
+  test("passive vellum signal does not create a conversation or message", async () => {
+    const signal = makeSignal({ requiresConversation: undefined });
+    const copy = makeCopy();
+
+    const result = await pairDeliveryWithConversation(
+      signal,
+      "vellum" as NotificationChannel,
+      copy,
+    );
+
+    expect(result.conversationId).toBeNull();
+    expect(result.messageId).toBeNull();
+    expect(result.strategy).toBe("start_new_conversation");
+    expect(result.createdNewConversation).toBe(false);
+    expect(result.conversationFallbackUsed).toBe(false);
+    expect(createConversationMock).not.toHaveBeenCalled();
+    expect(addMessageMock).not.toHaveBeenCalled();
+  });
+
+  test("passive vellum signal creates a conversation when home-page flag is off", async () => {
+    // Without the home feed there is no surface for passive notifications, so
+    // the suppression is gated off and pairing falls back to creating a
+    // conversation (the pre-home-feed behavior).
+    setOverridesForTesting({ "home-page": false });
+    const signal = makeSignal({ requiresConversation: undefined });
+    const copy = makeCopy();
+
+    const result = await pairDeliveryWithConversation(
+      signal,
+      "vellum" as NotificationChannel,
+      copy,
+    );
+
+    expect(result.conversationId).toBe("conv-001");
+    expect(result.messageId).toBe("msg-001");
+    expect(result.strategy).toBe("start_new_conversation");
+    expect(result.createdNewConversation).toBe(true);
+    expect(result.conversationFallbackUsed).toBe(false);
+    expect(createConversationMock).toHaveBeenCalledTimes(1);
+    expect(addMessageMock).toHaveBeenCalledTimes(1);
+  });
+
+  test("passive vellum signal still honors explicit reuse_existing action", async () => {
+    mockExistingConversations["conv-explicit-passive"] = {
+      id: "conv-explicit-passive",
+      source: "notification",
+      title: "Existing",
+    };
+    const signal = makeSignal({ requiresConversation: undefined });
+    const copy = makeCopy();
+    const conversationAction: ConversationAction = {
+      action: "reuse_existing",
+      conversationId: "conv-explicit-passive",
+    };
+
+    const result = await pairDeliveryWithConversation(
+      signal,
+      "vellum" as NotificationChannel,
+      copy,
+      { conversationAction },
+    );
+
+    expect(result.conversationId).toBe("conv-explicit-passive");
+    expect(result.createdNewConversation).toBe(false);
+    expect(createConversationMock).not.toHaveBeenCalled();
+    expect(addMessageMock).toHaveBeenCalledTimes(1);
+  });
+
   // ── conversationMetadata.conversationType override ─────────────────
 
   test("uses conversationMetadata.conversationType when set, overriding channel strategy", async () => {

package/src/__tests__/conversation-pre-run-repair.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 
-import { repairHistory } from "../daemon/history-repair.js";
+import { repairHistory } from "../plugins/defaults/history-repair/terminal.js";
 import type { Message } from "../providers/types.js";
 
 describe("pre-run history repair", () => {

package/src/__tests__/conversation-process-app-control-preactivation.test.ts

@@ -33,7 +33,10 @@ mock.module("../util/logger.js", () => ({
  * a connected macOS client for cross-client drain-path coverage. Reset in
  * afterEach so tests don't bleed state.
  */
-let mockCapabilityClients: Array<{ clientId: string; actorPrincipalId?: string }> = [];
+let mockCapabilityClients: Array<{
+  clientId: string;
+  actorPrincipalId?: string;
+}> = [];
 
 mock.module("../runtime/assistant-event-hub.js", () => ({
   assistantEventHub: {
@@ -50,6 +53,7 @@ mock.module("../memory/conversation-crud.js", () => ({
     trustContext: undefined,
   }),
   addMessage: () => ({ id: "msg-mock" }),
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/canonical-guardian-store.js", () => ({
@@ -77,7 +81,10 @@ mock.module("../agent/attachments.ts", () => ({
 // SQLite paths after the preactivation block has already run. The drain
 // chain doesn't recurse here because our stubbed `runAgentLoop` is a no-op.
 mock.module("../daemon/conversation-messaging.js", () => ({
-  persistQueuedMessageBody: async () => "user-msg-id",
+  persistQueuedMessageBody: async () => ({
+    id: "user-msg-id",
+    deduplicated: false,
+  }),
 }));
 
 // ---------------------------------------------------------------------------
@@ -135,7 +142,7 @@ function makeFakeContext(opts: {
     },
     async ensureActorScopedHistory() {},
     async persistUserMessage() {
-      return "user-msg-id";
+      return { id: "user-msg-id", deduplicated: false };
     },
     async runAgentLoop() {
       // No-op: the drain path's finally block would normally call drainQueue
@@ -157,6 +164,10 @@ function makeFakeContext(opts: {
         compactedMessages: 0,
       } as never;
     },
+    trustContext: {
+      trustClass: "guardian" as const,
+      guardianPrincipalId: "user-1",
+    },
     setTransportHints() {},
     applyHostEnvFromTransport() {},
     ensureHostProxiesForTurn() {},
@@ -312,7 +323,10 @@ describe("drainQueue preactivation re-add for host-proxy interfaces", () => {
       assistantMessageInterface: "web",
     };
     queue.push(
-      makeQueuedMessage({ requestId: "req-web-1", turnInterfaceContext: ifCtx }),
+      makeQueuedMessage({
+        requestId: "req-web-1",
+        turnInterfaceContext: ifCtx,
+      }),
     );
     const ctx = makeFakeContext({ queue, turnInterfaceContext: ifCtx });
 
@@ -334,7 +348,10 @@ describe("drainQueue preactivation re-add for host-proxy interfaces", () => {
       assistantMessageInterface: "web",
     };
     queue.push(
-      makeQueuedMessage({ requestId: "req-web-2", turnInterfaceContext: ifCtx }),
+      makeQueuedMessage({
+        requestId: "req-web-2",
+        turnInterfaceContext: ifCtx,
+      }),
     );
     const ctx = makeFakeContext({ queue, turnInterfaceContext: ifCtx });
 
@@ -354,7 +371,10 @@ describe("drainQueue preactivation re-add for host-proxy interfaces", () => {
       assistantMessageInterface: "web",
     };
     queue.push(
-      makeQueuedMessage({ requestId: "req-web-3", turnInterfaceContext: ifCtx }),
+      makeQueuedMessage({
+        requestId: "req-web-3",
+        turnInterfaceContext: ifCtx,
+      }),
     );
     const ctx = makeFakeContext({ queue, turnInterfaceContext: ifCtx });
 
@@ -371,7 +391,10 @@ describe("drainQueue preactivation re-add for host-proxy interfaces", () => {
       assistantMessageInterface: "web",
     };
     queue.push(
-      makeQueuedMessage({ requestId: "req-web-4", turnInterfaceContext: ifCtx }),
+      makeQueuedMessage({
+        requestId: "req-web-4",
+        turnInterfaceContext: ifCtx,
+      }),
     );
     const ctx = makeFakeContext({ queue, turnInterfaceContext: ifCtx });
 

package/src/__tests__/conversation-process-callsite.test.ts

@@ -4,14 +4,15 @@
  * user-initiated turns default to `'mainAgent'` when no caller-supplied
  * `callSite` is set.
  *
- * The test mocks `AgentLoop.run()` so it can capture the `callSite` parameter
- * the conversation passes after `processMessage` runs the slash-resolver and
- * runtime-injection pipeline. Adapter callers (heartbeat, filing, scheduler)
- * pass an explicit `callSite` so `RetryProvider` resolves their per-call
- * config from `llm.callSites.<id>`.
+ * The test mocks `AgentLoop.run()` so it can capture the `callSite` option
+ * the conversation passes via `AgentLoopRunOptions` after `processMessage`
+ * runs the slash-resolver and runtime-injection pipeline. Adapter callers
+ * (heartbeat, filing, scheduler) pass an explicit `callSite` so
+ * `RetryProvider` resolves their per-call config from `llm.callSites.<id>`.
  */
 import { describe, expect, mock, test } from "bun:test";
 
+import { CompactionCircuit } from "../agent/compaction-circuit.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
 
 // Use an object wrapper so TypeScript doesn't narrow the captured type to
@@ -183,6 +184,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   updateConversationTitle: () => {},
   getMessageById: () => null,
   getLastUserTimestampBefore: () => 0,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({
@@ -201,21 +203,21 @@ mock.module("../memory/retriever.js", () => ({
   injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
 }));
 
-// Mock AgentLoop to capture the callSite argument that runAgentLoopImpl passes.
-// The 6th positional parameter is `callSite` (see assistant/src/agent/loop.ts).
+// Mock AgentLoop to capture the callSite argument that runAgentLoopImpl passes
+// via the options object (see assistant/src/agent/loop.ts → AgentLoopConstructorOptions).
 mock.module("../agent/loop.js", () => ({
   AgentLoop: class {
+    compactionCircuit = new CompactionCircuit("test-conv");
     constructor(
       _provider: unknown,
       _systemPrompt: string,
-      config?: Record<string, unknown>,
-      _tools?: unknown,
-      _toolExecutor?: unknown,
-      _resolveTools?: unknown,
-      resolveSystemPrompt?: (history: Message[]) => Record<string, unknown>,
+      options?: {
+        config?: Record<string, unknown>;
+        resolveSystemPrompt?: (history: Message[]) => Record<string, unknown>;
+      },
     ) {
-      captured.constructorMaxTokens = config?.maxTokens;
-      const resolved = resolveSystemPrompt?.([]);
+      captured.constructorMaxTokens = options?.config?.maxTokens;
+      const resolved = options?.resolveSystemPrompt?.([]);
       captured.resolvedMaxTokens = resolved?.maxTokens;
       captured.resolvedHasMaxTokens =
         resolved !== undefined &&
@@ -230,12 +232,9 @@ mock.module("../agent/loop.js", () => ({
     async run(
       messages: Message[],
       onEvent: (event: Record<string, unknown>) => void,
-      _signal?: AbortSignal,
-      _requestId?: string,
-      _onCheckpoint?: unknown,
-      callSite?: string,
+      options?: { callSite?: string },
     ): Promise<Message[]> {
-      captured.callSite = callSite;
+      captured.callSite = options?.callSite;
       onEvent({
         type: "usage",
         inputTokens: 0,
@@ -310,9 +309,9 @@ function makeConversation(): Conversation {
     "conv-1",
     provider,
     "system prompt",
-    4096,
     () => {},
     "/tmp",
+    { maxTokens: 4096 },
   );
 }
 
@@ -332,15 +331,11 @@ describe("processMessage callSite threading", () => {
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
-    await conversation.processMessage(
-      "Heartbeat tick",
-      [],
-      () => {},
-      undefined, // requestId
-      undefined, // activeSurfaceId
-      undefined, // currentPage
-      { callSite: "heartbeatAgent" },
-    );
+    await conversation.processMessage({
+      content: "Heartbeat tick",
+      attachments: [],
+      callSite: "heartbeatAgent",
+    });
 
     expect(captured.callSite).toBe("heartbeatAgent");
   });
@@ -360,7 +355,10 @@ describe("processMessage callSite threading", () => {
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
-    await conversation.processMessage("Plain user message", [], () => {});
+    await conversation.processMessage({
+      content: "Plain user message",
+      attachments: [],
+    });
 
     expect(captured.callSite).toBe("mainAgent");
   });