Core AI On-Device Model Integration

import SwiftUI
import FoundationModels
import CoreAILM

// 1. Describe the structured output with @Generable
@Generable
struct VocabCard {
    @Guide(description: "The word in Mandarin Chinese (simplified characters)")
    var mandarinWord: String
    @Guide(description: "Pinyin romanisation of the Mandarin word")
    var pinyin: String
    @Guide(description: "A natural example sentence in Mandarin using the word")
    var exampleSentence: String
    @Guide(description: "English translation of the example sentence")
    var exampleTranslation: String
}

// 2. Actor that owns the model session
actor VocabCardActor {
    private var session: LanguageModelSession?

    func prepare(modelURL: URL) throws {
        // Load the .aimodel bundle — tokeniser, engine, assets all wired up automatically
        let customModel = try CoreAILanguageModel(contentsOf: modelURL)
        // Pass it into a standard FoundationModels session
        session = LanguageModelSession(model: customModel)
    }

    func generateCard(for englishLabel: String) async throws -> VocabCard {
        guard let session else { throw VocabError.notReady }
        let prompt = "Generate a Mandarin Chinese vocabulary card for the English word: \(englishLabel)"
        let response = try await session.respond(
            to: prompt,
            generating: VocabCard.self
        )
        return response.value
    }

    enum VocabError: Error { case notReady }
}

// 3. SwiftUI view wiring it together
struct VocabCardView: View {
    let englishLabel: String
    @State private var card: VocabCard?
    @State private var isLoading = false

    private let actor = VocabCardActor()

    var body: some View {
        VStack(spacing: 16) {
            if let card {
                Text(card.mandarinWord).font(.largeTitle)
                Text(card.pinyin).foregroundStyle(.secondary)
                Divider()
                Text(card.exampleSentence).italic()
                Text(card.exampleTranslation).foregroundStyle(.secondary)
            } else if isLoading {
                ProgressView("Generating card…")
            } else {
                Button("Generate Card for \(englishLabel)") {
                    Task { await generate() }
                }
                .buttonStyle(.borderedProminent)
            }
        }
        .padding()
    }

    private func generate() async {
        isLoading = true
        defer { isLoading = false }
        do {
            // modelURL points to the exported Qwen .aimodel bundle in the app container
            let modelURL = Bundle.main.url(forResource: "Qwen", withExtension: "aimodel")!
            try await actor.prepare(modelURL: modelURL)
            card = try await actor.generateCard(for: englishLabel)
        } catch {
            print("Card generation failed: \(error)")
        }
    }
}

#Preview {
    VocabCardView(englishLabel: "Hummingbird")
}