@vellumai/assistant 0.6.4 → 0.6.5

package/src/memory/qdrant-client.ts

@@ -20,7 +20,13 @@ export interface QdrantClientConfig {
 }
 
 export interface QdrantPointPayload {
-  target_type: "segment" | "item" | "summary" | "media" | "graph_node";
+  target_type:
+    | "segment"
+    | "item"
+    | "summary"
+    | "media"
+    | "graph_node"
+    | "pkb_file";
   target_id: string;
   text: string;
   kind?: string;
@@ -496,6 +502,44 @@ export class VellumQdrantClient {
     }
   }
 
+  /**
+   * Delete all vectors matching target_type, payload path, and memory scope.
+   * Used to remove every chunk belonging to a single PKB file within a scope.
+   * The memory_scope_id filter is required — omitting it would wipe that
+   * path's chunks across every scope that happens to index the same relpath.
+   */
+  async deleteByTargetTypeAndPath(
+    targetType: string,
+    path: string,
+    memoryScopeId: string,
+  ): Promise<void> {
+    await this.ensureCollection();
+
+    const doDelete = () =>
+      this.client.delete(this.collection, {
+        wait: true,
+        filter: {
+          must: [
+            { key: "target_type", match: { value: targetType } },
+            { key: "path", match: { value: path } },
+            { key: "memory_scope_id", match: { value: memoryScopeId } },
+          ],
+        },
+      });
+
+    try {
+      await doDelete();
+    } catch (err) {
+      if (this.isCollectionMissing(err)) {
+        this.collectionReady = false;
+        await this.ensureCollection();
+        await doDelete();
+      } else {
+        throw err;
+      }
+    }
+  }
+
   async count(): Promise<number> {
     await this.ensureCollection();
 
@@ -605,6 +649,10 @@ export class VellumQdrantClient {
         field_name: "memory_scope_id",
         field_schema: "keyword",
       }),
+      this.client.createPayloadIndex(this.collection, {
+        field_name: "path",
+        field_schema: "keyword",
+      }),
     ]);
   }
 
@@ -640,6 +688,79 @@ export class VellumQdrantClient {
     });
   }
 
