@actagent/googlechat 2026.6.2

package/src/approval-card-actions.test.ts

@@ -0,0 +1,113 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import {
+  clearGoogleChatApprovalCardBindingsForTest,
+  registerGoogleChatManualApprovalFollowupSuppression,
+  registerGoogleChatApprovalCardBinding,
+  shouldSuppressGoogleChatManualExecApprovalFollowupPayload,
+  shouldSuppressGoogleChatManualExecApprovalFollowupText,
+} from "./approval-card-actions.js";
+
+const approvalId = "12345678-1234-1234-1234-123456789012";
+type TestExecApprovalDecision = "allow-once" | "allow-always" | "deny";
+let tokenCounter = 0;
+
+function registerExecApprovalCard(overrides?: {
+  approvalId?: string;
+  expiresAtMs?: number;
+  allowedDecisions?: readonly TestExecApprovalDecision[];
+}): void {
+  registerGoogleChatApprovalCardBinding({
+    token: `token-${tokenCounter++}`,
+    accountId: "default",
+    approvalId: overrides?.approvalId ?? approvalId,
+    approvalKind: "exec",
+    decision: "allow-once",
+    allowedDecisions: overrides?.allowedDecisions ?? ["allow-once", "deny"],
+    spaceName: "spaces/AAA",
+    messageName: "spaces/AAA/messages/msg-1",
+    expiresAtMs: overrides?.expiresAtMs ?? Date.now() + 60_000,
+  });
+}
+
+describe("Google Chat approval card action registry", () => {
+  beforeEach(() => {
+    clearGoogleChatApprovalCardBindingsForTest();
+    tokenCounter = 0;
+  });
+
+  it("suppresses manual exec approval follow-up text for an active native card", () => {
+    registerExecApprovalCard();
+
+    expect(
+      shouldSuppressGoogleChatManualExecApprovalFollowupText(
+        `I need approval.\nReply with:\n/approve ${approvalId.slice(0, 8)} allow-once`,
+      ),
+    ).toBe(true);
+    expect(
+      shouldSuppressGoogleChatManualExecApprovalFollowupText(
+        `Run this if needed: \`/approve ${approvalId} deny\``,
+      ),
+    ).toBe(true);
+  });
+
+  it("suppresses manual exec approval follow-up text after native delivery before token binding", () => {
+    registerGoogleChatManualApprovalFollowupSuppression({
+      approvalId,
+      approvalKind: "exec",
+      allowedDecisions: ["allow-once", "deny"],
+      expiresAtMs: Date.now() + 60_000,
+    });
+
+    expect(
+      shouldSuppressGoogleChatManualExecApprovalFollowupText(
+        `Please reply with:\n/approve ${approvalId.slice(0, 8)} allow-once`,
+      ),
+    ).toBe(true);
+  });
+
+  it("keeps unrelated, expired, and non-sendable approval text visible", () => {
+    registerExecApprovalCard({ expiresAtMs: Date.now() - 1 });
+    expect(
+      shouldSuppressGoogleChatManualExecApprovalFollowupText(
+        `/approve ${approvalId.slice(0, 8)} allow-once`,
+      ),
+    ).toBe(false);
+
+    clearGoogleChatApprovalCardBindingsForTest();
+    registerExecApprovalCard();
+    expect(
+      shouldSuppressGoogleChatManualExecApprovalFollowupText("/approve deadbeef allow-once"),
+    ).toBe(false);
+    expect(
+      shouldSuppressGoogleChatManualExecApprovalFollowupText(`/approve ${approvalId} nope`),
+    ).toBe(false);
+  });
+
+  it("suppresses only text-only manual approval follow-up payloads", () => {
+    registerExecApprovalCard();
+
+    expect(
+      shouldSuppressGoogleChatManualExecApprovalFollowupPayload({
+        text: `/approve ${approvalId.slice(0, 8)} allow-once`,
+      }),
+    ).toBe(true);
+    expect(
+      shouldSuppressGoogleChatManualExecApprovalFollowupPayload({
+        text: `/approve ${approvalId.slice(0, 8)} allow-once`,
+        mediaUrl: "https://example.test/image.png",
+      }),
+    ).toBe(false);
+    expect(
+      shouldSuppressGoogleChatManualExecApprovalFollowupPayload({
+        text: `/approve ${approvalId.slice(0, 8)} allow-once`,
+        channelData: { execApproval: { approvalId } },
+      }),
+    ).toBe(true);
+    expect(
+      shouldSuppressGoogleChatManualExecApprovalFollowupPayload({
+        text: `/approve ${approvalId.slice(0, 8)} allow-once`,
+        presentation: { blocks: [] },
+      }),
+    ).toBe(false);
+  });
+});

