primocode 8.42.2 → 9.1.0

package/voz/primo_voz/__main__.py

@@ -0,0 +1,383 @@
+"""primo_voz — o Primo Code em modo voz.
+
+    "/voice abre o Primo Code em modo voz. Ele abre como um aplicativozinho,
+     não como uma janela de terminal comum. Base: a lógica do Jarvis, que já
+     funciona. Não roda mais com Claude por baixo: usa o modelo selecionado
+     nos conectores do Primo Code."
+
+── A DECISÃO QUE DEFINE ESTE ARQUIVO ───────────────────────────────────────
+Este programa NÃO tem cérebro. Ele ouve, transcreve, fala e desenha a orb — e
+manda o texto para o PrimoCode, que é quem pensa.
+
+O caminho óbvio era portar o cérebro para cá: o Jarvis fazia isso, mantendo
+uma sessão do Claude Code num processo filho. Copiar aquilo significaria uma
+segunda implementação do laço do agente, das trinta ferramentas, do portão de
+permissão do computador e da corrente de conectores — em outra linguagem. Duas
+implementações do mesmo laço é a garantia de que uma delas está errada, e de
+que a correção de amanhã vai para só uma.
+
+Então o cérebro é UM, e é o mesmo do terminal: o `lib/act.js`. Falar com ele
+custa uma linha de JSON no stdout. E é isto que faz o pedido ser cumprido sem
+gambiarra — "usa o modelo selecionado nos conectores do Primo Code" não é uma
+integração a construir: é consequência de o cérebro ser o Primo Code.
+
+── O PROTOCOLO ─────────────────────────────────────────────────────────────
+Uma linha de JSON por mensagem, nas duas direções.
+
+    para o Node:  {"tipo":"pedido","texto":"..."}   {"tipo":"fim"}
+    do Node:      {"tipo":"estado","estado":"pensando"}
+                  {"tipo":"resposta","texto":"..."}
+                  {"tipo":"erro","texto":"..."}
+
+── O QUE FOI REMOVIDO DO JARVIS ────────────────────────────────────────────
+A wake word "Jarvis" e as variantes dela, a saudação com o nome do dono, a
+pasta "Jarvis Workspace", as preferências pessoais, o gesto de câmera, o
+cursor próprio, a barra de comando e a janela de conversa. O que sobra é o que
+é do produto: ouvir, pensar, falar.
+"""
+from __future__ import annotations
+
+import json
+import os
+import queue
+import subprocess
+import sys
+import tempfile
+import threading
+import time
+from pathlib import Path
+
+AQUI = Path(__file__).resolve().parent
+sys.path.insert(0, str(AQUI.parent))
+
+from primo_voz import escuta, orbe  # noqa: E402
+
+
+def falar_para_o_node(obj: dict) -> None:
+    """Uma linha de JSON no stdout. Nada mais pode sair por aí."""
+    sys.stdout.write(json.dumps(obj, ensure_ascii=False) + "\n")
+    sys.stdout.flush()
+
+
+def avisar(texto: str) -> None:
+    """Recado para o terminal, na saída de ERRO — o stdout é do protocolo."""
+    sys.stderr.write(texto.rstrip() + "\n")
+    sys.stderr.flush()
+
+
+# O PowerShell que toca MP3 no Windows. MediaPlayer é assíncrono: Play()
+# devolve na hora, então é preciso esperar a duração — e esperar com teto, ou
+# um Open que falha deixaria a thread da fala pendurada para sempre.
+def motivo_da_narracao(r) -> str:
+    """O que o narrar.py disse que houve — em vez do código de saída.
+
+    Ele responde JSON em stdout, com "error" e "comoResolver". Quando esse
+    JSON não vem (o processo morreu antes de escrever), sobra o stderr, que
+    ainda diz mais que "returned non-zero exit status 1".
+    """
+    try:
+        d = json.loads((r.stdout or b"").decode("utf-8", "replace"))
+        if isinstance(d, dict) and d.get("error"):
+            comoResolver = d.get("comoResolver") or ""
+            return "não deu para gerar a voz: " + str(d["error"]) + (
+                " — " + str(comoResolver) if comoResolver else "")
+    except Exception:
+        pass
+    erro = (r.stderr or b"").decode("utf-8", "replace").strip()
+    ultima = erro.splitlines()[-1] if erro else ""
+    return "não deu para gerar a voz" + (f": {ultima[:300]}" if ultima else
+                                         f" (o narrar.py saiu com {r.returncode})")
+
+
+PS_TOCAR_MP3 = (
+    "Add-Type -AssemblyName PresentationCore; "
+    "$p = New-Object System.Windows.Media.MediaPlayer; "
+    "$p.Open([uri]'{arquivo}'); "
+    "$n = 0; "
+    "while (-not $p.NaturalDuration.HasTimeSpan -and $n -lt 100) "
+    "{{ Start-Sleep -Milliseconds 50; $n++ }}; "
+    "if (-not $p.NaturalDuration.HasTimeSpan) {{ exit 1 }}; "
+    "$p.Play(); "
+    "Start-Sleep -Seconds $p.NaturalDuration.TimeSpan.TotalSeconds; "
+    "$p.Close()"
+)
+
+
+class Voz:
+    """A costura: microfone → transcrição → Node → voz → microfone."""
+
+    def __init__(self, servidor: str, token: str, voz_escolhida: str = "antonio"):
+        self.servidor = servidor
+        self.token = token
+        self.voz = voz_escolhida
+
+        self.orb = orbe.Orbe(ao_fechar=self.parar)
+        self.gravador = escuta.Gravador()
+        self.corte = escuta.Corte()
+
+        self._blocos = queue.Queue()
+        self._vivo = True
+        self._falando = False
+        self._pensando = False
+        self._parar_fala = threading.Event()
+        self._do_node = queue.Queue()
+
+    # ── microfone ────────────────────────────────────────────────────────
+    def _ao_receber(self, bloco) -> None:
+        if not self._vivo:
+            return
+        nivel = escuta.rms(bloco)
+
+        # Falar por cima CORTA a resposta. Sem isto, a única forma de
+        # interromper é esperar ele terminar — e esperar um assistente
+        # terminar de falar uma coisa errada é a pior parte de usar um.
+        if self._falando:
+            self.corte.ele_falou(nivel)
+            if self.corte.alguem_cortou(nivel):
+                self._parar_fala.set()
+            return
+
+        self._blocos.put(bloco)
+        if self.orb:
+            self.orb.mudar(nivel=min(1.0, nivel / 2500.0))
+
+    # ── o laço ───────────────────────────────────────────────────────────
+    def _laco(self) -> None:
+        mic = escuta.Microfone(self._ao_receber)
+        try:
+            mic.abrir()
+        except Exception as e:
+            avisar(f"não consegui abrir o microfone: {e}")
+            falar_para_o_node({"tipo": "erro", "texto": f"microfone: {e}"})
+            self.parar()
+            return
+
+        while self._vivo:
+            self.orb.mudar(estado="esperando", nivel=0)
+            self.gravador.comecar()
+
+            # Esperar a frase.
+            acabou = False
+            while self._vivo and not acabou:
+                try:
+                    bloco = self._blocos.get(timeout=0.3)
+                except queue.Empty:
+                    continue
+                if self.gravador._falando:
+                    self.orb.mudar(estado="ouvindo")
+                acabou = self.gravador.alimentar(bloco)
+
+            if not self._vivo:
+                break
+            if self.gravador.encerrou_por == "ninguem-falou" or self.gravador.segundos < 0.4:
+                continue
+
+            wav = self.gravador.gravar_wav(Path(tempfile.gettempdir()) / "primo-voz-fala.wav")
+            if not wav:
+                continue
+
+            self.orb.mudar(estado="pensando")
+            texto = self._transcrever(wav)
+            if not texto or len(texto.strip()) < 2:
+                continue
+
+            falar_para_o_node({"tipo": "pedido", "texto": texto})
+            resposta = self._esperar_resposta()
+            if resposta:
+                self._falar(resposta)
+
+        mic.fechar()
+
+    # ── transcrição ──────────────────────────────────────────────────────
+    def _transcrever(self, wav: Path) -> str:
+        """Quem tem a chave é o servidor do PrimoCode, não este programa.
+
+        É a mesma rota que a legenda de vídeo usa. Duas formas de transcrever
+        seriam duas contas para pagar e duas para consertar.
+        """
+        import base64
+        import urllib.request
+
+        # O wav de 16 kHz mono já é pequeno; converter para mp3 exigiria
+        # ffmpeg, que nem toda máquina tem — e uma frase de dez segundos cabe
+        # em ~300 KB, que atravessa a rede sem dor.
+        dados = base64.b64encode(wav.read_bytes()).decode("ascii")
+        corpo = json.dumps({"audio": dados, "nome": "fala.wav", "idioma": "pt"}).encode("utf-8")
+        pedido = urllib.request.Request(
+            self.servidor.rstrip("/") + "/api/transcrever",
+            data=corpo,
+            headers={"Content-Type": "application/json", "x-primocode-token": self.token},
+        )
+        try:
+            with urllib.request.urlopen(pedido, timeout=90) as r:
+                j = json.loads(r.read().decode("utf-8"))
+            return str(j.get("texto") or "").strip()
+        except Exception as e:
+            avisar(f"não deu para transcrever: {e}")
+            return ""
+
+    # ── resposta do Node ─────────────────────────────────────────────────
+    def _esperar_resposta(self) -> str:
+        while self._vivo:
+            try:
+                msg = self._do_node.get(timeout=0.5)
+            except queue.Empty:
+                continue
+            tipo = msg.get("tipo")
+            if tipo == "estado":
+                self.orb.mudar(estado=msg.get("estado") or "pensando")
+            elif tipo == "resposta":
+                return str(msg.get("texto") or "")
+            elif tipo == "erro":
+                return str(msg.get("texto") or "não deu certo")
+            elif tipo == "fim":
+                self.parar()
+                return ""
+        return ""
+
+    def ouvir_o_node(self) -> None:
+        """Lê o stdin, linha a linha, até ele fechar."""
+        for linha in sys.stdin:
+            linha = linha.strip()
+            if not linha:
+                continue
+            try:
+                self._do_node.put(json.loads(linha))
+            except json.JSONDecodeError:
+                continue
+        self.parar()
+
+    # ── voz ──────────────────────────────────────────────────────────────
+    def _falar(self, texto: str) -> None:
+        """A resposta sai em voz — e SÓ em voz.
+
+        O texto não aparece em lugar nenhum da interface. É a regra do modo:
+        ler a resposta é trabalho, ouvir não é.
+        """
+        limpo = " ".join(str(texto).split())
+        if not limpo:
+            return
+        # Resposta longa demais em voz é castigo: quem ouve não pode passar o
+        # olho. O agente já responde curto no modo voz (o Node manda a
+        # instrução), e isto é a rede embaixo.
+        if len(limpo) > 900:
+            limpo = limpo[:880].rsplit(" ", 1)[0] + "…"
+
+        mp3 = Path(tempfile.gettempdir()) / f"primo-voz-{int(time.time() * 1000)}.mp3"
+        narrar = AQUI.parent.parent / "studio" / "narrar.py"
+        # O narrar.py IMPRIME um JSON dizendo o que faltou e como resolver
+        # ("instale o edge-tts com… "). Com check=True isso virava uma
+        # CalledProcessError cujo texto é "Command '[...]' returned non-zero
+        # exit status 1" — e era ISSO que chegava ao usuário, com o conselho
+        # útil jogado fora dentro do capture_output. Agora a saída é lida.
+        r = subprocess.run(
+            [sys.executable, str(narrar), "falar", "--texto", limpo,
+             "--saida", str(mp3), "--voz", self.voz],
+            capture_output=True, timeout=180)
+        if r.returncode != 0 or not mp3.exists():
+            avisar(motivo_da_narracao(r))
+            return
+
+        self._falando = True
+        self._parar_fala.clear()
+        self.orb.mudar(estado="falando")
+        try:
+            self._tocar(mp3)
+        finally:
+            self._falando = False
+            self.corte.nivel_dele = 0.0
+            try:
+                mp3.unlink()
+            except OSError:
+                pass
+
+    def _tocar(self, arquivo: Path) -> None:
+        """Toca o mp3 com o que a máquina tiver.
+
+        Nenhum tocador é garantido em todo sistema, então são vários, na ordem
+        de quem está mais presente — e o processo é interrompível, porque
+        falar por cima precisa calar a voz na hora.
+        """
+        tentativas = []
+        if sys.platform == "darwin":
+            tentativas.append(["afplay", str(arquivo)])
+        elif sys.platform == "win32":
+            # Media.SoundPlayer NÃO toca MP3 — ele só lê WAV, e o que o
+            # narrar.py entrega é MP3. Era a primeira tentativa da fila, e
+            # levantava exceção sempre; como o laço abaixo aceitava qualquer
+            # processo que tivesse CONSEGUIDO INICIAR, ele dava por tocado e
+            # voltava. Resultado: o modo voz era MUDO no Windows, sem nenhum
+            # aviso — a orb piscava "falando" e não saía som nenhum.
+            # MediaPlayer decodifica MP3; a espera é limitada para não travar
+            # a thread se o Open falhar.
+            tentativas.append(["powershell", "-NoProfile", "-Command", PS_TOCAR_MP3.format(arquivo=arquivo)])
+        tentativas += [
+            ["ffplay", "-nodisp", "-autoexit", "-loglevel", "quiet", str(arquivo)],
+            ["mpg123", "-q", str(arquivo)],
+            ["mpv", "--no-video", "--really-quiet", str(arquivo)],
+            ["cvlc", "--play-and-exit", "--intf", "dummy", str(arquivo)],
+        ]
+        for cmd in tentativas:
+            try:
+                p = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            except (FileNotFoundError, OSError):
+                continue
+            while p.poll() is None:
+                if self._parar_fala.is_set() or not self._vivo:
+                    try:
+                        p.terminate()
+                    except Exception:
+                        pass
+                    return          # calado de propósito: falaram por cima
+                time.sleep(0.05)
+            if p.returncode == 0:
+                return
+            # INICIAR não é TOCAR. O tocador existia e falhou (formato que ele
+            # não lê, dispositivo de áudio ocupado): a fila continua. Sair aqui
+            # era o que transformava "o primeiro tocador não serve" em silêncio
+            # absoluto, com quatro alternativas por tentar logo abaixo.
+            continue
+        avisar("não achei um tocador de áudio que funcione neste computador."
+               + (" Instale o ffmpeg: winget install ffmpeg" if sys.platform == "win32"
+                  else " Instale o ffmpeg: brew install ffmpeg" if sys.platform == "darwin"
+                  else " Instale o ffmpeg: sudo apt install ffmpeg"))
+
+    # ── ciclo de vida ────────────────────────────────────────────────────
+    def parar(self) -> None:
+        if not self._vivo:
+            return
+        self._vivo = False
+        self._parar_fala.set()
+        falar_para_o_node({"tipo": "fim"})
+
+    def rodar(self) -> None:
+        threading.Thread(target=self._laco, daemon=True).start()
+        threading.Thread(target=self.ouvir_o_node, daemon=True).start()
+        # A interface fica na thread principal, porque em todo sistema é lá
+        # que uma janela pode existir.
+        self.orb.rodar()
+
+
+def main() -> int:
+    servidor = os.environ.get("PRIMOCODE_SERVER", "").strip()
+    token = os.environ.get("PRIMOCODE_TOKEN", "").strip()
+    voz = os.environ.get("PRIMOCODE_VOZ", "antonio").strip() or "antonio"
+
+    if not servidor:
+        avisar("falta PRIMOCODE_SERVER — este programa é aberto pelo /voice do PrimoCode.")
+        return 2
+
+    try:
+        import numpy  # noqa: F401
+        import sounddevice  # noqa: F401
+    except ImportError as e:
+        avisar(f"falta um pacote de áudio ({e.name}). Rode: "
+               f"{sys.executable} -m pip install sounddevice numpy")
+        return 3
+
+    Voz(servidor, token, voz).rodar()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/voz/primo_voz/escuta.py

