@vellumai/assistant 0.10.0 → 0.10.1-staging.1

package/src/__tests__/relay-server.test.ts

@@ -26,10 +26,6 @@ import {
   test,
 } from "bun:test";
 
-import { ADMISSION_FLOOR } from "@vellumai/gateway-client";
-
-import { TRUST_CLASS_RANK } from "../runtime/actor-trust-resolver.js";
-
 // ── Platform + logger mocks (must come before any source imports) ────
 
 // eslint-disable-next-line @typescript-eslint/no-require-imports
@@ -42,6 +38,28 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
+// The voice redemption path now claims the gateway-canonical row over IPC
+// before mutating. Stub it so tests don't attempt a real socket connect; the
+// claim returns consumed (updated:true) so redemption proceeds.
+//
+// `inviteClaimCalls` counts gateway claims so concurrency tests can assert that
+// a repeated code does NOT launch a second claim. `inviteClaimGate`, when set,
+// holds the claim open mid-flight so a test can drive the race window where a
+// second code arrives while the first redemption is still awaiting the gateway.
+let inviteClaimCalls = 0;
+let inviteClaimGate: Promise<void> | null = null;
+mock.module("../ipc/gateway-client.js", () => ({
+  ipcCall: async () => undefined,
+  ipcCallPersistent: async (method: string) => {
+    if (method === "record_invite_redemption") {
+      inviteClaimCalls += 1;
+      if (inviteClaimGate) await inviteClaimGate;
+      return { ok: true, updated: true, mirrored: true };
+    }
+    return undefined;
+  },
+}));
+
 // ── Identity helpers mock ─────────────────────────────────────────────
 
 let mockAssistantName: string | null = "Vellum";
@@ -145,40 +163,6 @@ mock.module("../calls/channel-admission-reader.js", () => ({
   },
 }));
 
-// Real floor semantics, mirroring relay-setup-router.test.ts. The
-// enforceAdmissionPolicy mock omits the exempt-channel short-circuit so the
-// deny path can be exercised end-to-end regardless of channel.
-// eslint-disable-next-line @typescript-eslint/no-require-imports
-const realAdmissionPolicyModule = require("../runtime/routes/inbound-stages/admission-policy.js");
-mock.module("../runtime/routes/inbound-stages/admission-policy.js", () => ({
-  ...realAdmissionPolicyModule,
-  enforceAdmissionPolicy: (input: {
-    trustClass: string;
-    memberStatus: string | undefined;
-    policy: import("@vellumai/gateway-client").AdmissionPolicy;
-  }) => {
-    if (input.memberStatus === "blocked" || input.memberStatus === "revoked") {
-      return {
-        admitted: false,
-        reason:
-          input.memberStatus === "blocked" ? "member_blocked" : "member_revoked",
-        shouldChallenge: false,
-        effectivePolicy: input.policy,
-      };
-    }
-    const rank =
-      (TRUST_CLASS_RANK as Record<string, number>)[input.trustClass] ?? 0;
-    const floor = ADMISSION_FLOOR[input.policy];
-    if (rank >= floor) return { admitted: true };
-    return {
-      admitted: false,
-      reason: `admission_policy_${input.policy}`,
-      shouldChallenge: false,
-      effectivePolicy: input.policy,
-    };
-  },
-}));
-
 // ── TTS provider mocks (for call-speech-output) ─────────────────────
 
 let mockTtsProviderId: string = "elevenlabs";
@@ -317,7 +301,7 @@ import { generateVoiceCode, hashVoiceCode } from "../util/voice-code.js";
 import { resetDbForTesting } from "./db-test-helpers.js";
 import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
 
-initializeDb();
+await initializeDb();
 
 // Activate the channel-admission-reader stub only while this file's tests run,
 // so the registered (process-global) mock delegates to the real module for
@@ -489,6 +473,8 @@ describe("relay-server", () => {
       verifiedVia: "bootstrap",
     });
     activeRelayConnections.clear();
+    inviteClaimCalls = 0;
+    inviteClaimGate = null;
     mockUserReference = "my human";
     mockAssistantName = "Vellum";
     mockAdmissionPolicy = null;
