@vellumai/assistant 0.3.14 → 0.3.16

package/src/memory/embedding-backend.ts

@@ -4,12 +4,77 @@ import { getOllamaBaseUrlEnv } from '../config/env.js';
 import type { AssistantConfig } from '../config/types.js';
 import { getLogger } from '../util/logger.js';
 import { GeminiEmbeddingBackend } from './embedding-gemini.js';
-import { LocalEmbeddingBackend } from './embedding-local.js';
 import { OllamaEmbeddingBackend } from './embedding-ollama.js';
 import { OpenAIEmbeddingBackend } from './embedding-openai.js';
 
 const log = getLogger('memory-embeddings');
 
+// Tracks whether the local embedding backend has permanently failed to load
+// (e.g., onnxruntime-node missing in a compiled binary). Once set, `auto` mode
+// skips `local` as primary, avoiding repeated fallback latency and cost.
+let localBackendBroken = false;
+
+/**
+ * Lazy wrapper around LocalEmbeddingBackend that dynamically imports the
+ * module on first use. This avoids eagerly loading @huggingface/transformers
+ * (which statically imports onnxruntime-node) at module evaluation time.
+ * In compiled binaries where onnxruntime-node isn't bundled, the static
+ * import would crash the entire daemon at startup. By deferring the import,
+ * the failure is contained and other embedding backends can be used instead.
+ */
+
+class LazyLocalEmbeddingBackend implements EmbeddingBackend {
+  readonly provider = 'local' as const;
+  readonly model: string;
+  private delegate: EmbeddingBackend | null = null;
+  private initPromise: Promise<EmbeddingBackend> | null = null;
+
+  constructor(model: string) {
+    this.model = model;
+  }
+
+  async embed(texts: string[], options?: EmbeddingRequestOptions): Promise<number[][]> {
+    const backend = await this.getDelegate();
+    try {
+      return await backend.embed(texts, options);
+    } catch (err) {
+      // The onnxruntime-node failure surfaces here during the first embed() call
+      // (via LocalEmbeddingBackend.initialize()). Mark broken so auto mode stops
+      // selecting local on subsequent requests.
+      if (!localBackendBroken && isInitializationError(err)) {
+        localBackendBroken = true;
+        log.warn({ err }, 'Local embedding backend permanently unavailable; auto mode will skip it');
+      }
+      throw err;
+    }
+  }
+
+  private async getDelegate(): Promise<EmbeddingBackend> {
+    if (this.delegate) return this.delegate;
+    if (!this.initPromise) {
+      this.initPromise = (async () => {
+        try {
+          const { LocalEmbeddingBackend } = await import('./embedding-local.js');
+          this.delegate = new LocalEmbeddingBackend(this.model);
+          return this.delegate;
+        } catch (err) {
+          localBackendBroken = true;
+          log.warn({ err }, 'Local embedding backend permanently unavailable; auto mode will skip it');
+          throw err;
+        }
+      })();
+    }
+    return this.initPromise;
+  }
+}
+
+/** Detect errors thrown by LocalEmbeddingBackend.initialize() so we can
+ *  distinguish permanent init failures from transient embed-time errors. */
+function isInitializationError(err: unknown): boolean {
+  if (!(err instanceof Error)) return false;
+  return err.message.includes('Local embedding backend unavailable');
+}
+
 /** Global cache of embedding backend instances, keyed by "provider:model". */
 const backendCache = new Map<string, EmbeddingBackend>();
 
@@ -69,6 +134,7 @@ export function clearEmbeddingBackendCache(): void {
   backendCache.clear();
   vectorCache.clear();
   vectorCacheBytes = 0;
+  localBackendBroken = false;
 }
 
 function cacheKey(provider: string, model: string): string {
@@ -106,7 +172,7 @@ export function selectEmbeddingBackend(config: AssistantConfig): EmbeddingBacken
   if (requested === 'local') {
     return {
       backend: getCachedOrCreate('local', config.memory.embeddings.localModel,
-        () => new LocalEmbeddingBackend(config.memory.embeddings.localModel)),
+        () => new LazyLocalEmbeddingBackend(config.memory.embeddings.localModel)),
       reason: null,
     };
   }
