@vellumai/assistant 0.11.7 → 0.11.8-staging.1

package/src/messaging/providers/slack/__tests__/message-content.test.ts

@@ -0,0 +1,152 @@
+import { describe, expect, test } from "bun:test";
+
+import { slackMessageRawText } from "../message-content.js";
+
+describe("slackMessageRawText", () => {
+  test("returns top-level text untouched when present", () => {
+    expect(
+      slackMessageRawText({
+        text: "hello <@U123>",
+        attachments: [{ fallback: "ignored" }],
+      }),
+    ).toBe("hello <@U123>");
+  });
+
+  test("whitespace-only text falls through to attachments", () => {
+    expect(
+      slackMessageRawText({
+        text: "  \n ",
+        attachments: [{ fallback: "the fallback" }],
+      }),
+    ).toBe("the fallback");
+  });
+
+  test("prefers structured attachment fields over fallback", () => {
+    expect(
+      slackMessageRawText({
+        text: "",
+        attachments: [
+          {
+            fallback: "plain summary",
+            pretext: "build failed by <@U08E>",
+            author_name: "CI",
+            title: "CI Main Web",
+            title_link: "https://example.com/runs/1",
+            text: "3 tests failing",
+            fields: [
+              { title: "Branch", value: "main" },
+              { title: "", value: "value-only" },
+            ],
+            footer: "workflow #12",
+          },
+        ],
+      }),
+    ).toBe(
+      [
+        "build failed by <@U08E>",
+        "CI",
+        "CI Main Web (https://example.com/runs/1)",
+        "3 tests failing",
+        "Branch: main",
+        "value-only",
+        "workflow #12",
+      ].join("\n"),
+    );
+  });
+
+  test("uses fallback when the attachment has no structured text", () => {
+    expect(
+      slackMessageRawText({
+        text: "",
+        attachments: [{ fallback: "only the fallback" }],
+      }),
+    ).toBe("only the fallback");
+  });
+
+  test("joins multiple attachments with newlines and drops empty ones", () => {
+    expect(
+      slackMessageRawText({
+        text: "",
+        attachments: [{ text: "first" }, {}, { fallback: "second" }],
+      }),
+    ).toBe("first\nsecond");
+  });
+
+  test("extracts section, header, and context block text ahead of attachments", () => {
+    expect(
+      slackMessageRawText({
+        text: "",
+        blocks: [
+          {
+            type: "header",
+            text: { type: "plain_text", text: "Release v1.2" },
+          },
+          {
+            type: "section",
+            text: { type: "mrkdwn", text: "All green" },
+            fields: [
+              { type: "mrkdwn", text: "Env: prod" },
+              { type: "mrkdwn", text: "" },
+            ],
+          },
+          { type: "divider" },
+          {
+            type: "context",
+            elements: [
+              { type: "mrkdwn", text: "deployed by <@U42>" },
+              { type: "plain_text", text: "just now" },
+            ],
+          },
+        ],
+        attachments: [{ fallback: "attachment tail" }],
+      }),
+    ).toBe(
+      [
+        "Release v1.2",
+        "All green",
+        "Env: prod",
+        "deployed by <@U42> just now",
+        "attachment tail",
+      ].join("\n"),
+    );
+  });
+
+  test("extracts markdown block text", () => {
+    expect(
+      slackMessageRawText({
+        text: "",
+        blocks: [
+          { type: "markdown", text: "**Deploy failed** on `main`" },
+          { type: "divider" },
+        ],
+      }),
+    ).toBe("**Deploy failed** on `main`");
+  });
+
+  test("extracts blocks nested inside an attachment", () => {
+    expect(
+      slackMessageRawText({
+        text: "",
+        attachments: [
+          {
+            fallback: "plain summary",
+            blocks: [
+              { type: "section", text: { type: "mrkdwn", text: "Run #7 red" } },
+              { type: "markdown", text: "3 tests failing" },
+            ],
+          },
+        ],
+      }),
+    ).toBe("Run #7 red\n3 tests failing");
+  });
+
+  test("returns empty string when nothing carries text", () => {
+    expect(
+      slackMessageRawText({
+        text: "",
+        blocks: [{ type: "divider" }],
+        attachments: [{}],
+      }),
+    ).toBe("");
+  });
+});

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

@@ -38,6 +38,7 @@ import {
   isPrivateConversation,
   slackUserDisplayName,
 } from "./conversation-utils.js";
