@vellumai/assistant 0.10.3-dev.202606272229.2ffe9f3 → 0.10.3-dev.202606280110.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.202606272229.2ffe9f3",
+  "version": "0.10.3-dev.202606280110.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/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-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;
   }