@openclaw/googlechat 2026.7.1-beta.6 → 2026.7.2-beta.1

package/dist/actions-I93fRoRd.js

@@ -0,0 +1,76 @@
+import { l as resolveGoogleChatAccount, o as listEnabledGoogleChatAccounts } from "./channel-base-B16U1bY7.js";
+import { _ as sendGoogleChatMessage, p as resolveGoogleChatOutboundSpace } from "./channel.adapters-CvESEXlT.js";
+import { extractToolSend } from "openclaw/plugin-sdk/tool-send";
+import { jsonResult, readStringArrayParam, readStringParam } from "openclaw/plugin-sdk/channel-actions";
+//#region extensions/googlechat/src/actions.ts
+const providerId = "googlechat";
+function listEnabledAccounts(cfg) {
+	return listEnabledGoogleChatAccounts(cfg).filter((account) => account.enabled && account.credentialSource !== "none");
+}
+const OUTBOUND_MEDIA_KEYS = [
+	"media",
+	"mediaUrl",
+	"path",
+	"filePath",
+	"fileUrl"
+];
+const STRUCTURED_ATTACHMENT_MEDIA_KEYS = [...OUTBOUND_MEDIA_KEYS, "url"];
+function hasGoogleChatOutboundAttachment(params) {
+	if (OUTBOUND_MEDIA_KEYS.some((key) => readStringParam(params, key) !== void 0)) return true;
+	if (readStringArrayParam(params, "mediaUrls") !== void 0) return true;
+	if (!Array.isArray(params.attachments)) return false;
+	return params.attachments.some((attachment) => {
+		if (!attachment || typeof attachment !== "object" || Array.isArray(attachment)) return false;
+		const record = attachment;
+		return STRUCTURED_ATTACHMENT_MEDIA_KEYS.some((key) => readStringParam(record, key) !== void 0);
+	});
+}
+const googlechatMessageActions = {
+	describeMessageTool: ({ cfg, accountId }) => {
+		if ((accountId ? [resolveGoogleChatAccount({
+			cfg,
+			accountId
+		})].filter((account) => account.enabled && account.credentialSource !== "none") : listEnabledAccounts(cfg)).length === 0) return null;
+		return { actions: ["send"] };
+	},
+	supportsAction: ({ action }) => action === "send",
+	extractToolSend: ({ args }) => {
+		return extractToolSend(args, "sendMessage");
+	},
+	handleAction: async ({ action, params, cfg, accountId }) => {
+		if (action === "upload-file") throw new Error("Google Chat outbound attachments require user OAuth and are not supported by this service-account channel.");
+		if (action === "send") {
+			if (hasGoogleChatOutboundAttachment(params)) throw new Error("Google Chat outbound attachments require user OAuth and are not supported by this service-account channel.");
+		}
+		const account = resolveGoogleChatAccount({
+			cfg,
+			accountId
+		});
+		if (account.credentialSource === "none") throw new Error("Google Chat credentials are missing.");
+		if (action === "send") {
+			const to = readStringParam(params, "to", { required: true });
+			const content = readStringParam(params, "message", {
+				required: true,
+				allowEmpty: true
+			});
+			const threadId = readStringParam(params, "threadId") ?? readStringParam(params, "replyTo");
+			const space = await resolveGoogleChatOutboundSpace({
+				account,
+				target: to
+			});
+			return jsonResult({
+				ok: true,
+				to: space,
+				...await sendGoogleChatMessage({
+					account,
+					space,
+					text: content,
+					thread: threadId ?? void 0
+				})
+			});
+		}
+		throw new Error(`Action ${action} is not supported for provider ${providerId}.`);
+	}
+};
+//#endregion
+export { googlechatMessageActions };

package/dist/api.js

@@ -1,3 +1,3 @@
-import { a as googlechatSetupAdapter, i as googlechatSetupWizard } from "./channel-base-DJICAvKH.js";
-import { t as googlechatPlugin } from "./channel-_o671C-U.js";
+import { a as googlechatSetupAdapter, i as googlechatSetupWizard } from "./channel-base-B16U1bY7.js";
+import { t as googlechatPlugin } from "./channel-9ZeBzfmP.js";
 export { googlechatPlugin, googlechatSetupAdapter, googlechatSetupWizard };

package/dist/approval-auth-CMMwmCPY.js

