Swift SDK quickstart

https://github.com/bithuman-product/bithuman-kit-public.git

dependencies: [
    .package(url: "https://github.com/bithuman-product/bithuman-kit-public.git",
             from: "0.8.1")
],
targets: [
    .target(
        name: "MyApp",
        dependencies: [
            .product(name: "bitHumanKit", package: "bithuman-kit-public")
        ]
    )
]

<key>NSMicrophoneUsageDescription</key>
<string>Talk to your on-device assistant.</string>
<key>NSSpeechRecognitionUsageDescription</key>
<string>Recognise what you say so the assistant can respond.</string>

<key>com.apple.security.device.audio-input</key>
<true/>

<key>com.apple.developer.kernel.increased-memory-limit</key>
<true/>
<key>com.apple.developer.kernel.extended-virtual-addressing</key>
<true/>

import SwiftUI
import bitHumanKit

@main
struct MyApp: App {
    @StateObject private var lifecycle = MyLifecycle()

    var body: some Scene {
        WindowGroup {
            ContentView(lifecycle: lifecycle)
                .task { await lifecycle.start() }
        }
    }
}

@MainActor
final class MyLifecycle: ObservableObject {
    @Published var status = "booting…"
    private var chat: VoiceChat?

    func start() async {
        var config = VoiceChatConfig()
        config.localeIdentifier = "en-US"
        config.systemPrompt = "You are a helpful assistant. One sentence per turn."
        config.voice = .preset("Aiden")

        do {
            let chat = VoiceChat(config: config)
            try await chat.start()
            self.chat = chat
            status = "live — talk to me"
        } catch {
            status = "error: \(error.localizedDescription)"
        }
    }
}

struct ContentView: View {
    @ObservedObject var lifecycle: MyLifecycle
    var body: some View {
        Text(lifecycle.status).font(.title)
    }
}

import Foundation
import SwiftUI
import bitHumanKit

@MainActor
final class AvatarLifecycle: ObservableObject {
    @Published var phase: BootPhase = .idle
    @Published private(set) var coordinator: AvatarCoordinator?
    @Published private(set) var renderer: AvatarRendererView?
    private var chat: VoiceChat?
    private var pump: FramePump?

    enum BootPhase: Equatable {
        case idle
        case downloading(Double)   // 0…1
        case warming
        case live
        case error(String)
    }

    func start() async {
        do {
            // 1. Download/verify the universal weights bundle.
            //    Surface progress to the UI — first launch can take
            //    minutes on a slow network and silent hang is a
            //    reliable way to lose users.
            phase = .downloading(0)
            let weights = try await ExpressionWeights.ensureAvailable { event in
                Task { @MainActor in
                    if case .downloading(let f, _, _, _, _) = event {
                        self.phase = .downloading(f)
                    }
                }
            }
            phase = .warming

            // 2. Pick a bundled agent for the first run. Swap later
            //    via coordinator.applyAgent(_:) or the AgentPickerView.
            let agent = AgentCatalog.defaultAgent
            let portrait = AgentCatalog.thumbnailURL(for: agent)!

            // 3. Configure + boot. The apiKey here is required for
            //    the avatar pipeline; it's resolved from
            //    BITHUMAN_API_KEY automatically if you leave the
            //    field empty, but explicit-in-config is clearer.
            var config = VoiceChatConfig()
            config.systemPrompt = agent.systemPrompt
            config.avatar = AvatarConfig(modelPath: weights, portraitPath: portrait)
            config.apiKey = ProcessInfo.processInfo.environment["BITHUMAN_API_KEY"]
            let chat = VoiceChat(config: config)
            try await chat.start()  // throws .missingAPIKey / .authenticationFailed
            await chat.setVoicePreset(agent.voicePreset)

            // 4. Bind the coordinator + render stack.
            guard let bh = chat.bithuman else {
                phase = .error("avatar engine failed to initialise")
                return
            }
            let coord = AvatarCoordinator(chat: chat)
            coord.bindToOrchestrator()
            coord.prewarmPortraitURL = portrait
            coord.currentAgentCode = agent.code

            let renderer = AvatarRendererView(
                frame: .zero, idleFrame: chat.initialIdleFrame, clipMode: .circle)
            let pump = FramePump(
                bithuman: bh, chat: chat, window: renderer, coordinator: coord)
            coord.framePump = pump
            chat.onBargeIn = { [weak pump] in pump?.buffer.flushSpeech() }

            // 5. Hold strong refs so SwiftUI doesn't deinit them on
            //    re-render — this is the most common first-try bug.
            self.chat = chat
            self.pump = pump
            self.renderer = renderer
            self.coordinator = coord
            self.phase = .live
        } catch {
            phase = .error(error.localizedDescription)
        }
    }
}

#if canImport(AppKit)
import AppKit
struct AvatarHost: NSViewRepresentable {
    let view: AvatarRendererView
    func makeNSView(context: Context) -> AvatarRendererView { view }
    func updateNSView(_ nsView: AvatarRendererView, context: Context) {}
}
#elseif canImport(UIKit)
import UIKit
struct AvatarHost: UIViewRepresentable {
    let view: AvatarRendererView
    func makeUIView(context: Context) -> AvatarRendererView { view }
    func updateUIView(_ uiView: AvatarRendererView, context: Context) {}
}
#endif

// In your SwiftUI tree:
if let renderer = lifecycle.renderer {
    AvatarHost(view: renderer)
        .frame(width: 280, height: 280)
        .clipShape(Circle())
}

@main
struct MyApp: App {
    var body: some Scene {
        WindowGroup {
            switch HardwareCheck.evaluate() {
            case .supported:
                ContentView()
            case .unsupported(let reason):
                UnsupportedDeviceView(reason: reason)
            }
        }
    }
}