@vellumai/assistant 0.7.0 → 0.7.1

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")]);

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

@@ -58,6 +58,18 @@ export interface RenderOptions {
 
 const DEFAULT_MAX_REACTIONS = 5;
 
+export interface RenderedSlackTranscript {
+  /** Rendered messages paired with the Slack source timestamp they represent. */
+  readonly renderedMessages: readonly RenderedSlackTranscriptMessage[];
+  /** Convenience projection of `renderedMessages[].message`. */
+  readonly messages: Message[];
+}
+
+export interface RenderedSlackTranscriptMessage {
+  readonly message: Message;
+  readonly sourceChannelTs: string | null;
+}
+
 /**
  * Replayable Anthropic content-block types that we preserve verbatim from a
  * persisted row when rendering the Slack chronological transcript.
@@ -146,6 +158,30 @@ function formatEpochMs(ms: number): string {
   return `${mo}/${da}/${yy} ${hh}:${mm}`;
 }
 
+function renderSlackFileMarkers(
+  files: SlackMessageMetadata["slackFiles"],
+): string {
+  if (!files || files.length === 0) return "";
+  return files
+    .map((file) => {
+      const name = file.name.replace(/\s+/g, " ").trim();
+      const mime = file.mimetype?.replace(/\s+/g, " ").trim();
+      return mime
+        ? `[attached file: ${name}, ${mime}]`
+        : `[attached file: ${name}]`;
+    })
+    .join(" ");
+}
+
+function appendSlackFileMarkers(
+  content: string,
+  files: SlackMessageMetadata["slackFiles"],
+): string {
+  const markers = renderSlackFileMarkers(files);
+  if (!markers) return content;
+  return content.length > 0 ? `${content} ${markers}` : markers;
+}
+
 /**
  * Sort key for chronological ordering.
  *
@@ -162,6 +198,25 @@ function sortKey(msg: RenderableSlackMessage): number {
   return msg.createdAt / 1000;
 }
 
+export function compareSlackTs(a: string, b: string): number {
+  const aNum = Number.parseFloat(a);
+  const bNum = Number.parseFloat(b);
+  if (Number.isFinite(aNum) && Number.isFinite(bNum) && aNum !== bNum) {
+    return aNum - bNum;
+  }
+  return a.localeCompare(b);
+}
+
+export function isSlackTsAfter(ts: string, watermarkTs: string): boolean {
+  return compareSlackTs(ts, watermarkTs) > 0;
+}
+
+function maxNullableSlackTs(a: string | null, b: string | null): string | null {
+  if (a === null) return b;
+  if (b === null) return a;
+  return compareSlackTs(a, b) >= 0 ? a : b;
+}
+
 /**
  * Render a single non-reaction message (post-upgrade or legacy) as one
  * tagged line.
@@ -197,7 +252,7 @@ function sortKey(msg: RenderableSlackMessage): number {
 function renderMessage(msg: RenderableSlackMessage): string {
   if (msg.role === "assistant") {
     if (msg.metadata?.deletedAt !== undefined) return "[deleted]";
-    return msg.content;
+    return appendSlackFileMarkers(msg.content, msg.metadata?.slackFiles);
   }
 
   const meta = msg.metadata;
@@ -222,7 +277,7 @@ function renderMessage(msg: RenderableSlackMessage): string {
   if (meta.editedAt !== undefined) {
     head += `, edited ${formatEpochMs(meta.editedAt)}`;
   }
-  head += `]: ${msg.content}`;
+  head += `]: ${appendSlackFileMarkers(msg.content, meta.slackFiles)}`;
   return head;
 }
 
@@ -342,7 +397,16 @@ export function renderSlackTranscript(
   messages: RenderableSlackMessage[],
   opts?: RenderOptions,
 ): Message[] {
-  if (messages.length === 0) return [];
+  return renderSlackTranscriptWithProvenance(messages, opts).messages;
+}
+
+export function renderSlackTranscriptWithProvenance(
+  messages: RenderableSlackMessage[],
+  opts?: RenderOptions,
+): RenderedSlackTranscript {
+  if (messages.length === 0) {
+    return { renderedMessages: [], messages: [] };
+  }
 
   const maxReactions = Math.max(
     1,
@@ -364,23 +428,37 @@ export function renderSlackTranscript(
   // reaches an event that is not an overflowing reaction for that target.
   const overflowAccumulator = new Map<
     string,
-    { excess: number; role: "user" | "assistant" }
+    {
+      excess: number;
+      role: "user" | "assistant";
+      sourceChannelTs: string | null;
+    }
   >();
 
   const trailerMessage = (
     target: string,
-    acc: { excess: number; role: "user" | "assistant" },
-  ): Message => ({
-    role: acc.role,
-    content: [
-      {
-        type: "text" as const,
-        text: `[…and ${acc.excess} more ${acc.excess === 1 ? "reaction" : "reactions"} to ${parentAlias(target)}]`,
-      },
-    ],
+    acc: {
+      excess: number;
+      role: "user" | "assistant";
+      sourceChannelTs: string | null;
+    },
+  ): RenderedSlackTranscriptMessage => ({
+    message: {
+      role: acc.role,
+      content: [
+        {
+          type: "text" as const,
+          text: `[…and ${acc.excess} more ${acc.excess === 1 ? "reaction" : "reactions"} to ${parentAlias(target)}]`,
+        },
+      ],
+    },
+    sourceChannelTs: acc.sourceChannelTs,
   });
 
-  const flushOverflowExcept = (out: Message[], keepTarget: string | null) => {
+  const flushOverflowExcept = (
+    out: RenderedSlackTranscriptMessage[],
+    keepTarget: string | null,
+  ) => {
     for (const target of Array.from(overflowAccumulator.keys())) {
       if (target === keepTarget) continue;
       const acc = overflowAccumulator.get(target)!;
@@ -389,7 +467,7 @@ export function renderSlackTranscript(
     }
   };
 
-  const out: Message[] = [];
+  const out: RenderedSlackTranscriptMessage[] = [];
   for (const m of sorted) {
     const meta = m.metadata;
     if (meta?.eventKind === "reaction" && meta.reaction) {
@@ -403,8 +481,11 @@ export function renderSlackTranscript(
         const line = renderReaction(m);
         if (line !== null) {
           out.push({
-            role: m.role,
-            content: [{ type: "text" as const, text: line }],
+            message: {
+              role: m.role,
+              content: [{ type: "text" as const, text: line }],
+            },
+            sourceChannelTs: meta.channelTs,
           });
         }
       } else {
@@ -414,8 +495,13 @@ export function renderSlackTranscript(
         const acc = overflowAccumulator.get(target) ?? {
           excess: 0,
           role: m.role,
+          sourceChannelTs: null,
         };
         acc.excess += 1;
+        acc.sourceChannelTs = maxNullableSlackTs(
+          acc.sourceChannelTs,
+          meta.channelTs,
+        );
         overflowAccumulator.set(target, acc);
       }
       continue;
@@ -426,15 +512,22 @@ export function renderSlackTranscript(
     const blocks = buildMessageContentBlocks(m, tagLine);
     if (blocks.length === 0) continue;
     out.push({
-      role: m.role,
-      content: blocks,
+      message: {
+        role: m.role,
+        content: blocks,
+      },
+      sourceChannelTs: meta?.channelTs ?? null,
     });
   }
 
   // End of the walk: flush any still-open overflow windows.
   flushOverflowExcept(out, null);
 
-  return filterOrphanToolPairs(out);
+  const filtered = filterOrphanToolPairs(out);
+  return {
+    renderedMessages: filtered,
+    messages: filtered.map((entry) => entry.message),
+  };
 }
 
 /**
@@ -459,18 +552,21 @@ export function renderSlackTranscript(
  * emitted as `{role, content: []}` — empty-content messages are also
  * rejected by the provider.
  */
-function filterOrphanToolPairs(messages: Message[]): Message[] {
+function filterOrphanToolPairs(
+  entries: RenderedSlackTranscriptMessage[],
+): RenderedSlackTranscriptMessage[] {
   const produced = new Set<string>();
   const consumed = new Set<string>();
-  for (const msg of messages) {
+  for (const { message: msg } of entries) {
     for (const b of msg.content) {
       if (b.type === "tool_use") produced.add(b.id);
       else if (b.type === "tool_result" || b.type === "web_search_tool_result")
         consumed.add(b.tool_use_id);
     }
   }
-  const out: Message[] = [];
-  for (const msg of messages) {
+  const out: RenderedSlackTranscriptMessage[] = [];
+  for (const entry of entries) {
+    const msg = entry.message;
     const kept: ContentBlock[] = [];
     for (const b of msg.content) {
       if (b.type === "tool_use" && !consumed.has(b.id)) continue;
@@ -481,7 +577,12 @@ function filterOrphanToolPairs(messages: Message[]): Message[] {
         continue;
       kept.push(b);
     }
-    if (kept.length > 0) out.push({ role: msg.role, content: kept });
+    if (kept.length > 0) {
+      out.push({
+        message: { role: msg.role, content: kept },
+        sourceChannelTs: entry.sourceChannelTs,
+      });
+    }
   }
   return out;
 }

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

@@ -59,6 +59,7 @@ export interface SlackConversationHistoryResponse extends SlackApiResponse {
 export interface SlackConversationRepliesResponse extends SlackApiResponse {
   messages: SlackMessage[];
   has_more: boolean;
+  response_metadata?: { next_cursor?: string };
 }
 
 export interface SlackUser {