fix: Melhorar estabilidade da conexão gRPC na WebRTC Gateway

- Adicionar gRPC keep-alive e connection pooling otimizado
- Implementar retry logic robusto com exponential backoff
- Adicionar timeout de 30s para evitar conexões pendentes
- Melhorar detecção e reconexão automática em casos de broken pipe
- Configurar limites de mensagem para 10MB (send/receive)

Corrige erros intermitentes de "ECONNREFUSED" e "Broken pipe"
entre WebRTC Gateway e Ultravox server na porta 50051.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

services/webrtc_gateway/ultravox-chat-server.js

@@ -6,6 +6,21 @@ const grpc = require('@grpc/grpc-js');
 const protoLoader = require('@grpc/proto-loader');
 const { spawn } = require('child_process');
 const fs = require('fs');
+const ConversationMemory = require('./conversation-memory');
+
+// Opus codec para compressão de áudio
+let OpusEncoder = null;
+let OpusDecoder = null;
+let opusAvailable = false;
+try {
+    const opus = require('@discordjs/opus');
+    OpusEncoder = opus.OpusEncoder;
+    OpusDecoder = opus.OpusDecoder;
+    opusAvailable = true;
+    console.log('✅ Opus codec carregado - compressão de áudio habilitada');
+} catch (e) {
+    console.log('⚠️ Opus codec não disponível - usando PCM sem compressão');
+}
 
 const app = express();
 const PORT = 8082;
@@ -38,29 +53,71 @@ const protoDescriptor = grpc.loadPackageDefinition(packageDefinition);
 const speech = protoDescriptor.speech;
 const tts = protoDescriptor.tts;
 
-// Clientes gRPC
+// Clientes gRPC com connection pooling
 let ultravoxClient = null;
 let ttsClient = null;
+let reconnectAttempts = 0;
+const MAX_RECONNECT_ATTEMPTS = 3;
+const RECONNECT_DELAY = 1000; // 1 second
 
-// Conectar aos serviços
+// Conectar aos serviços com retry logic
 function connectServices() {
     try {
+        // Configurações de conexão otimizadas
+        const connectionOptions = {
+            'grpc.keepalive_time_ms': 30000,           // Keep-alive every 30s
+            'grpc.keepalive_timeout_ms': 5000,         // Keep-alive timeout 5s
+            'grpc.keepalive_permit_without_calls': true,
+            'grpc.http2.max_pings_without_data': 0,
+            'grpc.http2.min_time_between_pings_ms': 10000,
+            'grpc.http2.min_ping_interval_without_data_ms': 300000,
+            'grpc.max_connection_idle_ms': 300000,      // 5 minutes
+            'grpc.max_connection_age_ms': 3600000,      // 1 hour
+            'grpc.max_receive_message_length': 10 * 1024 * 1024, // 10MB
+            'grpc.max_send_message_length': 10 * 1024 * 1024     // 10MB
+        };
+        
         ultravoxClient = new speech.SpeechService(
             `${ULTRAVOX_HOST}:${ULTRAVOX_PORT}`,
-            grpc.credentials.createInsecure()
+            grpc.credentials.createInsecure(),
+            connectionOptions
         );
-        console.log(`✅ Conectado ao Ultravox em ${ULTRAVOX_HOST}:${ULTRAVOX_PORT}`);
+        console.log(`✅ Conectado ao Ultravox em ${ULTRAVOX_HOST}:${ULTRAVOX_PORT} com keep-alive`);
 
         ttsClient = new tts.TTSService(
             `${TTS_HOST}:${TTS_PORT}`,
-            grpc.credentials.createInsecure()
+            grpc.credentials.createInsecure(),
+            connectionOptions
         );
-        console.log(`✅ Conectado ao TTS em ${TTS_HOST}:${TTS_PORT}`);
+        console.log(`✅ Conectado ao TTS em ${TTS_HOST}:${TTS_PORT} com keep-alive`);
+        
+        reconnectAttempts = 0; // Reset on successful connection
     } catch (error) {
         console.error('❌ Erro ao conectar aos serviços:', error);
     }
 }
 
