@openclaw/googlechat 2026.6.1 → 2026.6.2-beta.1

package/dist/{actions-B4gjETr3.js → actions-DisAY2Ac.js}

@@ -1,7 +1,7 @@
 import { c as resolveGoogleChatAccount, o as listEnabledGoogleChatAccounts } from "./channel-base-DpPD0ef1.js";
 import { P as getGoogleChatRuntime } from "./runtime-api-BbVoWRxq.js";
 import { c as sendGoogleChatMessage, o as listGoogleChatReactions, r as deleteGoogleChatReaction, t as createGoogleChatReaction, u as uploadGoogleChatAttachment } from "./api-DPvlxpWa.js";
-import { n as resolveGoogleChatOutboundSpace } from "./channel-DxHy0I-n.js";
+import { d as resolveGoogleChatOutboundSpace } from "./channel.adapters-LlD3wKl5.js";
 import { extractToolSend } from "openclaw/plugin-sdk/tool-send";
 import { createActionGate, jsonResult, readPositiveIntegerParam, readReactionParams, readStringParam } from "openclaw/plugin-sdk/channel-actions";
 import { loadOutboundMediaFromUrl } from "openclaw/plugin-sdk/outbound-media";

package/dist/api.js

@@ -1,3 +1,3 @@
 import { a as googlechatSetupAdapter, i as googlechatSetupWizard } from "./channel-base-DpPD0ef1.js";
-import { t as googlechatPlugin } from "./channel-DxHy0I-n.js";
+import { t as googlechatPlugin } from "./channel-AbgtAg3y.js";
 export { googlechatPlugin, googlechatSetupAdapter, googlechatSetupWizard };

package/dist/channel-AbgtAg3y.js

