@openclaw/googlechat 2026.6.2-beta.1 → 2026.6.5-beta.1

package/dist/{api-DPvlxpWa.js → channel.adapters-BQoq1F4R.js}

@@ -1,12 +1,161 @@
-import { p as fetchWithSsrFGuard$1 } from "./runtime-api-BbVoWRxq.js";
-import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { l as resolveGoogleChatAccount, r as formatGoogleChatAllowFromEntry } from "./channel-base-Qh87GFW_.js";
+import { T as resolveChannelMediaMaxBytes, _ as missingTargetError, g as loadOutboundMediaFromUrl, i as PAIRING_APPROVED_MESSAGE, o as chunkTextForOutbound, p as fetchWithSsrFGuard$1, x as readRemoteMediaBuffer } from "./runtime-api-BbVoWRxq.js";
+import { createLazyRuntimeNamedExport } from "openclaw/plugin-sdk/lazy-runtime";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import crypto from "node:crypto";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { parseMediaContentLength } from "openclaw/plugin-sdk/media-runtime";
 import { readResponseWithLimit } from "openclaw/plugin-sdk/response-limit-runtime";
 import { buildHostnameAllowlistPolicyFromSuffixAllowlist, fetchWithSsrFGuard } from "openclaw/plugin-sdk/ssrf-runtime";
+import { createMessageReceiptFromOutboundResults, defineChannelMessageAdapter, sanitizeForPlainText } from "openclaw/plugin-sdk/channel-outbound";
 import fs from "node:fs/promises";
 import { resolveUserPath } from "openclaw/plugin-sdk/text-utility-runtime";