+  /**
+   * Scroll over every point with a given target_type and return the requested
+   * payload fields. Handles Qdrant's cursor-based pagination internally.
+   *
+   * Used by startup reconciliation (e.g. PKB filesystem diffing) to enumerate
+   * all indexed points for a target type without loading vectors.
+   */
+  async scrollByTargetType(
+    targetType: string,
+    options?: {
+      memoryScopeId?: string;
+      path?: string;
+      batchSize?: number;
+    },
+  ): Promise<Array<{ id: string; payload: Record<string, unknown> }>> {
+    await this.ensureCollection();
+
+    const batchSize = options?.batchSize ?? 256;
+    const must: Array<Record<string, unknown>> = [
+      { key: "target_type", match: { value: targetType } },
+    ];
+    if (options?.memoryScopeId) {
+      must.push({
+        key: "memory_scope_id",
+        match: { value: options.memoryScopeId },
+      });
+    }
+    if (options?.path) {
+      must.push({ key: "path", match: { value: options.path } });
+    }
+    const filter = {
+      must,
+      must_not: [{ key: "_meta", match: { value: true } }],
+    };
+
+    // Guard against a pathological pagination loop.
+    const maxIterations = 10_000;
+    const doScroll = async () => {
+      const out: Array<{ id: string; payload: Record<string, unknown> }> = [];
+      let offset: string | number | undefined = undefined;
+      for (let i = 0; i < maxIterations; i++) {
+        const result = await this.client.scroll(this.collection, {
+          filter,
+          limit: batchSize,
+          with_payload: true,
+          with_vector: false,
+          ...(offset !== undefined ? { offset } : {}),
+        });
+        for (const point of result.points) {
+          const id =
+            typeof point.id === "string" ? point.id : String(point.id);
+          const payload = (point.payload ?? {}) as Record<string, unknown>;
+          out.push({ id, payload });
+        }
+        const next = result.next_page_offset;
+        if (next == null) break;
+        offset = typeof next === "string" ? next : (next as number);
+      }
+      return out;
+    };
+
+    try {
+      return await doScroll();
+    } catch (err) {
+      if (this.isCollectionMissing(err)) {
+        this.collectionReady = false;
+        await this.ensureCollection();
+        return await doScroll();
+      }
+      throw err;
+    }
+  }
+
   private async findByTarget(
     targetType: string,
     targetId: string

package/src/memory/slack-thread-store.ts

@@ -62,6 +62,43 @@ export function setThreadTs(
   log.debug({ conversationId, channelId, threadTs }, "Thread mapping created");
 }
 
+/**
+ * Read-side accessor for the in-memory thread mapping. Returns the
+ * `threadTs` previously associated with this conversation via
+ * {@link setThreadTs}, or `null` if no mapping exists. Does not bump
+ * `lastUsedAt` or otherwise mutate the entry — pure lookup.
+ */
+export function getThreadTs(conversationId: string): string | null {
+  const mapping = threadMappings.get(conversationId);
+  return mapping ? mapping.threadTs : null;
+}
+
+/**
+ * Read both `threadTs` and `channelId` without mutating the entry. Used by
+ * dispatch to snapshot pre-update state so a turn that ends up rejected
+ * as already-processing can restore the in-flight turn's mapping.
+ */
+export function peekThreadMapping(
+  conversationId: string,
+): { threadTs: string; channelId: string } | null {
+  const mapping = threadMappings.get(conversationId);
+  return mapping
+    ? { threadTs: mapping.threadTs, channelId: mapping.channelId }
+    : null;
+}
+
+/**
+ * Drop any thread mapping associated with this conversation. Called on
+ * inbound Slack turns that arrive at the channel root (no `threadTs` on
+ * the callback URL) so that a stale mapping from a prior in-thread turn
+ * cannot be copied onto the outbound reply's `slackMeta`. Without this,
+ * a channel-root reply following an earlier thread turn would be
+ * persisted as if it belonged to the old thread.
+ */
+export function clearThreadTs(conversationId: string): void {
+  threadMappings.delete(conversationId);
+}
+
 /**
  * Extract the threadTs from a Slack reply callback URL, if present.
  * The gateway encodes threadTs as a query parameter on the callback URL.

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

@@ -65,6 +65,7 @@ function extractPlainTextBody(msg: GmailMessage): string {
 function mapGmailMessage(msg: GmailMessage): Message {
   const from = extractHeader(msg, "From");
   const subject = extractHeader(msg, "Subject");
+  const rfc822MessageId = extractHeader(msg, "Message-ID");
 
   // Parse sender name/email from "Name <email>" format
   const emailMatch = from.match(/<([^>]+)>/);
@@ -90,6 +91,7 @@ function mapGmailMessage(msg: GmailMessage): Message {
       subject,
       labelIds: msg.labelIds,
       snippet: msg.snippet,
+      ...(rfc822MessageId ? { rfc822MessageId } : {}),
     },
   };
 }
@@ -251,23 +253,11 @@ export const gmailMessagingProvider: MessagingProvider = {
     options?: HistoryOptions,
   ): Promise<Message[]> {
     const conn = requireConnection(connection);
-    // Get all messages in a Gmail thread
+    const thread = await gmail.getThread(conn, threadId, "full");
+    const messages = thread.messages ?? [];
+    if (!messages.length) return [];
     const limit = options?.limit ?? 50;
-    const listResult = await gmail.listMessages(
-      conn,
-      `thread:${threadId}`,
-      limit,
-    );
-
-    if (!listResult.messages?.length) return [];
-
-    const messages = await gmail.batchGetMessages(
-      conn,
-      listResult.messages.map((m) => m.id),
-      "full",
-    );
-
-    return messages.map(mapGmailMessage);
+    return messages.slice(0, limit).map(mapGmailMessage);
   },
 
   async markRead(

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

@@ -16,6 +16,7 @@ import type {
   GmailMessageListResponse,
   GmailModifyRequest,
   GmailProfile,
+  GmailThread,
   GmailVacationSettings,
 } from "./types.js";
 
@@ -217,6 +218,7 @@ export async function listMessages(
   maxResults = 20,
   pageToken?: string,
   labelIds?: string[],
+  signal?: AbortSignal,
 ): Promise<GmailMessageListResponse> {
   const params = new URLSearchParams();
   if (query) params.set("q", query);
@@ -230,6 +232,7 @@ export async function listMessages(
     "/messages",
     undefined,
     paramsToQuery(params),
+    signal,
   );
 }
 
@@ -256,6 +259,25 @@ export async function getMessage(
   );
 }
 
+/** Get a thread and all its messages by thread ID. */
+export async function getThread(
+  connection: OAuthConnection,
+  threadId: string,
+  format: GmailMessageFormat = "full",
+  metadataHeaders?: string[],
+): Promise<GmailThread> {
+  const params = new URLSearchParams({ format });
+  if (format === "metadata" && metadataHeaders) {
+    for (const h of metadataHeaders) params.append("metadataHeaders", h);
+  }
+  return request<GmailThread>(
+    connection,
+    `/threads/${threadId}`,
+    undefined,
+    paramsToQuery(params),
+  );
+}
+
 /**
  * Parse a single part from a multipart batch response into its HTTP status and JSON body.
  * Each part contains MIME headers, then an embedded HTTP response (status line, headers, body).

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

@@ -44,6 +44,13 @@ export interface GmailMessage {
   raw?: string;
 }
 
+/** Gmail thread response */
+export interface GmailThread {
+  id: string;
+  historyId?: string;
+  messages?: GmailMessage[];
+}
+
 /** Gmail label */
 export interface GmailLabel {
   id: string;

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

@@ -108,7 +108,8 @@ async function runReadWithFallback<T>(
   if (connection) return call(connection);
   const auth = getReadAuth(undefined);
   const usingUserToken =
-    _cachedSlackWriteAuth !== null && _cachedSlackReadAuth !== _cachedSlackWriteAuth;
+    _cachedSlackWriteAuth !== null &&
+    _cachedSlackReadAuth !== _cachedSlackWriteAuth;
   try {
     return await call(auth);
   } catch (err) {
@@ -203,6 +204,11 @@ function mapMessage(
   channelId: string,
   senderName: 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.
+  const isBot =
+    msg.subtype === "bot_message" || (msg.bot_id != null && !msg.user);
   return {
     id: msg.ts,
     conversationId: channelId,
@@ -214,6 +220,7 @@ function mapMessage(
     platform: "slack",
     reactions: msg.reactions?.map((r) => ({ name: r.name, count: r.count })),
     hasAttachments: (msg.files?.length ?? 0) > 0,
+    ...(isBot ? { metadata: { isBot: true } } : {}),
   };
 }
 
@@ -234,7 +241,12 @@ export const slackProvider: MessagingProvider = {
   id: "slack",
   displayName: "Slack",
   credentialService: "slack",
-  capabilities: new Set(["reactions", "threads", "join_channel", "leave_channel"]),
+  capabilities: new Set([
+    "reactions",
+    "threads",
+    "join_channel",
+    "leave_channel",
+  ]),
 
   async isConnected(): Promise<boolean> {
     // Socket Mode: check for bot token directly in credential store.

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

@@ -0,0 +1,257 @@
+/**
+ * Tests for the daemon-side Slack backfill helpers.
+ *
+ * Verifies:
+ *  - Pass-through of channelId, threadTs, and the `before` cursor.
+ *  - Default limit of 50 when none is supplied; explicit limits override.
+ *  - resolveConnection() is invoked once per call so any cached read/write
+ *    auth mutation lands before the adapter method runs.
+ *  - Transient failure modes (timeout, 401, generic Slack API error, missing
+ *    connection) return [] instead of propagating the error.
+ *  - `channel_not_found` errors are rethrown so wrong-workspace configuration
+ *    bugs in multi-account setups surface loudly rather than silently
+ *    dropping context.
+ *  - `account` is threaded through to resolveConnection() when provided.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { OAuthConnection } from "../../../oauth/connection.js";
+import type { Message } from "../../provider-types.js";
+
+// ── Module mocks ────────────────────────────────────────────────────────────
+
+type ResolveConnectionFn = (
+  account?: string,
+) => Promise<OAuthConnection | undefined>;
+type GetHistoryFn = (
+  connection: OAuthConnection | undefined,
+  conversationId: string,
+  options?: { limit?: number; before?: string; after?: string },
+) => Promise<Message[]>;
+type GetThreadRepliesFn = (
+  connection: OAuthConnection | undefined,
+  conversationId: string,
+  threadId: string,
+  options?: { limit?: number },
+) => Promise<Message[]>;
+
+const resolveConnectionMock = mock<ResolveConnectionFn>(async () => undefined);
+const getHistoryMock = mock<GetHistoryFn>(async () => []);
+const getThreadRepliesMock = mock<GetThreadRepliesFn>(async () => []);
+
+mock.module("./adapter.js", () => ({
+  slackProvider: {
+    id: "slack",
+    displayName: "Slack",
+    credentialService: "slack",
+    capabilities: new Set(["threads"]),
+    resolveConnection: (account?: string) => resolveConnectionMock(account),
+    getHistory: (
+      connection: OAuthConnection | undefined,
+      conversationId: string,
+      options?: { limit?: number; before?: string; after?: string },
+    ) => getHistoryMock(connection, conversationId, options),
+    getThreadReplies: (
+      connection: OAuthConnection | undefined,
+      conversationId: string,
+      threadId: string,
+      options?: { limit?: number },
+    ) => getThreadRepliesMock(connection, conversationId, threadId, options),
+    // Stub the rest of the MessagingProvider surface as no-ops; the backfill
+    // helpers should never reach for these.
+    testConnection: async () => {
+      throw new Error("not used");
+    },
+    listConversations: async () => [],
+    search: async () => ({ total: 0, messages: [], hasMore: false }),
+    sendMessage: async () => {
+      throw new Error("not used");
+    },
+  },
+}));
+
+import { backfillDm, backfillThread } from "./backfill.js";
+
+function makeMessage(overrides: Partial<Message> = {}): Message {
+  return {
+    id: "1700000000.000100",
+    conversationId: "C123",
+    sender: { id: "U1", name: "Alice" },
+    text: "hello",
+    timestamp: 1700000000000,
+    platform: "slack",
+    ...overrides,
+  };
+}
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe("backfillThread", () => {
+  beforeEach(() => {
+    resolveConnectionMock.mockReset();
+    resolveConnectionMock.mockImplementation(async () => undefined);
+    getThreadRepliesMock.mockReset();
+    getThreadRepliesMock.mockImplementation(async () => []);
+    getHistoryMock.mockReset();
+    getHistoryMock.mockImplementation(async () => []);
+  });
+
+  test("passes channelId/threadTs through and defaults limit to 50", async () => {
+    const reply = makeMessage({
+      id: "1700000000.000200",
+      threadId: "1700000000.000100",
+    });
+    getThreadRepliesMock.mockImplementation(async () => [reply]);
+
+    const out = await backfillThread("C123", "1700000000.000100");
+
+    expect(resolveConnectionMock).toHaveBeenCalledTimes(1);
+    expect(getThreadRepliesMock).toHaveBeenCalledTimes(1);
+    const [conn, channel, thread, opts] = getThreadRepliesMock.mock.calls[0];
+    expect(conn).toBeUndefined();
+    expect(channel).toBe("C123");
+    expect(thread).toBe("1700000000.000100");
+    expect(opts).toEqual({ limit: 50 });
+    expect(out).toEqual([reply]);
+  });
+
+  test("respects explicit limit override", async () => {
+    await backfillThread("C123", "1700000000.000100", { limit: 10 });
+    const [, , , opts] = getThreadRepliesMock.mock.calls[0];
+    expect(opts).toEqual({ limit: 10 });
+  });
+
+  test("returns [] when getThreadReplies throws (generic Slack API error)", async () => {
+    getThreadRepliesMock.mockImplementation(async () => {
+      throw new Error("Slack API error: ratelimited");
+    });
+    const out = await backfillThread("C123", "1700000000.000100");
+    expect(out).toEqual([]);
+  });
+
+  test("rethrows channel_not_found so wrong-workspace config surfaces", async () => {
+    getThreadRepliesMock.mockImplementation(async () => {
+      throw new Error("Slack API error: channel_not_found");
+    });
+    await expect(backfillThread("C123", "1700000000.000100")).rejects.toThrow(
+      /channel_not_found/,
+    );
+  });
+
+  test("threads `account` through to resolveConnection", async () => {
+    await backfillThread("C123", "1700000000.000100", {
+      account: "team-acme",
+    });
+    expect(resolveConnectionMock).toHaveBeenCalledTimes(1);
+    expect(resolveConnectionMock.mock.calls[0][0]).toBe("team-acme");
+  });
+
+  test("returns [] when getThreadReplies throws (auth error)", async () => {
+    getThreadRepliesMock.mockImplementation(async () => {
+      const err = new Error("Slack API HTTP 401");
+      Object.assign(err, { status: 401 });
+      throw err;
+    });
+    const out = await backfillThread("C123", "1700000000.000100");
+    expect(out).toEqual([]);
+  });
+
+  test("returns [] when getThreadReplies throws (timeout)", async () => {
+    getThreadRepliesMock.mockImplementation(async () => {
+      throw new Error("ETIMEDOUT");
+    });
+    const out = await backfillThread("C123", "1700000000.000100");
+    expect(out).toEqual([]);
+  });
+
+  test("returns [] when resolveConnection throws (missing connection)", async () => {
+    resolveConnectionMock.mockImplementation(async () => {
+      throw new Error("no connection available");
+    });
+    const out = await backfillThread("C123", "1700000000.000100");
+    expect(out).toEqual([]);
+    // resolveConnection failed before getThreadReplies could be reached.
+    expect(getThreadRepliesMock).not.toHaveBeenCalled();
+  });
+});
+
+describe("backfillDm", () => {
+  beforeEach(() => {
+    resolveConnectionMock.mockReset();
+    resolveConnectionMock.mockImplementation(async () => undefined);
+    getHistoryMock.mockReset();
+    getHistoryMock.mockImplementation(async () => []);
+    getThreadRepliesMock.mockReset();
+    getThreadRepliesMock.mockImplementation(async () => []);
+  });
+
+  test("passes channelId through and defaults limit to 50, before undefined", async () => {
+    const msg = makeMessage();
+    getHistoryMock.mockImplementation(async () => [msg]);
+
+    const out = await backfillDm("D123");
+
+    expect(resolveConnectionMock).toHaveBeenCalledTimes(1);
+    expect(getHistoryMock).toHaveBeenCalledTimes(1);
+    const [conn, channel, opts] = getHistoryMock.mock.calls[0];
+    expect(conn).toBeUndefined();
+    expect(channel).toBe("D123");
+    expect(opts).toEqual({ limit: 50, before: undefined });
+    expect(out).toEqual([msg]);
+  });
+
+  test("respects explicit limit override and forwards `before` cursor", async () => {
+    await backfillDm("D123", { limit: 25, before: "1700000000.000099" });
+    const [, , opts] = getHistoryMock.mock.calls[0];
+    expect(opts).toEqual({ limit: 25, before: "1700000000.000099" });
+  });
+
+  test("returns [] when getHistory throws (generic Slack API error)", async () => {
+    getHistoryMock.mockImplementation(async () => {
+      throw new Error("Slack API error: not_in_channel");
+    });
+    const out = await backfillDm("D123");
+    expect(out).toEqual([]);
+  });
+
+  test("rethrows channel_not_found so wrong-workspace config surfaces", async () => {
+    getHistoryMock.mockImplementation(async () => {
+      throw new Error("Slack API error: channel_not_found");
+    });
+    await expect(backfillDm("D123")).rejects.toThrow(/channel_not_found/);
+  });
+
+  test("threads `account` through to resolveConnection", async () => {
+    await backfillDm("D123", { account: "team-acme" });
+    expect(resolveConnectionMock).toHaveBeenCalledTimes(1);
+    expect(resolveConnectionMock.mock.calls[0][0]).toBe("team-acme");
+  });
+
+  test("returns [] when getHistory throws (auth error)", async () => {
+    getHistoryMock.mockImplementation(async () => {
+      const err = new Error("Slack API HTTP 401");
+      Object.assign(err, { status: 401 });
+      throw err;
+    });
+    const out = await backfillDm("D123");
+    expect(out).toEqual([]);
+  });
+
+  test("returns [] when getHistory throws (timeout)", async () => {
+    getHistoryMock.mockImplementation(async () => {
+      throw new Error("ETIMEDOUT");
+    });
+    const out = await backfillDm("D123");
+    expect(out).toEqual([]);
+  });
+
+  test("returns [] when resolveConnection throws (missing connection)", async () => {
+    resolveConnectionMock.mockImplementation(async () => {
+      throw new Error("no connection available");
+    });
+    const out = await backfillDm("D123");
+    expect(out).toEqual([]);
+    expect(getHistoryMock).not.toHaveBeenCalled();
+  });
+});