+import { slackMessageRawText } from "./message-content.js";
 import type {
   SlackConversation,
   SlackMessage,
@@ -79,6 +80,15 @@ const userInfoCache = new Map<string, Promise<SlackUserInfoLookupResult>>();
  */
 const channelNameCache = new Map<string, Promise<string | undefined>>();
 
+/**
+ * Cache resolved bot display names (`bots.info`) for bot-authored rows that
+ * carry only a `bot_id`, same lifetime and keying discipline as
+ * {@link userInfoCache}. Holds `undefined` for bots this auth provably
+ * cannot resolve so a wall of webhook history doesn't re-fire a doomed
+ * lookup per message batch.
+ */
+const botNameCache = new Map<string, Promise<string | undefined>>();
+
 /**
  * Cached auth resolved during resolveConnection(), split by direction.
  *
@@ -331,42 +341,113 @@ function slackUserInfoCacheKey(
 }
 
 /**
- * Resolve a channel's display name for inline mention rendering, cached per
- * auth scope. Returns undefined when the channel has no name (DMs) or this
- * auth cannot see it; transient failures are not cached so a later batch
- * retries.
+ * Shared resolve-once discipline for the Slack directory name caches
+ * (channel and bot names): concurrent callers share the in-flight promise,
+ * successes and provably-permanent failures stay cached, and transient
+ * failures are evicted so a later batch retries.
  */
-async function resolveChannelName(
-  auth: OAuthConnection | string,
-  channelId: string,
+async function resolveCachedSlackName(
+  cache: Map<string, Promise<string | undefined>>,
+  cacheKey: string,
+  lookup: () => Promise<string | undefined>,
+  isPermanentFailure: (err: unknown) => boolean,
 ): Promise<string | undefined> {
-  if (!channelId) {
-    return undefined;
-  }
-  const cacheKey = `${slackAuthCacheScope(auth)}:channel:${channelId}`;
-  const cached = channelNameCache.get(cacheKey);
+  const cached = cache.get(cacheKey);
   if (cached) {
     return cached;
   }
 
-  const resolved = slack.conversationInfo(auth, channelId).then(
-    (resp) => trimNonEmpty(resp.channel.name),
+  const resolved = lookup().then(
+    (name) => name,
     (err: unknown) => {
       // Cache the definitive "this auth cannot resolve it" answers; drop
       // everything else so transient failures retry on the next batch.
-      const permanent =
-        err instanceof SlackApiError &&
-        (err.category === "channel_not_found" || err.category === "permission");
-      if (!permanent) {
-        channelNameCache.delete(cacheKey);
+      if (!isPermanentFailure(err)) {
+        cache.delete(cacheKey);
       }
       return undefined;
     },
   );
-  channelNameCache.set(cacheKey, resolved);
+  cache.set(cacheKey, resolved);
   return resolved;
 }
 
+/**
+ * Resolve a channel's display name for inline mention rendering, cached per
+ * auth scope. Returns undefined when the channel has no name (DMs) or this
+ * auth cannot see it.
+ */
+async function resolveChannelName(
+  auth: OAuthConnection | string,
+  channelId: string,
+): Promise<string | undefined> {
+  if (!channelId) {
+    return undefined;
+  }
+  return resolveCachedSlackName(
+    channelNameCache,
+    `${slackAuthCacheScope(auth)}:channel:${channelId}`,
+    async () =>
+      trimNonEmpty(
+        (await slack.conversationInfo(auth, channelId)).channel.name,
+      ),
+    (err) =>
+      err instanceof SlackApiError &&
+      (err.category === "channel_not_found" || err.category === "permission"),
+  );
+}
+
+/**
+ * Resolve a bot's display name via `bots.info`, cached per auth scope.
+ * Returns undefined when this auth cannot resolve it.
+ */
+async function resolveBotName(
+  auth: OAuthConnection | string,
+  botId: string,
+): Promise<string | undefined> {
+  return resolveCachedSlackName(
+    botNameCache,
+    `${slackAuthCacheScope(auth)}:bot:${botId}`,
+    async () => trimNonEmpty((await slack.botsInfo(auth, botId)).bot.name),
+    (err) =>
+      err instanceof SlackApiError &&
+      (err.slackError === "bot_not_found" || err.category === "permission"),
+  );
+}
+
+/**
+ * Sender info for a bot-authored row (no `user` to look up). The message's
+ * own `username` (bot_message subtype) or `bot_profile.name` answers without
+ * I/O; `bots.info` covers rows carrying only a `bot_id`, with the id itself
+ * as the last resort so the sender is at least attributable.
+ *
+ * `batchBotNames` pins the first lookup attempt per bot id for the caller's
+ * batch: the module cache evicts transient failures (so a later batch
+ * retries), and without the pin a history page full of one webhook's rows
+ * would re-fire a doomed `bots.info` cycle per row during a Slack outage.
+ */
+async function resolveBotSenderInfo(
+  auth: OAuthConnection | string,
+  msg: SlackMessage,
+  batchBotNames: Map<string, Promise<string | undefined>>,
+): Promise<NormalizedSlackUserInfo> {
+  const fromMessage =
+    trimNonEmpty(msg.username) ?? trimNonEmpty(msg.bot_profile?.name);
+  if (fromMessage) {
+    return { displayName: fromMessage };
+  }
+  const botId = msg.bot_id?.trim();
+  if (!botId) {
+    return { displayName: "unknown" };
+  }
+  let pending = batchBotNames.get(botId);
+  if (pending === undefined) {
+    pending = resolveBotName(auth, botId);
+    batchBotNames.set(botId, pending);
+  }
+  return { displayName: (await pending) ?? botId };
+}
+
 function normalizeSlackUserInfo(
   user: SlackUser,
   contactDisplayName: string | undefined,
@@ -398,6 +479,7 @@ function trimNonEmpty(value: unknown): string | undefined {
 export function __resetSlackMentionCachesForTests(): void {
   userInfoCache.clear();
   channelNameCache.clear();
+  botNameCache.clear();
 }
 
 function slackUserInfoMetadata(
@@ -529,19 +611,22 @@ async function mapSlackMessages(
   channelId: string,
   slackMessages: SlackMessage[],
 ): Promise<Message[]> {
-  const labels = await buildMentionLabels(
-    auth,
-    slackMessages.map((msg) => msg.text),
-  );
+  // Raw text may come from attachments/blocks (bot and webhook posts), so
+  // mention labels are built from the same derived strings that get rendered.
+  const rawTexts = slackMessages.map((msg) => slackMessageRawText(msg));
+  const labels = await buildMentionLabels(auth, rawTexts);
+  const batchBotNames = new Map<string, Promise<string | undefined>>();
   const messages: Message[] = [];
-  for (const msg of slackMessages) {
-    const senderInfo = await resolveUserInfo(auth, msg.user ?? "");
+  for (const [i, msg] of slackMessages.entries()) {
+    const senderInfo = msg.user
+      ? await resolveUserInfo(auth, msg.user)
+      : await resolveBotSenderInfo(auth, msg, batchBotNames);
     messages.push(
       mapMessage(
         msg,
         channelId,
         senderInfo,
-        renderSlackTextForModel(msg.text, labels),
+        renderSlackTextForModel(rawTexts[i], labels),
       ),
     );
   }

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

@@ -28,6 +28,16 @@ mock.module("../../../security/secure-keys.js", () => ({
   }),
 }));
 
+// With `userTokenStored` false, `resolveSlackAuth` looks for a `slack` OAuth
+// connection before falling back to the bot token. This suite builds no
+// database, so the lookup has to be answered here; spread for the same reason
+// the secure-keys mock above does.
+const realOauthStore = await import("../../../oauth/oauth-store.js");
+mock.module("../../../oauth/oauth-store.js", () => ({
+  ...realOauthStore,
+  getConnectionByProvider: () => undefined,
+}));
+
 const { appendSlackStream, getSlackConversationInfo, startSlackStream } =
   await import("./api.js");
 

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

@@ -21,9 +21,11 @@
  *     any caller read the installer's channels or post as them. Also used for
  *     content the assistant posts as itself.
  *
- *   - "user" — act as the assistant's owner, using the optional user token for
- *     its wider reach (channels the owner is in but the bot isn't; and
- *     `search.messages`, which only a user token can call). Scoped to the
+ *   - "user": act as the assistant's owner, using whichever of the installer's
+ *     own tokens is present for its wider reach (channels the owner is in but
+ *     the bot isn't; and `search.messages`, which only a user token can call):
+ *     the channel's pasted user token, else a `slack` OAuth connection, else
+ *     the bot token. Scoped to the
  *     in-conversation messaging adapter, where the assistant is acting for its
  *     own owner within a trust-classified conversation — NOT the edge-reachable
  *     control-plane routes above. Falls back to the bot token when no user
@@ -57,12 +59,36 @@ export async function resolveSlackAuth(
   );
   if (botToken) {
     if (identity === "user") {
-      // Prefer the optional user token; fall back to the bot token when the
-      // install never captured one.
+      // Three rungs, widest reach first. The pasted channel user token and the
+      // `slack` OAuth connection are the same thing obtained two ways: the
+      // installer's own token, carrying the channel and search scopes a bot
+      // token cannot. Falling straight to the bot from a missing paste would
+      // drop `search.messages`, which only a user token can call, while a
+      // usable one sat in the OAuth connection.
       const userToken = await getSecureKeyAsync(
         credentialKey("slack_channel", "user_token"),
       );
-      return userToken ?? botToken;
+      if (userToken) {
+        return userToken;
+      }
+      // The connection holds the installer's user token: this provider always
+      // requests `user_scope`, and `exchangeCodeForTokens` stores the nested
+      // `authed_user` token whenever Slack returns one. An install that
+      // granted no user scopes leaves a bot token there instead, which is the
+      // same thing the next line falls back to, so the wrong guess costs
+      // nothing.
+      if (getConnectionByProvider("slack")) {
+        try {
+          return await resolveOAuthConnection("slack", {
+            account: opts.account,
+          });
+        } catch {
+          // Unlike the legacy branch below, this one has somewhere to go: a
+          // revoked or unrefreshable connection degrades to the bot token
+          // rather than failing a resolve the bot can still answer.
+        }
+      }
+      return botToken;
     }
     return botToken;
   }

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

@@ -22,7 +22,6 @@ import type {
   SlackConversationsListResponse,
   SlackConversationsOpenResponse,
   SlackPostMessageResponse,
-  SlackReactionsAddResponse,
   SlackSearchMessagesResponse,
   SlackUserInfoResponse,
   SlackUsersListResponse,
@@ -222,20 +221,6 @@ export async function searchMessages(
   );
 }
 
-export async function addReaction(
-  connectionOrToken: OAuthConnection | string,
-  channel: string,
-  timestamp: string,
-  name: string,
-): Promise<SlackReactionsAddResponse> {
-  return request<SlackReactionsAddResponse>(
-    connectionOrToken,
-    "reactions.add",
-    undefined,
-    { channel, timestamp, name },
-  );
-}
-
 export async function listUsers(
   connectionOrToken: OAuthConnection | string,
   limit = 200,

package/src/messaging/providers/slack/message-content.ts

@@ -0,0 +1,137 @@
+/**
+ * Fallback text extraction for Slack messages whose content lives outside
+ * the top-level `text` field.
+ *
+ * Bot and incoming-webhook posts (CI alerts, app notifications) routinely
+ * ship an empty `text` with the visible content in legacy `attachments` or
+ * Block Kit `blocks`; Slack's own clients render those. A mapping that reads
+ * only `text` turns such a message into an empty row, which downstream
+ * surfaces (transcripts, channel references) present as missing content.
+ *
+ * Output is raw Slack mrkdwn: mention/link tokens inside attachments and
+ * blocks are preserved so callers can route the result through the same
+ * `renderSlackTextForModel` pass as ordinary message text.
+ */
+import type {
+  AnyBlock,
+  ContextBlock,
+  HeaderBlock,
+  MarkdownBlock,
+  MessageAttachment,
+  SectionBlock,
+} from "@slack/types";
+
+import type { SlackMessage } from "./types.js";
+
+/**
+ * The model-facing raw mrkdwn for a Slack message: `text` when present,
+ * otherwise content derived from `blocks` and `attachments` (in that order,
+ * matching how Slack renders a message body above its attachments).
+ */
+export function slackMessageRawText(
+  msg: Pick<SlackMessage, "text" | "attachments" | "blocks">,
+): string {
+  if (msg.text?.trim()) {
+    return msg.text;
+  }
+  const parts = [
+    ...slackBlocksText(msg.blocks),
+    ...(msg.attachments ?? []).map(slackAttachmentText),
+  ].filter((part) => part.length > 0);
+  return parts.join("\n");
+}
+
+function slackAttachmentText(attachment: MessageAttachment): string {
+  // An attachment carrying Block Kit blocks renders them as its body, so
+  // they lead; the legacy fields still contribute when both are present.
+  const blockParts = slackBlocksText(attachment.blocks);
+  const title = trimmed(attachment.title);
+  const titleLink = trimmed(attachment.title_link);
+  const fieldLines = (attachment.fields ?? []).map((field) => {
+    const fieldTitle = trimmed(field.title);
+    const fieldValue = trimmed(field.value);
+    if (fieldTitle && fieldValue) {
+      return `${fieldTitle}: ${fieldValue}`;
+    }
+    return fieldTitle ?? fieldValue ?? "";
+  });
+  const structured = [
+    ...blockParts,
+    trimmed(attachment.pretext),
+    trimmed(attachment.author_name),
+    title && titleLink ? `${title} (${titleLink})` : title,
+    trimmed(attachment.text),
+    ...fieldLines,
+    trimmed(attachment.footer),
+  ].filter((part): part is string => !!part);
+  if (structured.length > 0) {
+    return structured.join("\n");
+  }
+  return trimmed(attachment.fallback) ?? "";
+}
+
+function isSectionBlock(block: AnyBlock): block is SectionBlock {
+  return block.type === "section";
+}
+
+function isHeaderBlock(block: AnyBlock): block is HeaderBlock {
+  return block.type === "header";
+}
+
+function isContextBlock(block: AnyBlock): block is ContextBlock {
+  return block.type === "context";
+}
+
+function isMarkdownBlock(block: AnyBlock): block is MarkdownBlock {
+  return block.type === "markdown";
+}
+
+/**
+ * Text carried by the block types that hold a message body's copy. Other
+ * block types contribute nothing: images/dividers/actions are non-textual,
+ * and `rich_text` (deeply nested; produced for user-typed messages, which
+ * carry the equivalent top-level `text`) is intentionally not walked.
+ */
+function slackBlocksText(blocks: readonly AnyBlock[] | undefined): string[] {
+  const parts: string[] = [];
+  for (const block of blocks ?? []) {
+    if (isSectionBlock(block)) {
+      const text = trimmed(block.text?.text);
+      if (text) {
+        parts.push(text);
+      }
+      for (const field of block.fields ?? []) {
+        const fieldText = trimmed(field.text);
+        if (fieldText) {
+          parts.push(fieldText);
+        }
+      }
+    } else if (isHeaderBlock(block)) {
+      const text = trimmed(block.text.text);
+      if (text) {
+        parts.push(text);
+      }
+    } else if (isContextBlock(block)) {
+      const contextText = block.elements
+        .map((element) =>
+          "text" in element ? trimmed(element.text) : undefined,
+        )
+        .filter((text): text is string => !!text)
+        .join(" ");
+      if (contextText) {
+        parts.push(contextText);
+      }
+    } else if (isMarkdownBlock(block)) {
+      const text = trimmed(block.text);
+      if (text) {
+        parts.push(text);
+      }
+    }
+  }
+  return parts;
+}
+
+function trimmed(value: string | undefined): string | undefined {
+  const result = value?.trim();
+  return result ? result : undefined;
+}

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

@@ -28,8 +28,12 @@ mock.module("./api.js", () => ({
 // the (unmocked) shared transport, so thrown test errors must be real
 // instances or every branch under test would silently take the generic path.
 const { SlackApiError } = await import("./web-api-transport.js");
-const { sendSlackAgentSessionStatus, sendSlackReply, updateSlackMessage } =
-  await import("./send.js");
+const {
+  sendSlackAgentSessionStatus,
+  sendSlackReaction,
+  sendSlackReply,
+  updateSlackMessage,
+} = await import("./send.js");
 
 describe("sendSlackAgentSessionStatus", () => {
   const threadTs = "1700000000.000100";
@@ -137,6 +141,43 @@ describe("sendSlackAgentSessionStatus", () => {
   });
 });
 
+describe("sendSlackReaction", () => {
+  test("adds with the bare emoji name, colons stripped", async () => {
+    const result = await sendSlackReaction("C1", ":tada:", "123.456", "add");
+    expect(result).toEqual({ ok: true });
+    expect(callSlackApiMock).toHaveBeenCalledWith("reactions.add", {
+      channel: "C1",
+      name: "tada",
+      timestamp: "123.456",
+    });
+  });
+
+  test("remove routes to reactions.remove", async () => {
+    await sendSlackReaction("C1", "tada", "123.456", "remove");
+    expect(callSlackApiMock).toHaveBeenCalledWith("reactions.remove", {
+      channel: "C1",
+      name: "tada",
+      timestamp: "123.456",
+    });
+  });
+
+  test("already_reacted reads as success: the end state holds", async () => {
+    callSlackApiMock.mockImplementationOnce(async () => {
+      throw new SlackApiError("already_reacted");
+    });
+    const result = await sendSlackReaction("C1", "tada", "123.456", "add");
+    expect(result).toEqual({ ok: true });
+  });
+
+  test("any other failure reports ok false without throwing", async () => {
+    callSlackApiMock.mockImplementationOnce(async () => {
+      throw new SlackApiError("channel_not_found");
+    });
+    const result = await sendSlackReaction("C1", "tada", "123.456", "add");
+    expect(result).toEqual({ ok: false });
+  });
+});
+
 describe("updateSlackMessage", () => {
   const messageTs = "1700000000.000100";
   const blocks: KnownBlock[] = [