@@ -0,0 +1,258 @@
+import { c as resolveGoogleChatAccount, n as createGoogleChatPluginBase, s as listGoogleChatAccountIds, t as GOOGLECHAT_CHANNEL_ID } from "./channel-base-DpPD0ef1.js";
+import { a as buildChannelConfigSchema, r as GoogleChatConfigSchema, t as DEFAULT_ACCOUNT_ID } from "./runtime-api-BbVoWRxq.js";
+import { a as googlechatPairingTextAdapter, c as isGoogleChatSpaceTarget, i as googlechatOutboundAdapter, l as isGoogleChatUserTarget, n as googlechatGroupsAdapter, o as googlechatSecurityAdapter, r as googlechatMessageAdapter, s as googlechatThreadingAdapter, t as googlechatDirectoryAdapter, u as normalizeGoogleChatTarget } from "./channel.adapters-LlD3wKl5.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 { createChatChannelPlugin } from "openclaw/plugin-sdk/channel-core";
+import { buildPassiveProbedChannelStatusSummary } from "openclaw/plugin-sdk/extension-shared";
+import { createLazyRuntimeNamedExport } from "openclaw/plugin-sdk/lazy-runtime";
+import { createComputedAccountStatusAdapter, createDefaultChannelRuntimeState } from "openclaw/plugin-sdk/status-helpers";
+import { extractToolSend } from "openclaw/plugin-sdk/tool-send";
+import { createResolvedApproverActionAuthAdapter, resolveApprovalApprovers } from "openclaw/plugin-sdk/approval-auth-runtime";
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { createAccountStatusSink, runPassiveAccountLifecycle } from "openclaw/plugin-sdk/channel-outbound";
+import { createDangerousNameMatchingMutableAllowlistWarningCollector } from "openclaw/plugin-sdk/channel-policy";
+//#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 googleChatApprovalAuth = createResolvedApproverActionAuthAdapter({
+	channelLabel: "Google Chat",
+	resolveApprovers: ({ cfg, accountId }) => {
+		const account = resolveGoogleChatAccount({
+			cfg,
+			accountId
+		}).config;
+		return resolveApprovalApprovers({
+			allowFrom: account.dm?.allowFrom,
+			defaultTo: account.defaultTo,
+			normalizeApprover: normalizeGoogleChatApproverId
+		});
+	},
+	normalizeSenderId: (value) => normalizeGoogleChatApproverId(value)
+});
+//#endregion
+//#region extensions/googlechat/src/doctor.ts
+function asObjectRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function isGoogleChatMutableAllowEntry(raw) {
+	const text = raw.trim();
+	if (!text || text === "*") return false;
+	const withoutPrefix = text.replace(/^(googlechat|google-chat|gchat):/i, "").trim();
+	if (!withoutPrefix) return false;
+	return withoutPrefix.replace(/^users\//i, "").includes("@");
+}
+const collectGoogleChatMutableAllowlistWarnings = createDangerousNameMatchingMutableAllowlistWarningCollector({
+	channel: "googlechat",
+	detector: isGoogleChatMutableAllowEntry,
+	collectLists: (scope) => {
+		const lists = [{
+			pathLabel: `${scope.prefix}.groupAllowFrom`,
+			list: scope.account.groupAllowFrom
+		}];
+		const dm = asObjectRecord(scope.account.dm);
+		if (dm) lists.push({
+			pathLabel: `${scope.prefix}.dm.allowFrom`,
+			list: dm.allowFrom
+		});
+		const groups = asObjectRecord(scope.account.groups);
+		if (groups) for (const [groupKey, groupRaw] of Object.entries(groups)) {
+			const group = asObjectRecord(groupRaw);
+			if (!group) continue;
+			lists.push({
+				pathLabel: `${scope.prefix}.groups.${groupKey}.users`,
+				list: group.users
+			});
+		}
+		return lists;
+	}
+});
+//#endregion
+//#region extensions/googlechat/src/gateway.ts
+const loadGoogleChatChannelRuntime$1 = createLazyRuntimeNamedExport(() => import("./channel.runtime-C4eLDKR3.js"), "googleChatChannelRuntime");
+async function startGoogleChatGatewayAccount(ctx) {
+	const account = ctx.account;
+	const statusSink = createAccountStatusSink({
+		accountId: account.accountId,
+		setStatus: ctx.setStatus
+	});
+	ctx.log?.info?.(`[${account.accountId}] starting Google Chat webhook`);
+	const { resolveGoogleChatWebhookPath, startGoogleChatMonitor } = await loadGoogleChatChannelRuntime$1();
+	statusSink({
+		running: true,
+		lastStartAt: Date.now(),
+		webhookPath: resolveGoogleChatWebhookPath({ account }),
+		audienceType: account.config.audienceType,
+		audience: account.config.audience
+	});
+	await runPassiveAccountLifecycle({
+		abortSignal: ctx.abortSignal,
+		start: async () => await startGoogleChatMonitor({
+			account,
+			config: ctx.cfg,
+			runtime: ctx.runtime,
+			abortSignal: ctx.abortSignal,
+			webhookPath: account.config.webhookPath,
+			webhookUrl: account.config.webhookUrl,
+			statusSink
+		}),
+		stop: async (unregister) => {
+			unregister?.();
+		},
+		onStop: async () => {
+			statusSink({
+				running: false,
+				lastStopAt: Date.now()
+			});
+		}
+	});
+}
+//#endregion
+//#region extensions/googlechat/src/channel.ts
+const loadGoogleChatChannelRuntime = createLazyRuntimeNamedExport(() => import("./channel.runtime-C4eLDKR3.js"), "googleChatChannelRuntime");
+const googlechatActions = {
+	describeMessageTool: ({ cfg, accountId }) => {
+		const accounts = 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 = 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) };
+	},
+	extractToolSend: ({ args }) => extractToolSend(args, "sendMessage"),
+	handleAction: async (ctx) => {
+		const { googlechatMessageActions } = await import("./actions-DisAY2Ac.js");
+		if (!googlechatMessageActions.handleAction) throw new Error("Google Chat actions are not available.");
+		return await googlechatMessageActions.handleAction(ctx);
+	}
+};
+const googlechatPlugin = createChatChannelPlugin({
+	base: {
+		...createGoogleChatPluginBase({ configSchema: buildChannelConfigSchema(GoogleChatConfigSchema) }),
+		approvalCapability: googleChatApprovalAuth,
+		secrets: {
+			secretTargetRegistryEntries,
+			collectRuntimeConfigAssignments
+		},
+		groups: googlechatGroupsAdapter,
+		messaging: {
+			targetPrefixes: [
+				"googlechat",
+				"google-chat",
+				"gchat"
+			],
+			normalizeTarget: normalizeGoogleChatTarget,
+			targetResolver: {
+				looksLikeId: (raw, normalized) => {
+					const value = normalized ?? raw.trim();
+					return isGoogleChatSpaceTarget(value) || isGoogleChatUserTarget(value);
+				},
+				hint: "<spaces/{space}|users/{user}>"
+			}
+		},
+		directory: googlechatDirectoryAdapter,
+		message: googlechatMessageAdapter,
+		resolver: { resolveTargets: async ({ inputs, kind }) => {
+			return inputs.map((input) => {
+				const normalized = normalizeGoogleChatTarget(input);
+				if (!normalized) return {
+					input,
+					resolved: false,
+					note: "empty target"
+				};
+				if (kind === "user" && isGoogleChatUserTarget(normalized)) return {
+					input,
+					resolved: true,
+					id: normalized
+				};
+				if (kind === "group" && isGoogleChatSpaceTarget(normalized)) return {
+					input,
+					resolved: true,
+					id: normalized
+				};
+				return {
+					input,
+					resolved: false,
+					note: "use spaces/{space} or users/{user}"
+				};
+			});
+		} },
+		actions: googlechatActions,
+		doctor: {
+			dmAllowFromMode: "nestedOnly",
+			groupModel: "route",
+			groupAllowFromFallbackToAllowFrom: false,
+			warnOnEmptyGroupSenderAllowlist: false,
+			legacyConfigRules,
+			normalizeCompatibilityConfig,
+			collectMutableAllowlistWarnings: collectGoogleChatMutableAllowlistWarnings
+		},
+		status: createComputedAccountStatusAdapter({
+			defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID),
+			collectStatusIssues: (accounts) => accounts.flatMap((entry) => {
+				const accountId = entry.accountId ?? DEFAULT_ACCOUNT_ID;
+				const enabled = entry.enabled !== false;
+				const configured = entry.configured === true;
+				if (!enabled || !configured) return [];
+				const issues = [];
+				if (!entry.audience) issues.push({
+					channel: GOOGLECHAT_CHANNEL_ID,
+					accountId,
+					kind: "config",
+					message: "Google Chat audience is missing (set channels.googlechat.audience).",
+					fix: "Set channels.googlechat.audienceType and channels.googlechat.audience."
+				});
+				if (!entry.audienceType) issues.push({
+					channel: GOOGLECHAT_CHANNEL_ID,
+					accountId,
+					kind: "config",
+					message: "Google Chat audienceType is missing (app-url or project-number).",
+					fix: "Set channels.googlechat.audienceType and channels.googlechat.audience."
+				});
+				return issues;
+			}),
+			buildChannelSummary: ({ snapshot }) => buildPassiveProbedChannelStatusSummary(snapshot, {
+				credentialSource: snapshot.credentialSource ?? "none",
+				audienceType: snapshot.audienceType ?? null,
+				audience: snapshot.audience ?? null,
+				webhookPath: snapshot.webhookPath ?? null,
+				webhookUrl: snapshot.webhookUrl ?? null
+			}),
+			probeAccount: async ({ account }) => (await loadGoogleChatChannelRuntime()).probeGoogleChat(account),
+			resolveAccountSnapshot: ({ account }) => ({
+				accountId: account.accountId,
+				name: account.name,
+				enabled: account.enabled,
+				configured: account.credentialSource !== "none",
+				extra: {
+					credentialSource: account.credentialSource,
+					audienceType: account.config.audienceType,
+					audience: account.config.audience,
+					webhookPath: account.config.webhookPath,
+					webhookUrl: account.config.webhookUrl,
+					dmPolicy: account.config.dm?.policy ?? "pairing"
+				}
+			})
+		}),
+		gateway: { startAccount: startGoogleChatGatewayAccount }
+	},
+	pairing: { text: googlechatPairingTextAdapter },
+	security: googlechatSecurityAdapter,
+	threading: googlechatThreadingAdapter,
+	outbound: googlechatOutboundAdapter
+});
+//#endregion
+export { googlechatPlugin as t };

