@vellumai/assistant 0.7.0 → 0.7.2

package/src/memory/migrations/__tests__/234-memory-v2-activation-logs.test.ts

@@ -0,0 +1,182 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import { getSqliteFrom } from "../../db-connection.js";
+import * as schema from "../../schema.js";
+import {
+  downMemoryV2ActivationLogs,
+  migrateMemoryV2ActivationLogs,
+} from "../234-memory-v2-activation-logs.js";
+
+interface TableRow {
+  name: string;
+}
+
+interface IndexRow {
+  name: string;
+}
+
+interface ColumnRow {
+  name: string;
+  type: string;
+  notnull: number;
+  dflt_value: string | null;
+  pk: number;
+}
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  sqlite.exec("PRAGMA foreign_keys = ON");
+  return drizzle(sqlite, { schema });
+}
+
+function bootstrapCheckpointsTable(raw: Database): void {
+  raw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS memory_checkpoints (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+}
+
+const EXPECTED_INDEXES = [
+  "idx_memory_v2_activation_logs_message_id",
+  "idx_memory_v2_activation_logs_conversation_id",
+  "idx_memory_v2_activation_logs_created_at",
+];
+
+describe("memory_v2_activation_logs migration", () => {
+  test("creates table with expected columns and indexes", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapCheckpointsTable(raw);
+
+    migrateMemoryV2ActivationLogs(db);
+
+    const tableRow = raw
+      .query(
+        `SELECT name FROM sqlite_master WHERE type='table' AND name='memory_v2_activation_logs'`,
+      )
+      .get() as TableRow | null;
+    expect(tableRow?.name).toBe("memory_v2_activation_logs");
+
+    const columns = raw
+      .query(`PRAGMA table_info(memory_v2_activation_logs)`)
+      .all() as ColumnRow[];
+    const byName = new Map(columns.map((c) => [c.name, c]));
+
+    expect(byName.get("id")?.pk).toBe(1);
+    expect(byName.get("id")?.type).toBe("TEXT");
+    expect(byName.get("conversation_id")?.notnull).toBe(1);
+    expect(byName.get("conversation_id")?.type).toBe("TEXT");
+    expect(byName.get("message_id")?.notnull).toBe(0);
+    expect(byName.get("message_id")?.type).toBe("TEXT");
+    expect(byName.get("turn")?.notnull).toBe(1);
+    expect(byName.get("turn")?.type).toBe("INTEGER");
+    expect(byName.get("mode")?.notnull).toBe(1);
+    expect(byName.get("mode")?.type).toBe("TEXT");
+    expect(byName.get("concepts_json")?.notnull).toBe(1);
+    expect(byName.get("concepts_json")?.type).toBe("TEXT");
+    expect(byName.get("skills_json")?.notnull).toBe(1);
+    expect(byName.get("skills_json")?.type).toBe("TEXT");
+    expect(byName.get("config_json")?.notnull).toBe(1);
+    expect(byName.get("config_json")?.type).toBe("TEXT");
+    expect(byName.get("created_at")?.notnull).toBe(1);
+    expect(byName.get("created_at")?.type).toBe("INTEGER");
+
+    const indexes = raw
+      .query(
+        `SELECT name FROM sqlite_master WHERE type='index' AND tbl_name='memory_v2_activation_logs'`,
+      )
+      .all() as IndexRow[];
+    const indexNames = new Set(indexes.map((r) => r.name));
+    for (const expected of EXPECTED_INDEXES) {
+      expect(indexNames.has(expected)).toBe(true);
+    }
+  });
+
+  test("re-running the migration is a no-op", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapCheckpointsTable(raw);
+
+    migrateMemoryV2ActivationLogs(db);
+
+    raw
+      .query(
+        /*sql*/ `
+        INSERT INTO memory_v2_activation_logs (
+          id,
+          conversation_id,
+          message_id,
+          turn,
+          mode,
+          concepts_json,
+          skills_json,
+          config_json,
+          created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `,
+      )
+      .run(
+        "log-1",
+        "conv-abc",
+        "msg-xyz",
+        3,
+        "per-turn",
+        "[]",
+        "[]",
+        "{}",
+        1000,
+      );
+
+    expect(() => migrateMemoryV2ActivationLogs(db)).not.toThrow();
+
+    const row = raw
+      .query(`SELECT id FROM memory_v2_activation_logs WHERE id = 'log-1'`)
+      .get() as { id: string } | null;
+    expect(row?.id).toBe("log-1");
+
+    const indexes = raw
+      .query(
+        `SELECT name FROM sqlite_master WHERE type='index' AND tbl_name='memory_v2_activation_logs'`,
+      )
+      .all() as IndexRow[];
+    const indexNames = new Set(indexes.map((r) => r.name));
+    for (const expected of EXPECTED_INDEXES) {
+      expect(indexNames.has(expected)).toBe(true);
+    }
+  });
+
+  test("down() drops the table and is idempotent", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapCheckpointsTable(raw);
+
+    migrateMemoryV2ActivationLogs(db);
+
+    expect(
+      raw
+        .query(
+          `SELECT name FROM sqlite_master WHERE type='table' AND name='memory_v2_activation_logs'`,
+        )
+        .get(),
+    ).toBeTruthy();
+
+    downMemoryV2ActivationLogs(db);
+
+    expect(
+      raw
+        .query(
+          `SELECT name FROM sqlite_master WHERE type='table' AND name='memory_v2_activation_logs'`,
+        )
+        .get(),
+    ).toBeNull();
+
+    expect(() => downMemoryV2ActivationLogs(db)).not.toThrow();
+  });
+});