+import { adaptScopedAccountAccessor } from "openclaw/plugin-sdk/channel-config-helpers";
+import { composeAccountWarningCollectors, createAllowlistProviderOpenWarningCollector, resolveChannelGroupRequireMention } from "openclaw/plugin-sdk/channel-policy";
+import { createChannelDirectoryAdapter, listResolvedDirectoryGroupEntriesFromMapKeys, listResolvedDirectoryUserEntriesFromAllowFrom } from "openclaw/plugin-sdk/directory-runtime";
+//#region extensions/googlechat/src/approval-card-actions.ts
+const GOOGLECHAT_APPROVAL_ACTION = "openclaw.approval";
+const GOOGLECHAT_APPROVAL_ACTION_PARAM = "openclaw_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;
+const approvalCardBindings = /* @__PURE__ */ new Map();
+const approvalCardResolvingTokens = /* @__PURE__ */ new Set();
+const manualApprovalFollowupSuppressions = /* @__PURE__ */ new Map();
+function createGoogleChatApprovalToken() {
+	return crypto.randomBytes(18).toString("base64url");
+}
+function buildGoogleChatApprovalActionParameters(token) {
+	return [{
+		key: GOOGLECHAT_APPROVAL_ACTION_PARAM,
+		value: GOOGLECHAT_APPROVAL_ACTION_VALUE
+	}, {
+		key: GOOGLECHAT_APPROVAL_TOKEN_PARAM,
+		value: token
+	}];
+}
+function collectEventParameters(event) {
+	const params = {};
+	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;
+}
+function readGoogleChatApprovalActionToken(event) {
+	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 !== "openclaw.approval" && !actionName.startsWith("https://")) return null;
+	return normalizeOptionalString(params[GOOGLECHAT_APPROVAL_TOKEN_PARAM]) ?? null;
+}
+function registerGoogleChatApprovalCardBinding(binding) {
+	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;
+}
+function getGoogleChatApprovalCardBinding(token) {
+	const binding = approvalCardBindings.get(token);
+	if (!binding) return null;
+	if (binding.expiresAtMs <= Date.now()) {
+		approvalCardBindings.delete(token);
+		return null;
+	}
+	return binding;
+}
+function normalizeApprovalRef(value) {
+	const normalized = value.trim().toLowerCase();
+	return normalized ? normalized : null;
+}
+function manualApprovalFollowupSuppressionKey(approvalId) {
+	return normalizeApprovalRef(approvalId);
+}
+function registerGoogleChatManualApprovalFollowupSuppression(suppression) {
+	if (suppression.expiresAtMs <= Date.now()) return false;
+	const key = manualApprovalFollowupSuppressionKey(suppression.approvalId);
+	if (!key) return false;
+	manualApprovalFollowupSuppressions.set(key, suppression);
+	return true;
+}
+function unregisterGoogleChatManualApprovalFollowupSuppression(approvalId) {
+	const key = manualApprovalFollowupSuppressionKey(approvalId);
+	if (key) manualApprovalFollowupSuppressions.delete(key);
+}
+function approvalRefMatches(bindingApprovalId, approvalRef) {
+	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) {
+	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) {
+	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;
+}
+function shouldSuppressGoogleChatManualExecApprovalFollowupText(text, nowMs = Date.now()) {
+	for (const match of text.matchAll(MANUAL_EXEC_APPROVAL_COMMAND_RE)) {
+		const approvalRef = match[1];
+		const decision = match[2]?.toLowerCase();
+		if (approvalRef && decision && hasActiveGoogleChatExecApprovalCardForManualCommand({
+			approvalRef,
+			decision,
+			nowMs
+		})) return true;
+	}
+	return false;
+}
+function hasSendableMedia(payload) {
+	return Boolean(payload.mediaUrl?.trim() || payload.mediaUrls?.some((url) => url.trim()));
+}
+function hasStructuredPayloadPart(payload) {
+	return Boolean(hasSendableMedia(payload) || payload.presentation || payload.interactive || payload.btw || payload.spokenText || payload.ttsSupplement);
+}
+function shouldSuppressGoogleChatManualExecApprovalFollowupPayload(payload, nowMs = Date.now()) {
+	const text = payload.text?.trim();
+	if (!text || hasStructuredPayloadPart(payload)) return false;
+	return shouldSuppressGoogleChatManualExecApprovalFollowupText(text, nowMs);
+}
+function claimGoogleChatApprovalCardBinding(token) {
+	const binding = getGoogleChatApprovalCardBinding(token);
+	if (!binding) return { kind: "missing" };
+	if (approvalCardResolvingTokens.has(token)) return { kind: "in-flight" };
+	approvalCardResolvingTokens.add(token);
+	return {
+		kind: "claimed",
+		binding
+	};
+}
+function completeGoogleChatApprovalCardBinding(token) {
+	const binding = approvalCardBindings.get(token);
+	approvalCardResolvingTokens.delete(token);
+	approvalCardBindings.delete(token);
+	if (binding) unregisterGoogleChatManualApprovalFollowupSuppression(binding.approvalId);
+}
+function releaseGoogleChatApprovalCardBinding(token) {
+	approvalCardResolvingTokens.delete(token);
+}
+function unregisterGoogleChatApprovalCardBindings(tokens) {
+	for (const token of tokens) {
+		const binding = approvalCardBindings.get(token);
+		approvalCardBindings.delete(token);
+		approvalCardResolvingTokens.delete(token);
+		if (binding) unregisterGoogleChatManualApprovalFollowupSuppression(binding.approvalId);
+	}
+}
+//#endregion
 //#region extensions/googlechat/src/google-auth.runtime.ts
 const GOOGLE_AUTH_POLICY = buildHostnameAllowlistPolicyFromSuffixAllowlist(["accounts.google.com", "googleapis.com"]);
 const GOOGLE_AUTH_AUDIT_CONTEXT = "googlechat.auth.google-auth";
