dependencies: [
    .package(url: "https://github.com/RunanywhereAI/runanywhere-sdks", from: "0.16.0")
],
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() }
    }
}

try await RunAnywhere.loadSTTModel("whisper-base-onnx")

let isLoaded = await RunAnywhere.isSTTModelLoaded

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

let options = STTOptions(
    language: "en-US",
    sampleRate: 16000,
    enableWordTimestamps: true
)

let result = try await RunAnywhere.transcribeWithOptions(audioData, options: options)
print("Text: \(result.text)")
print("Confidence: \(result.confidence ?? 0)")
if let language = result.detectedLanguage {
    print("Detected language: \(language)")
}

let output = try await RunAnywhere.transcribeStream(
    audioData: audioData,
    options: STTOptions(language: "en")
) { partialResult in
    print("Partial: \(partialResult.transcript)")
}

print("Final: \(output.text)")

try await RunAnywhere.unloadSTTModel()

try await RunAnywhere.loadTTSVoice("piper-en-us-amy")

let isLoaded = await RunAnywhere.isTTSVoiceLoaded

let output = try await RunAnywhere.synthesize(
    "Hello! Welcome to RunAnywhere.",
    options: TTSOptions(rate: 1.0, pitch: 1.0, volume: 0.8)
)

// output.audioData contains the synthesized audio
// output.duration contains the audio length in seconds

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

// With options
let result = try await RunAnywhere.speak(
    "Hello",
    options: TTSOptions(rate: 1.2, pitch: 1.0)
)
print("Duration: \(result.duration)s")

let output = try await RunAnywhere.synthesizeStream(
    "Long text to synthesize...",
    options: TTSOptions()
) { chunk in
    // Process audio chunk as it's generated
    playAudioChunk(chunk)
}

let voices = await RunAnywhere.availableTTSVoices
for voice in voices {
    print("Voice: \(voice)")
}

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

// Default configuration
try await RunAnywhere.initializeVAD()

// Custom configuration
try await RunAnywhere.initializeVAD(VADConfiguration(
    sampleRate: 16000,
    frameLength: 0.032,
    energyThreshold: 0.5
))

// From audio samples
let samples: [Float] = // your audio samples
let speechDetected = try await RunAnywhere.detectSpeech(in: samples)

// From AVAudioPCMBuffer
let buffer: AVAudioPCMBuffer = // your audio buffer
let speechDetected = try await RunAnywhere.detectSpeech(in: buffer)

// Speech activity callback
await RunAnywhere.setVADSpeechActivityCallback { event in
    switch event {
    case .started:
        print("Speech started")
    case .ended:
        print("Speech ended")
    }
}

// Audio buffer callback
await RunAnywhere.setVADAudioBufferCallback { samples in
    // Process audio samples
}

try await RunAnywhere.startVAD()
try await RunAnywhere.stopVAD()
await RunAnywhere.cleanupVAD()

public enum ONNX: RunAnywhereModule {
    /// Module identifier
    public static let moduleId = "onnx"

    /// Human-readable module name
    public static let moduleName = "ONNX Runtime"

    /// Capabilities provided by this module
    public static let capabilities: Set<SDKComponent> = [.stt, .tts, .vad]

    /// Default registration priority
    public static let defaultPriority: Int = 100

    /// Inference framework used
    public static let inferenceFramework: InferenceFramework = .onnx

    /// Module version
    public static let version = "2.0.0"

    /// Underlying ONNX Runtime version
    public static let onnxRuntimeVersion = "1.23.2"

    /// Register the module with the service registry
    @MainActor
    public static func register(priority: Int = 100)

    /// Unregister the module
    public static func unregister()

    /// Check if the module can handle a given STT model
    public static func canHandleSTT(modelId: String?) -> Bool

    /// Check if the module can handle a given TTS model
    public static func canHandleTTS(modelId: String?) -> Bool

    /// Check if the module can handle VAD
    public static func canHandleVAD(modelId: String?) -> Bool
}

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