@@ -0,0 +1,235 @@
+"""escuta.py — ouvir a pessoa falar, e saber quando ela terminou.
+
+Adaptado do Jarvis (src/jarvis/core/vad.py e audio_io.py), que é a parte dele
+que não tem nada de macOS: numpy e sounddevice, e mais nada.
+
+── AS DUAS COISAS QUE ERRAM FEIO SE FOREM INGÊNUAS ─────────────────────────
+
+**O limiar de "isso é fala"** não pode ser um número fixo. Num quarto
+silencioso, um número fixo fica surdo; numa sala com televisão, ele acha que a
+televisão está falando com ele. Então o limiar é relativo ao barulho do
+ambiente, medido um instante antes de cada frase.
+
+**O fim da frase** não é o primeiro silêncio. Quem explica alguma coisa pausa
+para pensar, e pausa de pensar passa fácil de um segundo — cortar ali é cortar
+a pessoa no meio. Por isso o rabo de silêncio é de dois segundos, e cresce
+quando a fala já vem longa: quem está explicando pausa mais.
+
+E há a **histerese**: começar a gravar exige som claramente acima do ambiente,
+mas CONTINUAR gravando exige bem menos. Sem isso, a sílaba fraca no fim ("…pra
+mim") cai abaixo do limiar e a frase é cortada antes de acabar.
+
+── O QUE SAIU DO JARVIS ────────────────────────────────────────────────────
+A wake word. Lá ela existia porque o assistente ficava ligado o dia inteiro
+esperando ser chamado. Aqui a pessoa abriu o modo voz de propósito: ele já
+está ouvindo, e não há nome para dizer. Some com isso o Vosk e os 40 MB de
+modelo que ele baixava.
+"""
+from __future__ import annotations
+
+import threading
+import time
+import wave
+from pathlib import Path
+from typing import List, Optional
+
+import numpy as np
+
+TAXA = 16000
+BLOCO_MS = 100
+BLOCO = int(TAXA * BLOCO_MS / 1000)
+
+PISO_FALA = 380.0          # RMS mínimo para começar a contar como fala
+MULT_AMBIENTE = 1.7        # precisa se destacar do ambiente nessa proporção
+TETO_FALA = 700.0          # nunca exige mais que isso (não ficar surdo)
+FATOR_CONTINUAR = 0.5      # a histerese: depois de começar, o limiar cai
+PRE_ROLL = 4               # blocos guardados ANTES do início da fala
+
+RABO_SILENCIO = 2.0        # silêncio que encerra a frase
+RABO_SILENCIO_LONGA = 2.8  # …e quando a fala já vem longa
+FALA_LONGA = 6.0
+ESPERA_COMECAR = 8.0       # tempo para a pessoa começar a falar
+MAX_FRASE = 45.0
+MAX_FRASE_ESTENDIDA = 100.0
+
+# Interromper ele falando: o microfone também ouve a voz DELE saindo pelo
+# alto-falante, então o limiar é relativo ao nível da própria fala dele.
+CORTE_FATOR = 2.3
+CORTE_BLOCOS = 3
+CORTE_MINIMO = 560.0
+
+
+def rms(bloco: np.ndarray) -> float:
+    """Energia do bloco. Em float para não estourar em int16."""
+    if bloco is None or len(bloco) == 0:
+        return 0.0
+    x = bloco.astype(np.float64)
+    return float(np.sqrt(np.mean(x * x)))
+
+
+class Gravador:
+    """Junta os blocos de uma frase, do começo ao silêncio que a encerra.
+
+    ── O RELÓGIO É O ÁUDIO, NÃO A PAREDE ───────────────────────────────────
+    O Jarvis media tudo com `time.monotonic()`, porque lá o áudio chegava em
+    tempo real do microfone e as duas coisas andavam juntas. Só que elas nem
+    sempre andam: o sistema entrega áudio em rajada quando a thread perde a
+    vez, e aí o relógio de parede diz "dois segundos de silêncio" no meio de
+    uma frase que acabou de chegar inteira de uma vez.
+
+    Aqui cada bloco vale exatamente 100 ms de áudio, e o tempo avança por
+    bloco consumido. A conta passa a ser exata, imune a soluço de
+    agendamento — e, de quebra, testável: dá para alimentar uma frase inteira
+    num laço e medir onde ela seria cortada, sem esperar em tempo real.
+    """
+
+    def __init__(self) -> None:
+        self._blocos: List[np.ndarray] = []
+        self._pre: List[np.ndarray] = []
+        self._falando = False
+        self._relogio = 0.0        # segundos de ÁUDIO consumidos
+        self._ultimo_som = 0.0
+        self._ambiente = PISO_FALA
+        self._amostras_ambiente: List[float] = []
+        self.encerrou_por = ""
+
+    # O ambiente é medido ENQUANTO ele espera a pessoa começar. Medir antes de
+    # abrir o microfone daria o silêncio do processo, não o do cômodo.
+    def _limiar(self) -> float:
+        base = max(PISO_FALA, min(TETO_FALA, self._ambiente * MULT_AMBIENTE))
+        return base * (FATOR_CONTINUAR if self._falando else 1.0)
+
+    def comecar(self) -> None:
+        self._blocos = []
+        self._pre = []
+        self._falando = False
+        self._relogio = 0.0
+        self._ultimo_som = 0.0
+        self._amostras_ambiente = []
+        self.encerrou_por = ""
+
+    def alimentar(self, bloco: np.ndarray) -> bool:
+        """Devolve True quando a frase acabou."""
+        self._relogio += BLOCO_MS / 1000.0
+        agora = self._relogio
+        nivel = rms(bloco)
+
+        if not self._falando:
+            # Guarda os últimos blocos: sem eles, a frase começa cortada na
+            # primeira sílaba, que é a que o reconhecedor mais precisa.
+            self._pre.append(bloco)
+            if len(self._pre) > PRE_ROLL:
+                self._pre.pop(0)
+
+            self._amostras_ambiente.append(nivel)
+            if len(self._amostras_ambiente) > 20:
+                self._amostras_ambiente.pop(0)
+            if len(self._amostras_ambiente) >= 5:
+                self._ambiente = float(np.median(self._amostras_ambiente))
+
+            if nivel > self._limiar():
+                self._falando = True
+                self._blocos = list(self._pre)
+                self._ultimo_som = agora
+            elif agora > ESPERA_COMECAR:
+                self.encerrou_por = "ninguem-falou"
+                return True
+            return False
+
+        self._blocos.append(bloco)
+        if nivel > self._limiar():
+            self._ultimo_som = agora
+
+        duracao = len(self._blocos) * BLOCO_MS / 1000.0
+        rabo = RABO_SILENCIO_LONGA if duracao > FALA_LONGA else RABO_SILENCIO
+
+        if agora - self._ultimo_som > rabo:
+            self.encerrou_por = "silencio"
+            return True
+        # Ainda falando ao bater o limite: estende em vez de cortar no meio da
+        # frase. Cortar no meio devolve um pedido pela metade, e o agente
+        # obedece ao pedido pela metade.
+        if duracao > MAX_FRASE and agora - self._ultimo_som > 0.6:
+            self.encerrou_por = "longa-demais"
+            return True
+        if duracao > MAX_FRASE_ESTENDIDA:
+            self.encerrou_por = "teto"
+            return True
+        return False
+
+    @property
+    def segundos(self) -> float:
+        return len(self._blocos) * BLOCO_MS / 1000.0
+
+    def gravar_wav(self, caminho: Path) -> Optional[Path]:
+        if not self._blocos:
+            return None
+        dados = np.concatenate(self._blocos)
+        caminho.parent.mkdir(parents=True, exist_ok=True)
+        with wave.open(str(caminho), "wb") as w:
+            w.setnchannels(1)
+            w.setsampwidth(2)
+            w.setframerate(TAXA)
+            w.writeframes(dados.astype(np.int16).tobytes())
+        return caminho
+
+
+class Corte:
+    """Percebe a pessoa falando por cima enquanto ele responde.
+
+    O limiar é relativo ao nível da fala DELE, medido ao vivo — com limiar
+    fixo, ou ele nunca é interrompido (alto-falante alto) ou se interrompe
+    sozinho o tempo todo (a própria voz dele passa do limiar).
+    """
+
+    def __init__(self) -> None:
+        self.nivel_dele = 0.0
+        self._seguidos = 0
+
+    def ele_falou(self, nivel: float) -> None:
+        # Média móvel: a voz dele oscila, e o limiar não pode oscilar junto.
+        self.nivel_dele = self.nivel_dele * 0.85 + nivel * 0.15
+
+    def alguem_cortou(self, nivel: float) -> bool:
+        limiar = max(CORTE_MINIMO, self.nivel_dele * CORTE_FATOR)
+        if nivel > limiar:
+            self._seguidos += 1
+        else:
+            self._seguidos = 0
+        if self._seguidos >= CORTE_BLOCOS:
+            self._seguidos = 0
+            return True
+        return False
+
+
+class Microfone:
+    """O microfone aberto, entregando blocos de 100 ms.
+
+    Um único fluxo para a sessão inteira: abrir e fechar a cada frase custa
+    centenas de milissegundos e, em alguns sistemas, faz um estalo.
+    """
+
+    def __init__(self, ao_receber):
+        import sounddevice as sd
+        self._sd = sd
+        self._ao_receber = ao_receber
+        self._fluxo = None
+
+    def abrir(self) -> None:
+        def retorno(dados, quadros, tempo, estado):  # noqa: ARG001
+            self._ao_receber(dados[:, 0].copy())
+
+        self._fluxo = self._sd.InputStream(
+            samplerate=TAXA, channels=1, dtype="int16",
+            blocksize=BLOCO, callback=retorno,
+        )
+        self._fluxo.start()
+
+    def fechar(self) -> None:
+        if self._fluxo is not None:
+            try:
+                self._fluxo.stop()
+                self._fluxo.close()
+            except Exception:
+                pass
+            self._fluxo = None