@vellumai/assistant 0.3.5 → 0.3.6

package/src/memory/db-init.ts

@@ -1,5 +1,4 @@
-import { Database } from 'bun:sqlite';
-import { getDb } from './db-connection.js';
+import { getDb, getSqliteFrom } from './db-connection.js';
 import { getLogger } from '../util/logger.js';
 import {
   migrateJobDeferrals,
@@ -12,7 +11,15 @@ import {
   migrateLlmUsageEventsDropAssistantId,
   migrateExtConvBindingsChannelChatUnique,
   migrateCallSessionsProviderSidDedup,
+  migrateCallSessionsAddInitiatedFrom,
   migrateMemoryFtsBackfill,
+  migrateGuardianActionTables,
+  migrateBackfillInboxThreadStateFromBindings,
+  migrateDropActiveSearchIndex,
+  migrateMemorySegmentsIndexes,
+  migrateMemoryItemsIndexes,
+  migrateRemainingTableIndexes,
+  validateMigrationState,
 } from './schema-migration.js';
 
 const log = getLogger('memory-db');
@@ -31,7 +38,8 @@ export function initializeDb(): void {
       total_estimated_cost REAL NOT NULL DEFAULT 0,
       context_summary TEXT,
       context_compacted_message_count INTEGER NOT NULL DEFAULT 0,
-      context_compacted_at INTEGER
+      context_compacted_at INTEGER,
+      source TEXT NOT NULL DEFAULT 'user'
     )
   `);
 
@@ -524,7 +532,9 @@ export function initializeDb(): void {
   try { database.run(/*sql*/ `ALTER TABLE channel_inbound_events ADD COLUMN retry_after INTEGER`); } catch { /* already exists */ }
   try { database.run(/*sql*/ `ALTER TABLE channel_inbound_events ADD COLUMN raw_payload TEXT`); } catch { /* already exists */ }
   try { database.run(/*sql*/ `ALTER TABLE conversations ADD COLUMN thread_type TEXT NOT NULL DEFAULT 'standard'`); } catch { /* already exists */ }
+  try { database.run(/*sql*/ `ALTER TABLE conversations ADD COLUMN source TEXT NOT NULL DEFAULT 'user'`); } catch { /* already exists */ }
   try { database.run(/*sql*/ `ALTER TABLE conversations ADD COLUMN memory_scope_id TEXT NOT NULL DEFAULT 'default'`); } catch { /* already exists */ }
+  try { database.run(/*sql*/ `ALTER TABLE conversations ADD COLUMN origin_channel TEXT`); } catch { /* already exists */ }
   try { database.run(/*sql*/ `ALTER TABLE attachments ADD COLUMN thumbnail_base64 TEXT`); } catch { /* already exists */ }
   try { database.run(/*sql*/ `ALTER TABLE cron_jobs ADD COLUMN schedule_syntax TEXT NOT NULL DEFAULT 'cron'`); } catch { /* already exists */ }
   try { database.run(/*sql*/ `ALTER TABLE messages ADD COLUMN metadata TEXT`); } catch { /* already exists */ }
@@ -542,6 +552,7 @@ export function initializeDb(): void {
   // Indexes for query performance on large datasets
   database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_llm_request_logs_conv_created ON llm_request_logs(conversation_id, created_at)`);
   database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_messages_conversation_id ON messages(conversation_id)`);
+  database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_messages_created_at ON messages(created_at)`);
   database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_tool_invocations_conversation_id ON tool_invocations(conversation_id)`);
   database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_conversations_updated_at ON conversations(updated_at)`);
   database.run(/*sql*/ `CREATE UNIQUE INDEX IF NOT EXISTS idx_memory_segments_message_segment ON memory_segments(message_id, segment_index)`);
@@ -558,10 +569,21 @@ export function initializeDb(): void {
     WHERE status = 'pending_clarification'
   `);
   database.run(/*sql*/ `CREATE UNIQUE INDEX IF NOT EXISTS idx_memory_items_fingerprint_scope ON memory_items(fingerprint, scope_id)`);
+  database.run(/*sql*/ `DROP INDEX IF EXISTS idx_memory_items_fingerprint`);
   database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_memory_items_kind_status ON memory_items(kind, status)`);
   database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_memory_items_status_invalid_at ON memory_items(status, invalid_at)`);
   database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_memory_items_scope_status_kind ON memory_items(scope_id, status, kind)`);
