@vellumai/assistant 0.11.2 → 0.11.3-staging.2

package/src/__tests__/conversation-surfaces-persisted-info.test.ts

@@ -0,0 +1,312 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// Mock the persistence layer the surface helpers read from so tests can seed
+// rows without touching SQLite. Swapped per test via the closure below.
+let getMessagesImpl: (conversationId: string) => Array<{
+  id: string;
+  conversationId: string;
+  role: string;
+  content: unknown;
+  createdAt: number;
+  metadata: string | null;
+}> = () => [];
+
+const realCrud = await import("../persistence/conversation-crud.js");
+
+mock.module("../persistence/conversation-crud.js", () => ({
+  ...realCrud,
+  getMessages: (conversationId: string) => getMessagesImpl(conversationId),
+}));
+
+// Import must come AFTER mock.module so the surface module picks up the
+// mocked persistence functions.
+const { findPersistedSurfaceInfo } =
+  await import("../daemon/conversation-surfaces.js");
+
+const CONVERSATION_ID = "conv-persisted-info-1";
+
+/** A guardian requester: sees every row, so no provenance filtering applies. */
+const GUARDIAN = { requesterCanAccessMemory: true };
+/** An untrusted requester: only non-guardian-provenance rows are visible. */
+const UNTRUSTED = { requesterCanAccessMemory: false };
+
+function seedRows(
+  rows: Array<{ id: string; content: unknown[]; metadata?: string }>,
+): void {
+  getMessagesImpl = () =>
+    rows.map((r) => ({
+      id: r.id,
+      conversationId: CONVERSATION_ID,
+      role: "assistant",
+      content: r.content,
+      createdAt: 0,
+      metadata: r.metadata ?? null,
+    }));
+}
+
+describe("findPersistedSurfaceInfo", () => {
+  beforeEach(() => {
+    getMessagesImpl = () => [];
+  });
+
+  test("returns the surfaceType of a persisted ui_surface block", () => {
+    seedRows([
+      {
+        id: "msg-1",
+        content: [
+          { type: "text", text: "pick one" },
+          {
+            type: "ui_surface",
+            surfaceId: "surface-choice-1",
+            surfaceType: "choice",
+            data: { options: [] },
+          },
+        ],
+      },
+    ]);
+
+    expect(
+      findPersistedSurfaceInfo(CONVERSATION_ID, "surface-choice-1", GUARDIAN)
+        ?.surfaceType,
+    ).toBe("choice");
+  });
+
+  test("returns the data of a persisted ui_surface block", () => {
+    seedRows([
+      {
+        id: "msg-1",
+        content: [
+          {
+            type: "ui_surface",
+            surfaceId: "surface-confirm-1",
+            surfaceType: "confirmation",
+            data: { message: "Delete it?", confirmLabel: "Delete forever" },
+          },
+        ],
+      },
+    ]);
+
+    expect(
+      findPersistedSurfaceInfo(CONVERSATION_ID, "surface-confirm-1", GUARDIAN)
+        ?.data,
+    ).toEqual({ message: "Delete it?", confirmLabel: "Delete forever" });
+  });
+
+  test("reports no data when the block carries no object data", () => {
+    seedRows([
+      {
+        id: "msg-1",
+        content: [
+          {
+            type: "ui_surface",
+            surfaceId: "surface-dataless-1",
+            surfaceType: "choice",
+          },
+        ],
+      },
+    ]);
+
+    const info = findPersistedSurfaceInfo(
+      CONVERSATION_ID,
+      "surface-dataless-1",
+      GUARDIAN,
+    );
+    expect(info?.surfaceType).toBe("choice");
+    expect(info?.data).toBeUndefined();
+  });
+
+  test("returns undefined for an unknown surfaceId", () => {
+    seedRows([
+      {
+        id: "msg-1",
+        content: [
+          {
+            type: "ui_surface",
+            surfaceId: "surface-choice-1",
+            surfaceType: "choice",
+            data: {},
+          },
+        ],
+      },
+    ]);
+
+    expect(
+      findPersistedSurfaceInfo(CONVERSATION_ID, "surface-missing", GUARDIAN),
+    ).toBeUndefined();
+  });
+
+  test("returns undefined for a conversation with no messages", () => {
+    seedRows([]);
+
+    expect(
+      findPersistedSurfaceInfo(CONVERSATION_ID, "surface-choice-1", GUARDIAN),
+    ).toBeUndefined();
+  });
+
+  test("reaches the oldest row when the newer ones carry no surface", () => {
+    seedRows([
+      {
+        id: "msg-oldest",
+        content: [
+          {
+            type: "ui_surface",
+            surfaceId: "surface-oldest-1",
+            surfaceType: "choice",
+            data: {},
+          },
+        ],
+      },
+      { id: "msg-2", content: [{ type: "text", text: "later" }] },
+      { id: "msg-3", content: [{ type: "text", text: "later" }] },
+      { id: "msg-4", content: [{ type: "text", text: "later" }] },
+    ]);
+
+    expect(
+      findPersistedSurfaceInfo(CONVERSATION_ID, "surface-oldest-1", GUARDIAN)
+        ?.surfaceType,
+    ).toBe("choice");
+  });
+
+  test("reports no surfaceType when the block carries no string one", () => {
+    seedRows([
+      {
+        id: "msg-1",
+        content: [
+          { type: "ui_surface", surfaceId: "surface-typeless-1", data: {} },
+        ],
+      },
+    ]);
+
+    const info = findPersistedSurfaceInfo(
+      CONVERSATION_ID,
+      "surface-typeless-1",
+      GUARDIAN,
+    );
+    expect(info).toBeDefined();
+    expect(info?.surfaceType).toBeUndefined();
+  });
+
+  test("returns undefined rather than throwing when the DB read fails", () => {
+    getMessagesImpl = () => {
+      throw new Error("database is locked");
+    };
+
+    expect(
+      findPersistedSurfaceInfo(CONVERSATION_ID, "surface-choice-1", GUARDIAN),
+    ).toBeUndefined();
+  });
+
+  test("hides a guardian-provenance row from an untrusted requester", () => {
+    seedRows([
+      {
+        id: "msg-guardian",
+        metadata: JSON.stringify({ provenanceTrustClass: "guardian" }),
+        content: [
+          {
+            type: "ui_surface",
+            surfaceId: "surface-guardian-1",
+            surfaceType: "confirmation",
+            data: { confirmLabel: "Wire the money" },
+          },
+        ],
+      },
+    ]);
+
+    // The same row the live history filter drops for this actor.
+    expect(
+      findPersistedSurfaceInfo(
+        CONVERSATION_ID,
+        "surface-guardian-1",
+        UNTRUSTED,
+      ),
+    ).toBeUndefined();
+    expect(
+      findPersistedSurfaceInfo(CONVERSATION_ID, "surface-guardian-1", GUARDIAN)
+        ?.data,
+    ).toEqual({ confirmLabel: "Wire the money" });
+  });
+
+  test("hides a provenance-less row from an untrusted requester", () => {
+    seedRows([
+      {
+        id: "msg-no-metadata",
+        content: [
+          {
+            type: "ui_surface",
+            surfaceId: "surface-unstamped-1",
+            surfaceType: "choice",
+            data: {},
+          },
+        ],
+      },
+    ]);
+
+    expect(
+      findPersistedSurfaceInfo(
+        CONVERSATION_ID,
+        "surface-unstamped-1",
+        UNTRUSTED,
+      ),
+    ).toBeUndefined();
+  });
+
+  test("serves a contact-provenance row to an untrusted requester", () => {
+    seedRows([
+      {
+        id: "msg-contact",
+        metadata: JSON.stringify({ provenanceTrustClass: "trusted_contact" }),
+        content: [
+          {
+            type: "ui_surface",
+            surfaceId: "surface-contact-1",
+            surfaceType: "choice",
+            data: { options: [] },
+          },
+        ],
+      },
+    ]);
+
+    expect(
+      findPersistedSurfaceInfo(CONVERSATION_ID, "surface-contact-1", UNTRUSTED)
+        ?.surfaceType,
+    ).toBe("choice");
+  });
+
+  test("skips a filtered newer row and serves the visible older one", () => {
+    seedRows([
+      {
+        id: "msg-contact",
+        metadata: JSON.stringify({ provenanceTrustClass: "trusted_contact" }),
+        content: [
+          {
+            type: "ui_surface",
+            surfaceId: "surface-dup-1",
+            surfaceType: "choice",
+            data: { options: [{ id: "visible" }] },
+          },
+        ],
+      },
+      {
+        id: "msg-guardian",
+        metadata: JSON.stringify({ provenanceTrustClass: "guardian" }),
+        content: [
+          {
+            type: "ui_surface",
+            surfaceId: "surface-dup-1",
+            surfaceType: "confirmation",
+            data: { options: [{ id: "hidden" }] },
+          },
+        ],
+      },
+    ]);
+
+    expect(
+      findPersistedSurfaceInfo(CONVERSATION_ID, "surface-dup-1", UNTRUSTED)
+        ?.data,
+    ).toEqual({ options: [{ id: "visible" }] });
+    expect(
+      findPersistedSurfaceInfo(CONVERSATION_ID, "surface-dup-1", GUARDIAN)
+        ?.data,
+    ).toEqual({ options: [{ id: "hidden" }] });
+  });
+});

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

