@vellumai/assistant 0.5.7 → 0.5.8

package/src/__tests__/secure-keys.test.ts

@@ -214,10 +214,11 @@ describe("secure-keys", () => {
       encryptedStore.setKey("enc-key-1", "val1");
       encryptedStore.setKey("enc-key-2", "val2");
 
-      const keys = await listSecureKeysAsync();
-      expect(keys).toContain("enc-key-1");
-      expect(keys).toContain("enc-key-2");
-      expect(keys.length).toBe(2);
+      const result = await listSecureKeysAsync();
+      expect(result.unreachable).toBe(false);
+      expect(result.accounts).toContain("enc-key-1");
+      expect(result.accounts).toContain("enc-key-2");
+      expect(result.accounts.length).toBe(2);
     });
 
     test("returns encrypted store keys with VELLUM_DEV=1", async () => {
@@ -227,10 +228,11 @@ describe("secure-keys", () => {
       encryptedStore.setKey("dev-key-1", "val2");
       encryptedStore.setKey("dev-key-2", "val3");
 
-      const keys = await listSecureKeysAsync();
-      expect(keys).toContain("dev-key-1");
-      expect(keys).toContain("dev-key-2");
-      expect(keys.length).toBe(2);
+      const result = await listSecureKeysAsync();
+      expect(result.unreachable).toBe(false);
+      expect(result.accounts).toContain("dev-key-1");
+      expect(result.accounts).toContain("dev-key-2");
+      expect(result.accounts.length).toBe(2);
     });
 
     test("returns encrypted store keys with VELLUM_DESKTOP_APP=1", async () => {
@@ -240,15 +242,16 @@ describe("secure-keys", () => {
       encryptedStore.setKey("desktop-key-1", "val1");
       encryptedStore.setKey("desktop-key-2", "val2");
 
-      const keys = await listSecureKeysAsync();
-      expect(keys).toContain("desktop-key-1");
-      expect(keys).toContain("desktop-key-2");
-      expect(keys.length).toBe(2);
+      const result = await listSecureKeysAsync();
+      expect(result.unreachable).toBe(false);
+      expect(result.accounts).toContain("desktop-key-1");
+      expect(result.accounts).toContain("desktop-key-2");
+      expect(result.accounts.length).toBe(2);
     });
 
-    test("returns empty array when store is empty", async () => {
-      const keys = await listSecureKeysAsync();
-      expect(keys).toEqual([]);
+    test("returns empty accounts when store is empty", async () => {
+      const result = await listSecureKeysAsync();
+      expect(result).toEqual({ accounts: [], unreachable: false });
     });
   });
 

package/src/__tests__/skill-memory.test.ts

@@ -276,8 +276,14 @@ describe("upsertSkillCapabilityMemory", () => {
       upsertSkillCapabilityMemory("test-skill", makeSkill());
     }).not.toThrow();
 
-    // Restore DB state for subsequent tests
+    // Restore DB state for subsequent tests.
+    // Delete the entire DB so initializeDb recreates it from scratch — just
+    // resetting the connection leaves stale migration checkpoints that skip
+    // checkpoint-guarded ALTER TABLE migrations (e.g. source_type column).
     resetDb();
+    for (const ext of ["", "-wal", "-shm"]) {
+      rmSync(join(testDir, `test.db${ext}`), { force: true });
+    }
     initializeDb();
   });
 });
@@ -324,8 +330,12 @@ describe("deleteSkillCapabilityMemory", () => {
       deleteSkillCapabilityMemory("test-skill");
     }).not.toThrow();
 
-    // Restore DB state for subsequent tests
+    // Restore DB state for subsequent tests (see upsert "does not throw" test
+    // for rationale on why we delete the DB file).
     resetDb();
+    for (const ext of ["", "-wal", "-shm"]) {
+      rmSync(join(testDir, `test.db${ext}`), { force: true });
+    }
     initializeDb();
   });
 });
@@ -542,8 +552,12 @@ describe("seedCatalogSkillMemories", () => {
 
     await expect(seedCatalogSkillMemories()).resolves.toBeUndefined();
 
-    // Restore DB state for subsequent tests
+    // Restore DB state for subsequent tests (see upsert "does not throw" test
+    // for rationale on why we delete the DB file).
     resetDb();
+    for (const ext of ["", "-wal", "-shm"]) {
+      rmSync(join(testDir, `test.db${ext}`), { force: true });
+    }
     initializeDb();
   });
 });

package/src/__tests__/stale-approval-dedup.test.ts

