@openclaw/googlechat 2026.5.7 → 2026.5.10-beta.1

package/dist/{channel.runtime-Bu7xf0wo.js → channel.runtime-CK4QbJkn.js}

@@ -1,40 +1,44 @@
-import { A as resolveInboundRouteEnvelopeBuilderWithRuntime, D as resolveDefaultGroupPolicy, F as warnMissingProviderGroupPolicyFallbackOnce, L as getGoogleChatRuntime, M as resolveWebhookPath, O as resolveDmGroupAccessWithLists, T as resolveAllowlistProviderRuntimeGroupPolicy, f as evaluateGroupRouteAccessForPolicy, g as isDangerousNameMatchingEnabled, j as resolveSenderScopedGroupPolicy, l as createChannelPairingController, n as GROUP_POLICY_BLOCKED_LABEL, u as createChannelReplyPipeline } from "./runtime-api-wkIdfwqY.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-C8OqyWsW.js";
-import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";
-import { resolveInboundMentionDecision } from "openclaw/plugin-sdk/channel-inbound";
+import { E as resolveDefaultGroupPolicy, M as warnMissingProviderGroupPolicyFallbackOnce, O as resolveInboundRouteEnvelopeBuilderWithRuntime, P as getGoogleChatRuntime, h as isDangerousNameMatchingEnabled, k as resolveWebhookPath, n as GROUP_POLICY_BLOCKED_LABEL, u as createChannelPairingController, w as resolveAllowlistProviderRuntimeGroupPolicy } from "./runtime-api-DMEzhesS.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-AErsImS_.js";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeStringEntries } from "openclaw/plugin-sdk/text-runtime";
 import { registerWebhookTargetWithPluginRoute, resolveWebhookTargetWithAuthOrReject, withResolvedWebhookRequestPipeline } from "openclaw/plugin-sdk/webhook-targets";
 import { createWebhookInFlightLimiter, readJsonWebhookBodyOrReject } from "openclaw/plugin-sdk/webhook-request-guards";
