generateStream()

RunAnywhere.generateStream("Tell me a story about AI")
    .collect { token ->
        // Display each token as it arrives
        print(token)
        textView.append(token)
    }

val streamResult = RunAnywhere.generateStreamWithMetrics(
    prompt = "Explain quantum computing",
    options = LLMGenerationOptions(maxTokens = 500)
)

// Collect tokens as they arrive
streamResult.stream.collect { token ->
    textView.append(token)
}

// Get final metrics after streaming completes
val metrics = streamResult.result.await()
println("\n\nGenerated ${metrics.tokensUsed} tokens")
println("Speed: ${metrics.tokensPerSecond} tok/s")
println("Time to first token: ${metrics.timeToFirstTokenMs}ms")

data class LLMStreamingResult(
    val stream: Flow<String>,                    // Token stream
    val result: Deferred<LLMGenerationResult>    // Final metrics (awaitable)
)

class ChatViewModel : ViewModel() {
    private val _currentResponse = MutableStateFlow("")
    val currentResponse: StateFlow<String> = _currentResponse

    private val _isGenerating = MutableStateFlow(false)
    val isGenerating: StateFlow<Boolean> = _isGenerating

    fun sendMessage(prompt: String) {
        viewModelScope.launch {
            _isGenerating.value = true
            _currentResponse.value = ""

            try {
                RunAnywhere.generateStream(prompt)
                    .collect { token ->
                        _currentResponse.value += token
                    }
            } catch (e: Exception) {
                _currentResponse.value = "Error: ${e.message}"
            } finally {
                _isGenerating.value = false
            }
        }
    }

    fun cancelGeneration() {
        RunAnywhere.cancelGeneration()
    }
}

@Composable
fun StreamingTextView(viewModel: ChatViewModel) {
    val response by viewModel.currentResponse.collectAsState()
    val isGenerating by viewModel.isGenerating.collectAsState()

    Column {
        Text(
            text = response,
            modifier = Modifier
                .fillMaxWidth()
                .padding(16.dp)
        )

        if (isGenerating) {
            LinearProgressIndicator(
                modifier = Modifier.fillMaxWidth()
            )
        }
    }
}