@@ -128,10 +194,10 @@ export function selectEmbeddingBackend(config: AssistantConfig): EmbeddingBacken
   for (const provider of order) {
     switch (provider) {
       case 'local':
-        // Local embeddings are always available (model downloaded on first use)
+        if (localBackendBroken) continue;
         return {
           backend: getCachedOrCreate('local', config.memory.embeddings.localModel,
-            () => new LocalEmbeddingBackend(config.memory.embeddings.localModel)),
+            () => new LazyLocalEmbeddingBackend(config.memory.embeddings.localModel)),
           reason: null,
         };
       case 'openai':

package/src/memory/embedding-local.ts

@@ -56,8 +56,18 @@ export class LocalEmbeddingBackend implements EmbeddingBackend {
 
   private async initialize(): Promise<void> {
     log.info({ model: this.model }, 'Loading local embedding model (first load downloads the model)');
-    const { pipeline } = await import('@huggingface/transformers');
-    this.extractor = await pipeline('feature-extraction', this.model, {
+    let transformers: typeof import('@huggingface/transformers');
+    try {
+      transformers = await import('@huggingface/transformers');
+    } catch (err) {
+      // onnxruntime-node is not bundled in compiled binaries, so the import
+      // fails at runtime. Surface a clear error so callers can fall back to
+      // another embedding backend.
+      throw new Error(
+        `Local embedding backend unavailable: failed to load @huggingface/transformers (${err instanceof Error ? err.message : String(err)})`,
+      );
+    }
+    this.extractor = await transformers.pipeline('feature-extraction', this.model, {
       dtype: 'fp32',
     }) as unknown as FeatureExtractionPipeline;
     log.info({ model: this.model }, 'Local embedding model loaded');

package/src/memory/entity-extractor.ts

@@ -4,7 +4,7 @@ import type { MemoryEntityConfig } from '../config/types.js';
 import { createTimeout, extractToolUse, getConfiguredProvider, userMessage } from '../providers/provider-send-message.js';
 import { getLogger } from '../util/logger.js';
 import { truncate } from '../util/truncate.js';
-import { getDb } from './db.js';
+import { getDb, rawAll } from './db.js';
 import { memoryEntities, memoryEntityRelations, memoryItemEntities } from './schema.js';
 
 const log = getLogger('memory-entity-extractor');
@@ -426,20 +426,15 @@ function parseExtractedRelations(
 function findEntityCandidates(nameOrAlias: string): Array<typeof memoryEntities.$inferSelect> {
   const normalized = normalizeEntityName(nameOrAlias);
   if (!normalized) return [];
-  const db = getDb();
   const nameLower = normalized.toLowerCase();
 
-  const raw = (db as unknown as {
-    $client: { query: (q: string) => { all: (...params: unknown[]) => unknown[] } };
-  }).$client;
-
-  return raw.query(`
+  return rawAll<typeof memoryEntities.$inferSelect>(`
     SELECT DISTINCT me.* FROM memory_entities me
     WHERE LOWER(me.name) = ?
     UNION
     SELECT DISTINCT me.* FROM memory_entities me, json_each(me.aliases) je
     WHERE me.aliases IS NOT NULL AND LOWER(je.value) = ?
-  `).all(nameLower, nameLower) as Array<typeof memoryEntities.$inferSelect>;
+  `, nameLower, nameLower);
 }
 
 /**

package/src/memory/fts-reconciler.ts

@@ -0,0 +1,121 @@
+import { getLogger } from '../util/logger.js';
+import { rawGet, rawRun } from './db.js';
+
+const log = getLogger('fts-reconciler');
+
+export interface FtsReconciliationResult {
+  table: string;
+  baseCount: number;
+  ftsCount: number;
+  missingInserted: number;
+  orphansRemoved: number;
+  staleRefreshed: number;
+}
+
+/**
+ * Reconcile a single FTS index against its base table. Detects missing entries
+ * (rows in the base table with no corresponding FTS row) and orphaned entries
+ * (FTS rows whose base table row no longer exists), then repairs both.
+ *
+ * This is lighter than a full rebuild — it only touches the delta rather than
+ * wiping and re-inserting the entire index.
+ */
+function reconcileTable(opts: {
+  ftsTable: string;
+  ftsIdColumn: string;
+  ftsContentColumn: string;
+  baseTable: string;
+  baseIdColumn: string;
+  baseContentColumn: string;
+}): FtsReconciliationResult {
+  const { ftsTable, ftsIdColumn, ftsContentColumn, baseTable, baseIdColumn, baseContentColumn } = opts;
+
+  const baseCount = (rawGet<{ c: number }>(`SELECT COUNT(*) AS c FROM ${baseTable}`) ?? { c: 0 }).c;
+  const ftsCount = (rawGet<{ c: number }>(`SELECT COUNT(*) AS c FROM ${ftsTable}`) ?? { c: 0 }).c;
+
+  // Find base table rows missing from the FTS index
+  const missingInserted = rawRun(/*sql*/ `
+    INSERT INTO ${ftsTable}(${ftsIdColumn}, ${ftsContentColumn})
+    SELECT b.${baseIdColumn}, b.${baseContentColumn}
+    FROM ${baseTable} b
+    LEFT JOIN ${ftsTable} f ON f.${ftsIdColumn} = b.${baseIdColumn}
+    WHERE f.${ftsIdColumn} IS NULL
+  `);
+
+  // Find FTS rows whose base table row no longer exists
+  const orphansRemoved = rawRun(/*sql*/ `
+    DELETE FROM ${ftsTable}
+    WHERE ${ftsIdColumn} IN (
+      SELECT f.${ftsIdColumn}
+      FROM ${ftsTable} f
+      LEFT JOIN ${baseTable} b ON b.${baseIdColumn} = f.${ftsIdColumn}
+      WHERE b.${baseIdColumn} IS NULL
+    )
+  `);
+
+  // Refresh FTS rows whose content is stale (base row was updated but the
+  // update trigger didn't fire or was missing). Delete-then-insert is the
+  // standard FTS5 update pattern.
+  const staleDeleted = rawRun(/*sql*/ `
+    DELETE FROM ${ftsTable}
+    WHERE ${ftsIdColumn} IN (
+      SELECT f.${ftsIdColumn}
+      FROM ${ftsTable} f
+      JOIN ${baseTable} b ON b.${baseIdColumn} = f.${ftsIdColumn}
+      WHERE b.${baseContentColumn} IS NOT f.${ftsContentColumn}
+    )
+  `);
+  if (staleDeleted > 0) {
+    rawRun(/*sql*/ `
+      INSERT INTO ${ftsTable}(${ftsIdColumn}, ${ftsContentColumn})
+      SELECT b.${baseIdColumn}, b.${baseContentColumn}
+      FROM ${baseTable} b
+      LEFT JOIN ${ftsTable} f ON f.${ftsIdColumn} = b.${baseIdColumn}
+      WHERE f.${ftsIdColumn} IS NULL
+    `);
+  }
+
+  return { table: ftsTable, baseCount, ftsCount, missingInserted, orphansRemoved, staleRefreshed: staleDeleted };
+}
+
+/**
+ * Reconcile all FTS indexes. Returns results for each table so callers can
+ * inspect what was repaired.
+ */
+export function reconcileFtsIndexes(): FtsReconciliationResult[] {
+  const results: FtsReconciliationResult[] = [];
+
+  // memory_segment_fts tracks memory_segments
+  const memResult = reconcileTable({
+    ftsTable: 'memory_segment_fts',
+    ftsIdColumn: 'segment_id',
+    ftsContentColumn: 'text',
+    baseTable: 'memory_segments',
+    baseIdColumn: 'id',
+    baseContentColumn: 'text',
+  });
+  results.push(memResult);
+  if (memResult.missingInserted > 0 || memResult.orphansRemoved > 0 || memResult.staleRefreshed > 0) {
+    log.info(memResult, 'Reconciled memory_segment_fts');
+  } else {
+    log.debug(memResult, 'memory_segment_fts is in sync');
+  }
+
+  // messages_fts tracks messages
+  const msgResult = reconcileTable({
+    ftsTable: 'messages_fts',
+    ftsIdColumn: 'message_id',
+    ftsContentColumn: 'content',
+    baseTable: 'messages',
+    baseIdColumn: 'id',
+    baseContentColumn: 'content',
+  });
+  results.push(msgResult);
+  if (msgResult.missingInserted > 0 || msgResult.orphansRemoved > 0 || msgResult.staleRefreshed > 0) {
+    log.info(msgResult, 'Reconciled messages_fts');
+  } else {
+    log.debug(msgResult, 'messages_fts is in sync');
+  }
+
+  return results;
+}