@openclaw/google-meet 2026.5.3 → 2026.5.4-beta.2

package/dist/index.js

@@ -6,16 +6,29 @@ import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 import { normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";
 import { Type } from "typebox";
 import { isBlockedHostnameOrIp } from "openclaw/plugin-sdk/ssrf-runtime";
-import { REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME, REALTIME_VOICE_AUDIO_FORMAT_G711_ULAW_8KHZ, REALTIME_VOICE_AUDIO_FORMAT_PCM16_24KHZ, buildRealtimeVoiceAgentConsultWorkingResponse, consultRealtimeVoiceAgent, createRealtimeVoiceBridgeSession, resolveConfiguredRealtimeVoiceProvider, resolveRealtimeVoiceAgentConsultToolPolicy, resolveRealtimeVoiceAgentConsultTools, resolveRealtimeVoiceAgentConsultToolsAllow } from "openclaw/plugin-sdk/realtime-voice";
+import { REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME, REALTIME_VOICE_AUDIO_FORMAT_G711_ULAW_8KHZ, REALTIME_VOICE_AUDIO_FORMAT_PCM16_24KHZ, buildRealtimeVoiceAgentConsultWorkingResponse, consultRealtimeVoiceAgent, convertPcmToMulaw8k, createRealtimeVoiceBridgeSession, mulawToPcm, resamplePcm, resolveConfiguredRealtimeVoiceProvider, resolveRealtimeVoiceAgentConsultToolPolicy, resolveRealtimeVoiceAgentConsultTools, resolveRealtimeVoiceAgentConsultToolsAllow } from "openclaw/plugin-sdk/realtime-voice";
 import { spawn, spawnSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
+import { getRealtimeTranscriptionProvider, listRealtimeTranscriptionProviders } from "openclaw/plugin-sdk/realtime-transcription";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 //#region extensions/google-meet/src/config.ts
-const DEFAULT_GOOGLE_MEET_AUDIO_INPUT_COMMAND = [
+const SOX_DEFAULT_BUFFER_BYTES = 8192;
+const SOX_MIN_BUFFER_BYTES = 17;
+const DEFAULT_GOOGLE_MEET_AUDIO_BUFFER_BYTES = SOX_DEFAULT_BUFFER_BYTES / 2;
+function withSoxBuffer(command, bufferBytes) {
+	return [
+		command[0] ?? "sox",
+		"-q",
+		"--buffer",
+		String(bufferBytes),
+		...command.slice(2)
+	];
+}
+const DEFAULT_GOOGLE_MEET_AUDIO_INPUT_COMMAND_BASE = [
 	"sox",
 	"-q",
 	"-t",
@@ -34,7 +47,7 @@ const DEFAULT_GOOGLE_MEET_AUDIO_INPUT_COMMAND = [
 	"-L",
 	"-"
 ];
-const DEFAULT_GOOGLE_MEET_AUDIO_OUTPUT_COMMAND = [
+const DEFAULT_GOOGLE_MEET_AUDIO_OUTPUT_COMMAND_BASE = [
 	"sox",
 	"-q",
 	"-t",
@@ -53,7 +66,7 @@ const DEFAULT_GOOGLE_MEET_AUDIO_OUTPUT_COMMAND = [
 	"coreaudio",
 	"BlackHole 2ch"
 ];
-const LEGACY_GOOGLE_MEET_AUDIO_INPUT_COMMAND = [
+const LEGACY_GOOGLE_MEET_AUDIO_INPUT_COMMAND_BASE = [
 	"rec",
 	"-q",
 	"-t",
@@ -68,7 +81,7 @@ const LEGACY_GOOGLE_MEET_AUDIO_INPUT_COMMAND = [
 	"8",
 	"-"
 ];
-const LEGACY_GOOGLE_MEET_AUDIO_OUTPUT_COMMAND = [
+const LEGACY_GOOGLE_MEET_AUDIO_OUTPUT_COMMAND_BASE = [
 	"play",
 	"-q",
 	"-t",
@@ -83,21 +96,24 @@ const LEGACY_GOOGLE_MEET_AUDIO_OUTPUT_COMMAND = [
 	"8",
 	"-"
 ];
+const DEFAULT_GOOGLE_MEET_AUDIO_INPUT_COMMAND = withSoxBuffer(DEFAULT_GOOGLE_MEET_AUDIO_INPUT_COMMAND_BASE, DEFAULT_GOOGLE_MEET_AUDIO_BUFFER_BYTES);
+const DEFAULT_GOOGLE_MEET_AUDIO_OUTPUT_COMMAND = withSoxBuffer(DEFAULT_GOOGLE_MEET_AUDIO_OUTPUT_COMMAND_BASE, DEFAULT_GOOGLE_MEET_AUDIO_BUFFER_BYTES);
 const DEFAULT_GOOGLE_MEET_CHROME_AUDIO_FORMAT = "pcm16-24khz";
 const DEFAULT_GOOGLE_MEET_BARGE_IN_RMS_THRESHOLD = 650;
 const DEFAULT_GOOGLE_MEET_BARGE_IN_PEAK_THRESHOLD = 2500;
 const DEFAULT_GOOGLE_MEET_BARGE_IN_COOLDOWN_MS = 900;
-const DEFAULT_GOOGLE_MEET_REALTIME_INSTRUCTIONS = `You are joining a private Google Meet as an OpenClaw agent. Keep spoken replies brief and natural. When a question needs deeper reasoning, current information, or tools, call ${REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME} before answering.`;
+const DEFAULT_GOOGLE_MEET_REALTIME_INSTRUCTIONS = `You are joining a private Google Meet as an OpenClaw voice transport. Keep spoken replies brief and natural. In agent mode, wait for OpenClaw consult results and speak them exactly. In bidi mode, answer directly and call ${REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME} for deeper reasoning, current information, or tools.`;
 const DEFAULT_GOOGLE_MEET_REALTIME_INTRO_MESSAGE = "Say exactly: I'm here and listening.";
 const DEFAULT_GOOGLE_MEET_CONFIG = {
 	enabled: true,
 	defaults: {},
 	preview: { enrollmentAcknowledged: false },
 	defaultTransport: "chrome",
-	defaultMode: "realtime",
+	defaultMode: "agent",
 	chrome: {
 		audioBackend: "blackhole-2ch",
 		audioFormat: DEFAULT_GOOGLE_MEET_CHROME_AUDIO_FORMAT,
+		audioBufferBytes: DEFAULT_GOOGLE_MEET_AUDIO_BUFFER_BYTES,
 		launch: true,
 		guestName: "OpenClaw Agent",
 		reuseExistingTab: true,
@@ -119,7 +135,9 @@ const DEFAULT_GOOGLE_MEET_CONFIG = {
 		postDtmfSpeechDelayMs: 5e3
 	},
 	realtime: {
+		strategy: "agent",
 		provider: "openai",
+		transcriptionProvider: "openai",
 		instructions: DEFAULT_GOOGLE_MEET_REALTIME_INSTRUCTIONS,
 		introMessage: DEFAULT_GOOGLE_MEET_REALTIME_INTRO_MESSAGE,
 		toolPolicy: "safe-read-only",
@@ -157,6 +175,9 @@ function readEnvString(env, keys) {
 		if (value) return value;
 	}
 }
+function normalizeStringAllowEmpty(value) {
+	return typeof value === "string" ? value.trim() : void 0;
+}
 function readEnvBoolean(env, keys) {
 	const normalized = normalizeOptionalLowercaseString(readEnvString(env, keys));
 	if (!normalized) return;
@@ -197,7 +218,12 @@ function resolveTransport$1(value, fallback) {
 }
 function resolveMode$1(value, fallback) {
 	const normalized = normalizeOptionalLowercaseString(value);
-	return normalized === "realtime" || normalized === "transcribe" ? normalized : fallback;
+	if (normalized === "realtime") return "agent";
+	return normalized === "agent" || normalized === "bidi" || normalized === "transcribe" ? normalized : fallback;
+}
+function resolveRealtimeStrategy(value, fallback) {
+	const normalized = normalizeOptionalLowercaseString(value);
+	return normalized === "agent" || normalized === "bidi" ? normalized : fallback;
 }
 function resolveChromeAudioFormat(value) {
 	switch (normalizeOptionalString(value)?.toLowerCase().replaceAll("_", "-")) {
@@ -213,11 +239,16 @@ function resolveChromeAudioFormat(value) {
 		default: return;
 	}
 }
-function defaultAudioInputCommand(format) {
-	return format === "g711-ulaw-8khz" ? LEGACY_GOOGLE_MEET_AUDIO_INPUT_COMMAND : DEFAULT_GOOGLE_MEET_AUDIO_INPUT_COMMAND;
+function resolveAudioBufferBytes(value, fallback) {
+	const number = resolveNumber(value, fallback);
+	if (!Number.isFinite(number) || number <= 0) return fallback;
+	return Math.max(SOX_MIN_BUFFER_BYTES, Math.trunc(number));
+}
+function defaultAudioInputCommand(format, bufferBytes) {
+	return withSoxBuffer(format === "g711-ulaw-8khz" ? LEGACY_GOOGLE_MEET_AUDIO_INPUT_COMMAND_BASE : DEFAULT_GOOGLE_MEET_AUDIO_INPUT_COMMAND_BASE, bufferBytes);
 }
-function defaultAudioOutputCommand(format) {
-	return format === "g711-ulaw-8khz" ? LEGACY_GOOGLE_MEET_AUDIO_OUTPUT_COMMAND : DEFAULT_GOOGLE_MEET_AUDIO_OUTPUT_COMMAND;
+function defaultAudioOutputCommand(format, bufferBytes) {
+	return withSoxBuffer(format === "g711-ulaw-8khz" ? LEGACY_GOOGLE_MEET_AUDIO_OUTPUT_COMMAND_BASE : DEFAULT_GOOGLE_MEET_AUDIO_OUTPUT_COMMAND_BASE, bufferBytes);
 }
 function resolveGoogleMeetConfig(input) {
 	return resolveGoogleMeetConfigWithEnv(input);
@@ -231,10 +262,13 @@ function resolveGoogleMeetConfigWithEnv(input, env = process.env) {
 	const configuredAudioOutputCommand = resolveStringArray(chrome.audioOutputCommand);
 	const hasCustomAudioCommand = configuredAudioInputCommand !== void 0 || configuredAudioOutputCommand !== void 0;
 	const audioFormat = resolveChromeAudioFormat(chrome.audioFormat) ?? (hasCustomAudioCommand ? "g711-ulaw-8khz" : DEFAULT_GOOGLE_MEET_CONFIG.chrome.audioFormat);
+	const audioBufferBytes = resolveAudioBufferBytes(chrome.audioBufferBytes, DEFAULT_GOOGLE_MEET_CONFIG.chrome.audioBufferBytes);
 	const chromeNode = asRecord$3(raw.chromeNode);
 	const twilio = asRecord$3(raw.twilio);
 	const voiceCall = asRecord$3(raw.voiceCall);
 	const realtime = asRecord$3(raw.realtime);
+	const realtimeProvider = normalizeOptionalString(realtime.provider);
+	const resolvedRealtimeProvider = realtimeProvider ?? DEFAULT_GOOGLE_MEET_CONFIG.realtime.provider;
 	const oauth = asRecord$3(raw.oauth);
 	const auth = asRecord$3(raw.auth);
 	return {
@@ -246,6 +280,7 @@ function resolveGoogleMeetConfigWithEnv(input, env = process.env) {
 		chrome: {
 			audioBackend: "blackhole-2ch",
 			audioFormat,
+			audioBufferBytes,
 			launch: resolveBoolean(chrome.launch, DEFAULT_GOOGLE_MEET_CONFIG.chrome.launch),
 			browserProfile: normalizeOptionalString(chrome.browserProfile),
 			guestName: normalizeOptionalString(chrome.guestName) ?? DEFAULT_GOOGLE_MEET_CONFIG.chrome.guestName,
@@ -253,8 +288,8 @@ function resolveGoogleMeetConfigWithEnv(input, env = process.env) {
 			autoJoin: resolveBoolean(chrome.autoJoin, DEFAULT_GOOGLE_MEET_CONFIG.chrome.autoJoin),
 			joinTimeoutMs: resolveNumber(chrome.joinTimeoutMs, DEFAULT_GOOGLE_MEET_CONFIG.chrome.joinTimeoutMs),
 			waitForInCallMs: resolveNumber(chrome.waitForInCallMs, DEFAULT_GOOGLE_MEET_CONFIG.chrome.waitForInCallMs),
-			audioInputCommand: configuredAudioInputCommand ?? [...defaultAudioInputCommand(audioFormat)],
-			audioOutputCommand: configuredAudioOutputCommand ?? [...defaultAudioOutputCommand(audioFormat)],
+			audioInputCommand: configuredAudioInputCommand ?? defaultAudioInputCommand(audioFormat, audioBufferBytes),
+			audioOutputCommand: configuredAudioOutputCommand ?? defaultAudioOutputCommand(audioFormat, audioBufferBytes),
 			bargeInInputCommand: resolveStringArray(chrome.bargeInInputCommand),
 			bargeInRmsThreshold: resolveNumber(chrome.bargeInRmsThreshold, DEFAULT_GOOGLE_MEET_CONFIG.chrome.bargeInRmsThreshold),
 			bargeInPeakThreshold: resolveNumber(chrome.bargeInPeakThreshold, DEFAULT_GOOGLE_MEET_CONFIG.chrome.bargeInPeakThreshold),
@@ -278,10 +313,13 @@ function resolveGoogleMeetConfigWithEnv(input, env = process.env) {
 			introMessage: normalizeOptionalString(voiceCall.introMessage)
 		},
 		realtime: {
-			provider: normalizeOptionalString(realtime.provider) ?? DEFAULT_GOOGLE_MEET_CONFIG.realtime.provider,
+			strategy: resolveRealtimeStrategy(realtime.strategy, DEFAULT_GOOGLE_MEET_CONFIG.realtime.strategy),
+			provider: resolvedRealtimeProvider,
+			transcriptionProvider: normalizeOptionalString(realtime.transcriptionProvider) ?? (realtimeProvider && realtimeProvider !== "google" ? resolvedRealtimeProvider : DEFAULT_GOOGLE_MEET_CONFIG.realtime.transcriptionProvider),
+			voiceProvider: normalizeOptionalString(realtime.voiceProvider),
 			model: normalizeOptionalString(realtime.model) ?? DEFAULT_GOOGLE_MEET_CONFIG.realtime.model,
 			instructions: normalizeOptionalString(realtime.instructions) ?? DEFAULT_GOOGLE_MEET_CONFIG.realtime.instructions,
-			introMessage: normalizeOptionalString(realtime.introMessage) ?? DEFAULT_GOOGLE_MEET_CONFIG.realtime.introMessage,
+			introMessage: normalizeStringAllowEmpty(realtime.introMessage) ?? DEFAULT_GOOGLE_MEET_CONFIG.realtime.introMessage,
 			agentId: normalizeOptionalString(realtime.agentId),
 			toolPolicy: resolveRealtimeVoiceAgentConsultToolPolicy(realtime.toolPolicy, DEFAULT_GOOGLE_MEET_CONFIG.realtime.toolPolicy),
 			providers: resolveProvidersConfig(realtime.providers)
@@ -320,7 +358,8 @@ function submitGoogleMeetConsultWorkingResponse(session, callId) {
 }
 async function consultOpenClawAgentForGoogleMeet(params) {
 	const agentId = normalizeAgentId(params.config.realtime.agentId);
-	const sessionKey = `agent:${agentId}:google-meet:${params.meetingSessionId}`;
+	const requesterSessionKey = normalizeOptionalString(params.requesterSessionKey) ?? `agent:${agentId}:main`;
+	const sessionKey = `agent:${agentId}:subagent:google-meet:${params.meetingSessionId}`;
 	return await consultRealtimeVoiceAgent({
 		cfg: params.fullConfig,
 		agentRuntime: params.runtime.agent,
@@ -330,6 +369,8 @@ async function consultOpenClawAgentForGoogleMeet(params) {
 		messageProvider: "google-meet",
 		lane: "google-meet",
 		runIdPrefix: `google-meet:${params.meetingSessionId}`,
+		spawnedBy: requesterSessionKey,
+		contextMode: "fork",
 		args: params.args,
 		transcript: params.transcript,
 		surface: "a private Google Meet",
@@ -362,7 +403,9 @@ function getGoogleMeetRealtimeTranscriptHealth(transcript) {
 		recentRealtimeTranscript: transcript.slice(-5)
 	};
 }
+const GOOGLE_MEET_OUTPUT_ECHO_SUPPRESSION_TAIL_MS = 3e3;
 function recordGoogleMeetRealtimeEvent(events, event) {
+	if (event.direction === "client" && event.type === "input_audio_buffer.append") return;
 	events.push({
 		at: (/* @__PURE__ */ new Date()).toISOString(),
 		...event
@@ -401,12 +444,88 @@ function readPcm16Stats(audio) {
 		peak
 	};
 }
+function normalizeTranscriptForEchoMatch(text) {
+	return text.toLowerCase().replace(/['’]/g, "").replace(/[^a-z0-9]+/g, " ").trim().split(/\s+/).filter((token) => token.length > 1);
+}
+function hasMeaningfulEchoOverlap(userTokens, assistantTokens) {
+	if (userTokens.length < 4 || assistantTokens.length < 4) return false;
+	const uniqueUserTokens = [...new Set(userTokens)];
+	if (uniqueUserTokens.length < 4) return false;
+	const assistantTokenSet = new Set(assistantTokens);
+	return uniqueUserTokens.filter((token) => assistantTokenSet.has(token)).length / uniqueUserTokens.length >= .58;
+}
+function isGoogleMeetLikelyAssistantEchoTranscript(params) {
+	const userTokens = normalizeTranscriptForEchoMatch(params.text);
+	if (userTokens.length < 4) return false;
+	const nowMs = params.nowMs ?? Date.now();
+	const recentAssistantText = params.transcript.filter((entry) => {
+		if (entry.role !== "assistant") return false;
+		const at = Date.parse(entry.at);
+		return Number.isFinite(at) && nowMs - at <= 45e3;
+	}).slice(-6).map((entry) => entry.text).join(" ");
+	if (!recentAssistantText.trim()) return false;
+	const userNormalized = userTokens.join(" ");
+	const assistantTokens = normalizeTranscriptForEchoMatch(recentAssistantText);
+	const assistantNormalized = assistantTokens.join(" ");
+	return userNormalized.length >= 18 && assistantNormalized.includes(userNormalized) || assistantNormalized.length >= 18 && userNormalized.includes(assistantNormalized) || hasMeaningfulEchoOverlap(userTokens, assistantTokens);
+}
+function extendGoogleMeetOutputEchoSuppression(params) {
+	const bytesPerMs = params.audioFormat === "g711-ulaw-8khz" ? 8 : 48;
+	const durationMs = Math.ceil(params.audio.byteLength / bytesPerMs);
+	const playbackEndMs = Math.max(params.nowMs, params.lastOutputPlayableUntilMs) + durationMs;
+	return {
+		durationMs,
+		lastOutputPlayableUntilMs: playbackEndMs,
+		suppressInputUntilMs: Math.max(params.suppressInputUntilMs, playbackEndMs + GOOGLE_MEET_OUTPUT_ECHO_SUPPRESSION_TAIL_MS)
+	};
+}
 function resolveGoogleMeetRealtimeAudioFormat(config) {
 	return config.chrome.audioFormat === "g711-ulaw-8khz" ? REALTIME_VOICE_AUDIO_FORMAT_G711_ULAW_8KHZ : REALTIME_VOICE_AUDIO_FORMAT_PCM16_24KHZ;
 }
+function convertGoogleMeetBridgeAudioForStt(audio, config) {
+	if (config.chrome.audioFormat === "g711-ulaw-8khz") return audio;
+	return convertPcmToMulaw8k(audio, 24e3);
+}
+function convertGoogleMeetTtsAudioForBridge(audio, sampleRate, config, outputFormat) {
+	const sourceFormat = sourceTelephonyTtsFormat(outputFormat);
+	if (config.chrome.audioFormat === "g711-ulaw-8khz" && sourceFormat === "mulaw" && sampleRate === 8e3) return audio;
+	const pcm = decodeGoogleMeetTelephonyTtsAudio(audio, sourceFormat);
+	return config.chrome.audioFormat === "g711-ulaw-8khz" ? convertPcmToMulaw8k(pcm, sampleRate) : resamplePcm(pcm, sampleRate, 24e3);
+}
+function sourceTelephonyTtsFormat(outputFormat) {
+	const normalized = outputFormat?.trim().toLowerCase().replaceAll("_", "-") ?? "";
+	if (!normalized || normalized === "pcm" || normalized.startsWith("pcm-") || normalized.includes("pcm16") || normalized.includes("16bit-mono-pcm")) return "pcm";
+	if (normalized === "mulaw" || normalized === "ulaw" || normalized.includes("mu-law") || normalized.includes("mulaw") || normalized.includes("ulaw")) return "mulaw";
+	if (normalized === "alaw" || normalized.includes("a-law") || normalized.includes("alaw")) return "alaw";
+	throw new Error(`Unsupported telephony TTS output format for Google Meet: ${outputFormat}`);
+}
+function decodeGoogleMeetTelephonyTtsAudio(audio, sourceFormat) {
+	switch (sourceFormat) {
+		case "pcm": return audio;
+		case "mulaw": return mulawToPcm(audio);
+		case "alaw": return alawToPcm(audio);
+	}
+	return unsupportedGoogleMeetTelephonyTtsFormat(sourceFormat);
+}
+function unsupportedGoogleMeetTelephonyTtsFormat(_format) {
+	throw new Error("Unsupported telephony TTS output format for Google Meet");
+}
+function alawToPcm(alaw) {
+	const pcm = Buffer.alloc(alaw.length * 2);
+	for (let index = 0; index < alaw.length; index += 1) pcm.writeInt16LE(alawByteToLinear(alaw[index] ?? 0), index * 2);
+	return pcm;
+}
+function alawByteToLinear(value) {
+	const aLaw = value ^ 85;
+	const sign = aLaw & 128;
+	const exponent = (aLaw & 112) >> 4;
+	const mantissa = aLaw & 15;
+	let sample = exponent === 0 ? (mantissa << 4) + 8 : (mantissa << 4) + 264 << exponent - 1;
+	return sign ? sample : -sample;
+}
 function resolveGoogleMeetRealtimeProvider(params) {
 	return resolveConfiguredRealtimeVoiceProvider({
-		configuredProviderId: params.config.realtime.provider,
+		configuredProviderId: params.config.realtime.voiceProvider ?? params.config.realtime.provider,
 		providerConfigs: params.config.realtime.providers,
 		cfg: params.fullConfig,
 		providers: params.providers,
@@ -414,6 +533,322 @@ function resolveGoogleMeetRealtimeProvider(params) {
 		noRegisteredProviderMessage: "No configured realtime voice provider registered"
 	});
 }
+function resolveGoogleMeetRealtimeTranscriptionProvider(params) {
+	const providers = params.providers ?? listRealtimeTranscriptionProviders(params.fullConfig);
+	if (providers.length === 0) throw new Error("No configured realtime transcription provider registered");
+	const providerId = params.config.realtime.transcriptionProvider ?? params.config.realtime.provider;
+	const provider = (providerId ? params.providers?.find((entry) => entry.id === providerId || entry.aliases?.includes(providerId)) ?? getRealtimeTranscriptionProvider(providerId, params.fullConfig) : void 0) ?? providers[0];
+	if (!provider) throw new Error("No configured realtime transcription provider registered");
+	const rawConfig = providerId ? params.config.realtime.providers[providerId] ?? params.config.realtime.providers[provider.id] ?? {} : params.config.realtime.providers[provider.id] ?? {};
+	const providerConfig = provider.resolveConfig ? provider.resolveConfig({
+		cfg: params.fullConfig,
+		rawConfig
+	}) : rawConfig;
+	if (!provider.isConfigured({
+		cfg: params.fullConfig,
+		providerConfig
+	})) throw new Error(`Realtime transcription provider "${provider.id}" is not configured`);
+	return {
+		provider,
+		providerConfig
+	};
+}
+function buildGoogleMeetSpeakExactUserMessage(text) {
+	return ["Speak this exact OpenClaw answer to the meeting, without adding, removing, or rephrasing words.", `Answer: ${JSON.stringify(text)}`].join("\n");
+}
+function readLogString(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function formatLogValue(value) {
+	return value?.replace(/\s+/g, "_").slice(0, 180) || "unknown";
+}
+function resolveProviderModelForLog(params) {
+	return readLogString(params.providerConfig.model) ?? readLogString(params.providerConfig.modelId) ?? readLogString(params.fallbackModel) ?? readLogString(params.provider.defaultModel) ?? "provider-default";
+}
+function formatGoogleMeetRealtimeVoiceModelLog(params) {
+	return [
+		`[google-meet] realtime voice bridge starting: strategy=${formatLogValue(params.strategy)}`,
+		`provider=${formatLogValue(params.provider.id)}`,
+		`model=${formatLogValue(resolveProviderModelForLog({
+			provider: params.provider,
+			providerConfig: params.providerConfig,
+			fallbackModel: params.fallbackModel
+		}))}`,
+		`audioFormat=${formatLogValue(params.audioFormat)}`
+	].join(" ");
+}
+function formatGoogleMeetAgentAudioModelLog(params) {
+	return [
+		`[google-meet] agent audio bridge starting: transcriptionProvider=${formatLogValue(params.provider.id)}`,
+		`transcriptionModel=${formatLogValue(resolveProviderModelForLog({
+			provider: params.provider,
+			providerConfig: params.providerConfig
+		}))}`,
+		"tts=telephony",
+		`audioFormat=${formatLogValue(params.audioFormat)}`
+	].join(" ");
+}
+function formatGoogleMeetAgentTtsResultLog(prefix, result) {
+	return [
+		`[google-meet] ${prefix} TTS: provider=${formatLogValue(result.provider)}`,
+		`model=${formatLogValue(result.providerModel)}`,
+		`voice=${formatLogValue(result.providerVoice)}`,
+		`outputFormat=${formatLogValue(result.outputFormat)}`,
+		`sampleRate=${result.sampleRate ?? "unknown"}`,
+		...result.fallbackFrom ? [`fallbackFrom=${formatLogValue(result.fallbackFrom)}`] : []
+	].join(" ");
+}
+function normalizeGoogleMeetTtsPromptText$1(text) {
+	const trimmed = text?.trim();
+	if (!trimmed) return;
+	const sayExactly = trimmed.match(/^say exactly:\s*(?<text>.+)$/is)?.groups?.text?.trim();
+	if (sayExactly) return sayExactly.replace(/^["']|["']$/g, "").trim() || trimmed;
+	return trimmed;
+}
+async function startCommandAgentAudioBridge(params) {
+	const input = splitCommand$1(params.inputCommand);
+	const output = splitCommand$1(params.outputCommand);
+	const spawnFn = params.spawn ?? ((command, args, options) => spawn(command, args, options));
+	const outputProcess = spawnFn(output.command, output.args, { stdio: [
+		"pipe",
+		"ignore",
+		"pipe"
+	] });
+	const inputProcess = spawnFn(input.command, input.args, { stdio: [
+		"ignore",
+		"pipe",
+		"pipe"
+	] });
+	let stopped = false;
+	let sttSession = null;
+	let realtimeReady = false;
+	let lastInputAt;
+	let lastOutputAt;
+	let lastInputBytes = 0;
+	let lastOutputBytes = 0;
+	let suppressedInputBytes = 0;
+	let lastSuppressedInputAt;
+	let suppressInputUntil = 0;
+	let lastOutputPlayableUntilMs = 0;
+	let agentConsultActive = false;
+	let pendingAgentQuestion;
+	let agentConsultDebounceTimer;
+	let ttsQueue = Promise.resolve();
+	const transcript = [];
+	const resolved = resolveGoogleMeetRealtimeTranscriptionProvider({
+		config: params.config,
+		fullConfig: params.fullConfig,
+		providers: params.providers
+	});
+	params.logger.info(formatGoogleMeetAgentAudioModelLog({
+		provider: resolved.provider,
+		providerConfig: resolved.providerConfig,
+		audioFormat: params.config.chrome.audioFormat
+	}));
+	const terminateProcess = (proc, signal = "SIGTERM") => {
+		if (proc.killed && signal !== "SIGKILL") return;
+		let exited = false;
+		proc.on("exit", () => {
+			exited = true;
+		});
+		try {
+			proc.kill(signal);
+		} catch {
+			return;
+		}
+		if (signal === "SIGKILL") return;
+		setTimeout(() => {
+			if (!exited) try {
+				proc.kill("SIGKILL");
+			} catch {}
+		}, 1e3).unref?.();
+	};
+	const stop = async () => {
+		if (stopped) return;
+		stopped = true;
+		if (agentConsultDebounceTimer) {
+			clearTimeout(agentConsultDebounceTimer);
+			agentConsultDebounceTimer = void 0;
+		}
+		try {
+			sttSession?.close();
+		} catch (error) {
+			params.logger.debug?.(`[google-meet] agent transcription bridge close ignored: ${formatErrorMessage(error)}`);
+		}
+		terminateProcess(inputProcess);
+		terminateProcess(outputProcess);
+	};
+	const fail = (label) => (error) => {
+		params.logger.warn(`[google-meet] ${label} failed: ${formatErrorMessage(error)}`);
+		stop();
+	};
+	inputProcess.on("error", fail("audio input command"));
+	inputProcess.on("exit", (code, signal) => {
+		if (!stopped) {
+			params.logger.warn(`[google-meet] audio input command exited (${code ?? signal ?? "done"})`);
+			stop();
+		}
+	});
+	inputProcess.stderr?.on("data", (chunk) => {
+		params.logger.debug?.(`[google-meet] audio input: ${String(chunk).trim()}`);
+	});
+	outputProcess.on("error", fail("audio output command"));
+	outputProcess.stdin?.on?.("error", fail("audio output command"));
+	outputProcess.on("exit", (code, signal) => {
+		if (!stopped) {
+			params.logger.warn(`[google-meet] audio output command exited (${code ?? signal ?? "done"})`);
+			stop();
+		}
+	});
+	outputProcess.stderr?.on("data", (chunk) => {
+		params.logger.debug?.(`[google-meet] audio output: ${String(chunk).trim()}`);
+	});
+	const writeOutputAudio = (audio) => {
+		const suppression = extendGoogleMeetOutputEchoSuppression({
+			audio,
+			audioFormat: params.config.chrome.audioFormat,
+			nowMs: Date.now(),
+			lastOutputPlayableUntilMs,
+			suppressInputUntilMs: suppressInputUntil
+		});
+		suppressInputUntil = suppression.suppressInputUntilMs;
+		lastOutputPlayableUntilMs = suppression.lastOutputPlayableUntilMs;
+		lastOutputAt = (/* @__PURE__ */ new Date()).toISOString();
+		lastOutputBytes += audio.byteLength;
+		try {
+			outputProcess.stdin?.write(audio);
+		} catch (error) {
+			fail("audio output command")(error);
+		}
+	};
+	const enqueueSpeakText = (text) => {
+		const normalized = normalizeGoogleMeetTtsPromptText$1(text);
+		if (!normalized || stopped) return;
+		ttsQueue = ttsQueue.then(async () => {
+			if (stopped) return;
+			recordGoogleMeetRealtimeTranscript(transcript, "assistant", normalized);
+			params.logger.info(`[google-meet] agent assistant: ${normalized}`);
+			const result = await params.runtime.tts.textToSpeechTelephony({
+				text: normalized,
+				cfg: params.fullConfig
+			});
+			if (!result.success || !result.audioBuffer || !result.sampleRate) throw new Error(result.error ?? "TTS conversion failed");
+			params.logger.info(formatGoogleMeetAgentTtsResultLog("agent", result));
+			writeOutputAudio(convertGoogleMeetTtsAudioForBridge(result.audioBuffer, result.sampleRate, params.config, result.outputFormat));
+		}).catch((error) => {
+			params.logger.warn(`[google-meet] agent TTS failed: ${formatErrorMessage(error)}`);
+		});
+	};
+	const runAgentConsultForUserTranscript = async (question) => {
+		const trimmed = question.trim();
+		if (!trimmed || stopped) return;
+		if (agentConsultActive) {
+			pendingAgentQuestion = trimmed;
+			return;
+		}
+		agentConsultActive = true;
+		let nextQuestion = trimmed;
+		try {
+			while (nextQuestion) {
+				if (stopped) return;
+				const currentQuestion = nextQuestion;
+				pendingAgentQuestion = void 0;
+				params.logger.info(`[google-meet] agent consult: ${currentQuestion}`);
+				enqueueSpeakText((await consultOpenClawAgentForGoogleMeet({
+					config: params.config,
+					fullConfig: params.fullConfig,
+					runtime: params.runtime,
+					logger: params.logger,
+					meetingSessionId: params.meetingSessionId,
+					requesterSessionKey: params.requesterSessionKey,
+					args: {
+						question: currentQuestion,
+						responseStyle: "Brief, natural spoken answer for a live meeting."
+					},
+					transcript
+				})).text);
+				nextQuestion = pendingAgentQuestion;
+			}
+		} catch (error) {
+			params.logger.warn(`[google-meet] agent consult failed: ${formatErrorMessage(error)}`);
+			enqueueSpeakText("I hit an error while checking that. Please try again.");
+		} finally {
+			agentConsultActive = false;
+			const queuedQuestion = pendingAgentQuestion;
+			pendingAgentQuestion = void 0;
+			if (queuedQuestion && !stopped) runAgentConsultForUserTranscript(queuedQuestion);
+		}
+	};
+	const enqueueAgentConsultForUserTranscript = (question) => {
+		const trimmed = question.trim();
+		if (!trimmed || stopped) return;
+		pendingAgentQuestion = pendingAgentQuestion ? `${pendingAgentQuestion}\n${trimmed}` : trimmed;
+		if (agentConsultDebounceTimer) clearTimeout(agentConsultDebounceTimer);
+		agentConsultDebounceTimer = setTimeout(() => {
+			agentConsultDebounceTimer = void 0;
+			const queuedQuestion = pendingAgentQuestion;
+			pendingAgentQuestion = void 0;
+			if (queuedQuestion && !stopped) runAgentConsultForUserTranscript(queuedQuestion);
+		}, 900);
+		agentConsultDebounceTimer.unref?.();
+	};
+	sttSession = resolved.provider.createSession({
+		providerConfig: resolved.providerConfig,
+		onTranscript: (text) => {
+			const trimmed = text.trim();
+			if (!trimmed || stopped) return;
+			recordGoogleMeetRealtimeTranscript(transcript, "user", trimmed);
+			params.logger.info(`[google-meet] agent user: ${trimmed}`);
+			if (isGoogleMeetLikelyAssistantEchoTranscript({
+				transcript,
+				text: trimmed
+			})) {
+				params.logger.info(`[google-meet] agent ignored assistant echo transcript: ${trimmed}`);
+				return;
+			}
+			enqueueAgentConsultForUserTranscript(trimmed);
+		},
+		onError: (error) => {
+			params.logger.warn(`[google-meet] agent transcription bridge failed: ${formatErrorMessage(error)}`);
+			stop();
+		}
+	});
+	await sttSession.connect();
+	realtimeReady = true;
+	inputProcess.stdout?.on("data", (chunk) => {
+		if (stopped) return;
+		const audio = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+		if (Date.now() < suppressInputUntil) {
+			lastSuppressedInputAt = (/* @__PURE__ */ new Date()).toISOString();
+			suppressedInputBytes += audio.byteLength;
+			return;
+		}
+		lastInputAt = (/* @__PURE__ */ new Date()).toISOString();
+		lastInputBytes += audio.byteLength;
+		sttSession?.sendAudio(convertGoogleMeetBridgeAudioForStt(audio, params.config));
+	});
+	return {
+		providerId: resolved.provider.id,
+		inputCommand: params.inputCommand,
+		outputCommand: params.outputCommand,
+		speak: enqueueSpeakText,
+		getHealth: () => ({
+			providerConnected: sttSession?.isConnected() ?? false,
+			realtimeReady,
+			audioInputActive: lastInputBytes > 0,
+			audioOutputActive: lastOutputBytes > 0,
+			lastInputAt,
+			lastOutputAt,
+			lastSuppressedInputAt,
+			lastInputBytes,
+			lastOutputBytes,
+			suppressedInputBytes,
+			...getGoogleMeetRealtimeTranscriptHealth(transcript),
+			bridgeClosed: stopped
+		}),
+		stop
+	};
+}
 async function startCommandRealtimeAudioBridge(params) {
 	const input = splitCommand$1(params.inputCommand);
 	const output = splitCommand$1(params.outputCommand);
@@ -444,12 +879,17 @@ async function startCommandRealtimeAudioBridge(params) {
 	let lastOutputAtMs = 0;
 	let lastOutputPlayableUntilMs = 0;
 	let bargeInInputProcess;
+	let agentConsultDebounceTimer;
 	const suppressInputForOutput = (audio) => {
-		const bytesPerMs = params.config.chrome.audioFormat === "g711-ulaw-8khz" ? 8 : 48;
-		const durationMs = Math.ceil(audio.byteLength / bytesPerMs);
-		const until = Date.now() + durationMs + 900;
-		suppressInputUntil = Math.max(suppressInputUntil, until);
-		lastOutputPlayableUntilMs = Math.max(lastOutputPlayableUntilMs, until);
+		const suppression = extendGoogleMeetOutputEchoSuppression({
+			audio,
+			audioFormat: params.config.chrome.audioFormat,
+			nowMs: Date.now(),
+			lastOutputPlayableUntilMs,
+			suppressInputUntilMs: suppressInputUntil
+		});
+		suppressInputUntil = suppression.suppressInputUntilMs;
+		lastOutputPlayableUntilMs = suppression.lastOutputPlayableUntilMs;
 	};
 	const terminateProcess = (proc, signal = "SIGTERM") => {
 		if (proc.killed && signal !== "SIGKILL") return;
@@ -472,6 +912,10 @@ async function startCommandRealtimeAudioBridge(params) {
 	const stop = async () => {
 		if (stopped) return;
 		stopped = true;
+		if (agentConsultDebounceTimer) {
+			clearTimeout(agentConsultDebounceTimer);
+			agentConsultDebounceTimer = void 0;
+		}
 		try {
 			bridge?.close();
 		} catch (error) {
@@ -490,6 +934,10 @@ async function startCommandRealtimeAudioBridge(params) {
 			if (proc !== outputProcess) return;
 			fail("audio output command")(error);
 		});
+		proc.stdin?.on?.("error", (error) => {
+			if (proc !== outputProcess) return;
+			fail("audio output command")(error);
+		});
 		proc.on("exit", (code, signal) => {
 			if (proc !== outputProcess) return;
 			if (!stopped) {
@@ -513,6 +961,13 @@ async function startCommandRealtimeAudioBridge(params) {
 		params.logger.debug?.(`[google-meet] cleared realtime audio output buffer by restarting playback command`);
 		terminateProcess(previousOutput, "SIGKILL");
 	};
+	const writeOutputAudio = (audio) => {
+		try {
+			outputProcess.stdin?.write(audio);
+		} catch (error) {
+			fail("audio output command")(error);
+		}
+	};
 	const startHumanBargeInMonitor = () => {
 		const commandArgv = params.config.chrome.bargeInInputCommand;
 		if (!commandArgv) return;
@@ -563,17 +1018,82 @@ async function startCommandRealtimeAudioBridge(params) {
 		fullConfig: params.fullConfig,
 		providers: params.providers
 	});
+	const strategy = params.config.realtime.strategy;
+	params.logger.info(formatGoogleMeetRealtimeVoiceModelLog({
+		strategy,
+		provider: resolved.provider,
+		providerConfig: resolved.providerConfig,
+		fallbackModel: params.config.realtime.model,
+		audioFormat: params.config.chrome.audioFormat
+	}));
 	const transcript = [];
 	const realtimeEvents = [];
+	let agentConsultActive = false;
+	let pendingAgentQuestion;
+	const enqueueAgentConsultForUserTranscript = (question) => {
+		const trimmed = question.trim();
+		if (!trimmed || stopped) return;
+		pendingAgentQuestion = pendingAgentQuestion ? `${pendingAgentQuestion}\n${trimmed}` : trimmed;
+		if (agentConsultDebounceTimer) clearTimeout(agentConsultDebounceTimer);
+		agentConsultDebounceTimer = setTimeout(() => {
+			agentConsultDebounceTimer = void 0;
+			const queuedQuestion = pendingAgentQuestion;
+			pendingAgentQuestion = void 0;
+			if (queuedQuestion && !stopped) runAgentConsultForUserTranscript(queuedQuestion);
+		}, 900);
+		agentConsultDebounceTimer.unref?.();
+	};
+	const runAgentConsultForUserTranscript = async (question) => {
+		const trimmed = question.trim();
+		if (!trimmed || stopped) return;
+		if (agentConsultActive) {
+			pendingAgentQuestion = trimmed;
+			return;
+		}
+		agentConsultActive = true;
+		let nextQuestion = trimmed;
+		try {
+			while (nextQuestion) {
+				if (stopped) return;
+				const currentQuestion = nextQuestion;
+				pendingAgentQuestion = void 0;
+				params.logger.info(`[google-meet] realtime agent consult: ${currentQuestion}`);
+				const result = await consultOpenClawAgentForGoogleMeet({
+					config: params.config,
+					fullConfig: params.fullConfig,
+					runtime: params.runtime,
+					logger: params.logger,
+					meetingSessionId: params.meetingSessionId,
+					requesterSessionKey: params.requesterSessionKey,
+					args: {
+						question: currentQuestion,
+						responseStyle: "Brief, natural spoken answer for a live meeting."
+					},
+					transcript
+				});
+				if (!stopped && result.text.trim()) bridge?.sendUserMessage(buildGoogleMeetSpeakExactUserMessage(result.text.trim()));
+				nextQuestion = pendingAgentQuestion;
+			}
+		} catch (error) {
+			params.logger.warn(`[google-meet] realtime agent consult failed: ${formatErrorMessage(error)}`);
+			if (!stopped) bridge?.sendUserMessage(buildGoogleMeetSpeakExactUserMessage("I hit an error while checking that. Please try again."));
+		} finally {
+			agentConsultActive = false;
+			const queuedQuestion = pendingAgentQuestion;
+			pendingAgentQuestion = void 0;
+			if (queuedQuestion && !stopped) runAgentConsultForUserTranscript(queuedQuestion);
+		}
+	};
 	bridge = createRealtimeVoiceBridgeSession({
 		provider: resolved.provider,
 		providerConfig: resolved.providerConfig,
 		audioFormat: resolveGoogleMeetRealtimeAudioFormat(params.config),
 		instructions: params.config.realtime.instructions,
 		initialGreetingInstructions: params.config.realtime.introMessage,
+		autoRespondToAudio: strategy === "bidi",
 		triggerGreetingOnReady: false,
 		markStrategy: "ack-immediately",
-		tools: resolveGoogleMeetRealtimeTools(params.config.realtime.toolPolicy),
+		tools: strategy === "bidi" ? resolveGoogleMeetRealtimeTools(params.config.realtime.toolPolicy) : [],
 		audioSink: {
 			isOpen: () => !stopped,
 			sendAudio: (audio) => {
@@ -581,7 +1101,7 @@ async function startCommandRealtimeAudioBridge(params) {
 				lastOutputAt = (/* @__PURE__ */ new Date()).toISOString();
 				lastOutputBytes += audio.byteLength;
 				suppressInputForOutput(audio);
-				outputProcess.stdin?.write(audio);
+				writeOutputAudio(audio);
 			},
 			clearAudio: clearOutputPlayback
 		},
@@ -589,16 +1109,30 @@ async function startCommandRealtimeAudioBridge(params) {
 			if (isFinal) {
 				recordGoogleMeetRealtimeTranscript(transcript, role, text);
 				params.logger.info(`[google-meet] realtime ${role}: ${text}`);
+				if (role === "user" && strategy === "agent") {
+					if (isGoogleMeetLikelyAssistantEchoTranscript({
+						transcript,
+						text
+					})) {
+						params.logger.info(`[google-meet] realtime ignored assistant echo transcript: ${text}`);
+						return;
+					}
+					enqueueAgentConsultForUserTranscript(text);
+				}
 			}
 		},
 		onEvent: (event) => {
 			recordGoogleMeetRealtimeEvent(realtimeEvents, event);
-			if (event.type === "error" || event.type === "response.done") {
+			if (event.type === "error" || event.type === "response.done" || event.type === "input_audio_buffer.speech_started" || event.type === "input_audio_buffer.speech_stopped" || event.type === "conversation.item.input_audio_transcription.completed" || event.type === "conversation.item.input_audio_transcription.failed") {
 				const detail = event.detail ? ` ${event.detail}` : "";
 				params.logger.info(`[google-meet] realtime ${event.direction}:${event.type}${detail}`);
 			}
 		},
 		onToolCall: (event, session) => {
+			if (strategy !== "bidi") {
+				session.submitToolResult(event.callId || event.itemId, { error: `Tool "${event.name}" is only available in bidi realtime strategy` });
+				return;
+			}
 			if (event.name !== GOOGLE_MEET_AGENT_CONSULT_TOOL_NAME) {
 				session.submitToolResult(event.callId || event.itemId, { error: `Tool "${event.name}" not available` });
 				return;
@@ -610,6 +1144,7 @@ async function startCommandRealtimeAudioBridge(params) {
 				runtime: params.runtime,
 				logger: params.logger,
 				meetingSessionId: params.meetingSessionId,
+				requesterSessionKey: params.requesterSessionKey,
 				args: event.args,
 				transcript
 			}).then((result) => {
@@ -677,6 +1212,252 @@ function asRecord$2(value) {
 function readString$1(value) {
 	return typeof value === "string" && value.trim() ? value : void 0;
 }
+function normalizeGoogleMeetTtsPromptText(text) {
+	const trimmed = text?.trim();
+	if (!trimmed) return;
+	const sayExactly = trimmed.match(/^say exactly:\s*(?<text>.+)$/is)?.groups?.text?.trim();
+	if (sayExactly) return sayExactly.replace(/^["']|["']$/g, "").trim() || trimmed;
+	return trimmed;
+}
+async function startNodeAgentAudioBridge(params) {
+	let stopped = false;
+	let sttSession = null;
+	let realtimeReady = false;
+	let lastInputAt;
+	let lastOutputAt;
+	let lastInputBytes = 0;
+	let lastOutputBytes = 0;
+	let suppressedInputBytes = 0;
+	let lastSuppressedInputAt;
+	let suppressInputUntil = 0;
+	let lastOutputPlayableUntilMs = 0;
+	let consecutiveInputErrors = 0;
+	let lastInputError;
+	const resolved = resolveGoogleMeetRealtimeTranscriptionProvider({
+		config: params.config,
+		fullConfig: params.fullConfig,
+		providers: params.providers
+	});
+	params.logger.info(formatGoogleMeetAgentAudioModelLog({
+		provider: resolved.provider,
+		providerConfig: resolved.providerConfig,
+		audioFormat: params.config.chrome.audioFormat
+	}));
+	const transcript = [];
+	let agentConsultActive = false;
+	let pendingAgentQuestion;
+	let agentConsultDebounceTimer;
+	let ttsQueue = Promise.resolve();
+	const stop = async () => {
+		if (stopped) return;
+		stopped = true;
+		if (agentConsultDebounceTimer) {
+			clearTimeout(agentConsultDebounceTimer);
+			agentConsultDebounceTimer = void 0;
+		}
+		try {
+			sttSession?.close();
+		} catch (error) {
+			params.logger.debug?.(`[google-meet] node agent transcription bridge close ignored: ${formatErrorMessage(error)}`);
+		}
+		try {
+			await params.runtime.nodes.invoke({
+				nodeId: params.nodeId,
+				command: "googlemeet.chrome",
+				params: {
+					action: "stop",
+					bridgeId: params.bridgeId
+				},
+				timeoutMs: 5e3
+			});
+		} catch (error) {
+			params.logger.debug?.(`[google-meet] node audio bridge stop ignored: ${formatErrorMessage(error)}`);
+		}
+	};
+	const pushOutputAudio = async (audio) => {
+		const suppression = extendGoogleMeetOutputEchoSuppression({
+			audio,
+			audioFormat: params.config.chrome.audioFormat,
+			nowMs: Date.now(),
+			lastOutputPlayableUntilMs,
+			suppressInputUntilMs: suppressInputUntil
+		});
+		suppressInputUntil = suppression.suppressInputUntilMs;
+		lastOutputPlayableUntilMs = suppression.lastOutputPlayableUntilMs;
+		lastOutputAt = (/* @__PURE__ */ new Date()).toISOString();
+		lastOutputBytes += audio.byteLength;
+		await params.runtime.nodes.invoke({
+			nodeId: params.nodeId,
+			command: "googlemeet.chrome",
+			params: {
+				action: "pushAudio",
+				bridgeId: params.bridgeId,
+				base64: Buffer.from(audio).toString("base64")
+			},
+			timeoutMs: 5e3
+		});
+	};
+	const enqueueSpeakText = (text) => {
+		const normalized = normalizeGoogleMeetTtsPromptText(text);
+		if (!normalized || stopped) return;
+		ttsQueue = ttsQueue.then(async () => {
+			if (stopped) return;
+			recordGoogleMeetRealtimeTranscript(transcript, "assistant", normalized);
+			params.logger.info(`[google-meet] node agent assistant: ${normalized}`);
+			const result = await params.runtime.tts.textToSpeechTelephony({
+				text: normalized,
+				cfg: params.fullConfig
+			});
+			if (!result.success || !result.audioBuffer || !result.sampleRate) throw new Error(result.error ?? "TTS conversion failed");
+			params.logger.info(formatGoogleMeetAgentTtsResultLog("node agent", result));
+			await pushOutputAudio(convertGoogleMeetTtsAudioForBridge(result.audioBuffer, result.sampleRate, params.config, result.outputFormat));
+		}).catch((error) => {
+			params.logger.warn(`[google-meet] node agent TTS failed: ${formatErrorMessage(error)}`);
+		});
+	};
+	const runAgentConsultForUserTranscript = async (question) => {
+		const trimmed = question.trim();
+		if (!trimmed || stopped) return;
+		if (agentConsultActive) {
+			pendingAgentQuestion = trimmed;
+			return;
+		}
+		agentConsultActive = true;
+		let nextQuestion = trimmed;
+		try {
+			while (nextQuestion) {
+				if (stopped) return;
+				const currentQuestion = nextQuestion;
+				pendingAgentQuestion = void 0;
+				params.logger.info(`[google-meet] node agent consult: ${currentQuestion}`);
+				enqueueSpeakText((await consultOpenClawAgentForGoogleMeet({
+					config: params.config,
+					fullConfig: params.fullConfig,
+					runtime: params.runtime,
+					logger: params.logger,
+					meetingSessionId: params.meetingSessionId,
+					requesterSessionKey: params.requesterSessionKey,
+					args: {
+						question: currentQuestion,
+						responseStyle: "Brief, natural spoken answer for a live meeting."
+					},
+					transcript
+				})).text);
+				nextQuestion = pendingAgentQuestion;
+			}
+		} catch (error) {
+			params.logger.warn(`[google-meet] node agent consult failed: ${formatErrorMessage(error)}`);
+			enqueueSpeakText("I hit an error while checking that. Please try again.");
+		} finally {
+			agentConsultActive = false;
+			const queuedQuestion = pendingAgentQuestion;
+			pendingAgentQuestion = void 0;
+			if (queuedQuestion && !stopped) runAgentConsultForUserTranscript(queuedQuestion);
+		}
+	};
+	const enqueueAgentConsultForUserTranscript = (question) => {
+		const trimmed = question.trim();
+		if (!trimmed || stopped) return;
+		pendingAgentQuestion = pendingAgentQuestion ? `${pendingAgentQuestion}\n${trimmed}` : trimmed;
+		if (agentConsultDebounceTimer) clearTimeout(agentConsultDebounceTimer);
+		agentConsultDebounceTimer = setTimeout(() => {
+			agentConsultDebounceTimer = void 0;
+			const queuedQuestion = pendingAgentQuestion;
+			pendingAgentQuestion = void 0;
+			if (queuedQuestion && !stopped) runAgentConsultForUserTranscript(queuedQuestion);
+		}, 900);
+		agentConsultDebounceTimer.unref?.();
+	};
+	sttSession = resolved.provider.createSession({
+		providerConfig: resolved.providerConfig,
+		onTranscript: (text) => {
+			const trimmed = text.trim();
+			if (!trimmed || stopped) return;
+			recordGoogleMeetRealtimeTranscript(transcript, "user", trimmed);
+			params.logger.info(`[google-meet] node agent user: ${trimmed}`);
+			if (isGoogleMeetLikelyAssistantEchoTranscript({
+				transcript,
+				text: trimmed
+			})) {
+				params.logger.info(`[google-meet] node agent ignored assistant echo transcript: ${trimmed}`);
+				return;
+			}
+			enqueueAgentConsultForUserTranscript(trimmed);
+		},
+		onError: (error) => {
+			params.logger.warn(`[google-meet] node agent transcription bridge failed: ${formatErrorMessage(error)}`);
+			stop();
+		}
+	});
+	await sttSession.connect();
+	realtimeReady = true;
+	(async () => {
+		for (;;) {
+			if (stopped) break;
+			try {
+				const raw = await params.runtime.nodes.invoke({
+					nodeId: params.nodeId,
+					command: "googlemeet.chrome",
+					params: {
+						action: "pullAudio",
+						bridgeId: params.bridgeId,
+						timeoutMs: 250
+					},
+					timeoutMs: 2e3
+				});
+				const result = asRecord$2(asRecord$2(raw).payload ?? raw);
+				consecutiveInputErrors = 0;
+				lastInputError = void 0;
+				const base64 = readString$1(result.base64);
+				if (base64) {
+					const audio = Buffer.from(base64, "base64");
+					if (Date.now() < suppressInputUntil) {
+						lastSuppressedInputAt = (/* @__PURE__ */ new Date()).toISOString();
+						suppressedInputBytes += audio.byteLength;
+						continue;
+					}
+					lastInputAt = (/* @__PURE__ */ new Date()).toISOString();
+					lastInputBytes += audio.byteLength;
+					sttSession?.sendAudio(convertGoogleMeetBridgeAudioForStt(audio, params.config));
+				}
+				if (result.closed === true) await stop();
+			} catch (error) {
+				if (!stopped) {
+					const message = formatErrorMessage(error);
+					consecutiveInputErrors += 1;
+					lastInputError = message;
+					params.logger.warn(`[google-meet] node agent audio input failed (${consecutiveInputErrors}/5): ${message}`);
+					if (consecutiveInputErrors >= 5 || /unknown bridgeId|bridge is not open/i.test(message)) await stop();
+					else await new Promise((resolve) => setTimeout(resolve, 250));
+				}
+			}
+		}
+	})();
+	return {
+		type: "node-command-pair",
+		providerId: resolved.provider.id,
+		nodeId: params.nodeId,
+		bridgeId: params.bridgeId,
+		speak: enqueueSpeakText,
+		getHealth: () => ({
+			providerConnected: sttSession?.isConnected() ?? false,
+			realtimeReady,
+			audioInputActive: lastInputBytes > 0,
+			audioOutputActive: lastOutputBytes > 0,
+			lastInputAt,
+			lastOutputAt,
+			lastSuppressedInputAt,
+			lastInputBytes,
+			lastOutputBytes,
+			suppressedInputBytes,
+			...getGoogleMeetRealtimeTranscriptHealth(transcript),
+			consecutiveInputErrors,
+			lastInputError,
+			bridgeClosed: stopped
+		}),
+		stop
+	};
+}
 async function startNodeRealtimeAudioBridge(params) {
 	let stopped = false;
 	let bridge = null;
@@ -686,6 +1467,10 @@ async function startNodeRealtimeAudioBridge(params) {
 	let lastClearAt;
 	let lastInputBytes = 0;
 	let lastOutputBytes = 0;
+	let suppressedInputBytes = 0;
+	let lastSuppressedInputAt;
+	let suppressInputUntil = 0;
+	let lastOutputPlayableUntilMs = 0;
 	let consecutiveInputErrors = 0;
 	let lastInputError;
 	let clearCount = 0;
@@ -696,9 +1481,78 @@ async function startNodeRealtimeAudioBridge(params) {
 	});
 	const transcript = [];
 	const realtimeEvents = [];
+	const strategy = params.config.realtime.strategy;
+	params.logger.info(formatGoogleMeetRealtimeVoiceModelLog({
+		strategy,
+		provider: resolved.provider,
+		providerConfig: resolved.providerConfig,
+		fallbackModel: params.config.realtime.model,
+		audioFormat: params.config.chrome.audioFormat
+	}));
+	let agentConsultActive = false;
+	let pendingAgentQuestion;
+	let agentConsultDebounceTimer;
+	const enqueueAgentConsultForUserTranscript = (question) => {
+		const trimmed = question.trim();
+		if (!trimmed || stopped) return;
+		pendingAgentQuestion = pendingAgentQuestion ? `${pendingAgentQuestion}\n${trimmed}` : trimmed;
+		if (agentConsultDebounceTimer) clearTimeout(agentConsultDebounceTimer);
+		agentConsultDebounceTimer = setTimeout(() => {
+			agentConsultDebounceTimer = void 0;
+			const queuedQuestion = pendingAgentQuestion;
+			pendingAgentQuestion = void 0;
+			if (queuedQuestion && !stopped) runAgentConsultForUserTranscript(queuedQuestion);
+		}, 900);
+		agentConsultDebounceTimer.unref?.();
+	};
+	const runAgentConsultForUserTranscript = async (question) => {
+		const trimmed = question.trim();
+		if (!trimmed || stopped) return;
+		if (agentConsultActive) {
+			pendingAgentQuestion = trimmed;
+			return;
+		}
+		agentConsultActive = true;
+		let nextQuestion = trimmed;
+		try {
+			while (nextQuestion) {
+				if (stopped) return;
+				const currentQuestion = nextQuestion;
+				pendingAgentQuestion = void 0;
+				params.logger.info(`[google-meet] node realtime agent consult: ${currentQuestion}`);
+				const result = await consultOpenClawAgentForGoogleMeet({
+					config: params.config,
+					fullConfig: params.fullConfig,
+					runtime: params.runtime,
+					logger: params.logger,
+					meetingSessionId: params.meetingSessionId,
+					requesterSessionKey: params.requesterSessionKey,
+					args: {
+						question: currentQuestion,
+						responseStyle: "Brief, natural spoken answer for a live meeting."
+					},
+					transcript
+				});
+				if (!stopped && result.text.trim()) bridge?.sendUserMessage(buildGoogleMeetSpeakExactUserMessage(result.text.trim()));
+				nextQuestion = pendingAgentQuestion;
+			}
+		} catch (error) {
+			params.logger.warn(`[google-meet] node realtime agent consult failed: ${formatErrorMessage(error)}`);
+			if (!stopped) bridge?.sendUserMessage(buildGoogleMeetSpeakExactUserMessage("I hit an error while checking that. Please try again."));
+		} finally {
+			agentConsultActive = false;
+			const queuedQuestion = pendingAgentQuestion;
+			pendingAgentQuestion = void 0;
+			if (queuedQuestion && !stopped) runAgentConsultForUserTranscript(queuedQuestion);
+		}
+	};
 	const stop = async () => {
 		if (stopped) return;
 		stopped = true;
+		if (agentConsultDebounceTimer) {
+			clearTimeout(agentConsultDebounceTimer);
+			agentConsultDebounceTimer = void 0;
+		}
 		try {
 			bridge?.close();
 		} catch (error) {
@@ -724,12 +1578,22 @@ async function startNodeRealtimeAudioBridge(params) {
 		audioFormat: resolveGoogleMeetRealtimeAudioFormat(params.config),
 		instructions: params.config.realtime.instructions,
 		initialGreetingInstructions: params.config.realtime.introMessage,
+		autoRespondToAudio: strategy === "bidi",
 		triggerGreetingOnReady: false,
 		markStrategy: "ack-immediately",
-		tools: resolveGoogleMeetRealtimeTools(params.config.realtime.toolPolicy),
+		tools: strategy === "bidi" ? resolveGoogleMeetRealtimeTools(params.config.realtime.toolPolicy) : [],
 		audioSink: {
 			isOpen: () => !stopped,
 			sendAudio: (audio) => {
+				const suppression = extendGoogleMeetOutputEchoSuppression({
+					audio,
+					audioFormat: params.config.chrome.audioFormat,
+					nowMs: Date.now(),
+					lastOutputPlayableUntilMs,
+					suppressInputUntilMs: suppressInputUntil
+				});
+				suppressInputUntil = suppression.suppressInputUntilMs;
+				lastOutputPlayableUntilMs = suppression.lastOutputPlayableUntilMs;
 				lastOutputAt = (/* @__PURE__ */ new Date()).toISOString();
 				lastOutputBytes += audio.byteLength;
 				params.runtime.nodes.invoke({
@@ -749,6 +1613,8 @@ async function startNodeRealtimeAudioBridge(params) {
 			clearAudio: () => {
 				lastClearAt = (/* @__PURE__ */ new Date()).toISOString();
 				clearCount += 1;
+				suppressInputUntil = 0;
+				lastOutputPlayableUntilMs = 0;
 				params.runtime.nodes.invoke({
 					nodeId: params.nodeId,
 					command: "googlemeet.chrome",
@@ -767,16 +1633,30 @@ async function startNodeRealtimeAudioBridge(params) {
 			if (isFinal) {
 				recordGoogleMeetRealtimeTranscript(transcript, role, text);
 				params.logger.info(`[google-meet] node realtime ${role}: ${text}`);
+				if (role === "user" && strategy === "agent") {
+					if (isGoogleMeetLikelyAssistantEchoTranscript({
+						transcript,
+						text
+					})) {
+						params.logger.info(`[google-meet] node realtime ignored assistant echo transcript: ${text}`);
+						return;
+					}
+					enqueueAgentConsultForUserTranscript(text);
+				}
 			}
 		},
 		onEvent: (event) => {
 			recordGoogleMeetRealtimeEvent(realtimeEvents, event);
-			if (event.type === "error" || event.type === "response.done") {
+			if (event.type === "error" || event.type === "response.done" || event.type === "input_audio_buffer.speech_started" || event.type === "input_audio_buffer.speech_stopped" || event.type === "conversation.item.input_audio_transcription.completed" || event.type === "conversation.item.input_audio_transcription.failed") {
 				const detail = event.detail ? ` ${event.detail}` : "";
 				params.logger.info(`[google-meet] node realtime ${event.direction}:${event.type}${detail}`);
 			}
 		},
 		onToolCall: (event, session) => {
+			if (strategy !== "bidi") {
+				session.submitToolResult(event.callId || event.itemId, { error: `Tool "${event.name}" is only available in bidi realtime strategy` });
+				return;
+			}
 			if (event.name !== GOOGLE_MEET_AGENT_CONSULT_TOOL_NAME) {
 				session.submitToolResult(event.callId || event.itemId, { error: `Tool "${event.name}" not available` });
 				return;
@@ -788,6 +1668,7 @@ async function startNodeRealtimeAudioBridge(params) {
 				runtime: params.runtime,
 				logger: params.logger,
 				meetingSessionId: params.meetingSessionId,
+				requesterSessionKey: params.requesterSessionKey,
 				args: event.args,
 				transcript
 			}).then((result) => {
@@ -829,6 +1710,11 @@ async function startNodeRealtimeAudioBridge(params) {
 				const base64 = readString$1(result.base64);
 				if (base64) {
 					const audio = Buffer.from(base64, "base64");
+					if (Date.now() < suppressInputUntil) {
+						lastSuppressedInputAt = (/* @__PURE__ */ new Date()).toISOString();
+						suppressedInputBytes += audio.byteLength;
+						continue;
+					}
 					lastInputAt = (/* @__PURE__ */ new Date()).toISOString();
 					lastInputBytes += audio.byteLength;
 					bridge?.sendAudio(audio);
@@ -861,9 +1747,11 @@ async function startNodeRealtimeAudioBridge(params) {
 			audioOutputActive: lastOutputBytes > 0,
 			lastInputAt,
 			lastOutputAt,
+			lastSuppressedInputAt,
 			lastClearAt,
 			lastInputBytes,
 			lastOutputBytes,
+			suppressedInputBytes,
 			...getGoogleMeetRealtimeTranscriptHealth(transcript),
 			...getGoogleMeetRealtimeEventHealth(realtimeEvents),
 			consecutiveInputErrors,
@@ -878,6 +1766,9 @@ async function startNodeRealtimeAudioBridge(params) {
 //#region extensions/google-meet/src/transports/chrome.ts
 const GOOGLE_MEET_SYSTEM_PROFILER_COMMAND = "/usr/sbin/system_profiler";
 const chromeTransportDeps = { callGatewayFromCli };
+function isGoogleMeetTalkBackMode$2(mode) {
+	return mode === "agent" || mode === "bidi";
+}
 function outputMentionsBlackHole2ch(output) {
 	return /\bBlackHole\s+2ch\b/i.test(output);
 }
@@ -899,7 +1790,7 @@ async function assertBlackHole2chAvailable(params) {
 }
 async function launchChromeMeet(params) {
 	const checkRealtimeAudioPrerequisites = async () => {
-		if (params.mode !== "realtime") return;
+		if (!isGoogleMeetTalkBackMode$2(params.mode)) return;
 		await assertBlackHole2chAvailable({
 			runtime: params.runtime,
 			timeoutMs: Math.min(params.config.chrome.joinTimeoutMs, 1e4)
@@ -910,20 +1801,37 @@ async function launchChromeMeet(params) {
 		}
 	};
 	const startRealtimeAudioBridge = async () => {
-		if (params.mode !== "realtime") return;
+		if (!isGoogleMeetTalkBackMode$2(params.mode)) return;
 		if (params.config.chrome.audioBridgeCommand) {
+			if (params.mode === "agent") throw new Error("Chrome agent mode requires chrome.audioInputCommand and chrome.audioOutputCommand so OpenClaw can run STT and regular TTS directly.");
 			const bridge = await params.runtime.system.runCommandWithTimeout(params.config.chrome.audioBridgeCommand, { timeoutMs: params.config.chrome.joinTimeoutMs });
 			if (bridge.code !== 0) throw new Error(`failed to start Chrome audio bridge: ${bridge.stderr || bridge.stdout || bridge.code}`);
 			return { type: "external-command" };
 		}
-		if (!params.config.chrome.audioInputCommand || !params.config.chrome.audioOutputCommand) throw new Error("Chrome realtime mode requires chrome.audioInputCommand and chrome.audioOutputCommand, or chrome.audioBridgeCommand for an external bridge.");
+		if (!params.config.chrome.audioInputCommand || !params.config.chrome.audioOutputCommand) throw new Error("Chrome talk-back mode requires chrome.audioInputCommand and chrome.audioOutputCommand, or chrome.audioBridgeCommand for an external bridge.");
 		return {
 			type: "command-pair",
-			...await startCommandRealtimeAudioBridge({
+			...params.mode === "agent" ? await startCommandAgentAudioBridge({
 				config: params.config,
 				fullConfig: params.fullConfig,
 				runtime: params.runtime,
 				meetingSessionId: params.meetingSessionId,
+				requesterSessionKey: params.requesterSessionKey,
+				inputCommand: params.config.chrome.audioInputCommand,
+				outputCommand: params.config.chrome.audioOutputCommand,
+				logger: params.logger
+			}) : await startCommandRealtimeAudioBridge({
+				config: {
+					...params.config,
+					realtime: {
+						...params.config.realtime,
+						strategy: "bidi"
+					}
+				},
+				fullConfig: params.fullConfig,
+				runtime: params.runtime,
+				meetingSessionId: params.meetingSessionId,
+				requesterSessionKey: params.requesterSessionKey,
 				inputCommand: params.config.chrome.audioInputCommand,
 				outputCommand: params.config.chrome.audioOutputCommand,
 				logger: params.logger
@@ -941,7 +1849,7 @@ async function launchChromeMeet(params) {
 		mode: params.mode,
 		url: params.url
 	});
-	const audioBridge = params.mode === "realtime" && result.browser?.inCall === true && result.browser.micMuted !== true && result.browser.manualActionRequired !== true ? await startRealtimeAudioBridge() : void 0;
+	const audioBridge = isGoogleMeetTalkBackMode$2(params.mode) && result.browser?.inCall === true && result.browser.micMuted !== true && result.browser.manualActionRequired !== true ? await startRealtimeAudioBridge() : void 0;
 	return {
 		...result,
 		audioBridge
@@ -968,6 +1876,9 @@ function parseMeetBrowserStatus(result) {
 		lastCaptionSpeaker: parsed.lastCaptionSpeaker,
 		lastCaptionText: parsed.lastCaptionText,
 		recentTranscript: parsed.recentTranscript,
+		audioOutputRouted: parsed.audioOutputRouted,
+		audioOutputDeviceLabel: parsed.audioOutputDeviceLabel,
+		audioOutputRouteError: parsed.audioOutputRouteError,
 		manualActionRequired: parsed.manualActionRequired,
 		manualActionReason: parsed.manualActionReason,
 		manualActionMessage: parsed.manualActionMessage,
@@ -1022,7 +1933,7 @@ async function grantMeetMediaPermissions(params) {
 	}
 }
 function meetStatusScript(params) {
-	return `() => {
+	return `async () => {
   const text = (node) => (node?.innerText || node?.textContent || "").trim();
   const allowMicrophone = ${JSON.stringify(params.allowMicrophone)};
   const captureCaptions = ${JSON.stringify(params.captureCaptions)};
@@ -1038,6 +1949,9 @@ function meetStatusScript(params) {
       .join(" ");
   const buttonLabels = buttons.map(buttonLabel).filter(Boolean);
   const notes = [];
+  let audioOutputRouted;
+  let audioOutputDeviceLabel;
+  let audioOutputRouteError;
   const findButton = (pattern) =>
     buttons.find((button) => {
       const label = buttonLabel(button);
@@ -1071,7 +1985,7 @@ function meetStatusScript(params) {
   }
   if (!readOnly && allowMicrophone && mic && /turn on microphone/i.test(buttonLabel(mic))) {
     mic.click();
-    notes.push("Attempted to turn on the Meet microphone for realtime mode.");
+    notes.push("Attempted to turn on the Meet microphone for talk-back mode.");
   }
   if (!readOnly && !allowMicrophone && mic && /turn off microphone/i.test(mic.getAttribute('aria-label') || text(mic))) {
     mic.click();
@@ -1091,6 +2005,55 @@ function meetStatusScript(params) {
     notes.push("Skipped Meet microphone prompt for observe-only mode.");
   }
   const inCall = buttons.some((button) => /leave call/i.test(button.getAttribute('aria-label') || text(button)));
+  const routeMeetAudioOutput = async () => {
+    if (
+      !allowMicrophone ||
+      typeof navigator === 'undefined' ||
+      !navigator.mediaDevices?.enumerateDevices
+    ) return;
+    const mediaElements = [...document.querySelectorAll('audio, video')]
+      .filter((el) => typeof el.setSinkId === 'function');
+    if (mediaElements.length === 0) return;
+    try {
+      const devices = await navigator.mediaDevices.enumerateDevices();
+      const output = devices.find((device) =>
+        device.kind === 'audiooutput' && /\\bBlackHole\\s+2ch\\b/i.test(device.label || '')
+      ) || devices.find((device) =>
+        device.kind === 'audiooutput' && /\\bBlackHole\\b/i.test(device.label || '')
+      );
+      if (!output?.deviceId) {
+        if (devices.some((device) => device.kind === 'audiooutput')) {
+          notes.push("BlackHole 2ch speaker output was not visible to Meet.");
+        }
+        return;
+      }
+      let routed = 0;
+      for (const element of mediaElements) {
+        if (element.sinkId !== output.deviceId) {
+          if (readOnly) {
+            continue;
+          }
+          await element.setSinkId(output.deviceId);
+          routed += 1;
+        }
+      }
+      audioOutputRouted = mediaElements.some((element) => element.sinkId === output.deviceId);
+      audioOutputDeviceLabel = output.label || "BlackHole 2ch";
+      if (!readOnly && audioOutputRouted) {
+        notes.push(
+          routed > 0
+            ? \`Routed Meet media output to \${audioOutputDeviceLabel}.\`
+            : \`Meet media output already routed to \${audioOutputDeviceLabel}.\`
+        );
+      }
+    } catch (error) {
+      audioOutputRouteError = error?.message || String(error);
+      notes.push(\`Could not route Meet speaker output to BlackHole 2ch: \${audioOutputRouteError}\`);
+    }
+  };
+  if (inCall) {
+    await routeMeetAudioOutput();
+  }
   let captioning = false;
   let captionsEnabledAttempted = false;
   let transcriptLines = 0;
@@ -1213,6 +2176,9 @@ function meetStatusScript(params) {
     lastCaptionSpeaker,
     lastCaptionText,
     recentTranscript,
+    audioOutputRouted,
+    audioOutputDeviceLabel,
+    audioOutputRouteError,
     manualActionRequired: Boolean(manualActionReason),
     manualActionReason,
     manualActionMessage,
@@ -1275,7 +2241,7 @@ async function openMeetWithBrowserRequest(params) {
 		}
 	};
 	const permissionNotes = await grantMeetMediaPermissions({
-		allowMicrophone: params.mode === "realtime",
+		allowMicrophone: isGoogleMeetTalkBackMode$2(params.mode),
 		callBrowser: params.callBrowser,
 		targetId,
 		timeoutMs
@@ -1296,7 +2262,7 @@ async function openMeetWithBrowserRequest(params) {
 					kind: "evaluate",
 					targetId,
 					fn: meetStatusScript({
-						allowMicrophone: params.mode === "realtime",
+						allowMicrophone: isGoogleMeetTalkBackMode$2(params.mode),
 						captureCaptions: params.mode === "transcribe",
 						guestName: params.config.chrome.guestName,
 						autoJoin: params.config.chrome.autoJoin
@@ -1304,7 +2270,7 @@ async function openMeetWithBrowserRequest(params) {
 				},
 				timeoutMs: Math.min(timeoutMs, 1e4)
 			})) ?? browser, permissionNotes);
-			if (browser?.inCall === true && (params.mode !== "realtime" || browser.micMuted !== true)) return {
+			if (browser?.inCall === true && (!isGoogleMeetTalkBackMode$2(params.mode) || browser.micMuted !== true)) return {
 				launched: true,
 				browser
 			};
@@ -1492,11 +2458,18 @@ async function launchChromeMeetOnNode(params) {
 	}));
 	if (result.audioBridge?.type === "node-command-pair") {
 		if (!result.bridgeId) throw new Error("Google Meet node did not return an audio bridge id.");
-		const bridge = await startNodeRealtimeAudioBridge({
-			config: params.config,
+		const bridge = await (params.mode === "agent" ? startNodeAgentAudioBridge : startNodeRealtimeAudioBridge)({
+			config: params.mode === "agent" ? params.config : {
+				...params.config,
+				realtime: {
+					...params.config.realtime,
+					strategy: "bidi"
+				}
+			},
 			fullConfig: params.fullConfig,
 			runtime: params.runtime,
 			meetingSessionId: params.meetingSessionId,
+			requesterSessionKey: params.requesterSessionKey,
 			nodeId,
 			bridgeId: result.bridgeId,
 			logger: params.logger
@@ -1583,6 +2556,9 @@ function attachOutputProcessHandlers(session, outputProcess) {
 	outputProcess.on("error", () => {
 		if (session.output === outputProcess) stopSession(session);
 	});
+	outputProcess.stdin?.on?.("error", () => {
+		if (session.output === outputProcess) stopSession(session);
+	});
 }
 function startOutputProcess(command) {
 	return spawn(command.command, command.args, { stdio: [
@@ -1670,7 +2646,12 @@ function pushAudio(params) {
 	const audio = Buffer.from(base64, "base64");
 	session.lastOutputAt = (/* @__PURE__ */ new Date()).toISOString();
 	session.lastOutputBytes += audio.byteLength;
-	session.output?.stdin?.write(audio);
+	try {
+		session.output?.stdin?.write(audio);
+	} catch {
+		stopSession(session);
+		throw new Error(`bridge is not open: ${bridgeId}`);
+	}
 	return {
 		bridgeId,
 		ok: true
@@ -1701,7 +2682,7 @@ function startChrome(params) {
 	const mode = readString(params.mode);
 	let bridgeId;
 	let audioBridge;
-	if (mode === "realtime") {
+	if (mode === "agent" || mode === "bidi" || mode === "realtime") {
 		assertBlackHoleAvailable(Math.min(timeoutMs, 1e4));
 		const healthCommand = readStringArray(params.audioBridgeHealthCommand);
 		if (healthCommand) {
@@ -1710,6 +2691,7 @@ function startChrome(params) {
 		}
 		const bridgeCommand = readStringArray(params.audioBridgeCommand);
 		if (bridgeCommand) {
+			if (mode === "agent") throw new Error("Chrome agent mode requires audioInputCommand and audioOutputCommand so OpenClaw can run STT and regular TTS directly.");
 			const bridge = runCommandWithTimeout(bridgeCommand, timeoutMs);
 			if (bridge.code !== 0) throw new Error(`failed to start Chrome audio bridge: ${bridge.stderr || bridge.stdout || bridge.code}`);
 			audioBridge = { type: "external-command" };
@@ -1925,7 +2907,7 @@ function getGoogleMeetSetupStatus(config, options) {
 	const fullConfig = asRecord(options?.fullConfig);
 	const mode = options?.mode ?? config.defaultMode;
 	const transport = options?.transport ?? config.defaultTransport;
-	const needsChromeRealtimeAudio = mode === "realtime" && (transport === "chrome" || transport === "chrome-node");
+	const needsChromeRealtimeAudio = (mode === "agent" || mode === "bidi") && (transport === "chrome" || transport === "chrome-node");
 	const pluginEntries = asRecord(asRecord(fullConfig.plugins).entries);
 	const pluginAllow = asRecord(fullConfig.plugins).allow;
 	const voiceCallEntry = asRecord(pluginEntries["voice-call"]);
@@ -1948,12 +2930,16 @@ function getGoogleMeetSetupStatus(config, options) {
 		ok: true,
 		message: config.chrome.browserProfile ? "Local Chrome uses the OpenClaw browser profile; chrome.browserProfile is passed to chrome-node hosts" : "Local Chrome uses the OpenClaw browser profile; configure browser.defaultProfile to choose another profile"
 	});
-	if (needsChromeRealtimeAudio) checks.push({
-		id: "audio-bridge",
-		ok: Boolean(config.chrome.audioBridgeCommand || config.chrome.audioInputCommand && config.chrome.audioOutputCommand),
-		message: config.chrome.audioBridgeCommand ? "Chrome audio bridge command configured" : config.chrome.audioInputCommand && config.chrome.audioOutputCommand ? `Chrome command-pair realtime audio bridge configured (${config.chrome.audioFormat})` : "Chrome realtime audio bridge not configured"
-	});
-	else if (transport === "chrome" || transport === "chrome-node") checks.push({
+	if (needsChromeRealtimeAudio) {
+		const hasCommandPair = Boolean(config.chrome.audioInputCommand && config.chrome.audioOutputCommand);
+		const hasExternalBridge = Boolean(config.chrome.audioBridgeCommand);
+		const agentModeExternalBridgeInvalid = mode === "agent" && hasExternalBridge;
+		checks.push({
+			id: "audio-bridge",
+			ok: mode === "agent" ? hasCommandPair && !agentModeExternalBridgeInvalid : hasExternalBridge || hasCommandPair,
+			message: agentModeExternalBridgeInvalid ? "Chrome agent mode requires chrome.audioInputCommand and chrome.audioOutputCommand; chrome.audioBridgeCommand is bidi-only" : hasExternalBridge ? "Chrome audio bridge command configured" : hasCommandPair ? `Chrome command-pair talk-back audio bridge configured (${config.chrome.audioFormat})` : "Chrome talk-back audio bridge not configured"
+		});
+	} else if (transport === "chrome" || transport === "chrome-node") checks.push({
 		id: "audio-bridge",
 		ok: true,
 		message: "Chrome observe-only mode does not require a realtime audio bridge"
@@ -1985,7 +2971,7 @@ function getGoogleMeetSetupStatus(config, options) {
 	}
 	if (config.voiceCall.enabled && (transport === "twilio" || Boolean(config.twilio.defaultDialInNumber) || Object.hasOwn(pluginEntries, "voice-call"))) {
 		const voiceCallAllowed = !Array.isArray(pluginAllow) || pluginAllow.includes("voice-call");
-		const voiceCallEnabled = voiceCallEntry.enabled !== false;
+		const voiceCallEnabled = Object.hasOwn(pluginEntries, "voice-call") && voiceCallEntry.enabled !== false;
 		checks.push({
 			id: "twilio-voice-call-plugin",
 			ok: voiceCallAllowed && voiceCallEnabled,
@@ -2127,11 +3113,14 @@ async function joinMeetViaVoiceCallGateway(params) {
 			}
 			const spoken = await client.request("voicecall.speak", {
 				callId: start.callId,
+				allowTwimlFallback: false,
 				message: params.message
 			}, { timeoutMs: params.config.voiceCall.requestTimeoutMs });
-			if (spoken.success === false) throw new Error(spoken.error || "voicecall.speak failed");
-			introSent = true;
-			params.logger?.info(`[google-meet] Intro speech requested after Meet dial sequence: callId=${start.callId}`);
+			if (spoken.success === false) params.logger?.warn?.(`[google-meet] Skipped intro speech because realtime bridge was not ready: ${spoken.error || "voicecall.speak failed"}`);
+			else {
+				introSent = true;
+				params.logger?.info(`[google-meet] Intro speech requested after Meet dial sequence: callId=${start.callId}`);
+			}
 		}
 		return {
 			callId: start.callId,
@@ -2186,7 +3175,10 @@ function resolveTransport(input, config) {
 	return input ?? config.defaultTransport;
 }
 function resolveMode(input, config) {
-	return input ?? config.defaultMode;
+	return input === "realtime" ? "agent" : input ?? config.defaultMode;
+}
+function isGoogleMeetTalkBackMode$1(mode) {
+	return mode === "agent" || mode === "bidi";
 }
 function hasRealtimeAudioOutputAdvanced(health, startOutputBytes) {
 	return (health?.lastOutputBytes ?? 0) > startOutputBytes;
@@ -2215,7 +3207,7 @@ function isManagedChromeBrowserSession(session) {
 	return Boolean((session.transport === "chrome" || session.transport === "chrome-node") && session.chrome && session.chrome.launched);
 }
 function evaluateSpeechReadiness(session) {
-	if (session.mode !== "realtime" || !session.chrome) return { ready: true };
+	if (!isGoogleMeetTalkBackMode$1(session.mode) || !session.chrome) return { ready: true };
 	if (!isManagedChromeBrowserSession(session)) {
 		if (session.chrome.audioBridge) return { ready: true };
 		return {
@@ -2329,7 +3321,7 @@ var GoogleMeetRuntime = class {
 				message: formatErrorMessage(error)
 			});
 		}
-		if (transport === "chrome" && mode === "realtime") {
+		if (transport === "chrome" && isGoogleMeetTalkBackMode$1(mode)) {
 			try {
 				await assertBlackHole2chAvailable({
 					runtime: this.params.runtime,
@@ -2357,7 +3349,7 @@ var GoogleMeetRuntime = class {
 			status = addGoogleMeetSetupCheck(status, {
 				id: "chrome-local-audio-commands",
 				ok: commands.length > 0 && missingCommands.length === 0,
-				message: commands.length === 0 ? "Chrome realtime 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(", ")}`
+				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(", ")}`
 			});
 		}
 		return status;
@@ -2394,7 +3386,7 @@ var GoogleMeetRuntime = class {
 			reusable.updatedAt = nowIso();
 			return {
 				session: reusable,
-				spoken: mode === "realtime" && speechInstructions ? await this.#speakWhenReady(reusable, speechInstructions) : false
+				spoken: isGoogleMeetTalkBackMode$1(mode) && speechInstructions ? await this.#speakWhenReady(reusable, speechInstructions) : false
 			};
 		}
 		const createdAt = nowIso();
@@ -2409,9 +3401,11 @@ var GoogleMeetRuntime = class {
 			updatedAt: createdAt,
 			participantIdentity: transport === "twilio" ? "Twilio phone participant" : transport === "chrome-node" ? "signed-in Google Chrome profile on a paired node" : "signed-in Google Chrome profile",
 			realtime: {
-				enabled: mode === "realtime",
-				provider: this.params.config.realtime.provider,
-				model: this.params.config.realtime.model,
+				enabled: isGoogleMeetTalkBackMode$1(mode),
+				strategy: mode === "bidi" ? "bidi" : "agent",
+				provider: mode === "bidi" ? this.params.config.realtime.voiceProvider ?? this.params.config.realtime.provider : void 0,
+				model: mode === "bidi" ? this.params.config.realtime.model : void 0,
+				transcriptionProvider: mode === "agent" ? this.params.config.realtime.transcriptionProvider ?? this.params.config.realtime.provider : void 0,
 				toolPolicy: this.params.config.realtime.toolPolicy
 			},
 			notes: []
@@ -2423,6 +3417,7 @@ var GoogleMeetRuntime = class {
 					config: this.params.config,
 					fullConfig: this.params.fullConfig,
 					meetingSessionId: session.id,
+					requesterSessionKey: request.requesterSessionKey,
 					mode,
 					url,
 					logger: this.params.logger
@@ -2431,6 +3426,7 @@ var GoogleMeetRuntime = class {
 					config: this.params.config,
 					fullConfig: this.params.fullConfig,
 					meetingSessionId: session.id,
+					requesterSessionKey: request.requesterSessionKey,
 					mode,
 					url,
 					logger: this.params.logger
@@ -2443,7 +3439,7 @@ var GoogleMeetRuntime = class {
 					health: "browser" in result ? result.browser : void 0
 				};
 				this.#attachChromeAudioBridge(session, result.audioBridge);
-				session.notes.push(result.audioBridge ? 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." : mode === "realtime" ? "Chrome transport joins as the signed-in Google profile and expects BlackHole 2ch audio routing." : "Chrome transport joins as the signed-in Google profile without starting the realtime audio bridge.");
+				session.notes.push(result.audioBridge ? 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." : isGoogleMeetTalkBackMode$1(mode) ? "Chrome transport joins as the signed-in Google profile and expects BlackHole 2ch audio routing." : "Chrome transport joins as the signed-in Google profile without starting the realtime audio bridge.");
 				this.#refreshSpeechReadiness(session);
 			} else {
 				const dialInNumber = normalizeDialInNumber(request.dialInNumber ?? this.params.config.twilio.defaultDialInNumber);
@@ -2457,7 +3453,7 @@ var GoogleMeetRuntime = class {
 					dialInNumber,
 					dtmfSequence,
 					logger: this.params.logger,
-					message: mode === "realtime" ? request.message ?? this.params.config.voiceCall.introMessage ?? this.params.config.realtime.introMessage : void 0
+					message: isGoogleMeetTalkBackMode$1(mode) ? request.message ?? this.params.config.voiceCall.introMessage ?? this.params.config.realtime.introMessage : void 0
 				}) : void 0;
 				delegatedTwilioSpoken = Boolean(voiceCallResult?.introSent);
 				session.twilio = {
@@ -2483,7 +3479,7 @@ var GoogleMeetRuntime = class {
 		this.#sessions.set(session.id, session);
 		return {
 			session,
-			spoken: transport === "twilio" ? delegatedTwilioSpoken : mode === "realtime" && speechInstructions ? await this.#speakWhenReady(session, speechInstructions) : false
+			spoken: transport === "twilio" ? delegatedTwilioSpoken : isGoogleMeetTalkBackMode$1(mode) && speechInstructions ? await this.#speakWhenReady(session, speechInstructions) : false
 		};
 	}
 	async leave(sessionId) {
@@ -2563,22 +3559,22 @@ var GoogleMeetRuntime = class {
 			const health = result.session?.chrome?.health;
 			if (health?.manualActionRequired || result.session?.state !== "active") return false;
 			const blocked = health?.speechBlockedReason;
-			if (blocked && blocked !== "not-in-call" && blocked !== "browser-unverified") return false;
+			if (blocked && blocked !== "not-in-call" && blocked !== "browser-unverified" && blocked !== "meet-microphone-muted") return false;
 		}
 		return false;
 	}
 	async testSpeech(request) {
-		if (request.mode === "transcribe") throw new Error("test_speech requires mode: realtime; use join mode: transcribe for observe-only sessions.");
+		if (request.mode === "transcribe") throw new Error("test_speech requires mode: agent or bidi; use join mode: transcribe for observe-only sessions.");
 		const url = normalizeMeetUrl(request.url);
 		const transport = resolveTransport(request.transport, this.params.config);
 		const beforeSessions = this.list();
 		const before = new Set(beforeSessions.map((session) => session.id));
-		const startOutputBytes = beforeSessions.find((session) => session.state === "active" && isSameMeetUrlForReuse(session.url, url) && session.transport === transport && session.mode === "realtime")?.chrome?.health?.lastOutputBytes ?? 0;
+		const startOutputBytes = beforeSessions.find((session) => session.state === "active" && isSameMeetUrlForReuse(session.url, url) && session.transport === transport && isGoogleMeetTalkBackMode$1(session.mode))?.chrome?.health?.lastOutputBytes ?? 0;
 		const result = await this.join({
 			...request,
 			transport,
 			url,
-			mode: "realtime",
+			mode: "agent",
 			message: request.message ?? "Say exactly: Google Meet speech test complete."
 		});
 		let health = result.session.chrome?.health;
@@ -2611,7 +3607,8 @@ var GoogleMeetRuntime = class {
 		};
 	}
 	async testListen(request) {
-		if (request.mode === "realtime") throw new Error("test_listen requires mode: transcribe; use test_speech for realtime talk-back.");
+		const requestedMode = request.mode ? resolveMode(request.mode, this.params.config) : void 0;
+		if (requestedMode && isGoogleMeetTalkBackMode$1(requestedMode)) throw new Error("test_listen requires mode: transcribe; use test_speech for talk-back sessions.");
 		const url = normalizeMeetUrl(request.url);
 		const transport = resolveTransport(request.transport, this.params.config);
 		if (transport === "twilio") throw new Error("test_listen supports chrome or chrome-node transports");
@@ -2682,7 +3679,7 @@ var GoogleMeetRuntime = class {
 			this.#refreshSpeechReadiness(session);
 			return;
 		}
-		if (!options.force && session.mode === "realtime" && evaluateSpeechReadiness(session).ready) {
+		if (!options.force && isGoogleMeetTalkBackMode$1(session.mode) && evaluateSpeechReadiness(session).ready) {
 			this.#refreshSpeechReadiness(session);
 			return;
 		}
@@ -2724,7 +3721,7 @@ var GoogleMeetRuntime = class {
 		}
 	}
 	async #ensureChromeRealtimeBridge(session) {
-		if (session.mode !== "realtime" || session.transport !== "chrome" || session.state !== "active" || !session.chrome || session.chrome.audioBridge) return;
+		if (!isGoogleMeetTalkBackMode$1(session.mode) || session.transport !== "chrome" || session.state !== "active" || !session.chrome || session.chrome.audioBridge) return;
 		const health = session.chrome.health;
 		if (health?.inCall !== true || health.micMuted === true || health.manualActionRequired === true) return;
 		const result = await launchChromeMeet({
@@ -2792,7 +3789,7 @@ const googleMeetConfigSchema = {
 		},
 		defaultMode: {
 			label: "Default Mode",
-			help: "Realtime starts the duplex voice model loop. Transcribe joins/observes without the realtime talk-back bridge."
+			help: "Agent uses realtime transcription plus regular OpenClaw TTS. Bidi uses the realtime voice model directly. Transcribe observes only."
 		},
 		"chrome.audioBackend": {
 			label: "Chrome Audio Backend",
@@ -2825,6 +3822,11 @@ const googleMeetConfigSchema = {
 			help: "Command-pair audio format. PCM16 24 kHz is the default Chrome/Meet path; G.711 mu-law 8 kHz remains available for legacy command pairs.",
 			advanced: true
 		},
+		"chrome.audioBufferBytes": {
+			label: "Audio Buffer Bytes",
+			help: "SoX processing buffer for generated Chrome command-pair audio commands. Lower values reduce latency but may underrun on busy hosts.",
+			advanced: true
+		},
 		"chrome.audioInputCommand": {
 			label: "Audio Input Command",
 			help: "Command that writes meeting audio to stdout in chrome.audioFormat.",
@@ -2908,12 +3910,25 @@ const googleMeetConfigSchema = {
 			label: "Voice Call Intro Message",
 			advanced: true
 		},
+		"realtime.strategy": {
+			label: "Realtime Strategy",
+			help: "Legacy realtime alias setting. Use mode=agent or mode=bidi for new Meet joins."
+		},
 		"realtime.provider": {
-			label: "Realtime Provider",
-			help: "Defaults to OpenAI; uses OPENAI_API_KEY when no provider config is set."
+			label: "Speech Provider",
+			help: "Compatibility fallback for both realtime transcription and bidi voice. Prefer realtime.transcriptionProvider and realtime.voiceProvider for new configs."
+		},
+		"realtime.transcriptionProvider": {
+			label: "Realtime Transcription Provider",
+			help: "Agent mode uses this provider to transcribe meeting audio before regular OpenClaw TTS answers."
+		},
+		"realtime.voiceProvider": {
+			label: "Bidi Voice Provider",
+			help: "Bidi mode uses this realtime voice provider. Falls back to realtime.provider when unset."
 		},
 		"realtime.model": {
-			label: "Realtime Model",
+			label: "Bidi Realtime Model",
+			help: "Only used by mode=bidi. Agent mode answers with the configured OpenClaw agent and regular TTS.",
 			advanced: true
 		},
 		"realtime.instructions": {
@@ -3001,8 +4016,12 @@ const GoogleMeetToolSchema = Type.Object({
 		description: "Join transport"
 	})),
 	mode: Type.Optional(Type.String({
-		enum: ["realtime", "transcribe"],
-		description: "Join mode. realtime starts live listen/talk-back through the realtime voice model; transcribe joins without the realtime talk-back bridge."
+		enum: [
+			"agent",
+			"bidi",
+			"transcribe"
+		],
+		description: "Join mode. agent uses realtime transcription, the configured OpenClaw agent, and regular TTS. bidi uses the realtime voice model directly. transcribe joins observe-only."
 	})),
 	dialInNumber: Type.Optional(Type.String({ description: "Meet dial-in phone number for Twilio. Required for Twilio unless twilio.defaultDialInNumber is configured; Meet URLs cannot be dialed directly." })),
 	pin: Type.Optional(Type.String({ description: "Meet phone PIN for Twilio; # is appended if omitted" })),
@@ -3047,7 +4066,11 @@ function normalizeTransport(value) {
 	return value === "chrome" || value === "chrome-node" || value === "twilio" ? value : void 0;
 }
 function normalizeMode(value) {
-	return value === "realtime" || value === "transcribe" ? value : void 0;
+	if (value === "realtime") return "agent";
+	return value === "agent" || value === "bidi" || value === "transcribe" ? value : void 0;
+}
+function isGoogleMeetTalkBackMode(mode) {
+	return mode === "agent" || mode === "bidi";
 }
 function resolveMeetingInput(config, value) {
 	const meeting = normalizeOptionalString(value) ?? config.defaults.meeting;
@@ -3091,12 +4114,12 @@ function isGoogleMeetAgentToolActionUnsupportedOnHost(params) {
 	const action = params.raw.action;
 	if (action !== "join" && action !== "test_speech" && !(action === "create" && shouldJoinCreatedMeet(params.raw))) return false;
 	const transport = normalizeTransport(params.raw.transport) ?? params.config.defaultTransport;
-	const mode = action === "test_speech" ? "realtime" : normalizeMode(params.raw.mode) ?? params.config.defaultMode;
-	return transport === "chrome" && mode === "realtime";
+	const mode = action === "test_speech" ? "agent" : normalizeMode(params.raw.mode) ?? params.config.defaultMode;
+	return transport === "chrome" && isGoogleMeetTalkBackMode(mode);
 }
 function assertGoogleMeetAgentToolActionSupported(params) {
 	if (!isGoogleMeetAgentToolActionUnsupportedOnHost(params)) return;
-	throw new Error("Google Meet local Chrome realtime audio is macOS-only. On this host, use mode: transcribe, transport: twilio, or transport: chrome-node backed by a macOS node.");
+	throw new Error("Google Meet local Chrome talk-back audio is macOS-only. On this host, use mode: transcribe, transport: twilio, or transport: chrome-node backed by a macOS node.");
 }
 function resolveGoogleMeetToolGatewayTimeoutMs(config) {
 	return Math.max(6e4, config.chrome.joinTimeoutMs + 3e4, config.voiceCall.requestTimeoutMs + 1e4);
@@ -3118,10 +4141,10 @@ async function callGoogleMeetGatewayFromTool(params) {
 	}
 }
 async function createMeetFromParams(params) {
-	return (await import("./create-0ye_2zVk.js")).createMeetFromParams(params);
+	return (await import("./create-mHH3keLH.js")).createMeetFromParams(params);
 }
 async function createAndJoinMeetFromParams(params) {
-	return (await import("./create-0ye_2zVk.js")).createAndJoinMeetFromParams(params);
+	return (await import("./create-mHH3keLH.js")).createAndJoinMeetFromParams(params);
 }
 async function resolveGoogleMeetTokenFromParams(config, raw) {
 	const { resolveGoogleMeetAccessToken } = await import("./oauth-BJwzuzT-.js");
@@ -3213,7 +4236,7 @@ async function exportGoogleMeetBundleFromParams(config, raw) {
 		lateAfterMinutes: resolved.lateAfterMinutes,
 		earlyBeforeMinutes: resolved.earlyBeforeMinutes
 	})]);
-	const { buildGoogleMeetExportManifest, googleMeetExportFileNames, writeMeetExportBundle } = await import("./cli-B_wJa8XB.js");
+	const { buildGoogleMeetExportManifest, googleMeetExportFileNames, writeMeetExportBundle } = await import("./cli-CP1gp7Wl.js");
 	const calendarId = normalizeOptionalString(raw.calendarId);
 	const request = {
 		...resolved.meeting ? { meeting: resolved.meeting } : {},
@@ -3290,7 +4313,8 @@ var google_meet_default = definePluginEntry({
 					dialInNumber: normalizeOptionalString(params?.dialInNumber),
 					pin: normalizeOptionalString(params?.pin),
 					dtmfSequence: normalizeOptionalString(params?.dtmfSequence),
-					message: normalizeOptionalString(params?.message)
+					message: normalizeOptionalString(params?.message),
+					requesterSessionKey: normalizeOptionalString(params?.requesterSessionKey)
 				}));
 			} catch (err) {
 				sendError(respond, err);
@@ -3460,7 +4484,8 @@ var google_meet_default = definePluginEntry({
 					dialInNumber: normalizeOptionalString(params?.dialInNumber),
 					pin: normalizeOptionalString(params?.pin),
 					dtmfSequence: normalizeOptionalString(params?.dtmfSequence),
-					message: normalizeOptionalString(params?.message)
+					message: normalizeOptionalString(params?.message),
+					requesterSessionKey: normalizeOptionalString(params?.requesterSessionKey)
 				}));
 			} catch (err) {
 				sendError(respond, err);
@@ -3478,13 +4503,18 @@ var google_meet_default = definePluginEntry({
 				sendError(respond, err);
 			}
 		});
-		api.registerTool({
+		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. If local Chrome realtime audio is unsupported on this OS, use mode=transcribe, transport=twilio, or a macOS chrome-node for realtime Chrome. 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. If local Chrome talk-back audio is unsupported on this OS, use mode=transcribe, transport=twilio, or a macOS chrome-node for agent/bidi Chrome. 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.",
 			parameters: GoogleMeetToolSchema,
 			async execute(_toolCallId, params) {
 				const raw = asParamRecord(params);
+				const requesterSessionKey = normalizeOptionalString(toolContext.sessionKey);
+				const rawWithRequester = requesterSessionKey ? {
+					...raw,
+					requesterSessionKey
+				} : raw;
 				try {
 					assertGoogleMeetAgentToolActionSupported({
 						config,
@@ -3494,17 +4524,17 @@ var google_meet_default = definePluginEntry({
 						case "join": return json(await callGoogleMeetGatewayFromTool({
 							config,
 							action: "join",
-							raw
+							raw: rawWithRequester
 						}));
 						case "create": return json(await callGoogleMeetGatewayFromTool({
 							config,
 							action: "create",
-							raw
+							raw: rawWithRequester
 						}));
 						case "test_speech": return json(await callGoogleMeetGatewayFromTool({
 							config,
 							action: "test_speech",
-							raw
+							raw: rawWithRequester
 						}));
 						case "test_listen": return json(await callGoogleMeetGatewayFromTool({
 							config,
@@ -3615,14 +4645,14 @@ var google_meet_default = definePluginEntry({
 					return json(formatGatewayError(err));
 				}
 			}
-		});
+		}), { name: "google_meet" });
 		api.registerNodeHostCommand({
 			command: "googlemeet.chrome",
 			cap: "google-meet",
 			handle: handleGoogleMeetNodeHostCommand
 		});
 		api.registerCli(async ({ program }) => {
-			const { registerGoogleMeetCli } = await import("./cli-B_wJa8XB.js");
+			const { registerGoogleMeetCli } = await import("./cli-CP1gp7Wl.js");
 			registerGoogleMeetCli({
 				program,
 				config,