@@ -0,0 +1,30 @@
+import { l as resolveGoogleChatAccount } from "./channel-base-B16U1bY7.js";
+import { d as normalizeGoogleChatTarget, u as isGoogleChatUserTarget } from "./channel.adapters-CvESEXlT.js";
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { createChannelApprovalAuth } from "openclaw/plugin-sdk/approval-auth-runtime";
+//#region extensions/googlechat/src/approval-auth.ts
+function normalizeGoogleChatApproverId(value) {
+	const normalized = normalizeGoogleChatTarget(String(value));
+	if (!normalized || !isGoogleChatUserTarget(normalized)) return;
+	const suffix = normalizeLowercaseStringOrEmpty(normalized.slice(6));
+	if (!suffix || suffix.includes("@")) return;
+	return `users/${suffix}`;
+}
+const googleChatApproval = createChannelApprovalAuth({
+	channelLabel: "Google Chat",
+	resolveInputs: ({ cfg, accountId }) => {
+		const account = resolveGoogleChatAccount({
+			cfg,
+			accountId
+		}).config;
+		return {
+			allowFrom: account.dm?.allowFrom,
+			defaultTo: account.defaultTo
+		};
+	},
+	normalizeApprover: normalizeGoogleChatApproverId
+});
+const getGoogleChatApprovalApprovers = googleChatApproval.resolveApprovers;
+const googleChatApprovalAuth = googleChatApproval.approvalAuth;
+//#endregion
+export { googleChatApprovalAuth as n, normalizeGoogleChatApproverId as r, getGoogleChatApprovalApprovers as t };

package/dist/{approval-handler.runtime-BnkufknT.js → approval-handler.runtime-DcSqrj8k.js}

@@ -1,6 +1,6 @@
-import { l as resolveGoogleChatAccount } from "./channel-base-DJICAvKH.js";
-import { F as unregisterGoogleChatManualApprovalFollowupSuppression, M as registerGoogleChatManualApprovalFollowupSuppression, O as createGoogleChatApprovalToken, P as unregisterGoogleChatApprovalCardBindings, T as buildGoogleChatApprovalActionParameters, b as sendGoogleChatMessage, j as registerGoogleChatApprovalCardBinding, p as resolveGoogleChatOutboundSpace, w as GOOGLECHAT_APPROVAL_ACTION, x as updateGoogleChatMessage } from "./channel.adapters-FEj7zUjh.js";
-import { n as isGoogleChatNativeApprovalClientEnabled, r as shouldHandleGoogleChatNativeApprovalRequest } from "./channel-_o671C-U.js";
+import { l as resolveGoogleChatAccount } from "./channel-base-B16U1bY7.js";
+import { A as unregisterGoogleChatApprovalCardBindings, D as registerGoogleChatApprovalCardBinding, O as registerGoogleChatManualApprovalFollowupSuppression, _ as sendGoogleChatMessage, b as GOOGLECHAT_APPROVAL_ACTION, j as unregisterGoogleChatManualApprovalFollowupSuppression, p as resolveGoogleChatOutboundSpace, v as updateGoogleChatMessage, w as createGoogleChatApprovalToken, x as buildGoogleChatApprovalActionParameters } from "./channel.adapters-CvESEXlT.js";
+import { n as isGoogleChatNativeApprovalClientEnabled, r as shouldHandleGoogleChatNativeApprovalRequest } from "./channel-9ZeBzfmP.js";
 import { buildChannelApprovalNativeTargetKey } from "openclaw/plugin-sdk/approval-native-runtime";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
@@ -155,9 +155,10 @@ const googleChatApprovalNativeRuntime = createChannelApprovalNativeRuntimeAdapte
 			cfg,
 			accountId
 		}),
