@vellumai/assistant 0.7.0 → 0.7.1

package/src/__tests__/host-browser-proxy.test.ts

@@ -1,26 +1,66 @@
-import { afterEach, describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ── Module mocks ─────────────────────────────────────────────────────
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+/** Events published through the mock event hub. */
+let publishedEvents: unknown[] = [];
+let mockHasConnection = true;
+
+mock.module("../runtime/assistant-event-hub.js", () => ({
+  assistantEventHub: {
+    publish: async (event: unknown, _options?: unknown) => {
+      publishedEvents.push(event);
+    },
+    getMostRecentClientByCapability: (cap: string) =>
+      cap === "host_browser" && mockHasConnection
+        ? {
+            type: "client",
+            clientId: "test-client",
+            interfaceId: "macos",
+            capabilities: ["host_browser"],
+          }
+        : undefined,
+  },
+}));
+
+mock.module("../runtime/assistant-event.js", () => ({
+  buildAssistantEvent: (message: unknown) => ({ message }),
+}));
+
+// ── Real imports (after mocks) ───────────────────────────────────────
 
 const { HostBrowserProxy } = await import("../daemon/host-browser-proxy.js");
 
+/** Extract the ServerMessage payloads from published events. */
+function getPublishedMessages(): unknown[] {
+  return publishedEvents.map((e) => (e as { message: unknown }).message);
+}
+
+// ── Tests ────────────────────────────────────────────────────────────
+
 describe("HostBrowserProxy", () => {
   let proxy: InstanceType<typeof HostBrowserProxy>;
-  let sentMessages: unknown[];
-  let sendToClient: (msg: unknown) => void;
 
-  function setup(onInternalResolve?: (requestId: string) => void) {
-    sentMessages = [];
-    sendToClient = (msg: unknown) => sentMessages.push(msg);
-    proxy = new HostBrowserProxy(sendToClient, onInternalResolve);
-  }
+  beforeEach(() => {
+    HostBrowserProxy.reset();
+    publishedEvents = [];
+    mockHasConnection = true;
+    proxy = HostBrowserProxy.instance;
+  });
 
   afterEach(() => {
-    proxy?.dispose();
+    HostBrowserProxy.reset();
   });
 
   describe("request/resolve lifecycle (happy path)", () => {
     test("sends host_browser_request and resolves with content", async () => {
-      setup();
-
       const resultPromise = proxy.request(
         {
           cdpMethod: "Page.navigate",
@@ -29,9 +69,8 @@ describe("HostBrowserProxy", () => {
         "session-1",
       );
 
-      // Verify the request was sent to the client
-      expect(sentMessages).toHaveLength(1);
-      const sent = sentMessages[0] as Record<string, unknown>;
+      expect(getPublishedMessages()).toHaveLength(1);
+      const sent = getPublishedMessages()[0] as Record<string, unknown>;
       expect(sent.type).toBe("host_browser_request");
       expect(sent.conversationId).toBe("session-1");
       expect(sent.cdpMethod).toBe("Page.navigate");
@@ -41,11 +80,7 @@ describe("HostBrowserProxy", () => {
       const requestId = sent.requestId as string;
       expect(proxy.hasPendingRequest(requestId)).toBe(true);
 
-      // Simulate client response
-      proxy.resolve(requestId, {
-        content: "ok",
-        isError: false,
-      });
+      proxy.resolve(requestId, { content: "ok", isError: false });
 
       const result = await resultPromise;
       expect(result.content).toBe("ok");
@@ -54,8 +89,6 @@ describe("HostBrowserProxy", () => {
     });
 
     test("forwards cdpParams and cdpSessionId on the emitted envelope", async () => {
-      setup();
-
       const resultPromise = proxy.request(
         {
           cdpMethod: "Runtime.evaluate",
@@ -65,8 +98,8 @@ describe("HostBrowserProxy", () => {
         "session-1",
       );
 
-      expect(sentMessages).toHaveLength(1);
-      const sent = sentMessages[0] as Record<string, unknown>;
+      expect(getPublishedMessages()).toHaveLength(1);
+      const sent = getPublishedMessages()[0] as Record<string, unknown>;
       expect(sent.type).toBe("host_browser_request");
       expect(sent.cdpMethod).toBe("Runtime.evaluate");
       expect(sent.cdpParams).toEqual({
@@ -75,8 +108,7 @@ describe("HostBrowserProxy", () => {
       });
       expect(sent.cdpSessionId).toBe("session-abc");
 
-      const requestId = sent.requestId as string;
-      proxy.resolve(requestId, {
+      proxy.resolve(sent.requestId as string, {
         content: "Example Domain",
         isError: false,
       });
@@ -85,17 +117,13 @@ describe("HostBrowserProxy", () => {
     });
 
     test("resolves error responses correctly", async () => {
-      setup();
-
       const resultPromise = proxy.request(
         { cdpMethod: "Page.navigate", cdpParams: { url: "invalid://" } },
         "session-1",
       );
 
-      const sent = sentMessages[0] as Record<string, unknown>;
-      const requestId = sent.requestId as string;
-
-      proxy.resolve(requestId, {
+      const sent = getPublishedMessages()[0] as Record<string, unknown>;
+      proxy.resolve(sent.requestId as string, {
         content: "Navigation failed",
         isError: true,
       });
@@ -108,14 +136,12 @@ describe("HostBrowserProxy", () => {
 
   describe("pending tracking", () => {
     test("hasPendingRequest returns true after request and false after resolve", async () => {
-      setup();
-
       const resultPromise = proxy.request(
         { cdpMethod: "Page.navigate", cdpParams: { url: "https://a.test" } },
         "session-1",
       );
 
-      const sent = sentMessages[0] as Record<string, unknown>;
+      const sent = getPublishedMessages()[0] as Record<string, unknown>;
       const requestId = sent.requestId as string;
       expect(proxy.hasPendingRequest(requestId)).toBe(true);
 
@@ -128,38 +154,30 @@ describe("HostBrowserProxy", () => {
 
   describe("timeout", () => {
     test("resolves with timeout error when proxy timeout fires", async () => {
-      const resolvedIds: string[] = [];
-      setup((id) => resolvedIds.push(id));
-
       const resultPromise = proxy.request(
         {
           cdpMethod: "Page.navigate",
           cdpParams: { url: "https://slow.test" },
-          // Sub-second timeout to trigger the timer quickly.
           timeout_seconds: 0.01,
         },
         "session-1",
       );
 
-      const sent = sentMessages[0] as Record<string, unknown>;
+      const sent = getPublishedMessages()[0] as Record<string, unknown>;
       const requestId = sent.requestId as string;
       expect(proxy.hasPendingRequest(requestId)).toBe(true);
 
-      // Wait long enough for the timer (10ms) to fire.
       await new Promise((r) => setTimeout(r, 50));
 
       const result = await resultPromise;
       expect(result.isError).toBe(true);
       expect(result.content).toContain("Host browser proxy timed out");
       expect(proxy.hasPendingRequest(requestId)).toBe(false);
-      expect(resolvedIds).toEqual([requestId]);
     });
   });
 
   describe("abort signal", () => {
     test("returns immediately if signal already aborted", async () => {
-      setup();
-
       const controller = new AbortController();
       controller.abort();
 
@@ -171,13 +189,10 @@ describe("HostBrowserProxy", () => {
 
       expect(result.content).toBe("Aborted");
       expect(result.isError).toBe(true);
-      expect(sentMessages).toHaveLength(0); // No envelope emitted.
+      expect(getPublishedMessages()).toHaveLength(0);
     });
 
     test("mid-flight abort resolves with Aborted and emits host_browser_cancel", async () => {
-      const resolvedIds: string[] = [];
-      setup((id) => resolvedIds.push(id));
-
       const controller = new AbortController();
       const resultPromise = proxy.request(
         { cdpMethod: "Page.navigate", cdpParams: { url: "https://a.test" } },
@@ -185,7 +200,7 @@ describe("HostBrowserProxy", () => {
         controller.signal,
       );
 
-      const sent = sentMessages[0] as Record<string, unknown>;
+      const sent = getPublishedMessages()[0] as Record<string, unknown>;
       const requestId = sent.requestId as string;
       expect(proxy.hasPendingRequest(requestId)).toBe(true);
 
@@ -196,68 +211,28 @@ describe("HostBrowserProxy", () => {
       expect(result.isError).toBe(true);
       expect(proxy.hasPendingRequest(requestId)).toBe(false);
 
-      // Second message should be the cancel envelope.
-      expect(sentMessages).toHaveLength(2);
-      const cancelMsg = sentMessages[1] as Record<string, unknown>;
+      // Cancel envelope should have been sent.
+      expect(getPublishedMessages()).toHaveLength(2);
+      const cancelMsg = getPublishedMessages()[1] as Record<string, unknown>;
       expect(cancelMsg.type).toBe("host_browser_cancel");
       expect(cancelMsg.requestId).toBe(requestId);
-
-      // onInternalResolve should have been invoked.
-      expect(resolvedIds).toEqual([requestId]);
     });
   });
 
   describe("isAvailable", () => {
-    test("returns false by default (no client connected)", () => {
-      setup();
-      expect(proxy.isAvailable()).toBe(false);
-    });
-
-    test("returns true after updateSender with clientConnected=true", () => {
-      setup();
-      proxy.updateSender(sendToClient, true);
+    test("returns true when a connection exists in the registry", () => {
+      mockHasConnection = true;
       expect(proxy.isAvailable()).toBe(true);
     });
 
-    test("returns false after updateSender with clientConnected=false", () => {
-      setup();
-      proxy.updateSender(sendToClient, true);
-      expect(proxy.isAvailable()).toBe(true);
-      proxy.updateSender(sendToClient, false);
+    test("returns false when no connection exists", () => {
+      mockHasConnection = false;
       expect(proxy.isAvailable()).toBe(false);
     });
   });
 
-  describe("updateSender", () => {
-    test("uses updated sender for new requests", async () => {
-      setup();
-
-      const newMessages: unknown[] = [];
-      proxy.updateSender((msg) => newMessages.push(msg), true);
-
-      const resultPromise = proxy.request(
-        { cdpMethod: "Page.navigate", cdpParams: { url: "https://a.test" } },
-        "session-1",
-      );
-
-      expect(sentMessages).toHaveLength(0); // Old sender not used.
-      expect(newMessages).toHaveLength(1); // New sender used.
-
-      const sent = newMessages[0] as Record<string, unknown>;
-      proxy.resolve(sent.requestId as string, {
-        content: "ok",
-        isError: false,
-      });
-
-      await resultPromise;
-    });
-  });
-
   describe("dispose", () => {
-    test("rejects all pending requests, emits cancels, invokes onInternalResolve", async () => {
-      const resolvedIds: string[] = [];
-      setup((id) => resolvedIds.push(id));
-
+    test("rejects all pending requests and emits cancels", async () => {
       const p1 = proxy.request(
         { cdpMethod: "Page.navigate", cdpParams: { url: "https://a.test" } },
         "session-1",
@@ -266,63 +241,70 @@ describe("HostBrowserProxy", () => {
         { cdpMethod: "Page.navigate", cdpParams: { url: "https://b.test" } },
         "session-1",
       );
-      // Attach rejection handlers immediately so Bun doesn't flag the
-      // promises as unhandled before the awaited assertions run.
       const p1Swallowed = p1.catch(() => {});
       const p2Swallowed = p2.catch(() => {});
 
-      const requestIds = (sentMessages as Array<Record<string, unknown>>).map(
-        (m) => m.requestId as string,
-      );
+      const requestIds = (
+        getPublishedMessages() as Array<Record<string, unknown>>
+      ).map((m) => m.requestId as string);
       expect(requestIds).toHaveLength(2);
-      expect(proxy.hasPendingRequest(requestIds[0]!)).toBe(true);
-      expect(proxy.hasPendingRequest(requestIds[1]!)).toBe(true);
 
       proxy.dispose();
 
-      // Both pending requests should no longer be tracked.
       expect(proxy.hasPendingRequest(requestIds[0]!)).toBe(false);
       expect(proxy.hasPendingRequest(requestIds[1]!)).toBe(false);
 
-      // Both promises should reject with AssistantError message.
       await expect(p1).rejects.toThrow("Host browser proxy disposed");
       await expect(p2).rejects.toThrow("Host browser proxy disposed");
-      // Drain the swallowed copies so the unhandled-rejection guard clears.
       await p1Swallowed;
       await p2Swallowed;
 
-      // After the 2 request messages, dispose should have sent 2 cancel messages.
-      const cancelMessages = sentMessages
+      const cancelMessages = getPublishedMessages()
         .slice(2)
         .filter(
           (m) => (m as Record<string, unknown>).type === "host_browser_cancel",
         ) as Array<Record<string, unknown>>;
       expect(cancelMessages).toHaveLength(2);
-      expect(cancelMessages.map((m) => m.requestId)).toContain(requestIds[0]);
-      expect(cancelMessages.map((m) => m.requestId)).toContain(requestIds[1]);
-
-      // onInternalResolve fired for each pending request on dispose.
-      expect(resolvedIds).toHaveLength(2);
-      expect(resolvedIds).toContain(requestIds[0]!);
-      expect(resolvedIds).toContain(requestIds[1]!);
     });
   });
 
   describe("resolve with unknown requestId", () => {
     test("silently ignores unknown requestId", () => {
-      setup();
-      // Should not throw.
-      proxy.resolve("nonexistent", {
-        content: "stale",
-        isError: false,
-      });
+      proxy.resolve("nonexistent", { content: "stale", isError: false });
+    });
+  });
+
+  describe("send failure", () => {
+    test("rejects when no connection exists at send time", async () => {
+      mockHasConnection = false;
+
+      const resultPromise = proxy.request(
+        { cdpMethod: "Page.navigate", cdpParams: { url: "https://x.test" } },
+        "session-1",
+      );
+
+      await expect(resultPromise).rejects.toThrow(
+        "no active extension connection",
+      );
+    });
+  });
+
+  describe("singleton", () => {
+    test("instance always returns the same proxy", () => {
+      const a = HostBrowserProxy.instance;
+      const b = HostBrowserProxy.instance;
+      expect(a).toBe(b);
+    });
+
+    test("reset() clears the singleton", () => {
+      const before = HostBrowserProxy.instance;
+      HostBrowserProxy.reset();
+      const after = HostBrowserProxy.instance;
+      expect(before).not.toBe(after);
     });
   });
 
   describe("abort listener lifecycle", () => {
-    // Helper that wraps an AbortSignal to observe add/removeEventListener
-    // invocations without tripping over tsc's strict overload matching on
-    // AbortSignal itself.
     type Spied = {
       signal: AbortSignal;
       addCalls: string[];
@@ -334,17 +316,11 @@ describe("HostBrowserProxy", () => {
       const s = source as any;
       const origAdd = source.addEventListener.bind(source);
       const origRemove = source.removeEventListener.bind(source);
-      s.addEventListener = (
-        type: string,
-        ...rest: any[]
-      ) => {
+      s.addEventListener = (type: string, ...rest: any[]) => {
         addCalls.push(type);
         return (origAdd as any)(type, ...rest);
       };
-      s.removeEventListener = (
-        type: string,
-        ...rest: any[]
-      ) => {
+      s.removeEventListener = (type: string, ...rest: any[]) => {
         removeCalls.push(type);
         return (origRemove as any)(type, ...rest);
       };
@@ -352,7 +328,6 @@ describe("HostBrowserProxy", () => {
     }
 
     test("removes abort listener from signal after resolve completes", async () => {
-      setup();
       const controller = new AbortController();
       const spy = spySignal(controller.signal);
 
@@ -365,22 +340,18 @@ describe("HostBrowserProxy", () => {
       expect(spy.addCalls).toEqual(["abort"]);
       expect(spy.removeCalls).toEqual([]);
 
-      const requestId = (sentMessages[0] as Record<string, unknown>)
+      const requestId = (getPublishedMessages()[0] as Record<string, unknown>)
         .requestId as string;
       proxy.resolve(requestId, { content: "ok", isError: false });
       await resultPromise;
 
-      // Listener is detached after normal completion.
       expect(spy.removeCalls).toEqual(["abort"]);
 
-      // Subsequent aborts are harmless no-ops (no side effects on the proxy).
       controller.abort();
-      // No additional emitted envelopes from the late abort.
-      expect(sentMessages).toHaveLength(1);
+      expect(getPublishedMessages()).toHaveLength(1);
     });
 
     test("removes abort listener from signal after dispose", () => {
-      setup();
       const controller = new AbortController();
       const spy = spySignal(controller.signal);
 
@@ -389,56 +360,11 @@ describe("HostBrowserProxy", () => {
         "session-1",
         spy.signal,
       );
-      p.catch(() => {}); // Swallow expected rejection.
+      p.catch(() => {});
 
       proxy.dispose();
 
       expect(spy.removeCalls).toEqual(["abort"]);
     });
   });
-
-  describe("sender throws synchronously", () => {
-    test("rejects the promise, clears pending state and timer, invokes onInternalResolve", async () => {
-      const resolvedIds: string[] = [];
-      sentMessages = [];
-      sendToClient = () => {
-        throw new Error("transport down");
-      };
-      proxy = new HostBrowserProxy(sendToClient, (id) => resolvedIds.push(id));
-
-      // request() synchronously calls sendToClient inside the Promise
-      // executor. A throw there surfaces as a rejected promise.
-      const resultPromise = proxy.request(
-        { cdpMethod: "Page.navigate", cdpParams: { url: "https://x.test" } },
-        "session-1",
-      );
-
-      await expect(resultPromise).rejects.toThrow("transport down");
-
-      // No entries should have leaked into the pending map.
-      // (We can't assert against a specific requestId because the sender
-      // threw before any message was observed, so there's nothing to read
-      // the id from. We can instead assert the internal resolve fired once
-      // and that no pending entries remain for any id we issue next.)
-      expect(resolvedIds).toHaveLength(1);
-
-      // Issue a new request on a fresh (non-throwing) sender and verify
-      // the proxy is still functional — no stale timers or bookkeeping
-      // from the failed request.
-      sentMessages = [];
-      proxy.updateSender((msg) => sentMessages.push(msg), true);
-      const okPromise = proxy.request(
-        { cdpMethod: "Page.reload" },
-        "session-1",
-      );
-      expect(sentMessages).toHaveLength(1);
-      const okRequestId = (sentMessages[0] as Record<string, unknown>)
-        .requestId as string;
-      expect(proxy.hasPendingRequest(okRequestId)).toBe(true);
-      proxy.resolve(okRequestId, { content: "reloaded", isError: false });
-      const okResult = await okPromise;
-      expect(okResult.content).toBe("reloaded");
-      expect(okResult.isError).toBe(false);
-    });
-  });
 });

package/src/__tests__/host-browser-routes.test.ts

@@ -1,13 +1,11 @@
 /**
  * Unit tests for the /v1/host-browser-result route handler.
  *
- * Tests handleHostBrowserResult directly via RouteHandlerArgs with a
- * stub Conversation whose resolveHostBrowser method records calls.
+ * Resolution goes through HostBrowserProxy.instance (singleton). The
+ * mock below controls the proxy's pending request map and resolve spy.
  */
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
-import type { Conversation } from "../daemon/conversation.js";
-
 // ── Module mocks ─────────────────────────────────────────────────────
 
 mock.module("../config/env.js", () => ({
@@ -15,10 +13,36 @@ mock.module("../config/env.js", () => ({
   hasUngatedHttpAuthDisabled: () => false,
 }));
 
+interface ResolveCall {
+  requestId: string;
+  response: { content: string; isError: boolean };
+}
+
+const resolveSpy: ResolveCall[] = [];
+const pendingRequests = new Set<string>();
+
+mock.module("../daemon/host-browser-proxy.js", () => ({
+  HostBrowserProxy: {
+    get instance() {
+      return {
+        hasPendingRequest(requestId: string) {
+          return pendingRequests.has(requestId);
+        },
+        resolve(
+          requestId: string,
+          response: { content: string; isError: boolean },
+        ) {
+          pendingRequests.delete(requestId);
+          resolveSpy.push({ requestId, response });
+        },
+      };
+    },
+  },
+}));
+
 // ── Real imports (after mocks) ───────────────────────────────────────
 
-import * as pendingInteractions from "../runtime/pending-interactions.js";
-import { BadRequestError, ConflictError, NotFoundError } from "../runtime/routes/errors.js";
+import { BadRequestError, NotFoundError } from "../runtime/routes/errors.js";
 import { ROUTES } from "../runtime/routes/host-browser-routes.js";
 
 afterAll(() => {
@@ -29,53 +53,28 @@ const handleHostBrowserResult = ROUTES.find(
   (r) => r.endpoint === "host-browser-result",
 )!.handler;
 
-// ── Helpers ──────────────────────────────────────────────────────────
-
-interface ResolveHostBrowserCall {
-  requestId: string;
-  response: { content: string; isError: boolean };
-}
-
-function makeStubConversation(spy: ResolveHostBrowserCall[]): Conversation {
-  return {
-    resolveHostBrowser(
-      requestId: string,
-      response: { content: string; isError: boolean },
-    ) {
-      spy.push({ requestId, response });
-    },
-  } as unknown as Conversation;
-}
-
 // ── Tests ────────────────────────────────────────────────────────────
 
 describe("handleHostBrowserResult", () => {
   beforeEach(() => {
-    pendingInteractions.clear();
+    pendingRequests.clear();
+    resolveSpy.length = 0;
   });
 
-  test("happy path: resolves a pending host_browser interaction", async () => {
-    const spy: ResolveHostBrowserCall[] = [];
-    const conversation = makeStubConversation(spy);
+  test("happy path: resolves a pending host_browser request via singleton", async () => {
     const requestId = "browser-req-happy";
-
-    pendingInteractions.register(requestId, {
-      conversation,
-      conversationId: "conv-1",
-      kind: "host_browser",
-    });
+    pendingRequests.add(requestId);
 
     const result = await handleHostBrowserResult({
       body: { requestId, content: "ok", isError: false },
     });
 
     expect(result).toEqual({ accepted: true });
-    expect(spy).toHaveLength(1);
-    expect(spy[0].requestId).toBe(requestId);
-    expect(spy[0].response).toEqual({ content: "ok", isError: false });
+    expect(resolveSpy).toHaveLength(1);
+    expect(resolveSpy[0].requestId).toBe(requestId);
+    expect(resolveSpy[0].response).toEqual({ content: "ok", isError: false });
 
-    // Pending interaction should be consumed
-    expect(pendingInteractions.get(requestId)).toBeUndefined();
+    expect(pendingRequests.has(requestId)).toBe(false);
   });
 
   test("missing body: throws BadRequestError", () => {
@@ -83,9 +82,9 @@ describe("handleHostBrowserResult", () => {
   });
 
   test("missing requestId: throws BadRequestError", () => {
-    expect(() =>
-      handleHostBrowserResult({ body: { content: "x" } }),
-    ).toThrow(BadRequestError);
+    expect(() => handleHostBrowserResult({ body: { content: "x" } })).toThrow(
+      BadRequestError,
+    );
   });
 
   test("unknown requestId: throws NotFoundError", () => {
@@ -100,44 +99,15 @@ describe("handleHostBrowserResult", () => {
     ).toThrow(NotFoundError);
   });
 
-  test("wrong kind: throws ConflictError with mismatch message", () => {
-    const spy: ResolveHostBrowserCall[] = [];
-    const conversation = makeStubConversation(spy);
-    const requestId = "browser-req-wrong-kind";
-
-    pendingInteractions.register(requestId, {
-      conversation,
-      conversationId: "conv-1",
-      kind: "host_bash",
-    });
-
-    expect(() =>
-      handleHostBrowserResult({
-        body: { requestId, content: "x", isError: false },
-      }),
-    ).toThrow(ConflictError);
-
-    // Pending interaction should NOT have been consumed
-    expect(pendingInteractions.get(requestId)).toBeDefined();
-    expect(spy).toHaveLength(0);
-  });
-
   test("defaults: missing content/isError default to '' and false", async () => {
-    const spy: ResolveHostBrowserCall[] = [];
-    const conversation = makeStubConversation(spy);
     const requestId = "browser-req-defaults";
-
-    pendingInteractions.register(requestId, {
-      conversation,
-      conversationId: "conv-1",
-      kind: "host_browser",
-    });
+    pendingRequests.add(requestId);
 
     const result = await handleHostBrowserResult({ body: { requestId } });
 
     expect(result).toEqual({ accepted: true });
-    expect(spy).toHaveLength(1);
-    expect(spy[0].requestId).toBe(requestId);
-    expect(spy[0].response).toEqual({ content: "", isError: false });
+    expect(resolveSpy).toHaveLength(1);
+    expect(resolveSpy[0].requestId).toBe(requestId);
+    expect(resolveSpy[0].response).toEqual({ content: "", isError: false });
   });
 });