@vellumai/assistant 0.5.1 → 0.5.3

package/src/__tests__/db-memory-reducer-checkpoints.test.ts

@@ -0,0 +1,273 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Database } from "bun:sqlite";
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+const testDir = mkdtempSync(join(tmpdir(), "memory-reducer-checkpoints-"));
+const dbPath = join(testDir, "test.db");
+const originalBunTest = process.env.BUN_TEST;
+
+mock.module("../util/platform.js", () => ({
+  getDataDir: () => testDir,
+  isMacOS: () => process.platform === "darwin",
+  isLinux: () => process.platform === "linux",
+  isWindows: () => process.platform === "win32",
+  getPidPath: () => join(testDir, "test.pid"),
+  getDbPath: () => dbPath,
+  getLogPath: () => join(testDir, "test.log"),
+  ensureDataDir: () => {},
+  getConversationsDir: () => join(testDir, "conversations"),
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import { initializeDb, resetDb } from "../memory/db.js";
+import { getSqliteFrom } from "../memory/db-connection.js";
+import { migrateMemoryReducerCheckpoints } from "../memory/migrations/187-memory-reducer-checkpoints.js";
+import * as schema from "../memory/schema.js";
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  sqlite.exec("PRAGMA foreign_keys = ON");
+  return drizzle(sqlite, { schema });
+}
+
+function getColumnInfo(
+  raw: Database,
+): Array<{ name: string; notnull: number }> {
+  return raw.query(`PRAGMA table_info(conversations)`).all() as Array<{
+    name: string;
+    notnull: number;
+  }>;
+}
+
+function bootstrapPreCheckpointConversations(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,
+      total_input_tokens INTEGER NOT NULL DEFAULT 0,
+      total_output_tokens INTEGER NOT NULL DEFAULT 0,
+      total_estimated_cost REAL NOT NULL DEFAULT 0,
+      context_summary TEXT,
+      context_compacted_message_count INTEGER NOT NULL DEFAULT 0,
+      context_compacted_at INTEGER,
+      conversation_type TEXT NOT NULL DEFAULT 'standard',
+      source TEXT NOT NULL DEFAULT 'user',
+      memory_scope_id TEXT NOT NULL DEFAULT 'default',
+      origin_channel TEXT,
+      origin_interface TEXT,
+      fork_parent_conversation_id TEXT,
+      fork_parent_message_id TEXT,
+      is_auto_title INTEGER NOT NULL DEFAULT 1,
+      schedule_job_id TEXT
+    )
+  `);
+}
+
+function removeTestDbFiles(): void {
+  rmSync(dbPath, { force: true });
+  rmSync(`${dbPath}-shm`, { force: true });
+  rmSync(`${dbPath}-wal`, { force: true });
+}
+
+describe("memory reducer checkpoint columns migration", () => {
+  beforeEach(() => {
+    process.env.BUN_TEST = "0";
+    resetDb();
+    removeTestDbFiles();
+  });
+
+  afterEach(() => {
+    resetDb();
+    removeTestDbFiles();
+  });
+
+  afterAll(() => {
+    if (originalBunTest === undefined) {
+      delete process.env.BUN_TEST;
+    } else {
+      process.env.BUN_TEST = originalBunTest;
+    }
+    resetDb();
+    removeTestDbFiles();
+    try {
+      rmSync(testDir, { recursive: true });
+    } catch {
+      /* best effort */
+    }
+  });
+
+  test("fresh DB initialization includes nullable reducer checkpoint columns", () => {
+    initializeDb();
+
+    const raw = new Database(dbPath);
+    const columns = getColumnInfo(raw);
+
+    const checkpointColumns = columns.filter(
+      (c) =>
+        c.name === "memory_reduced_through_message_id" ||
+        c.name === "memory_dirty_tail_since_message_id" ||
+        c.name === "memory_last_reduced_at",
+    );
+
+    expect(checkpointColumns).toHaveLength(3);
+    expect(checkpointColumns.every((c) => c.notnull === 0)).toBe(true);
+
+    raw.close();
+  });
+
+  test("migration upgrades the pre-checkpoint schema without disturbing existing rows", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    const now = Date.now();
+
+    bootstrapPreCheckpointConversations(raw);
+    raw.exec(/*sql*/ `
+      INSERT INTO conversations (
+        id,
+        title,
+        created_at,
+        updated_at,
+        conversation_type,
+        source,
+        memory_scope_id,
+        is_auto_title
+      ) VALUES (
+        'conv-upgrade',
+        'Existing conversation',
+        ${now},
+        ${now},
+        'standard',
+        'user',
+        'default',
+        1
+      )
+    `);
+
+    migrateMemoryReducerCheckpoints(db);
+
+    const columnNames = getColumnInfo(raw).map((c) => c.name);
+    expect(columnNames).toContain("memory_reduced_through_message_id");
+    expect(columnNames).toContain("memory_dirty_tail_since_message_id");
+    expect(columnNames).toContain("memory_last_reduced_at");
+
+    const row = raw
+      .query(
+        `SELECT id, title, memory_reduced_through_message_id, memory_dirty_tail_since_message_id, memory_last_reduced_at
+         FROM conversations WHERE id = 'conv-upgrade'`,
+      )
+      .get() as {
+      id: string;
+      title: string | null;
+      memory_reduced_through_message_id: string | null;
+      memory_dirty_tail_since_message_id: string | null;
+      memory_last_reduced_at: number | null;
+    } | null;
+
+    expect(row).toEqual({
+      id: "conv-upgrade",
+      title: "Existing conversation",
+      memory_reduced_through_message_id: null,
+      memory_dirty_tail_since_message_id: null,
+      memory_last_reduced_at: null,
+    });
+
+    raw.close();
+  });
+
+  test("re-running the migration preserves populated checkpoint values", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    const now = Date.now();
+
+    bootstrapPreCheckpointConversations(raw);
+    raw.exec(/*sql*/ `
+      INSERT INTO conversations (
+        id,
+        title,
+        created_at,
+        updated_at,
+        conversation_type,
+        source,
+        memory_scope_id,
+        is_auto_title
+      ) VALUES (
+        'conv-rerun',
+        'Reduced conversation',
+        ${now},
+        ${now},
+        'standard',
+        'user',
+        'default',
+        1
+      )
+    `);
+
+    migrateMemoryReducerCheckpoints(db);
+    raw.exec(/*sql*/ `
+      UPDATE conversations
+      SET memory_reduced_through_message_id = 'msg-100',
+          memory_dirty_tail_since_message_id = 'msg-101',
+          memory_last_reduced_at = ${now}
+      WHERE id = 'conv-rerun'
+    `);
+
+    expect(() => migrateMemoryReducerCheckpoints(db)).not.toThrow();
+
+    const row = raw
+      .query(
+        `SELECT memory_reduced_through_message_id, memory_dirty_tail_since_message_id, memory_last_reduced_at
+         FROM conversations WHERE id = 'conv-rerun'`,
+      )
+      .get() as {
+      memory_reduced_through_message_id: string | null;
+      memory_dirty_tail_since_message_id: string | null;
+      memory_last_reduced_at: number | null;
+    } | null;
+
+    expect(row).toEqual({
+      memory_reduced_through_message_id: "msg-100",
+      memory_dirty_tail_since_message_id: "msg-101",
+      memory_last_reduced_at: now,
+    });
+
+    raw.close();
+  });
+
+  test("getConversation exposes the new checkpoint fields as null for new rows", async () => {
+    initializeDb();
+
+    // Dynamic import to avoid circular module init issues — conversation-crud
+    // depends on getDb being initialized which happens in initializeDb above.
+    const { createConversation, getConversation } =
+      await import("../memory/conversation-crud.js");
+
+    const created = createConversation("Test conversation");
+    const loaded = getConversation(created.id);
+
+    expect(loaded).not.toBeNull();
+    expect(loaded!.memoryReducedThroughMessageId).toBeNull();
+    expect(loaded!.memoryDirtyTailSinceMessageId).toBeNull();
+    expect(loaded!.memoryLastReducedAt).toBeNull();
+  });
+});

package/src/__tests__/diagnostics-export.test.ts

@@ -5,11 +5,13 @@
  * (specific ID → most recent assistant → any message → empty conversation).
  */
 
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
+import JSZip from "jszip";
+
 const testDir = mkdtempSync(join(tmpdir(), "diagnostics-export-test-"));
 
 mock.module("../util/platform.js", () => ({
@@ -90,6 +92,27 @@ function seedMessage(
   );
 }
 
+function seedLlmRequestLog(
+  id: string,
+  conversationId: string,
+  provider: string | null,
+  requestPayload: unknown,
+  responsePayload: unknown,
+  createdAt: number,
+): void {
+  db().run(
+    "INSERT INTO llm_request_logs (id, conversation_id, provider, request_payload, response_payload, created_at) VALUES (?, ?, ?, ?, ?, ?)",
+    [
+      id,
+      conversationId,
+      provider,
+      JSON.stringify(requestPayload),
+      JSON.stringify(responsePayload),
+      createdAt,
+    ],
+  );
+}
+
 function seedConversationKey(
   conversationKey: string,
   conversationId: string,
@@ -102,6 +125,7 @@ function seedConversationKey(
 
 function cleanDb(): void {
   db().run("DELETE FROM messages");
+  db().run("DELETE FROM llm_request_logs");
   db().run("DELETE FROM conversation_keys");
   db().run("DELETE FROM conversations");
 }
@@ -216,4 +240,49 @@ describe("diagnostics export", () => {
     const json = (await res.json()) as { success: boolean };
     expect(json.success).toBe(true);
   });
+
+  test("preserves llm request provider identity in the exported JSONL", async () => {
+    const convId = "conv-7";
+    const now = Date.now();
+
+    seedConversation(convId);
+    seedMessage("msg-user-7", convId, "user", "hello", now - 1000);
+    seedMessage("msg-assistant-7", convId, "assistant", "world", now);
+    seedLlmRequestLog(
+      "log-7",
+      convId,
+      "openrouter",
+      { model: "openai/gpt-4.1-mini", input: "hello" },
+      { output: "world" },
+      now,
+    );
+
+    const res = await callExport({ conversationId: convId });
+    expect(res.status).toBe(200);
+    const json = (await res.json()) as { success: boolean; filePath: string };
+    expect(json.success).toBe(true);
+
+    const zip = await JSZip.loadAsync(readFileSync(json.filePath));
+    const llmRequests = zip.file("llm_requests.jsonl");
+    expect(llmRequests).not.toBeNull();
+
+    const lines = (await llmRequests!.async("string")).trim().split("\n");
+    expect(lines).toHaveLength(1);
+
+    const row = JSON.parse(lines[0]) as {
+      id: string;
+      conversationId: string;
+      provider?: string | null;
+      request: unknown;
+      response: unknown;
+    };
+
+    expect(row).toMatchObject({
+      id: "log-7",
+      conversationId: convId,
+      provider: "openrouter",
+    });
+
+    rmSync(json.filePath, { force: true });
+  });
 });

package/src/__tests__/first-greeting.test.ts

@@ -0,0 +1,80 @@
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, mock } from "bun:test";
+
+let tempDir: string;
+
+mock.module("../util/platform.js", () => ({
+  getWorkspacePromptPath: mock((file: string) => join(tempDir, file)),
+  getWorkspaceDir: () => tempDir,
+  getRootDir: () => tempDir,
+  getDataDir: () => join(tempDir, "data"),
+  getPlatformName: () => "darwin",
+  isMacOS: () => false,
+  isLinux: () => false,
+  isWindows: () => false,
+  ensureDataDir: () => {},
+  getDbPath: () => "",
+  getLogPath: () => "",
+  getHistoryPath: () => "",
+  getHooksDir: () => "",
+  getSessionTokenPath: () => "",
+  getPlatformTokenPath: () => "",
+  getPidPath: () => "",
+}));
+
+const { isWakeUpGreeting, getCannedFirstGreeting, CANNED_FIRST_GREETING } =
+  await import("../daemon/first-greeting.js");
+
+describe("first-greeting", () => {
+  beforeEach(() => {
+    tempDir = join(tmpdir(), `first-greeting-test-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe("isWakeUpGreeting", () => {
+    it("returns true for wake-up greeting with 0 messages and BOOTSTRAP.md present", () => {
+      writeFileSync(join(tempDir, "BOOTSTRAP.md"), "bootstrap content");
+      expect(isWakeUpGreeting("Wake up, my friend.", 0)).toBe(true);
+    });
+
+    it("returns true for case variations", () => {
+      writeFileSync(join(tempDir, "BOOTSTRAP.md"), "bootstrap content");
+      expect(isWakeUpGreeting("wake up, my friend.", 0)).toBe(true);
+      expect(isWakeUpGreeting("WAKE UP, MY FRIEND.", 0)).toBe(true);
+      expect(isWakeUpGreeting("Wake Up, My Friend.", 0)).toBe(true);
+    });
+
+    it("returns false when content doesn't match wake-up greeting", () => {
+      writeFileSync(join(tempDir, "BOOTSTRAP.md"), "bootstrap content");
+      expect(isWakeUpGreeting("Hello", 0)).toBe(false);
+      expect(isWakeUpGreeting("Hey there", 0)).toBe(false);
+      expect(isWakeUpGreeting("Wake up", 0)).toBe(false);
+    });
+
+    it("returns false when conversationMessageCount > 0", () => {
+      writeFileSync(join(tempDir, "BOOTSTRAP.md"), "bootstrap content");
+      expect(isWakeUpGreeting("Wake up, my friend.", 1)).toBe(false);
+      expect(isWakeUpGreeting("Wake up, my friend.", 5)).toBe(false);
+    });
+
+    it("returns false when BOOTSTRAP.md doesn't exist", () => {
+      expect(existsSync(join(tempDir, "BOOTSTRAP.md"))).toBe(false);
+      expect(isWakeUpGreeting("Wake up, my friend.", 0)).toBe(false);
+    });
+  });
+
+  describe("getCannedFirstGreeting", () => {
+    it("returns the expected greeting string", () => {
+      const greeting = getCannedFirstGreeting();
+      expect(greeting).toBe(CANNED_FIRST_GREETING);
+      expect(greeting).toContain("brand new");
+      expect(greeting).toContain("no name, no memories");
+    });
+  });
+});

