@vellumai/assistant 0.4.54 → 0.4.56

package/src/inbound/platform-callback-registration.ts

@@ -24,18 +24,40 @@ import {
   getPlatformInternalApiKey,
 } from "../config/env.js";
 import { getIsContainerized } from "../config/env-registry.js";
+import { isManagedProxyEnabledSync } from "../providers/managed-proxy/context.js";
 import { getLogger } from "../util/logger.js";
 
 const log = getLogger("platform-callback-registration");
 
+/**
+ * Whether this is a platform-managed deployment with usable managed credentials.
+ *
+ * True when PLATFORM_BASE_URL and PLATFORM_ASSISTANT_ID are both set **and**
+ * the managed proxy prerequisites (including the assistant API key) were
+ * satisfied the last time `resolveManagedProxyContext()` ran. This prevents
+ * the system prompt from claiming managed credentials are available during
+ * partial/failed platform bootstrap where the API key is missing.
+ */
+export function isPlatformManaged(): boolean {
+  return (
+    !!getPlatformBaseUrl() &&
+    !!getPlatformAssistantId() &&
+    isManagedProxyEnabledSync()
+  );
+}
+
 /**
  * Whether the daemon should register callback routes with the platform.
  * True when IS_CONTAINERIZED, PLATFORM_BASE_URL, and PLATFORM_ASSISTANT_ID
- * are all set.
+ * are all set. Intentionally does **not** require the managed proxy API key
+ * so that callback-only flows (OAuth transport, Telegram/Twilio callback
+ * registration) work during partial bootstrap before the key is injected.
  */
 export function shouldUsePlatformCallbacks(): boolean {
   return (
-    getIsContainerized() && !!getPlatformBaseUrl() && !!getPlatformAssistantId()
+    getIsContainerized() &&
+    !!getPlatformBaseUrl() &&
+    !!getPlatformAssistantId()
   );
 }
 

package/src/instrument.ts

@@ -2,7 +2,7 @@ import { arch, hostname, platform, release } from "node:os";
 
 import * as Sentry from "@sentry/node";
 
-import { getSentryDsn } from "./config/env.js";
+import { getPlatformOrganizationId, getSentryDsn } from "./config/env.js";
 import { APP_VERSION, COMMIT_SHA } from "./version.js";
 
 /** Patterns that match sensitive data in Sentry event values. */
