@vellumai/assistant 0.4.26 → 0.4.29

package/src/memory/qdrant-client.ts

@@ -1,20 +1,20 @@
-import { QdrantClient as QdrantRestClient } from '@qdrant/js-client-rest';
-import { v4 as uuid } from 'uuid';
+import { QdrantClient as QdrantRestClient } from "@qdrant/js-client-rest";
+import { v4 as uuid } from "uuid";
 
-import { getLogger } from '../util/logger.js';
+import { getLogger } from "../util/logger.js";
 
-const log = getLogger('qdrant-client');
+const log = getLogger("qdrant-client");
 
 export interface QdrantClientConfig {
   url: string;
   collection: string;
   vectorSize: number;
   onDisk: boolean;
-  quantization: 'scalar' | 'none';
+  quantization: "scalar" | "none";
 }
 
 export interface QdrantPointPayload {
-  target_type: 'segment' | 'item' | 'summary';
+  target_type: "segment" | "item" | "summary";
   target_id: string;
   text: string;
   kind?: string;
@@ -39,12 +39,16 @@ let _instance: VellumQdrantClient | null = null;
 
 export function getQdrantClient(): VellumQdrantClient {
   if (!_instance) {
-    throw new Error('Qdrant client not initialized. Call initQdrantClient() first.');
+    throw new Error(
+      "Qdrant client not initialized. Call initQdrantClient() first.",
+    );
   }
   return _instance;
 }
 
-export function initQdrantClient(config: QdrantClientConfig): VellumQdrantClient {
+export function initQdrantClient(
+  config: QdrantClientConfig,
+): VellumQdrantClient {
   _instance = new VellumQdrantClient(config);
   return _instance;
 }
@@ -54,11 +58,14 @@ export class VellumQdrantClient {
   private readonly collection: string;
   private readonly vectorSize: number;
   private readonly onDisk: boolean;
-  private readonly quantization: 'scalar' | 'none';
+  private readonly quantization: "scalar" | "none";
   private collectionReady = false;
 
   constructor(config: QdrantClientConfig) {
-    this.client = new QdrantRestClient({ url: config.url, checkCompatibility: false });
+    this.client = new QdrantRestClient({
+      url: config.url,
+      checkCompatibility: false,
+    });
     this.collection = config.collection;
     this.vectorSize = config.vectorSize;
     this.onDisk = config.onDisk;
@@ -78,13 +85,16 @@ export class VellumQdrantClient {
       // Collection doesn't exist, create it
     }
 
-    log.info({ collection: this.collection, vectorSize: this.vectorSize }, 'Creating Qdrant collection');
+    log.info(
+      { collection: this.collection, vectorSize: this.vectorSize },
+      "Creating Qdrant collection",
+    );
 
     try {
       await this.client.createCollection(this.collection, {
         vectors: {
           size: this.vectorSize,
-          distance: 'Cosine',
+          distance: "Cosine",
           on_disk: this.onDisk,
         },
         hnsw_config: {
@@ -92,20 +102,25 @@ export class VellumQdrantClient {
           m: 16,
           ef_construct: 100,
         },
-        quantization_config: this.quantization === 'scalar'
-          ? {
-            scalar: {
-              type: 'int8',
-              quantile: 0.99,
-              always_ram: true,
-            },
-          }
-          : undefined,
+        quantization_config:
+          this.quantization === "scalar"
+            ? {
+                scalar: {
+                  type: "int8",
+                  quantile: 0.99,
+                  always_ram: true,
+                },
+              }
+            : undefined,
         on_disk_payload: this.onDisk,
       });
     } catch (err) {
       // 409 = collection was created by a concurrent caller — that's fine
-      if (err instanceof Error && 'status' in err && (err as { status: number }).status === 409) {
+      if (
+        err instanceof Error &&
+        "status" in err &&
+        (err as { status: number }).status === 409
+      ) {
         this.collectionReady = true;
         return;
       }
@@ -115,40 +130,43 @@ export class VellumQdrantClient {
     // Create payload indexes for efficient filtering
     await Promise.all([
       this.client.createPayloadIndex(this.collection, {
-        field_name: 'target_type',
-        field_schema: 'keyword',
+        field_name: "target_type",
+        field_schema: "keyword",
       }),
       this.client.createPayloadIndex(this.collection, {
-        field_name: 'target_id',
-        field_schema: 'keyword',
+        field_name: "target_id",
+        field_schema: "keyword",
       }),
       this.client.createPayloadIndex(this.collection, {
-        field_name: 'kind',
-        field_schema: 'keyword',
+        field_name: "kind",
+        field_schema: "keyword",
       }),
       this.client.createPayloadIndex(this.collection, {
-        field_name: 'status',
-        field_schema: 'keyword',
+        field_name: "status",
+        field_schema: "keyword",
       }),
       this.client.createPayloadIndex(this.collection, {
-        field_name: 'created_at',
-        field_schema: 'integer',
+        field_name: "created_at",
+        field_schema: "integer",
       }),
       this.client.createPayloadIndex(this.collection, {
-        field_name: 'conversation_id',
-        field_schema: 'keyword',
+        field_name: "conversation_id",
+        field_schema: "keyword",
       }),
     ]);
 
     this.collectionReady = true;
-    log.info({ collection: this.collection }, 'Qdrant collection created with payload indexes');
+    log.info(
+      { collection: this.collection },
+      "Qdrant collection created with payload indexes",
+    );
   }
 
   async upsert(
-    targetType: 'segment' | 'item' | 'summary',
+    targetType: "segment" | "item" | "summary",
     targetId: string,
     vector: number[],
-    payload: Omit<QdrantPointPayload, 'target_type' | 'target_id'>,
+    payload: Omit<QdrantPointPayload, "target_type" | "target_id">,
   ): Promise<string> {
     await this.ensureCollection();
 
@@ -211,7 +229,7 @@ export class VellumQdrantClient {
         limit,
         with_payload: true,
         score_threshold: 0.0,
-        filter: filter as Parameters<QdrantRestClient['search']>[1]['filter'],
+        filter: filter as Parameters<QdrantRestClient["search"]>[1]["filter"],
       });
     } catch (err) {
       if (this.isCollectionMissing(err)) {
@@ -222,7 +240,7 @@ export class VellumQdrantClient {
           limit,
           with_payload: true,
           score_threshold: 0.0,
-          filter: filter as Parameters<QdrantRestClient['search']>[1]['filter'],
+          filter: filter as Parameters<QdrantRestClient["search"]>[1]["filter"],
         });
       } else {
         throw err;
@@ -230,7 +248,7 @@ export class VellumQdrantClient {
     }
 
     return results.map((result) => ({
-      id: typeof result.id === 'string' ? result.id : String(result.id),
+      id: typeof result.id === "string" ? result.id : String(result.id),
       score: result.score,
       payload: result.payload as unknown as QdrantPointPayload,
     }));
@@ -239,12 +257,12 @@ export class VellumQdrantClient {
   async searchWithFilter(
     vector: number[],
     limit: number,
-    targetTypes: Array<'segment' | 'item' | 'summary'>,
+    targetTypes: Array<"segment" | "item" | "summary">,
     excludeMessageIds?: string[],
   ): Promise<QdrantSearchResult[]> {
     const mustConditions: Array<Record<string, unknown>> = [
       {
-        key: 'target_type',
+        key: "target_type",
         match: { any: targetTypes },
       },
     ];
@@ -255,11 +273,11 @@ export class VellumQdrantClient {
         should: [
           {
             must: [
-              { key: 'target_type', match: { value: 'item' } },
-              { key: 'status', match: { value: 'active' } },
+              { key: "target_type", match: { value: "item" } },
+              { key: "status", match: { value: "active" } },
             ],
           },
-          { key: 'target_type', match: { any: ['segment', 'summary'] } },
+          { key: "target_type", match: { any: ["segment", "summary"] } },
         ],
       });
     }
@@ -267,7 +285,7 @@ export class VellumQdrantClient {
     const mustNotConditions: Array<Record<string, unknown>> = [];
     if (excludeMessageIds && excludeMessageIds.length > 0) {
       mustNotConditions.push({
-        key: 'message_id',
+        key: "message_id",
         match: { any: excludeMessageIds },
       });
     }
@@ -285,15 +303,16 @@ export class VellumQdrantClient {
   async deleteByTarget(targetType: string, targetId: string): Promise<void> {
     await this.ensureCollection();
 
-    const doDelete = () => this.client.delete(this.collection, {
-      wait: true,
-      filter: {
-        must: [
-          { key: 'target_type', match: { value: targetType } },
-          { key: 'target_id', match: { value: targetId } },
-        ],
-      },
-    });
+    const doDelete = () =>
+      this.client.delete(this.collection, {
+        wait: true,
+        filter: {
+          must: [
+            { key: "target_type", match: { value: targetType } },
+            { key: "target_id", match: { value: targetId } },
+          ],
+        },
+      });
 
     try {
       await doDelete();
@@ -318,7 +337,9 @@ export class VellumQdrantClient {
       if (this.isCollectionMissing(err)) {
         this.collectionReady = false;
         await this.ensureCollection();
-        const result = await this.client.count(this.collection, { exact: false });
+        const result = await this.client.count(this.collection, {
+          exact: false,
+        });
         return result.count;
       }
       throw err;
@@ -333,7 +354,10 @@ export class VellumQdrantClient {
       this.collectionReady = false;
       return true;
     } catch (err) {
-      log.warn({ err, collection: this.collection }, 'Failed to delete Qdrant collection');
+      log.warn(
+        { err, collection: this.collection },
+        "Failed to delete Qdrant collection",
+      );
       return false;
     }
   }
@@ -344,20 +368,32 @@ export class VellumQdrantClient {
    * (e.g. `vellum sessions clear`).
    */
   private isCollectionMissing(err: unknown): boolean {
-    if (err && typeof err === 'object' && 'status' in err && (err as { status: number }).status === 404) {
+    if (
+      err &&
+      typeof err === "object" &&
+      "status" in err &&
+      (err as { status: number }).status === 404
+    ) {
       return true;
     }
     const msg = err instanceof Error ? err.message : String(err);
-    return msg.includes('Not found') || msg.includes('doesn\'t exist') || msg.includes('not found');
+    return (
+      msg.includes("Not found") ||
+      msg.includes("doesn't exist") ||
+      msg.includes("not found")
+    );
   }
 
-  private async findByTarget(targetType: string, targetId: string): Promise<string | null> {
+  private async findByTarget(
+    targetType: string,
+    targetId: string,
+  ): Promise<string | null> {
     try {
       const results = await this.client.scroll(this.collection, {
         filter: {
           must: [
-            { key: 'target_type', match: { value: targetType } },
-            { key: 'target_id', match: { value: targetId } },
+            { key: "target_type", match: { value: targetType } },
+            { key: "target_id", match: { value: targetId } },
           ],
         },
         limit: 1,
@@ -366,7 +402,7 @@ export class VellumQdrantClient {
       });
       if (results.points.length > 0) {
         const id = results.points[0].id;
-        return typeof id === 'string' ? id : String(id);
+        return typeof id === "string" ? id : String(id);
       }
     } catch {
       // Not found

package/src/memory/qdrant-manager.ts

@@ -1,17 +1,24 @@
-import { createHash } from 'node:crypto';
-import { chmodSync,existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
-import { arch, platform } from 'node:os';
-import { dirname,join } from 'node:path';
-
-import type { Subprocess } from 'bun';
-
-import { getQdrantUrlEnv } from '../config/env.js';
-import { getLogger } from '../util/logger.js';
-import { getDataDir } from '../util/platform.js';
-
-const log = getLogger('qdrant-manager');
-
-const QDRANT_VERSION = '1.13.2';
+import { createHash } from "node:crypto";
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { arch, platform } from "node:os";
+import { dirname, join } from "node:path";
+
+import type { Subprocess } from "bun";
+
+import { getQdrantUrlEnv } from "../config/env.js";
+import { getLogger } from "../util/logger.js";
+import { getDataDir } from "../util/platform.js";
+
+const log = getLogger("qdrant-manager");
+
+const QDRANT_VERSION = "1.13.2";
 const READYZ_POLL_INTERVAL_MS = 200;
 const READYZ_TIMEOUT_MS = 30_000;
 const SHUTDOWN_GRACE_MS = 5_000;
@@ -54,11 +61,12 @@ export class QdrantManager {
     this.url = config.url;
     const parsed = new URL(config.url);
     this.host = parsed.hostname;
-    this.port = parseInt(parsed.port || '6333', 10);
-    this.storagePath = config.storagePath ?? join(getDataDir(), 'qdrant');
-    this.pidPath = join(getDataDir(), 'qdrant', 'qdrant.pid');
+    this.port = parseInt(parsed.port || "6333", 10);
+    this.storagePath = config.storagePath ?? join(getDataDir(), "qdrant");
+    this.pidPath = join(getDataDir(), "qdrant", "qdrant.pid");
 
-    this.readyzPollIntervalMs = config.readyzPollIntervalMs ?? READYZ_POLL_INTERVAL_MS;
+    this.readyzPollIntervalMs =
+      config.readyzPollIntervalMs ?? READYZ_POLL_INTERVAL_MS;
     this.readyzTimeoutMs = config.readyzTimeoutMs ?? READYZ_TIMEOUT_MS;
     this.shutdownGraceMs = config.shutdownGraceMs ?? SHUTDOWN_GRACE_MS;
 
@@ -68,7 +76,10 @@ export class QdrantManager {
 
   async start(): Promise<void> {
     if (this.isExternal) {
-      log.info({ url: this.url }, 'Qdrant running in external mode, verifying connectivity');
+      log.info(
+        { url: this.url },
+        "Qdrant running in external mode, verifying connectivity",
+      );
       await this.waitForReady();
       return;
     }
@@ -81,7 +92,10 @@ export class QdrantManager {
       await this.installBinary(binaryPath);
     }
 
-    log.info({ binaryPath, storagePath: this.storagePath, port: this.port }, 'Starting Qdrant');
+    log.info(
+      { binaryPath, storagePath: this.storagePath, port: this.port },
+      "Starting Qdrant",
+    );
 
     this.process = Bun.spawn({
       cmd: [binaryPath],
@@ -89,13 +103,13 @@ export class QdrantManager {
         ...process.env,
         QDRANT__SERVICE__HOST: this.host,
         QDRANT__SERVICE__HTTP_PORT: String(this.port),
-        QDRANT__SERVICE__GRPC_PORT: '0', // disable gRPC
-        QDRANT__TELEMETRY_DISABLED: 'true',
+        QDRANT__SERVICE__GRPC_PORT: "0", // disable gRPC
+        QDRANT__TELEMETRY_DISABLED: "true",
         QDRANT__STORAGE__STORAGE_PATH: this.storagePath,
-        QDRANT__LOG_LEVEL: 'WARN',
+        QDRANT__LOG_LEVEL: "WARN",
       },
-      stdout: 'ignore',
-      stderr: 'ignore',
+      stdout: "ignore",
+      stderr: "ignore",
     });
 
     if (this.process.pid) {
@@ -104,7 +118,7 @@ export class QdrantManager {
 
     try {
       await this.waitForReady();
-      log.info({ pid: this.process.pid, port: this.port }, 'Qdrant is ready');
+      log.info({ pid: this.process.pid, port: this.port }, "Qdrant is ready");
     } catch (err) {
       // If startup fails, clean up
       await this.stop();
@@ -118,24 +132,26 @@ export class QdrantManager {
       return;
     }
 
-    log.info('Stopping Qdrant');
-    this.process.kill('SIGTERM');
+    log.info("Stopping Qdrant");
+    this.process.kill("SIGTERM");
 
     // Wait for graceful shutdown
     const graceful = await Promise.race([
       this.process.exited.then(() => true),
-      new Promise<false>((resolve) => setTimeout(() => resolve(false), this.shutdownGraceMs)),
+      new Promise<false>((resolve) =>
+        setTimeout(() => resolve(false), this.shutdownGraceMs),
+      ),
     ]);
 
     if (!graceful) {
-      log.warn('Qdrant did not exit gracefully, sending SIGKILL');
-      this.process.kill('SIGKILL');
+      log.warn("Qdrant did not exit gracefully, sending SIGKILL");
+      this.process.kill("SIGKILL");
       await this.process.exited;
     }
 
     this.process = null;
     this.cleanupPid();
-    log.info('Qdrant stopped');
+    log.info("Qdrant stopped");
   }
 
   getUrl(): string {
@@ -147,18 +163,18 @@ export class QdrantManager {
     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';
+    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.',
+          "Set QDRANT_URL to use an external Qdrant instance.",
       );
     }
 
@@ -167,7 +183,7 @@ export class QdrantManager {
     const url = `${baseUrl}/${filename}`;
     const checksumUrl = `${baseUrl}/${filename}.sha256`;
 
-    log.info({ url, binaryPath }, 'Downloading Qdrant binary');
+    log.info({ url, binaryPath }, "Downloading Qdrant binary");
 
     // Fetch the tarball and its SHA-256 checksum in parallel
     const [response, checksumResponse] = await Promise.all([
@@ -176,7 +192,9 @@ export class QdrantManager {
     ]);
 
     if (!response.ok) {
-      throw new Error(`Failed to download Qdrant: ${response.status} ${response.statusText} from ${url}`);
+      throw new Error(
+        `Failed to download Qdrant: ${response.status} ${response.statusText} from ${url}`,
+      );
     }
 
     const tarball = await response.arrayBuffer();
@@ -186,17 +204,22 @@ export class QdrantManager {
       const checksumText = (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)).digest('hex');
+      const actualHash = createHash("sha256")
+        .update(Buffer.from(tarball))
+        .digest("hex");
 
       if (actualHash !== expectedHash) {
         throw new Error(
           `Qdrant binary checksum mismatch! ` +
-          `expected=${expectedHash} actual=${actualHash} url=${url}`,
+            `expected=${expectedHash} actual=${actualHash} url=${url}`,
         );
       }
-      log.info({ hash: actualHash }, 'Qdrant binary checksum verified');
+      log.info({ hash: actualHash }, "Qdrant binary checksum verified");
     } else {
-      log.warn({ checksumUrl, status: checksumResponse.status }, 'Could not fetch Qdrant checksum — skipping integrity check');
+      log.warn(
+        { checksumUrl, status: checksumResponse.status },
+        "Could not fetch Qdrant checksum — skipping integrity check",
+      );
     }
 
     // Extract the qdrant binary from the tarball
@@ -209,9 +232,9 @@ export class QdrantManager {
 
     try {
       const proc = Bun.spawn({
-        cmd: ['tar', 'xzf', tmpTar, '-C', binDir, 'qdrant'],
-        stdout: 'ignore',
-        stderr: 'pipe',
+        cmd: ["tar", "xzf", tmpTar, "-C", binDir, "qdrant"],
+        stdout: "ignore",
+        stderr: "pipe",
       });
       await proc.exited;
       if (proc.exitCode !== 0) {
@@ -219,11 +242,18 @@ export class QdrantManager {
         throw new Error(`Failed to extract Qdrant binary: ${stderr}`);
       }
     } finally {
-      try { unlinkSync(tmpTar); } catch { /* ignore */ }
+      try {
+        unlinkSync(tmpTar);
+      } catch {
+        /* ignore */
+      }
     }
 
     chmodSync(binaryPath, 0o755);
-    log.info({ binaryPath, version: QDRANT_VERSION }, 'Qdrant binary installed');
+    log.info(
+      { binaryPath, version: QDRANT_VERSION },
+      "Qdrant binary installed",
+    );
   }
 
   private async waitForReady(): Promise<void> {
@@ -237,11 +267,13 @@ export class QdrantManager {
       }
       await Bun.sleep(this.readyzPollIntervalMs);
     }
-    throw new Error(`Qdrant did not become ready within ${this.readyzTimeoutMs}ms at ${this.url}`);
+    throw new Error(
+      `Qdrant did not become ready within ${this.readyzTimeoutMs}ms at ${this.url}`,
+    );
   }
 
   private getBinaryPath(): string {
-    return join(getDataDir(), 'qdrant', 'bin', 'qdrant');
+    return join(getDataDir(), "qdrant", "bin", "qdrant");
   }
 
   private cleanupStaleProcess(): void {
@@ -251,8 +283,8 @@ export class QdrantManager {
     try {
       process.kill(pid, 0); // Check if process exists
       // Process is still running — kill it
-      log.warn({ pid }, 'Found stale Qdrant process, killing it');
-      process.kill(pid, 'SIGTERM');
+      log.warn({ pid }, "Found stale Qdrant process, killing it");
+      process.kill(pid, "SIGTERM");
     } catch {
       // Process doesn't exist, just clean up PID file
     }
@@ -262,7 +294,7 @@ export class QdrantManager {
   private readPid(): number | null {
     if (!existsSync(this.pidPath)) return null;
     try {
-      const pid = parseInt(readFileSync(this.pidPath, 'utf-8').trim(), 10);
+      const pid = parseInt(readFileSync(this.pidPath, "utf-8").trim(), 10);
       return isNaN(pid) ? null : pid;
     } catch {
       return null;

package/src/memory/query-builder.ts

@@ -1,7 +1,7 @@
-import { getSummaryFromContextMessage } from '../context/window-manager.js';
-import type { Message } from '../providers/types.js';
+import { getSummaryFromContextMessage } from "../context/window-manager.js";
+import type { Message } from "../providers/types.js";
 
-const TRUNCATION_MARKER = '<truncated />';
+const TRUNCATION_MARKER = "<truncated />";
 
 export interface MemoryQueryBuilderOptions {
   maxUserRequestChars?: number;
@@ -25,10 +25,13 @@ export function buildMemoryQuery(
     .map((message) => getSummaryFromContextMessage(message))
     .find((summary): summary is string => summary != null);
 
-  const content = requestText.length > 0 ? requestText : '(empty)';
+  const content = requestText.length > 0 ? requestText : "(empty)";
 
   if (sessionSummary && sessionSummary.trim().length > 0) {
-    const compactSummary = clampSection(sessionSummary.trim(), maxSessionSummaryChars);
+    const compactSummary = clampSection(
+      sessionSummary.trim(),
+      maxSessionSummaryChars,
+    );
     return `${content}\n\nContext summary:\n${compactSummary}`;
   }
 
@@ -36,10 +39,9 @@ export function buildMemoryQuery(
 }
 
 function clampSection(value: string, maxChars: number): string {
-  if (maxChars <= 0) return '';
+  if (maxChars <= 0) return "";
   if (value.length <= maxChars) return value;
   const half = Math.floor((maxChars - TRUNCATION_MARKER.length) / 2);
   if (half <= 0) return value.slice(0, maxChars);
   return value.slice(0, half) + TRUNCATION_MARKER + value.slice(-half);
 }
-