@vellumai/assistant 0.11.5 → 0.11.6-staging.1

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

@@ -319,9 +319,9 @@ mock.module("../../../cli/lib/toggle-plugin.js", () => ({
   enablePlugin: enablePluginSpy,
 }));
 
-// Spy on the plugin-schedule reconcile the disable handler pokes. The handler
-// imports it lazily at call time, so this mock intercepts the dynamic import
-// and keeps the reconciler's persistence graph out of the test.
+// Spy on the plugin-schedule reconcile so a toggle cannot silently go back
+// to poking it from the route. Enable and disable both await the source
+// reconcile, which converges schedules itself.
 const reconcilePluginSchedulesSpy = mock(() => Promise.resolve());
 
 mock.module("../../../schedule/plugin-schedule-reconciler.js", () => ({
@@ -2597,27 +2597,10 @@ async function invokeEnable(
   return (await enableHandler(args)) as { ok: boolean };
 }
 
-function invokeDisable(args: RouteHandlerArgs = {}): { ok: boolean } {
-  return disableHandler(args) as { ok: boolean };
-}
-
-/**
- * Wait for a toggle handler's fire-and-forget reconcile poke to land. The poke
- * runs off the microtask queue (the disable path also resolves a lazy
- * `import()` first), so the assertion cannot run on the handler's synchronous
- * return.
- */
-async function waitForReconcile(
-  spy: { mock: { calls: unknown[] } },
-  label: string,
-): Promise<void> {
-  for (let i = 0; i < 50; i++) {
-    if (spy.mock.calls.length > 0) {
-      return;
-    }
-    await new Promise((resolve) => setTimeout(resolve, 2));
-  }
-  throw new Error(`${label} was never triggered`);
+async function invokeDisable(
+  args: RouteHandlerArgs = {},
+): Promise<{ ok: boolean }> {
+  return (await disableHandler(args)) as { ok: boolean };
 }
 
 /** Assert the spy received exactly one sync_changed carrying `plugins:list`. */
@@ -2745,42 +2728,38 @@ describe("POST /v1/plugins/:name/disable", () => {
     reconcilePluginSourcesNowSpy.mockClear();
   });
 
-  test("reconciles plugin-declared schedules so the plugin's rows disarm now", async () => {
+  test("awaits the source reconcile so shutdown runs before the route returns", async () => {
     disablePluginSpy.mockImplementation((name) =>
       toggleResult(name, "disable"),
     );
 
-    invokeDisable({ pathParams: { name: "simple-memory" } });
+    await invokeDisable({ pathParams: { name: "simple-memory" } });
 
-    // Without this poke the rows stay armed until the reconciler's next
-    // backstop sweep. Disable stays on the schedule poke: the sentinel filters
-    // the plugin out at read time, and a source reconcile here would run its
-    // shutdown hooks.
-    await waitForReconcile(
-      reconcilePluginSchedulesSpy,
-      "plugin schedule reconcile",
-    );
-    expect(reconcilePluginSourcesNowSpy).not.toHaveBeenCalled();
+    // The sentinel hides tools at read time, but `init` already opened
+    // in-process work (a live subscribe, a poll worker). The source
+    // reconcile is what runs `shutdown`. It converges schedules itself, so
+    // the route does not poke them separately.
+    expect(reconcilePluginSourcesNowSpy).toHaveBeenCalledTimes(1);
+    expect(reconcilePluginSchedulesSpy).not.toHaveBeenCalled();
   });
 
-  test("a failed toggle does not poke the schedule reconcile", async () => {
+  test("a failed toggle does not run the source reconcile", async () => {
     disablePluginSpy.mockImplementation((name) => {
       throw new PluginDirectoryNotFoundError(name);
     });
 
-    expect(() => invokeDisable({ pathParams: { name: "ghost" } })).toThrow(
-      NotFoundError,
-    );
-    await new Promise((resolve) => setTimeout(resolve, 10));
-    expect(reconcilePluginSchedulesSpy).not.toHaveBeenCalled();
+    await expect(
+      invokeDisable({ pathParams: { name: "ghost" } }),
+    ).rejects.toThrow(NotFoundError);
+    expect(reconcilePluginSourcesNowSpy).not.toHaveBeenCalled();
   });
 
-  test("disables the plugin and broadcasts sync_changed(plugins:list)", () => {
+  test("disables the plugin and broadcasts sync_changed(plugins:list)", async () => {
     disablePluginSpy.mockImplementation((name) =>
       toggleResult(name, "disable"),
     );
 
-    const result = invokeDisable({ pathParams: { name: "simple-memory" } });
+    const result = await invokeDisable({ pathParams: { name: "simple-memory" } });
 
     expect(result).toEqual({ ok: true });
     expect(disablePluginSpy.mock.calls[0]?.[0]).toBe("simple-memory");
@@ -2789,12 +2768,12 @@ describe("POST /v1/plugins/:name/disable", () => {
     expectPluginsListBroadcast();
   });
 
-  test("threads x-vellum-client-id into the published event's originClientId", () => {
+  test("threads x-vellum-client-id into the published event's originClientId", async () => {
     disablePluginSpy.mockImplementation((name) =>
       toggleResult(name, "disable"),
     );
 
-    invokeDisable({
+    await invokeDisable({
       pathParams: { name: "simple-memory" },
       headers: { "x-vellum-client-id": "client-xyz" },
     });
@@ -2806,35 +2785,35 @@ describe("POST /v1/plugins/:name/disable", () => {
     });
   });
 
-  test("PluginAlreadyInStateException → ConflictError (409), no broadcast", () => {
+  test("PluginAlreadyInStateException → ConflictError (409), no broadcast", async () => {
     disablePluginSpy.mockImplementation((name) => {
       throw new PluginAlreadyInStateException(name, "disable");
     });
 
-    expect(() =>
+    await expect(
       invokeDisable({ pathParams: { name: "simple-memory" } }),
-    ).toThrow(ConflictError);
+    ).rejects.toThrow(ConflictError);
     expect(broadcastMessageSpy).not.toHaveBeenCalled();
   });
 
-  test("PluginDirectoryNotFoundError → NotFoundError (404)", () => {
+  test("PluginDirectoryNotFoundError → NotFoundError (404)", async () => {
     disablePluginSpy.mockImplementation((name) => {
       throw new PluginDirectoryNotFoundError(name);
     });
 
-    expect(() => invokeDisable({ pathParams: { name: "ghost" } })).toThrow(
-      NotFoundError,
-    );
+    await expect(
+      invokeDisable({ pathParams: { name: "ghost" } }),
+    ).rejects.toThrow(NotFoundError);
   });
 
-  test("InvalidPluginNameError → BadRequestError (400)", () => {
+  test("InvalidPluginNameError → BadRequestError (400)", async () => {
     disablePluginSpy.mockImplementation(() => {
       throw new ToggleInvalidPluginNameError("../escape");
     });
 
-    expect(() => invokeDisable({ pathParams: { name: "../escape" } })).toThrow(
-      BadRequestError,
-    );
+    await expect(
+      invokeDisable({ pathParams: { name: "../escape" } }),
+    ).rejects.toThrow(BadRequestError);
   });
 });
 

package/src/runtime/routes/__tests__/watch-routes-guardian-cache.test.ts

@@ -0,0 +1,139 @@
+/**
+ * A watch session's principal lookup against a stale guardian-delivery cache.
+ *
+ * The cache keeps a successful read that found no binding, and a gateway-side
+ * binding write does not invalidate it, so the read a session start depends on
+ * has to force a refresh or a first run fails for the cache's whole TTL. The
+ * guardian reader is mocked here rather than in the main watch-routes suite so
+ * the substitution stays inside this file.
+ */
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { GuardianDelivery } from "@vellumai/gateway-client";
+
+let cachedResult: GuardianDelivery[] | null = null;
+let freshResult: GuardianDelivery[] | null = null;
+let cachedCalls = 0;
+let freshCalls = 0;
+
+// Only the two read entry points are substituted; the rest of the reader's
+// surface stays real, because other modules in this graph import from it.
+const realReader =
+  await import("../../../contacts/guardian-delivery-reader.js");
+mock.module("../../../contacts/guardian-delivery-reader.js", () => ({
+  ...realReader,
+  getGuardianDelivery: () => {
+    cachedCalls++;
+    return Promise.resolve(cachedResult);
+  },
+  getGuardianDeliveryFresh: () => {
+    freshCalls++;
+    return Promise.resolve(freshResult);
+  },
+  peekCachedGuardianDelivery: () => undefined,
+}));
+
+const { initializeDb } = await import("../../../persistence/db-init.js");
+const { WatchSessionManager } =
+  await import("../../../watch/watch-session-manager.js");
+const { WatchStreamSession, resolveWatchActorPrincipalId } =
+  await import("../watch-routes.js");
+
+await initializeDb();
+
+afterAll(() => {
+  mock.restore();
+});
+
+/** The shape `guardianForChannel` matches on for the vellum binding. */
+function guardian(principalId: string): GuardianDelivery {
+  return {
+    principalId,
+    channelType: "vellum",
+    status: "active",
+  } as unknown as GuardianDelivery;
+}
+
+/** A socket that keeps the frame types the session sent it. */
+function newSocket() {
+  const types: string[] = [];
+  return {
+    types,
+    send: (data: string) => {
+      types.push((JSON.parse(data) as { type: string }).type);
+    },
+    close: () => {},
+  };
+}
+
+/** A transcriber that opens without reaching any provider. */
+function newTranscriber() {
+  return {
+    providerId: "deepgram" as const,
+    boundaryId: "daemon-streaming" as const,
+    start: async () => {},
+    sendAudio: () => {},
+    stop: () => {},
+  };
+}
+
+describe("watch principal lookup against a stale guardian cache", () => {
+  beforeEach(() => {
+    cachedCalls = 0;
+    freshCalls = 0;
+    cachedResult = [];
+    freshResult = [];
+  });
+
+  test("reads past an empty cached answer to the binding that now exists", async () => {
+    cachedResult = [];
+    freshResult = [guardian("guardian-just-bound")];
+
+    expect(await resolveWatchActorPrincipalId()).toBe("guardian-just-bound");
+    expect(freshCalls).toBe(1);
+    expect(cachedCalls).toBe(0);
+  });
+
+  test("a session started after the binding appears reaches ready", async () => {
+    // The cache still holds the empty answer from before the guardian was
+    // bound, which is the state a first run starts in.
+    cachedResult = [];
+    freshResult = [guardian("guardian-just-bound")];
+
+    const manager = new WatchSessionManager({
+      observe: async () => ({ ok: true, axTree: "Window: Editor" }),
+    });
+    const ws = newSocket();
+    const session = new WatchStreamSession(ws, {
+      mimeType: "audio/webm",
+      manager,
+      resolveTranscriber: async () => newTranscriber(),
+    });
+
+    await session.start();
+
+    // The handshake rather than the exact sequence: the session reads the
+    // screen as it opens, so its capture acknowledgement lands in here too.
+    expect(ws.types[0]).toBe("ready");
+    expect(ws.types).not.toContain("error");
+    expect(manager.isActive()).toBe(true);
+
+    session.destroy();
+  });
+
+  test("no binding at all still fails closed", async () => {
+    cachedResult = [];
+    freshResult = [];
+
+    const ws = newSocket();
+    const session = new WatchStreamSession(ws, {
+      mimeType: "audio/webm",
+      manager: new WatchSessionManager(),
+      resolveTranscriber: async () => newTranscriber(),
+    });
+
+    await session.start();
+
+    expect(ws.types).toEqual(["error", "closed"]);
+  });
+});