@vellumai/assistant 0.10.3-dev.202606272129.e87b552 → 0.10.3-dev.202606272328.b705e83

package/openapi.yaml

@@ -17577,6 +17577,13 @@ paths:
                             - channelId
                             - channelTs
                           additionalProperties: false
+                        queueStatus:
+                          type: string
+                          enum:
+                            - queued
+                            - processing
+                        queuePosition:
+                          type: number
                       required:
                         - id
                         - role

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.10.3-dev.202606272129.e87b552",
+  "version": "0.10.3-dev.202606272328.b705e83",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/list-messages-queued.test.ts

@@ -0,0 +1,220 @@
+/**
+ * Tests for handleListMessages surfacing the in-memory message queue.
+ *
+ * Messages enqueued while the agent is mid-turn live only in the live
+ * conversation's in-memory queue until the queue drains and persists them.
+ * The messages snapshot appends them (carrying `queueStatus: "queued"` and a
+ * 1-based `queuePosition`, mirroring the client `DisplayMessage` shape) to the
+ * newest page so a cold reload restores the queued rows that the
+ * `message_queued` SSE events would otherwise be the only source of.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0 },
+  }),
+}));
+
+import type { Conversation } from "../daemon/conversation.js";
+import type { QueuedMessage } from "../daemon/conversation-queue-manager.js";
+import {
+  clearConversations,
+  setConversation,
+} from "../daemon/conversation-registry.js";
+import { addMessage, createConversation } from "../memory/conversation-crud.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { handleListMessages } from "../runtime/routes/conversation-routes.js";
+
+await initializeDb();
+
+function resetTables() {
+  const db = getDb();
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+  clearConversations();
+}
+
+interface MessagePayload {
+  id: string;
+  role: string;
+  content?: string;
+  clientMessageId?: string;
+  queueStatus?: "queued" | "processing";
+  queuePosition?: number;
+  attachments?: Array<{ id: string; filename: string; kind: string }>;
+}
+
+/** Register a live conversation whose in-memory queue holds `queued`. */
+function registerLiveConversation(
+  conversationId: string,
+  queued: QueuedMessage[],
+): void {
+  const stub = {
+    snapshotQueuedMessages: () => queued,
+    // A conversation only holds a queue while it is mid-turn; mirror that so
+    // `isConversationProcessing` (which prefers the live instance) reports busy.
+    isProcessing: () => true,
+  } as unknown as Conversation;
+  setConversation(conversationId, stub);
+}
+
+function makeQueued(overrides: Partial<QueuedMessage>): QueuedMessage {
+  return {
+    content: "queued body",
+    attachments: [],
+    requestId: "req-1",
+    onEvent: () => {},
+    sentAt: 1_700_000_000_000,
+    ...overrides,
+  } as QueuedMessage;
+}
+
+describe("handleListMessages in-memory queue", () => {
+  beforeEach(resetTables);
+
+  test("appends queued rows in FIFO order with 1-based queuePosition", async () => {
+    // GIVEN a persisted user turn and two messages still waiting in the queue
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "first" }]),
+      { skipIndexing: true },
+    );
+    registerLiveConversation(conv.id, [
+      makeQueued({
+        requestId: "req-queued-1",
+        content: "please also do this",
+        clientMessageId: "nonce-queued",
+      }),
+      makeQueued({ requestId: "req-queued-2", content: "and then this" }),
+    ]);
+
+    // WHEN the messages snapshot is built for the newest page
+    const response = handleListMessages({
+      queryParams: { conversationId: conv.id },
+    });
+    const body = response as { messages: MessagePayload[] };
+
+    // THEN the queued messages are appended after the persisted row, carrying
+    // queue state and keyed by their requestId for the delete/steer endpoints
+    expect(body.messages).toHaveLength(3);
+    expect(body.messages[0].queueStatus).toBeUndefined();
+
+    const first = body.messages[1];
+    expect(first.queueStatus).toBe("queued");
+    expect(first.queuePosition).toBe(1);
+    expect(first.role).toBe("user");
+    expect(first.id).toBe("req-queued-1");
+    expect(first.content).toBe("please also do this");
+    expect(first.clientMessageId).toBe("nonce-queued");
+
+    const second = body.messages[2];
+    expect(second.queueStatus).toBe("queued");
+    expect(second.queuePosition).toBe(2);
+    expect(second.id).toBe("req-queued-2");
+  });
+
+  test("prefers displayContent over the model-facing content", async () => {
+    const conv = createConversation();
+    registerLiveConversation(conv.id, [
+      makeQueued({
+        requestId: "req-display",
+        content: "stripped recording intent",
+        displayContent: "what the user actually typed",
+      }),
+    ]);
+
+    const response = handleListMessages({
+      queryParams: { conversationId: conv.id },
+    });
+    const body = response as { messages: MessagePayload[] };
+
+    expect(body.messages).toHaveLength(1);
+    expect(body.messages[0].content).toBe("what the user actually typed");
+  });
+
+  test("renders queued attachments with a derived kind", async () => {
+    const conv = createConversation();
+    registerLiveConversation(conv.id, [
+      makeQueued({
+        requestId: "req-att",
+        content: "see attached",
+        attachments: [
+          {
+            filename: "diagram.png",
+            mimeType: "image/png",
+            data: "AAAA",
+          },
+        ],
+      }),
+    ]);
+
+    const response = handleListMessages({
+      queryParams: { conversationId: conv.id },
+    });
+    const body = response as { messages: MessagePayload[] };
+
+    const att = body.messages[0].attachments?.[0];
+    expect(att?.filename).toBe("diagram.png");
+    expect(att?.kind).toBe("image");
+    expect(att?.id).toBe("req-att:attachment:0");
+  });
+
+  test("does not append queued messages to an older-history page", async () => {
+    // GIVEN history requested with beforeTimestamp (older page)
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "old" }]),
+      { skipIndexing: true },
+    );
+    registerLiveConversation(conv.id, [makeQueued({ requestId: "req-old" })]);
+
+    // WHEN paging older history
+    const response = handleListMessages({
+      queryParams: {
+        conversationId: conv.id,
+        beforeTimestamp: String(Date.now() + 1_000),
+      },
+    });
+    const body = response as { messages: MessagePayload[] };
+
+    // THEN the queued message is not mixed into the older page
+    expect(body.messages.every((m) => m.queueStatus == null)).toBe(true);
+  });
+
+  test("returns only persisted rows when the conversation is not live", async () => {
+    // GIVEN a conversation with no live in-memory instance (cold / aged out)
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "only persisted" }]),
+      { skipIndexing: true },
+    );
+
+    const response = handleListMessages({
+      queryParams: { conversationId: conv.id },
+    });
+    const body = response as { messages: MessagePayload[] };
+
+    expect(body.messages).toHaveLength(1);
+    expect(body.messages[0].queueStatus).toBeUndefined();
+  });
+});

