@vellumai/assistant 0.12.1 → 0.12.2-dev.202609162214.308bda0

package/src/__tests__/conversation-fork-crud.test.ts

@@ -5,6 +5,7 @@ import { beforeEach, describe, expect, test } from "bun:test";
 import { eq, like } from "drizzle-orm";
 
 import {
+  getAttachmentContent,
   getAttachmentsForMessage,
   linkAttachmentToMessage,
   uploadAttachment,
@@ -17,10 +18,17 @@ import {
 import {
   addMessage,
   createConversation,
+  deleteConversation,
   forkConversation,
   getMessages,
+  listConversationAttachments,
+  updateMessageMetadata,
 } from "../persistence/conversation-crud.js";
 import { getConversationDirPath } from "../persistence/conversation-disk-view.js";
+import {
+  COMPUTER_USE_SCREENSHOT_ATTACHMENT_IDS_KEY,
+  computerUseScreenshotAttachmentIdsFromMetadata,
+} from "../persistence/conversation-types.js";
 import {
   getDb,
   getLogsDb,
@@ -63,6 +71,7 @@ import {
   recordInjected as recordV3Injected,
 } from "../plugins/defaults/memory/v3/ever-injected-store.js";
 import { ensureMemoryV3InjectedSectionsSchema } from "../plugins/defaults/memory/v3/plugin-schema.js";
+import { handleListMessages } from "../runtime/routes/conversation-routes.js";
 
 await initializeDb();
 
@@ -748,6 +757,188 @@ describe("forkConversation", () => {
     );
   });
 
+  test("remaps automatic screenshot refs and widens fork provenance", async () => {
+    const screenshotBase64 =
+      "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg==";
+    const source = createConversation("Computer use thread");
+    await addMessage(source.id, "user", "Open the example", {
+      skipIndexing: true,
+    });
+    await addMessage(
+      source.id,
+      "assistant",
+      JSON.stringify([
+        {
+          type: "tool_use",
+          id: "computer-use-call",
+          name: "computer_use_click",
+          input: { x: 10, y: 20 },
+        },
+      ]),
+      { skipIndexing: true },
+    );
+    const screenshot = await uploadAttachment(
+      "computer-use-click.png",
+      "image/png",
+      screenshotBase64,
+    );
+    const toolResult = await addMessage(
+      source.id,
+      "user",
+      JSON.stringify([
+        {
+          type: "tool_result",
+          tool_use_id: "computer-use-call",
+          content: "Clicked",
+          contentBlocks: [
+            {
+              type: "image",
+              source: {
+                type: "workspace_ref",
+                media_type: "image/png",
+                attachmentId: screenshot.id,
+                sizeBytes: Buffer.from(screenshotBase64, "base64").byteLength,
+              },
+            },
+          ],
+        },
+      ]),
+      { skipIndexing: true },
+    );
+    linkAttachmentToMessage(toolResult.id, screenshot.id, 0);
+
+    const reply = await addMessage(
+      source.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "Done." }]),
+      { skipIndexing: true },
+    );
+    linkAttachmentToMessage(reply.id, screenshot.id, 0);
+    const explicit = await uploadAttachment(
+      "report.pdf",
+      "application/pdf",
+      "JVBERg==",
+    );
+    linkAttachmentToMessage(reply.id, explicit.id, 1);
+    updateMessageMetadata(reply.id, {
+      [COMPUTER_USE_SCREENSHOT_ATTACHMENT_IDS_KEY]: [screenshot.id],
+    });
+
+    const fork = forkConversation({ conversationId: source.id });
+    const forkRows = getMessages(fork.id);
+    const forkToolResult = forkRows.find(
+      (row) =>
+        row.role === "user" &&
+        JSON.stringify(row.content).includes("tool_result"),
+    );
+    const forkReply = forkRows.find(
+      (row) =>
+        row.role === "assistant" &&
+        JSON.stringify(row.content).includes("Done."),
+    );
+    expect(forkToolResult).toBeDefined();
+    expect(forkReply).toBeDefined();
+
+    const forkReplyAttachments = getAttachmentsForMessage(forkReply!.id);
+    const clonedScreenshot = forkReplyAttachments.find(
+      (attachment) => attachment.originalFilename === "computer-use-click.png",
+    );
+    const clonedExplicit = forkReplyAttachments.find(
+      (attachment) => attachment.originalFilename === "report.pdf",
+    );
+    expect(clonedScreenshot?.id).toBeDefined();
+    expect(clonedScreenshot?.id).not.toBe(screenshot.id);
+    expect(clonedExplicit?.id).toBeDefined();
+    expect(JSON.stringify(forkToolResult!.content)).toContain(
+      `"attachmentId":"${clonedScreenshot!.id}"`,
+    );
+    expect(JSON.stringify(forkToolResult!.content)).not.toContain(
+      `"attachmentId":"${screenshot.id}"`,
+    );
+    const persistedSourceToolResult = getMessages(source.id).find(
+      (row) => row.id === toolResult.id,
+    );
+    expect(JSON.stringify(persistedSourceToolResult?.content)).toContain(
+      `"attachmentId":"${screenshot.id}"`,
+    );
+    expect(JSON.stringify(persistedSourceToolResult?.content)).not.toContain(
+      `"attachmentId":"${clonedScreenshot!.id}"`,
+    );
+    expect(
+      getAttachmentsForMessage(forkToolResult!.id).map(
+        (attachment) => attachment.id,
+      ),
+    ).toEqual([clonedScreenshot!.id]);
+
+    deleteConversation(source.id);
+
+    const forkJsonl = readFileSync(
+      join(getConversationDirPath(fork.id, fork.createdAt), "messages.jsonl"),
+      "utf-8",
+    );
+    expect(forkJsonl).toContain(
+      '"toolResults":[{"content":"Clicked"}],"attachments":["computer-use-click.png"]',
+    );
+
+    const forkMarkerIds = computerUseScreenshotAttachmentIdsFromMetadata(
+      parseMetadata(forkReply!.metadata) as Record<string, unknown>,
+    );
+    expect(forkMarkerIds).toEqual([screenshot.id, clonedScreenshot!.id]);
+    expect(forkMarkerIds).not.toContain(clonedExplicit!.id);
+
+    const history = (await handleListMessages({
+      queryParams: { conversationId: fork.id },
+    })) as {
+      messages: Array<{
+        toolCalls?: Array<{ imageAttachmentIds?: string[] }>;
+        attachments: Array<{
+          id: string;
+          computerUseScreenshot?: boolean;
+        }>;
+      }>;
+    };
+    expect(
+      history.messages.flatMap((message) =>
+        (message.toolCalls ?? []).flatMap(
+          (toolCall) => toolCall.imageAttachmentIds ?? [],
+        ),
+      ),
+    ).toEqual([clonedScreenshot!.id]);
+    const hydratedScreenshot = history.messages
+      .flatMap((message) => message.attachments)
+      .find((attachment) => attachment.id === clonedScreenshot!.id);
+    const hydratedExplicit = history.messages
+      .flatMap((message) => message.attachments)
+      .find((attachment) => attachment.id === clonedExplicit!.id);
+    expect(hydratedScreenshot?.computerUseScreenshot).toBe(true);
+    expect(hydratedExplicit?.computerUseScreenshot).toBeUndefined();
+    expect(getAttachmentContent(screenshot.id)).toBeNull();
+    expect(getAttachmentContent(clonedScreenshot!.id)?.toString("base64")).toBe(
+      screenshotBase64,
+    );
+
+    const firstFilesPage = listConversationAttachments(fork.id, {
+      limit: 1,
+      offset: 0,
+    });
+    const secondFilesPage = listConversationAttachments(fork.id, {
+      limit: 1,
+      offset: 1,
+    });
+    expect(firstFilesPage.total).toBe(2);
+    expect(secondFilesPage.total).toBe(2);
+    expect(
+      [...firstFilesPage.attachments, ...secondFilesPage.attachments].map(
+        (attachment) => attachment.id,
+      ),
+    ).toEqual([clonedScreenshot!.id, clonedExplicit!.id]);
+    expect(
+      [...firstFilesPage.attachments, ...secondFilesPage.attachments].every(
+        (attachment) => attachment.messageId === forkReply!.id,
+      ),
+    ).toBe(true);
+  });
+
   test("inherits the source conversation's inference profile", async () => {
     const source = createConversation("Pinned profile thread");
     await addMessage(source.id, "user", "Use the balanced profile", {

package/src/__tests__/conversation-key-store-disk-view.test.ts

@@ -59,7 +59,7 @@ describe("conversation-key-store disk view", () => {
 
     const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
     expect(meta.id).toBe(first.conversationId);
-    expect(meta.title).toBe("Generating title...");
+    expect(meta.title).toBe("conversation.title.generating");
     expect(meta.type).toBe("standard");
     expect(meta.channel).toBeNull();
     expect(readdirSync(conversationsDir)).toEqual([expectedDirName]);

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

@@ -901,6 +901,32 @@ describe("pairDeliveryWithConversation", () => {
   // body has to land there for that button to open something that contains
   // the notification the user tapped.
 
+  test("assistant reply keeps the source conversation without appending its preview", async () => {
+    mockExistingConversations["conv-user-chat"] = {
+      id: "conv-user-chat",
+      source: "user",
+      title: "An ordinary chat",
+    };
+    const signal = makeSignal({
+      requiresConversation: undefined,
+      sourceContextId: "conv-user-chat",
+      sourceEventName: "chat.assistant_reply",
+    });
+
+    const result = await pairDeliveryWithConversation(
+      signal,
+      "vellum" as NotificationChannel,
+      makeCopy({ body: "A short push preview…" }),
+    );
+
+    expect(result.conversationId).toBe("conv-user-chat");
+    expect(result.messageId).toBeNull();
+    expect(result.createdNewConversation).toBe(false);
+    expect(createConversationMock).not.toHaveBeenCalled();
+    expect(addMessageMock).not.toHaveBeenCalled();
+    expect(messagesInvalidated).toEqual([]);
+  });
+
   test("passive vellum signal appends the body to the producing conversation", async () => {
     mockExistingConversations["conv-producer"] = {
       id: "conv-producer",

package/src/__tests__/conversation-process-app-control-preactivation.test.ts

@@ -161,12 +161,6 @@ function makeFakeContext(opts: {
       trustClass: "guardian" as const,
       guardianPrincipalId: "user-1",
     },
-    setTrustContext(
-      this: { trustContext?: TrustContext },
-      trustContext: TrustContext | null,
-    ) {
-      this.trustContext = trustContext ?? undefined;
-    },
     setTransportHints() {},
     applyHostEnvFromTransport() {},
     ensureHostProxiesForTurn() {},
@@ -415,10 +409,10 @@ describe("drainQueue preactivation re-add for host-proxy interfaces", () => {
       "U-contact",
     );
     expect(ctx.currentTurnTrustContext?.sourceChannel).toBe("slack");
-    // The drain is where a queued message commits to a run, so the resting
-    // slot names the sender too: history is scoped from it, and a slot still
-    // naming the guardian would hand the contact's turn the guardian's rows.
-    expect(ctx.trustContext).toBe(contactTrust);
+    // The slot itself is left alone; only the turn's view is corrected. A
+    // drain stamping it would attribute the conversation to a sender whose
+    // turn can still lose the processing lock at persist time.
+    expect(ctx.trustContext?.trustClass).toBe("guardian");
   });
 
   test("buildPassthroughBatch refuses to coalesce two channel senders", async () => {

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

@@ -450,17 +450,6 @@ async function waitForCondition(
   }
 }
 
-/** Count the history reloads a conversation performs from this point on. */
-function countHistoryReloads(conversation: Conversation): () => number {
-  const originalLoad = conversation.loadFromDb.bind(conversation);
-  let reloads = 0;
-  conversation.loadFromDb = async () => {
-    reloads++;
-    return originalLoad();
-  };
-  return () => reloads;
-}
-
 /**
  * Resolve the Nth pending AgentLoop.run() call. Fires the minimal events
  * that `runAgentLoop` expects (usage + message_complete) so the conversation
@@ -726,22 +715,21 @@ describe("Conversation message queue", () => {
     await new Promise((r) => setTimeout(r, 10));
   });
 
-  test("a drained turn commits its sender as the resting actor and re-scopes history", async () => {
-    // A contact's channel turn leaves the resting slot, and the resident
-    // history scoped from it, naming the contact. The guardian's message
-    // queued behind that turn must run as the guardian everywhere the slot is
-    // read, not only in the per-turn snapshot: the `<turn_context>` actor
-    // section is derived at turn start and history is scoped from the slot,
-    // so a drain that stamped only the snapshot rendered the guardian's own
-    // web turn as a trusted contact's and hid the guardian's rows from it.
+  test("the turn-context actor section describes the turn's actor, not the conversation's resting actor", async () => {
+    // The drain carries its sender on the per-turn field and leaves the
+    // resting slot naming the previous actor. The actor section is frozen at
+    // turn start, so it has to read the turn's actor: reading the slot is what
+    // told the guardian's own drained turn it was talking to a trusted
+    // contact.
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
-    conversation.setTrustContext({
-      trustClass: "trusted_contact",
-      sourceChannel: "slack",
+    const contact = {
+      trustClass: "trusted_contact" as const,
+      sourceChannel: "slack" as const,
       requesterExternalUserId: "U-contact",
-    });
+    };
+    conversation.setTrustContext(contact);
 
     const p1 = conversation.processMessage({
       content: "msg-1",
@@ -756,7 +744,6 @@ describe("Conversation message queue", () => {
       sourceChannel: "vellum" as const,
       requesterExternalUserId: "guardian-principal",
     };
-    const reloads = countHistoryReloads(conversation);
     conversation.enqueueMessage({
       content: "msg-2",
       requestId: "req-2",
@@ -767,83 +754,30 @@ describe("Conversation message queue", () => {
     await p1;
     await waitForPendingRun(2);
 
-    // Read while run 2 is in flight: the slot, the snapshot, and the frozen
-    // actor section all describe the guardian, and the history was reloaded
-    // for that scope exactly once.
-    expect(conversation.getTrustContext()).toBe(guardian);
+    // Guard the test itself: the slot must disagree with the turn, or the
+    // assertion below passes for the wrong reason.
+    expect(conversation.getTrustContext()).toBe(contact);
     expect(conversation.currentTurnTrustContext).toBe(guardian);
+    // A guardian turn renders no actor section, whatever the slot says.
     expect(conversation.currentTurnInboundActorContext).toBeNull();
-    expect(reloads()).toBe(1);
 
     await resolveRun(1);
     await new Promise((r) => setTimeout(r, 10));
   });
 
-  test("a batched drain commits the head's sender as the resting actor", async () => {
-    // Same commitment on the batched path, which coalesces only messages that
-    // share a trust identity, so the head's sender is the batch's actor.
+  test("the actor section names the drained contact while the slot holds the guardian", async () => {
+    // The inverse direction, so the assertion above cannot pass merely because
+    // the section is always absent: a contact's message drained behind the
+    // guardian's turn must be described as that contact.
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
-    conversation.setTrustContext({
-      trustClass: "trusted_contact",
-      sourceChannel: "slack",
-      requesterExternalUserId: "U-contact",
-    });
-
-    const p1 = conversation.processMessage({
-      content: "msg-1",
-      attachments: [],
-      onEvent: () => {},
-      requestId: "req-1",
-    });
-    await waitForPendingRun(1);
-
     const guardian = {
       trustClass: "guardian" as const,
       sourceChannel: "vellum" as const,
       requesterExternalUserId: "guardian-principal",
     };
-    const reloads = countHistoryReloads(conversation);
-    conversation.enqueueMessage({
-      content: "msg-2",
-      requestId: "req-2",
-      trustContext: guardian,
-    });
-    conversation.enqueueMessage({
-      content: "msg-3",
-      requestId: "req-3",
-      trustContext: guardian,
-    });
-
-    await resolveRun(0);
-    await p1;
-    await waitForPendingRun(2);
-
-    // One batched run for both siblings, committed as the guardian.
-    expect(pendingRuns.length).toBe(2);
-    expect(conversation.getTrustContext()).toBe(guardian);
-    expect(conversation.currentTurnTrustContext).toBe(guardian);
-    expect(conversation.currentTurnInboundActorContext).toBeNull();
-    expect(reloads()).toBe(1);
-
-    await resolveRun(1);
-    await new Promise((r) => setTimeout(r, 10));
-  });
-
-  test("a drained turn keeps its sender when the slot moves during the history reload", async () => {
-    // The commit captures the sender before the reload awaits. A writer that
-    // moves the slot inside that await (a wake's stamp, a pointer elevation)
-    // must not become the turn's actor: the history was reloaded for the
-    // sender, and running someone else's trust over it is the escalation.
-    const conversation = makeConversation();
-    await conversation.loadFromDb();
-
-    conversation.setTrustContext({
-      trustClass: "trusted_contact",
-      sourceChannel: "slack",
-      requesterExternalUserId: "U-contact",
-    });
+    conversation.setTrustContext(guardian);
 
     const p1 = conversation.processMessage({
       content: "msg-1",
@@ -853,49 +787,39 @@ describe("Conversation message queue", () => {
     });
     await waitForPendingRun(1);
 
-    const guardian = {
-      trustClass: "guardian" as const,
-      sourceChannel: "vellum" as const,
-      requesterExternalUserId: "guardian-principal",
-    };
-    const intruder = {
-      trustClass: "unknown" as const,
-      sourceChannel: "telegram" as const,
-      requesterExternalUserId: "T-stranger",
+    const contact = {
+      trustClass: "trusted_contact" as const,
+      sourceChannel: "slack" as const,
+      requesterExternalUserId: "U-contact",
     };
     conversation.enqueueMessage({
       content: "msg-2",
       requestId: "req-2",
-      trustContext: guardian,
+      trustContext: contact,
     });
 
-    // The drain's reload is the await the writer lands inside.
-    const originalLoad = conversation.loadFromDb.bind(conversation);
-    let movedDuringReload = false;
-    conversation.loadFromDb = async () => {
-      const result = await originalLoad();
-      conversation.setTrustContext(intruder);
-      movedDuringReload = true;
-      return result;
-    };
-
     await resolveRun(0);
     await p1;
     await waitForPendingRun(2);
 
-    expect(movedDuringReload).toBe(true);
-    expect(conversation.getTrustContext()).toBe(intruder);
-    expect(conversation.currentTurnTrustContext).toBe(guardian);
-    expect(conversation.currentTurnInboundActorContext).toBeNull();
+    expect(conversation.getTrustContext()).toBe(guardian);
+    expect(conversation.currentTurnTrustContext).toBe(contact);
+    expect(conversation.currentTurnInboundActorContext).toMatchObject({
+      trustClass: "trusted_contact",
+      sourceChannel: "slack",
+      canonicalActorIdentity: "U-contact",
+    });
 
     await resolveRun(1);
     await new Promise((r) => setTimeout(r, 10));
   });
 
-  test("a drain whose history reload fails puts the resting actor back", async () => {
-    // A reload that fails starts no turn: the message is requeued for the
-    // next drain, so the slot must not keep naming a sender whose turn never
-    // began, or conversation-level readers report an owner that is not there.
+  test("a processMessage turn whose history reload fails puts the resting actor back", async () => {
+    // `processMessage` is the commitment point, so it stamps the slot before
+    // scoping history. A reload that throws starts no turn, and leaving the
+    // stamp would attribute the conversation to a sender that never ran: an
+    // actorless dispatch afterwards (a deferred wake) resolves the resting
+    // slot and would inherit it.
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
@@ -906,110 +830,27 @@ describe("Conversation message queue", () => {
     };
     conversation.setTrustContext(contact);
 
-    const p1 = conversation.processMessage({
-      content: "msg-1",
-      attachments: [],
-      onEvent: () => {},
-      requestId: "req-1",
-    });
-    await waitForPendingRun(1);
-
-    const guardian = {
-      trustClass: "guardian" as const,
-      sourceChannel: "vellum" as const,
-      requesterExternalUserId: "guardian-principal",
-    };
-    conversation.enqueueMessage({
-      content: "msg-2",
-      requestId: "req-2",
-      trustContext: guardian,
-    });
-
-    let reloadAttempts = 0;
     conversation.loadFromDb = async () => {
-      reloadAttempts++;
       throw new Error("history store exploded");
     };
 
-    // Finish the first turn; the drain (and its one retry) fail on the reload.
-    await resolveRun(0);
-    await p1;
-    await waitForCondition(() => reloadAttempts >= 2);
-    await new Promise((r) => setTimeout(r, 20));
-
-    expect(pendingRuns.length).toBe(1);
-    expect(conversation.getQueueDepth()).toBe(1);
-    expect(conversation.getTrustContext()).toBe(contact);
-  });
-
-  test("the turn-context actor section follows the turn's actor when the slot moves before the loop opens", async () => {
-    // The actor section is frozen at turn start from the turn's own actor,
-    // not from the resting slot. The drain stamps the slot and then awaits
-    // (persist) before the loop opens; an out-of-band writer landing in that
-    // window (pointer elevation restore, a wake's restore) moves the slot
-    // without owning the turn, and a read of the slot there would describe
-    // that writer's actor to the model.
-    const conversation = makeConversation();
-    await conversation.loadFromDb();
-
-    const contact = {
-      trustClass: "trusted_contact" as const,
-      sourceChannel: "slack" as const,
-      requesterExternalUserId: "U-contact",
-    };
-    conversation.setTrustContext(contact);
-
-    const p1 = conversation.processMessage({
-      content: "msg-1",
-      attachments: [],
-      onEvent: () => {},
-      requestId: "req-1",
-    });
-    await waitForPendingRun(1);
-
     const guardian = {
       trustClass: "guardian" as const,
       sourceChannel: "vellum" as const,
       requesterExternalUserId: "guardian-principal",
     };
-    conversation.enqueueMessage({
-      content: "msg-2",
-      requestId: "req-2",
-      trustContext: guardian,
-    });
-
-    // Land the out-of-band slot write inside the drain's window, after its
-    // stamp and before the loop opens: the drain awaits persistUserMessage
-    // there. The resting slot alone is moved; the per-turn snapshot is the
-    // drain's to carry into the run.
-    const originalPersist = conversation.persistUserMessage.bind(conversation);
-    let slotMoved = false;
-    (
-      conversation as unknown as {
-        persistUserMessage: typeof conversation.persistUserMessage;
-      }
-    ).persistUserMessage = async (opts) => {
-      const result = await originalPersist(opts);
-      conversation.setTrustContext(contact);
-      slotMoved = true;
-      return result;
-    };
-
-    await resolveRun(0);
-    await p1;
-    await waitForPendingRun(2);
+    await expect(
+      conversation.processMessage({
+        content: "msg-1",
+        attachments: [],
+        onEvent: () => {},
+        requestId: "req-1",
+        trustContext: guardian,
+      }),
+    ).rejects.toThrow("history store exploded");
 
-    // Guard the test itself: the injection must have run, and the slot must
-    // disagree with the turn, or the assertion below passes for the wrong
-    // reason.
-    expect(slotMoved).toBe(true);
     expect(conversation.getTrustContext()).toBe(contact);
-    expect(conversation.currentTurnTrustContext).toBe(guardian);
-    // The guardian's turn renders no actor section, whatever the slot says.
-    expect(conversation.currentTurnInboundActorContext).toBeNull();
-
-    await resolveRun(1);
-    await new Promise((r) => setTimeout(r, 10));
+    expect(pendingRuns.length).toBe(0);
   });
 
   test("a processMessage turn keeps its turn-start trust when the slot moves before the loop opens", async () => {