@@ -0,0 +1,171 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Mocks — must be declared before importing the module under test
+// ---------------------------------------------------------------------------
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+const deliveredMessages: Array<{
+  url: string;
+  body: Record<string, unknown>;
+}> = [];
+
+let deliveryShouldFail = false;
+
+mock.module("../runtime/gateway-client.js", () => ({
+  deliverChannelReply: async (url: string, body: Record<string, unknown>) => {
+    if (deliveryShouldFail) {
+      throw new Error("simulated delivery failure");
+    }
+    deliveredMessages.push({ url, body });
+  },
+}));
+
+mock.module("../runtime/approval-message-composer.js", () => ({
+  composeApprovalMessageGenerative: async () => "Already resolved.",
+}));
+
+// ---------------------------------------------------------------------------
+// Import the module under test after mocks are set up
+// ---------------------------------------------------------------------------
+
+import type pino from "pino";
+
+import {
+  clearStaleNotificationCache,
+  deliverStaleApprovalReply,
+} from "../runtime/routes/guardian-approval-reply-helpers.js";
+
+const noopLogger = new Proxy({} as pino.Logger, {
+  get: () => () => {},
+});
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("deliverStaleApprovalReply deduplication", () => {
+  beforeEach(() => {
+    deliveredMessages.length = 0;
+    deliveryShouldFail = false;
+    clearStaleNotificationCache();
+  });
+
+  afterEach(() => {
+    clearStaleNotificationCache();
+  });
+
+  test("sends the first 'approval_already_resolved' notification", async () => {
+    await deliverStaleApprovalReply({
+      scenario: "approval_already_resolved",
+      sourceChannel: "slack",
+      replyCallbackUrl: "https://example.com/reply",
+      chatId: "chat-1",
+      assistantId: "asst-1",
+      logger: noopLogger,
+      errorLogMessage: "test",
+    });
+
+    expect(deliveredMessages).toHaveLength(1);
+  });
+
+  test("suppresses duplicate 'approval_already_resolved' for the same chat", async () => {
+    const params = {
+      scenario: "approval_already_resolved" as const,
+      sourceChannel: "slack" as const,
+      replyCallbackUrl: "https://example.com/reply",
+      chatId: "chat-1",
+      assistantId: "asst-1",
+      logger: noopLogger,
+      errorLogMessage: "test",
+    };
+
+    await deliverStaleApprovalReply(params);
+    await deliverStaleApprovalReply(params);
+    await deliverStaleApprovalReply(params);
+
+    expect(deliveredMessages).toHaveLength(1);
+  });
+
+  test("allows 'approval_already_resolved' for different chats", async () => {
+    const base = {
+      scenario: "approval_already_resolved" as const,
+      sourceChannel: "slack" as const,
+      replyCallbackUrl: "https://example.com/reply",
+      assistantId: "asst-1",
+      logger: noopLogger,
+      errorLogMessage: "test",
+    };
+
+    await deliverStaleApprovalReply({ ...base, chatId: "chat-1" });
+    await deliverStaleApprovalReply({ ...base, chatId: "chat-2" });
+
+    expect(deliveredMessages).toHaveLength(2);
+  });
+
+  test("does not deduplicate non-'approval_already_resolved' scenarios", async () => {
+    const params = {
+      scenario: "reminder_prompt" as const,
+      sourceChannel: "slack" as const,
+      replyCallbackUrl: "https://example.com/reply",
+      chatId: "chat-1",
+      assistantId: "asst-1",
+      logger: noopLogger,
+      errorLogMessage: "test",
+    };
+
+    await deliverStaleApprovalReply(params);
+    await deliverStaleApprovalReply(params);
+
+    expect(deliveredMessages).toHaveLength(2);
+  });
+
+  test("allows re-send after cache is cleared (simulates TTL expiry)", async () => {
+    const params = {
+      scenario: "approval_already_resolved" as const,
+      sourceChannel: "slack" as const,
+      replyCallbackUrl: "https://example.com/reply",
+      chatId: "chat-1",
+      assistantId: "asst-1",
+      logger: noopLogger,
+      errorLogMessage: "test",
+    };
+
+    await deliverStaleApprovalReply(params);
+    expect(deliveredMessages).toHaveLength(1);
+
+    // Simulate TTL expiry
+    clearStaleNotificationCache();
+
+    await deliverStaleApprovalReply(params);
+    expect(deliveredMessages).toHaveLength(2);
+  });
+
+  test("does not cache dedup key when delivery fails, allowing retries", async () => {
+    const params = {
+      scenario: "approval_already_resolved" as const,
+      sourceChannel: "slack" as const,
+      replyCallbackUrl: "https://example.com/reply",
+      chatId: "chat-1",
+      assistantId: "asst-1",
+      logger: noopLogger,
+      errorLogMessage: "test",
+    };
+
+    // First attempt fails — should not cache the dedup key
+    deliveryShouldFail = true;
+    await deliverStaleApprovalReply(params);
+    expect(deliveredMessages).toHaveLength(0);
+
+    // Second attempt succeeds — should not be suppressed by dedup
+    deliveryShouldFail = false;
+    await deliverStaleApprovalReply(params);
+    expect(deliveredMessages).toHaveLength(1);
+  });
+});