@vellumai/assistant 0.4.17 → 0.4.18

package/src/__tests__/channel-retry-sweep.test.ts

@@ -1,34 +1,35 @@
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { mkdtempSync, 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 { afterAll, beforeEach, describe, expect, mock, test } from 'bun:test';
-import { eq } from 'drizzle-orm';
+import { eq } from "drizzle-orm";
 
-const testDir = mkdtempSync(join(tmpdir(), 'channel-retry-sweep-test-'));
+const testDir = mkdtempSync(join(tmpdir(), "channel-retry-sweep-test-"));
 
-mock.module('../util/platform.js', () => ({
+mock.module("../util/platform.js", () => ({
   getDataDir: () => testDir,
-  isMacOS: () => process.platform === 'darwin',
-  isLinux: () => process.platform === 'linux',
-  isWindows: () => process.platform === 'win32',
-  getSocketPath: () => join(testDir, 'test.sock'),
-  getPidPath: () => join(testDir, 'test.pid'),
-  getDbPath: () => join(testDir, 'test.db'),
-  getLogPath: () => join(testDir, 'test.log'),
+  isMacOS: () => process.platform === "darwin",
+  isLinux: () => process.platform === "linux",
+  isWindows: () => process.platform === "win32",
+  getSocketPath: () => join(testDir, "test.sock"),
+  getPidPath: () => join(testDir, "test.pid"),
+  getDbPath: () => join(testDir, "test.db"),
+  getLogPath: () => join(testDir, "test.log"),
   ensureDataDir: () => {},
 }));
 
-mock.module('../util/logger.js', () => ({
-  getLogger: () => new Proxy({} as Record<string, unknown>, {
-    get: () => () => {},
-  }),
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
 }));
 
-import * as channelDeliveryStore from '../memory/channel-delivery-store.js';
-import { getDb, initializeDb, resetDb } from '../memory/db.js';
-import { channelInboundEvents, messages } from '../memory/schema.js';
-import { sweepFailedEvents } from '../runtime/channel-retry-sweep.js';
+import * as channelDeliveryStore from "../memory/channel-delivery-store.js";
+import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import { channelInboundEvents, messages } from "../memory/schema.js";
+import { sweepFailedEvents } from "../runtime/channel-retry-sweep.js";
 
 initializeDb();
 
@@ -43,26 +44,30 @@ afterAll(() => {
 
 function resetTables(): void {
   const db = getDb();
-  db.run('DELETE FROM channel_inbound_events');
-  db.run('DELETE FROM conversation_keys');
-  db.run('DELETE FROM messages');
-  db.run('DELETE FROM conversations');
+  db.run("DELETE FROM channel_inbound_events");
+  db.run("DELETE FROM conversation_keys");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
 }
 
 function seedFailedEventWithTrustClass(
   trustClass: string,
   extra?: Record<string, unknown>,
 ): string {
-  const inbound = channelDeliveryStore.recordInbound('telegram', `chat-${trustClass}`, `msg-${trustClass}`);
+  const inbound = channelDeliveryStore.recordInbound(
+    "telegram",
+    `chat-${trustClass}`,
+    `msg-${trustClass}`,
+  );
   channelDeliveryStore.storePayload(inbound.eventId, {
-    content: 'retry me',
-    sourceChannel: 'telegram',
-    interface: 'telegram',
+    content: "retry me",
+    sourceChannel: "telegram",
+    interface: "telegram",
     guardianCtx: {
       trustClass,
-      sourceChannel: 'telegram',
-      guardianPrincipalId: 'principal-1',
-      requesterExternalUserId: 'user-1',
+      sourceChannel: "telegram",
+      guardianPrincipalId: "principal-1",
+      requesterExternalUserId: "user-1",
       requesterChatId: `chat-${trustClass}`,
       ...extra,
     },
@@ -71,7 +76,7 @@ function seedFailedEventWithTrustClass(
   const db = getDb();
   db.update(channelInboundEvents)
     .set({
-      processingStatus: 'failed',
+      processingStatus: "failed",
       processingAttempts: 1,
       retryAfter: Date.now() - 1,
     })
@@ -82,17 +87,21 @@ function seedFailedEventWithTrustClass(
 }
 
 function seedFailedEventWithActorRoleOnly(
-  actorRole: 'guardian' | 'non-guardian' | 'unverified_channel',
+  actorRole: "guardian" | "non-guardian" | "unverified_channel",
 ): string {
-  const inbound = channelDeliveryStore.recordInbound('telegram', `chat-legacy-${actorRole}`, `msg-legacy-${actorRole}`);
+  const inbound = channelDeliveryStore.recordInbound(
+    "telegram",
+    `chat-legacy-${actorRole}`,
+    `msg-legacy-${actorRole}`,
+  );
   channelDeliveryStore.storePayload(inbound.eventId, {
-    content: 'retry me',
-    sourceChannel: 'telegram',
-    interface: 'telegram',
+    content: "retry me",
+    sourceChannel: "telegram",
+    interface: "telegram",
     guardianCtx: {
       actorRole,
-      sourceChannel: 'telegram',
-      requesterExternalUserId: 'legacy-user',
+      sourceChannel: "telegram",
+      requesterExternalUserId: "legacy-user",
       requesterChatId: `chat-legacy-${actorRole}`,
     },
   });
@@ -100,7 +109,7 @@ function seedFailedEventWithActorRoleOnly(
   const db = getDb();
   db.update(channelInboundEvents)
     .set({
-      processingStatus: 'failed',
+      processingStatus: "failed",
       processingAttempts: 1,
       retryAfter: Date.now() - 1,
     })
@@ -110,65 +119,79 @@ function seedFailedEventWithActorRoleOnly(
   return inbound.eventId;
 }
 
-describe('channel-retry-sweep', () => {
+describe("channel-retry-sweep", () => {
   beforeEach(() => {
     resetTables();
   });
 
-  test('replays canonical payloads with trustClass correctly', async () => {
+  test("replays canonical payloads with trustClass correctly", async () => {
     const cases: Array<{
-      trustClass: 'guardian' | 'trusted_contact' | 'unknown';
+      trustClass: "guardian" | "trusted_contact" | "unknown";
       expectedInteractive: boolean;
     }> = [
-      { trustClass: 'guardian', expectedInteractive: true },
-      { trustClass: 'trusted_contact', expectedInteractive: false },
-      { trustClass: 'unknown', expectedInteractive: false },
+      { trustClass: "guardian", expectedInteractive: true },
+      { trustClass: "trusted_contact", expectedInteractive: false },
+      { trustClass: "unknown", expectedInteractive: false },
     ];
 
     for (const c of cases) {
       resetTables();
       const eventId = seedFailedEventWithTrustClass(c.trustClass);
-      let capturedOptions: {
-        guardianContext?: { trustClass?: string; guardianPrincipalId?: string };
-        isInteractive?: boolean;
-      } | undefined;
+      let capturedOptions:
+        | {
+            guardianContext?: {
+              trustClass?: string;
+              guardianPrincipalId?: string;
+            };
+            isInteractive?: boolean;
+          }
+        | undefined;
 
       await sweepFailedEvents(
         async (conversationId, _content, _attachmentIds, options) => {
           capturedOptions = options as {
-            guardianContext?: { trustClass?: string; guardianPrincipalId?: string };
+            guardianContext?: {
+              trustClass?: string;
+              guardianPrincipalId?: string;
+            };
             isInteractive?: boolean;
           };
           const messageId = `message-${c.trustClass}`;
           const db = getDb();
-          db.insert(messages).values({
-            id: messageId,
-            conversationId,
-            role: 'user',
-            content: JSON.stringify([{ type: 'text', text: 'retry me' }]),
-            createdAt: Date.now(),
-          }).run();
+          db.insert(messages)
+            .values({
+              id: messageId,
+              conversationId,
+              role: "user",
+              content: JSON.stringify([{ type: "text", text: "retry me" }]),
+              createdAt: Date.now(),
+            })
+            .run();
           return { messageId };
         },
         undefined,
       );
 
       expect(capturedOptions?.guardianContext?.trustClass).toBe(c.trustClass);
-      expect(capturedOptions?.guardianContext?.guardianPrincipalId).toBe('principal-1');
+      expect(capturedOptions?.guardianContext?.guardianPrincipalId).toBe(
+        "principal-1",
+      );
       expect(capturedOptions?.isInteractive).toBe(c.expectedInteractive);
 
       const db = getDb();
-      const row = db.select().from(channelInboundEvents).where(eq(channelInboundEvents.id, eventId)).get();
-      expect(row?.processingStatus).toBe('processed');
+      const row = db
+        .select()
+        .from(channelInboundEvents)
+        .where(eq(channelInboundEvents.id, eventId))
+        .get();
+      expect(row?.processingStatus).toBe("processed");
     }
   });
 
-  test('marks legacy payloads with only actorRole (no trustClass) as failed', async () => {
-    const actorRoles: Array<'guardian' | 'non-guardian' | 'unverified_channel'> = [
-      'guardian',
-      'non-guardian',
-      'unverified_channel',
-    ];
+  test("marks legacy payloads with only actorRole (no trustClass) as failed", async () => {
+    const actorRoles: Array<
+      "guardian" | "non-guardian" | "unverified_channel"
+    > = ["guardian", "non-guardian", "unverified_channel"];
 
     for (const actorRole of actorRoles) {
       resetTables();
@@ -180,13 +203,15 @@ describe('channel-retry-sweep', () => {
           processMessageCalled = true;
           const messageId = `message-legacy-${actorRole}`;
           const db = getDb();
-          db.insert(messages).values({
-            id: messageId,
-            conversationId,
-            role: 'user',
-            content: JSON.stringify([{ type: 'text', text: 'retry me' }]),
-            createdAt: Date.now(),
-          }).run();
+          db.insert(messages)
+            .values({
+              id: messageId,
+              conversationId,
+              role: "user",
+              content: JSON.stringify([{ type: "text", text: "retry me" }]),
+              createdAt: Date.now(),
+            })
+            .run();
           return { messageId };
         },
         undefined,
@@ -198,28 +223,34 @@ describe('channel-retry-sweep', () => {
       expect(processMessageCalled).toBe(false);
 
       const db = getDb();
-      const row = db.select().from(channelInboundEvents).where(eq(channelInboundEvents.id, eventId)).get();
-      expect(row?.processingStatus).toBe('failed');
+      const row = db
+        .select()
+        .from(channelInboundEvents)
+        .where(eq(channelInboundEvents.id, eventId))
+        .get();
+      expect(row?.processingStatus).toBe("failed");
     }
   });
 
-  test('marks payloads with invalid trustClass values as failed', async () => {
+  test("marks payloads with invalid trustClass values as failed", async () => {
     resetTables();
-    const eventId = seedFailedEventWithTrustClass('invalid_value');
+    const eventId = seedFailedEventWithTrustClass("invalid_value");
     let processMessageCalled = false;
 
     await sweepFailedEvents(
       async (conversationId, _content, _attachmentIds, _options) => {
         processMessageCalled = true;
-        const messageId = 'message-invalid';
+        const messageId = "message-invalid";
         const db = getDb();
-        db.insert(messages).values({
-          id: messageId,
-          conversationId,
-          role: 'user',
-          content: JSON.stringify([{ type: 'text', text: 'retry me' }]),
-          createdAt: Date.now(),
-        }).run();
+        db.insert(messages)
+          .values({
+            id: messageId,
+            conversationId,
+            role: "user",
+            content: JSON.stringify([{ type: "text", text: "retry me" }]),
+            createdAt: Date.now(),
+          })
+          .run();
         return { messageId };
       },
       undefined,
@@ -230,32 +261,42 @@ describe('channel-retry-sweep', () => {
     expect(processMessageCalled).toBe(false);
 
     const db = getDb();
-    const row = db.select().from(channelInboundEvents).where(eq(channelInboundEvents.id, eventId)).get();
-    expect(row?.processingStatus).toBe('failed');
+    const row = db
+      .select()
+      .from(channelInboundEvents)
+      .where(eq(channelInboundEvents.id, eventId))
+      .get();
+    expect(row?.processingStatus).toBe("failed");
   });
 
-  test('synthesizes unknown trust context when guardianCtx is missing', async () => {
-    const inbound = channelDeliveryStore.recordInbound('telegram', 'chat-no-ctx', 'msg-no-ctx');
+  test("synthesizes unknown trust context when guardianCtx is missing", async () => {
+    const inbound = channelDeliveryStore.recordInbound(
+      "telegram",
+      "chat-no-ctx",
+      "msg-no-ctx",
+    );
     channelDeliveryStore.storePayload(inbound.eventId, {
-      content: 'retry me',
-      sourceChannel: 'telegram',
-      interface: 'telegram',
+      content: "retry me",
+      sourceChannel: "telegram",
+      interface: "telegram",
     });
 
     const db = getDb();
     db.update(channelInboundEvents)
       .set({
-        processingStatus: 'failed',
+        processingStatus: "failed",
         processingAttempts: 1,
         retryAfter: Date.now() - 1,
       })
       .where(eq(channelInboundEvents.id, inbound.eventId))
       .run();
 
-    let capturedOptions: {
-      guardianContext?: { trustClass?: string; sourceChannel?: string };
-      isInteractive?: boolean;
-    } | undefined;
+    let capturedOptions:
+      | {
+          guardianContext?: { trustClass?: string; sourceChannel?: string };
+          isInteractive?: boolean;
+        }
+      | undefined;
 
     await sweepFailedEvents(
       async (conversationId, _content, _attachmentIds, options) => {
@@ -263,14 +304,16 @@ describe('channel-retry-sweep', () => {
           guardianContext?: { trustClass?: string; sourceChannel?: string };
           isInteractive?: boolean;
         };
-        const messageId = 'message-no-ctx';
-        db.insert(messages).values({
-          id: messageId,
-          conversationId,
-          role: 'user',
-          content: JSON.stringify([{ type: 'text', text: 'retry me' }]),
-          createdAt: Date.now(),
-        }).run();
+        const messageId = "message-no-ctx";
+        db.insert(messages)
+          .values({
+            id: messageId,
+            conversationId,
+            role: "user",
+            content: JSON.stringify([{ type: "text", text: "retry me" }]),
+            createdAt: Date.now(),
+          })
+          .run();
         return { messageId };
       },
       undefined,
@@ -278,8 +321,8 @@ describe('channel-retry-sweep', () => {
 
     // When guardianCtx is absent, the sweep synthesizes an explicit 'unknown'
     // trust context to prevent downstream defaults from granting guardian trust.
-    expect(capturedOptions?.guardianContext?.trustClass).toBe('unknown');
-    expect(capturedOptions?.guardianContext?.sourceChannel).toBe('telegram');
+    expect(capturedOptions?.guardianContext?.trustClass).toBe("unknown");
+    expect(capturedOptions?.guardianContext?.sourceChannel).toBe("telegram");
     expect(capturedOptions?.isInteractive).toBe(false);
   });
 });