@vellumai/assistant 0.7.0 → 0.7.2

package/src/__tests__/db-connection-isolation.test.ts

@@ -0,0 +1,125 @@
+import {
+  mkdirSync,
+  mkdtempSync,
+  realpathSync,
+  rmSync,
+  symlinkSync,
+} from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, expect, test } from "bun:test";
+
+import { getDb, resetDb } from "../memory/db-connection.js";
+
+const originalWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR;
+const originalAllowRealWorkspace =
+  process.env.VELLUM_ALLOW_REAL_WORKSPACE_IN_TESTS;
+const originalTestRealWorkspace = process.env.VELLUM_TEST_REAL_WORKSPACE_DIR;
+const originalHome = process.env.HOME;
+
+afterEach(() => {
+  resetDb();
+  if (originalWorkspaceDir === undefined) {
+    delete process.env.VELLUM_WORKSPACE_DIR;
+  } else {
+    process.env.VELLUM_WORKSPACE_DIR = originalWorkspaceDir;
+  }
+
+  if (originalAllowRealWorkspace === undefined) {
+    delete process.env.VELLUM_ALLOW_REAL_WORKSPACE_IN_TESTS;
+  } else {
+    process.env.VELLUM_ALLOW_REAL_WORKSPACE_IN_TESTS =
+      originalAllowRealWorkspace;
+  }
+
+  if (originalTestRealWorkspace === undefined) {
+    delete process.env.VELLUM_TEST_REAL_WORKSPACE_DIR;
+  } else {
+    process.env.VELLUM_TEST_REAL_WORKSPACE_DIR = originalTestRealWorkspace;
+  }
+
+  if (originalHome === undefined) {
+    delete process.env.HOME;
+  } else {
+    process.env.HOME = originalHome;
+  }
+});
+
+test("getDb refuses test runs without an isolated workspace", () => {
+  resetDb();
+  delete process.env.VELLUM_WORKSPACE_DIR;
+  delete process.env.VELLUM_ALLOW_REAL_WORKSPACE_IN_TESTS;
+
+  expect(() => getDb()).toThrow(
+    "Refusing to open the assistant DB during tests without VELLUM_WORKSPACE_DIR",
+  );
+});
+
+test("getDb refuses the real workspace during tests even when explicitly set", () => {
+  resetDb();
+  process.env.VELLUM_WORKSPACE_DIR = join(homedir(), ".vellum", "workspace");
+  delete process.env.VELLUM_ALLOW_REAL_WORKSPACE_IN_TESTS;
+
+  expect(() => getDb()).toThrow(
+    "Refusing to open the real assistant workspace DB during tests",
+  );
+});
+
+test("getDb refuses symlink aliases to the real workspace during tests", () => {
+  resetDb();
+  const testRoot = realpathSync(
+    mkdtempSync(join(tmpdir(), "vellum-db-isolation-")),
+  );
+
+  try {
+    const fakeHome = join(testRoot, "home");
+    const realWorkspace = join(fakeHome, ".vellum", "workspace");
+    const aliasParent = join(testRoot, "aliases");
+    const workspaceAlias = join(aliasParent, "workspace-link");
+
+    mkdirSync(realWorkspace, { recursive: true });
+    mkdirSync(aliasParent, { recursive: true });
+    symlinkSync(realWorkspace, workspaceAlias, "dir");
+
+    process.env.HOME = fakeHome;
+    process.env.VELLUM_WORKSPACE_DIR = workspaceAlias;
+    process.env.VELLUM_TEST_REAL_WORKSPACE_DIR = realWorkspace;
+    delete process.env.VELLUM_ALLOW_REAL_WORKSPACE_IN_TESTS;
+
+    expect(() => getDb()).toThrow(
+      "Refusing to open the real assistant workspace DB during tests",
+    );
+  } finally {
+    rmSync(testRoot, { recursive: true, force: true });
+  }
+});
+
+test("getDb refuses missing children under symlink aliases to the real workspace", () => {
+  resetDb();
+  const testRoot = realpathSync(
+    mkdtempSync(join(tmpdir(), "vellum-db-isolation-")),
+  );
+
+  try {
+    const fakeHome = join(testRoot, "home");
+    const realWorkspace = join(fakeHome, ".vellum", "workspace");
+    const aliasParent = join(testRoot, "aliases");
+    const workspaceLink = join(aliasParent, "workspace-link");
+    const missingChild = join(workspaceLink, "new-test-workspace");
+
+    mkdirSync(realWorkspace, { recursive: true });
+    mkdirSync(aliasParent, { recursive: true });
+    symlinkSync(realWorkspace, workspaceLink, "dir");
+
+    process.env.HOME = fakeHome;
+    process.env.VELLUM_WORKSPACE_DIR = missingChild;
+    process.env.VELLUM_TEST_REAL_WORKSPACE_DIR = realWorkspace;
+    delete process.env.VELLUM_ALLOW_REAL_WORKSPACE_IN_TESTS;
+
+    expect(() => getDb()).toThrow(
+      "Refusing to open the real assistant workspace DB during tests",
+    );
+  } finally {
+    rmSync(testRoot, { recursive: true, force: true });
+  }
+});

