debug: Simplify VoiceCal to isolate restart issue cause

- Remove complex JavaScript WebRTC integration temporarily
- Create minimal Streamlit interface for startup debugging
- Backup original version as streamlit_websocket_app.py.backup
- Add test_streamlit_simple.py for isolated testing
- Focus on basic Streamlit functionality first
- Will re-add WebRTC after confirming basic startup works

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

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

streamlit_websocket_app.py

@@ -1,16 +1,10 @@
 #!/usr/bin/env python3
 """
 Streamlit app with embedded WebSocket server for VoiceCal WebRTC
-Single-service approach for HuggingFace Spaces compatibility
+Simplified version for debugging startup issues
 """
 
 import streamlit as st
-import asyncio
-import threading
-import json
-import sys
-from datetime import datetime
-import os
 
 # Configure Streamlit page
 st.set_page_config(
@@ -45,325 +39,12 @@ def main():
     st.markdown("---")
     st.header("🌐 WebRTC Voice Interface")
     
-    # Simplified WebRTC interface that connects directly to STT service
-    webrtc_html = """
-    <div id="voice-interface" style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); padding: 20px; border-radius: 10px; margin: 20px 0;">
-        <h3 style="color: white; margin-top: 0;">🎤 Voice Interface (Direct STT Connection)</h3>
-        
-        <div style="display: flex; gap: 10px; margin: 20px 0;">
-            <button id="start-recording" style="background: #ff4757; color: white; border: none; padding: 10px 20px; border-radius: 5px; cursor: pointer;">
-                🎙️ Start Recording
-            </button>
-            <button id="stop-recording" style="background: #2f3542; color: white; border: none; padding: 10px 20px; border-radius: 5px; cursor: pointer;" disabled>
-                ⏹️ Stop Recording  
-            </button>
-            <button id="test-connection" style="background: #5352ed; color: white; border: none; padding: 10px 20px; border-radius: 5px; cursor: pointer;">
-                🔗 Test STT Connection
-            </button>
-        </div>
-        
-        <div id="status" style="background: rgba(0,0,0,0.2); padding: 10px; border-radius: 5px; color: white; font-family: monospace;">
-            Status: Ready to connect to STT service...
-        </div>
-        
-        <div id="transcription" style="background: rgba(255,255,255,0.9); padding: 15px; border-radius: 5px; margin-top: 10px; min-height: 50px;">
-            <strong>Transcription:</strong> <span id="transcription-text">Ready for voice input...</span>
-        </div>
-    </div>
-
-    <script>
-    // Direct STT WebSocket Connection (unmute.sh Pattern)
-    class VoiceCalDirectSTT {
-        constructor() {
-            this.sttWebSocket = null;
-            this.mediaRecorder = null;
-            this.audioChunks = [];
-            this.isRecording = false;
-            this.clientId = 'voicecal-' + Math.random().toString(36).substr(2, 9);
-            // Connect to standalone WebSocket STT service v1.0.0
-            this.sttWebSocketUrl = 'wss://pgits-stt-gpu-service.hf.space/ws/stt';
-            
-            this.setupEventListeners();
-        }
-        
-        setupEventListeners() {
-            document.getElementById('start-recording').addEventListener('click', () => {
-                this.startRecording();
-            });
-            
-            document.getElementById('stop-recording').addEventListener('click', () => {
-                this.stopRecording();
-            });
-            
-            document.getElementById('test-connection').addEventListener('click', () => {
-                this.testSTTConnection();
-            });
-        }
-        
-        async testSTTConnection() {
-            this.updateStatus('🔗 Testing WebSocket STT service connection...');
-            
-            try {
-                // Test WebSocket connection to standalone STT service v1.0.0
-                const testSocket = new WebSocket(this.sttWebSocketUrl);
-                
-                testSocket.onopen = () => {
-                    this.updateStatus('✅ STT WebSocket connection successful!');
-                    console.log('STT service WebSocket is ready');
-                    testSocket.close();
-                };
-                
-                testSocket.onerror = (error) => {
-                    this.updateStatus('❌ STT WebSocket connection failed');
-                    console.error('STT WebSocket error:', error);
-                };
-                
-            } catch (error) {
-                this.updateStatus('❌ Failed to test STT WebSocket connection');
-                console.error('STT connection test error:', error);
-            }
-        }
-        
-        async connectToSTT() {
-            this.updateStatus('🔌 Connecting to STT service...');
-            
-            try {
-                this.sttWebSocket = new WebSocket(this.sttWebSocketUrl);
-                
-                this.sttWebSocket.onopen = () => {
-                    this.updateStatus('✅ Connected to STT service - Ready for audio');
-                };
-                
-                this.sttWebSocket.onmessage = (event) => {
-                    const data = JSON.parse(event.data);
-                    this.handleSTTResponse(data);
-                };
-                
-                this.sttWebSocket.onclose = () => {
-                    this.updateStatus('🔌 STT connection closed');
-                };
-                
-                this.sttWebSocket.onerror = (error) => {
-                    this.updateStatus('❌ STT connection error');
-                    console.error('STT WebSocket error:', error);
-                };
-                
-                return true;
-            } catch (error) {
-                this.updateStatus('❌ Failed to connect to STT service');
-                console.error('STT connection failed:', error);
-                return false;
-            }
-        }
-        
-        handleSTTResponse(data) {
-            console.log('STT WebSocket Response:', data);
-            
-            switch(data.type) {
-                case 'stt_connection_confirmed':
-                    this.updateStatus(`✅ ${data.service} v${data.version} connected - ${data.model} ready`);
-                    break;
-                    
-                case 'stt_transcription_complete':
-                    this.updateTranscription(data.transcription);
-                    const processingTime = data.timing?.processing_time || 'unknown';
-                    this.updateStatus(`✅ Transcription completed (${processingTime}s)`);
-                    break;
-                    
-                case 'stt_transcription_error':
-                    this.updateStatus(`❌ Transcription error: ${data.error}`);
-                    break;
-                    
-                case 'pong':
-                    console.log('STT service pong received');
-                    break;
-                    
-                default:
-                    console.log('Unknown STT response type:', data.type);
-            }
-        }
-        
-        async startRecording() {
-            // Connect to STT service first
-            const connected = await this.connectToSTT();
-            if (!connected) {
-                return;
-            }
-            
-            try {
-                const stream = await navigator.mediaDevices.getUserMedia({ 
-                    audio: {
-                        sampleRate: 16000,
-                        channelCount: 1,
-                        echoCancellation: true,
-                        noiseSuppression: true
-                    } 
-                });
-                
-                // unmute.sh pattern: WebM format with small chunks
-                this.mediaRecorder = new MediaRecorder(stream, {
-                    mimeType: 'audio/webm;codecs=opus'
-                });
-                
-                this.audioChunks = [];
-                
-                this.mediaRecorder.ondataavailable = (event) => {
-                    if (event.data.size > 0) {
-                        this.audioChunks.push(event.data);
-                    }
-                };
-                
-                this.mediaRecorder.onstop = () => {
-                    this.processRecordedAudio();
-                    stream.getTracks().forEach(track => track.stop());
-                };
-                
-                // Start recording
-                this.mediaRecorder.start();
-                this.isRecording = true;
-                
-                // Update UI
-                document.getElementById('start-recording').disabled = true;
-                document.getElementById('stop-recording').disabled = false;
-                this.updateStatus('🎙️ Recording audio - Speak now...');
-                
-            } catch (error) {
-                console.error('Recording failed:', error);
-                this.updateStatus('❌ Microphone access failed');
-            }
-        }
-        
-        stopRecording() {
-            if (this.mediaRecorder && this.isRecording) {
-                this.mediaRecorder.stop();
-                this.isRecording = false;
-                
-                // Update UI
-                document.getElementById('start-recording').disabled = false;
-                document.getElementById('stop-recording').disabled = true;
-                this.updateStatus('⏹️ Recording stopped - Processing audio...');
-            }
-        }
-        
-        async processRecordedAudio() {
-            if (this.audioChunks.length === 0) {
-                this.updateStatus('❌ No audio data recorded');
-                return;
-            }
-            
-            try {
-                this.updateStatus('⚙️ Processing audio with WebSocket STT...');
-                
-                // Combine all audio chunks (unmute.sh pattern)
-                const audioBlob = new Blob(this.audioChunks, { type: 'audio/webm' });
-                
-                // Send to STT service via WebSocket
-                await this.sendAudioViaWebSocket(audioBlob);
-                
-            } catch (error) {
-                console.error('Audio processing failed:', error);
-                this.updateStatus('❌ Audio processing failed');
-            }
-        }
-        
-        async sendAudioViaWebSocket(audioBlob) {
-            try {
-                if (!this.sttWebSocket || this.sttWebSocket.readyState !== WebSocket.OPEN) {
-                    this.updateStatus('❌ WebSocket not connected');
-                    return;
-                }
-                
-                this.updateStatus('📤 Sending audio to STT via WebSocket...');
-                
-                // Convert audio blob to base64 for WebSocket transmission
-                const arrayBuffer = await audioBlob.arrayBuffer();
-                const base64Audio = btoa(String.fromCharCode(...new Uint8Array(arrayBuffer)));
-                
-                // Send audio data via WebSocket to standalone STT service v1.0.0
-                this.sttWebSocket.send(JSON.stringify({
-                    type: "stt_audio_chunk",
-                    audio_data: base64Audio,
-                    language: "auto",
-                    model_size: "base",
-                    client_id: this.clientId
-                }));
-                
-                console.log('Audio sent via WebSocket:', base64Audio.length, 'bytes');
-                
-            } catch (error) {
-                console.error('WebSocket audio transmission failed:', error);
-                this.updateStatus('❌ WebSocket transmission failed: ' + error.message);
-            }
-        }
-        
-        /* COMMENTED OUT: HTTP API fallback - focusing on WebSocket-only connectivity
-        async sendAudioToSTTAPI(audioBlob) {
-            try {
-                this.updateStatus('📤 Sending audio to STT via Gradio API...');
-                
-                // Create FormData for Gradio API
-                const formData = new FormData();
-                formData.append('data', audioBlob, 'audio.webm');
-                
-                // Gradio API expects this format: data: ["auto", "base", true]
-                formData.append('data', JSON.stringify(["auto", "base", true]));
-                
-                // Send to Gradio API
-                const response = await fetch('https://pgits-stt-gpu-service.hf.space/api/predict', {
-                    method: 'POST',
-                    body: formData
-                });
-                
-                if (response.ok) {
-                    const result = await response.json();
-                    console.log('STT API Response:', result);
-                    
-                    // Extract transcription from Gradio response format
-                    if (result && result.data && result.data.length > 1) {
-                        const transcription = result.data[1]; // [status, transcription, timestamps]
-                        if (transcription && transcription.trim()) {
-                            this.updateTranscription(transcription);
-                            this.updateStatus('✅ Transcription completed via Gradio API');
-                        } else {
-                            this.updateStatus('⚠️ No transcription received');
-                        }
-                    } else {
-                        this.updateStatus('❌ Unexpected API response format');
-                        console.error('Unexpected response:', result);
-                    }
-                } else {
-                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-                }
-                
-            } catch (error) {
-                console.error('STT API request failed:', error);
-                this.updateStatus('❌ STT API request failed: ' + error.message);
-            }
-        }
-        */ // END COMMENTED OUT HTTP API fallback
-        
-        updateStatus(message) {
-            document.getElementById('status').innerHTML = `Status: ${message}`;
-        }
-        
-        updateTranscription(text) {
-            document.getElementById('transcription-text').innerHTML = text;
-        }
-    }
-    
-    // Initialize when DOM is ready
-    if (document.readyState === 'loading') {
-        document.addEventListener('DOMContentLoaded', () => {
-            window.voiceCalDirectSTT = new VoiceCalDirectSTT();
-        });
-    } else {
-        window.voiceCalDirectSTT = new VoiceCalDirectSTT();
-    }
-    </script>
-    """
-    
-    # Render the WebRTC interface
-    st.components.v1.html(webrtc_html, height=500)
+    # Simplified message while we debug
+    st.info("WebRTC interface temporarily simplified for debugging startup issues.")
+    st.markdown("**Next steps:**")
+    st.markdown("1. Verify basic Streamlit functionality ✅")
+    st.markdown("2. Test WebSocket connectivity")
+    st.markdown("3. Add WebRTC JavaScript integration")
     
     # Technical Information
     st.markdown("---")
@@ -391,19 +72,6 @@ Connection: Pure WebSocket (no fallbacks)
         st.write("✅ No HTTP API fallbacks")
         st.write("✅ Base64 audio transmission")
     
-    # Connection Status
-    st.subheader("🔗 Service Status")
-    st.json({
-        "stt_websocket": "wss://pgits-stt-gpu-service.hf.space/ws/stt",
-        "stt_service": "Standalone WebSocket STT v1.0.0",
-        "connection_type": "pure_websocket",
-        "audio_format": "WebM/Opus 16kHz",
-        "transmission": "Base64 encoded",
-        "pattern": "unmute.sh WebSocket methodology",
-        "fallbacks": "disabled",
-        "status": "Ready for WebSocket voice interaction"
-    })
-    
     # Footer
     st.markdown("---")
     st.markdown("🚀 **VoiceCal WebSocket STT** - Pure WebSocket WebRTC with standalone STT service v1.0.0")

streamlit_websocket_app.py.backup

@@ -0,0 +1,412 @@
+#!/usr/bin/env python3
+"""
+Streamlit app with embedded WebSocket server for VoiceCal WebRTC
+Single-service approach for HuggingFace Spaces compatibility
+"""
+
+import streamlit as st
+import asyncio
+import threading
+import json
+import sys
+from datetime import datetime
+import os
+
+# Configure Streamlit page
+st.set_page_config(
+    page_title="VoiceCal - Voice Assistant", 
+    page_icon="🎤", 
+    layout="wide"
+)
+
+def main():
+    st.title("🎤📅 VoiceCal - Voice-Enabled AI Assistant")
+    st.markdown("**WebRTC Voice Integration Following unmute.sh Pattern**")
+    
+    # Service status dashboard
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        st.metric("🎤 VoiceCal", "Online", "✅")
+        st.metric("📡 WebSocket", "Embedded", "🔧")
+    
+    with col2:
+        st.metric("🧠 STT Service", "Ready", "✅")
+        st.metric("🔊 TTS Service", "Ready", "✅")
+    
+    with col3:
+        st.metric("🌐 Connection", "Direct", "⚡")
+        st.metric("📱 Pattern", "unmute.sh", "🎯")
+    
+    # Connection Status  
+    st.success("🎯 **STT Service Connected**: `wss://pgits-stt-gpu-service.hf.space/ws/stt`")
+    
+    # WebRTC Integration Section
+    st.markdown("---")
+    st.header("🌐 WebRTC Voice Interface")
+    
+    # Simplified WebRTC interface that connects directly to STT service
+    webrtc_html = """
+    <div id="voice-interface" style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); padding: 20px; border-radius: 10px; margin: 20px 0;">
+        <h3 style="color: white; margin-top: 0;">🎤 Voice Interface (Direct STT Connection)</h3>
+        
+        <div style="display: flex; gap: 10px; margin: 20px 0;">
+            <button id="start-recording" style="background: #ff4757; color: white; border: none; padding: 10px 20px; border-radius: 5px; cursor: pointer;">
+                🎙️ Start Recording
+            </button>
+            <button id="stop-recording" style="background: #2f3542; color: white; border: none; padding: 10px 20px; border-radius: 5px; cursor: pointer;" disabled>
+                ⏹️ Stop Recording  
+            </button>
+            <button id="test-connection" style="background: #5352ed; color: white; border: none; padding: 10px 20px; border-radius: 5px; cursor: pointer;">
+                🔗 Test STT Connection
+            </button>
+        </div>
+        
+        <div id="status" style="background: rgba(0,0,0,0.2); padding: 10px; border-radius: 5px; color: white; font-family: monospace;">
+            Status: Ready to connect to STT service...
+        </div>
+        
+        <div id="transcription" style="background: rgba(255,255,255,0.9); padding: 15px; border-radius: 5px; margin-top: 10px; min-height: 50px;">
+            <strong>Transcription:</strong> <span id="transcription-text">Ready for voice input...</span>
+        </div>
+    </div>
+
+    <script>
+    // Direct STT WebSocket Connection (unmute.sh Pattern)
+    class VoiceCalDirectSTT {
+        constructor() {
+            this.sttWebSocket = null;
+            this.mediaRecorder = null;
+            this.audioChunks = [];
+            this.isRecording = false;
+            this.clientId = 'voicecal-' + Math.random().toString(36).substr(2, 9);
+            // Connect to standalone WebSocket STT service v1.0.0
+            this.sttWebSocketUrl = 'wss://pgits-stt-gpu-service.hf.space/ws/stt';
+            
+            this.setupEventListeners();
+        }
+        
+        setupEventListeners() {
+            document.getElementById('start-recording').addEventListener('click', () => {
+                this.startRecording();
+            });
+            
+            document.getElementById('stop-recording').addEventListener('click', () => {
+                this.stopRecording();
+            });
+            
+            document.getElementById('test-connection').addEventListener('click', () => {
+                this.testSTTConnection();
+            });
+        }
+        
+        async testSTTConnection() {
+            this.updateStatus('🔗 Testing WebSocket STT service connection...');
+            
+            try {
+                // Test WebSocket connection to standalone STT service v1.0.0
+                const testSocket = new WebSocket(this.sttWebSocketUrl);
+                
+                testSocket.onopen = () => {
+                    this.updateStatus('✅ STT WebSocket connection successful!');
+                    console.log('STT service WebSocket is ready');
+                    testSocket.close();
+                };
+                
+                testSocket.onerror = (error) => {
+                    this.updateStatus('❌ STT WebSocket connection failed');
+                    console.error('STT WebSocket error:', error);
+                };
+                
+            } catch (error) {
+                this.updateStatus('❌ Failed to test STT WebSocket connection');
+                console.error('STT connection test error:', error);
+            }
+        }
+        
+        async connectToSTT() {
+            this.updateStatus('🔌 Connecting to STT service...');
+            
+            try {
+                this.sttWebSocket = new WebSocket(this.sttWebSocketUrl);
+                
+                this.sttWebSocket.onopen = () => {
+                    this.updateStatus('✅ Connected to STT service - Ready for audio');
+                };
+                
+                this.sttWebSocket.onmessage = (event) => {
+                    const data = JSON.parse(event.data);
+                    this.handleSTTResponse(data);
+                };
+                
+                this.sttWebSocket.onclose = () => {
+                    this.updateStatus('🔌 STT connection closed');
+                };
+                
+                this.sttWebSocket.onerror = (error) => {
+                    this.updateStatus('❌ STT connection error');
+                    console.error('STT WebSocket error:', error);
+                };
+                
+                return true;
+            } catch (error) {
+                this.updateStatus('❌ Failed to connect to STT service');
+                console.error('STT connection failed:', error);
+                return false;
+            }
+        }
+        
+        handleSTTResponse(data) {
+            console.log('STT WebSocket Response:', data);
+            
+            switch(data.type) {
+                case 'stt_connection_confirmed':
+                    this.updateStatus(`✅ ${data.service} v${data.version} connected - ${data.model} ready`);
+                    break;
+                    
+                case 'stt_transcription_complete':
+                    this.updateTranscription(data.transcription);
+                    const processingTime = data.timing?.processing_time || 'unknown';
+                    this.updateStatus(`✅ Transcription completed (${processingTime}s)`);
+                    break;
+                    
+                case 'stt_transcription_error':
+                    this.updateStatus(`❌ Transcription error: ${data.error}`);
+                    break;
+                    
+                case 'pong':
+                    console.log('STT service pong received');
+                    break;
+                    
+                default:
+                    console.log('Unknown STT response type:', data.type);
+            }
+        }
+        
+        async startRecording() {
+            // Connect to STT service first
+            const connected = await this.connectToSTT();
+            if (!connected) {
+                return;
+            }
+            
+            try {
+                const stream = await navigator.mediaDevices.getUserMedia({ 
+                    audio: {
+                        sampleRate: 16000,
+                        channelCount: 1,
+                        echoCancellation: true,
+                        noiseSuppression: true
+                    } 
+                });
+                
+                // unmute.sh pattern: WebM format with small chunks
+                this.mediaRecorder = new MediaRecorder(stream, {
+                    mimeType: 'audio/webm;codecs=opus'
+                });
+                
+                this.audioChunks = [];
+                
+                this.mediaRecorder.ondataavailable = (event) => {
+                    if (event.data.size > 0) {
+                        this.audioChunks.push(event.data);
+                    }
+                };
+                
+                this.mediaRecorder.onstop = () => {
+                    this.processRecordedAudio();
+                    stream.getTracks().forEach(track => track.stop());
+                };
+                
+                // Start recording
+                this.mediaRecorder.start();
+                this.isRecording = true;
+                
+                // Update UI
+                document.getElementById('start-recording').disabled = true;
+                document.getElementById('stop-recording').disabled = false;
+                this.updateStatus('🎙️ Recording audio - Speak now...');
+                
+            } catch (error) {
+                console.error('Recording failed:', error);
+                this.updateStatus('❌ Microphone access failed');
+            }
+        }
+        
+        stopRecording() {
+            if (this.mediaRecorder && this.isRecording) {
+                this.mediaRecorder.stop();
+                this.isRecording = false;
+                
+                // Update UI
+                document.getElementById('start-recording').disabled = false;
+                document.getElementById('stop-recording').disabled = true;
+                this.updateStatus('⏹️ Recording stopped - Processing audio...');
+            }
+        }
+        
+        async processRecordedAudio() {
+            if (this.audioChunks.length === 0) {
+                this.updateStatus('❌ No audio data recorded');
+                return;
+            }
+            
+            try {
+                this.updateStatus('⚙️ Processing audio with WebSocket STT...');
+                
+                // Combine all audio chunks (unmute.sh pattern)
+                const audioBlob = new Blob(this.audioChunks, { type: 'audio/webm' });
+                
+                // Send to STT service via WebSocket
+                await this.sendAudioViaWebSocket(audioBlob);
+                
+            } catch (error) {
+                console.error('Audio processing failed:', error);
+                this.updateStatus('❌ Audio processing failed');
+            }
+        }
+        
+        async sendAudioViaWebSocket(audioBlob) {
+            try {
+                if (!this.sttWebSocket || this.sttWebSocket.readyState !== WebSocket.OPEN) {
+                    this.updateStatus('❌ WebSocket not connected');
+                    return;
+                }
+                
+                this.updateStatus('📤 Sending audio to STT via WebSocket...');
+                
+                // Convert audio blob to base64 for WebSocket transmission
+                const arrayBuffer = await audioBlob.arrayBuffer();
+                const base64Audio = btoa(String.fromCharCode(...new Uint8Array(arrayBuffer)));
+                
+                // Send audio data via WebSocket to standalone STT service v1.0.0
+                this.sttWebSocket.send(JSON.stringify({
+                    type: "stt_audio_chunk",
+                    audio_data: base64Audio,
+                    language: "auto",
+                    model_size: "base",
+                    client_id: this.clientId
+                }));
+                
+                console.log('Audio sent via WebSocket:', base64Audio.length, 'bytes');
+                
+            } catch (error) {
+                console.error('WebSocket audio transmission failed:', error);
+                this.updateStatus('❌ WebSocket transmission failed: ' + error.message);
+            }
+        }
+        
+        /* COMMENTED OUT: HTTP API fallback - focusing on WebSocket-only connectivity
+        async sendAudioToSTTAPI(audioBlob) {
+            try {
+                this.updateStatus('📤 Sending audio to STT via Gradio API...');
+                
+                // Create FormData for Gradio API
+                const formData = new FormData();
+                formData.append('data', audioBlob, 'audio.webm');
+                
+                // Gradio API expects this format: data: ["auto", "base", true]
+                formData.append('data', JSON.stringify(["auto", "base", true]));
+                
+                // Send to Gradio API
+                const response = await fetch('https://pgits-stt-gpu-service.hf.space/api/predict', {
+                    method: 'POST',
+                    body: formData
+                });
+                
+                if (response.ok) {
+                    const result = await response.json();
+                    console.log('STT API Response:', result);
+                    
+                    // Extract transcription from Gradio response format
+                    if (result && result.data && result.data.length > 1) {
+                        const transcription = result.data[1]; // [status, transcription, timestamps]
+                        if (transcription && transcription.trim()) {
+                            this.updateTranscription(transcription);
+                            this.updateStatus('✅ Transcription completed via Gradio API');
+                        } else {
+                            this.updateStatus('⚠️ No transcription received');
+                        }
+                    } else {
+                        this.updateStatus('❌ Unexpected API response format');
+                        console.error('Unexpected response:', result);
+                    }
+                } else {
+                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                }
+                
+            } catch (error) {
+                console.error('STT API request failed:', error);
+                this.updateStatus('❌ STT API request failed: ' + error.message);
+            }
+        }
+        */ // END COMMENTED OUT HTTP API fallback
+        
+        updateStatus(message) {
+            document.getElementById('status').innerHTML = `Status: ${message}`;
+        }
+        
+        updateTranscription(text) {
+            document.getElementById('transcription-text').innerHTML = text;
+        }
+    }
+    
+    // Initialize when DOM is ready
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', () => {
+            window.voiceCalDirectSTT = new VoiceCalDirectSTT();
+        });
+    } else {
+        window.voiceCalDirectSTT = new VoiceCalDirectSTT();
+    }
+    </script>
+    """
+    
+    # Render the WebRTC interface
+    st.components.v1.html(webrtc_html, height=500)
+    
+    # Technical Information
+    st.markdown("---")
+    st.header("🔧 Technical Details")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.subheader("📡 WebSocket Connection")
+        st.code("""
+STT WebSocket: wss://pgits-stt-gpu-service.hf.space/ws/stt
+Audio Format: WebM/Opus (16kHz, Mono)
+Service: Standalone STT v1.0.0
+Pattern: unmute.sh methodology
+Connection: Pure WebSocket (no fallbacks)
+        """)
+    
+    with col2:
+        st.subheader("🎯 Features")
+        st.write("✅ Pure WebSocket STT connection")
+        st.write("✅ WebRTC MediaRecorder integration")
+        st.write("✅ unmute.sh audio processing")
+        st.write("✅ Real-time voice transcription")
+        st.write("✅ Standalone STT service v1.0.0")
+        st.write("✅ No HTTP API fallbacks")
+        st.write("✅ Base64 audio transmission")
+    
+    # Connection Status
+    st.subheader("🔗 Service Status")
+    st.json({
+        "stt_websocket": "wss://pgits-stt-gpu-service.hf.space/ws/stt",
+        "stt_service": "Standalone WebSocket STT v1.0.0",
+        "connection_type": "pure_websocket",
+        "audio_format": "WebM/Opus 16kHz",
+        "transmission": "Base64 encoded",
+        "pattern": "unmute.sh WebSocket methodology",
+        "fallbacks": "disabled",
+        "status": "Ready for WebSocket voice interaction"
+    })
+    
+    # Footer
+    st.markdown("---")
+    st.markdown("🚀 **VoiceCal WebSocket STT** - Pure WebSocket WebRTC with standalone STT service v1.0.0")
+
+if __name__ == "__main__":
+    main()

test_streamlit_simple.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python3
+"""
+Simple test Streamlit app to verify basic functionality
+"""
+
+import streamlit as st
+
+# Configure Streamlit page
+st.set_page_config(
+    page_title="VoiceCal Test", 
+    page_icon="🎤", 
+    layout="wide"
+)
+
+def main():
+    st.title("🎤📅 VoiceCal - Voice-Enabled AI Assistant (Test)")
+    st.markdown("**Testing basic Streamlit functionality**")
+    
+    # Simple content without JavaScript
+    st.success("✅ Basic Streamlit is working!")
+    
+    st.markdown("### Service Status")
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.metric("🎤 VoiceCal", "Online", "✅")
+        st.metric("🧠 STT Service", "Ready", "✅")
+    
+    with col2:
+        st.metric("🔊 TTS Service", "Ready", "✅")
+        st.metric("📱 Pattern", "unmute.sh", "🎯")
+    
+    st.markdown("---")
+    st.markdown("🎯 **Ready for WebSocket integration testing**")
+    
+    # Add simple HTML without complex JavaScript
+    simple_html = """
+    <div style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); padding: 20px; border-radius: 10px; margin: 20px 0;">
+        <h3 style="color: white; margin-top: 0;">🎤 Simple Voice Interface Test</h3>
+        <p style="color: white;">JavaScript functionality will be added after basic test passes.</p>
+    </div>
+    """
+    
+    st.components.v1.html(simple_html, height=150)
+
+if __name__ == "__main__":
+    main()