@openclaw/google-meet 2026.9.6 → 2026.9.8

package/dist/.setup/{runtime-BuIZ5e3V.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();
@@ -491,7 +505,31 @@ var GoogleMeetRuntime = class {
 		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,
@@ -576,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);
 	}
@@ -713,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
 			});
@@ -805,7 +849,7 @@ var GoogleMeetRuntime = class {
 			return;
 		}
 		try {
-			const status = await getMeetVoiceCallGatewayCall({
+			const status = await getMeetingVoiceCallGatewayCall({
 				gateway: this.#voiceCallGateway,
 				callId
 			});
@@ -819,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-B3LXKV4R.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");

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);
 }

package/node_modules/typebox/build/guard/emit.mjs

@@ -97,10 +97,10 @@ export function IsGreaterEqualThan(left, right) {
 // String
 // --------------------------------------------------------------------------
 export function IsMinLength(value, length) {
-    return `Guard.IsMinLength(${value}, ${length})`;
+    return `(${value}.length >= ${(+length) << 1} || (${value}.length >= ${length} && Guard.CodePointCount(${value}) >= ${length}))`;
 }
 export function IsMaxLength(value, length) {
-    return `Guard.IsMaxLength(${value}, ${length})`;
+    return `(${value}.length <= ${length} || (${value}.length <= ${(+length) << 1} && Guard.CodePointCount(${value}) <= ${length}))`;
 }
 // --------------------------------------------------------------------------
 // Array

package/node_modules/typebox/build/guard/guard.d.mts

@@ -33,12 +33,14 @@ export declare function IsMultipleOf(dividend: bigint | number, divisor: bigint
 /** Returns true if the value appears to be an instance of a class. */
 export declare function IsClassInstance(value: unknown): boolean;
 export declare function IsValueLike(value: unknown): value is bigint | boolean | null | number | string | undefined;
-/** Returns the number of grapheme clusters in the string */
+/** Returns the total number of visual grapheme clusters in the string. */
 export declare function GraphemeCount(value: string): number;
-/** Returns true if the string has at most the given number of graphemes */
-export declare function IsMaxLength(value: string, length: number): boolean;
-/** Returns true if the string has at least the given number of graphemes */
-export declare function IsMinLength(value: string, length: number): boolean;
+/** Returns the total number of Unicode code points in the string. */
+export declare function CodePointCount(value: string): number;
+/** Returns true if the string length in Unicode code points does not exceed maxLength */
+export declare function IsMaxLength(value: string, maxLength: number): boolean;
+/** Returns true if the string length in Unicode code points is at least minLength */
+export declare function IsMinLength(value: string, minLength: number): boolean;
 /** Returns true if every element from offset satisfies the callback, short-circuiting on the first failure */
 export declare function Every<T>(value: T[], offset: number, callback: (value: T, index: number) => boolean): boolean;
 /** Returns true if every element from offset satisfies the callback, using exhaustive enumeration */

package/node_modules/typebox/build/guard/guard.mjs

@@ -1,5 +1,6 @@
 // deno-fmt-ignore-file
-import * as String from './string.mjs';
+import * as UnicodeSegmentGuard from './unicode/unicode_segment.mjs';
+import * as UnicodeGuard from './unicode/unicode.mjs';
 // --------------------------------------------------------------------------
 // Guards
 // --------------------------------------------------------------------------
@@ -123,17 +124,21 @@ export function IsValueLike(value) {
 // --------------------------------------------------------------------------
 // String
 // --------------------------------------------------------------------------
-/** Returns the number of grapheme clusters in the string */
+/** Returns the total number of visual grapheme clusters in the string. */
 export function GraphemeCount(value) {
-    return String.GraphemeCount(value);
+    return UnicodeSegmentGuard.GraphemeCount(value);
 }
-/** Returns true if the string has at most the given number of graphemes */
-export function IsMaxLength(value, length) {
-    return String.IsMaxLength(value, length);
+/** Returns the total number of Unicode code points in the string. */
+export function CodePointCount(value) {
+    return UnicodeGuard.CodePointCount(value);
 }
-/** Returns true if the string has at least the given number of graphemes */
-export function IsMinLength(value, length) {
-    return String.IsMinLength(value, length);
+/** Returns true if the string length in Unicode code points does not exceed maxLength */
+export function IsMaxLength(value, maxLength) {
+    return UnicodeGuard.IsMaxLength(value, maxLength);
+}
+/** Returns true if the string length in Unicode code points is at least minLength */
+export function IsMinLength(value, minLength) {
+    return UnicodeGuard.IsMinLength(value, minLength);
 }
 // --------------------------------------------------------------------------
 // Array

package/node_modules/typebox/build/guard/index.mjs

@@ -1,6 +1,12 @@
+// ------------------------------------------------------------------
+// Guards
+// ------------------------------------------------------------------
 export * as EmitGuard from './emit.mjs';
 export * as GlobalsGuard from './globals.mjs';
 export * as NativeGuard from './native.mjs';
+// ------------------------------------------------------------------
+// Default
+// ------------------------------------------------------------------
 import * as Guard from './guard.mjs';
 export * as Guard from './guard.mjs';
 export default Guard;

package/node_modules/typebox/build/guard/unicode/unicode.d.mts

@@ -0,0 +1,6 @@
+/** Returns the total number of Unicode code points in the string */
+export declare function CodePointCount(value: string): number;
+/** Returns true if the string length in Unicode code points is less than or equal to maxLength */
+export declare function IsMaxLength(value: string, maxLength: number): boolean;
+/** Returns true if the string length in Unicode code points is greater than or equal to minLength */
+export declare function IsMinLength(value: string, minLength: number): boolean;

package/node_modules/typebox/build/guard/unicode/unicode.mjs

@@ -0,0 +1,35 @@
+// ------------------------------------------------------------------
+// CodePointCount (10-bit Shift Branchless)
+//
+// Counts code points by enumerating UTF-16 sequences and incrementing
+// when not within a high/low pairing. Because surrogate blocks are
+// 1024 (2^10) wide and aligned, by shifting right by (0xA), we can
+// collapse each unit to a constant per block (high: 0x36, low: 0x37)
+// and shift again into a packed (0x3637) for comparison. Fetch calls
+// to charCodeAt(...) are kept to one call per iteration.
+//
+// ------------------------------------------------------------------
+/** Returns the total number of Unicode code points in the string */
+export function CodePointCount(value) {
+    let result = 0, index = 0, prev = 0;
+    while (index < value.length) {
+        const next = value.charCodeAt(index++) >> 0xA; // shift  (10-bits into high/low)
+        result += +(((prev << 8) | next) !== 0x3637); // packed (or +!(prev === 0x36 && next === 0x37))
+        prev = next;
+    }
+    return result;
+}
+// ------------------------------------------------------------------
+// IsMaxLength
+// ------------------------------------------------------------------
+/** Returns true if the string length in Unicode code points is less than or equal to maxLength */
+export function IsMaxLength(value, maxLength) {
+    return value.length <= maxLength || (value.length <= (maxLength << 1) && CodePointCount(value) <= maxLength);
+}
+// ------------------------------------------------------------------
+// IsMinLength
+// ------------------------------------------------------------------
+/** Returns true if the string length in Unicode code points is greater than or equal to minLength */
+export function IsMinLength(value, minLength) {
+    return value.length >= (minLength << 1) || (value.length >= minLength && CodePointCount(value) >= minLength);
+}