@vellumai/assistant 0.11.2 → 0.11.3-staging.2

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

@@ -164,7 +164,11 @@ function makeConversationWithPendingConfirmation(
       promoteToHead: (requestId: string) => ({ requestId }),
     },
     pendingSteerRepair: false,
-    setTrustContext: () => {},
+    // Stores rather than discarding, so a test can observe which trust the
+    // route resolved and move the slot afterwards.
+    setTrustContext(this: { trustContext: unknown }, ctx: unknown) {
+      this.trustContext = ctx;
+    },
     updateClient: () => {},
     emitConfirmationStateChanged: () => {},
     emitActivityState: () => {},
@@ -354,3 +358,62 @@ describe("hidden sends to an idle conversation with a pending confirmation", ()
     expect(spies.agentLoopOptions()?.isHiddenPrompt).toBeUndefined();
   });
 });
+
+describe("POST /messages turn trust", () => {
+  test("the idle send path runs its turn under the trust resolved for the request", async () => {
+    // The idle web path does not go through `processMessage`; it persists and
+    // calls `runAgentLoop` directly. Without the captured trust travelling
+    // with that call, the loop re-reads the conversation slot when it opens,
+    // and the slot is writable in between by paths that do not own this turn
+    // (channel ingress for another actor, live-voice hydration, pointer
+    // elevation, the voice bridge).
+    //
+    // The defect here is at the call site, not inside the loop, so observing
+    // the options the route passes is sufficient. The re-read *inside* the
+    // loop is covered separately against a real Conversation, since a stub
+    // like this one cannot see it.
+    const spies = makeConversationWithPendingConfirmation(false);
+    setConversation(CONV_ID, spies.conversation);
+
+    const conversation = spies.conversation as unknown as {
+      trustContext: unknown;
+      persistUserMessage: () => Promise<{ id: string; deduplicated: boolean }>;
+    };
+
+    // Another actor writes the slot inside the window, after the route
+    // resolves this request's trust and before the loop call.
+    let slotMoved = false;
+    conversation.persistUserMessage = async () => {
+      conversation.trustContext = {
+        trustClass: "trusted_contact",
+        sourceChannel: "slack",
+        requesterExternalUserId: "U-other-actor",
+      };
+      slotMoved = true;
+      return { id: "persisted-user-id", deduplicated: false };
+    };
+
+    const res = await callHandler(
+      (args) => handleSendMessage(args, makeDeps(spies.conversation)),
+      makeRequest({ content: "run a command" }),
+      undefined,
+      202,
+    );
+
+    expect(res.status).toBe(202);
+    // Guard the test itself: if the injection stopped running the assertion
+    // below would pass for the wrong reason.
+    expect(slotMoved).toBe(true);
+    expect(
+      (conversation.trustContext as { trustClass?: string } | undefined)
+        ?.trustClass,
+    ).toBe("trusted_contact");
+
+    // The turn carries the trust this request resolved, not the moved slot.
+    const turnTrust = spies.agentLoopOptions()?.turnTrustContext as
+      | { trustClass?: string }
+      | undefined;
+    expect(turnTrust).toBeDefined();
+    expect(turnTrust?.trustClass).toBe("guardian");
+  });
+});

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", () => {

package/src/__tests__/conversation-surfaces-data-persist.test.ts

@@ -46,15 +46,16 @@ 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 {
   CardSurfaceData,
   SurfaceData,
   SurfaceType,
 } from "../daemon/message-protocol.js";
+import { asConversation } from "./helpers/mock-conversation.js";
 
-function makeContext(sent: AssistantEvent[] = []): SurfaceConversationContext {
-  return {
+function makeContext(sent: AssistantEvent[] = []): Conversation {
+  return asConversation({
     conversationId: "conv-persist-1",
     sendToClient: (msg) => sent.push(msg),
     pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
@@ -74,7 +75,7 @@ function makeContext(sent: AssistantEvent[] = []): SurfaceConversationContext {
     getQueueDepth: () => 0,
     processMessage: async () => "ok",
     withSurface: createSurfaceMutex(),
-  };
+  });
 }
 
 function seedRows(rows: Array<{ id: string; content: unknown }>): void {