@vellumai/assistant 0.7.0 → 0.7.1

package/src/messaging/providers/slack/__tests__/adapter-mention-rendering.test.ts

@@ -0,0 +1,226 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { OAuthConnection } from "../../../../oauth/connection.js";
+import { credentialKey } from "../../../../security/credential-key.js";
+
+const BOT_TOKEN = "xoxb-BOT";
+
+const getSecureKeyAsyncMock = mock(
+  async (_key: string): Promise<string | null> => null,
+);
+mock.module("../../../../security/secure-keys.js", () => ({
+  getSecureKeyAsync: getSecureKeyAsyncMock,
+}));
+
+mock.module("../../../../oauth/connection-resolver.js", () => ({
+  resolveOAuthConnection: async (): Promise<OAuthConnection> => {
+    throw new Error("OAuth fallback was not expected");
+  },
+}));
+mock.module("../../../../oauth/oauth-store.js", () => ({
+  isProviderConnected: async () => false,
+}));
+
+const findContactChannelMock = mock(() => undefined);
+const upsertContactChannelMock = mock(() => {});
+mock.module("../../../../contacts/contact-store.js", () => ({
+  findContactChannel: findContactChannelMock,
+}));
+mock.module("../../../../contacts/contacts-write.js", () => ({
+  upsertContactChannel: upsertContactChannelMock,
+}));
+
+import { slackProvider } from "../adapter.js";
+
+const originalFetch = globalThis.fetch;
+
+function installFetchStub() {
+  globalThis.fetch = (async (
+    input: RequestInfo | URL,
+    init?: RequestInit,
+  ): Promise<Response> => {
+    const url =
+      typeof input === "string"
+        ? input
+        : input instanceof URL
+          ? input.toString()
+          : input.url;
+    const headers = new Headers(init?.headers ?? {});
+    expect(headers.get("authorization")).toBe(`Bearer ${BOT_TOKEN}`);
+
+    return new Response(JSON.stringify(fakeSlackResponse(url)), {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    });
+  }) as typeof fetch;
+}
+
+function fakeSlackResponse(url: string): Record<string, unknown> {
+  const parsed = new URL(url);
+  const method = parsed.pathname.split("/").at(-1);
+
+  if (method === "conversations.history") {
+    return {
+      ok: true,
+      has_more: false,
+      messages: [
+        {
+          type: "message",
+          ts: "1700000000.000100",
+          user: "USENDER",
+          text: "History for <@ULEO> and <@UMISSING>",
+          thread_ts: "1700000000.000100",
+          reply_count: 2,
+          reactions: [{ name: "eyes", count: 1, users: ["ULEO"] }],
+        },
+      ],
+    };
+  }
+
+  if (method === "conversations.replies") {
+    return {
+      ok: true,
+      has_more: false,
+      messages: [
+        {
+          type: "message",
+          ts: "1700000001.000200",
+          user: "UTHREAD",
+          text: "Thread follow-up for <@ULEO>",
+          thread_ts: "1700000000.000100",
+        },
+      ],
+    };
+  }
+
+  if (method === "search.messages") {
+    return {
+      ok: true,
+      messages: {
+        total: 1,
+        matches: [
+          {
+            iid: "search-1",
+            ts: "1700000002.000300",
+            text: "Search result for <@ULEO> and <@UMISSING>",
+            user: "USENDER",
+            username: "sender",
+            channel: { id: "C_HISTORY", name: "history" },
+            permalink:
+              "https://example.slack.com/archives/C_HISTORY/p1700000002000300",
+            thread_ts: "1700000000.000100",
+          },
+        ],
+        paging: { count: 20, total: 1, page: 1, pages: 1 },
+      },
+    };
+  }
+
+  if (method === "users.info") {
+    return fakeUserInfoResponse(parsed.searchParams.get("user") ?? "");
+  }
+
+  return { ok: true };
+}
+
+function fakeUserInfoResponse(userId: string): Record<string, unknown> {
+  if (userId === "ULEO") {
+    return {
+      ok: true,
+      user: {
+        id: "ULEO",
+        name: "leo",
+        profile: { display_name: "Leo" },
+      },
+    };
+  }
+
+  if (userId === "USENDER") {
+    return {
+      ok: true,
+      user: {
+        id: "USENDER",
+        name: "sender",
+        profile: { display_name: "Sender" },
+      },
+    };
+  }
+
+  if (userId === "UTHREAD") {
+    return {
+      ok: true,
+      user: {
+        id: "UTHREAD",
+        name: "thread_sender",
+        profile: { display_name: "Thread Sender" },
+      },
+    };
+  }
+
+  return { ok: false, error: "user_not_found" };
+}
+
+describe("Slack adapter mention rendering", () => {
+  beforeEach(async () => {
+    getSecureKeyAsyncMock.mockReset();
+    getSecureKeyAsyncMock.mockImplementation(async (key: string) => {
+      if (key === credentialKey("slack_channel", "bot_token")) {
+        return BOT_TOKEN;
+      }
+      return null;
+    });
+    findContactChannelMock.mockClear();
+    upsertContactChannelMock.mockClear();
+    installFetchStub();
+    await slackProvider.resolveConnection!();
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  test("getHistory renders Slack user mentions for model-facing text without changing sender identity", async () => {
+    const messages = await slackProvider.getHistory(undefined, "C_HISTORY");
+
+    expect(messages).toHaveLength(1);
+    expect(messages[0].text).toBe("History for @Leo and @unknown-user");
+    expect(messages[0].sender).toEqual({ id: "USENDER", name: "Sender" });
+    expect(messages[0].threadId).toBe("1700000000.000100");
+    expect(messages[0].replyCount).toBe(2);
+    expect(messages[0].reactions).toEqual([{ name: "eyes", count: 1 }]);
+  });
+
+  test("getThreadReplies renders Slack user mentions for model-facing text without changing sender identity", async () => {
+    const messages = await slackProvider.getThreadReplies!(
+      undefined,
+      "C_HISTORY",
+      "1700000000.000100",
+    );
+
+    expect(messages).toHaveLength(1);
+    expect(messages[0].text).toBe("Thread follow-up for @Leo");
+    expect(messages[0].sender).toEqual({
+      id: "UTHREAD",
+      name: "Thread Sender",
+    });
+    expect(messages[0].threadId).toBe("1700000000.000100");
+  });
+
+  test("search renders Slack user mentions for model-facing text", async () => {
+    const result = await slackProvider.search!(undefined, "from:sender");
+
+    expect(result.messages).toHaveLength(1);
+    expect(result.messages[0].text).toBe(
+      "Search result for @Leo and @unknown-user",
+    );
+    expect(result.messages[0].sender).toEqual({
+      id: "USENDER",
+      name: "sender",
+    });
+    expect(result.messages[0].metadata).toEqual({
+      permalink:
+        "https://example.slack.com/archives/C_HISTORY/p1700000002000300",
+      channelName: "history",
+    });
+  });
+});

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

@@ -5,6 +5,11 @@
  * implements the MessagingProvider interface.
  */
 
+import {
+  buildSlackUserLabelMap,
+  renderSlackTextForModel,
+} from "@vellumai/slack-text";
+
 import { findContactChannel } from "../../../contacts/contact-store.js";
 import { upsertContactChannel } from "../../../contacts/contacts-write.js";
 import type { OAuthConnection } from "../../../oauth/connection.js";
@@ -17,6 +22,7 @@ import type {
   ConnectionInfo,
   Conversation,
   HistoryOptions,
+  HistoryPageResult,
   ListOptions,
   Message,
   SearchOptions,
@@ -199,37 +205,63 @@ function mapConversation(conv: SlackConversation): Conversation {
   };
 }
 
+function mapSlackFiles(
+  files: SlackMessage["files"],
+): Array<{ id?: string; name: string; mimetype?: string }> | undefined {
+  if (!files || files.length === 0) return undefined;
+  const mapped = files
+    .map((file) => ({
+      ...(file.id ? { id: file.id } : {}),
+      name: file.name,
+      ...(file.mimetype ? { mimetype: file.mimetype } : {}),
+    }))
+    .filter((file) => file.name.length > 0);
+  return mapped.length > 0 ? mapped : undefined;
+}
+
 function mapMessage(
   msg: SlackMessage,
   channelId: string,
   senderName: string,
+  renderedText: 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);
+  const slackFiles = mapSlackFiles(msg.files);
   return {
     id: msg.ts,
     conversationId: channelId,
     sender: { id: msg.user ?? msg.bot_id ?? "unknown", name: senderName },
-    text: msg.text,
+    text: renderedText,
     timestamp: parseFloat(msg.ts) * 1000,
     threadId: msg.thread_ts,
     replyCount: msg.reply_count,
     platform: "slack",
     reactions: msg.reactions?.map((r) => ({ name: r.name, count: r.count })),
     hasAttachments: (msg.files?.length ?? 0) > 0,
-    ...(isBot ? { metadata: { isBot: true } } : {}),
+    ...(isBot || slackFiles
+      ? {
+          metadata: {
+            ...(isBot ? { isBot: true } : {}),
+            ...(slackFiles ? { slackFiles } : {}),
+          },
+        }
+      : {}),
   };
 }
 
-function mapSearchMatch(match: SlackSearchMatch): Message {
+function mapSearchMatch(
+  match: SlackSearchMatch,
+  userLabels: Record<string, string>,
+): Message {
   return {
     id: match.ts,
     conversationId: match.channel.id,
     sender: { id: match.user ?? "unknown", name: match.username ?? "unknown" },
-    text: match.text,
+    text: renderSlackTextForModel(match.text, { userLabels }),
     timestamp: parseFloat(match.ts) * 1000,
     threadId: match.thread_ts,
     platform: "slack",
@@ -237,6 +269,50 @@ function mapSearchMatch(match: SlackSearchMatch): Message {
   };
 }
 
+async function mapSlackMessages(
+  auth: OAuthConnection | string,
+  channelId: string,
+  slackMessages: SlackMessage[],
+): Promise<Message[]> {
+  const userLabels = await buildMentionUserLabels(
+    auth,
+    slackMessages.map((msg) => msg.text),
+  );
+  const messages: Message[] = [];
+  for (const msg of slackMessages) {
+    const name = await resolveUserName(auth, msg.user ?? "");
+    messages.push(
+      mapMessage(
+        msg,
+        channelId,
+        name,
+        renderSlackTextForModel(msg.text, { userLabels }),
+      ),
+    );
+  }
+  return messages;
+}
+
+async function buildMentionUserLabels(
+  auth: OAuthConnection | string,
+  textValues: Iterable<string | undefined>,
+): Promise<Record<string, string>> {
+  return buildSlackUserLabelMap(textValues, (userId) =>
+    resolveUserName(auth, userId),
+  );
+}
+
+async function mapSearchMatches(
+  auth: OAuthConnection | string,
+  matches: SlackSearchMatch[],
+): Promise<Message[]> {
+  const userLabels = await buildMentionUserLabels(
+    auth,
+    matches.map((match) => match.text),
+  );
+  return matches.map((match) => mapSearchMatch(match, userLabels));
+}
+
 export const slackProvider: MessagingProvider = {
   id: "slack",
   displayName: "Slack",
@@ -395,16 +471,12 @@ export const slackProvider: MessagingProvider = {
         options?.limit ?? 50,
         options?.before,
         options?.after,
+        options?.cursor,
+        options?.inclusive,
       );
     });
 
-    const messages: Message[] = [];
-    for (const msg of resp.messages) {
-      const name = await resolveUserName(auth, msg.user ?? "");
-      messages.push(mapMessage(msg, conversationId, name));
-    }
-
-    return messages;
+    return mapSlackMessages(auth, conversationId, resp.messages);
   },
 
   async search(
@@ -412,12 +484,14 @@ export const slackProvider: MessagingProvider = {
     query: string,
     options?: SearchOptions,
   ): Promise<SearchResult> {
-    const resp = await runReadWithFallback(connection, (auth) =>
-      slack.searchMessages(auth, query, options?.count ?? 20),
-    );
+    let auth: OAuthConnection | string = getReadAuth(connection);
+    const resp = await runReadWithFallback(connection, async (a) => {
+      auth = a;
+      return slack.searchMessages(a, query, options?.count ?? 20);
+    });
     return {
       total: resp.messages.total,
-      messages: resp.messages.matches.map(mapSearchMatch),
+      messages: await mapSearchMatches(auth, resp.messages.matches),
       hasMore: resp.messages.paging.page < resp.messages.paging.pages,
     };
   },
@@ -456,14 +530,41 @@ export const slackProvider: MessagingProvider = {
         conversationId,
         threadId,
         options?.limit ?? 50,
+        options?.before,
+        options?.after,
+        options?.inclusive,
+        options?.cursor,
       );
     });