package/src/memory/migrations/index.ts

@@ -181,6 +181,25 @@ export {
   downActivationState,
   migrateActivationState,
 } from "./232-activation-state.js";
+export { migrateCreateDocumentConversations } from "./233-document-conversations.js";
+export {
+  downMemoryV2ActivationLogs,
+  migrateMemoryV2ActivationLogs,
+} from "./234-memory-v2-activation-logs.js";
+export { migrateLlmUsageAttribution } from "./235-llm-usage-attribution.js";
+export {
+  downSlackCompactionWatermark,
+  migrateSlackCompactionWatermark,
+} from "./235-slack-compaction-watermark.js";
+export {
+  downToolInvocationsMatchedRuleId,
+  migrateToolInvocationsMatchedRuleId,
+} from "./236-tool-invocations-matched-rule-id.js";
+export {
+  downHeartbeatRuns,
+  migrateHeartbeatRuns,
+} from "./237-heartbeat-runs.js";
+export { migrateScheduleRetryPolicy } from "./238-schedule-retry-policy.js";
 export {
   MIGRATION_REGISTRY,
   type MigrationRegistryEntry,

package/src/memory/migrations/registry.ts

@@ -44,6 +44,10 @@ import { migrateScrubCorruptedImageAttachmentsDown } from "./206-scrub-corrupted
 import { downConversationHostAccess } from "./217-conversation-host-access.js";
 import { downNormalizeUserFileByPrincipal } from "./220-normalize-user-file-by-principal.js";
 import { downActivationState } from "./232-activation-state.js";
+import { downMemoryV2ActivationLogs } from "./234-memory-v2-activation-logs.js";
+import { downSlackCompactionWatermark } from "./235-slack-compaction-watermark.js";
+import { downToolInvocationsMatchedRuleId } from "./236-tool-invocations-matched-rule-id.js";
+import { downHeartbeatRuns } from "./237-heartbeat-runs.js";
 
 export interface MigrationRegistryEntry {
   /** The checkpoint key written to memory_checkpoints on completion. */
@@ -380,6 +384,34 @@ export const MIGRATION_REGISTRY: MigrationRegistryEntry[] = [
     description: "Create activation_state table for memory v2",
     down: downActivationState,
   },
+  {
+    key: "migration_memory_v2_activation_logs_v1",
+    version: 44,
+    description:
+      "Create memory_v2_activation_logs table for per-turn v2 activation telemetry consumed by the LLM Context Inspector",
+    down: downMemoryV2ActivationLogs,
+  },
+  {
+    key: "migration_slack_compaction_watermark_v1",
+    version: 45,
+    description:
+      "Add Slack-specific compaction watermark columns to conversations",
+    down: downSlackCompactionWatermark,
+  },
+  {
+    key: "migration_tool_invocations_matched_trust_rule_id_v1",
+    version: 46,
+    description:
+      "Add matched_trust_rule_id column to tool_invocations for trust rule audit and rule editor UI",
+    down: downToolInvocationsMatchedRuleId,
+  },
+  {
+    key: "migration_heartbeat_runs_v1",
+    version: 47,
+    description:
+      "Create heartbeat_runs table for tracking heartbeat execution lifecycle with CAS state transitions",
+    down: downHeartbeatRuns,
+  },
 ];
 
 export function getMaxMigrationVersion(): number {

package/src/memory/pkb/pkb-search.ts

@@ -2,7 +2,9 @@
 // PKB — Qdrant hybrid search for indexed PKB markdown files
 // ---------------------------------------------------------------------------
 
+import { getConfig } from "../../config/loader.js";
 import { getLogger } from "../../util/logger.js";
+import { isMemoryV2ReadActive } from "../context-search/sources/memory-v2.js";
 import {
   isQdrantBreakerOpen,
   withQdrantBreaker,
@@ -40,6 +42,11 @@ export async function searchPkbFiles(
   limit: number,
   scopeIds?: string[],
 ): Promise<PkbSearchResult[]> {
+  // v2 owns the read path when both gates are on; v2 absorbs PKB as a read
+  // source, so PKB hint search short-circuits to keep traffic off the v1
+  // collection (avoiding OOM-crash risk from a corrupted sparse segment).
+  if (isMemoryV2ReadActive(getConfig())) return [];
+
   if (isQdrantBreakerOpen()) {
     log.warn("Qdrant circuit breaker open, skipping PKB search");
     return [];

package/src/memory/qdrant-client.ts

@@ -73,19 +73,31 @@ export interface QdrantSearchResult {
   payload: QdrantPointPayload;
 }
 
+/**
+ * Strip a trailing `:sparse-v<digits>` segment from a sentinel string.
+ *
+ * Legacy v1 sentinels (pre-decouple) included the sparse encoder version in
+ * the embedding-model identity. The suffix is no longer written, but stored
+ * sentinels written by older daemons may still carry it — strip it before
+ * comparing identities so existing collections aren't unnecessarily rebuilt.
+ */
+export function stripLegacySparseSuffix(sentinel: string): string {
+  return sentinel.replace(/:sparse-v\d+$/, "");
+}
+
 let _instance: VellumQdrantClient | null = null;
 
 export function getQdrantClient(): VellumQdrantClient {
   if (!_instance) {
     throw new Error(
-      "Qdrant client not initialized. Call initQdrantClient() first."
+      "Qdrant client not initialized. Call initQdrantClient() first.",
     );
   }
   return _instance;
 }
 
 export function initQdrantClient(
-  config: QdrantClientConfig
+  config: QdrantClientConfig,
 ): VellumQdrantClient {
   _instance = new VellumQdrantClient(config);
   return _instance;
@@ -140,12 +152,28 @@ export class VellumQdrantClient {
           const dimMismatch =
             currentSize != null && currentSize !== this.vectorSize;
 
-          // Check model identity via a sentinel point that stores the embedding model
+          // Check model identity via a sentinel point that stores the embedding model.
+          //
+          // Legacy sentinels included a ":sparse-v<N>" suffix that conflated the
+          // sparse encoder version with the dense model identity. Sparse vectors
+          // are upserted in place and never require collection recreation, so a
+          // stored value matching the current dense identity after stripping any
+          // legacy sparse suffix is treated as compatible. Compatible-but-legacy
+          // sentinels are rewritten to the new format below to clean up gradually.
           let modelMismatch = false;
+          let needsSentinelRewrite = false;
           if (this.embeddingModel) {
             const sentinel = await this.readSentinel();
-            if (sentinel && sentinel !== this.embeddingModel) {
-              modelMismatch = true;
+            if (sentinel) {
+              const normalizedStored = stripLegacySparseSuffix(sentinel);
+              const normalizedCurrent = stripLegacySparseSuffix(
+                this.embeddingModel,
+              );
+              if (normalizedStored !== normalizedCurrent) {
+                modelMismatch = true;
+              } else if (sentinel !== this.embeddingModel) {
+                needsSentinelRewrite = true;
+              }
             }
           }
 
@@ -156,7 +184,7 @@ export class VellumQdrantClient {
                 currentSize,
                 expectedSize: this.vectorSize,
               },
-              "Qdrant collection uses unnamed vectors (legacy) — deleting and recreating with named vectors. Embeddings will be re-indexed."
+              "Qdrant collection uses unnamed vectors (legacy) — deleting and recreating with named vectors. Embeddings will be re-indexed.",
             );
             await this.client.deleteCollection(this.collection);
             migrated = true;
@@ -169,7 +197,7 @@ export class VellumQdrantClient {
                 expectedSize: this.vectorSize,
                 modelMismatch,
               },
-              "Qdrant collection incompatible (dimension or model change) — deleting and recreating. Embeddings will be regenerated on demand."
+              "Qdrant collection incompatible (dimension or model change) — deleting and recreating. Embeddings will be regenerated on demand.",
             );
             await this.client.deleteCollection(this.collection);
             migrated = true;
@@ -178,12 +206,15 @@ export class VellumQdrantClient {
             if (await this.ensurePayloadIndexesSafe()) {
               this.collectionReady = true;
             }
+            if (needsSentinelRewrite && this.embeddingModel) {
+              await this.writeSentinel(this.embeddingModel);
+            }
             return { migrated: false };
           }
         } catch (err) {
           log.warn(
             { err },
-            "Failed to verify collection compatibility, assuming compatible"
+            "Failed to verify collection compatibility, assuming compatible",
           );
           if (await this.ensurePayloadIndexesSafe()) {
             this.collectionReady = true;
@@ -197,7 +228,7 @@ export class VellumQdrantClient {
 
     log.info(
       { collection: this.collection, vectorSize: this.vectorSize },
-      "Creating Qdrant collection with named vectors (dense + sparse)"
+      "Creating Qdrant collection with named vectors (dense + sparse)",
     );
 
     try {
@@ -253,7 +284,7 @@ export class VellumQdrantClient {
       this.collectionReady = true;
       log.info(
         { collection: this.collection },
-        "Qdrant collection created with payload indexes"
+        "Qdrant collection created with payload indexes",
       );
     }
 
@@ -265,7 +296,7 @@ export class VellumQdrantClient {
     targetId: string,
     vector: number[],
     payload: Omit<QdrantPointPayload, "target_type" | "target_id">,
-    sparseVector?: QdrantSparseVector
+    sparseVector?: QdrantSparseVector,
   ): Promise<string> {
     await this.ensureCollection();
 
@@ -320,7 +351,7 @@ export class VellumQdrantClient {
   async search(
     vector: number[],
     limit: number,
-    filter?: Record<string, unknown>
+    filter?: Record<string, unknown>,
   ): Promise<QdrantSearchResult[]> {
     await this.ensureCollection();
 
@@ -348,7 +379,7 @@ export class VellumQdrantClient {
     return results.map((result) => ({
       id: typeof result.id === "string" ? result.id : String(result.id),
       score: result.score,
-      payload: (result.payload as unknown) as QdrantPointPayload,
+      payload: result.payload as unknown as QdrantPointPayload,
     }));
   }
 
@@ -357,7 +388,7 @@ export class VellumQdrantClient {
     limit: number,
     targetTypes: Array<"segment" | "item" | "summary" | "media">,
     excludeMessageIds?: string[],
-    scopeIds?: string[]
+    scopeIds?: string[],
   ): Promise<QdrantSearchResult[]> {
     const mustConditions: Array<Record<string, unknown>> = [
       {
@@ -434,7 +465,7 @@ export class VellumQdrantClient {
     const queryParams = {
       prefetch: [
         {
-          query: (denseVector as unknown) as number[],
+          query: denseVector as unknown as number[],
           using: "dense",
           limit: effectivePrefetchLimit,
         },
@@ -469,7 +500,7 @@ export class VellumQdrantClient {
     return (results.points ?? []).map((point) => ({
       id: typeof point.id === "string" ? point.id : String(point.id),
       score: point.score ?? 0,
-      payload: (point.payload as unknown) as QdrantPointPayload,
+      payload: point.payload as unknown as QdrantPointPayload,
     }));
   }
 
@@ -594,7 +625,7 @@ export class VellumQdrantClient {
     } catch (err) {
       log.warn(
         { err, collection: this.collection },
-        "Failed to delete Qdrant collection"
+        "Failed to delete Qdrant collection",
       );
       return false;
     }
@@ -762,8 +793,7 @@ export class VellumQdrantClient {
           ...(offset !== undefined ? { offset } : {}),
         });
         for (const point of result.points) {
-          const id =
-            typeof point.id === "string" ? point.id : String(point.id);
+          const id = typeof point.id === "string" ? point.id : String(point.id);
           const payload = (point.payload ?? {}) as Record<string, unknown>;
           out.push({ id, payload });
         }
@@ -788,7 +818,7 @@ export class VellumQdrantClient {
 
   private async findByTarget(
     targetType: string,
-    targetId: string
+    targetId: string,
   ): Promise<string | null> {
     try {
       const results = await this.client.scroll(this.collection, {

package/src/memory/raw-query.ts

@@ -30,9 +30,9 @@
  * filtering, ordering, pagination — use Drizzle.
  */
 
-import type { Database, SQLQueryBindings } from "bun:sqlite";
+import type { SQLQueryBindings } from "bun:sqlite";
 
-import { type DrizzleDb, getSqlite, getSqliteFrom } from "./db-connection.js";
+import { getSqlite } from "./db-connection.js";
 
 type SqlParam = SQLQueryBindings;
 
@@ -82,72 +82,6 @@ export function rawChanges(): number {
   return (getSqlite().query("SELECT changes() AS c").get() as { c: number }).c;
 }
 
-// ---------------------------------------------------------------------------
-// Typed query helpers (explicit Drizzle instance)
-//
-// Used by migrations and tests that receive the Drizzle instance as a
-// parameter rather than using the global singleton.
-// ---------------------------------------------------------------------------
-
-/** Execute a raw SQL query against a specific Drizzle instance and return a single typed row. */
-export function rawGetFrom<T>(
-  db: DrizzleDb,
-  sql: string,
-  ...params: SqlParam[]
-): T | null {
-  return (
-    (getSqliteFrom(db)
-      .query(sql)
-      .get(...params) as T) ?? null
-  );
-}
-
-/** Execute a raw SQL query against a specific Drizzle instance and return all matching rows. */
-export function rawAllFrom<T>(
-  db: DrizzleDb,
-  sql: string,
-  ...params: SqlParam[]
-): T[] {
-  return getSqliteFrom(db)
-    .query(sql)
-    .all(...params) as T[];
-}
-
-/**
- * Execute a raw SQL statement against a specific Drizzle instance and return
- * affected row count.
- */
-export function rawRunFrom(
-  db: DrizzleDb,
-  sql: string,
-  ...params: SqlParam[]
-): number {
-  const sqlite = getSqliteFrom(db);
-  sqlite.query(sql).run(...params);
-  return (sqlite.query("SELECT changes() AS c").get() as { c: number }).c;
-}
-
-/** Execute batch SQL against a specific Drizzle instance. */
-export function rawExecFrom(db: DrizzleDb, sql: string): void {
-  getSqliteFrom(db).exec(sql);
-}
-
-/**
- * Create a prepared statement from the raw SQLite client.
- * Useful when you need to execute the same parameterized query in a loop.
- */
-export function rawPrepare(sql: string): ReturnType<Database["prepare"]> {
-  return getSqlite().prepare(sql);
-}
-
-/** Create a prepared statement from a specific Drizzle instance. */
-export function rawPrepareFrom(
-  db: DrizzleDb,
-  sql: string,
-): ReturnType<Database["prepare"]> {
-  return getSqliteFrom(db).prepare(sql);
-}
-
 /**
  * Delete all rows from the given tables in a single transaction.
  *

package/src/memory/schema/conversations.ts

@@ -21,6 +21,12 @@ export const conversations = sqliteTable(
       .notNull()
       .default(0),
     contextCompactedAt: integer("context_compacted_at"),
+    slackContextCompactionWatermarkTs: text(
+      "slack_context_compaction_watermark_ts",
+    ),
+    slackContextCompactionWatermarkAt: integer(
+      "slack_context_compaction_watermark_at",
+    ),
     conversationType: text("conversation_type").notNull().default("standard"),
     source: text("source").notNull().default("user"),
     memoryScopeId: text("memory_scope_id").notNull().default("default"),
@@ -72,6 +78,7 @@ export const toolInvocations = sqliteTable(
     result: text("result").notNull(),
     decision: text("decision").notNull(),
     riskLevel: text("risk_level").notNull(),
+    matchedTrustRuleId: text("matched_trust_rule_id"),
     durationMs: integer("duration_ms").notNull(),
     createdAt: integer("created_at").notNull(),
   },

package/src/memory/schema/infrastructure.ts

@@ -19,6 +19,8 @@ export const cronJobs = sqliteTable("cron_jobs", {
   lastRunAt: integer("last_run_at"),
   lastStatus: text("last_status"), // 'ok' | 'error'
   retryCount: integer("retry_count").notNull().default(0),
+  maxRetries: integer("max_retries").notNull().default(3),
+  retryBackoffMs: integer("retry_backoff_ms").notNull().default(60000),
   createdBy: text("created_by").notNull(), // 'agent' | 'user'
   mode: text("mode").notNull().default("execute"), // 'notify' | 'execute'
   routingIntent: text("routing_intent").notNull().default("all_channels"), // 'single_channel' | 'multi_channel' | 'all_channels'
@@ -54,6 +56,19 @@ export const cronRuns = sqliteTable("cron_runs", {
 export const scheduleJobs = cronJobs;
 export const scheduleRuns = cronRuns;
 
+export const heartbeatRuns = sqliteTable("heartbeat_runs", {
+  id: text("id").primaryKey(),
+  scheduledFor: integer("scheduled_for").notNull(),
+  startedAt: integer("started_at"),
+  finishedAt: integer("finished_at"),
+  durationMs: integer("duration_ms"),
+  status: text("status").notNull(), // 'pending' | 'running' | 'ok' | 'error' | 'timeout' | 'skipped' | 'missed' | 'superseded'
+  skipReason: text("skip_reason"), // 'disabled' | 'outside_active_hours' | 'overlap'
+  error: text("error"),
+  conversationId: text("conversation_id"),
+  createdAt: integer("created_at").notNull(),
+});
+
 export const sharedAppLinks = sqliteTable("shared_app_links", {
   id: text("id").primaryKey(),
   shareToken: text("share_token").notNull().unique(),
@@ -161,6 +176,28 @@ export const memoryRecallLogs = sqliteTable(
   ],
 );
 
+export const memoryV2ActivationLogs = sqliteTable(
+  "memory_v2_activation_logs",
+  {
+    id: text("id").primaryKey(),
+    conversationId: text("conversation_id").notNull(),
+    messageId: text("message_id"),
+    turn: integer("turn").notNull(),
+    mode: text("mode").notNull(), // "context-load" | "per-turn"
+    conceptsJson: text("concepts_json").notNull(),
+    skillsJson: text("skills_json").notNull(),
+    configJson: text("config_json").notNull(),
+    createdAt: integer("created_at").notNull(),
+  },
+  (table) => [
+    index("idx_memory_v2_activation_logs_message_id").on(table.messageId),
+    index("idx_memory_v2_activation_logs_conversation_id").on(
+      table.conversationId,
+    ),
+    index("idx_memory_v2_activation_logs_created_at").on(table.createdAt),
+  ],
+);
+
 export const llmUsageEvents = sqliteTable(
   "llm_usage_events",
   {
@@ -170,6 +207,9 @@ export const llmUsageEvents = sqliteTable(
     runId: text("run_id"),
     requestId: text("request_id"),
     actor: text("actor").notNull(),
+    callSite: text("call_site"),
+    inferenceProfile: text("inference_profile"),
+    inferenceProfileSource: text("inference_profile_source"),
     provider: text("provider").notNull(),
     model: text("model").notNull(),
     inputTokens: integer("input_tokens").notNull(),