@vellumai/assistant 0.10.0 → 0.10.1-dev.202606240317.ea25efe

package/src/__tests__/host-app-control-routes.test.ts

@@ -62,7 +62,7 @@ afterAll(() => {
 
 const handleHostAppControlResult = ROUTES.find(
   (r) => r.endpoint === "host-app-control-result",
-)!.handler;
+)!.handler as (args: Record<string, unknown>) => Promise<unknown>;
 
 // ── Tests ────────────────────────────────────────────────────────────
 
@@ -395,7 +395,7 @@ describe("handleHostAppControlResult — same-actor guard", () => {
     ).toThrow(BadRequestError);
   });
 
-  test("targeted + missing header: interaction is NOT consumed (still pending)", () => {
+  test("targeted + missing header: interaction is NOT consumed (still pending)", async () => {
     const requestId = "ac-req-targeted-no-header-stays";
     pending.set(requestId, {
       conversationId: "conv-1",
@@ -404,13 +404,11 @@ describe("handleHostAppControlResult — same-actor guard", () => {
       targetActorPrincipalId: "user-1",
     });
 
-    try {
-      handleHostAppControlResult({
-        body: { requestId, state: "running" },
-      });
-    } catch {
+    await handleHostAppControlResult({
+      body: { requestId, state: "running" },
+    }).catch(() => {
       // expected
-    }
+    });
 
     expect(pending.has(requestId)).toBe(true);
   });
@@ -437,7 +435,7 @@ describe("handleHostAppControlResult — same-actor guard", () => {
     ).toThrow(ForbiddenError);
   });
 
-  test("targeted + wrong client id: interaction is NOT consumed", () => {
+  test("targeted + wrong client id: interaction is NOT consumed", async () => {
     const requestId = "ac-req-targeted-wrong-client-stays";
     pending.set(requestId, {
       conversationId: "conv-1",
@@ -446,17 +444,15 @@ describe("handleHostAppControlResult — same-actor guard", () => {
       targetActorPrincipalId: "user-1",
     });
 
-    try {
-      handleHostAppControlResult({
-        body: { requestId, state: "running" },
-        headers: {
-          "x-vellum-client-id": "client-B",
-          "x-vellum-actor-principal-id": "user-1",
-        },
-      });
-    } catch {
+    await handleHostAppControlResult({
+      body: { requestId, state: "running" },
+      headers: {
+        "x-vellum-client-id": "client-B",
+        "x-vellum-actor-principal-id": "user-1",
+      },
+    }).catch(() => {
       // expected
-    }
+    });
 
     expect(pending.has(requestId)).toBe(true);
   });
@@ -483,7 +479,7 @@ describe("handleHostAppControlResult — same-actor guard", () => {
     ).toThrow(ForbiddenError);
   });
 
-  test("targeted + wrong actor principal: interaction is NOT consumed", () => {
+  test("targeted + wrong actor principal: interaction is NOT consumed", async () => {
     const requestId = "ac-req-targeted-wrong-actor-stays";
     pending.set(requestId, {
       conversationId: "conv-1",
@@ -492,17 +488,15 @@ describe("handleHostAppControlResult — same-actor guard", () => {
       targetActorPrincipalId: "user-1",
     });
 
-    try {
-      handleHostAppControlResult({
-        body: { requestId, state: "running" },
-        headers: {
-          "x-vellum-client-id": "client-A",
-          "x-vellum-actor-principal-id": "user-2",
-        },
-      });
-    } catch {
+    await handleHostAppControlResult({
+      body: { requestId, state: "running" },
+      headers: {
+        "x-vellum-client-id": "client-A",
+        "x-vellum-actor-principal-id": "user-2",
+      },
+    }).catch(() => {
       // expected
-    }
+    });
 
     expect(pending.has(requestId)).toBe(true);
   });

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

@@ -95,7 +95,7 @@ afterAll(() => {
 
 const handleHostBashResult = ROUTES.find(
   (r) => r.endpoint === "host-bash-result",
-)!.handler;
+)!.handler as (args: Record<string, unknown>) => Promise<unknown>;
 
 // ── Helpers ──────────────────────────────────────────────────────────
 
@@ -244,22 +244,20 @@ describe("handleHostBashResult", () => {
       ).toThrow(ForbiddenError);
     });
 
-    test("interaction is NOT resolved on cross-actor 403 (still pending)", () => {
+    test("interaction is NOT resolved on cross-actor 403 (still pending)", async () => {
       const requestId = "req-actor-mismatch-stays";
       clientActorPrincipals.set("client-abc", "principal-victim");
       registerPending(requestId, { targetClientId: "client-abc" });
 
-      try {
-        handleHostBashResult({
-          body: bashBody(requestId),
-          headers: {
-            "x-vellum-client-id": "client-abc",
-            "x-vellum-actor-principal-id": "principal-attacker",
-          },
-        });
-      } catch {
+      await 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);
@@ -278,19 +276,17 @@ describe("handleHostBashResult", () => {
       ).toThrow(ForbiddenError);
     });
 
-    test("interaction is NOT resolved when submitting actor is missing (still pending)", () => {
+    test("interaction is NOT resolved when submitting actor is missing (still pending)", async () => {
       const requestId = "req-actor-missing-stays";
       clientActorPrincipals.set("client-abc", "principal-victim");
       registerPending(requestId, { targetClientId: "client-abc" });
 
-      try {
-        handleHostBashResult({
-          body: bashBody(requestId),
-          headers: { "x-vellum-client-id": "client-abc" },
-        });
-      } catch {
+      await handleHostBashResult({
+        body: bashBody(requestId),
+        headers: { "x-vellum-client-id": "client-abc" },
+      }).catch(() => {
         // expected
-      }
+      });
 
       expect(resolvedIds).not.toContain(requestId);
       expect(pendingStore.has(requestId)).toBe(true);
@@ -358,15 +354,13 @@ describe("handleHostBashResult", () => {
       ).toThrow(BadRequestError);
     });
 
-    test("interaction is NOT resolved on 400 (still pending)", () => {
+    test("interaction is NOT resolved on 400 (still pending)", async () => {
       const requestId = "req-targeted-no-header-stays";
       registerPending(requestId, { targetClientId: "client-abc" });
 
-      try {
-        handleHostBashResult({ body: bashBody(requestId) });
-      } catch {
+      await handleHostBashResult({ body: bashBody(requestId) }).catch(() => {
         // expected
-      }
+      });
 
       expect(resolvedIds).not.toContain(requestId);
       expect(pendingStore.has(requestId)).toBe(true);
@@ -388,19 +382,17 @@ describe("handleHostBashResult", () => {
       ).toThrow(ForbiddenError);
     });
 
-    test("ForbiddenError message names both the submitting and expected client", () => {
+    test("ForbiddenError message names both the submitting and expected client", async () => {
       const requestId = "req-targeted-mismatch-msg";
       registerPending(requestId, { targetClientId: "client-abc" });
 
       let caught: unknown;
-      try {
-        handleHostBashResult({
-          body: bashBody(requestId),
-          headers: { "x-vellum-client-id": "client-xyz" },
-        });
-      } catch (e) {
+      await handleHostBashResult({
+        body: bashBody(requestId),
+        headers: { "x-vellum-client-id": "client-xyz" },
+      }).catch((e: unknown) => {
         caught = e;
-      }
+      });
 
       expect(caught).toBeInstanceOf(ForbiddenError);
       const msg = (caught as ForbiddenError).message;
@@ -408,18 +400,16 @@ describe("handleHostBashResult", () => {
       expect(msg).toContain("client-abc");
     });
 
-    test("interaction is NOT resolved on 403 (still pending)", () => {
+    test("interaction is NOT resolved on 403 (still pending)", async () => {
       const requestId = "req-targeted-mismatch-stays";
       registerPending(requestId, { targetClientId: "client-abc" });
 
-      try {
-        handleHostBashResult({
-          body: bashBody(requestId),
-          headers: { "x-vellum-client-id": "client-xyz" },
-        });
-      } catch {
+      await 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;
+)!.handler as (args: Record<string, unknown>) => Promise<unknown>;
 
 // ── Tests ────────────────────────────────────────────────────────────
 
@@ -212,7 +212,7 @@ describe("handleHostBrowserResult — same-actor guard", () => {
       ).toThrow(BadRequestError);
     });
 
-    test("interaction is NOT consumed on 400 (still pending)", () => {
+    test("interaction is NOT consumed on 400 (still pending)", async () => {
       const requestId = "browser-req-targeted-no-header-stays";
       pendingInteractions.register(requestId, {
         conversationId: "conv-1",
@@ -221,13 +221,11 @@ describe("handleHostBrowserResult — same-actor guard", () => {
         targetActorPrincipalId: "user-1",
       });
 
-      try {
-        handleHostBrowserResult({
-          body: { requestId, content: "ok", isError: false },
-        });
-      } catch {
+      await handleHostBrowserResult({
+        body: { requestId, content: "ok", isError: false },
+      }).catch(() => {
         // expected
-      }
+      });
 
       expect(pendingInteractions.get(requestId)).toBeDefined();
     });
@@ -256,7 +254,7 @@ describe("handleHostBrowserResult — same-actor guard", () => {
       ).toThrow(ForbiddenError);
     });
 
-    test("ForbiddenError message names both submitting and expected client", () => {
+    test("ForbiddenError message names both submitting and expected client", async () => {
       const requestId = "browser-req-targeted-mismatch-msg";
       pendingInteractions.register(requestId, {
         conversationId: "conv-1",
@@ -267,7 +265,7 @@ describe("handleHostBrowserResult — same-actor guard", () => {
 
       let caught: unknown;
       try {
-        handleHostBrowserResult({
+        await handleHostBrowserResult({
           body: { requestId, content: "ok", isError: false },
           headers: {
             "x-vellum-client-id": "client-B",
@@ -284,7 +282,7 @@ describe("handleHostBrowserResult — same-actor guard", () => {
       expect(msg).toContain("client-B");
     });
 
-    test("interaction is NOT consumed on 403 (still pending)", () => {
+    test("interaction is NOT consumed on 403 (still pending)", async () => {
       const requestId = "browser-req-targeted-mismatch-stays";
       pendingInteractions.register(requestId, {
         conversationId: "conv-1",
@@ -293,17 +291,15 @@ describe("handleHostBrowserResult — same-actor guard", () => {
         targetActorPrincipalId: "user-1",
       });
 
-      try {
-        handleHostBrowserResult({
-          body: { requestId, content: "ok", isError: false },
-          headers: {
-            "x-vellum-client-id": "client-B",
-            "x-vellum-actor-principal-id": "user-1",
-          },
-        });
-      } catch {
+      await 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();
     });
@@ -369,7 +365,7 @@ describe("handleHostBrowserResult — same-actor guard", () => {
       ).toThrow(ForbiddenError);
     });
 
-    test("interaction NOT consumed on actor-mismatch 403", () => {
+    test("interaction NOT consumed on actor-mismatch 403", async () => {
       const requestId = "browser-req-actor-mismatch-stays";
       pendingInteractions.register(requestId, {
         conversationId: "conv-1",
@@ -378,17 +374,15 @@ describe("handleHostBrowserResult — same-actor guard", () => {
         targetActorPrincipalId: "user-1",
       });
 
-      try {
-        handleHostBrowserResult({
-          body: { requestId, content: "ok", isError: false },
-          headers: {
-            "x-vellum-client-id": "client-A",
-            "x-vellum-actor-principal-id": "user-2",
-          },
-        });
-      } catch {
+      await 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;
+)!.handler as (args: Record<string, unknown>) => Promise<unknown>;
 
 // ── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -226,15 +226,13 @@ describe("handleHostCuResult — Phase 2 targetClientId guard", () => {
       ).toThrow(BadRequestError);
     });
 
-    test("interaction is NOT resolved on 400 (still pending)", () => {
+    test("interaction is NOT resolved on 400 (still pending)", async () => {
       const requestId = "req-cu-targeted-no-header-stays";
       registerPending(requestId, { targetClientId: "client-A" });
 
-      try {
-        handleHostCuResult({ body: cuBody(requestId) });
-      } catch {
+      await handleHostCuResult({ body: cuBody(requestId) }).catch(() => {
         // expected
-      }
+      });
 
       expect(resolvedIds).not.toContain(requestId);
       expect(pendingStore.has(requestId)).toBe(true);
@@ -256,19 +254,17 @@ describe("handleHostCuResult — Phase 2 targetClientId guard", () => {
       ).toThrow(ForbiddenError);
     });
 
-    test("ForbiddenError message names both submitting and expected client", () => {
+    test("ForbiddenError message names both submitting and expected client", async () => {
       const requestId = "req-cu-targeted-mismatch-msg";
       registerPending(requestId, { targetClientId: "client-A" });
 
       let caught: unknown;
-      try {
-        handleHostCuResult({
-          body: cuBody(requestId),
-          headers: { "x-vellum-client-id": "client-B" },
-        });
-      } catch (e) {
+      await handleHostCuResult({
+        body: cuBody(requestId),
+        headers: { "x-vellum-client-id": "client-B" },
+      }).catch((e: unknown) => {
         caught = e;
-      }
+      });
 
       expect(caught).toBeInstanceOf(ForbiddenError);
       const msg = (caught as ForbiddenError).message;
@@ -276,18 +272,16 @@ describe("handleHostCuResult — Phase 2 targetClientId guard", () => {
       expect(msg).toContain("client-A");
     });
 
-    test("interaction is NOT consumed on 403 (pendingInteractions.get still returns it)", () => {
+    test("interaction is NOT consumed on 403 (pendingInteractions.get still returns it)", async () => {
       const requestId = "req-cu-targeted-mismatch-stays";
       registerPending(requestId, { targetClientId: "client-A" });
 
-      try {
-        handleHostCuResult({
-          body: cuBody(requestId),
-          headers: { "x-vellum-client-id": "client-B" },
-        });
-      } catch {
+      await handleHostCuResult({
+        body: cuBody(requestId),
+        headers: { "x-vellum-client-id": "client-B" },
+      }).catch(() => {
         // expected
-      }
+      });
 
       expect(resolvedIds).not.toContain(requestId);
       expect(pendingStore.has(requestId)).toBe(true);
@@ -331,22 +325,20 @@ describe("handleHostCuResult — Phase 2 targetClientId guard", () => {
       ).toThrow(ForbiddenError);
     });
 
-    test("interaction NOT consumed on 403 actor mismatch", () => {
+    test("interaction NOT consumed on 403 actor mismatch", async () => {
       const requestId = "req-cu-actor-mismatch-stays";
       actorPrincipalByClient.set("client-A", "user-1");
       registerPending(requestId, { targetClientId: "client-A" });
 
-      try {
-        handleHostCuResult({
-          body: cuBody(requestId),
-          headers: {
-            "x-vellum-client-id": "client-A",
-            "x-vellum-actor-principal-id": "user-2",
-          },
-        });
-      } catch {
+      await 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;
+)!.handler as (args: Record<string, unknown>) => Promise<unknown>;
 
 // ── Helpers ─────────────────────────────────────────────────────────────────
 
@@ -189,15 +189,13 @@ describe("handleHostFileResult — targetClientId guard", () => {
       ).toThrow(BadRequestError);
     });
 
-    test("interaction is NOT resolved on 400 (still pending)", () => {
+    test("interaction is NOT resolved on 400 (still pending)", async () => {
       const requestId = "req-file-targeted-no-header-stays";
       registerPending(requestId, { targetClientId: "client-A" });
 
-      try {
-        handleHostFileResult({ body: fileBody(requestId) });
-      } catch {
+      await handleHostFileResult({ body: fileBody(requestId) }).catch(() => {
         // expected
-      }
+      });
 
       expect(resolvedIds).not.toContain(requestId);
       expect(pendingStore.has(requestId)).toBe(true);
@@ -219,19 +217,17 @@ describe("handleHostFileResult — targetClientId guard", () => {
       ).toThrow(ForbiddenError);
     });
 
-    test("ForbiddenError message names both submitting and expected client", () => {
+    test("ForbiddenError message names both submitting and expected client", async () => {
       const requestId = "req-file-targeted-mismatch-msg";
       registerPending(requestId, { targetClientId: "client-A" });
 
       let caught: unknown;
-      try {
-        handleHostFileResult({
-          body: fileBody(requestId),
-          headers: { "x-vellum-client-id": "client-B" },
-        });
-      } catch (e) {
+      await handleHostFileResult({
+        body: fileBody(requestId),
+        headers: { "x-vellum-client-id": "client-B" },
+      }).catch((e: unknown) => {
         caught = e;
-      }
+      });
 
       expect(caught).toBeInstanceOf(ForbiddenError);
       const msg = (caught as ForbiddenError).message;
@@ -239,18 +235,16 @@ describe("handleHostFileResult — targetClientId guard", () => {
       expect(msg).toContain("client-A");
     });
 
-    test("interaction is NOT consumed on 403 (pendingInteractions.get still returns it)", () => {
+    test("interaction is NOT consumed on 403 (pendingInteractions.get still returns it)", async () => {
       const requestId = "req-file-targeted-mismatch-stays";
       registerPending(requestId, { targetClientId: "client-A" });
 
-      try {
-        handleHostFileResult({
-          body: fileBody(requestId),
-          headers: { "x-vellum-client-id": "client-B" },
-        });
-      } catch {
+      await handleHostFileResult({
+        body: fileBody(requestId),
+        headers: { "x-vellum-client-id": "client-B" },
+      }).catch(() => {
         // expected
-      }
+      });
 
       expect(resolvedIds).not.toContain(requestId);
       expect(pendingStore.has(requestId)).toBe(true);
@@ -306,22 +300,20 @@ describe("handleHostFileResult — targetClientId guard", () => {
       ).toThrow(ForbiddenError);
     });
 
-    test("interaction is NOT consumed on actor-mismatch 403", () => {
+    test("interaction is NOT consumed on actor-mismatch 403", async () => {
       const requestId = "req-file-actor-mismatch-stays";
       clientActors.set("client-A", "actor-1");
       registerPending(requestId, { targetClientId: "client-A" });
 
-      try {
-        handleHostFileResult({
-          body: fileBody(requestId),
-          headers: {
-            "x-vellum-client-id": "client-A",
-            "x-vellum-actor-principal-id": "actor-2",
-          },
-        });
-      } catch {
+      await 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);
@@ -360,19 +352,17 @@ describe("handleHostFileResult — targetClientId guard", () => {
       ).toThrow(ForbiddenError);
     });
 
-    test("interaction is NOT consumed when submitting actor is missing", () => {
+    test("interaction is NOT consumed when submitting actor is missing", async () => {
       const requestId = "req-file-actor-missing-stays";
       clientActors.set("client-A", "actor-1");
       registerPending(requestId, { targetClientId: "client-A" });
 
-      try {
-        handleHostFileResult({
-          body: fileBody(requestId),
-          headers: { "x-vellum-client-id": "client-A" },
-        });
-      } catch {
+      await handleHostFileResult({
+        body: fileBody(requestId),
+        headers: { "x-vellum-client-id": "client-A" },
+      }).catch(() => {
         // expected
-      }
+      });
 
       expect(resolvedIds).not.toContain(requestId);
       expect(pendingStore.has(requestId)).toBe(true);
@@ -398,21 +388,19 @@ describe("handleHostFileResult — targetClientId guard", () => {
       ).toThrow(ForbiddenError);
     });
 
-    test("interaction is NOT consumed when target client has no stored actor", () => {
+    test("interaction is NOT consumed when target client has no stored actor", async () => {
       const requestId = "req-file-target-no-actor-stays";
       registerPending(requestId, { targetClientId: "client-A" });
 
-      try {
-        handleHostFileResult({
-          body: fileBody(requestId),
-          headers: {
-            "x-vellum-client-id": "client-A",
-            "x-vellum-actor-principal-id": "actor-1",
-          },
-        });
-      } catch {
+      await 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);