@openclaw/google-meet 2026.9.5 → 2026.9.7

package/dist/.setup/{plugin-registration-CfZbUMDY.mjs → plugin-registration-aCEuCerg.mjs}

@@ -1,14 +1,14 @@
-import { i as isGoogleMeetBrowserManualActionError, n as GOOGLE_MEET_NODE_COMMAND } from "./google-meet-platform-constants-Bs5iAg3E.mjs";
-import { i as resolveGoogleMeetGatewayOperationTimeoutMs } from "./config-C-6enWkx.mjs";
-import { asNonArrayRecord as asParamRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { n as GOOGLE_MEET_NODE_COMMAND, r as GoogleMeetBrowserManualActionError } from "./google-meet-platform-constants-CnRfrYX7.mjs";
+import { i as resolveGoogleMeetGatewayOperationTimeoutMs } from "./config-BXGAMntj.mjs";
+import { asNonArrayRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 //#region extensions/google-meet/src/plugin-registration.ts
-const loadGoogleMeetPluginHelpers = createLazyRuntimeModule(() => import("./plugin-helpers-rGjL9QFK.mjs").then((n) => n.r));
-const loadGoogleMeetCliModule = createLazyRuntimeModule(() => import("./cli-MJjnaxoP.mjs"));
-const loadGoogleMeetNodeHostModule = createLazyRuntimeModule(() => import("./node-host-BOzEP_Us.mjs"));
-const loadGoogleMeetRuntimeModule = createLazyRuntimeModule(() => import("./runtime-D_C0dFI1.mjs"));
-const loadGoogleMeetNodeInvokePolicyModule = createLazyRuntimeModule(() => import("./node-invoke-policy-hwXq9MfV.mjs"));
+const loadGoogleMeetPluginHelpers = createLazyRuntimeModule(() => import("./plugin-helpers-CdQ_YNA7.mjs").then((n) => n.i));
+const loadGoogleMeetCliModule = createLazyRuntimeModule(() => import("./cli-DVDq0TFu.mjs"));
+const loadGoogleMeetNodeHostModule = createLazyRuntimeModule(() => import("./node-host-Tr7Mx3da.mjs"));
+const loadGoogleMeetRuntimeModule = createLazyRuntimeModule(() => import("./runtime-BdiF53A2.mjs"));
+const loadGoogleMeetNodeInvokePolicyModule = createLazyRuntimeModule(() => import("./node-invoke-policy-Dd3krTYV.mjs"));
 const loadGoogleMeetGatewayRuntimeModule = createLazyRuntimeModule(() => import("openclaw/plugin-sdk/gateway-runtime"));
 const loadGoogleMeetNodeInvokePolicy = async (config) => (await loadGoogleMeetNodeInvokePolicyModule()).createGoogleMeetChromeNodeInvokePolicy(config);
 function normalizeTransport(value) {
@@ -29,6 +29,7 @@ function shouldJoinCreatedMeet(raw) {
 const googleMeetToolDeps = { platform: () => process.platform };
 function googleMeetGatewayMethodForToolAction(action) {
 	switch (action) {
+		case "participation_context": return "googlemeet.participationContext";
 		case "recover_current_tab": return "googlemeet.recoverCurrentTab";
 		case "setup_status": return "googlemeet.setup";
 		case "test_speech": return "googlemeet.testSpeech";
@@ -37,6 +38,29 @@ function googleMeetGatewayMethodForToolAction(action) {
 		default: return `googlemeet.${action}`;
 	}
 }
+function readGoogleMeetParticipationParams(raw) {
+	const sessionId = normalizeOptionalString(raw.sessionId);
+	if (!sessionId) throw new Error("sessionId required");
+	const requestId = normalizeOptionalString(raw.requestId);
+	if (!requestId) throw new Error("requestId required");
+	for (const name of ["sourceId", "correctionOf"]) if (raw[name] !== void 0 && !normalizeOptionalString(raw[name])) throw new Error(`${name} must be a non-empty string`);
+	const action = asNonArrayRecord(raw.participationAction);
+	const type = normalizeOptionalString(action.type);
+	if (!type) throw new Error("participationAction.type required");
+	for (const name of ["text", "reaction"]) if (action[name] !== void 0 && typeof action[name] !== "string") throw new Error(`participationAction.${name} must be a string`);
+	return {
+		sessionId,
+		request: {
+			requestId,
+			...raw.sourceId !== void 0 ? { sourceId: normalizeOptionalString(raw.sourceId) } : {},
+			...raw.correctionOf !== void 0 ? { correctionOf: normalizeOptionalString(raw.correctionOf) } : {},
+			action: {
+				...action,
+				type
+			}
+		}
+	};
+}
 function isGoogleMeetAgentToolActionUnsupportedOnHost(params) {
 	const platform = googleMeetToolDeps.platform();
 	if (platform === "darwin" || platform === "linux") return false;
@@ -83,15 +107,34 @@ function keepTrustedToolAgentId(raw, client) {
 	} : rest;
 }
 function createGoogleMeetRuntimeAccessor(params) {
+	let transcriptsEnabled = params.api.config.transcripts?.enabled !== false;
+	let runtime;
 	let runtimePromise;
+	params.api.registerService({
+		id: "google-meet-transcripts",
+		reload: { configPrefixes: ["transcripts.enabled"] },
+		start: ({ config }) => {
+			transcriptsEnabled = config.transcripts?.enabled !== false;
+			return runtime?.reconcileTranscriptPolicy(transcriptsEnabled);
+		},
+		stop: () => {
+			transcriptsEnabled = false;
+			return runtime?.reconcileTranscriptPolicy(false);
+		}
+	});
 	return async () => {
 		if (!params.config.enabled) throw new Error("Google Meet plugin disabled in plugin config");
-		return await (runtimePromise ?? (runtimePromise = loadGoogleMeetRuntimeModule().then(({ GoogleMeetRuntime: Runtime }) => new Runtime({
-			config: params.config,
-			fullConfig: params.api.config,
-			runtime: params.api.runtime,
-			logger: params.api.logger
-		}))));
+		runtimePromise ??= loadGoogleMeetRuntimeModule().then(async ({ GoogleMeetRuntime: Runtime }) => {
+			runtime = new Runtime({
+				config: params.config,
+				fullConfig: params.api.config,
+				runtime: params.api.runtime,
+				logger: params.api.logger
+			});
+			await runtime.reconcileTranscriptPolicy(transcriptsEnabled);
+			return runtime;
+		});
+		return await runtimePromise;
 	};
 }
 function createLazyGoogleMeetNodeInvokePolicy(config, loadPolicy = loadGoogleMeetNodeInvokePolicy) {
@@ -117,7 +160,7 @@ function createLazyGoogleMeetNodeInvokePolicy(config, loadPolicy = loadGoogleMee
 	};
 }
 function formatGoogleMeetGatewayError(err) {
-	return isGoogleMeetBrowserManualActionError(err) ? err.payload : { error: formatErrorMessage(err) };
+	return err instanceof GoogleMeetBrowserManualActionError ? err.payload : { error: formatErrorMessage(err) };
 }
 function sendGoogleMeetGatewayError(respond, err, code = "UNAVAILABLE") {
 	const payload = formatGoogleMeetGatewayError(err);
@@ -128,4 +171,4 @@ function sendGoogleMeetGatewayError(respond, err, code = "UNAVAILABLE") {
 	});
 }
 //#endregion
-export { createLazyGoogleMeetNodeInvokePolicy as a, loadGoogleMeetCliModule as c, normalizeMode as d, normalizeTransport as f, shouldJoinCreatedMeet as h, createGoogleMeetRuntimeAccessor as i, loadGoogleMeetNodeHostModule as l, sendGoogleMeetGatewayError as m, assertGoogleMeetAgentToolActionSupported as n, formatGoogleMeetGatewayError as o, resolveMeetingInput as p, callGoogleMeetGatewayFromTool as r, keepTrustedToolAgentId as s, asParamRecord as t, loadGoogleMeetPluginHelpers as u };
+export { formatGoogleMeetGatewayError as a, loadGoogleMeetNodeHostModule as c, normalizeTransport as d, readGoogleMeetParticipationParams as f, shouldJoinCreatedMeet as h, createLazyGoogleMeetNodeInvokePolicy as i, loadGoogleMeetPluginHelpers as l, sendGoogleMeetGatewayError as m, callGoogleMeetGatewayFromTool as n, keepTrustedToolAgentId as o, resolveMeetingInput as p, createGoogleMeetRuntimeAccessor as r, loadGoogleMeetCliModule as s, assertGoogleMeetAgentToolActionSupported as t, normalizeMode as u };

package/dist/.setup/{runtime-D_C0dFI1.mjs → runtime-BdiF53A2.mjs}

@@ -1,28 +1,23 @@
-import { n as GOOGLE_MEET_NODE_COMMAND, t as GOOGLE_MEET_BROWSER_NODE_ADAPTER } from "./google-meet-platform-constants-Bs5iAg3E.mjs";
+import { n as GOOGLE_MEET_NODE_COMMAND, t as GOOGLE_MEET_BROWSER_NODE_ADAPTER } from "./google-meet-platform-constants-CnRfrYX7.mjs";
 import { t as normalizeMeetUrl } from "./meet-url-BP2Jlvjs.mjs";
-import { c as callBrowserProxyOnNode, l as resolveChromeNode, u as resolveChromeNodeInfo } from "./chrome-create-BZRBHJp9.mjs";
-import { n as normalizeDialInNumber, t as GOOGLE_MEET_PLATFORM_ADAPTER } from "./google-meet-platform-adapter-DQZ74Kd5.mjs";
+import { c as callBrowserProxyOnNode, l as resolveChromeNode, u as resolveChromeNodeInfo } from "./chrome-create-wuAK5Pnq.mjs";
+import { n as normalizeDialInNumber, t as GOOGLE_MEET_PLATFORM_ADAPTER } from "./google-meet-platform-adapter-gosgbMIM.mjs";
 import { asOptionalRecord, asRecord, normalizeOptionalString, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
-import { GatewayClient, startGatewayClientWhenEventLoopReady } from "openclaw/plugin-sdk/gateway-runtime";
 import path from "node:path";
 import { isBlockedHostnameOrIp } from "openclaw/plugin-sdk/ssrf-runtime";
-import { MeetingPlatformAdapter, MeetingSessionRuntime, addMeetingSetupCheck, createMeetingSession, createMeetingSetupStatus, createMeetingVoiceCallGateway, endMeetingVoiceCallGatewayCall, getMeetingVoiceCallGatewayCall, isMeetingVoiceCallMissingError, joinMeetingViaVoiceCallGateway, leaveMeetingWithBrowser, readMeetingTranscriptWithBrowser, recoverMeetingBrowserTab, resolveLocalMeetingBrowserRequest, speakMeetingViaVoiceCallGateway } from "openclaw/plugin-sdk/meeting-runtime";
+import { GatewayClient, startGatewayClientWhenEventLoopReady } from "openclaw/plugin-sdk/gateway-runtime";
+import { MeetingPlatformAdapter, MeetingSessionRuntime, addMeetingSetupCheck, createMeetingSession, createMeetingSetupStatus, createMeetingVoiceCallGateway, endMeetingVoiceCallGatewayCall, getMeetingVoiceCallGatewayCall, isMeetingVoiceCallMissingError, joinMeetingViaVoiceCallGateway, leaveMeetingWithBrowser, readMeetingTranscriptWithBrowser, recoverMeetingBrowserTab, resolveLocalMeetingBrowserRequest, runMeetingParticipationWithBrowser, speakMeetingViaVoiceCallGateway } from "openclaw/plugin-sdk/meeting-runtime";
 import { resolveDefaultAgentId } from "openclaw/plugin-sdk/agent-runtime";
 import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
 import fs from "node:fs";
 import os from "node:os";
 import { resolveTranscriptsConfig } from "openclaw/plugin-sdk/transcripts";
 //#region extensions/google-meet/src/runtime-probes.ts
-function resolveProbeTimeoutMs(input, fallback) {
-	if (input === void 0) return Math.min(Math.max(fallback, 1), 12e4);
-	if (!Number.isFinite(input) || input <= 0) throw new Error("timeoutMs must be a positive number");
-	return Math.min(Math.trunc(input), 12e4);
-}
 const probes = MeetingPlatformAdapter.createRuntimeProbes({
 	defaultSpeechMessage: "Say exactly: Google Meet speech test complete.",
 	invalidRequest: (message) => new Error(message),
-	resolveTimeoutMs: resolveProbeTimeoutMs,
+	resolveTimeoutMs: MeetingPlatformAdapter.resolveProbeTimeoutMs,
 	shouldWaitForListening: (session) => Boolean((session.transport === "chrome" || session.transport === "chrome-node") && session.chrome?.launched),
 	talkBackMode: MeetingPlatformAdapter.isTalkBackMode,
 	normalizeUrl: normalizeMeetUrl,
@@ -200,9 +195,6 @@ function getGoogleMeetSetupStatus(config, options) {
 	}
 	return createMeetingSetupStatus(checks);
 }
-function addGoogleMeetSetupCheck(status, check) {
-	return addMeetingSetupCheck(status, check);
-}
 //#endregion
 //#region extensions/google-meet/src/transports/chrome.ts
 const chromeTransport = MeetingPlatformAdapter.createChromeTransportWithExternalAudio({
@@ -218,13 +210,7 @@ const chromeTransport = MeetingPlatformAdapter.createChromeTransportWithExternal
 });
 const assertGoogleMeetAudioAvailable = chromeTransport.assertAudioDeviceAvailable;
 const launchChromeMeetOnNode = chromeTransport.launchOnNode;
-async function launchChromeMeet(params) {
-	const result = await chromeTransport.launchInChrome(params);
-	return {
-		...result,
-		audioBridge: result.audioBridge
-	};
-}
+const launchChromeMeet = chromeTransport.launchInChrome;
 function shouldCaptureCaptions(mode, fullConfig) {
 	return mode === "transcribe" || !fullConfig || resolveTranscriptsConfig(fullConfig.transcripts).enabled;
 }
@@ -329,7 +315,7 @@ async function getGoogleMeetRuntimeSetupStatus(params) {
 			requestedNode: params.config.chromeNode.node
 		});
 		const label = node.displayName ?? node.remoteIp ?? node.nodeId ?? "connected node";
-		status = addGoogleMeetSetupCheck(status, {
+		status = addMeetingSetupCheck(status, {
 			id: "chrome-node-connected",
 			ok: true,
 			message: `Connected Google Meet node ready: ${label}`
@@ -348,14 +334,14 @@ async function getGoogleMeetRuntimeSetupStatus(params) {
 				},
 				timeoutMs: 12e3
 			});
-			status = addGoogleMeetSetupCheck(status, {
+			status = addMeetingSetupCheck(status, {
 				id: "chrome-node-audio-prerequisites",
 				ok: true,
 				message: setup ? "Remote virtual audio backend and command-pair prerequisites are ready" : "Remote audio setup completed"
 			});
 		}
 	} catch (error) {
-		status = addGoogleMeetSetupCheck(status, {
+		status = addMeetingSetupCheck(status, {
 			id: "chrome-node-connected",
 			ok: false,
 			message: formatErrorMessage(error)
@@ -368,13 +354,13 @@ async function getGoogleMeetRuntimeSetupStatus(params) {
 			config: params.config,
 			timeoutMs: Math.min(params.config.chrome.joinTimeoutMs, 1e4)
 		});
-		status = addGoogleMeetSetupCheck(status, {
+		status = addMeetingSetupCheck(status, {
 			id: "chrome-local-audio-device",
 			ok: true,
 			message: "Virtual meeting audio backend is ready"
 		});
 	} catch (error) {
-		status = addGoogleMeetSetupCheck(status, {
+		status = addMeetingSetupCheck(status, {
 			id: "chrome-local-audio-device",
 			ok: false,
 			message: formatErrorMessage(error)
@@ -387,13 +373,51 @@ async function getGoogleMeetRuntimeSetupStatus(params) {
 	} catch {
 		missingCommands.push(command);
 	}
-	return addGoogleMeetSetupCheck(status, {
+	return addMeetingSetupCheck(status, {
 		id: "chrome-local-audio-commands",
 		ok: commands.length > 0 && missingCommands.length === 0,
 		message: commands.length === 0 ? "Chrome talk-back audio commands are not configured" : missingCommands.length === 0 ? `Chrome audio command${commands.length === 1 ? "" : "s"} available: ${commands.join(", ")}` : `Chrome audio command${missingCommands.length === 1 ? "" : "s"} missing: ${missingCommands.join(", ")}`
 	});
 }
 //#endregion
+//#region extensions/google-meet/src/transports/chrome-participation.ts
+async function participateInChromeMeet(params) {
+	const adapter = GOOGLE_MEET_PLATFORM_ADAPTER.browser.participation;
+	const { session } = params;
+	const tab = session.chrome?.browserTab;
+	if (!adapter || !tab || session.transport !== "chrome" && session.transport !== "chrome-node") return {
+		status: "unsupported",
+		message: "Participation requires a supported tracked browser meeting."
+	};
+	const { nodeId } = session.chrome ?? {};
+	const meetingSessionId = session.id;
+	const meetingUrl = session.url;
+	const targetId = tab.targetId;
+	if (session.transport === "chrome-node" && nodeId === void 0) return {
+		status: "rejected",
+		message: "The meeting has no pinned browser node."
+	};
+	params.assertCurrent();
+	const callBrowser = session.transport === "chrome-node" ? (request) => callBrowserProxyOnNode({
+		...request,
+		runtime: params.runtime,
+		nodeId
+	}) : await resolveLocalMeetingBrowserRequest(params.runtime);
+	params.assertCurrent();
+	return await runMeetingParticipationWithBrowser({
+		adapter,
+		callBrowser,
+		meetingSessionId,
+		meetingUrl,
+		targetId,
+		requestId: params.request.requestId,
+		action: params.request.action,
+		assertCurrent: () => params.assertCurrent(),
+		isSameMeetingUrl: (left, right) => GOOGLE_MEET_PLATFORM_ADAPTER.urls.isSameMeeting(left, right),
+		timeoutMs: Math.min(1e4, params.config.chrome.joinTimeoutMs)
+	});
+}
+//#endregion
 //#region extensions/google-meet/src/voice-call-gateway.ts
 const GOOGLE_MEET_VOICE_CALL_SURFACE = {
 	clientDisplayName: "Google Meet plugin",
@@ -458,7 +482,6 @@ function createVoiceCallGateway(params) {
 		connectClient: createConnectedGatewayClient
 	});
 }
-const isVoiceCallMissingError = isMeetingVoiceCallMissingError;
 async function joinMeetViaVoiceCallGateway(params) {
 	return await joinMeetingViaVoiceCallGateway({
 		...params,
@@ -466,15 +489,6 @@ async function joinMeetViaVoiceCallGateway(params) {
 		surface: GOOGLE_MEET_VOICE_CALL_SURFACE
 	});
 }
-async function endMeetVoiceCallGatewayCall(params) {
-	await endMeetingVoiceCallGatewayCall(params);
-}
-async function getMeetVoiceCallGatewayCall(params) {
-	return await getMeetingVoiceCallGatewayCall(params);
-}
-async function speakMeetViaVoiceCallGateway(params) {
-	await speakMeetingViaVoiceCallGateway(params);
-}
 //#endregion
 //#region extensions/google-meet/src/runtime.ts
 const nowIso = () => (/* @__PURE__ */ new Date()).toISOString();
@@ -482,13 +496,40 @@ var GoogleMeetRuntime = class {
 	#createdBrowserTabs;
 	#voiceCallGateway;
 	#sessions;
+	reconcileTranscriptPolicy(enabled) {
+		return this.#sessions.reconcileTranscriptPolicy(enabled);
+	}
 	constructor(params) {
 		this.params = params;
 		this.#createdBrowserTabs = /* @__PURE__ */ new Map();
 		this.transcriptSourceRuntime = () => this.#sessions;
 		const adapter = GOOGLE_MEET_PLATFORM_ADAPTER;
 		this.#voiceCallGateway = createVoiceCallGateway(params);
+		let participationStore;
+		const getParticipationStore = () => participationStore ??= params.runtime.state.openKeyedStore({
+			namespace: "meeting-participation",
+			maxEntries: 1e4,
+			overflowPolicy: "reject-new"
+		});
 		this.#sessions = new MeetingSessionRuntime({
+			participation: {
+				store: {
+					entries: async () => await getParticipationStore().entries(),
+					delete: async (key) => await getParticipationStore().delete(key),
+					lookup: async (key) => await getParticipationStore().lookup(key),
+					registerIfAbsent: async (key, attempt) => await getParticipationStore().registerIfAbsent(key, attempt),
+					register: async (key, attempt) => await getParticipationStore().register(key, attempt)
+				},
+				capabilities: (session) => isBrowserTransport(session.transport) && session.chrome?.launched && session.chrome.browserTab && session.chrome.health?.inCall === true && !session.chrome.health.manualAction ? adapter.browser.participation?.capabilities ?? [] : [],
+				validateAction: (action) => adapter.browser.participation?.validateAction(action),
+				execute: async (session, request, assertCurrent) => await participateInChromeMeet({
+					runtime: params.runtime,
+					config: params.config,
+					session,
+					request,
+					assertCurrent
+				})
+			},
 			logger: params.logger,
 			logScope: "[google-meet]",
 			formatError: formatErrorMessage,
@@ -561,6 +602,7 @@ var GoogleMeetRuntime = class {
 			speakViaTransport: async (session, instructions) => await this.#speakViaTransport(session, instructions),
 			durableTranscripts: {
 				config: params.fullConfig.transcripts,
+				openclawConfig: params.fullConfig,
 				providerId: "google-meet",
 				providerName: "Google Meet"
 			}
@@ -572,6 +614,12 @@ var GoogleMeetRuntime = class {
 	async status(sessionId) {
 		return await this.#sessions.status(sessionId);
 	}
+	participationContext(sessionId) {
+		return this.#sessions.participationContext(sessionId);
+	}
+	participate(sessionId, request) {
+		return this.#sessions.participate(sessionId, request);
+	}
 	async transcript(sessionId, options = {}) {
 		return await this.#sessions.transcript(sessionId, options);
 	}
@@ -709,7 +757,7 @@ var GoogleMeetRuntime = class {
 			introSent: voiceCallResult?.introSent
 		};
 		if (voiceCallResult?.callId) context.attachRuntimeHandles(session, { stop: async () => {
-			await endMeetVoiceCallGatewayCall({
+			await endMeetingVoiceCallGatewayCall({
 				gateway: this.#voiceCallGateway,
 				callId: voiceCallResult.callId
 			});
@@ -801,7 +849,7 @@ var GoogleMeetRuntime = class {
 			return;
 		}
 		try {
-			const status = await getMeetVoiceCallGatewayCall({
+			const status = await getMeetingVoiceCallGatewayCall({
 				gateway: this.#voiceCallGateway,
 				callId
 			});
@@ -815,13 +863,13 @@ var GoogleMeetRuntime = class {
 	async #speakViaTransport(session, instructions) {
 		if (session.transport !== "twilio" || !session.twilio?.voiceCallId) return;
 		try {
-			await speakMeetViaVoiceCallGateway({
+			await speakMeetingViaVoiceCallGateway({
 				gateway: this.#voiceCallGateway,
 				callId: session.twilio.voiceCallId,
 				message: instructions || this.params.config.voiceCall.introMessage || this.params.config.realtime.introMessage || ""
 			});
 		} catch (error) {
-			if (!isVoiceCallMissingError(error)) throw error;
+			if (!isMeetingVoiceCallMissingError(error)) throw error;
 			this.#sessions.markSessionEnded(session, "Voice Call is no longer active.");
 			return {
 				handled: true,

package/dist/doctor-contract-api.js

@@ -1,12 +1,9 @@
 import { asNullableRecord, normalizeOptionalLowercaseString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/google-meet/src/config-compat.ts
-function hasOwn(record, key) {
-	return Object.hasOwn(record, key);
-}
 function hasLegacyGoogleRealtimeProvider(value) {
 	const realtime = asNullableRecord(value);
 	if (!realtime || normalizeOptionalLowercaseString(realtime.provider) !== "google") return false;
-	return !hasOwn(realtime, "voiceProvider") || !hasOwn(realtime, "transcriptionProvider");
+	return !Object.hasOwn(realtime, "voiceProvider") || !Object.hasOwn(realtime, "transcriptionProvider");
 }
 const legacyConfigRules = [{
 	path: [
@@ -36,8 +33,8 @@ function migrateGoogleMeetLegacyRealtimeProvider(config) {
 	const nextRealtime = asNullableRecord(nextPluginConfig.realtime) ?? {};
 	nextPluginConfig.realtime = nextRealtime;
 	nextRealtime.provider = "openai";
-	if (!hasOwn(nextRealtime, "transcriptionProvider")) nextRealtime.transcriptionProvider = "openai";
-	if (!hasOwn(nextRealtime, "voiceProvider")) nextRealtime.voiceProvider = "google";
+	if (!Object.hasOwn(nextRealtime, "transcriptionProvider")) nextRealtime.transcriptionProvider = "openai";
+	if (!Object.hasOwn(nextRealtime, "voiceProvider")) nextRealtime.voiceProvider = "google";
 	return {
 		config: nextConfig,
 		changes: ["Moved Google Meet legacy realtime.provider=\"google\" intent to realtime.voiceProvider=\"google\" and realtime.transcriptionProvider=\"openai\"."]

package/dist/index.js

@@ -1,9 +1,9 @@
 import { t as GOOGLE_MEET_CLI_DESCRIPTOR } from "./.setup/cli-output-mode-BwH_6tH8.mjs";
-import { n as GOOGLE_MEET_NODE_COMMAND } from "./.setup/google-meet-platform-constants-Bs5iAg3E.mjs";
-import { r as resolveGoogleMeetConfig } from "./.setup/config-C-6enWkx.mjs";
-import { a as createLazyGoogleMeetNodeInvokePolicy, c as loadGoogleMeetCliModule, d as normalizeMode, f as normalizeTransport, h as shouldJoinCreatedMeet, i as createGoogleMeetRuntimeAccessor, l as loadGoogleMeetNodeHostModule, m as sendGoogleMeetGatewayError, n as assertGoogleMeetAgentToolActionSupported, o as formatGoogleMeetGatewayError, p as resolveMeetingInput, r as callGoogleMeetGatewayFromTool, s as keepTrustedToolAgentId, t as asParamRecord, u as loadGoogleMeetPluginHelpers } from "./.setup/plugin-registration-CfZbUMDY.mjs";
+import { n as GOOGLE_MEET_NODE_COMMAND } from "./.setup/google-meet-platform-constants-CnRfrYX7.mjs";
+import { r as resolveGoogleMeetConfig } from "./.setup/config-BXGAMntj.mjs";
+import { a as formatGoogleMeetGatewayError, c as loadGoogleMeetNodeHostModule, d as normalizeTransport, f as readGoogleMeetParticipationParams, h as shouldJoinCreatedMeet, i as createLazyGoogleMeetNodeInvokePolicy, l as loadGoogleMeetPluginHelpers, m as sendGoogleMeetGatewayError, n as callGoogleMeetGatewayFromTool, o as keepTrustedToolAgentId, p as resolveMeetingInput, r as createGoogleMeetRuntimeAccessor, s as loadGoogleMeetCliModule, t as assertGoogleMeetAgentToolActionSupported, u as normalizeMode } from "./.setup/plugin-registration-aCEuCerg.mjs";
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
-import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { asNonArrayRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { jsonResult } from "openclaw/plugin-sdk/tool-results";
 import { optionalPositiveIntegerSchema } from "openclaw/plugin-sdk/channel-actions";
 import { Type } from "typebox";
@@ -18,6 +18,8 @@ const GoogleMeetToolSchema = Type.Object({
 			"create",
 			"status",
 			"transcript",
+			"participation_context",
+			"participate",
 			"setup_status",
 			"resolve_space",
 			"preflight",
@@ -69,6 +71,14 @@ const GoogleMeetToolSchema = Type.Object({
 	pin: Type.Optional(Type.String({ description: "Meet phone PIN for Twilio; # is appended if omitted" })),
 	dtmfSequence: Type.Optional(Type.String({ description: "Explicit DTMF sequence for Twilio" })),
 	sessionId: Type.Optional(Type.String({ description: "Meet session ID" })),
+	requestId: Type.Optional(Type.String({ description: "For participate, a unique request ID. Reuse the same ID only to retry the same action." })),
+	sourceId: Type.Optional(Type.String({ description: "For participate, the current source ID from participation_context." })),
+	correctionOf: Type.Optional(Type.String({ description: "For participate, the rejected request ID whose correction is being submitted." })),
+	participationAction: Type.Optional(Type.Object({
+		type: Type.String({ description: "Action type advertised by participation_context capabilities." }),
+		text: Type.Optional(Type.String({ description: "Text for a supported participation action." })),
+		reaction: Type.Optional(Type.String({ description: "Native reaction advertised by the current capability." }))
+	})),
 	sinceIndex: Type.Optional(Type.Integer({
 		description: "For transcript, resume from the previous response's nextIndex.",
 		minimum: 0
@@ -119,7 +129,7 @@ var google_meet_default = definePluginEntry({
 			});
 		};
 		const resolveTrustedJoinParams = ({ params, client }) => {
-			const trustedParams = keepTrustedToolAgentId(asParamRecord(params), client);
+			const trustedParams = keepTrustedToolAgentId(asNonArrayRecord(params), client);
 			return {
 				url: resolveMeetingInput(config, trustedParams.url),
 				transport: normalizeTransport(trustedParams.transport),
@@ -183,7 +193,7 @@ var google_meet_default = definePluginEntry({
 			options.respond(true, await runtime.join(resolveTrustedJoinParams(options)));
 		});
 		registerGatewayMethod("googlemeet.create", async ({ params, client, respond }) => {
-			const raw = keepTrustedToolAgentId(asParamRecord(params), client);
+			const raw = keepTrustedToolAgentId(asNonArrayRecord(params), client);
 			const helpers = await loadGoogleMeetPluginHelpers();
 			respond(true, shouldJoinCreatedMeet(raw) ? await helpers.createAndJoinMeetFromParams({
 				config,
@@ -212,6 +222,24 @@ var google_meet_default = definePluginEntry({
 			}
 			respond(true, await (await ensureRuntime()).transcript(sessionId, sinceIndex === void 0 ? {} : { sinceIndex }));
 		});
+		registerGatewayMethod("googlemeet.participationContext", async ({ params, respond }) => {
+			const sessionId = normalizeOptionalString(params?.sessionId);
+			if (!sessionId) {
+				sendGoogleMeetGatewayError(respond, /* @__PURE__ */ new Error("sessionId required"), "INVALID_REQUEST");
+				return;
+			}
+			respond(true, (await ensureRuntime()).participationContext(sessionId));
+		});
+		registerGatewayMethod("googlemeet.participate", async ({ params, respond }) => {
+			let parsed;
+			try {
+				parsed = readGoogleMeetParticipationParams(asNonArrayRecord(params));
+			} catch (err) {
+				sendGoogleMeetGatewayError(respond, err, "INVALID_REQUEST");
+				return;
+			}
+			respond(true, await (await ensureRuntime()).participate(parsed.sessionId, parsed.request));
+		});
 		registerGatewayMethod("googlemeet.recoverCurrentTab", async ({ params, respond }) => {
 			respond(true, await (await ensureRuntime()).recoverCurrentTab({
 				url: normalizeOptionalString(params?.url),
@@ -231,10 +259,10 @@ var google_meet_default = definePluginEntry({
 			["googlemeet.artifacts", "artifacts"],
 			["googlemeet.attendance", "attendance"]
 		]) registerGatewayMethod(method, async ({ params, respond }) => {
-			respond(true, await queryActions[action](asParamRecord(params)));
+			respond(true, await queryActions[action](asNonArrayRecord(params)));
 		});
 		registerGatewayMethod("googlemeet.export", async ({ params, respond }) => {
-			respond(true, await (await loadGoogleMeetPluginHelpers()).exportGoogleMeetBundleFromParams(config, asParamRecord(params)));
+			respond(true, await (await loadGoogleMeetPluginHelpers()).exportGoogleMeetBundleFromParams(config, asNonArrayRecord(params)));
 		});
 		registerGatewayMethod("googlemeet.leave", async ({ params, respond }) => {
 			const sessionId = normalizeOptionalString(params?.sessionId);
@@ -245,7 +273,7 @@ var google_meet_default = definePluginEntry({
 			respond(true, await (await ensureRuntime()).leave(sessionId));
 		});
 		registerGatewayMethod("googlemeet.endActiveConference", async ({ params, respond }) => {
-			const raw = asParamRecord(params);
+			const raw = asNonArrayRecord(params);
 			const helpers = await loadGoogleMeetPluginHelpers();
 			const token = await helpers.resolveGoogleMeetTokenFromParams(config, raw);
 			respond(true, await helpers.endGoogleMeetActiveConference({
@@ -266,7 +294,7 @@ var google_meet_default = definePluginEntry({
 			options.respond(true, await runtime.testSpeech(resolveTrustedJoinParams(options)));
 		});
 		registerGatewayMethod("googlemeet.testListen", async ({ params, client, respond }) => {
-			const trustedParams = keepTrustedToolAgentId(asParamRecord(params), client);
+			const trustedParams = keepTrustedToolAgentId(asNonArrayRecord(params), client);
 			const runtime = await ensureRuntime();
 			const { readPositiveIntegerParam } = await import("openclaw/plugin-sdk/param-readers");
 			respond(true, await runtime.testListen({
@@ -280,10 +308,10 @@ var google_meet_default = definePluginEntry({
 		api.registerTool((toolContext) => ({
 			name: "google_meet",
 			label: "Google Meet",
-			description: "Join and track Google Meet sessions through Chrome or Twilio. Call setup_status before join/create/test_listen/test_speech; if it reports a Chrome node offline, local audio missing, or missing Twilio dial plan, surface that blocker instead of retrying or switching transports. Twilio cannot dial a Meet URL directly: provide dialInNumber plus optional pin/dtmfSequence, or configure twilio.defaultDialInNumber. Offline nodes are diagnostics only, not usable candidates. Local Chrome talk-back needs macOS with BlackHole 2ch or Linux with PipeWire-Pulse; otherwise use mode=transcribe, transport=twilio, or a supported chrome-node. If a Meet tab is already open after a timeout, call recover_current_tab before retrying join to report login, permission, or admission blockers without opening another tab.",
+			description: "Join and track Google Meet sessions through Chrome or Twilio. Call setup_status before join/create/test_listen/test_speech; if it reports a Chrome node offline, local audio missing, or missing Twilio dial plan, surface that blocker instead of retrying or switching transports. Twilio cannot dial a Meet URL directly: provide dialInNumber plus optional pin/dtmfSequence, or configure twilio.defaultDialInNumber. Offline nodes are diagnostics only, not usable candidates. Local Chrome talk-back needs macOS with BlackHole 2ch or Linux with PipeWire-Pulse; otherwise use mode=transcribe, transport=twilio, or a supported chrome-node. If a Meet tab is already open after a timeout, call recover_current_tab before retrying join to report login, permission, or admission blockers without opening another tab. For meeting participation, call participation_context for current source identities and supported capabilities, then participate with a unique requestId and participationAction. An empty capability list means native participation is unavailable. Reuse a requestId only for an identical retry; use correctionOf only when a rejected result permits one correction.",
 			parameters: GoogleMeetToolSchema,
 			async execute(_toolCallId, params) {
-				const raw = asParamRecord(params);
+				const raw = asNonArrayRecord(params);
 				const requesterSessionKey = normalizeOptionalString(toolContext.sessionKey);
 				try {
 					const { normalizeAgentId, parseAgentSessionKey } = await import("openclaw/plugin-sdk/routing");
@@ -342,6 +370,14 @@ var google_meet_default = definePluginEntry({
 							const helpers = await loadGoogleMeetPluginHelpers();
 							return jsonResult(await helpers.exportGoogleMeetBundleFromParams(config, raw));
 						}
+						case "participate":
+							readGoogleMeetParticipationParams(raw);
+							return jsonResult(await callGoogleMeetGatewayFromTool({
+								config,
+								action: raw.action,
+								raw
+							}));
+						case "participation_context":
 						case "leave":
 						case "speak":
 							if (!normalizeOptionalString(raw.sessionId)) throw new Error("sessionId required");
@@ -357,11 +393,16 @@ var google_meet_default = definePluginEntry({
 				}
 			}
 		}), { name: "google_meet" });
+		let nodeHost;
 		api.registerNodeHostCommand({
 			command: GOOGLE_MEET_NODE_COMMAND,
 			cap: "google-meet",
 			dangerous: true,
-			handle: async (paramsJSON) => await (await loadGoogleMeetNodeHostModule()).handleGoogleMeetNodeHostCommand(paramsJSON)
+			hasActiveWork: () => nodeHost?.handleGoogleMeetNodeHostCommand.hasActiveWork() ?? false,
+			handle: async (paramsJSON) => {
+				nodeHost ??= await loadGoogleMeetNodeHostModule();
+				return await nodeHost.handleGoogleMeetNodeHostCommand(paramsJSON);
+			}
 		});
 		api.registerNodeInvokePolicy(createLazyGoogleMeetNodeInvokePolicy(config));
 		api.registerCli(async ({ program }) => {

package/node_modules/typebox/build/compile/code.mjs

@@ -16,9 +16,8 @@ function Separator() {
 function ImportSection(build) {
     const context = build.UseUnevaluated() ? [`import { CheckContext } from "typebox/schema"`] : [];
     const hashing = `import { Hashing } from "typebox/system"`;
-    const format = `import { Format } from "typebox/format"`;
     const guard = `import { Guard } from "typebox/guard"`;
-    return [...context, hashing, format, guard];
+    return [...context, hashing, guard];
 }
 // ------------------------------------------------------------------
 // ExternalSection

package/node_modules/typebox/build/compile/validator.mjs

@@ -1,4 +1,5 @@
 // deno-fmt-ignore-file
+import { EnableParseErrors, DisableParseErrors } from '../system/settings/internal.mjs';
 import { Settings } from '../system/settings/index.mjs';
 import { Errors, Clean, Convert, Create, Default, Decode, Encode, HasCodec, Parser, ParseError } from '../value/index.mjs';
 import { Build } from '../schema/index.mjs';
@@ -51,7 +52,10 @@ export class Validator {
             return value;
         if (Settings.Get().correctiveParse)
             return Parser(this.Context(), this.Type(), value);
-        throw new ParseError(value, this.Errors(value));
+        EnableParseErrors();
+        const errors = this.Errors(value);
+        DisableParseErrors();
+        throw new ParseError(value, errors);
     }
     /** Returns an array of validation errors for the given value. */
     Errors(value) {

package/node_modules/typebox/build/format/iri.mjs

@@ -1,9 +1,10 @@
 // deno-lint-ignore-file no-control-regex
-const IpvFutureMatchMaxLength = 2048;
-const IpvFutureMatch = /\[[vV][0-9a-fA-F]+\.[^\]]+\]/; // Guarded By IpvFutureMatchMaxLength
-const InvalidIriChars = /[\x00-\x20<>\^`{|}\\]/;
-const InvalidPercentEncoding = /%(?![0-9a-fA-F]{2})/;
 // ------------------------------------------------------------------
+//
+// Removed by the following PR
+//
+// https://github.com/json-schema-org/JSON-Schema-Test-Suite/pull/1176
+//
 // NarrowIpvFuture
 //
 // Substitutes an IPvFuture address with a standard IPv6 loopback
@@ -13,12 +14,18 @@ const InvalidPercentEncoding = /%(?![0-9a-fA-F]{2})/;
 // be expensive on large strings, this operation is strictly
 // limited to inputs under a defined length threshold.
 //
-// (review-optimization)
+// ------------------------------------------------------------------
+//
+// const IpvFutureMatchMaxLength = 2048
+// const IpvFutureMatch = /\[[vV][0-9a-fA-F]+\.[^\]]+\]/ // Guarded By IpvFutureMatchMaxLength
+//
+// function NarrowIpvFuture(value: string): string {
+//   return value.length < IpvFutureMatchMaxLength ? value.replace(IpvFutureMatch, '[::1]') : value
+// }
 //
 // ------------------------------------------------------------------
-function NarrowIpvFuture(value) {
-    return value.length < IpvFutureMatchMaxLength ? value.replace(IpvFutureMatch, '[::1]') : value;
-}
+const InvalidIriChars = /[\x00-\x20<>\^`{|}\\]/;
+const InvalidPercentEncoding = /%(?![0-9a-fA-F]{2})/;
 /**
  * Returns true if the value is a valid Internationalized Resource Identifier.
  * @specification https://datatracker.ietf.org/doc/html/rfc3987
@@ -31,5 +38,5 @@ export function IsIri(value) {
     if (InvalidPercentEncoding.test(value))
         return false;
     // 3. Delegate to the native URL parser, patching the IPvFuture edge case beforehand.
-    return URL.canParse(NarrowIpvFuture(value));
+    return URL.canParse(value);
 }