-		shouldHandle: ({ cfg, accountId, request }) => shouldHandleGoogleChatNativeApprovalRequest({
+		shouldHandle: ({ cfg, accountId, approvalKind, request }) => shouldHandleGoogleChatNativeApprovalRequest({
 			cfg,
 			accountId,
+			approvalKind,
 			request
 		})
 	},

package/dist/{channel-_o671C-U.js → channel-9ZeBzfmP.js}

@@ -1,9 +1,10 @@
-import { c as resolveDefaultGoogleChatAccountId, l as resolveGoogleChatAccount, n as createGoogleChatPluginBase, s as listGoogleChatAccountIds, t as GOOGLECHAT_CHANNEL_ID } from "./channel-base-DJICAvKH.js";
-import { a as googlechatPairingTextAdapter, d as normalizeGoogleChatTarget, f as resolveGoogleChatOutboundSessionRoute, i as googlechatOutboundAdapter, l as isGoogleChatSpaceTarget, n as googlechatGroupsAdapter, o as googlechatSecurityAdapter, r as googlechatMessageAdapter, s as googlechatThreadingAdapter, t as googlechatDirectoryAdapter, u as isGoogleChatUserTarget } from "./channel.adapters-FEj7zUjh.js";
-import { a as buildChannelConfigSchema, r as GoogleChatConfigSchema, t as DEFAULT_ACCOUNT_ID } from "./runtime-api-BbVoWRxq.js";
-import { n as googleChatApprovalAuth, r as normalizeGoogleChatApproverId, t as getGoogleChatApprovalApprovers } from "./approval-auth-C_BVZZFA.js";
-import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-BcEqUZ4j.js";
-import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries } from "./secret-contract-lCMHqumt.js";
+import { c as resolveDefaultGoogleChatAccountId, l as resolveGoogleChatAccount, n as createGoogleChatPluginBase, s as listGoogleChatAccountIds, t as GOOGLECHAT_CHANNEL_ID } from "./channel-base-B16U1bY7.js";
+import { a as googlechatPairingTextAdapter, d as normalizeGoogleChatTarget, f as resolveGoogleChatOutboundSessionRoute, i as googlechatOutboundAdapter, l as isGoogleChatSpaceTarget, n as googlechatGroupsAdapter, o as googlechatSecurityAdapter, r as googlechatMessageAdapter, s as googlechatThreadingAdapter, t as googlechatDirectoryAdapter, u as isGoogleChatUserTarget } from "./channel.adapters-CvESEXlT.js";
+import { n as buildChannelConfigSchema, t as GoogleChatConfigSchema } from "./config-api-CsD0IFxF.js";
+import { t as DEFAULT_ACCOUNT_ID } from "./runtime-api-1v-DgldF.js";
+import { n as googleChatApprovalAuth, r as normalizeGoogleChatApproverId, t as getGoogleChatApprovalApprovers } from "./approval-auth-CMMwmCPY.js";
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-CvhD0eoX.js";
+import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries } from "./secret-contract-D__4IIu_.js";
 import { createChatChannelPlugin } from "openclaw/plugin-sdk/channel-core";
 import { buildPassiveProbedChannelStatusSummary } from "openclaw/plugin-sdk/extension-shared";
 import { createLazyRuntimeNamedExport } from "openclaw/plugin-sdk/lazy-runtime";
@@ -134,12 +135,13 @@ const googleChatApprovalCapability = createApproverRestrictedNativeApprovalCapab
 			cfg,
 			accountId
 		}),
-		shouldHandle: ({ cfg, accountId, request }) => shouldHandleGoogleChatNativeApprovalRequest({
+		shouldHandle: ({ cfg, accountId, approvalKind, request }) => shouldHandleGoogleChatNativeApprovalRequest({
 			cfg,
 			accountId,
+			approvalKind,
 			request
 		}),
-		load: async () => (await import("./approval-handler.runtime-BnkufknT.js")).googleChatApprovalNativeRuntime
+		load: async () => (await import("./approval-handler.runtime-DcSqrj8k.js")).googleChatApprovalNativeRuntime
 	})
 });
 //#endregion
@@ -181,7 +183,7 @@ const collectGoogleChatMutableAllowlistWarnings = createDangerousNameMatchingMut
 });
 //#endregion
 //#region extensions/googlechat/src/gateway.ts
