@vellumai/vellum-gateway 0.7.0 → 0.7.2

package/src/slack/normalize.ts

@@ -1,3 +1,8 @@
+import {
+  renderSlackTextForModel,
+  stripLeadingSlackMentionFallback,
+  stripLeadingSlackUserMention,
+} from "@vellumai/slack-text";
 import type { GatewayConfig } from "../config.js";
 import { fetchImpl } from "../fetch.js";
 import { resolveAssistant, isRejection } from "../routing/resolve-assistant.js";
@@ -275,15 +280,55 @@ export interface SlackMessageDeletedEvent {
   };
 }
 
+export type SlackTextRenderContext = {
+  botUserId?: string;
+  userLabels?: Record<string, string>;
+};
+
 /**
- * Strip leading bot-mention tokens (`<@U...>`) from the message text.
- * Slack wraps mentions as `<@UXXXXXX>`, often at the start of an
- * app_mention event's text field. We remove all leading occurrences
- * so the assistant receives clean user content.
+ * Strip leading bot-mention tokens from Slack message text.
+ *
+ * When the bot user ID is known, only that exact mention is stripped. Without a
+ * bot user ID, strip just one leading mention as an app_mention compatibility
+ * fallback.
  */
-export function stripBotMention(text: string): string {
-  const stripped = text.replace(/^(<@[A-Z0-9]+>\s*)+/i, "").trim();
-  return stripped || text.trim();
+export function stripBotMention(text: string, botUserId?: string): string {
+  const stripped = botUserId
+    ? stripLeadingSlackUserMention(text, botUserId)
+    : stripLeadingSlackMentionFallback(text);
+  return stripped.trim() || text.trim();
+}
+
+function renderSlackInboundText(
+  text: string,
+  context: SlackTextRenderContext = {},
+  options: {
+    stripLeadingBotMention?: boolean;
+    fallbackStripFirstMention?: boolean;
+  } = {},
+): string {
+  let stripped = text;
+  if (options.stripLeadingBotMention) {
+    stripped = context.botUserId
+      ? stripBotMention(text, context.botUserId)
+      : options.fallbackStripFirstMention
+        ? stripBotMention(text)
+        : text.trim();
+  }
+
+  return renderSlackTextForModel(stripped, {
+    userLabels: context.userLabels,
+  });
+}
+
+function withBotUserId(
+  botUserId: string | undefined,
+  context: SlackTextRenderContext | undefined,
+): SlackTextRenderContext {
+  return {
+    ...context,
+    botUserId: context?.botUserId ?? botUserId,
+  };
 }
 
 function extractSlackAttachments(files: SlackFile[] | undefined): Array<{
@@ -307,6 +352,18 @@ function extractSlackAttachments(files: SlackFile[] | undefined): Array<{
     }));
 }
 
