@vellumai/assistant 0.3.5 → 0.3.7

package/src/memory/schema.ts

@@ -1,4 +1,4 @@
-import { sqliteTable, text, integer, real, blob } from 'drizzle-orm/sqlite-core';
+import { sqliteTable, text, integer, real, blob, index } from 'drizzle-orm/sqlite-core';
 
 export const conversations = sqliteTable('conversations', {
   id: text('id').primaryKey(),
@@ -12,7 +12,9 @@ export const conversations = sqliteTable('conversations', {
   contextCompactedMessageCount: integer('context_compacted_message_count').notNull().default(0),
   contextCompactedAt: integer('context_compacted_at'),
   threadType: text('thread_type').notNull().default('standard'),
+  source: text('source').notNull().default('user'),
   memoryScopeId: text('memory_scope_id').notNull().default('default'),
+  originChannel: text('origin_channel'),
 });
 
 export const messages = sqliteTable('messages', {
@@ -24,7 +26,9 @@ export const messages = sqliteTable('messages', {
   content: text('content').notNull(),
   createdAt: integer('created_at').notNull(),
   metadata: text('metadata'),
-});
+}, (table) => [
+  index('idx_messages_conversation_id').on(table.conversationId),
+]);
 
 export const toolInvocations = sqliteTable('tool_invocations', {
   id: text('id').primaryKey(),
@@ -38,7 +42,9 @@ export const toolInvocations = sqliteTable('tool_invocations', {
   riskLevel: text('risk_level').notNull(),
   durationMs: integer('duration_ms').notNull(),
   createdAt: integer('created_at').notNull(),
-});
+}, (table) => [
+  index('idx_tool_invocations_conversation_id').on(table.conversationId),
+]);
 
 export const memorySegments = sqliteTable('memory_segments', {
   id: text('id').primaryKey(),
@@ -56,7 +62,10 @@ export const memorySegments = sqliteTable('memory_segments', {
   contentHash: text('content_hash'),
   createdAt: integer('created_at').notNull(),
   updatedAt: integer('updated_at').notNull(),
-});
+}, (table) => [
+  index('idx_memory_segments_scope_id').on(table.scopeId),
+  index('idx_memory_segments_conversation_id').on(table.conversationId),
+]);
 
 export const memoryItems = sqliteTable('memory_items', {
   id: text('id').primaryKey(),
@@ -75,7 +84,10 @@ export const memoryItems = sqliteTable('memory_items', {
   lastUsedAt: integer('last_used_at'),
   validFrom: integer('valid_from'),
   invalidAt: integer('invalid_at'),
-});
+}, (table) => [
+  index('idx_memory_items_scope_id').on(table.scopeId),
+  index('idx_memory_items_fingerprint').on(table.fingerprint),
+]);
 
 export const memoryItemSources = sqliteTable('memory_item_sources', {
   memoryItemId: text('memory_item_id')
@@ -105,7 +117,9 @@ export const memoryItemConflicts = sqliteTable('memory_item_conflicts', {
   resolvedAt: integer('resolved_at'),
   createdAt: integer('created_at').notNull(),
   updatedAt: integer('updated_at').notNull(),
-});
+}, (table) => [
+  index('idx_memory_item_conflicts_scope_id').on(table.scopeId),
+]);
 
 export const memorySummaries = sqliteTable('memory_summaries', {
   id: text('id').primaryKey(),
@@ -119,7 +133,9 @@ export const memorySummaries = sqliteTable('memory_summaries', {
   endAt: integer('end_at').notNull(),
   createdAt: integer('created_at').notNull(),
   updatedAt: integer('updated_at').notNull(),
-});
+}, (table) => [
+  index('idx_memory_summaries_scope_id').on(table.scopeId),
+]);
 
 export const memoryEmbeddings = sqliteTable('memory_embeddings', {
   id: text('id').primaryKey(),
@@ -551,6 +567,8 @@ export const callSessions = sqliteTable('call_sessions', {
   status: text('status').notNull().default('initiated'),
   callerIdentityMode: text('caller_identity_mode'),
   callerIdentitySource: text('caller_identity_source'),
+  assistantId: text('assistant_id'),
+  initiatedFromConversationId: text('initiated_from_conversation_id'),
   startedAt: integer('started_at'),
   endedAt: integer('ended_at'),
   lastError: text('last_error'),
@@ -778,3 +796,108 @@ export const mediaEventFeedback = sqliteTable('media_event_feedback', {
   notes: text('notes'),
   createdAt: integer('created_at').notNull(),
 });
+
+// ── Guardian Action Requests (cross-channel voice guardian) ──────────
+
+export const guardianActionRequests = sqliteTable('guardian_action_requests', {
+  id: text('id').primaryKey(),
+  assistantId: text('assistant_id').notNull().default('self'),
+  kind: text('kind').notNull(),                                  // 'ask_guardian'
+  sourceChannel: text('source_channel').notNull(),               // 'voice'
+  sourceConversationId: text('source_conversation_id').notNull(),
+  callSessionId: text('call_session_id')
+    .notNull()
+    .references(() => callSessions.id, { onDelete: 'cascade' }),
+  pendingQuestionId: text('pending_question_id')
+    .notNull()
+    .references(() => callPendingQuestions.id, { onDelete: 'cascade' }),
+  questionText: text('question_text').notNull(),
+  requestCode: text('request_code').notNull(),                   // short human-readable code for routing replies
+  status: text('status').notNull().default('pending'),           // pending | answered | expired | cancelled
+  answerText: text('answer_text'),
+  answeredByChannel: text('answered_by_channel'),
+  answeredByExternalUserId: text('answered_by_external_user_id'),
+  answeredAt: integer('answered_at'),
+  expiresAt: integer('expires_at').notNull(),
+  createdAt: integer('created_at').notNull(),
+  updatedAt: integer('updated_at').notNull(),
+});
+
+// ── Guardian Action Deliveries (per-channel delivery tracking) ───────
+
+export const guardianActionDeliveries = sqliteTable('guardian_action_deliveries', {
+  id: text('id').primaryKey(),
+  requestId: text('request_id')
+    .notNull()
+    .references(() => guardianActionRequests.id, { onDelete: 'cascade' }),
+  destinationChannel: text('destination_channel').notNull(),       // 'telegram' | 'sms' | 'macos'
+  destinationConversationId: text('destination_conversation_id'),
+  destinationChatId: text('destination_chat_id'),
+  destinationExternalUserId: text('destination_external_user_id'),
+  status: text('status').notNull().default('pending'),             // pending | sent | failed | answered | expired | cancelled
+  sentAt: integer('sent_at'),
+  respondedAt: integer('responded_at'),
+  lastError: text('last_error'),
+  createdAt: integer('created_at').notNull(),
+  updatedAt: integer('updated_at').notNull(),
+});
+
+// ── Assistant Inbox ──────────────────────────────────────────────────
+
+export const assistantIngressInvites = sqliteTable('assistant_ingress_invites', {
+  id: text('id').primaryKey(),
+  assistantId: text('assistant_id').notNull().default('self'),
+  sourceChannel: text('source_channel').notNull(),
+  tokenHash: text('token_hash').notNull(),
+  createdBySessionId: text('created_by_session_id'),
+  note: text('note'),
+  maxUses: integer('max_uses').notNull().default(1),
+  useCount: integer('use_count').notNull().default(0),
+  expiresAt: integer('expires_at').notNull(),
+  status: text('status').notNull().default('active'),
+  redeemedByExternalUserId: text('redeemed_by_external_user_id'),
+  redeemedByExternalChatId: text('redeemed_by_external_chat_id'),
+  redeemedAt: integer('redeemed_at'),
+  createdAt: integer('created_at').notNull(),
+  updatedAt: integer('updated_at').notNull(),
+});
+
+export const assistantIngressMembers = sqliteTable('assistant_ingress_members', {
+  id: text('id').primaryKey(),
+  assistantId: text('assistant_id').notNull().default('self'),
+  sourceChannel: text('source_channel').notNull(),
+  externalUserId: text('external_user_id'),
+  externalChatId: text('external_chat_id'),
+  displayName: text('display_name'),
+  username: text('username'),
+  status: text('status').notNull().default('pending'),
+  policy: text('policy').notNull().default('allow'),
+  inviteId: text('invite_id')
+    .references(() => assistantIngressInvites.id),
+  createdBySessionId: text('created_by_session_id'),
+  revokedReason: text('revoked_reason'),
+  blockedReason: text('blocked_reason'),
+  lastSeenAt: integer('last_seen_at'),
+  createdAt: integer('created_at').notNull(),
+  updatedAt: integer('updated_at').notNull(),
+});
+
+export const assistantInboxThreadState = sqliteTable('assistant_inbox_thread_state', {
+  conversationId: text('conversation_id')
+    .primaryKey()
+    .references(() => conversations.id, { onDelete: 'cascade' }),
+  assistantId: text('assistant_id').notNull().default('self'),
+  sourceChannel: text('source_channel').notNull(),
+  externalChatId: text('external_chat_id').notNull(),
+  externalUserId: text('external_user_id'),
+  displayName: text('display_name'),
+  username: text('username'),
+  lastInboundAt: integer('last_inbound_at'),
+  lastOutboundAt: integer('last_outbound_at'),
+  lastMessageAt: integer('last_message_at'),
+  unreadCount: integer('unread_count').notNull().default(0),
+  pendingEscalationCount: integer('pending_escalation_count').notNull().default(0),
+  hasPendingEscalation: integer('has_pending_escalation').notNull().default(0),
+  createdAt: integer('created_at').notNull(),
+  updatedAt: integer('updated_at').notNull(),
+});

package/src/memory/search/entity.ts

@@ -1,7 +1,7 @@
 import { and, desc, eq, inArray, isNull, or } from 'drizzle-orm';
 import type { MemoryEntityConfig } from '../../config/types.js';
 import { getLogger } from '../../util/logger.js';
-import { getDb } from '../db.js';
+import { getDb, rawAll } from '../db.js';
 import {
   memoryEntityRelations,
   memoryItemEntities,
@@ -130,8 +130,6 @@ export function findMatchedEntities(query: string, maxMatches: number): MatchedE
   const trimmed = query.trim();
   if (trimmed.length === 0) return [];
 
-  const db = getDb();
-  const raw = (db as unknown as { $client: { query: (q: string) => { all: (...params: unknown[]) => unknown[] } } }).$client;
   const safeLimit = Math.max(1, Math.floor(maxMatches));
 
   // Tokenize query into words for entity matching (min length 3 to reduce false positives)
@@ -173,14 +171,12 @@ export function findMatchedEntities(query: string, maxMatches: number): MatchedE
     queryParams = [fullQuery, fullQuery];
   }
 
-  let matchedEntities: MatchedEntityRow[] = [];
   try {
-    matchedEntities = raw.query(entityQuery).all(...queryParams) as MatchedEntityRow[];
+    return rawAll<MatchedEntityRow>(entityQuery, ...queryParams);
   } catch (err) {
     log.warn({ err }, 'Entity search query failed');
     return [];
   }
-  return matchedEntities;
 }
 
 /**
@@ -225,9 +221,10 @@ export function findNeighborEntities(
       const frontierPlaceholders = frontier.map(() => '?').join(',');
       const limit = Math.max(1, edgeBudget);
 
-      const raw = (db as unknown as { $client: { query: (q: string) => { all: (...params: unknown[]) => unknown[] } } }).$client;
       const relationParams = relationTypes && relationTypes.length > 0 ? relationTypes : [];
 
+      type EdgeRow = { sourceEntityId: string; targetEntityId: string };
+
       if (directed) {
         // GROUP BY deduplicates entity pairs that have multiple relation rows
         const q1 = `
@@ -240,8 +237,7 @@ export function findNeighborEntities(
           ORDER BY MAX(r.last_seen_at) DESC
           LIMIT ?
         `;
-        const params1 = [...frontier, ...relationParams, ...entityTypes, limit];
-        rows = raw.query(q1).all(...params1) as Array<{ sourceEntityId: string; targetEntityId: string }>;
+        rows = rawAll<EdgeRow>(q1, ...frontier, ...relationParams, ...entityTypes, limit);
       } else {
         // Combine both directions in a single query with global recency
         // ordering so the edge budget isn't direction-biased.
@@ -263,17 +259,12 @@ export function findNeighborEntities(
           ORDER BY MAX(last_seen_at) DESC
           LIMIT ?
         `;
-        const params = [
-          ...frontier,
-          ...relationParams,
-          ...entityTypes,
-          ...frontier,
-          ...relationParams,
-          ...entityTypes,
+        rows = rawAll<EdgeRow>(
+          q,
+          ...frontier, ...relationParams, ...entityTypes,
+          ...frontier, ...relationParams, ...entityTypes,
           limit,
-        ];
-
-        rows = raw.query(q).all(...params) as Array<{ sourceEntityId: string; targetEntityId: string }>;
+        );
       }
     } else {
       const frontierCondition = directed

package/src/memory/search/lexical.ts

@@ -1,62 +1,91 @@
 import { and, desc, eq, inArray, notInArray } from 'drizzle-orm';
 import { getLogger } from '../../util/logger.js';
-import { getDb } from '../db.js';
+import { getDb, rawAll } from '../db.js';
 import { memorySegments } from '../schema.js';
 import type { Candidate, CandidateType } from './types.js';
 import { computeRecencyScore } from './ranking.js';
 
 const log = getLogger('memory-retriever');
 
+// Threshold beyond which a raw SQL query is considered slow and logged as a warning.
+const SLOW_QUERY_MS = 2000;
+
+/**
+ * Execute a synchronous raw SQL query with timing. Logs a warning if the
+ * query exceeds SLOW_QUERY_MS. Since bun:sqlite queries are synchronous,
+ * we can't abort them mid-execution, but we can detect and report slowness.
+ */
+function timedRawQuery<T>(label: string, fn: () => T[]): T[] {
+  const start = performance.now();
+  const result = fn();
+  const elapsed = performance.now() - start;
+  if (elapsed >= SLOW_QUERY_MS) {
+    log.warn({ label, elapsedMs: Math.round(elapsed) }, 'Raw SQL query exceeded slow threshold');
+  }
+  return result;
+}
+
+interface FtsRow {
+  segment_id: string;
+  message_id: string;
+  text: string;
+  created_at: number;
+  rank: number;
+}
+
 export function lexicalSearch(query: string, limit: number, excludedMessageIds: string[] = [], scopeIds?: string[]): Candidate[] {
   const trimmed = query.trim();
   if (trimmed.length === 0 || limit <= 0) return [];
   const matchQuery = buildFtsMatchQuery(trimmed);
   if (!matchQuery) return [];
   const excluded = new Set(excludedMessageIds);
-  const db = getDb();
-  const raw = (db as unknown as { $client: { query: (q: string) => { all: (...params: unknown[]) => unknown[] } } }).$client;
-  let rows: Array<{
-    segment_id: string;
-    message_id: string;
-    text: string;
-    created_at: number;
-    rank: number;
-  }> = [];
-  const queryLimit = excluded.size > 0
-    ? Math.max(limit + 24, limit * 2)
-    : limit;
   const scopeClause = scopeIds
     ? ` AND s.scope_id IN (${scopeIds.map(() => '?').join(',')})`
     : '';
-  const params: unknown[] = [matchQuery, ...(scopeIds ?? []), queryLimit];
-  try {
-    rows = raw.query(`
-      SELECT
-        f.segment_id AS segment_id,
-        s.message_id AS message_id,
-        s.text AS text,
-        s.created_at AS created_at,
-        bm25(memory_segment_fts) AS rank
-      FROM memory_segment_fts f
-      JOIN memory_segments s ON s.id = f.segment_id
-      WHERE memory_segment_fts MATCH ?${scopeClause}
-      ORDER BY rank
-      LIMIT ?
-    `).all(...params) as Array<{
-      segment_id: string;
-      message_id: string;
-      text: string;
-      created_at: number;
-      rank: number;
-    }>;
-  } catch (err) {
-    log.warn({ err, query: truncate(trimmed, 80) }, 'Memory lexical search query parse failed');
-    return [];
+
+  // Adaptive overfetch: when exclusions are present, double the SQL LIMIT until we
+  // collect `limit` visible rows or the DB has no more matching results to offer.
+  // This handles dense exclusion sets without wasteful fixed-ratio over-fetching.
+  const MAX_FETCH_MULTIPLIER = 8;
+  let queryLimit = excluded.size > 0 ? Math.max(limit * 2, limit + 24) : limit;
+  let visibleRows: FtsRow[] = [];
+
+  while (true) {
+    let rows: FtsRow[] = [];
+    try {
+      rows = timedRawQuery('lexicalSearch', () =>
+        rawAll<FtsRow>(`
+          SELECT
+            f.segment_id AS segment_id,
+            s.message_id AS message_id,
+            s.text AS text,
+            s.created_at AS created_at,
+            bm25(memory_segment_fts) AS rank
+          FROM memory_segment_fts f
+          JOIN memory_segments s ON s.id = f.segment_id
+          WHERE memory_segment_fts MATCH ?${scopeClause}
+          ORDER BY rank
+          LIMIT ?
+        `, matchQuery, ...(scopeIds ?? []), queryLimit),
+      );
+    } catch (err) {
+      log.warn({ err, query: truncate(trimmed, 80) }, 'Memory lexical search query parse failed');
+      return [];
+    }
+
+    visibleRows = excluded.size > 0
+      ? rows.filter((row) => !excluded.has(row.message_id))
+      : rows;
+
+    // Stop when we have enough rows, the DB returned fewer than requested
+    // (no more results exist), or we've reached the safety cap.
+    if (visibleRows.length >= limit || rows.length < queryLimit || queryLimit >= limit * MAX_FETCH_MULTIPLIER) {
+      break;
+    }
+    queryLimit = Math.min(queryLimit * 2, limit * MAX_FETCH_MULTIPLIER);
   }
 
-  const visibleRows = excluded.size > 0
-    ? rows.filter((row) => !excluded.has(row.message_id)).slice(0, limit)
-    : rows;
+  visibleRows = visibleRows.slice(0, limit);
 
   const finiteRanks = visibleRows
     .map((row) => row.rank)
@@ -124,17 +153,19 @@ export function recencySearch(conversationId: string, limit: number, excludedMes
  * Supplements FTS-based lexical search with LIKE-based matching on items.
  */
 export function directItemSearch(query: string, limit: number, scopeIds?: string[]): Candidate[] {
-  const db = getDb();
   const tokens = [...new Set(query
     .toLowerCase()
     .split(/[^a-z0-9_.-]+/g)
     .filter((t) => t.length >= 2))];
   if (tokens.length === 0) return [];
 
-  const raw = (db as unknown as { $client: { query: (q: string) => { all: (...params: unknown[]) => unknown[] } } }).$client;
   const likeClauses = tokens.map(
-    (t) => `(LOWER(subject) LIKE '%${escapeSqlLike(t)}%' OR LOWER(statement) LIKE '%${escapeSqlLike(t)}%')`,
+    () => `(LOWER(subject) LIKE ? OR LOWER(statement) LIKE ?)`,
   );
+  const likeParams = tokens.flatMap((t) => {
+    const pattern = `%${escapeLikeWildcards(t)}%`;
+    return [pattern, pattern];
+  });
   const scopeClause = scopeIds
     ? ` AND scope_id IN (${scopeIds.map(() => '?').join(',')})`
     : '';
@@ -145,9 +176,8 @@ export function directItemSearch(query: string, limit: number, scopeIds?: string
     ORDER BY last_seen_at DESC
     LIMIT ?
   `;
-  const params: unknown[] = [...(scopeIds ?? []), limit];
 
-  let rows: Array<{
+  interface ItemRow {
     id: string;
     kind: string;
     subject: string;
@@ -156,9 +186,13 @@ export function directItemSearch(query: string, limit: number, scopeIds?: string
     importance: number | null;
     first_seen_at: number;
     last_seen_at: number;
-  }> = [];
+  }
+
+  let rows: ItemRow[] = [];
   try {
-    rows = raw.query(sqlQuery).all(...params) as typeof rows;
+    rows = timedRawQuery('directItemSearch', () =>
+      rawAll<ItemRow>(sqlQuery, ...likeParams, ...(scopeIds ?? []), limit),
+    );
   } catch {
     return [];
   }
@@ -212,11 +246,6 @@ export function buildFtsMatchQuery(text: string): string | null {
     .join(' OR ');
 }
 
-export function escapeSqlLike(s: string): string {
-  return s.replace(/'/g, "''").replace(/%/g, '').replace(/_/g, '');
-}
-
-/** Escape only LIKE wildcards (% and _) for use with parameterized queries where the driver handles quoting. */
 export function escapeLikeWildcards(s: string): string {
   return s.replace(/%/g, '').replace(/_/g, '');
 }

package/src/memory/search/ranking.ts

@@ -1,9 +1,8 @@
 import { inArray, sql } from 'drizzle-orm';
-import Anthropic from '@anthropic-ai/sdk';
 import type { AssistantConfig, MemoryRerankingConfig } from '../../config/types.js';
-import { getConfig } from '../../config/loader.js';
 import { estimateTextTokens } from '../../context/token-estimator.js';
 import { getLogger } from '../../util/logger.js';
+import { getConfiguredProvider, extractText, userMessage } from '../../providers/provider-send-message.js';
 import { getDb } from '../db.js';
 import { memoryItems } from '../schema.js';
 import type { Candidate, CandidateSource, ItemMetadata } from './types.js';
@@ -296,10 +295,9 @@ export async function rerankWithLLM(
   candidates: Candidate[],
   rerankingConfig: MemoryRerankingConfig,
 ): Promise<Candidate[]> {
-  const config = getConfig();
-  const apiKey = config.apiKeys.anthropic ?? process.env.ANTHROPIC_API_KEY;
-  if (!apiKey) {
-    log.debug('No Anthropic API key available for LLM re-ranking, skipping');
+  const provider = getConfiguredProvider();
+  if (!provider) {
+    log.debug('Configured provider unavailable for LLM re-ranking, skipping');
     return candidates;
   }
 
@@ -309,26 +307,27 @@ export async function rerankWithLLM(
     text: truncate(c.text, 200),
   }));
 
-  const client = new Anthropic({ apiKey });
-  const response = await client.messages.create({
-    model: rerankingConfig.model,
-    max_tokens: 1024,
-    system: 'You are a relevance scoring assistant. Given a query and a list of memory candidates, rate each candidate\'s relevance to the query on a scale of 0-10. Return ONLY a JSON array of objects with "index" (the candidate index) and "score" (0-10 integer). No explanation.',
-    messages: [{
-      role: 'user',
-      content: `Query: ${truncate(query, 200)}\n\nCandidates:\n${candidateList.map((c) => `[${c.index}] ${c.text}`).join('\n')}`,
-    }],
-  });
+  const response = await provider.sendMessage(
+    [userMessage(`Query: ${truncate(query, 200)}\n\nCandidates:\n${candidateList.map((c) => `[${c.index}] ${c.text}`).join('\n')}`)],
+    undefined,
+    'You are a relevance scoring assistant. Given a query and a list of memory candidates, rate each candidate\'s relevance to the query on a scale of 0-10. Return ONLY a JSON array of objects with "index" (the candidate index) and "score" (0-10 integer). No explanation.',
+    {
+      config: {
+        model: rerankingConfig.model,
+        max_tokens: 1024,
+      },
+    },
+  );
 
   // Extract text from the response
-  const textBlock = response.content.find((block) => block.type === 'text');
-  if (!textBlock || textBlock.type !== 'text') {
+  const responseText = extractText(response);
+  if (!responseText) {
     log.warn('LLM re-ranking returned no text block, skipping');
     return candidates;
   }
 
   // Parse the JSON array from the response
-  const jsonMatch = textBlock.text.match(/\[[\s\S]*\]/);
+  const jsonMatch = responseText.match(/\[[\s\S]*\]/);
   if (!jsonMatch) {
     log.warn('LLM re-ranking response did not contain JSON array, skipping');
     return candidates;
@@ -359,10 +358,10 @@ export async function rerankWithLLM(
 
   reranked.sort((a, b) => {
     // Scored items come before unscored items
-    if (a.llmScore !== null && b.llmScore === null) return -1;
-    if (a.llmScore === null && b.llmScore !== null) return 1;
+    if (a.llmScore != null && b.llmScore == null) return -1;
+    if (a.llmScore == null && b.llmScore != null) return 1;
     // Both scored: sort by score descending
-    if (a.llmScore !== null && b.llmScore !== null) {
+    if (a.llmScore != null && b.llmScore != null) {
       const scoreDelta = b.llmScore - a.llmScore;
       if (scoreDelta !== 0) return scoreDelta;
     }