@@ -541,9 +690,11 @@ async function fetchBuffer(account, url, init, options) {
 	});
 }
 async function sendGoogleChatMessage(params) {
-	const { account, space, text, thread, attachments } = params;
+	const { account, space, text, thread, cardsV2, attachments } = params;
+	if (text && (!cardsV2 || cardsV2.length === 0) && (!attachments || attachments.length === 0) && shouldSuppressGoogleChatManualExecApprovalFollowupText(text)) return null;
 	const body = {};
 	if (text) body.text = text;
+	if (cardsV2 && cardsV2.length > 0) body.cardsV2 = cardsV2;
 	if (thread) body.thread = { name: thread };
 	if (attachments && attachments.length > 0) body.attachment = attachments.map((item) => Object.assign({ attachmentDataRef: { attachmentUploadToken: item.attachmentUploadToken } }, item.contentName ? { contentName: item.contentName } : {}));
 	const urlObj = new URL(`${CHAT_API_BASE}/${space}/messages`);
@@ -555,10 +706,16 @@ async function sendGoogleChatMessage(params) {
 	return result ? { messageName: result.name } : null;
 }
 async function updateGoogleChatMessage(params) {
-	const { account, messageName, text } = params;
-	return { messageName: (await fetchJson(account, `${CHAT_API_BASE}/${messageName}?updateMask=text`, {
+	const { account, messageName, text, cardsV2 } = params;
+	const updateMask = [...text !== void 0 ? ["text"] : [], ...cardsV2 !== void 0 ? ["cardsV2"] : []];
+	if (updateMask.length === 0) throw new Error("Google Chat message update requires text or cardsV2.");
+	const url = `${CHAT_API_BASE}/${messageName}?updateMask=${updateMask.join(",")}`;
+	const body = {};
+	if (text !== void 0) body.text = text;
+	if (cardsV2 !== void 0) body.cardsV2 = cardsV2;
+	return { messageName: (await fetchJson(account, url, {
 		method: "PATCH",
-		body: JSON.stringify({ text })
+		body: JSON.stringify(body)
 	})).name };
 }
 async function deleteGoogleChatMessage(params) {
@@ -631,4 +788,275 @@ async function probeGoogleChat(account) {
 	}
 }
 //#endregion
-export { findGoogleChatDirectMessage as a, sendGoogleChatMessage as c, verifyGoogleChatRequest as d, downloadGoogleChatMedia as i, updateGoogleChatMessage as l, deleteGoogleChatMessage as n, listGoogleChatReactions as o, deleteGoogleChatReaction as r, probeGoogleChat as s, createGoogleChatReaction as t, uploadGoogleChatAttachment as u };
+//#region extensions/googlechat/src/targets.ts
+function normalizeGoogleChatTarget(raw) {
+	const trimmed = raw?.trim();
+	if (!trimmed) return;
+	const normalized = trimmed.replace(/^(googlechat|google-chat|gchat):/i, "").replace(/^user:(users\/)?/i, "users/").replace(/^space:(spaces\/)?/i, "spaces/");
+	if (isGoogleChatUserTarget(normalized)) {
+		const suffix = normalized.slice(6);
+		return suffix.includes("@") ? `users/${normalizeLowercaseStringOrEmpty(suffix)}` : normalized;
+	}
+	if (isGoogleChatSpaceTarget(normalized)) return normalized;
+	if (normalized.includes("@")) return `users/${normalizeLowercaseStringOrEmpty(normalized)}`;
+	return normalized;
+}
+function isGoogleChatUserTarget(value) {
+	return normalizeLowercaseStringOrEmpty(value).startsWith("users/");
+}
+function isGoogleChatSpaceTarget(value) {
+	return normalizeLowercaseStringOrEmpty(value).startsWith("spaces/");
+}
+function stripMessageSuffix(target) {
+	const index = target.indexOf("/messages/");
+	if (index === -1) return target;
+	return target.slice(0, index);
+}
+async function resolveGoogleChatOutboundSpace(params) {
+	const normalized = normalizeGoogleChatTarget(params.target);
+	if (!normalized) throw new Error("Missing Google Chat target.");
+	const base = stripMessageSuffix(normalized);
+	if (isGoogleChatSpaceTarget(base)) return base;
+	if (isGoogleChatUserTarget(base)) {
+		const dm = await findGoogleChatDirectMessage({
+			account: params.account,
+			userName: base
+		});
+		if (!dm?.name) throw new Error(`No Google Chat DM found for ${base}`);
+		return dm.name;
+	}
+	return base;
+}
+//#endregion
+//#region extensions/googlechat/src/group-policy.ts
+function resolveGoogleChatGroupRequireMention(params) {
+	return resolveChannelGroupRequireMention({
+		cfg: params.cfg,
+		channel: "googlechat",
+		groupId: params.groupId,
+		accountId: params.accountId
+	});
+}
+//#endregion
+//#region extensions/googlechat/src/channel.adapters.ts
+const loadGoogleChatChannelRuntime = createLazyRuntimeNamedExport(() => import("./channel.runtime-CbSK_Zox.js"), "googleChatChannelRuntime");
+function createGoogleChatSendReceipt(params) {
+	const messageId = params.messageId?.trim();
+	return createMessageReceiptFromOutboundResults({
+		results: messageId ? [{
+			channel: "googlechat",
+			messageId,
+			chatId: params.chatId,
+			conversationId: params.chatId
+		}] : [],
+		threadId: params.chatId,
+		kind: params.kind
+	});
+}
+const formatAllowFromEntry = formatGoogleChatAllowFromEntry;
+const collectGoogleChatSecurityWarnings = composeAccountWarningCollectors(createAllowlistProviderOpenWarningCollector({
+	providerConfigPresent: (cfg) => cfg.channels?.googlechat !== void 0,
+	resolveGroupPolicy: (account) => account.config.groupPolicy,
+	buildOpenWarning: {
+		surface: "Google Chat spaces",
+		openBehavior: "allows any space to trigger (mention-gated)",
+		remediation: "Set channels.googlechat.groupPolicy=\"allowlist\" and configure channels.googlechat.groups"
+	}
+}), (account) => account.config.dm?.policy === "open" && "- Google Chat DMs are open to anyone. Set channels.googlechat.dm.policy=\"pairing\" or \"allowlist\".");
+const googlechatGroupsAdapter = { resolveRequireMention: resolveGoogleChatGroupRequireMention };
+const googlechatDirectoryAdapter = createChannelDirectoryAdapter({
+	listPeers: async (params) => listResolvedDirectoryUserEntriesFromAllowFrom({
+		...params,
+		resolveAccount: adaptScopedAccountAccessor(resolveGoogleChatAccount),
+		resolveAllowFrom: (account) => account.config.dm?.allowFrom,
+		normalizeId: (entry) => normalizeGoogleChatTarget(entry) ?? entry
+	}),
+	listGroups: async (params) => listResolvedDirectoryGroupEntriesFromMapKeys({
+		...params,
+		resolveAccount: adaptScopedAccountAccessor(resolveGoogleChatAccount),
+		resolveGroups: (account) => account.config.groups
+	})
+});
+const googlechatSecurityAdapter = {
+	dm: {
+		channelKey: "googlechat",
+		resolvePolicy: (account) => account.config.dm?.policy,
+		resolveAllowFrom: (account) => account.config.dm?.allowFrom,
+		allowFromPathSuffix: "dm.",
+		normalizeEntry: (raw) => formatAllowFromEntry(raw)
+	},
+	collectWarnings: collectGoogleChatSecurityWarnings
+};
+const googlechatThreadingAdapter = {
+	scopedAccountReplyToMode: {
+		resolveAccount: (cfg, accountId) => resolveGoogleChatAccount({
+			cfg,
+			accountId
+		}),
+		resolveReplyToMode: (account, _chatType) => account.config.replyToMode,
+		fallback: "off"
+	},
+	buildToolContext: ({ cfg, accountId, context, hasRepliedRef }) => {
+		const currentChannelId = normalizeGoogleChatTarget(context.To);
+		const replyToId = normalizeOptionalString(context.ReplyToIdFull) ?? normalizeOptionalString(context.ReplyToId);
+		return {
+			currentChannelId,
+			currentMessageId: replyToId,
+			currentThreadTs: replyToId,
+			replyToMode: resolveGoogleChatAccount({
+				cfg,
+				accountId
+			}).config.replyToMode,
+			hasRepliedRef
+		};
+	}
+};
+const googlechatPairingTextAdapter = {
+	idLabel: "googlechatUserId",
+	message: PAIRING_APPROVED_MESSAGE,
+	normalizeAllowEntry: (entry) => formatAllowFromEntry(entry),
+	notify: async ({ cfg, id, message, accountId }) => {
+		const account = resolveGoogleChatAccount({
+			cfg,
+			accountId
+		});
+		if (account.credentialSource === "none") return;
+		const user = normalizeGoogleChatTarget(id) ?? id;
+		const space = await resolveGoogleChatOutboundSpace({
+			account,
+			target: isGoogleChatUserTarget(user) ? user : `users/${user}`
+		});
+		const { sendGoogleChatMessage } = await loadGoogleChatChannelRuntime();
+		await sendGoogleChatMessage({
+			account,
+			space,
+			text: message
+		});
+	}
+};
+const googlechatOutboundAdapter = {
+	base: {
+		deliveryMode: "direct",
+		chunker: chunkTextForOutbound,
+		chunkerMode: "markdown",
+		textChunkLimit: 4e3,
+		sanitizeText: ({ text }) => sanitizeForPlainText(text),
+		normalizePayload: ({ payload }) => shouldSuppressGoogleChatManualExecApprovalFollowupPayload(payload) ? null : payload,
+		resolveTarget: ({ to }) => {
+			const trimmed = normalizeOptionalString(to) ?? "";
+			if (trimmed) {
+				const normalized = normalizeGoogleChatTarget(trimmed);
+				if (!normalized) return {
+					ok: false,
+					error: missingTargetError("Google Chat", "<spaces/{space}|users/{user}>")
+				};
+				return {
+					ok: true,
+					to: normalized
+				};
+			}
+			return {
+				ok: false,
+				error: missingTargetError("Google Chat", "<spaces/{space}|users/{user}>")
+			};
+		}
+	},
+	attachedResults: {
+		channel: "googlechat",
+		sendText: async ({ cfg, to, text, accountId, replyToId, threadId }) => {
+			const account = resolveGoogleChatAccount({
+				cfg,
+				accountId
+			});
+			const space = await resolveGoogleChatOutboundSpace({
+				account,
+				target: to
+			});
+			const thread = typeof threadId === "number" ? String(threadId) : threadId ?? replyToId ?? void 0;
+			const { sendGoogleChatMessage } = await loadGoogleChatChannelRuntime();
+			const messageId = (await sendGoogleChatMessage({
+				account,
+				space,
+				text,
+				thread
+			}))?.messageName ?? "";
+			return {
+				messageId,
+				chatId: space,
+				receipt: createGoogleChatSendReceipt({
+					messageId,
+					chatId: space,
+					kind: "text"
+				})
+			};
+		},
+		sendMedia: async ({ cfg, to, text, mediaUrl, mediaAccess, mediaLocalRoots, mediaReadFile, accountId, replyToId, threadId }) => {
+			if (!mediaUrl) throw new Error("Google Chat mediaUrl is required.");
+			const account = resolveGoogleChatAccount({
+				cfg,
+				accountId
+			});
+			const space = await resolveGoogleChatOutboundSpace({
+				account,
+				target: to
+			});
+			const thread = typeof threadId === "number" ? String(threadId) : threadId ?? replyToId ?? void 0;
+			const effectiveMaxBytes = resolveChannelMediaMaxBytes({
+				cfg,
+				resolveChannelLimitMb: ({ cfg: cfgLocal, accountId: accountIdLocal }) => (cfgLocal.channels?.googlechat)?.accounts?.[accountIdLocal]?.mediaMaxMb ?? (cfgLocal.channels?.googlechat)?.mediaMaxMb,
+				accountId
+			}) ?? (account.config.mediaMaxMb ?? 20) * 1024 * 1024;
+			const loaded = /^https?:\/\//i.test(mediaUrl) ? await readRemoteMediaBuffer({
+				url: mediaUrl,
+				maxBytes: effectiveMaxBytes
+			}) : await loadOutboundMediaFromUrl(mediaUrl, {
+				maxBytes: effectiveMaxBytes,
+				mediaAccess,
+				mediaLocalRoots,
+				mediaReadFile
+			});
+			const { sendGoogleChatMessage, uploadGoogleChatAttachment } = await loadGoogleChatChannelRuntime();
+			const upload = await uploadGoogleChatAttachment({
+				account,
+				space,
+				filename: loaded.fileName ?? "attachment",
+				buffer: loaded.buffer,
+				contentType: loaded.contentType
+			});
+			const messageId = (await sendGoogleChatMessage({
+				account,
+				space,
+				text,
+				thread,
+				attachments: upload.attachmentUploadToken ? [{
+					attachmentUploadToken: upload.attachmentUploadToken,
+					contentName: loaded.fileName
+				}] : void 0
+			}))?.messageName ?? "";
+			return {
+				messageId,
+				chatId: space,
+				receipt: createGoogleChatSendReceipt({
+					messageId,
+					chatId: space,
+					kind: "media"
+				})
+			};
+		}
+	}
+};
+const googlechatMessageAdapter = defineChannelMessageAdapter({
+	id: "googlechat",
+	durableFinal: { capabilities: {
+		text: true,
+		media: true,
+		thread: true,
+		messageSendingHooks: true
+	} },
+	send: {
+		text: googlechatOutboundAdapter.attachedResults.sendText,
+		media: googlechatOutboundAdapter.attachedResults.sendMedia
+	}
+});
+//#endregion
+export { registerGoogleChatManualApprovalFollowupSuppression as A, buildGoogleChatApprovalActionParameters as C, getGoogleChatApprovalCardBinding as D, createGoogleChatApprovalToken as E, unregisterGoogleChatApprovalCardBindings as M, unregisterGoogleChatManualApprovalFollowupSuppression as N, readGoogleChatApprovalActionToken as O, GOOGLECHAT_APPROVAL_ACTION as S, completeGoogleChatApprovalCardBinding as T, probeGoogleChat as _, googlechatPairingTextAdapter as a, uploadGoogleChatAttachment as b, isGoogleChatSpaceTarget as c, resolveGoogleChatOutboundSpace as d, createGoogleChatReaction as f, listGoogleChatReactions as g, downloadGoogleChatMedia as h, googlechatOutboundAdapter as i, releaseGoogleChatApprovalCardBinding as j, registerGoogleChatApprovalCardBinding as k, isGoogleChatUserTarget as l, deleteGoogleChatReaction as m, googlechatGroupsAdapter as n, googlechatSecurityAdapter as o, deleteGoogleChatMessage as p, googlechatMessageAdapter as r, googlechatThreadingAdapter as s, googlechatDirectoryAdapter as t, normalizeGoogleChatTarget as u, sendGoogleChatMessage as v, claimGoogleChatApprovalCardBinding as w, verifyGoogleChatRequest as x, updateGoogleChatMessage as y };

package/dist/{channel.runtime-C4eLDKR3.js → channel.runtime-CbSK_Zox.js}

@@ -1,13 +1,83 @@
+import { D as getGoogleChatApprovalCardBinding, O as readGoogleChatApprovalActionToken, T as completeGoogleChatApprovalCardBinding, _ as probeGoogleChat, b as uploadGoogleChatAttachment, h as downloadGoogleChatMedia, j as releaseGoogleChatApprovalCardBinding, p as deleteGoogleChatMessage, v as sendGoogleChatMessage, w as claimGoogleChatApprovalCardBinding, x as verifyGoogleChatRequest, y as updateGoogleChatMessage } from "./channel.adapters-BQoq1F4R.js";
 import { E as resolveDefaultGroupPolicy, M as warnMissingProviderGroupPolicyFallbackOnce, O as resolveInboundRouteEnvelopeBuilderWithRuntime, P as getGoogleChatRuntime, k as resolveWebhookPath, m as isDangerousNameMatchingEnabled, n as GROUP_POLICY_BLOCKED_LABEL, u as createChannelPairingController, w as resolveAllowlistProviderRuntimeGroupPolicy } from "./runtime-api-BbVoWRxq.js";
-import { c as sendGoogleChatMessage, d as verifyGoogleChatRequest, i as downloadGoogleChatMedia, l as updateGoogleChatMessage, n as deleteGoogleChatMessage, s as probeGoogleChat, u as uploadGoogleChatAttachment } from "./api-DPvlxpWa.js";
+import { n as googleChatApprovalAuth } from "./approval-auth-C-vWY4bY.js";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { mergePairLoopGuardConfig } from "openclaw/plugin-sdk/pair-loop-guard-runtime";
 import { recordChannelBotPairLoopAndCheckSuppression } from "openclaw/plugin-sdk/channel-inbound";
 import { WEBHOOK_RATE_LIMIT_DEFAULTS, createFixedWindowRateLimiter, normalizeWebhookPath, resolveRequestClientIp } from "openclaw/plugin-sdk/webhook-ingress";
 import { registerWebhookTargetWithPluginRoute, resolveWebhookTargetWithAuthOrReject, withResolvedWebhookRequestPipeline } from "openclaw/plugin-sdk/webhook-targets";
 import { createWebhookInFlightLimiter, readJsonWebhookBodyOrReject } from "openclaw/plugin-sdk/webhook-request-guards";
+import { resolveApprovalOverGateway } from "openclaw/plugin-sdk/approval-gateway-runtime";
 import { channelIngressRoutes, createChannelIngressResolver, defineStableChannelIngressIdentity } from "openclaw/plugin-sdk/channel-ingress-runtime";
 import { deliverTextOrMediaReply, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
+//#region extensions/googlechat/src/approval-card-click.ts
+function logIgnored(target, message) {
+	target.runtime.log?.(`[${target.account.accountId}] googlechat approval ignored: ${message}`);
+}
+async function maybeHandleGoogleChatApprovalCardClick(params) {
+	if ((params.event.type ?? params.event.eventType) !== "CARD_CLICKED") return false;
+	const token = readGoogleChatApprovalActionToken(params.event);
+	if (!token) return false;
+	const binding = getGoogleChatApprovalCardBinding(token);
+	if (!binding) {
+		logIgnored(params.target, "unknown or expired card token");
+		return true;
+	}
+	if (binding.accountId !== params.target.account.accountId) {
+		logIgnored(params.target, "card token account mismatch");
+		return true;
+	}
+	if (params.event.space?.name !== binding.spaceName) {
+		logIgnored(params.target, "card token space mismatch");
+		return true;
+	}
+	if (params.event.message?.name && params.event.message.name !== binding.messageName) {
+		logIgnored(params.target, "card token message mismatch");
+		return true;
+	}
+	if (!binding.allowedDecisions.includes(binding.decision)) {
+		logIgnored(params.target, "card token decision is no longer allowed");
+		return true;
+	}
+	const actor = params.event.user?.name;
+	if (!(googleChatApprovalAuth.authorizeActorAction?.({
+		cfg: params.target.config,
+		accountId: params.target.account.accountId,
+		senderId: actor,
+		action: "approve",
+		approvalKind: binding.approvalKind
+	}))?.authorized) {
+		logIgnored(params.target, `unauthorized actor ${actor || "unknown"}`);
+		return true;
+	}
+	const claim = claimGoogleChatApprovalCardBinding(token);
+	if (claim.kind === "missing") {
+		logIgnored(params.target, "card token already consumed");
+		return true;
+	}
+	if (claim.kind === "in-flight") {
+		logIgnored(params.target, "card token resolve already in flight");
+		return true;
+	}
+	const consumed = claim.binding;
+	try {
+		await resolveApprovalOverGateway({
+			cfg: params.target.config,
+			approvalId: consumed.approvalId,
+			decision: consumed.decision,
+			senderId: actor,
+			allowPluginFallback: consumed.approvalKind === "exec",
+			clientDisplayName: `Google Chat approval (${actor?.trim() || "unknown"})`
+		});
+	} catch (error) {
+		releaseGoogleChatApprovalCardBinding(token);
+		throw error;
+	}
+	completeGoogleChatApprovalCardBinding(token);
+	params.target.runtime.log?.(`[${params.target.account.accountId}] googlechat approval resolved id=${consumed.approvalId} decision=${consumed.decision} sender=${actor || "unknown"}`);
+	return true;
+}
+//#endregion
 //#region extensions/googlechat/src/monitor-access.ts
 function normalizeUserId(raw) {
 	const trimmed = normalizeOptionalString(raw) ?? "";
@@ -419,6 +489,14 @@ function extractBearerToken(header) {
 }
 const ADD_ON_PREAUTH_MAX_BYTES = 16 * 1024;
 const ADD_ON_PREAUTH_TIMEOUT_MS = 3e3;
+function recordParamsToActionParameters(params) {
+	if (!params) return;
+	const entries = Object.entries(params).filter((entry) => typeof entry[1] === "string").map(([key, value]) => ({
+		key,
+		value
+	}));
+	return entries.length > 0 ? entries : void 0;
+}
 function parseGoogleChatInboundPayload(raw, res) {
 	if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
 		res.statusCode = 400;
@@ -428,6 +506,7 @@ function parseGoogleChatInboundPayload(raw, res) {
 	let eventPayload = raw;
 	let addOnBearerToken = "";
 	const rawObj = raw;
+	if (rawObj.commonEventObject?.hostApp === "CHAT") addOnBearerToken = typeof rawObj.authorizationEventObject?.systemIdToken === "string" ? rawObj.authorizationEventObject.systemIdToken.trim() : "";
 	if (rawObj.commonEventObject?.hostApp === "CHAT" && rawObj.chat?.messagePayload) {
 		const chat = rawObj.chat;
 		const messagePayload = chat.messagePayload;
@@ -438,7 +517,28 @@ function parseGoogleChatInboundPayload(raw, res) {
 			user: chat.user,
 			eventTime: chat.eventTime
 		};
-		addOnBearerToken = typeof rawObj.authorizationEventObject?.systemIdToken === "string" ? rawObj.authorizationEventObject.systemIdToken.trim() : "";
+	} else if (rawObj.commonEventObject?.hostApp === "CHAT") {
+		const chat = rawObj.chat;
+		const buttonClickedPayload = chat?.buttonClickedPayload;
+		if (buttonClickedPayload) {
+			const invokedFunction = rawObj.commonEventObject.invokedFunction;
+			const actionParameters = recordParamsToActionParameters(rawObj.commonEventObject.parameters);
+			eventPayload = {
+				type: "CARD_CLICKED",
+				space: buttonClickedPayload.space,
+				message: buttonClickedPayload.message,
+				user: buttonClickedPayload.user ?? chat.user,
+				eventTime: chat.eventTime,
+				action: buttonClickedPayload.action ?? {
+					...typeof invokedFunction === "string" ? { actionMethodName: invokedFunction } : {},
+					...actionParameters ? { parameters: actionParameters } : {}
+				},
+				commonEventObject: {
+					...typeof invokedFunction === "string" ? { invokedFunction } : {},
+					parameters: rawObj.commonEventObject.parameters
+				}
+			};
+		}
 	}
 	const event = eventPayload;
 	const eventType = event.type ?? eventPayload.eventType;
@@ -458,6 +558,12 @@ function parseGoogleChatInboundPayload(raw, res) {
 			res.end("invalid payload");
 			return { ok: false };
 		}
+	} else if (eventType === "CARD_CLICKED") {
+		if (!event.user || typeof event.user !== "object" || Array.isArray(event.user)) {
+			res.statusCode = 400;
+			res.end("invalid payload");
+			return { ok: false };
+		}
 	}
 	return {
 		ok: true,
@@ -677,7 +783,15 @@ function shouldSuppressGoogleChatBotLoop(params) {
 	return true;
 }
 async function processGoogleChatEvent(event, target) {
-	if ((event.type ?? event.eventType) !== "MESSAGE") return;
+	const eventType = event.type ?? event.eventType;
+	if (eventType === "CARD_CLICKED") {
+		await maybeHandleGoogleChatApprovalCardClick({
+			event,
+			target
+		});
+		return;
+	}
+	if (eventType !== "MESSAGE") return;
 	if (!event.message || !event.space) return;
 	await processMessageWithPipeline({
 		event,

package/dist/directory-contract-api.js

@@ -1,4 +1,4 @@
-import { t as googlechatDirectoryAdapter } from "./channel.adapters-LlD3wKl5.js";
+import { t as googlechatDirectoryAdapter } from "./channel.adapters-BQoq1F4R.js";
 //#region extensions/googlechat/directory-contract-api.ts
 const googlechatDirectoryContractPlugin = {
 	id: "googlechat",

package/dist/setup-plugin-api.js

@@ -1,4 +1,4 @@
-import { n as createGoogleChatPluginBase } from "./channel-base-DpPD0ef1.js";
+import { n as createGoogleChatPluginBase } from "./channel-base-Qh87GFW_.js";
 //#region extensions/googlechat/src/channel.setup.ts
 const googlechatSetupPlugin = createGoogleChatPluginBase();
 //#endregion

package/npm-shrinkwrap.json

@@ -1,19 +1,19 @@
 {
   "name": "@openclaw/googlechat",
-  "version": "2026.6.2-beta.1",
+  "version": "2026.6.5-beta.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@openclaw/googlechat",
-      "version": "2026.6.2-beta.1",
+      "version": "2026.6.5-beta.1",
       "dependencies": {
         "gaxios": "7.1.4",
         "google-auth-library": "10.6.2",
         "zod": "4.4.3"
       },
       "peerDependencies": {
-        "openclaw": ">=2026.6.2-beta.1"
+        "openclaw": ">=2026.6.5-beta.1"
       },
       "peerDependenciesMeta": {
         "openclaw": {