@vellumai/assistant 0.8.3 → 0.8.5

package/src/messaging/providers/slack/__tests__/adapter-token-routing.test.ts

@@ -49,7 +49,11 @@ mock.module("../../../../contacts/contacts-write.js", () => ({
   upsertContactChannel: () => {},
 }));
 
-import { slackProvider, withSlackBotToken } from "../adapter.js";
+import {
+  resolveSlackBotUserId,
+  slackProvider,
+  withSlackBotToken,
+} from "../adapter.js";
 
 // ── fetch capture ───────────────────────────────────────────────────────────
 
@@ -104,6 +108,16 @@ function fakeSlackResponse(url: string): Record<string, unknown> {
   if (url.includes("/chat.postMessage")) {
     return { ok: true, ts: "1700000000.000100", channel: "C123" };
   }
+  if (url.includes("/bots.info")) {
+    const botId = new URL(url).searchParams.get("bot");
+    return {
+      ok: true,
+      bot: {
+        id: botId,
+        user_id: botId === "B_ASSISTANT" ? "U_BOT" : "U_OTHER_BOT",
+      },
+    };
+  }
   // Default envelope for any other method the adapter might call.
   return { ok: true };
 }
@@ -319,4 +333,23 @@ describe("Slack adapter token routing", () => {
       account: "workspace-b",
     });
   });
+
+  test("bot id resolver maps Slack bot ids through the bot token", async () => {
+    const resolved = await slackProvider.resolveConnection!();
+    expect(resolved).toBeUndefined();
+
+    const userId = await resolveSlackBotUserId(undefined, "B_ASSISTANT");
+    const repeatedUserId = await resolveSlackBotUserId(
+      undefined,
+      "B_ASSISTANT",
+    );
+
+    expect(userId).toBe("U_BOT");
+    expect(repeatedUserId).toBe("U_BOT");
+    const botsInfoCalls = captured.filter((c) => c.url.includes("/bots.info"));
+    expect(botsInfoCalls).toHaveLength(2);
+    for (const call of botsInfoCalls) {
+      expect(call.authorization).toBe(`Bearer ${BOT_TOKEN}`);
+    }
+  });
 });

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

@@ -5,6 +5,8 @@
  * implements the MessagingProvider interface.
  */
 