@@ -37,8 +37,8 @@ function redactObject(obj: unknown): unknown {
 /**
  * Call after dotenv has loaded so SENTRY_DSN is available.
  * Always initializes Sentry to capture early startup crashes. If the user
- * later opts out via the "collect-usage-data" feature flag, call closeSentry()
- * after config is loaded to stop future event capturing.
+ * later opts out via the sendDiagnostics config key (or VELLUM_DEV=1),
+ * call closeSentry() after config is loaded to stop future event capturing.
  */
 export function initSentry(): void {
   Sentry.init({
@@ -58,6 +58,9 @@ export function initSentry(): void {
         runtime: "bun",
         runtime_version:
           typeof Bun !== "undefined" ? Bun.version : process.version,
+        ...(getPlatformOrganizationId()
+          ? { organization_id: getPlatformOrganizationId() }
+          : {}),
       },
     },
     beforeSend(event) {
@@ -86,23 +89,36 @@ export function initSentry(): void {
 
 /**
  * Stop capturing future Sentry events. Called after config loads when the
- * user has opted out of crash reporting so that early-startup crashes are
+ * user has disabled sendDiagnostics so that early-startup crashes are
  * still captured but subsequent events are suppressed.
  */
 export async function closeSentry(): Promise<void> {
   await Sentry.close();
 }
 
-// ── Dynamic session-scoped Sentry tags ──────────────────────────────
+/**
+ * Set (or clear) the organization_id tag on the global Sentry scope.
+ *
+ * Called after the platform organization ID is rehydrated from the
+ * credential store or updated at runtime so that every subsequent
+ * Sentry event includes the organization context.
+ */
+export function setSentryOrganizationId(
+  organizationId: string | undefined,
+): void {
+  Sentry.setTag("organization_id", organizationId || undefined);
+}
+
+// ── Dynamic conversation-scoped Sentry tags ─────────────────────────
 //
 // These tags change per conversation turn and are set on the current
 // Sentry scope before the agent loop runs. Any `Sentry.captureException`
 // call within that async execution chain (e.g. inside agent/loop.ts)
-// will inherit these tags, enabling filtering by conversation, session,
-// user, or assistant in the Sentry dashboard.
+// will inherit these tags, enabling filtering by conversation, user, or
+// assistant in the Sentry dashboard.
 
-/** Tag keys set by {@link setSentrySessionContext}. */
-const SESSION_TAG_KEYS = [
+/** Tag keys set by {@link setSentryConversationContext}. */
+const CONVERSATION_TAG_KEYS = [
   "assistant_id",
   "conversation_id",
   "session_id",
@@ -110,10 +126,10 @@ const SESSION_TAG_KEYS = [
   "user_identifier",
 ] as const;
 
-export interface SentrySessionContext {
+export interface SentryConversationContext {
   /** Internal assistant ID (daemon uses 'self'). */
   assistantId: string;
-  /** Conversation/session identifier. */
+  /** Conversation identifier. */
   conversationId: string;
   /** Number of messages in the conversation at time of the turn. */
   messageCount: number;
@@ -122,16 +138,18 @@ export interface SentrySessionContext {
 }
 
 /**
- * Set session-scoped tags on the current Sentry scope.
+ * Set conversation-scoped tags on the current Sentry scope.
  *
  * Call at the start of each agent loop turn so that any exceptions
- * captured within the turn include conversation/session context.
+ * captured within the turn include conversation context.
  */
-export function setSentrySessionContext(ctx: SentrySessionContext): void {
+export function setSentryConversationContext(
+  ctx: SentryConversationContext,
+): void {
   Sentry.setTag("assistant_id", ctx.assistantId);
   Sentry.setTag("conversation_id", ctx.conversationId);
-  // session_id mirrors conversation_id — in this codebase they are the
-  // same value, but downstream Sentry users may search by either name.
+  // session_id mirrors conversation_id — downstream Sentry dashboards and
+  // alerts may still filter by the legacy tag name.
   Sentry.setTag("session_id", ctx.conversationId);
   Sentry.setTag("message_count", String(ctx.messageCount));
   if (ctx.userIdentifier) {
@@ -140,13 +158,13 @@ export function setSentrySessionContext(ctx: SentrySessionContext): void {
 }
 
 /**
- * Clear session-scoped tags from the current Sentry scope.
+ * Clear conversation-scoped tags from the current Sentry scope.
  *
  * Call in the finally block after the agent loop completes so tags
  * from one conversation do not leak into unrelated error captures.
  */
-export function clearSentrySessionContext(): void {
-  for (const key of SESSION_TAG_KEYS) {
+export function clearSentryConversationContext(): void {
+  for (const key of CONVERSATION_TAG_KEYS) {
     Sentry.setTag(key, undefined);
   }
 }

package/src/media/app-icon-generator.ts

@@ -15,7 +15,7 @@ import {
   buildManagedBaseUrl,
   resolveManagedProxyContext,
 } from "../providers/managed-proxy/context.js";
-import { getSecureKeyAsync } from "../security/secure-keys.js";
+import { getProviderKeyAsync } from "../security/secure-keys.js";
 import { getLogger } from "../util/logger.js";
 import {
   generateImage,
@@ -37,7 +37,7 @@ export async function generateAppIcon(
   appDescription?: string,
 ): Promise<void> {
   const config = getConfig();
-  const apiKey = await getSecureKeyAsync("gemini");
+  const apiKey = await getProviderKeyAsync("gemini");
 
   let credentials: ImageGenCredentials | undefined;
   if (apiKey) {
@@ -88,7 +88,7 @@ export async function generateAppIcon(
     const result = await generateImage(credentials, {
       prompt,
       mode: "generate",
-      model: config.imageGenModel,
+      model: config.services["image-generation"].model,
     });
 
     if (result.images.length === 0) {

package/src/media/avatar-router.ts

@@ -3,7 +3,7 @@ import {
   buildManagedBaseUrl,
   resolveManagedProxyContext,
 } from "../providers/managed-proxy/context.js";
-import { getSecureKeyAsync } from "../security/secure-keys.js";
+import { getProviderKeyAsync } from "../security/secure-keys.js";
 import { ConfigError, ProviderError } from "../util/errors.js";
 import {
   generateImage,
@@ -14,7 +14,7 @@ export async function generateAvatar(
   prompt: string,
 ): Promise<{ imageBase64: string; mimeType: string }> {
   const config = getConfig();
-  const geminiKey = await getSecureKeyAsync("gemini");
+  const geminiKey = await getProviderKeyAsync("gemini");
 
   let credentials: ImageGenCredentials | undefined;
   if (geminiKey) {
@@ -40,7 +40,7 @@ export async function generateAvatar(
   const result = await generateImage(credentials, {
     prompt,
     mode: "generate",
-    model: config.imageGenModel,
+    model: config.services["image-generation"].model,
   });
 
   const image = result.images[0];

package/src/memory/app-git-service.ts

@@ -162,7 +162,7 @@ export async function commitAppChange(message: string): Promise<void> {
  * Fire-and-forget safe: errors are logged but never thrown.
  */
 export async function commitAppTurnChanges(
-  sessionId: string,
+  conversationId: string,
   turnNumber: number,
 ): Promise<void> {
   try {
@@ -172,11 +172,11 @@ export async function commitAppTurnChanges(
     const gitService = getWorkspaceGitService(appsDir);
     await gitService.commitIfDirty(() => ({
       message: `Turn ${turnNumber}: app changes`,
-      metadata: { sessionId, turnNumber },
+      metadata: { conversationId, turnNumber },
     }));
   } catch (err) {
     log.error(
-      { err, sessionId, turnNumber },
+      { err, conversationId, turnNumber },
       "Failed to commit app turn changes",
     );
   }

package/src/memory/attachments-store.ts

@@ -5,11 +5,13 @@
  * data. Provides upload, delete, and message-linkage operations.
  */
 
-import { unlinkSync } from "node:fs";
+import { mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { basename, join } from "node:path";
 
 import { eq } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
+import { getWorkspaceDir } from "../util/platform.js";
 import { getDb, rawAll, rawGet, rawRun } from "./db.js";
 import { attachments, messageAttachments } from "./schema.js";
 
@@ -46,8 +48,28 @@ function formatBytes(bytes: number): string {
 // Size and encoding limits
 // ---------------------------------------------------------------------------
 
-/** Hard ceiling on a single uploaded attachment (20 MB, matching assistant limits). */
-export const MAX_UPLOAD_BYTES = 20 * 1024 * 1024;
+/** Hard ceiling on a single uploaded attachment (50 MB, matching assistant limits). */
+export const MAX_UPLOAD_BYTES = 50 * 1024 * 1024;
+
+/** Attachments larger than this are stored on disk instead of inline in SQLite. */
+export const FILE_BACKED_THRESHOLD_BYTES = 5 * 1024 * 1024;
+
+/**
+ * Write decoded base64 data to disk under the workspace attachments directory.
+ * Returns the absolute file path of the written file.
+ */
+export function writeAttachmentToDisk(
+  dataBase64: string,
+  filename: string,
+): string {
+  const dir = join(getWorkspaceDir(), "data", "attachments");
+  mkdirSync(dir, { recursive: true });
+  const destFilename = `${uuid()}-${basename(filename)}`;
+  const destPath = join(dir, destFilename);
+  const buffer = Buffer.from(dataBase64, "base64");
+  writeFileSync(destPath, buffer);
+  return destPath;
+}
 
 /**
  * Validate that a string contains only characters from the standard base64
@@ -201,25 +223,14 @@ function computeContentHash(dataBase64: string): string {
 // File-backed attachment storage (avoids reading large files into memory)
 // ---------------------------------------------------------------------------
 
-function ensureFilePathColumn(): void {
-  try {
-    // SQLite allows ALTER TABLE ADD COLUMN for nullable columns
-    rawRun("ALTER TABLE attachments ADD COLUMN file_path TEXT");
-  } catch {
-    // Column already exists — ignore the error
-  }
-}
-
-let filePathColumnEnsured = false;
-
 /**
  * Store a file-backed attachment by path reference, without reading the file
  * into memory. This avoids OOM risk for large recordings that exceed the
- * normal 20 MB upload limit.
+ * normal 50 MB upload limit.
  *
  * The file stays on disk; the attachment row stores an empty dataBase64 and
- * records the on-disk path in a `file_path` column (added via runtime
- * migration since the Drizzle schema doesn't know about it).
+ * records the on-disk path in a `file_path` column (added via DB migration
+ * in 102-alter-table-columns.ts since the Drizzle schema doesn't know about it).
  */
 export function uploadFileBackedAttachment(
   filename: string,
@@ -227,11 +238,6 @@ export function uploadFileBackedAttachment(
   filePath: string,
   sizeBytes: number,
 ): StoredAttachment & { filePath: string } {
-  if (!filePathColumnEnsured) {
-    ensureFilePathColumn();
-    filePathColumnEnsured = true;
-  }
-
   const now = Date.now();
   const kind = classifyKind(mimeType);
   const id = uuid();
@@ -263,13 +269,9 @@ export function uploadFileBackedAttachment(
 
 /**
  * Returns the file_path for a file-backed attachment, or null if not file-backed.
- * Uses raw SQL since file_path is added via runtime migration and is not in the Drizzle schema.
+ * Uses raw SQL since file_path is added via DB migration and is not in the Drizzle schema.
  */
 export function getFilePathForAttachment(attachmentId: string): string | null {
-  if (!filePathColumnEnsured) {
-    ensureFilePathColumn();
-    filePathColumnEnsured = true;
-  }
   const row = rawGet<{ file_path: string | null }>(
     "SELECT file_path FROM attachments WHERE id = ?",
     attachmentId,
@@ -277,6 +279,57 @@ export function getFilePathForAttachment(attachmentId: string): string | null {
   return row?.file_path ?? null;
 }
 
+/**
+ * Batch-fetch file_path values for multiple attachment IDs in a single query.
+ * Returns a Set of attachment IDs that are file-backed (have a non-null file_path).
+ * Uses raw SQL since file_path is added via runtime migration and is not in the Drizzle schema.
+ */
+export function getFileBackedAttachmentIds(
+  attachmentIds: string[],
+): Set<string> {
+  if (attachmentIds.length === 0) return new Set();
+  const placeholders = attachmentIds.map(() => "?").join(", ");
+  const rows = rawAll<{ id: string }>(
+    `SELECT id FROM attachments WHERE id IN (${placeholders}) AND file_path IS NOT NULL`,
+    ...attachmentIds,
+  );
+  return new Set(rows.map((r) => r.id));
+}
+
+/**
+ * Return the raw binary content for an attachment, abstracting over inline
+ * (base64-in-DB) vs file-backed (on-disk) storage.
+ *
+ * For file-backed attachments the bytes are read from the on-disk path;
+ * for inline attachments the base64 payload is decoded from the DB row.
+ *
+ * Returns null if the attachment does not exist.
+ */
+export function getAttachmentContent(attachmentId: string): Buffer | null {
+  const filePath = getFilePathForAttachment(attachmentId);
+  if (filePath) {
+    try {
+      return readFileSync(filePath);
+    } catch (err: unknown) {
+      if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+        return null;
+      }
+      throw err;
+    }
+  }
+
+  // Fall back to inline base64 stored in the DB
+  const db = getDb();
+  const row = db
+    .select({ dataBase64: attachments.dataBase64 })
+    .from(attachments)
+    .where(eq(attachments.id, attachmentId))
+    .get();
+
+  if (!row) return null;
+  return Buffer.from(row.dataBase64, "base64");
+}
+
 export function uploadAttachment(
   filename: string,
   mimeType: string,
@@ -394,8 +447,20 @@ export function deleteAttachment(attachmentId: string): DeleteAttachmentResult {
 
   if (refCount > 0) return "still_referenced";
 
+  // Collect file path BEFORE deleting the DB row (the row contains the path reference)
+  const filePath = getFilePathForAttachment(attachmentId);
+
   db.delete(attachments).where(eq(attachments.id, attachmentId)).run();
 
+  // Clean up on-disk file only after the DB row has been removed
+  if (filePath) {
+    try {
+      unlinkSync(filePath);
+    } catch {
+      /* file may already be gone */
+    }
+  }
+
   return "deleted";
 }
 

package/src/memory/canonical-guardian-store.ts

@@ -7,7 +7,7 @@
  * request from the expected status wins.
  */
 
-import { and, desc, eq, inArray } from "drizzle-orm";
+import { and, desc, eq, inArray, isNotNull, lt, or } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
 import { IntegrityError } from "../util/errors.js";
@@ -29,7 +29,7 @@ export function isRequestExpired(
   request: Pick<CanonicalGuardianRequest, "expiresAt">,
 ): boolean {
   if (!request.expiresAt) return false;
-  return new Date(request.expiresAt).getTime() < Date.now();
+  return request.expiresAt < Date.now();
 }
 
 // ---------------------------------------------------------------------------
@@ -64,9 +64,9 @@ export interface CanonicalGuardianRequest {
   decidedByExternalUserId: string | null;
   decidedByPrincipalId: string | null;
   followupState: string | null;
-  expiresAt: string | null;
-  createdAt: string;
-  updatedAt: string;
+  expiresAt: number | null;
+  createdAt: number;
+  updatedAt: number;
 }
 
 export interface CanonicalGuardianDelivery {
@@ -77,8 +77,8 @@ export interface CanonicalGuardianDelivery {
   destinationChatId: string | null;
   destinationMessageId: string | null;
   status: string;
-  createdAt: string;
-  updatedAt: string;
+  createdAt: number;
+  updatedAt: number;
 }
 
 // ---------------------------------------------------------------------------
@@ -201,7 +201,7 @@ export interface CreateCanonicalGuardianRequestParams {
   decidedByExternalUserId?: string;
   decidedByPrincipalId?: string;
   followupState?: string;
-  expiresAt?: string;
+  expiresAt?: number;
 }
 
 /**
@@ -231,7 +231,7 @@ export function createCanonicalGuardianRequest(
   }
 
   const db = getDb();
-  const now = new Date().toISOString();
+  const now = Date.now();
   const id = params.id ?? uuid();
 
   const row = {
@@ -383,7 +383,7 @@ export interface UpdateCanonicalGuardianRequestParams {
   decidedByExternalUserId?: string;
   decidedByPrincipalId?: string;
   followupState?: string | null;
-  expiresAt?: string;
+  expiresAt?: number;
 }
 
 export function updateCanonicalGuardianRequest(
@@ -391,7 +391,7 @@ export function updateCanonicalGuardianRequest(
   updates: UpdateCanonicalGuardianRequestParams,
 ): CanonicalGuardianRequest | null {
   const db = getDb();
-  const now = new Date().toISOString();
+  const now = Date.now();
 
   const setValues: Record<string, unknown> = { updatedAt: now };
   if (updates.status !== undefined) setValues.status = updates.status;
@@ -431,7 +431,7 @@ export function resolveCanonicalGuardianRequest(
   decision: ResolveDecision,
 ): CanonicalGuardianRequest | null {
   const db = getDb();
-  const now = new Date().toISOString();
+  const now = Date.now();
 
   const setValues: Record<string, unknown> = {
     status: decision.status,
@@ -471,30 +471,40 @@ export function resolveCanonicalGuardianRequest(
 const INTERACTION_BOUND_KINDS = ["tool_approval", "pending_question"];
 
 /**
- * Expire pending interaction-bound canonical guardian requests in a single
- * bulk update.
+ * Expire stale pending canonical guardian requests in a single bulk update.
  *
- * Called at daemon startup to clean up requests that can never be completed
- * because the in-memory pending-interactions Map (which holds session
- * references needed by resolvers) was wiped on restart.
+ * Called at daemon startup to clean up two categories of requests:
  *
- * Only expires request kinds that depend on in-memory pending interactions
- * (`tool_approval`, `pending_question`). Persistent kinds like
- * `access_request` and `tool_grant_request` resolve without pending
- * interactions and remain valid across restarts.
+ * 1. **Interaction-bound kinds** (`tool_approval`, `pending_question`) — these
+ *    can never be completed after a restart because the in-memory
+ *    pending-interactions Map was wiped.
+ *
+ * 2. **Already-dead persistent kinds** (`access_request`, `tool_grant_request`)
+ *    whose `expiresAt` has already passed while the daemon was stopped. Without
+ *    this, stale rows stay `pending` until the periodic sweep runs, causing
+ *    deduplication logic to return expired rows instead of creating fresh
+ *    requests.
  *
  * Returns the number of requests transitioned from pending → expired.
  */
 export function expireAllPendingCanonicalRequests(): number {
   const db = getDb();
-  const now = new Date().toISOString();
+  const now = Date.now();
 
   db.update(canonicalGuardianRequests)
     .set({ status: "expired", updatedAt: now })
     .where(
       and(
         eq(canonicalGuardianRequests.status, "pending"),
-        inArray(canonicalGuardianRequests.kind, INTERACTION_BOUND_KINDS),
+        or(
+          // Interaction-bound kinds: always expire on restart
+          inArray(canonicalGuardianRequests.kind, INTERACTION_BOUND_KINDS),
+          // Persistent kinds: expire only if already past their deadline
+          and(
+            isNotNull(canonicalGuardianRequests.expiresAt),
+            lt(canonicalGuardianRequests.expiresAt, now),
+          ),
+        ),
       ),
     )
     .run();
@@ -520,7 +530,7 @@ export function createCanonicalGuardianDelivery(
   params: CreateCanonicalGuardianDeliveryParams,
 ): CanonicalGuardianDelivery {
   const db = getDb();
-  const now = new Date().toISOString();
+  const now = Date.now();
   const id = params.id ?? uuid();
 
   const row = {
@@ -653,7 +663,7 @@ export function listPendingCanonicalGuardianRequestsByDestinationChat(
 
 /**
  * List pending canonical requests in scope for a conversation, unioning:
- *   1. Requests whose source `conversationId` matches the queried thread.
+ *   1. Requests whose source `conversationId` matches the queried conversation.
  *   2. Requests that have a delivery whose `destinationConversationId` matches.
  *
  * When `channel` is provided the delivery-scoped lookup is narrowed to that
@@ -781,7 +791,7 @@ export function getCanonicalRequestByPendingQuestionId(
  */
 export function expireCanonicalGuardianRequest(id: string): void {
   const db = getDb();
-  const now = new Date().toISOString();
+  const now = Date.now();
 
   db.update(canonicalGuardianRequests)
     .set({ status: "expired", updatedAt: now })
@@ -804,7 +814,7 @@ export function updateCanonicalGuardianDelivery(
   updates: UpdateCanonicalGuardianDeliveryParams,
 ): CanonicalGuardianDelivery | null {
   const db = getDb();
-  const now = new Date().toISOString();
+  const now = Date.now();
 
   const setValues: Record<string, unknown> = { updatedAt: now };
   if (updates.status !== undefined) setValues.status = updates.status;

package/src/memory/channel-verification-sessions.ts

@@ -59,7 +59,7 @@ export interface VerificationSession {
   challengeHash: string;
   expiresAt: number;
   status: SessionStatus;
-  createdBySessionId: string | null;
+  createdByConversationId: string | null;
   consumedByExternalUserId: string | null;
   consumedByChatId: string | null;
   // Outbound session: expected-identity binding
@@ -96,7 +96,7 @@ function rowToSession(
     challengeHash: row.challengeHash,
     expiresAt: row.expiresAt,
     status: row.status as SessionStatus,
-    createdBySessionId: row.createdBySessionId,
+    createdByConversationId: row.createdByConversationId,
     consumedByExternalUserId: row.consumedByExternalUserId,
     consumedByChatId: row.consumedByChatId,
     expectedExternalUserId: row.expectedExternalUserId ?? null,
@@ -127,7 +127,7 @@ export function createInboundSession(params: {
   channel: string;
   challengeHash: string;
   expiresAt: number;
-  createdBySessionId?: string;
+  createdByConversationId?: string;
 }): VerificationSession {
   const db = getDb();
   const now = Date.now();
@@ -150,7 +150,7 @@ export function createInboundSession(params: {
     challengeHash: params.challengeHash,
     expiresAt: params.expiresAt,
     status: "pending" as const,
-    createdBySessionId: params.createdBySessionId ?? null,
+    createdByConversationId: params.createdByConversationId ?? null,
     consumedByExternalUserId: null,
     consumedByChatId: null,
     expectedExternalUserId: null,
@@ -278,7 +278,7 @@ export function createVerificationSession(params: {
   challengeHash: string;
   expiresAt: number;
   status: SessionStatus;
-  createdBySessionId?: string;
+  createdByConversationId?: string;
   expectedExternalUserId?: string | null;
   expectedChatId?: string | null;
   expectedPhoneE164?: string | null;
@@ -313,7 +313,7 @@ export function createVerificationSession(params: {
     challengeHash: params.challengeHash,
     expiresAt: params.expiresAt,
     status: params.status as string,
-    createdBySessionId: params.createdBySessionId ?? null,
+    createdByConversationId: params.createdByConversationId ?? null,
     consumedByExternalUserId: null,
     consumedByChatId: null,
     expectedExternalUserId: params.expectedExternalUserId ?? null,

package/src/memory/checkpoints.ts

@@ -30,6 +30,11 @@ export function setMemoryCheckpoint(key: string, value: string): void {
     .run();
 }
 
+export function deleteMemoryCheckpoint(key: string): void {
+  const db = getDb();
+  db.delete(memoryCheckpoints).where(eq(memoryCheckpoints.key, key)).run();
+}
+
 export function readMessageCursorCheckpoint(
   createdAtKey: string,
   messageIdKey: string,

package/src/memory/conversation-bootstrap.ts

@@ -6,7 +6,7 @@ import {
 } from "./conversation-title-service.js";
 
 export interface BootstrapConversationOptions {
-  threadType?: "standard" | "private" | "background";
+  conversationType?: "standard" | "private" | "background";
   source?: string;
   origin: TitleOrigin;
   systemHint: string;
@@ -16,7 +16,7 @@ export interface BootstrapConversationOptions {
 export function bootstrapConversation(opts: BootstrapConversationOptions) {
   const conversation = createConversation({
     title: GENERATING_TITLE,
-    ...(opts.threadType && { threadType: opts.threadType }),
+    ...(opts.conversationType && { conversationType: opts.conversationType }),
     ...(opts.source && { source: opts.source }),
     ...(opts.scheduleJobId && { scheduleJobId: opts.scheduleJobId }),
   });