package/src/__tests__/db-migration-rollback.test.ts

@@ -57,6 +57,7 @@ import { migrateRenameThreadStartersCheckpointsDown } from "../memory/migrations
 import { migrateBackfillAudioAttachmentMimeTypesDown } from "../memory/migrations/191-backfill-audio-attachment-mime-types.js";
 import {
   migrateJobDeferrals,
+  migrateLlmUsageAttribution,
   migrateMemoryEntityRelationDedup,
   migrateMemoryItemsFingerprintScopeUnique,
   migrateMemoryItemsScopeSaltedFingerprints,
@@ -1767,6 +1768,106 @@ describe("memory migration down() functions", () => {
     });
   });
 
+  describe("migrateLlmUsageAttribution", () => {
+    test("adds nullable attribution columns without rewriting existing usage rows", () => {
+      const db = createTestDb();
+      const raw = getRaw(db);
+
+      raw.exec(/*sql*/ `
+        CREATE TABLE llm_usage_events (
+          id TEXT PRIMARY KEY,
+          created_at INTEGER NOT NULL,
+          conversation_id TEXT,
+          run_id TEXT,
+          request_id TEXT,
+          actor TEXT NOT NULL,
+          provider TEXT NOT NULL,
+          model TEXT NOT NULL,
+          input_tokens INTEGER NOT NULL,
+          output_tokens INTEGER NOT NULL,
+          cache_creation_input_tokens INTEGER,
+          cache_read_input_tokens INTEGER,
+          estimated_cost_usd REAL,
+          pricing_status TEXT NOT NULL,
+          llm_call_count INTEGER,
+          metadata_json TEXT
+        );
+        INSERT INTO llm_usage_events (
+          id,
+          created_at,
+          actor,
+          provider,
+          model,
+          input_tokens,
+          output_tokens,
+          pricing_status
+        ) VALUES (
+          'usage-1',
+          1000,
+          'main_agent',
+          'anthropic',
+          'claude-sonnet-4-20250514',
+          100,
+          50,
+          'priced'
+        );
+      `);
+
+      migrateLlmUsageAttribution(db);
+
+      const row = raw
+        .query(
+          /*sql*/ `
+          SELECT call_site, inference_profile, inference_profile_source
+          FROM llm_usage_events
+          WHERE id = 'usage-1'
+        `,
+        )
+        .get() as {
+        call_site: string | null;
+        inference_profile: string | null;
+        inference_profile_source: string | null;
+      };
+      expect(row.call_site).toBeNull();
+      expect(row.inference_profile).toBeNull();
+      expect(row.inference_profile_source).toBeNull();
+    });
+
+    test("idempotency: calling migration twice does not throw", () => {
+      const db = createTestDb();
+      const raw = getRaw(db);
+
+      raw.exec(/*sql*/ `
+        CREATE TABLE llm_usage_events (
+          id TEXT PRIMARY KEY,
+          created_at INTEGER NOT NULL,
+          actor TEXT NOT NULL,
+          provider TEXT NOT NULL,
+          model TEXT NOT NULL,
+          input_tokens INTEGER NOT NULL,
+          output_tokens INTEGER NOT NULL,
+          pricing_status TEXT NOT NULL
+        )
+      `);
+
+      migrateLlmUsageAttribution(db);
+      migrateLlmUsageAttribution(db);
+
+      for (const column of [
+        "call_site",
+        "inference_profile",
+        "inference_profile_source",
+      ]) {
+        const found = raw
+          .query(
+            `SELECT 1 FROM pragma_table_info('llm_usage_events') WHERE name = '${column}'`,
+          )
+          .get();
+        expect(found).toBeTruthy();
+      }
+    });
+  });
+
   // ── v9: downDropActiveSearchIndex ────────────────────────────────────
 
   describe("v9: downDropActiveSearchIndex", () => {

package/src/__tests__/db-schedule-syntax-migration.test.ts

@@ -36,6 +36,8 @@ describe("schedule_syntax column migration", () => {
         last_run_at INTEGER,
         last_status TEXT,
         retry_count INTEGER NOT NULL DEFAULT 0,
+        max_retries INTEGER NOT NULL DEFAULT 3,
+        retry_backoff_ms INTEGER NOT NULL DEFAULT 60000,
         created_by TEXT NOT NULL,
         mode TEXT NOT NULL DEFAULT 'execute',
         routing_intent TEXT NOT NULL DEFAULT 'all_channels',

package/src/__tests__/db-slack-compaction-watermark-migration.test.ts

@@ -0,0 +1,169 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import { getSqliteFrom } from "../memory/db-connection.js";
+import {
+  downSlackCompactionWatermark,
+  migrateSlackCompactionWatermark,
+} from "../memory/migrations/235-slack-compaction-watermark.js";
+import * as schema from "../memory/schema.js";
+
+interface ColumnRow {
+  name: string;
+  type: string;
+  notnull: number;
+}
+
+interface ConversationCompactionRow {
+  id: string;
+  context_summary: string | null;
+  context_compacted_message_count: number;
+  context_compacted_at: number | null;
+  slack_context_compaction_watermark_ts: string | null;
+  slack_context_compaction_watermark_at: number | null;
+}
+
+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
+    )
+  `);
+}
+
+function bootstrapLegacyConversations(raw: Database): void {
+  raw.exec(/*sql*/ `
+    CREATE TABLE conversations (
+      id TEXT PRIMARY KEY,
+      title TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      context_summary TEXT,
+      context_compacted_message_count INTEGER NOT NULL DEFAULT 0,
+      context_compacted_at INTEGER
+    )
+  `);
+}
+
+function getConversationColumns(raw: Database): Map<string, ColumnRow> {
+  const columns = raw
+    .query(`PRAGMA table_info(conversations)`)
+    .all() as ColumnRow[];
+  return new Map(columns.map((column) => [column.name, column]));
+}
+
+describe("migrateSlackCompactionWatermark", () => {
+  test("adds nullable Slack watermark columns and preserves existing compaction state", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapCheckpointsTable(raw);
+    bootstrapLegacyConversations(raw);
+
+    raw
+      .query(
+        /*sql*/ `
+          INSERT INTO conversations (
+            id,
+            title,
+            created_at,
+            updated_at,
+            context_summary,
+            context_compacted_message_count,
+            context_compacted_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?)
+        `,
+      )
+      .run(
+        "conv-1",
+        "legacy slack thread",
+        1000,
+        2000,
+        "existing compacted summary",
+        42,
+        3000,
+      );
+
+    migrateSlackCompactionWatermark(db);
+
+    const columns = getConversationColumns(raw);
+    expect(columns.get("slack_context_compaction_watermark_ts")).toMatchObject({
+      type: "TEXT",
+      notnull: 0,
+    });
+    expect(columns.get("slack_context_compaction_watermark_at")).toMatchObject({
+      type: "INTEGER",
+      notnull: 0,
+    });
+
+    const row = raw
+      .query(
+        /*sql*/ `
+          SELECT
+            id,
+            context_summary,
+            context_compacted_message_count,
+            context_compacted_at,
+            slack_context_compaction_watermark_ts,
+            slack_context_compaction_watermark_at
+          FROM conversations
+          WHERE id = ?
+        `,
+      )
+      .get("conv-1") as ConversationCompactionRow | null;
+
+    expect(row).toEqual({
+      id: "conv-1",
+      context_summary: "existing compacted summary",
+      context_compacted_message_count: 42,
+      context_compacted_at: 3000,
+      slack_context_compaction_watermark_ts: null,
+      slack_context_compaction_watermark_at: null,
+    });
+  });
+
+  test("is idempotent when columns already exist", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapCheckpointsTable(raw);
+    bootstrapLegacyConversations(raw);
+    raw.exec(
+      `ALTER TABLE conversations ADD COLUMN slack_context_compaction_watermark_ts TEXT`,
+    );
+    raw.exec(
+      `ALTER TABLE conversations ADD COLUMN slack_context_compaction_watermark_at INTEGER`,
+    );
+
+    expect(() => migrateSlackCompactionWatermark(db)).not.toThrow();
+
+    const columns = getConversationColumns(raw);
+    expect(columns.has("slack_context_compaction_watermark_ts")).toBe(true);
+    expect(columns.has("slack_context_compaction_watermark_at")).toBe(true);
+  });
+
+  test("down migration drops Slack watermark columns and is idempotent", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapCheckpointsTable(raw);
+    bootstrapLegacyConversations(raw);
+
+    migrateSlackCompactionWatermark(db);
+
+    downSlackCompactionWatermark(db);
+    expect(() => downSlackCompactionWatermark(db)).not.toThrow();
+
+    const columns = getConversationColumns(raw);
+    expect(columns.has("slack_context_compaction_watermark_ts")).toBe(false);
+    expect(columns.has("slack_context_compaction_watermark_at")).toBe(false);
+  });
+});

package/src/__tests__/deterministic-verification-control-plane.test.ts

@@ -42,11 +42,11 @@ mock.module("../daemon/process-message.js", () => ({
     _processMessageCalled = true;
     return { messageId: "mock-msg" };
   },
+  processMessageInBackground: async () => ({ messageId: "mock-bg" }),
   // Re-export other functions as pass-through stubs; only processMessage
   // is imported by inbound-message-handler.
   resolveTurnChannel: () => "telegram",
   resolveTurnInterface: () => "telegram",
-  makePendingInteractionRegistrar: () => () => {},
   prepareConversationForMessage: async () => ({}),
 }));
 
@@ -239,83 +239,6 @@ describe("Call session mode metadata", () => {
 // ---------------------------------------------------------------------------
 
 describe("Verification control messages are deterministic (guard)", () => {
-  test("handleChannelInbound does not call processMessage for verification code replies", async () => {
-    const { createHash } = await import("node:crypto");
-
-    const { createInboundSession } =
-      await import("../memory/channel-verification-sessions.js");
-
-    // Set up a pending challenge
-    const secret = "123456";
-    const challengeHash = createHash("sha256").update(secret).digest("hex");
-    createInboundSession({
-      id: "challenge-guard-test",
-      channel: "telegram",
-      challengeHash,
-      expiresAt: Date.now() + 600_000,
-    });
-
-    _processMessageCalled = false;
-
-    // Track channel replies
-    const deliveredReplies: Array<{ chatId: string; text: string }> = [];
-    const originalFetch = globalThis.fetch;
-    globalThis.fetch = (async (
-      input: string | URL | Request,
-      init?: RequestInit,
-    ) => {
-      const _url =
-        typeof input === "string"
-          ? input
-          : input instanceof URL
-            ? input.toString()
-            : input.url;
-      if (init?.method === "POST" && init.body) {
-        try {
-          const body = JSON.parse(init.body as string);
-          if (body.chatId && body.text) {
-            deliveredReplies.push({ chatId: body.chatId, text: body.text });
-          }
-        } catch {
-          /* not JSON */
-        }
-        return new Response(JSON.stringify({ ok: true }), { status: 200 });
-      }
-      return originalFetch(input, init as never);
-    }) as unknown as typeof fetch;
-
-    try {
-      const req = new Request("http://localhost/channels/inbound", {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          sourceChannel: "telegram",
-          interface: "telegram",
-          conversationExternalId: "chat-123",
-          externalMessageId: `msg-guard-${Date.now()}`,
-          content: secret,
-          actorExternalId: "user-123",
-          actorDisplayName: "Test User",
-          replyCallbackUrl: "http://localhost/callback",
-        }),
-      });
-
-      const response = await handleChannelInbound({ body: JSON.parse(await req.text()) });
-      const body = response as Record<string, unknown>;
-
-      // Verification should have been handled
-      expect(body.verificationOutcome).toBeDefined();
-
-      // processMessage must NOT have been called — this is the guard
-      expect(_processMessageCalled).toBe(false);
-
-      // A deterministic reply should have been delivered
-      expect(deliveredReplies.length).toBeGreaterThan(0);
-    } finally {
-      globalThis.fetch = originalFetch;
-    }
-  });
-
   test("handleChannelInbound does not call processMessage for /start gv_<token> bootstrap commands", async () => {
     const { createHash, randomBytes } = await import("node:crypto");
 
@@ -383,7 +306,9 @@ describe("Verification control messages are deterministic (guard)", () => {
         }),
       });
 
-      const response = await handleChannelInbound({ body: JSON.parse(await req.text()) });
+      const response = await handleChannelInbound({
+        body: JSON.parse(await req.text()),
+      });
       const body = response as Record<string, unknown>;
 
       // Bootstrap should have been handled deterministically
@@ -446,7 +371,9 @@ describe("Verification control messages are deterministic (guard)", () => {
       }),
     });
 
-    const response = await handleChannelInbound({ body: JSON.parse(await req.text()) });
+    const response = await handleChannelInbound({
+      body: JSON.parse(await req.text()),
+    });
     const body = response as Record<string, unknown>;
 
     expect(body.accepted).toBe(true);