@vellumai/assistant 0.10.0 → 0.10.1-dev.202606240317.ea25efe

package/src/runtime/routes/__tests__/connection-routes-vs-cli-parity.test.ts

@@ -29,13 +29,16 @@ mock.module("../../../util/logger.js", () => ({
 import { getDb } from "../../../memory/db-connection.js";
 import { initializeDb } from "../../../memory/db-init.js";
 import { providerConnections } from "../../../memory/schema/inference.js";
-import { createConnection, getConnection } from "../../../providers/inference/connections.js";
+import {
+  createConnection,
+  getConnection,
+} from "../../../providers/inference/connections.js";
 import { ROUTES } from "../inference-provider-connection-routes.js";
 import type { RouteDefinition } from "../types.js";
 
 // ── DB bootstrap ──────────────────────────────────────────────────────────────
 
-initializeDb();
+await initializeDb();
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
@@ -49,8 +52,14 @@ function clearConnections(): void {
   getDb().delete(providerConnections).run();
 }
 
-function normalizeTimestamps<T extends object>(obj: T): Omit<T, "createdAt" | "updatedAt"> {
-  const { createdAt: _c, updatedAt: _u, ...rest } = obj as T & { createdAt?: unknown; updatedAt?: unknown };
+function normalizeTimestamps<T extends object>(
+  obj: T,
+): Omit<T, "createdAt" | "updatedAt"> {
+  const {
+    createdAt: _c,
+    updatedAt: _u,
+    ...rest
+  } = obj as T & { createdAt?: unknown; updatedAt?: unknown };
   return rest as Omit<T, "createdAt" | "updatedAt">;
 }
 
@@ -79,7 +88,9 @@ describe("CLI vs HTTP route parity", () => {
     clearConnections();
 
     // ── HTTP route path ───────────────────────────────────────────────────────
-    const httpResult = (await findHandler("inference_provider_connections_create")({
+    const httpResult = (await findHandler(
+      "inference_provider_connections_create",
+    )({
       body: {
         name: payload.name,
         provider: payload.provider,
@@ -111,7 +122,11 @@ describe("CLI vs HTTP route parity", () => {
     clearConnections();
 
     await findHandler("inference_provider_connections_create")({
-      body: { name: payload.name, provider: payload.provider, auth: payload.auth },
+      body: {
+        name: payload.name,
+        provider: payload.provider,
+        auth: payload.auth,
+      },
     });
     const httpRow = getConnection(getDb(), payload.name);
 
@@ -133,7 +148,11 @@ describe("CLI vs HTTP route parity", () => {
     clearConnections();
 
     await findHandler("inference_provider_connections_create")({
-      body: { name: payload.name, provider: payload.provider, auth: payload.auth },
+      body: {
+        name: payload.name,
+        provider: payload.provider,
+        auth: payload.auth,
+      },
     });
     const httpRow = getConnection(getDb(), payload.name);
 

package/src/runtime/routes/__tests__/consolidation-routes.test.ts

@@ -38,14 +38,14 @@ mock.module("../../../util/logger.js", () => ({
 
 import { invalidateConfigCache } from "../../../config/loader.js";
 import { createConversation } from "../../../memory/conversation-crud.js";
-import { getDb } from "../../../memory/db-connection.js";
+import { getDb, getMemorySqlite } from "../../../memory/db-connection.js";
 import { initializeDb } from "../../../memory/db-init.js";
 import { recordUsageEvent } from "../../../memory/llm-usage-store.js";
-import { rawAll, rawRun } from "../../../memory/raw-query.js";
+import { rawRun } from "../../../memory/raw-query.js";
 import { ROUTES } from "../consolidation-routes.js";
 import type { RouteDefinition } from "../types.js";
 
-initializeDb();
+await initializeDb();
 
 let workspaceDir: string;
 let origWorkspaceDir: string | undefined;
@@ -56,7 +56,7 @@ function resetTables(): void {
   db.run(`DELETE FROM llm_usage_events`);
   db.run(`DELETE FROM messages`);
   db.run(`DELETE FROM conversations`);
-  db.run(`DELETE FROM memory_jobs`);
+  getMemorySqlite()!.run(`DELETE FROM memory_jobs`);
 }
 
 function findHandler(operationId: string): RouteDefinition["handler"] {
@@ -117,16 +117,20 @@ function readMemoryJobRows(): Array<{
   lastError: string | null;
   payload: string;
 }> {
-  return rawAll<{
+  return getMemorySqlite()!
+    .query(
+      `
+    SELECT id, status, last_error AS lastError, payload
+    FROM memory_jobs
+    ORDER BY id
+  `,
+    )
+    .all() as Array<{
     id: string;
     status: string;
     lastError: string | null;
     payload: string;
-  }>(`
-    SELECT id, status, last_error AS lastError, payload
-    FROM memory_jobs
-    ORDER BY id
-  `);
+  }>;
 }
 
 interface RunRecord {

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: () => {},
 }));