@vellumai/assistant 0.8.1 → 0.8.2

package/src/memory/llm-usage-store.ts

@@ -1,4 +1,4 @@
-import { and, asc, desc, eq, gt, or } from "drizzle-orm";
+import { and, asc, desc, eq, gt, or, sql } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
 import type {
@@ -8,7 +8,7 @@ import type {
 } from "../usage/types.js";
 import { getDb } from "./db-connection.js";
 import { rawAll } from "./raw-query.js";
-import { llmUsageEvents } from "./schema.js";
+import { conversations, llmUsageEvents } from "./schema.js";
 import {
   bucketEventsByDay,
   bucketEventsByHour,
@@ -123,15 +123,96 @@ export function listUsageEvents(options?: { limit?: number }): UsageEvent[] {
   return rows.map(rowToUsageEvent);
 }
 
+/**
+ * Telemetry-flavoured `UsageEvent`: the persisted columns plus the two
+ * JOIN-computed conversation-level fields the reporter needs to emit
+ * for analytics (`avg turns per conversation`, `tokens on first turn`,
+ * foreground/background split on llm_usage rows themselves).
+ *
+ * Lives next to the query that produces it so the shape stays in lockstep
+ * with the SELECT; broader `UsageEvent` consumers stay untouched.
+ */
+export interface UnreportedUsageEvent extends UsageEvent {
+  /**
+   * Type of the parent conversation (`"standard"` / `"background"` /
+   * `"scheduled"`). Null when the LLM call has no `conversationId`
+   * (memory consolidation, background embedding work, etc.) and so no
+   * `conversations` row to join against.
+   */
+  conversationType: string | null;
+  /**
+   * 1-indexed position of the user turn this LLM call belongs to within
+   * the parent conversation, counting only real user turns (tool-result
+   * rows persisted with role="user" are excluded — same filter as the
+   * turn-event eligibility predicate). Computed as the count of user
+   * messages with `created_at <= this LLM call's created_at` in the
+   * parent conversation. Null when there's no parent conversation, or
+   * when the LLM call fired before any user turn (rare — covers seed
+   * agent starts).
+   */
+  turnIndex: number | null;
+}
+
 export function queryUnreportedUsageEvents(
   afterCreatedAt: number,
   afterId: string | undefined,
   limit: number,
-): UsageEvent[] {
+): UnreportedUsageEvent[] {
   const db = getDb();
+  // JOIN to `conversations` to attach `conversationType`. LEFT JOIN
+  // because `llm_usage_events.conversationId` is nullable — calls that
+  // aren't tied to a conversation (memory consolidation, etc.) still
+  // need to flush through telemetry.
+  //
+  // `turnIndex` is a correlated subquery counting real user turns in
+  // the same conversation up to and including this LLM call's
+  // `created_at`. The filter mirrors `queryUnreportedTurnEvents` so the
+  // two indexes stay aligned: an LLM call fired during processing of
+  // turn N reports `turn_index = N`, matching what the turn event
+  // stream emitted for the triggering user message.
   const rows = db
-    .select()
+    .select({
+      id: llmUsageEvents.id,
+      createdAt: llmUsageEvents.createdAt,
+      conversationId: llmUsageEvents.conversationId,
+      runId: llmUsageEvents.runId,
+      requestId: llmUsageEvents.requestId,
+      actor: llmUsageEvents.actor,
+      callSite: llmUsageEvents.callSite,
+      inferenceProfile: llmUsageEvents.inferenceProfile,
+      inferenceProfileSource: llmUsageEvents.inferenceProfileSource,
+      provider: llmUsageEvents.provider,
+      model: llmUsageEvents.model,
+      inputTokens: llmUsageEvents.inputTokens,
+      outputTokens: llmUsageEvents.outputTokens,
+      cacheCreationInputTokens: llmUsageEvents.cacheCreationInputTokens,
+      cacheReadInputTokens: llmUsageEvents.cacheReadInputTokens,
+      estimatedCostUsd: llmUsageEvents.estimatedCostUsd,
+      pricingStatus: llmUsageEvents.pricingStatus,
+      conversationType: conversations.conversationType,
+      // Null when conversationId is null (no parent conversation).
+      // Otherwise the count of eligible user turns up to and including
+      // this LLM call's createdAt. The COALESCE guard returns null
+      // (rather than 0) for the "no user turn yet" edge case so the
+      // analytics layer can distinguish "before-first-turn" LLM calls.
+      turnIndex: sql<number | null>`(
+        CASE WHEN ${llmUsageEvents.conversationId} IS NULL THEN NULL
+        ELSE (
+          SELECT COUNT(*) FROM messages AS m2
+          WHERE m2.conversation_id = ${llmUsageEvents.conversationId}
+            AND m2.role = 'user'
+            AND m2.content NOT LIKE '%"type":"tool\\_result"%' ESCAPE '\\'
+            AND m2.content NOT LIKE '%"type":"web\\_search\\_tool\\_result"%' ESCAPE '\\'
+            AND m2.created_at <= ${llmUsageEvents.createdAt}
+        )
+        END
+      )`.as("turn_index"),
+    })
     .from(llmUsageEvents)
+    .leftJoin(
+      conversations,
+      eq(llmUsageEvents.conversationId, conversations.id),
+    )
     .where(
       afterId
         ? or(
@@ -146,7 +227,15 @@ export function queryUnreportedUsageEvents(
     .orderBy(asc(llmUsageEvents.createdAt), asc(llmUsageEvents.id))
     .limit(limit)
     .all();
-  return rows.map(rowToUsageEvent);
+  return rows.map((row) => ({
+    ...rowToUsageEvent(row),
+    conversationType: row.conversationType,
+    // SQLite returns COUNT(*) as 0 when no rows match; the CASE in the
+    // subquery already collapses the no-conversation case to NULL.
+    // Convert the integer column to `number | null` for the typed
+    // return value.
+    turnIndex: row.turnIndex === null ? null : Number(row.turnIndex),
+  }));
 }
 
 // ---------------------------------------------------------------------------
@@ -252,6 +341,37 @@ interface GroupRow {
   event_count: number;
 }
 
+/**
+ * Return aggregate usage for a single conversation (e.g. a subagent).
+ */
+export function getConversationUsageTotals(conversationId: string): {
+  inputTokens: number;
+  outputTokens: number;
+  estimatedCost: number;
+} {
+  const rows = rawAll<{
+    total_input: number;
+    total_output: number;
+    total_cost: number | null;
+  }>(
+    /*sql*/ `
+    SELECT
+      COALESCE(SUM(input_tokens + COALESCE(cache_creation_input_tokens, 0) + COALESCE(cache_read_input_tokens, 0)), 0) AS total_input,
+      COALESCE(SUM(output_tokens), 0) AS total_output,
+      COALESCE(SUM(estimated_cost_usd), 0) AS total_cost
+    FROM llm_usage_events
+    WHERE conversation_id = ?1
+    `,
+    conversationId,
+  );
+  const row = rows[0];
+  return {
+    inputTokens: row.total_input,
+    outputTokens: row.total_output,
+    estimatedCost: row.total_cost ?? 0,
+  };
+}
+
 /**
  * Return aggregate totals for all usage events within the given time range.
  */

package/src/memory/memory-retrospective-startup-cleanup.ts

@@ -24,8 +24,23 @@
 //     conversation might be the active one. We're conservative and only
 //     sweep when no job exists at all, since the worst-case false-positive
 //     is leaving a few extra orphans for the next sweep to catch.)
+//   - AND the row is NOT the most-recent retrospective for its source
+//     conversation. The next retrospective run reads the most-recent prior
+//     retro via `findMostRecentRetrospectiveFor` to seed its
+//     `<already_remembered>` dedup block; sweeping it would force the
+//     next run to re-save facts the prior pass already captured.
 
-import { and, eq, inArray, isNotNull, lt, notInArray, sql } from "drizzle-orm";
+import {
+  and,
+  eq,
+  inArray,
+  isNotNull,
+  isNull,
+  lt,
+  notInArray,
+  or,
+  sql,
+} from "drizzle-orm";
 
 import { getLogger } from "../util/logger.js";
 import { deleteConversation } from "./conversation-crud.js";
@@ -53,7 +68,14 @@ export function sweepOrphanMemoryRetrospectiveConversations(
   const cutoff = now - ORPHAN_AGE_MS;
   const db = getDb();
 
-  const activeJobConversationIds = db
+  // Job payloads encode the SOURCE conversation id (the conversation being
+  // analyzed), not the background-conversation id of the retrospective itself.
+  // The background conversation links back to its source via
+  // `forkParentConversationId` (set when bootstrapped — see
+  // memory-retrospective-job.ts). To protect in-flight jobs we therefore
+  // compare source-id to source-id by filtering on
+  // `conversations.forkParentConversationId`, not `conversations.id`.
+  const activeJobSourceConversationIds = db
     .select({
       conversationId: sql<string>`json_extract(${memoryJobs.payload}, '$.conversationId')`,
     })
@@ -68,6 +90,40 @@ export function sweepOrphanMemoryRetrospectiveConversations(
     .map((row) => row.conversationId)
     .filter((id): id is string => typeof id === "string" && id.length > 0);
 
+  // Compute the most-recent retro per source so we can preserve it.
+  // `findMostRecentRetrospectiveFor` (called by the next retrospective run)
+  // pulls dedup context from this row; sweeping it would re-introduce the
+  // unbounded-growth bug PR #30331 was created to fix.
+  const allRetros = db
+    .select({
+      id: conversations.id,
+      forkParentConversationId: conversations.forkParentConversationId,
+      createdAt: conversations.createdAt,
+    })
+    .from(conversations)
+    .where(
+      and(
+        eq(conversations.source, MEMORY_RETROSPECTIVE_SOURCE),
+        isNotNull(conversations.forkParentConversationId),
+      ),
+    )
+    .all();
+  const mostRecentPerSource = new Map<
+    string,
+    { id: string; createdAt: number }
+  >();
+  for (const row of allRetros) {
+    const parent = row.forkParentConversationId;
+    if (parent === null) continue;
+    const cur = mostRecentPerSource.get(parent);
+    if (!cur || row.createdAt > cur.createdAt) {
+      mostRecentPerSource.set(parent, { id: row.id, createdAt: row.createdAt });
+    }
+  }
+  const preservedIds = new Set(
+    Array.from(mostRecentPerSource.values(), (v) => v.id),
+  );
+
   const orphans = db
     .select({ id: conversations.id })
     .from(conversations)
@@ -79,12 +135,23 @@ export function sweepOrphanMemoryRetrospectiveConversations(
         // last_message_at value are too fresh to assess.
         isNotNull(conversations.lastMessageAt),
         lt(conversations.lastMessageAt, cutoff),
-        activeJobConversationIds.length > 0
-          ? notInArray(conversations.id, activeJobConversationIds)
+        activeJobSourceConversationIds.length > 0
+          ? // `forkParentConversationId` is nullable, and SQLite's
+            // `NULL NOT IN (...)` evaluates to unknown (falsy), so legacy
+            // rows with a null parent would never match. Include them
+            // explicitly so the sweep covers them.
+            or(
+              isNull(conversations.forkParentConversationId),
+              notInArray(
+                conversations.forkParentConversationId,
+                activeJobSourceConversationIds,
+              ),
+            )
           : sql`1=1`,
       ),
     )
-    .all();
+    .all()
+    .filter((row) => !preservedIds.has(row.id));
 
   let swept = 0;
   for (const row of orphans) {

package/src/memory/message-content.ts

@@ -152,7 +152,7 @@ export function stringifyMessageContent(stored: string): string {
     return stored.trim();
   }
   if (typeof parsed === "string") return parsed.trim();
-  if (!Array.isArray(parsed)) return "";
+  if (!Array.isArray(parsed)) return stored.trim();
   const parts: string[] = [];
   for (const block of parsed) {
     if (

package/src/memory/migrations/109-external-conversation-bindings.ts

@@ -1,8 +1,7 @@
 import type { DrizzleDb } from "../db-connection.js";
-import { migrateExtConvBindingsChannelChatUnique } from "./010-ext-conv-bindings-channel-chat-unique.js";
 
 /**
- * External conversation bindings table with indexes and unique constraint migration.
+ * External conversation bindings table with indexes.
  */
 export function createExternalConversationBindingsTables(
   database: DrizzleDb,
@@ -12,6 +11,7 @@ export function createExternalConversationBindingsTables(
       conversation_id TEXT PRIMARY KEY REFERENCES conversations(id) ON DELETE CASCADE,
       source_channel TEXT NOT NULL,
       external_chat_id TEXT NOT NULL,
+      external_thread_id TEXT,
       external_user_id TEXT,
       display_name TEXT,
       username TEXT,
@@ -25,9 +25,20 @@ export function createExternalConversationBindingsTables(
   database.run(
     /*sql*/ `CREATE INDEX IF NOT EXISTS idx_ext_conv_bindings_channel_chat ON external_conversation_bindings(source_channel, external_chat_id)`,
   );
+  database.run(
+    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_ext_conv_bindings_channel_chat_thread ON external_conversation_bindings(source_channel, external_chat_id, external_thread_id)`,
+  );
   database.run(
     /*sql*/ `CREATE INDEX IF NOT EXISTS idx_ext_conv_bindings_channel ON external_conversation_bindings(source_channel)`,
   );
-
-  migrateExtConvBindingsChannelChatUnique(database);
+  database.run(/*sql*/ `
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_ext_conv_bindings_channel_chat_no_thread_unique
+    ON external_conversation_bindings(source_channel, external_chat_id)
+    WHERE external_thread_id IS NULL
+  `);
+  database.run(/*sql*/ `
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_ext_conv_bindings_channel_chat_thread_unique
+    ON external_conversation_bindings(source_channel, external_chat_id, external_thread_id)
+    WHERE external_thread_id IS NOT NULL
+  `);
 }

package/src/memory/migrations/229-delete-private-conversations.test.ts

@@ -1133,7 +1133,7 @@ describe("migrateDeletePrivateConversations", () => {
         1,
         'text',
         'eA==',
-        ${now}
+        ${now - 60_000}
       );
     `);
 
@@ -1153,4 +1153,41 @@ describe("migrateDeletePrivateConversations", () => {
       countWhere(raw, "attachments", `id = 'conv-standard-attachment'`),
     ).toBe(1);
   });
+
+  test("preserves pre-staged uploads (unlinked attachments) created after migration starts", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    const now = Date.now();
+
+    bootstrapTables(raw);
+    seedConversation(raw, "conv-standard", "standard");
+    // created_at in the future ensures it lands after the migration's start
+    // snapshot regardless of clock resolution / test-runner scheduling.
+    raw.exec(/*sql*/ `
+      INSERT INTO attachments (
+        id,
+        original_filename,
+        mime_type,
+        size_bytes,
+        kind,
+        data_base64,
+        created_at
+      ) VALUES (
+        'pre-staged-upload',
+        'pending.txt',
+        'text/plain',
+        1,
+        'text',
+        'eA==',
+        ${now + 60_000}
+      );
+    `);
+
+    migrateDeletePrivateConversations(db);
+
+    expect(countWhere(raw, "attachments", `id = 'pre-staged-upload'`)).toBe(1);
+    expect(
+      countWhere(raw, "attachments", `id = 'conv-standard-attachment'`),
+    ).toBe(1);
+  });
 });

package/src/memory/migrations/229-delete-private-conversations.ts

@@ -12,6 +12,12 @@ const PRIVATE_GRAPH_NODE_IDS = /*sql*/ `
 `;
 
 export function migrateDeletePrivateConversations(database: DrizzleDb): void {
+  // Snapshot the migration's start time. The trailing orphan-attachment sweep
+  // uses this as an upper bound so it cleans up leaks from prior runs of this
+  // migration (those rows were created before this run started) without
+  // touching pre-staged uploads created during or after the migration.
+  const migrationStartTs = Date.now();
+
   database.run(/*sql*/ `
     DELETE FROM tool_invocations
     WHERE conversation_id IN (${PRIVATE_CONVERSATION_IDS})
@@ -204,6 +210,7 @@ export function migrateDeletePrivateConversations(database: DrizzleDb): void {
       FROM message_attachments ma
       WHERE ma.attachment_id = attachments.id
     )
+      AND created_at <= ${migrationStartTs}
   `);
   database.run(/*sql*/ `
     DELETE FROM memory_summaries

package/src/memory/migrations/247-external-conversation-binding-thread-id.ts

@@ -0,0 +1,78 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Add a provider thread anchor to external conversation bindings.
+ *
+ * Slack conversations are keyed by `(channel_id, thread_ts)`, while legacy
+ * channels still use only `(source_channel, external_chat_id)`. SQLite treats
+ * NULLs as distinct in unique indexes, so use two partial unique indexes:
+ * one for legacy/no-thread bindings and one for threaded bindings.
+ */
+export function migrateExternalConversationBindingThreadId(
+  database: DrizzleDb,
+): void {
+  const raw = getSqliteFrom(database);
+
+  const tableExists = raw
+    .query(
+      `SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'external_conversation_bindings'`,
+    )
+    .get();
+  if (!tableExists) return;
+
+  const columns = raw
+    .query(`PRAGMA table_info(external_conversation_bindings)`)
+    .all() as Array<{ name: string }>;
+  if (!columns.some((column) => column.name === "external_thread_id")) {
+    raw.exec(
+      `ALTER TABLE external_conversation_bindings ADD COLUMN external_thread_id TEXT`,
+    );
+  }
+
+  try {
+    raw.exec("BEGIN");
+
+    raw.exec(`DROP INDEX IF EXISTS idx_ext_conv_bindings_channel_chat_unique`);
+
+    raw.exec(/*sql*/ `
+      DELETE FROM external_conversation_bindings
+      WHERE rowid NOT IN (
+        SELECT rowid FROM (
+          SELECT rowid,
+                 ROW_NUMBER() OVER (
+                   PARTITION BY source_channel, external_chat_id, COALESCE(external_thread_id, '')
+                   ORDER BY updated_at DESC, created_at DESC, rowid DESC
+                 ) AS rn
+          FROM external_conversation_bindings
+        )
+        WHERE rn = 1
+      )
+    `);
+
+    raw.exec(/*sql*/ `
+      CREATE INDEX IF NOT EXISTS idx_ext_conv_bindings_channel_chat_thread
+      ON external_conversation_bindings(source_channel, external_chat_id, external_thread_id)
+    `);
+
+    raw.exec(/*sql*/ `
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_ext_conv_bindings_channel_chat_no_thread_unique
+      ON external_conversation_bindings(source_channel, external_chat_id)
+      WHERE external_thread_id IS NULL
+    `);
+
+    raw.exec(/*sql*/ `
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_ext_conv_bindings_channel_chat_thread_unique
+      ON external_conversation_bindings(source_channel, external_chat_id, external_thread_id)
+      WHERE external_thread_id IS NOT NULL
+    `);
+
+    raw.exec("COMMIT");
+  } catch (err) {
+    try {
+      raw.exec("ROLLBACK");
+    } catch {
+      /* no active transaction */
+    }
+    throw err;
+  }
+}

package/src/memory/migrations/248-create-onboarding-events.ts

@@ -0,0 +1,21 @@
+import type { DrizzleDb } from "../db-connection.js";
+
+/**
+ * Create the onboarding_events table for tracking pre-chat onboarding
+ * selections (tools, tasks, tone, Google connect status).
+ */
+export function createOnboardingEventsTable(database: DrizzleDb): void {
+  database.run(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS onboarding_events (
+      id TEXT PRIMARY KEY,
+      created_at INTEGER NOT NULL,
+      screen TEXT NOT NULL,
+      tools_json TEXT,
+      tasks_json TEXT,
+      tone TEXT,
+      google_connected INTEGER,
+      google_scopes_json TEXT,
+      ab_variant TEXT
+    )
+  `);
+}