@vellumai/assistant 0.6.3 → 0.6.5

package/src/messaging/providers/slack/adapter.ts

@@ -25,6 +25,7 @@ import type {
   SendResult,
 } from "../../provider-types.js";
 import * as slack from "./client.js";
+import { SlackApiError } from "./client.js";
 import type {
   SlackConversation,
   SlackMessage,
@@ -35,27 +36,96 @@ import type {
 const userNameCache = new Map<string, string>();
 
 /**
- * Cached auth resolved during resolveConnection().
+ * Cached auth resolved during resolveConnection(), split by direction.
  *
- * For Socket Mode this holds a raw bot token string; for OAuth it holds the
+ * Read and write auth are tracked separately so reads can use a user OAuth
+ * token (xoxp-) — giving visibility into channels the user is in but the
+ * bot isn't — while writes continue to use the bot token (xoxb-) so posts
+ * come from the bot identity. When no user_token is stored, reads fall
+ * back to the bot token. If a stored user_token is rejected at runtime
+ * (revoked/expired), the read cache is reset to the bot token for the rest
+ * of the session — see runReadWithFallback().
+ *
+ * For Socket Mode these hold a raw bot token string; for OAuth they hold the
  * OAuthConnection. The Slack client functions accept both via their own
- * OAuthConnection | string union, so we can pass this value through directly.
+ * OAuthConnection | string union, so we can pass the cached value through
+ * directly.
  */
-let _cachedSlackAuth: OAuthConnection | string | null = null;
+let _cachedSlackWriteAuth: OAuthConnection | string | null = null;
+let _cachedSlackReadAuth: OAuthConnection | string | null = null;
 
 /**
  * Get the Slack auth value to pass to Slack client functions.
  * Prefers the explicit connection from the caller; falls back to the cached
- * value set during resolveConnection().
+ * write auth. Callers that care about read vs write semantics should use
+ * getReadAuth() / getWriteAuth() directly.
  */
 function getSlackAuth(connection?: OAuthConnection): OAuthConnection | string {
   if (connection) return connection;
-  if (_cachedSlackAuth) return _cachedSlackAuth;
+  if (_cachedSlackWriteAuth) return _cachedSlackWriteAuth;
+  if (_cachedSlackReadAuth) return _cachedSlackReadAuth;
   throw new Error(
     "Slack: no connection or cached token available. Was resolveConnection() called?",
   );
 }
 
+/**
+ * Resolve auth for read operations (listConversations, getHistory,
+ * conversation replies, search, users.info lookups).
+ */
+function getReadAuth(connection?: OAuthConnection): OAuthConnection | string {
+  if (connection) return connection;
+  if (_cachedSlackReadAuth) return _cachedSlackReadAuth;
+  return getSlackAuth(connection);
+}
+
+// SAFETY: content-creating writes (postMessage, updateMessage, deleteMessage,
+// reactions) MUST use the bot token. Using the user token would post as the
+// user, not as the bot. State-changing methods that target the authenticated
+// identity's own state (e.g. conversations.mark) should use the read auth so
+// the cursor matches the perspective the adapter exposes.
+/**
+ * Resolve auth for content-creating write operations (postMessage and any
+ * future reactions, joins, leaves, updates, or deletes).
+ */
+function getWriteAuth(connection?: OAuthConnection): OAuthConnection | string {
+  if (connection) return connection;
+  if (_cachedSlackWriteAuth) return _cachedSlackWriteAuth;
+  return getSlackAuth(connection);
+}
+
+/**
+ * Run a read-path Slack call, falling back to the bot token if the cached
+ * user token is rejected with an auth error. On fallback, the read cache is
+ * reset to the bot token so subsequent reads in this session don't re-pay
+ * the round trip. Caller-supplied connections are passed through unchanged
+ * (no fallback) since the caller owns that auth.
+ */
+async function runReadWithFallback<T>(
+  connection: OAuthConnection | undefined,
+  call: (auth: OAuthConnection | string) => Promise<T>,
+): Promise<T> {
+  if (connection) return call(connection);
+  const auth = getReadAuth(undefined);
+  const usingUserToken =
+    _cachedSlackWriteAuth !== null &&
+    _cachedSlackReadAuth !== _cachedSlackWriteAuth;
+  try {
+    return await call(auth);
+  } catch (err) {
+    if (
+      usingUserToken &&
+      err instanceof SlackApiError &&
+      err.status === 401 &&
+      _cachedSlackWriteAuth
+    ) {
+      _cachedSlackReadAuth = _cachedSlackWriteAuth;
+      return call(_cachedSlackWriteAuth);
+    }
+    throw err;
+  }
+}
+
 async function resolveUserName(
   auth: OAuthConnection | string,
   userId: string,
@@ -134,6 +204,11 @@ function mapMessage(
   channelId: string,
   senderName: string,
 ): Message {
+  // Bot-authored when Slack sets `subtype: "bot_message"` or attributes the
+  // row to a `bot_id` with no user. Backfill callers rely on this flag to
+  // avoid rehydrating assistant/bot replies as user turns.
+  const isBot =
+    msg.subtype === "bot_message" || (msg.bot_id != null && !msg.user);
   return {
     id: msg.ts,
     conversationId: channelId,
@@ -145,6 +220,7 @@ function mapMessage(
     platform: "slack",
     reactions: msg.reactions?.map((r) => ({ name: r.name, count: r.count })),
     hasAttachments: (msg.files?.length ?? 0) > 0,
+    ...(isBot ? { metadata: { isBot: true } } : {}),
   };
 }
 
@@ -165,7 +241,12 @@ export const slackProvider: MessagingProvider = {
   id: "slack",
   displayName: "Slack",
   credentialService: "slack",
-  capabilities: new Set(["reactions", "threads", "leave_channel"]),
+  capabilities: new Set([
+    "reactions",
+    "threads",
+    "join_channel",
+    "leave_channel",
+  ]),
 
   async isConnected(): Promise<boolean> {
     // Socket Mode: check for bot token directly in credential store.
@@ -184,16 +265,26 @@ export const slackProvider: MessagingProvider = {
   ): Promise<OAuthConnection | undefined> {
     // Socket Mode: cache the raw bot token for use in adapter methods.
     // Token presence is sufficient — no connection row required.
+    //
+    // When a user_token is also stored, prefer it for reads so the adapter
+    // can see channels the user is in but the bot isn't (conversations.list,
+    // conversations.history, search.messages). Writes always stay on the
+    // bot token — see SAFETY note above getWriteAuth().
     const botToken = await getSecureKeyAsync(
       credentialKey("slack_channel", "bot_token"),
     );
+    const userToken = await getSecureKeyAsync(
+      credentialKey("slack_channel", "user_token"),
+    );
     if (botToken) {
-      _cachedSlackAuth = botToken;
+      _cachedSlackWriteAuth = botToken;
+      _cachedSlackReadAuth = userToken ?? botToken;
       return undefined;
     }
     // Preserve existing OAuth path for backwards compat.
     const conn = await resolveOAuthConnection("slack", { account });
-    _cachedSlackAuth = conn;
+    _cachedSlackWriteAuth = conn;
+    _cachedSlackReadAuth = conn;
     return conn;
   },
 
@@ -212,7 +303,6 @@ export const slackProvider: MessagingProvider = {
     connection: OAuthConnection | undefined,
     options?: ListOptions,
   ): Promise<Conversation[]> {
-    const auth = getSlackAuth(connection);
     const typeMap: Record<string, string> = {
       channel: "public_channel,private_channel",
       dm: "im",
@@ -228,16 +318,32 @@ export const slackProvider: MessagingProvider = {
 
     const conversations: Conversation[] = [];
     let cursor: string | undefined = options?.cursor;
+    let auth = getReadAuth(connection);
 
-    // Paginate through all results
+    // Paginate through all results. The first page is wrapped in
+    // runReadWithFallback so that a 401 on the user token retries with the
+    // bot token before we commit to the rest of the pagination.
+    let firstPage = true;
     do {
-      const resp = await slack.listConversations(
-        auth,
-        types,
-        options?.excludeArchived ?? true,
-        options?.limit ?? 200,
-        cursor,
-      );
+      const resp = firstPage
+        ? await runReadWithFallback(connection, async (a) => {
+            auth = a;
+            return slack.listConversations(
+              a,
+              types,
+              options?.excludeArchived ?? true,
+              options?.limit ?? 200,
+              cursor,
+            );
+          })
+        : await slack.listConversations(
+            auth,
+            types,
+            options?.excludeArchived ?? true,
+            options?.limit ?? 200,
+            cursor,
+          );
+      firstPage = false;
       conversations.push(...resp.channels.map(mapConversation));
       cursor = resp.response_metadata?.next_cursor || undefined;
     } while (
@@ -280,14 +386,17 @@ export const slackProvider: MessagingProvider = {
     conversationId: string,
     options?: HistoryOptions,
   ): Promise<Message[]> {
-    const auth = getSlackAuth(connection);
-    const resp = await slack.conversationHistory(
-      auth,
-      conversationId,
-      options?.limit ?? 50,
-      options?.before,
-      options?.after,
-    );
+    let auth: OAuthConnection | string = getReadAuth(connection);
+    const resp = await runReadWithFallback(connection, async (a) => {
+      auth = a;
+      return slack.conversationHistory(
+        a,
+        conversationId,
+        options?.limit ?? 50,
+        options?.before,
+        options?.after,
+      );
+    });
 
     const messages: Message[] = [];
     for (const msg of resp.messages) {
@@ -303,8 +412,9 @@ export const slackProvider: MessagingProvider = {
     query: string,
     options?: SearchOptions,
   ): Promise<SearchResult> {
-    const auth = getSlackAuth(connection);
-    const resp = await slack.searchMessages(auth, query, options?.count ?? 20);
+    const resp = await runReadWithFallback(connection, (auth) =>
+      slack.searchMessages(auth, query, options?.count ?? 20),
+    );
     return {
       total: resp.messages.total,
       messages: resp.messages.matches.map(mapSearchMatch),
@@ -318,7 +428,7 @@ export const slackProvider: MessagingProvider = {
     text: string,
     options?: SendOptions,
   ): Promise<SendResult> {
-    const auth = getSlackAuth(connection);
+    const auth = getWriteAuth(connection);
     const resp = await slack.postMessage(
       auth,
       conversationId,
@@ -338,13 +448,16 @@ export const slackProvider: MessagingProvider = {
     threadId: string,
     options?: HistoryOptions,
   ): Promise<Message[]> {
-    const auth = getSlackAuth(connection);
-    const resp = await slack.conversationReplies(
-      auth,
-      conversationId,
-      threadId,
-      options?.limit ?? 50,
-    );
+    let auth: OAuthConnection | string = getReadAuth(connection);
+    const resp = await runReadWithFallback(connection, async (a) => {
+      auth = a;
+      return slack.conversationReplies(
+        a,
+        conversationId,
+        threadId,
+        options?.limit ?? 50,
+      );
+    });
     const messages: Message[] = [];
     for (const msg of resp.messages) {
       const name = await resolveUserName(auth, msg.user ?? "");
@@ -358,9 +471,13 @@ export const slackProvider: MessagingProvider = {
     conversationId: string,
     messageId?: string,
   ): Promise<void> {
-    const auth = getSlackAuth(connection);
+    // conversations.mark sets the read cursor for the authenticated identity.
+    // It must use the same token as the read path so the cursor matches the
+    // perspective the adapter exposes (unread counts in listConversations).
     // Slack's conversations.mark requires a timestamp — use the provided one or "now"
     const ts = messageId ?? String(Date.now() / 1000);
-    await slack.conversationMark(auth, conversationId, ts);
+    await runReadWithFallback(connection, (auth) =>
+      slack.conversationMark(auth, conversationId, ts),
+    );
   },
 };

package/src/messaging/providers/slack/backfill.test.ts

@@ -0,0 +1,257 @@
+/**
+ * Tests for the daemon-side Slack backfill helpers.
+ *
+ * Verifies:
+ *  - Pass-through of channelId, threadTs, and the `before` cursor.
+ *  - Default limit of 50 when none is supplied; explicit limits override.
+ *  - resolveConnection() is invoked once per call so any cached read/write
+ *    auth mutation lands before the adapter method runs.
+ *  - Transient failure modes (timeout, 401, generic Slack API error, missing
+ *    connection) return [] instead of propagating the error.
+ *  - `channel_not_found` errors are rethrown so wrong-workspace configuration
+ *    bugs in multi-account setups surface loudly rather than silently
+ *    dropping context.
+ *  - `account` is threaded through to resolveConnection() when provided.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { OAuthConnection } from "../../../oauth/connection.js";
+import type { Message } from "../../provider-types.js";
+
+// ── Module mocks ────────────────────────────────────────────────────────────
+
+type ResolveConnectionFn = (
+  account?: string,
+) => Promise<OAuthConnection | undefined>;
+type GetHistoryFn = (
+  connection: OAuthConnection | undefined,
+  conversationId: string,
+  options?: { limit?: number; before?: string; after?: string },
+) => Promise<Message[]>;
+type GetThreadRepliesFn = (
+  connection: OAuthConnection | undefined,
+  conversationId: string,
+  threadId: string,
+  options?: { limit?: number },
+) => Promise<Message[]>;
+
+const resolveConnectionMock = mock<ResolveConnectionFn>(async () => undefined);
+const getHistoryMock = mock<GetHistoryFn>(async () => []);
+const getThreadRepliesMock = mock<GetThreadRepliesFn>(async () => []);
+
+mock.module("./adapter.js", () => ({
+  slackProvider: {
+    id: "slack",
+    displayName: "Slack",
+    credentialService: "slack",
+    capabilities: new Set(["threads"]),
+    resolveConnection: (account?: string) => resolveConnectionMock(account),
+    getHistory: (
+      connection: OAuthConnection | undefined,
+      conversationId: string,
+      options?: { limit?: number; before?: string; after?: string },
+    ) => getHistoryMock(connection, conversationId, options),
+    getThreadReplies: (
+      connection: OAuthConnection | undefined,
+      conversationId: string,
+      threadId: string,
+      options?: { limit?: number },
+    ) => getThreadRepliesMock(connection, conversationId, threadId, options),
+    // Stub the rest of the MessagingProvider surface as no-ops; the backfill
+    // helpers should never reach for these.
+    testConnection: async () => {
+      throw new Error("not used");
+    },
+    listConversations: async () => [],
+    search: async () => ({ total: 0, messages: [], hasMore: false }),
+    sendMessage: async () => {
+      throw new Error("not used");
+    },
+  },
+}));
+
+import { backfillDm, backfillThread } from "./backfill.js";
+
+function makeMessage(overrides: Partial<Message> = {}): Message {
+  return {
+    id: "1700000000.000100",
+    conversationId: "C123",
+    sender: { id: "U1", name: "Alice" },
+    text: "hello",
+    timestamp: 1700000000000,
+    platform: "slack",
+    ...overrides,
+  };
+}
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe("backfillThread", () => {
+  beforeEach(() => {
+    resolveConnectionMock.mockReset();
+    resolveConnectionMock.mockImplementation(async () => undefined);
+    getThreadRepliesMock.mockReset();
+    getThreadRepliesMock.mockImplementation(async () => []);
+    getHistoryMock.mockReset();
+    getHistoryMock.mockImplementation(async () => []);
+  });
+
+  test("passes channelId/threadTs through and defaults limit to 50", async () => {
+    const reply = makeMessage({
+      id: "1700000000.000200",
+      threadId: "1700000000.000100",
+    });
+    getThreadRepliesMock.mockImplementation(async () => [reply]);
+
+    const out = await backfillThread("C123", "1700000000.000100");
+
+    expect(resolveConnectionMock).toHaveBeenCalledTimes(1);
+    expect(getThreadRepliesMock).toHaveBeenCalledTimes(1);
+    const [conn, channel, thread, opts] = getThreadRepliesMock.mock.calls[0];
+    expect(conn).toBeUndefined();
+    expect(channel).toBe("C123");
+    expect(thread).toBe("1700000000.000100");
+    expect(opts).toEqual({ limit: 50 });
+    expect(out).toEqual([reply]);
+  });
+
+  test("respects explicit limit override", async () => {
+    await backfillThread("C123", "1700000000.000100", { limit: 10 });
+    const [, , , opts] = getThreadRepliesMock.mock.calls[0];
+    expect(opts).toEqual({ limit: 10 });
+  });
+
+  test("returns [] when getThreadReplies throws (generic Slack API error)", async () => {
+    getThreadRepliesMock.mockImplementation(async () => {
+      throw new Error("Slack API error: ratelimited");
+    });
+    const out = await backfillThread("C123", "1700000000.000100");
+    expect(out).toEqual([]);
+  });
+
+  test("rethrows channel_not_found so wrong-workspace config surfaces", async () => {
+    getThreadRepliesMock.mockImplementation(async () => {
+      throw new Error("Slack API error: channel_not_found");
+    });
+    await expect(backfillThread("C123", "1700000000.000100")).rejects.toThrow(
+      /channel_not_found/,
+    );
+  });
+
+  test("threads `account` through to resolveConnection", async () => {
+    await backfillThread("C123", "1700000000.000100", {
+      account: "team-acme",
+    });
+    expect(resolveConnectionMock).toHaveBeenCalledTimes(1);
+    expect(resolveConnectionMock.mock.calls[0][0]).toBe("team-acme");
+  });
+
+  test("returns [] when getThreadReplies throws (auth error)", async () => {
+    getThreadRepliesMock.mockImplementation(async () => {
+      const err = new Error("Slack API HTTP 401");
+      Object.assign(err, { status: 401 });
+      throw err;
+    });
+    const out = await backfillThread("C123", "1700000000.000100");
+    expect(out).toEqual([]);
+  });
+
+  test("returns [] when getThreadReplies throws (timeout)", async () => {
+    getThreadRepliesMock.mockImplementation(async () => {
+      throw new Error("ETIMEDOUT");
+    });
+    const out = await backfillThread("C123", "1700000000.000100");
+    expect(out).toEqual([]);
+  });
+
+  test("returns [] when resolveConnection throws (missing connection)", async () => {
+    resolveConnectionMock.mockImplementation(async () => {
+      throw new Error("no connection available");
+    });
+    const out = await backfillThread("C123", "1700000000.000100");
+    expect(out).toEqual([]);
+    // resolveConnection failed before getThreadReplies could be reached.
+    expect(getThreadRepliesMock).not.toHaveBeenCalled();
+  });
+});
+
+describe("backfillDm", () => {
+  beforeEach(() => {
+    resolveConnectionMock.mockReset();
+    resolveConnectionMock.mockImplementation(async () => undefined);
+    getHistoryMock.mockReset();
+    getHistoryMock.mockImplementation(async () => []);
+    getThreadRepliesMock.mockReset();
+    getThreadRepliesMock.mockImplementation(async () => []);
+  });
+
+  test("passes channelId through and defaults limit to 50, before undefined", async () => {
+    const msg = makeMessage();
+    getHistoryMock.mockImplementation(async () => [msg]);
+
+    const out = await backfillDm("D123");
+
+    expect(resolveConnectionMock).toHaveBeenCalledTimes(1);
+    expect(getHistoryMock).toHaveBeenCalledTimes(1);
+    const [conn, channel, opts] = getHistoryMock.mock.calls[0];
+    expect(conn).toBeUndefined();
+    expect(channel).toBe("D123");
+    expect(opts).toEqual({ limit: 50, before: undefined });
+    expect(out).toEqual([msg]);
+  });
+
+  test("respects explicit limit override and forwards `before` cursor", async () => {
+    await backfillDm("D123", { limit: 25, before: "1700000000.000099" });
+    const [, , opts] = getHistoryMock.mock.calls[0];
+    expect(opts).toEqual({ limit: 25, before: "1700000000.000099" });
+  });
+
+  test("returns [] when getHistory throws (generic Slack API error)", async () => {
+    getHistoryMock.mockImplementation(async () => {
+      throw new Error("Slack API error: not_in_channel");
+    });
+    const out = await backfillDm("D123");
+    expect(out).toEqual([]);
+  });
+
+  test("rethrows channel_not_found so wrong-workspace config surfaces", async () => {
+    getHistoryMock.mockImplementation(async () => {
+      throw new Error("Slack API error: channel_not_found");
+    });
+    await expect(backfillDm("D123")).rejects.toThrow(/channel_not_found/);
+  });
+
+  test("threads `account` through to resolveConnection", async () => {
+    await backfillDm("D123", { account: "team-acme" });
+    expect(resolveConnectionMock).toHaveBeenCalledTimes(1);
+    expect(resolveConnectionMock.mock.calls[0][0]).toBe("team-acme");
+  });
+
+  test("returns [] when getHistory throws (auth error)", async () => {
+    getHistoryMock.mockImplementation(async () => {
+      const err = new Error("Slack API HTTP 401");
+      Object.assign(err, { status: 401 });
+      throw err;
+    });
+    const out = await backfillDm("D123");
+    expect(out).toEqual([]);
+  });
+
+  test("returns [] when getHistory throws (timeout)", async () => {
+    getHistoryMock.mockImplementation(async () => {
+      throw new Error("ETIMEDOUT");
+    });
+    const out = await backfillDm("D123");
+    expect(out).toEqual([]);
+  });
+
+  test("returns [] when resolveConnection throws (missing connection)", async () => {
+    resolveConnectionMock.mockImplementation(async () => {
+      throw new Error("no connection available");
+    });
+    const out = await backfillDm("D123");
+    expect(out).toEqual([]);
+    expect(getHistoryMock).not.toHaveBeenCalled();
+  });
+});

package/src/messaging/providers/slack/backfill.ts

@@ -0,0 +1,101 @@
+/**
+ * Daemon-side Slack backfill helpers.
+ *
+ * These wrap the existing slackProvider adapter methods so callers (thread
+ * recovery, DM context hydration) can fetch a small window of recent messages
+ * without re-implementing connection resolution or token routing.
+ *
+ * Best-effort semantics: transient or auth failures (timeout, 401, missing
+ * connection, generic Slack API errors) are logged at WARN and yield an empty
+ * array. Callers proceed without backfill rather than propagating the error.
+ *
+ * Exception: `channel_not_found` is rethrown. In multi-account Slack setups it
+ * typically signals that the resolved connection points at the wrong
+ * workspace, and silently returning [] would mask that misconfiguration. Pass
+ * the conversation's own account via `opts.account` so resolveConnection()
+ * picks the right workspace.
+ */
+import { getLogger } from "../../../util/logger.js";
+import type { Message } from "../../provider-types.js";
+import { slackProvider } from "./adapter.js";
+
+const log = getLogger("slack-backfill");
+
+const DEFAULT_LIMIT = 50;
+
+function isChannelNotFound(err: unknown): boolean {
+  const msg = err instanceof Error ? err.message : String(err);
+  return /channel_not_found/i.test(msg);
+}
+
+/**
+ * Fetch the most recent messages in a Slack thread.
+ *
+ * Resolves the cached Slack connection, then delegates to
+ * `slackProvider.getThreadReplies()`. Returns the messages mapped to the
+ * platform-agnostic `Message` shape (with `threadId` already populated from
+ * `thread_ts`). Returns `[]` on transient errors; rethrows `channel_not_found`.
+ */
+export async function backfillThread(
+  channelId: string,
+  threadTs: string,
+  opts?: { limit?: number; account?: string },
+): Promise<Message[]> {
+  const limit = opts?.limit ?? DEFAULT_LIMIT;
+  try {
+    const connection = await slackProvider.resolveConnection?.(opts?.account);
+    if (!slackProvider.getThreadReplies) {
+      log.warn(
+        { channelId, threadTs },
+        "Slack provider does not implement getThreadReplies — returning []",
+      );
+      return [];
+    }
+    return await slackProvider.getThreadReplies(
+      connection,
+      channelId,
+      threadTs,
+      { limit },
+    );
+  } catch (err) {
+    if (isChannelNotFound(err)) {
+      throw err;
+    }
+    log.warn(
+      { channelId, threadTs, account: opts?.account, err },
+      "Slack thread backfill failed — returning []",
+    );
+    return [];
+  }
+}
+
+/**
+ * Fetch the most recent messages in a Slack DM (or any conversation).
+ *
+ * Resolves the cached Slack connection, then delegates to
+ * `slackProvider.getHistory()`. The `before` option, when provided, is passed
+ * through as Slack's `latest` cursor so callers can paginate backwards.
+ * Returns `[]` on transient errors; rethrows `channel_not_found`.
+ */
+export async function backfillDm(
+  channelId: string,
+  opts?: { limit?: number; before?: string; account?: string },
+): Promise<Message[]> {
+  const limit = opts?.limit ?? DEFAULT_LIMIT;
+  try {
+    const connection = await slackProvider.resolveConnection?.(opts?.account);
+    return await slackProvider.getHistory(connection, channelId, {
+      limit,
+      before: opts?.before,
+    });
+  } catch (err) {
+    if (isChannelNotFound(err)) {
+      throw err;
+    }
+    log.warn(
+      { channelId, before: opts?.before, account: opts?.account, err },
+      "Slack DM backfill failed — returning []",
+    );
+    return [];
+  }
+}