package/src/__tests__/persist-user-message-set-processing-failure.test.ts

@@ -0,0 +1,70 @@
+/**
+ * Regression: `persistUserMessage` calls `ctx.setProcessing(true)`, which
+ * persists the flag to the DB and can throw (e.g. SQLITE_BUSY). That call must
+ * run inside the function's try/catch so a failure unwinds the request-id and
+ * abort-controller bookkeeping instead of stranding it on the conversation.
+ * A later failure while clearing the flag must not mask the original error.
+ */
+import { describe, expect, test } from "bun:test";
+
+import type { MessagingConversationContext } from "../daemon/conversation-messaging.js";
+import { persistUserMessage } from "../daemon/conversation-messaging.js";
+
+type SetProcessingBehavior = (value: boolean) => void;
+
+function makeContext(
+  setProcessing: SetProcessingBehavior,
+): MessagingConversationContext & {
+  processing: boolean;
+} {
+  let processing = false;
+  const ctx = {
+    conversationId: "conv-set-processing-failure",
+    messages: [],
+    abortController: null,
+    currentRequestId: undefined,
+    queue: {} as never,
+    get processing() {
+      return processing;
+    },
+    isProcessing: () => processing,
+    setProcessing: (value: boolean) => {
+      setProcessing(value);
+      processing = value;
+    },
+    getTurnChannelContext: () => null,
+    getTurnInterfaceContext: () => null,
+  } as unknown as MessagingConversationContext & { processing: boolean };
+  return ctx;
+}
+
+describe("persistUserMessage setProcessing failure", () => {
+  test("clears request-id and abort bookkeeping when setProcessing(true) throws", async () => {
+    const ctx = makeContext((value) => {
+      if (value) throw new Error("database is locked (SQLITE_BUSY)");
+    });
+
+    await expect(
+      persistUserMessage(ctx, { content: "hello", requestId: "req-1" }),
+    ).rejects.toThrow("database is locked");
+
+    expect(ctx.currentRequestId).toBeUndefined();
+    expect(ctx.abortController).toBeNull();
+    expect(ctx.isProcessing()).toBe(false);
+  });
+
+  test("a failing clear does not mask the original persist error", async () => {
+    // setProcessing throws on both the set and the clear; the original error
+    // must still propagate and the bookkeeping must still be reset.
+    const ctx = makeContext(() => {
+      throw new Error("database is locked (SQLITE_BUSY)");
+    });
+
+    await expect(
+      persistUserMessage(ctx, { content: "hello", requestId: "req-2" }),
+    ).rejects.toThrow("database is locked");
+
+    expect(ctx.currentRequestId).toBeUndefined();
+    expect(ctx.abortController).toBeNull();
+  });
+});

package/src/api/responses/conversation-message.ts

