openclaw/docs
openclaw/docs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore(i18n): refresh pt-BR translations

Browse Source
This commit is contained in:
openclaw-docs-i18n[bot] 2026-04-24 09:52:44 +00:00
parent f3a8688084
commit c8c5cfc0c3
3 changed files with 330 additions and 287 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

213
docs/pt-BR/plugins/google-meet.md
View File

@ -1,54 +1,52 @@
---
read_when:
- Você quer que um agente OpenClaw entre em uma chamada do Google Meet
- Você está configurando Chrome, Chrome Node ou Twilio como transporte do Google Meet
summary: 'Plugin Google Meet: entrar em URLs explícitas do Meet pelo Chrome ou Twilio com padrões de voz em tempo real'
title: Plugin Google Meet
- Você quer que um agente do OpenClaw entre em uma chamada do Google Meet
- Você está configurando o Chrome, o Node do Chrome ou o Twilio como um transporte do Google Meet
summary: 'Plugin do Google Meet: entre em URLs explícitas do Meet pelo Chrome ou Twilio com padrões de voz em tempo real'
title: Plugin do Google Meet
x-i18n:
generated_at: "2026-04-24T08:59:10Z"
generated_at: "2026-04-24T09:51:45Z"
model: gpt-5.4
provider: openai
source_hash: 8d430a1f2d6ee7fc1d997ef388a2e0d2915a6475480343e7060edac799dfc027
source_hash: f1673ac4adc9cf163194a340dd6e451d0e4d28bb62adeb126898298e62106d43
source_path: plugins/google-meet.md
workflow: 15
---
# Google Meet (Plugin)
Suporte a participantes do Google Meet para OpenClaw.
Suporte a participantes do Google Meet para o OpenClaw.
O Plugin é explícito por design:
O Plugin é explícito por definição:
- Ele só entra em uma URL explícita `https://meet.google.com/...`.
- Ele entra apenas em uma URL explícita `https://meet.google.com/...`.
- A voz `realtime` é o modo padrão.
- A voz em tempo real pode retornar ao agente OpenClaw completo quando for necessário
raciocínio mais profundo ou uso de ferramentas.
- A voz em tempo real pode retornar ao agente completo do OpenClaw quando for necessário raciocínio mais profundo ou ferramentas.
- A autenticação começa como OAuth pessoal do Google ou com um perfil do Chrome já autenticado.
- Não há anúncio automático de consentimento.
- O backend de áudio padrão do Chrome é `BlackHole 2ch`.
- O Chrome pode ser executado localmente ou em um host Node pareado.
- O Twilio aceita um número de discagem mais PIN opcional ou sequência DTMF.
- O comando da CLI é `googlemeet`; `meet` é reservado para fluxos de
teleconferência mais amplos do agente.
- O Twilio aceita um número de discagem mais um PIN ou sequência DTMF opcional.
- O comando da CLI é `googlemeet`; `meet` fica reservado para fluxos mais amplos de teleconferência com agentes.
## Início rápido
Instale as dependências locais de áudio e verifique se o provedor realtime pode usar
OpenAI:
Instale as dependências locais de áudio e configure um provedor de voz em tempo real no backend. OpenAI é o padrão; Google Gemini Live também funciona com `realtime.provider: "google"`:
```bash
brew install blackhole-2ch sox
export OPENAI_API_KEY=sk-...
# or
export GEMINI_API_KEY=...
```
`blackhole-2ch` instala o dispositivo de áudio virtual `BlackHole 2ch`. O
instalador do Homebrew exige reinicialização antes que o macOS exponha o dispositivo:
`blackhole-2ch` instala o dispositivo de áudio virtual `BlackHole 2ch`. O instalador do Homebrew exige uma reinicialização antes que o macOS exponha o dispositivo:
```bash
sudo reboot
```
Após reiniciar, verifique os dois componentes:
Após reiniciar, verifique as duas partes:
```bash
system_profiler SPAudioDataType | grep -i BlackHole
@ -82,7 +80,7 @@ Entre em uma reunião:
openclaw googlemeet join https://meet.google.com/abc-defg-hij
```
Ou deixe um agente entrar por meio da ferramenta `google_meet`:
Ou deixe um agente entrar usando a ferramenta `google_meet`:
```json
{
@ -91,25 +89,17 @@ Ou deixe um agente entrar por meio da ferramenta `google_meet`:
}
```
O Chrome entra usando o perfil autenticado do Chrome. No Meet, selecione `BlackHole 2ch` para
o caminho de microfone/alto-falante usado pelo OpenClaw. Para áudio duplex limpo, use
dispositivos virtuais separados ou um grafo no estilo Loopback; um único dispositivo BlackHole é
suficiente para um primeiro teste rápido, mas pode causar eco.
O Chrome entra usando o perfil autenticado no Chrome. No Meet, escolha `BlackHole 2ch` para o caminho de microfone/alto-falante usado pelo OpenClaw. Para áudio duplex limpo, use dispositivos virtuais separados ou um grafo no estilo Loopback; um único dispositivo BlackHole já basta para um primeiro teste rápido, mas pode causar eco.
### Gateway local + Chrome no Parallels
Você **não** precisa de um Gateway OpenClaw completo nem de uma chave de API de modelo dentro de uma VM macOS
apenas para fazer a VM hospedar o Chrome. Execute o Gateway e o agente localmente e depois execute um
host Node na VM. Ative o Plugin incluído na VM uma vez para que o Node anuncie o comando do Chrome:
Você **não** precisa de um Gateway completo do OpenClaw nem de uma chave de API de modelo dentro de uma VM macOS apenas para fazer a VM ser a dona do Chrome. Execute o Gateway e o agente localmente, depois execute um host Node na VM. Ative o Plugin empacotado na VM uma vez para que o Node anuncie o comando do Chrome:
O que roda em cada lugar:
- Host do Gateway: Gateway OpenClaw, workspace do agente, chaves de modelo/API, provedor
realtime e a configuração do Plugin Google Meet.
- VM macOS do Parallels: CLI/host Node do OpenClaw, Google Chrome, SoX, BlackHole 2ch
e um perfil do Chrome autenticado no Google.
- Não é necessário na VM: serviço do Gateway, configuração do agente, chave OpenAI/GPT ou configuração
do provedor de modelo.
- Host do Gateway: Gateway do OpenClaw, workspace do agente, chaves de modelo/API, provedor realtime e a configuração do Plugin do Google Meet.
- VM macOS no Parallels: CLI/host Node do OpenClaw, Google Chrome, SoX, BlackHole 2ch e um perfil do Chrome autenticado no Google.
- Não necessário na VM: serviço Gateway, configuração do agente, chave OpenAI/GPT ou configuração de provedor de modelo.
Instale as dependências da VM:
@ -123,14 +113,14 @@ Reinicie a VM após instalar o BlackHole para que o macOS exponha `BlackHole 2ch
sudo reboot
```
Após reiniciar, verifique se a VM consegue ver o dispositivo de áudio e os comandos SoX:
Após reiniciar, confirme que a VM consegue ver o dispositivo de áudio e os comandos do SoX:
```bash
system_profiler SPAudioDataType | grep -i BlackHole
command -v rec play
```
Instale ou atualize o OpenClaw na VM e então ative o Plugin incluído nela:
Instale ou atualize o OpenClaw na VM e então ative o Plugin empacotado lá:
```bash
openclaw plugins enable google-meet
@ -142,15 +132,14 @@ Inicie o host Node na VM:
openclaw node run --host <gateway-host> --port 18789 --display-name parallels-macos
```
Se `<gateway-host>` for um IP de LAN e você não estiver usando TLS, o Node recusará o
WebSocket em texto puro, a menos que você permita explicitamente essa rede privada confiável:
Se `<gateway-host>` for um IP da LAN e você não estiver usando TLS, o Node recusará o WebSocket em texto puro, a menos que você habilite explicitamente essa rede privada confiável:
```bash
OPENCLAW_ALLOW_INSECURE_PRIVATE_WS=1 \
openclaw node run --host <gateway-lan-ip> --port 18789 --display-name parallels-macos
```
Use a mesma variável de ambiente ao instalar o Node como LaunchAgent:
Use a mesma variável de ambiente ao instalar o Node como um LaunchAgent:
```bash
OPENCLAW_ALLOW_INSECURE_PRIVATE_WS=1 \
@ -158,9 +147,7 @@ OPENCLAW_ALLOW_INSECURE_PRIVATE_WS=1 \
openclaw node restart
```
`OPENCLAW_ALLOW_INSECURE_PRIVATE_WS=1` é uma variável de ambiente do processo, não uma
configuração de `openclaw.json`. `openclaw node install` a armazena no ambiente do LaunchAgent
quando ela está presente no comando de instalação.
`OPENCLAW_ALLOW_INSECURE_PRIVATE_WS=1` é uma variável de ambiente de processo, não uma configuração de `openclaw.json`. `openclaw node install` a armazena no ambiente do LaunchAgent quando ela está presente no comando de instalação.
Aprove o Node a partir do host do Gateway:
@ -208,62 +195,40 @@ openclaw googlemeet join https://meet.google.com/abc-defg-hij
ou peça ao agente para usar a ferramenta `google_meet` com `transport: "chrome-node"`.
Se `chromeNode.node` for omitido, o OpenClaw seleciona automaticamente apenas quando exatamente um
Node conectado anuncia `googlemeet.chrome`. Se vários Nodes com essa capacidade estiverem
conectados, defina `chromeNode.node` como o ID do Node, nome de exibição ou IP remoto.
Se `chromeNode.node` for omitido, o OpenClaw faz seleção automática apenas quando exatamente um Node conectado anuncia `googlemeet.chrome`. Se houver vários Nodes compatíveis conectados, defina `chromeNode.node` como o id do Node, o nome de exibição ou o IP remoto.
Verificações comuns de falha:
- `No connected Google Meet-capable node`: inicie `openclaw node run` na VM,
aprove o pareamento e verifique se `openclaw plugins enable google-meet` foi executado
na VM. Confirme também que o host do Gateway permite o comando do Node com
`gateway.nodes.allowCommands: ["googlemeet.chrome"]`.
- `BlackHole 2ch audio device not found on the node`: instale `blackhole-2ch`
na VM e reinicie a VM.
- O Chrome abre mas não consegue entrar: autentique-se no Chrome dentro da VM e confirme que
esse perfil consegue entrar manualmente na URL do Meet.
- Sem áudio: no Meet, roteie microfone/alto-falante pelo caminho de dispositivo de áudio virtual
usado pelo OpenClaw; use dispositivos virtuais separados ou roteamento no estilo Loopback
para áudio duplex limpo.
- `No connected Google Meet-capable node`: inicie `openclaw node run` na VM, aprove o pareamento e confirme que `openclaw plugins enable google-meet` foi executado na VM. Confirme também que o host do Gateway permite o comando do Node com `gateway.nodes.allowCommands: ["googlemeet.chrome"]`.
- `BlackHole 2ch audio device not found on the node`: instale `blackhole-2ch` na VM e reinicie a VM.
- O Chrome abre, mas não consegue entrar: faça login no Chrome dentro da VM e confirme que esse perfil consegue entrar manualmente na URL do Meet.
- Sem áudio: no Meet, encaminhe o microfone/alto-falante pelo caminho do dispositivo de áudio virtual usado pelo OpenClaw; use dispositivos virtuais separados ou roteamento no estilo Loopback para áudio duplex limpo.
## Observações de instalação
## Notas de instalação
O padrão realtime do Chrome usa duas ferramentas externas:
- `sox`: utilitário de áudio de linha de comando. O Plugin usa os comandos `rec` e `play`
para a ponte de áudio G.711 mu-law padrão em 8 kHz.
- `blackhole-2ch`: driver de áudio virtual para macOS. Ele cria o dispositivo de áudio `BlackHole 2ch`
pelo qual o Chrome/Meet pode ser roteado.
- `sox`: utilitário de áudio de linha de comando. O Plugin usa seus comandos `rec` e `play` para a ponte de áudio padrão G.711 mu-law de 8 kHz.
- `blackhole-2ch`: driver de áudio virtual do macOS. Ele cria o dispositivo de áudio `BlackHole 2ch` pelo qual o Chrome/Meet pode ser roteado.
O OpenClaw não inclui nem redistribui nenhum dos dois pacotes. A documentação instrui os usuários a
instalá-los como dependências do host via Homebrew. O SoX é licenciado como
`LGPL-2.0-only AND GPL-2.0-only`; o BlackHole é GPL-3.0. Se você construir um
instalador ou appliance que inclua o BlackHole junto com o OpenClaw, revise os
termos de licenciamento upstream do BlackHole ou obtenha uma licença separada da Existential Audio.
O OpenClaw não empacota nem redistribui nenhum dos dois pacotes. A documentação orienta os usuários a instalá-los como dependências do host via Homebrew. O SoX é licenciado como `LGPL-2.0-only AND GPL-2.0-only`; o BlackHole é GPL-3.0. Se você criar um instalador ou appliance que empacote BlackHole com o OpenClaw, revise os termos de licenciamento upstream do BlackHole ou obtenha uma licença separada da Existential Audio.
## Transportes
### Chrome
O transporte Chrome abre a URL do Meet no Google Chrome e entra usando o perfil autenticado
do Chrome. No macOS, o Plugin verifica `BlackHole 2ch` antes da inicialização.
Se configurado, ele também executa um comando de verificação de integridade da ponte de áudio e um comando
de inicialização antes de abrir o Chrome. Use `chrome` quando Chrome/áudio estiverem no host do Gateway;
use `chrome-node` quando Chrome/áudio estiverem em um Node pareado, como uma VM macOS do Parallels.
O transporte Chrome abre a URL do Meet no Google Chrome e entra usando o perfil autenticado no Chrome. No macOS, o Plugin verifica a presença de `BlackHole 2ch` antes da inicialização. Se estiver configurado, ele também executa um comando de verificação de integridade da ponte de áudio e um comando de inicialização antes de abrir o Chrome. Use `chrome` quando o Chrome/áudio estiver no host do Gateway; use `chrome-node` quando o Chrome/áudio estiver em um Node pareado, como uma VM macOS no Parallels.
```bash
openclaw googlemeet join https://meet.google.com/abc-defg-hij --transport chrome
openclaw googlemeet join https://meet.google.com/abc-defg-hij --transport chrome-node
```
Encaminhe o áudio de microfone e alto-falante do Chrome pela ponte de áudio local do OpenClaw.
Se `BlackHole 2ch` não estiver instalado, a entrada falhará com um erro de configuração
em vez de entrar silenciosamente sem um caminho de áudio.
Encaminhe o áudio de microfone e alto-falante do Chrome pela ponte local de áudio do OpenClaw. Se `BlackHole 2ch` não estiver instalado, a entrada falha com um erro de configuração em vez de entrar silenciosamente sem um caminho de áudio.
### Twilio
O transporte Twilio é um plano de discagem estrito delegado ao Plugin Voice Call. Ele
não analisa páginas do Meet em busca de números de telefone.
O transporte Twilio é um plano de discagem estrito delegado ao Plugin Voice Call. Ele não analisa páginas do Meet em busca de números de telefone.
```bash
openclaw googlemeet join https://meet.google.com/abc-defg-hij \
@ -272,7 +237,7 @@ openclaw googlemeet join https://meet.google.com/abc-defg-hij \
--pin 123456
```
Use `--dtmf-sequence` quando a reunião precisar de uma sequência personalizada:
Use `--dtmf-sequence` quando a reunião exigir uma sequência personalizada:
```bash
openclaw googlemeet join https://meet.google.com/abc-defg-hij \
@ -283,16 +248,13 @@ openclaw googlemeet join https://meet.google.com/abc-defg-hij \
## OAuth e preflight
O acesso à Google Meet Media API usa primeiro um cliente OAuth pessoal. Configure
`oauth.clientId` e, opcionalmente, `oauth.clientSecret`, e então execute:
O acesso à API de mídia do Google Meet usa primeiro um cliente OAuth pessoal. Configure `oauth.clientId` e opcionalmente `oauth.clientSecret`, depois execute:
```bash
openclaw googlemeet auth login --json
```
O comando imprime um bloco de configuração `oauth` com um refresh token. Ele usa PKCE,
callback localhost em `http://localhost:8085/oauth2callback` e um fluxo manual de
copiar/colar com `--manual`.
O comando imprime um bloco de configuração `oauth` com um token de atualização. Ele usa PKCE, callback localhost em `http://localhost:8085/oauth2callback` e um fluxo manual de copiar/colar com `--manual`.
Estas variáveis de ambiente são aceitas como fallback:
@ -311,24 +273,23 @@ Resolva uma URL do Meet, código ou `spaces/{id}` por meio de `spaces.get`:
openclaw googlemeet resolve-space --meeting https://meet.google.com/abc-defg-hij
```
Execute o preflight antes de trabalhar com mídia:
Execute o preflight antes do trabalho de mídia:
```bash
openclaw googlemeet preflight --meeting https://meet.google.com/abc-defg-hij
```
Defina `preview.enrollmentAcknowledged: true` somente após confirmar que seu projeto Cloud,
principal OAuth e participantes da reunião estão inscritos no Google
Workspace Developer Preview Program para as APIs de mídia do Meet.
Defina `preview.enrollmentAcknowledged: true` somente após confirmar que seu projeto do Cloud, principal OAuth e participantes da reunião estão inscritos no Google Workspace Developer Preview Program para APIs de mídia do Meet.
## Configuração
O caminho realtime comum com Chrome precisa apenas do Plugin ativado, BlackHole, SoX
e uma chave OpenAI:
O caminho realtime comum do Chrome precisa apenas do Plugin ativado, BlackHole, SoX e uma chave de provedor de voz em tempo real no backend. OpenAI é o padrão; defina `realtime.provider: "google"` para usar Google Gemini Live:
```bash
brew install blackhole-2ch sox
export OPENAI_API_KEY=sk-...
# or
export GEMINI_API_KEY=...
```
Defina a configuração do Plugin em `plugins.entries.google-meet.config`:
@ -350,18 +311,15 @@ Padrões:
- `defaultTransport: "chrome"`
- `defaultMode: "realtime"`
- `chromeNode.node`: ID/nome/IP opcional do Node para `chrome-node`
- `chromeNode.node`: id/nome/IP opcional do Node para `chrome-node`
- `chrome.audioBackend: "blackhole-2ch"`
- `chrome.audioInputCommand`: comando SoX `rec` que grava áudio G.711 mu-law
em 8 kHz para stdout
- `chrome.audioOutputCommand`: comando SoX `play` que lê áudio G.711 mu-law
em 8 kHz de stdin
- `chrome.audioInputCommand`: comando SoX `rec` que grava áudio G.711 mu-law de 8 kHz na stdout
- `chrome.audioOutputCommand`: comando SoX `play` que lê áudio G.711 mu-law de 8 kHz da stdin
- `realtime.provider: "openai"`
- `realtime.toolPolicy: "safe-read-only"`
- `realtime.instructions`: respostas faladas breves, com
`openclaw_agent_consult` para respostas mais profundas
- `realtime.introMessage`: verificação breve de prontidão falada quando a ponte realtime
se conecta; defina como `""` para entrar em silêncio
- `realtime.introMessage`: verificação curta falada de prontidão quando a ponte realtime se conecta; defina como `""` para entrar em silêncio
Substituições opcionais:
@ -377,8 +335,15 @@ Substituições opcionais:
node: "parallels-macos",
},
realtime: {
provider: "google",
toolPolicy: "owner",
introMessage: "Say exactly: I'm here.",
providers: {
google: {
model: "gemini-2.5-flash-native-audio-preview-12-2025",
voice: "Kore",
},
},
},
}
```
@ -411,14 +376,9 @@ Agentes podem usar a ferramenta `google_meet`:
}
```
Use `transport: "chrome"` quando o Chrome estiver em execução no host do Gateway. Use
`transport: "chrome-node"` quando o Chrome estiver em execução em um Node pareado, como uma VM
do Parallels. Em ambos os casos, o modelo realtime e `openclaw_agent_consult` são executados no
host do Gateway, então as credenciais do modelo permanecem lá.
Use `transport: "chrome"` quando o Chrome estiver em execução no host do Gateway. Use `transport: "chrome-node"` quando o Chrome estiver em execução em um Node pareado, como uma VM no Parallels. Em ambos os casos, o modelo realtime e `openclaw_agent_consult` são executados no host do Gateway, então as credenciais do modelo permanecem lá.
Use `action: "status"` para listar sessões ativas ou inspecionar um ID de sessão. Use
`action: "speak"` com `sessionId` e `message` para fazer o agente realtime
falar imediatamente. Use `action: "leave"` para marcar uma sessão como encerrada.
Use `action: "status"` para listar sessões ativas ou inspecionar um ID de sessão. Use `action: "speak"` com `sessionId` e `message` para fazer o agente realtime falar imediatamente. Use `action: "leave"` para marcar uma sessão como encerrada.
```json
{
@ -428,60 +388,43 @@ falar imediatamente. Use `action: "leave"` para marcar uma sessão como encerrad
}
```
## Consulta do agente realtime
## Consulta ao agente em tempo real
O modo realtime do Chrome é otimizado para um loop de voz ao vivo. O provedor de voz
realtime escuta o áudio da reunião e fala por meio da ponte de áudio configurada.
Quando o modelo realtime precisa de raciocínio mais profundo, informações atuais ou ferramentas normais do
OpenClaw, ele pode chamar `openclaw_agent_consult`.
O modo realtime do Chrome é otimizado para um loop de voz ao vivo. O provedor de voz em tempo real ouve o áudio da reunião e fala por meio da ponte de áudio configurada. Quando o modelo realtime precisa de raciocínio mais profundo, informações atuais ou ferramentas normais do OpenClaw, ele pode chamar `openclaw_agent_consult`.
A ferramenta de consulta executa o agente OpenClaw normal nos bastidores com contexto recente da transcrição
da reunião e retorna uma resposta falada concisa para a sessão de voz realtime. O modelo de voz pode
então falar essa resposta de volta na reunião.
A ferramenta de consulta executa o agente normal do OpenClaw nos bastidores com o contexto recente da transcrição da reunião e retorna uma resposta falada concisa para a sessão de voz em tempo real. O modelo de voz pode então falar essa resposta de volta na reunião.
`realtime.toolPolicy` controla a execução da consulta:
- `safe-read-only`: expõe a ferramenta de consulta e limita o agente normal a
`read`, `web_search`, `web_fetch`, `x_search`, `memory_search` e
`memory_get`.
- `owner`: expõe a ferramenta de consulta e permite que o agente normal use a política
normal de ferramentas do agente.
- `none`: não expõe a ferramenta de consulta ao modelo de voz realtime.
- `owner`: expõe a ferramenta de consulta e permite que o agente normal use a política normal de ferramentas do agente.
- `none`: não expõe a ferramenta de consulta ao modelo de voz em tempo real.
A chave da sessão de consulta é delimitada por sessão do Meet, então chamadas de consulta subsequentes
podem reutilizar o contexto anterior da consulta durante a mesma reunião.
A chave da sessão de consulta tem escopo por sessão do Meet, para que chamadas de consulta de acompanhamento possam reutilizar o contexto anterior da consulta durante a mesma reunião.
Para forçar uma verificação falada de prontidão depois que o Chrome tiver entrado totalmente na chamada:
Para forçar uma verificação falada de prontidão depois que o Chrome já tiver entrado totalmente na chamada:
```bash
openclaw googlemeet speak meet_... "Say exactly: I'm here and listening."
```
## Observações
## Notas
A API oficial de mídia do Google Meet é orientada a recebimento, então falar em uma chamada do Meet
ainda exige um caminho de participante. Este Plugin mantém esse limite visível:
o Chrome cuida da participação pelo navegador e do roteamento local de áudio; o Twilio cuida
da participação por discagem telefônica.
A API oficial de mídia do Google Meet é orientada a recebimento, então falar em uma chamada do Meet ainda exige um caminho de participante. Este Plugin mantém esse limite visível: o Chrome lida com a participação no navegador e o roteamento de áudio local; o Twilio lida com a participação por discagem telefônica.
O modo realtime do Chrome exige uma destas opções:
O modo realtime do Chrome precisa de um destes:
- `chrome.audioInputCommand` mais `chrome.audioOutputCommand`: o OpenClaw controla a
ponte do modelo realtime e encaminha áudio G.711 mu-law em 8 kHz entre esses
comandos e o provedor de voz realtime selecionado.
- `chrome.audioBridgeCommand`: um comando de ponte externo controla todo o caminho
local de áudio e deve sair após iniciar ou validar seu daemon.
- `chrome.audioInputCommand` mais `chrome.audioOutputCommand`: o OpenClaw controla a ponte do modelo realtime e canaliza áudio G.711 mu-law de 8 kHz entre esses comandos e o provedor de voz em tempo real selecionado.
- `chrome.audioBridgeCommand`: um comando de ponte externa controla todo o caminho de áudio local e deve encerrar após iniciar ou validar seu daemon.
Para áudio duplex limpo, encaminhe a saída do Meet e o microfone do Meet por dispositivos
virtuais separados ou por um grafo de dispositivo virtual no estilo Loopback. Um único dispositivo
BlackHole compartilhado pode ecoar outros participantes de volta para a chamada.
Para áudio duplex limpo, encaminhe a saída do Meet e o microfone do Meet por dispositivos virtuais separados ou por um grafo de dispositivo virtual no estilo Loopback. Um único dispositivo BlackHole compartilhado pode ecoar outros participantes de volta para a chamada.
`googlemeet speak` aciona a ponte de áudio realtime ativa para uma sessão do
Chrome. `googlemeet leave` interrompe essa ponte. Para sessões Twilio delegadas
por meio do Plugin Voice Call, `leave` também desliga a chamada de voz subjacente.
`googlemeet speak` aciona a ponte de áudio realtime ativa para uma sessão do Chrome. `googlemeet leave` interrompe essa ponte. Para sessões do Twilio delegadas por meio do Plugin Voice Call, `leave` também encerra a chamada de voz subjacente.
## Relacionados
## Relacionado
- [Plugin Voice Call](/pt-BR/plugins/voice-call)
- [Modo Talk](/pt-BR/nodes/talk)
- [Como criar Plugins](/pt-BR/plugins/building-plugins)
- [Modo de conversa](/pt-BR/nodes/talk)
- [Criando Plugins](/pt-BR/plugins/building-plugins)

298
docs/pt-BR/plugins/voice-call.md
View File

@ -1,54 +1,54 @@
---
read_when:
- Você quer fazer uma chamada de voz de saída a partir do OpenClaw
- Você está configurando ou desenvolvendo o Plugin voice-call
summary: 'Plugin Voice Call: chamadas de saída + entrada via Twilio/Telnyx/Plivo (instalação do Plugin + configuração + CLI)'
title: Plugin Voice Call
- Você está configurando ou desenvolvendo o plugin de chamada de voz
summary: 'Plugin de chamada de voz: chamadas de saída + entrada via Twilio/Telnyx/Plivo (instalação do plugin + configuração + CLI)'
title: Plugin de chamada de voz
x-i18n:
generated_at: "2026-04-24T06:05:28Z"
generated_at: "2026-04-24T09:51:46Z"
model: gpt-5.4
provider: openai
source_hash: 4cd57118133506c22604ab9592a823546a91795ab425de4b7a81edbbb8374e6d
source_hash: 6aed4e33ce090c86f43c71280f033e446f335c53d42456fdc93c9938250e9af6
source_path: plugins/voice-call.md
workflow: 15
---
# Voice Call (Plugin)
# Chamada de Voz (plugin)
Chamadas de voz para o OpenClaw via Plugin. Compatível com chamadas de saída para notificações e
conversas de vários turnos com políticas de entrada.
Chamadas de voz para o OpenClaw via um plugin. Compatível com notificações de saída e
conversas de múltiplas interações com políticas de entrada.
Provedores atuais:
- `twilio` (Programmable Voice + Media Streams)
- `telnyx` (Call Control v2)
- `plivo` (Voice API + transferência XML + GetInput speech)
- `mock` (dev/sem rede)
- `plivo` (Voice API + transferência XML + fala com GetInput)
- `mock` (desenvolvimento/sem rede)
Modelo mental rápido:
- Instalar o Plugin
- Instalar o plugin
- Reiniciar o Gateway
- Configurar em `plugins.entries.voice-call.config`
- Usar `openclaw voicecall ...` ou a ferramenta `voice_call`
## Onde ele é executado (local vs remoto)
O Plugin Voice Call é executado **dentro do processo do Gateway**.
O plugin de Chamada de Voz é executado **dentro do processo do Gateway**.
Se você usa um Gateway remoto, instale/configure o Plugin na **máquina que executa o Gateway** e depois reinicie o Gateway para carregá-lo.
Se você usa um Gateway remoto, instale/configure o plugin na **máquina que executa o Gateway** e depois reinicie o Gateway para carregá-lo.
## Instalação
### Opção A: instalar pelo npm (recomendado)
### Opção A: instalar via npm (recomendado)
```bash
openclaw plugins install @openclaw/voice-call
```
Reinicie o Gateway depois.
Reinicie o Gateway em seguida.
### Opção B: instalar de uma pasta local (dev, sem copiar)
### Opção B: instalar a partir de uma pasta local (desenvolvimento, sem cópia)
```bash
PLUGIN_SRC=./path/to/local/voice-call-plugin
@ -56,7 +56,7 @@ openclaw plugins install "$PLUGIN_SRC"
cd "$PLUGIN_SRC" && pnpm install
```
Reinicie o Gateway depois.
Reinicie o Gateway em seguida.
## Configuração
@ -69,8 +69,8 @@ Defina a configuração em `plugins.entries.voice-call.config`:
"voice-call": {
enabled: true,
config: {
provider: "twilio", // or "telnyx" | "plivo" | "mock"
fromNumber: "+15550001234", // or TWILIO_FROM_NUMBER for Twilio
provider: "twilio", // ou "telnyx" | "plivo" | "mock"
fromNumber: "+15550001234", // ou TWILIO_FROM_NUMBER para Twilio
toNumber: "+15550005678",
twilio: {
@ -81,8 +81,8 @@ Defina a configuração em `plugins.entries.voice-call.config`:
telnyx: {
apiKey: "...",
connectionId: "...",
// Telnyx webhook public key from the Telnyx Mission Control Portal
// (Base64 string; can also be set via TELNYX_PUBLIC_KEY).
// Chave pública do Webhook do Telnyx do Telnyx Mission Control Portal
// (string Base64; também pode ser definida via TELNYX_PUBLIC_KEY).
publicKey: "...",
},
@ -91,19 +91,19 @@ Defina a configuração em `plugins.entries.voice-call.config`:
authToken: "...",
},
// Webhook server
// Servidor de Webhook
serve: {
port: 3334,
path: "/voice/webhook",
},
// Webhook security (recommended for tunnels/proxies)
// Segurança de Webhook (recomendado para túneis/proxies)
webhookSecurity: {
allowedHosts: ["voice.example.com"],
trustedProxyIPs: ["100.64.0.1"],
},
// Public exposure (pick one)
// Exposição pública (escolha uma)
// publicUrl: "https://example.ngrok.app/voice/webhook",
// tunnel: { provider: "ngrok" },
// tailscale: { mode: "funnel", path: "/voice/webhook" }
@ -114,11 +114,11 @@ Defina a configuração em `plugins.entries.voice-call.config`:
streaming: {
enabled: true,
provider: "openai", // optional; first registered realtime transcription provider when unset
provider: "openai", // opcional; usa o primeiro provedor de transcrição em tempo real registrado quando não definido
streamPath: "/voice/stream",
providers: {
openai: {
apiKey: "sk-...", // optional if OPENAI_API_KEY is set
apiKey: "sk-...", // opcional se OPENAI_API_KEY estiver definido
model: "gpt-4o-transcribe",
silenceDurationMs: 800,
vadThreshold: 0.5,
@ -129,6 +129,17 @@ Defina a configuração em `plugins.entries.voice-call.config`:
maxPendingConnectionsPerIp: 4,
maxConnections: 128,
},
realtime: {
enabled: false,
provider: "google", // opcional; usa o primeiro provedor de voz em tempo real registrado quando não definido
providers: {
google: {
model: "gemini-2.5-flash-native-audio-preview-12-2025",
voice: "Kore",
},
},
},
},
},
},
@ -138,45 +149,130 @@ Defina a configuração em `plugins.entries.voice-call.config`:
Observações:
- Twilio/Telnyx exigem uma URL de Webhook **publicamente acessível**.
- Plivo exige uma URL de Webhook **publicamente acessível**.
- Twilio/Telnyx exigem uma URL de Webhook **acessível publicamente**.
- Plivo exige uma URL de Webhook **acessível publicamente**.
- `mock` é um provedor local para desenvolvimento (sem chamadas de rede).
- Se configurações antigas ainda usarem `provider: "log"`, `twilio.from` ou chaves legadas `streaming.*` do OpenAI, execute `openclaw doctor --fix` para reescrevê-las.
- Telnyx exige `telnyx.publicKey` (ou `TELNYX_PUBLIC_KEY`), a menos que `skipSignatureVerification` seja true.
- Se configurações mais antigas ainda usarem `provider: "log"`, `twilio.from` ou chaves legadas `streaming.*` do OpenAI, execute `openclaw doctor --fix` para reescrevê-las.
- O Telnyx exige `telnyx.publicKey` (ou `TELNYX_PUBLIC_KEY`) a menos que `skipSignatureVerification` seja `true`.
- `skipSignatureVerification` é apenas para testes locais.
- Se você usar o plano gratuito do ngrok, defina `publicUrl` com a URL exata do ngrok; a verificação de assinatura é sempre aplicada.
- `tunnel.allowNgrokFreeTierLoopbackBypass: true` permite Webhooks do Twilio com assinaturas inválidas **somente** quando `tunnel.provider="ngrok"` e `serve.bind` está em loopback (agente local do ngrok). Use apenas para desenvolvimento local.
- URLs do plano gratuito do ngrok podem mudar ou adicionar comportamento intermediário; se `publicUrl` divergir, as assinaturas do Twilio falharão. Para produção, prefira um domínio estável ou Tailscale funnel.
- Se você usa o plano gratuito do ngrok, defina `publicUrl` para a URL exata do ngrok; a verificação de assinatura é sempre aplicada.
- `tunnel.allowNgrokFreeTierLoopbackBypass: true` permite Webhooks do Twilio com assinaturas inválidas **apenas** quando `tunnel.provider="ngrok"` e `serve.bind` é loopback (agente local do ngrok). Use apenas para desenvolvimento local.
- URLs do plano gratuito do ngrok podem mudar ou adicionar comportamento intersticial; se `publicUrl` mudar, as assinaturas do Twilio falharão. Para produção, prefira um domínio estável ou o funnel do Tailscale.
- `realtime.enabled` inicia conversas completas de voz para voz; não o habilite junto com `streaming.enabled`.
- Padrões de segurança de streaming:
- `streaming.preStartTimeoutMs` fecha sockets que nunca enviam um frame `start` válido.
- `streaming.maxPendingConnections` limita o total de sockets pré-início não autenticados.
- `streaming.maxPendingConnectionsPerIp` limita sockets pré-início não autenticados por IP de origem.
- `streaming.maxConnections` limita o total de sockets abertos de media stream (pendentes + ativos).
- O fallback de runtime ainda aceita essas chaves antigas de voice-call por enquanto, mas o caminho de reescrita é `openclaw doctor --fix` e o shim de compatibilidade é temporário.
- `streaming.maxConnections` limita o total de sockets abertos de fluxo de mídia (pendentes + ativos).
- O fallback em tempo de execução ainda aceita essas chaves antigas de voice-call por enquanto, mas o caminho de reescrita é `openclaw doctor --fix` e o shim de compatibilidade é temporário.
## Conversas de voz em tempo real
`realtime` seleciona um provedor de voz em tempo real full duplex para áudio de chamada ao vivo.
Ele é separado de `streaming`, que apenas encaminha áudio para provedores
de transcrição em tempo real.
Comportamento atual em tempo de execução:
- `realtime.enabled` é compatível com Twilio Media Streams.
- `realtime.enabled` não pode ser combinado com `streaming.enabled`.
- `realtime.provider` é opcional. Quando não definido, Chamada de Voz usa o primeiro
provedor de voz em tempo real registrado.
- Os provedores de voz em tempo real incluídos incluem Google Gemini Live (`google`) e
OpenAI (`openai`), registrados por seus plugins de provedor.
- A configuração bruta de propriedade do provedor fica em `realtime.providers.<providerId>`.
- Se `realtime.provider` apontar para um provedor não registrado, ou nenhum provedor
de voz em tempo real estiver registrado, Chamada de Voz registra um aviso e ignora
a mídia em tempo real em vez de falhar o plugin inteiro.
Padrões de tempo real do Google Gemini Live:
- Chave de API: `realtime.providers.google.apiKey`, `GEMINI_API_KEY` ou
`GOOGLE_GENERATIVE_AI_API_KEY`
- model: `gemini-2.5-flash-native-audio-preview-12-2025`
- voice: `Kore`
Exemplo:
```json5
{
plugins: {
entries: {
"voice-call": {
config: {
provider: "twilio",
inboundPolicy: "allowlist",
allowFrom: ["+15550005678"],
realtime: {
enabled: true,
provider: "google",
instructions: "Fale brevemente e pergunte antes de usar ferramentas.",
providers: {
google: {
apiKey: "${GEMINI_API_KEY}",
model: "gemini-2.5-flash-native-audio-preview-12-2025",
voice: "Kore",
},
},
},
},
},
},
},
}
```
Use OpenAI em vez disso:
```json5
{
plugins: {
entries: {
"voice-call": {
config: {
realtime: {
enabled: true,
provider: "openai",
providers: {
openai: {
apiKey: "${OPENAI_API_KEY}",
},
},
},
},
},
},
},
}
```
Veja [Provedor Google](/pt-BR/providers/google) e [Provedor OpenAI](/pt-BR/providers/openai)
para opções específicas de voz em tempo real do provedor.
## Transcrição por streaming
`streaming` seleciona um provedor de transcrição em tempo real para áudio de chamadas ao vivo.
`streaming` seleciona um provedor de transcrição em tempo real para áudio de chamada ao vivo.
Comportamento atual do runtime:
Comportamento atual em tempo de execução:
- `streaming.provider` é opcional. Se não for definido, o Voice Call usa o primeiro
- `streaming.provider` é opcional. Quando não definido, Chamada de Voz usa o primeiro
provedor de transcrição em tempo real registrado.
- Provedores integrados de transcrição em tempo real incluem Deepgram (`deepgram`),
- Os provedores de transcrição em tempo real incluídos incluem Deepgram (`deepgram`),
ElevenLabs (`elevenlabs`), Mistral (`mistral`), OpenAI (`openai`) e xAI
(`xai`), registrados por seus Plugins de provedor.
- A configuração bruta de cada provedor fica em `streaming.providers.<providerId>`.
- Se `streaming.provider` apontar para um provedor não registrado, ou se nenhum provedor de transcrição em tempo real estiver registrado, o Voice Call registra um aviso e
ignora o streaming de mídia em vez de fazer o Plugin inteiro falhar.
(`xai`), registrados por seus plugins de provedor.
- A configuração bruta de propriedade do provedor fica em `streaming.providers.<providerId>`.
- Se `streaming.provider` apontar para um provedor não registrado, ou nenhum provedor
de transcrição em tempo real estiver registrado, Chamada de Voz registra um aviso e
ignora o streaming de mídia em vez de falhar o plugin inteiro.
Padrões da transcrição por streaming da OpenAI:
Padrões de transcrição por streaming do OpenAI:
- Chave de API: `streaming.providers.openai.apiKey` ou `OPENAI_API_KEY`
- modelo: `gpt-4o-transcribe`
- model: `gpt-4o-transcribe`
- `silenceDurationMs`: `800`
- `vadThreshold`: `0.5`
Padrões da transcrição por streaming da xAI:
Padrões de transcrição por streaming do xAI:
- Chave de API: `streaming.providers.xai.apiKey` ou `XAI_API_KEY`
- endpoint: `wss://api.x.ai/v1/stt`
@ -199,7 +295,7 @@ Exemplo:
streamPath: "/voice/stream",
providers: {
openai: {
apiKey: "sk-...", // optional if OPENAI_API_KEY is set
apiKey: "sk-...", // opcional se OPENAI_API_KEY estiver definido
model: "gpt-4o-transcribe",
silenceDurationMs: 800,
vadThreshold: 0.5,
@ -227,7 +323,7 @@ Use xAI em vez disso:
streamPath: "/voice/stream",
providers: {
xai: {
apiKey: "${XAI_API_KEY}", // optional if XAI_API_KEY is set
apiKey: "${XAI_API_KEY}", // opcional se XAI_API_KEY estiver definido
endpointingMs: 800,
language: "en",
},
@ -248,17 +344,17 @@ Chaves legadas ainda são migradas automaticamente por `openclaw doctor --fix`:
- `streaming.silenceDurationMs` → `streaming.providers.openai.silenceDurationMs`
- `streaming.vadThreshold` → `streaming.providers.openai.vadThreshold`
## Reaper de chamadas obsoletas
## Limpador de chamadas obsoletas
Use `staleCallReaperSeconds` para encerrar chamadas que nunca recebem um Webhook terminal
(por exemplo, chamadas em modo notify que nunca se completam). O padrão é `0`
(desativado).
Use `staleCallReaperSeconds` para encerrar chamadas que nunca recebem um Webhook
terminal (por exemplo, chamadas em modo notify que nunca são concluídas). O padrão é `0`
(desabilitado).
Faixas recomendadas:
- **Produção:** `120`–`300` segundos para fluxos no estilo notify.
- Mantenha esse valor **maior que `maxDurationSeconds`** para que chamadas normais possam
terminar. Um bom ponto de partida é `maxDurationSeconds + 30–60` segundos.
- Mantenha esse valor **maior que `maxDurationSeconds`** para que chamadas normais
possam terminar. Um bom ponto de partida é `maxDurationSeconds + 30–60` segundos.
Exemplo:
@ -279,28 +375,28 @@ Exemplo:
## Segurança de Webhook
Quando um proxy ou tunnel fica na frente do Gateway, o Plugin reconstrói a
URL pública para verificação de assinatura. Essas opções controlam em quais
cabeçalhos encaminhados confiar.
Quando um proxy ou túnel fica na frente do Gateway, o plugin reconstrói a
URL pública para verificação de assinatura. Essas opções controlam quais cabeçalhos
encaminhados são confiáveis.
`webhookSecurity.allowedHosts` coloca hosts de cabeçalhos encaminhados em allowlist.
`webhookSecurity.allowedHosts` cria uma lista de permissões de hosts a partir de cabeçalhos de encaminhamento.
`webhookSecurity.trustForwardingHeaders` confia em cabeçalhos encaminhados sem uma allowlist.
`webhookSecurity.trustForwardingHeaders` confia em cabeçalhos encaminhados sem uma lista de permissões.
`webhookSecurity.trustedProxyIPs` só confia em cabeçalhos encaminhados quando o IP
remoto da solicitação corresponde à lista.
remoto da requisição corresponde à lista.
A proteção contra replay de Webhook está ativada para Twilio e Plivo. Solicitações de Webhook válidas reproduzidas
são reconhecidas, mas ignoradas para efeitos colaterais.
A proteção contra repetição de Webhook está habilitada para Twilio e Plivo. Requisições
de Webhook válidas repetidas são confirmadas, mas ignoradas para efeitos colaterais.
Turnos de conversa do Twilio incluem um token por turno em callbacks `<Gather>`, então
callbacks de fala obsoletos/reproduzidos não podem satisfazer um turno de transcrição pendente mais novo.
Interações de conversa do Twilio incluem um token por interação em callbacks de `<Gather>`, então
callbacks de fala antigos/repetidos não podem satisfazer uma interação de transcrição pendente mais nova.
Solicitações de Webhook não autenticadas são rejeitadas antes da leitura do corpo quando
os cabeçalhos de assinatura exigidos pelo provedor estão ausentes.
Requisições de Webhook não autenticadas são rejeitadas antes da leitura do corpo quando os
cabeçalhos de assinatura exigidos pelo provedor estão ausentes.
O Webhook de voice-call usa o perfil compartilhado de corpo de pré-autenticação (64 KB / 5 segundos)
mais um limite por IP de solicitações simultâneas antes da verificação de assinatura.
O Webhook de voice-call usa o perfil compartilhado de corpo pré-autenticação (64 KB / 5 segundos)
mais um limite por IP de requisições em andamento antes da verificação de assinatura.
Exemplo com um host público estável:
@ -324,8 +420,8 @@ Exemplo com um host público estável:
## TTS para chamadas
O Voice Call usa a configuração central `messages.tts` para
fala por streaming em chamadas. Você pode sobrescrevê-la na configuração do Plugin com o
**mesmo formato** — ela é mesclada profundamente com `messages.tts`.
transmissão de fala em chamadas. Você pode substituí-la na configuração do plugin com o
**mesmo formato** — ela faz deep merge com `messages.tts`.
```json5
{
@ -343,15 +439,15 @@ fala por streaming em chamadas. Você pode sobrescrevê-la na configuração do
Observações:
- Chaves legadas `tts.<provider>` dentro da configuração do Plugin (`openai`, `elevenlabs`, `microsoft`, `edge`) são migradas automaticamente para `tts.providers.<provider>` no carregamento. Prefira o formato `providers` na configuração versionada.
- **Microsoft speech é ignorado para chamadas de voz** (o áudio de telefonia precisa de PCM; o transporte atual da Microsoft não expõe saída PCM de telefonia).
- O TTS central é usado quando o streaming de mídia do Twilio está ativado; caso contrário, as chamadas recorrem a vozes nativas do provedor.
- Se um media stream do Twilio já estiver ativo, o Voice Call não recorre a `<Say>` do TwiML. Se TTS de telefonia não estiver disponível nesse estado, a solicitação de reprodução falha em vez de misturar dois caminhos de reprodução.
- Chaves legadas `tts.<provider>` dentro da configuração do plugin (`openai`, `elevenlabs`, `microsoft`, `edge`) são migradas automaticamente para `tts.providers.<provider>` no carregamento. Prefira o formato `providers` na configuração versionada.
- **Microsoft speech é ignorado para chamadas de voz** (o áudio de telefonia precisa de PCM; o transporte atual da Microsoft não expõe saída PCM para telefonia).
- O TTS central é usado quando o streaming de mídia do Twilio está habilitado; caso contrário, as chamadas recorrem às vozes nativas do provedor.
- Se um stream de mídia do Twilio já estiver ativo, o Voice Call não recorre ao TwiML `<Say>`. Se o TTS de telefonia não estiver disponível nesse estado, a solicitação de reprodução falha em vez de misturar dois caminhos de reprodução.
- Quando o TTS de telefonia recorre a um provedor secundário, o Voice Call registra um aviso com a cadeia de provedores (`from`, `to`, `attempts`) para depuração.
### Mais exemplos
Usar apenas o TTS central (sem sobrescrever):
Usar apenas o TTS central (sem substituição):
```json5
{
@ -366,7 +462,7 @@ Usar apenas o TTS central (sem sobrescrever):
}
```
Sobrescrever para ElevenLabs apenas em chamadas (manter o padrão central em outros lugares):
Substituir por ElevenLabs apenas para chamadas (manter o padrão central em outros lugares):
```json5
{
@ -391,7 +487,7 @@ Sobrescrever para ElevenLabs apenas em chamadas (manter o padrão central em out
}
```
Sobrescrever apenas o modelo OpenAI para chamadas (exemplo de mesclagem profunda):
Substituir apenas o modelo OpenAI para chamadas (exemplo de deep merge):
```json5
{
@ -416,23 +512,23 @@ Sobrescrever apenas o modelo OpenAI para chamadas (exemplo de mesclagem profunda
## Chamadas de entrada
A política de entrada usa `disabled` por padrão. Para ativar chamadas de entrada, defina:
A política de entrada usa `disabled` por padrão. Para habilitar chamadas de entrada, defina:
```json5
{
inboundPolicy: "allowlist",
allowFrom: ["+15550001234"],
inboundGreeting: "Hello! How can I help?",
inboundGreeting: "Olá! Como posso ajudar?",
}
```
`inboundPolicy: "allowlist"` é uma filtragem de ID de chamador de baixa garantia. O Plugin
`inboundPolicy: "allowlist"` é uma verificação de identificador de chamadas de baixa garantia. O plugin
normaliza o valor `From` fornecido pelo provedor e o compara com `allowFrom`.
A verificação do Webhook autentica a entrega do provedor e a integridade da carga, mas
não comprova a posse do número do chamador em PSTN/VoIP. Trate `allowFrom` como
filtragem de ID de chamador, não como identidade forte do chamador.
ela não comprova a propriedade do número do chamador em PSTN/VoIP. Trate `allowFrom` como
um filtro de identificador de chamadas, não como uma identidade forte do chamador.
As respostas automáticas usam o sistema do agente. Ajuste com:
As respostas automáticas usam o sistema de agentes. Ajuste com:
- `responseModel`
- `responseSystemPrompt`
@ -440,15 +536,15 @@ As respostas automáticas usam o sistema do agente. Ajuste com:
### Contrato de saída falada
Para respostas automáticas, o Voice Call acrescenta um contrato estrito de saída falada ao prompt de sistema:
Para respostas automáticas, o Voice Call anexa um contrato rígido de saída falada ao prompt do sistema:
- `{"spoken":"..."}`
O Voice Call então extrai o texto de fala de forma defensiva:
Depois, o Voice Call extrai o texto de fala de forma defensiva:
- Ignora cargas marcadas como conteúdo de raciocínio/erro.
- Analisa JSON direto, JSON delimitado por cercas ou chaves `"spoken"` inline.
- Usa fallback para texto simples e remove parágrafos iniciais que provavelmente são planejamento/meta.
- Analisa JSON direto, JSON em bloco delimitado ou chaves `"spoken"` inline.
- Recorre a texto simples e remove parágrafos iniciais que provavelmente sejam de planejamento/meta.
Isso mantém a reprodução falada focada no texto voltado ao chamador e evita o vazamento de texto de planejamento para o áudio.
@ -456,16 +552,16 @@ Isso mantém a reprodução falada focada no texto voltado ao chamador e evita o
Para chamadas de saída em modo `conversation`, o tratamento da primeira mensagem está vinculado ao estado de reprodução ao vivo:
- Limpeza de fila por barge-in e resposta automática são suprimidas apenas enquanto a saudação inicial está sendo falada ativamente.
- A limpeza da fila por interrupção e a resposta automática são suprimidas apenas enquanto a saudação inicial estiver sendo falada ativamente.
- Se a reprodução inicial falhar, a chamada volta para `listening` e a mensagem inicial permanece na fila para nova tentativa.
- A reprodução inicial para streaming do Twilio começa na conexão do stream sem atraso extra.
### Período de tolerância para desconexão de stream no Twilio
### Período de tolerância para desconexão de stream do Twilio
Quando um media stream do Twilio é desconectado, o Voice Call aguarda `2000ms` antes de encerrar automaticamente a chamada:
Quando um stream de mídia do Twilio é desconectado, o Voice Call espera `2000ms` antes de encerrar automaticamente a chamada:
- Se o stream se reconectar dentro dessa janela, o encerramento automático é cancelado.
- Se nenhum stream for registrado novamente após o período de tolerância, a chamada será encerrada para evitar chamadas ativas presas.
- Se o stream se reconectar durante essa janela, o encerramento automático é cancelado.
- Se nenhum stream for registrado novamente após o período de tolerância, a chamada será encerrada para evitar chamadas ativas travadas.
## CLI
@ -478,14 +574,14 @@ openclaw voicecall dtmf --call-id <id> --digits "ww123456#"
openclaw voicecall end --call-id <id>
openclaw voicecall status --call-id <id>
openclaw voicecall tail
openclaw voicecall latency # summarize turn latency from logs
openclaw voicecall latency # resume a latência por interação a partir dos logs
openclaw voicecall expose --mode funnel
```
`latency` lê `calls.jsonl` do caminho padrão de armazenamento do voice-call. Use
`latency` lê `calls.jsonl` do caminho de armazenamento padrão do voice-call. Use
`--file <path>` para apontar para um log diferente e `--last <n>` para limitar a análise
aos últimos N registros (padrão 200). A saída inclui p50/p90/p99 para
latência de turno e tempos de espera em listening.
aos últimos N registros (padrão 200). A saída inclui p50/p90/p99 para a
latência por interação e tempos de espera em escuta.
## Ferramenta do agente
@ -500,9 +596,9 @@ Ações:
- `end_call` (callId)
- `get_status` (callId)
Este repositório inclui uma documentação de skill correspondente em `skills/voice-call/SKILL.md`.
Este repositório inclui um documento de Skill correspondente em `skills/voice-call/SKILL.md`.
## RPC do Gateway
## Gateway RPC
- `voicecall.initiate` (`to?`, `message`, `mode?`)
- `voicecall.continue` (`callId`, `message`)
@ -511,8 +607,8 @@ Este repositório inclui uma documentação de skill correspondente em `skills/v
- `voicecall.end` (`callId`)
- `voicecall.status` (`callId`)
## Relacionado
## Relacionados
- [Text-to-speech](/pt-BR/tools/tts)
- [Modo de conversa](/pt-BR/nodes/talk)
- [Texto para fala](/pt-BR/tools/tts)
- [Modo de fala](/pt-BR/nodes/talk)
- [Ativação por voz](/pt-BR/nodes/voicewake)

106
docs/pt-BR/tools/media-overview.md
View File

@ -1,87 +1,91 @@
---
read_when:
- Procurando uma visão geral das capacidades de mídia
- Decidindo qual provider de mídia configurar
- Procurando uma visão geral dos recursos de mídia
- Decidindo qual provedor de mídia configurar
- Entendendo como funciona a geração de mídia assíncrona
summary: Página inicial unificada para capacidades de geração, compreensão e fala de mídia
summary: Página de destino unificada para recursos de geração, compreensão e fala de mídia
title: Visão geral de mídia
x-i18n:
generated_at: "2026-04-24T06:17:34Z"
generated_at: "2026-04-24T09:51:47Z"
model: gpt-5.4
provider: openai
source_hash: 469fb173ac3853011b8cd4f89f3ab97dd7d14e12e4e1d7d87e84de05d025a593
source_hash: 39848c6104ebd4feeb37b233b70f3312fa076b535c3b3780336729eb9fdfa4e6
source_path: tools/media-overview.md
workflow: 15
---
# Geração e compreensão de mídia
O OpenClaw gera imagens, vídeos e música, entende mídia de entrada (imagens, áudio, vídeo) e fala respostas em voz alta com texto para fala. Todas as capacidades de mídia são orientadas por tools: o agente decide quando usá-las com base na conversa, e cada tool só aparece quando pelo menos um provider de backend está configurado.
O OpenClaw gera imagens, vídeos e músicas, compreende mídia recebida (imagens, áudio, vídeo) e vocaliza respostas com conversão de texto em fala. Todos os recursos de mídia são orientados por ferramentas: o agente decide quando usá-los com base na conversa, e cada ferramenta só aparece quando pelo menos um provedor de suporte está configurado.
## Capacidades em resumo
## Recursos em resumo
| Capacidade | Tool | Providers | O que faz |
| --------------------- | ---------------- | ------------------------------------------------------------------------------------------- | ------------------------------------------------------ |
| Geração de imagem | `image_generate` | ComfyUI, fal, Google, MiniMax, OpenAI, Vydra, xAI | Cria ou edita imagens a partir de prompts de texto ou referências |
| Geração de vídeo | `video_generate` | Alibaba, BytePlus, ComfyUI, fal, Google, MiniMax, OpenAI, Qwen, Runway, Together, Vydra, xAI | Cria vídeos a partir de texto, imagens ou vídeos existentes |
| Geração de música | `music_generate` | ComfyUI, Google, MiniMax | Cria música ou faixas de áudio a partir de prompts de texto |
| Texto para fala (TTS) | `tts` | ElevenLabs, Microsoft, MiniMax, OpenAI, xAI | Converte respostas de saída em áudio falado |
| Compreensão de mídia | (automática) | Qualquer provider de modelo com capacidade de visão/áudio, mais fallbacks de CLI | Resume imagens, áudio e vídeo de entrada |
| Recurso | Ferramenta | Provedores | O que faz |
| -------------------- | ---------------- | ------------------------------------------------------------------------------------------- | ------------------------------------------------------- |
| Geração de imagens | `image_generate` | ComfyUI, fal, Google, MiniMax, OpenAI, Vydra, xAI | Cria ou edita imagens a partir de prompts de texto ou referências |
| Geração de vídeo | `video_generate` | Alibaba, BytePlus, ComfyUI, fal, Google, MiniMax, OpenAI, Qwen, Runway, Together, Vydra, xAI | Cria vídeos a partir de texto, imagens ou vídeos existentes |
| Geração de música | `music_generate` | ComfyUI, Google, MiniMax | Cria músicas ou faixas de áudio a partir de prompts de texto |
| Texto para fala (TTS) | `tts` | ElevenLabs, Google, Microsoft, MiniMax, OpenAI, xAI | Converte respostas de saída em áudio falado |
| Compreensão de mídia | (automática) | Qualquer provedor de modelo com suporte a visão/áudio, além de fallbacks da CLI | Resume imagens, áudios e vídeos recebidos |
## Matriz de capacidades por provider
## Matriz de recursos por provedor
Esta tabela mostra quais providers oferecem suporte a quais capacidades de mídia em toda a plataforma.
Esta tabela mostra quais provedores oferecem suporte a quais recursos de mídia em toda a plataforma.
| Provider | Imagem | Vídeo | Música | TTS | STT / Transcrição | Compreensão de mídia |
| ---------- | ------ | ----- | ------ | --- | ----------------- | -------------------- |
| Alibaba | | Sim | | | | |
| BytePlus | | Sim | | | | |
| ComfyUI | Sim | Sim | Sim | | | |
| Deepgram | | | | | Sim | |
| ElevenLabs | | | | Sim | Sim | |
| fal | Sim | Sim | | | | |
| Google | Sim | Sim | Sim | | | Sim |
| Microsoft | | | | Sim | | |
| MiniMax | Sim | Sim | Sim | Sim | | |
| Mistral | | | | | Sim | |
| OpenAI | Sim | Sim | | Sim | Sim | Sim |
| Qwen | | Sim | | | | |
| Runway | | Sim | | | | |
| Together | | Sim | | | | |
| Vydra | Sim | Sim | | | | |
| xAI | Sim | Sim | | Sim | Sim | Sim |
| Provedor | Imagem | Vídeo | Música | TTS | STT / Transcrição | Voz em tempo real | Compreensão de mídia |
| ---------- | ------ | ----- | ------ | --- | ----------------- | ----------------- | -------------------- |
| Alibaba | | Sim | | | | | |
| BytePlus | | Sim | | | | | |
| ComfyUI | Sim | Sim | Sim | | | | |
| Deepgram | | | | | Sim | | |
| ElevenLabs | | | | Sim | Sim | | |
| fal | Sim | Sim | | | | | |
| Google | Sim | Sim | Sim | Sim | | Sim | Sim |
| Microsoft | | | | Sim | | | |
| MiniMax | Sim | Sim | Sim | Sim | | | |
| Mistral | | | | | Sim | | |
| OpenAI | Sim | Sim | | Sim | Sim | Sim | Sim |
| Qwen | | Sim | | | | | |
| Runway | | Sim | | | | | |
| Together | | Sim | | | | | |
| Vydra | Sim | Sim | | | | | |
| xAI | Sim | Sim | | Sim | Sim | | Sim |
<Note>
A compreensão de mídia usa qualquer modelo com capacidade de visão ou áudio registrado na sua configuração de provider. A tabela acima destaca providers com suporte dedicado a compreensão de mídia; a maioria dos providers de LLM com modelos multimodais (Anthropic, Google, OpenAI etc.) também pode entender mídia de entrada quando configurada como modelo ativo de resposta.
A compreensão de mídia usa qualquer modelo com capacidade de visão ou áudio registrado na sua configuração de provedor. A tabela acima destaca os provedores com suporte dedicado à compreensão de mídia; a maioria dos provedores de LLM com modelos multimodais (Anthropic, Google, OpenAI etc.) também consegue compreender mídia recebida quando configurada como o modelo de resposta ativo.
</Note>
## Como funciona a geração assíncrona
Geração de vídeo e música é executada como tarefa em segundo plano porque o processamento do provider normalmente leva de 30 segundos a vários minutos. Quando o agente chama `video_generate` ou `music_generate`, o OpenClaw envia a requisição ao provider, retorna imediatamente um ID de tarefa e rastreia o job no ledger de tarefas. O agente continua respondendo a outras mensagens enquanto o job é executado. Quando o provider termina, o OpenClaw acorda o agente para que ele possa publicar a mídia finalizada de volta no canal original. Geração de imagem e TTS são síncronos e são concluídos inline com a resposta.
A geração de vídeo e música é executada como tarefas em segundo plano porque o processamento do provedor normalmente leva de 30 segundos a vários minutos. Quando o agente chama `video_generate` ou `music_generate`, o OpenClaw envia a solicitação ao provedor, retorna imediatamente um ID de tarefa e acompanha o trabalho no registro de tarefas. O agente continua respondendo a outras mensagens enquanto o trabalho está em execução. Quando o provedor termina, o OpenClaw desperta o agente para que ele possa publicar a mídia concluída de volta no canal original. A geração de imagens e o TTS são síncronos e são concluídos inline com a resposta.
Deepgram, ElevenLabs, Mistral, OpenAI e xAI podem transcrever áudio de entrada
Deepgram, ElevenLabs, Mistral, OpenAI e xAI podem transcrever áudio recebido
pelo caminho em lote `tools.media.audio` quando configurados. Deepgram,
ElevenLabs, Mistral, OpenAI e xAI também registram providers de STT em streaming para Voice Call,
então o áudio ao vivo da chamada pode ser encaminhado ao vendor selecionado
sem esperar por uma gravação concluída.
ElevenLabs, Mistral, OpenAI e xAI também registram provedores de STT de
streaming para Voice Call, para que o áudio telefônico ao vivo possa ser
encaminhado ao fornecedor selecionado sem esperar por uma gravação concluída.
A OpenAI mapeia para as superfícies do OpenClaw de imagem, vídeo, TTS em lote, STT em lote, STT em streaming para Voice Call, voz realtime e embeddings de memória. A xAI atualmente
mapeia para as superfícies do OpenClaw de imagem, vídeo, busca, execução de código, TTS em lote, STT em lote
e STT em streaming para Voice Call. A voz Realtime da xAI é uma
capacidade upstream, mas não é registrada no OpenClaw até que o contrato compartilhado
de voz realtime possa representá-la.
Google corresponde às superfícies de imagem, vídeo, música, TTS em lote, voz
em tempo real no backend e compreensão de mídia do OpenClaw. OpenAI corresponde
às superfícies de imagem, vídeo, TTS em lote, STT em lote, STT de streaming
para Voice Call, voz em tempo real no backend e embeddings de memória do
OpenClaw. xAI atualmente corresponde às superfícies de imagem, vídeo, busca,
execução de código, TTS em lote, STT em lote e STT de streaming para Voice Call
do OpenClaw. A voz Realtime do xAI é um recurso upstream, mas não está
registrada no OpenClaw até que o contrato compartilhado de voz em tempo real
consiga representá-la.
## Links rápidos
- [Geração de imagem](/pt-BR/tools/image-generation) -- geração e edição de imagens
- [Geração de imagens](/pt-BR/tools/image-generation) -- gerar e editar imagens
- [Geração de vídeo](/pt-BR/tools/video-generation) -- texto para vídeo, imagem para vídeo e vídeo para vídeo
- [Geração de música](/pt-BR/tools/music-generation) -- criação de música e faixas de áudio
- [Texto para fala](/pt-BR/tools/tts) -- conversão de respostas em áudio falado
- [Compreensão de mídia](/pt-BR/nodes/media-understanding) -- compreensão de imagens, áudio e vídeo de entrada
- [Geração de música](/pt-BR/tools/music-generation) -- criar músicas e faixas de áudio
- [Texto para fala](/pt-BR/tools/tts) -- converter respostas em áudio falado
- [Compreensão de mídia](/pt-BR/nodes/media-understanding) -- compreender imagens, áudios e vídeos recebidos
## Relacionado
## Relacionados
- [Geração de imagem](/pt-BR/tools/image-generation)
- [Geração de imagens](/pt-BR/tools/image-generation)
- [Geração de vídeo](/pt-BR/tools/video-generation)
- [Geração de música](/pt-BR/tools/music-generation)
- [Texto para fala](/pt-BR/tools/tts)