Core AI On-Device Model Integration

import SwiftUI
import FoundationModels
import CoreAILM

// Define structured output with @Generable — same as Foundation Models
@Generable
struct VocabCard {
    @Guide(description: "The word in the target language")
    var word: String
    @Guide(description: "Romanized pronunciation")
    var pronunciation: String
    @Guide(description: "English translation")
    var translation: String
    @Guide(description: "Example sentence in the target language")
    var exampleSentence: String
    @Guide(description: "English meaning of the example sentence")
    var exampleMeaning: String
}

@MainActor
class VocabCardViewModel: ObservableObject {
    @Published var card: VocabCard?
    @Published var isLoading = false
    @Published var errorMessage: String?

    // Load a custom Core AI LLM from the app bundle (e.g. Qwen 0.6B)
    private var languageModel: CoreAILanguageModel = {
        guard let modelURL = Bundle.main.url(
            forResource: "Qwen-0.6B",
            withExtension: "aimodel"
        ) else {
            fatalError("Qwen model bundle not found in app resources")
        }
        return CoreAILanguageModel(modelURL: modelURL)
    }()

    func generateCard(for englishLabel: String, targetLanguage: String) async {
        isLoading = true
        card = nil
        errorMessage = nil

        do {
            // Pass your custom model to LanguageModelSession — same API as Apple Intelligence
            let session = LanguageModelSession(model: languageModel)

            let prompt = "Generate a \(targetLanguage) vocabulary card for the English word: \(englishLabel)"

            // Structured output generation using @Generable — identical to Foundation Models usage
            let response = try await session.respond(
                to: Prompt(prompt),
                generating: VocabCard.self
            )
            card = response.content
        } catch {
            errorMessage = error.localizedDescription
        }
        isLoading = false
    }
}

struct VocabCardView: View {
    @StateObject private var viewModel = VocabCardViewModel()
    let detectedLabel: String = "hummingbird"

    var body: some View {
        VStack(spacing: 16) {
            if viewModel.isLoading {
                ProgressView("Generating vocab card...")
            } else if let card = viewModel.card {
                VStack(alignment: .leading, spacing: 8) {
                    Text(card.word).font(.largeTitle.bold())
                    Text(card.pronunciation).font(.subheadline).foregroundStyle(.secondary)
                    Text(card.translation).font(.title3)
                    Divider()
                    Text(card.exampleSentence).italic()
                    Text(card.exampleMeaning).font(.caption).foregroundStyle(.secondary)
                }
                .padding()
                .background(.regularMaterial, in: RoundedRectangle(cornerRadius: 16))
            } else if let error = viewModel.errorMessage {
                Text("Error: \(error)").foregroundStyle(.red)
            }

            Button("Generate Card for '\(detectedLabel)'") {
                Task {
                    await viewModel.generateCard(for: detectedLabel, targetLanguage: "Mandarin Chinese")
                }
            }
            .buttonStyle(.borderedProminent)
        }
        .padding()
    }
}