@@ -1,24 +1,25 @@
 import { describe, expect, test } from "bun:test";
 
 import type { AssistantEvent, AssistantEventEnvelope } from "../api/index.js";
+import type { Conversation } from "../daemon/conversation.js";
 import {
   createSurfaceMutex,
   handleSurfaceAction,
-  type SurfaceConversationContext,
 } from "../daemon/conversation-surfaces.js";
 import type { SurfaceType } from "../daemon/message-protocol.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
+import { asConversation } from "./helpers/mock-conversation.js";
 
 const CONV_ID = "surfaces-queued-emit-conv";
 
 /**
- * Minimal SurfaceConversationContext whose `enqueueMessage` behaves like the
+ * Minimal Conversation whose `enqueueMessage` behaves like the
  * real one on the queued path: it acks the accepted enqueue by emitting
  * `message_queued` on the caller-supplied `onEvent` sink, then reports
  * `queued: true`.
  */
-function makeQueuedContext(): SurfaceConversationContext {
-  return {
+function makeQueuedContext(): Conversation {
+  return asConversation({
     conversationId: CONV_ID,
     sendToClient: () => {},
     pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
@@ -45,7 +46,7 @@ function makeQueuedContext(): SurfaceConversationContext {
     getQueueDepth: () => 1,
     processMessage: async () => "ok",
     withSurface: createSurfaceMutex(),
-  };
+  });
 }
 
 describe("surface action queued path", () => {

package/src/__tests__/conversation-surfaces-standalone-payloads.test.ts

@@ -26,12 +26,17 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
   broadcastMessage: (msg: AssistantEvent) => broadcastImpl(msg),
 }));
 
+import type { Conversation } from "../daemon/conversation.js";
 import {
   buildCompletionSummary,
+  createSurfaceMutex,
   handleSurfaceAction,
   showStandaloneSurface,
-  type SurfaceConversationContext,
 } from "../daemon/conversation-surfaces.js";
+import {
+  asConversation,
+  mockChannelCapabilities,
+} from "./helpers/mock-conversation.js";
 
 // ── Helpers ──────────────────────────────────────────────────────────
 
@@ -41,7 +46,7 @@ function createMockContext(
     supportsDynamicUi: boolean;
     channel: string;
   }>,
-): SurfaceConversationContext & {
+): Conversation & {
   sentMessages: AssistantEvent[];
   enqueuedMessages: Array<{ content: string; requestId: string }>;
 } {
@@ -49,15 +54,15 @@ function createMockContext(
   broadcastImpl = (msg: AssistantEvent) => sentMessages.push(msg);
   const enqueuedMessages: Array<{ content: string; requestId: string }> = [];
 
-  return {
+  return asConversation({
     conversationId: "payload-test-conv",
     assistantId: undefined,
     trustContext: undefined,
     channelCapabilities: overrides?.channel
-      ? {
+      ? mockChannelCapabilities({
           channel: overrides.channel,
           supportsDynamicUi: overrides.supportsDynamicUi ?? true,
-        }
+        })
       : undefined,
     sendToClient: (msg: AssistantEvent) => sentMessages.push(msg),
     pendingSurfaceActions: new Map(),
@@ -81,11 +86,10 @@ function createMockContext(
     },
     getQueueDepth: () => 0,
     processMessage: async () => "msg-id",
-    withSurface: async <T>(_surfaceId: string, fn: () => T | Promise<T>) =>
-      fn(),
+    withSurface: createSurfaceMutex(),
     sentMessages,
     enqueuedMessages,
-  };
+  });
 }
 
 type AnyRecord = Record<string, unknown>;

package/src/__tests__/conversation-surfaces-standalone.test.ts

@@ -8,18 +8,23 @@ mock.module("../runtime/assistant-event-hub.js", () => ({
   broadcastMessage: (msg: AssistantEvent) => broadcastImpl(msg),
 }));
 
+import type { Conversation } from "../daemon/conversation.js";
 import {
   canShowInteractiveUi,
   cleanupStandaloneSurface,
+  createSurfaceMutex,
   handleSurfaceAction,
   showStandaloneSurface,
-  type SurfaceConversationContext,
 } from "../daemon/conversation-surfaces.js";
+import {
+  asConversation,
+  mockChannelCapabilities,
+} from "./helpers/mock-conversation.js";
 
 // ── Helpers ──────────────────────────────────────────────────────────
 
 /**
- * Build a minimal SurfaceConversationContext stub for testing standalone
+ * Build a minimal Conversation stub for testing standalone
  * surface lifecycle. Only the fields accessed by the standalone surface
  * functions are populated.
  */
@@ -29,7 +34,7 @@ function createMockContext(
     supportsDynamicUi: boolean;
     channel: string;
   }>,
-): SurfaceConversationContext & {
+): Conversation & {
   sentMessages: AssistantEvent[];
   enqueuedMessages: Array<{ content: string; requestId: string }>;
 } {
@@ -37,15 +42,15 @@ function createMockContext(
   broadcastImpl = (msg: AssistantEvent) => sentMessages.push(msg);
   const enqueuedMessages: Array<{ content: string; requestId: string }> = [];
 
-  return {
+  return asConversation({
     conversationId: "test-conv-1",
     assistantId: undefined,
     trustContext: undefined,
     channelCapabilities: overrides?.channel
-      ? {
+      ? mockChannelCapabilities({
           channel: overrides.channel,
           supportsDynamicUi: overrides.supportsDynamicUi ?? true,
-        }
+        })
       : undefined,
     sendToClient: (msg: AssistantEvent) => sentMessages.push(msg),
     pendingSurfaceActions: new Map(),
@@ -70,11 +75,10 @@ function createMockContext(
     },
     getQueueDepth: () => 0,
     processMessage: async () => "msg-id",
-    withSurface: async <T>(_surfaceId: string, fn: () => T | Promise<T>) =>
-      fn(),
+    withSurface: createSurfaceMutex(),
     sentMessages,
     enqueuedMessages,
-  };
+  });
 }
 
 // ── canShowInteractiveUi ─────────────────────────────────────────────
@@ -102,7 +106,10 @@ describe("canShowInteractiveUi", () => {
     expect(
       canShowInteractiveUi({
         hasNoClient: false,
-        channelCapabilities: { channel: "sms", supportsDynamicUi: false },
+        channelCapabilities: mockChannelCapabilities({
+          channel: "sms",
+          supportsDynamicUi: false,
+        }),
       }),
     ).toBe(false);
   });
@@ -111,7 +118,10 @@ describe("canShowInteractiveUi", () => {
     expect(
       canShowInteractiveUi({
         hasNoClient: false,
-        channelCapabilities: { channel: "web", supportsDynamicUi: true },
+        channelCapabilities: mockChannelCapabilities({
+          channel: "web",
+          supportsDynamicUi: true,
+        }),
       }),
     ).toBe(true);
   });

package/src/__tests__/conversation-surfaces-state-update.test.ts

@@ -1,23 +1,22 @@
 import { describe, expect, test } from "bun:test";
 
 import type { AssistantEvent } from "../api/index.js";
+import type { Conversation } from "../daemon/conversation.js";
 import {
   createSurfaceMutex,
   handleSurfaceAction,
   restoreSurfaceStateEntry,
-  type SurfaceConversationContext,
   surfaceProxyResolver,
 } from "../daemon/conversation-surfaces.js";
 import type { SurfaceType } from "../daemon/message-protocol.js";
+import { asConversation } from "./helpers/mock-conversation.js";
 
 /**
- * Build a minimal SurfaceConversationContext for testing.
+ * Build a minimal Conversation for testing.
  * Tracks calls to enqueueMessage and processMessage so tests can assert
  * whether an LLM turn was triggered.
  */
-function makeContext(opts?: {
-  sent?: AssistantEvent[];
-}): SurfaceConversationContext & {
+function makeContext(opts?: { sent?: AssistantEvent[] }): Conversation & {
   enqueueCalls: Array<{ content: string; requestId: string }>;
   processCalls: Array<{ content: string; requestId?: string }>;
 } {
@@ -25,7 +24,7 @@ function makeContext(opts?: {
   const enqueueCalls: Array<{ content: string; requestId: string }> = [];
   const processCalls: Array<{ content: string; requestId?: string }> = [];
 
-  return {
+  return asConversation({
     conversationId: "test-session",
     sendToClient: (msg) => sent.push(msg),
     pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
@@ -55,14 +54,11 @@ function makeContext(opts?: {
     withSurface: createSurfaceMutex(),
     enqueueCalls,
     processCalls,
-  };
+  });
 }
 
 /** Register a dynamic_page surface in the context so state_update is accepted. */
-function registerDynamicPage(
-  ctx: SurfaceConversationContext,
-  surfaceId: string,
-): void {
+function registerDynamicPage(ctx: Conversation, surfaceId: string): void {
   ctx.pendingSurfaceActions.set(surfaceId, { surfaceType: "dynamic_page" });
   ctx.surfaceState.set(surfaceId, {
     surfaceType: "dynamic_page",

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

@@ -1,19 +1,20 @@
 import { describe, expect, test } from "bun:test";
 
 import type { AssistantEvent } from "../api/index.js";
+import type { Conversation } from "../daemon/conversation.js";
 import {
   createSurfaceMutex,
   handleSurfaceAction,
-  type SurfaceConversationContext,
 } from "../daemon/conversation-surfaces.js";
 import type { SurfaceType } from "../daemon/message-protocol.js";
+import { asConversation } from "./helpers/mock-conversation.js";
 
 /**
- * Build a minimal SurfaceConversationContext for testing table surface actions.
+ * Build a minimal Conversation for testing table surface actions.
  * Tracks calls to enqueueMessage and processMessage so tests can assert
  * whether an LLM turn was triggered with the correct content.
  */
-function makeContext(): SurfaceConversationContext & {
+function makeContext(): Conversation & {
   enqueueCalls: Array<{
     content: string;
     requestId: string;
@@ -46,7 +47,7 @@ function makeContext(): SurfaceConversationContext & {
   }> = [];
   const sentMessages: AssistantEvent[] = [];
 
-  return {
+  return asConversation({
     conversationId: "test-convo",
     sendToClient: (msg) => sentMessages.push(msg),
     pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
@@ -85,7 +86,7 @@ function makeContext(): SurfaceConversationContext & {
     enqueueCalls,
     processCalls,
     sentMessages,
-  };
+  });
 }
 
 /**
@@ -93,7 +94,7 @@ function makeContext(): SurfaceConversationContext & {
  * mimicking what surfaceProxyResolver does for ui_show with await_action.
  */
 function registerTableSurface(
-  ctx: SurfaceConversationContext,
+  ctx: Conversation,
   surfaceId: string,
   opts?: {
     selectionMode?: "single" | "multiple" | "none";

package/src/__tests__/conversation-surfaces-task-progress.test.ts

@@ -1,9 +1,9 @@
 import { describe, expect, test } from "bun:test";
 
 import type { AssistantEvent } from "../api/index.js";
+import type { Conversation } from "../daemon/conversation.js";
 import {
   createSurfaceMutex,
-  type SurfaceConversationContext,
   surfaceProxyResolver,
 } from "../daemon/conversation-surfaces.js";
 import type {
@@ -13,14 +13,19 @@ import type {
   UiSurfaceShow,
   UISurfaceUpdateEvent,
 } from "../daemon/message-protocol.js";
+import {
+  asConversation,
+  mockChannelCapabilities,
+} from "./helpers/mock-conversation.js";
 
 function makeContext(
   sent: AssistantEvent[] = [],
-  channelCapabilities?: SurfaceConversationContext["channelCapabilities"],
-): SurfaceConversationContext {
-  return {
+  channelCapabilities?: { channel: string; supportsDynamicUi: boolean },
+): Conversation {
+  return asConversation({
     conversationId: "session-1",
-    channelCapabilities,
+    channelCapabilities:
+      channelCapabilities && mockChannelCapabilities(channelCapabilities),
     sendToClient: (msg) => sent.push(msg),
     pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
     lastSurfaceAction: new Map<
@@ -37,7 +42,7 @@ function makeContext(
     getQueueDepth: () => 0,
     processMessage: async () => "ok",
     withSurface: createSurfaceMutex(),
-  };
+  });
 }
 
 describe("task_progress surface compatibility", () => {

package/src/__tests__/conversation-tool-setup-app-refresh.test.ts

@@ -13,7 +13,7 @@
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import type { ToolSetupContext } from "../daemon/conversation-tool-setup.js";
+import type { Conversation } from "../daemon/conversation.js";
 import { SYNC_TAGS } from "../daemon/message-types/sync.js";
 import type { PermissionPrompter } from "../permissions/prompter.js";
 import type { SecretPrompter } from "../permissions/secret-prompter.js";
@@ -65,7 +65,9 @@ mock.module("../apps/app-store.js", () => ({
 // Import createToolExecutor after mocks are in place
 // ---------------------------------------------------------------------------
 
+import { createSurfaceMutex } from "../daemon/conversation-surfaces.js";
 import { createToolExecutor } from "../daemon/conversation-tool-setup.js";
+import { asConversation } from "./helpers/mock-conversation.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -84,12 +86,13 @@ function expectAppChangeBroadcast(appId: string): void {
   );
 }
 
-/** Build a minimal ToolSetupContext stub. */
-function makeCtx(overrides: Partial<ToolSetupContext> = {}): ToolSetupContext {
-  return {
+/** Build a minimal Conversation stub. */
+function makeCtx(overrides: Partial<Conversation> = {}): Conversation {
+  return asConversation({
     conversationId: "conv-test",
     currentRequestId: "req-1",
     workingDir: "/tmp/test",
+    getTurnActorPrincipalId: () => undefined,
     abortController: null,
     sendToClient: mock(() => {}),
     pendingSurfaceActions: new Map(),
@@ -103,9 +106,9 @@ function makeCtx(overrides: Partial<ToolSetupContext> = {}): ToolSetupContext {
     enqueueMessage: () => ({ queued: false, requestId: "r" }),
     getQueueDepth: () => 0,
     processMessage: async () => "",
-    withSurface: async <T>(_id: string, fn: () => T | Promise<T>) => fn(),
+    withSurface: createSurfaceMutex(),
     ...overrides,
-  };
+  });
 }
 
 /** Fake ToolExecutor whose execute() returns a controlled result. */