transcribe()

let output = try await RunAnywhere.transcribe(audio: audioData)
print("You said: \(output.text)")

import RunAnywhere
import ONNXRuntime

@MainActor
func setup() {
    ONNX.register()
}

var request = RAModelLoadRequest()
request.modelID = "sherpa-onnx-whisper-tiny.en"
request.category = .speechRecognition

let result = await RunAnywhere.loadModel(request)
guard result.success else {
    print("Load failed: \(result.errorMessage)")
    return
}

public static func transcribe(
    audio audioData: Data,
    options: RASTTOptions = .defaults()
) async throws -> RASTTOutput

import AVFoundation

@MainActor
final class AudioRecorder {
    private var audioRecorder: AVAudioRecorder?

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

        let url = FileManager.default.temporaryDirectory
            .appendingPathComponent("recording.wav")

        let settings: [String: Any] = [
            AVFormatIDKey: Int(kAudioFormatLinearPCM),
            AVSampleRateKey: 16000,
            AVNumberOfChannelsKey: 1,
            AVLinearPCMBitDepthKey: 16,
            AVLinearPCMIsFloatKey: false
        ]

        audioRecorder = try AVAudioRecorder(url: url, settings: settings)
        audioRecorder?.record()
    }

    func stopAndTranscribe() async throws -> String {
        guard let recorder = audioRecorder else { return "" }
        recorder.stop()
        let audioData = try Data(contentsOf: recorder.url)
        return try await RunAnywhere.transcribe(audio: audioData).text
    }
}

var options = RASTTOptions.defaults()
options.enableWordTimestamps = true

let output = try await RunAnywhere.transcribe(audio: audioData, options: options)

print("Full text: \(output.text)")
for word in output.words {
    let start = Double(word.startMs) / 1000
    let end = Double(word.endMs) / 1000
    print("\(word.word): \(start)s - \(end)s")
}

// Let the model detect the language
var auto = RASTTOptions.defaults()
auto.language = .auto
let detected = try await RunAnywhere.transcribe(audio: audioData, options: auto)
print("Detected: \(detected.language)")

// Pin Spanish
var spanish = RASTTOptions.defaults()
spanish.language = .es
let output = try await RunAnywhere.transcribe(audio: audioData, options: spanish)

struct VoiceInputView: View {
    @State private var recorder = AudioRecorder()
    @State private var transcription = ""
    @State private var isRecording = false
    @State private var isProcessing = false

    var body: some View {
        VStack(spacing: 20) {
            Text(transcription)
                .frame(maxWidth: .infinity, minHeight: 100, alignment: .topLeading)
                .padding()
                .background(Color.gray.opacity(0.1))
                .cornerRadius(12)

            Button(action: toggleRecording) {
                ZStack {
                    Circle()
                        .fill(isRecording ? Color.red : Color.blue)
                        .frame(width: 80, height: 80)

                    if isProcessing {
                        ProgressView().tint(.white)
                    } else {
                        Image(systemName: isRecording ? "stop.fill" : "mic.fill")
                            .font(.title)
                            .foregroundColor(.white)
                    }
                }
            }
            .disabled(isProcessing)

            Text(isRecording ? "Tap to stop" : "Tap to record")
                .font(.caption)
                .foregroundColor(.secondary)
        }
        .padding()
    }

    func toggleRecording() {
        if isRecording {
            isRecording = false
            isProcessing = true
            Task {
                do {
                    transcription = try await recorder.stopAndTranscribe()
                } catch {
                    transcription = "Transcription failed: \(error.localizedDescription)"
                }
                isProcessing = false
            }
        } else {
            do {
                try recorder.startRecording()
                isRecording = true
            } catch {
                transcription = "Failed to start recording: \(error.localizedDescription)"
            }
        }
    }
}

// Load
var load = RAModelLoadRequest()
load.modelID = "sherpa-onnx-whisper-tiny.en"
load.category = .speechRecognition
let loaded = await RunAnywhere.loadModel(load)

// Check what is loaded
var query = RACurrentModelRequest()
query.category = .speechRecognition
let current = RunAnywhere.currentModel(query)
print("STT loaded: \(current.found)")

// Unload
var unload = RAModelUnloadRequest()
unload.category = .speechRecognition
_ = await RunAnywhere.unloadModel(unload)

let stt = try await RunAnywhere.registerModel(
    archive: "https://github.com/RunanywhereAI/sherpa-onnx/releases/download/runanywhere-models-v1/sherpa-onnx-whisper-tiny.en.tar.gz",
    structure: .nestedDirectory,
    id: "sherpa-onnx-whisper-tiny.en",
    name: "Sherpa Whisper Tiny",
    framework: .onnx,
    modality: .speechRecognition,
    archiveType: .tarGz,
    memoryRequirement: 75_000_000
)

_ = try await RunAnywhere.downloadModel(stt)

do {
    let output = try await RunAnywhere.transcribe(audio: audioData)
    print(output.text)
} catch let error as SDKException {
    switch error.code {
    case .notInitialized:
        print("Load an STT model first")
    case .emptyAudioBuffer:
        print("Audio data is empty")
    case .processingFailed:
        print("Transcription failed: \(error.message)")
    default:
        print("Error: \(error.localizedDescription)")
    }
}