@vellumai/assistant 0.11.7 → 0.11.8-staging.1

package/src/runtime/routes/__tests__/contact-record-prompt-route.test.ts

@@ -0,0 +1,303 @@
+/**
+ * Unit tests for the daemon `contacts_record_prompt` route.
+ *
+ * The route is the parked half of a guardian-confirmed contact write: it
+ * broadcasts the proposal and waits. It must never write, and the promise it
+ * parks must be resolvable only by the gateway's `resolve_contact_prompt`
+ * callback, which is what keeps an unattended assistant from changing the
+ * contact graph.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+type Broadcast = Record<string, unknown>;
+
+let broadcasts: Broadcast[] = [];
+
+const broadcastMock = mock((message: Broadcast) => {
+  broadcasts.push(message);
+});
+
+const actualHub = await import("../../assistant-event-hub.js");
+mock.module("../../assistant-event-hub.js", () => ({
+  ...actualHub,
+  broadcastMessage: broadcastMock,
+}));
+
+const { CONTACT_PROMPT_ROUTES } = await import("../contact-prompt-routes.js");
+
+function routeFor(operationId: string) {
+  const route = CONTACT_PROMPT_ROUTES.find(
+    (r) => r.operationId === operationId,
+  );
+  if (!route) {
+    throw new Error(`route ${operationId} not registered`);
+  }
+  return route;
+}
+
+const recordPrompt = routeFor("contacts_record_prompt");
+const resolvePrompt = routeFor("resolve_contact_prompt");
+const claimPrompt = routeFor("contact_prompt_claim");
+
+/** The broadcast for the only prompt parked so far. */
+function parkedRequestId(): string {
+  const message = broadcasts.find((b) => b.type === "contact_record_request");
+  expect(message).toBeDefined();
+  return message!.requestId as string;
+}
+
+describe("contacts_record_prompt", () => {
+  beforeEach(() => {
+    broadcasts = [];
+    broadcastMock.mockClear();
+  });
+
+  test("broadcasts the proposal and stays parked until the guardian answers", async () => {
+    const pending = recordPrompt.handler({
+      body: {
+        operation: "create",
+        displayName: "Alice",
+        notes: "Dentist",
+        label: "Add a contact",
+      },
+    }) as Promise<Record<string, unknown>>;
+
+    // Settled only by the gateway callback: a bare await here would hang.
+    let settled = false;
+    void pending.then(() => {
+      settled = true;
+    });
+    await Promise.resolve();
+    expect(settled).toBe(false);
+
+    const message = broadcasts.find((b) => b.type === "contact_record_request");
+    expect(message).toBeDefined();
+    expect(message!.operation).toBe("create");
+    expect(message!.displayName).toBe("Alice");
+    expect(message!.notes).toBe("Dentist");
+    expect(message!.label).toBe("Add a contact");
+    expect(typeof message!.requestId).toBe("string");
+
+    resolvePrompt.handler({
+      body: { requestId: parkedRequestId(), contactId: "ct_new" },
+    });
+
+    expect(await pending).toEqual({ ok: true, contactId: "ct_new" });
+
+    // Every client saw this form, so every client is told it is over.
+    expect(
+      broadcasts.find((b) => b.type === "contact_form_closed"),
+    ).toMatchObject({ reason: "answered" });
+  });
+
+  test("a dismissal closes the form on the clients that did not dismiss it", async () => {
+    const pending = recordPrompt.handler({
+      body: { operation: "create", displayName: "Alice" },
+    }) as Promise<Record<string, unknown>>;
+    const requestId = parkedRequestId();
+
+    resolvePrompt.handler({
+      body: { requestId, error: "Cancelled by user" },
+    });
+    await pending;
+
+    expect(
+      broadcasts.find((b) => b.type === "contact_form_closed"),
+    ).toMatchObject({ requestId, reason: "cancelled" });
+  });
+
+  test("carries the gateway's error back to the caller", async () => {
+    const pending = recordPrompt.handler({
+      body: { operation: "delete", contactId: "ct_1" },
+    }) as Promise<Record<string, unknown>>;
+
+    resolvePrompt.handler({
+      body: { requestId: parkedRequestId(), error: "Cancelled by user" },
+    });
+
+    expect(await pending).toEqual({ ok: false, error: "Cancelled by user" });
+  });
+
+  test("update and delete require a contact id, and broadcast nothing without one", async () => {
+    for (const operation of ["update", "delete"]) {
+      broadcasts = [];
+      const result = (await recordPrompt.handler({
+        body: { operation, displayName: "Alice" },
+      })) as Record<string, unknown>;
+
+      expect(result.ok).toBe(false);
+      expect(result.error).toBe(`contactId is required to ${operation}`);
+      expect(broadcasts).toHaveLength(0);
+    }
+  });
+
+  test("rejects an operation outside create/update/delete", async () => {
+    expect(() =>
+      recordPrompt.handler({ body: { operation: "promote" } }),
+    ).toThrow();
+    expect(broadcasts).toHaveLength(0);
+  });
+
+  test("only the first claim on a form is granted", async () => {
+    const pending = recordPrompt.handler({
+      body: { operation: "create", displayName: "Alice" },
+    }) as Promise<Record<string, unknown>>;
+    const requestId = parkedRequestId();
+
+    // Two clients answering the same broadcast. The daemon holds the only
+    // record of which forms are open, so it is what settles the race.
+    // A granted claim carries the window its write has to report back in.
+    expect(claimPrompt.handler({ body: { requestId } })).toMatchObject({
+      claimed: true,
+      settleMs: expect.any(Number),
+    });
+    expect(claimPrompt.handler({ body: { requestId } })).toEqual({
+      claimed: false,
+      reason: "already_claimed",
+    });
+
+    resolvePrompt.handler({ body: { requestId, contactId: "ct_new" } });
+    await pending;
+  });
+
+  test("a claim on a form nobody is waiting on is refused as unknown", () => {
+    expect(
+      claimPrompt.handler({ body: { requestId: "never-parked" } }),
+    ).toEqual({
+      claimed: false,
+      reason: "unknown",
+    });
+  });
+
+  test("a resolved form can no longer be claimed", async () => {
+    const pending = recordPrompt.handler({
+      body: { operation: "create", displayName: "Alice" },
+    }) as Promise<Record<string, unknown>>;
+    const requestId = parkedRequestId();
+
+    claimPrompt.handler({ body: { requestId } });
+    resolvePrompt.handler({ body: { requestId, contactId: "ct_new" } });
+    await pending;
+
+    // The entry is gone once the call it was holding has returned, so a late
+    // submission has nothing to write for.
+    expect(claimPrompt.handler({ body: { requestId } })).toEqual({
+      claimed: false,
+      reason: "unknown",
+    });
+  });
+
+  test("the caller's timeout is what closes the form", async () => {
+    const pending = recordPrompt.handler({
+      body: { operation: "create", displayName: "Alice", timeoutMs: 60 },
+    }) as Promise<Record<string, unknown>>;
+    const requestId = parkedRequestId();
+
+    // A form that outlived the command that opened it could still be answered,
+    // writing something the caller was already told had failed.
+    expect(await pending).toEqual({ ok: false, error: "Prompt timed out" });
+
+    // And it is gone, so a late answer has nothing to claim.
+    expect(claimPrompt.handler({ body: { requestId } })).toEqual({
+      claimed: false,
+      reason: "unknown",
+    });
+
+    // Clients are told, so the card comes down rather than offering to submit
+    // an answer that would now be refused.
+    expect(
+      broadcasts.find((b) => b.type === "contact_form_closed"),
+    ).toMatchObject({ requestId, reason: "timed_out" });
+  });
+
+  test("claiming a form stops its deadline, so a slow write is not reported as a timeout", async () => {
+    const pending = recordPrompt.handler({
+      body: { operation: "delete", contactId: "ct_1", timeoutMs: 60 },
+    }) as Promise<Record<string, unknown>>;
+    const requestId = parkedRequestId();
+
+    // Somebody answered right at the deadline and the write is in flight. The
+    // original timer firing now would tell the caller nothing happened while
+    // the delete went on to commit.
+    expect(claimPrompt.handler({ body: { requestId } })).toMatchObject({
+      claimed: true,
+    });
+
+    let settled = false;
+    void pending.then(() => {
+      settled = true;
+    });
+    await new Promise((r) => setTimeout(r, 120));
+    expect(settled).toBe(false);
+    expect(broadcasts.some((b) => b.type === "contact_form_closed")).toBe(
+      false,
+    );
+
+    resolvePrompt.handler({ body: { requestId, contactId: "ct_1" } });
+    expect(await pending).toEqual({ ok: true, contactId: "ct_1" });
+  });
+
+  test("a second form is refused rather than replacing the first", async () => {
+    const first = recordPrompt.handler({
+      body: { operation: "create", displayName: "Alice" },
+    }) as Promise<Record<string, unknown>>;
+    const firstRequestId = parkedRequestId();
+
+    // A client shows one contact form at a time, so a second broadcast would
+    // take the first's card away and leave its command waiting on a form
+    // nobody can answer.
+    const second = (await recordPrompt.handler({
+      body: { operation: "create", displayName: "Bob" },
+    })) as Record<string, unknown>;
+
+    expect(second.ok).toBe(false);
+    expect(String(second.error)).toContain("already open");
+    expect(
+      broadcasts.filter((b) => b.type === "contact_record_request"),
+    ).toHaveLength(1);
+
+    resolvePrompt.handler({
+      body: { requestId: firstRequestId, contactId: "ct_new" },
+    });
+    await first;
+  });
+
+  test("a form that has been answered does not block the next one", async () => {
+    const first = recordPrompt.handler({
+      body: { operation: "create", displayName: "Alice" },
+    }) as Promise<Record<string, unknown>>;
+    const firstRequestId = parkedRequestId();
+    claimPrompt.handler({ body: { requestId: firstRequestId } });
+
+    // Claimed means somebody answered it; its write is on its way and the
+    // guardian's card is done. The next command should not be refused.
+    const second = recordPrompt.handler({
+      body: { operation: "create", displayName: "Bob" },
+    }) as Promise<Record<string, unknown>>;
+
+    expect(
+      broadcasts.filter((b) => b.type === "contact_record_request"),
+    ).toHaveLength(2);
+
+    resolvePrompt.handler({
+      body: { requestId: firstRequestId, contactId: "ct_new" },
+    });
+    await first;
+    const secondId = (
+      broadcasts.filter((b) => b.type === "contact_record_request")[1] as {
+        requestId: string;
+      }
+    ).requestId;
+    resolvePrompt.handler({ body: { requestId: secondId, contactId: "ct_2" } });
+    await second;
+  });
+
+  test("a resolve for an unknown request is ignored", () => {
+    expect(
+      resolvePrompt.handler({
+        body: { requestId: "never-parked", contactId: "ct_x" },
+      }),
+    ).toEqual({ resolved: false });
+  });
+});

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

