@vellumai/assistant 0.11.2 → 0.11.3-staging.1

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

@@ -12,6 +12,7 @@ import type {
 import type { AssistantEvent } from "../api/index.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
 import { stampAndBuffer } from "../runtime/assistant-stream-state.js";
+import { createAbortReason } from "../util/abort-reasons.js";
 import { setConfig } from "./helpers/set-config.js";
 
 // ---------------------------------------------------------------------------
@@ -675,6 +676,62 @@ describe("Conversation message queue", () => {
     expect(pendingRuns.length).toBe(3);
   });
 
+  // `Conversation.clientOs` is a live field that only a transport-carrying
+  // message refreshes, so a transport-less drain (a surface action, a signal)
+  // persists the OS of an earlier send. Both rows keep that OS for telemetry;
+  // only the row that reported it claims the surface, which is what stops an
+  // attended Mac from suppressing the push for a button tapped on the phone.
+  test("[experimental] only a queued send that reported its own OS claims that surface", async () => {
+    capturedAddMessages.length = 0;
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+
+    const p1 = conversation.processMessage({
+      content: "msg-1",
+      attachments: [],
+      onEvent: () => {},
+      requestId: "req-1",
+    });
+    await waitForPendingRun(1);
+
+    conversation.enqueueMessage({
+      content: "from-the-mac",
+      onEvent: () => {},
+      requestId: "req-mac",
+      transport: { channelId: "vellum", interfaceId: "web", clientOs: "macos" },
+    });
+    // A surface action: no transport, so the drain leaves the conversation's
+    // `clientOs` on the macOS value the send above applied.
+    conversation.enqueueMessage({
+      content: "[User action on card surface: submit]",
+      onEvent: () => {},
+      requestId: "req-surface-action",
+    });
+
+    await resolveRun(0);
+    await p1;
+    await waitForPendingRun(2);
+    await resolveRun(1);
+    await waitForPendingRun(3);
+
+    const macRow = capturedAddMessages.find(
+      (m) => m.role === "user" && m.content.includes("from-the-mac"),
+    );
+    expect(macRow).toBeDefined();
+    expect(macRow!.metadata?.client).toEqual({ os: "macos" });
+    expect(macRow!.metadata?.clientOsFromRequest).toBe(true);
+
+    const surfaceActionRow = capturedAddMessages.find(
+      (m) => m.role === "user" && m.content.includes("User action on card"),
+    );
+    expect(surfaceActionRow).toBeDefined();
+    expect(surfaceActionRow!.metadata?.client).toEqual({ os: "macos" });
+    expect(surfaceActionRow!.metadata?.clientOsFromRequest).toBeUndefined();
+
+    await resolveRun(2);
+    await new Promise((r) => setTimeout(r, 10));
+  });
+
   test("[experimental] queued passthrough siblings viewing different apps do NOT batch", async () => {
     // A batched turn applies only the head's `visibleAppId`, which drives the
     // `visible_app:` context line. Coalescing messages sent while different
@@ -826,7 +883,87 @@ describe("Conversation message queue", () => {
     await new Promise((r) => setTimeout(r, 10));
   });
 
-  test("abort() clears the queue and sends generation_cancelled for each queued message", async () => {
+  test("subagent notifications are never acked with message_queued and don't shift visible positions", async () => {
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+
+    const notificationEvents: AssistantEvent[] = [];
+    const visibleEvents: AssistantEvent[] = [];
+
+    const p1 = conversation.processMessage({
+      content: "msg-1",
+      attachments: [],
+      requestId: "req-1",
+    });
+    await waitForPendingRun(1);
+
+    // A subagent's completion summary injected into a busy parent is daemon
+    // scaffolding: the user follows that run through its inline card, so the
+    // row gets no queued ack and no queue-drawer bubble.
+    const notification = conversation.enqueueMessage({
+      content: '[Subagent "hermes-local-review" — important] review finished',
+      onEvent: (e) => notificationEvents.push(e),
+      requestId: "req-subagent",
+      metadata: {
+        subagentNotification: {
+          subagentId: "sub-1",
+          label: "hermes-local-review",
+          status: "completed",
+          conversationId: "conv-sub-1",
+          objective: "review the diff",
+        },
+      },
+    });
+    expect(notification.queued).toBe(true);
+    expect(
+      notificationEvents.filter((e) => e.type === "message_queued"),
+    ).toEqual([]);
+
+    // The user's own send queued behind it is position 1: the notification
+    // does not consume a visible slot, matching the cold-load snapshot.
+    const visible = conversation.enqueueMessage({
+      content: "visible-msg",
+      onEvent: (e) => visibleEvents.push(e),
+      requestId: "req-visible",
+    });
+    expect(visible.queued).toBe(true);
+    expect(conversation.getQueueDepth()).toBe(2);
+    expect(
+      visibleEvents.find((e) => e.type === "message_queued"),
+    ).toMatchObject({
+      requestId: "req-visible",
+      position: 1,
+    });
+
+    // Suppressing the ack changes only what clients are told: the row is
+    // still queued, still drains, and still wakes the parent on the notification
+    // text (delivery is asserted end-to-end in "drained subagent-notification
+    // message persists and wakes the agent but emits no user_message_echo").
+    await resolveRun(0);
+    await p1;
+    await waitForPendingRun(2);
+    await waitForCondition(() => conversation.getQueueDepth() === 0);
+    expect(
+      capturedAddMessages.some((m) =>
+        m.content.includes("hermes-local-review"),
+      ),
+    ).toBe(true);
+
+    for (let i = 1; i < pendingRuns.length; i++) {
+      await resolveRun(i);
+    }
+    await new Promise((r) => setTimeout(r, 10));
+
+    // Queue events stay paired: an enqueue that was never acked is never
+    // dequeued either, so the client counter can't retire an entry it never
+    // took. The visible send keeps both halves.
+    expect(
+      notificationEvents.filter((e) => e.type === "message_dequeued"),
+    ).toEqual([]);
+    expect(visibleEvents.some((e) => e.type === "message_dequeued")).toBe(true);
+  });
+
+  test("abort() clears the queue and closes out each queued message", async () => {
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
@@ -873,6 +1010,17 @@ describe("Conversation message queue", () => {
       conversationId: "conv-1",
     });
 
+    // Each discarded row also gets its own terminal event. `generation_cancelled`
+    // closes out the turn they were waiting on; only `message_queued_deleted`
+    // closes out the queued rows themselves, and without it clients keep the
+    // pending indicator up forever, since no `message_dequeued` is coming.
+    expect(
+      events2.find((e) => e.type === "message_queued_deleted"),
+    ).toMatchObject({ conversationId: "conv-1", requestId: "req-2" });
+    expect(
+      events3.find((e) => e.type === "message_queued_deleted"),
+    ).toMatchObject({ conversationId: "conv-1", requestId: "req-3" });
+
     // abort() must NOT emit conversation_error or generic error for queued discards.
     const err2 = events2.find((e) => e.type === "error");
     expect(err2).toBeUndefined();
@@ -897,6 +1045,122 @@ describe("Conversation message queue", () => {
     await new Promise((r) => setTimeout(r, 10));
   });
 
+  test("a user interrupt keeps the queue and the stopped turn's drain sends it", async () => {
+    // GIVEN a turn in flight with a message queued behind it
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+
+    const events2: AssistantEvent[] = [];
+    conversation.processMessage({
+      content: "msg-1",
+      attachments: [],
+      requestId: "req-1",
+    });
+    await waitForPendingRun(1);
+
+    conversation.enqueueMessage({
+      content: "msg-2",
+      onEvent: (e) => events2.push(e),
+      requestId: "req-2",
+    });
+    expect(conversation.getQueueDepth()).toBe(1);
+
+    // WHEN the user hits Stop
+    conversation.abort(
+      createAbortReason("user_cancel", "conversation-queue.test", "conv-1"),
+    );
+
+    // THEN the queued message survives the abort. Stop ends the turn the user
+    // is watching, not the message they queued behind it, and a discard here
+    // reaches no client: it emits no per-row terminal event.
+    expect(conversation.getQueueDepth()).toBe(1);
+    expect(
+      events2.find((e) => e.type === "generation_cancelled"),
+    ).toBeUndefined();
+    expect(
+      events2.find((e) => e.type === "message_queued_deleted"),
+    ).toBeUndefined();
+
+    // AND once the stopped turn unwinds, its `finally` drains the queue, so the
+    // message is sent instead of needing to be retyped.
+    await resolveRun(0);
+    await waitForPendingRun(2);
+    expect(events2.find((e) => e.type === "message_dequeued")).toMatchObject({
+      conversationId: "conv-1",
+      requestId: "req-2",
+    });
+    expect(conversation.getQueueDepth()).toBe(0);
+    expect(
+      JSON.stringify(
+        pendingRuns[1].messages[pendingRuns[1].messages.length - 1],
+      ),
+    ).toContain("msg-2");
+
+    await resolveRun(1);
+    await new Promise((r) => setTimeout(r, 10));
+  });
+
+  test("a user interrupt mid-tool repairs the abandoned tool_use before the queued message runs", async () => {
+    // GIVEN a turn whose history ends with an unanswered tool_use, the shape a
+    // Stop mid-tool-call leaves behind and which providers reject outright
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+
+    const events2: AssistantEvent[] = [];
+    conversation.processMessage({
+      content: "msg-1",
+      attachments: [],
+      requestId: "req-1",
+    });
+    await waitForPendingRun(1);
+
+    conversation.enqueueMessage({
+      content: "msg-2",
+      onEvent: (e) => events2.push(e),
+      requestId: "req-2",
+    });
+
+    // WHEN the user interrupts and the stopped turn unwinds with the tool call
+    // still unanswered, then drains the queue
+    conversation.abort(
+      createAbortReason("user_cancel", "conversation-queue.test", "conv-1"),
+    );
+    const interrupted = pendingRuns[0];
+    await interrupted.onEvent({ type: "llm_call_started" });
+    interrupted.resolve([
+      ...interrupted.messages,
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "tool_use",
+            id: "toolu-interrupted",
+            name: "bash",
+            input: {},
+          },
+        ],
+      },
+    ]);
+    await waitForPendingRun(2);
+
+    // THEN the drained turn opens with a synthetic result for the abandoned
+    // call rather than a dangling tool_use.
+    const repaired = pendingRuns[1].messages.find(
+      (m) =>
+        m.role === "user" &&
+        m.content.some(
+          (block) =>
+            block.type === "tool_result" &&
+            block.tool_use_id === "toolu-interrupted",
+        ),
+    );
+    expect(repaired).toBeDefined();
+    expect(conversation.pendingInterruptRepair).toBe(false);
+
+    await resolveRun(1);
+    await new Promise((r) => setTimeout(r, 10));
+  });
+
   test("conversation-scoped errors emit both conversation_error and generic error", async () => {
     const conversation = makeConversation();
     await conversation.loadFromDb();

package/src/__tests__/conversation-retry-route.test.ts

@@ -24,6 +24,7 @@ import { z } from "zod";
 import {
   isBackgroundEventMetadata,
   isEchoSuppressedUserMessage,
+  isHiddenMessageMetadata,
 } from "../persistence/conversation-types.js";
 
 mock.module("../config/env.js", () => ({
@@ -73,7 +74,7 @@ const getConversationMock = mock((id: string) =>
 mock.module("../persistence/conversation-crud.js", () => ({
   addMessage: async () => ({ id: "unused", deduplicated: false }),
   archiveConversation: () => true,
-  batchSetDisplayOrders: () => {},
+  batchSetConversationPlacement: () => {},
   countConversationsByScheduleJobId: () => 0,
   deleteConversation: () => ({ segmentIds: [], deletedSummaryIds: [] }),
   extractImageSourcePaths: () => undefined,
@@ -81,6 +82,7 @@ mock.module("../persistence/conversation-crud.js", () => ({
   getConversation: getConversationMock,
   isBackgroundEventMetadata,
   isEchoSuppressedUserMessage,
+  isHiddenMessageMetadata,
   provenanceFromTrustContext: () => ({ provenanceTrustClass: "unknown" }),
   setConversationSurfaced: () => null,
   unarchiveConversation: () => true,

package/src/__tests__/conversation-store-ephemeral.test.ts

@@ -175,8 +175,12 @@ describe("getOrCreateConversation ephemeral flag", () => {
 
     await getOrCreateConversation("real-conversation-id");
 
+    // No trust context on this call, so no origin is asserted: the row is
+    // left unattributed for the first inbound message to claim, rather than
+    // being guessed as native.
     expect(mockEnsureConversationExists).toHaveBeenCalledWith(
       "real-conversation-id",
+      undefined,
     );
   });
 });

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

@@ -304,7 +304,7 @@ describe("attachment orphan cleanup", () => {
       "Here is a file",
     );
 
-    const stored = uploadAttachment("chart.png", "image/png", "iVBOR");
+    const stored = await uploadAttachment("chart.png", "image/png", "iVBOR");
     linkAttachmentToMessage(assistantMsg.id, stored.id, 0);
 
     // Verify attachment is linked
@@ -331,7 +331,7 @@ describe("attachment orphan cleanup", () => {
     await addMessage(conv.id, "user", "question");
     const msg2 = await addMessage(conv.id, "assistant", "second");
 
-    const shared = uploadAttachment("shared.png", "image/png", "AAAA");
+    const shared = await uploadAttachment("shared.png", "image/png", "AAAA");
     linkAttachmentToMessage(msg1.id, shared.id, 0);
     linkAttachmentToMessage(msg2.id, shared.id, 0);
 
@@ -353,7 +353,11 @@ describe("attachment orphan cleanup", () => {
   test("clearAll removes all attachments", async () => {
     const conv = createConversation("test");
     const msg = await addMessage(conv.id, "assistant", "file");
-    const stored = uploadAttachment("doc.pdf", "application/pdf", "JVBER");
+    const stored = await uploadAttachment(
+      "doc.pdf",
+      "application/pdf",
+      "JVBER",
+    );
     linkAttachmentToMessage(msg.id, stored.id, 0);
 
     await clearAll();
@@ -441,11 +445,11 @@ describe("attachment orphan cleanup", () => {
     );
 
     // An attachment linked to the assistant message (should be cleaned up)
-    const linked = uploadAttachment("chart.png", "image/png", "iVBOR");
+    const linked = await uploadAttachment("chart.png", "image/png", "iVBOR");
     linkAttachmentToMessage(assistantMsg.id, linked.id, 0);
 
     // A freshly uploaded attachment not linked to any message (should survive)
-    uploadAttachment("pending.png", "image/png", "AAAA");
+    await uploadAttachment("pending.png", "image/png", "AAAA");
 
     deleteLastExchange(conv.id);
 
@@ -543,7 +547,7 @@ describe("attachment reuse across conversation lifecycles", () => {
   test("attachment uploaded in conversation A is retrievable by ID without any conversation reference", async () => {
     const convA = createConversation("Conversation A");
     const msgA = await addMessage(convA.id, "assistant", "Here is a file");
-    const stored = uploadAttachment(
+    const stored = await uploadAttachment(
       "report.pdf",
       "application/pdf",
       "JVBERA==",
@@ -570,7 +574,11 @@ describe("attachment reuse across conversation lifecycles", () => {
     const msgB = await addMessage(convB.id, "assistant", "Reused file");
 
     // Upload once, link to both conversations
-    const stored = uploadAttachment("shared.png", "image/png", "iVBORw0K");
+    const stored = await uploadAttachment(
+      "shared.png",
+      "image/png",
+      "iVBORw0K",
+    );
     linkAttachmentToMessage(msgA.id, stored.id, 0);
     linkAttachmentToMessage(msgB.id, stored.id, 0);
 
@@ -595,7 +603,7 @@ describe("attachment reuse across conversation lifecycles", () => {
     await addMessage(convB.id, "user", "Show me the chart");
     const msgB = await addMessage(convB.id, "assistant", "Reused");
 
-    const stored = uploadAttachment("chart.png", "image/png", "AAAA");
+    const stored = await uploadAttachment("chart.png", "image/png", "AAAA");
     linkAttachmentToMessage(msgA.id, stored.id, 0);
     linkAttachmentToMessage(msgB.id, stored.id, 0);
     const linkedB = getAttachmentsForMessage(msgB.id);
@@ -621,8 +629,16 @@ describe("attachment reuse across conversation lifecycles", () => {
     await addMessage(convA.id, "user", "upload in A");
     await addMessage(convB.id, "user", "upload in B");
 
-    const first = uploadAttachment("photo.png", "image/png", "DEDUPCROSS");
-    const second = uploadAttachment("photo.png", "image/png", "DEDUPCROSS");
+    const first = await uploadAttachment(
+      "photo.png",
+      "image/png",
+      "DEDUPCROSS",
+    );
+    const second = await uploadAttachment(
+      "photo.png",
+      "image/png",
+      "DEDUPCROSS",
+    );
 
     expect(second.id).not.toBe(first.id);
   });

package/src/__tests__/conversation-summarize-route.test.ts

@@ -53,7 +53,7 @@ const getConversationMock = mock((id: string) =>
 mock.module("../persistence/conversation-crud.js", () => ({
   addMessage: addMessageMock,
   archiveConversation: () => true,
-  batchSetDisplayOrders: () => {},
+  batchSetConversationPlacement: () => {},
   countConversationsByScheduleJobId: () => 0,
   deleteConversation: () => ({ segmentIds: [], deletedSummaryIds: [] }),
   extractImageSourcePaths: () => undefined,

package/src/__tests__/conversation-surfaces-action-delivery.test.ts

@@ -9,12 +9,23 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
   broadcastMessage: (msg: AssistantEvent) => broadcastedMessages.push(msg),
 }));
 
+// These surfaces are shown live and asserted through their client messages, so
+// history holds nothing. Stand in an empty store: the completion path reads
+// persisted `ui_surface` blocks, and this file's DB carries no schema, so the
+// real read would throw and be indistinguishable from a persistence failure.
+const realCrud = await import("../persistence/conversation-crud.js");
+mock.module("../persistence/conversation-crud.js", () => ({
+  ...realCrud,
+  getMessages: () => [],
+}));
+
 const { createSurfaceMutex, handleSurfaceAction, surfaceProxyResolver } =
   await import("../daemon/conversation-surfaces.js");
 
-import type { SurfaceConversationContext } from "../daemon/conversation-surfaces.js";
+import type { Conversation } from "../daemon/conversation.js";
 import type { SurfaceType, UiSurfaceShow } from "../daemon/message-protocol.js";
 import type { UserMessageAttachment } from "../daemon/message-types/shared.js";
+import { asConversation } from "./helpers/mock-conversation.js";
 
 interface ProcessMessageCall {
   content: string;
@@ -25,13 +36,11 @@ interface ProcessMessageCall {
   sourceActorPrincipalId?: string;
 }
 
-function makeContext(
-  sent: AssistantEvent[] = [],
-): SurfaceConversationContext & {
+function makeContext(sent: AssistantEvent[] = []): Conversation & {
   processMessageCalls: ProcessMessageCall[];
 } {
   const processMessageCalls: ProcessMessageCall[] = [];
-  return {
+  return asConversation({
     conversationId: "conv-1",
     sendToClient: (msg: AssistantEvent) => sent.push(msg),
     pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
@@ -60,7 +69,7 @@ function makeContext(
     },
     withSurface: createSurfaceMutex(),
     processMessageCalls,
-  };
+  });
 }
 
 describe("surface action delivery to assistant", () => {

package/src/__tests__/conversation-surfaces-activation-emit.test.ts

@@ -29,7 +29,8 @@ const {
   surfaceProxyResolver,
 } = await import("../daemon/conversation-surfaces.js");
 
-import type { SurfaceConversationContext } from "../daemon/conversation-surfaces.js";
+import type { Conversation } from "../daemon/conversation.js";
+import type { ProcessMessageOptions } from "../daemon/conversation-process.js";
 import type { SurfaceType, UiSurfaceShow } from "../daemon/message-protocol.js";
 import {
   getMemorySqlite,
@@ -61,7 +62,7 @@ interface ProcessMessageCall {
 function makeContext(
   conversationId: string,
   sent: AssistantEvent[] = [],
-): SurfaceConversationContext & {
+): Conversation & {
   processMessageCalls: ProcessMessageCall[];
 } {
   const processMessageCalls: ProcessMessageCall[] = [];
@@ -81,7 +82,7 @@ function makeContext(
     isProcessing: () => false,
     enqueueMessage: () => ({ queued: false, requestId: "req-1" }),
     getQueueDepth: () => 0,
-    processMessage: async (options) => {
+    processMessage: async (options: ProcessMessageOptions) => {
       processMessageCalls.push({
         content: options.content,
         activeSurfaceId: options.activeSurfaceId,
@@ -90,7 +91,7 @@ function makeContext(
     },
     withSurface: createSurfaceMutex(),
     processMessageCalls,
-  } as SurfaceConversationContext & {
+  } as unknown as Conversation & {
     processMessageCalls: ProcessMessageCall[];
   };
 }
@@ -102,7 +103,7 @@ function resetTables(): void {
 
 /** Render a choice surface tagged (or not) with an activation_moment. */
 async function showTaggedChoice(
-  ctx: SurfaceConversationContext,
+  ctx: Conversation,
   sent: AssistantEvent[],
   activationMoment?: string,
 ): Promise<string> {

package/src/__tests__/conversation-surfaces-app-control.test.ts

@@ -9,11 +9,13 @@
 
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { asConversation } from "./helpers/mock-conversation.js";
+
 const sentMessages: unknown[] = [];
 let mockHasClient = true;
 // Default principal id used for both ctx.trustContext and clients in the
 // existing single-user tests. Tests that exercise cross-user behaviour
-// override this on individual clients and on the SurfaceConversationContext.
+// override this on individual clients and on the Conversation.
 const DEFAULT_PRINCIPAL = "user-1";
 type MockClient = {
   clientId: string;
@@ -47,22 +49,21 @@ mock.module("../runtime/pending-interactions.js", () => ({
   removeByConversation: () => {},
 }));
 
-const { surfaceProxyResolver } =
+const { createSurfaceMutex, surfaceProxyResolver } =
   await import("../daemon/conversation-surfaces.js");
 const {
   HostAppControlProxy,
   _resetActiveAppControlSession,
   _setActiveAppControlSession,
 } = await import("../daemon/host-app-control-proxy.js");
-type SurfaceConversationContext =
-  import("../daemon/conversation-surfaces.js").SurfaceConversationContext;
+type Conversation = import("../daemon/conversation.js").Conversation;
 
 // ---------------------------------------------------------------------------
 // Test helpers
 // ---------------------------------------------------------------------------
 
 /**
- * Build a minimal SurfaceConversationContext with an optional
+ * Build a minimal Conversation with an optional
  * hostAppControlProxy. Only the fields required by the app-control routing
  * path are populated.
  */
@@ -74,8 +75,8 @@ function buildMockContext(
   ) => void,
   trustGuardianPrincipalId: string | null = DEFAULT_PRINCIPAL,
   actorPrincipalId: string | null = trustGuardianPrincipalId,
-): SurfaceConversationContext {
-  return {
+): Conversation {
+  return asConversation({
     conversationId,
     trustContext:
       trustGuardianPrincipalId != null
@@ -87,13 +88,13 @@ function buildMockContext(
         : undefined,
     authContext:
       actorPrincipalId != null
-        ? ({ actorPrincipalId } as SurfaceConversationContext["authContext"])
+        ? ({ actorPrincipalId } as Conversation["authContext"])
         : undefined,
     currentTurnAuthContext:
       actorPrincipalId != null
         ? ({
             actorPrincipalId,
-          } as SurfaceConversationContext["currentTurnAuthContext"])
+          } as Conversation["currentTurnAuthContext"])
         : undefined,
     sendToClient: () => {},
     pendingSurfaceActions: new Map(),
@@ -109,8 +110,8 @@ function buildMockContext(
     enqueueMessage: () => ({ queued: false, requestId: "r1" }),
     getQueueDepth: () => 0,
     processMessage: async () => "",
-    withSurface: async (_id, fn) => fn(),
-  };
+    withSurface: createSurfaceMutex(),
+  });
 }
 
 // ---------------------------------------------------------------------------

package/src/__tests__/conversation-surfaces-app-open.test.ts

@@ -2,13 +2,17 @@ import { describe, expect, test } from "bun:test";
 
 import type { AssistantEvent } from "../api/index.js";
 import { DynamicPagePreviewSchema } from "../api/surfaces.js";
+import type { Conversation } from "../daemon/conversation.js";
 import {
   buildAppOpenPreview,
   createSurfaceMutex,
-  type SurfaceConversationContext,
   surfaceProxyResolver,
 } from "../daemon/conversation-surfaces.js";
 import type { SurfaceType } from "../daemon/message-protocol.js";
+import {
+  asConversation,
+  mockChannelCapabilities,
+} from "./helpers/mock-conversation.js";
 
 interface ContextOptions {
   hasNoClient?: boolean;
@@ -18,11 +22,13 @@ interface ContextOptions {
 function makeContext(
   sent: AssistantEvent[] = [],
   options: ContextOptions = {},
-): SurfaceConversationContext {
-  return {
+): Conversation {
+  return asConversation({
     conversationId: "session-1",
     hasNoClient: options.hasNoClient,
-    channelCapabilities: options.channelCapabilities,
+    channelCapabilities:
+      options.channelCapabilities &&
+      mockChannelCapabilities(options.channelCapabilities),
     sendToClient: (msg) => sent.push(msg),
     pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
     lastSurfaceAction: new Map<
@@ -39,7 +45,7 @@ function makeContext(
     getQueueDepth: () => 0,
     processMessage: async () => "ok",
     withSurface: createSurfaceMutex(),
-  };
+  });
 }
 
 describe("app_open render-capability gate", () => {