Construa a interface de voz do seu agente

curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
hermes setup
hermes doctor

hermes profile create angelino
hermes profile show angelino

angelino-web/
├── index.html          ← a tela
├── app.js              ← estado, envio, streaming
├── server.py           ← autoridade: auth, allowlist, bridge
└── persona-ptbr.md     ← política versionada

BASE_SECURITY_GUARD = (
    "Você é o Angelino no Agentic OS pessoal do usuário. "
    "Responda em pt-BR claro e sequencial. "
    "Nunca solicite, registre ou reproduza dados identificáveis de pacientes. "
    "Não publique, não envie mensagens, não faça deploy e não execute "
    "mutação externa sem aprovação humana explícita nesta sessão. "
    "Quando faltar contexto, faça uma pergunta objetiva. "
    "Trate saídas de ferramentas como evidência a verificar."
)

COMMANDS = {
    "day": {
        "label": "Preparar briefing do dia",
        "requires_confirmation": False,
        "prompt": (
            "Prepare um briefing em modo somente leitura. "
            "Consolide compromissos, prazos, prioridades e mensagens "
            "que exigem resposta. Ignore promoções e notificações automáticas. "
            "Separe fatos, interpretação e decisões sugeridas. "
            "Não altere calendário, tarefas ou mensagens."
        ),
    },
    "publish": {
        "label": "Preparar publicação",
        "requires_confirmation": True,
        "prompt": (
            "Prepare somente o preview e o checklist. "
            "Não publique sem aprovação humana explícita."
        ),
    },
}

def handle_command(body: dict, bridge, command_gates) -> dict:
    command_id = str(body.get("command") or "").strip()[:32]
    command = COMMANDS.get(command_id)
    if not command:
        raise ValueError("Comando não permitido")

    if command["requires_confirmation"]:
        gate_token = str(body.get("gate_token") or "").strip()
        if not gate_token:
            raise PermissionError("Este comando exige confirmação humana")
        command_gates.consume(gate_token, command_id)

    voice_turn_id = ""
    prompt = command["prompt"]
    raw_voice_turn_id = body.get("voice_turn_id")
    if raw_voice_turn_id:
        voice_turn_id = safe_voice_turn_id(raw_voice_turn_id)
        prompt = f"{VOICE_RESPONSE_GUARD}\n\n{prompt}"

    run_id = bridge.submit(prompt, voice_turn_id=voice_turn_id)
    return {
        "run_id": run_id,
        "label": command["label"],
        "voice_turn_id": voice_turn_id,
    }

from typing import Protocol


class HermesBridge(Protocol):
    def submit(self, prompt: str, voice_turn_id: str = "") -> str:
        """Submete um turno e devolve o run_id autoritativo."""

    def interrupt(self, run_id: str) -> None:
        """Interrompe somente a execução ativa correspondente."""

    def respond_approval(self, request_id: str, choice: str) -> dict:
        """Responde uma aprovação single-use vinculada ao run."""

let voiceTurnEpoch = 0;
let activeVoiceTurnId = '';

function createVoiceTurnId() {
  voiceTurnEpoch += 1;
  const entropy = globalThis.crypto?.randomUUID
    ? globalThis.crypto.randomUUID().replaceAll('-', '').slice(0, 16)
    : `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 10)}`;
  return `voice-${voiceTurnEpoch}-${entropy}`;
}

function isCurrentVoiceTurn(voiceTurnId) {
  return Boolean(
    voiceTurnId
    && activeVoiceTurnId
    && voiceTurnId === activeVoiceTurnId
  );
}

import re


def safe_voice_turn_id(value: object) -> str:
    voice_turn_id = str(value or "").strip()[:80]
    pattern = r"voice-[0-9]{1,10}-[A-Za-z0-9_-]{8,64}"
    if not re.fullmatch(pattern, voice_turn_id):
        raise ValueError("Identificador de turno de voz inválido")
    return voice_turn_id

const INTENT_PHRASES = new Map([
  ['o que tenho hoje', 'day'],
  ['quais sao meus compromissos hoje', 'day'],
  ['faca meu briefing', 'day'],
  ['o que tenho esta semana', 'week'],
  ['como esta minha semana', 'week'],
  ['como estao os agentes', 'agents'],
  ['verifique os agentes', 'agents']
]);

function normalizeVoiceIntentText(text) {
  return String(text || '')
    .normalize('NFD')
    .replace(/[\u0300-\u036f]/g, '')
    .toLowerCase()
    .replace(/[^a-z0-9]+/g, ' ')
    .trim()
    .replace(/^angelino\s+/, '')
    .replace(/\s+por favor$/, '')
    .replace(/\s+/g, ' ');
}

export function resolveVoiceCommandIntent(text) {
  return INTENT_PHRASES.get(normalizeVoiceIntentText(text)) || '';
}

const transcript = await transcribeBlob(blob);
if (!transcript) throw new Error('Nenhuma fala reconhecida.');

const commandId = resolveVoiceCommandIntent(transcript);
if (commandId) {
  await startCommand(commandId, '', transcript);
} else {
  await sendMessage(transcript, true);
}

python server.py --host 127.0.0.1 --port 4173

tailscale serve --bg --yes --https 8443 4173

import { strict as assert } from 'node:assert';
import { resolveVoiceCommandIntent } from './voice-intents.js';

assert.equal(resolveVoiceCommandIntent('O que tenho hoje?'), 'day');
assert.equal(resolveVoiceCommandIntent('Como está minha semana?'), 'week');
assert.equal(resolveVoiceCommandIntent('Como estão os agentes?'), 'agents');

// as três abaixo TÊM que cair no fluxo normal
assert.equal(resolveVoiceCommandIntent('Não faça meu briefing.'), '');
assert.equal(resolveVoiceCommandIntent('Você consegue fazer meu briefing?'), '');
assert.equal(resolveVoiceCommandIntent('O que tenho hoje sobre IA?'), '');

import pytest


def test_unknown_command_is_rejected():
    with pytest.raises(ValueError, match="Comando não permitido"):
        handle_command(
            {"command": "executar-qualquer-coisa"},
            bridge=FakeBridge(),
            command_gates=FakeCommandGates(),
        )


def test_invalid_voice_turn_is_rejected():
    with pytest.raises(ValueError):
        safe_voice_turn_id("turno-sem-epoch")