-    const messages: Message[] = [];
-    for (const msg of resp.messages) {
-      const name = await resolveUserName(auth, msg.user ?? "");
-      messages.push(mapMessage(msg, conversationId, name));
-    }
-    return messages;
+    return mapSlackMessages(auth, conversationId, resp.messages);
+  },
+
+  async getThreadRepliesPage(
+    connection: OAuthConnection | undefined,
+    conversationId: string,
+    threadId: string,
+    options?: HistoryOptions,
+  ): Promise<HistoryPageResult> {
+    let auth: OAuthConnection | string = getReadAuth(connection);
+    const resp = await runReadWithFallback(connection, async (a) => {
+      auth = a;
+      return slack.conversationReplies(
+        a,
+        conversationId,
+        threadId,
+        options?.limit ?? 50,
+        options?.before,
+        options?.after,
+        options?.inclusive,
+        options?.cursor,
+      );
+    });
+    const nextCursor = resp.response_metadata?.next_cursor || undefined;
+    return {
+      messages: await mapSlackMessages(auth, conversationId, resp.messages),
+      hasMore: Boolean(resp.has_more || nextCursor),
+      ...(nextCursor ? { nextCursor } : {}),
+    };
   },
 
   async markRead(

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

@@ -17,7 +17,11 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { OAuthConnection } from "../../../oauth/connection.js";
-import type { Message } from "../../provider-types.js";
+import type {
+  HistoryOptions,
+  HistoryPageResult,
+  Message,
+} from "../../provider-types.js";
 
 // ── Module mocks ────────────────────────────────────────────────────────────
 
@@ -27,18 +31,30 @@ type ResolveConnectionFn = (
 type GetHistoryFn = (
   connection: OAuthConnection | undefined,
   conversationId: string,
-  options?: { limit?: number; before?: string; after?: string },
+  options?: HistoryOptions,
 ) => Promise<Message[]>;
 type GetThreadRepliesFn = (
   connection: OAuthConnection | undefined,
   conversationId: string,
   threadId: string,
-  options?: { limit?: number },
+  options?: HistoryOptions,
 ) => Promise<Message[]>;
+type GetThreadRepliesPageFn = (
+  connection: OAuthConnection | undefined,
+  conversationId: string,
+  threadId: string,
+  options?: HistoryOptions,
+) => Promise<HistoryPageResult>;
 
 const resolveConnectionMock = mock<ResolveConnectionFn>(async () => undefined);
 const getHistoryMock = mock<GetHistoryFn>(async () => []);
 const getThreadRepliesMock = mock<GetThreadRepliesFn>(async () => []);
+const getThreadRepliesPageMock = mock<GetThreadRepliesPageFn>(
+  async (...args) => ({
+    messages: await getThreadRepliesMock(...args),
+    hasMore: false,
+  }),
+);
 
 mock.module("./adapter.js", () => ({
   slackProvider: {
@@ -50,14 +66,21 @@ mock.module("./adapter.js", () => ({
     getHistory: (
       connection: OAuthConnection | undefined,
       conversationId: string,
-      options?: { limit?: number; before?: string; after?: string },
+      options?: HistoryOptions,
     ) => getHistoryMock(connection, conversationId, options),
     getThreadReplies: (
       connection: OAuthConnection | undefined,
       conversationId: string,
       threadId: string,
-      options?: { limit?: number },
+      options?: HistoryOptions,
     ) => getThreadRepliesMock(connection, conversationId, threadId, options),
+    getThreadRepliesPage: (
+      connection: OAuthConnection | undefined,
+      conversationId: string,
+      threadId: string,
+      options?: HistoryOptions,
+    ) =>
+      getThreadRepliesPageMock(connection, conversationId, threadId, options),
     // Stub the rest of the MessagingProvider surface as no-ops; the backfill
     // helpers should never reach for these.
     testConnection: async () => {
@@ -71,7 +94,12 @@ mock.module("./adapter.js", () => ({
   },
 }));
 
-import { backfillDm, backfillThread } from "./backfill.js";
+import {
+  backfillDm,
+  backfillThread,
+  backfillThreadWindow,
+  backfillThreadWindowPage,
+} from "./backfill.js";
 
 function makeMessage(overrides: Partial<Message> = {}): Message {
   return {
@@ -93,6 +121,11 @@ describe("backfillThread", () => {
     resolveConnectionMock.mockImplementation(async () => undefined);
     getThreadRepliesMock.mockReset();
     getThreadRepliesMock.mockImplementation(async () => []);
+    getThreadRepliesPageMock.mockReset();
+    getThreadRepliesPageMock.mockImplementation(async (...args) => ({
+      messages: await getThreadRepliesMock(...args),
+      hasMore: false,
+    }));
     getHistoryMock.mockReset();
     getHistoryMock.mockImplementation(async () => []);
   });
@@ -122,6 +155,57 @@ describe("backfillThread", () => {
     expect(opts).toEqual({ limit: 10 });
   });
 
+  test("forwards explicit before/after window through window helper", async () => {
+    await backfillThreadWindow("C123", "1700000000.000100", {
+      limit: 10,
+      after: "1700000000.000100",
+      before: "1700000005.000100",
+    });
+
+    const [, , , opts] = getThreadRepliesMock.mock.calls[0];
+    expect(opts).toEqual({
+      limit: 10,
+      after: "1700000000.000100",
+      before: "1700000005.000100",
+    });
+  });
+
+  test("forwards cursor through window helper", async () => {
+    await backfillThreadWindow("C123", "1700000000.000100", {
+      cursor: "cursor-123",
+    });
+
+    const [, , , opts] = getThreadRepliesMock.mock.calls[0];
+    expect(opts).toEqual({
+      limit: 50,
+      cursor: "cursor-123",
+    });
+  });
+
+  test("page helper returns Slack pagination metadata", async () => {
+    const reply = makeMessage({
+      id: "1700000000.000300",
+      threadId: "1700000000.000100",
+    });
+    getThreadRepliesPageMock.mockImplementation(async () => ({
+      messages: [reply],
+      hasMore: true,
+      nextCursor: "cursor-next",
+    }));
+
+    const out = await backfillThreadWindowPage("C123", "1700000000.000100", {
+      limit: 25,
+      before: "1700000005.000100",
+    });
+
+    expect(getThreadRepliesPageMock).toHaveBeenCalledTimes(1);
+    expect(out).toEqual({
+      messages: [reply],
+      hasMore: true,
+      nextCursor: "cursor-next",
+    });
+  });
+
   test("returns [] when getThreadReplies throws (generic Slack API error)", async () => {
     getThreadRepliesMock.mockImplementation(async () => {
       throw new Error("Slack API error: ratelimited");
@@ -184,6 +268,11 @@ describe("backfillDm", () => {
     getHistoryMock.mockImplementation(async () => []);
     getThreadRepliesMock.mockReset();
     getThreadRepliesMock.mockImplementation(async () => []);
+    getThreadRepliesPageMock.mockReset();
+    getThreadRepliesPageMock.mockImplementation(async (...args) => ({
+      messages: await getThreadRepliesMock(...args),
+      hasMore: false,
+    }));
   });
 
   test("passes channelId through and defaults limit to 50, before undefined", async () => {