@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/__tests__/conversation-loop-db-lock-resilience.test.ts

@@ -0,0 +1,191 @@
+/**
+ * Regression tests for SQLite write-contention resilience in the agent loop.
+ *
+ * When another writer holds the SQLite write lock long enough that
+ * `busy_timeout` elapses, an in-loop content write throws `SQLITE_BUSY`
+ * ("database is locked"). The turn-finalizing write at `message_complete` is on
+ * `dispatchAgentEvent`'s re-throw allowlist, so before this resilience layer a
+ * single transient lock aborted the whole turn and surfaced to the user as
+ * "Processing failed: database is locked".
+ *
+ * These tests pin the two guarantees:
+ *  1. A transient `SQLITE_BUSY` is retried and the row is finalized normally.
+ *  2. A persistent `SQLITE_BUSY` is swallowed (logged) so the turn continues
+ *     instead of throwing — a later write (this turn or the next) overwrites
+ *     the dropped content.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ── Mock platform (must precede imports that read it) ─────────────────────────
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({ memory: {} }),
+  loadConfig: () => ({}),
+}));
+
+// `updateMessageContent` throws `SQLITE_BUSY` for the first
+// `updateContentFailuresRemaining` calls, then records the content written.
+let updateContentFailuresRemaining = 0;
+const writtenContentById = new Map<string, string>();
+const updateMessageContentMock = mock((id: string, content: string) => {
+  if (updateContentFailuresRemaining > 0) {
+    updateContentFailuresRemaining -= 1;
+    throw Object.assign(new Error("database is locked"), {
+      code: "SQLITE_BUSY",
+    });
+  }
+  writtenContentById.set(id, content);
+});
+
+// Stand-in for the `conversations.seq` column, mirroring the monotonic,
+// ignore-non-positive semantics of the real `recordConversationPersistedSeq`.
+const persistedSeqByConversation = new Map<string, number>();
+
+mock.module("../persistence/conversation-crud.js", () => ({
+  setConversationProcessingStartedAt: () => {},
+  isConversationProcessing: () => false,
+  getConversation: () => null,
+  getMessageById: () => null,
+  updateMessageContent: updateMessageContentMock,
+  provenanceFromTrustContext: () => ({}),
+  reserveMessage: async (_conversationId: string, role: string) => ({
+    id: role === "user" ? "tool-result-row" : "assistant-row",
+  }),
+  recordConversationPersistedSeq: (id: string, seq: number) => {
+    if (!Number.isFinite(seq) || seq <= 0) return;
+    const prev = persistedSeqByConversation.get(id);
+    if (prev == null || prev < seq) persistedSeqByConversation.set(id, seq);
+  },
+  getConversationPersistedSeq: (id: string) =>
+    persistedSeqByConversation.get(id) ?? null,
+}));
+
+mock.module("../persistence/conversation-disk-view.js", () => ({
+  syncMessageToDisk: () => {},
+}));
+
+mock.module("../persistence/llm-request-log-store.js", () => ({
+  recordRequestLog: () => {},
+  backfillMessageIdOnLogs: () => {},
+}));
+
+mock.module("../plugins/defaults/memory/memory-recall-log-store.js", () => ({
+  backfillMemoryRecallLogMessageId: () => {},
+}));
+
+mock.module(
+  "../plugins/defaults/memory/memory-v2-activation-log-store.js",
+  () => ({
+    backfillMemoryV2ActivationMessageId: () => {},
+  }),
+);
+
+// ── Imports (after mocks) ─────────────────────────────────────────────────────
+import type { AgentEvent } from "../agent/loop.js";
+import type {
+  EventHandlerDeps,
+  EventHandlerState,
+} from "../daemon/conversation-agent-loop-handlers.js";
+import {
+  createEventHandlerState,
+  handleMessageComplete,
+} from "../daemon/conversation-agent-loop-handlers.js";
+import type { ServerMessage } from "../daemon/message-protocol.js";
+import { getConversationPersistedSeq } from "../persistence/conversation-crud.js";
+
+const CONVERSATION_ID = "test-session-id";
+
+function createMockDeps(): EventHandlerDeps {
+  return {
+    ctx: {
+      conversationId: CONVERSATION_ID,
+      provider: { name: "anthropic" },
+      traceEmitter: { emit: () => {} },
+      streamThinking: false,
+      emitActivityState: () => {},
+      markWorkspaceTopLevelDirty: () => {},
+      currentTurnSurfaces: [],
+    } as unknown as EventHandlerDeps["ctx"],
+    onEvent: (_msg: ServerMessage) => {},
+    reqId: "test-req-id",
+    isFirstMessage: false,
+    shouldGenerateTitle: false,
+    rlog: new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }) as unknown as EventHandlerDeps["rlog"],
+    turnChannelContext: {
+      userMessageChannel: "vellum",
+      assistantMessageChannel: "vellum",
+    } as EventHandlerDeps["turnChannelContext"],
+    turnInterfaceContext: {
+      userMessageInterface: "macos",
+      assistantMessageInterface: "macos",
+    } as EventHandlerDeps["turnInterfaceContext"],
+  } as EventHandlerDeps;
+}
+
+const MESSAGE_COMPLETE_EVENT = {
+  type: "message_complete",
+  message: { role: "assistant", content: [{ type: "text", text: "done" }] },
+} as Extract<AgentEvent, { type: "message_complete" }>;
+
+describe("agent loop SQLite write-contention resilience", () => {
+  let state: EventHandlerState;
+
+  beforeEach(() => {
+    state = createEventHandlerState();
+    // A row was reserved at llm_call_started; message_complete finalizes it.
+    state.lastAssistantMessageId = "assistant-row";
+    state.assistantRowAwaitingFinalization = true;
+    state.lastPersistedContentSeq = 5;
+    updateContentFailuresRemaining = 0;
+    writtenContentById.clear();
+    persistedSeqByConversation.clear();
+    updateMessageContentMock.mockClear();
+  });
+
+  test("retries a transient SQLITE_BUSY and finalizes the assistant row", async () => {
+    // GIVEN the finalize write loses the write-lock race twice before winning
+    updateContentFailuresRemaining = 2;
+
+    // WHEN message_complete drains
+    await handleMessageComplete(
+      state,
+      createMockDeps(),
+      MESSAGE_COMPLETE_EVENT,
+    );
+
+    // THEN it retried until the write committed (2 failures + 1 success) ...
+    expect(updateMessageContentMock).toHaveBeenCalledTimes(3);
+    expect(writtenContentById.get("assistant-row")).toContain("done");
+    // ... the finalization completed ...
+    expect(state.assistantRowAwaitingFinalization).toBe(false);
+    // ... and the persisted seq advanced because the content is durable.
+    expect(getConversationPersistedSeq(CONVERSATION_ID)).toBe(5);
+  });
+
+  test("swallows a persistent SQLITE_BUSY without aborting the turn", async () => {
+    // GIVEN every finalize attempt loses the race (lock held past every retry)
+    updateContentFailuresRemaining = Number.POSITIVE_INFINITY;
+
+    // WHEN message_complete drains, it must resolve rather than throw — a thrown
+    // SQLITE_BUSY here is on dispatchAgentEvent's re-throw allowlist and would
+    // kill the turn.
+    await expect(
+      handleMessageComplete(state, createMockDeps(), MESSAGE_COMPLETE_EVENT),
+    ).resolves.toBeUndefined();
+
+    // THEN the write was attempted (initial try + the retries) ...
+    expect(updateMessageContentMock.mock.calls.length).toBeGreaterThan(1);
+    // ... no content landed ...
+    expect(writtenContentById.has("assistant-row")).toBe(false);
+    // ... and the seq was NOT advanced past content that never became durable.
+    expect(getConversationPersistedSeq(CONVERSATION_ID)).toBeNull();
+  });
+});

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

@@ -431,4 +431,41 @@ describe("processMessage callSite threading", () => {
 
     expect(conversation.clientTimezone).toBe("Europe/London");
   });
+
+  test("applies clientOs in the create and reuse transport metadata path", async () => {
+    mockConversation = {
+      id: "conv-store-client-os",
+      contextSummary: null,
+      contextCompactedMessageCount: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalEstimatedCost: 0,
+    };
+    mockDbMessages = [];
+    clearCaptured();
+    clearAllActiveConversations();
+
+    // `interface` is always the transport surface (here "web"); the OS is
+    // carried separately as `clientOs` and must be applied on both the create
+    // and reuse paths so each turn reflects its own surface.
+    const conversation = await getOrCreateConversation("conv-store-client-os", {
+      transport: {
+        channelId: "vellum",
+        interfaceId: "web",
+        clientOs: "macos",
+      },
+    });
+
+    expect(conversation.clientOs).toBe("macos");
+
+    await getOrCreateConversation("conv-store-client-os", {
+      transport: {
+        channelId: "vellum",
+        interfaceId: "web",
+        clientOs: "ios",
+      },
+    });
+
+    expect(conversation.clientOs).toBe("ios");
+  });
 });

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

@@ -681,6 +681,49 @@ describe("Conversation message queue", () => {
     expect(events3.some((e) => e.type === "message_complete")).toBe(true);
   });
 
+  test("[experimental] queued passthrough siblings from different client OS do NOT batch", async () => {
+    // Post-decouple, web/iOS/macOS all report interfaceId "web", so the
+    // interface-based batch split no longer separates them. A batched turn
+    // applies only the head's clientOs, so messages from different OS surfaces
+    // must split into separate runs rather than coalesce under one OS.
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+
+    const p1 = conversation.processMessage({
+      content: "msg-1",
+      attachments: [],
+      onEvent: () => {},
+      requestId: "req-1",
+    });
+    await waitForPendingRun(1);
+
+    // Two siblings on the same transport interface ("web") but different OS.
+    conversation.enqueueMessage({
+      content: "msg-2",
+      onEvent: () => {},
+      requestId: "req-2",
+      transport: { channelId: "vellum", interfaceId: "web", clientOs: "macos" },
+    });
+    conversation.enqueueMessage({
+      content: "msg-3",
+      onEvent: () => {},
+      requestId: "req-3",
+      transport: { channelId: "vellum", interfaceId: "web", clientOs: "ios" },
+    });
+    expect(conversation.getQueueDepth()).toBe(2);
+
+    // Drain: msg-2 (macos) is the batch head; msg-3 (ios) has a different
+    // clientOs, so it must NOT join the batch.
+    await resolveRun(0);
+    await p1;
+    await waitForPendingRun(2);
+    await resolveRun(1);
+    await waitForPendingRun(3);
+
+    // Three runs total (msg-1, msg-2, msg-3) — msg-3 was not batched with msg-2.
+    expect(pendingRuns.length).toBe(3);
+  });
+
   test("message_queued and message_dequeued events are emitted", async () => {
     const conversation = makeConversation();
     await conversation.loadFromDb();
@@ -784,6 +827,13 @@ describe("Conversation message queue", () => {
       (e) => e.type === "conversation_error",
     );
     expect(conversationErr3).toBeUndefined();
+
+    // Settle the aborted in-flight run so its abort watchdog clears the
+    // real-time timer it armed. A leaked ~5s timer otherwise fires during a
+    // later test and drives this stale turn into commitTurnChanges, inflating
+    // the shared turnCommitCalls counter that other tests assert against.
+    await resolveRun(0);
+    await new Promise((r) => setTimeout(r, 10));
   });
 
   test("conversation-scoped errors emit both conversation_error and generic error", async () => {
@@ -2758,6 +2808,13 @@ describe("Regression: cancel semantics and error channel split", () => {
       );
       expect(conversationErr).toBeUndefined();
     }
+
+    // Settle the aborted in-flight run so its abort watchdog clears the
+    // real-time timer it armed. A leaked ~5s timer otherwise fires during a
+    // later test and drives this stale turn into commitTurnChanges, inflating
+    // the shared turnCommitCalls counter that other tests assert against.
+    await resolveRun(0);
+    await new Promise((r) => setTimeout(r, 10));
   });
 
   test("commitTurnChanges never resolving within budget -> turn still completes and drains queue", async () => {
@@ -3005,6 +3062,54 @@ describe("subagent notification user_message_echo suppression", () => {
     await new Promise((r) => setTimeout(r, 10));
   });
 
+  test("drained hidden message persists with hidden metadata and emits no user_message_echo", async () => {
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+
+    const events1: ServerMessage[] = [];
+    const eventsHidden: ServerMessage[] = [];
+
+    // Occupy the conversation so the hidden send queues — e.g. the user
+    // closes the channel-setup wizard while the assistant is mid-turn.
+    const p1 = conversation.processMessage({
+      content: "msg-1",
+      attachments: [],
+      onEvent: (e) => events1.push(e),
+      requestId: "req-1",
+    });
+    await waitForPendingRun(1);
+
+    // A hidden `POST /messages` send carries `hidden: true` metadata through
+    // the queue branch (see conversation-routes.ts).
+    conversation.enqueueMessage({
+      content:
+        "[User action on channel_setup surface: closed the slack setup wizard]",
+      onEvent: (e) => eventsHidden.push(e),
+      requestId: "req-hidden",
+      metadata: { hidden: true },
+    });
+
+    await resolveRun(0);
+    await p1;
+    await waitForPendingRun(2);
+
+    // Persisted with the hidden flag so the transcript filter keeps it out
+    // of the rendered history...
+    const persisted = capturedAddMessages.find((m) =>
+      m.content.includes("channel_setup"),
+    );
+    expect(persisted?.metadata?.hidden).toBe(true);
+    // ...the agent still wakes on it...
+    expect(pendingRuns.length).toBe(2);
+    // ...and no user_message_echo is broadcast, so no visible user bubble.
+    expect(eventsHidden.some((e) => e.type === "user_message_echo")).toBe(
+      false,
+    );
+
+    await resolveRun(1);
+    await new Promise((r) => setTimeout(r, 10));
+  });
+
   test("drained acp-notification message persists and wakes the agent but emits no user_message_echo", async () => {
     const conversation = makeConversation();
     await conversation.loadFromDb();
@@ -3047,4 +3152,48 @@ describe("subagent notification user_message_echo suppression", () => {
     await resolveRun(1);
     await new Promise((r) => setTimeout(r, 10));
   });
+
+  test("drained background-tool wake message persists and wakes the agent but emits no user_message_echo", async () => {
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+
+    const events1: ServerMessage[] = [];
+    const eventsNotif: ServerMessage[] = [];
+
+    // Occupy the conversation so the injected wake queues.
+    const p1 = conversation.processMessage({
+      content: "msg-1",
+      attachments: [],
+      onEvent: (e) => events1.push(e),
+      requestId: "req-1",
+    });
+    await waitForPendingRun(1);
+
+    // The backgrounded bash/host_bash completion wake persists a
+    // `<background_event source="background-tool">` row, tagged with the
+    // `backgroundEventSource` metadata `persistWakeTriggerMessage` writes.
+    conversation.enqueueMessage({
+      content:
+        '<background_event source="background-tool">Background command completed (id=bg-1, exit=0):</background_event>',
+      onEvent: (e) => eventsNotif.push(e),
+      requestId: "req-bg-notif",
+      metadata: { backgroundEventSource: "background-tool" },
+    });
+
+    await resolveRun(0);
+    await p1;
+    await waitForPendingRun(2);
+
+    // Still persisted (so the orchestrator LLM sees it) and still wakes the
+    // agent...
+    expect(
+      capturedAddMessages.some((m) => m.content.includes("background_event")),
+    ).toBe(true);
+    expect(pendingRuns.length).toBe(2);
+    // ...but no user_message_echo, so the client never renders a live bubble.
+    expect(eventsNotif.some((e) => e.type === "user_message_echo")).toBe(false);
+
+    await resolveRun(1);
+    await new Promise((r) => setTimeout(r, 10));
+  });
 });