-import { expandAllowFromWithAccessGroups } from "openclaw/plugin-sdk/security-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/sender-allow.ts
-function normalizeUserId$1(raw) {
-	const trimmed = typeof raw === "string" ? raw.trim() : "";
-	if (!trimmed) return "";
-	return normalizeLowercaseStringOrEmpty(trimmed.replace(/^users\//i, ""));
-}
-function isEmailLike(value) {
-	return value.includes("@");
-}
-function isSenderAllowed(senderId, senderEmail, allowFrom, allowNameMatching = false) {
-	if (allowFrom.includes("*")) return true;
-	const normalizedSenderId = normalizeUserId$1(senderId);
-	const normalizedEmail = normalizeLowercaseStringOrEmpty(senderEmail ?? "");
-	return allowFrom.some((entry) => {
-		const normalized = normalizeLowercaseStringOrEmpty(entry);
-		if (!normalized) return false;
-		const withoutPrefix = normalized.replace(/^(googlechat|google-chat|gchat):/i, "");
-		if (withoutPrefix.startsWith("users/")) return normalizeUserId$1(withoutPrefix) === normalizedSenderId;
-		if (allowNameMatching && normalizedEmail && isEmailLike(withoutPrefix)) return withoutPrefix === normalizedEmail;
-		return withoutPrefix.replace(/^users\//i, "") === normalizedSenderId;
-	});
-}
-//#endregion
 //#region extensions/googlechat/src/monitor-access.ts
 function normalizeUserId(raw) {
 	const trimmed = normalizeOptionalString(raw) ?? "";
 	if (!trimmed) return "";
 	return normalizeLowercaseStringOrEmpty(trimmed.replace(/^users\//i, ""));
 }
+const GOOGLECHAT_EMAIL_KIND = "plugin:googlechat-email";
+function normalizeEntryValue(raw) {
+	return normalizeLowercaseStringOrEmpty(raw ?? "");
+}
+function normalizeGoogleChatStableEntry(entry) {
+	const withoutProvider = normalizeEntryValue(entry).replace(/^(googlechat|google-chat|gchat):/i, "");
+	if (!withoutProvider) return null;
+	return withoutProvider.startsWith("users/") ? normalizeUserId(withoutProvider) : withoutProvider;
+}
+function normalizeGoogleChatEmailEntry(entry) {
+	if (normalizeEntryValue(entry).replace(/^(googlechat|google-chat|gchat):/i, "").startsWith("users/")) return null;
+	const stable = normalizeGoogleChatStableEntry(entry);
+	return stable?.includes("@") ? stable : null;
+}
+const googleChatIngressIdentity = defineStableChannelIngressIdentity({
+	key: "sender-id",
+	normalizeEntry: normalizeGoogleChatStableEntry,
+	normalizeSubject: normalizeUserId,
+	aliases: [{
+		key: "email",
+		kind: GOOGLECHAT_EMAIL_KIND,
+		normalizeEntry: normalizeGoogleChatEmailEntry,
+		normalizeSubject: normalizeEntryValue,
+		dangerous: true
+	}],
+	isWildcardEntry: (entry) => normalizeEntryValue(entry) === "*",
+	resolveEntryId: ({ entryIndex, fieldKey }) => fieldKey === "stableId" ? `entry-${entryIndex + 1}:user` : `entry-${entryIndex + 1}:${fieldKey}`
+});
 function resolveGroupConfig(params) {
 	const { groupId, groupName, groups } = params;
 	const entries = groups ?? {};
@@ -121,120 +125,116 @@ async function applyGoogleChatInboundAccessPolicy(params) {
 	});
 	const groupEntry = groupConfigResolved.entry;
 	const groupUsers = groupEntry?.users ?? account.config.groupAllowFrom ?? [];
-	const isGoogleChatSenderAllowed = (_senderId, allowFrom) => isSenderAllowed(senderId, senderEmail, allowFrom, allowNameMatching);
-	const expandedGroupUsers = await expandAllowFromWithAccessGroups({
-		cfg: config,
-		allowFrom: groupUsers,
-		channel: "googlechat",
+	let effectiveWasMentioned;
+	const dmPolicy = account.config.dm?.policy ?? "pairing";
+	const rawConfigAllowFrom = normalizeStringEntries(account.config.dm?.allowFrom);
+	const shouldComputeAuth = core.channel.commands.shouldComputeCommandAuthorized(rawBody, config);
+	const groupActivation = (() => {
+		if (!isGroup) return;
+		const requireMention = groupEntry?.requireMention ?? account.config.requireMention ?? true;
+		const mentionInfo = extractMentionInfo(message.annotations ?? [], account.config.botUser);
+		return {
+			requireMention,
+			allowTextCommands: core.channel.commands.shouldHandleTextCommands({
+				cfg: config,
+				surface: "googlechat"
+			}),
+			hasControlCommand: core.channel.text.hasControlCommand(rawBody, config),
+			wasMentioned: mentionInfo.wasMentioned,
+			hasAnyMention: mentionInfo.hasAnyMention
+		};
+	})();
+	const command = {
+		hasControlCommand: groupActivation?.hasControlCommand ?? shouldComputeAuth,
+		groupOwnerAllowFrom: "none"
+	};
+	const groupAllowFrom = normalizeStringEntries(groupUsers);
+	const senderGroupPolicy = groupConfigResolved.allowlistConfigured && groupAllowFrom.length === 0 ? groupPolicy : groupPolicy === "disabled" ? "disabled" : groupAllowFrom.length > 0 ? "allowlist" : "open";
+	const route = channelIngressRoutes(isGroup && groupPolicy !== "disabled" && groupEntry?.enabled === false && {
+		id: "googlechat:space",
+		enabled: false,
+		matched: true,
+		matchId: "googlechat-space",
+		blockReason: "route_disabled"
+	}, isGroup && groupPolicy === "allowlist" && groupEntry?.enabled !== false && !groupConfigResolved.allowlistConfigured && {
+		id: "googlechat:space",
+		allowed: false,
+		blockReason: "empty_allowlist"
+	}, isGroup && groupPolicy === "allowlist" && groupEntry?.enabled !== false && groupConfigResolved.allowlistConfigured && {
+		id: "googlechat:space",
+		senderPolicy: "deny-when-empty",
+		...groupEntry ? { senderAllowFromSource: "effective-group" } : {},
+		allowed: Boolean(groupEntry),
+		matchId: "googlechat-space",
+		blockReason: groupEntry ? "sender_empty_allowlist" : "route_not_allowlisted"
+	});
+	const resolvedAccess = await createChannelIngressResolver({
+		channelId: "googlechat",
 		accountId: account.accountId,
-		senderId,
-		isSenderAllowed: isGoogleChatSenderAllowed
+		identity: googleChatIngressIdentity,
+		cfg: config,
+		readStoreAllowFrom: pairing.readAllowFromStore
+	}).message({
+		subject: {
+			stableId: senderId,
+			aliases: { email: senderEmail }
+		},
+		conversation: {
+			kind: isGroup ? "group" : "direct",
+			id: spaceId
+		},
+		route,
+		allowFrom: rawConfigAllowFrom,
+		groupAllowFrom,
+		dmPolicy,
+		groupPolicy: senderGroupPolicy,
+		policy: {
+			groupAllowFromFallbackToAllowFrom: false,
+			mutableIdentifierMatching: allowNameMatching ? "enabled" : "disabled",
+			...groupActivation ? { activation: {
+				requireMention: groupActivation.requireMention,
+				allowTextCommands: groupActivation.allowTextCommands
+			} } : {}
+		},
+		...groupActivation == null ? {} : { mentionFacts: {
+			canDetectMention: true,
+			wasMentioned: groupActivation.wasMentioned,
+			hasAnyMention: groupActivation.hasAnyMention,
+			implicitMentionKinds: []
+		} },
+		command
 	});
-	let effectiveWasMentioned;
+	const senderAccess = resolvedAccess.senderAccess;
+	const commandAuthorized = resolvedAccess.commandAccess.requested ? resolvedAccess.commandAccess.authorized : void 0;
 	if (isGroup) {
 		if (groupConfigResolved.deprecatedNameMatch) {
 			logVerbose(`drop group message (deprecated mutable group key matched, space=${spaceId})`);
 			return { ok: false };
 		}
-		const groupAllowlistConfigured = groupConfigResolved.allowlistConfigured;
-		const routeAccess = evaluateGroupRouteAccessForPolicy({
-			groupPolicy,
-			routeAllowlistConfigured: groupAllowlistConfigured,
-			routeMatched: Boolean(groupEntry),
-			routeEnabled: groupEntry?.enabled !== false
-		});
-		if (!routeAccess.allowed) {
-			if (routeAccess.reason === "disabled") logVerbose(`drop group message (groupPolicy=disabled, space=${spaceId})`);
-			else if (routeAccess.reason === "empty_allowlist") logVerbose(`drop group message (groupPolicy=allowlist, no allowlist, space=${spaceId})`);
-			else if (routeAccess.reason === "route_not_allowlisted") logVerbose(`drop group message (not allowlisted, space=${spaceId})`);
-			else if (routeAccess.reason === "route_disabled") logVerbose(`drop group message (space disabled, space=${spaceId})`);
+		const routeBlockReason = resolvedAccess.routeAccess.reason;
+		if (routeBlockReason && routeBlockReason !== "sender_empty_allowlist") {
+			if (routeBlockReason === "empty_allowlist") logVerbose(`drop group message (groupPolicy=allowlist, no allowlist, space=${spaceId})`);
+			else if (routeBlockReason === "route_not_allowlisted") logVerbose(`drop group message (not allowlisted, space=${spaceId})`);
+			else if (routeBlockReason === "route_disabled") logVerbose(`drop group message (space disabled, space=${spaceId})`);
 			return { ok: false };
 		}
-		if (expandedGroupUsers.length > 0) {
-			warnDeprecatedUsersEmailEntries(logVerbose, expandedGroupUsers);
-			if (!isSenderAllowed(senderId, senderEmail, expandedGroupUsers, allowNameMatching)) {
-				logVerbose(`drop group message (sender not allowed, ${senderId})`);
-				return { ok: false };
-			}
+		if (senderAccess.effectiveGroupAllowFrom.length > 0 && senderAccess.decision !== "allow") {
+			warnDeprecatedUsersEmailEntries(logVerbose, senderAccess.effectiveGroupAllowFrom);
+			logVerbose(`drop group message (sender not allowed, ${senderId})`);
+			return { ok: false };
 		}
 	}
-	const dmPolicy = account.config.dm?.policy ?? "pairing";
-	const rawConfigAllowFrom = (account.config.dm?.allowFrom ?? []).map((v) => String(v));
-	const normalizedGroupUsers = expandedGroupUsers;
-	const senderGroupPolicy = groupConfigResolved.allowlistConfigured && normalizedGroupUsers.length === 0 ? groupPolicy : resolveSenderScopedGroupPolicy({
-		groupPolicy,
-		groupAllowFrom: normalizedGroupUsers
-	});
-	const shouldComputeAuth = core.channel.commands.shouldComputeCommandAuthorized(rawBody, config);
-	const storeAllowFrom = !isGroup && dmPolicy !== "allowlist" && dmPolicy !== "open" ? await pairing.readAllowFromStore().catch(() => []) : [];
-	const [configAllowFrom, effectiveStoreAllowFrom] = await Promise.all([expandAllowFromWithAccessGroups({
-		cfg: config,
-		allowFrom: rawConfigAllowFrom,
-		channel: "googlechat",
-		accountId: account.accountId,
-		senderId,
-		isSenderAllowed: isGoogleChatSenderAllowed
-	}), expandAllowFromWithAccessGroups({
-		cfg: config,
-		allowFrom: storeAllowFrom,
-		channel: "googlechat",
-		accountId: account.accountId,
-		senderId,
-		isSenderAllowed: isGoogleChatSenderAllowed
-	})]);
-	const access = resolveDmGroupAccessWithLists({
-		isGroup,
-		dmPolicy,
-		groupPolicy: senderGroupPolicy,
-		allowFrom: configAllowFrom,
-		groupAllowFrom: normalizedGroupUsers,
-		storeAllowFrom: effectiveStoreAllowFrom,
-		groupAllowFromFallbackToAllowFrom: false,
-		isSenderAllowed: (allowFrom) => isSenderAllowed(senderId, senderEmail, allowFrom, allowNameMatching)
-	});
-	const effectiveAllowFrom = access.effectiveAllowFrom;
-	const effectiveGroupAllowFrom = access.effectiveGroupAllowFrom;
+	const effectiveAllowFrom = senderAccess.effectiveAllowFrom;
 	warnDeprecatedUsersEmailEntries(logVerbose, effectiveAllowFrom);
-	const commandAllowFrom = isGroup ? effectiveGroupAllowFrom : effectiveAllowFrom;
-	const useAccessGroups = config.commands?.useAccessGroups !== false;
-	const senderAllowedForCommands = isSenderAllowed(senderId, senderEmail, commandAllowFrom, allowNameMatching);
-	const commandAuthorized = shouldComputeAuth ? core.channel.commands.resolveCommandAuthorizedFromAuthorizers({
-		useAccessGroups,
-		authorizers: [{
-			configured: commandAllowFrom.length > 0,
-			allowed: senderAllowedForCommands
-		}]
-	}) : void 0;
-	if (isGroup) {
-		const requireMention = groupEntry?.requireMention ?? account.config.requireMention ?? true;
-		const mentionInfo = extractMentionInfo(message.annotations ?? [], account.config.botUser);
-		const allowTextCommands = core.channel.commands.shouldHandleTextCommands({
-			cfg: config,
-			surface: "googlechat"
-		});
-		const mentionDecision = resolveInboundMentionDecision({
-			facts: {
-				canDetectMention: true,
-				wasMentioned: mentionInfo.wasMentioned,
-				hasAnyMention: mentionInfo.hasAnyMention,
-				implicitMentionKinds: []
-			},
-			policy: {
-				isGroup: true,
-				requireMention,
-				allowTextCommands,
-				hasControlCommand: core.channel.text.hasControlCommand(rawBody, config),
-				commandAuthorized: commandAuthorized === true
-			}
-		});
-		effectiveWasMentioned = mentionDecision.effectiveWasMentioned;
-		if (mentionDecision.shouldSkip) {
+	if (isGroup && resolvedAccess.activationAccess.ran) {
+		effectiveWasMentioned = resolvedAccess.activationAccess.effectiveWasMentioned;
+		if (resolvedAccess.activationAccess.shouldSkip) {
 			logVerbose(`drop group message (mention required, space=${spaceId})`);
 			return { ok: false };
 		}
 	}
-	if (isGroup && access.decision !== "allow") {
-		logVerbose(`drop group message (sender policy blocked, reason=${access.reason}, space=${spaceId})`);
+	if (isGroup && senderAccess.decision !== "allow") {
+		logVerbose(`drop group message (sender policy blocked, reason=${resolvedAccess.ingress.reasonCode === "route_sender_empty" ? "groupPolicy=allowlist (empty allowlist)" : senderAccess.reasonCode}, space=${spaceId})`);
 		return { ok: false };
 	}
 	if (!isGroup) {
@@ -242,8 +242,8 @@ async function applyGoogleChatInboundAccessPolicy(params) {
 			logVerbose(`Blocked Google Chat DM from ${senderId} (dmPolicy=disabled)`);
 			return { ok: false };
 		}
-		if (access.decision !== "allow") {
-			if (access.decision === "pairing") await pairing.issueChallenge({
+		if (senderAccess.decision !== "allow") {
+			if (senderAccess.decision === "pairing") await pairing.issueChallenge({
 				senderId,
 				senderIdLine: `Your Google Chat user id: ${senderId}`,
 				meta: {
@@ -281,6 +281,19 @@ async function applyGoogleChatInboundAccessPolicy(params) {
 	};
 }
 //#endregion
+//#region extensions/googlechat/src/monitor-durable.ts
+function resolveGoogleChatDurableReplyOptions(params) {
+	if (params.infoKind !== "final" || params.typingMessageName) return false;
+	const threadId = params.payload.replyToId?.trim() || void 0;
+	return {
+		to: params.spaceId,
+		...threadId ? {
+			replyToId: threadId,
+			threadId
+		} : {}
+	};
+}
+//#endregion
 //#region extensions/googlechat/src/monitor-reply-delivery.ts
 async function deliverGoogleChatReply(params) {
 	const { payload, account, spaceId, runtime, core, config, statusSink } = params;
@@ -791,12 +804,6 @@ async function processMessageWithPipeline(params) {
 	} catch (err) {
 		runtime.error?.(`Failed sending typing message: ${String(err)}`);
 	}
-	const { onModelSelected, ...replyPipeline } = createChannelReplyPipeline({
-		cfg: config,
-		agentId: route.agentId,
-		channel: "googlechat",
-		accountId: route.accountId
-	});
 	await core.channel.turn.run({
 		channel: "googlechat",
 		accountId: route.accountId,
@@ -821,6 +828,12 @@ async function processMessageWithPipeline(params) {
 				recordInboundSession: core.channel.session.recordInboundSession,
 				dispatchReplyWithBufferedBlockDispatcher: core.channel.reply.dispatchReplyWithBufferedBlockDispatcher,
 				delivery: {
+					durable: (payload, info) => resolveGoogleChatDurableReplyOptions({
+						payload,
+						infoKind: info.kind,
+						spaceId,
+						typingMessageName
+					}),
 					deliver: async (payload) => {
 						await deliverGoogleChatReply({
 							payload,
@@ -834,12 +847,14 @@ async function processMessageWithPipeline(params) {
 						});
 						typingMessageName = void 0;
 					},
+					onDelivered: () => {
+						statusSink?.({ lastOutboundAt: Date.now() });
+					},
 					onError: (err, info) => {
 						runtime.error?.(`[${account.accountId}] Google Chat ${info.kind} reply failed: ${String(err)}`);
 					}
 				},
-				dispatcherOptions: replyPipeline,
-				replyOptions: { onModelSelected },
+				replyPipeline: {},
 				record: { onRecordError: (err) => {
 					runtime.error?.(`googlechat: failed updating session meta: ${String(err)}`);
 				} }

package/dist/contract-api.js

@@ -1,3 +1,3 @@
-import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-CG1sLToP.js";
-import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries } from "./secret-contract-DtQ_IO7J.js";
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-BsERSjSe.js";
+import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries } from "./secret-contract-DLAG2_NI.js";
 export { collectRuntimeConfigAssignments, legacyConfigRules, normalizeCompatibilityConfig, secretTargetRegistryEntries };

package/dist/doctor-contract-api.js

@@ -1,2 +1,2 @@
-import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-CG1sLToP.js";
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-BsERSjSe.js";
 export { legacyConfigRules, normalizeCompatibilityConfig };

package/dist/{runtime-api-wkIdfwqY.js → runtime-api-DMEzhesS.js}

@@ -1,21 +1,20 @@
-import { createActionGate as createActionGate$1, jsonResult as jsonResult$1, readNumberParam as readNumberParam$1, readReactionParams as readReactionParams$1, readStringParam as readStringParam$1 } from "openclaw/plugin-sdk/channel-actions";
-import { loadOutboundMediaFromUrl as loadOutboundMediaFromUrl$1 } from "openclaw/plugin-sdk/outbound-media";
 import { extractToolSend as extractToolSend$1 } from "openclaw/plugin-sdk/tool-send";
 import { fetchWithSsrFGuard as fetchWithSsrFGuard$1 } from "openclaw/plugin-sdk/ssrf-runtime";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
+import { createActionGate as createActionGate$1, jsonResult as jsonResult$1, readNumberParam as readNumberParam$1, readReactionParams as readReactionParams$1, readStringParam as readStringParam$1 } from "openclaw/plugin-sdk/channel-actions";
 import { buildChannelConfigSchema } from "openclaw/plugin-sdk/channel-config-primitives";
 import { missingTargetError } from "openclaw/plugin-sdk/channel-feedback";
 import { createAccountStatusSink as createAccountStatusSink$1, runPassiveAccountLifecycle as runPassiveAccountLifecycle$1 } from "openclaw/plugin-sdk/channel-lifecycle";
 import { createChannelPairingController } from "openclaw/plugin-sdk/channel-pairing";
-import { createChannelReplyPipeline } from "openclaw/plugin-sdk/channel-reply-pipeline";
-import { evaluateGroupRouteAccessForPolicy, resolveDmGroupAccessWithLists, resolveSenderScopedGroupPolicy } from "openclaw/plugin-sdk/channel-policy";
+import { createChannelMessageReplyPipeline } from "openclaw/plugin-sdk/channel-message";
 import { PAIRING_APPROVED_MESSAGE } from "openclaw/plugin-sdk/channel-status";
 import { chunkTextForOutbound } from "openclaw/plugin-sdk/text-chunking";
 import { GoogleChatConfigSchema } from "openclaw/plugin-sdk/bundled-channel-config-schema";
 import { GROUP_POLICY_BLOCKED_LABEL, resolveAllowlistProviderRuntimeGroupPolicy, resolveDefaultGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
 import { isDangerousNameMatchingEnabled } from "openclaw/plugin-sdk/dangerous-name-runtime";
 import { fetchRemoteMedia, resolveChannelMediaMaxBytes } from "openclaw/plugin-sdk/media-runtime";
-import { resolveInboundMentionDecision as resolveInboundMentionDecision$1 } from "openclaw/plugin-sdk/channel-inbound";
+import { loadOutboundMediaFromUrl as loadOutboundMediaFromUrl$1 } from "openclaw/plugin-sdk/outbound-media";
+import { resolveInboundMentionDecision } from "openclaw/plugin-sdk/channel-inbound";
 import { resolveInboundRouteEnvelopeBuilderWithRuntime } from "openclaw/plugin-sdk/inbound-envelope";
 import { resolveWebhookPath } from "openclaw/plugin-sdk/webhook-path";
 import { registerWebhookTargetWithPluginRoute as registerWebhookTargetWithPluginRoute$1, resolveWebhookTargetWithAuthOrReject as resolveWebhookTargetWithAuthOrReject$1, withResolvedWebhookRequestPipeline as withResolvedWebhookRequestPipeline$1 } from "openclaw/plugin-sdk/webhook-targets";
@@ -27,4 +26,4 @@ const { setRuntime: setGoogleChatRuntime, getRuntime: getGoogleChatRuntime } = c
 	errorMessage: "Google Chat runtime not initialized"
 });
 //#endregion
-export { resolveInboundRouteEnvelopeBuilderWithRuntime as A, readStringParam$1 as C, resolveDefaultGroupPolicy as D, resolveChannelMediaMaxBytes as E, warnMissingProviderGroupPolicyFallbackOnce as F, withResolvedWebhookRequestPipeline$1 as I, getGoogleChatRuntime as L, resolveWebhookPath as M, resolveWebhookTargetWithAuthOrReject$1 as N, resolveDmGroupAccessWithLists as O, runPassiveAccountLifecycle$1 as P, setGoogleChatRuntime as R, readReactionParams$1 as S, resolveAllowlistProviderRuntimeGroupPolicy as T, jsonResult$1 as _, buildChannelConfigSchema as a, readJsonWebhookBodyOrReject$1 as b, createActionGate$1 as c, createWebhookInFlightLimiter$1 as d, evaluateGroupRouteAccessForPolicy as f, isDangerousNameMatchingEnabled as g, fetchWithSsrFGuard$1 as h, PAIRING_APPROVED_MESSAGE as i, resolveSenderScopedGroupPolicy as j, resolveInboundMentionDecision$1 as k, createChannelPairingController as l, fetchRemoteMedia as m, GROUP_POLICY_BLOCKED_LABEL as n, chunkTextForOutbound as o, extractToolSend$1 as p, GoogleChatConfigSchema as r, createAccountStatusSink$1 as s, DEFAULT_ACCOUNT_ID as t, createChannelReplyPipeline as u, loadOutboundMediaFromUrl$1 as v, registerWebhookTargetWithPluginRoute$1 as w, readNumberParam$1 as x, missingTargetError as y };
+export { resolveWebhookTargetWithAuthOrReject$1 as A, registerWebhookTargetWithPluginRoute$1 as C, resolveInboundMentionDecision as D, resolveDefaultGroupPolicy as E, setGoogleChatRuntime as F, warnMissingProviderGroupPolicyFallbackOnce as M, withResolvedWebhookRequestPipeline$1 as N, resolveInboundRouteEnvelopeBuilderWithRuntime as O, getGoogleChatRuntime as P, readStringParam$1 as S, resolveChannelMediaMaxBytes as T, loadOutboundMediaFromUrl$1 as _, buildChannelConfigSchema as a, readNumberParam$1 as b, createActionGate$1 as c, createWebhookInFlightLimiter$1 as d, extractToolSend$1 as f, jsonResult$1 as g, isDangerousNameMatchingEnabled as h, PAIRING_APPROVED_MESSAGE as i, runPassiveAccountLifecycle$1 as j, resolveWebhookPath as k, createChannelMessageReplyPipeline as l, fetchWithSsrFGuard$1 as m, GROUP_POLICY_BLOCKED_LABEL as n, chunkTextForOutbound as o, fetchRemoteMedia as p, GoogleChatConfigSchema as r, createAccountStatusSink$1 as s, DEFAULT_ACCOUNT_ID as t, createChannelPairingController as u, missingTargetError as v, resolveAllowlistProviderRuntimeGroupPolicy as w, readReactionParams$1 as x, readJsonWebhookBodyOrReject$1 as y };

package/dist/runtime-api.js

@@ -1,2 +1,2 @@
-import { A as resolveInboundRouteEnvelopeBuilderWithRuntime, C as readStringParam, D as resolveDefaultGroupPolicy, E as resolveChannelMediaMaxBytes, F as warnMissingProviderGroupPolicyFallbackOnce, I as withResolvedWebhookRequestPipeline, M as resolveWebhookPath, N as resolveWebhookTargetWithAuthOrReject, O as resolveDmGroupAccessWithLists, P as runPassiveAccountLifecycle, R as setGoogleChatRuntime, S as readReactionParams, T as resolveAllowlistProviderRuntimeGroupPolicy, _ as jsonResult, a as buildChannelConfigSchema, b as readJsonWebhookBodyOrReject, c as createActionGate, d as createWebhookInFlightLimiter, f as evaluateGroupRouteAccessForPolicy, g as isDangerousNameMatchingEnabled, h as fetchWithSsrFGuard, i as PAIRING_APPROVED_MESSAGE, j as resolveSenderScopedGroupPolicy, k as resolveInboundMentionDecision, l as createChannelPairingController, m as fetchRemoteMedia, n as GROUP_POLICY_BLOCKED_LABEL, o as chunkTextForOutbound, p as extractToolSend, r as GoogleChatConfigSchema, s as createAccountStatusSink, t as DEFAULT_ACCOUNT_ID, u as createChannelReplyPipeline, v as loadOutboundMediaFromUrl, w as registerWebhookTargetWithPluginRoute, x as readNumberParam, y as missingTargetError } from "./runtime-api-wkIdfwqY.js";
-export { DEFAULT_ACCOUNT_ID, GROUP_POLICY_BLOCKED_LABEL, GoogleChatConfigSchema, PAIRING_APPROVED_MESSAGE, buildChannelConfigSchema, chunkTextForOutbound, createAccountStatusSink, createActionGate, createChannelPairingController, createChannelReplyPipeline, createWebhookInFlightLimiter, evaluateGroupRouteAccessForPolicy, extractToolSend, fetchRemoteMedia, fetchWithSsrFGuard, isDangerousNameMatchingEnabled, jsonResult, loadOutboundMediaFromUrl, missingTargetError, readJsonWebhookBodyOrReject, readNumberParam, readReactionParams, readStringParam, registerWebhookTargetWithPluginRoute, resolveAllowlistProviderRuntimeGroupPolicy, resolveChannelMediaMaxBytes, resolveDefaultGroupPolicy, resolveDmGroupAccessWithLists, resolveInboundMentionDecision, resolveInboundRouteEnvelopeBuilderWithRuntime, resolveSenderScopedGroupPolicy, resolveWebhookPath, resolveWebhookTargetWithAuthOrReject, runPassiveAccountLifecycle, setGoogleChatRuntime, warnMissingProviderGroupPolicyFallbackOnce, withResolvedWebhookRequestPipeline };
+import { A as resolveWebhookTargetWithAuthOrReject, C as registerWebhookTargetWithPluginRoute, D as resolveInboundMentionDecision, E as resolveDefaultGroupPolicy, F as setGoogleChatRuntime, M as warnMissingProviderGroupPolicyFallbackOnce, N as withResolvedWebhookRequestPipeline, O as resolveInboundRouteEnvelopeBuilderWithRuntime, S as readStringParam, T as resolveChannelMediaMaxBytes, _ as loadOutboundMediaFromUrl, a as buildChannelConfigSchema, b as readNumberParam, c as createActionGate, d as createWebhookInFlightLimiter, f as extractToolSend, g as jsonResult, h as isDangerousNameMatchingEnabled, i as PAIRING_APPROVED_MESSAGE, j as runPassiveAccountLifecycle, k as resolveWebhookPath, l as createChannelMessageReplyPipeline, m as fetchWithSsrFGuard, n as GROUP_POLICY_BLOCKED_LABEL, o as chunkTextForOutbound, p as fetchRemoteMedia, r as GoogleChatConfigSchema, s as createAccountStatusSink, t as DEFAULT_ACCOUNT_ID, u as createChannelPairingController, v as missingTargetError, w as resolveAllowlistProviderRuntimeGroupPolicy, x as readReactionParams, y as readJsonWebhookBodyOrReject } from "./runtime-api-DMEzhesS.js";
+export { DEFAULT_ACCOUNT_ID, GROUP_POLICY_BLOCKED_LABEL, GoogleChatConfigSchema, PAIRING_APPROVED_MESSAGE, buildChannelConfigSchema, chunkTextForOutbound, createAccountStatusSink, createActionGate, createChannelMessageReplyPipeline, createChannelPairingController, createWebhookInFlightLimiter, extractToolSend, fetchRemoteMedia, fetchWithSsrFGuard, isDangerousNameMatchingEnabled, jsonResult, loadOutboundMediaFromUrl, missingTargetError, readJsonWebhookBodyOrReject, readNumberParam, readReactionParams, readStringParam, registerWebhookTargetWithPluginRoute, resolveAllowlistProviderRuntimeGroupPolicy, resolveChannelMediaMaxBytes, resolveDefaultGroupPolicy, resolveInboundMentionDecision, resolveInboundRouteEnvelopeBuilderWithRuntime, resolveWebhookPath, resolveWebhookTargetWithAuthOrReject, runPassiveAccountLifecycle, setGoogleChatRuntime, warnMissingProviderGroupPolicyFallbackOnce, withResolvedWebhookRequestPipeline };

package/dist/secret-contract-api.js

@@ -1,2 +1,2 @@
-import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries, t as channelSecrets } from "./secret-contract-DtQ_IO7J.js";
+import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries, t as channelSecrets } from "./secret-contract-DLAG2_NI.js";
 export { channelSecrets, collectRuntimeConfigAssignments, secretTargetRegistryEntries };

package/dist/setup-plugin-api.js

@@ -1,4 +1,5 @@
-import { a as resolveDefaultGoogleChatAccountId, i as listGoogleChatAccountIds, n as googlechatSetupAdapter, o as resolveGoogleChatAccount, s as resolveGoogleChatConfigAccessorAccount, t as googlechatSetupWizard } from "./setup-surface-CofP-Gg9.js";
+import { a as resolveGoogleChatConfigAccessorAccount, i as resolveGoogleChatAccount, n as listGoogleChatAccountIds, r as resolveDefaultGoogleChatAccountId } from "./accounts-BbM9zX1S.js";
+import { n as googlechatSetupAdapter, t as googlechatSetupWizard } from "./setup-surface-S4ArLnR8.js";
 import { describeAccountSnapshot } from "openclaw/plugin-sdk/account-helpers";
 import { formatNormalizedAllowFromEntries } from "openclaw/plugin-sdk/allow-from";
 import { adaptScopedAccountAccessor, createScopedChannelConfigAdapter } from "openclaw/plugin-sdk/channel-config-helpers";

package/dist/{setup-surface-CofP-Gg9.js → setup-surface-S4ArLnR8.js}

@@ -1,99 +1,7 @@
-import { safeParseJsonWithSchema, safeParseWithSchema } from "openclaw/plugin-sdk/extension-shared";
-import { DEFAULT_ACCOUNT_ID, createAccountListHelpers, normalizeAccountId, resolveAccountEntry, resolveMergedAccountConfig } from "openclaw/plugin-sdk/account-resolution";
-import { isSecretRef } from "openclaw/plugin-sdk/secret-input";
+import { i as resolveGoogleChatAccount, r as resolveDefaultGoogleChatAccountId } from "./accounts-BbM9zX1S.js";
 import { normalizeOptionalString, normalizeStringifiedOptionalString } from "openclaw/plugin-sdk/text-runtime";
-import { z } from "zod";
 import { createPatchedAccountSetupAdapter, createSetupInputPresenceValidator } from "openclaw/plugin-sdk/setup-runtime";
-import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1, addWildcardAllowFrom, applySetupAccountConfigPatch, createPromptParsedAllowFromForAccount, createStandardChannelSetupStatus, formatDocsLink, mergeAllowFromEntries, migrateBaseNameToDefaultAccount, splitSetupEntries } from "openclaw/plugin-sdk/setup";
-//#region extensions/googlechat/src/accounts.ts
-const ENV_SERVICE_ACCOUNT$1 = "GOOGLE_CHAT_SERVICE_ACCOUNT";
-const ENV_SERVICE_ACCOUNT_FILE$1 = "GOOGLE_CHAT_SERVICE_ACCOUNT_FILE";
-const JsonRecordSchema = z.record(z.string(), z.unknown());
-const { listAccountIds: listGoogleChatAccountIds, resolveDefaultAccountId: resolveDefaultGoogleChatAccountId } = createAccountListHelpers("googlechat");
-function mergeGoogleChatAccountConfig(cfg, accountId) {
-	const raw = cfg.channels?.["googlechat"] ?? {};
-	const base = resolveMergedAccountConfig({
-		channelConfig: raw,
-		accounts: raw.accounts,
-		accountId,
-		omitKeys: ["defaultAccount"]
-	});
-	const defaultAccountConfig = resolveAccountEntry(raw.accounts, DEFAULT_ACCOUNT_ID) ?? {};
-	if (accountId === DEFAULT_ACCOUNT_ID) return base;
-	const { enabled: _ignoredEnabled, dangerouslyAllowNameMatching: _ignoredDangerouslyAllowNameMatching, serviceAccount: _ignoredServiceAccount, serviceAccountRef: _ignoredServiceAccountRef, serviceAccountFile: _ignoredServiceAccountFile, ...defaultAccountShared } = defaultAccountConfig;
-	return {
-		...defaultAccountShared,
-		...base
-	};
-}
-function resolveGoogleChatConfigAccessorAccount(params) {
-	const accountId = normalizeAccountId(params.accountId ?? params.cfg.channels?.googlechat?.defaultAccount);
-	return { config: mergeGoogleChatAccountConfig(params.cfg, accountId) };
-}
-function parseServiceAccount(value) {
-	if (isSecretRef(value)) return null;
-	if (typeof value === "string") {
-		const trimmed = value.trim();
-		if (!trimmed) return null;
-		return safeParseJsonWithSchema(JsonRecordSchema, trimmed);
-	}
-	return safeParseWithSchema(JsonRecordSchema, value);
-}
-function resolveCredentialsFromConfig(params) {
-	const { account, accountId } = params;
-	const inline = parseServiceAccount(account.serviceAccount);
-	if (inline) return {
-		credentials: inline,
-		source: "inline"
-	};
-	if (isSecretRef(account.serviceAccount)) throw new Error(`channels.googlechat.accounts.${accountId}.serviceAccount: unresolved SecretRef "${account.serviceAccount.source}:${account.serviceAccount.provider}:${account.serviceAccount.id}". Resolve this command against an active gateway runtime snapshot before reading it.`);
-	if (isSecretRef(account.serviceAccountRef)) throw new Error(`channels.googlechat.accounts.${accountId}.serviceAccount: unresolved SecretRef "${account.serviceAccountRef.source}:${account.serviceAccountRef.provider}:${account.serviceAccountRef.id}". Resolve this command against an active gateway runtime snapshot before reading it.`);
-	const file = normalizeOptionalString(account.serviceAccountFile);
-	if (file) return {
-		credentialsFile: file,
-		source: "file"
-	};
-	if (accountId === DEFAULT_ACCOUNT_ID) {
-		const envJson = process.env[ENV_SERVICE_ACCOUNT$1];
-		const envInline = parseServiceAccount(envJson);
-		if (envInline) return {
-			credentials: envInline,
-			source: "env"
-		};
-		const envFile = normalizeOptionalString(process.env[ENV_SERVICE_ACCOUNT_FILE$1]);
-		if (envFile) return {
-			credentialsFile: envFile,
-			source: "env"
-		};
-	}
-	return { source: "none" };
-}
-function resolveGoogleChatAccount(params) {
-	const accountId = normalizeAccountId(params.accountId ?? params.cfg.channels?.["googlechat"]?.defaultAccount);
-	const baseEnabled = params.cfg.channels?.["googlechat"]?.enabled !== false;
-	const merged = mergeGoogleChatAccountConfig(params.cfg, accountId);
-	const accountEnabled = merged.enabled !== false;
-	const enabled = baseEnabled && accountEnabled;
-	const credentials = resolveCredentialsFromConfig({
-		accountId,
-		account: merged
-	});
-	return {
-		accountId,
-		name: normalizeOptionalString(merged.name),
-		enabled,
-		config: merged,
-		credentialSource: credentials.source,
-		credentials: credentials.credentials,
-		credentialsFile: credentials.credentialsFile
-	};
-}
-function listEnabledGoogleChatAccounts(cfg) {
-	return listGoogleChatAccountIds(cfg).map((accountId) => resolveGoogleChatAccount({
-		cfg,
-		accountId
-	})).filter((account) => account.enabled);
-}
+import { DEFAULT_ACCOUNT_ID, addWildcardAllowFrom, applySetupAccountConfigPatch, createPromptParsedAllowFromForAccount, createStandardChannelSetupStatus, formatDocsLink, mergeAllowFromEntries, migrateBaseNameToDefaultAccount, splitSetupEntries } from "openclaw/plugin-sdk/setup";
 const googlechatSetupAdapter = createPatchedAccountSetupAdapter({
 	channelKey: "googlechat",
 	validateInput: createSetupInputPresenceValidator({
@@ -130,7 +38,7 @@ const googlechatDmPolicy = {
 	channel,
 	policyKey: "channels.googlechat.dm.policy",
 	allowFromKey: "channels.googlechat.dm.allowFrom",
-	resolveConfigKeys: (cfg, accountId) => (accountId ?? resolveDefaultGoogleChatAccountId(cfg)) !== DEFAULT_ACCOUNT_ID$1 ? {
+	resolveConfigKeys: (cfg, accountId) => (accountId ?? resolveDefaultGoogleChatAccountId(cfg)) !== DEFAULT_ACCOUNT_ID ? {
 		policyKey: `channels.googlechat.accounts.${accountId ?? resolveDefaultGoogleChatAccountId(cfg)}.dm.policy`,
 		allowFromKey: `channels.googlechat.accounts.${accountId ?? resolveDefaultGoogleChatAccountId(cfg)}.dm.allowFrom`
 	} : {
@@ -221,7 +129,7 @@ const googlechatSetupWizard = {
 		]
 	},
 	prepare: async ({ cfg, accountId, credentialValues, prompter }) => {
-		if (accountId === DEFAULT_ACCOUNT_ID$1 && (Boolean(process.env[ENV_SERVICE_ACCOUNT]) || Boolean(process.env[ENV_SERVICE_ACCOUNT_FILE]))) {
+		if (accountId === DEFAULT_ACCOUNT_ID && (Boolean(process.env[ENV_SERVICE_ACCOUNT]) || Boolean(process.env[ENV_SERVICE_ACCOUNT_FILE]))) {
 			if (await prompter.confirm({
 				message: "Use GOOGLE_CHAT_SERVICE_ACCOUNT env vars?",
 				initialValue: true
@@ -306,4 +214,4 @@ const googlechatSetupWizard = {
 	dmPolicy: googlechatDmPolicy
 };
 //#endregion
-export { resolveDefaultGoogleChatAccountId as a, listGoogleChatAccountIds as i, googlechatSetupAdapter as n, resolveGoogleChatAccount as o, listEnabledGoogleChatAccounts as r, resolveGoogleChatConfigAccessorAccount as s, googlechatSetupWizard as t };
+export { googlechatSetupAdapter as n, googlechatSetupWizard as t };

package/dist/targets-qggOq6n-.js

@@ -0,0 +1,43 @@
+import { a as findGoogleChatDirectMessage } from "./api-AErsImS_.js";
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/text-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
+export { resolveGoogleChatOutboundSpace as i, isGoogleChatUserTarget as n, normalizeGoogleChatTarget as r, isGoogleChatSpaceTarget as t };

package/dist/test-api.js

@@ -1,3 +1,3 @@
-import { R as setGoogleChatRuntime } from "./runtime-api-wkIdfwqY.js";
-import { t as googlechatPlugin } from "./channel-CHniJUSZ.js";
+import { F as setGoogleChatRuntime } from "./runtime-api-DMEzhesS.js";
+import { t as googlechatPlugin } from "./channel-9lvRWX6T.js";
 export { googlechatPlugin, setGoogleChatRuntime };