+function extractSlackFileMap(
+  files: SlackFile[] | undefined,
+): Map<string, SlackFile> | undefined {
+  if (!files || files.length === 0) return undefined;
+  const downloadableFiles = files.filter(
+    (f) => f.url_private_download || f.url_private,
+  );
+  return downloadableFiles.length
+    ? new Map(downloadableFiles.map((f) => [f.id, f]))
+    : undefined;
+}
+
 export type NormalizedSlackEvent = {
   event: GatewayInboundEvent;
   routing: RouteResult;
@@ -332,6 +389,7 @@ export function normalizeSlackDirectMessage(
   config: GatewayConfig,
   botUserId?: string,
   botToken?: string,
+  renderContext?: SlackTextRenderContext,
 ): NormalizedSlackEvent | null {
   // Ignore messages from the bot itself
   if (botUserId && event.user === botUserId) return null;
@@ -360,13 +418,7 @@ export function normalizeSlackDirectMessage(
     event.client_msg_id ?? event.ts ?? `${event.channel}:${event.ts}`;
 
   const attachments = extractSlackAttachments(event.files);
-  const slackFiles = event.files?.length
-    ? new Map(
-        event.files
-          .filter((f) => f.url_private_download || f.url_private)
-          .map((f) => [f.id, f]),
-      )
-    : undefined;
+  const slackFiles = extractSlackFileMap(event.files);
 
   // Use cache-only lookup to avoid blocking normalization on network calls.
   // A background fetch warms the cache for subsequent messages from this user.
@@ -374,6 +426,10 @@ export function normalizeSlackDirectMessage(
     botToken && event.user
       ? resolveSlackUserSync(event.user, botToken)
       : undefined;
+  const content = renderSlackInboundText(
+    event.text,
+    withBotUserId(botUserId, renderContext),
+  );
 
   return {
     event: {
@@ -381,7 +437,7 @@ export function normalizeSlackDirectMessage(
       sourceChannel: "slack",
       receivedAt: new Date().toISOString(),
       message: {
-        content: event.text,
+        content,
         conversationExternalId: event.channel,
         externalMessageId,
         ...(attachments.length > 0 ? { attachments } : {}),
@@ -396,6 +452,7 @@ export function normalizeSlackDirectMessage(
       source: {
         updateId: eventId,
         messageId: event.ts,
+        chatType: "im",
         ...(event.thread_ts ? { threadId: event.thread_ts } : {}),
       },
       raw: event as unknown as Record<string, unknown>,
@@ -420,6 +477,7 @@ export function normalizeSlackChannelMessage(
   config: GatewayConfig,
   botUserId?: string,
   botToken?: string,
+  renderContext?: SlackTextRenderContext,
 ): NormalizedSlackEvent | null {
   if (botUserId && event.user === botUserId) return null;
   // file_share is allowed so image/file uploads are delivered to the assistant.
@@ -429,18 +487,16 @@ export function normalizeSlackChannelMessage(
   const routing = resolveAssistant(config, event.channel, event.user);
   if (isRejection(routing)) return null;
 
-  const content = stripBotMention(event.text);
+  const content = renderSlackInboundText(
+    event.text,
+    withBotUserId(botUserId, renderContext),
+    { stripLeadingBotMention: true, fallbackStripFirstMention: true },
+  );
   const externalMessageId =
     event.client_msg_id ?? event.ts ?? `${event.channel}:${event.ts}`;
 
   const attachments = extractSlackAttachments(event.files);
-  const slackFiles = event.files?.length
-    ? new Map(
-        event.files
-          .filter((f) => f.url_private_download || f.url_private)
-          .map((f) => [f.id, f]),
-      )
-    : undefined;
+  const slackFiles = extractSlackFileMap(event.files);
 
   const userInfo =
     botToken && event.user
@@ -491,25 +547,28 @@ export function normalizeSlackAppMention(
   event: SlackAppMentionEvent,
   eventId: string,
   config: GatewayConfig,
+  botUserId?: string,
   botToken?: string,
+  renderContext?: SlackTextRenderContext,
 ): NormalizedSlackEvent | null {
   const routing = resolveAssistant(config, event.channel, event.user);
   if (isRejection(routing)) {
     return null;
   }
 
-  const content = stripBotMention(event.text);
+  const content = renderSlackInboundText(
+    event.text,
+    withBotUserId(botUserId, renderContext),
+    {
+      stripLeadingBotMention: true,
+      fallbackStripFirstMention: true,
+    },
+  );
   const externalMessageId =
     event.client_msg_id ?? event.ts ?? `${event.channel}:${event.ts}`;
 
   const attachments = extractSlackAttachments(event.files);
-  const slackFiles = event.files?.length
-    ? new Map(
-        event.files
-          .filter((f) => f.url_private_download || f.url_private)
-          .map((f) => [f.id, f]),
-      )
-    : undefined;
+  const slackFiles = extractSlackFileMap(event.files);
 
   const userInfo =
     botToken && event.user
@@ -791,6 +850,7 @@ export function normalizeSlackMessageEdit(
   eventId: string,
   config: GatewayConfig,
   botUserId?: string,
+  renderContext?: SlackTextRenderContext,
 ): NormalizedSlackEvent | null {
   const edited = event.message;
   if (!edited) return null;
@@ -816,7 +876,14 @@ export function normalizeSlackMessageEdit(
   }
   if (isRejection(routing)) return null;
 
-  const content = stripBotMention(edited.text);
+  const content = renderSlackInboundText(
+    edited.text,
+    withBotUserId(botUserId, renderContext),
+    {
+      stripLeadingBotMention: true,
+      fallbackStripFirstMention: !botUserId,
+    },
+  );
 
   // Each edit event gets a unique externalMessageId so the dedup pipeline
   // does not discard subsequent edits of the same Slack message.
@@ -875,9 +942,17 @@ export function normalizeSlackMessageDelete(
   event: SlackMessageDeletedEvent,
   eventId: string,
   config: GatewayConfig,
+  botUserId?: string,
 ): NormalizedSlackEvent | null {
   if (!event.deleted_ts) return null;
 
+  // Drop deletions of the bot's own messages. Slack echoes self-deletes back
+  // via Socket Mode; without this filter the bot's user ID flows into the
+  // assistant's ACL as the actor, fails member lookup (the bot is never its
+  // own trusted contact), and triggers a spurious access-request notification
+  // to the guardian. Mirrors the bot-self filter on the edit path above.
+  if (botUserId && event.previous_message?.user === botUserId) return null;
+
   // Use the previous author for actor identity when available; otherwise fall
   // back to a synthetic identifier so routing/trust still has something to key on.
   const actorId = event.previous_message?.user ?? "slack-system";

package/src/slack/slack-web.ts

@@ -0,0 +1,213 @@
+import { fetchImpl } from "../fetch.js";
+import { getLogger } from "../logger.js";
+
+const log = getLogger("slack-web");
+
+/**
+ * Subset of the Slack `conversations.history` / `conversations.replies`
+ * message payload that the gateway needs for catch-up. Synthesized
+ * Socket Mode envelopes are built by mapping these fields onto the
+ * `app_mention` / `message` event shapes that the live path already
+ * understands.
+ */
+export type SlackHistoryMessage = {
+  type?: string;
+  subtype?: string;
+  user?: string;
+  bot_id?: string;
+  text?: string;
+  ts: string;
+  thread_ts?: string;
+  team?: string;
+  blocks?: unknown[];
+  files?: unknown[];
+  attachments?: unknown[];
+  edited?: { user?: string; ts?: string };
+};
+
+type SlackHistoryResponse = {
+  ok: boolean;
+  error?: string;
+  messages?: SlackHistoryMessage[];
+  has_more?: boolean;
+};
+
+export type FetchSlackHistoryResult = {
+  /** Messages returned by Slack. Empty on transient failure. */
+  messages: SlackHistoryMessage[];
+  /** True when Slack indicates additional pages are available. */
+  hasMore: boolean;
+  /**
+   * `true` when the call succeeded (HTTP 200 + `ok: true`). False results
+   * are logged and silently treated as zero messages so a transient outage
+   * during catch-up doesn't block reconnect.
+   */
+  ok: boolean;
+};
+
+/** Slack rate-limit handling — wait this long after a 429 before retrying. */
+const RATE_LIMIT_FALLBACK_MS = 5_000;
+
+/**
+ * Coordinates per-cycle catch-up cancellation. When any worker hits a 429,
+ * it calls `abort()`; remaining workers check `aborted` before each call
+ * and bail out without issuing further requests, so the catch-up cycle
+ * stops cleanly instead of cascading into more rate-limit responses.
+ */
+export class CatchupAbortSignal {
+  private flag = false;
+  abort(): void {
+    this.flag = true;
+  }
+  get aborted(): boolean {
+    return this.flag;
+  }
+}
+
+async function callSlackApi(
+  url: string,
+  botToken: string,
+  abort: CatchupAbortSignal | undefined,
+): Promise<SlackHistoryResponse | undefined> {
+  if (abort?.aborted) return undefined;
+
+  let resp: Response;
+  try {
+    resp = await fetchImpl(url, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${botToken}` },
+    });
+  } catch (err) {
+    log.warn({ err, url: redact(url) }, "Slack catch-up fetch threw");
+    return undefined;
+  }
+
+  if (resp.status === 429) {
+    const retryHeader = resp.headers.get("retry-after");
+    const waitMs = retryHeader
+      ? Number.parseInt(retryHeader, 10) * 1_000
+      : RATE_LIMIT_FALLBACK_MS;
+    abort?.abort();
+    log.warn(
+      { url: redact(url), waitMs },
+      "Slack catch-up rate limited; aborting cycle",
+    );
+    return undefined;
+  }
+
+  if (!resp.ok) {
+    log.warn(
+      { url: redact(url), status: resp.status },
+      "Slack catch-up returned non-OK HTTP status",
+    );
+    return undefined;
+  }
+
+  let data: SlackHistoryResponse;
+  try {
+    data = (await resp.json()) as SlackHistoryResponse;
+  } catch (err) {
+    log.warn({ err, url: redact(url) }, "Slack catch-up response not JSON");
+    return undefined;
+  }
+
+  if (!data.ok) {
+    log.warn(
+      { url: redact(url), error: data.error },
+      "Slack catch-up API returned ok=false",
+    );
+    return undefined;
+  }
+
+  return data;
+}
+
+/** Strip the channel/oldest query for log readability. */
+function redact(url: string): string {
+  const idx = url.indexOf("?");
+  return idx >= 0 ? url.slice(0, idx) : url;
+}
+
+/**
+ * Fetch messages in `channel` strictly newer than `oldest` (Slack ts).
+ * `inclusive=false` is the default; we set it explicitly to make the
+ * behavior obvious on read. No pagination — we cap at `limit` messages
+ * per channel per reconnect to bound API budget.
+ */
+export async function fetchChannelHistorySince(params: {
+  botToken: string;
+  channel: string;
+  oldest: string;
+  limit: number;
+  abort?: CatchupAbortSignal;
+}): Promise<FetchSlackHistoryResult> {
+  const { botToken, channel, oldest, limit, abort } = params;
+  const url =
+    "https://slack.com/api/conversations.history" +
+    `?channel=${encodeURIComponent(channel)}` +
+    `&oldest=${encodeURIComponent(oldest)}` +
+    `&limit=${limit}` +
+    `&inclusive=false`;
+  const data = await callSlackApi(url, botToken, abort);
+  if (!data) return { messages: [], hasMore: false, ok: false };
+  return {
+    messages: data.messages ?? [],
+    hasMore: data.has_more === true,
+    ok: true,
+  };
+}
+
+/**
+ * Fetch replies in a thread strictly newer than `oldest`. Uses
+ * `conversations.replies` because it returns a smaller, thread-scoped
+ * window than `conversations.history` and avoids re-paging the channel
+ * for every active thread on reconnect.
+ */
+export async function fetchThreadRepliesSince(params: {
+  botToken: string;
+  channel: string;
+  threadTs: string;
+  oldest: string;
+  limit: number;
+  abort?: CatchupAbortSignal;
+}): Promise<FetchSlackHistoryResult> {
+  const { botToken, channel, threadTs, oldest, limit, abort } = params;
+  const url =
+    "https://slack.com/api/conversations.replies" +
+    `?channel=${encodeURIComponent(channel)}` +
+    `&ts=${encodeURIComponent(threadTs)}` +
+    `&oldest=${encodeURIComponent(oldest)}` +
+    `&limit=${limit}` +
+    `&inclusive=false`;
+  const data = await callSlackApi(url, botToken, abort);
+  if (!data) return { messages: [], hasMore: false, ok: false };
+  return {
+    messages: data.messages ?? [],
+    hasMore: data.has_more === true,
+    ok: true,
+  };
+}
+
+/**
+ * Drives a list of async tasks with bounded concurrency. Used to fan out
+ * catch-up fetches across channels without flooding Slack's rate limits.
+ */
+export async function runWithConcurrency<T>(
+  tasks: Array<() => Promise<T>>,
+  concurrency: number,
+): Promise<T[]> {
+  const results: T[] = new Array(tasks.length);
+  let cursor = 0;
+  const workers = Array.from(
+    { length: Math.min(concurrency, tasks.length) },
+    async () => {
+      while (true) {
+        const idx = cursor++;
+        if (idx >= tasks.length) return;
+        results[idx] = await tasks[idx]();
+      }
+    },
+  );
+  await Promise.all(workers);
+  return results;
+}