package/src/__tests__/gateway-only-guard.test.ts

@@ -24,6 +24,7 @@ const ALLOWLIST = new Set([
   // --- Intentional local daemon-control paths ---
   "assistant/src/cli/commands/conversations.ts", // CLI wipe talks to runtime directly
   "clients/shared/Network/DaemonClient.swift",
+  "clients/shared/App/Auth/PlatformOAuthService.swift", // comment explaining runtimeUrl vs platformUrl
   "clients/macos/vellum-assistant/App/AppDelegate.swift",
   "clients/macos/vellum-assistant/Features/Settings/SettingsConnectTab.swift",
   ".claude/skills/update/SKILL.md", // daemon health check script

package/src/__tests__/handlers-user-message-approval-consumption.test.ts

@@ -268,13 +268,9 @@ describe("handleConfirmationResponse canonical status sync", () => {
       undefined,
       { source: "button" },
     ]);
-    expect(resolveCanonicalGuardianRequestMock).toHaveBeenCalledWith(
-      "req-confirm-allow",
-      "pending",
-      {
-        status: "approved",
-      },
-    );
+    // Canonical status sync is now handled inside Conversation.handleConfirmationResponse,
+    // which this test mocks out — so the handler itself no longer calls resolveCanonicalGuardianRequest.
+    expect(resolveCanonicalGuardianRequestMock).not.toHaveBeenCalled();
     expect(resolveMock).toHaveBeenCalledWith("req-confirm-allow");
   });
 });