+import { createHash } from "node:crypto";
+
 import {
   buildSlackUserLabelMap,
   renderSlackTextForModel,
@@ -35,10 +37,32 @@ import type {
   SlackConversation,
   SlackMessage,
   SlackSearchMatch,
+  SlackUser,
 } from "./types.js";
 
-// Cache user display names to avoid repeated API calls within a session
-const userNameCache = new Map<string, string>();
+interface NormalizedSlackUserInfo {
+  displayName: string;
+  timezone?: string;
+  timezoneLabel?: string;
+  timezoneOffsetSeconds?: number;
+}
+
+interface SlackUserInfoLookupResult {
+  info: NormalizedSlackUserInfo;
+  cacheable: boolean;
+}
+
+const PERMANENT_USER_INFO_SLACK_ERRORS = new Set([
+  "account_inactive",
+  "ekm_access_denied",
+  "missing_scope",
+  "not_allowed_token_type",
+  "user_not_found",
+  "user_not_visible",
+]);
+
+// Cache normalized Slack user facts to avoid repeated API calls within a session.
+const userInfoCache = new Map<string, Promise<SlackUserInfoLookupResult>>();
 
 /**
  * Cached auth resolved during resolveConnection(), split by direction.
@@ -58,6 +82,7 @@ const userNameCache = new Map<string, string>();
  */
 let _cachedSlackWriteAuth: OAuthConnection | string | null = null;
 let _cachedSlackReadAuth: OAuthConnection | string | null = null;
+const botUserIdByBotIdCache = new Map<string, string>();
 
 /**
  * Get the Slack auth value to pass to Slack client functions.
@@ -123,6 +148,32 @@ export async function withSlackBotToken<T>(
   return auth.withToken(fn);
 }
 
+export async function resolveSlackBotUserId(
+  account: string | undefined,
+  botId: string,
+): Promise<string | null> {
+  const trimmedBotId = botId.trim();
+  if (!trimmedBotId) return null;
+
+  const cacheKey = account ? `${account}:${trimmedBotId}` : null;
+  if (cacheKey && botUserIdByBotIdCache.has(cacheKey)) {
+    return botUserIdByBotIdCache.get(cacheKey) ?? null;
+  }
+
+  const resolvedUserId = await withSlackBotToken(account, async (token) => {
+    const resp = await slack.botsInfo(token, trimmedBotId);
+    const userId = resp.bot.user_id?.trim();
+    return userId && userId.length > 0 ? userId : null;
+  });
+  if (resolvedUserId) {
+    if (cacheKey) {
+      botUserIdByBotIdCache.set(cacheKey, resolvedUserId);
+    }
+    return resolvedUserId;
+  }
+  return null;
+}
+
 /**
  * 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
@@ -159,20 +210,46 @@ async function resolveUserName(
   auth: OAuthConnection | string,
   userId: string,
 ): Promise<string> {
-  if (!userId) return "unknown";
-  const cached = userNameCache.get(userId);
-  if (cached) return cached;
+  return (await resolveUserInfo(auth, userId)).displayName;
+}
+
+async function resolveUserInfo(
+  auth: OAuthConnection | string,
+  userId: string,
+): Promise<NormalizedSlackUserInfo> {
+  if (!userId) return { displayName: "unknown" };
+  const cacheKey = slackUserInfoCacheKey(auth, userId);
+  const cached = userInfoCache.get(cacheKey);
+  if (cached) return (await cached).info;
+
+  const resolved = resolveUserInfoUncached(auth, userId).then(
+    (result) => {
+      if (!result.cacheable) {
+        userInfoCache.delete(cacheKey);
+      }
+      return result;
+    },
+    (err) => {
+      userInfoCache.delete(cacheKey);
+      throw err;
+    },
+  );
+  userInfoCache.set(cacheKey, resolved);
+  return (await resolved).info;
+}
 
-  // Check contacts DB for a persistent cache hit
+async function resolveUserInfoUncached(
+  auth: OAuthConnection | string,
+  userId: string,
+): Promise<SlackUserInfoLookupResult> {
+  let contactDisplayName: string | undefined;
   try {
     const result = findContactChannel({
       channelType: "slack",
       externalUserId: userId,
     });
     if (result) {
-      const name = result.contact.displayName;
-      userNameCache.set(userId, name);
-      return name;
+      contactDisplayName = result.contact.displayName;
     }
   } catch {
     // Contact lookup failures are non-fatal — fall through to API
@@ -180,18 +257,86 @@ async function resolveUserName(
 
   try {
     const resp = await slack.userInfo(auth, userId);
-    const name =
-      resp.user.profile?.display_name ||
-      resp.user.profile?.real_name ||
-      resp.user.real_name ||
-      resp.user.name;
-    userNameCache.set(userId, name);
-    return name;
-  } catch {
-    return userId;
+    return {
+      info: normalizeSlackUserInfo(resp.user, contactDisplayName),
+      cacheable: true,
+    };
+  } catch (err) {
+    return {
+      info: { displayName: contactDisplayName ?? userId },
+      cacheable: isPermanentSlackUserInfoFailure(err),
+    };
   }
 }
 
+function isPermanentSlackUserInfoFailure(err: unknown): boolean {
+  return (
+    err instanceof SlackApiError &&
+    PERMANENT_USER_INFO_SLACK_ERRORS.has(err.slackError)
+  );
+}
+
+function slackUserInfoCacheKey(
+  auth: OAuthConnection | string,
+  userId: string,
+): string {
+  const authScope =
+    typeof auth === "string"
+      ? `token:${createHash("sha256").update(auth).digest("hex")}`
+      : `connection:${auth.id}:${auth.accountInfo ?? ""}`;
+  return `${authScope}:user:${userId}`;
+}
+
+function normalizeSlackUserInfo(
+  user: SlackUser,
+  contactDisplayName: string | undefined,
+): NormalizedSlackUserInfo {
+  const displayName =
+    contactDisplayName ||
+    user.profile?.display_name ||
+    user.profile?.real_name ||
+    user.real_name ||
+    user.name ||
+    user.id;
+  const timezone = trimNonEmpty(user.tz);
+  const timezoneLabel = trimNonEmpty(user.tz_label);
+  const timezoneOffsetSeconds =
+    typeof user.tz_offset === "number" && Number.isFinite(user.tz_offset)
+      ? user.tz_offset
+      : undefined;
+  return {
+    displayName,
+    ...(timezone ? { timezone } : {}),
+    ...(timezoneLabel ? { timezoneLabel } : {}),
+    ...(timezoneOffsetSeconds !== undefined ? { timezoneOffsetSeconds } : {}),
+  };
+}
+
+function trimNonEmpty(value: unknown): string | undefined {
+  if (typeof value !== "string") return undefined;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+
+export function __resetSlackUserInfoCacheForTests(): void {
+  userInfoCache.clear();
+}
+
+function slackUserInfoMetadata(
+  userInfo: NormalizedSlackUserInfo | undefined,
+): Record<string, unknown> {
+  if (!userInfo) return {};
+  return {
+    ...(userInfo.timezone ? { actorTimezone: userInfo.timezone } : {}),
+    ...(userInfo.timezoneLabel
+      ? { actorTimezoneLabel: userInfo.timezoneLabel }
+      : {}),
+    ...(userInfo.timezoneOffsetSeconds !== undefined
+      ? { actorTimezoneOffsetSeconds: userInfo.timezoneOffsetSeconds }
+      : {}),
+  };
+}
+
 function mapConversationType(conv: SlackConversation): Conversation["type"] {
   if (conv.is_im) return "dm";
   if (conv.is_mpim) return "group";
@@ -249,19 +394,25 @@ function mapSlackFiles(files: SlackMessage["files"]):
 function mapMessage(
   msg: SlackMessage,
   channelId: string,
-  senderName: string,
+  senderInfo: NormalizedSlackUserInfo,
   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.
+  // row to a `bot_id` with no user. Backfill callers use this flag for
+  // bot-specific filtering while preserving real bot rows as channel replay.
   const isBot =
     msg.subtype === "bot_message" || (msg.bot_id != null && !msg.user);
   const slackFiles = mapSlackFiles(msg.files);
+  const slackBotId = msg.bot_id?.trim();
+  const userMetadata = slackUserInfoMetadata(msg.user ? senderInfo : undefined);
+  const hasUserMetadata = Object.keys(userMetadata).length > 0;
   return {
     id: msg.ts,
     conversationId: channelId,
-    sender: { id: msg.user ?? msg.bot_id ?? "unknown", name: senderName },
+    sender: {
+      id: msg.user ?? msg.bot_id ?? "unknown",
+      name: senderInfo.displayName,
+    },
     text: renderedText,
     timestamp: parseFloat(msg.ts) * 1000,
     threadId: msg.thread_ts,
@@ -269,11 +420,13 @@ function mapMessage(
     platform: "slack",
     reactions: msg.reactions?.map((r) => ({ name: r.name, count: r.count })),
     hasAttachments: (msg.files?.length ?? 0) > 0,
-    ...(isBot || slackFiles
+    ...(isBot || slackFiles || hasUserMetadata
       ? {
           metadata: {
             ...(isBot ? { isBot: true } : {}),
+            ...(slackBotId ? { slackBotId } : {}),
             ...(slackFiles ? { slackFiles } : {}),
+            ...userMetadata,
           },
         }
       : {}),
@@ -307,12 +460,12 @@ async function mapSlackMessages(
   );
   const messages: Message[] = [];
   for (const msg of slackMessages) {
-    const name = await resolveUserName(auth, msg.user ?? "");
+    const senderInfo = await resolveUserInfo(auth, msg.user ?? "");
     messages.push(
       mapMessage(
         msg,
         channelId,
-        name,
+        senderInfo,
         renderSlackTextForModel(msg.text, { userLabels }),
       ),
     );

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

@@ -0,0 +1,54 @@
+import { afterAll, afterEach, describe, expect, mock, test } from "bun:test";
+
+const BOT_TOKEN = "xoxb-test";
+
+mock.module("../../../security/secure-keys.js", () => ({
+  getSecureKeyAsync: async () => BOT_TOKEN,
+}));
+
+const { getSlackConversationInfo } = await import("./api.js");
+
+const originalFetch = globalThis.fetch;
+
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+});
+
+afterAll(() => {
+  mock.restore();
+});
+
+describe("getSlackConversationInfo", () => {
+  test("calls conversations.info with GET query params", async () => {
+    let capturedUrl: string | undefined;
+    let capturedInit: RequestInit | undefined;
+
+    globalThis.fetch = mock(async (input, init) => {
+      capturedUrl = String(input);
+      capturedInit = init;
+      return new Response(
+        JSON.stringify({
+          ok: true,
+          channel: {
+            id: "C123",
+            name: "engineering",
+          },
+        }),
+        { status: 200, headers: { "content-type": "application/json" } },
+      );
+    }) as unknown as typeof fetch;
+
+    const info = await getSlackConversationInfo("C123");
+
+    expect(info).toEqual({ id: "C123", name: "engineering" });
+    expect(capturedUrl).toBeDefined();
+    const url = new URL(capturedUrl!);
+    expect(url.pathname).toBe("/api/conversations.info");
+    expect(url.searchParams.get("channel")).toBe("C123");
+    expect(capturedInit?.method).toBe("GET");
+    expect(capturedInit?.body).toBeUndefined();
+    expect(capturedInit?.headers).toEqual({
+      Authorization: `Bearer ${BOT_TOKEN}`,
+    });
+  });
+});

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

@@ -53,9 +53,7 @@ const SLACK_ERROR_CODE_MAP: Record<string, SlackErrorCategory> = {
   invalid_blocks: "client_error",
 };
 
-function classifySlackError(
-  errorCode: string | undefined,
-): SlackErrorCategory {
+function classifySlackError(errorCode: string | undefined): SlackErrorCategory {
   if (!errorCode) return "unknown";
   return SLACK_ERROR_CODE_MAP[errorCode] ?? "unknown";
 }
@@ -98,6 +96,20 @@ interface SlackApiResponse {
   file_id?: string;
 }
 
+interface SlackConversationsInfoResponse extends SlackApiResponse {
+  channel?: {
+    id?: unknown;
+    name?: unknown;
+    name_normalized?: unknown;
+  };
+}
+
+export interface SlackConversationInfo {
+  id: string;
+  name?: string;
+  nameNormalized?: string;
+}
+
 /**
  * Call a Slack Web API method with rate-limit retries.
  *
@@ -178,6 +190,110 @@ export async function callSlackApi(
   );
 }
 
+/**
+ * Call a Slack Web API read method with query parameters.
+ */
+async function callSlackApiGet(
+  method: string,
+  params: URLSearchParams,
+): Promise<SlackApiResponse> {
+  const botToken = await resolveBotToken();
+  const query = params.toString();
+  const url = `${SLACK_API_BASE}/${method}${query ? `?${query}` : ""}`;
+
+  let lastError: string | undefined;
+
+  for (let attempt = 0; attempt <= SLACK_MAX_RATE_LIMIT_RETRIES; attempt++) {
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${botToken}`,
+      },
+    });
+
+    if (response.status === 429) {
+      if (attempt >= SLACK_MAX_RATE_LIMIT_RETRIES) {
+        throw new Error("Slack rate limit exceeded after retries");
+      }
+      const retryAfter =
+        parseInt(response.headers.get("Retry-After") ?? "", 10) ||
+        SLACK_DEFAULT_RETRY_AFTER_S;
+      log.warn({ method, retryAfter, attempt }, "Slack rate limited, retrying");
+      await new Promise((r) => setTimeout(r, retryAfter * 1000));
+      continue;
+    }
+
+    if (response.status >= 500) {
+      if (attempt >= SLACK_MAX_RATE_LIMIT_RETRIES) {
+        throw new Error(
+          `Slack ${method} failed with status ${response.status} after retries`,
+        );
+      }
+      log.warn(
+        { method, status: response.status, attempt },
+        "Slack 5xx error, retrying",
+      );
+      await new Promise((r) =>
+        setTimeout(r, SLACK_DEFAULT_RETRY_AFTER_S * 1000),
+      );
+      continue;
+    }
+
+    const data = (await response.json()) as SlackApiResponse;
+
+    if (!data.ok) {
+      lastError = data.error;
+      const category = classifySlackError(data.error);
+
+      if (category === "rate_limit" && attempt < SLACK_MAX_RATE_LIMIT_RETRIES) {
+        log.warn(
+          { method, slackError: data.error, attempt },
+          "Slack rate limited (body), retrying",
+        );
+        await new Promise((r) =>
+          setTimeout(r, SLACK_DEFAULT_RETRY_AFTER_S * 1000),
+        );
+        continue;
+      }
+
+      throw new SlackApiError(data.error);
+    }
+
+    return data;
+  }
+
+  throw new Error(
+    `Slack ${method} failed after retries: ${lastError ?? "unknown"}`,
+  );
+}
+
+function normalizeSlackString(value: unknown): string | undefined {
+  if (typeof value !== "string") return undefined;
+  const trimmed = value.trim();
+  return trimmed || undefined;
+}
+
+export async function getSlackConversationInfo(
+  channelId: string,
+): Promise<SlackConversationInfo | null> {
+  const data = (await callSlackApiGet(
+    "conversations.info",
+    new URLSearchParams({ channel: channelId }),
+  )) as SlackConversationsInfoResponse;
+
+  const id = normalizeSlackString(data.channel?.id);
+  if (!id) return null;
+
+  const name = normalizeSlackString(data.channel?.name);
+  const nameNormalized = normalizeSlackString(data.channel?.name_normalized);
+
+  return {
+    id,
+    ...(name ? { name } : {}),
+    ...(nameNormalized ? { nameNormalized } : {}),
+  };
+}
+
 /**
  * Call a Slack Web API method with form-urlencoded body.
  */

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

@@ -14,6 +14,7 @@ import type { OAuthConnection } from "../../../oauth/connection.js";
 import type {
   SlackApiResponse,
   SlackAuthTestResponse,
+  SlackBotsInfoResponse,
   SlackConversationHistoryResponse,
   SlackConversationMarkResponse,
   SlackConversationRepliesResponse,
@@ -286,6 +287,17 @@ export async function authTest(
   return request<SlackAuthTestResponse>(connectionOrToken, "auth.test");
 }
 
+export async function botsInfo(
+  connectionOrToken: OAuthConnection | string,
+  botId: string,
+  teamId?: string,
+): Promise<SlackBotsInfoResponse> {
+  return request<SlackBotsInfoResponse>(connectionOrToken, "bots.info", {
+    bot: botId,
+    team_id: teamId,
+  });
+}
+
 export async function listConversations(
   connectionOrToken: OAuthConnection | string,
   types = "public_channel,private_channel,mpim,im",

package/src/messaging/providers/slack/deep-link.ts

@@ -40,13 +40,31 @@ export function buildSlackWebMessageUrl(params: {
   teamUrl?: string | null;
   channelId: string;
   messageTs: string;
+  threadTs?: string;
 }): string | undefined {
   const teamUrl = normalizeSlackTeamUrl(params.teamUrl);
   if (!teamUrl) return undefined;
 
-  return `${teamUrl}/archives/${encodeURIComponent(
+  const baseUrl = `${teamUrl}/archives/${encodeURIComponent(
     params.channelId,
   )}/p${formatSlackPermalinkTimestamp(params.messageTs)}`;
+  if (!params.threadTs) return baseUrl;
+
+  const search = new URLSearchParams({
+    thread_ts: params.threadTs,
+    cid: params.channelId,
+  });
+  return `${baseUrl}?${search.toString()}`;
+}
+
+export function buildSlackWebChannelUrl(params: {
+  teamUrl?: string | null;
+  channelId: string;
+}): string | undefined {
+  const teamUrl = normalizeSlackTeamUrl(params.teamUrl);
+  if (!teamUrl) return undefined;
+
+  return `${teamUrl}/archives/${encodeURIComponent(params.channelId)}`;
 }
 
 export function buildSlackMessageDeepLinks(params: {
@@ -54,6 +72,7 @@ export function buildSlackMessageDeepLinks(params: {
   teamUrl?: string | null;
   channelId: string;
   messageTs: string;
+  threadTs?: string;
 }): SlackMessageDeepLinks | undefined {
   const appUrl = buildSlackAppMessageUrl(params);
   const webUrl = buildSlackWebMessageUrl(params);

package/src/messaging/providers/slack/message-metadata.test.ts

@@ -1,6 +1,8 @@
 import { describe, expect, test } from "bun:test";
 
 import {
+  buildSlackTimezoneMetadata,
+  formatSlackTimezoneLabel,
   mergeSlackMetadata,
   readSlackMetadata,
   readSlackMetadataFromMessageMetadata,
@@ -8,6 +10,42 @@ import {
   writeSlackMetadata,
 } from "./message-metadata.js";
 
+describe("formatSlackTimezoneLabel", () => {
+  test("uses compact common labels for IANA timezones", () => {
+    expect(formatSlackTimezoneLabel("America/Denver")).toBe("MT");
+    expect(formatSlackTimezoneLabel("America/New_York")).toBe("ET");
+  });
+
+  test("compacts persisted Slack profile labels before falling back to timezone", () => {
+    expect(
+      formatSlackTimezoneLabel("America/New_York", {
+        persistedLabel: "Eastern Time",
+      }),
+    ).toBe("ET");
+  });
+});
+
+describe("buildSlackTimezoneMetadata", () => {
+  test("copies only populated Slack timezone fields", () => {
+    expect(
+      buildSlackTimezoneMetadata({
+        actorTimezone: " America/New_York ",
+        actorTimezoneLabel: " ET ",
+        actorTimezoneOffsetSeconds: -18_000,
+        timestampTimezone: "America/New_York",
+        timestampTimezoneLabel: "",
+        speakerTimezoneLabel: " Eastern Time ",
+      }),
+    ).toEqual({
+      actorTimezone: "America/New_York",
+      actorTimezoneLabel: "ET",
+      actorTimezoneOffsetSeconds: -18_000,
+      timestampTimezone: "America/New_York",
+      speakerTimezoneLabel: "Eastern Time",
+    });
+  });
+});
+
 describe("readSlackMetadata", () => {
   test("tolerates null and undefined", () => {
     expect(readSlackMetadata(null)).toBeNull();
@@ -62,9 +100,17 @@ describe("readSlackMetadata", () => {
       eventKind: "message",
       editedAt: "not-a-number",
     });
+    const badChannelName = JSON.stringify({
+      source: "slack",
+      channelId: "C123",
+      channelName: 42,
+      channelTs: "1700000000.000100",
+      eventKind: "message",
+    });
     expect(readSlackMetadata(badThreadTs)).toBeNull();
     expect(readSlackMetadata(badReactionOp)).toBeNull();
     expect(readSlackMetadata(badEditedAt)).toBeNull();
+    expect(readSlackMetadata(badChannelName)).toBeNull();
   });
 
   test("strips unknown top-level keys from the returned object", () => {
@@ -111,6 +157,7 @@ describe("readSlackMetadata", () => {
     const meta: SlackMessageMetadata = {
       source: "slack",
       channelId: "C123",
+      channelName: "engineering",
       channelTs: "1700000000.000100",
       threadTs: "1699999999.000000",
       displayName: "Alice",
@@ -174,6 +221,7 @@ describe("writeSlackMetadata", () => {
     const meta: SlackMessageMetadata = {
       source: "slack",
       channelId: "C123",
+      channelName: "engineering",
       channelTs: "1700000000.000100",
       threadTs: "1699999999.000000",
       displayName: "Alice",