@vellumai/assistant 0.3.5 → 0.3.6

package/src/memory/search/semantic.ts

@@ -1,6 +1,7 @@
-import { eq } from 'drizzle-orm';
+import { inArray } from 'drizzle-orm';
 import { getDb } from '../db.js';
 import { getQdrantClient } from '../qdrant-client.js';
+import type { QdrantSearchResult } from '../qdrant-client.js';
 import {
   memoryItems,
   memoryItemSources,
@@ -9,6 +10,84 @@ import {
 } from '../schema.js';
 import type { Candidate } from './types.js';
 import { computeRecencyScore } from './ranking.js';
+import { getLogger } from '../../util/logger.js';
+
+const log = getLogger('qdrant-circuit-breaker');
+
+// ── Qdrant circuit breaker ───────────────────────────────────────────
+// After FAILURE_THRESHOLD consecutive Qdrant failures, stop sending
+// requests (open state). After COOLDOWN_MS, allow a single probe
+// request (half-open). If the probe succeeds, close the circuit; if it
+// fails, re-open and restart the cooldown.
+
+const FAILURE_THRESHOLD = 5;
+const COOLDOWN_MS = 60_000;
+
+type BreakerState = 'closed' | 'open' | 'half-open';
+
+let breakerState: BreakerState = 'closed';
+let consecutiveFailures = 0;
+let openedAt = 0;
+// Ensures only one request passes through during half-open state
+let halfOpenProbeInFlight = false;
+
+function qdrantBreakerAllows(): boolean {
+  if (breakerState === 'closed') return true;
+  if (breakerState === 'open') {
+    if (Date.now() - openedAt >= COOLDOWN_MS) {
+      breakerState = 'half-open';
+      halfOpenProbeInFlight = true;
+      log.info('Qdrant circuit breaker entering half-open state — allowing probe request');
+      return true;
+    }
+    return false;
+  }
+  // half-open: only allow through if no probe is already in flight
+  if (halfOpenProbeInFlight) return false;
+  halfOpenProbeInFlight = true;
+  return true;
+}
+
+function qdrantBreakerRecordSuccess(): void {
+  if (breakerState !== 'closed') {
+    log.info({ previousFailures: consecutiveFailures }, 'Qdrant circuit breaker closed — search succeeded');
+  }
+  consecutiveFailures = 0;
+  breakerState = 'closed';
+  openedAt = 0;
+  halfOpenProbeInFlight = false;
+}
+
+function qdrantBreakerRecordFailure(): void {
+  consecutiveFailures++;
+  halfOpenProbeInFlight = false;
+  if (consecutiveFailures >= FAILURE_THRESHOLD) {
+    breakerState = 'open';
+    openedAt = Date.now();
+    log.warn(
+      { consecutiveFailures, cooldownMs: COOLDOWN_MS },
+      'Qdrant circuit breaker opened — semantic search disabled until probe succeeds',
+    );
+  } else if (breakerState === 'half-open') {
+    // Probe failed — re-open
+    breakerState = 'open';
+    openedAt = Date.now();
+    log.warn('Qdrant circuit breaker re-opened — half-open probe failed');
+  }
+}
+
+/** @internal Test-only: reset circuit breaker state */
+export function _resetQdrantBreaker(): void {
+  breakerState = 'closed';
+  consecutiveFailures = 0;
+  openedAt = 0;
+  halfOpenProbeInFlight = false;
+}
+
+/** @internal Test-only: get breaker state */
+export function _getQdrantBreakerState(): { state: BreakerState; consecutiveFailures: number } {
+  return { state: breakerState, consecutiveFailures };
+}
 
 export async function semanticSearch(
   queryVector: number[],
@@ -20,18 +99,79 @@ export async function semanticSearch(
 ): Promise<Candidate[]> {
   if (limit <= 0) return [];
 
+  // Circuit breaker: throw so the caller's .catch() marks the result as degraded
+  if (!qdrantBreakerAllows()) {
+    log.debug('Qdrant circuit breaker open — skipping semantic search');
+    throw new Error('Qdrant circuit breaker open');
+  }
+
   const qdrant = getQdrantClient();
 
   // Overfetch to account for items filtered out post-query (invalidated, excluded, etc.)
-  const fetchLimit = limit * 2;
-  const results = await qdrant.searchWithFilter(
-    queryVector,
-    fetchLimit,
-    ['item', 'summary', 'segment'],
-    excludedMessageIds,
-  );
+  // Use 3x when exclusions are active to ensure enough results survive filtering
+  const overfetchMultiplier = excludedMessageIds.length > 0 ? 3 : 2;
+  const fetchLimit = limit * overfetchMultiplier;
+  let results: QdrantSearchResult[];
+  try {
+    results = await qdrant.searchWithFilter(
+      queryVector,
+      fetchLimit,
+      ['item', 'summary', 'segment'],
+      excludedMessageIds,
+    );
+    qdrantBreakerRecordSuccess();
+  } catch (err) {
+    qdrantBreakerRecordFailure();
+    throw err;
+  }
 
   const db = getDb();
+
+  // Batch-fetch all backing records upfront to avoid N+1 queries per result
+  const itemTargetIds: string[] = [];
+  const summaryTargetIds: string[] = [];
+  const segmentTargetIds: string[] = [];
+  for (const r of results) {
+    if (r.payload.target_type === 'item') itemTargetIds.push(r.payload.target_id);
+    else if (r.payload.target_type === 'summary') summaryTargetIds.push(r.payload.target_id);
+    else segmentTargetIds.push(r.payload.target_id);
+  }
+
+  const itemsMap = new Map<string, typeof memoryItems.$inferSelect>();
+  if (itemTargetIds.length > 0) {
+    const allItems = db.select().from(memoryItems).where(inArray(memoryItems.id, itemTargetIds)).all();
+    for (const item of allItems) itemsMap.set(item.id, item);
+  }
+
+  const sourcesMap = new Map<string, string[]>();
+  if (itemTargetIds.length > 0) {
+    const allSources = db.select({
+      memoryItemId: memoryItemSources.memoryItemId,
+      messageId: memoryItemSources.messageId,
+    }).from(memoryItemSources)
+      .where(inArray(memoryItemSources.memoryItemId, itemTargetIds))
+      .all();
+    for (const s of allSources) {
+      const existing = sourcesMap.get(s.memoryItemId);
+      if (existing) existing.push(s.messageId);
+      else sourcesMap.set(s.memoryItemId, [s.messageId]);
+    }
+  }
+
+  const summariesMap = new Map<string, typeof memorySummaries.$inferSelect>();
+  if (scopeIds && summaryTargetIds.length > 0) {
+    const allSummaries = db.select().from(memorySummaries).where(inArray(memorySummaries.id, summaryTargetIds)).all();
+    for (const s of allSummaries) summariesMap.set(s.id, s);
+  }
+
+  const segmentsMap = new Map<string, typeof memorySegments.$inferSelect>();
+  if (scopeIds && segmentTargetIds.length > 0) {
+    const allSegments = db.select().from(memorySegments).where(inArray(memorySegments.id, segmentTargetIds)).all();
+    for (const seg of allSegments) segmentsMap.set(seg.id, seg);
+  }
+
+  const excludedSet = excludedMessageIds.length > 0 ? new Set(excludedMessageIds) : null;
+
   const candidates: Candidate[] = [];
   for (const result of results) {
     const { payload, score } = result;
@@ -39,16 +179,14 @@ export async function semanticSearch(
     const createdAt = payload.created_at ?? Date.now();
 
     if (payload.target_type === 'item') {
-      // Validate the backing memory item is still active and has non-excluded evidence
-      const item = db.select().from(memoryItems).where(eq(memoryItems.id, payload.target_id)).get();
-      if (!item || item.status !== 'active' || item.invalidAt !== null) continue;
+      const item = itemsMap.get(payload.target_id);
+      if (!item || item.status !== 'active' || item.invalidAt != null) continue;
       if (scopeIds && !scopeIds.includes(item.scopeId)) continue;
-      const sources = db.select().from(memoryItemSources)
-        .where(eq(memoryItemSources.memoryItemId, payload.target_id)).all();
-      if (sources.length === 0) continue;
-      if (excludedMessageIds.length > 0) {
-        const nonExcluded = sources.filter((s) => !excludedMessageIds.includes(s.messageId));
-        if (nonExcluded.length === 0) continue;
+      const sources = sourcesMap.get(payload.target_id);
+      if (!sources || sources.length === 0) continue;
+      if (excludedSet) {
+        const hasNonExcluded = sources.some((msgId) => !excludedSet.has(msgId));
+        if (!hasNonExcluded) continue;
       }
       candidates.push({
         key: `item:${payload.target_id}`,
@@ -67,7 +205,7 @@ export async function semanticSearch(
       });
     } else if (payload.target_type === 'summary') {
       if (scopeIds) {
-        const summary = db.select().from(memorySummaries).where(eq(memorySummaries.id, payload.target_id)).get();
+        const summary = summariesMap.get(payload.target_id);
         if (!summary || !scopeIds.includes(summary.scopeId)) continue;
       }
       candidates.push({
@@ -87,7 +225,7 @@ export async function semanticSearch(
       });
     } else {
       if (scopeIds) {
-        const segment = db.select().from(memorySegments).where(eq(memorySegments.id, payload.target_id)).get();
+        const segment = segmentsMap.get(payload.target_id);
         if (!segment || !scopeIds.includes(segment.scopeId)) continue;
       }
       candidates.push({

package/src/memory/shared-app-links-store.ts

@@ -6,7 +6,7 @@
 
 import { eq, lte, or, and, isNull } from 'drizzle-orm';
 import { randomUUID, randomBytes } from 'node:crypto';
-import { getDb } from './db.js';
+import { getDb, rawRun } from './db.js';
 import { sharedAppLinks } from './schema.js';
 import type { AppManifest } from '../bundler/manifest.js';
 
@@ -130,9 +130,8 @@ export function deleteSharedAppLinkByToken(shareToken: string): boolean {
 }
 
 export function incrementDownloadCount(shareToken: string): void {
-  const db = getDb();
-  const raw = (db as unknown as { $client: import('bun:sqlite').Database }).$client;
-  raw.prepare(
+  rawRun(
     `UPDATE shared_app_links SET download_count = download_count + 1 WHERE share_token = ?`,
-  ).run(shareToken);
+    shareToken,
+  );
 }

package/src/memory/validation.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+
+/**
+ * Unit interval [0, 1] — used for confidence and importance fields on memory items.
+ * Coerces out-of-range numbers to the nearest bound rather than rejecting,
+ * since LLM-generated values occasionally exceed the range.
+ */
+export const unitInterval = z.number().transform((v) => Math.min(1, Math.max(0, v)));
+
+/** Zod schema for validating confidence/importance values on memory items. */
+export const memoryItemScores = z.object({
+  confidence: unitInterval,
+  importance: unitInterval,
+});
+
+/** Clamp a numeric value to [0, 1]. */
+export function clampUnitInterval(value: number): number {
+  return Math.min(1, Math.max(0, value));
+}

package/src/messaging/draft-store.ts

@@ -5,8 +5,9 @@
  * Works across all platforms — Slack, Gmail, Discord, etc.
  */
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, readdirSync } from 'node:fs';
+import { readFileSync, writeFileSync, unlinkSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
+import { ensureDir, pathExists } from '../util/fs.js';
 import { randomUUID } from 'node:crypto';
 import { getRootDir } from '../util/platform.js';
 
@@ -24,9 +25,7 @@ export interface Draft {
 
 function getDraftsDir(platform: string): string {
   const dir = join(getRootDir(), 'workspace', 'data', 'drafts', platform);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
+  ensureDir(dir);
   return dir;
 }
 
@@ -61,7 +60,7 @@ export function createDraft(opts: {
 
 export function getDraft(platform: string, id: string): Draft | null {
   const path = getDraftPath(platform, id);
-  if (!existsSync(path)) return null;
+  if (!pathExists(path)) return null;
   return JSON.parse(readFileSync(path, 'utf-8')) as Draft;
 }
 
@@ -82,7 +81,7 @@ export function listDrafts(platform: string): Draft[] {
 
 export function deleteDraft(platform: string, id: string): boolean {
   const path = getDraftPath(platform, id);
-  if (!existsSync(path)) return false;
+  if (!pathExists(path)) return false;
   unlinkSync(path);
   return true;
 }

package/src/messaging/providers/sms/adapter.ts

@@ -29,17 +29,14 @@ import type {
 import { getSecureKey } from '../../../security/secure-keys.js';
 import { readHttpToken } from '../../../util/platform.js';
 import { loadConfig } from '../../../config/loader.js';
+import { getGatewayInternalBaseUrl, getTwilioPhoneNumberEnv } from '../../../config/env.js';
 import { getOrCreateConversation } from '../../../memory/conversation-key-store.js';
 import * as externalConversationStore from '../../../memory/external-conversation-store.js';
 import * as sms from './client.js';
 
 /** Resolve the gateway base URL, preferring GATEWAY_INTERNAL_BASE_URL if set. */
 function getGatewayUrl(): string {
-  if (process.env.GATEWAY_INTERNAL_BASE_URL) {
-    return process.env.GATEWAY_INTERNAL_BASE_URL.replace(/\/+$/, '');
-  }
-  const port = Number(process.env.GATEWAY_PORT) || 7830;
-  return `http://127.0.0.1:${port}`;
+  return getGatewayInternalBaseUrl();
 }
 
 /** Read the runtime HTTP bearer token used to authenticate with the gateway. */
@@ -75,7 +72,7 @@ function getPhoneNumber(assistantId?: string): string | undefined {
     }
   }
 
-  const fromEnv = process.env.TWILIO_PHONE_NUMBER;
+  const fromEnv = getTwilioPhoneNumberEnv();
   if (fromEnv) return fromEnv;
 
   try {

package/src/messaging/providers/telegram-bot/adapter.ts

@@ -25,17 +25,14 @@ import type {
 } from '../../provider-types.js';
 import { getSecureKey } from '../../../security/secure-keys.js';
 import { readHttpToken } from '../../../util/platform.js';
+import { getGatewayInternalBaseUrl } from '../../../config/env.js';
 import { getOrCreateConversation } from '../../../memory/conversation-key-store.js';
 import * as externalConversationStore from '../../../memory/external-conversation-store.js';
 import * as telegram from './client.js';
 
 /** Resolve the gateway base URL, preferring GATEWAY_INTERNAL_BASE_URL if set. */
 function getGatewayUrl(): string {
-  if (process.env.GATEWAY_INTERNAL_BASE_URL) {
-    return process.env.GATEWAY_INTERNAL_BASE_URL.replace(/\/+$/, "");
-  }
-  const port = Number(process.env.GATEWAY_PORT) || 7830;
-  return `http://127.0.0.1:${port}`;
+  return getGatewayInternalBaseUrl();
 }
 
 /** Read the runtime HTTP bearer token used to authenticate with the gateway. */

package/src/messaging/providers/whatsapp/adapter.ts

@@ -0,0 +1,136 @@
+/**
+ * WhatsApp Business messaging provider adapter.
+ *
+ * Enables proactive outbound WhatsApp messaging via the gateway's /deliver/whatsapp
+ * endpoint. Delivery is proxied through the gateway which owns the Meta Cloud API
+ * credentials (phone_number_id + access_token).
+ *
+ * The `token` parameter in MessagingProvider methods is unused for WhatsApp
+ * because delivery is authenticated via the gateway's bearer token, not
+ * a per-user OAuth token.
+ */
+
+import type { MessagingProvider } from '../../provider.js';
+import type {
+  Conversation,
+  Message,
+  SearchResult,
+  SendResult,
+  ConnectionInfo,
+  ListOptions,
+  HistoryOptions,
+  SearchOptions,
+  SendOptions,
+} from '../../provider-types.js';
+import { getSecureKey } from '../../../security/secure-keys.js';
+import { readHttpToken } from '../../../util/platform.js';
+import { getGatewayInternalBaseUrl } from '../../../config/env.js';
+import { getOrCreateConversation } from '../../../memory/conversation-key-store.js';
+import * as externalConversationStore from '../../../memory/external-conversation-store.js';
+import * as whatsapp from './client.js';
+
+/** Resolve the gateway base URL. */
+function getGatewayUrl(): string {
+  return getGatewayInternalBaseUrl();
+}
+
+/** Read the runtime HTTP bearer token used to authenticate with the gateway. */
+function getBearerToken(): string {
+  const token = readHttpToken();
+  if (!token) {
+    throw new Error('No runtime HTTP bearer token available — is the daemon running?');
+  }
+  return token;
+}
+
+/** Check whether WhatsApp credentials are stored. */
+function hasWhatsAppCredentials(): boolean {
+  return (
+    !!getSecureKey('credential:whatsapp:phone_number_id') &&
+    !!getSecureKey('credential:whatsapp:access_token')
+  );
+}
+
+export const whatsappMessagingProvider: MessagingProvider = {
+  id: 'whatsapp',
+  displayName: 'WhatsApp',
+  credentialService: 'whatsapp',
+  capabilities: new Set(['send']),
+
+  /**
+   * WhatsApp is connected when Meta Cloud API credentials are stored.
+   */
+  isConnected(): boolean {
+    return hasWhatsAppCredentials();
+  },
+
+  async testConnection(_token: string): Promise<ConnectionInfo> {
+    if (!hasWhatsAppCredentials()) {
+      return {
+        connected: false,
+        user: 'unknown',
+        platform: 'whatsapp',
+        metadata: { error: 'No WhatsApp credentials found. Configure WHATSAPP_PHONE_NUMBER_ID and WHATSAPP_ACCESS_TOKEN.' },
+      };
+    }
+
+    const phoneNumberId = getSecureKey('credential:whatsapp:phone_number_id')!;
+
+    return {
+      connected: true,
+      user: phoneNumberId,
+      platform: 'whatsapp',
+      metadata: {
+        phoneNumberId: phoneNumberId.slice(0, 6) + '...',
+      },
+    };
+  },
+
+  async sendMessage(_token: string, conversationId: string, text: string, options?: SendOptions): Promise<SendResult> {
+    const gatewayUrl = getGatewayUrl();
+    const bearerToken = getBearerToken();
+    const assistantId = options?.assistantId;
+
+    await whatsapp.sendMessage(gatewayUrl, bearerToken, conversationId, text, assistantId);
+
+    // Upsert external conversation binding so the conversation key mapping
+    // exists for the next inbound WhatsApp message from this number.
+    try {
+      const sourceChannel = 'whatsapp';
+      const conversationKey = assistantId && assistantId !== 'self'
+        ? `asst:${assistantId}:${sourceChannel}:${conversationId}`
+        : `${sourceChannel}:${conversationId}`;
+      const { conversationId: internalId } = getOrCreateConversation(conversationKey);
+      if (!assistantId || assistantId === 'self') {
+        externalConversationStore.upsertOutboundBinding({
+          conversationId: internalId,
+          sourceChannel,
+          externalChatId: conversationId,
+        });
+      }
+    } catch {
+      // Best-effort — don't fail the send if binding upsert fails
+    }
+
+    return {
+      id: `whatsapp-${Date.now()}`,
+      timestamp: Date.now(),
+      conversationId,
+    };
+  },
+
+  // WhatsApp does not support listing conversations via this provider.
+  async listConversations(_token: string, _options?: ListOptions): Promise<Conversation[]> {
+    return [];
+  },
+
+  // WhatsApp does not provide message history retrieval via the gateway.
+  async getHistory(_token: string, _conversationId: string, _options?: HistoryOptions): Promise<Message[]> {
+    return [];
+  },
+
+  // WhatsApp does not support message search.
+  async search(_token: string, _query: string, _options?: SearchOptions): Promise<SearchResult> {
+    return { total: 0, messages: [], hasMore: false };
+  },
+};

package/src/messaging/providers/whatsapp/client.ts

@@ -0,0 +1,67 @@
+/**
+ * Low-level WhatsApp operations.
+ *
+ * Outbound message delivery routes through the gateway's /deliver/whatsapp
+ * endpoint, which handles WhatsApp credential management and the Meta Cloud API.
+ */
+
+const DELIVERY_TIMEOUT_MS = 30_000;
+
+export class WhatsAppApiError extends Error {
+  constructor(
+    public readonly status: number,
+    message: string,
+  ) {
+    super(message);
+    this.name = 'WhatsAppApiError';
+  }
+}
+
+/** Payload accepted by the gateway's /deliver/whatsapp endpoint. */
+interface DeliverPayload {
+  to: string;
+  text: string;
+  assistantId?: string;
+}
+
+/** Result returned by sendMessage. */
+export interface WhatsAppSendResult {
+  ok: boolean;
+}
+
+/**
+ * Send a WhatsApp message via the gateway's /deliver/whatsapp endpoint.
+ */
+export async function sendMessage(
+  gatewayUrl: string,
+  bearerToken: string,
+  to: string,
+  text: string,
+  assistantId?: string,
+): Promise<WhatsAppSendResult> {
+  const payload: DeliverPayload = { to, text };
+  if (assistantId) {
+    payload.assistantId = assistantId;
+  }
+
+  const url = `${gatewayUrl}/deliver/whatsapp`;
+  const resp = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${bearerToken}`,
+    },
+    body: JSON.stringify(payload),
+    signal: AbortSignal.timeout(DELIVERY_TIMEOUT_MS),
+  });
+
+  if (!resp.ok) {
+    const body = await resp.text().catch(() => '<unreadable>');
+    throw new WhatsAppApiError(
+      resp.status,
+      `Gateway /deliver/whatsapp failed (${resp.status}): ${body}`,
+    );
+  }
+
+  return { ok: true };
+}

package/src/messaging/style-analyzer.ts

@@ -9,8 +9,7 @@
 import type { Message as ProviderMessage } from './provider-types.js';
 import type { Message, ToolDefinition } from '../providers/types.js';
 import { truncate } from '../util/truncate.js';
-import { getProvider } from '../providers/registry.js';
-import { getConfig } from '../config/loader.js';
+import { getConfiguredProvider } from '../providers/provider-send-message.js';
 
 export interface StylePattern {
   aspect: string;
@@ -118,8 +117,10 @@ export async function extractStylePatterns(
 
   const corpus = corpusEntries.map((e, i) => `--- Message ${i + 1} ---\n${e}`).join('\n\n');
 
-  const config = getConfig();
-  const provider = getProvider(config.provider);
+  const provider = getConfiguredProvider();
+  if (!provider) {
+    return { stylePatterns: [], contactObservations: [] };
+  }
   const promptMessages: Message[] = [{
     role: 'user',
     content: [{ type: 'text', text: `Analyze these ${corpusEntries.length} sent messages for writing style patterns:\n\n${corpus}` }],