dependencies: [
    .package(url: "https://github.com/RunanywhereAI/runanywhere-sdks", from: "0.20.11")
],
targets: [
    .target(
        name: "YourApp",
        dependencies: [
            .product(name: "RunAnywhere", package: "runanywhere-sdks"),
            .product(name: "RunAnywhereONNX", package: "runanywhere-sdks"),
        ]
    )
]

import RunAnywhere
import ONNXRuntime

@main
struct MyApp: App {
    init() {
        Task { @MainActor in
            ONNX.register()

            try RunAnywhere.initialize(
                apiKey: "<YOUR_API_KEY>",
                baseURL: "https://api.runanywhere.ai",
                environment: .production
            )
        }
    }

    var body: some Scene {
        WindowGroup { ContentView() }
    }
}

var req = RAModelLoadRequest()
req.modelID = "whisper-base-onnx"
req.category = .speechRecognition
req.framework = .onnx
let result = await RunAnywhere.loadModel(req)
print("Loaded: \(result.resolvedPath)")

let audioData: Data = // your audio data (16kHz, mono, Float32)
let output = try await RunAnywhere.transcribe(audio: audioData)
print("Transcribed: \(output.text)")

var options = RASTTOptions.defaults()
options.language = .en
options.sampleRate = 16000
options.enableWordTimestamps = true

let output = try await RunAnywhere.transcribe(audio: audioData, options: options)
print("Text: \(output.text)")
print("Confidence: \(output.confidence)")
if output.hasLanguageCode {
    print("Detected language: \(output.languageCode)")
}

var options = RASTTOptions.defaults()
options.language = .en

for await partial in RunAnywhere.transcribeStream(audio: audioStream, options: options) {
    if partial.isFinal {
        print("Final: \(partial.text)")
    } else {
        print("Partial: \(partial.text)")
    }
}

var unload = RAModelUnloadRequest()
unload.modelID = "whisper-base-onnx"
unload.category = .speechRecognition
_ = await RunAnywhere.unloadModel(unload)

var req = RAModelLoadRequest()
req.modelID = "piper-en-us-amy"
req.category = .speechSynthesis
req.framework = .onnx
_ = await RunAnywhere.loadModel(req)

var options = RATTSOptions.defaults()
options.rate = 1.0
options.pitch = 1.0
options.volume = 0.8

let output = try await RunAnywhere.synthesize(
    "Hello! Welcome to RunAnywhere.",
    options: options
)

// output.audioData contains the synthesized audio
// output.durationMs contains the audio length in ms

// Synthesize and play through device speakers
let result = try await RunAnywhere.speak("Hello world")

// With options
var options = RATTSOptions.defaults()
options.rate = 1.2
options.pitch = 1.0
let result = try await RunAnywhere.speak("Hello", options: options)
print("Duration: \(result.output.durationMs) ms")

for await chunk in RunAnywhere.synthesizeStream("Long text to synthesize...") {
    // Process audio chunk as it is generated
    playAudioChunk(chunk.audioData)
}

await RunAnywhere.stopSynthesis()
await RunAnywhere.stopSpeaking()

// Single buffer
var opts = RAVADOptions()
opts.sampleRate = 16000
opts.energyThreshold = 0.5

let samples: Data = // Float32 PCM at 16 kHz mono
let result = try await RunAnywhere.detectVoiceActivity(samples, options: opts)
if result.isSpeech {
    print("Speech detected (confidence: \(result.confidence))")
}

// Stream VAD over a chunked AsyncStream<Data>
for await vadResult in RunAnywhere.streamVAD(audio: audioStream) {
    if vadResult.isSpeech { handleSpeechFrame(vadResult) }
}

try await RunAnywhere.resetVAD()

public enum ONNX {
    /// Module version
    public static let version = "2.0.0"

    /// Underlying ONNX Runtime version
    public static let onnxRuntimeVersion = RAVersions.onnxRuntimeIOS // 1.24.3

    /// Register the ONNX backend with the C++ service registry.
    /// Registers the generic ONNX module (embeddings + Silero VAD) and the
    /// Sherpa-ONNX engine plugin (STT: Whisper / Zipformer / Paraformer,
    /// TTS: Piper / VITS) so `framework == .sherpa` resolves through the
    /// unified C++ plugin router.
    @MainActor
    public static func register(priority: Int = 100)

    /// Unregister the ONNX backend (also unregisters the Sherpa-ONNX plugin)
    @MainActor
    public static func unregister()

    /// Trigger registration via property access (auto-registration helper)
    public static let autoRegister: Void
}

ONNX.swift (Swift wrapper)
       |
ONNXBackend (C headers)
       |
RABackendONNX.xcframework (C++ implementation)
       |
+---------------+----------------+
|               |                |
ONNX Runtime   Sherpa-ONNX     Silero VAD