@vellumai/assistant 0.8.1 → 0.8.3

package/src/runtime/routes/inbound-conversation.ts

@@ -1,16 +1,23 @@
 /**
  * Channel conversation deletion handler.
  */
-import { deleteConversationKey } from "../../memory/conversation-key-store.js";
-import { deleteBindingByChannelChat } from "../../memory/external-conversation-store.js";
-import { DAEMON_INTERNAL_ASSISTANT_ID } from "../assistant-scope.js";
+import {
+  deleteConversationKey,
+  getOrCreateConversation,
+} from "../../memory/conversation-key-store.js";
+import { buildScopedConversationKey } from "../../memory/delivery-crud.js";
+import {
+  deleteBindingByChannelChat,
+  deleteBindingByChannelChatThread,
+} from "../../memory/external-conversation-store.js";
 import { BadRequestError } from "./errors.js";
 import type { RouteHandlerArgs } from "./types.js";
 
 export function handleDeleteConversation({ body = {} }: RouteHandlerArgs) {
-  const { sourceChannel, conversationExternalId } = body as {
+  const { sourceChannel, conversationExternalId, sourceThreadId } = body as {
     sourceChannel?: string;
     conversationExternalId?: string;
+    sourceThreadId?: string;
   };
 
   if (!sourceChannel || typeof sourceChannel !== "string") {
@@ -20,14 +27,27 @@ export function handleDeleteConversation({ body = {} }: RouteHandlerArgs) {
     throw new BadRequestError("conversationExternalId is required");
   }
 
-  const assistantId = DAEMON_INTERNAL_ASSISTANT_ID;
+  const normalizedThreadId = sourceThreadId?.trim() || undefined;
 
-  const scopedKey = `asst:${assistantId}:${sourceChannel}:${conversationExternalId}`;
+  const scopedKey = buildScopedConversationKey(
+    sourceChannel,
+    conversationExternalId,
+    normalizedThreadId,
+  );
   deleteConversationKey(scopedKey);
-  if (assistantId === DAEMON_INTERNAL_ASSISTANT_ID) {
-    const legacyKey = `${sourceChannel}:${conversationExternalId}`;
+  const legacyKey = `${sourceChannel}:${conversationExternalId}`;
+  if (!normalizedThreadId) {
     deleteConversationKey(legacyKey);
     deleteBindingByChannelChat(sourceChannel, conversationExternalId);
+  } else {
+    if (sourceChannel === "slack") {
+      getOrCreateConversation(scopedKey);
+    }
+    deleteBindingByChannelChatThread(
+      sourceChannel,
+      conversationExternalId,
+      normalizedThreadId,
+    );
   }
 
   return { ok: true };

package/src/runtime/routes/inbound-message-handler.ts

@@ -4,6 +4,10 @@
  * verification, guardian action answers, approval interception, and
  * invite token redemption.
  */
+import {
+  attachmentsToContentBlocks,
+  type MessageAttachmentInput,
+} from "../../agent/attachments.js";
 import { getChannelPermissionProfile } from "../../channels/permission-profiles.js";
 import {
   CHANNEL_IDS,
@@ -20,7 +24,12 @@ import { classifyDiskPressureTurnPolicy } from "../../daemon/disk-pressure-polic
 import { processMessage } from "../../daemon/process-message.js";
 import type { TrustContext } from "../../daemon/trust-context.js";
 import { HeartbeatService } from "../../heartbeat/heartbeat-service.js";
-import { getAttachmentsByIds } from "../../memory/attachments-store.js";
+import {
+  attachInlineAttachmentToMessage,
+  AttachmentUploadError,
+  getAttachmentsByIds,
+  validateAttachmentUpload,
+} from "../../memory/attachments-store.js";
 import {
   recordConversationSeenSignal,
   type SignalType,
@@ -30,6 +39,7 @@ import {
   getMessageById,
   getMessages,
   selectSlackMetaCandidateMetadata,
+  updateMessageContent,
   updateMessageMetadata,
 } from "../../memory/conversation-crud.js";
 import {
@@ -45,18 +55,21 @@ import {
 import { markProcessed } from "../../memory/delivery-status.js";
 import { upsertBinding } from "../../memory/external-conversation-store.js";
 import type { Message as ProviderMessage } from "../../messaging/provider-types.js";
+import { withSlackBotToken } from "../../messaging/providers/slack/adapter.js";
 import {
   backfillDm,
   backfillThreadWindowPage,
   type SlackBackfillWindowPage,
 } from "../../messaging/providers/slack/backfill.js";
+import { downloadSlackFile } from "../../messaging/providers/slack/download.js";
 import {
   mergeSlackMetadata,
-  readSlackMetadata,
+  readSlackMetadataFromMessageMetadata,
   type SlackFileMetadata,
   type SlackMessageMetadata,
   writeSlackMetadata,
 } from "../../messaging/providers/slack/message-metadata.js";
+import type { ContentBlock } from "../../providers/types.js";
 import { wrapUntrustedContent } from "../../security/untrusted-content.js";
 import { canonicalizeInboundIdentity } from "../../util/canonicalize-identity.js";
 import { getLogger } from "../../util/logger.js";
@@ -454,6 +467,12 @@ export async function handleChannelInbound({
     typeof sourceMetadata?.messageId === "string"
       ? sourceMetadata.messageId
       : undefined;
+  const slackThreadTs =
+    sourceChannel === "slack" &&
+    typeof sourceMetadata?.threadId === "string" &&
+    sourceMetadata.threadId.trim().length > 0
+      ? sourceMetadata.threadId.trim()
+      : undefined;
 
   if (isEdit && !sourceMessageId) {
     throw new BadRequestError("sourceMetadata.messageId is required for edits");
@@ -466,6 +485,7 @@ export async function handleChannelInbound({
       conversationExternalId,
       externalMessageId,
       sourceMessageId,
+      sourceThreadId: slackThreadTs,
       canonicalAssistantId,
       assistantId,
       content,
@@ -478,7 +498,11 @@ export async function handleChannelInbound({
     sourceChannel,
     conversationExternalId,
     externalMessageId,
-    { sourceMessageId, assistantId: canonicalAssistantId },
+    {
+      sourceMessageId,
+      assistantId: canonicalAssistantId,
+      sourceThreadId: slackThreadTs,
+    },
   );
 
   const replyCallbackUrl = body.replyCallbackUrl;
@@ -523,6 +547,7 @@ export async function handleChannelInbound({
       conversationId: result.conversationId,
       sourceChannel,
       externalChatId: conversationExternalId,
+      externalThreadId: slackThreadTs ?? null,
       externalUserId: canonicalSenderId ?? rawSenderId ?? null,
       displayName: body.actorDisplayName ?? null,
       username: body.actorUsername ?? null,
@@ -1018,11 +1043,6 @@ export async function handleChannelInbound({
       // this into a `slackMeta` sub-object in the row's metadata column so
       // the chronological renderer can reconstruct thread structure without
       // re-fetching from Slack.
-      const slackThreadTs =
-        sourceChannel === "slack" &&
-        typeof sourceMetadata?.threadId === "string"
-          ? sourceMetadata.threadId
-          : undefined;
       const slackInbound =
         sourceChannel === "slack"
           ? {
@@ -1034,6 +1054,9 @@ export async function handleChannelInbound({
                     displayName: body.actorDisplayName ?? body.actorUsername!,
                   }
                 : {}),
+              ...(trustCtx.requesterExternalUserId
+                ? { actorExternalUserId: trustCtx.requesterExternalUserId }
+                : {}),
             }
           : undefined;
 
@@ -1048,6 +1071,8 @@ export async function handleChannelInbound({
         sourceMetadata.account.length > 0
           ? sourceMetadata.account
           : undefined;
+      const slackBotMentioned =
+        sourceChannel === "slack" && sourceMetadata?.slackBotMentioned === true;
 
       // ── DM cold-start backfill ──
       // First time a Slack DM lands in a conversation that has fewer than
@@ -1071,6 +1096,7 @@ export async function handleChannelInbound({
           conversationId: result.conversationId,
           channelId: conversationExternalId,
           account: slackAccount,
+          guardianExternalUserId: trustCtx.guardianExternalUserId,
           latestTs: boundingTs,
         });
       }
@@ -1093,6 +1119,7 @@ export async function handleChannelInbound({
           threadTs: slackThreadTs,
           excludeChannelTs: slackInbound?.channelTs,
           account: slackAccount,
+          guardianExternalUserId: trustCtx.guardianExternalUserId,
         });
         const lateJoinNotice = buildSlackLateJoinNotice(backfillResult);
         if (lateJoinNotice) slackRuntimeContextNotice = lateJoinNotice;
@@ -1103,10 +1130,14 @@ export async function handleChannelInbound({
       const contentForProcessing =
         trustCtx.trustClass !== "guardian"
           ? wrapUntrustedContent(trimmedContent, {
-              source: "webhook",
+              source: sourceChannel === "slack" ? "slack" : "webhook",
               sourceDetail: trustCtx.requesterIdentifier,
             })
           : trimmedContent;
+      const displayContentForProcessing =
+        sourceChannel === "slack" && trustCtx.trustClass !== "guardian"
+          ? trimmedContent
+          : undefined;
 
       // Fire-and-forget: process the message and deliver the reply in the background.
       // The HTTP response returns immediately so the gateway webhook is not blocked.
@@ -1117,6 +1148,7 @@ export async function handleChannelInbound({
         conversationId: result.conversationId,
         eventId: result.eventId,
         content: contentForProcessing,
+        displayContent: displayContentForProcessing,
         attachmentIds: hasAttachments ? attachmentIds : undefined,
         sourceChannel,
         sourceInterface,
@@ -1131,6 +1163,7 @@ export async function handleChannelInbound({
         assistantId: canonicalAssistantId,
         approvalCopyGenerator,
         chatType: sourceChatType,
+        slackBotMentioned,
         slackInbound,
       });
     }
@@ -1330,25 +1363,6 @@ function countSlackMetaMessages(conversationId: string): number {
   return count;
 }
 
-function readSlackMetadataFromMessageMetadata(
-  metadata: string | null | undefined,
-): SlackMessageMetadata | null {
-  if (!metadata) return null;
-  let parent: Record<string, unknown> | null = null;
-  try {
-    const parsed = JSON.parse(metadata) as unknown;
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-      parent = parsed as Record<string, unknown>;
-    }
-  } catch {
-    return null;
-  }
-  if (!parent) return null;
-  const raw = parent.slackMeta;
-  if (typeof raw !== "string") return null;
-  return readSlackMetadata(raw);
-}
-
 /**
  * Build the set of `slackMeta.channelTs` values already stored on a
  * conversation. Used by both DM cold-start backfill and thread gap/delta
@@ -1433,11 +1447,10 @@ function readStoredSlackThreadState(
  * `slackMeta` envelope.
  *
  * Shared insertion point for any path that hydrates Slack history lazily
- * (DM cold-start backfill, thread gap/delta backfill, etc.). Role is derived
- * from `message.metadata.isBot` — bot-authored rows map to `"assistant"` so
- * our own prior replies (and any other bot traffic) are not rehydrated as
- * user turns, which would otherwise corrupt speaker attribution and make
- * the assistant treat its own outputs as new user input on later turns.
+ * (DM cold-start backfill, thread gap/delta backfill, etc.). Backfilled Slack
+ * rows are always persisted as `user` history: `assistant` rows are reserved
+ * for messages produced by the local assistant loop, not third-party channel
+ * replay.
  * Caller is responsible for dedup checks before invoking; this helper
  * performs no idempotency check itself.
  */
@@ -1445,9 +1458,21 @@ async function persistBackfilledSlackMessage(params: {
   conversationId: string;
   channelId: string;
   message: ProviderMessage;
+  account?: string;
+  guardianExternalUserId?: string;
 }): Promise<void> {
   const { message } = params;
-  const slackFiles = readSlackFilesFromProviderMetadata(message.metadata);
+  const slackFilesWithUrls = readSlackFilesWithUrlsFromProviderMetadata(
+    message.metadata,
+  );
+  // Persisted shape strips the transient URL fields; only `{ id, name,
+  // mimetype }` is allowed by `slackFileMetadataSchema`.
+  const slackFiles: SlackFileMetadata[] = slackFilesWithUrls.map((f) => ({
+    ...(f.id ? { id: f.id } : {}),
+    name: f.name,
+    ...(f.mimetype ? { mimetype: f.mimetype } : {}),
+  }));
+  const actorExternalUserId = message.sender?.id?.trim();
   const slackMeta: SlackMessageMetadata = {
     source: "slack",
     channelId: params.channelId,
@@ -1455,20 +1480,163 @@ async function persistBackfilledSlackMessage(params: {
     eventKind: "message",
     ...(message.threadId ? { threadTs: message.threadId } : {}),
     ...(message.sender?.name ? { displayName: message.sender.name } : {}),
+    ...(actorExternalUserId ? { actorExternalUserId } : {}),
     ...(slackFiles.length > 0 ? { slackFiles } : {}),
   };
-  const role = message.metadata?.isBot === true ? "assistant" : "user";
-  await addMessage(params.conversationId, role, message.text ?? "", {
+
+  const isGuardian = isBackfilledSlackGuardianMessage(
+    message,
+    params.guardianExternalUserId,
+  );
+  const role = "user";
+
+  const rawText = message.text ?? "";
+
+  const persisted = await addMessage(params.conversationId, role, rawText, {
     slackMeta: writeSlackMetadata(slackMeta),
+    provenanceTrustClass: isGuardian ? "guardian" : "unknown",
+    provenanceSourceChannel: "slack",
+    ...(params.guardianExternalUserId
+      ? { provenanceGuardianExternalUserId: params.guardianExternalUserId }
+      : {}),
+    ...(actorExternalUserId
+      ? { provenanceRequesterIdentifier: actorExternalUserId }
+      : {}),
   });
+
+  // Hydrate image attachments inline, then rewrite the saved row to include
+  // `type: "image"` content blocks. Slack context assembly reloads from
+  // `messages.content`; the attachment link alone is not part of the model
+  // transcript. Non-image files keep the marker produced by the Slack renderer.
+  const imageFiles = slackFilesWithUrls.filter(
+    (f) =>
+      (f.urlPrivateDownload || f.urlPrivate) &&
+      typeof f.mimetype === "string" &&
+      f.mimetype.startsWith("image/"),
+  );
+  if (imageFiles.length === 0) return;
+
+  const hydratedAttachments = await withSlackBotToken(
+    params.account,
+    async (token) => {
+      const attachments: MessageAttachmentInput[] = [];
+
+      for (let i = 0; i < imageFiles.length; i++) {
+        const file = imageFiles[i];
+        try {
+          const downloaded = await downloadSlackFile(file, token);
+          if (!downloaded) continue;
+          const validation = validateAttachmentUpload(
+            downloaded.filename,
+            downloaded.mimeType,
+          );
+          if (!validation.ok) {
+            log.warn(
+              {
+                filename: downloaded.filename,
+                mimeType: downloaded.mimeType,
+                error: validation.error,
+                channelTs: message.id,
+              },
+              "Skipping backfilled Slack image: validation failed",
+            );
+            continue;
+          }
+          attachInlineAttachmentToMessage(
+            persisted.id,
+            i,
+            downloaded.filename,
+            downloaded.mimeType,
+            downloaded.data,
+          );
+          attachments.push({
+            filename: downloaded.filename,
+            mimeType: downloaded.mimeType,
+            data: downloaded.data,
+          });
+        } catch (err) {
+          if (err instanceof AttachmentUploadError) {
+            log.warn(
+              {
+                filename: file.name,
+                error: err.message,
+                channelTs: message.id,
+              },
+              "Skipping backfilled Slack image: upload error",
+            );
+            continue;
+          }
+          log.warn(
+            { err, fileId: file.id, name: file.name, channelTs: message.id },
+            "Failed to hydrate backfilled Slack image; proceeding without it",
+          );
+        }
+      }
+
+      return attachments;
+    },
+  );
+  if (hydratedAttachments === null) {
+    log.debug(
+      { conversationId: params.conversationId, channelTs: message.id },
+      "No Slack token available for backfill image hydration; skipping",
+    );
+    return;
+  }
+
+  if (hydratedAttachments.length > 0) {
+    updateMessageContent(
+      persisted.id,
+      JSON.stringify(
+        buildBackfilledSlackContentBlocks(rawText, hydratedAttachments),
+      ),
+    );
+  }
+}
+
+function buildBackfilledSlackContentBlocks(
+  text: string,
+  attachments: MessageAttachmentInput[],
+): ContentBlock[] {
+  const blocks: ContentBlock[] = [];
+  if (text.trim().length > 0) {
+    blocks.push({ type: "text", text });
+  }
+  blocks.push(...attachmentsToContentBlocks(attachments));
+  return blocks;
+}
+
+function isBackfilledSlackGuardianMessage(
+  message: ProviderMessage,
+  guardianExternalUserId: string | undefined,
+): boolean {
+  const rawSenderId = message.sender?.id?.trim();
+  if (!rawSenderId || !guardianExternalUserId) return false;
+  const canonicalSender =
+    canonicalizeInboundIdentity("slack", rawSenderId) ?? rawSenderId;
+  const canonicalGuardian =
+    canonicalizeInboundIdentity("slack", guardianExternalUserId) ??
+    guardianExternalUserId.trim();
+  return canonicalSender === canonicalGuardian;
+}
+
+/**
+ * Transient view of `slackFiles` that preserves the download URLs added by
+ * `mapSlackFiles` on the in-flight `ProviderMessage`. These URLs never reach
+ * persisted storage — see `slackFileMetadataSchema`. The backfill image
+ * hydration path is the only consumer; URLs are absent from persisted rows.
+ */
+interface SlackFileWithUrls extends SlackFileMetadata {
+  urlPrivateDownload?: string;
+  urlPrivate?: string;
 }
 
-function readSlackFilesFromProviderMetadata(
+function readSlackFilesWithUrlsFromProviderMetadata(
   metadata: Record<string, unknown> | undefined,
-): SlackFileMetadata[] {
+): SlackFileWithUrls[] {
   const raw = metadata?.slackFiles;
   if (!Array.isArray(raw)) return [];
-  const files: SlackFileMetadata[] = [];
+  const files: SlackFileWithUrls[] = [];
   for (const item of raw) {
     if (item === null || typeof item !== "object" || Array.isArray(item)) {
       continue;
@@ -1484,6 +1652,13 @@ function readSlackFilesFromProviderMetadata(
       ...(typeof record.mimetype === "string" && record.mimetype.length > 0
         ? { mimetype: record.mimetype }
         : {}),
+      ...(typeof record.urlPrivateDownload === "string" &&
+      record.urlPrivateDownload.length > 0
+        ? { urlPrivateDownload: record.urlPrivateDownload }
+        : {}),
+      ...(typeof record.urlPrivate === "string" && record.urlPrivate.length > 0
+        ? { urlPrivate: record.urlPrivate }
+        : {}),
     });
   }
   return files;
@@ -1515,6 +1690,7 @@ async function tryBackfillSlackDmIfCold(params: {
   conversationId: string;
   channelId: string;
   account?: string;
+  guardianExternalUserId?: string;
   latestTs?: string;
 }): Promise<void> {
   const existing = _dmBackfillInFlight.get(params.conversationId);
@@ -1533,6 +1709,7 @@ async function runBackfillSlackDmIfCold(params: {
   conversationId: string;
   channelId: string;
   account?: string;
+  guardianExternalUserId?: string;
   latestTs?: string;
 }): Promise<void> {
   try {
@@ -1573,6 +1750,10 @@ async function runBackfillSlackDmIfCold(params: {
           conversationId: params.conversationId,
           channelId: params.channelId,
           message,
+          ...(params.account ? { account: params.account } : {}),
+          ...(params.guardianExternalUserId
+            ? { guardianExternalUserId: params.guardianExternalUserId }
+            : {}),
         });
         seen.add(message.id);
         written++;
@@ -2045,9 +2226,21 @@ export async function triggerSlackThreadBackfillIfNeeded(params: {
    * connection.
    */
   account?: string;
+  /**
+   * Canonical Slack user ID for the guardian, when a verified Slack guardian
+   * binding exists. Backfilled messages from this sender are trusted history
+   * and should not be wrapped as external content.
+   */
+  guardianExternalUserId?: string;
 }): Promise<SlackThreadBackfillResult> {
-  const { conversationId, channelId, threadTs, excludeChannelTs, account } =
-    params;
+  const {
+    conversationId,
+    channelId,
+    threadTs,
+    excludeChannelTs,
+    account,
+    guardianExternalUserId,
+  } = params;
 
   try {
     const upperBoundTs = parseSlackTimestamp(excludeChannelTs)
@@ -2132,6 +2325,8 @@ export async function triggerSlackThreadBackfillIfNeeded(params: {
           conversationId,
           channelId,
           message,
+          ...(account ? { account } : {}),
+          ...(guardianExternalUserId ? { guardianExternalUserId } : {}),
         });
         threadState.storedChannelTs.add(message.id);
         persisted++;

package/src/runtime/routes/inbound-stages/background-dispatch.test.ts

@@ -50,6 +50,7 @@ import {
   isBoundGuardianActor,
   processChannelMessageInBackground,
   shouldStartSlackThinkingStatusForText,
+  shouldStartSlackThinkingStatusImmediately,
 } from "./background-dispatch.js";
 
 describe("isBoundGuardianActor", () => {
@@ -201,6 +202,116 @@ describe("Slack thinking status timing", () => {
     ).toBe(true);
   });
 
+  test("starts Slack thinking status immediately for DMs and direct mentions", () => {
+    expect(
+      shouldStartSlackThinkingStatusImmediately({
+        sourceChannel: "slack",
+        chatType: "im",
+      }),
+    ).toBe(true);
+    expect(
+      shouldStartSlackThinkingStatusImmediately({
+        sourceChannel: "slack",
+        slackBotMentioned: true,
+      }),
+    ).toBe(true);
+    expect(
+      shouldStartSlackThinkingStatusImmediately({
+        sourceChannel: "slack",
+        chatType: "channel",
+      }),
+    ).toBe(false);
+    expect(
+      shouldStartSlackThinkingStatusImmediately({
+        sourceChannel: "telegram",
+        chatType: "im",
+        slackBotMentioned: true,
+      }),
+    ).toBe(false);
+  });
+
+  test("sets Slack thinking indicator immediately for a DM", async () => {
+    const conversationId = "conv-dm-immediate-status";
+    const channelId = "D-DM-IMMEDIATE";
+    const messageTs = "1700000000.000010";
+
+    const processMessage: MessageProcessor = async () => {
+      expect(deliveredChannelReplies).toHaveLength(1);
+      expect(deliveredChannelReplies[0]!.payload.reaction).toEqual({
+        action: "add",
+        name: "eyes",
+        messageTs,
+      });
+      return { messageId: "user-msg-dm-immediate" };
+    };
+
+    processChannelMessageInBackground({
+      processMessage,
+      conversationId,
+      eventId: "evt-dm-immediate-status",
+      content: "dm message",
+      sourceChannel: "slack",
+      sourceInterface: "slack",
+      externalChatId: channelId,
+      trustCtx,
+      metadataHints: [],
+      chatType: "im",
+      replyCallbackUrl: `https://example.test/deliver/slack?channel=${channelId}&messageTs=${messageTs}`,
+    });
+
+    await flush();
+
+    const reactions = deliveredChannelReplies.map(
+      (entry) => entry.payload.reaction,
+    );
+    expect(reactions).toEqual([
+      { action: "add", name: "eyes", messageTs },
+      { action: "remove", name: "eyes", messageTs },
+    ]);
+  });
+
+  test("sets Slack thinking status immediately for an app mention", async () => {
+    const conversationId = "conv-mention-immediate-status";
+    const channelId = "C-MENTION-IMMEDIATE";
+    const threadTs = "1700000000.000011";
+
+    const processMessage: MessageProcessor = async () => {
+      expect(deliveredChannelReplies).toHaveLength(1);
+      expect(deliveredChannelReplies[0]!.payload.assistantThreadStatus).toEqual(
+        {
+          channel: channelId,
+          threadTs,
+          status: "is thinking...",
+        },
+      );
+      return { messageId: "user-msg-mention-immediate" };
+    };
+
+    processChannelMessageInBackground({
+      processMessage,
+      conversationId,
+      eventId: "evt-mention-immediate-status",
+      content: "@assistant please respond",
+      sourceChannel: "slack",
+      sourceInterface: "slack",
+      externalChatId: channelId,
+      trustCtx,
+      metadataHints: [],
+      slackBotMentioned: true,
+      replyCallbackUrl: `https://example.test/deliver/slack?channel=${channelId}&threadTs=${threadTs}`,
+    });
+
+    await flush();
+
+    const statuses = deliveredChannelReplies.map((entry) => {
+      const status = entry.payload.assistantThreadStatus as
+        | { status?: string }
+        | undefined;
+      return status?.status;
+    });
+    expect(statuses).toEqual(["is thinking...", ""]);
+  });
+
   test("does not set Slack thinking status for no_response text deltas", async () => {
     const conversationId = "conv-no-response-status";
     const channelId = "C-NO-RESPONSE";