@@ -2311,8 +2297,9 @@ describe("relay-server", () => {
 
   // ── Inbound voice invite redemption ──────────────────────────────────
 
-  test("inbound voice invite redemption: personalized welcome prompt with friend/guardian names", async () => {
+  test("inbound voice invite redemption: personalized welcome prompt uses contact displayName", async () => {
     ensureConversation("conv-invite-welcome");
+    mockUserReference = "Bob";
     const session = createCallSession({
       conversationId: "conv-invite-welcome",
       provider: "twilio",
@@ -2320,18 +2307,16 @@ describe("relay-server", () => {
       toNumber: "+15551111111",
     });
 
-    // Create a voice invite with friend/guardian names
+    // The invitee's name is read from the bound contact's displayName.
     const code = generateVoiceCode(6);
     const codeHash = hashVoiceCode(code);
     createInvite({
       sourceChannel: "phone",
-      contactId: createTargetContact(),
+      contactId: createTargetContact("Alice"),
       maxUses: 1,
       expectedExternalUserId: "+15558887777",
       voiceCodeHash: codeHash,
       voiceCodeDigits: 6,
-      friendName: "Alice",
-      guardianName: "Bob",
     });
 
     mockSendMessage.mockImplementation(
@@ -2352,7 +2337,8 @@ describe("relay-server", () => {
     // Should be in verification-pending state for invite redemption
     expect(relay.getConnectionState()).toBe("verification_pending");
 
-    // Check that the welcome prompt includes friend/guardian names
+    // Welcome prompt should use the contact's first-name and the resolved
+    // guardian label (not stale name flags from the invite row).
     const textMessages = ws.sentMessages
       .map((raw) => JSON.parse(raw) as { type: string; token?: string })
       .filter((m) => m.type === "text");
@@ -2387,6 +2373,7 @@ describe("relay-server", () => {
 
   test("inbound voice invite redemption: invalid code gets exact failure copy with guardian name and call ends", async () => {
     ensureConversation("conv-invite-fail");
+    mockUserReference = "Dave";
     const session = createCallSession({
       conversationId: "conv-invite-fail",
       provider: "twilio",
@@ -2394,18 +2381,16 @@ describe("relay-server", () => {
       toNumber: "+15551111111",
     });
 
-    // Create a voice invite with friend/guardian names
+    // Bound contact's displayName is used; guardian label is resolved at runtime.
     const code = generateVoiceCode(6);
     const codeHash = hashVoiceCode(code);
     createInvite({
       sourceChannel: "phone",
-      contactId: createTargetContact(),
+      contactId: createTargetContact("Carol"),
       maxUses: 1,
       expectedExternalUserId: "+15558886666",
       voiceCodeHash: codeHash,
       voiceCodeDigits: 6,
-      friendName: "Carol",
-      guardianName: "Dave",
     });
 
     const { ws, relay } = createMockWs(session.id);
@@ -2426,7 +2411,11 @@ describe("relay-server", () => {
       await relay.handleMessage(JSON.stringify({ type: "dtmf", digit }));
     }
 
-    // Call should be marked as failed immediately
+    // Redemption is dispatched async (it now consults the gateway lifecycle
+    // pre-check over IPC), so flush the microtask/timer queue before asserting.
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    // Call should be marked as failed
     const updated = getCallSession(session.id);
     expect(updated).not.toBeNull();
     expect(updated!.status).toBe("failed");
@@ -2466,6 +2455,184 @@ describe("relay-server", () => {
     relay.destroy();
   });
 
+  test("inbound voice invite redemption: repeated code during in-flight claim is deduped (no second redemption, no spurious failure)", async () => {
+    ensureConversation("conv-invite-dedup");
+    const session = createCallSession({
+      conversationId: "conv-invite-dedup",
+      provider: "twilio",
+      fromNumber: "+15558885555",
+      toNumber: "+15551111111",
+    });
+
+    const code = generateVoiceCode(6);
+    const codeHash = hashVoiceCode(code);
+    createInvite({
+      sourceChannel: "phone",
+      contactId: createTargetContact("Eve"),
+      maxUses: 1,
+      expectedExternalUserId: "+15558885555",
+      voiceCodeHash: codeHash,
+      voiceCodeDigits: 6,
+    });
+
+    mockSendMessage.mockImplementation(
+      createMockProviderResponse(["Hello, how can I help?"]),
+    );
+
+    const { ws, relay } = createMockWs(session.id);
+
+    await relay.handleMessage(
+      JSON.stringify({
+        type: "setup",
+        callSid: "CA_invite_dedup",
+        from: "+15558885555",
+        to: "+15551111111",
+      }),
+    );
+
+    expect(relay.getConnectionState()).toBe("verification_pending");
+
+    // Hold the gateway claim open so the first redemption stays in flight while
+    // the caller re-speaks the SAME code (the race this guard prevents).
+    let releaseClaim: () => void = () => {};
+    inviteClaimGate = new Promise<void>((resolve) => {
+      releaseClaim = resolve;
+    });
+
+    // First attempt: enter the full code via DTMF — dispatched fire-and-forget.
+    for (const digit of code) {
+      await relay.handleMessage(JSON.stringify({ type: "dtmf", digit }));
+    }
+    // Let the async handler reach the awaited gateway claim.
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(inviteClaimCalls).toBe(1);
+
+    // Second attempt with the SAME code arrives while the first is in flight.
+    // It must be ignored — no second claim, no failure branch.
+    for (const digit of code) {
+      await relay.handleMessage(JSON.stringify({ type: "dtmf", digit }));
+    }
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    expect(inviteClaimCalls).toBe(1);
+
+    // Now let the first redemption resolve.
+    releaseClaim();
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    // Exactly one gateway claim ran across both attempts.
+    expect(inviteClaimCalls).toBe(1);
+
+    // Activation succeeded — call continued, never marked failed.
+    expect(relay.getConnectionState()).toBe("connected");
+    const updated = getCallSession(session.id);
+    expect(updated).not.toBeNull();
+    expect(updated!.status).not.toBe("failed");
+
+    const events = getCallEvents(session.id);
+    expect(
+      events.some((e) => e.eventType === "invite_redemption_succeeded"),
+    ).toBe(true);
+    expect(events.some((e) => e.eventType === "invite_redemption_failed")).toBe(
+      false,
+    );
+
+    // No failure copy was sent for the deduped second attempt.
+    const failureCopy = ws.sentMessages
+      .map((raw) => JSON.parse(raw) as { type: string; token?: string })
+      .filter(
+        (m) =>
+          m.type === "text" &&
+          (m.token ?? "").includes("incorrect or has since expired"),
+      );
+    expect(failureCopy.length).toBe(0);
+
+    relay.destroy();
+  });
+
+  test("inbound voice invite redemption: a fresh redemption after a prior attempt fully resolves still proceeds (guard cleared, no deadlock)", async () => {
+    // Prior attempt: a fully-resolved redemption on its own call.
+    ensureConversation("conv-invite-prior");
+    const priorSession = createCallSession({
+      conversationId: "conv-invite-prior",
+      provider: "twilio",
+      fromNumber: "+15558883333",
+      toNumber: "+15551111111",
+    });
+    const priorCode = generateVoiceCode(6);
+    createInvite({
+      sourceChannel: "phone",
+      contactId: createTargetContact("Ivan"),
+      maxUses: 1,
+      expectedExternalUserId: "+15558883333",
+      voiceCodeHash: hashVoiceCode(priorCode),
+      voiceCodeDigits: 6,
+    });
+
+    mockSendMessage.mockImplementation(
+      createMockProviderResponse(["Hello, how can I help?"]),
+    );
+
+    const prior = createMockWs(priorSession.id);
+    await prior.relay.handleMessage(
+      JSON.stringify({
+        type: "setup",
+        callSid: "CA_invite_prior",
+        from: "+15558883333",
+        to: "+15551111111",
+      }),
+    );
+    for (const digit of priorCode) {
+      await prior.relay.handleMessage(
+        JSON.stringify({ type: "dtmf", digit }),
+      );
+    }
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    expect(prior.relay.getConnectionState()).toBe("connected");
+    expect(inviteClaimCalls).toBe(1);
+    prior.relay.destroy();
+
+    // Fresh attempt: a brand-new redemption proceeds (the in-flight guard from
+    // the resolved attempt does not block it — it was cleared in finally).
+    ensureConversation("conv-invite-fresh");
+    const freshSession = createCallSession({
+      conversationId: "conv-invite-fresh",
+      provider: "twilio",
+      fromNumber: "+15558882222",
+      toNumber: "+15551111111",
+    });
+    const freshCode = generateVoiceCode(6);
+    createInvite({
+      sourceChannel: "phone",
+      contactId: createTargetContact("Kim"),
+      maxUses: 1,
+      expectedExternalUserId: "+15558882222",
+      voiceCodeHash: hashVoiceCode(freshCode),
+      voiceCodeDigits: 6,
+    });
+
+    const fresh = createMockWs(freshSession.id);
+    await fresh.relay.handleMessage(
+      JSON.stringify({
+        type: "setup",
+        callSid: "CA_invite_fresh",
+        from: "+15558882222",
+        to: "+15551111111",
+      }),
+    );
+    for (const digit of freshCode) {
+      await fresh.relay.handleMessage(
+        JSON.stringify({ type: "dtmf", digit }),
+      );
+    }
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    // A second claim ran for the fresh attempt — guard did not deadlock it.
+    expect(inviteClaimCalls).toBe(2);
+    expect(fresh.relay.getConnectionState()).toBe("connected");
+
+    fresh.relay.destroy();
+  });
+
   test("inbound voice: unknown caller with no active invite enters name capture flow", async () => {
     ensureConversation("conv-invite-no-invite");
     const session = createCallSession({
@@ -4519,7 +4686,7 @@ describe("relay-server", () => {
     relay.destroy();
   });
 
-  test("invite redemption success: continues call with handoff copy instead of ending", async () => {
+  test("invite redemption success: greeting uses bound contact's displayName first-token, not friendName", async () => {
     ensureConversation("conv-invite-continue");
     const session = createCallSession({
       conversationId: "conv-invite-continue",
@@ -4530,15 +4697,19 @@ describe("relay-server", () => {
 
     const code = generateVoiceCode(6);
     const codeHash = hashVoiceCode(code);
+    // Bound contact's displayName is the source of truth — its first token
+    // (here "Carolina") is what the post-redemption greeting should use.
+    // The legacy friendName column carries an out-of-date free-text label
+    // ("Stale Name") to prove the greeting reads from the contact, not the
+    // legacy column.
     createInvite({
       sourceChannel: "phone",
-      contactId: createTargetContact(),
+      contactId: createTargetContact("Carolina Flaherty"),
       maxUses: 1,
       expectedExternalUserId: "+15557776666",
       voiceCodeHash: codeHash,
       voiceCodeDigits: 6,
-      friendName: "Eve",
-      guardianName: "Frank",
+      friendName: "Stale Name",
     });
 
     mockSendMessage.mockImplementation(
@@ -4569,15 +4740,18 @@ describe("relay-server", () => {
     // Call should remain connected
     expect(relay.getConnectionState()).toBe("connected");
 
-    // Handoff copy should have been sent
+    // Handoff copy should use the contact's first-name, not the stale friendName
     const textMessages = ws.sentMessages
       .map((raw) => JSON.parse(raw) as { type: string; token?: string })
       .filter((m) => m.type === "text");
     expect(
       textMessages.some((m) =>
-        (m.token ?? "").includes("verified that you are Eve"),
+        (m.token ?? "").includes("verified that you are Carolina"),
       ),
     ).toBe(true);
+    expect(
+      textMessages.every((m) => !(m.token ?? "").includes("Stale Name")),
+    ).toBe(true);
 
     // No end message — call stays alive
     const endMessages = ws.sentMessages
@@ -4602,6 +4776,7 @@ describe("relay-server", () => {
   test("outbound invite prompt uses assistant introduction", async () => {
     ensureConversation("conv-outbound-invite-origin");
     ensureConversation("conv-outbound-invite");
+    mockUserReference = "Hank";
     const session = createCallSession({
       conversationId: "conv-outbound-invite",
       provider: "twilio",
@@ -4644,6 +4819,132 @@ describe("relay-server", () => {
     relay.destroy();
   });
 
+  test("invite redemption success: empty contact displayName triggers neutral 'Hi there' greeting", async () => {
+    ensureConversation("conv-invite-blank-name");
+    mockUserReference = "my human";
+    mockAssistantName = "";
+    const session = createCallSession({
+      conversationId: "conv-invite-blank-name",
+      provider: "twilio",
+      fromNumber: "+15557775555",
+      toNumber: "+15551111111",
+    });
+
+    const code = generateVoiceCode(6);
+    const codeHash = hashVoiceCode(code);
+    // displayName is whitespace-only — greeting falls back to "Hi there"
+    // rather than substituting the channel address.
+    createInvite({
+      sourceChannel: "phone",
+      contactId: createTargetContact("   "),
+      maxUses: 1,
+      expectedExternalUserId: "+15557775555",
+      voiceCodeHash: codeHash,
+      voiceCodeDigits: 6,
+    });
+
+    mockSendMessage.mockImplementation(
+      createMockProviderResponse(["I'd be happy to help."]),
+    );
+
+    const { ws, relay } = createMockWs(session.id);
+
+    await relay.handleMessage(
+      JSON.stringify({
+        type: "setup",
+        callSid: "CA_invite_blank_name",
+        from: "+15557775555",
+        to: "+15551111111",
+      }),
+    );
+
+    for (const digit of code) {
+      await relay.handleMessage(JSON.stringify({ type: "dtmf", digit }));
+    }
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    expect(relay.getConnectionState()).toBe("connected");
+
+    const textMessages = ws.sentMessages
+      .map((raw) => JSON.parse(raw) as { type: string; token?: string })
+      .filter((m) => m.type === "text");
+    expect(
+      textMessages.some((m) => (m.token ?? "").startsWith("Hi there!")),
+    ).toBe(true);
+    expect(
+      textMessages.every(
+        (m) => !(m.token ?? "").includes("+15557775555"),
+      ),
+    ).toBe(true);
+
+    relay.destroy();
+  });
+
+  test("invite redemption success: empty contact displayName with stale friendName column still greets 'Hi there'", async () => {
+    // Guards the Codex P2 on #35581 (discussion_r3453033493): when a bound
+    // contact's displayName is blank and the invite row carries a stale
+    // free-text friend_name, the greeting must NOT fall back to that stale
+    // label. contact_id is NOT NULL, so every invite is bound — empty
+    // displayName falls through to the neutral "Hi there" copy.
+    ensureConversation("conv-invite-stale-friend");
+    mockUserReference = "my human";
+    mockAssistantName = "";
+    const session = createCallSession({
+      conversationId: "conv-invite-stale-friend",
+      provider: "twilio",
+      fromNumber: "+15557774444",
+      toNumber: "+15551111111",
+    });
+
+    const code = generateVoiceCode(6);
+    const codeHash = hashVoiceCode(code);
+    createInvite({
+      sourceChannel: "phone",
+      contactId: createTargetContact("   "),
+      maxUses: 1,
+      expectedExternalUserId: "+15557774444",
+      voiceCodeHash: codeHash,
+      voiceCodeDigits: 6,
+      friendName: "Stale Legacy Name",
+    });
+
+    mockSendMessage.mockImplementation(
+      createMockProviderResponse(["I'd be happy to help."]),
+    );
+
+    const { ws, relay } = createMockWs(session.id);
+
+    await relay.handleMessage(
+      JSON.stringify({
+        type: "setup",
+        callSid: "CA_invite_stale_friend",
+        from: "+15557774444",
+        to: "+15551111111",
+      }),
+    );
+
+    for (const digit of code) {
+      await relay.handleMessage(JSON.stringify({ type: "dtmf", digit }));
+    }
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    expect(relay.getConnectionState()).toBe("connected");
+
+    const textMessages = ws.sentMessages
+      .map((raw) => JSON.parse(raw) as { type: string; token?: string })
+      .filter((m) => m.type === "text");
+    expect(
+      textMessages.some((m) => (m.token ?? "").startsWith("Hi there!")),
+    ).toBe(true);
+    expect(
+      textMessages.every(
+        (m) => !(m.token ?? "").includes("Stale Legacy Name"),
+      ),
+    ).toBe(true);
+
+    relay.destroy();
+  });
+
   // ── resolveGuardianLabel resolution priority ─────────────────────────
 
   test("guardian label: guardian persona name takes precedence over Contact.displayName", async () => {

package/src/__tests__/runtime-attachment-metadata.test.ts

@@ -58,8 +58,9 @@ import { resetTestTables } from "../memory/raw-query.js";
 import { RuntimeHttpServer } from "../runtime/http-server.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { resetDbForTesting } from "./db-test-helpers.js";
+import { resolveLocalTrustVerdict } from "./helpers/channel-test-adapter.js";
 
-initializeDb();
+await initializeDb();
 
 afterAll(() => {
   resetDbForTesting();
@@ -266,6 +267,13 @@ describe("WhatsApp channel ingress attachment resolution", () => {
   function makeInboundBody(
     overrides: Record<string, unknown> = {},
   ): Record<string, unknown> {
+    // Mirror the gateway: stamp a trust verdict from the local contact store so
+    // the daemon's fail-closed ACL stage admits the request to attachment logic.
+    const trustVerdict = resolveLocalTrustVerdict({
+      channelType: "whatsapp",
+      actorExternalId: WHATSAPP_USER_ID,
+      externalChatId: "whatsapp-chat-1",
+    });
     return {
       sourceChannel: "whatsapp",
       interface: "whatsapp",
@@ -274,6 +282,7 @@ describe("WhatsApp channel ingress attachment resolution", () => {
       externalMessageId: `wa-msg-${Date.now()}-${Math.random()}`,
       content: "Check these attachments",
       replyCallbackUrl: "https://gateway.test/deliver",
+      sourceMetadata: { trustVerdict },
       ...overrides,
     };
   }

package/src/__tests__/runtime-events-sse-bilingual.test.ts

@@ -38,13 +38,10 @@ import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { buildAssistantEvent } from "../runtime/assistant-event.js";
 import { AssistantEventHub } from "../runtime/assistant-event-hub.js";
-import {
-  BadRequestError,
-  NotFoundError,
-} from "../runtime/routes/errors.js";
+import { BadRequestError, NotFoundError } from "../runtime/routes/errors.js";
 import { handleSubscribeAssistantEvents } from "../runtime/routes/events-routes.js";
 
-initializeDb();
+await initializeDb();
 
 describe("GET /v1/events — bilingual scope query params", () => {
   beforeEach(() => {
@@ -75,7 +72,9 @@ describe("GET /v1/events — bilingual scope query params", () => {
     expect(new TextDecoder().decode(heartbeat.value)).toBe(": heartbeat\n\n");
 
     // Publish an event scoped to that conversation — should be delivered.
-    await testHub.publish(buildAssistantEvent({ type: "pong" }, conversationId));
+    await testHub.publish(
+      buildAssistantEvent({ type: "pong" }, conversationId),
+    );
 
     const { value, done } = await reader.read();
     ac.abort();
@@ -99,9 +98,8 @@ describe("GET /v1/events — bilingual scope query params", () => {
     // Materialise two distinct conversations: one we'll subscribe to by id,
     // one we'll publish to via the ignored key.
     const { conversationId: idConv } = getOrCreateConversation("sse-id-wins");
-    const { conversationId: keyConv } = getOrCreateConversation(
-      "sse-key-ignored",
-    );
+    const { conversationId: keyConv } =
+      getOrCreateConversation("sse-key-ignored");
     expect(idConv).not.toBe(keyConv);
 
     const ac = new AbortController();

package/src/__tests__/runtime-events-sse-parity.test.ts

@@ -44,7 +44,7 @@ import type { AssistantEvent } from "../runtime/assistant-event.js";
 import { buildAssistantEvent } from "../runtime/assistant-event.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 
-initializeDb();
+await initializeDb();
 
 // ---------------------------------------------------------------------------
 // Helpers

package/src/__tests__/runtime-events-sse-reconnect.test.ts

@@ -39,7 +39,7 @@ import {
   stampAndBuffer,
 } from "../runtime/assistant-stream-state.js";
 
-initializeDb();
+await initializeDb();
 
 const decoder = new TextDecoder();
 

package/src/__tests__/runtime-events-sse.test.ts

@@ -36,7 +36,7 @@ import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { mintToken } from "../runtime/auth/token-service.js";
 import { RuntimeHttpServer } from "../runtime/http-server.js";
 
-initializeDb();
+await initializeDb();
 
 const TEST_JWT = mintToken({
   aud: "vellum-daemon",

package/src/__tests__/schedule-retry.test.ts

@@ -82,7 +82,7 @@ function startScheduler(
   return startSchedulerReal(processMessage, notifyScheduleOneShot, options);
 }
 
-initializeDb();
+await initializeDb();
 
 /** Access the underlying bun:sqlite Database for raw parameterized queries. */
 function getRawDb(): import("bun:sqlite").Database {

package/src/__tests__/schedule-routes-workflow-validation.test.ts

@@ -51,7 +51,7 @@ import {
   listSchedules,
 } from "../schedule/schedule-store.js";
 
-initializeDb();
+await initializeDb();
 
 function clearTables(): void {
   const db = getDb();