Streaming STT

let (audio, continuation) = AsyncStream<Data>.makeStream()

let task = Task {
    for await partial in RunAnywhere.transcribeStream(audio: audio) {
        if partial.isFinal {
            print("Final: \(partial.text)")
        } else {
            print("Partial: \(partial.text)")
        }
    }
}

// Feed microphone chunks
continuation.yield(pcmChunk)

// End the session
continuation.finish()

public static func transcribeStream(
    audio: AsyncStream<Data>,
    options: RASTTOptions = .defaults()
) -> AsyncStream<RASTTPartialResult>

import AVFoundation

@MainActor
@Observable
final class LiveTranscriber {
    var partialText = ""
    var committedText = ""
    var isTranscribing = false

    private var audioEngine: AVAudioEngine?
    private var continuation: AsyncStream<Data>.Continuation?
    private var streamTask: Task<Void, Never>?

    func start() throws {
        let session = AVAudioSession.sharedInstance()
        try session.setCategory(.playAndRecord, mode: .measurement)
        try session.setActive(true)

        let (audio, continuation) = AsyncStream<Data>.makeStream()
        self.continuation = continuation

        streamTask = Task { [weak self] in
            for await partial in RunAnywhere.transcribeStream(audio: audio) {
                guard let self, !Task.isCancelled else { break }
                self.handle(partial)
            }
        }

        let engine = AVAudioEngine()
        audioEngine = engine

        let format = AVAudioFormat(
            commonFormat: .pcmFormatFloat32,
            sampleRate: 16000,
            channels: 1,
            interleaved: false
        )!

        engine.inputNode.installTap(onBus: 0, bufferSize: 4096, format: format) { buffer, _ in
            guard let channel = buffer.floatChannelData?[0] else { return }
            let bytes = Int(buffer.frameLength) * MemoryLayout<Float>.size
            continuation.yield(Data(bytes: channel, count: bytes))
        }

        engine.prepare()
        try engine.start()
        isTranscribing = true
    }

    private func handle(_ partial: RASTTPartialResult) {
        let text = partial.text.trimmingCharacters(in: .whitespacesAndNewlines)
        guard !text.isEmpty else { return }

        if partial.isFinal {
            committedText = committedText.isEmpty ? text : committedText + "\n" + text
            partialText = ""
        } else {
            partialText = text
        }
    }

    func stop() {
        audioEngine?.inputNode.removeTap(onBus: 0)
        audioEngine?.stop()
        audioEngine = nil

        continuation?.finish()
        continuation = nil
        streamTask?.cancel()
        streamTask = nil
        isTranscribing = false
    }
}

struct LiveTranscriptionView: View {
    @State private var transcriber = LiveTranscriber()

    var body: some View {
        VStack(spacing: 20) {
            ScrollView {
                Text(transcriber.committedText)
                    .frame(maxWidth: .infinity, alignment: .leading)
            }
            .frame(height: 200)
            .padding()
            .background(Color.gray.opacity(0.1))
            .cornerRadius(12)

            if !transcriber.partialText.isEmpty {
                Text(transcriber.partialText)
                    .foregroundColor(.secondary)
                    .italic()
            }

            if transcriber.isTranscribing {
                HStack {
                    Circle().fill(Color.red).frame(width: 12, height: 12)
                    Text("Listening")
                }
            }

            HStack(spacing: 20) {
                Button {
                    try? transcriber.start()
                } label: {
                    Label("Start", systemImage: "mic.fill")
                }
                .disabled(transcriber.isTranscribing)

                Button {
                    transcriber.stop()
                } label: {
                    Label("Stop", systemImage: "stop.fill")
                }
                .disabled(!transcriber.isTranscribing)
            }
        }
        .padding()
    }
}

@MainActor
final class VoiceCommandDetector {
    private let commands = ["play", "pause", "stop", "next", "previous"]
    var onCommandDetected: ((String) -> Void)?

    func run(audio: AsyncStream<Data>) async {
        for await partial in RunAnywhere.transcribeStream(audio: audio) {
            let lowercased = partial.text.lowercased()
            if let match = commands.first(where: lowercased.contains) {
                onCommandDetected?(match)
            }
        }
    }
}

var options = RASTTOptions.defaults()
options.chunkDurationMs = 1000     // decoding chunk size
options.endpointSilenceMs = 600    // silence before an utterance closes

for await partial in RunAnywhere.transcribeStream(audio: audio, options: options) {
    // ...
}

for await partial in RunAnywhere.transcribeStream(audio: audio) {
    if partial.isFinal, partial.text.hasPrefix("STT stream failed") {
        print("Stream error: \(partial.text)")
        break
    }
    render(partial.text)
}