@vellumai/assistant 0.11.3 → 0.11.4-dev.202608190019.b94dbf2

package/src/persistence/embeddings/qdrant-manager.ts

@@ -33,6 +33,45 @@ const SHUTDOWN_GRACE_MS = 5_000;
 const STDOUT_CAPTURE_LIMIT = 16_384;
 const STDERR_CAPTURE_LIMIT = 4_096;
 
+export function resolveQdrantReleaseAsset(
+  os: NodeJS.Platform,
+  cpu: string,
+): {
+  binaryName: string;
+  filename: string;
+  format: "tar.gz" | "zip";
+  sha256?: string;
+} {
+  let target: string;
+  if (os === "darwin" && cpu === "arm64") {
+    target = "aarch64-apple-darwin";
+  } else if (os === "darwin" && cpu === "x64") {
+    target = "x86_64-apple-darwin";
+  } else if (os === "linux" && cpu === "x64") {
+    target = "x86_64-unknown-linux-musl";
+  } else if (os === "linux" && cpu === "arm64") {
+    target = "aarch64-unknown-linux-musl";
+  } else if (os === "win32" && cpu === "x64") {
+    return {
+      binaryName: "qdrant.exe",
+      filename: "qdrant-x86_64-pc-windows-msvc.zip",
+      format: "zip",
+      sha256:
+        "9d3b1d1fa58566bc71709347c4c9b83a0111d23a550daa93c3ee48e3150c4470",
+    };
+  } else {
+    throw new Error(
+      `Unsupported platform: ${os}/${cpu}. ` +
+        "Set QDRANT_URL to use an external Qdrant instance.",
+    );
+  }
+  return {
+    binaryName: "qdrant",
+    filename: `qdrant-${target}.tar.gz`,
+    format: "tar.gz",
+  };
+}
+
 export interface QdrantManagerConfig {
   url: string;
   storagePath?: string;
@@ -181,34 +220,18 @@ export class QdrantManager {
   private async installBinary(binaryPath: string): Promise<void> {
     const os = platform();
     const cpu = arch();
-
-    let target: string;
-    if (os === "darwin" && cpu === "arm64") {
-      target = "aarch64-apple-darwin";
-    } else if (os === "darwin" && cpu === "x64") {
-      target = "x86_64-apple-darwin";
-    } else if (os === "linux" && cpu === "x64") {
-      target = "x86_64-unknown-linux-musl";
-    } else if (os === "linux" && cpu === "arm64") {
-      target = "aarch64-unknown-linux-musl";
-    } else {
-      throw new Error(
-        `Unsupported platform: ${os}/${cpu}. ` +
-          "Set QDRANT_URL to use an external Qdrant instance.",
-      );
-    }
-
-    const filename = `qdrant-${target}.tar.gz`;
+    const release = resolveQdrantReleaseAsset(os, cpu);
+    const { filename } = release;
     const baseUrl = `https://github.com/qdrant/qdrant/releases/download/v${QDRANT_VERSION}`;
     const url = `${baseUrl}/${filename}`;
     const checksumUrl = `${baseUrl}/${filename}.sha256`;
 
     log.info({ url, binaryPath }, "Downloading Qdrant binary");
 
-    // Fetch the tarball and its SHA-256 checksum in parallel
+    // Fetch the archive and its SHA-256 checksum in parallel
     const [response, checksumResponse] = await Promise.all([
       fetch(url),
-      fetch(checksumUrl),
+      release.sha256 ? Promise.resolve(null) : fetch(checksumUrl),
     ]);
 
     if (!response.ok) {
@@ -217,15 +240,17 @@ export class QdrantManager {
       );
     }
 
-    const tarball = await response.arrayBuffer();
+    const archive = await response.arrayBuffer();
 
-    // Verify SHA-256 integrity if the checksum file is available
-    if (checksumResponse.ok) {
-      const checksumText = (await checksumResponse.text()).trim();
+    // Verify SHA-256 integrity if a pinned or published checksum is available
+    if (release.sha256 || checksumResponse?.ok) {
+      const checksumText = release.sha256
+        ? release.sha256
+        : (await checksumResponse!.text()).trim();
       // Checksum files contain "<hex>  <filename>" or just "<hex>"
       const expectedHash = checksumText.split(/\s+/)[0].toLowerCase();
       const actualHash = createHash("sha256")
-        .update(Buffer.from(tarball))
+        .update(Buffer.from(archive))
         .digest("hex");
 
       if (actualHash !== expectedHash) {
@@ -237,39 +262,45 @@ export class QdrantManager {
       log.info({ hash: actualHash }, "Qdrant binary checksum verified");
     } else {
       log.warn(
-        { checksumUrl, status: checksumResponse.status },
-        "Could not fetch Qdrant checksum — skipping integrity check",
+        { checksumUrl, status: checksumResponse?.status },
+        "Could not fetch Qdrant checksum; skipping integrity check",
       );
     }
 
-    // Extract the qdrant binary from the tarball
     const binDir = dirname(binaryPath);
     mkdirSync(binDir, { recursive: true });
-
-    // Write tarball to temp file, extract with tar
-    const tmpTar = join(binDir, `qdrant-download-${Date.now()}.tar.gz`);
-    writeFileSync(tmpTar, Buffer.from(tarball));
-
-    try {
-      const proc = Bun.spawn({
-        cmd: ["tar", "xzf", tmpTar, "-C", binDir, "qdrant"],
-        stdout: "ignore",
-        stderr: "pipe",
-      });
-      await proc.exited;
-      if (proc.exitCode !== 0) {
-        const stderr = await new Response(proc.stderr).text();
-        throw new Error(`Failed to extract Qdrant binary: ${stderr}`);
+    if (release.format === "zip") {
+      const { default: JSZip } = await import("jszip");
+      const zip = await JSZip.loadAsync(archive);
+      const entry = zip.file(release.binaryName);
+      if (!entry) {
+        throw new Error(`${filename} does not contain ${release.binaryName}.`);
       }
-    } finally {
+      writeFileSync(binaryPath, await entry.async("nodebuffer"));
+    } else {
+      const tmpTar = join(binDir, `qdrant-download-${Date.now()}.tar.gz`);
+      writeFileSync(tmpTar, Buffer.from(archive));
       try {
-        unlinkSync(tmpTar);
-      } catch {
-        /* ignore */
+        const proc = Bun.spawn({
+          cmd: ["tar", "xzf", tmpTar, "-C", binDir, release.binaryName],
+          stdout: "ignore",
+          stderr: "pipe",
+        });
+        await proc.exited;
+        if (proc.exitCode !== 0) {
+          const stderr = await new Response(proc.stderr).text();
+          throw new Error(`Failed to extract Qdrant binary: ${stderr}`);
+        }
+      } finally {
+        try {
+          unlinkSync(tmpTar);
+        } catch {}
       }
     }
 
-    chmodSync(binaryPath, 0o755);
+    if (os !== "win32") {
+      chmodSync(binaryPath, 0o755);
+    }
     log.info(
       { binaryPath, version: QDRANT_VERSION },
       "Qdrant binary installed",
@@ -395,7 +426,8 @@ export class QdrantManager {
   }
 
   private getBinaryPath(): string {
-    return join(getDataDir(), "qdrant", "bin", "qdrant");
+    const binaryName = platform() === "win32" ? "qdrant.exe" : "qdrant";
+    return join(getDataDir(), "qdrant", "bin", binaryName);
   }
 
   private cleanupStaleProcess(): void {
@@ -447,6 +479,9 @@ export class QdrantManager {
    * discoverable by tools that scan for "vellum" in process names.
    */
   private ensureVellumSymlink(binaryPath: string): string {
+    if (platform() === "win32") {
+      return binaryPath;
+    }
     const symlinkPath = join(dirname(binaryPath), "vellum-qdrant");
     const expectedTarget = realpathSync(binaryPath);
 

package/src/persistence/external-conversation-store.ts

@@ -7,7 +7,8 @@
  * list APIs.
  */
 
-import { and, eq, inArray, isNull, sql } from "drizzle-orm";
+import { and, eq, inArray, isNull, type SQL, sql } from "drizzle-orm";
+import type { AnySQLiteColumn } from "drizzle-orm/sqlite-core";
 
 import { getDb } from "./db-connection.js";
 import { externalConversationBindings } from "./schema/index.js";
@@ -45,6 +46,19 @@ function normalizeExternalThreadId(
   return trimmed ? trimmed : null;
 }
 
+/**
+ * An upsert value that leaves the stored column alone when the caller said
+ * nothing about it, distinguishing "I do not know" from "there is none".
+ */
+function keepStoredIfAbsent<T extends string | null | undefined>(
+  value: T,
+  column: AnySQLiteColumn,
+): Exclude<T, undefined> | SQL {
+  return value === undefined
+    ? sql`${column}`
+    : (value as Exclude<T, undefined>);
+}
+
 function normalizeExternalChatName(
   externalChatName?: string | null,
 ): string | null {
@@ -103,9 +117,23 @@ export function upsertBinding(input: UpsertBindingInput): void {
           externalChatName ??
           sql`${externalConversationBindings.externalChatName}`,
         externalThreadId,
-        externalUserId: input.externalUserId ?? null,
-        displayName: input.displayName ?? null,
-        username: input.username ?? null,
+        // An omitted sender field keeps what is stored; an explicit value,
+        // including null, replaces it. A caller that knows only the chat
+        // coordinates on a message is silent about the sender rather than
+        // asserting there is none, and erasing a known name on that silence
+        // drops it from the conversation and session APIs.
+        externalUserId: keepStoredIfAbsent(
+          input.externalUserId,
+          externalConversationBindings.externalUserId,
+        ),
+        displayName: keepStoredIfAbsent(
+          input.displayName,
+          externalConversationBindings.displayName,
+        ),
+        username: keepStoredIfAbsent(
+          input.username,
+          externalConversationBindings.username,
+        ),
         updatedAt: now,
         lastInboundAt: now,
       },

package/src/persistence/llm-request-log-store.ts

@@ -28,13 +28,14 @@ import {
   getTurnTimeBounds,
   messageMetadataSchema,
 } from "./conversation-crud.js";
-import { type DrizzleDb, getDb, getLogsDb } from "./db-connection.js";
+import { type DrizzleDb, getLogsDb } from "./db-connection.js";
 import { getClickHouseLlmRequestLogSink } from "./llm-request-log-sink-clickhouse.js";
 import type {
   LlmRequestLogWriter,
   LlmRequestLogWriteRow,
 } from "./llm-request-log-writer-types.js";
-import { llmRequestLogs, messages } from "./schema/index.js";
+import { existingMessageIds } from "./message-reads.js";
+import { llmRequestLogs } from "./schema/index.js";
 import { timeSyncSection } from "./slow-sync-log.js";
 
 /**
@@ -593,14 +594,7 @@ function selectOrphanedLogsInRange(
   const candidateMessageIds = [
     ...new Set(candidates.map((c) => c.messageId as string)),
   ];
-  const existing = new Set(
-    getDb()
-      .select({ id: messages.id })
-      .from(messages)
-      .where(inArray(messages.id, candidateMessageIds))
-      .all()
-      .map((r) => r.id),
-  );
+  const existing = existingMessageIds(candidateMessageIds);
 
   // Orphaned = the referenced message no longer exists.
   return candidates.filter((c) => !existing.has(c.messageId as string));

package/src/persistence/llm-usage-store.ts

@@ -10,7 +10,10 @@ import type {
 import { APP_VERSION } from "../version.js";
 import { getDb } from "./db-connection.js";
 import { rawAll } from "./raw-query.js";
-import { realUserTurnContentFilter } from "./real-user-turn-filter.js";
+import {
+  realUserTurnContentFilter,
+  realUserTurnContentFilterSql,
+} from "./real-user-turn-filter.js";
 import {
   buildScheduleAttributionSubquery,
   buildScheduleRunWindowExists,
@@ -300,6 +303,9 @@ export function queryUnreportedUsageEvents(
   // branch from a turn far earlier than the fork's creation time, so
   // they anchor on the fork boundary message instead; child creation is
   // the fallback when the boundary message is absent.
+  // The turn-index subqueries below count user-role rows only. User rows are
+  // always written finalized (only assistant turns stream), so no completeness
+  // predicate is needed; do not copy this shape for assistant-row counts.
   const parentTurnCutoffSql = sql<number>`CASE
     WHEN ${conversations.parentConversationId} IS NOT NULL THEN ${conversations.createdAt}
     ELSE COALESCE(
@@ -879,8 +885,7 @@ export function getUsageGroupBreakdown(
                SELECT COUNT(*) FROM messages AS m2
                WHERE m2.conversation_id = e.conversation_id
                  AND m2.role = 'user'
-                 AND m2.content NOT LIKE '%"type":"tool\\_result"%' ESCAPE '\\'
-                 AND m2.content NOT LIKE '%"type":"web\\_search\\_tool\\_result"%' ESCAPE '\\'
+                 AND ${realUserTurnContentFilterSql("m2")}
              )
         END                                              AS turn_count
       FROM llm_usage_events e

package/src/persistence/message-reads.test.ts

@@ -0,0 +1,197 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { eq } from "drizzle-orm";
+
+import { createConversation } from "./conversation-crud.js";
+import { getDb } from "./db-connection.js";
+import { initializeDb } from "./db-init.js";
+import {
+  countMessagesByRoleForConversations,
+  existingMessageIds,
+  latestAssistantMessage,
+  latestAssistantMessageBefore,
+  latestUserMessageRawContent,
+  messageConversationId,
+} from "./message-reads.js";
+import { messages } from "./schema/index.js";
+
+await initializeDb();
+
+let seq = 0;
+function insertRow(opts: {
+  conversationId: string;
+  role: string;
+  createdAt: number;
+  content?: string;
+  finalized?: 0 | 1;
+}): string {
+  const id = `msg-${String(++seq).padStart(4, "0")}`;
+  getDb()
+    .insert(messages)
+    .values({
+      id,
+      conversationId: opts.conversationId,
+      role: opts.role,
+      content: opts.content ?? JSON.stringify([{ type: "text", text: "hi" }]),
+      createdAt: opts.createdAt,
+      metadata: null,
+      finalized: opts.finalized ?? 1,
+    })
+    .run();
+  return id;
+}
+
+function seedConversation(): string {
+  return createConversation("Message reads test").id;
+}
+
+describe("message-reads", () => {
+  beforeEach(() => {
+    const db = getDb();
+    db.run("DELETE FROM messages");
+    db.run("DELETE FROM conversations");
+  });
+
+  test("latestAssistantMessage returns the newest finalized assistant row", () => {
+    const conv = seedConversation();
+    insertRow({ conversationId: conv, role: "user", createdAt: 1_000 });
+    const older = insertRow({
+      conversationId: conv,
+      role: "assistant",
+      createdAt: 2_000,
+    });
+    const newer = insertRow({
+      conversationId: conv,
+      role: "assistant",
+      createdAt: 3_000,
+    });
+
+    expect(latestAssistantMessage(conv)?.id).toBe(newer);
+    expect(latestAssistantMessage(conv)?.id).not.toBe(older);
+    expect(latestAssistantMessage("missing-conv")).toBeNull();
+  });
+
+  test("latestAssistantMessage never anchors on a streaming row", () => {
+    const conv = seedConversation();
+    const finalizedReply = insertRow({
+      conversationId: conv,
+      role: "assistant",
+      createdAt: 1_000,
+    });
+    insertRow({
+      conversationId: conv,
+      role: "assistant",
+      createdAt: 2_000,
+      finalized: 0,
+    });
+
+    // The streaming row is newest but is not a reply yet; the watermark must
+    // sit on the completed one until the turn finishes.
+    expect(latestAssistantMessage(conv)?.id).toBe(finalizedReply);
+  });
+
+  test("a streaming row qualifies on its own once finalized", () => {
+    const conv = seedConversation();
+    insertRow({ conversationId: conv, role: "assistant", createdAt: 1_000 });
+    const streaming = insertRow({
+      conversationId: conv,
+      role: "assistant",
+      createdAt: 2_000,
+      finalized: 0,
+    });
+
+    getDb()
+      .update(messages)
+      .set({ finalized: 1 })
+      .where(eq(messages.id, streaming))
+      .run();
+
+    expect(latestAssistantMessage(conv)?.id).toBe(streaming);
+  });
+
+  test("latestAssistantMessageBefore is strict and skips streaming rows", () => {
+    const conv = seedConversation();
+    const first = insertRow({
+      conversationId: conv,
+      role: "assistant",
+      createdAt: 1_000,
+    });
+    insertRow({
+      conversationId: conv,
+      role: "assistant",
+      createdAt: 2_000,
+      finalized: 0,
+    });
+    insertRow({ conversationId: conv, role: "assistant", createdAt: 3_000 });
+
+    // Strictly before 3000: the streaming row at 2000 is passed over in
+    // favour of the completed row at 1000.
+    expect(latestAssistantMessageBefore(conv, 3_000)?.id).toBe(first);
+    // Strictly before 1000: nothing.
+    expect(latestAssistantMessageBefore(conv, 1_000)).toBeNull();
+  });
+
+  test("latestUserMessageRawContent resolves same-timestamp rows by insertion order", () => {
+    const conv = seedConversation();
+    insertRow({
+      conversationId: conv,
+      role: "user",
+      createdAt: 1_000,
+      content: "first",
+    });
+    insertRow({
+      conversationId: conv,
+      role: "user",
+      createdAt: 1_000,
+      content: "second",
+    });
+    insertRow({ conversationId: conv, role: "assistant", createdAt: 2_000 });
+
+    expect(latestUserMessageRawContent(conv)).toBe("second");
+    expect(latestUserMessageRawContent("missing-conv")).toBeNull();
+  });
+
+  test("countMessagesByRoleForConversations aggregates per conversation", () => {
+    const convA = seedConversation();
+    const convB = seedConversation();
+    insertRow({ conversationId: convA, role: "assistant", createdAt: 1_000 });
+    insertRow({ conversationId: convA, role: "assistant", createdAt: 2_000 });
+    insertRow({ conversationId: convA, role: "user", createdAt: 3_000 });
+    insertRow({ conversationId: convB, role: "assistant", createdAt: 4_000 });
+
+    const stats = countMessagesByRoleForConversations(
+      [convA, convB],
+      "assistant",
+    );
+    expect(stats.get(convA)).toEqual({ count: 2, lastAt: 2_000 });
+    expect(stats.get(convB)).toEqual({ count: 1, lastAt: 4_000 });
+    expect(countMessagesByRoleForConversations([], "assistant").size).toBe(0);
+  });
+
+  test("existingMessageIds returns only ids that exist", () => {
+    const conv = seedConversation();
+    const present = insertRow({
+      conversationId: conv,
+      role: "user",
+      createdAt: 1_000,
+    });
+
+    const existing = existingMessageIds([present, "msg-not-there"]);
+    expect(existing.has(present)).toBe(true);
+    expect(existing.has("msg-not-there")).toBe(false);
+    expect(existingMessageIds([]).size).toBe(0);
+  });
+
+  test("messageConversationId resolves ownership in any state", () => {
+    const conv = seedConversation();
+    const streaming = insertRow({
+      conversationId: conv,
+      role: "assistant",
+      createdAt: 1_000,
+      finalized: 0,
+    });
+
+    expect(messageConversationId(streaming)).toBe(conv);
+    expect(messageConversationId("msg-not-there")).toBeNull();
+  });
+});