Plugin Google Meet

Google Meet participant support for OpenClaw — the plugin is explicit by design:

• It only joins an explicit https://meet.google.com/... URL.
• It can create a new Meet space through the Google Meet API, then join the returned URL.
• agent is the default talk-back mode: realtime transcription listens, the configured OpenClaw agent answers, and regular OpenClaw TTS speaks into Meet.
• bidi remains available as the fallback direct realtime voice model mode.
• Agents choose the join behavior with mode: use agent for live listen/talk-back, bidi for direct realtime voice fallback, or transcribe to join/control the browser without the talk-back bridge.
• Auth starts as personal Google OAuth or an already signed-in Chrome profile.
• There is no automatic consent announcement.
• The default Chrome audio backend is BlackHole 2ch.
• Chrome can run locally or on a paired node host.
• Twilio accepts a dial-in number plus optional PIN or DTMF sequence; it cannot dial a Meet URL directly.
• The CLI command is googlemeet; meet is reserved for broader agent teleconference workflows.

Quick start

Install the local audio dependencies and configure a realtime transcription provider plus regular OpenClaw TTS. OpenAI is the default transcription provider; Google Gemini Live also works as a separate bidi voice fallback with realtime.voiceProvider: "google":

brew install blackhole-2ch soxexport OPENAI_API_KEY=sk-...# only needed when realtime.voiceProvider is "google" for bidi modeexport GEMINI_API_KEY=...

blackhole-2ch installs the BlackHole 2ch virtual audio device. Homebrew's installer requires a reboot before macOS exposes the device:

sudo reboot

After reboot, verify both pieces:

system_profiler SPAudioDataType | grep -i BlackHolecommand -v sox

Enable the plugin:

{  plugins: {    entries: {      "google-meet": {        enabled: true,        config: {},      },    },  },}

Check setup:

openclaw googlemeet setup

The setup output is meant to be agent-readable and mode-aware. It reports Chrome profile, node pinning, and, for realtime Chrome joins, the BlackHole/SoX audio bridge and delayed realtime intro checks. For observe-only joins, check the same transport with --mode transcribe; that mode skips realtime audio prerequisites because it does not listen through or speak through the bridge:

openclaw googlemeet setup --transport chrome-node --mode transcribe

When Twilio delegation is configured, setup also reports whether the voice-call plugin, Twilio credentials, and public webhook exposure are ready. Treat any ok: false check as a blocker for the checked transport and mode before asking an agent to join. Use openclaw googlemeet setup --json for scripts or machine-readable output. Use --transport chrome, --transport chrome-node, or --transport twilio to preflight a specific transport before an agent tries it.

For Twilio, always preflight the transport explicitly when the default transport is Chrome:

openclaw googlemeet setup --transport twilio

That catches missing voice-call wiring, Twilio credentials, or unreachable webhook exposure before the agent tries to dial the meeting.

Join a meeting:

openclaw googlemeet join https://meet.google.com/abc-defg-hij

Or let an agent join through the google_meet tool:

{  "action": "join",  "url": "https://meet.google.com/abc-defg-hij",  "transport": "chrome-node",  "mode": "agent"}

The agent-facing google_meet tool stays available on non-macOS hosts for artifact, calendar, setup, transcribe, Twilio, and chrome-node flows. Local Chrome talk-back actions are blocked there because the bundled Chrome audio path currently depends on macOS BlackHole 2ch. On Linux, use mode: "transcribe", Twilio dial-in, or a macOS chrome-node host for Chrome talk-back participation.

Create a new meeting and join it:

openclaw googlemeet create --transport chrome-node --mode agent

For API-created rooms, use Google Meet SpaceConfig.accessType when you want the room's no-knock policy to be explicit instead of inherited from the Google account defaults:

openclaw googlemeet create --access-type OPEN --transport chrome-node --mode agent

OPEN lets anyone with the Meet URL join without knocking. TRUSTED lets the host organization's trusted users, invited external users, and dial-in users join without knocking. RESTRICTED limits no-knock entry to invitees. These settings only apply to the official Google Meet API creation path, so OAuth credentials must be configured.

If you authenticated Google Meet before this option was available, rerun openclaw googlemeet auth login --json after adding the meetings.space.settings scope to your Google OAuth consent screen.

Create only the URL without joining:

openclaw googlemeet create --no-join

googlemeet create has two paths:

• API create: used when Google Meet OAuth credentials are configured. This is the most deterministic path and does not depend on browser UI state.
• Browser fallback: used when OAuth credentials are absent. OpenClaw uses the pinned Chrome node, opens https://meet.google.com/new, waits for Google to redirect to a real meeting-code URL, then returns that URL. This path requires the OpenClaw Chrome profile on the node to already be signed in to Google. Browser automation handles Meet's own first-run microphone prompt; that prompt is not treated as a Google login failure. Join and create flows also try to reuse an existing Meet tab before opening a new one. Matching ignores harmless URL query strings such as authuser, so an agent retry should focus the already-open meeting instead of creating a second Chrome tab.

The command/tool output includes a source field (api or browser) so agents can explain which path was used. create joins the new meeting by default and returns joined: true plus the join session. To only mint the URL, use create --no-join on the CLI or pass "join": false to the tool.

Or tell an agent: "Create a Google Meet, join it with the agent talk-back mode, and send me the link." The agent should call google_meet with action: "create" and then share the returned meetingUri.

{  "action": "create",  "transport": "chrome-node",  "mode": "agent"}

For an observe-only/browser-control join, set "mode": "transcribe". That does not start the duplex realtime voice bridge, does not require BlackHole or SoX, and will not talk back into the meeting. Chrome joins in this mode also avoid OpenClaw's microphone/camera permission grant and avoid the Meet Use microphone path. If Meet shows an audio-choice interstitial, automation tries the no-microphone path and otherwise reports a manual action instead of opening the local microphone. In transcribe mode, managed Chrome transports also install a best-effort Meet caption observer. googlemeet status --json and googlemeet doctor surface captioning, captionsEnabledAttempted, transcriptLines, lastCaptionAt, lastCaptionSpeaker, lastCaptionText, and a short recentTranscript tail so operators can tell whether the browser joined the call and whether Meet captions are producing text. Use openclaw googlemeet test-listen <meet-url> --transport chrome-node when you need a yes/no probe: it joins in transcribe mode, waits for fresh caption or transcript movement, and returns listenVerified, listenTimedOut, manual action fields, and the latest caption health.

During realtime sessions, google_meet status includes browser and audio bridge health such as inCall, manualActionRequired, providerConnected, realtimeReady, audioInputActive, audioOutputActive, last input/output timestamps, byte counters, and bridge closed state. If a safe Meet page prompt appears, browser automation handles it when it can. Login, host admission, and browser/OS permission prompts are reported as manual action with a reason and message for the agent to relay. Managed Chrome sessions only emit the intro or test phrase after browser health reports inCall: true; otherwise status reports speechReady: false and the speech attempt is blocked instead of pretending the agent spoke into the meeting.

Local Chrome joins through the signed-in OpenClaw browser profile. Realtime mode requires BlackHole 2ch for the microphone/speaker path used by OpenClaw. For clean duplex audio, use separate virtual devices or a Loopback-style graph; a single BlackHole device is enough for a first smoke test but can echo.

Local gateway + Parallels Chrome

You do not need a full OpenClaw Gateway or model API key inside a macOS VM just to make the VM own Chrome. Run the Gateway and agent locally, then run a node host in the VM. Enable the bundled plugin on the VM once so the node advertises the Chrome command:

What runs where:

• Gateway host: OpenClaw Gateway, agent workspace, model/API keys, realtime provider, and the Google Meet plugin config.
• Parallels macOS VM: OpenClaw CLI/node host, Google Chrome, SoX, BlackHole 2ch, and a Chrome profile signed in to Google.
• Not needed in the VM: Gateway service, agent config, OpenAI/GPT key, or model provider setup.

Install the VM dependencies:

brew install blackhole-2ch sox

Reboot the VM after installing BlackHole so macOS exposes BlackHole 2ch:

sudo reboot

After reboot, verify the VM can see the audio device and SoX commands:

system_profiler SPAudioDataType | grep -i BlackHolecommand -v sox

Install or update OpenClaw in the VM, then enable the bundled plugin there:

openclaw plugins enable google-meet

Start the node host in the VM:

openclaw node run --host <gateway-host> --port 18789 --display-name parallels-macos

If <gateway-host> is a LAN IP and you are not using TLS, the node refuses the plaintext WebSocket unless you opt in for that trusted private network:

