Apple Intelligence 非対応の iPhone にもフォールバックする Foundation Models の使い方

import FoundationModels

enum AppleModel {
    static var isAvailable: Bool {
        if #available(iOS 26.0, macOS 26.0, *),
           case .available = SystemLanguageModel.default.availability {
            return true
        }
        return false
    }

    /// Something you can show in Settings, or nil when the model is ready.
    static var unavailableReason: String? {
        if #available(iOS 26.0, macOS 26.0, *) {
            switch SystemLanguageModel.default.availability {
            case .available:
                return nil
            case .unavailable(.deviceNotEligible):
                return "This device doesn't support Apple Intelligence."
            case .unavailable(.appleIntelligenceNotEnabled):
                return "Apple Intelligence is turned off in Settings."
            case .unavailable(.modelNotReady):
                return "Apple Intelligence is still downloading its model."
            case .unavailable:
                return "Apple Intelligence isn't available right now."
            }
        }
        return "Apple Intelligence needs iOS 26."
    }
}

import FoundationModels

@Generable
struct Letter {
    @Guide(description: "Who sent it, short")
    var sender: String
    @Guide(.anyOf(["none", "pay", "reply", "sign"]))
    var action: String
    @Guide(description: "Tiny steps, each starting with a verb", .maximumCount(4))
    var steps: [String]
}

let session = LanguageModelSession(instructions: "Read the letter. Use only facts from it.")
let letter = try await session.respond(to: scannedText, generating: Letter.self).content

struct Property {
    let name: String
    let field: Field
    let description: String?
}

indirect enum Field {
    case string
    case choice([String])
    case integer(ClosedRange<Int>?)
    case boolean
    case date                      // "YYYY-MM-DD" or ""
    case list(Field, max: Int?)
}

let letterFields: [Property] = [
    .init(name: "sender", field: .string, description: "Who sent it, short"),
    .init(name: "action", field: .choice(["none", "pay", "reply", "sign"]), description: nil),
    .init(name: "urgency", field: .integer(0...3), description: "0 information only, 3 deadline soon"),
    .init(name: "deadline", field: .date, description: "Only if the letter names one"),
    .init(name: "steps", field: .list(.string, max: 4), description: "Tiny steps, each starting with a verb"),
]

import FoundationModels

@available(iOS 26.0, macOS 26.0, *)
extension Field {
    func dynamic(name: String) -> DynamicGenerationSchema {
        switch self {
        case .string:
            DynamicGenerationSchema(type: String.self)
        case .choice(let values):
            DynamicGenerationSchema(name: name, anyOf: values)
        case .integer(let range):
            DynamicGenerationSchema(type: Int.self, guides: range.map { [.range($0)] } ?? [])
        case .boolean:
            DynamicGenerationSchema(type: Bool.self)
        case .date:
            DynamicGenerationSchema(type: String.self, guides: [.pattern(/^$|^\d{4}-\d{2}-\d{2}$/)])
        case .list(let item, let max):
            DynamicGenerationSchema(arrayOf: item.dynamic(name: name + "_item"), maximumElements: max)
        }
    }
}

@available(iOS 26.0, macOS 26.0, *)
func appleJSON(schemaName: String, fields: [Property], instructions: String, input: String) async throws -> String {
    let root = DynamicGenerationSchema(
        name: schemaName,
        description: nil,
        properties: fields.map { p in
            DynamicGenerationSchema.Property(
                name: p.name,
                description: p.description,
                schema: p.field.dynamic(name: "\(schemaName)_\(p.name)")
            )
        }
    )
    let schema = try GenerationSchema(root: root, dependencies: [])
    let session = LanguageModelSession(instructions: instructions)
    let response = try await session.respond(to: input, schema: schema)
    return response.content.jsonString
}

struct LetterAnswer: Codable, Sendable {
    var sender: String
    var action: String
    var urgency: Int
    var deadline: String
    var steps: [String]
}

let json = try await appleJSON(schemaName: "Letter", fields: letterFields,
                               instructions: "Read the letter. Use only facts from it.",
                               input: scannedText)
let letter = try JSONDecoder().decode(LetterAnswer.self, from: Data(json.utf8))

enum Tier: String { case apple, local, rules }

struct LetterAssistant {
    var localModel: () async -> URL?                  // nil until the GGUF is downloaded
    var local: (URL, String) async throws -> LetterAnswer
    var rules: (String) -> LetterAnswer?

    func run(_ input: String) async throws -> (LetterAnswer, Tier) {
        var lastError: Error = CancellationError()
        for tier in [Tier.apple, .local, .rules] {
            do {
                switch tier {
                case .apple:
                    guard AppleModel.isAvailable, #available(iOS 26.0, macOS 26.0, *) else { continue }
                    let json = try await appleJSON(schemaName: "Letter", fields: letterFields,
                                                   instructions: "Read the letter. Use only facts from it.",
                                                   input: input)
                    return (try JSONDecoder().decode(LetterAnswer.self, from: Data(json.utf8)), .apple)
                case .local:
                    guard let url = await localModel() else { continue }
                    return (try await local(url, input), .local)
                case .rules:
                    guard let answer = rules(input) else { continue }
                    return (answer, .rules)
                }
            } catch {
                lastError = error   // try the next tier
            }
        }
        throw lastError
    }
}