Voice Agent

RunAnywhere.configureVoiceAgent(VoiceAgentConfiguration(
    sttModelId = "whisper-tiny",
    llmModelId = "qwen-0.5b",
    ttsVoiceId = "en-us-default",
    systemPrompt = "You are a helpful assistant. Keep responses brief.",
    interruptionEnabled = true
))

data class VoiceAgentConfiguration(
    val sttModelId: String,              // Speech-to-text model
    val llmModelId: String,              // Language model
    val ttsVoiceId: String,              // Text-to-speech voice
    val systemPrompt: String? = null,    // LLM system prompt
    val vadConfiguration: VADConfiguration? = null,
    val interruptionEnabled: Boolean = true  // Allow user interruption
)

val audioData = // ... recorded audio from user

val result = RunAnywhere.processVoice(audioData)

println("User said: ${result.transcription}")
println("AI response: ${result.response}")
println("Total latency: ${result.totalLatencyMs}ms")

// Play the response audio
result.audioData?.let { audio ->
    audioPlayer.play(audio)
}

lifecycleScope.launch {
    RunAnywhere.startVoiceSession()
        .collect { event ->
            when (event) {
                is VoiceSessionEvent.Listening -> {
                    updateUI("Listening...")
                    showMicrophoneActive()
                }
                is VoiceSessionEvent.Transcribed -> {
                    updateUI("You: ${event.text}")
                }
                is VoiceSessionEvent.Thinking -> {
                    updateUI("Thinking...")
                    showLoadingIndicator()
                }
                is VoiceSessionEvent.Responded -> {
                    updateUI("AI: ${event.text}")
                }
                is VoiceSessionEvent.Speaking -> {
                    updateUI("Speaking...")
                }
                is VoiceSessionEvent.Idle -> {
                    updateUI("Ready")
                }
                is VoiceSessionEvent.Error -> {
                    showError(event.message)
                }
            }
        }
}

sealed class VoiceSessionEvent {
    object Listening : VoiceSessionEvent()
    data class Transcribed(val text: String) : VoiceSessionEvent()
    object Thinking : VoiceSessionEvent()
    data class Responded(val text: String) : VoiceSessionEvent()
    object Speaking : VoiceSessionEvent()
    object Idle : VoiceSessionEvent()
    data class Error(val message: String) : VoiceSessionEvent()
}

// Stop the voice session
RunAnywhere.stopVoiceSession()

// Check if session is active
val isActive = RunAnywhere.isVoiceSessionActive()

// Clear conversation history
RunAnywhere.clearVoiceConversation()

// Update system prompt mid-session
RunAnywhere.setVoiceSystemPrompt("You are now a coding assistant.")

class VoiceAssistantActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_voice_assistant)

        lifecycleScope.launch {
            // Configure voice agent
            RunAnywhere.configureVoiceAgent(VoiceAgentConfiguration(
                sttModelId = "whisper-tiny",
                llmModelId = "qwen-0.5b",
                ttsVoiceId = "en-us-default",
                systemPrompt = """
                    You are a helpful voice assistant.
                    Keep responses under 2 sentences.
                    Be friendly and conversational.
                """.trimIndent()
            ))

            // Check if ready
            if (!RunAnywhere.isVoiceAgentReady()) {
                showMessage("Loading models...")
                RunAnywhere.initializeVoiceAgentWithLoadedModels()
            }
        }

        startButton.setOnClickListener {
            startVoiceSession()
        }

        stopButton.setOnClickListener {
            lifecycleScope.launch {
                RunAnywhere.stopVoiceSession()
            }
        }
    }

    private fun startVoiceSession() {
        lifecycleScope.launch {
            RunAnywhere.startVoiceSession()
                .collect { event ->
                    runOnUiThread {
                        when (event) {
                            is VoiceSessionEvent.Listening -> {
                                statusText.text = "🎤 Listening..."
                                micButton.setColorFilter(Color.RED)
                            }
                            is VoiceSessionEvent.Transcribed -> {
                                transcriptionText.text = event.text
                            }
                            is VoiceSessionEvent.Thinking -> {
                                statusText.text = "🤔 Thinking..."
                            }
                            is VoiceSessionEvent.Responded -> {
                                responseText.text = event.text
                            }
                            is VoiceSessionEvent.Speaking -> {
                                statusText.text = "🔊 Speaking..."
                            }
                            is VoiceSessionEvent.Idle -> {
                                statusText.text = "Ready"
                                micButton.clearColorFilter()
                            }
                            is VoiceSessionEvent.Error -> {
                                Toast.makeText(this@VoiceAssistantActivity,
                                    event.message, Toast.LENGTH_SHORT).show()
                            }
                        }
                    }
                }
        }
    }
}

val states = RunAnywhere.voiceAgentComponentStates()
println("STT ready: ${states.sttReady}")
println("LLM ready: ${states.llmReady}")
println("TTS ready: ${states.ttsReady}")
println("VAD ready: ${states.vadReady}")