@vellumai/assistant 0.7.0 → 0.7.2

package/src/messaging/providers/outlook/client.ts

@@ -162,23 +162,6 @@ export async function listMessages(
   );
 }
 
-/** Get a single message by ID. */
-export async function getMessage(
-  connection: OAuthConnection,
-  messageId: string,
-  select?: string,
-): Promise<OutlookMessage> {
-  const query: Record<string, string> = {};
-  if (select) query["$select"] = select;
-
-  return request<OutlookMessage>(
-    connection,
-    `/v1.0/me/messages/${encodeURIComponent(messageId)}`,
-    undefined,
-    Object.keys(query).length > 0 ? query : undefined,
-  );
-}
-
 /** Search messages using Microsoft Graph KQL syntax. */
 export async function searchMessages(
   connection: OAuthConnection,
@@ -278,38 +261,6 @@ export async function markMessageRead(
   );
 }
 
-/** Patch arbitrary fields on a message (e.g. to update recipients on a draft). */
-export async function patchMessage(
-  connection: OAuthConnection,
-  messageId: string,
-  fields: Record<string, unknown>,
-): Promise<OutlookMessage> {
-  return request<OutlookMessage>(
-    connection,
-    `/v1.0/me/messages/${encodeURIComponent(messageId)}`,
-    {
-      method: "PATCH",
-      body: JSON.stringify(fields),
-    },
-  );
-}
-
-/** Move a message to a different folder (e.g. for archiving). */
-export async function moveMessage(
-  connection: OAuthConnection,
-  messageId: string,
-  destinationFolderId: string,
-): Promise<OutlookMessage> {
-  return request<OutlookMessage>(
-    connection,
-    `/v1.0/me/messages/${encodeURIComponent(messageId)}/move`,
-    {
-      method: "POST",
-      body: JSON.stringify({ destinationId: destinationFolderId }),
-    },
-  );
-}
-
 /** Create a draft message in the user's Drafts folder. */
 export async function createDraft(
   connection: OAuthConnection,
@@ -389,30 +340,6 @@ export async function createForwardDraft(
 }
 
 /** Max concurrent individual getMessage requests for batch fetching. */
-const BATCH_CONCURRENCY = 5;
-
-/** Fetch multiple messages with concurrency limiting. */
-export async function batchGetMessages(
-  connection: OAuthConnection,
-  messageIds: string[],
-  select?: string,
-): Promise<OutlookMessage[]> {
-  if (messageIds.length === 0) return [];
-
-  if (messageIds.length === 1) {
-    return [await getMessage(connection, messageIds[0], select)];
-  }
-
-  const results: OutlookMessage[] = [];
-  for (let i = 0; i < messageIds.length; i += BATCH_CONCURRENCY) {
-    const wave = messageIds.slice(i, i + BATCH_CONCURRENCY);
-    const waveResults = await Promise.all(
-      wave.map((id) => getMessage(connection, id, select)),
-    );
-    results.push(...waveResults);
-  }
-  return results;
-}
 
 /** List attachments on a message. */
 export async function listAttachments(

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,8 +5,12 @@
  * 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";
 import { resolveOAuthConnection } from "../../../oauth/connection-resolver.js";
 import { isProviderConnected } from "../../../oauth/oauth-store.js";
@@ -17,6 +21,7 @@ import type {
   ConnectionInfo,
   Conversation,
   HistoryOptions,
+  HistoryPageResult,
   ListOptions,
   Message,
   SearchOptions,
@@ -157,18 +162,6 @@ async function resolveUserName(
       resp.user.real_name ||
       resp.user.name;
     userNameCache.set(userId, name);
-
-    // Persist to contacts for future sessions
-    try {
-      upsertContactChannel({
-        sourceChannel: "slack",
-        externalUserId: userId,
-        displayName: name,
-      });
-    } catch {
-      // Non-fatal — caching failure shouldn't break messaging
-    }
-
     return name;
   } catch {
     return userId;
@@ -199,37 +192,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 +256,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",
@@ -357,24 +420,7 @@ export const slackProvider: MessagingProvider = {
         const dmUserId = conv.metadata.dmUserId as string;
         conv.name = await resolveUserName(auth, dmUserId);
 
-        // Persist the DM channel ID so future sends skip conversations.open
-        try {
-          const existing = findContactChannel({
-            channelType: "slack",
-            externalUserId: dmUserId,
-          });
-          if (existing && !existing.channel.externalChatId) {
-            upsertContactChannel({
-              contactId: existing.contact.id,
-              sourceChannel: "slack",
-              externalUserId: dmUserId,
-              externalChatId: conv.id,
-              displayName: conv.name,
-            });
-          }
-        } catch {
-          // Non-fatal
-        }
+
       }
     }
 
@@ -395,16 +441,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 +454,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 +500,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(