@@ -522,5 +522,18 @@ export const ConversationMessageSchema = z.object({
   contentBlocks: z.array(ConversationContentBlockSchema).optional(),
   subagentNotification: ConversationSubagentNotificationSchema.optional(),
   slackMessage: ConversationSlackMessageSchema.optional(),
+  /**
+   * Queue state for a user message that is still waiting in the daemon's
+   * in-memory queue (enqueued while the agent was mid-turn, not yet drained or
+   * persisted to the database). Derived at render time from the live
+   * conversation's queue, so it is present only while the message is genuinely
+   * pending and lets a cold reload restore the queued rows the live
+   * `message_queued` SSE events would otherwise be the only source of. Absent
+   * on already-persisted rows. Mirrors the client `DisplayMessage` fields so
+   * the wire and display shapes converge.
+   */
+  queueStatus: z.enum(["queued", "processing"]).optional(),
+  /** 1-based position in the queue, mirroring the `message_queued` SSE event. */
+  queuePosition: z.number().optional(),
 });
 export type ConversationMessage = z.infer<typeof ConversationMessageSchema>;

package/src/background-wake/wake-intent-hooks.test.ts

@@ -235,12 +235,10 @@ describe("background wake intent publisher hooks", () => {
       "utf-8",
     );
 
-    expect(lifecycleSource).toContain(
-      [
-        "heartbeat.start();",
-        "registerBackgroundWakeRuntime({ scheduler, heartbeat });",
-        'refreshBackgroundWakeIntent("daemon-startup");',
-      ].join("\n    "),
+    // Match the three calls in order, tolerant of indentation, so the
+    // assertion survives reformatting/re-indentation of lifecycle.ts.
+    expect(lifecycleSource).toMatch(
+      /heartbeat\.start\(\);\n[ \t]*registerBackgroundWakeRuntime\(\{ scheduler, heartbeat \}\);\n[ \t]*refreshBackgroundWakeIntent\("daemon-startup"\);/,
     );
   });
 

package/src/daemon/conversation-messaging.ts

@@ -412,10 +412,13 @@ export async function persistUserMessage(
 
   const reqId = options.requestId ?? uuid();
   ctx.currentRequestId = reqId;
-  ctx.setProcessing(true);
   ctx.abortController = new AbortController();
 
   try {
+    // `setProcessing(true)` persists the flag and can throw (e.g.
+    // SQLITE_BUSY). Keeping it inside the try ensures a failure here unwinds
+    // the request-id/abort bookkeeping below rather than stranding it.
+    ctx.setProcessing(true);
     const result = await persistQueuedMessageBody(ctx, {
       ...options,
       attachments,
@@ -428,7 +431,18 @@ export async function persistUserMessage(
     }
     return result;
   } catch (err) {
-    ctx.setProcessing(false);
+    // Clear the flag, but never let a clear failure mask the original error
+    // or skip the bookkeeping reset. `setProcessing` reverts its own
+    // in-memory flag when its persist throws, so the conversation is left
+    // consistent either way.
+    try {
+      ctx.setProcessing(false);
+    } catch (clearErr) {
+      log.error(
+        { err: clearErr, conversationId: ctx.conversationId },
+        "Failed to clear processing flag after persistUserMessage failure",
+      );
+    }
     ctx.abortController = null;
     ctx.currentRequestId = undefined;
     throw err;

package/src/daemon/conversation-queue-manager.ts

@@ -130,6 +130,12 @@ export class MessageQueue {
     return this.items[index];
   }
 
+  /** FIFO snapshot of the queued messages. The array is a copy; the items are
+   * the live references (callers must treat them as read-only). */
+  snapshot(): QueuedMessage[] {
+    return [...this.items];
+  }
+
   /**
    * Pop up to `count` messages FIFO and return them in order.
    * Decrements the byte budget for each popped item using the same

package/src/daemon/conversation.ts

@@ -129,7 +129,10 @@ import {
   drainQueue as drainQueueImpl,
   processMessage as processMessageImpl,
 } from "./conversation-process.js";
-import type { QueueDrainReason } from "./conversation-queue-manager.js";
+import type {
+  QueuedMessage,
+  QueueDrainReason,
+} from "./conversation-queue-manager.js";
 import { MessageQueue } from "./conversation-queue-manager.js";
 import {
   type ChannelCapabilities,
@@ -1466,6 +1469,12 @@ export class Conversation {
     return !this.queue.isEmpty;
   }
 
+  /** FIFO snapshot of the messages currently waiting in the in-memory queue.
+   * Read-only — used to surface queued user messages in history responses. */
+  snapshotQueuedMessages(): QueuedMessage[] {
+    return this.queue.snapshot();
+  }
+
   removeQueuedMessage(requestId: string): boolean {
     return this.queue.removeByRequestId(requestId) !== undefined;
   }