@vellumai/assistant 0.11.7-dev.202609011522.ce7ad01 → 0.11.7-dev.202609011637.5f3cbff

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.7-dev.202609011522.ce7ad01",
+  "version": "0.11.7-dev.202609011637.5f3cbff",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/access-request-seed-content-blocks.test.ts

@@ -90,7 +90,7 @@ describe("buildAccessRequestSeedContentBlocks", () => {
     });
     expect(data.metadata).toContainEqual({
       label: "Source",
-      value: "Slack — #C01ABC",
+      value: "Slack · #C01ABC",
     });
   });
 
@@ -101,7 +101,7 @@ describe("buildAccessRequestSeedContentBlocks", () => {
     });
     expect(surfaceOf(blocks).data.metadata).toContainEqual({
       label: "Source",
-      value: "Slack — Direct message",
+      value: "Slack · Direct message",
     });
   });
 

package/src/__tests__/channel-delivery-store.test.ts

@@ -180,6 +180,63 @@ describe("channel-delivery-store", () => {
     ).toBeNull();
   });
 
+  test("linked inbound rows are excluded from the provider-id scan; crash-window rows resolve", () => {
+    const chatId = "chat-scan-budget";
+    const minted = recordInbound("telegram", chatId, "evt-linked", {
+      sourceMessageId: "tg-linked-1",
+    });
+    const envelope = (messageId: string) =>
+      JSON.stringify({
+        providerMeta: JSON.stringify({
+          source: "telegram",
+          conversationExternalId: chatId,
+          messageId,
+          eventKind: "message",
+        }),
+      });
+
+    // A normally-ingested inbound row: linked to its event, so the
+    // inbound-event index owns its resolution and the fallback scan must
+    // not spend budget on it.
+    insertMessage("linked-user-row", minted.conversationId, {});
+    getDb()
+      .update(messages)
+      .set({ metadata: envelope("tg-linked-1") })
+      .where(eq(messages.id, "linked-user-row"))
+      .run();
+    linkMessage(minted.eventId, "linked-user-row");
+    expect(
+      findConversationByProviderMessageId("telegram", chatId, "tg-linked-1"),
+    ).toBeNull();
+
+    // A crash-window row: persisted with its envelope but its event link
+    // never landed. The fallback is the only path that can resolve it.
+    insertMessage("orphan-user-row", minted.conversationId, {});
+    getDb()
+      .update(messages)
+      .set({ metadata: envelope("tg-orphan-1") })
+      .where(eq(messages.id, "orphan-user-row"))
+      .run();
+    expect(
+      findConversationByProviderMessageId("telegram", chatId, "tg-orphan-1"),
+    ).toBe(minted.conversationId);
+
+    // A legacy linked row whose event carries no source_message_id:
+    // findMessageBySourceId matches only that column, so the fallback must
+    // still admit the row or reactions to it become unresolvable.
+    const legacy = recordInbound("telegram", chatId, "evt-legacy");
+    insertMessage("legacy-user-row", legacy.conversationId, {});
+    getDb()
+      .update(messages)
+      .set({ metadata: envelope("tg-legacy-1") })
+      .where(eq(messages.id, "legacy-user-row"))
+      .run();
+    linkMessage(legacy.eventId, "legacy-user-row");
+    expect(
+      findConversationByProviderMessageId("telegram", chatId, "tg-legacy-1"),
+    ).toBe(legacy.conversationId);
+  });
+
   test("same chat on same channel reuses the same conversation", () => {
     const r1 = recordInbound("telegram", "chat-1", "msg-1");
     const r2 = recordInbound("telegram", "chat-1", "msg-2");

package/src/__tests__/channel-retry-sweep.test.ts

@@ -236,6 +236,55 @@ function seedFailedSlackEvent(opts: {
   return inbound.eventId;
 }
 
+function seedFailedTelegramEvent(opts: {
+  content: string;
+  externalChatId: string;
+  messageId: string;
+  threadId?: string;
+  /** Sender display name as `storePayload` records it at ingress. */
+  senderName?: string;
+  /** Stands in for the `channelInbound` the live path captures onto the payload. */
+  channelInbound?: Record<string, unknown>;
+}): string {
+  const inbound = deliveryCrud.recordInbound(
+    "telegram",
+    opts.externalChatId,
+    opts.messageId,
+  );
+  deliveryCrud.storePayload(inbound.eventId, {
+    content: opts.content,
+    sourceChannel: "telegram",
+    interface: "telegram",
+    externalChatId: opts.externalChatId,
+    externalMessageId: opts.messageId,
+    sourceMetadata: {
+      messageId: opts.messageId,
+      ...(opts.threadId ? { threadId: opts.threadId } : {}),
+    },
+    ...(opts.senderName ? { senderName: opts.senderName } : {}),
+    ...(opts.channelInbound ? { channelInbound: opts.channelInbound } : {}),
+    trustCtx: {
+      trustClass: "guardian",
+      sourceChannel: "telegram",
+      requesterExternalUserId: "user-1",
+      requesterChatId: opts.externalChatId,
+      guardianPrincipalId: "principal-1",
+    },
+  });
+
+  getDb()
+    .update(channelInboundEvents)
+    .set({
+      processingStatus: "failed",
+      processingAttempts: 1,
+      retryAfter: Date.now() - 1,
+    })
+    .where(eq(channelInboundEvents.id, inbound.eventId))
+    .run();
+
+  return inbound.eventId;
+}
+
 describe("channel-retry-sweep", () => {
   beforeEach(() => {
     resetTables();
@@ -442,6 +491,125 @@ describe("channel-retry-sweep", () => {
     expect(capturedOptions?.slackInbound?.channelTs).toBe("1700000000.000200");
   });
 
+  test("replays a captured channelInbound envelope verbatim", async () => {
+    const captured = {
+      source: "telegram",
+      conversationExternalId: "chat-500",
+      messageId: "tg-msg-1",
+      threadId: "topic-3",
+      actorExternalId: "user-77",
+      displayName: "Alice",
+      eventKind: "message",
+    };
+    seedFailedTelegramEvent({
+      content: "retry me",
+      externalChatId: "chat-500",
+      messageId: "tg-msg-1",
+      channelInbound: captured,
+    });
+
+    let capturedOptions:
+      | { channelInbound?: Record<string, unknown> }
+      | undefined;
+    await sweepFailedEvents(async (conversationId, content, options) => {
+      capturedOptions = options as {
+        channelInbound?: Record<string, unknown>;
+      };
+      const messageId = "message-tg-captured";
+      getDb()
+        .insert(messages)
+        .values({
+          id: messageId,
+          conversationId,
+          role: "user",
+          content: JSON.stringify([{ type: "text", text: content }]),
+          createdAt: Date.now(),
+        })
+        .run();
+      return { messageId };
+    });
+
+    // The captured envelope is the EXACT object the live turn used, so the
+    // replayed row persists an identical providerMeta.
+    expect(capturedOptions?.channelInbound).toEqual(captured);
+  });
+
+  test("reconstructs channelInbound from the stored payload when no capture exists", async () => {
+    // The crash window: `storePayload` ran at ingress but the daemon died
+    // before `storeInboundChannelMetadata`. Recovery must rebuild the same
+    // envelope the live turn would have persisted, sender fields included.
+    seedFailedTelegramEvent({
+      content: "retry me",
+      externalChatId: "chat-501",
+      messageId: "tg-msg-2",
+      threadId: "topic-9",
+      senderName: "Alice",
+    });
+
+    let capturedOptions:
+      | { channelInbound?: Record<string, unknown> }
+      | undefined;
+    await sweepFailedEvents(async (conversationId, content, options) => {
+      capturedOptions = options as {
+        channelInbound?: Record<string, unknown>;
+      };
+      const messageId = "message-tg-fallback";
+      getDb()
+        .insert(messages)
+        .values({
+          id: messageId,
+          conversationId,
+          role: "user",
+          content: JSON.stringify([{ type: "text", text: content }]),
+          createdAt: Date.now(),
+        })
+        .run();
+      return { messageId };
+    });
+
+    expect(capturedOptions?.channelInbound).toEqual({
+      source: "telegram",
+      conversationExternalId: "chat-501",
+      messageId: "tg-msg-2",
+      threadId: "topic-9",
+      displayName: "Alice",
+      actorExternalId: "user-1",
+      eventKind: "message",
+    });
+  });
+
+  test("a Slack replay carries no channelInbound (Slack keeps slackMeta)", async () => {
+    seedFailedSlackEvent({
+      trustClass: "guardian",
+      content: "hello",
+      externalChatId: "C0000001",
+      channelTs: "1700000001.000100",
+    });
+
+    let capturedOptions:
+      | { channelInbound?: Record<string, unknown> }
+      | undefined;
+    await sweepFailedEvents(async (conversationId, content, options) => {
+      capturedOptions = options as {
+        channelInbound?: Record<string, unknown>;
+      };
+      const messageId = "message-slack-no-neutral";
+      getDb()
+        .insert(messages)
+        .values({
+          id: messageId,
+          conversationId,
+          role: "user",
+          content: JSON.stringify([{ type: "text", text: content }]),
+          createdAt: Date.now(),
+        })
+        .run();
+      return { messageId };
+    });
+
+    expect(capturedOptions?.channelInbound).toBeUndefined();
+  });
+
   test("replays the sender's Slack app context from the captured slackInbound", async () => {
     seedFailedSlackEvent({
       trustClass: "guardian",

package/src/__tests__/external-binding-chat-name.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, test } from "bun:test";
+
+import { createConversation } from "../persistence/conversation-crud.js";
+import { initializeDb } from "../persistence/db-init.js";
+import {
+  getBindingByConversation,
+  upsertBinding,
+} from "../persistence/external-conversation-store.js";
+
+await initializeDb();
+
+async function boundConversation(): Promise<string> {
+  const conversation = await createConversation({ title: "t" });
+  upsertBinding({
+    conversationId: conversation.id,
+    sourceChannel: "slack",
+    externalChatId: "C0123CHANNEL",
+    externalChatName: "user-feedback",
+  });
+  return conversation.id;
+}
+
+describe("upsertBinding chat-name preservation", () => {
+  test("a nameless upsert for the same chat keeps the stored name", async () => {
+    const conversationId = await boundConversation();
+    upsertBinding({
+      conversationId,
+      sourceChannel: "slack",
+      externalChatId: "C0123CHANNEL",
+    });
+    expect(getBindingByConversation(conversationId)?.externalChatName).toBe(
+      "user-feedback",
+    );
+  });
+
+  test("a move to a nameless chat clears the stored name", async () => {
+    const conversationId = await boundConversation();
+    upsertBinding({
+      conversationId,
+      sourceChannel: "slack",
+      externalChatId: "D0MOVEDHERE",
+    });
+    const binding = getBindingByConversation(conversationId);
+    expect(binding?.externalChatId).toBe("D0MOVEDHERE");
+    expect(binding?.externalChatName ?? null).toBeNull();
+  });
+
+  test("a move that reports a name takes the new name", async () => {
+    const conversationId = await boundConversation();
+    upsertBinding({
+      conversationId,
+      sourceChannel: "slack",
+      externalChatId: "C0ELSEWHERE",
+      externalChatName: "new-home",
+    });
+    expect(getBindingByConversation(conversationId)?.externalChatName).toBe(
+      "new-home",
+    );
+  });
+});

package/src/__tests__/provider-meta-persistence.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, test } from "bun:test";
+
+import { buildProviderMetaForPersistence } from "../daemon/conversation-messaging.js";
+import type { ProviderMessageMetadata } from "../messaging/provider-message-metadata.js";
+import { readProviderMetadata } from "../messaging/read-provider-metadata.js";
+
+const telegramInbound: ProviderMessageMetadata = {
+  source: "telegram",
+  conversationExternalId: "chat-42",
+  messageId: "msg-100",
+  threadId: "topic-7",
+  actorExternalId: "user-9",
+  displayName: "Alice",
+  eventKind: "message",
+};
+
+describe("buildProviderMetaForPersistence", () => {
+  test("a matching non-Slack turn persists an envelope the neutral reader round-trips", () => {
+    const serialized = buildProviderMetaForPersistence({
+      channelInbound: telegramInbound,
+      turnChannel: "telegram",
+    });
+    expect(serialized).not.toBeNull();
+
+    // The stored row's metadata JSON carries the envelope under the
+    // `providerMeta` key; the canonical reader must resolve it.
+    const rowMetadata = JSON.stringify({
+      userMessageChannel: "telegram",
+      providerMeta: serialized,
+    });
+    const read = readProviderMetadata(rowMetadata);
+    expect(read).toEqual(telegramInbound);
+  });
+
+  test("a Slack turn never gains a providerMeta key", () => {
+    expect(
+      buildProviderMetaForPersistence({
+        channelInbound: { ...telegramInbound, source: "slack" },
+        turnChannel: "slack",
+      }),
+    ).toBeNull();
+  });
+
+  test("a turn channel that does not match the envelope's source is refused", () => {
+    expect(
+      buildProviderMetaForPersistence({
+        channelInbound: telegramInbound,
+        turnChannel: "discord",
+      }),
+    ).toBeNull();
+    expect(
+      buildProviderMetaForPersistence({
+        channelInbound: telegramInbound,
+        turnChannel: undefined,
+      }),
+    ).toBeNull();
+  });
+
+  test("an absent envelope persists nothing", () => {
+    expect(
+      buildProviderMetaForPersistence({
+        channelInbound: undefined,
+        turnChannel: "telegram",
+      }),
+    ).toBeNull();
+  });
+});

package/src/__tests__/tool-approval-seed-content-blocks.test.ts

@@ -214,7 +214,7 @@ describe("buildToolApprovalSeedContentBlocks", () => {
     );
     expect(surface.data.metadata).toContainEqual({
       label: "Source",
-      value: "Slack — Direct message",
+      value: "Slack · Direct message",
     });
   });
 
@@ -232,7 +232,20 @@ describe("buildToolApprovalSeedContentBlocks", () => {
     );
     expect(surface.data.metadata).toContainEqual({
       label: "Source",
-      value: "Slack — #C01ABC",
+      value: "Slack · #C01ABC",
+    });
+  });
+
+  test("Slack channel source prefers the captured channel name", () => {
+    const payload = {
+      ...toolApprovalPayload,
+      sourceChatId: "C01ABC",
+      sourceChatName: "user-feedback",
+    };
+    const surface = surfaceBlock(buildToolApprovalSeedContentBlocks(payload)!);
+    expect(surface.data.metadata).toContainEqual({
+      label: "Source",
+      value: "Slack · #user-feedback",
     });
   });
 
@@ -245,7 +258,7 @@ describe("buildToolApprovalSeedContentBlocks", () => {
     expect(surface.data.body).not.toContain("[View message]");
     expect(surface.data.metadata).toContainEqual({
       label: "Source",
-      value: "Slack — Direct message",
+      value: "Slack · Direct message",
     });
   });
 

package/src/daemon/conversation-messaging.ts

@@ -27,6 +27,10 @@ import {
   parseInterfaceId,
 } from "../channels/types.js";
 import { parseImageDimensions } from "../context/image-dimensions.js";
+import {
+  type ProviderMessageMetadata,
+  providerMessageMetadataSchema,
+} from "../messaging/provider-message-metadata.js";
 import {
   buildSlackTimezoneMetadata,
   type SlackMessageMetadata,
@@ -748,6 +752,37 @@ export function buildSlackMetaForPersistence(params: {
   return writeSlackMetadata(slackMeta);
 }
 
+/**
+ * Build the neutral channel envelope persisted under the `providerMeta` key
+ * on a user message's `metadata` JSON, the non-Slack counterpart of
+ * {@link buildSlackMetaForPersistence}. Returns `null` (do not include the
+ * key) when the turn channel does not match the envelope's own `source`, so
+ * a stale plumbing field can never tag a row with another channel's
+ * identity. Slack turns also return `null`: Slack still writes `slackMeta`,
+ * which `readProviderMetadata` maps onto the neutral shape on read, and a
+ * `providerMeta` key on a Slack row would shadow that richer envelope.
+ *
+ * TRANSITIONAL: the Slack exclusion exists only while Slack writes its own
+ * envelope; do not extend it.
+ */
+export function buildProviderMetaForPersistence(params: {
+  channelInbound: ProviderMessageMetadata | undefined;
+  turnChannel: string | undefined;
+}): string | null {
+  const inbound = params.channelInbound;
+  if (!inbound) {
+    return null;
+  }
+  if (params.turnChannel !== inbound.source || inbound.source === "slack") {
+    return null;
+  }
+  const parsed = providerMessageMetadataSchema.safeParse(inbound);
+  if (!parsed.success) {
+    return null;
+  }
+  return JSON.stringify(parsed.data);
+}
+
 // ── EnqueueMessageOptions ────────────────────────────────────────────
 
 /** Options for `enqueueMessage`. Only `content` is required; everything
@@ -1119,11 +1154,13 @@ export async function persistQueuedMessageBody(
     // never reported.
     const {
       slackInbound: rawSlackInbound,
+      channelInbound: rawChannelInbound,
       scripted: rawScriptedFromMetadata,
       clientOsFromRequest: _rawClientOsFromRequest,
       ...metadataWithoutSlackInbound
     } = (metadata ?? {}) as Record<string, unknown> & {
       slackInbound?: SlackInboundMessageMetadata;
+      channelInbound?: ProviderMessageMetadata;
       scripted?: unknown;
       clientOsFromRequest?: unknown;
     };
@@ -1131,6 +1168,10 @@ export async function persistQueuedMessageBody(
       slackInbound: rawSlackInbound,
       turnChannel: turnCtx?.userMessageChannel,
     });
+    const providerMeta = buildProviderMetaForPersistence({
+      channelInbound: rawChannelInbound,
+      turnChannel: turnCtx?.userMessageChannel,
+    });
 
     // See the `scripted` note on the merged metadata below. Only a real
     // boolean in the bag counts: a stray truthy string must not be read as a
@@ -1210,6 +1251,7 @@ export async function persistQueuedMessageBody(
       ...(clientOsFromRequest ? { clientOsFromRequest: true } : {}),
       ...(imageSourcePaths ? { imageSourcePaths } : {}),
       ...(slackMeta ? { slackMeta } : {}),
+      ...(providerMeta ? { providerMeta } : {}),
       // Scripted-turn marker, forwarded by `turn-events-store` onto
       // `TurnTelemetryEvent.scripted`. Written LAST so it cannot be
       // half-overwritten by the raw metadata spread above.

package/src/daemon/handlers/shared.ts

@@ -15,6 +15,7 @@ import { ConfirmationDecisionSchema } from "../../api/responses/conversation-mes
 import { getConfig } from "../../config/loader.js";
 import type { LLMCallSite, Speed } from "../../config/schemas/llm.js";
 import { ipcCall as gatewayIpcCall } from "../../ipc/gateway-client.js";
+import type { ProviderMessageMetadata } from "../../messaging/provider-message-metadata.js";
 import type { SecretPromptResult } from "../../permissions/secret-prompt-types.js";
 import type { ConversationCreateType } from "../../persistence/conversation-types.js";
 import { resolveMediaSourceData } from "../../providers/media-resolve.js";
@@ -223,6 +224,14 @@ export interface ConversationCreateOptions {
    * chronological renderer to consume.
    */
   slackInbound?: SlackInboundMessageMetadata;
+  /**
+   * Neutral per-row channel envelope captured at the channel ingress
+   * boundary, the non-Slack counterpart of `slackInbound`. When present (and
+   * the turn channel matches its `source`), persistence writes it as the
+   * message's `providerMeta` metadata key so the stored row can say which
+   * external message it is, in which thread, from whom.
+   */
+  channelInbound?: ProviderMessageMetadata;
   /**
    * Conversation type for newly created conversations. When omitted,
    * defaults to `"standard"` (visible in the sidebar). Set to

package/src/daemon/process-message.ts

@@ -38,6 +38,7 @@ import {
 import { getLogger } from "../util/logger.js";
 import type { Conversation } from "./conversation.js";
 import {
+  buildProviderMetaForPersistence,
   buildSlackMetaForPersistence,
   CONVERSATION_BUSY_MESSAGE,
   serializePersistedUserMessageContent,
@@ -148,6 +149,43 @@ export function deriveIngressIdempotencyKey(options?: {
   return undefined;
 }
 
+/**
+ * The transient carrier bag `persistUserMessage` strips back out of the
+ * metadata: the channel ingress envelopes threaded through options.
+ * Undefined when the turn carries neither, so non-channel turns persist no
+ * extra keys.
+ */
+function buildIngressCarrierMetadata(
+  options?: ProcessMessageOptions,
+): Record<string, unknown> | undefined {
+  if (!options?.slackInbound && !options?.channelInbound) {
+    return undefined;
+  }
+  return {
+    ...(options.slackInbound ? { slackInbound: options.slackInbound } : {}),
+    ...(options.channelInbound
+      ? { channelInbound: options.channelInbound }
+      : {}),
+  };
+}
+
+/**
+ * Layer the turn's persisted channel envelopes onto a metadata object:
+ * `slackMeta` for Slack turns, `providerMeta` for every other channel.
+ * At most one is non-null per turn.
+ */
+function withChannelEnvelopes(
+  base: Record<string, unknown>,
+  slackMeta: string | null,
+  providerMeta: string | null,
+): Record<string, unknown> {
+  return {
+    ...base,
+    ...(slackMeta ? { slackMeta } : {}),
+    ...(providerMeta ? { providerMeta } : {}),
+  };
+}
+
 function buildEventEmitter(
   observer?: (msg: AssistantEvent) => void,
 ): (msg: AssistantEvent) => void {
@@ -432,9 +470,14 @@ export async function processMessage(
   });
   const slashResult = await resolveSlash(content, slashContext);
 
+  const turnChannel = conversation.getTurnChannelContext()?.userMessageChannel;
   const slackMeta = buildSlackMetaForPersistence({
     slackInbound: options?.slackInbound,
-    turnChannel: conversation.getTurnChannelContext()?.userMessageChannel,
+    turnChannel,
+  });
+  const providerMeta = buildProviderMetaForPersistence({
+    channelInbound: options?.channelInbound,
+    turnChannel,
   });
 
   if (slashResult.kind === "unknown") {
@@ -469,9 +512,11 @@ export async function processMessage(
         : {}),
       ...(Object.keys(imageSourcePaths).length > 0 ? { imageSourcePaths } : {}),
     };
-    const userMetaWithSlack = slackMeta
-      ? { ...serverChannelMeta, slackMeta }
-      : serverChannelMeta;
+    const userMetaWithSlack = withChannelEnvelopes(
+      serverChannelMeta,
+      slackMeta,
+      providerMeta,
+    );
     const cleanMsg = await createUserMessage(content, attachments);
     const llmMsg = enrichMessageWithSourcePaths(cleanMsg, attachments);
     const persisted = await addMessage(
@@ -566,9 +611,11 @@ export async function processMessage(
           }
         : {}),
     };
-    const compactUserMeta = slackMeta
-      ? { ...compactChannelMeta, slackMeta }
-      : compactChannelMeta;
+    const compactUserMeta = withChannelEnvelopes(
+      compactChannelMeta,
+      slackMeta,
+      providerMeta,
+    );
     const cleanMsg = await createUserMessage(content, attachments);
     const persisted = await addMessage(
       conversationId,
@@ -624,9 +671,11 @@ export async function processMessage(
           }
         : {}),
     };
-    const cleanUserMeta = slackMeta
-      ? { ...cleanChannelMeta, slackMeta }
-      : cleanChannelMeta;
+    const cleanUserMeta = withChannelEnvelopes(
+      cleanChannelMeta,
+      slackMeta,
+      providerMeta,
+    );
     const cleanMsg = await createUserMessage(content, attachments);
     const persisted = await addMessage(
       conversationId,
@@ -660,9 +709,7 @@ export async function processMessage(
   const resolvedContent = slashResult.content;
 
   const requestId = uuidv7();
-  const persistMetadata = options?.slackInbound
-    ? { slackInbound: options.slackInbound }
-    : undefined;
+  const persistMetadata = buildIngressCarrierMetadata(options);
   const ingressKey = deriveIngressIdempotencyKey(options);
   const { id: messageId, deduplicated } = await conversation.persistUserMessage(
     {
@@ -743,9 +790,7 @@ export async function processMessageInBackground(
   const emitEvent = buildEventEmitter(options?.onEvent);
 
   const requestId = uuidv7();
-  const persistMetadata = options?.slackInbound
-    ? { slackInbound: options.slackInbound }
-    : undefined;
+  const persistMetadata = buildIngressCarrierMetadata(options);
   const ingressKey = deriveIngressIdempotencyKey(options);
   const { id: messageId, deduplicated } = await conversation.persistUserMessage(
     {