package/dist/channel-plugin-api.js

@@ -1,2 +1,2 @@
-import { t as googlechatPlugin } from "./channel-DxHy0I-n.js";
+import { t as googlechatPlugin } from "./channel-AbgtAg3y.js";
 export { googlechatPlugin };

package/dist/channel.adapters-LlD3wKl5.js

@@ -0,0 +1,280 @@
+import { c as resolveGoogleChatAccount, r as formatGoogleChatAllowFromEntry } from "./channel-base-DpPD0ef1.js";
+import { T as resolveChannelMediaMaxBytes, _ as missingTargetError, g as loadOutboundMediaFromUrl, i as PAIRING_APPROVED_MESSAGE, o as chunkTextForOutbound, x as readRemoteMediaBuffer } from "./runtime-api-BbVoWRxq.js";
+import { a as findGoogleChatDirectMessage } from "./api-DPvlxpWa.js";
+import { createLazyRuntimeNamedExport } from "openclaw/plugin-sdk/lazy-runtime";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { createMessageReceiptFromOutboundResults, defineChannelMessageAdapter, sanitizeForPlainText } from "openclaw/plugin-sdk/channel-outbound";
+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/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-C4eLDKR3.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),
+		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 { googlechatPairingTextAdapter as a, isGoogleChatSpaceTarget as c, resolveGoogleChatOutboundSpace as d, googlechatOutboundAdapter as i, isGoogleChatUserTarget as l, googlechatGroupsAdapter as n, googlechatSecurityAdapter as o, googlechatMessageAdapter as r, googlechatThreadingAdapter as s, googlechatDirectoryAdapter as t, normalizeGoogleChatTarget as u };