-const loadGoogleChatChannelRuntime$1 = createLazyRuntimeNamedExport(() => import("./channel.runtime-CYmt7Ybo.js"), "googleChatChannelRuntime");
+const loadGoogleChatChannelRuntime$1 = createLazyRuntimeNamedExport(() => import("./channel.runtime-B0u_Dy7b.js"), "googleChatChannelRuntime");
 async function startGoogleChatGatewayAccount(ctx) {
 	const account = ctx.account;
 	const statusSink = createAccountStatusSink({
@@ -243,27 +245,22 @@ async function startGoogleChatGatewayAccount(ctx) {
 }
 //#endregion
 //#region extensions/googlechat/src/channel.ts
-const loadGoogleChatChannelRuntime = createLazyRuntimeNamedExport(() => import("./channel.runtime-CYmt7Ybo.js"), "googleChatChannelRuntime");
+const loadGoogleChatChannelRuntime = createLazyRuntimeNamedExport(() => import("./channel.runtime-B0u_Dy7b.js"), "googleChatChannelRuntime");
 const googlechatActions = {
 	describeMessageTool: ({ cfg, accountId }) => {
-		const accounts = accountId ? [resolveGoogleChatAccount({
+		if ((accountId ? [resolveGoogleChatAccount({
 			cfg,
 			accountId
 		})].filter((account) => account.enabled && account.credentialSource !== "none") : listGoogleChatAccountIds(cfg).map((id) => resolveGoogleChatAccount({
 			cfg,
 			accountId: id
-		})).filter((account) => account.enabled && account.credentialSource !== "none");
-		if (accounts.length === 0) return null;
-		const actions = /* @__PURE__ */ new Set(["send", "upload-file"]);
-		if (accounts.some((account) => account.config.actions?.reactions !== false)) {
-			actions.add("react");
-			actions.add("reactions");
-		}
-		return { actions: Array.from(actions) };
+		})).filter((account) => account.enabled && account.credentialSource !== "none")).length === 0) return null;
+		return { actions: ["send"] };
 	},
+	supportsAction: ({ action }) => action === "send",
 	extractToolSend: ({ args }) => extractToolSend(args, "sendMessage"),
 	handleAction: async (ctx) => {
-		const { googlechatMessageActions } = await import("./actions-BacnMHv0.js");
+		const { googlechatMessageActions } = await import("./actions-I93fRoRd.js");
 		if (!googlechatMessageActions.handleAction) throw new Error("Google Chat actions are not available.");
 		return await googlechatMessageActions.handleAction(ctx);
 	}

package/dist/{channel-base-DJICAvKH.js → channel-base-B16U1bY7.js}

@@ -373,7 +373,6 @@ function createGoogleChatPluginBase(params = {}) {
 				"group",
 				"thread"
 			],
-			reactions: true,
 			threads: true,
 			media: true,
 			nativeCommands: false,

package/dist/channel-config-api.js

@@ -1,5 +1,4 @@
-import { buildChannelConfigSchema } from "openclaw/plugin-sdk/channel-config-primitives";
-import { GoogleChatConfigSchema } from "openclaw/plugin-sdk/bundled-channel-config-schema";
+import { n as buildChannelConfigSchema, t as GoogleChatConfigSchema } from "./config-api-CsD0IFxF.js";
 //#region extensions/googlechat/src/config-schema.ts
 const GoogleChatChannelConfigSchema = buildChannelConfigSchema(GoogleChatConfigSchema);
 //#endregion

package/dist/channel-plugin-api.js

@@ -1,2 +1,2 @@
-import { t as googlechatPlugin } from "./channel-_o671C-U.js";
+import { t as googlechatPlugin } from "./channel-9ZeBzfmP.js";
 export { googlechatPlugin };

package/dist/{channel.adapters-FEj7zUjh.js → channel.adapters-CvESEXlT.js}

@@ -1,20 +1,21 @@
-import { l as resolveGoogleChatAccount, r as formatGoogleChatAllowFromEntry } from "./channel-base-DJICAvKH.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 { l as resolveGoogleChatAccount, r as formatGoogleChatAllowFromEntry } from "./channel-base-B16U1bY7.js";
+import { d as fetchWithSsrFGuard$1, i as chunkTextForOutbound, m as missingTargetError, r as PAIRING_APPROVED_MESSAGE } from "./runtime-api-1v-DgldF.js";
 import { buildChannelOutboundSessionRoute } from "openclaw/plugin-sdk/channel-core";
 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 { readProviderJsonResponse, readResponseTextLimited } from "openclaw/plugin-sdk/provider-http";
+import { parseMediaContentLength, readResponseTextSnippet } 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 crypto from "node:crypto";
+import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
+import { readProviderJsonResponse } from "openclaw/plugin-sdk/provider-http";
 import { createMessageReceiptFromOutboundResults, defineChannelMessageAdapter, sanitizeForPlainText } from "openclaw/plugin-sdk/channel-outbound";
 import { sanitizeAssistantVisibleText } from "openclaw/plugin-sdk/text-chunking";
 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 { buildChannelGroupsScopeTree, composeAccountWarningCollectors, createAllowlistProviderOpenWarningCollector, resolveScopeRequireMention } 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";
@@ -24,6 +25,8 @@ 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 GOOGLECHAT_APPROVAL_CARD_BINDING_MAX_ENTRIES = 1024;
+const GOOGLECHAT_MANUAL_APPROVAL_SUPPRESSION_MAX_ENTRIES = 1024;
 const manualApprovalFollowupSuppressions = /* @__PURE__ */ new Map();
 function createGoogleChatApprovalToken() {
 	return crypto.randomBytes(18).toString("base64url");
@@ -53,7 +56,9 @@ function readGoogleChatApprovalActionToken(event) {
 }
 function registerGoogleChatApprovalCardBinding(binding) {
 	if (binding.expiresAtMs <= Date.now()) return false;
+	if (approvalCardBindings.has(binding.token)) approvalCardBindings.delete(binding.token);
 	approvalCardBindings.set(binding.token, binding);
+	pruneMapToMaxSize(approvalCardBindings, GOOGLECHAT_APPROVAL_CARD_BINDING_MAX_ENTRIES);
 	registerGoogleChatManualApprovalFollowupSuppression({
 		approvalId: binding.approvalId,
 		approvalKind: binding.approvalKind,
@@ -82,7 +87,9 @@ function registerGoogleChatManualApprovalFollowupSuppression(suppression) {
 	if (suppression.expiresAtMs <= Date.now()) return false;
 	const key = manualApprovalFollowupSuppressionKey(suppression.approvalId);
 	if (!key) return false;
+	if (manualApprovalFollowupSuppressions.has(key)) manualApprovalFollowupSuppressions.delete(key);
 	manualApprovalFollowupSuppressions.set(key, suppression);
+	pruneMapToMaxSize(manualApprovalFollowupSuppressions, GOOGLECHAT_MANUAL_APPROVAL_SUPPRESSION_MAX_ENTRIES);
 	return true;
 }
 function unregisterGoogleChatManualApprovalFollowupSuppression(approvalId) {
@@ -161,7 +168,7 @@ function unregisterGoogleChatApprovalCardBindings(tokens) {
 //#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";
+const GOOGLE_AUTH_FETCH_TIMEOUT_MS = 3e4;
 const GOOGLE_AUTH_URI = "https://accounts.google.com/o/oauth2/auth";
 const GOOGLE_AUTH_PROVIDER_CERTS_URL = "https://www.googleapis.com/oauth2/v1/certs";
 const GOOGLE_AUTH_TOKEN_URI = "https://oauth2.googleapis.com/token";
@@ -381,10 +388,12 @@ function createGoogleAuthFetch(baseFetch) {
 		const url = input instanceof Request ? input.url : String(input);
 		const guardedOptions = resolveGoogleAuthDispatcherPolicy(input, init);
 		const { response, release } = await fetchWithSsrFGuard({
-			auditContext: GOOGLE_AUTH_AUDIT_CONTEXT,
+			auditContext: "googlechat.auth.google-auth",
 			dispatcherPolicy: guardedOptions.dispatcherPolicy,
 			init: guardedOptions.init,
 			policy: GOOGLE_AUTH_POLICY,
+			signal: guardedOptions.init?.signal ?? void 0,
+			timeoutMs: GOOGLE_AUTH_FETCH_TIMEOUT_MS,
 			url,
 			...baseFetch ? { fetchImpl: baseFetch } : {}
 		});
@@ -437,24 +446,15 @@ async function readGoogleAuthResponseBytes(response) {
 	return bytes;
 }
 async function loadGoogleAuthRuntime() {
-	if (!googleAuthRuntimePromise) googleAuthRuntimePromise = (async () => {
-		try {
-			const [googleAuthModule, gaxiosModule] = await Promise.all([import("google-auth-library"), import("gaxios")]);
-			return {
-				Gaxios: gaxiosModule.Gaxios,
-				GoogleAuth: googleAuthModule.GoogleAuth,
-				OAuth2Client: googleAuthModule.OAuth2Client
-			};
-		} catch (error) {
-			googleAuthRuntimePromise = null;
-			throw error;
-		}
-	})();
+	googleAuthRuntimePromise ??= import("google-auth-library").catch((error) => {
+		googleAuthRuntimePromise = null;
+		throw error;
+	});
 	return await googleAuthRuntimePromise;
 }
 async function getGoogleAuthTransport() {
-	const { Gaxios } = await loadGoogleAuthRuntime();
-	return installGoogleAuthHeaderCompatibilityInterceptor(new Gaxios({ fetchImplementation: createGoogleAuthFetch() }));
+	const { gaxios } = await loadGoogleAuthRuntime();
+	return installGoogleAuthHeaderCompatibilityInterceptor(new gaxios.Gaxios({ fetchImplementation: createGoogleAuthFetch() }));
 }
 async function resolveValidatedGoogleChatCredentials(account) {
 	if (account.credentials) return validateGoogleChatServiceAccountCredentials(account.credentials);
@@ -467,6 +467,7 @@ const CHAT_SCOPE = "https://www.googleapis.com/auth/chat.bot";
 const CHAT_ISSUER = "chat@system.gserviceaccount.com";
 const ADDON_ISSUER_PATTERN = /^service-\d+@gcp-sa-gsuiteaddons\.iam\.gserviceaccount\.com$/;
 const CHAT_CERTS_URL = "https://www.googleapis.com/service_accounts/v1/metadata/x509/chat@system.gserviceaccount.com";
+const GOOGLECHAT_CERT_FETCH_TIMEOUT_MS = 3e4;
 async function readGoogleChatCertsResponse(response) {
 	return readProviderJsonResponse(response, "Google Chat cert fetch failed");
 }
@@ -495,12 +496,11 @@ async function getAuthInstance(account) {
 	const key = buildAuthKey(account);
 	const cached = authCache.get(account.accountId);
 	if (cached && cached.key === key) return cached.auth;
-	const [{ GoogleAuth }, rawTransporter, credentials] = await Promise.all([
+	const [{ GoogleAuth }, transporter, credentials] = await Promise.all([
 		loadGoogleAuthRuntime(),
 		getGoogleAuthTransport(),
 		resolveValidatedGoogleChatCredentials(account)
 	]);
-	const transporter = rawTransporter;
 	const evictOldest = () => {
 		if (authCache.size > MAX_AUTH_CACHE_SIZE) {
 			const oldest = authCache.keys().next().value;
@@ -530,7 +530,8 @@ async function fetchChatCerts() {
 	if (cachedCerts && now - cachedCerts.fetchedAt < 600 * 1e3) return cachedCerts.certs;
 	const { response, release } = await fetchWithSsrFGuard$1({
 		url: CHAT_CERTS_URL,
-		auditContext: "googlechat.auth.certs"
+		auditContext: "googlechat.auth.certs",
+		timeoutMs: GOOGLECHAT_CERT_FETCH_TIMEOUT_MS
 	});
 	try {
 		if (!response.ok) throw new Error(`Failed to fetch Chat certs (${response.status})`);
@@ -607,13 +608,41 @@ async function verifyGoogleChatRequest(params) {
 //#endregion
 //#region extensions/googlechat/src/api.ts
 const CHAT_API_BASE = "https://chat.googleapis.com/v1";
-const CHAT_UPLOAD_BASE = "https://chat.googleapis.com/upload/v1";
+const GOOGLECHAT_API_TIMEOUT_MS = 3e4;
+const GOOGLECHAT_MEDIA_TIMEOUT_GRACE_MS = 3e4;
+const GOOGLECHAT_MEDIA_MIN_BYTES_PER_SECOND = 256 * 1024;
+const GOOGLECHAT_MEDIA_MAX_TIMEOUT_MS = 15 * 6e4;
+const GOOGLECHAT_RESPONSE_READ_IDLE_TIMEOUT_MS = 3e4;
+const GOOGLECHAT_JSON_RESPONSE_MAX_BYTES = 16 * 1024 * 1024;
+const GOOGLECHAT_ERROR_BODY_MAX_BYTES = 16 * 1024;
+function resolveGoogleChatMediaTimeoutMs(maxBytes) {
+	if (!maxBytes) return GOOGLECHAT_MEDIA_MAX_TIMEOUT_MS;
+	const transferMs = Math.ceil(maxBytes / GOOGLECHAT_MEDIA_MIN_BYTES_PER_SECOND * 1e3);
+	return Math.min(GOOGLECHAT_MEDIA_TIMEOUT_GRACE_MS + transferMs, GOOGLECHAT_MEDIA_MAX_TIMEOUT_MS);
+}
 async function readGoogleChatJsonResponse(response, label) {
-	return readProviderJsonResponse(response, label);
+	const bytes = await readResponseWithLimit(response, GOOGLECHAT_JSON_RESPONSE_MAX_BYTES, {
+		chunkTimeoutMs: GOOGLECHAT_RESPONSE_READ_IDLE_TIMEOUT_MS,
+		onIdleTimeout: ({ chunkTimeoutMs }) => /* @__PURE__ */ new Error(`${label}: response body stalled after ${chunkTimeoutMs}ms`),
+		onOverflow: ({ maxBytes }) => /* @__PURE__ */ new Error(`${label}: JSON response exceeds ${maxBytes} bytes`)
+	});
+	try {
+		return JSON.parse(new TextDecoder().decode(bytes));
+	} catch (cause) {
+		throw new Error(`${label}: malformed JSON response`, { cause });
+	}
+}
+async function readGoogleChatErrorResponse(response, label) {
+	return await readResponseTextSnippet(response, {
+		maxBytes: GOOGLECHAT_ERROR_BODY_MAX_BYTES,
+		maxChars: GOOGLECHAT_ERROR_BODY_MAX_BYTES,
+		chunkTimeoutMs: GOOGLECHAT_RESPONSE_READ_IDLE_TIMEOUT_MS,
+		onIdleTimeout: ({ chunkTimeoutMs }) => /* @__PURE__ */ new Error(`${label} error response stalled after ${chunkTimeoutMs}ms`)
+	}) ?? "";
 }
 const headersToObject = (headers) => headers instanceof Headers ? Object.fromEntries(headers.entries()) : Array.isArray(headers) ? Object.fromEntries(headers) : headers || {};
 async function withGoogleChatResponse(params) {
-	const { account, url, init, auditContext, errorPrefix = "Google Chat API", handleResponse } = params;
+	const { account, url, init, auditContext, errorPrefix = "Google Chat API", timeoutMs = GOOGLECHAT_API_TIMEOUT_MS, handleResponse } = params;
 	const token = await getGoogleChatAccessToken(account);
 	const { response, release } = await fetchWithSsrFGuard({
 		url,
@@ -624,11 +653,12 @@ async function withGoogleChatResponse(params) {
 				Authorization: `Bearer ${token}`
 			}
 		},
-		auditContext
+		auditContext,
+		timeoutMs
 	});
 	try {
 		if (!response.ok) {
-			const text = await readResponseTextLimited(response).catch(() => "");
+			const text = await readGoogleChatErrorResponse(response, errorPrefix);
 			throw new Error(`${errorPrefix} ${response.status}: ${text || response.statusText}`);
 		}
 		return await handleResponse(response);
@@ -666,6 +696,7 @@ async function fetchBuffer(account, url, init, options) {
 		url,
 		init,
 		auditContext: "googlechat.api.buffer",
+		timeoutMs: resolveGoogleChatMediaTimeoutMs(options?.maxBytes),
 		handleResponse: async (res) => {
 			const maxBytes = options?.maxBytes;
 			const lengthHeader = res.headers.get("content-length");
@@ -678,20 +709,22 @@ async function fetchBuffer(account, url, init, options) {
 				contentType: res.headers.get("content-type") ?? void 0
 			};
 			return {
-				buffer: await readResponseWithLimit(res, maxBytes, { onOverflow: () => /* @__PURE__ */ new Error(`Google Chat media exceeds max bytes (${maxBytes})`) }),
+				buffer: await readResponseWithLimit(res, maxBytes, {
+					chunkTimeoutMs: GOOGLECHAT_RESPONSE_READ_IDLE_TIMEOUT_MS,
+					onOverflow: () => /* @__PURE__ */ new Error(`Google Chat media exceeds max bytes (${maxBytes})`)
+				}),
 				contentType: res.headers.get("content-type") ?? void 0
 			};
 		}
 	});
 }
 async function sendGoogleChatMessage(params) {
-	const { account, space, text, thread, cardsV2, attachments } = params;
-	if (text && (!cardsV2 || cardsV2.length === 0) && (!attachments || attachments.length === 0) && shouldSuppressGoogleChatManualExecApprovalFollowupText(text)) return null;
+	const { account, space, text, thread, cardsV2 } = params;
+	if (text && (!cardsV2 || cardsV2.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`);
 	if (thread) urlObj.searchParams.set("messageReplyOption", "REPLY_MESSAGE_FALLBACK_TO_NEW_THREAD");
 	const result = await fetchJson(account, urlObj.toString(), {
@@ -720,52 +753,10 @@ async function deleteGoogleChatMessage(params) {
 	const { account, messageName } = params;
 	await fetchOk(account, `${CHAT_API_BASE}/${messageName}`, { method: "DELETE" });
 }
-async function uploadGoogleChatAttachment(params) {
-	const { account, space, filename, buffer, contentType } = params;
-	const boundary = `openclaw-${crypto.randomUUID()}`;
-	const header = `--${boundary}\r\nContent-Type: application/json; charset=UTF-8\r\n\r\n${JSON.stringify({ filename })}\r\n`;
-	const mediaHeader = `--${boundary}\r\nContent-Type: ${contentType ?? "application/octet-stream"}\r\n\r\n`;
-	const footer = `\r\n--${boundary}--\r\n`;
-	const body = Buffer.concat([
-		Buffer.from(header, "utf8"),
-		Buffer.from(mediaHeader, "utf8"),
-		buffer,
-		Buffer.from(footer, "utf8")
-	]);
-	return { attachmentUploadToken: (await withGoogleChatResponse({
-		account,
-		url: `${CHAT_UPLOAD_BASE}/${space}/attachments:upload?uploadType=multipart`,
-		init: {
-			method: "POST",
-			headers: { "Content-Type": `multipart/related; boundary=${boundary}` },
-			body
-		},
-		auditContext: "googlechat.upload",
-		errorPrefix: "Google Chat upload",
-		handleResponse: async (response) => await readGoogleChatJsonResponse(response, "Google Chat upload failed")
-	})).attachmentDataRef?.attachmentUploadToken };
-}
 async function downloadGoogleChatMedia(params) {
 	const { account, resourceName, maxBytes } = params;
 	return await fetchBuffer(account, `${CHAT_API_BASE}/media/${resourceName}?alt=media`, void 0, { maxBytes });
 }
-async function createGoogleChatReaction(params) {
-	const { account, messageName, emoji } = params;
-	return await fetchJson(account, `${CHAT_API_BASE}/${messageName}/reactions`, {
-		method: "POST",
-		body: JSON.stringify({ emoji: { unicode: emoji } })
-	});
-}
-async function listGoogleChatReactions(params) {
-	const { account, messageName, limit } = params;
-	const url = new URL(`${CHAT_API_BASE}/${messageName}/reactions`);
-	if (limit && limit > 0) url.searchParams.set("pageSize", String(limit));
-	return (await fetchJson(account, url.toString(), { method: "GET" })).reactions ?? [];
-}
-async function deleteGoogleChatReaction(params) {
-	const { account, reactionName } = params;
-	await fetchOk(account, `${CHAT_API_BASE}/${reactionName}`, { method: "DELETE" });
-}
 async function findGoogleChatDirectMessage(params) {
 	const { account, userName } = params;
 	const url = new URL(`${CHAT_API_BASE}/spaces:findDirectMessage`);
@@ -876,17 +867,18 @@ async function resolveGoogleChatOutboundSessionRoute(params) {
 }
 //#endregion
 //#region extensions/googlechat/src/group-policy.ts
+function resolveScopePath(params) {
+	return params.groupId ? [params.groupId] : [];
+}
 function resolveGoogleChatGroupRequireMention(params) {
-	return resolveChannelGroupRequireMention({
-		cfg: params.cfg,
-		channel: "googlechat",
-		groupId: params.groupId,
-		accountId: params.accountId
+	return resolveScopeRequireMention({
+		tree: buildChannelGroupsScopeTree(params.cfg, "googlechat", params.accountId),
+		path: resolveScopePath(params)
 	});
 }
 //#endregion
 //#region extensions/googlechat/src/channel.adapters.ts
-const loadGoogleChatChannelRuntime = createLazyRuntimeNamedExport(() => import("./channel.runtime-CYmt7Ybo.js"), "googleChatChannelRuntime");
+const loadGoogleChatChannelRuntime = createLazyRuntimeNamedExport(() => import("./channel.runtime-B0u_Dy7b.js"), "googleChatChannelRuntime");
 function createGoogleChatSendReceipt(params) {
 	const messageId = params.messageId?.trim();
 	return createMessageReceiptFromOutboundResults({
@@ -1035,59 +1027,6 @@ const googlechatOutboundAdapter = {
 					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"
-				})
-			};
 		}
 	}
 };
@@ -1095,14 +1034,10 @@ const googlechatMessageAdapter = defineChannelMessageAdapter({
 	id: "googlechat",
 	durableFinal: { capabilities: {
 		text: true,
-		media: true,
 		thread: true,
 		messageSendingHooks: true
 	} },
-	send: {
-		text: googlechatOutboundAdapter.attachedResults.sendText,
-		media: googlechatOutboundAdapter.attachedResults.sendMedia
-	}
+	send: { text: googlechatOutboundAdapter.attachedResults.sendText }
 });
 //#endregion
-export { readGoogleChatApprovalActionToken as A, verifyGoogleChatRequest as C, completeGoogleChatApprovalCardBinding as D, claimGoogleChatApprovalCardBinding as E, unregisterGoogleChatManualApprovalFollowupSuppression as F, registerGoogleChatManualApprovalFollowupSuppression as M, releaseGoogleChatApprovalCardBinding as N, createGoogleChatApprovalToken as O, unregisterGoogleChatApprovalCardBindings as P, uploadGoogleChatAttachment as S, buildGoogleChatApprovalActionParameters as T, downloadGoogleChatMedia as _, googlechatPairingTextAdapter as a, sendGoogleChatMessage as b, isGoogleChatGroupSpace as c, normalizeGoogleChatTarget as d, resolveGoogleChatOutboundSessionRoute as f, deleteGoogleChatReaction as g, deleteGoogleChatMessage as h, googlechatOutboundAdapter as i, registerGoogleChatApprovalCardBinding as j, getGoogleChatApprovalCardBinding as k, isGoogleChatSpaceTarget as l, createGoogleChatReaction as m, googlechatGroupsAdapter as n, googlechatSecurityAdapter as o, resolveGoogleChatOutboundSpace as p, googlechatMessageAdapter as r, googlechatThreadingAdapter as s, googlechatDirectoryAdapter as t, isGoogleChatUserTarget as u, listGoogleChatReactions as v, GOOGLECHAT_APPROVAL_ACTION as w, updateGoogleChatMessage as x, probeGoogleChat as y };
+export { unregisterGoogleChatApprovalCardBindings as A, completeGoogleChatApprovalCardBinding as C, registerGoogleChatApprovalCardBinding as D, readGoogleChatApprovalActionToken as E, registerGoogleChatManualApprovalFollowupSuppression as O, claimGoogleChatApprovalCardBinding as S, getGoogleChatApprovalCardBinding as T, sendGoogleChatMessage as _, googlechatPairingTextAdapter as a, GOOGLECHAT_APPROVAL_ACTION as b, isGoogleChatGroupSpace as c, normalizeGoogleChatTarget as d, resolveGoogleChatOutboundSessionRoute as f, probeGoogleChat as g, downloadGoogleChatMedia as h, googlechatOutboundAdapter as i, unregisterGoogleChatManualApprovalFollowupSuppression as j, releaseGoogleChatApprovalCardBinding as k, isGoogleChatSpaceTarget as l, deleteGoogleChatMessage as m, googlechatGroupsAdapter as n, googlechatSecurityAdapter as o, resolveGoogleChatOutboundSpace as p, googlechatMessageAdapter as r, googlechatThreadingAdapter as s, googlechatDirectoryAdapter as t, isGoogleChatUserTarget as u, updateGoogleChatMessage as v, createGoogleChatApprovalToken as w, buildGoogleChatApprovalActionParameters as x, verifyGoogleChatRequest as y };