@@ -4,7 +4,7 @@
  * The route handlers run inside the daemon and own the monitor process. We mock
  * monitoring-control, the config loader, and the sample ring buffer so the
  * tests assert handler behaviour:
- *   - start spawns as a daemon child (detached:false) and throws on spawn
+ *   - start spawns the worker and throws on spawn
  *     failure.
  *   - stop signals the monitor (a runtime pause — the daemon respawns it at
  *     the next boot).
@@ -19,7 +19,7 @@ import { getMonitoringPidPath } from "../../../util/platform.js";
 class FakeSpawnError extends Error {}
 
 let spawnImpl: () => Promise<{ pid: number; alreadyRunning: boolean }>;
-let spawnArgs: Array<{ detached?: boolean; terminateOnTimeout?: boolean }> = [];
+let spawnArgs: Array<{ terminateOnTimeout?: boolean } | undefined> = [];
 let stopImpl: () => { status: "running" | "not_running"; pid?: number };
 let monitoringProbe: { status: "running" | "not_running"; pid?: number } = {
   status: "not_running",
@@ -29,7 +29,6 @@ let latestSample: ResourceSample | null = null;
 mock.module("../../../monitoring/control.js", () => ({
   MonitoringWorkerSpawnError: FakeSpawnError,
   spawnMonitoringWorkerProcess: async (opts: {
-    detached?: boolean;
     terminateOnTimeout?: boolean;
   }) => {
     spawnArgs.push(opts);
@@ -71,7 +70,7 @@ describe("monitoring_start", () => {
 
     const res = await handler("monitoring_start")();
 
-    expect(spawnArgs).toEqual([{ detached: false, terminateOnTimeout: true }]);
+    expect(spawnArgs).toEqual([{ terminateOnTimeout: true }]);
     expect(res).toEqual({
       pid: 4242,
       alreadyRunning: false,

package/src/runtime/routes/__tests__/pending-interactions-route.test.ts

@@ -23,7 +23,13 @@ import type { RouteDefinition, RouteHandlerArgs } from "../types.js";
 // The conversation-key lookup is the only path into the unresolvable-conversation
 // early return, and it reads SQLite. Stub it so this stays a unit test of the
 // response shape. Imported dynamically below so the stub is in place first.
+// The factory spreads the real module: the route module's import graph pulls
+// other named exports from this store, and a partial factory fails at import
+// time the moment any transitive module adds one.
+const actualConversationKeyStore =
+  await import("../../../persistence/conversation-key-store.js");
 mock.module("../../../persistence/conversation-key-store.js", () => ({
+  ...actualConversationKeyStore,
   getConversationByKey: () => undefined,
 }));
 

package/src/runtime/routes/__tests__/route-host-worker-routes.test.ts

@@ -3,7 +3,7 @@
  *
  * The handlers run inside the daemon and manage the route host process. We mock
  * the route host control surface so the tests assert handler behaviour:
- *   - start spawns as a daemon child (detached:false) and throws on failure.
+ *   - start spawns the worker and throws on failure.
  *   - stop signals the host and reports its prior state.
  *   - status reports the host process liveness.
  */
@@ -15,7 +15,7 @@ import { getProcPidPath } from "../../../util/platform.js";
 class FakeSpawnError extends Error {}
 
 let spawnImpl: () => Promise<{ pid: number; alreadyRunning: boolean }>;
-let spawnArgs: Array<{ detached?: boolean; terminateOnTimeout?: boolean }> = [];
+let spawnArgs: Array<{ terminateOnTimeout?: boolean } | undefined> = [];
 let stopImpl: () => { status: "running" | "not_running"; pid?: number };
 let workerProbe: { status: "running" | "not_running"; pid?: number } = {
   status: "not_running",
@@ -24,7 +24,6 @@ let workerProbe: { status: "running" | "not_running"; pid?: number } = {
 mock.module("../../../routes/control.js", () => ({
   RouteHostSpawnError: FakeSpawnError,
   spawnRouteHostWorkerProcess: async (opts: {
-    detached?: boolean;
     terminateOnTimeout?: boolean;
   }) => {
     spawnArgs.push(opts);
@@ -57,7 +56,7 @@ describe("routes_worker_start", () => {
 
     const res = await handler("routes_worker_start")();
 
-    expect(spawnArgs).toEqual([{ detached: false }]);
+    expect(spawnArgs).toEqual([undefined]);
     expect(res).toEqual({
       pid: 4242,
       alreadyRunning: false,

package/src/runtime/routes/__tests__/schedule-worker-routes.test.ts

@@ -3,7 +3,7 @@
  *
  * The route handlers run inside the daemon and manage the worker process. We
  * mock schedule worker-control so the tests assert handler behaviour:
- *   - start spawns as a daemon child (detached:false) and throws on failure.
+ *   - start spawns the worker and throws on failure.
  *   - stop signals the worker and reports its prior state.
  *   - status reports the worker process liveness.
  */
@@ -15,7 +15,7 @@ import { getScheduleWorkerPidPath } from "../../../util/platform.js";
 class FakeSpawnError extends Error {}
 
 let spawnImpl: () => Promise<{ pid: number; alreadyRunning: boolean }>;
-let spawnArgs: Array<{ detached?: boolean; terminateOnTimeout?: boolean }> = [];
+let spawnArgs: Array<{ terminateOnTimeout?: boolean } | undefined> = [];
 let stopImpl: () => { status: "running" | "not_running"; pid?: number };
 let workerProbe: { status: "running" | "not_running"; pid?: number } = {
   status: "not_running",
@@ -24,8 +24,7 @@ const adminStoppedCalls: boolean[] = [];
 
 mock.module("../../../schedule/worker-control.js", () => ({
   ScheduleWorkerSpawnError: FakeSpawnError,
-  spawnScheduleWorkerProcess: async (opts: {
-    detached?: boolean;
+  spawnScheduleWorkerProcess: async (opts?: {
     terminateOnTimeout?: boolean;
   }) => {
     spawnArgs.push(opts);
@@ -57,12 +56,12 @@ beforeEach(() => {
 });
 
 describe("schedules_worker_start", () => {
-  test("spawns as a daemon child and returns the PID", async () => {
+  test("spawns the worker and returns the PID", async () => {
     spawnImpl = async () => ({ pid: 4242, alreadyRunning: false });
 
     const res = await handler("schedules_worker_start")();
 
-    expect(spawnArgs).toEqual([{ detached: false }]);
+    expect(spawnArgs).toEqual([undefined]);
     expect(res).toEqual({
       pid: 4242,
       alreadyRunning: false,

package/src/runtime/routes/acp-routes-list.test.ts

@@ -153,3 +153,61 @@ describe("GET /v1/acp/sessions — SQL pad amount", () => {
     expect(capturedLimits).toEqual([24]);
   });
 });
+
+describe("GET /v1/acp/sessions: the marker lookup stays off the common path", () => {
+  test("a conversation whose history fits the page issues no extra query", async () => {
+    // Most conversations have never had a credential failure. A short read
+    // means every row is already in hand, which is proof enough that no marker
+    // is hiding outside the page, so the database is not asked to confirm the
+    // absence on every list.
+    inMemoryStates.clear();
+    capturedLimits.length = 0;
+    getDb()
+      .insert(acpSessionHistory)
+      .values({
+        id: "short-1",
+        agentId: "claude",
+        acpSessionId: "proto-short-1",
+        parentConversationId: "conv-short",
+        startedAt: 1,
+        status: "completed",
+        eventLogJson: "[]",
+      })
+      .run();
+
+    const handler = getListHandler();
+    await handler({
+      queryParams: { conversationId: "conv-short", limit: "10" },
+    });
+
+    expect(capturedLimits).toEqual([10]);
+  });
+
+  test("a full page does look, because a marker could be beyond it", async () => {
+    inMemoryStates.clear();
+    capturedLimits.length = 0;
+    for (let i = 0; i < 3; i++) {
+      getDb()
+        .insert(acpSessionHistory)
+        .values({
+          id: `full-${i}`,
+          agentId: "claude",
+          acpSessionId: `proto-full-${i}`,
+          parentConversationId: "conv-full",
+          startedAt: 10 + i,
+          status: "completed",
+          eventLogJson: "[]",
+        })
+        .run();
+    }
+
+    const handler = getListHandler();
+    await handler({
+      queryParams: { conversationId: "conv-full", limit: "2" },
+    });
+
+    // The page query, then the bounded scan for a marker beyond it.
+    expect(capturedLimits.length).toBeGreaterThan(1);
+    expect(capturedLimits[0]).toBe(2);
+  });
+});