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

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

@@ -1,7 +1,6 @@
-import { c as resolveGoogleChatAccount, o as listEnabledGoogleChatAccounts } from "./channel-base-DpPD0ef1.js";
+import { l as resolveGoogleChatAccount, o as listEnabledGoogleChatAccounts } from "./channel-base-Qh87GFW_.js";
+import { b as uploadGoogleChatAttachment, d as resolveGoogleChatOutboundSpace, f as createGoogleChatReaction, g as listGoogleChatReactions, m as deleteGoogleChatReaction, v as sendGoogleChatMessage } from "./channel.adapters-BQoq1F4R.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 { 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-AbgtAg3y.js";
+import { a as googlechatSetupAdapter, i as googlechatSetupWizard } from "./channel-base-Qh87GFW_.js";
+import { t as googlechatPlugin } from "./channel-BY9hwCh2.js";
 export { googlechatPlugin, googlechatSetupAdapter, googlechatSetupWizard };

package/dist/approval-auth-C-vWY4bY.js

@@ -0,0 +1,27 @@
+import { l as resolveGoogleChatAccount } from "./channel-base-Qh87GFW_.js";
+import { l as isGoogleChatUserTarget, u as normalizeGoogleChatTarget } from "./channel.adapters-BQoq1F4R.js";
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { createResolvedApproverActionAuthAdapter, resolveApprovalApprovers } 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}`;
+}
+function getGoogleChatApprovalApprovers(params) {
+	const account = resolveGoogleChatAccount(params).config;
+	return resolveApprovalApprovers({
+		allowFrom: account.dm?.allowFrom,
+		defaultTo: account.defaultTo,
+		normalizeApprover: normalizeGoogleChatApproverId
+	});
+}
+const googleChatApprovalAuth = createResolvedApproverActionAuthAdapter({
+	channelLabel: "Google Chat",
+	resolveApprovers: getGoogleChatApprovalApprovers,
+	normalizeSenderId: (value) => normalizeGoogleChatApproverId(value)
+});
+//#endregion
+export { googleChatApprovalAuth as n, normalizeGoogleChatApproverId as r, getGoogleChatApprovalApprovers as t };

package/dist/approval-handler.runtime-CWeVJAQF.js

@@ -0,0 +1,272 @@
+import { l as resolveGoogleChatAccount } from "./channel-base-Qh87GFW_.js";
+import { A as registerGoogleChatManualApprovalFollowupSuppression, C as buildGoogleChatApprovalActionParameters, E as createGoogleChatApprovalToken, M as unregisterGoogleChatApprovalCardBindings, N as unregisterGoogleChatManualApprovalFollowupSuppression, S as GOOGLECHAT_APPROVAL_ACTION, d as resolveGoogleChatOutboundSpace, k as registerGoogleChatApprovalCardBinding, v as sendGoogleChatMessage, y as updateGoogleChatMessage } from "./channel.adapters-BQoq1F4R.js";
+import { n as isGoogleChatNativeApprovalClientEnabled, r as shouldHandleGoogleChatNativeApprovalRequest } from "./channel-BY9hwCh2.js";
+import { buildChannelApprovalNativeTargetKey } from "openclaw/plugin-sdk/approval-native-runtime";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { createChannelApprovalNativeRuntimeAdapter } from "openclaw/plugin-sdk/approval-handler-runtime";
+import { createSubsystemLogger } from "openclaw/plugin-sdk/runtime-env";
+//#region extensions/googlechat/src/approval-handler.runtime.ts
+const log = createSubsystemLogger("googlechat/approvals");
+const GOOGLECHAT_APPROVAL_CARD_ID = "openclaw-approval";
+const MAX_TEXT_PARAGRAPH_CHARS = 1800;
+function resolveHandlerAccount(params) {
+	const account = params.context?.account ?? resolveGoogleChatAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	if (!account.enabled || account.credentialSource === "none") return null;
+	return account;
+}
+function escapeGoogleChatText(text) {
+	return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function truncateText(text, maxChars = MAX_TEXT_PARAGRAPH_CHARS) {
+	return text.length <= maxChars ? text : `${text.slice(0, maxChars - 3)}...`;
+}
+function buildMetadataText(metadata) {
+	return metadata.map((item) => `<b>${escapeGoogleChatText(item.label)}:</b> ${escapeGoogleChatText(item.value)}`).join("<br>");
+}
+function formatDecision(decision) {
+	return decision === "allow-once" ? "Allowed once" : decision === "allow-always" ? "Allowed always" : "Denied";
+}
+function buildMainTextWidget(text) {
+	return { textParagraph: { text: escapeGoogleChatText(truncateText(text)) } };
+}
+function buildHtmlTextWidget(text) {
+	return { textParagraph: { text: truncateText(text) } };
+}
+function buildExecPendingSections(view) {
+	if (view.approvalKind !== "exec") return [];
+	return [{
+		header: "Command",
+		widgets: [buildMainTextWidget(view.commandText)]
+	}, ...view.commandPreview && view.commandPreview !== view.commandText ? [{
+		header: "Preview",
+		widgets: [buildMainTextWidget(view.commandPreview)]
+	}] : []];
+}
+function buildPluginPendingSections(view) {
+	if (view.approvalKind !== "plugin") return [];
+	return [{
+		header: "Request",
+		widgets: [buildHtmlTextWidget(`<b>${escapeGoogleChatText(view.title)}</b>${view.description ? `<br>${escapeGoogleChatText(view.description)}` : ""}`)]
+	}];
+}
+function buildMetadataSection(view) {
+	const metadata = [{
+		label: "Approval ID",
+		value: view.approvalId
+	}, ...view.metadata];
+	return metadata.length > 0 ? [{
+		header: "Details",
+		widgets: [buildHtmlTextWidget(buildMetadataText(metadata))]
+	}] : [];
+}
+function buildActionSection(params) {
+	const { actionFunction, view } = params;
+	const actionTokens = view.actions.map((action) => ({
+		token: createGoogleChatApprovalToken(),
+		decision: action.decision
+	}));
+	return {
+		actionTokens,
+		section: { widgets: [{ buttonList: { buttons: view.actions.map((action, index) => {
+			const actionToken = actionTokens[index];
+			if (!actionToken) throw new Error("Google Chat approval action token missing.");
+			return {
+				text: action.label,
+				onClick: { action: {
+					function: actionFunction,
+					parameters: buildGoogleChatApprovalActionParameters(actionToken.token),
+					loadIndicator: "SPINNER"
+				} }
+			};
+		}) } }] }
+	};
+}
+function buildPendingPayload(params) {
+	const { actionFunction, nowMs, view } = params;
+	const { section: actionSection, actionTokens } = buildActionSection({
+		actionFunction,
+		view
+	});
+	const card = {
+		cardId: GOOGLECHAT_APPROVAL_CARD_ID,
+		card: {
+			header: {
+				title: view.approvalKind === "plugin" ? "Plugin Approval Required" : "Exec Approval Required",
+				subtitle: `Expires in ${Math.max(0, Math.ceil((view.expiresAtMs - nowMs) / 1e3))}s`
+			},
+			sections: [
+				...buildExecPendingSections(view),
+				...buildPluginPendingSections(view),
+				...buildMetadataSection(view),
+				actionSection
+			]
+		}
+	};
+	return {
+		approvalId: view.approvalId,
+		approvalKind: view.approvalKind,
+		expiresAtMs: view.expiresAtMs,
+		cardsV2: [card],
+		actionTokens,
+		allowedDecisions: view.actions.map((action) => action.decision)
+	};
+}
+function resolveApprovalActionFunction(params) {
+	const account = resolveHandlerAccount(params);
+	const audience = normalizeOptionalString(account?.config.audience);
+	const appPrincipal = normalizeOptionalString(account?.config.appPrincipal);
+	return account?.config.audienceType === "app-url" && audience && appPrincipal ? audience : GOOGLECHAT_APPROVAL_ACTION;
+}
+function buildResolvedPayload(view) {
+	const resolvedBy = normalizeOptionalString(view.resolvedBy);
+	return { cardsV2: [{
+		cardId: GOOGLECHAT_APPROVAL_CARD_ID,
+		card: {
+			header: {
+				title: `${view.approvalKind === "plugin" ? "Plugin" : "Exec"} Approval: ${formatDecision(view.decision)}`,
+				subtitle: resolvedBy ? `Resolved by ${resolvedBy}` : "Resolved"
+			},
+			sections: buildMetadataSection(view)
+		}
+	}] };
+}
+function buildExpiredPayload(view) {
+	return { cardsV2: [{
+		cardId: GOOGLECHAT_APPROVAL_CARD_ID,
+		card: {
+			header: {
+				title: `${view.approvalKind === "plugin" ? "Plugin" : "Exec"} Approval Expired`,
+				subtitle: "This approval request expired before it was resolved."
+			},
+			sections: buildMetadataSection(view)
+		}
+	}] };
+}
+const googleChatApprovalNativeRuntime = createChannelApprovalNativeRuntimeAdapter({
+	eventKinds: ["exec", "plugin"],
+	availability: {
+		isConfigured: ({ cfg, accountId }) => isGoogleChatNativeApprovalClientEnabled({
+			cfg,
+			accountId
+		}),
+		shouldHandle: ({ cfg, accountId, request }) => shouldHandleGoogleChatNativeApprovalRequest({
+			cfg,
+			accountId,
+			request
+		})
+	},
+	presentation: {
+		buildPendingPayload: ({ cfg, accountId, context, nowMs, view }) => buildPendingPayload({
+			actionFunction: resolveApprovalActionFunction({
+				cfg,
+				accountId,
+				context
+			}),
+			nowMs,
+			view
+		}),
+		buildResolvedResult: ({ view }) => ({
+			kind: "update",
+			payload: buildResolvedPayload(view)
+		}),
+		buildExpiredResult: ({ view }) => ({
+			kind: "update",
+			payload: buildExpiredPayload(view)
+		})
+	},
+	transport: {
+		prepareTarget: ({ plannedTarget }) => ({
+			dedupeKey: buildChannelApprovalNativeTargetKey(plannedTarget.target),
+			target: {
+				to: plannedTarget.target.to,
+				threadName: plannedTarget.target.threadId != null ? String(plannedTarget.target.threadId) : void 0
+			}
+		}),
+		deliverPending: async ({ cfg, accountId, context, preparedTarget, pendingPayload }) => {
+			const account = resolveHandlerAccount({
+				cfg,
+				accountId,
+				context
+			});
+			if (!account) return null;
+			const spaceName = await resolveGoogleChatOutboundSpace({
+				account,
+				target: preparedTarget.to
+			});
+			registerGoogleChatManualApprovalFollowupSuppression({
+				approvalId: pendingPayload.approvalId,
+				approvalKind: pendingPayload.approvalKind,
+				allowedDecisions: pendingPayload.allowedDecisions,
+				expiresAtMs: pendingPayload.expiresAtMs
+			});
+			let sent;
+			try {
+				sent = await sendGoogleChatMessage({
+					account,
+					space: spaceName,
+					cardsV2: pendingPayload.cardsV2,
+					thread: preparedTarget.threadName
+				});
+			} catch (error) {
+				unregisterGoogleChatManualApprovalFollowupSuppression(pendingPayload.approvalId);
+				throw error;
+			}
+			if (!sent?.messageName) {
+				unregisterGoogleChatManualApprovalFollowupSuppression(pendingPayload.approvalId);
+				return null;
+			}
+			return {
+				accountId: account.accountId,
+				spaceName,
+				messageName: sent.messageName,
+				...preparedTarget.threadName ? { threadName: preparedTarget.threadName } : {},
+				actionTokens: pendingPayload.actionTokens
+			};
+		},
+		updateEntry: async ({ cfg, accountId, context, entry, payload }) => {
+			const account = resolveHandlerAccount({
+				cfg,
+				accountId,
+				context
+			});
+			if (!account) return;
+			await updateGoogleChatMessage({
+				account,
+				messageName: entry.messageName,
+				cardsV2: payload.cardsV2
+			});
+		}
+	},
+	interactions: {
+		bindPending: ({ entry, request, approvalKind, view, pendingPayload }) => {
+			const tokens = [];
+			for (const actionToken of entry.actionTokens) if (registerGoogleChatApprovalCardBinding({
+				token: actionToken.token,
+				accountId: entry.accountId,
+				approvalId: request.id,
+				approvalKind,
+				decision: actionToken.decision,
+				allowedDecisions: pendingPayload.allowedDecisions,
+				spaceName: entry.spaceName,
+				messageName: entry.messageName,
+				threadName: entry.threadName ?? null,
+				expiresAtMs: view.expiresAtMs
+			})) tokens.push(actionToken.token);
+			return tokens.length > 0 ? tokens : null;
+		},
+		unbindPending: ({ binding }) => {
+			unregisterGoogleChatApprovalCardBindings(binding);
+		},
+		cancelDelivered: ({ entry }) => {
+			unregisterGoogleChatApprovalCardBindings(entry.actionTokens.map((actionToken) => actionToken.token));
+		}
+	},
+	observe: { onDeliveryError: ({ error, request }) => {
+		log.error(`googlechat approvals: failed to send request ${request.id}: ${String(error)}`);
+	} }
+});
+//#endregion
+export { googleChatApprovalNativeRuntime };

package/dist/{channel-AbgtAg3y.js → channel-BY9hwCh2.js}

@@ -1,6 +1,7 @@
-import { c as resolveGoogleChatAccount, n as createGoogleChatPluginBase, s as listGoogleChatAccountIds, t as GOOGLECHAT_CHANNEL_ID } from "./channel-base-DpPD0ef1.js";
+import { c as resolveDefaultGoogleChatAccountId, l as resolveGoogleChatAccount, n as createGoogleChatPluginBase, s as listGoogleChatAccountIds, t as GOOGLECHAT_CHANNEL_ID } from "./channel-base-Qh87GFW_.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-BQoq1F4R.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 googleChatApprovalAuth, r as normalizeGoogleChatApproverId, t as getGoogleChatApprovalApprovers } from "./approval-auth-C-vWY4bY.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";
@@ -8,33 +9,140 @@ import { buildPassiveProbedChannelStatusSummary } from "openclaw/plugin-sdk/exte
 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 { createApproverRestrictedNativeApprovalCapability, splitChannelApprovalCapability } from "openclaw/plugin-sdk/approval-delivery-runtime";
+import { CHANNEL_APPROVAL_NATIVE_RUNTIME_CONTEXT_CAPABILITY, createLazyChannelApprovalNativeRuntimeAdapter } from "openclaw/plugin-sdk/approval-handler-adapter-runtime";
+import { createChannelApproverDmTargetResolver, createChannelNativeOriginTargetResolver, createNativeApprovalChannelRouteGates, shouldSuppressLocalNativeExecApprovalPrompt } from "openclaw/plugin-sdk/approval-native-runtime";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } 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}`;
+import { registerChannelRuntimeContext } from "openclaw/plugin-sdk/channel-runtime-context";
+//#region extensions/googlechat/src/approval-native.ts
+const DEFAULT_APPROVAL_FORWARDING_MODE = "session";
+function isGoogleChatAccountConfigured(params) {
+	const account = resolveGoogleChatAccount(params);
+	return account.enabled && account.credentialSource !== "none";
 }
