@vellumai/assistant 0.6.5 → 0.7.0

package/src/__tests__/heartbeat-service.test.ts

@@ -61,7 +61,6 @@ const createdConversations: Array<{ title: string; conversationType: string }> =
 let conversationIdCounter = 0;
 
 mock.module("../memory/conversation-crud.js", () => ({
-  getConversationType: () => "default",
   setConversationOriginChannelIfUnset: () => {},
   updateConversationContextWindow: () => {},
   deleteMessageById: () => {},
@@ -107,6 +106,27 @@ mock.module("../memory/conversation-title-service.js", () => ({
   queueGenerateConversationTitle: () => {},
 }));
 
+// Mock processMessage — HeartbeatService now imports it directly.
+// Tests override _testProcessMessage to capture / customize calls.
+let _testProcessMessage: ((...args: unknown[]) => Promise<{ messageId: string }>) | undefined;
+
+mock.module("../daemon/process-message.js", () => ({
+  processMessage: async (...args: unknown[]) => {
+    if (_testProcessMessage) return _testProcessMessage(...args);
+    return { messageId: `mock-msg-${Date.now()}` };
+  },
+  resolveTurnChannel: () => "vellum",
+  resolveTurnInterface: () => "vellum",
+  makePendingInteractionRegistrar: () => () => {},
+  prepareConversationForMessage: async () => ({}),
+}));
+
+export function setTestProcessMessage(
+  fn: ((...args: unknown[]) => Promise<{ messageId: string }>) | undefined,
+): void {
+  _testProcessMessage = fn;
+}
+
 // Import after mocks are set up
 const { HeartbeatService, isShallowProfile } =
   await import("../heartbeat/heartbeat-service.js");
@@ -180,6 +200,16 @@ describe("HeartbeatService", () => {
     conversationIdCounter = 0;
     mockGuardianPersona = null;
 
+    // Default processMessage mock: capture calls for assertions.
+    setTestProcessMessage(async (...args: unknown[]) => {
+      processMessageCalls.push({
+        conversationId: args[0] as string,
+        content: args[1] as string,
+        options: (args[3] as { callSite?: string } | undefined) ?? undefined,
+      });
+      return { messageId: "msg-1" };
+    });
+
     mockConfig = {
       heartbeat: {
         enabled: true,
@@ -192,23 +222,14 @@ describe("HeartbeatService", () => {
 
   function createService(overrides?: {
     processMessage?: (
-      id: string,
-      content: string,
-      options?: { callSite?: string },
+      ...args: unknown[]
     ) => Promise<{ messageId: string }>;
     getCurrentHour?: () => number;
   }) {
+    if (overrides?.processMessage) {
+      setTestProcessMessage(overrides.processMessage);
+    }
     return new HeartbeatService({
-      processMessage:
-        overrides?.processMessage ??
-        (async (
-          conversationId: string,
-          content: string,
-          options?: { callSite?: string },
-        ) => {
-          processMessageCalls.push({ conversationId, content, options });
-          return { messageId: "msg-1" };
-        }),
       alerter: (alert: { type: string; title: string; body: string }) => {
         alerterCalls.push(alert);
       },
@@ -540,22 +561,19 @@ describe("HeartbeatService", () => {
     await service.runOnce();
 
     expect(processMessageCalls).toHaveLength(1);
-    expect(processMessageCalls[0].options).toEqual({
+    expect(processMessageCalls[0].options).toMatchObject({
       callSite: "heartbeatAgent",
     });
   });
 
-  test("processMessage receives only callSite — no legacy speed knob", async () => {
-    // The heartbeat service unconditionally passes `callSite:
-    // 'heartbeatAgent'` and nothing else. The resolver maps that identifier
-    // to whatever `llm.callSites.heartbeatAgent` (or `llm.default`)
-    // configures.
+  test("processMessage receives callSite and trustContext", async () => {
     const service = createService();
     await service.runOnce();
 
     expect(processMessageCalls).toHaveLength(1);
-    expect(processMessageCalls[0].options).toEqual({
+    expect(processMessageCalls[0].options).toMatchObject({
       callSite: "heartbeatAgent",
+      trustContext: { sourceChannel: "vellum", trustClass: "guardian" },
     });
   });
 

package/src/__tests__/helpers/call-route-handler.ts

@@ -0,0 +1,72 @@
+/**
+ * Test helper that bridges old Request-based handler calls to the new
+ * RouteHandlerArgs pattern. Allows existing tests to continue passing
+ * Request objects while handlers accept RouteHandlerArgs internally.
+ */
+import { RouteError } from "../../runtime/routes/errors.js";
+import type { RouteHandlerArgs } from "../../runtime/routes/types.js";
+import { RouteResponse } from "../../runtime/routes/types.js";
+
+export async function callHandler(
+  handler: (args: RouteHandlerArgs) => Promise<unknown>,
+  req: Request,
+  pathParams?: Record<string, string>,
+  /** Override the default 200 success status (e.g. 202 for async job routes). */
+  successStatus = 200,
+): Promise<Response> {
+  // Read content-type BEFORE consuming the body — Bun clears headers after arrayBuffer().
+  const contentType = req.headers.get("content-type") ?? "";
+  const headers: Record<string, string> = {};
+  req.headers.forEach((value, key) => {
+    headers[key] = value;
+  });
+
+  let body: Record<string, unknown> | undefined;
+  let rawBody: Uint8Array | undefined;
+
+  if (req.method !== "GET" && req.method !== "HEAD") {
+    if (contentType.includes("application/json")) {
+      try {
+        body = (await req.clone().json()) as Record<string, unknown>;
+      } catch {
+        /* no body or invalid JSON */
+      }
+    }
+    // Always capture rawBody for non-JSON content types
+    if (!contentType.includes("application/json") || !body) {
+      try {
+        rawBody = new Uint8Array(await req.arrayBuffer());
+      } catch {
+        /* no body */
+      }
+    }
+  }
+
+  const args: RouteHandlerArgs = { body, rawBody, headers, pathParams };
+
+  try {
+    const result = await handler(args);
+    if (result instanceof RouteResponse) {
+      return new Response(result.body, {
+        status: result.status ?? successStatus,
+        headers: result.headers,
+      });
+    }
+    if (
+      result instanceof ReadableStream ||
+      result instanceof Uint8Array ||
+      typeof result === "string"
+    ) {
+      return new Response(result as BodyInit, { status: successStatus });
+    }
+    return Response.json(result, { status: successStatus });
+  } catch (err) {
+    if (err instanceof RouteError) {
+      return Response.json(
+        { error: { code: err.code, message: err.message } },
+        { status: err.statusCode },
+      );
+    }
+    throw err;
+  }
+}

package/src/__tests__/helpers/channel-test-adapter.ts

@@ -0,0 +1,161 @@
+/**
+ * Backward-compatible test adapter for channel route handlers.
+ *
+ * The production handlers now accept {@link RouteHandlerArgs} and resolve
+ * deps via direct module imports. This adapter preserves the old
+ * `(Request, processMessage?, assistantId?)` call convention so existing
+ * tests don't need 200+ mechanical call-site changes.
+ *
+ * ## processMessage mocking
+ *
+ * The inbound handler imports `processMessage` directly from
+ * `daemon/process-message.js`. Tests that need to intercept or spy on
+ * processMessage should call `setAdapterProcessMessage(fn)` before
+ * invoking `handleChannelInbound`. The mock.module below routes all
+ * processMessage calls through the adapter's override when set; when
+ * unset it returns a safe no-op result.
+ *
+ * Tests should reset the override in `beforeEach` via
+ * `setAdapterProcessMessage(undefined)`.
+ */
+
+import { mock } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Module-level processMessage + approval-generators mock.
+//
+// Declared here (in the adapter) rather than in each test file so that
+// the mock is registered BEFORE any transitive import of the handler
+// module (which statically imports process-message.js). Because this
+// file is imported by test files, the mock.module calls execute when
+// the adapter module is first loaded — before the handler's own import
+// of process-message.js resolves.
+// ---------------------------------------------------------------------------
+
+let _adapterProcessMessage: ((...args: any[]) => any) | undefined;
+
+/**
+ * Set or clear the processMessage override used by the adapter's mock.
+ * Pass `undefined` to reset to the default no-op stub.
+ */
+export function setAdapterProcessMessage(
+  fn: ((...args: any[]) => any) | undefined,
+): void {
+  _adapterProcessMessage = fn;
+}
+
+mock.module("../../daemon/process-message.js", () => ({
+  resolveTurnChannel: () => "telegram",
+  resolveTurnInterface: () => "telegram",
+  makePendingInteractionRegistrar: () => () => {},
+  prepareConversationForMessage: async () => ({}),
+  processMessage: (...args: unknown[]) => {
+    if (_adapterProcessMessage) return _adapterProcessMessage(...args);
+    return Promise.resolve({ messageId: `mock-msg-adapter-${Date.now()}` });
+  },
+}));
+
+mock.module("../../daemon/approval-generators.js", () => ({
+  createApprovalCopyGenerator: () => undefined,
+  createApprovalConversationGenerator: () => undefined,
+}));
+
+import type {
+  ApprovalConversationGenerator,
+  ApprovalCopyGenerator,
+  GuardianActionCopyGenerator,
+  GuardianFollowUpConversationGenerator,
+  MessageProcessor,
+} from "../../runtime/http-types.js";
+import {
+  handleChannelDeliveryAck as _handleChannelDeliveryAck,
+  handleListDeadLetters as _handleListDeadLetters,
+  handleReplayDeadLetters as _handleReplayDeadLetters,
+} from "../../runtime/routes/channel-delivery-routes.js";
+import {
+  handleChannelInbound as _handleChannelInbound,
+  handleDeleteConversation as _handleDeleteConversation,
+} from "../../runtime/routes/channel-inbound-routes.js";
+import { RouteError } from "../../runtime/routes/errors.js";
+
+/**
+ * Wrap a transport-agnostic handler call, converting RouteError throws
+ * back to Response objects so existing tests that assert on `.status`
+ * and `.json()` continue to work.
+ */
+async function wrapHandler<T>(fn: () => T | Promise<T>): Promise<Response> {
+  try {
+    const result = await fn();
+    if (result === null || result === undefined) {
+      return new Response(null, { status: 204 });
+    }
+    return Response.json(result);
+  } catch (err) {
+    if (err instanceof RouteError) {
+      return Response.json(
+        { error: { code: err.code, message: err.message } },
+        { status: err.statusCode },
+      );
+    }
+    throw err;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// handleChannelInbound adapter
+// ---------------------------------------------------------------------------
+
+export async function handleChannelInbound(
+  req: Request,
+  _processMessage?: MessageProcessor,
+  _assistantId?: string,
+  _approvalCopyGenerator?: ApprovalCopyGenerator,
+  _approvalConversationGenerator?: ApprovalConversationGenerator,
+  _guardianActionCopyGenerator?: GuardianActionCopyGenerator,
+  _guardianFollowUpConversationGenerator?: GuardianFollowUpConversationGenerator,
+): Promise<Response> {
+  const body = await req.json();
+  return wrapHandler(() => _handleChannelInbound({ body }));
+}
+
+// ---------------------------------------------------------------------------
+// handleDeleteConversation adapter
+// ---------------------------------------------------------------------------
+
+export async function handleDeleteConversation(
+  req: Request,
+  _assistantId?: string,
+): Promise<Response> {
+  const body = await req.json();
+  return wrapHandler(() => _handleDeleteConversation({ body }));
+}
+
+// ---------------------------------------------------------------------------
+// handleChannelDeliveryAck adapter
+// ---------------------------------------------------------------------------
+
+export async function handleChannelDeliveryAck(
+  req: Request,
+): Promise<Response> {
+  const body = await req.json();
+  return wrapHandler(() => _handleChannelDeliveryAck({ body }));
+}
+
+// ---------------------------------------------------------------------------
+// handleListDeadLetters adapter
+// ---------------------------------------------------------------------------
+
+export function handleListDeadLetters(): Response {
+  const result = _handleListDeadLetters();
+  return Response.json(result);
+}
+
+// ---------------------------------------------------------------------------
+// handleReplayDeadLetters adapter
+// ---------------------------------------------------------------------------
+
+export async function handleReplayDeadLetters(req: Request): Promise<Response> {
+  const body = await req.json();
+  return wrapHandler(() => _handleReplayDeadLetters({ body }));
+}
+

package/src/__tests__/helpers/gateway-classify-mock.ts

@@ -0,0 +1,67 @@
+/**
+ * Shared test helper: mock the IPC transport layer so tests can run
+ * without a live gateway Unix socket.
+ *
+ * Mocks `@vellumai/gateway-client/ipc-client` — the lowest transport
+ * layer — so that `gateway-client.ts` and everything above it (including
+ * `ipcClassifyRisk`, response validation, singleton management) runs
+ * for real.
+ *
+ * Tests register expected IPC responses via `mockIpcResponse()` before
+ * exercising the code under test. Unmatched calls return undefined
+ * (one-shot `ipcCall`) or reject (persistent client).
+ *
+ * @example
+ *   // In your test file:
+ *   import { installIpcMock, mockIpcResponse } from "./helpers/gateway-classify-mock.js";
+ *   installIpcMock();
+ *
+ *   mockIpcResponse("classify_risk",
+ *     { risk: "low", reason: "ls", matchType: "shell" });
+ *
+ *   const result = await classifyRisk("bash", { command: "ls" });
+ */
+
+import { mock } from "bun:test";
+
+// ── Response registry ───────────────────────────────────────────────────────
+
+const responses = new Map<string, unknown>();
+
+/**
+ * Register a static response for an IPC method. Every call to that method
+ * returns the same response regardless of params.
+ */
+export function mockIpcResponse(method: string, response: unknown): void {
+  responses.set(method, response);
+}
+
+/** Clear all registered responses. */
+export function clearIpcMocks(): void {
+  responses.clear();
+}
+
+function handleCall(method: string): unknown {
+  const response = responses.get(method);
+  if (response !== undefined) return response;
+  return undefined;
+}
+
+// ── Mock installation ───────────────────────────────────────────────────────
+
+/**
+ * Install the IPC transport mock. Call this at the top of your test file
+ * (before any imports that transitively load gateway-client.ts).
+ */
+export function installIpcMock(): void {
+  mock.module("@vellumai/gateway-client/ipc-client", () => ({
+    ipcCall: async (_socketPath: string, method: string) => handleCall(method),
+
+    PersistentIpcClient: class MockPersistentIpcClient {
+      async call(method: string): Promise<unknown> {
+        return handleCall(method);
+      }
+      destroy(): void {}
+    },
+  }));
+}

package/src/__tests__/helpers/mock-logger.ts

@@ -0,0 +1,36 @@
+/**
+ * Shared test helper: a recursive no-op logger mock.
+ *
+ * The naive pattern that several tests use — `getLogger: () => new Proxy({},
+ * { get: () => () => {} })` — silently breaks when any consumer calls
+ * `log.child({...}).<method>()`. The `.child()` thunk returns `undefined`,
+ * so `undefined.<method>` throws a TypeError. This usually doesn't surface in
+ * isolation, because the success path of most code under test doesn't call
+ * `.child()`. But Bun's `mock.module()` DOES NOT hoist above static imports
+ * in the same file: the test file's own `import { runAgentLoopImpl } from …`
+ * statement triggers a transitive import chain that calls `getLogger` AT
+ * MODULE-INIT TIME, BEFORE the test file's `mock.module(...)` runs. If a
+ * previous test file in the same `bun test` run installed a non-recursive
+ * proxy mock for `util/logger.js`, that mock is now active for every newly
+ * loaded module — and any path that touches `log.child(...)` blows up.
+ *
+ * This helper installs a recursive proxy whose `child` access returns another
+ * proxy of the same shape, so every `log.<method>(...)` and
+ * `log.child({...}).<method>(...)` call is a safe no-op regardless of how
+ * deep callers nest.
+ *
+ * Usage:
+ *
+ *   import { mock } from "bun:test";
+ *   import { makeMockLogger } from "./helpers/mock-logger.js";
+ *
+ *   mock.module("../util/logger.js", () => ({
+ *     getLogger: () => makeMockLogger(),
+ *   }));
+ */
+
+export function makeMockLogger(): unknown {
+  return new Proxy({} as Record<string, unknown>, {
+    get: (_target, prop) => (prop === "child" ? makeMockLogger : () => {}),
+  });
+}