@openclaw/google-meet 2026.10.1-beta.2 → 2026.10.5-beta.1

package/dist/.setup/{node-host-CyFclhO_.mjs → node-host-BP4g4zw3.mjs}

@@ -1,17 +1,13 @@
 import { n as GOOGLE_MEET_NODE_COMMAND } from "./google-meet-platform-constants-CnRfrYX7.mjs";
 import { n as DEFAULT_GOOGLE_MEET_AUDIO_OUTPUT_COMMAND, t as DEFAULT_GOOGLE_MEET_AUDIO_INPUT_COMMAND } from "./config-BXGAMntj.mjs";
-import { t as GOOGLE_MEET_PLATFORM_ADAPTER } from "./google-meet-platform-adapter-CKXMbP3X.mjs";
+import { t as GOOGLE_MEET_PLATFORM_ADAPTER } from "./google-meet-platform-adapter-Bz77Bdt-.mjs";
 import { MeetingPlatformAdapter } from "openclaw/plugin-sdk/meeting-runtime";
 //#region extensions/google-meet/src/node-host.ts
 function normalizeMeetKey(value) {
 	if (!value) return;
-	try {
-		const url = new URL(value);
-		if (url.hostname.toLowerCase() !== "meet.google.com") return value;
-		return /^\/([a-z]{3}-[a-z]{4}-[a-z]{3})(?:$|[/?#])/i.exec(url.pathname)?.[1]?.toLowerCase() ?? value;
-	} catch {
-		return value;
-	}
+	const url = URL.parse(value);
+	if (url?.hostname.toLowerCase() !== "meet.google.com") return value;
+	return /^\/([a-z]{3}-[a-z]{4}-[a-z]{3})(?:$|[/?#])/i.exec(url.pathname)?.[1]?.toLowerCase() ?? value;
 }
 const handleGoogleMeetNodeHostCommand = MeetingPlatformAdapter.createNodeHostHandler({
 	commandName: GOOGLE_MEET_NODE_COMMAND,

package/dist/.setup/{node-invoke-policy-BnX3PaH7.mjs → node-invoke-policy-67WaZNPN.mjs}

@@ -1,5 +1,5 @@
 import { n as GOOGLE_MEET_NODE_COMMAND } from "./google-meet-platform-constants-CnRfrYX7.mjs";
-import { t as GOOGLE_MEET_PLATFORM_ADAPTER } from "./google-meet-platform-adapter-CKXMbP3X.mjs";
+import { t as GOOGLE_MEET_PLATFORM_ADAPTER } from "./google-meet-platform-adapter-Bz77Bdt-.mjs";
 import { createMeetingBrowserNodeInvokePolicy } from "openclaw/plugin-sdk/meeting-runtime";
 //#region extensions/google-meet/src/node-invoke-policy.ts
 const START_MODES = /* @__PURE__ */ new Set([

package/dist/.setup/{oauth-XgdPFWEJ.mjs → oauth-pXa-YQ9H.mjs}

@@ -1,4 +1,4 @@
-import { t as readGoogleApiErrorDetail } from "./google-api-DEZ9mWx7.mjs";
+import { t as readGoogleApiErrorDetail } from "./google-api-KAOF1Wn5.mjs";
 import { MAX_DATE_TIMESTAMP_MS, resolveDateTimestampMs, resolveExpiresAtMsFromDurationSeconds } from "openclaw/plugin-sdk/number-runtime";
 import { readProviderJsonResponse } from "openclaw/plugin-sdk/provider-http";
 import { fetchWithSsrFGuard } from "openclaw/plugin-sdk/ssrf-runtime";
@@ -19,8 +19,8 @@ const GOOGLE_MEET_SCOPES = [
 	"https://www.googleapis.com/auth/calendar.events.readonly",
 	"https://www.googleapis.com/auth/drive.meet.readonly"
 ];
-function resolveGoogleMeetTokenExpiresAt(value, nowMs = Date.now()) {
-	const now = resolveDateTimestampMs(nowMs);
+function resolveGoogleMeetTokenExpiresAt(value) {
+	const now = resolveDateTimestampMs(Date.now());
 	if (typeof value === "number" && Number.isFinite(value) && value <= 0) return now;
 	return resolveExpiresAtMsFromDurationSeconds(value, { nowMs: now }) ?? resolveExpiresAtMsFromDurationSeconds(GOOGLE_MEET_DEFAULT_TOKEN_LIFETIME_SECONDS, { nowMs: now }) ?? now;
 }
@@ -96,9 +96,8 @@ async function refreshGoogleMeetAccessToken(params) {
 	}));
 }
 function shouldUseCachedGoogleMeetAccessToken(params) {
-	const now = params.now ?? Date.now();
-	const safetyWindowMs = params.safetyWindowMs ?? 6e4;
-	return Boolean(params.accessToken?.trim() && typeof params.expiresAt === "number" && Number.isFinite(params.expiresAt) && params.expiresAt <= MAX_DATE_TIMESTAMP_MS && params.expiresAt > now + safetyWindowMs);
+	const now = Date.now();
+	return Boolean(params.accessToken?.trim() && typeof params.expiresAt === "number" && Number.isFinite(params.expiresAt) && params.expiresAt <= MAX_DATE_TIMESTAMP_MS && params.expiresAt > now + 6e4);
 }
 async function resolveGoogleMeetAccessToken(params) {
 	if (shouldUseCachedGoogleMeetAccessToken(params)) return {

package/dist/.setup/{plugin-helpers-D1OyyzEZ.mjs → plugin-helpers-BhofFtQ0.mjs}

@@ -1,6 +1,6 @@
-import { m as resolveMeetingInput } from "./plugin-registration-BP83dqMw.mjs";
-import { n as requestGoogleApi } from "./google-api-DEZ9mWx7.mjs";
-import { t as normalizeMeetUrl } from "./meet-url-BP2Jlvjs.mjs";
+import { m as resolveMeetingInput } from "./plugin-registration-B_Ohay99.mjs";
+import { n as requestGoogleApi } from "./google-api-KAOF1Wn5.mjs";
+import { t as normalizeMeetUrl } from "./meet-url-i_QvIxnP.mjs";
 import { normalizeOptionalString, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
@@ -74,13 +74,13 @@ function rankCalendarEvent(event, nowMs) {
 }
 async function fetchGoogleCalendarEvents(params) {
 	const calendarId = params.calendarId?.trim() || "primary";
-	const now = params.now ?? /* @__PURE__ */ new Date();
+	const now = /* @__PURE__ */ new Date();
 	const defaultTimeMax = new Date(now);
 	defaultTimeMax.setDate(defaultTimeMax.getDate() + 7);
 	return requestGoogleApi({
 		url: `${GOOGLE_CALENDAR_API_BASE_URL}/calendars/${encodeURIComponent(calendarId)}/events`,
 		query: {
-			maxResults: params.maxResults ?? 50,
+			maxResults: 50,
 			orderBy: "startTime",
 			q: params.eventQuery?.trim() || void 0,
 			showDeleted: false,
@@ -371,11 +371,7 @@ function extractGoogleDriveDocumentId(value) {
 	if (typeof value !== "string") return;
 	const trimmed = value.trim();
 	if (!trimmed) return;
-	if (/^https?:\/\//i.test(trimmed)) try {
-		return new URL(trimmed).pathname.match(/\/document\/d\/([^/]+)/)?.[1];
-	} catch {
-		return;
-	}
+	if (/^https?:\/\//i.test(trimmed)) return URL.parse(trimmed)?.pathname.match(/\/document\/d\/([^/]+)/)?.[1];
 	return trimmed.split("/").filter(Boolean).at(-1);
 }
 async function exportGoogleDriveDocumentText(params) {
@@ -602,9 +598,9 @@ var plugin_helpers_exports = /* @__PURE__ */ __exportAll({
 	resolveMeetingFromParams: () => resolveMeetingFromParams,
 	resolveSpaceFromParams: () => resolveSpaceFromParams
 });
-const loadGoogleMeetExportModule = createLazyRuntimeModule(() => import("./cli-export-BOebaVFW.mjs").then((n) => n.t));
+const loadGoogleMeetExportModule = createLazyRuntimeModule(() => import("./cli-export-DDUSzhh0.mjs").then((n) => n.t));
 async function resolveGoogleMeetTokenFromParams(config, raw) {
-	const { resolveGoogleMeetAccessToken } = await import("./oauth-XgdPFWEJ.mjs");
+	const { resolveGoogleMeetAccessToken } = await import("./oauth-pXa-YQ9H.mjs");
 	return resolveGoogleMeetAccessToken({
 		clientId: normalizeOptionalString(raw.clientId) ?? config.oauth.clientId,
 		clientSecret: normalizeOptionalString(raw.clientSecret) ?? config.oauth.clientSecret,

package/dist/.setup/{plugin-registration-BP83dqMw.mjs → plugin-registration-B_Ohay99.mjs}

@@ -4,14 +4,13 @@ import { asNonArrayRecord, normalizeOptionalString } from "openclaw/plugin-sdk/s
 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-D1OyyzEZ.mjs").then((n) => n.i));
-const loadGoogleMeetCliModule = createLazyRuntimeModule(() => import("./cli-Bfm5LpNM.mjs"));
-const loadGoogleMeetCreateModule = createLazyRuntimeModule(() => import("./create-DyYbmN11.mjs").then((n) => n.t));
-const loadGoogleMeetNodeHostModule = createLazyRuntimeModule(() => import("./node-host-CyFclhO_.mjs"));
-const loadGoogleMeetRuntimeModule = createLazyRuntimeModule(() => import("./runtime-DQgxZ2Na.mjs"));
-const loadGoogleMeetNodeInvokePolicyModule = createLazyRuntimeModule(() => import("./node-invoke-policy-BnX3PaH7.mjs"));
+const loadGoogleMeetPluginHelpers = createLazyRuntimeModule(() => import("./plugin-helpers-BhofFtQ0.mjs").then((n) => n.i));
+const loadGoogleMeetCliModule = createLazyRuntimeModule(() => import("./cli-vTuiXh8U.mjs"));
+const loadGoogleMeetCreateModule = createLazyRuntimeModule(() => import("./create-0pfsnISA.mjs").then((n) => n.n));
+const loadGoogleMeetNodeHostModule = createLazyRuntimeModule(() => import("./node-host-BP4g4zw3.mjs"));
+const loadGoogleMeetRuntimeModule = createLazyRuntimeModule(() => import("./runtime-B9xiaF9M.mjs"));
+const loadGoogleMeetNodeInvokePolicyModule = createLazyRuntimeModule(() => import("./node-invoke-policy-67WaZNPN.mjs"));
 const loadGoogleMeetGatewayRuntimeModule = createLazyRuntimeModule(() => import("openclaw/plugin-sdk/gateway-runtime"));
-const loadGoogleMeetNodeInvokePolicy = async (config) => (await loadGoogleMeetNodeInvokePolicyModule()).createGoogleMeetChromeNodeInvokePolicy(config);
 function normalizeTransport(value) {
 	return value === "chrome" || value === "chrome-node" || value === "twilio" ? value : void 0;
 }
@@ -27,8 +26,14 @@ function resolveMeetingInput(config, value) {
 function shouldJoinCreatedMeet(raw) {
 	return raw.join !== false && raw.join !== "false";
 }
-const googleMeetToolDeps = { platform: () => process.platform };
 const googleMeetGatewayMethods = {
+	join: "googlemeet.join",
+	create: "googlemeet.create",
+	status: "googlemeet.status",
+	transcript: "googlemeet.transcript",
+	participate: "googlemeet.participate",
+	leave: "googlemeet.leave",
+	speak: "googlemeet.speak",
 	participation_context: "googlemeet.participationContext",
 	recover_current_tab: "googlemeet.recoverCurrentTab",
 	setup_status: "googlemeet.setup",
@@ -60,7 +65,7 @@ function readGoogleMeetParticipationParams(raw) {
 	};
 }
 function assertGoogleMeetAgentToolActionSupported(params) {
-	const platform = googleMeetToolDeps.platform();
+	const platform = process.platform;
 	if (platform === "darwin" || platform === "linux") return;
 	const action = params.raw.action;
 	if (action !== "join" && action !== "test_speech" && !(action === "create" && shouldJoinCreatedMeet(params.raw))) return;
@@ -70,13 +75,14 @@ function assertGoogleMeetAgentToolActionSupported(params) {
 	throw new Error("Google Meet local Chrome talk-back audio requires macOS with BlackHole 2ch or Linux with PipeWire-Pulse. On this host, use mode: transcribe, transport: twilio, or a supported chrome-node.");
 }
 async function callGoogleMeetGatewayFromTool(params) {
-	const method = googleMeetGatewayMethods[params.action] ?? `googlemeet.${params.action}`;
+	const method = googleMeetGatewayMethods[params.action];
 	try {
 		if (params.runtime) return await params.runtime.gateway.request(method, params.raw, {
 			timeoutMs: resolveGoogleMeetGatewayOperationTimeoutMs(params.config),
 			scopes: ["operator.admin"]
 		});
-		return await (googleMeetToolDeps.callGatewayFromCli ?? (await loadGoogleMeetGatewayRuntimeModule()).callGatewayFromCli)(method, {
+		const { callGatewayFromCli } = await loadGoogleMeetGatewayRuntimeModule();
+		return await callGatewayFromCli(method, {
 			json: true,
 			timeout: String(resolveGoogleMeetGatewayOperationTimeoutMs(params.config))
 		}, params.raw, {
@@ -129,7 +135,7 @@ function createGoogleMeetRuntimeAccessor(params) {
 		return await runtimePromise;
 	};
 }
-function createLazyGoogleMeetNodeInvokePolicy(config, loadPolicy = loadGoogleMeetNodeInvokePolicy) {
+function createLazyGoogleMeetNodeInvokePolicy(config) {
 	let policyPromise;
 	return {
 		commands: [GOOGLE_MEET_NODE_COMMAND],
@@ -137,7 +143,7 @@ function createLazyGoogleMeetNodeInvokePolicy(config, loadPolicy = loadGoogleMee
 		async handle(ctx) {
 			let policy;
 			try {
-				policyPromise ??= loadPolicy(config);
+				policyPromise ??= loadGoogleMeetNodeInvokePolicyModule().then((module) => module.createGoogleMeetChromeNodeInvokePolicy(config));
 				policy = await policyPromise;
 			} catch (error) {
 				return {

package/dist/.setup/{runtime-DQgxZ2Na.mjs → runtime-B9xiaF9M.mjs}

@@ -1,7 +1,7 @@
 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-Bh1L33pr.mjs";
-import { n as normalizeDialInNumber, t as GOOGLE_MEET_PLATFORM_ADAPTER } from "./google-meet-platform-adapter-CKXMbP3X.mjs";
+import { t as normalizeMeetUrl } from "./meet-url-i_QvIxnP.mjs";
+import { c as callBrowserProxyOnNode, l as resolveChromeNode, u as resolveChromeNodeInfo } from "./chrome-create-CW_QQzuj.mjs";
+import { n as normalizeDialInNumber, t as GOOGLE_MEET_PLATFORM_ADAPTER } from "./google-meet-platform-adapter-Bz77Bdt-.mjs";
 import { asOptionalRecord, asRecord, normalizeOptionalString, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import path from "node:path";
@@ -65,12 +65,8 @@ function resolveUserPath(input) {
 	return input;
 }
 function isProviderUnreachableWebhookUrl(webhookUrl) {
-	try {
-		const parsed = new URL(webhookUrl);
-		return isBlockedHostnameOrIp(parsed.hostname);
-	} catch {
-		return false;
-	}
+	const parsed = URL.parse(webhookUrl);
+	return parsed ? isBlockedHostnameOrIp(parsed.hostname) : false;
 }
 function resolveVoiceCallSetupValue(configured, fallback) {
 	return normalizeOptionalString(configured) ?? normalizeOptionalString(fallback);
@@ -216,13 +212,10 @@ function shouldCaptureCaptions(mode, fullConfig) {
 	return mode === "transcribe" || !fullConfig || resolveTranscriptsConfig(fullConfig.transcripts).enabled;
 }
 function chromeNodeBrowserRequest(runtime, nodeId) {
-	return async (request) => await callBrowserProxyOnNode({
+	return (request) => callBrowserProxyOnNode({
+		...request,
 		runtime,
-		nodeId,
-		method: request.method,
-		path: request.path,
-		body: request.body,
-		timeoutMs: request.timeoutMs
+		nodeId
 	});
 }
 async function leaveChromeMeet(params) {
@@ -444,26 +437,19 @@ async function joinMeetViaVoiceCallGateway(params) {
 //#endregion
 //#region extensions/google-meet/src/runtime.ts
 const nowIso = () => (/* @__PURE__ */ new Date()).toISOString();
-var GoogleMeetRuntime = class {
-	#createdBrowserTabs;
+var GoogleMeetRuntime = class extends MeetingSessionRuntime {
+	#createdBrowserTabs = /* @__PURE__ */ new Map();
 	#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);
+		const voiceCallGateway = createVoiceCallGateway(params);
 		let participationStore;
 		const getParticipationStore = () => participationStore ??= params.runtime.state.openKeyedStore({
 			namespace: "meeting-participation",
 			maxEntries: 1e4,
 			overflowPolicy: "reject-new"
 		});
-		this.#sessions = new MeetingSessionRuntime({
+		super({
 			participation: {
 				store: {
 					entries: async () => await getParticipationStore().entries(),
@@ -556,21 +542,8 @@ var GoogleMeetRuntime = class {
 				providerName: "Google Meet"
 			}
 		});
-	}
-	list() {
-		return this.#sessions.list();
-	}
-	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);
+		this.params = params;
+		this.#voiceCallGateway = voiceCallGateway;
 	}
 	async setupStatus(options = {}) {
 		return await getGoogleMeetRuntimeSetupStatus({
@@ -600,15 +573,6 @@ var GoogleMeetRuntime = class {
 			url
 		});
 	}
-	async join(request) {
-		return await this.#sessions.join(request);
-	}
-	async leave(sessionId, options) {
-		return await this.#sessions.leave(sessionId, options);
-	}
-	async speak(sessionId, instructions) {
-		return await this.#sessions.speak(sessionId, instructions);
-	}
 	async testSpeech(request) {
 		return await testGoogleMeetSpeech(this.#probeContext(), request);
 	}
@@ -621,10 +585,10 @@ var GoogleMeetRuntime = class {
 			resolveAgentId: (request) => this.#resolveAgentId(request.agentId),
 			list: () => this.list(),
 			join: async (request) => await this.join(request),
-			isReusable: (session, resolved) => this.#sessions.isReusableSession(session, resolved),
-			hasHealthHandle: (sessionId) => this.#sessions.hasHealthHandle(sessionId),
-			refreshHealth: (sessionId) => this.#sessions.refreshHealth(sessionId),
-			refreshCaptionHealth: async (session) => await this.#sessions.refreshCaptionHealth(session)
+			isReusable: (session, resolved) => this.isReusableSession(session, resolved),
+			hasHealthHandle: (sessionId) => this.hasHealthHandle(sessionId),
+			refreshHealth: (sessionId) => this.refreshHealth(sessionId),
+			refreshCaptionHealth: async (session) => await this.refreshCaptionHealth(session)
 		};
 	}
 	#resolveAgentId(requestedAgentId) {
@@ -670,7 +634,7 @@ var GoogleMeetRuntime = class {
 			const handles = this.#attachChromeAudioBridge(session, result.audioBridge);
 			if (handles) context.attachRuntimeHandles(session, handles);
 			session.notes.push(result.audioBridge ? session.transport === "chrome-node" ? "Chrome node transport joins as the signed-in Google profile on the selected node and routes realtime audio through the node bridge." : "Chrome transport joins as the signed-in Google profile and routes realtime audio through the configured bridge." : MeetingPlatformAdapter.isTalkBackMode(session.mode) ? "Chrome transport is waiting for verified virtual input/output audio routing." : "Chrome transport joins as the signed-in Google profile without starting the realtime audio bridge.");
-			this.#sessions.refreshSpeechReadiness(session);
+			this.refreshSpeechReadiness(session);
 			return {};
 		}
 		const dialPlan = GOOGLE_MEET_PLATFORM_ADAPTER.dialIn.buildPlan({
@@ -784,17 +748,17 @@ var GoogleMeetRuntime = class {
 		}
 	}
 	async #refreshStatus(session) {
-		if (isBrowserTransport(session.transport)) await this.#sessions.refreshBrowserHealth(session, {
+		if (isBrowserTransport(session.transport)) await this.refreshBrowserHealth(session, {
 			force: true,
 			readOnly: true
 		});
 		else if (session.transport === "twilio") await this.#refreshTwilioVoiceCallStatus(session);
-		else this.#sessions.refreshSpeechReadiness(session);
+		else this.refreshSpeechReadiness(session);
 	}
 	async #refreshTwilioVoiceCallStatus(session) {
 		const callId = session.twilio?.voiceCallId;
 		if (!callId || session.state !== "active") {
-			this.#sessions.refreshSpeechReadiness(session);
+			this.refreshSpeechReadiness(session);
 			return;
 		}
 		try {
@@ -803,11 +767,11 @@ var GoogleMeetRuntime = class {
 				callId
 			});
 			const call = asOptionalRecord(status.call);
-			if (status.found === false || call?.endedAt !== void 0 || call?.endReason !== void 0) this.#sessions.markSessionEnded(session, "Voice Call is no longer active.");
+			if (status.found === false || call?.endedAt !== void 0 || call?.endReason !== void 0) this.markSessionEnded(session, "Voice Call is no longer active.");
 		} catch (error) {
 			this.params.logger.debug?.(`[google-meet] voice-call status refresh ignored: ${formatErrorMessage(error)}`);
 		}
-		this.#sessions.refreshSpeechReadiness(session);
+		this.refreshSpeechReadiness(session);
 	}
 	async #speakViaTransport(session, instructions) {
 		if (session.transport !== "twilio" || !session.twilio?.voiceCallId) return;
@@ -819,7 +783,7 @@ var GoogleMeetRuntime = class {
 			});
 		} catch (error) {
 			if (!isMeetingVoiceCallMissingError(error)) throw error;
-			this.#sessions.markSessionEnded(session, "Voice Call is no longer active.");
+			this.markSessionEnded(session, "Voice Call is no longer active.");
 			return {
 				handled: true,
 				spoken: false

package/dist/index.js

@@ -1,7 +1,7 @@
 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-CnRfrYX7.mjs";
 import { r as resolveGoogleMeetConfig } from "./.setup/config-BXGAMntj.mjs";
-import { a as formatGoogleMeetGatewayError, c as loadGoogleMeetCreateModule, d as normalizeMode, f as normalizeTransport, g as shouldJoinCreatedMeet, h as sendGoogleMeetGatewayError, i as createLazyGoogleMeetNodeInvokePolicy, l as loadGoogleMeetNodeHostModule, m as resolveMeetingInput, n as callGoogleMeetGatewayFromTool, o as keepTrustedToolAgentId, p as readGoogleMeetParticipationParams, r as createGoogleMeetRuntimeAccessor, s as loadGoogleMeetCliModule, t as assertGoogleMeetAgentToolActionSupported, u as loadGoogleMeetPluginHelpers } from "./.setup/plugin-registration-BP83dqMw.mjs";
+import { a as formatGoogleMeetGatewayError, c as loadGoogleMeetCreateModule, d as normalizeMode, f as normalizeTransport, g as shouldJoinCreatedMeet, h as sendGoogleMeetGatewayError, i as createLazyGoogleMeetNodeInvokePolicy, l as loadGoogleMeetNodeHostModule, m as resolveMeetingInput, n as callGoogleMeetGatewayFromTool, o as keepTrustedToolAgentId, p as readGoogleMeetParticipationParams, r as createGoogleMeetRuntimeAccessor, s as loadGoogleMeetCliModule, t as assertGoogleMeetAgentToolActionSupported, u as loadGoogleMeetPluginHelpers } from "./.setup/plugin-registration-B_Ohay99.mjs";
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 import { asNonArrayRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { jsonResult } from "openclaw/plugin-sdk/tool-results";
@@ -84,7 +84,7 @@ const GoogleMeetToolSchema = Type.Object({
 		minimum: 0
 	})),
 	message: Type.Optional(Type.String({ description: "Realtime instructions to speak now" })),
-	timeoutMs: optionalPositiveIntegerSchema({ description: "Probe timeout in milliseconds" }),
+	timeoutMs: optionalPositiveIntegerSchema({ description: "Check timeout in milliseconds" }),
 	meeting: Type.Optional(Type.String({ description: "Meet URL, meeting code, or spaces/{id}" })),
 	today: Type.Optional(Type.Boolean({ description: "For latest, artifacts, or attendance, find a Meet link on today's calendar." })),
 	event: Type.Optional(Type.String({ description: "For latest, artifacts, or attendance, find a matching Calendar event." })),
@@ -108,6 +108,12 @@ const GoogleMeetToolSchema = Type.Object({
 });
 //#endregion
 //#region extensions/google-meet/index.ts
+var InvalidGoogleMeetRequest = class extends Error {};
+function requireSessionId(params) {
+	const sessionId = normalizeOptionalString(params?.sessionId);
+	if (!sessionId) throw new InvalidGoogleMeetRequest("sessionId required");
+	return sessionId;
+}
 var google_meet_default = definePluginEntry({
 	id: "google-meet",
 	name: "Google Meet",
@@ -122,9 +128,9 @@ var google_meet_default = definePluginEntry({
 		const registerGatewayMethod = (method, handler) => {
 			api.registerGatewayMethod(method, async (options) => {
 				try {
-					await handler(options);
+					options.respond(true, await handler(options));
 				} catch (err) {
-					sendGoogleMeetGatewayError(options.respond, err);
+					sendGoogleMeetGatewayError(options.respond, err, err instanceof InvalidGoogleMeetRequest ? "INVALID_REQUEST" : "UNAVAILABLE");
 				}
 			});
 		};
@@ -179,131 +185,106 @@ var google_meet_default = definePluginEntry({
 				return helpers.fetchResolvedGoogleMeetAttendance(await helpers.resolveArtifactQueryFromParams(config, raw));
 			}
 		};
-		const transcriptSourceRuntime = async () => (await ensureRuntime()).transcriptSourceRuntime();
 		api.registerTranscriptSourceProvider({
 			id: "google-meet",
 			aliases: ["googlemeet", "meet"],
 			name: "Google Meet",
 			sourceKinds: ["live-caption"],
-			start: async (request) => await (await transcriptSourceRuntime()).startTranscriptSource(request),
-			stop: async (request) => await (await transcriptSourceRuntime()).stopTranscriptSource(request)
+			start: async (request) => await (await ensureRuntime()).startTranscriptSource(request),
+			stop: async (request) => await (await ensureRuntime()).stopTranscriptSource(request)
 		});
 		registerGatewayMethod("googlemeet.join", async (options) => {
-			const runtime = await ensureRuntime();
-			options.respond(true, await runtime.join(resolveTrustedJoinParams(options)));
+			return (await ensureRuntime()).join(resolveTrustedJoinParams(options));
 		});
-		registerGatewayMethod("googlemeet.create", async ({ params, client, respond }) => {
+		registerGatewayMethod("googlemeet.create", async ({ params, client }) => {
 			const raw = keepTrustedToolAgentId(asNonArrayRecord(params), client);
 			const create = await loadGoogleMeetCreateModule();
-			respond(true, shouldJoinCreatedMeet(raw) ? await create.createAndJoinMeetFromParams({
+			return shouldJoinCreatedMeet(raw) ? create.createAndJoinMeetFromParams({
 				config,
 				runtime: api.runtime,
 				raw,
 				ensureRuntime
-			}) : await create.createMeetFromParams({
+			}) : create.createMeetFromParams({
 				config,
 				runtime: api.runtime,
 				raw
-			}));
+			});
 		});
-		registerGatewayMethod("googlemeet.status", async ({ params, respond }) => {
-			respond(true, await (await ensureRuntime()).status(normalizeOptionalString(params?.sessionId)));
+		registerGatewayMethod("googlemeet.status", async ({ params }) => {
+			return (await ensureRuntime()).status(normalizeOptionalString(params?.sessionId));
 		});
-		registerGatewayMethod("googlemeet.transcript", async ({ params, respond }) => {
-			const sessionId = normalizeOptionalString(params?.sessionId);
-			if (!sessionId) {
-				sendGoogleMeetGatewayError(respond, /* @__PURE__ */ new Error("sessionId required"), "INVALID_REQUEST");
-				return;
-			}
+		registerGatewayMethod("googlemeet.transcript", async ({ params }) => {
+			const sessionId = requireSessionId(params);
 			const sinceIndex = params?.sinceIndex;
-			if (sinceIndex !== void 0 && (typeof sinceIndex !== "number" || !Number.isSafeInteger(sinceIndex) || sinceIndex < 0)) {
-				sendGoogleMeetGatewayError(respond, /* @__PURE__ */ new Error("sinceIndex must be a non-negative safe integer"), "INVALID_REQUEST");
-				return;
-			}
-			respond(true, await (await ensureRuntime()).transcript(sessionId, sinceIndex === void 0 ? {} : { sinceIndex }));
+			if (sinceIndex !== void 0 && (typeof sinceIndex !== "number" || !Number.isSafeInteger(sinceIndex) || sinceIndex < 0)) throw new InvalidGoogleMeetRequest("sinceIndex must be a non-negative safe integer");
+			return (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.participationContext", async ({ params }) => {
+			const sessionId = requireSessionId(params);
+			return (await ensureRuntime()).participationContext(sessionId);
 		});
-		registerGatewayMethod("googlemeet.participate", async ({ params, respond }) => {
+		registerGatewayMethod("googlemeet.participate", async ({ params }) => {
 			let parsed;
 			try {
 				parsed = readGoogleMeetParticipationParams(asNonArrayRecord(params));
 			} catch (err) {
-				sendGoogleMeetGatewayError(respond, err, "INVALID_REQUEST");
-				return;
+				throw new InvalidGoogleMeetRequest(formatGoogleMeetGatewayError(err).error);
 			}
-			respond(true, await (await ensureRuntime()).participate(parsed.sessionId, parsed.request));
+			return (await ensureRuntime()).participate(parsed.sessionId, parsed.request);
 		});
-		registerGatewayMethod("googlemeet.recoverCurrentTab", async ({ params, respond }) => {
-			respond(true, await (await ensureRuntime()).recoverCurrentTab({
+		registerGatewayMethod("googlemeet.recoverCurrentTab", async ({ params }) => {
+			return (await ensureRuntime()).recoverCurrentTab({
 				url: normalizeOptionalString(params?.url),
 				transport: normalizeTransport(params?.transport)
-			}));
+			});
 		});
-		registerGatewayMethod("googlemeet.setup", async ({ params, respond }) => {
-			respond(true, await (await ensureRuntime()).setupStatus({
+		registerGatewayMethod("googlemeet.setup", async ({ params }) => {
+			return (await ensureRuntime()).setupStatus({
 				transport: normalizeTransport(params?.transport),
 				mode: normalizeMode(params?.mode),
 				dialInNumber: normalizeOptionalString(params?.dialInNumber)
-			}));
+			});
 		});
 		for (const [method, action] of [
 			["googlemeet.latest", "latest"],
 			["googlemeet.calendarEvents", "calendar_events"],
 			["googlemeet.artifacts", "artifacts"],
 			["googlemeet.attendance", "attendance"]
-		]) registerGatewayMethod(method, async ({ params, respond }) => {
-			respond(true, await queryActions[action](asNonArrayRecord(params)));
-		});
-		registerGatewayMethod("googlemeet.export", async ({ params, respond }) => {
-			respond(true, await (await loadGoogleMeetPluginHelpers()).exportGoogleMeetBundleFromParams(config, asNonArrayRecord(params)));
+		]) registerGatewayMethod(method, ({ params }) => queryActions[action](asNonArrayRecord(params)));
+		registerGatewayMethod("googlemeet.export", async ({ params }) => {
+			return (await loadGoogleMeetPluginHelpers()).exportGoogleMeetBundleFromParams(config, asNonArrayRecord(params));
 		});
-		registerGatewayMethod("googlemeet.leave", async ({ params, respond }) => {
-			const sessionId = normalizeOptionalString(params?.sessionId);
-			if (!sessionId) {
-				sendGoogleMeetGatewayError(respond, /* @__PURE__ */ new Error("sessionId required"), "INVALID_REQUEST");
-				return;
-			}
-			respond(true, await (await ensureRuntime()).leave(sessionId));
+		registerGatewayMethod("googlemeet.leave", async ({ params }) => {
+			const sessionId = requireSessionId(params);
+			return (await ensureRuntime()).leave(sessionId);
 		});
-		registerGatewayMethod("googlemeet.endActiveConference", async ({ params, respond }) => {
+		registerGatewayMethod("googlemeet.endActiveConference", async ({ params }) => {
 			const raw = asNonArrayRecord(params);
 			const helpers = await loadGoogleMeetPluginHelpers();
 			const token = await helpers.resolveGoogleMeetTokenFromParams(config, raw);
-			respond(true, await helpers.endGoogleMeetActiveConference({
+			return helpers.endGoogleMeetActiveConference({
 				accessToken: token.accessToken,
 				meeting: resolveMeetingInput(config, raw.meeting)
-			}));
+			});
 		});
-		registerGatewayMethod("googlemeet.speak", async ({ params, respond }) => {
-			const sessionId = normalizeOptionalString(params?.sessionId);
-			if (!sessionId) {
-				sendGoogleMeetGatewayError(respond, /* @__PURE__ */ new Error("sessionId required"), "INVALID_REQUEST");
-				return;
-			}
-			respond(true, await (await ensureRuntime()).speak(sessionId, normalizeOptionalString(params?.message)));
+		registerGatewayMethod("googlemeet.speak", async ({ params }) => {
+			const sessionId = requireSessionId(params);
+			return (await ensureRuntime()).speak(sessionId, normalizeOptionalString(params?.message));
 		});
 		registerGatewayMethod("googlemeet.testSpeech", async (options) => {
-			const runtime = await ensureRuntime();
-			options.respond(true, await runtime.testSpeech(resolveTrustedJoinParams(options)));
+			return (await ensureRuntime()).testSpeech(resolveTrustedJoinParams(options));
 		});
-		registerGatewayMethod("googlemeet.testListen", async ({ params, client, respond }) => {
+		registerGatewayMethod("googlemeet.testListen", async ({ 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({
+			return runtime.testListen({
 				url: resolveMeetingInput(config, trustedParams.url),
 				transport: normalizeTransport(trustedParams.transport),
 				mode: normalizeMode(trustedParams.mode),
 				agentId: normalizeOptionalString(trustedParams.agentId),
 				timeoutMs: readPositiveIntegerParam(trustedParams, "timeoutMs")
-			}));
+			});
 		});
 		api.registerTool((toolContext) => ({
 			name: "google_meet",
@@ -329,25 +310,19 @@ var google_meet_default = definePluginEntry({
 						config,
 						raw
 					});
+					let routeRequester = false;
 					switch (raw.action) {
 						case "join":
 						case "create":
 						case "test_speech":
-						case "test_listen": return jsonResult(await callGoogleMeetGatewayFromTool({
-							config,
-							action: raw.action,
-							raw: rawWithRequester,
-							runtime: useTrustedRuntime ? api.runtime : void 0
-						}));
+						case "test_listen":
+							routeRequester = true;
+							break;
 						case "status":
 						case "transcript":
 						case "recover_current_tab":
 						case "setup_status":
-						case "end_active_conference": return jsonResult(await callGoogleMeetGatewayFromTool({
-							config,
-							action: raw.action,
-							raw
-						}));
+						case "end_active_conference": break;
 						case "resolve_space": {
 							const { token: _token, ...result } = await (await loadGoogleMeetPluginHelpers()).resolveSpaceFromParams(config, raw);
 							return jsonResult(result);
@@ -372,22 +347,20 @@ var google_meet_default = definePluginEntry({
 						}
 						case "participate":
 							readGoogleMeetParticipationParams(raw);
-							return jsonResult(await callGoogleMeetGatewayFromTool({
-								config,
-								action: raw.action,
-								raw
-							}));
+							break;
 						case "participation_context":
 						case "leave":
 						case "speak":
 							if (!normalizeOptionalString(raw.sessionId)) throw new Error("sessionId required");
-							return jsonResult(await callGoogleMeetGatewayFromTool({
-								config,
-								action: raw.action,
-								raw
-							}));
+							break;
 						default: throw new Error("unknown google_meet action");
 					}
+					return jsonResult(await callGoogleMeetGatewayFromTool({
+						config,
+						action: raw.action,
+						raw: routeRequester ? rawWithRequester : raw,
+						runtime: routeRequester && useTrustedRuntime ? api.runtime : void 0
+					}));
 				} catch (err) {
 					return jsonResult(formatGoogleMeetGatewayError(err));
 				}