-const googleChatApprovalAuth = createResolvedApproverActionAuthAdapter({
+function hasGoogleChatWebhookApprovalAuthConfig(params) {
+	const account = resolveGoogleChatAccount(params).config;
+	if (!normalizeOptionalString(account.audience)) return false;
+	if (account.audienceType === "project-number") return true;
+	return account.audienceType === "app-url";
+}
+function isGoogleChatApprovalTransportEnabled(params) {
+	return isGoogleChatAccountConfigured(params) && hasGoogleChatWebhookApprovalAuthConfig(params);
+}
+function normalizeGoogleChatForwardTarget(target) {
+	if (normalizeLowercaseStringOrEmpty(target.channel) !== "googlechat") return null;
+	const to = normalizeGoogleChatTarget(target.to);
+	return to ? {
+		to,
+		accountId: normalizeOptionalString(target.accountId),
+		threadId: target.threadId ?? null
+	} : null;
+}
+function resolveTurnSourceGoogleChatOriginTarget(request) {
+	if (normalizeLowercaseStringOrEmpty(request.request.turnSourceChannel) !== "googlechat") return null;
+	const target = normalizeGoogleChatTarget(request.request.turnSourceTo ?? "");
+	if (!target || !isGoogleChatSpaceTarget(target)) return null;
+	return {
+		to: target,
+		accountId: normalizeOptionalString(request.request.turnSourceAccountId),
+		threadId: request.request.turnSourceThreadId ?? null
+	};
+}
+const googleChatApprovalRouteGates = createNativeApprovalChannelRouteGates({
+	channel: "googlechat",
+	defaultForwardingMode: DEFAULT_APPROVAL_FORWARDING_MODE,
+	isTransportEnabled: isGoogleChatApprovalTransportEnabled,
+	listAccountIds: listGoogleChatAccountIds,
+	resolveDefaultAccountId: resolveDefaultGoogleChatAccountId,
+	normalizeForwardTarget: normalizeGoogleChatForwardTarget,
+	resolveTurnSourceTarget: resolveTurnSourceGoogleChatOriginTarget
+});
+function isGoogleChatNativeApprovalClientEnabled(params) {
+	return googleChatApprovalRouteGates.canAnyApprovalPotentiallyRouteToChannel({
+		...params,
+		nativeSessionOnly: true
+	}) && getGoogleChatApprovalApprovers(params).length > 0;
+}
+function resolveSessionGoogleChatOriginTarget(sessionTarget) {
+	const target = normalizeGoogleChatTarget(sessionTarget.to);
+	return target && isGoogleChatSpaceTarget(target) ? {
+		to: target,
+		threadId: sessionTarget.threadId ?? null
+	} : null;
+}
+function shouldHandleGoogleChatNativeApprovalRequest(params) {
+	return googleChatApprovalRouteGates.shouldHandleApprovalRequest(params) && getGoogleChatApprovalApprovers(params).length > 0 && Boolean(resolveTurnSourceGoogleChatOriginTarget(params.request));
+}
+function shouldSuppressLocalGoogleChatExecApprovalPrompt(params) {
+	return shouldSuppressLocalNativeExecApprovalPrompt({
+		...params,
+		isNativeDeliveryEnabled: isGoogleChatNativeApprovalClientEnabled
+	});
+}
+const googleChatApprovalCapability = createApproverRestrictedNativeApprovalCapability({
+	channel: "googlechat",
 	channelLabel: "Google Chat",
-	resolveApprovers: ({ cfg, accountId }) => {
-		const account = resolveGoogleChatAccount({
+	describeExecApprovalSetup: ({ accountId }) => {
+		const prefix = accountId && accountId !== "default" ? `channels.googlechat.accounts.${accountId}` : "channels.googlechat";
+		return `Approve it from the Web UI or terminal UI for now. Google Chat supports native approvals for this account when the webhook and service account are configured. Configure \`${prefix}.dm.allowFrom\` or \`${prefix}.defaultTo\` with numeric \`users/{id}\` approvers.`;
+	},
+	listAccountIds: listGoogleChatAccountIds,
+	hasApprovers: ({ cfg, accountId }) => getGoogleChatApprovalApprovers({
+		cfg,
+		accountId
+	}).length > 0,
+	isExecAuthorizedSender: ({ cfg, accountId, senderId }) => googleChatApprovalAuth.authorizeActorAction?.({
+		cfg,
+		accountId,
+		senderId,
+		action: "approve",
+		approvalKind: "exec"
+	})?.authorized ?? false,
+	isPluginAuthorizedSender: ({ cfg, accountId, senderId }) => googleChatApprovalAuth.authorizeActorAction?.({
+		cfg,
+		accountId,
+		senderId,
+		action: "approve",
+		approvalKind: "plugin"
+	})?.authorized ?? false,
+	isNativeDeliveryEnabled: isGoogleChatNativeApprovalClientEnabled,
+	resolveNativeDeliveryMode: () => "channel",
+	requireMatchingTurnSourceChannel: true,
+	resolveSuppressionAccountId: ({ target, request }) => normalizeOptionalString(target.accountId) ?? normalizeOptionalString(request.request.turnSourceAccountId),
+	resolveOriginTarget: createChannelNativeOriginTargetResolver({
+		channel: "googlechat",
+		shouldHandleRequest: shouldHandleGoogleChatNativeApprovalRequest,
+		resolveTurnSourceTarget: resolveTurnSourceGoogleChatOriginTarget,
+		resolveSessionTarget: resolveSessionGoogleChatOriginTarget
+	}),
+	resolveApproverDmTargets: createChannelApproverDmTargetResolver({
+		shouldHandleRequest: shouldHandleGoogleChatNativeApprovalRequest,
+		resolveApprovers: getGoogleChatApprovalApprovers,
+		mapApprover: (approver, params) => {
+			const to = normalizeGoogleChatApproverId(approver);
+			return to ? {
+				to,
+				accountId: normalizeOptionalString(params.accountId)
+			} : null;
+		}
+	}),
+	nativeRuntime: createLazyChannelApprovalNativeRuntimeAdapter({
+		eventKinds: ["exec", "plugin"],
+		isConfigured: ({ cfg, accountId }) => isGoogleChatNativeApprovalClientEnabled({
 			cfg,
 			accountId
-		}).config;
-		return resolveApprovalApprovers({
-			allowFrom: account.dm?.allowFrom,
-			defaultTo: account.defaultTo,
-			normalizeApprover: normalizeGoogleChatApproverId
-		});
-	},
-	normalizeSenderId: (value) => normalizeGoogleChatApproverId(value)
+		}),
+		shouldHandle: ({ cfg, accountId, request }) => shouldHandleGoogleChatNativeApprovalRequest({
+			cfg,
+			accountId,
+			request
+		}),
+		load: async () => (await import("./approval-handler.runtime-CWeVJAQF.js")).googleChatApprovalNativeRuntime
+	})
 });
+splitChannelApprovalCapability(googleChatApprovalCapability);
 //#endregion
 //#region extensions/googlechat/src/doctor.ts
 function asObjectRecord(value) {
@@ -74,7 +182,7 @@ const collectGoogleChatMutableAllowlistWarnings = createDangerousNameMatchingMut
 });
 //#endregion
 //#region extensions/googlechat/src/gateway.ts
-const loadGoogleChatChannelRuntime$1 = createLazyRuntimeNamedExport(() => import("./channel.runtime-C4eLDKR3.js"), "googleChatChannelRuntime");
+const loadGoogleChatChannelRuntime$1 = createLazyRuntimeNamedExport(() => import("./channel.runtime-CbSK_Zox.js"), "googleChatChannelRuntime");
 async function startGoogleChatGatewayAccount(ctx) {
 	const account = ctx.account;
 	const statusSink = createAccountStatusSink({
@@ -90,6 +198,17 @@ async function startGoogleChatGatewayAccount(ctx) {
 		audienceType: account.config.audienceType,
 		audience: account.config.audience
 	});
+	if (isGoogleChatNativeApprovalClientEnabled({
+		cfg: ctx.cfg,
+		accountId: account.accountId
+	})) registerChannelRuntimeContext({
+		channelRuntime: ctx.channelRuntime,
+		channelId: "googlechat",
+		accountId: account.accountId,
+		capability: CHANNEL_APPROVAL_NATIVE_RUNTIME_CONTEXT_CAPABILITY,
+		context: { account },
+		abortSignal: ctx.abortSignal
+	});
 	await runPassiveAccountLifecycle({
 		abortSignal: ctx.abortSignal,
 		start: async () => await startGoogleChatMonitor({
@@ -114,7 +233,7 @@ async function startGoogleChatGatewayAccount(ctx) {
 }
 //#endregion
 //#region extensions/googlechat/src/channel.ts
-const loadGoogleChatChannelRuntime = createLazyRuntimeNamedExport(() => import("./channel.runtime-C4eLDKR3.js"), "googleChatChannelRuntime");
+const loadGoogleChatChannelRuntime = createLazyRuntimeNamedExport(() => import("./channel.runtime-CbSK_Zox.js"), "googleChatChannelRuntime");
 const googlechatActions = {
 	describeMessageTool: ({ cfg, accountId }) => {
 		const accounts = accountId ? [resolveGoogleChatAccount({
@@ -134,7 +253,7 @@ const googlechatActions = {
 	},
 	extractToolSend: ({ args }) => extractToolSend(args, "sendMessage"),
 	handleAction: async (ctx) => {
-		const { googlechatMessageActions } = await import("./actions-DisAY2Ac.js");
+		const { googlechatMessageActions } = await import("./actions-DvYC089V.js");
 		if (!googlechatMessageActions.handleAction) throw new Error("Google Chat actions are not available.");
 		return await googlechatMessageActions.handleAction(ctx);
 	}
@@ -142,7 +261,7 @@ const googlechatActions = {
 const googlechatPlugin = createChatChannelPlugin({
 	base: {
 		...createGoogleChatPluginBase({ configSchema: buildChannelConfigSchema(GoogleChatConfigSchema) }),
-		approvalCapability: googleChatApprovalAuth,
+		approvalCapability: googleChatApprovalCapability,
 		secrets: {
 			secretTargetRegistryEntries,
 			collectRuntimeConfigAssignments
@@ -252,7 +371,18 @@ const googlechatPlugin = createChatChannelPlugin({
 	pairing: { text: googlechatPairingTextAdapter },
 	security: googlechatSecurityAdapter,
 	threading: googlechatThreadingAdapter,
-	outbound: googlechatOutboundAdapter
+	outbound: {
+		...googlechatOutboundAdapter,
+		base: {
+			...googlechatOutboundAdapter.base,
+			shouldSuppressLocalPayloadPrompt: ({ cfg, accountId, payload, hint }) => shouldSuppressLocalGoogleChatExecApprovalPrompt({
+				cfg,
+				accountId,
+				payload,
+				hint
+			})
+		}
+	}
 });
 //#endregion
-export { googlechatPlugin as t };
+export { isGoogleChatNativeApprovalClientEnabled as n, shouldHandleGoogleChatNativeApprovalRequest as r, googlechatPlugin as t };

package/dist/{channel-base-DpPD0ef1.js → channel-base-Qh87GFW_.js}

@@ -396,4 +396,4 @@ function createGoogleChatPluginBase(params = {}) {
 	};
 }
 //#endregion
-export { googlechatSetupAdapter as a, resolveGoogleChatAccount as c, googlechatSetupWizard as i, createGoogleChatPluginBase as n, listEnabledGoogleChatAccounts as o, formatGoogleChatAllowFromEntry as r, listGoogleChatAccountIds as s, GOOGLECHAT_CHANNEL_ID as t };
+export { googlechatSetupAdapter as a, resolveDefaultGoogleChatAccountId as c, googlechatSetupWizard as i, resolveGoogleChatAccount as l, createGoogleChatPluginBase as n, listEnabledGoogleChatAccounts as o, formatGoogleChatAllowFromEntry as r, listGoogleChatAccountIds as s, GOOGLECHAT_CHANNEL_ID as t };

package/dist/channel-plugin-api.js

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