@vellumai/assistant 0.10.2-dev.202606250318.5e7cfb0 → 0.10.2

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

@@ -95,7 +95,7 @@ afterAll(() => {
 
 const handleHostBashResult = ROUTES.find(
   (r) => r.endpoint === "host-bash-result",
-)!.handler as (args: Record<string, unknown>) => Promise<unknown>;
+)!.handler;
 
 // ── Helpers ──────────────────────────────────────────────────────────
 
@@ -244,20 +244,22 @@ describe("handleHostBashResult", () => {
       ).toThrow(ForbiddenError);
     });
 
-    test("interaction is NOT resolved on cross-actor 403 (still pending)", async () => {
+    test("interaction is NOT resolved on cross-actor 403 (still pending)", () => {
       const requestId = "req-actor-mismatch-stays";
       clientActorPrincipals.set("client-abc", "principal-victim");
       registerPending(requestId, { targetClientId: "client-abc" });
 
-      await handleHostBashResult({
-        body: bashBody(requestId),
-        headers: {
-          "x-vellum-client-id": "client-abc",
-          "x-vellum-actor-principal-id": "principal-attacker",
-        },
-      }).catch(() => {
+      try {
+        handleHostBashResult({
+          body: bashBody(requestId),
+          headers: {
+            "x-vellum-client-id": "client-abc",
+            "x-vellum-actor-principal-id": "principal-attacker",
+          },
+        });
+      } catch {
         // expected
-      });
+      }
 
       expect(resolvedIds).not.toContain(requestId);
       expect(pendingStore.has(requestId)).toBe(true);
@@ -276,17 +278,19 @@ describe("handleHostBashResult", () => {
       ).toThrow(ForbiddenError);
     });
 
-    test("interaction is NOT resolved when submitting actor is missing (still pending)", async () => {
+    test("interaction is NOT resolved when submitting actor is missing (still pending)", () => {
       const requestId = "req-actor-missing-stays";
       clientActorPrincipals.set("client-abc", "principal-victim");
       registerPending(requestId, { targetClientId: "client-abc" });
 
-      await handleHostBashResult({
-        body: bashBody(requestId),
-        headers: { "x-vellum-client-id": "client-abc" },
-      }).catch(() => {
+      try {
+        handleHostBashResult({
+          body: bashBody(requestId),
+          headers: { "x-vellum-client-id": "client-abc" },
+        });
+      } catch {
         // expected
-      });
+      }
 
       expect(resolvedIds).not.toContain(requestId);
       expect(pendingStore.has(requestId)).toBe(true);
@@ -354,13 +358,15 @@ describe("handleHostBashResult", () => {
       ).toThrow(BadRequestError);
     });
 
-    test("interaction is NOT resolved on 400 (still pending)", async () => {
+    test("interaction is NOT resolved on 400 (still pending)", () => {
       const requestId = "req-targeted-no-header-stays";
       registerPending(requestId, { targetClientId: "client-abc" });
 
-      await handleHostBashResult({ body: bashBody(requestId) }).catch(() => {
+      try {
+        handleHostBashResult({ body: bashBody(requestId) });
+      } catch {
         // expected
-      });
+      }
 
       expect(resolvedIds).not.toContain(requestId);
       expect(pendingStore.has(requestId)).toBe(true);
@@ -382,17 +388,19 @@ describe("handleHostBashResult", () => {
       ).toThrow(ForbiddenError);
     });
 
-    test("ForbiddenError message names both the submitting and expected client", async () => {
+    test("ForbiddenError message names both the submitting and expected client", () => {
       const requestId = "req-targeted-mismatch-msg";
       registerPending(requestId, { targetClientId: "client-abc" });
 
       let caught: unknown;
-      await handleHostBashResult({
-        body: bashBody(requestId),
-        headers: { "x-vellum-client-id": "client-xyz" },
-      }).catch((e: unknown) => {
+      try {
+        handleHostBashResult({
+          body: bashBody(requestId),
+          headers: { "x-vellum-client-id": "client-xyz" },
+        });
+      } catch (e) {
         caught = e;
-      });
+      }
 
       expect(caught).toBeInstanceOf(ForbiddenError);
       const msg = (caught as ForbiddenError).message;
@@ -400,16 +408,18 @@ describe("handleHostBashResult", () => {
       expect(msg).toContain("client-abc");
     });
 
-    test("interaction is NOT resolved on 403 (still pending)", async () => {
+    test("interaction is NOT resolved on 403 (still pending)", () => {
       const requestId = "req-targeted-mismatch-stays";
       registerPending(requestId, { targetClientId: "client-abc" });
 
-      await handleHostBashResult({
-        body: bashBody(requestId),
-        headers: { "x-vellum-client-id": "client-xyz" },
-      }).catch(() => {
+      try {
+        handleHostBashResult({
+          body: bashBody(requestId),
+          headers: { "x-vellum-client-id": "client-xyz" },
+        });
+      } catch {
         // expected
-      });
+      }
 
       expect(resolvedIds).not.toContain(requestId);
       expect(pendingStore.has(requestId)).toBe(true);

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

@@ -39,7 +39,7 @@ afterAll(() => {
 
 const handleHostBrowserResult = ROUTES.find(
   (r) => r.endpoint === "host-browser-result",
-)!.handler as (args: Record<string, unknown>) => Promise<unknown>;
+)!.handler;
 
 // ── Tests ────────────────────────────────────────────────────────────
 
@@ -212,7 +212,7 @@ describe("handleHostBrowserResult — same-actor guard", () => {
       ).toThrow(BadRequestError);
     });
 
-    test("interaction is NOT consumed on 400 (still pending)", async () => {
+    test("interaction is NOT consumed on 400 (still pending)", () => {
       const requestId = "browser-req-targeted-no-header-stays";
       pendingInteractions.register(requestId, {
         conversationId: "conv-1",
@@ -221,11 +221,13 @@ describe("handleHostBrowserResult — same-actor guard", () => {
         targetActorPrincipalId: "user-1",
       });
 
-      await handleHostBrowserResult({
-        body: { requestId, content: "ok", isError: false },
-      }).catch(() => {
+      try {
+        handleHostBrowserResult({
+          body: { requestId, content: "ok", isError: false },
+        });
+      } catch {
         // expected
-      });
+      }
 
       expect(pendingInteractions.get(requestId)).toBeDefined();
     });
@@ -254,7 +256,7 @@ describe("handleHostBrowserResult — same-actor guard", () => {
       ).toThrow(ForbiddenError);
     });
 
-    test("ForbiddenError message names both submitting and expected client", async () => {
+    test("ForbiddenError message names both submitting and expected client", () => {
       const requestId = "browser-req-targeted-mismatch-msg";
       pendingInteractions.register(requestId, {
         conversationId: "conv-1",
@@ -265,7 +267,7 @@ describe("handleHostBrowserResult — same-actor guard", () => {
 
       let caught: unknown;
       try {
-        await handleHostBrowserResult({
+        handleHostBrowserResult({
           body: { requestId, content: "ok", isError: false },
           headers: {
             "x-vellum-client-id": "client-B",
@@ -282,7 +284,7 @@ describe("handleHostBrowserResult — same-actor guard", () => {
       expect(msg).toContain("client-B");
     });
 
-    test("interaction is NOT consumed on 403 (still pending)", async () => {
+    test("interaction is NOT consumed on 403 (still pending)", () => {
       const requestId = "browser-req-targeted-mismatch-stays";
       pendingInteractions.register(requestId, {
         conversationId: "conv-1",
@@ -291,15 +293,17 @@ describe("handleHostBrowserResult — same-actor guard", () => {
         targetActorPrincipalId: "user-1",
       });
 
-      await handleHostBrowserResult({
-        body: { requestId, content: "ok", isError: false },
-        headers: {
-          "x-vellum-client-id": "client-B",
-          "x-vellum-actor-principal-id": "user-1",
-        },
-      }).catch(() => {
+      try {
+        handleHostBrowserResult({
+          body: { requestId, content: "ok", isError: false },
+          headers: {
+            "x-vellum-client-id": "client-B",
+            "x-vellum-actor-principal-id": "user-1",
+          },
+        });
+      } catch {
         // expected
-      });
+      }
 
       expect(pendingInteractions.get(requestId)).toBeDefined();
     });
@@ -365,7 +369,7 @@ describe("handleHostBrowserResult — same-actor guard", () => {
       ).toThrow(ForbiddenError);
     });
 
-    test("interaction NOT consumed on actor-mismatch 403", async () => {
+    test("interaction NOT consumed on actor-mismatch 403", () => {
       const requestId = "browser-req-actor-mismatch-stays";
       pendingInteractions.register(requestId, {
         conversationId: "conv-1",
@@ -374,15 +378,17 @@ describe("handleHostBrowserResult — same-actor guard", () => {
         targetActorPrincipalId: "user-1",
       });
 
-      await handleHostBrowserResult({
-        body: { requestId, content: "ok", isError: false },
-        headers: {
-          "x-vellum-client-id": "client-A",
-          "x-vellum-actor-principal-id": "user-2",
-        },
-      }).catch(() => {
+      try {
+        handleHostBrowserResult({
+          body: { requestId, content: "ok", isError: false },
+          headers: {
+            "x-vellum-client-id": "client-A",
+            "x-vellum-actor-principal-id": "user-2",
+          },
+        });
+      } catch {
         // expected
-      });
+      }
 
       expect(pendingInteractions.get(requestId)).toBeDefined();
     });

package/src/__tests__/host-cu-routes-targeted.test.ts

@@ -104,7 +104,7 @@ afterAll(() => {
 
 const handleHostCuResult = ROUTES.find(
   (r: { endpoint: string }) => r.endpoint === "host-cu-result",
-)!.handler as (args: Record<string, unknown>) => Promise<unknown>;
+)!.handler;
 
 // ── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -226,13 +226,15 @@ describe("handleHostCuResult — Phase 2 targetClientId guard", () => {
       ).toThrow(BadRequestError);
     });
 
-    test("interaction is NOT resolved on 400 (still pending)", async () => {
+    test("interaction is NOT resolved on 400 (still pending)", () => {
       const requestId = "req-cu-targeted-no-header-stays";
       registerPending(requestId, { targetClientId: "client-A" });
 
-      await handleHostCuResult({ body: cuBody(requestId) }).catch(() => {
+      try {
+        handleHostCuResult({ body: cuBody(requestId) });
+      } catch {
         // expected
-      });
+      }
 
       expect(resolvedIds).not.toContain(requestId);
       expect(pendingStore.has(requestId)).toBe(true);
@@ -254,17 +256,19 @@ describe("handleHostCuResult — Phase 2 targetClientId guard", () => {
       ).toThrow(ForbiddenError);
     });
 
-    test("ForbiddenError message names both submitting and expected client", async () => {
+    test("ForbiddenError message names both submitting and expected client", () => {
       const requestId = "req-cu-targeted-mismatch-msg";
       registerPending(requestId, { targetClientId: "client-A" });
 
       let caught: unknown;
-      await handleHostCuResult({
-        body: cuBody(requestId),
-        headers: { "x-vellum-client-id": "client-B" },
-      }).catch((e: unknown) => {
+      try {
+        handleHostCuResult({
+          body: cuBody(requestId),
+          headers: { "x-vellum-client-id": "client-B" },
+        });
+      } catch (e) {
         caught = e;
-      });
+      }
 
       expect(caught).toBeInstanceOf(ForbiddenError);
       const msg = (caught as ForbiddenError).message;
@@ -272,16 +276,18 @@ describe("handleHostCuResult — Phase 2 targetClientId guard", () => {
       expect(msg).toContain("client-A");
     });
 
-    test("interaction is NOT consumed on 403 (pendingInteractions.get still returns it)", async () => {
+    test("interaction is NOT consumed on 403 (pendingInteractions.get still returns it)", () => {
       const requestId = "req-cu-targeted-mismatch-stays";
       registerPending(requestId, { targetClientId: "client-A" });
 
-      await handleHostCuResult({
-        body: cuBody(requestId),
-        headers: { "x-vellum-client-id": "client-B" },
-      }).catch(() => {
+      try {
+        handleHostCuResult({
+          body: cuBody(requestId),
+          headers: { "x-vellum-client-id": "client-B" },
+        });
+      } catch {
         // expected
-      });
+      }
 
       expect(resolvedIds).not.toContain(requestId);
       expect(pendingStore.has(requestId)).toBe(true);
@@ -325,20 +331,22 @@ describe("handleHostCuResult — Phase 2 targetClientId guard", () => {
       ).toThrow(ForbiddenError);
     });
 
-    test("interaction NOT consumed on 403 actor mismatch", async () => {
+    test("interaction NOT consumed on 403 actor mismatch", () => {
       const requestId = "req-cu-actor-mismatch-stays";
       actorPrincipalByClient.set("client-A", "user-1");
       registerPending(requestId, { targetClientId: "client-A" });
 
-      await handleHostCuResult({
-        body: cuBody(requestId),
-        headers: {
-          "x-vellum-client-id": "client-A",
-          "x-vellum-actor-principal-id": "user-2",
-        },
-      }).catch(() => {
+      try {
+        handleHostCuResult({
+          body: cuBody(requestId),
+          headers: {
+            "x-vellum-client-id": "client-A",
+            "x-vellum-actor-principal-id": "user-2",
+          },
+        });
+      } catch {
         // expected
-      });
+      }
 
       expect(resolvedIds).not.toContain(requestId);
       expect(pendingStore.has(requestId)).toBe(true);

package/src/__tests__/host-file-routes-targeted.test.ts

@@ -87,7 +87,7 @@ afterAll(() => {
 
 const handleHostFileResult = ROUTES.find(
   (r) => r.endpoint === "host-file-result",
-)!.handler as (args: Record<string, unknown>) => Promise<unknown>;
+)!.handler;
 
 // ── Helpers ─────────────────────────────────────────────────────────────────
 
@@ -189,13 +189,15 @@ describe("handleHostFileResult — targetClientId guard", () => {
       ).toThrow(BadRequestError);
     });
 
-    test("interaction is NOT resolved on 400 (still pending)", async () => {
+    test("interaction is NOT resolved on 400 (still pending)", () => {
       const requestId = "req-file-targeted-no-header-stays";
       registerPending(requestId, { targetClientId: "client-A" });
 
-      await handleHostFileResult({ body: fileBody(requestId) }).catch(() => {
+      try {
+        handleHostFileResult({ body: fileBody(requestId) });
+      } catch {
         // expected
-      });
+      }
 
       expect(resolvedIds).not.toContain(requestId);
       expect(pendingStore.has(requestId)).toBe(true);
@@ -217,17 +219,19 @@ describe("handleHostFileResult — targetClientId guard", () => {
       ).toThrow(ForbiddenError);
     });
 
-    test("ForbiddenError message names both submitting and expected client", async () => {
+    test("ForbiddenError message names both submitting and expected client", () => {
       const requestId = "req-file-targeted-mismatch-msg";
       registerPending(requestId, { targetClientId: "client-A" });
 
       let caught: unknown;
-      await handleHostFileResult({
-        body: fileBody(requestId),
-        headers: { "x-vellum-client-id": "client-B" },
-      }).catch((e: unknown) => {
+      try {
+        handleHostFileResult({
+          body: fileBody(requestId),
+          headers: { "x-vellum-client-id": "client-B" },
+        });
+      } catch (e) {
         caught = e;
-      });
+      }
 
       expect(caught).toBeInstanceOf(ForbiddenError);
       const msg = (caught as ForbiddenError).message;
@@ -235,16 +239,18 @@ describe("handleHostFileResult — targetClientId guard", () => {
       expect(msg).toContain("client-A");
     });
 
-    test("interaction is NOT consumed on 403 (pendingInteractions.get still returns it)", async () => {
+    test("interaction is NOT consumed on 403 (pendingInteractions.get still returns it)", () => {
       const requestId = "req-file-targeted-mismatch-stays";
       registerPending(requestId, { targetClientId: "client-A" });
 
-      await handleHostFileResult({
-        body: fileBody(requestId),
-        headers: { "x-vellum-client-id": "client-B" },
-      }).catch(() => {
+      try {
+        handleHostFileResult({
+          body: fileBody(requestId),
+          headers: { "x-vellum-client-id": "client-B" },
+        });
+      } catch {
         // expected
-      });
+      }
 
       expect(resolvedIds).not.toContain(requestId);
       expect(pendingStore.has(requestId)).toBe(true);
@@ -300,20 +306,22 @@ describe("handleHostFileResult — targetClientId guard", () => {
       ).toThrow(ForbiddenError);
     });
 
-    test("interaction is NOT consumed on actor-mismatch 403", async () => {
+    test("interaction is NOT consumed on actor-mismatch 403", () => {
       const requestId = "req-file-actor-mismatch-stays";
       clientActors.set("client-A", "actor-1");
       registerPending(requestId, { targetClientId: "client-A" });
 
-      await handleHostFileResult({
-        body: fileBody(requestId),
-        headers: {
-          "x-vellum-client-id": "client-A",
-          "x-vellum-actor-principal-id": "actor-2",
-        },
-      }).catch(() => {
+      try {
+        handleHostFileResult({
+          body: fileBody(requestId),
+          headers: {
+            "x-vellum-client-id": "client-A",
+            "x-vellum-actor-principal-id": "actor-2",
+          },
+        });
+      } catch {
         // expected
-      });
+      }
 
       expect(resolvedIds).not.toContain(requestId);
       expect(pendingStore.has(requestId)).toBe(true);
@@ -352,17 +360,19 @@ describe("handleHostFileResult — targetClientId guard", () => {
       ).toThrow(ForbiddenError);
     });
 
-    test("interaction is NOT consumed when submitting actor is missing", async () => {
+    test("interaction is NOT consumed when submitting actor is missing", () => {
       const requestId = "req-file-actor-missing-stays";
       clientActors.set("client-A", "actor-1");
       registerPending(requestId, { targetClientId: "client-A" });
 
-      await handleHostFileResult({
-        body: fileBody(requestId),
-        headers: { "x-vellum-client-id": "client-A" },
-      }).catch(() => {
+      try {
+        handleHostFileResult({
+          body: fileBody(requestId),
+          headers: { "x-vellum-client-id": "client-A" },
+        });
+      } catch {
         // expected
-      });
+      }
 
       expect(resolvedIds).not.toContain(requestId);
       expect(pendingStore.has(requestId)).toBe(true);
@@ -388,19 +398,21 @@ describe("handleHostFileResult — targetClientId guard", () => {
       ).toThrow(ForbiddenError);
     });
 
-    test("interaction is NOT consumed when target client has no stored actor", async () => {
+    test("interaction is NOT consumed when target client has no stored actor", () => {
       const requestId = "req-file-target-no-actor-stays";
       registerPending(requestId, { targetClientId: "client-A" });
 
-      await handleHostFileResult({
-        body: fileBody(requestId),
-        headers: {
-          "x-vellum-client-id": "client-A",
-          "x-vellum-actor-principal-id": "actor-1",
-        },
-      }).catch(() => {
+      try {
+        handleHostFileResult({
+          body: fileBody(requestId),
+          headers: {
+            "x-vellum-client-id": "client-A",
+            "x-vellum-actor-principal-id": "actor-1",
+          },
+        });
+      } catch {
         // expected
-      });
+      }
 
       expect(resolvedIds).not.toContain(requestId);
       expect(pendingStore.has(requestId)).toBe(true);

package/src/__tests__/host-transfer-routes-targeted.test.ts

@@ -99,7 +99,7 @@ afterAll(() => {
 
 const handleTransferContentGet = ROUTES.find(
   (r) => r.endpoint === "transfers/:transferId/content" && r.method === "GET",
-)!.handler as (args: Record<string, unknown>) => Promise<unknown>;
+)!.handler;
 
 const handleTransferContentPut = ROUTES.find(
   (r) => r.endpoint === "transfers/:transferId/content" && r.method === "PUT",
@@ -107,7 +107,7 @@ const handleTransferContentPut = ROUTES.find(
 
 const handleTransferResult = ROUTES.find(
   (r) => r.endpoint === "host-transfer-result",
-)!.handler as (args: Record<string, unknown>) => Promise<unknown>;
+)!.handler;
 
 // ── Helpers ─────────────────────────────────────────────────────────────────
 
@@ -186,13 +186,15 @@ describe("handleTransferContentGet — Phase 3 targetClientId guard", () => {
       ).toThrow(BadRequestError);
     });
 
-    test("getTransferContent NOT called on 400", async () => {
+    test("getTransferContent NOT called on 400", () => {
       stubTargetClientId = "client-A";
-      await handleTransferContentGet({
-        pathParams: { transferId: TEST_TRANSFER_ID },
-      }).catch(() => {
+      try {
+        handleTransferContentGet({
+          pathParams: { transferId: TEST_TRANSFER_ID },
+        });
+      } catch {
         // expected
-      });
+      }
       expect(getTransferContentCalls).toHaveLength(0);
     });
   });
@@ -210,14 +212,16 @@ describe("handleTransferContentGet — Phase 3 targetClientId guard", () => {
       ).toThrow(ForbiddenError);
     });
 
-    test("getTransferContent NOT called on 403", async () => {
+    test("getTransferContent NOT called on 403", () => {
       stubTargetClientId = "client-A";
-      await handleTransferContentGet({
-        pathParams: { transferId: TEST_TRANSFER_ID },
-        headers: { "x-vellum-client-id": "client-B" },
-      }).catch(() => {
+      try {
+        handleTransferContentGet({
+          pathParams: { transferId: TEST_TRANSFER_ID },
+          headers: { "x-vellum-client-id": "client-B" },
+        });
+      } catch {
         // expected
-      });
+      }
       expect(getTransferContentCalls).toHaveLength(0);
     });
   });
@@ -522,19 +526,23 @@ describe("handleTransferResult — Phase 3 targetClientId guard", () => {
       );
     });
 
-    test("resolveTransferResult NOT called on 400", async () => {
+    test("resolveTransferResult NOT called on 400", () => {
       registerHostTransferPending("client-A");
-      await handleTransferResult({ body: resultBody() }).catch(() => {
+      try {
+        handleTransferResult({ body: resultBody() });
+      } catch {
         // expected
-      });
+      }
       expect(resolveTransferResultCalls).toHaveLength(0);
     });
 
-    test("pending interaction still present after 400", async () => {
+    test("pending interaction still present after 400", () => {
       registerHostTransferPending("client-A");
-      await handleTransferResult({ body: resultBody() }).catch(() => {
+      try {
+        handleTransferResult({ body: resultBody() });
+      } catch {
         // expected
-      });
+      }
       expect(pendingStore.has(TEST_REQUEST_ID)).toBe(true);
     });
   });
@@ -552,25 +560,29 @@ describe("handleTransferResult — Phase 3 targetClientId guard", () => {
       ).toThrow(ForbiddenError);
     });
 
-    test("resolveTransferResult NOT called on 403", async () => {
+    test("resolveTransferResult NOT called on 403", () => {
       registerHostTransferPending("client-A");
-      await handleTransferResult({
-        body: resultBody(),
-        headers: { "x-vellum-client-id": "client-B" },
-      }).catch(() => {
+      try {
+        handleTransferResult({
+          body: resultBody(),
+          headers: { "x-vellum-client-id": "client-B" },
+        });
+      } catch {
         // expected
-      });
+      }
       expect(resolveTransferResultCalls).toHaveLength(0);
     });
 
-    test("pending interaction still present after 403", async () => {
+    test("pending interaction still present after 403", () => {
       registerHostTransferPending("client-A");
-      await handleTransferResult({
-        body: resultBody(),
-        headers: { "x-vellum-client-id": "client-B" },
-      }).catch(() => {
+      try {
+        handleTransferResult({
+          body: resultBody(),
+          headers: { "x-vellum-client-id": "client-B" },
+        });
+      } catch {
         // expected
-      });
+      }
       expect(pendingStore.has(TEST_REQUEST_ID)).toBe(true);
     });
   });