+// Retry connection with backoff
+async function retryConnection(serviceName, retryFn, maxRetries = MAX_RECONNECT_ATTEMPTS) {
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+            console.log(`🔄 Tentativa ${attempt}/${maxRetries} de reconexão para ${serviceName}...`);
+            await retryFn();
+            console.log(`✅ Reconexão bem-sucedida para ${serviceName}`);
+            return true;
+        } catch (error) {
+            console.error(`❌ Tentativa ${attempt} falhou para ${serviceName}:`, error.message);
+            if (attempt < maxRetries) {
+                const delay = RECONNECT_DELAY * Math.pow(2, attempt - 1); // Exponential backoff
+                console.log(`⏳ Aguardando ${delay}ms antes da próxima tentativa...`);
+                await new Promise(resolve => setTimeout(resolve, delay));
+            }
+        }
+    }
+    console.error(`❌ Falha em reconectar para ${serviceName} após ${maxRetries} tentativas`);
+    return false;
+}
+
 // Servir arquivos estáticos
 app.use(express.static(path.join(__dirname, '../../web-interface')));
 
@@ -69,6 +126,85 @@ const clients = new Map();
 const rooms = new Map();
 const sessions = new Map(); // Armazenar contexto das sessões
 
+// Sistema de memória de conversações
+const conversationMemory = new ConversationMemory();
+
+// Configurações Opus
+const OPUS_CONFIG = {
+    channels: 1,        // Mono para voz
+    sampleRate: 24000,  // Taxa de amostragem (24kHz ou 16kHz)
+    bitrate: 32000,     // 32 kbps - ótimo balanço qualidade/tamanho
+};
+
+// Criar encoders/decoders Opus para cada cliente
+const opusEncoders = new Map();
+const opusDecoders = new Map();
+
+// Função para comprimir PCM com Opus
+function compressPCMWithOpus(pcmBuffer, sampleRate = 24000) {
+    if (!opusAvailable) {
+        return { 
+            data: pcmBuffer, 
+            format: 'pcm',
+            sampleRate: sampleRate 
+        };
+    }
+    
+    try {
+        // Criar encoder se não existir para esta taxa
+        const encoderKey = `${sampleRate}`;
+        if (!opusEncoders.has(encoderKey)) {
+            opusEncoders.set(encoderKey, new OpusEncoder(sampleRate, 1));
+        }
+        const encoder = opusEncoders.get(encoderKey);
+        
+        // Comprimir PCM para Opus
+        const opusPacket = encoder.encode(pcmBuffer);
+        
+        console.log(`🗜️ Compressão Opus: ${pcmBuffer.length} bytes PCM → ${opusPacket.length} bytes Opus (${Math.round(100 - (opusPacket.length/pcmBuffer.length)*100)}% menor)`);
+        
+        return {
+            data: opusPacket,
+            format: 'opus',
+            sampleRate: sampleRate,
+            originalSize: pcmBuffer.length
+        };
+    } catch (error) {
+        console.error('❌ Erro ao comprimir com Opus:', error);
+        return { 
+            data: pcmBuffer, 
+            format: 'pcm',
+            sampleRate: sampleRate 
+        };
+    }
+}
+
+// Função para descomprimir Opus para PCM
+function decompressOpusToPCM(opusBuffer, sampleRate = 24000) {
+    if (!opusAvailable) {
+        return opusBuffer;
+    }
+    
+    try {
+        // Criar decoder se não existir para esta taxa
+        const decoderKey = `${sampleRate}`;
+        if (!opusDecoders.has(decoderKey)) {
+            opusDecoders.set(decoderKey, new OpusDecoder(sampleRate, 1));
+        }
+        const decoder = opusDecoders.get(decoderKey);
+        
+        // Descomprimir Opus para PCM
+        const pcmBuffer = decoder.decode(opusBuffer);
+        
+        console.log(`🔊 Descompressão Opus: ${opusBuffer.length} bytes Opus → ${pcmBuffer.length} bytes PCM`);
+        
+        return pcmBuffer;
+    } catch (error) {
+        console.error('❌ Erro ao descomprimir Opus:', error);
+        return opusBuffer;
+    }
+}
+
 // Create HTTP server
 const server = app.listen(PORT, () => {
     console.log(`🚀 Servidor rodando na porta ${PORT}`);
@@ -84,10 +220,17 @@ wss.on('connection', (ws) => {
     const clientId = generateId();
     console.log(`✅ New client connected: ${clientId}`);
     
-    // Store client
+    // Criar conversação na memória
+    const conversation = conversationMemory.createConversation(null, {
+        userAgent: ws._socket.remoteAddress,
+        clientId: clientId
+    });
+    
+    // Store client com conversationId
     clients.set(clientId, {
         ws,
         id: clientId,
+        conversationId: conversation.id,
         peer: null,
         room: null,
         isProcessing: false
@@ -95,6 +238,7 @@ wss.on('connection', (ws) => {
     
     // Criar sessão para contexto
     sessions.set(clientId, {
+        conversationId: conversation.id,
         context: [],
         preferences: {
             voice_id: 'pf_dora',
@@ -103,26 +247,38 @@ wss.on('connection', (ws) => {
         }
     });
     
-    // Send client ID
+    // Send client ID e conversation ID
     ws.send(JSON.stringify({
         type: 'init',
-        clientId
+        clientId,
+        conversationId: conversation.id
     }));
     
     ws.on('message', (message) => {
         try {
-            // Debug: verificar tipo da mensagem
-            console.log(`📦 Message type: ${typeof message}, isBuffer: ${message instanceof Buffer}, constructor: ${message.constructor.name}`);
+            const messageBuffer = Buffer.from(message);
             
-            if (message instanceof Buffer || message instanceof ArrayBuffer) {
-                // Dados binários (PCM)
-                console.log(`🎤 Binary PCM data received: ${message.byteLength || message.length} bytes`);
-                handleBinaryMessage(clientId, Buffer.from(message));
-            } else {
-                // Mensagem JSON (string)
-                const data = JSON.parse(message.toString());
-                console.log(`📨 Message from ${clientId}: ${data.type}`);
-                handleMessage(clientId, data);
+            // Check first byte to determine message type
+            // 0x7B = '{' (JSON)
+            // 0x50 = 'P' (PCM header)
+            // Others = Raw PCM audio
+            const firstByte = messageBuffer[0];
+            
+            if (firstByte === 0x7B) { // '{' - JSON message
+                try {
+                    const messageStr = messageBuffer.toString('utf8');
+                    const data = JSON.parse(messageStr);
+                    console.log(`📨 JSON Message from ${clientId}: ${data.type}`);
+                    handleMessage(clientId, data);
+                } catch (jsonError) {
+                    console.error(`❌ Invalid JSON from ${clientId}:`, jsonError.message);
+                }
+            } else if (firstByte === 0x50 && messageBuffer.length === 8) { // PCM header
+                console.log(`🎤 PCM header received`);
+                handleBinaryMessage(clientId, messageBuffer);
+            } else { // Raw PCM audio data
+                console.log(`🎵 PCM audio data: ${messageBuffer.length} bytes`);
+                handleBinaryMessage(clientId, messageBuffer);
             }
         } catch (error) {
             console.error(`❌ Error handling message from ${clientId}:`, error);
@@ -168,6 +324,99 @@ function handleMessage(clientId, data) {
         case 'ping':
             client.ws.send(JSON.stringify({ type: 'pong' }));
             break;
+            
+        case 'set-voice':
+            // Atualizar preferência de voz
+            if (sessions.has(clientId) && data.voice_id) {
+                const session = sessions.get(clientId);
+                session.preferences.voice_id = data.voice_id;
+                console.log(`🔊 Voice changed for ${clientId}: ${data.voice_id}`);
+                client.ws.send(JSON.stringify({ 
+                    type: 'voice-changed', 
+                    voice_id: data.voice_id 
+                }));
+            }
+            break;
+            
+        case 'text-to-speech':
+            // TTS direto (sem Ultravox)
+            if (data.text && data.voice_id) {
+                const quality = data.quality || 'high'; // Default to high quality
+                const format = data.format || 'pcm'; // Default to PCM
+                console.log(`🎤 TTS direto solicitado: voz=${data.voice_id}, qualidade=${quality}, formato=${format}, texto="${data.text.substring(0, 50)}..."`);
+                handleTextToSpeech(clientId, data.text, data.voice_id, quality, format);
+            }
+            break;
+            
+        case 'audio':
+            // Handler para teste com áudio base64
+            if (data.data) {
+                const audioBuffer = Buffer.from(data.data, 'base64');
+                console.log(`📨 Teste de áudio recebido: ${audioBuffer.length} bytes`);
+                handlePCMData(clientId, audioBuffer);
+            }
+            break;
+            
+        case 'get-conversation':
+            // Recuperar conversação atual
+            {
+                const conversation = conversationMemory.getConversation(client.conversationId);
+                if (conversation) {
+                    client.ws.send(JSON.stringify({
+                        type: 'conversation',
+                        conversation: conversationMemory.exportConversation(client.conversationId)
+                    }));
+                } else {
+                    client.ws.send(JSON.stringify({
+                        type: 'error',
+                        message: 'Conversação não encontrada'
+                    }));
+                }
+            }
+            break;
+            
+        case 'load-conversation':
+            // Carregar conversação específica por ID
+            if (data.conversationId) {
+                const conversation = conversationMemory.getConversation(data.conversationId);
+                if (conversation) {
+                    client.conversationId = data.conversationId;
+                    sessions.get(clientId).conversationId = data.conversationId;
+                    client.ws.send(JSON.stringify({
+                        type: 'conversation-loaded',
+                        conversationId: data.conversationId,
+                        messages: conversation.messages
+                    }));
+                } else {
+                    client.ws.send(JSON.stringify({
+                        type: 'error',
+                        message: 'Conversação não encontrada'
+                    }));
+                }
+            }
+            break;
+            
+        case 'list-conversations':
+            // Listar todas as conversações ativas
+            {
+                const conversations = conversationMemory.listConversations();
+                client.ws.send(JSON.stringify({
+                    type: 'conversations-list',
+                    conversations
+                }));
+            }
+            break;
+            
+        case 'get-stats':
+            // Obter estatísticas de memória
+            {
+                const stats = conversationMemory.getStats();
+                client.ws.send(JSON.stringify({
+                    type: 'memory-stats',
+                    stats
+                }));
+            }
+            break;
     }
 }
 
@@ -322,11 +571,12 @@ function handleBinaryMessage(clientId, buffer) {
             pcmBuffers.set(clientId, { expectedSize: size, data: Buffer.alloc(0) });
         }
     } else {
-        // Dados PCM
-        const bufferInfo = pcmBuffers.get(clientId);
-        if (bufferInfo) {
-            // Processar PCM diretamente
-            handlePCMData(clientId, buffer);
+        // Processar PCM diretamente (com ou sem header prévio)
+        console.log(`🎵 Processando PCM direto: ${buffer.length} bytes`);
+        handlePCMData(clientId, buffer);
+        
+        // Limpar buffer info se existir
+        if (pcmBuffers.has(clientId)) {
             pcmBuffers.delete(clientId);
         }
     }
@@ -355,9 +605,30 @@ async function handlePCMData(clientId, pcmBuffer) {
         // Converter PCM int16 para float32 (formato que Ultravox espera)
         const pcmInt16 = new Int16Array(pcmBuffer.buffer, pcmBuffer.byteOffset, pcmBuffer.length / 2);
         const pcmFloat32 = new Float32Array(pcmInt16.length);
+        
+        // Análise de qualidade do áudio
+        let maxValue = 0;
+        let minValue = 0;
+        let sumSquares = 0;
+        
         for (let i = 0; i < pcmInt16.length; i++) {
             pcmFloat32[i] = pcmInt16[i] / 32768.0; // Normalizar para -1.0 a 1.0
+            maxValue = Math.max(maxValue, pcmFloat32[i]);
+            minValue = Math.min(minValue, pcmFloat32[i]);
+            sumSquares += pcmFloat32[i] * pcmFloat32[i];
         }
+        
+        const rms = Math.sqrt(sumSquares / pcmFloat32.length);
+        console.log(`   📊 Análise do áudio:`);
+        console.log(`      - Amplitude: min=${minValue.toFixed(3)}, max=${maxValue.toFixed(3)}`);
+        console.log(`      - RMS (volume): ${rms.toFixed(4)}`);
+        console.log(`      - Duração: ${(pcmInt16.length/16000).toFixed(2)}s`);
+        
+        // Verificar se o áudio está muito distorcido
+        if (Math.abs(maxValue) > 0.99 || Math.abs(minValue) > 0.99) {
+            console.log(`   ⚠️ AVISO: Áudio pode estar saturado/distorcido!`);
+        }
+        
         const float32Buffer = Buffer.from(pcmFloat32.buffer);
         console.log(`   📊 Convertido para Float32: ${float32Buffer.length} bytes`);
         
@@ -365,9 +636,29 @@ async function handlePCMData(clientId, pcmBuffer) {
         const response = await processWithUltravox(clientId, float32Buffer, session);
         console.log(`   📝 Resposta: "${response}"`);
         
+        // Armazenar mensagem do usuário e resposta na memória
+        const conversationId = client.conversationId;
+        if (conversationId) {
+            // Adicionar pergunta do usuário (por enquanto sem transcrição do áudio)
+            conversationMemory.addMessage(conversationId, {
+                role: 'user',
+                content: '[Áudio processado]', // Futuramente podemos adicionar transcrição
+                audioSize: pcmBuffer ? pcmBuffer.length : 0,
+                timestamp: startTime
+            });
+            
+            // Adicionar resposta do assistente
+            conversationMemory.addMessage(conversationId, {
+                role: 'assistant',
+                content: response,
+                latency: Date.now() - startTime
+            });
+        }
+        
         // Sintetizar áudio com TTS
-        const responseAudio = await synthesizeWithTTS(clientId, response, session);
-        console.log(`   🔊 Áudio sintetizado: ${responseAudio.length} bytes`);
+        const ttsResult = await synthesizeWithTTS(clientId, response, session);
+        const responseAudio = ttsResult.audioData;
+        console.log(`   🔊 Áudio sintetizado: ${responseAudio.length} bytes @ ${ttsResult.sampleRate}Hz`);
         
         // Enviar PCM direto (sem conversão para WebM!)
         client.ws.send(responseAudio);
@@ -442,9 +733,29 @@ async function handleAudioData(clientId, audioBase64) {
         const response = await processWithUltravox(clientId, float32Buffer, session);
         console.log(`   📝 Resposta: "${response}"`);
         
+        // Armazenar mensagem do usuário e resposta na memória
+        const conversationId = client.conversationId;
+        if (conversationId) {
+            // Adicionar pergunta do usuário (por enquanto sem transcrição do áudio)
+            conversationMemory.addMessage(conversationId, {
+                role: 'user',
+                content: '[Áudio processado]', // Futuramente podemos adicionar transcrição
+                audioSize: pcmBuffer ? pcmBuffer.length : 0,
+                timestamp: startTime
+            });
+            
+            // Adicionar resposta do assistente
+            conversationMemory.addMessage(conversationId, {
+                role: 'assistant',
+                content: response,
+                latency: Date.now() - startTime
+            });
+        }
+        
         // Sintetizar áudio com TTS
-        const responseAudio = await synthesizeWithTTS(clientId, response, session);
-        console.log(`   🔊 Áudio sintetizado: ${responseAudio.length} bytes`);
+        const ttsResult = await synthesizeWithTTS(clientId, response, session);
+        const responseAudio = ttsResult.audioData;
+        console.log(`   🔊 Áudio sintetizado: ${responseAudio.length} bytes @ ${ttsResult.sampleRate}Hz`);
         
         // LEGADO: Converter áudio PCM de volta para WebM/Opus
         const webmAudio = await convertPCMToWebM(responseAudio);
@@ -559,16 +870,73 @@ function convertPCMToWebM(pcmBuffer) {
     });
 }
 
-// Processar áudio com Ultravox
-function processWithUltravox(clientId, pcmAudio, session) {
+// Processar áudio com Ultravox - versão com retry robusta
+async function processWithUltravox(clientId, pcmAudio, session) {
+    const maxRetries = 3;
+    
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+            return await processWithUltravoxAttempt(clientId, pcmAudio, session, attempt);
+        } catch (error) {
+            console.error(`❌ Tentativa ${attempt}/${maxRetries} falhou para Ultravox:`, error.message);
+            
+            // Se é erro de conexão, tentar reconectar
+            if (error.code === 14 || error.message.includes('UNAVAILABLE') || error.message.includes('Broken pipe')) {
+                console.log(`🔄 Erro de conexão detectado, tentando reconectar...`);
+                
+                // Reconectar cliente Ultravox
+                const reconnected = await retryConnection('Ultravox', async () => {
+                    ultravoxClient = new speech.SpeechService(
+                        `${ULTRAVOX_HOST}:${ULTRAVOX_PORT}`,
+                        grpc.credentials.createInsecure(),
+                        {
+                            'grpc.keepalive_time_ms': 30000,
+                            'grpc.keepalive_timeout_ms': 5000,
+                            'grpc.keepalive_permit_without_calls': true,
+                            'grpc.max_receive_message_length': 10 * 1024 * 1024,
+                            'grpc.max_send_message_length': 10 * 1024 * 1024
+                        }
+                    );
+                }, 2);
+                
+                if (!reconnected && attempt === maxRetries) {
+                    return "Erro no processamento: [Errno 32] Broken pipe";
+                }
+            }
+            
+            // Se última tentativa falhou
+            if (attempt === maxRetries) {
+                return "Erro no processamento: " + error.message;
+            }
+            
+            // Aguardar antes da próxima tentativa
+            await new Promise(resolve => setTimeout(resolve, 1000 * attempt));
+        }
+    }
+}
+
+// Função auxiliar para uma tentativa de processamento
+function processWithUltravoxAttempt(clientId, pcmAudio, session, attempt) {
     return new Promise((resolve, reject) => {
         if (!ultravoxClient) {
             reject(new Error('Cliente Ultravox não conectado'));
             return;
         }
         
+        console.log(`🎯 Tentativa ${attempt} - Processando com Ultravox...`);
+        
         const call = ultravoxClient.StreamingRecognize();
         let fullResponse = '';
+        let hasEnded = false;
+        
+        // Timeout para evitar hang
+        const timeout = setTimeout(() => {
+            if (!hasEnded) {
+                hasEnded = true;
+                call.cancel();
+                reject(new Error('Timeout na resposta do Ultravox'));
+            }
+        }, 30000); // 30 segundos
         
         // Handler para respostas
         call.on('data', (token) => {
@@ -582,34 +950,56 @@ function processWithUltravox(clientId, pcmAudio, session) {
         });
         
         call.on('error', (error) => {
-            console.error('Erro no Ultravox:', error);
-            reject(error);
+            clearTimeout(timeout);
+            if (!hasEnded) {
+                hasEnded = true;
+                console.error('Erro no Ultravox:', error);
+                reject(error);
+            }
         });
         
         call.on('end', () => {
-            if (!fullResponse) {
-                fullResponse = 'Desculpe, não consegui processar o áudio.';
-            }
-            // Adicionar ao contexto
-            session.context.push({
-                role: 'assistant',
-                content: fullResponse
-            });
-            // Limitar contexto a 10 mensagens
-            if (session.context.length > 10) {
-                session.context = session.context.slice(-10);
+            clearTimeout(timeout);
+            if (!hasEnded) {
+                hasEnded = true;
+                if (!fullResponse) {
+                    fullResponse = 'Desculpe, não consegui processar o áudio. Poderia repetir?';
+                }
+                // Adicionar ao contexto
+                session.context.push({
+                    role: 'assistant',
+                    content: fullResponse
+                });
+                // Limitar contexto a 10 mensagens
+                if (session.context.length > 10) {
+                    session.context = session.context.slice(-10);
+                }
+                resolve(fullResponse);
             }
-            resolve(fullResponse);
         });
         
-        // Construir prompt com contexto
-        let systemPrompt = 'Você é um assistente útil que responde em português brasileiro. A capital do Brasil é Brasília.';
-        if (session.context.length > 0) {
-            const lastMessages = session.context.slice(-3).map(msg => 
-                `${msg.role}: ${msg.content}`
-            ).join('\n');
-            systemPrompt += ' Contexto da conversa:\n' + lastMessages;
-        }
+        // NÃO enviar contexto - deixar Ultravox processar apenas o áudio
+        let systemPrompt = '';
+        
+        // DEBUG: Verificar o que está sendo enviado
+        console.log(`🔍 DEBUG - Enviando para Ultravox:`);
+        console.log(`   session_id: ${clientId}`);
+        console.log(`   audio_data: ${pcmAudio.length} bytes`);
+        console.log(`   system_prompt: "${systemPrompt}" (vazio: ${systemPrompt === ''})`);
+        console.log(`   contexto atual na sessão: ${session.context.length} mensagens`);
+        
+        // IMPORTANTE: Limpar contexto de respostas incoerentes
+        const problematicPhrases = [
+            'capital do brasil',
+            'brasília',
+            'cidade mais populosa',
+            'região centro-oeste'
+        ];
+        
+        session.context = session.context.filter(msg => {
+            const content = msg.content.toLowerCase();
+            return !problematicPhrases.some(phrase => content.includes(phrase));
+        });
         
         // Enviar áudio
         const audioChunk = {
@@ -624,6 +1014,56 @@ function processWithUltravox(clientId, pcmAudio, session) {
     });
 }
 
+// Handler para TTS direto (sem Ultravox)
+async function handleTextToSpeech(clientId, text, voice_id, quality = 'high', format = 'pcm') {
+    const client = clients.get(clientId);
+    if (!client) return;
+    
+    try {
+        console.log(`🎵 Processando TTS direto: "${text.substring(0, 50)}..." com voz ${voice_id} (${quality} quality, ${format} format)`);
+        
+        // Criar sessão temporária com a voz e qualidade solicitada
+        const tempSession = {
+            preferences: {
+                voice_id: voice_id,
+                speech_speed: 1.0,
+                quality: quality,
+                format: format
+            }
+        };
+        
+        // Sintetizar com TTS
+        const ttsResult = await synthesizeWithTTS(clientId, text, tempSession);
+        const audioBuffer = ttsResult.audioData;
+        const sampleRate = ttsResult.sampleRate; // Usar taxa real do TTS
+        console.log(`   🔊 TTS gerado: ${audioBuffer.length} bytes @ ${sampleRate}Hz (taxa real)`);
+        
+        // IMPORTANTE: Não fazer conversão - TTS já retorna Opus 24kHz
+        // O áudio do TTS já vem no formato correto
+        let audioData = audioBuffer;  // Já é Opus se format='opus'
+        let audioFormat = format;
+        
+        // Enviar áudio como base64 com metadados
+        client.ws.send(JSON.stringify({
+            type: 'tts-response',
+            audio: audioData.toString('base64'),
+            sampleRate: sampleRate,
+            quality: quality,
+            format: audioFormat,
+            originalSize: audioBuffer.length
+        }));
+        
+        console.log(`✅ TTS direto concluído para ${clientId}`);
+        
+    } catch (error) {
+        console.error('❌ Erro no TTS direto:', error);
+        client.ws.send(JSON.stringify({
+            type: 'error',
+            message: `Erro no TTS: ${error.message}`
+        }));
+    }
+}
+
 // Sintetizar texto com TTS
 function synthesizeWithTTS(clientId, text, session) {
     return new Promise((resolve, reject) => {
@@ -632,11 +1072,14 @@ function synthesizeWithTTS(clientId, text, session) {
             return;
         }
         
-        // Criar request
+        // Criar request com qualidade
+        const quality = session.preferences.quality || 'high';
+        console.log(`🔊 TTS Request - Voice: ${session.preferences.voice_id}, Speed: ${session.preferences.speech_speed}, Quality: ${quality}`);
         const request = {
             text: text,
             voice_id: session.preferences.voice_id,
             speed: session.preferences.speech_speed,
+            quality: quality,
             session_id: clientId
         };
         
@@ -661,7 +1104,15 @@ function synthesizeWithTTS(clientId, text, session) {
         
         call.on('end', () => {
             const fullAudio = Buffer.concat(audioChunks);
-            resolve(fullAudio);
+            
+            // CORRIGIDO: TTS agora preserva qualidade nativa do Kokoro (24kHz)
+            const finalSampleRate = (quality === 'high' ? 24000 : 16000);
+            console.log(`   🎵 Audio final: ${fullAudio.length} bytes @ ${finalSampleRate}Hz (TTS output real)`);
+            
+            resolve({
+                audioData: fullAudio,
+                sampleRate: finalSampleRate
+            });
         });
     });
 }