package/src/__tests__/history-repair.test.ts

@@ -491,12 +491,17 @@ describe("repairHistory", () => {
     expect(assistantMsg.content[1]).toMatchObject({
       type: "web_search_tool_result",
       tool_use_id: "stu_1",
-      content: { type: "web_search_tool_result_error", error_code: "unavailable" },
+      content: {
+        type: "web_search_tool_result_error",
+        error_code: "unavailable",
+      },
     });
 
     // User message has no web_search_tool_result
     const userMsg = repaired[2];
-    expect(userMsg.content.every((b) => b.type !== "web_search_tool_result")).toBe(true);
+    expect(
+      userMsg.content.every((b) => b.type !== "web_search_tool_result"),
+    ).toBe(true);
   });
 
   test("migrates legacy web_search_tool_result from user message to assistant message", () => {
@@ -527,7 +532,9 @@ describe("repairHistory", () => {
           {
             type: "web_search_tool_result",
             tool_use_id: "srvtoolu_abc",
-            content: [{ type: "web_search_result", url: "https://example.com" }],
+            content: [
+              { type: "web_search_result", url: "https://example.com" },
+            ],
           },
           { type: "tool_result", tool_use_id: "tu_1", content: "files" },
         ],
@@ -545,8 +552,12 @@ describe("repairHistory", () => {
 
     // The assistant message now has the server pair + client tool_use
     const assistantMsg = repaired[1];
-    const serverToolUse = assistantMsg.content.find((b) => b.type === "server_tool_use");
-    const webSearchResult = assistantMsg.content.find((b) => b.type === "web_search_tool_result");
+    const serverToolUse = assistantMsg.content.find(
+      (b) => b.type === "server_tool_use",
+    );
+    const webSearchResult = assistantMsg.content.find(
+      (b) => b.type === "web_search_tool_result",
+    );
     expect(serverToolUse).toBeDefined();
     expect(webSearchResult).toBeDefined();
 
@@ -554,7 +565,9 @@ describe("repairHistory", () => {
     const userMsg = repaired[2];
     expect(stats.orphanToolResultsDowngraded).toBe(1);
     expect(userMsg.content.some((b) => b.type === "tool_result")).toBe(true);
-    expect(userMsg.content.every((b) => b.type !== "web_search_tool_result")).toBe(true);
+    expect(
+      userMsg.content.every((b) => b.type !== "web_search_tool_result"),
+    ).toBe(true);
   });
 
   test("trailing server_tool_use gets synthetic result in same assistant message", () => {
@@ -584,7 +597,10 @@ describe("repairHistory", () => {
     expect(repaired[1].content[1]).toMatchObject({
       type: "web_search_tool_result",
       tool_use_id: "stu_1",
-      content: { type: "web_search_tool_result_error", error_code: "unavailable" },
+      content: {
+        type: "web_search_tool_result_error",
+        error_code: "unavailable",
+      },
     });
   });
 
@@ -696,11 +712,15 @@ describe("repairHistory", () => {
 
     // Assistant message has the server pair
     const assistantMsg = repaired[1];
-    expect(assistantMsg.content.some((b) => b.type === "web_search_tool_result")).toBe(true);
+    expect(
+      assistantMsg.content.some((b) => b.type === "web_search_tool_result"),
+    ).toBe(true);
 
     // User message has no web_search_tool_result — the tool_result was downgraded to text
     const userMsg = repaired[2];
-    expect(userMsg.content.every((b) => b.type !== "web_search_tool_result")).toBe(true);
+    expect(
+      userMsg.content.every((b) => b.type !== "web_search_tool_result"),
+    ).toBe(true);
     expect(userMsg.content.every((b) => b.type !== "tool_result")).toBe(true);
   });
 
@@ -720,7 +740,9 @@ describe("repairHistory", () => {
           {
             type: "web_search_tool_result",
             tool_use_id: "tu_1",
-            content: [{ type: "web_search_result", url: "https://example.com" }],
+            content: [
+              { type: "web_search_result", url: "https://example.com" },
+            ],
           },
         ],
       },