@vellumai/assistant 0.5.10 → 0.5.12

package/src/__tests__/messaging-skill-split.test.ts

@@ -18,8 +18,6 @@ function loadManifest(skillDir: string) {
 const messagingManifest = loadManifest("messaging");
 const gmailManifest = loadManifest("gmail");
 const sequencesManifest = loadManifest("sequences");
-const slackManifest = loadManifest("slack");
-
 describe("Messaging skill split", () => {
   const expectedMessagingToolNames = [
     "messaging_auth_test",
@@ -62,8 +60,6 @@ describe("Messaging skill split", () => {
     "sequence_analytics",
   ];
 
-  const expectedSlackToolNames = ["slack_add_reaction", "slack_leave_channel"];
-
   test("messaging/TOOLS.json contains all expected messaging_* tool names", () => {
     const names: string[] = messagingManifest.tools.map(
       (t: { name: string }) => t.name,
@@ -103,26 +99,15 @@ describe("Messaging skill split", () => {
     }
   });
 
-  test("slack/TOOLS.json contains all expected slack_* tool names", () => {
-    const names: string[] = slackManifest.tools.map(
-      (t: { name: string }) => t.name,
-    );
-    for (const name of expectedSlackToolNames) {
-      expect(names).toContain(name);
-    }
-  });
-
   test("total tools across all manifests meets expected minimum", () => {
     const expectedMinimum =
       expectedMessagingToolNames.length +
       expectedGmailToolNames.length +
-      expectedSequenceToolNames.length +
-      expectedSlackToolNames.length;
+      expectedSequenceToolNames.length;
     const totalTools =
       messagingManifest.tools.length +
       gmailManifest.tools.length +
-      sequencesManifest.tools.length +
-      slackManifest.tools.length;
+      sequencesManifest.tools.length;
     expect(totalTools).toBeGreaterThanOrEqual(expectedMinimum);
   });
 

package/src/__tests__/notification-telegram-adapter.test.ts

@@ -6,6 +6,9 @@ const deliveryCalls: Array<{
   bearerToken?: string;
 }> = [];
 
+/** When true, deliverChannelReply throws if the payload contains an approval field. */
+let rejectRichDelivery = false;
+
 mock.module("../config/env.js", () => ({
   isHttpAuthDisabled: () => true,
   getGatewayInternalBaseUrl: () => "http://gateway.internal",
@@ -17,6 +20,9 @@ mock.module("../runtime/gateway-client.js", () => ({
     payload: Record<string, unknown>,
     bearerToken?: string,
   ) => {
+    if (rejectRichDelivery && payload.approval) {
+      throw new Error("Telegram API error: buttons not supported");
+    }
     deliveryCalls.push({ url, payload, bearerToken });
   },
 }));
@@ -60,6 +66,7 @@ function makeDestination(
 describe("TelegramAdapter", () => {
   beforeEach(() => {
     deliveryCalls.length = 0;
+    rejectRichDelivery = false;
   });
 
   test("prefers deliveryText and does not append deterministic label", async () => {
@@ -156,4 +163,122 @@ describe("TelegramAdapter", () => {
     );
     expect(deliveryCalls[2]?.payload.text).toBe("watcher escalation");
   });
+
+  // ── Access request inline keyboard tests ──────────────────────────────
+
+  test("includes approval payload with inline buttons for access requests", async () => {
+    const adapter = new TelegramAdapter();
+    const payload = makePayload({
+      sourceEventName: "ingress.access_request",
+      copy: {
+        title: "Access Request",
+        body: "Someone is requesting access.",
+        deliveryText: "Someone is requesting access to the assistant.",
+      },
+      contextPayload: {
+        requestId: "req-abc-123",
+        requestCode: "XYZW",
+        senderIdentifier: "Marina",
+        sourceChannel: "telegram",
+      },
+    });
+
+    const result = await adapter.send(payload, makeDestination());
+
+    expect(result.success).toBe(true);
+    expect(deliveryCalls).toHaveLength(1);
+
+    const call = deliveryCalls[0]!;
+    expect(call.payload.text).toBe(
+      "Someone is requesting access to the assistant.",
+    );
+
+    const approval = call.payload.approval as {
+      requestId: string;
+      actions: Array<{ id: string; label: string }>;
+      plainTextFallback: string;
+    };
+    expect(approval).toBeDefined();
+    expect(approval.requestId).toBe("req-abc-123");
+    expect(approval.actions).toHaveLength(2);
+    expect(approval.actions[0]).toEqual({
+      id: "approve_once",
+      label: "Approve once",
+    });
+    expect(approval.actions[1]).toEqual({ id: "reject", label: "Reject" });
+    expect(approval.plainTextFallback).toContain("XYZW");
+  });
+
+  test("sends plain text without approval when contextPayload is missing", async () => {
+    const adapter = new TelegramAdapter();
+    const payload = makePayload({
+      sourceEventName: "ingress.access_request",
+      copy: {
+        title: "Access Request",
+        body: "Someone is requesting access.",
+      },
+    });
+
+    const result = await adapter.send(payload, makeDestination());
+
+    expect(result.success).toBe(true);
+    expect(deliveryCalls).toHaveLength(1);
+    expect(deliveryCalls[0]?.payload.approval).toBeUndefined();
+  });
+
+  test("sends plain text without approval when requestId is missing from contextPayload", async () => {
+    const adapter = new TelegramAdapter();
+    const payload = makePayload({
+      sourceEventName: "ingress.access_request",
+      copy: {
+        title: "Access Request",
+        body: "Someone is requesting access.",
+      },
+      contextPayload: {
+        senderIdentifier: "Marina",
+        sourceChannel: "telegram",
+        // no requestId
+      },
+    });
+
+    const result = await adapter.send(payload, makeDestination());
+
+    expect(result.success).toBe(true);
+    expect(deliveryCalls).toHaveLength(1);
+    expect(deliveryCalls[0]?.payload.approval).toBeUndefined();
+  });
+
+  test("falls back to plain text with instructions when rich delivery fails", async () => {
+    rejectRichDelivery = true;
+
+    const adapter = new TelegramAdapter();
+    const payload = makePayload({
+      sourceEventName: "ingress.access_request",
+      copy: {
+        title: "Access Request",
+        body: "Someone is requesting access.",
+        deliveryText: "Someone is requesting access to the assistant.",
+      },
+      contextPayload: {
+        requestId: "req-abc-123",
+        requestCode: "XYZW",
+        senderIdentifier: "Marina",
+        sourceChannel: "telegram",
+      },
+    });
+
+    const result = await adapter.send(payload, makeDestination());
+
+    expect(result.success).toBe(true);
+    // Rich delivery threw, so only the plain-text fallback should be recorded.
+    expect(deliveryCalls).toHaveLength(1);
+    const call = deliveryCalls[0]!;
+    // No approval payload in the fallback delivery.
+    expect(call.payload.approval).toBeUndefined();
+    // The fallback text should include the original message AND the
+    // typed-command instructions from plainTextFallback.
+    const text = call.payload.text as string;
+    expect(text).toContain("Someone is requesting access to the assistant.");
+    expect(text).toContain("XYZW");
+  });
 });