+  database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_memory_items_scope_kind_status ON memory_items(scope_id, kind, status)`);
   database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_memory_items_last_seen_at ON memory_items(last_seen_at)`);
+  // Partial covering index for directItemSearch: the LIKE '%term%' pattern can't
+  // seek a B-tree, but this index lets SQLite scan only active non-invalidated rows
+  // and evaluate LIKE + return columns without touching the main table.
+  migrateDropActiveSearchIndex(database);
+  database.run(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_items_active_search
+    ON memory_items(status, invalid_at, last_seen_at DESC, subject, statement, id, kind, confidence, importance, first_seen_at, scope_id)
+    WHERE status = 'active' AND invalid_at IS NULL
+  `);
   database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_memory_embeddings_target ON memory_embeddings(target_type, target_id)`);
   database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_memory_embeddings_provider_model ON memory_embeddings(provider, model)`);
   database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_memory_embeddings_content_hash ON memory_embeddings(content_hash, provider, model)`);
@@ -583,7 +605,7 @@ export function initializeDb(): void {
   // Deduplicate before creating unique index — existing DBs may have duplicate content_hash values.
   // Re-point message_attachments to the survivor (MIN rowid per content_hash), then delete dupes.
   {
-    const raw = (database as unknown as { $client: Database }).$client;
+    const raw = getSqliteFrom(database);
     raw.exec(/*sql*/ `
       UPDATE message_attachments
       SET attachment_id = (
@@ -782,6 +804,12 @@ export function initializeDb(): void {
   try { database.run(/*sql*/ `ALTER TABLE call_sessions ADD COLUMN caller_identity_mode TEXT`); } catch { /* already exists */ }
   try { database.run(/*sql*/ `ALTER TABLE call_sessions ADD COLUMN caller_identity_source TEXT`); } catch { /* already exists */ }
 
+  // Persist assistantId so the webhook path can resolve assistant-scoped Twilio numbers
+  try { database.run(/*sql*/ `ALTER TABLE call_sessions ADD COLUMN assistant_id TEXT`); } catch { /* already exists */ }
+
+  // Track which conversation initiated the call (the chat where call_start was invoked)
+  migrateCallSessionsAddInitiatedFrom(database);
+
   // Unique constraint: at most one non-null provider_call_sid per (provider, provider_call_sid).
   // On upgraded databases that pre-date this constraint, duplicate rows may exist; deduplicate
   // them first to avoid a UNIQUE constraint failure that would prevent startup.
@@ -1159,5 +1187,94 @@ export function initializeDb(): void {
   database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_media_event_feedback_event_id ON media_event_feedback(event_id)`);
   database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_media_event_feedback_type ON media_event_feedback(asset_id, feedback_type)`);
 
+  // ── Assistant Inbox ──────────────────────────────────────────────────
+
+  database.run(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS assistant_ingress_invites (
+      id TEXT PRIMARY KEY,
+      assistant_id TEXT NOT NULL DEFAULT 'self',
+      source_channel TEXT NOT NULL,
+      token_hash TEXT NOT NULL,
+      created_by_session_id TEXT,
+      note TEXT,
+      max_uses INTEGER NOT NULL DEFAULT 1 CHECK (max_uses > 0),
+      use_count INTEGER NOT NULL DEFAULT 0 CHECK (use_count >= 0),
+      expires_at INTEGER NOT NULL,
+      status TEXT NOT NULL DEFAULT 'active',
+      redeemed_by_external_user_id TEXT,
+      redeemed_by_external_chat_id TEXT,
+      redeemed_at INTEGER,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+
+  database.run(/*sql*/ `CREATE UNIQUE INDEX IF NOT EXISTS idx_ingress_invites_token_hash ON assistant_ingress_invites(token_hash)`);
+  database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_ingress_invites_channel_status ON assistant_ingress_invites(assistant_id, source_channel, status, expires_at)`);
+  database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_ingress_invites_channel_created ON assistant_ingress_invites(assistant_id, source_channel, created_at)`);
+
+  database.run(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS assistant_ingress_members (
+      id TEXT PRIMARY KEY,
+      assistant_id TEXT NOT NULL DEFAULT 'self',
+      source_channel TEXT NOT NULL,
+      external_user_id TEXT,
+      external_chat_id TEXT,
+      display_name TEXT,
+      username TEXT,
+      status TEXT NOT NULL DEFAULT 'pending',
+      policy TEXT NOT NULL DEFAULT 'allow',
+      invite_id TEXT REFERENCES assistant_ingress_invites(id),
+      created_by_session_id TEXT,
+      revoked_reason TEXT,
+      blocked_reason TEXT,
+      last_seen_at INTEGER,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      CHECK (external_user_id IS NOT NULL OR external_chat_id IS NOT NULL)
+    )
+  `);
+
+  database.run(/*sql*/ `CREATE UNIQUE INDEX IF NOT EXISTS idx_ingress_members_user ON assistant_ingress_members(assistant_id, source_channel, external_user_id) WHERE external_user_id IS NOT NULL`);
+  database.run(/*sql*/ `CREATE UNIQUE INDEX IF NOT EXISTS idx_ingress_members_chat ON assistant_ingress_members(assistant_id, source_channel, external_chat_id) WHERE external_chat_id IS NOT NULL`);
+  database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_ingress_members_status_policy ON assistant_ingress_members(assistant_id, source_channel, status, policy)`);
+  database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_ingress_members_updated ON assistant_ingress_members(assistant_id, source_channel, updated_at)`);
+
+  database.run(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS assistant_inbox_thread_state (
+      conversation_id TEXT PRIMARY KEY REFERENCES conversations(id) ON DELETE CASCADE,
+      assistant_id TEXT NOT NULL DEFAULT 'self',
+      source_channel TEXT NOT NULL,
+      external_chat_id TEXT NOT NULL,
+      external_user_id TEXT,
+      display_name TEXT,
+      username TEXT,
+      last_inbound_at INTEGER,
+      last_outbound_at INTEGER,
+      last_message_at INTEGER,
+      unread_count INTEGER NOT NULL DEFAULT 0,
+      pending_escalation_count INTEGER NOT NULL DEFAULT 0,
+      has_pending_escalation INTEGER NOT NULL DEFAULT 0,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+
+  database.run(/*sql*/ `CREATE UNIQUE INDEX IF NOT EXISTS idx_inbox_thread_state_channel ON assistant_inbox_thread_state(assistant_id, source_channel, external_chat_id)`);
+  database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_inbox_thread_state_last_msg ON assistant_inbox_thread_state(assistant_id, last_message_at)`);
+  database.run(/*sql*/ `CREATE INDEX IF NOT EXISTS idx_inbox_thread_state_escalation ON assistant_inbox_thread_state(assistant_id, has_pending_escalation, last_message_at)`);
+
+  migrateBackfillInboxThreadStateFromBindings(database);
+
+  migrateGuardianActionTables(database);
+
   migrateMemoryFtsBackfill(database);
+
+  migrateMemorySegmentsIndexes(database);
+
+  migrateMemoryItemsIndexes(database);
+
+  migrateRemainingTableIndexes(database);
+
+  validateMigrationState(database);
 }

package/src/memory/db.ts

@@ -1,2 +1,15 @@
-export { getDb, resetDb } from './db-connection.js';
+export { getDb, resetDb, getSqlite, getSqliteFrom, type DrizzleDb } from './db-connection.js';
 export { initializeDb } from './db-init.js';
+export {
+  rawGet,
+  rawAll,
+  rawRun,
+  rawExec,
+  rawChanges,
+  rawGetFrom,
+  rawAllFrom,
+  rawRunFrom,
+  rawExecFrom,
+  rawPrepare,
+  rawPrepareFrom,
+} from './raw-query.js';

package/src/memory/embedding-backend.ts

@@ -1,6 +1,7 @@
 import { createHash } from 'node:crypto';
 import type { AssistantConfig } from '../config/types.js';
 import { getLogger } from '../util/logger.js';
+import { getOllamaBaseUrlEnv } from '../config/env.js';
 import { GeminiEmbeddingBackend } from './embedding-gemini.js';
 import { LocalEmbeddingBackend } from './embedding-local.js';
 import { OllamaEmbeddingBackend } from './embedding-ollama.js';
@@ -14,8 +15,17 @@ const backendCache = new Map<string, EmbeddingBackend>();
 // ── In-memory embedding vector cache ──────────────────────────────
 // LRU cache keyed by sha256(provider + model + text) → embedding vector.
 // Avoids redundant API calls / local compute for identical content.
-const VECTOR_CACHE_MAX_ENTRIES = 4096;
+// Eviction is based on estimated byte size (32 MB cap) rather than entry count,
+// since vector dimensions vary across providers/models.
+const VECTOR_CACHE_MAX_BYTES = 33_554_432; // 32 MB
 const vectorCache = new Map<string, number[]>();
+let vectorCacheBytes = 0;
+
+/** Estimate in-memory byte cost of a single cache entry. */
+function estimateEntryBytes(key: string, vector: number[]): number {
+  // key: UTF-16 chars (2 bytes each) + vector: 8 bytes per float64
+  return key.length * 2 + vector.length * 8;
+}
 
 function vectorCacheKey(provider: string, model: string, text: string): string {
   return createHash('sha256').update(`${provider}\0${model}\0${text}`).digest('hex');
@@ -34,18 +44,30 @@ function getFromVectorCache(provider: string, model: string, text: string): numb
 
 function putInVectorCache(provider: string, model: string, text: string, vector: number[]): void {
   const key = vectorCacheKey(provider, model, text);
-  vectorCache.delete(key);
-  if (vectorCache.size >= VECTOR_CACHE_MAX_ENTRIES) {
+  // If replacing an existing entry, subtract its old cost first
+  const existing = vectorCache.get(key);
+  if (existing !== undefined) {
+    vectorCacheBytes -= estimateEntryBytes(key, existing);
+    vectorCache.delete(key);
+  }
+  const entryBytes = estimateEntryBytes(key, vector);
+  // Evict oldest entries until we have room
+  while (vectorCacheBytes + entryBytes > VECTOR_CACHE_MAX_BYTES && vectorCache.size > 0) {
     const oldest = vectorCache.keys().next().value;
-    if (oldest !== undefined) vectorCache.delete(oldest);
+    if (oldest === undefined) break;
+    const oldVec = vectorCache.get(oldest)!;
+    vectorCacheBytes -= estimateEntryBytes(oldest, oldVec);
+    vectorCache.delete(oldest);
   }
   vectorCache.set(key, vector);
+  vectorCacheBytes += entryBytes;
 }
 
 /** Clear cached embedding backends and the in-memory vector cache. */
 export function clearEmbeddingBackendCache(): void {
   backendCache.clear();
   vectorCache.clear();
+  vectorCacheBytes = 0;
 }
 
 function cacheKey(provider: string, model: string): string {
@@ -293,5 +315,5 @@ function selectFallbackBackends(config: AssistantConfig, exclude: EmbeddingProvi
 function isOllamaConfigured(config: AssistantConfig): boolean {
   return config.provider === 'ollama'
     || Boolean(config.apiKeys.ollama)
-    || Boolean(process.env.OLLAMA_BASE_URL);
+    || Boolean(getOllamaBaseUrlEnv());
 }

package/src/memory/embedding-ollama.ts

@@ -1,4 +1,5 @@
 import type { EmbeddingBackend, EmbeddingRequestOptions } from './embedding-backend.js';
+import { getOllamaBaseUrlEnv } from '../config/env.js';
 
 interface OllamaEmbeddingsResponse {
   data?: Array<{ embedding: number[] }>;
@@ -49,7 +50,7 @@ export class OllamaEmbeddingBackend implements EmbeddingBackend {
 }
 
 function resolveBaseUrl(override?: string): string {
-  const value = (override ?? process.env.OLLAMA_BASE_URL ?? DEFAULT_OLLAMA_BASE_URL).trim();
+  const value = (override ?? getOllamaBaseUrlEnv() ?? DEFAULT_OLLAMA_BASE_URL).trim();
   if (value.endsWith('/')) return value.slice(0, -1);
   return value;
 }

package/src/memory/entity-extractor.ts

@@ -1,9 +1,8 @@
-import Anthropic from '@anthropic-ai/sdk';
 import { eq, sql } from 'drizzle-orm';
-import { getConfig } from '../config/loader.js';
 import type { MemoryEntityConfig } from '../config/types.js';
 import { getLogger } from '../util/logger.js';
 import { truncate } from '../util/truncate.js';
+import { getConfiguredProvider, createTimeout, extractToolUse, userMessage } from '../providers/provider-send-message.js';
 import { getDb } from './db.js';
 import { memoryEntities, memoryEntityRelations, memoryItemEntities } from './schema.js';
 
@@ -123,51 +122,55 @@ export async function extractEntitiesWithLLM(
   text: string,
   entityConfig: MemoryEntityConfig,
 ): Promise<ExtractedEntityGraph> {
-  const config = getConfig();
-  const apiKey = config.apiKeys.anthropic ?? process.env.ANTHROPIC_API_KEY;
-  if (!apiKey) {
-    log.debug('No Anthropic API key available for entity extraction');
+  const provider = getConfiguredProvider();
+  if (!provider) {
+    log.debug('Configured provider unavailable for entity extraction');
     return { entities: [], relations: [] };
   }
 
   const extractRelations = entityConfig.extractRelations?.enabled ?? false;
 
   try {
-    const client = new Anthropic({ apiKey });
-    const response = await Promise.race([
-      client.messages.create({
-        model: entityConfig.model,
-        max_tokens: 1024,
-        system: ENTITY_EXTRACTION_SYSTEM_PROMPT,
-        tools: [{
+    const { signal, cleanup } = createTimeout(ENTITY_EXTRACTION_TIMEOUT_MS);
+    try {
+      const response = await provider.sendMessage(
+        [userMessage(text)],
+        [{
           name: 'store_entities',
           description: 'Store extracted entities from the text',
           input_schema: buildToolInputSchema(extractRelations),
         }],
-        tool_choice: { type: 'tool' as const, name: 'store_entities' },
-        messages: [{ role: 'user' as const, content: text }],
-      }) as Promise<Anthropic.Message>,
-      new Promise<never>((_, reject) =>
-        setTimeout(() => reject(new Error('Entity extraction LLM timeout')), ENTITY_EXTRACTION_TIMEOUT_MS),
-      ),
-    ]) as Anthropic.Message;
-
-    const toolBlock = response.content.find((block) => block.type === 'tool_use');
-    if (!toolBlock || toolBlock.type !== 'tool_use') {
-      log.warn('No tool_use block in entity extraction response');
-      return { entities: [], relations: [] };
-    }
+        ENTITY_EXTRACTION_SYSTEM_PROMPT,
+        {
+          config: {
+            model: entityConfig.model,
+            max_tokens: 1024,
+            tool_choice: { type: 'tool' as const, name: 'store_entities' },
+          },
+          signal,
+        },
+      );
+      cleanup();
 
-    const input = toolBlock.input as { entities?: LLMExtractedEntity[]; relations?: LLMExtractedRelation[] };
-    if (!Array.isArray(input.entities)) {
-      log.warn('Invalid entities in entity extraction response');
-      return { entities: [], relations: [] };
-    }
+      const toolBlock = extractToolUse(response);
+      if (!toolBlock) {
+        log.warn('No tool_use block in entity extraction response');
+        return { entities: [], relations: [] };
+      }
+
+      const input = toolBlock.input as { entities?: LLMExtractedEntity[]; relations?: LLMExtractedRelation[] };
+      if (!Array.isArray(input.entities)) {
+        log.warn('Invalid entities in entity extraction response');
+        return { entities: [], relations: [] };
+      }
 
-    const entities = parseExtractedEntities(input.entities);
-    const relations = extractRelations ? parseExtractedRelations(input.relations) : [];
+      const entities = parseExtractedEntities(input.entities);
+      const relations = extractRelations ? parseExtractedRelations(input.relations) : [];
 
-    return { entities, relations };
+      return { entities, relations };
+    } finally {
+      cleanup();
+    }
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     log.warn({ err: message }, 'Entity extraction LLM call failed');
@@ -284,7 +287,7 @@ export function upsertEntityRelation(input: UpsertEntityRelationInput): void {
       memoryEntityRelations.targetEntityId,
       memoryEntityRelations.relation,
     ],
-    set: normalizedEvidence === null
+    set: normalizedEvidence === undefined
       ? {
         firstSeenAt: sql`MIN(${memoryEntityRelations.firstSeenAt}, ${seenAt})`,
         lastSeenAt: sql`MAX(${memoryEntityRelations.lastSeenAt}, ${seenAt})`,