OPENCLAW_ALLOW_INSECURE_PRIVATE_WS=1 \  openclaw node run --host <gateway-lan-ip> --port 18789 --display-name parallels-macos

Use the same environment variable when installing the node as a LaunchAgent:

OPENCLAW_ALLOW_INSECURE_PRIVATE_WS=1 \  openclaw node install --host <gateway-lan-ip> --port 18789 --display-name parallels-macos --forceopenclaw node restart

OPENCLAW_ALLOW_INSECURE_PRIVATE_WS=1 is process environment, not an openclaw.json setting. openclaw node install stores it in the LaunchAgent environment when it is present on the install command.

Approve the node from the Gateway host:

openclaw devices listopenclaw devices approve <requestId>

Confirm the Gateway sees the node and that it advertises both googlemeet.chrome and browser capability/browser.proxy:

openclaw nodes status

Route Meet through that node on the Gateway host:

{  gateway: {    nodes: {      allowCommands: ["googlemeet.chrome", "browser.proxy"],    },  },  plugins: {    entries: {      "google-meet": {        enabled: true,        config: {          defaultTransport: "chrome-node",          chrome: {            guestName: "OpenClaw Agent",            autoJoin: true,            reuseExistingTab: true,          },          chromeNode: {            node: "parallels-macos",          },        },      },    },  },}

Now join normally from the Gateway host:

openclaw googlemeet join https://meet.google.com/abc-defg-hij

or ask the agent to use the google_meet tool with transport: "chrome-node".

For a one-command smoke test that creates or reuses a session, speaks a known phrase, and prints session health:

openclaw googlemeet test-speech https://meet.google.com/abc-defg-hij

Durante l'accesso in realtime, l'automazione del browser di OpenClaw inserisce il nome dell'ospite, fa clic su Join/Ask to join e accetta la scelta di primo avvio "Use microphone" di Meet quando compare il prompt. Durante l'accesso in sola osservazione o la creazione di una riunione solo da browser, prosegue oltre lo stesso prompt senza microfono quando questa scelta è disponibile. Se il profilo del browser non ha eseguito l'accesso, Meet è in attesa dell'ammissione da parte dell'host, Chrome richiede l'autorizzazione per microfono/camera per un accesso realtime, oppure Meet è bloccato su un prompt che l'automazione non è riuscita a risolvere, il risultato di accesso/test-speech segnala manualActionRequired: true con manualActionReason e manualActionMessage. Gli agenti devono smettere di ritentare l'accesso, riportare esattamente quel messaggio insieme agli attuali browserUrl/browserTitle, e ritentare solo dopo che l'azione manuale nel browser è stata completata.

Se chromeNode.node viene omesso, OpenClaw seleziona automaticamente solo quando esattamente un nodo connesso dichiara sia googlemeet.chrome sia il controllo del browser. Se sono connessi più nodi idonei, imposta chromeNode.node sull'id del nodo, sul nome visualizzato o sull'IP remoto.

Controlli comuni degli errori:

• Configured Google Meet node ... is not usable: offline: il nodo fissato è noto al Gateway ma non disponibile. Gli agenti devono trattare quel nodo come stato diagnostico, non come host Chrome utilizzabile, e riportare il blocco di configurazione invece di ripiegare su un altro transport, a meno che l'utente non lo abbia richiesto.
• No connected Google Meet-capable node: avvia openclaw node run nella VM, approva l'associazione e assicurati che openclaw plugins enable google-meet e openclaw plugins enable browser siano stati eseguiti nella VM. Conferma inoltre che l'host Gateway consenta entrambi i comandi del nodo con gateway.nodes.allowCommands: ["googlemeet.chrome", "browser.proxy"].
• BlackHole 2ch audio device not found: installa blackhole-2ch sull'host controllato e riavvia prima di usare l'audio di Chrome locale.
• BlackHole 2ch audio device not found on the node: installa blackhole-2ch nella VM e riavvia la VM.
• Chrome si apre ma non riesce ad accedere: esegui l'accesso al profilo del browser dentro la VM, oppure mantieni chrome.guestName impostato per l'accesso come ospite. L'accesso automatico come ospite usa l'automazione del browser di OpenClaw tramite il proxy browser del nodo; assicurati che la configurazione del browser del nodo punti al profilo desiderato, per esempio browser.defaultProfile: "user" o un profilo di sessione esistente con nome.
• Schede Meet duplicate: lascia chrome.reuseExistingTab: true abilitato. OpenClaw attiva una scheda esistente per lo stesso URL Meet prima di aprirne una nuova, e la creazione di riunioni da browser riutilizza una scheda https://meet.google.com/new o un prompt dell'account Google in corso prima di aprirne un'altra.
• Nessun audio: in Meet, instrada microfono/altoparlante attraverso il percorso del dispositivo audio virtuale usato da OpenClaw; usa dispositivi virtuali separati o routing in stile Loopback per audio duplex pulito.

Note di installazione

Il default talk-back di Chrome usa due strumenti esterni:

• sox: utility audio da riga di comando. Il plugin usa comandi espliciti del dispositivo CoreAudio per il bridge audio PCM16 predefinito a 24 kHz.
• blackhole-2ch: driver audio virtuale per macOS. Crea il dispositivo audio BlackHole 2ch attraverso cui Chrome/Meet può instradare l'audio.

OpenClaw non include né ridistribuisce nessuno dei due pacchetti. La documentazione chiede agli utenti di installarli come dipendenze dell'host tramite Homebrew. SoX è concesso in licenza come LGPL-2.0-only AND GPL-2.0-only; BlackHole è GPL-3.0. Se crei un installer o un'appliance che include BlackHole con OpenClaw, rivedi i termini di licenza upstream di BlackHole o ottieni una licenza separata da Existential Audio.

Transport

Chrome

Il transport Chrome apre l'URL Meet tramite il controllo browser di OpenClaw e accede come profilo browser OpenClaw con accesso effettuato. Su macOS, il plugin verifica la presenza di BlackHole 2ch prima dell'avvio. Se configurato, esegue anche un comando di salute del bridge audio e un comando di avvio prima di aprire Chrome. Usa chrome quando Chrome/audio sono sull'host Gateway; usa chrome-node quando Chrome/audio sono su un nodo associato, come una VM macOS Parallels. Per Chrome locale, scegli il profilo con browser.defaultProfile; chrome.browserProfile viene passato agli host chrome-node.

openclaw googlemeet join https://meet.google.com/abc-defg-hij --transport chromeopenclaw googlemeet join https://meet.google.com/abc-defg-hij --transport chrome-node

Instrada l'audio del microfono e degli altoparlanti di Chrome attraverso il bridge audio locale di OpenClaw. Se BlackHole 2ch non è installato, l'accesso fallisce con un errore di configurazione invece di accedere silenziosamente senza un percorso audio.

Twilio

Il transport Twilio è un piano di chiamata rigoroso delegato al plugin Voice Call. Non analizza le pagine Meet per trovare numeri di telefono.

Usalo quando la partecipazione tramite Chrome non è disponibile o vuoi un fallback di accesso telefonico. Google Meet deve esporre un numero di accesso telefonico e un PIN per la riunione; OpenClaw non li scopre dalla pagina Meet.

Abilita il plugin Voice Call sull'host Gateway, non sul nodo Chrome:

{  plugins: {    allow: ["google-meet", "voice-call", "google"],    entries: {      "google-meet": {        enabled: true,        config: {          defaultTransport: "chrome-node",          // or set "twilio" if Twilio should be the default        },      },      "voice-call": {        enabled: true,        config: {          provider: "twilio",          inboundPolicy: "allowlist",          realtime: {            enabled: true,            provider: "google",            instructions: "Join this Google Meet as an OpenClaw agent. Be brief.",            toolPolicy: "safe-read-only",            providers: {              google: {                silenceDurationMs: 500,                startSensitivity: "high",              },            },          },        },      },      google: {        enabled: true,      },    },  },}

Fornisci le credenziali Twilio tramite ambiente o configurazione. L'ambiente mantiene i segreti fuori da openclaw.json:

export TWILIO_ACCOUNT_SID=AC...export TWILIO_AUTH_TOKEN=...export TWILIO_FROM_NUMBER=+15550001234export GEMINI_API_KEY=...

Usa invece realtime.provider: "openai" con il plugin provider OpenAI e OPENAI_API_KEY se quello è il tuo provider vocale realtime.

Riavvia o ricarica il Gateway dopo aver abilitato voice-call; le modifiche alla configurazione del plugin non compaiono in un processo Gateway già in esecuzione finché non viene ricaricato.

Poi verifica:

openclaw config validateopenclaw plugins list | grep -E 'google-meet|voice-call'openclaw googlemeet setup

Quando la delega Twilio è collegata, googlemeet setup include controlli riusciti twilio-voice-call-plugin, twilio-voice-call-credentials e twilio-voice-call-webhook.

openclaw googlemeet join https://meet.google.com/abc-defg-hij \  --transport twilio \  --dial-in-number +15551234567 \  --pin 123456

Usa --dtmf-sequence quando la riunione richiede una sequenza personalizzata:

openclaw googlemeet join https://meet.google.com/abc-defg-hij \  --transport twilio \  --dial-in-number +15551234567 \  --dtmf-sequence ww123456#

OAuth e controlli preliminari

OAuth è facoltativo per creare un link Meet perché googlemeet create può ricorrere all'automazione del browser. Configura OAuth quando vuoi la creazione tramite API ufficiale, la risoluzione degli spazi o i controlli preliminari della Meet Media API.

L'accesso alla Google Meet API usa OAuth utente: crea un client OAuth Google Cloud, richiedi gli ambiti necessari, autorizza un account Google, quindi archivia il refresh token risultante nella configurazione del plugin Google Meet oppure fornisci le variabili d'ambiente OPENCLAW_GOOGLE_MEET_*.

OAuth non sostituisce il percorso di partecipazione tramite Chrome. I trasporti Chrome e Chrome-node continuano a partecipare tramite un profilo Chrome con accesso effettuato, BlackHole/SoX e un nodo connesso quando usi la partecipazione tramite browser. OAuth serve solo per il percorso ufficiale della Google Meet API: creare spazi riunione, risolvere spazi ed eseguire controlli preliminari della Meet Media API.

Crea le credenziali Google

In Google Cloud Console:

1. Crea o seleziona un progetto Google Cloud.

2. Abilita Google Meet REST API per quel progetto.

3. Configura la schermata di consenso OAuth.

   • Internal è l'opzione più semplice per un'organizzazione Google Workspace.
   • External funziona per configurazioni personali/di test; mentre l'app è in Testing, aggiungi ogni account Google che autorizzerà l'app come utente di test.

4. Aggiungi gli ambiti richiesti da OpenClaw:

   • https://www.googleapis.com/auth/meetings.space.created
   • https://www.googleapis.com/auth/meetings.space.readonly
   • https://www.googleapis.com/auth/meetings.space.settings
   • https://www.googleapis.com/auth/meetings.conference.media.readonly

5. Crea un ID client OAuth.

   • Tipo di applicazione: Web application.

   • URI di reindirizzamento autorizzato:

     http://localhost:8085/oauth2callback

6. Copia l'ID client e il client secret.

meetings.space.created è richiesto da Google Meet spaces.create. meetings.space.readonly consente a OpenClaw di risolvere URL/codici Meet in spazi. meetings.space.settings consente a OpenClaw di passare impostazioni SpaceConfig come accessType durante la creazione di stanze tramite API. meetings.conference.media.readonly serve per i controlli preliminari della Meet Media API e per il lavoro sui media; Google potrebbe richiedere l'iscrizione alla Developer Preview per l'uso effettivo della Media API. Se ti servono solo partecipazioni Chrome basate su browser, salta completamente OAuth.

Genera il refresh token

Configura oauth.clientId e facoltativamente oauth.clientSecret, oppure passali come variabili d'ambiente, quindi esegui:

openclaw googlemeet auth login --json

Il comando stampa un blocco di configurazione oauth con un refresh token. Usa PKCE, callback localhost su http://localhost:8085/oauth2callback e un flusso manuale di copia/incolla con --manual.

Esempi:

OPENCLAW_GOOGLE_MEET_CLIENT_ID="your-client-id" \OPENCLAW_GOOGLE_MEET_CLIENT_SECRET="your-client-secret" \openclaw googlemeet auth login --json

Usa la modalità manuale quando il browser non può raggiungere la callback locale:

OPENCLAW_GOOGLE_MEET_CLIENT_ID="your-client-id" \OPENCLAW_GOOGLE_MEET_CLIENT_SECRET="your-client-secret" \openclaw googlemeet auth login --json --manual

L'output JSON include:

{  "oauth": {    "clientId": "your-client-id",    "clientSecret": "your-client-secret",    "refreshToken": "refresh-token",    "accessToken": "access-token",    "expiresAt": 1770000000000  },  "scope": "..."}

Archivia l'oggetto oauth nella configurazione del plugin Google Meet:

{  plugins: {    entries: {      "google-meet": {        enabled: true,        config: {          oauth: {            clientId: "your-client-id",            clientSecret: "your-client-secret",            refreshToken: "refresh-token",          },        },      },    },  },}

Preferisci le variabili d'ambiente quando non vuoi inserire il refresh token nella configurazione. Se sono presenti sia valori di configurazione sia valori d'ambiente, il plugin risolve prima la configurazione e poi usa l'ambiente come fallback.

Il consenso OAuth include la creazione di spazi Meet, l'accesso in lettura agli spazi Meet e l'accesso in lettura ai contenuti multimediali delle conferenze Meet. Se hai eseguito l'autenticazione prima che esistesse il supporto per la creazione di riunioni, riesegui openclaw googlemeet auth login --json in modo che il refresh token abbia l'ambito meetings.space.created.

Verifica OAuth con doctor

Esegui il doctor OAuth quando vuoi un controllo di integrità rapido e senza segreti:

openclaw googlemeet doctor --oauth --json

Questo non carica il runtime Chrome e non richiede un nodo Chrome connesso. Verifica che la configurazione OAuth esista e che il refresh token possa generare un access token. Il report JSON include solo campi di stato come ok, configured, tokenSource, expiresAt e messaggi di controllo; non stampa l'access token, il refresh token o il client secret.

Risultati comuni:

Per dimostrare anche l'abilitazione dell'API Google Meet e l'ambito spaces.create, esegui la verifica di creazione con effetti collaterali:

openclaw googlemeet doctor --oauth --create-space --jsonopenclaw googlemeet create --no-join --json

--create-space crea un URL Meet temporaneo. Usalo quando devi confermare che il progetto Google Cloud abbia l'API Meet abilitata e che l'account autorizzato abbia l'ambito meetings.space.created.

Per dimostrare l'accesso in lettura a uno spazio riunione esistente:

openclaw googlemeet doctor --oauth --meeting https://meet.google.com/abc-defg-hij --jsonopenclaw googlemeet resolve-space --meeting https://meet.google.com/abc-defg-hij

doctor --oauth --meeting e resolve-space dimostrano l'accesso in lettura a uno spazio esistente a cui l'account Google autorizzato può accedere. Un 403 da queste verifiche di solito significa che l'API REST di Google Meet è disabilitata, che al token di aggiornamento con consenso manca l'ambito richiesto, oppure che l'account Google non può accedere a quello spazio Meet. Un errore del token di aggiornamento significa rieseguire openclaw googlemeet auth login --json e salvare il nuovo blocco oauth.

Non sono necessarie credenziali OAuth per il fallback del browser. In quella modalità, l'autenticazione Google proviene dal profilo Chrome con accesso effettuato sul nodo selezionato, non dalla configurazione OpenClaw.

Queste variabili d'ambiente sono accettate come fallback:

• OPENCLAW_GOOGLE_MEET_CLIENT_ID o GOOGLE_MEET_CLIENT_ID
• OPENCLAW_GOOGLE_MEET_CLIENT_SECRET o GOOGLE_MEET_CLIENT_SECRET
• OPENCLAW_GOOGLE_MEET_REFRESH_TOKEN o GOOGLE_MEET_REFRESH_TOKEN
• OPENCLAW_GOOGLE_MEET_ACCESS_TOKEN o GOOGLE_MEET_ACCESS_TOKEN
• OPENCLAW_GOOGLE_MEET_ACCESS_TOKEN_EXPIRES_AT o GOOGLE_MEET_ACCESS_TOKEN_EXPIRES_AT
• OPENCLAW_GOOGLE_MEET_DEFAULT_MEETING o GOOGLE_MEET_DEFAULT_MEETING
• OPENCLAW_GOOGLE_MEET_PREVIEW_ACK o GOOGLE_MEET_PREVIEW_ACK

Risolvi un URL Meet, un codice o spaces/{id} tramite spaces.get:

openclaw googlemeet resolve-space --meeting https://meet.google.com/abc-defg-hij

Esegui il preflight prima del lavoro multimediale:

openclaw googlemeet preflight --meeting https://meet.google.com/abc-defg-hij

Elenca gli artefatti della riunione e le presenze dopo che Meet ha creato i record della conferenza:

openclaw googlemeet artifacts --meeting https://meet.google.com/abc-defg-hijopenclaw googlemeet attendance --meeting https://meet.google.com/abc-defg-hijopenclaw googlemeet export --meeting https://meet.google.com/abc-defg-hij --output ./meet-export

Con --meeting, artifacts e attendance usano per impostazione predefinita il record della conferenza più recente. Passa --all-conference-records quando vuoi ogni record conservato per quella riunione.

La ricerca nel calendario può risolvere l'URL della riunione da Google Calendar prima di leggere gli artefatti Meet:

openclaw googlemeet latest --todayopenclaw googlemeet calendar-events --today --jsonopenclaw googlemeet artifacts --event "Weekly sync"openclaw googlemeet attendance --today --format csv --output attendance.csv

--today cerca nel calendario primary di oggi un evento Calendar con un link Google Meet. Usa --event <query> per cercare testo evento corrispondente e --calendar <id> per un calendario non primario. La ricerca nel calendario richiede un nuovo accesso OAuth che includa l'ambito di sola lettura degli eventi Calendar. calendar-events mostra un'anteprima degli eventi Meet corrispondenti e contrassegna l'evento che latest, artifacts, attendance o export sceglierà.

Se conosci già l'id del record della conferenza, indirizzalo direttamente:

openclaw googlemeet latest --meeting https://meet.google.com/abc-defg-hijopenclaw googlemeet artifacts --conference-record conferenceRecords/abc123 --jsonopenclaw googlemeet attendance --conference-record conferenceRecords/abc123 --json

Termina una conferenza attiva per uno spazio creato dall'API quando vuoi chiudere la stanza dopo la chiamata:

openclaw googlemeet end-active-conference https://meet.google.com/abc-defg-hij

Questo chiama Google Meet spaces.endActiveConference e richiede OAuth con l'ambito meetings.space.created per uno spazio che l'account autorizzato può gestire. OpenClaw accetta un URL Meet, un codice riunione o un input spaces/{id} e lo risolve nella risorsa spazio API prima di terminare la conferenza attiva. È separato da googlemeet leave: leave interrompe la partecipazione locale/di sessione di OpenClaw, mentre end-active-conference chiede a Google Meet di terminare la conferenza attiva per lo spazio.

Scrivi un report leggibile:

openclaw googlemeet artifacts --conference-record conferenceRecords/abc123 \  --format markdown --output meet-artifacts.mdopenclaw googlemeet attendance --conference-record conferenceRecords/abc123 \  --format markdown --output meet-attendance.mdopenclaw googlemeet attendance --conference-record conferenceRecords/abc123 \  --format csv --output meet-attendance.csvopenclaw googlemeet export --conference-record conferenceRecords/abc123 \  --include-doc-bodies --zip --output meet-exportopenclaw googlemeet export --conference-record conferenceRecords/abc123 \  --include-doc-bodies --dry-run

artifacts restituisce i metadati del record della conferenza più i metadati delle risorse di partecipanti, registrazioni, trascrizioni, voci di trascrizione strutturate e note intelligenti quando Google li espone per la riunione. Usa --no-transcript-entries per saltare la ricerca delle voci per riunioni di grandi dimensioni. attendance espande i partecipanti in righe di sessione partecipante con orari di prima/ultima visualizzazione, durata totale della sessione, flag di ritardo/uscita anticipata e risorse partecipante duplicate unite per utente con accesso effettuato o nome visualizzato. Passa --no-merge-duplicates per mantenere separate le risorse partecipante grezze, --late-after-minutes per regolare il rilevamento dei ritardi e --early-before-minutes per regolare il rilevamento dell'uscita anticipata.

export scrive una cartella contenente summary.md, attendance.csv, transcript.md, artifacts.json, attendance.json e manifest.json. manifest.json registra l'input scelto, le opzioni di esportazione, i record della conferenza, i file di output, i conteggi, l'origine del token, l'evento Calendar quando ne è stato usato uno e qualsiasi avviso di recupero parziale. Passa --zip per scrivere anche un archivio portatile accanto alla cartella. Passa --include-doc-bodies per esportare il testo dei documenti Google collegati di trascrizioni e note intelligenti tramite Google Drive files.export; questo richiede un nuovo accesso OAuth che includa l'ambito di sola lettura Drive Meet. Senza --include-doc-bodies, le esportazioni includono solo metadati Meet e voci di trascrizione strutturate. Se Google restituisce un errore parziale degli artefatti, come un errore di elenco delle note intelligenti, di voce di trascrizione o di corpo del documento Drive, il riepilogo e il manifest mantengono l'avviso invece di far fallire l'intera esportazione. Usa --dry-run per recuperare gli stessi dati di artefatti/presenze e stampare il JSON del manifest senza creare la cartella o lo ZIP. È utile prima di scrivere una grande esportazione o quando un agente ha bisogno solo di conteggi, record selezionati e avvisi.

Gli agenti possono creare lo stesso bundle anche tramite lo strumento google_meet:

{  "action": "export",  "conferenceRecord": "conferenceRecords/abc123",  "includeDocumentBodies": true,  "outputDir": "meet-export",  "zip": true}

Imposta "dryRun": true per restituire solo il manifest di esportazione e saltare le scritture dei file.

Gli agenti possono anche creare una stanza supportata dall'API con un criterio di accesso esplicito:

{  "action": "create",  "transport": "chrome-node",  "mode": "agent",  "accessType": "OPEN"}

E possono terminare la conferenza attiva per una stanza nota:

{  "action": "end_active_conference",  "meeting": "https://meet.google.com/abc-defg-hij"}

Per una validazione con ascolto preliminare, gli agenti dovrebbero usare test_listen prima di affermare che la riunione è utile:

{  "action": "test_listen",  "url": "https://meet.google.com/abc-defg-hij",  "transport": "chrome-node",  "timeoutMs": 30000}

Esegui il live smoke protetto su una riunione reale conservata:

OPENCLAW_LIVE_TEST=1 \OPENCLAW_GOOGLE_MEET_LIVE_MEETING=https://meet.google.com/abc-defg-hij \pnpm test:live -- extensions/google-meet/google-meet.live.test.ts

Esegui il probe live del browser con ascolto preliminare su una riunione in cui qualcuno parlerà con sottotitoli Meet disponibili:

openclaw googlemeet setup --transport chrome-node --mode transcribeopenclaw googlemeet test-listen https://meet.google.com/abc-defg-hij --transport chrome-node --timeout-ms 30000

Ambiente live smoke:

• OPENCLAW_LIVE_TEST=1 abilita i test live protetti.
• OPENCLAW_GOOGLE_MEET_LIVE_MEETING punta a un URL Meet, codice o spaces/{id} conservato.
• OPENCLAW_GOOGLE_MEET_CLIENT_ID o GOOGLE_MEET_CLIENT_ID fornisce l'id client OAuth.
• OPENCLAW_GOOGLE_MEET_REFRESH_TOKEN o GOOGLE_MEET_REFRESH_TOKEN fornisce il token di aggiornamento.
• Opzionale: OPENCLAW_GOOGLE_MEET_CLIENT_SECRET, OPENCLAW_GOOGLE_MEET_ACCESS_TOKEN e OPENCLAW_GOOGLE_MEET_ACCESS_TOKEN_EXPIRES_AT usano gli stessi nomi di fallback senza il prefisso OPENCLAW_.

Il live smoke di base per artefatti/presenze richiede https://www.googleapis.com/auth/meetings.space.readonly e https://www.googleapis.com/auth/meetings.conference.media.readonly. La ricerca nel calendario richiede https://www.googleapis.com/auth/calendar.events.readonly. L'esportazione del corpo dei documenti Drive richiede https://www.googleapis.com/auth/drive.meet.readonly.

Crea un nuovo spazio Meet:

openclaw googlemeet create

Il comando stampa il nuovo meeting uri, l'origine e la sessione di accesso. Con le credenziali OAuth usa l'API Google Meet ufficiale. Senza credenziali OAuth usa come fallback il profilo browser con accesso effettuato del nodo Chrome fissato. Gli agenti possono usare lo strumento google_meet con action: "create" per creare e accedere in un solo passaggio. Per la creazione solo URL, passa "join": false.

Esempio di output JSON dal fallback del browser:

{  "source": "browser",  "meetingUri": "https://meet.google.com/abc-defg-hij",  "joined": true,  "browser": {    "nodeId": "ba0f4e4bc...",    "targetId": "tab-1"  },  "join": {    "session": {      "id": "meet_...",      "url": "https://meet.google.com/abc-defg-hij"    }  }}

Se il fallback del browser incontra il login Google o un blocco di permessi Meet prima di poter creare l'URL, il metodo Gateway restituisce una risposta non riuscita e lo strumento google_meet restituisce dettagli strutturati invece di una stringa semplice:

{  "source": "browser",  "error": "google-login-required: Sign in to Google in the OpenClaw browser profile, then retry meeting creation.",  "manualActionRequired": true,  "manualActionReason": "google-login-required",  "manualActionMessage": "Sign in to Google in the OpenClaw browser profile, then retry meeting creation.",  "browser": {    "nodeId": "ba0f4e4bc...",    "targetId": "tab-1",    "browserUrl": "https://accounts.google.com/signin",    "browserTitle": "Sign in - Google Accounts"  }}

Quando un agente vede manualActionRequired: true, deve riportare il manualActionMessage più il contesto nodo/scheda del browser e smettere di aprire nuove schede Meet finché l'operatore non completa il passaggio nel browser.

Esempio di output JSON dalla creazione tramite API:

{  "source": "api",  "meetingUri": "https://meet.google.com/abc-defg-hij",  "joined": true,  "space": {    "name": "spaces/abc-defg-hij",    "meetingCode": "abc-defg-hij",    "meetingUri": "https://meet.google.com/abc-defg-hij"  },  "join": {    "session": {      "id": "meet_...",      "url": "https://meet.google.com/abc-defg-hij"    }  }}

La creazione di un Meet accede alla riunione per impostazione predefinita. Il trasporto Chrome o Chrome-node richiede comunque un profilo Google Chrome con accesso eseguito per partecipare tramite il browser. Se il profilo non ha effettuato l'accesso, OpenClaw segnala manualActionRequired: true o un errore di fallback del browser e chiede all'operatore di completare l'accesso a Google prima di riprovare.

Imposta preview.enrollmentAcknowledged: true solo dopo aver confermato che il tuo progetto Cloud, il principale OAuth e i partecipanti alla riunione sono iscritti al Google Workspace Developer Preview Program per le API multimediali di Meet.

Configurazione

Il percorso comune dell'agente Chrome richiede solo il plugin abilitato, BlackHole, SoX, una chiave del provider di trascrizione realtime e un provider TTS OpenClaw configurato. OpenAI è il provider di trascrizione predefinito; imposta realtime.voiceProvider su "google" e realtime.model per usare Google Gemini Live per la modalità bidi senza modificare il provider di trascrizione predefinito della modalità agente:

brew install blackhole-2ch soxexport OPENAI_API_KEY=sk-...# orexport GEMINI_API_KEY=...

Imposta la configurazione del plugin in plugins.entries.google-meet.config:

{  plugins: {    entries: {      "google-meet": {        enabled: true,        config: {},      },    },  },}

Valori predefiniti:

• defaultTransport: "chrome"
• defaultMode: "agent" ("realtime" è accettato solo come alias di compatibilità legacy per "agent"; le nuove chiamate agli strumenti dovrebbero indicare "agent")
• chromeNode.node: id/nome/IP opzionale del nodo per chrome-node
• chrome.audioBackend: "blackhole-2ch"
• chrome.guestName: "OpenClaw Agent": nome usato nella schermata ospite di Meet senza accesso eseguito
• chrome.autoJoin: true: compilazione best-effort del nome ospite e clic su Partecipa ora tramite l'automazione del browser OpenClaw su chrome-node
• chrome.reuseExistingTab: true: attiva una scheda Meet esistente invece di aprire duplicati
• chrome.waitForInCallMs: 20000: attende che la scheda Meet segnali di essere in chiamata prima di attivare l'introduzione talk-back
• chrome.audioFormat: "pcm16-24khz": formato audio della coppia di comandi. Usa "g711-ulaw-8khz" solo per coppie di comandi legacy/personalizzate che emettono ancora audio telefonico.
• chrome.audioBufferBytes: 4096: buffer di elaborazione SoX per i comandi audio della coppia di comandi Chrome generati. È metà del buffer predefinito di SoX da 8192 byte, riducendo la latenza predefinita della pipe e lasciando margine per aumentarlo su host occupati. I valori inferiori al minimo di SoX vengono limitati a 17 byte.
• chrome.audioInputCommand: comando SoX che legge da CoreAudio BlackHole 2ch e scrive audio in chrome.audioFormat
• chrome.audioOutputCommand: comando SoX che legge audio in chrome.audioFormat e scrive su CoreAudio BlackHole 2ch
• chrome.bargeInInputCommand: comando opzionale del microfono locale che scrive PCM mono little-endian firmato a 16 bit per il rilevamento dell'interruzione umana mentre la riproduzione dell'assistente è attiva. Attualmente si applica al bridge della coppia di comandi chrome ospitato dal Gateway.
• chrome.bargeInRmsThreshold: 650: livello RMS che conta come interruzione umana su chrome.bargeInInputCommand
• chrome.bargeInPeakThreshold: 2500: livello di picco che conta come interruzione umana su chrome.bargeInInputCommand
• chrome.bargeInCooldownMs: 900: ritardo minimo tra cancellazioni ripetute di interruzioni umane
• mode: "agent": modalità talk-back predefinita. Il parlato dei partecipanti viene trascritto dal provider di trascrizione realtime configurato, inviato all'agente OpenClaw configurato in una sessione di sub-agente per riunione e riprodotto vocalmente tramite il normale runtime TTS di OpenClaw.
• mode: "bidi": modalità fallback diretta del modello realtime bidirezionale. Il provider vocale realtime risponde direttamente al parlato dei partecipanti e può chiamare openclaw_agent_consult per risposte più approfondite/supportate da strumenti.
• mode: "transcribe": modalità di sola osservazione senza bridge talk-back.
• realtime.provider: "openai": fallback di compatibilità usato quando i campi provider con ambito sottostanti non sono impostati.
• realtime.transcriptionProvider: "openai": id del provider usato dalla modalità agent per la trascrizione realtime.
• realtime.voiceProvider: id del provider usato dalla modalità bidi per la voce realtime diretta. Impostalo su "google" per usare Gemini Live mantenendo la trascrizione in modalità agente su OpenAI.
• realtime.toolPolicy: "safe-read-only"
• realtime.instructions: brevi risposte parlate, con openclaw_agent_consult per risposte più approfondite
• realtime.introMessage: breve controllo di prontezza parlato quando il bridge realtime si connette; impostalo su "" per partecipare in silenzio
• realtime.agentId: id agente OpenClaw opzionale per openclaw_agent_consult; valore predefinito main

Override opzionali:

{  defaults: {    meeting: "https://meet.google.com/abc-defg-hij",  },  browser: {    defaultProfile: "openclaw",  },  chrome: {    guestName: "OpenClaw Agent",    waitForInCallMs: 30000,    bargeInInputCommand: [      "sox",      "-q",      "-t",      "coreaudio",      "External Microphone",      "-r",      "24000",      "-c",      "1",      "-b",      "16",      "-e",      "signed-integer",      "-t",      "raw",      "-",    ],  },  chromeNode: {    node: "parallels-macos",  },  defaultMode: "agent",  realtime: {    provider: "openai",    transcriptionProvider: "openai",    voiceProvider: "google",    model: "gemini-2.5-flash-native-audio-preview-12-2025",    agentId: "jay",    toolPolicy: "owner",    introMessage: "Say exactly: I'm here.",    providers: {      google: {        speakerVoice: "Kore",      },    },  },}

ElevenLabs sia per l'ascolto sia per il parlato in modalità agente:

{  messages: {    tts: {      provider: "elevenlabs",      providers: {        elevenlabs: {          modelId: "eleven_v3",          speakerVoiceId: "pMsXgVXv3BLzUgSXRplE",        },      },    },  },  plugins: {    entries: {      "google-meet": {        config: {          realtime: {            transcriptionProvider: "elevenlabs",            providers: {              elevenlabs: {                modelId: "scribe_v2_realtime",                audioFormat: "ulaw_8000",                sampleRate: 8000,                commitStrategy: "vad",              },            },          },        },      },    },  },}

La voce persistente di Meet proviene da messages.tts.providers.elevenlabs.speakerVoiceId. Le risposte dell'agente possono anche usare direttive per risposta [[tts:speakerVoiceId=... model=eleven_v3]] quando gli override del modello TTS sono abilitati, ma la configurazione è il valore predefinito deterministico per le riunioni. All'accesso, i log dovrebbero mostrare transcriptionProvider=elevenlabs e ogni risposta parlata dovrebbe registrare provider=elevenlabs model=eleven_v3 speakerVoiceId=<voiceId>.

Configurazione solo Twilio:

{  defaultTransport: "twilio",  twilio: {    defaultDialInNumber: "+15551234567",    defaultPin: "123456",  },  voiceCall: {    gatewayUrl: "ws://127.0.0.1:18789",  },}

voiceCall.enabled ha valore predefinito true; con il trasporto Twilio delega la chiamata PSTN effettiva, il DTMF e il saluto introduttivo al plugin Voice Call. Voice Call riproduce la sequenza DTMF prima di aprire lo stream multimediale realtime, poi usa il testo introduttivo salvato come saluto realtime iniziale. Se voice-call non è abilitato, Google Meet può comunque convalidare e registrare il piano di composizione, ma non può effettuare la chiamata Twilio.

Strumento

Gli agenti possono usare lo strumento google_meet:

{  "action": "join",  "url": "https://meet.google.com/abc-defg-hij",  "transport": "chrome-node",  "mode": "agent"}

Usa transport: "chrome" quando Chrome viene eseguito sull'host Gateway. Usa transport: "chrome-node" quando Chrome viene eseguito su un nodo associato, come una VM Parallels. In entrambi i casi i provider di modelli e openclaw_agent_consult vengono eseguiti sull'host Gateway, quindi le credenziali dei modelli restano lì. Con il valore predefinito mode: "agent", il provider di trascrizione realtime gestisce l'ascolto, l'agente OpenClaw configurato produce la risposta e il normale TTS di OpenClaw la pronuncia in Meet. Usa mode: "bidi" quando vuoi che il modello vocale realtime risponda direttamente. Il mode: "realtime" grezzo resta accettato come alias di compatibilità legacy per mode: "agent", ma non è più pubblicizzato nello schema dello strumento agente. I log della modalità agente includono il provider/modello di trascrizione risolto all'avvio del bridge e il provider TTS, il modello, la voce, il formato di output e la frequenza di campionamento dopo ogni risposta sintetizzata.

Usa action: "status" per elencare le sessioni attive o ispezionare un ID sessione. Usa action: "speak" con sessionId e message per far parlare immediatamente l'agente realtime. Usa action: "test_speech" per creare o riusare la sessione, attivare una frase nota e restituire lo stato di salute inCall quando l'host Chrome può segnalarlo. test_speech forza sempre mode: "agent" e fallisce se viene chiesto di eseguire in mode: "transcribe" perché le sessioni di sola osservazione intenzionalmente non possono emettere parlato. Il suo risultato speechOutputVerified si basa sull'aumento dei byte di output audio realtime durante questa chiamata di test, quindi una sessione riusata con audio precedente non conta come nuovo controllo vocale riuscito. Usa action: "leave" per contrassegnare una sessione come terminata.

status include lo stato di salute di Chrome quando disponibile:

• inCall: Chrome sembra essere all'interno della chiamata Meet
• micMuted: stato best-effort del microfono Meet
• manualActionRequired / manualActionReason / manualActionMessage: il profilo del browser richiede accesso manuale, ammissione da parte dell'host Meet, autorizzazioni o riparazione del controllo browser prima che il parlato possa funzionare
• speechReady / speechBlockedReason / speechBlockedMessage: indica se il parlato Chrome gestito è consentito ora. speechReady: false significa che OpenClaw non ha inviato la frase introduttiva/di test nel bridge audio.
• providerConnected / realtimeReady: stato del bridge vocale realtime
• lastInputAt / lastOutputAt: ultimo audio visto dal bridge o inviato al bridge
• audioOutputRouted / audioOutputDeviceLabel: indica se l'output multimediale della scheda Meet è stato instradato attivamente al dispositivo BlackHole usato dal bridge
• lastSuppressedInputAt / suppressedInputBytes: input local loopback ignorato mentre la riproduzione dell'assistente è attiva

{  "action": "speak",  "sessionId": "meet_...",  "message": "Say exactly: I'm here and listening."}

Modalità agente e bidi

La modalità Chrome agent è ottimizzata per il comportamento "il mio agente è nella riunione". Il provider di trascrizione realtime ascolta l'audio della riunione, le trascrizioni finali dei partecipanti vengono instradate attraverso l'agente OpenClaw configurato e la risposta viene pronunciata tramite il normale runtime TTS di OpenClaw. Imposta mode: "bidi" quando vuoi che il modello vocale realtime risponda direttamente. I frammenti vicini della trascrizione finale vengono accorpati prima della consultazione, così un turno parlato non produce diverse risposte parziali obsolete. Anche l'input realtime viene soppresso mentre l'audio dell'assistente in coda è ancora in riproduzione, e gli echi recenti di trascrizioni simili all'assistente vengono ignorati prima della consultazione dell'agente così il local loopback di BlackHole non fa rispondere all'agente il proprio parlato.

In modalità bidi, quando il modello realtime richiede ragionamento più approfondito, informazioni aggiornate o i normali strumenti OpenClaw, può chiamare openclaw_agent_consult.

Lo strumento consult esegue dietro le quinte il normale agente OpenClaw con il contesto recente della trascrizione della riunione e restituisce una risposta parlata concisa. In modalità agent, OpenClaw invia quella risposta direttamente al runtime TTS; in modalità bidi, il modello vocale realtime può pronunciare il risultato di consult nella riunione. Usa lo stesso meccanismo condiviso di consult di Voice Call.

Per impostazione predefinita, le consultazioni vengono eseguite sull'agente main. Imposta realtime.agentId quando una corsia Meet deve consultare un'area di lavoro, impostazioni predefinite del modello, policy degli strumenti, memoria e cronologia della sessione di un agente OpenClaw dedicato.

Le consultazioni in modalità agente usano una chiave di sessione per riunione agent:<id>:subagent:google-meet:<session>, così le domande successive mantengono il contesto della riunione ereditando al contempo la normale policy dell'agente dall'agente configurato.

realtime.toolPolicy controlla l'esecuzione di consult:

• safe-read-only: espone lo strumento consult e limita il normale agente a read, web_search, web_fetch, x_search, memory_search e memory_get.
• owner: espone lo strumento consult e lascia che il normale agente usi la normale policy degli strumenti dell'agente.
• none: non espone lo strumento consult al modello vocale realtime.

La chiave di sessione di consult ha ambito per sessione Meet, quindi le chiamate consult successive possono riutilizzare il contesto consult precedente durante la stessa riunione.

Per forzare un controllo di prontezza parlato dopo che Chrome ha partecipato completamente alla chiamata:

openclaw googlemeet speak meet_... "Say exactly: I'm here and listening."

Per lo smoke completo di partecipazione e parlato:

openclaw googlemeet test-speech https://meet.google.com/abc-defg-hij \  --transport chrome-node \  --message "Say exactly: I'm here and listening."

Checklist dei test live

Usa questa sequenza prima di affidare una riunione a un agente non presidiato:

openclaw googlemeet setupopenclaw nodes statusopenclaw googlemeet test-speech https://meet.google.com/abc-defg-hij \  --transport chrome-node \  --message "Say exactly: Google Meet speech test complete."

Stato Chrome-node previsto:

• googlemeet setup è tutto verde.
• googlemeet setup include chrome-node-connected quando Chrome-node è il trasporto predefinito o un nodo è fissato.
• nodes status mostra il nodo selezionato connesso.
• Il nodo selezionato pubblicizza sia googlemeet.chrome sia browser.proxy.
• La scheda Meet partecipa alla chiamata e test-speech restituisce lo stato di integrità di Chrome con inCall: true.

Per un host Chrome remoto, ad esempio una VM macOS Parallels, questo è il controllo sicuro più breve dopo l'aggiornamento del Gateway o della VM:

openclaw googlemeet setupopenclaw nodes status --connectedopenclaw nodes invoke \  --node parallels-macos \  --command googlemeet.chrome \  --params '{"action":"setup"}'

Questo dimostra che il Plugin Gateway è caricato, che il nodo VM è connesso con il token corrente e che il bridge audio Meet è disponibile prima che un agente apra una vera scheda di riunione.

Per uno smoke Twilio, usa una riunione che espone i dettagli di accesso telefonico:

openclaw googlemeet setupopenclaw googlemeet join https://meet.google.com/abc-defg-hij \  --transport twilio \  --dial-in-number +15551234567 \  --pin 123456

Stato Twilio previsto:

• googlemeet setup include controlli verdi twilio-voice-call-plugin, twilio-voice-call-credentials e twilio-voice-call-webhook.
• voicecall è disponibile nella CLI dopo il ricaricamento del Gateway.
• La sessione restituita ha transport: "twilio" e un twilio.voiceCallId.
• openclaw logs --follow mostra il TwiML DTMF servito prima del TwiML realtime, quindi un bridge realtime con il saluto iniziale in coda.
• googlemeet leave <sessionId> termina la chiamata vocale delegata.

Risoluzione dei problemi

L'agente non riesce a vedere lo strumento Google Meet

Conferma che il plugin sia abilitato nella configurazione del Gateway e ricarica il Gateway:

openclaw plugins list | grep google-meetopenclaw googlemeet setup

Se hai appena modificato plugins.entries.google-meet, riavvia o ricarica il Gateway. L'agente in esecuzione vede solo gli strumenti dei plugin registrati dal processo Gateway corrente.

Sugli host Gateway non macOS, lo strumento google_meet rivolto all'agente resta visibile, ma le azioni locali di talk-back di Chrome vengono bloccate prima di raggiungere il bridge audio. L'audio talk-back locale di Chrome attualmente dipende da BlackHole 2ch di macOS, quindi gli agenti Linux dovrebbero usare mode: "transcribe", l'accesso telefonico Twilio o un host chrome-node macOS invece del percorso agente Chrome locale predefinito.

Nessun nodo compatibile con Google Meet connesso

Sull'host del nodo, esegui:

openclaw plugins enable google-meetopenclaw plugins enable browserOPENCLAW_ALLOW_INSECURE_PRIVATE_WS=1 \  openclaw node run --host <gateway-lan-ip> --port 18789 --display-name parallels-macos

Sull'host Gateway, approva il nodo e verifica i comandi:

openclaw devices listopenclaw devices approve <requestId>openclaw nodes status

Il nodo deve essere connesso ed elencare googlemeet.chrome più browser.proxy. La configurazione del Gateway deve consentire questi comandi del nodo:

{  gateway: {    nodes: {      allowCommands: ["browser.proxy", "googlemeet.chrome"],    },  },}

Se googlemeet setup non supera chrome-node-connected o il log del Gateway segnala gateway token mismatch, reinstalla o riavvia il nodo con il token Gateway corrente. Per un Gateway LAN questo di solito significa:

OPENCLAW_ALLOW_INSECURE_PRIVATE_WS=1 \  openclaw node install \  --host <gateway-lan-ip> \  --port 18789 \  --display-name parallels-macos \  --force

Poi ricarica il servizio del nodo ed esegui di nuovo:

openclaw googlemeet setupopenclaw nodes status --connected

Il browser si apre ma l'agente non riesce a partecipare

Esegui googlemeet test-listen per partecipazioni in sola osservazione o googlemeet test-speech per partecipazioni in tempo reale, quindi esamina lo stato di salute di Chrome restituito. Se una delle due sonde segnala manualActionRequired: true, mostra manualActionMessage all'operatore e interrompi i tentativi finché l'azione nel browser non è completa.

Azioni manuali comuni:

• Accedi al profilo Chrome.
• Ammetti l'ospite dall'account host di Meet.
• Concedi a Chrome le autorizzazioni per microfono/fotocamera quando compare la richiesta di autorizzazione nativa di Chrome.
• Chiudi o correggi una finestra di autorizzazione Meet bloccata.

Non segnalare "accesso non effettuato" solo perché Meet mostra "Vuoi che gli altri possano sentirti nella riunione?" Quello è l'interstitial di scelta audio di Meet; OpenClaw fa clic su Usa microfono tramite automazione del browser quando disponibile e continua ad attendere il vero stato della riunione. Per il fallback del browser di sola creazione, OpenClaw può fare clic su Continua senza microfono perché la creazione dell'URL non richiede il percorso audio in tempo reale.

La creazione della riunione non riesce

googlemeet create usa prima l'endpoint Google Meet API spaces.create quando le credenziali OAuth sono configurate. Senza credenziali OAuth ripiega sul browser del nodo Chrome fissato. Conferma:

• Per la creazione tramite API: oauth.clientId e oauth.refreshToken sono configurati, oppure sono presenti variabili d'ambiente OPENCLAW_GOOGLE_MEET_* corrispondenti.
• Per la creazione tramite API: il token di aggiornamento è stato generato dopo l'aggiunta del supporto alla creazione. I token più vecchi potrebbero non avere lo scope meetings.space.created; riesegui openclaw googlemeet auth login --json e aggiorna la configurazione del plugin.
• Per il fallback del browser: defaultTransport: "chrome-node" e chromeNode.node puntano a un nodo connesso con browser.proxy e googlemeet.chrome.
• Per il fallback del browser: il profilo Chrome di OpenClaw su quel nodo ha effettuato l'accesso a Google e può aprire https://meet.google.com/new.
• Per il fallback del browser: i tentativi riutilizzano una scheda esistente https://meet.google.com/new o una scheda di richiesta dell'account Google prima di aprire una nuova scheda. Se un agente va in timeout, riprova la chiamata allo strumento invece di aprire manualmente un'altra scheda Meet.
• Per il fallback del browser: se lo strumento restituisce manualActionRequired: true, usa browser.nodeId, browser.targetId, browserUrl e manualActionMessage restituiti per guidare l'operatore. Non riprovare in ciclo finché tale azione non è completa.
• Per il fallback del browser: se Meet mostra "Vuoi che gli altri possano sentirti nella riunione?", lascia aperta la scheda. OpenClaw dovrebbe fare clic su Usa microfono oppure, per il fallback di sola creazione, su Continua senza microfono tramite automazione del browser e continuare ad attendere l'URL Meet generato. Se non ci riesce, l'errore dovrebbe menzionare meet-audio-choice-required, non google-login-required.

L'agente partecipa ma non parla

Controlla il percorso in tempo reale:

openclaw googlemeet setupopenclaw googlemeet doctor

Usa mode: "agent" per il normale percorso STT -> agente OpenClaw -> risposta vocale TTS, oppure mode: "bidi" per il fallback vocale diretto in tempo reale. mode: "transcribe" intenzionalmente non avvia il bridge di risposta vocale. Per il debug in sola osservazione, esegui openclaw googlemeet status --json <session-id> dopo che i partecipanti hanno parlato e controlla captioning, transcriptLines e lastCaptionText. Se inCall è true ma transcriptLines rimane a 0, i sottotitoli di Meet potrebbero essere disabilitati, nessuno ha parlato da quando l'osservatore è stato installato, l'interfaccia utente di Meet è cambiata oppure i sottotitoli live non sono disponibili per la lingua/account della riunione.

googlemeet test-speech controlla sempre il percorso in tempo reale e segnala se sono stati osservati byte di output del bridge per quella invocazione. Se speechOutputVerified è false e speechOutputTimedOut è true, il provider in tempo reale potrebbe aver accettato l'enunciato ma OpenClaw non ha visto nuovi byte di output raggiungere il bridge audio di Chrome.

Verifica anche:

• Una chiave del provider in tempo reale è disponibile sull'host Gateway, come OPENAI_API_KEY o GEMINI_API_KEY.
• BlackHole 2ch è visibile sull'host Chrome.
• sox esiste sull'host Chrome.
• Il microfono e l'altoparlante di Meet sono instradati attraverso il percorso audio virtuale usato da OpenClaw. doctor dovrebbe mostrare meet output routed: yes per partecipazioni in tempo reale con Chrome locale.

googlemeet doctor [session-id] stampa sessione, nodo, stato in chiamata, motivo dell'azione manuale, connessione del provider in tempo reale, realtimeReady, attività audio di input/output, ultimi timestamp audio, contatori di byte e URL del browser. Usa googlemeet status [session-id] --json quando hai bisogno del JSON grezzo. Usa googlemeet doctor --oauth quando devi verificare l'aggiornamento OAuth di Google Meet senza esporre token; aggiungi --meeting o --create-space quando ti serve anche una prova dell'API Google Meet.

Se un agente è andato in timeout e puoi vedere una scheda Meet già aperta, esamina quella scheda senza aprirne un'altra:

openclaw googlemeet recover-tabopenclaw googlemeet recover-tab https://meet.google.com/abc-defg-hij

L'azione strumento equivalente è recover_current_tab. Porta in primo piano ed esamina una scheda Meet esistente per il trasporto selezionato. Con chrome, usa il controllo del browser locale tramite il Gateway; con chrome-node, usa il nodo Chrome configurato. Non apre una nuova scheda né crea una nuova sessione; segnala il blocco corrente, come accesso, ammissione, autorizzazioni o stato di scelta audio. Il comando CLI comunica con il Gateway configurato, quindi il Gateway deve essere in esecuzione; chrome-node richiede anche che il nodo Chrome sia connesso.

I controlli di configurazione Twilio non riescono

twilio-voice-call-plugin non riesce quando voice-call non è consentito o non è abilitato. Aggiungilo a plugins.allow, abilita plugins.entries.voice-call e ricarica il Gateway.

twilio-voice-call-credentials non riesce quando al backend Twilio mancano SID account, token di autenticazione o numero chiamante. Impostali sull'host Gateway:

export TWILIO_ACCOUNT_SID=AC...export TWILIO_AUTH_TOKEN=...export TWILIO_FROM_NUMBER=+15550001234

twilio-voice-call-webhook non riesce quando voice-call non ha esposizione Webhook pubblica, oppure quando publicUrl punta al loopback o a uno spazio di rete privato. Imposta plugins.entries.voice-call.config.publicUrl sull'URL pubblico del provider oppure configura un'esposizione tunnel/Tailscale per voice-call.

Gli URL di loopback e privati non sono validi per i callback degli operatori. Non usare localhost, 127.0.0.1, 0.0.0.0, 10.x, 172.16.x-172.31.x, 192.168.x, 169.254.x, fc00::/7 o fd00::/8 come publicUrl.

Per un URL pubblico stabile:

{  plugins: {    entries: {      "voice-call": {        enabled: true,        config: {          provider: "twilio",          fromNumber: "+15550001234",          publicUrl: "https://voice.example.com/voice/webhook",        },      },    },  },}

Per lo sviluppo locale, usa un tunnel o un'esposizione Tailscale invece di un URL host privato:

{  plugins: {    entries: {      "voice-call": {        config: {          tunnel: { provider: "ngrok" },          // or          tailscale: { mode: "funnel", path: "/voice/webhook" },        },      },    },  },}

Poi riavvia o ricarica il Gateway ed esegui:

openclaw googlemeet setup --transport twilioopenclaw voicecall setupopenclaw voicecall smoke

voicecall smoke per impostazione predefinita verifica solo la disponibilità. Per eseguire una prova senza effetti su un numero specifico:

openclaw voicecall smoke --to "+15555550123"

Aggiungi --yes solo quando vuoi intenzionalmente effettuare una chiamata di notifica in uscita reale:

openclaw voicecall smoke --to "+15555550123" --yes

La chiamata Twilio parte ma non entra mai nella riunione

Conferma che l'evento Meet esponga i dettagli di accesso telefonico. Passa il numero di accesso telefonico e il PIN esatti oppure una sequenza DTMF personalizzata:

openclaw googlemeet join https://meet.google.com/abc-defg-hij \  --transport twilio \  --dial-in-number +15551234567 \  --dtmf-sequence ww123456#

Usa w iniziali o virgole in --dtmf-sequence se il provider richiede una pausa prima di inserire il PIN.

Se la chiamata telefonica viene creata ma l'elenco dei partecipanti Meet non mostra mai il partecipante con accesso telefonico:

• Esegui openclaw googlemeet doctor <session-id> per confermare l'ID chiamata Twilio delegata, se il DTMF è stato messo in coda e se è stato richiesto il saluto introduttivo.
• Esegui openclaw voicecall status --call-id <id> e conferma che la chiamata sia ancora attiva.
• Esegui openclaw voicecall tail e verifica che i Webhook Twilio arrivino al Gateway.
• Esegui openclaw logs --follow e cerca la sequenza Twilio Meet: Google Meet delega l'accesso, Voice Call archivia e serve il TwiML DTMF pre-connessione, Voice Call serve il TwiML in tempo reale per la chiamata Twilio, poi Google Meet richiede il parlato introduttivo con voicecall.speak.
• Riesegui openclaw googlemeet setup --transport twilio; è richiesto un controllo di configurazione verde, ma non dimostra che la sequenza del PIN della riunione sia corretta.
• Conferma che il numero di accesso telefonico appartenga allo stesso invito Meet e alla stessa regione del PIN.
• Aumenta voiceCall.dtmfDelayMs rispetto al valore predefinito di 12 secondi se Meet risponde lentamente o se la trascrizione della chiamata mostra ancora il prompt che chiede un PIN dopo l'invio del DTMF pre-connessione.
• Se il partecipante entra ma non senti il saluto, controlla openclaw logs --follow per la richiesta post-DTMF voicecall.speak e la riproduzione TTS tramite media-stream oppure il fallback Twilio OPENCLAW_DOCS_MARKER:calloutOpen:U2F5. Se la trascrizione della chiamata contiene ancora "enter the meeting PIN", il ramo telefonico non è ancora entrato nella stanza Meet, quindi i partecipanti alla riunione non sentiranno il parlato.

Se i Webhook non arrivano, esegui prima il debug del Plugin Voice Call: il provider deve raggiungere plugins.entries.voice-call.config.publicUrl o il tunnel configurato. Consulta Risoluzione dei problemi delle chiamate vocali.

Note

L'API media ufficiale di Google Meet è orientata alla ricezione, quindi parlare in una chiamata Meet richiede comunque un percorso partecipante. Questo Plugin mantiene visibile quel confine: Chrome gestisce la partecipazione tramite browser e l'instradamento audio locale; Twilio gestisce la partecipazione tramite accesso telefonico.

Le modalità talk-back di Chrome richiedono BlackHole 2ch più una delle seguenti opzioni:

• chrome.audioInputCommand più chrome.audioOutputCommand: OpenClaw possiede il bridge e convoglia l'audio in chrome.audioFormat tra quei comandi e il provider selezionato. La modalità agente usa trascrizione in tempo reale più TTS normale; la modalità bidi usa il provider vocale in tempo reale. Il percorso Chrome predefinito è PCM16 a 24 kHz con chrome.audioBufferBytes: 4096; G.711 mu-law a 8 kHz rimane disponibile per le coppie di comandi legacy.
• chrome.audioBridgeCommand: un comando bridge esterno possiede l'intero percorso audio locale e deve terminare dopo aver avviato o validato il proprio daemon. Questo è valido solo per bidi perché la modalità agent richiede accesso diretto alla coppia di comandi per il TTS.

Quando un agente chiama lo strumento google_meet in modalità agente, la sessione consulente della riunione biforca la trascrizione corrente del chiamante prima di rispondere al parlato dei partecipanti. La sessione Meet rimane comunque separata (agent:<agentId>:subagent:google-meet:<sessionId>) così i follow-up della riunione non modificano direttamente la trascrizione del chiamante.

Per un audio duplex pulito, instrada l'output Meet e il microfono Meet attraverso dispositivi virtuali separati o un grafo di dispositivi virtuali in stile Loopback. Un singolo dispositivo BlackHole condiviso può rimandare l'eco degli altri partecipanti nella chiamata.

Con il bridge Chrome a coppia di comandi, chrome.bargeInInputCommand può ascoltare un microfono locale separato e cancellare la riproduzione dell'assistente quando l'umano inizia a parlare. Questo mantiene il parlato umano davanti all'output dell'assistente anche quando l'input BlackHole loopback condiviso viene temporaneamente soppresso durante la riproduzione dell'assistente. Come chrome.audioInputCommand e chrome.audioOutputCommand, è un comando locale configurato dall'operatore. Usa un percorso di comando attendibile esplicito o un elenco di argomenti, e non puntarlo a script provenienti da posizioni non attendibili.

googlemeet speak attiva il bridge audio talk-back attivo per una sessione Chrome. googlemeet leave arresta quel bridge. Per le sessioni Twilio delegate tramite il Plugin Voice Call, leave chiude anche la chiamata vocale sottostante. Usa googlemeet end-active-conference quando vuoi anche chiudere la conferenza Google Meet attiva per uno spazio gestito dall'API.

Correlati

• Plugin Voice Call
• Modalità talk
• Creazione di Plugin