@vellumai/assistant 0.7.0 → 0.7.2

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 () => {

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

@@ -23,6 +23,12 @@ const log = getLogger("slack-backfill");
 
 const DEFAULT_LIMIT = 50;
 
+export interface SlackBackfillWindowPage {
+  messages: Message[];
+  hasMore: boolean;
+  nextCursor?: string;
+}
+
 function isChannelNotFound(err: unknown): boolean {
   const msg = err instanceof Error ? err.message : String(err);
   return /channel_not_found/i.test(msg);
@@ -41,31 +47,103 @@ export async function backfillThread(
   threadTs: string,
   opts?: { limit?: number; account?: string },
 ): Promise<Message[]> {
+  return backfillThreadWindow(channelId, threadTs, opts);
+}
+
+/**
+ * Fetch a bounded window of messages in a Slack thread.
+ *
+ * `after` and `before` are passed through to Slack as `oldest` and `latest`;
+ * callers can also pass a Slack pagination cursor when continuing a bounded
+ * scan. Returns `[]` on transient errors; rethrows `channel_not_found`.
+ */
+export async function backfillThreadWindow(
+  channelId: string,
+  threadTs: string,
+  opts?: {
+    limit?: number;
+    after?: string;
+    before?: string;
+    cursor?: string;
+    account?: string;
+  },
+): Promise<Message[]> {
+  const page = await backfillThreadWindowPage(channelId, threadTs, opts);
+  return page.messages;
+}
+
+/**
+ * Fetch a bounded Slack thread page and preserve Slack pagination metadata.
+ *
+ * This is the preferred helper for callers that need to know whether a
+ * bounded window fully covered the requested range. The older
+ * `backfillThreadWindow` wrapper intentionally returns only messages for
+ * existing consumers.
+ */
+export async function backfillThreadWindowPage(
+  channelId: string,
+  threadTs: string,
+  opts?: {
+    limit?: number;
+    after?: string;
+    before?: string;
+    cursor?: string;
+    account?: string;
+  },
+): Promise<SlackBackfillWindowPage> {
   const limit = opts?.limit ?? DEFAULT_LIMIT;
   try {
     const connection = await slackProvider.resolveConnection?.(opts?.account);
-    if (!slackProvider.getThreadReplies) {
+    if (
+      !slackProvider.getThreadRepliesPage &&
+      !slackProvider.getThreadReplies
+    ) {
       log.warn(
         { channelId, threadTs },
-        "Slack provider does not implement getThreadReplies — returning []",
+        "Slack provider does not implement thread reply reads — returning []",
       );
-      return [];
+      return { messages: [], hasMore: false };
     }
-    return await slackProvider.getThreadReplies(
-      connection,
-      channelId,
-      threadTs,
-      { limit },
-    );
+    const historyOptions = {
+      limit,
+      ...(opts?.after !== undefined ? { after: opts.after } : {}),
+      ...(opts?.before !== undefined ? { before: opts.before } : {}),
+      ...(opts?.cursor !== undefined ? { cursor: opts.cursor } : {}),
+    };
+    if (slackProvider.getThreadRepliesPage) {
+      return await slackProvider.getThreadRepliesPage(
+        connection,
+        channelId,
+        threadTs,
+        historyOptions,
+      );
+    }
+    return {
+      messages: await slackProvider.getThreadReplies!(
+        connection,
+        channelId,
+        threadTs,
+        historyOptions,
+      ),
+      hasMore: false,
+    };
   } catch (err) {
     if (isChannelNotFound(err)) {
       throw err;
     }
     log.warn(
-      { channelId, threadTs, account: opts?.account, err },
+      {
+        channelId,
+        threadTs,
+        after: opts?.after,
+        before: opts?.before,
+        cursor: opts?.cursor,
+        account: opts?.account,
+        err,
+      },
       "Slack thread backfill failed — returning []",
     );
-    return [];
+    return { messages: [], hasMore: false };
   }
 }
 

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

@@ -14,19 +14,12 @@ import type { OAuthConnection } from "../../../oauth/connection.js";
 import type {
   SlackApiResponse,
   SlackAuthTestResponse,
-  SlackChatDeleteResponse,
-  SlackChatUpdateResponse,
   SlackConversationHistoryResponse,
-  SlackConversationInfoResponse,
-  SlackConversationJoinResponse,
-  SlackConversationLeaveResponse,
   SlackConversationMarkResponse,
   SlackConversationRepliesResponse,
   SlackConversationsListResponse,
   SlackConversationsOpenResponse,
-  SlackPostEphemeralResponse,
   SlackPostMessageResponse,
-  SlackReactionAddResponse,
   SlackSearchMessagesResponse,
   SlackUserInfoResponse,
 } from "./types.js";
@@ -310,19 +303,6 @@ export async function listConversations(
   );
 }
 
-export async function conversationInfo(
-  connectionOrToken: OAuthConnection | string,
-  channel: string,
-): Promise<SlackConversationInfoResponse> {
-  return request<SlackConversationInfoResponse>(
-    connectionOrToken,
-    "conversations.info",
-    {
-      channel,
-    },
-  );
-}
-
 export async function conversationHistory(
   connectionOrToken: OAuthConnection | string,
   channel: string,
@@ -330,6 +310,7 @@ export async function conversationHistory(
   latest?: string,
   oldest?: string,
   cursor?: string,
+  inclusive?: boolean,
 ): Promise<SlackConversationHistoryResponse> {
   return request<SlackConversationHistoryResponse>(
     connectionOrToken,
@@ -340,6 +321,7 @@ export async function conversationHistory(
       latest,
       oldest,
       cursor,
+      inclusive: inclusive === undefined ? undefined : String(inclusive),
     },
   );
 }
@@ -349,6 +331,10 @@ export async function conversationReplies(
   channel: string,
   ts: string,
   limit = 50,
+  latest?: string,
+  oldest?: string,
+  inclusive?: boolean,
+  cursor?: string,
 ): Promise<SlackConversationRepliesResponse> {
   return request<SlackConversationRepliesResponse>(
     connectionOrToken,
@@ -357,6 +343,10 @@ export async function conversationReplies(
       channel,
       ts,
       limit: String(limit),
+      latest,
+      oldest,
+      inclusive: inclusive === undefined ? undefined : String(inclusive),
+      cursor,
     },
   );
 }
@@ -426,29 +416,6 @@ export async function postMessage(
   );
 }
 
-/**
- * Post an ephemeral message visible only to the specified user.
- *
- * Ephemeral messages are fire-and-forget: they cannot be edited or deleted
- * after posting, and they disappear when the user reloads the Slack client.
- */
-export async function postEphemeral(
-  connectionOrToken: OAuthConnection | string,
-  channel: string,
-  user: string,
-  text: string,
-  threadTs?: string,
-): Promise<SlackPostEphemeralResponse> {
-  const body: Record<string, unknown> = { channel, user, text };
-  if (threadTs) body.thread_ts = threadTs;
-  return request<SlackPostEphemeralResponse>(
-    connectionOrToken,
-    "chat.postEphemeral",
-    undefined,
-    body,
-  );
-}
-
 export async function searchMessages(
   connectionOrToken: OAuthConnection | string,
   query: string,
@@ -465,84 +432,3 @@ export async function searchMessages(
     },
   );
 }
-
-export async function addReaction(
-  connectionOrToken: OAuthConnection | string,
-  channel: string,
-  timestamp: string,
-  name: string,
-): Promise<SlackReactionAddResponse> {
-  return request<SlackReactionAddResponse>(
-    connectionOrToken,
-    "reactions.add",
-    undefined,
-    {
-      channel,
-      timestamp,
-      name,
-    },
-  );
-}
-
-export async function updateMessage(
-  connectionOrToken: OAuthConnection | string,
-  channel: string,
-  ts: string,
-  text: string,
-): Promise<SlackChatUpdateResponse> {
-  return request<SlackChatUpdateResponse>(
-    connectionOrToken,
-    "chat.update",
-    undefined,
-    {
-      channel,
-      ts,
-      text,
-    },
-  );
-}
-
-export async function deleteMessage(
-  connectionOrToken: OAuthConnection | string,
-  channel: string,
-  ts: string,
-): Promise<SlackChatDeleteResponse> {
-  return request<SlackChatDeleteResponse>(
-    connectionOrToken,
-    "chat.delete",
-    undefined,
-    {
-      channel,
-      ts,
-    },
-  );
-}
-
-export async function joinConversation(
-  connectionOrToken: OAuthConnection | string,
-  channel: string,
-): Promise<SlackConversationJoinResponse> {
-  return request<SlackConversationJoinResponse>(
-    connectionOrToken,
-    "conversations.join",
-    undefined,
-    {
-      channel,
-    },
-  );
-}
-
-export async function leaveConversation(
-  connectionOrToken: OAuthConnection | string,
-  channel: string,
-): Promise<SlackConversationLeaveResponse> {
-  return request<SlackConversationLeaveResponse>(
-    connectionOrToken,
-    "conversations.leave",
-    undefined,
-    {
-      channel,
-    },
-  );
-}
-

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

@@ -11,8 +11,10 @@ import { z } from "zod";
  * Slack-only blob for fresh writes; `mergeSlackMetadata` patches Slack fields
  * while preserving unrelated keys on the existing JSON.
  *
- * This file is a pure library addition — no consumers wire into it yet; that
- * happens in later PRs of the slack-thread-aware-context plan.
+ * Slack transcript rendering and backfill paths persist and read this metadata
+ * to reconstruct thread order, reactions, edits, deletes, and lightweight
+ * Slack file markers. Transient late-join notices are current-turn runtime
+ * context only and do not become durable message metadata.
  */
 
 export type SlackEventKind = "message" | "reaction";
@@ -24,6 +26,12 @@ const slackReactionMetadataSchema = z.object({
   op: z.enum(["added", "removed"]),
 });
 
+const slackFileMetadataSchema = z.object({
+  id: z.string().optional(),
+  name: z.string(),
+  mimetype: z.string().optional(),
+});
+
 export const slackMessageMetadataSchema = z.object({
   source: z.literal("slack"),
   channelId: z.string(),
@@ -34,9 +42,11 @@ export const slackMessageMetadataSchema = z.object({
   reaction: slackReactionMetadataSchema.optional(),
   editedAt: z.number().optional(),
   deletedAt: z.number().optional(),
+  slackFiles: z.array(slackFileMetadataSchema).optional(),
 });
 
 export type SlackReactionMetadata = z.infer<typeof slackReactionMetadataSchema>;
+export type SlackFileMetadata = z.infer<typeof slackFileMetadataSchema>;
 export type SlackMessageMetadata = z.infer<typeof slackMessageMetadataSchema>;
 
 /**

package/src/messaging/providers/slack/render-transcript.test.ts

@@ -16,6 +16,7 @@ import {
   parentAlias,
   type RenderableSlackMessage,
   renderSlackTranscript,
+  renderSlackTranscriptWithProvenance,
 } from "./render-transcript.js";
 
 // ── helpers ──────────────────────────────────────────────────────────────────
@@ -44,6 +45,7 @@ function userMsg(
     deletedAt?: number;
     role?: "user" | "assistant";
     createdAt?: number;
+    slackFiles?: Array<{ id?: string; name: string; mimetype?: string }>;
   } = {},
 ): RenderableSlackMessage {
   return {
@@ -59,6 +61,7 @@ function userMsg(
       eventKind: "message",
       editedAt: opts.editedAt,
       deletedAt: opts.deletedAt,
+      slackFiles: opts.slackFiles,
     },
   };
 }
@@ -242,6 +245,59 @@ describe("renderSlackTranscript — basics", () => {
     expect(out).toEqual([textMsg("assistant", "yo 👋")]);
   });
 
+  test("backfilled Slack file metadata renders as concise attachment markers", () => {
+    const out = renderSlackTranscript([
+      userMsg(TS_14_25, "@alice", "shared the draft", {
+        slackFiles: [
+          { id: "F123", name: "requirements.txt", mimetype: "text/plain" },
+        ],
+      }),
+      userMsg(TS_14_26, "@bob", "", {
+        slackFiles: [{ name: "diagram.png", mimetype: "image/png" }],
+      }),
+    ]);
+
+    expect(out).toEqual([
+      textMsg(
+        "user",
+        "[11/14/23 14:25 @alice]: shared the draft [attached file: requirements.txt, text/plain]",
+      ),
+      textMsg(
+        "user",
+        "[11/14/23 14:26 @bob]: [attached file: diagram.png, image/png]",
+      ),
+    ]);
+  });
+
+  test("provenance follows the rendered sequence after orphan filtering", () => {
+    const out = renderSlackTranscriptWithProvenance([
+      userMsg(TS_14_25, "@alice", "kept"),
+      {
+        ...userMsg(TS_14_26, null, "", { role: "assistant" }),
+        contentBlocks: [
+          { type: "tool_use", id: "tool-1", name: "lookup", input: {} },
+        ],
+      },
+      userMsg(TS_14_28, "@bob", "also kept"),
+    ]);
+
+    expect(extractTagLineTexts(out.messages)).toEqual([
+      "[11/14/23 14:25 @alice]: kept",
+      "[11/14/23 14:28 @bob]: also kept",
+    ]);
+    expect(out.renderedMessages.map((entry) => entry.message)).toEqual(
+      out.messages,
+    );
+    expect(out.renderedMessages.map((entry) => entry.sourceChannelTs)).toEqual([
+      TS_14_25,
+      TS_14_28,
+    ]);
+    expect(out.renderedMessages.map((entry) => entry.sourceChannelTs)).toEqual([
+      TS_14_25,
+      TS_14_28,
+    ]);
+  });
+
   test("omits sender label for user-role message with null senderLabel (no displayName)", () => {
     const out = renderSlackTranscript([userMsg(TS_14_25, null, "yo")]);
     expect(out).toEqual([textMsg("user", "[11/14/23 14:25]: yo")]);