package/dist/directory-contract-api.js

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

package/npm-shrinkwrap.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/googlechat",
-  "version": "2026.6.1",
+  "version": "2026.6.2-beta.1",
   "description": "OpenClaw Google Chat channel plugin for spaces and direct messages.",
   "repository": {
     "type": "git",
@@ -13,7 +13,7 @@
     "zod": "4.4.3"
   },
   "peerDependencies": {
-    "openclaw": ">=2026.6.1"
+    "openclaw": ">=2026.6.2-beta.1"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -71,10 +71,10 @@
       "minHostVersion": ">=2026.4.10"
     },
     "compat": {
-      "pluginApi": ">=2026.6.1"
+      "pluginApi": ">=2026.6.2-beta.1"
     },
     "build": {
-      "openclawVersion": "2026.6.1"
+      "openclawVersion": "2026.6.2-beta.1"
     },
     "release": {
       "publishToClawHub": true,

package/dist/channel-DxHy0I-n.js

@@ -1,530 +0,0 @@
-import { c as resolveGoogleChatAccount, n as createGoogleChatPluginBase, r as formatGoogleChatAllowFromEntry, s as listGoogleChatAccountIds, t as GOOGLECHAT_CHANNEL_ID } from "./channel-base-DpPD0ef1.js";
-import { T as resolveChannelMediaMaxBytes, _ as missingTargetError, a as buildChannelConfigSchema, g as loadOutboundMediaFromUrl, i as PAIRING_APPROVED_MESSAGE, o as chunkTextForOutbound, r as GoogleChatConfigSchema, t as DEFAULT_ACCOUNT_ID, x as readRemoteMediaBuffer } from "./runtime-api-BbVoWRxq.js";
-import { a as findGoogleChatDirectMessage } from "./api-DPvlxpWa.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 { createChatChannelPlugin } from "openclaw/plugin-sdk/channel-core";
-import { buildPassiveProbedChannelStatusSummary } from "openclaw/plugin-sdk/extension-shared";
-import { createLazyRuntimeNamedExport } from "openclaw/plugin-sdk/lazy-runtime";
-import { createComputedAccountStatusAdapter, createDefaultChannelRuntimeState } from "openclaw/plugin-sdk/status-helpers";
-import { extractToolSend } from "openclaw/plugin-sdk/tool-send";
-import { createResolvedApproverActionAuthAdapter, resolveApprovalApprovers } from "openclaw/plugin-sdk/approval-auth-runtime";
-import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { createAccountStatusSink, createMessageReceiptFromOutboundResults, defineChannelMessageAdapter, runPassiveAccountLifecycle, sanitizeForPlainText } from "openclaw/plugin-sdk/channel-outbound";
-import { adaptScopedAccountAccessor } from "openclaw/plugin-sdk/channel-config-helpers";
-import { composeAccountWarningCollectors, createAllowlistProviderOpenWarningCollector, createDangerousNameMatchingMutableAllowlistWarningCollector, resolveChannelGroupRequireMention } from "openclaw/plugin-sdk/channel-policy";
-import { createChannelDirectoryAdapter, listResolvedDirectoryGroupEntriesFromMapKeys, listResolvedDirectoryUserEntriesFromAllowFrom } from "openclaw/plugin-sdk/directory-runtime";
-//#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/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 googleChatApprovalAuth = createResolvedApproverActionAuthAdapter({
-	channelLabel: "Google Chat",
-	resolveApprovers: ({ cfg, accountId }) => {
-		const account = resolveGoogleChatAccount({
-			cfg,
-			accountId
-		}).config;
-		return resolveApprovalApprovers({
-			allowFrom: account.dm?.allowFrom,
-			defaultTo: account.defaultTo,
-			normalizeApprover: normalizeGoogleChatApproverId
-		});
-	},
-	normalizeSenderId: (value) => normalizeGoogleChatApproverId(value)
-});
-//#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$2 = createLazyRuntimeNamedExport(() => import("./channel.runtime-C4eLDKR3.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$2();
-		await sendGoogleChatMessage({
-			account,
-			space,
-			text: message
-		});
-	}
-};
-const googlechatOutboundAdapter = {
-	base: {
-		deliveryMode: "direct",
-		chunker: chunkTextForOutbound,
-		chunkerMode: "markdown",
-		textChunkLimit: 4e3,
-		sanitizeText: ({ text }) => sanitizeForPlainText(text),
-		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$2();
-			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$2();
-			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
-//#region extensions/googlechat/src/doctor.ts
-function asObjectRecord(value) {
-	return value && typeof value === "object" && !Array.isArray(value) ? value : null;
-}
-function isGoogleChatMutableAllowEntry(raw) {
-	const text = raw.trim();
-	if (!text || text === "*") return false;
-	const withoutPrefix = text.replace(/^(googlechat|google-chat|gchat):/i, "").trim();
-	if (!withoutPrefix) return false;
-	return withoutPrefix.replace(/^users\//i, "").includes("@");
-}
-const collectGoogleChatMutableAllowlistWarnings = createDangerousNameMatchingMutableAllowlistWarningCollector({
-	channel: "googlechat",
-	detector: isGoogleChatMutableAllowEntry,
-	collectLists: (scope) => {
-		const lists = [{
-			pathLabel: `${scope.prefix}.groupAllowFrom`,
-			list: scope.account.groupAllowFrom
-		}];
-		const dm = asObjectRecord(scope.account.dm);
-		if (dm) lists.push({
-			pathLabel: `${scope.prefix}.dm.allowFrom`,
-			list: dm.allowFrom
-		});
-		const groups = asObjectRecord(scope.account.groups);
-		if (groups) for (const [groupKey, groupRaw] of Object.entries(groups)) {
-			const group = asObjectRecord(groupRaw);
-			if (!group) continue;
-			lists.push({
-				pathLabel: `${scope.prefix}.groups.${groupKey}.users`,
-				list: group.users
-			});
-		}
-		return lists;
-	}
-});
-//#endregion
-//#region extensions/googlechat/src/gateway.ts
-const loadGoogleChatChannelRuntime$1 = createLazyRuntimeNamedExport(() => import("./channel.runtime-C4eLDKR3.js"), "googleChatChannelRuntime");
-async function startGoogleChatGatewayAccount(ctx) {
-	const account = ctx.account;
-	const statusSink = createAccountStatusSink({
-		accountId: account.accountId,
-		setStatus: ctx.setStatus
-	});
-	ctx.log?.info?.(`[${account.accountId}] starting Google Chat webhook`);
-	const { resolveGoogleChatWebhookPath, startGoogleChatMonitor } = await loadGoogleChatChannelRuntime$1();
-	statusSink({
-		running: true,
-		lastStartAt: Date.now(),
-		webhookPath: resolveGoogleChatWebhookPath({ account }),
-		audienceType: account.config.audienceType,
-		audience: account.config.audience
-	});
-	await runPassiveAccountLifecycle({
-		abortSignal: ctx.abortSignal,
-		start: async () => await startGoogleChatMonitor({
-			account,
-			config: ctx.cfg,
-			runtime: ctx.runtime,
-			abortSignal: ctx.abortSignal,
-			webhookPath: account.config.webhookPath,
-			webhookUrl: account.config.webhookUrl,
-			statusSink
-		}),
-		stop: async (unregister) => {
-			unregister?.();
-		},
-		onStop: async () => {
-			statusSink({
-				running: false,
-				lastStopAt: Date.now()
-			});
-		}
-	});
-}
-//#endregion
-//#region extensions/googlechat/src/channel.ts
-const loadGoogleChatChannelRuntime = createLazyRuntimeNamedExport(() => import("./channel.runtime-C4eLDKR3.js"), "googleChatChannelRuntime");
-const googlechatActions = {
-	describeMessageTool: ({ cfg, accountId }) => {
-		const accounts = 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 = 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) };
-	},
-	extractToolSend: ({ args }) => extractToolSend(args, "sendMessage"),
-	handleAction: async (ctx) => {
-		const { googlechatMessageActions } = await import("./actions-B4gjETr3.js");
-		if (!googlechatMessageActions.handleAction) throw new Error("Google Chat actions are not available.");
-		return await googlechatMessageActions.handleAction(ctx);
-	}
-};
-const googlechatPlugin = createChatChannelPlugin({
-	base: {
-		...createGoogleChatPluginBase({ configSchema: buildChannelConfigSchema(GoogleChatConfigSchema) }),
-		approvalCapability: googleChatApprovalAuth,
-		secrets: {
-			secretTargetRegistryEntries,
-			collectRuntimeConfigAssignments
-		},
-		groups: googlechatGroupsAdapter,
-		messaging: {
-			targetPrefixes: [
-				"googlechat",
-				"google-chat",
-				"gchat"
-			],
-			normalizeTarget: normalizeGoogleChatTarget,
-			targetResolver: {
-				looksLikeId: (raw, normalized) => {
-					const value = normalized ?? raw.trim();
-					return isGoogleChatSpaceTarget(value) || isGoogleChatUserTarget(value);
-				},
-				hint: "<spaces/{space}|users/{user}>"
-			}
-		},
-		directory: googlechatDirectoryAdapter,
-		message: googlechatMessageAdapter,
-		resolver: { resolveTargets: async ({ inputs, kind }) => {
-			return inputs.map((input) => {
-				const normalized = normalizeGoogleChatTarget(input);
-				if (!normalized) return {
-					input,
-					resolved: false,
-					note: "empty target"
-				};
-				if (kind === "user" && isGoogleChatUserTarget(normalized)) return {
-					input,
-					resolved: true,
-					id: normalized
-				};
-				if (kind === "group" && isGoogleChatSpaceTarget(normalized)) return {
-					input,
-					resolved: true,
-					id: normalized
-				};
-				return {
-					input,
-					resolved: false,
-					note: "use spaces/{space} or users/{user}"
-				};
-			});
-		} },
-		actions: googlechatActions,
-		doctor: {
-			dmAllowFromMode: "nestedOnly",
-			groupModel: "route",
-			groupAllowFromFallbackToAllowFrom: false,
-			warnOnEmptyGroupSenderAllowlist: false,
-			legacyConfigRules,
-			normalizeCompatibilityConfig,
-			collectMutableAllowlistWarnings: collectGoogleChatMutableAllowlistWarnings
-		},
-		status: createComputedAccountStatusAdapter({
-			defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID),
-			collectStatusIssues: (accounts) => accounts.flatMap((entry) => {
-				const accountId = entry.accountId ?? DEFAULT_ACCOUNT_ID;
-				const enabled = entry.enabled !== false;
-				const configured = entry.configured === true;
-				if (!enabled || !configured) return [];
-				const issues = [];
-				if (!entry.audience) issues.push({
-					channel: GOOGLECHAT_CHANNEL_ID,
-					accountId,
-					kind: "config",
-					message: "Google Chat audience is missing (set channels.googlechat.audience).",
-					fix: "Set channels.googlechat.audienceType and channels.googlechat.audience."
-				});
-				if (!entry.audienceType) issues.push({
-					channel: GOOGLECHAT_CHANNEL_ID,
-					accountId,
-					kind: "config",
-					message: "Google Chat audienceType is missing (app-url or project-number).",
-					fix: "Set channels.googlechat.audienceType and channels.googlechat.audience."
-				});
-				return issues;
-			}),
-			buildChannelSummary: ({ snapshot }) => buildPassiveProbedChannelStatusSummary(snapshot, {
-				credentialSource: snapshot.credentialSource ?? "none",
-				audienceType: snapshot.audienceType ?? null,
-				audience: snapshot.audience ?? null,
-				webhookPath: snapshot.webhookPath ?? null,
-				webhookUrl: snapshot.webhookUrl ?? null
-			}),
-			probeAccount: async ({ account }) => (await loadGoogleChatChannelRuntime()).probeGoogleChat(account),
-			resolveAccountSnapshot: ({ account }) => ({
-				accountId: account.accountId,
-				name: account.name,
-				enabled: account.enabled,
-				configured: account.credentialSource !== "none",
-				extra: {
-					credentialSource: account.credentialSource,
-					audienceType: account.config.audienceType,
-					audience: account.config.audience,
-					webhookPath: account.config.webhookPath,
-					webhookUrl: account.config.webhookUrl,
-					dmPolicy: account.config.dm?.policy ?? "pairing"
-				}
-			})
-		}),
-		gateway: { startAccount: startGoogleChatGatewayAccount }
-	},
-	pairing: { text: googlechatPairingTextAdapter },
-	security: googlechatSecurityAdapter,
-	threading: googlechatThreadingAdapter,
-	outbound: googlechatOutboundAdapter
-});
-//#endregion
-export { resolveGoogleChatOutboundSpace as n, googlechatPlugin as t };