package/src/approval-card-actions.ts

@@ -0,0 +1,307 @@
+import crypto from "node:crypto";
+import type { ExecApprovalDecision } from "actagent/plugin-sdk/approval-runtime";
+import { normalizeOptionalString } from "actagent/plugin-sdk/string-coerce-runtime";
+import type { GoogleChatActionParameter, GoogleChatEvent } from "./types.js";
+
+export const GOOGLECHAT_APPROVAL_ACTION = "actagent.approval";
+const GOOGLECHAT_APPROVAL_ACTION_PARAM = "actagent_action";
+const GOOGLECHAT_APPROVAL_TOKEN_PARAM = "token";
+const GOOGLECHAT_APPROVAL_ACTION_VALUE = "approval";
+const MANUAL_EXEC_APPROVAL_COMMAND_RE =
+  /(?:^|[\s`])\/approve[ \t]+([^ \t\r\n`|]+)[ \t]+(allow-once|allow-always|deny)(?=$|[\s`|.,;:!?])/giu;
+
+export type GoogleChatApprovalCardBinding = {
+  token: string;
+  accountId: string;
+  approvalId: string;
+  approvalKind: "exec" | "plugin";
+  decision: ExecApprovalDecision;
+  allowedDecisions: readonly ExecApprovalDecision[];
+  spaceName: string;
+  messageName: string;
+  threadName?: string | null;
+  expiresAtMs: number;
+};
+
+const approvalCardBindings = new Map<string, GoogleChatApprovalCardBinding>();
+const approvalCardResolvingTokens = new Set<string>();
+
+type GoogleChatManualApprovalSuppressionPayload = {
+  text?: string;
+  mediaUrl?: string;
+  mediaUrls?: string[];
+  presentation?: unknown;
+  interactive?: unknown;
+  channelData?: unknown;
+  btw?: unknown;
+  spokenText?: unknown;
+  ttsSupplement?: unknown;
+};
+
+type GoogleChatManualApprovalFollowupSuppression = {
+  approvalId: string;
+  approvalKind: "exec" | "plugin";
+  allowedDecisions: readonly ExecApprovalDecision[];
+  expiresAtMs: number;
+};
+
+export type GoogleChatApprovalCardClaim =
+  | { kind: "claimed"; binding: GoogleChatApprovalCardBinding }
+  | { kind: "missing" }
+  | { kind: "in-flight" };
+
+const manualApprovalFollowupSuppressions = new Map<
+  string,
+  GoogleChatManualApprovalFollowupSuppression
+>();
+
+export function createGoogleChatApprovalToken(): string {
+  return crypto.randomBytes(18).toString("base64url");
+}
+
+export function buildGoogleChatApprovalActionParameters(
+  token: string,
+): GoogleChatActionParameter[] {
+  return [
+    { key: GOOGLECHAT_APPROVAL_ACTION_PARAM, value: GOOGLECHAT_APPROVAL_ACTION_VALUE },
+    { key: GOOGLECHAT_APPROVAL_TOKEN_PARAM, value: token },
+  ];
+}
+
+function collectEventParameters(event: GoogleChatEvent): Record<string, string> {
+  const params: Record<string, string> = {};
+  for (const [key, value] of Object.entries(event.common?.parameters ?? {})) {
+    if (typeof value === "string") {
+      params[key] = value;
+    }
+  }
+  for (const [key, value] of Object.entries(event.commonEventObject?.parameters ?? {})) {
+    if (typeof value === "string") {
+      params[key] = value;
+    }
+  }
+  for (const item of event.action?.parameters ?? []) {
+    if (typeof item.key === "string" && typeof item.value === "string") {
+      params[item.key] = item.value;
+    }
+  }
+  return params;
+}
+
+export function readGoogleChatApprovalActionToken(event: GoogleChatEvent): string | null {
+  const params = collectEventParameters(event);
+  if (params[GOOGLECHAT_APPROVAL_ACTION_PARAM] !== GOOGLECHAT_APPROVAL_ACTION_VALUE) {
+    return null;
+  }
+  const actionName =
+    normalizeOptionalString(event.action?.actionMethodName) ??
+    normalizeOptionalString(event.common?.invokedFunction) ??
+    normalizeOptionalString(event.commonEventObject?.invokedFunction);
+  if (
+    actionName &&
+    actionName !== GOOGLECHAT_APPROVAL_ACTION &&
+    !actionName.startsWith("https://")
+  ) {
+    return null;
+  }
+  return normalizeOptionalString(params[GOOGLECHAT_APPROVAL_TOKEN_PARAM]) ?? null;
+}
+
+export function registerGoogleChatApprovalCardBinding(
+  binding: GoogleChatApprovalCardBinding,
+): boolean {
+  if (binding.expiresAtMs <= Date.now()) {
+    return false;
+  }
+  approvalCardBindings.set(binding.token, binding);
+  registerGoogleChatManualApprovalFollowupSuppression({
+    approvalId: binding.approvalId,
+    approvalKind: binding.approvalKind,
+    allowedDecisions: binding.allowedDecisions,
+    expiresAtMs: binding.expiresAtMs,
+  });
+  return true;
+}
+
+export function getGoogleChatApprovalCardBinding(
+  token: string,
+): GoogleChatApprovalCardBinding | null {
+  const binding = approvalCardBindings.get(token);
+  if (!binding) {
+    return null;
+  }
+  if (binding.expiresAtMs <= Date.now()) {
+    approvalCardBindings.delete(token);
+    return null;
+  }
+  return binding;
+}
+
+function normalizeApprovalRef(value: string): string | null {
+  const normalized = value.trim().toLowerCase();
+  return normalized ? normalized : null;
+}
+
+function manualApprovalFollowupSuppressionKey(approvalId: string): string | null {
+  return normalizeApprovalRef(approvalId);
+}
+
+export function registerGoogleChatManualApprovalFollowupSuppression(
+  suppression: GoogleChatManualApprovalFollowupSuppression,
+): boolean {
+  if (suppression.expiresAtMs <= Date.now()) {
+    return false;
+  }
+  const key = manualApprovalFollowupSuppressionKey(suppression.approvalId);
+  if (!key) {
+    return false;
+  }
+  manualApprovalFollowupSuppressions.set(key, suppression);
+  return true;
+}
+
+export function unregisterGoogleChatManualApprovalFollowupSuppression(approvalId: string): void {
+  const key = manualApprovalFollowupSuppressionKey(approvalId);
+  if (key) {
+    manualApprovalFollowupSuppressions.delete(key);
+  }
+}
+
+function approvalRefMatches(bindingApprovalId: string, approvalRef: string): boolean {
+  const normalizedBindingId = normalizeApprovalRef(bindingApprovalId);
+  const normalizedRef = normalizeApprovalRef(approvalRef);
+  if (!normalizedBindingId || !normalizedRef) {
+    return false;
+  }
+  return (
+    normalizedRef === normalizedBindingId ||
+    (normalizedRef.length >= 8 && normalizedBindingId.startsWith(normalizedRef))
+  );
+}
+
+function pruneExpiredGoogleChatApprovalCardBindings(nowMs: number): void {
+  for (const [token, binding] of approvalCardBindings) {
+    if (binding.expiresAtMs <= nowMs) {
+      approvalCardBindings.delete(token);
+      approvalCardResolvingTokens.delete(token);
+    }
+  }
+  for (const [approvalId, suppression] of manualApprovalFollowupSuppressions) {
+    if (suppression.expiresAtMs <= nowMs) {
+      manualApprovalFollowupSuppressions.delete(approvalId);
+    }
+  }
+}
+
+function hasActiveGoogleChatExecApprovalCardForManualCommand(params: {
+  approvalRef: string;
+  decision: ExecApprovalDecision;
+  nowMs: number;
+}): boolean {
+  pruneExpiredGoogleChatApprovalCardBindings(params.nowMs);
+  for (const binding of approvalCardBindings.values()) {
+    if (
+      binding.approvalKind === "exec" &&
+      binding.allowedDecisions.includes(params.decision) &&
+      approvalRefMatches(binding.approvalId, params.approvalRef)
+    ) {
+      return true;
+    }
+  }
+  for (const suppression of manualApprovalFollowupSuppressions.values()) {
+    if (
+      suppression.approvalKind === "exec" &&
+      suppression.allowedDecisions.includes(params.decision) &&
+      approvalRefMatches(suppression.approvalId, params.approvalRef)
+    ) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export function shouldSuppressGoogleChatManualExecApprovalFollowupText(
+  text: string,
+  nowMs = Date.now(),
+): boolean {
+  for (const match of text.matchAll(MANUAL_EXEC_APPROVAL_COMMAND_RE)) {
+    const approvalRef = match[1];
+    const decision = match[2]?.toLowerCase() as ExecApprovalDecision | undefined;
+    if (
+      approvalRef &&
+      decision &&
+      hasActiveGoogleChatExecApprovalCardForManualCommand({ approvalRef, decision, nowMs })
+    ) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function hasSendableMedia(payload: GoogleChatManualApprovalSuppressionPayload): boolean {
+  return Boolean(payload.mediaUrl?.trim() || payload.mediaUrls?.some((url) => url.trim()));
+}
+
+function hasStructuredPayloadPart(payload: GoogleChatManualApprovalSuppressionPayload): boolean {
+  return Boolean(
+    hasSendableMedia(payload) ||
+    payload.presentation ||
+    payload.interactive ||
+    payload.btw ||
+    payload.spokenText ||
+    payload.ttsSupplement,
+  );
+}
+
+export function shouldSuppressGoogleChatManualExecApprovalFollowupPayload(
+  payload: GoogleChatManualApprovalSuppressionPayload,
+  nowMs = Date.now(),
+): boolean {
+  const text = payload.text?.trim();
+  if (!text || hasStructuredPayloadPart(payload)) {
+    return false;
+  }
+  return shouldSuppressGoogleChatManualExecApprovalFollowupText(text, nowMs);
+}
+
+export function claimGoogleChatApprovalCardBinding(token: string): GoogleChatApprovalCardClaim {
+  const binding = getGoogleChatApprovalCardBinding(token);
+  if (!binding) {
+    return { kind: "missing" };
+  }
+  if (approvalCardResolvingTokens.has(token)) {
+    return { kind: "in-flight" };
+  }
+  approvalCardResolvingTokens.add(token);
+  return { kind: "claimed", binding };
+}
+
+export function completeGoogleChatApprovalCardBinding(token: string): void {
+  const binding = approvalCardBindings.get(token);
+  approvalCardResolvingTokens.delete(token);
+  approvalCardBindings.delete(token);
+  if (binding) {
+    unregisterGoogleChatManualApprovalFollowupSuppression(binding.approvalId);
+  }
+}
+
+export function releaseGoogleChatApprovalCardBinding(token: string): void {
+  approvalCardResolvingTokens.delete(token);
+}
+
+export function unregisterGoogleChatApprovalCardBindings(tokens: readonly string[]): void {
+  for (const token of tokens) {
+    const binding = approvalCardBindings.get(token);
+    approvalCardBindings.delete(token);
+    approvalCardResolvingTokens.delete(token);
+    if (binding) {
+      unregisterGoogleChatManualApprovalFollowupSuppression(binding.approvalId);
+    }
+  }
+}
+
+export function clearGoogleChatApprovalCardBindingsForTest(): void {
+  approvalCardBindings.clear();
+  approvalCardResolvingTokens.clear();
+  manualApprovalFollowupSuppressions.clear();
+}

package/src/approval-card-click.test.ts

@@ -0,0 +1,279 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  buildGoogleChatApprovalActionParameters,
+  clearGoogleChatApprovalCardBindingsForTest,
+  registerGoogleChatApprovalCardBinding,
+} from "./approval-card-actions.js";
+import { maybeHandleGoogleChatApprovalCardClick } from "./approval-card-click.js";
+import type { WebhookTarget } from "./monitor-types.js";
+import type { GoogleChatEvent } from "./types.js";
+
+const resolveApprovalOverGateway = vi.hoisted(() => vi.fn());
+
+vi.mock("actagent/plugin-sdk/approval-gateway-runtime", () => ({
+  resolveApprovalOverGateway,
+}));
+
+function createTarget(): WebhookTarget {
+  return {
+    account: {
+      accountId: "default",
+      enabled: true,
+      credentialSource: "inline",
+      config: {
+        dm: { allowFrom: ["users/123"] },
+      },
+    },
+    config: {
+      channels: {
+        googlechat: {
+          dm: { allowFrom: ["users/123"] },
+        },
+      },
+    },
+    runtime: { log: vi.fn(), error: vi.fn() },
+    core: {} as never,
+    path: "/googlechat",
+    mediaMaxMb: 20,
+  };
+}
+
+function createCardClickEvent(token: string, userName = "users/123"): GoogleChatEvent {
+  return {
+    type: "CARD_CLICKED",
+    space: { name: "spaces/AAA" },
+    message: { name: "spaces/AAA/messages/msg-1" },
+    user: { name: userName },
+    action: {
+      actionMethodName: "actagent.approval",
+      parameters: buildGoogleChatApprovalActionParameters(token),
+    },
+  };
+}
+
+describe("maybeHandleGoogleChatApprovalCardClick", () => {
+  beforeEach(() => {
+    clearGoogleChatApprovalCardBindingsForTest();
+    resolveApprovalOverGateway.mockReset();
+  });
+
+  it("authorizes the Chat actor and resolves the bound approval over the gateway", async () => {
+    registerGoogleChatApprovalCardBinding({
+      token: "token-1",
+      accountId: "default",
+      approvalId: "approval-1",
+      approvalKind: "exec",
+      decision: "allow-once",
+      allowedDecisions: ["allow-once", "deny"],
+      spaceName: "spaces/AAA",
+      messageName: "spaces/AAA/messages/msg-1",
+      expiresAtMs: Date.now() + 60_000,
+    });
+
+    await expect(
+      maybeHandleGoogleChatApprovalCardClick({
+        event: createCardClickEvent("token-1"),
+        target: createTarget(),
+      }),
+    ).resolves.toBe(true);
+
+    expect(resolveApprovalOverGateway).toHaveBeenCalledWith({
+      cfg: expect.any(Object),
+      approvalId: "approval-1",
+      decision: "allow-once",
+      senderId: "users/123",
+      allowPluginFallback: true,
+      clientDisplayName: "Google Chat approval (users/123)",
+    });
+  });
+
+  it("accepts add-on clicks that only carry approval token parameters", async () => {
+    registerGoogleChatApprovalCardBinding({
+      token: "token-addon",
+      accountId: "default",
+      approvalId: "approval-addon",
+      approvalKind: "exec",
+      decision: "allow-once",
+      allowedDecisions: ["allow-once", "deny"],
+      spaceName: "spaces/AAA",
+      messageName: "spaces/AAA/messages/msg-1",
+      expiresAtMs: Date.now() + 60_000,
+    });
+
+    await expect(
+      maybeHandleGoogleChatApprovalCardClick({
+        event: {
+          type: "CARD_CLICKED",
+          space: { name: "spaces/AAA" },
+          message: { name: "spaces/AAA/messages/msg-1" },
+          user: { name: "users/123" },
+          commonEventObject: {
+            parameters: {
+              actagent_action: "approval",
+              token: "token-addon",
+            },
+          },
+        },
+        target: createTarget(),
+      }),
+    ).resolves.toBe(true);
+
+    expect(resolveApprovalOverGateway).toHaveBeenCalledWith(
+      expect.objectContaining({
+        approvalId: "approval-addon",
+        decision: "allow-once",
+      }),
+    );
+  });
+
+  it("accepts standard cardsV2 clicks with common parameters", async () => {
+    registerGoogleChatApprovalCardBinding({
+      token: "token-common",
+      accountId: "default",
+      approvalId: "approval-common",
+      approvalKind: "plugin",
+      decision: "deny",
+      allowedDecisions: ["allow-once", "deny"],
+      spaceName: "spaces/AAA",
+      messageName: "spaces/AAA/messages/msg-1",
+      expiresAtMs: Date.now() + 60_000,
+    });
+
+    await expect(
+      maybeHandleGoogleChatApprovalCardClick({
+        event: {
+          type: "CARD_CLICKED",
+          space: { name: "spaces/AAA" },
+          message: { name: "spaces/AAA/messages/msg-1" },
+          user: { name: "users/123" },
+          common: {
+            invokedFunction: "actagent.approval",
+            parameters: {
+              actagent_action: "approval",
+              token: "token-common",
+            },
+          },
+        },
+        target: createTarget(),
+      }),
+    ).resolves.toBe(true);
+
+    expect(resolveApprovalOverGateway).toHaveBeenCalledWith(
+      expect.objectContaining({
+        approvalId: "approval-common",
+        decision: "deny",
+        allowPluginFallback: false,
+      }),
+    );
+  });
+
+  it("accepts endpoint URL invoked functions for app-url card actions", async () => {
+    registerGoogleChatApprovalCardBinding({
+      token: "token-url",
+      accountId: "default",
+      approvalId: "approval-url",
+      approvalKind: "exec",
+      decision: "allow-once",
+      allowedDecisions: ["allow-once", "deny"],
+      spaceName: "spaces/AAA",
+      messageName: "spaces/AAA/messages/msg-1",
+      expiresAtMs: Date.now() + 60_000,
+    });
+
+    await expect(
+      maybeHandleGoogleChatApprovalCardClick({
+        event: {
+          type: "CARD_CLICKED",
+          space: { name: "spaces/AAA" },
+          message: { name: "spaces/AAA/messages/msg-1" },
+          user: { name: "users/123" },
+          commonEventObject: {
+            invokedFunction: "https://chat-app.example.test/googlechat",
+            parameters: {
+              actagent_action: "approval",
+              token: "token-url",
+            },
+          },
+        },
+        target: createTarget(),
+      }),
+    ).resolves.toBe(true);
+
+    expect(resolveApprovalOverGateway).toHaveBeenCalledWith(
+      expect.objectContaining({
+        approvalId: "approval-url",
+        decision: "allow-once",
+      }),
+    );
+  });
+
+  it("does not consume the token when an unauthorized user clicks", async () => {
+    registerGoogleChatApprovalCardBinding({
+      token: "token-2",
+      accountId: "default",
+      approvalId: "plugin:approval-2",
+      approvalKind: "plugin",
+      decision: "deny",
+      allowedDecisions: ["allow-once", "deny"],
+      spaceName: "spaces/AAA",
+      messageName: "spaces/AAA/messages/msg-1",
+      expiresAtMs: Date.now() + 60_000,
+    });
+
+    await expect(
+      maybeHandleGoogleChatApprovalCardClick({
+        event: createCardClickEvent("token-2", "users/999"),
+        target: createTarget(),
+      }),
+    ).resolves.toBe(true);
+
+    expect(resolveApprovalOverGateway).not.toHaveBeenCalled();
+
+    await expect(
+      maybeHandleGoogleChatApprovalCardClick({
+        event: createCardClickEvent("token-2", "users/123"),
+        target: createTarget(),
+      }),
+    ).resolves.toBe(true);
+
+    expect(resolveApprovalOverGateway).toHaveBeenCalledWith(
+      expect.objectContaining({
+        approvalId: "plugin:approval-2",
+        decision: "deny",
+        allowPluginFallback: false,
+      }),
+    );
+  });
+
+  it("keeps the token retryable when gateway resolution fails", async () => {
+    registerGoogleChatApprovalCardBinding({
+      token: "token-retry",
+      accountId: "default",
+      approvalId: "approval-retry",
+      approvalKind: "exec",
+      decision: "allow-once",
+      allowedDecisions: ["allow-once", "deny"],
+      spaceName: "spaces/AAA",
+      messageName: "spaces/AAA/messages/msg-1",
+      expiresAtMs: Date.now() + 60_000,
+    });
+    resolveApprovalOverGateway.mockRejectedValueOnce(new Error("gateway unavailable"));
+
+    await expect(
+      maybeHandleGoogleChatApprovalCardClick({
+        event: createCardClickEvent("token-retry"),
+        target: createTarget(),
+      }),
+    ).rejects.toThrow("gateway unavailable");
+
+    resolveApprovalOverGateway.mockResolvedValueOnce(undefined);
+    await expect(
+      maybeHandleGoogleChatApprovalCardClick({
+        event: createCardClickEvent("token-retry"),
+        target: createTarget(),
+      }),
+    ).resolves.toBe(true);
+
+    expect(resolveApprovalOverGateway).toHaveBeenCalledTimes(2);
+  });
+});