@vellumai/assistant 0.10.0 → 0.10.1-staging.1

package/src/runtime/routes/__tests__/contact-routes-update-channel-relay.test.ts

@@ -0,0 +1,164 @@
+/**
+ * Unit tests for the daemon updateContactChannel relay.
+ *
+ * `handleUpdateContactChannelRoute` is a thin relay to the gateway IPC method
+ * `update_contact_channel` via `ipcCallPersistent`. The gateway DB is the source
+ * of truth: the daemon writes NOTHING to the assistant DB directly. These tests
+ * assert the handler forwards `{ contactChannelId, status, policy, reason }`
+ * unchanged, returns the gateway response verbatim, never touches the assistant
+ * contact store, and propagates an unexpected relay rejection (no fallback).
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { IpcCallError } from "@vellumai/gateway-client/ipc-client";
+
+type IpcCall = {
+  method: string;
+  params?: Record<string, unknown>;
+  timeoutMs?: number;
+};
+
+let ipcCalls: IpcCall[] = [];
+let ipcResult: unknown = { ok: true };
+let ipcError: Error | undefined;
+
+const ipcCallPersistentMock = mock(
+  async (
+    method: string,
+    params?: Record<string, unknown>,
+    timeoutMs?: number,
+  ) => {
+    ipcCalls.push({ method, params, timeoutMs });
+    if (ipcError) throw ipcError;
+    return ipcResult;
+  },
+);
+
+const actualGatewayClient = await import("../../../ipc/gateway-client.js");
+
+mock.module("../../../ipc/gateway-client.js", () => ({
+  ...actualGatewayClient,
+  ipcCallPersistent: ipcCallPersistentMock,
+}));
+
+// Guard: fail loudly if the relay still writes the assistant contact store
+// directly. The relayed update path must go through the gateway only.
+const actualContactStore = await import("../../../contacts/contact-store.js");
+
+const contactStoreWriteGuard = mock(() => {
+  throw new Error(
+    "assistant contact-store write must not happen on the relayed update path",
+  );
+});
+
+mock.module("../../../contacts/contact-store.js", () => ({
+  ...actualContactStore,
+  updateChannelStatus: contactStoreWriteGuard,
+}));
+
+const { handleUpdateContactChannelRoute, ROUTES } = await import(
+  "../contact-routes.js"
+);
+
+describe("update contact channel relay", () => {
+  beforeEach(() => {
+    ipcCalls = [];
+    ipcResult = { ok: true };
+    ipcError = undefined;
+    ipcCallPersistentMock.mockClear();
+    contactStoreWriteGuard.mockClear();
+  });
+
+  test("forwards { contactChannelId, status, policy, reason } unchanged and returns the gateway response verbatim", async () => {
+    const gatewayResponse = {
+      ok: true,
+      contact: { id: "ct_1", displayName: "Alice", channels: [] },
+    };
+    ipcResult = gatewayResponse;
+
+    const result = await handleUpdateContactChannelRoute({
+      pathParams: { contactChannelId: "ch_1" },
+      body: { status: "revoked", policy: "deny", reason: "user request" },
+    });
+
+    expect(ipcCalls).toEqual([
+      {
+        method: "update_contact_channel",
+        params: {
+          contactChannelId: "ch_1",
+          status: "revoked",
+          policy: "deny",
+          reason: "user request",
+        },
+        timeoutMs: undefined,
+      },
+    ]);
+    expect(result).toEqual(gatewayResponse);
+    // Must NOT write the assistant DB directly.
+    expect(contactStoreWriteGuard).not.toHaveBeenCalled();
+  });
+
+  test("omits absent body fields from the relayed params", async () => {
+    ipcResult = { ok: true };
+
+    await handleUpdateContactChannelRoute({
+      pathParams: { contactChannelId: "ch_2" },
+      body: { status: "active" },
+    });
+
+    expect(ipcCalls).toEqual([
+      {
+        method: "update_contact_channel",
+        params: { contactChannelId: "ch_2", status: "active" },
+        timeoutMs: undefined,
+      },
+    ]);
+    expect(contactStoreWriteGuard).not.toHaveBeenCalled();
+  });
+
+  test("relayed IpcCallError surfaces with its statusCode/errorCode", async () => {
+    ipcError = new IpcCallError("Channel not found", {
+      statusCode: 404,
+      errorCode: "NOT_FOUND",
+    });
+
+    try {
+      await handleUpdateContactChannelRoute({
+        pathParams: { contactChannelId: "missing" },
+        body: { status: "active" },
+      });
+      throw new Error("expected handler to throw");
+    } catch (err) {
+      const e = err as { statusCode?: number; code?: string; message: string };
+      expect(e.message).toBe("Channel not found");
+      expect(e.statusCode).toBe(404);
+      expect(e.code).toBe("NOT_FOUND");
+    }
+    expect(contactStoreWriteGuard).not.toHaveBeenCalled();
+  });
+
+  test("an unexpected relay rejection propagates (no fallback, no second write)", async () => {
+    ipcError = new Error("ipc transport exploded");
+
+    try {
+      await handleUpdateContactChannelRoute({
+        pathParams: { contactChannelId: "ch_3" },
+        body: { status: "active" },
+      });
+      throw new Error("expected handler to throw");
+    } catch (err) {
+      expect((err as Error).message).toBe("ipc transport exploded");
+    }
+    // No daemon-side fallback write.
+    expect(contactStoreWriteGuard).not.toHaveBeenCalled();
+    expect(ipcCalls).toHaveLength(1);
+  });
+
+  test("the updateContactChannel route is registered and wired to the relay", () => {
+    const route = ROUTES.find((r) => r.operationId === "updateContactChannel");
+    expect(route).toBeDefined();
+    expect(route?.endpoint).toBe("contact-channels/:contactChannelId");
+    expect(route?.method).toBe("PATCH");
+  });
+});

package/src/runtime/routes/__tests__/conversation-list-routes.test.ts

@@ -37,7 +37,7 @@ import type { RouteDefinition } from "../types.js";
 // DB bootstrap
 // ---------------------------------------------------------------------------
 
-initializeDb();
+await initializeDb();
 
 function clearConversations(): void {
   getDb().delete(conversations).run();

package/src/runtime/routes/__tests__/conversation-management-routes.test.ts

@@ -39,7 +39,7 @@ import type { RouteDefinition } from "../types.js";
 // DB bootstrap
 // ---------------------------------------------------------------------------
 
-initializeDb();
+await initializeDb();
 
 // ---------------------------------------------------------------------------
 // Config fixture — must expose at least one profile so the handler can

package/src/runtime/routes/__tests__/conversation-query-routes.test.ts

@@ -57,7 +57,7 @@ mock.module("../../../memory/embedding-backend.js", () => ({
 }));
 
 import type { ConversationCreateType } from "../../../memory/conversation-crud.js";
-import { getDb } from "../../../memory/db-connection.js";
+import { getDb, getLogsDb } from "../../../memory/db-connection.js";
 import { initializeDb } from "../../../memory/db-init.js";
 import {
   backfillMemoryV2ActivationMessageId,
@@ -84,7 +84,7 @@ const sampleConcepts: MemoryV2ConceptRowRecord[] = sharedSampleConcepts.slice(
   1,
 );
 
-initializeDb();
+await initializeDb();
 
 const llmContextRoute = ROUTES.find(
   (r) => r.method === "GET" && r.endpoint === "messages/:id/llm-context",
@@ -108,7 +108,7 @@ function dispatchConversationLlmContext(queryParams: Record<string, string>) {
 
 function clearTables(): void {
   const db = getDb();
-  db.delete(llmRequestLogs).run();
+  getLogsDb()!.delete(llmRequestLogs).run();
   db.delete(memoryV2ActivationLogs).run();
   db.delete(messages).run();
   db.delete(conversationKeys).run();
@@ -156,7 +156,7 @@ function seedRequestLog(
   id: string,
   options: { agentLoopExitReason?: string | null } = {},
 ): void {
-  getDb()
+  getLogsDb()!
     .insert(llmRequestLogs)
     .values({
       id,
@@ -176,7 +176,7 @@ function seedRequestLog(
 }
 
 function seedRequestLogWithSections(messageId: string, id: string): void {
-  getDb()
+  getLogsDb()!
     .insert(llmRequestLogs)
     .values({
       id,
@@ -243,7 +243,7 @@ describe("GET /v1/conversations/llm-context", () => {
     seedConversationKey("conv-key", "conv-1");
     seedRequestLog("msg-2", "log-b");
     seedRequestLog("msg-1", "log-a");
-    getDb()
+    getLogsDb()!
       .insert(llmRequestLogs)
       .values({
         id: "log-other",
@@ -630,7 +630,7 @@ describe("GET /v1/messages/:id/llm-context — synthetic call_site projection",
     // loop was about to send; response = the notice text the user saw),
     // `call_site = "syntheticAgentErrorMessage"`, exit reason stamped at
     // insert time.
-    getDb()
+    getLogsDb()!
       .insert(llmRequestLogs)
       .values({
         id: "log-yield",
@@ -681,7 +681,7 @@ describe("GET /v1/messages/:id/llm-context — synthetic call_site projection",
       source: "user",
       conversationType: "standard",
     });
-    getDb()
+    getLogsDb()!
       .insert(llmRequestLogs)
       .values({
         id: "log-regular",

package/src/runtime/routes/__tests__/conversation-surface-routes.test.ts

@@ -60,7 +60,7 @@ import type { RouteDefinition } from "../types.js";
 // DB bootstrap
 // ---------------------------------------------------------------------------
 
-initializeDb();
+await initializeDb();
 
 // ---------------------------------------------------------------------------
 // Helpers

package/src/runtime/routes/__tests__/inference-provider-connection-routes.test.ts

@@ -40,7 +40,7 @@ import type { RouteDefinition, RouteHandlerArgs } from "../types.js";
 
 // ── DB bootstrap ──────────────────────────────────────────────────────────────
 
-initializeDb();
+await initializeDb();
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
@@ -157,7 +157,6 @@ describe("GET inference/provider-connections (list)", () => {
     )) as { connections: unknown[] };
     expect(result.connections).toEqual([]);
   });
-
 });
 
 // ── GET single ────────────────────────────────────────────────────────────────
@@ -186,7 +185,6 @@ describe("GET inference/provider-connections/:name (single)", () => {
       }),
     ).rejects.toBeInstanceOf(NotFoundError);
   });
-
 });
 
 // ── POST create ───────────────────────────────────────────────────────────────

package/src/runtime/routes/__tests__/invite-relay-routes.test.ts

@@ -0,0 +1,240 @@
+/**
+ * Unit tests for the CLI invite relay routes.
+ *
+ * Three CLI invite handlers (list/create/revoke) are thin relays to the gateway
+ * IPC methods via `ipcCallPersistent`. These tests assert each relays with the
+ * correct method + params, returns the parsed gateway response, never writes the
+ * assistant invite store directly, and surfaces a relayed IpcCallError with its
+ * statusCode. `invites_redeem` and `invites_trigger_call` stay daemon-local: the
+ * gateway delegates the actual provider call to the daemon-local handler, so
+ * relaying it back would loop gateway→assistant→gateway.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { IpcCallError } from "@vellumai/gateway-client/ipc-client";
+
+type IpcCall = {
+  method: string;
+  params?: Record<string, unknown>;
+  timeoutMs?: number;
+};
+
+let ipcCalls: IpcCall[] = [];
+let ipcResult: unknown = {};
+let ipcError: Error | undefined;
+
+const ipcCallPersistentMock = mock(
+  async (
+    method: string,
+    params?: Record<string, unknown>,
+    timeoutMs?: number,
+  ) => {
+    ipcCalls.push({ method, params, timeoutMs });
+    if (ipcError) throw ipcError;
+    return ipcResult;
+  },
+);
+
+const actualGatewayClient = await import("../../../ipc/gateway-client.js");
+
+mock.module("../../../ipc/gateway-client.js", () => ({
+  ...actualGatewayClient,
+  ipcCallPersistent: ipcCallPersistentMock,
+}));
+
+// Guard: fail loudly if any relayed handler still writes the assistant invite
+// store directly. The relayed CLI paths must go through the gateway only, so we
+// spy on the store's write functions and assert they are never invoked.
+const actualInviteStore = await import("../../../memory/invite-store.js");
+
+const inviteStoreCall = mock(() => {
+  throw new Error("invite-store write must not happen on relayed CLI paths");
+});
+
+mock.module("../../../memory/invite-store.js", () => ({
+  ...actualInviteStore,
+  createInvite: inviteStoreCall,
+  listInvites: inviteStoreCall,
+  revokeInvite: inviteStoreCall,
+}));
+
+// `invites_trigger_call` is daemon-local: the handler invokes the local
+// `triggerInviteCall` provider logic directly (never `ipcCallPersistent`).
+let triggerInviteCallResult: unknown = { ok: true, data: { callSid: "CA000" } };
+const triggerInviteCallMock = mock(async (_id: string) => triggerInviteCallResult);
+
+const actualInviteService = await import("../../invite-service.js");
+
+mock.module("../../invite-service.js", () => ({
+  ...actualInviteService,
+  triggerInviteCall: triggerInviteCallMock,
+}));
+
+const {
+  handleListInvites,
+  handleCreateInvite,
+  handleRevokeInvite,
+  handleTriggerInviteCall,
+  ROUTES,
+} = await import("../contact-routes.js");
+
+describe("invite relay routes", () => {
+  beforeEach(() => {
+    ipcCalls = [];
+    ipcResult = {};
+    ipcError = undefined;
+    ipcCallPersistentMock.mockClear();
+    inviteStoreCall.mockClear();
+    triggerInviteCallResult = { ok: true, data: { callSid: "CA000" } };
+    triggerInviteCallMock.mockClear();
+  });
+
+  describe("handleListInvites", () => {
+    test("relays invites_list with filters from queryParams", async () => {
+      ipcResult = { invites: [{ id: "i1" }] };
+      const result = await handleListInvites({
+        queryParams: { sourceChannel: "telegram", status: "active" },
+      });
+
+      expect(ipcCalls).toEqual([
+        {
+          method: "invites_list",
+          params: { sourceChannel: "telegram", status: "active" },
+          // List uses the default IPC timeout (no longer-timeout relay needed).
+          timeoutMs: undefined,
+        },
+      ]);
+      expect(result).toEqual({ ok: true, invites: [{ id: "i1" }] });
+      expect(inviteStoreCall).not.toHaveBeenCalled();
+    });
+
+    test("omits absent filters", async () => {
+      ipcResult = { invites: [] };
+      await handleListInvites({ queryParams: {} });
+
+      expect(ipcCalls).toEqual([
+        { method: "invites_list", params: {}, timeoutMs: undefined },
+      ]);
+    });
+  });
+
+  describe("handleCreateInvite", () => {
+    test("relays invites_create with mapped body and returns invite + rawToken", async () => {
+      ipcResult = { invite: { id: "i9", token: "tok-9" }, rawToken: "tok-9" };
+      const result = await handleCreateInvite({
+        body: {
+          contactId: "c1",
+          sourceChannel: "telegram",
+          note: "hi",
+          maxUses: 2,
+        },
+      });
+
+      expect(ipcCalls).toEqual([
+        {
+          method: "invites_create",
+          params: {
+            contactId: "c1",
+            sourceChannel: "telegram",
+            note: "hi",
+            maxUses: 2,
+            expiresInMs: undefined,
+            expectedExternalUserId: undefined,
+          },
+          // The create relay uses a generous timeout (gateway invites_mint can
+          // spend ~5s in generateInviteInstruction); list/revoke use the default.
+          timeoutMs: 30_000,
+        },
+      ]);
+      expect(result).toEqual({
+        ok: true,
+        invite: { id: "i9", token: "tok-9" },
+        rawToken: "tok-9",
+      });
+      expect(inviteStoreCall).not.toHaveBeenCalled();
+    });
+
+    test("omits rawToken when the gateway returns none", async () => {
+      ipcResult = { invite: { id: "i9" } };
+      const result = await handleCreateInvite({
+        body: { contactId: "c1", sourceChannel: "phone" },
+      });
+
+      expect(result).toEqual({ ok: true, invite: { id: "i9" } });
+    });
+  });
+
+  describe("handleRevokeInvite", () => {
+    test("relays invites_revoke with id from pathParams", async () => {
+      ipcResult = { invite: { id: "i3", status: "revoked" } };
+      const result = await handleRevokeInvite({ pathParams: { id: "i3" } });
+
+      expect(ipcCalls).toEqual([
+        { method: "invites_revoke", params: { id: "i3" }, timeoutMs: undefined },
+      ]);
+      expect(result).toEqual({
+        ok: true,
+        invite: { id: "i3", status: "revoked" },
+      });
+      expect(inviteStoreCall).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("handleTriggerInviteCall (daemon-local carve-out)", () => {
+    test("invokes the local triggerInviteCall and does NOT relay to the gateway", async () => {
+      triggerInviteCallResult = { ok: true, data: { callSid: "CA123" } };
+      const result = await handleTriggerInviteCall({ pathParams: { id: "i7" } });
+
+      expect(triggerInviteCallMock).toHaveBeenCalledTimes(1);
+      expect(triggerInviteCallMock).toHaveBeenCalledWith("i7");
+      // Must NOT relay: relaying invites_trigger_call would loop
+      // gateway→assistant→gateway (the gateway calls THIS to place the call).
+      expect(ipcCalls).toEqual([]);
+      expect(result).toEqual({ ok: true, callSid: "CA123" });
+    });
+
+    test("surfaces a failed provider call as a 400", async () => {
+      triggerInviteCallResult = { ok: false, error: "Invite not eligible" };
+
+      try {
+        await handleTriggerInviteCall({ pathParams: { id: "i7" } });
+        throw new Error("expected handler to throw");
+      } catch (err) {
+        const e = err as { statusCode?: number; message: string };
+        expect(e.message).toBe("Invite not eligible");
+        expect(e.statusCode).toBe(400);
+      }
+      expect(ipcCalls).toEqual([]);
+    });
+  });
+
+  describe("error propagation", () => {
+    test("relayed IpcCallError surfaces with its statusCode/errorCode", async () => {
+      ipcError = new IpcCallError("Invite not found", {
+        statusCode: 404,
+        errorCode: "NOT_FOUND",
+      });
+
+      try {
+        await handleRevokeInvite({ pathParams: { id: "missing" } });
+        throw new Error("expected handler to throw");
+      } catch (err) {
+        const e = err as { statusCode?: number; code?: string; message: string };
+        expect(e.message).toBe("Invite not found");
+        expect(e.statusCode).toBe(404);
+        expect(e.code).toBe("NOT_FOUND");
+      }
+    });
+  });
+
+  describe("invites_redeem carve-out", () => {
+    test("redeem route is registered but NOT relayed to the gateway", () => {
+      const redeemRoute = ROUTES.find((r) => r.operationId === "invites_redeem");
+      expect(redeemRoute).toBeDefined();
+      // The redeem handler is daemon-local; it must not appear in the relayed
+      // operation set above. No gateway IPC call is made by registering it.
+      expect(ipcCalls).toEqual([]);
+    });
+  });
+});

package/src/runtime/routes/__tests__/memory-v2-simulate-route.test.ts

@@ -80,6 +80,10 @@ mock.module("../../../memory/db-connection.js", () => ({
   getDb: () => ({ __stub: true }),
   getSqlite: () => ({ __stub: true }),
   getSqliteFrom: () => ({ __stub: true }),
+  getMemoryDb: () => ({ __stub: true }),
+  getMemorySqlite: () => ({ __stub: true }),
+  getLogsDb: () => ({ __stub: true }),
+  getLogsSqlite: () => ({ __stub: true }),
   resetDb: () => {},
 }));