Apple Foundation Models と Gemini を差し替え可能にする — アプリ内 AI 層の3層抽象化設計

// アプリ内の AI 呼び出しはすべてこのプロトコルだけに依存させる
protocol AITextClient: Sendable {
    var tier: AITier { get }
    func generate(_ request: AIRequest) async throws -> AIResponse
}
 
enum AITier: Int, Comparable, Sendable {
    case onDevice = 0
    case privateCloud = 1
    case thirdParty = 2
    static func < (lhs: Self, rhs: Self) -> Bool { lhs.rawValue < rhs.rawValue }
}
 
struct AIRequest: Sendable {
    let prompt: String
    let maxTokens: Int
    let privacy: PrivacyClass    // 入力データの性質。ルーティングで使う
    let deadline: TimeInterval   // 呼び出し側が許容できる待ち時間（秒）
}
 
enum PrivacyClass: Sendable {
    case sensitive   // 個人情報・ユーザー作成コンテンツを含む
    case standard    // 端末外に出せるが、自社管理外には出したくない
    case open        // どの層に送ってもよい
}
 
struct AIResponse: Sendable {
    let text: String
    let servedBy: AITier  // どの層が応答したかを記録しておくと運用分析に効く
}

struct GeminiClient: AITextClient {
    let tier: AITier = .thirdParty
    private let apiKey: String  // Keychain 等から注入する。コードに直書きしない
 
    init(apiKey: String) {
        self.apiKey = apiKey
    }
 
    func generate(_ request: AIRequest) async throws -> AIResponse {
        var urlRequest = URLRequest(url: URL(string:
            "https://generativelanguage.googleapis.com/v1/models/gemini-pro:generateContent?key=\(apiKey)")!)
        urlRequest.httpMethod = "POST"
        urlRequest.setValue("application/json", forHTTPHeaderField: "Content-Type")
        urlRequest.httpBody = try JSONEncoder().encode(
            GeminiPayload(prompt: request.prompt, maxOutputTokens: request.maxTokens))
 
        let (data, _) = try await URLSession.shared.data(for: urlRequest)
        let decoded = try JSONDecoder().decode(GeminiResult.self, from: data)
        return AIResponse(text: decoded.text, servedBy: .thirdParty)
    }
}

enum AIRouterError: Error {
    case allTiersFailed
    case timedOut
}
 
struct AIRouter {
    let clients: [AITextClient]  // tier の昇順で渡す
 
    func generate(_ request: AIRequest) async -> Result<AIResponse, AIRouterError> {
        for client in orderedClients(for: request) {
            do {
                let response = try await withTimeout(seconds: request.deadline) {
                    try await client.generate(request)
                }
                return .success(response)
            } catch {
                continue  // この層は諦めて次の層へ
            }
        }
        return .failure(.allTiersFailed)
    }
 
    private func orderedClients(for request: AIRequest) -> [AITextClient] {
        switch request.privacy {
        case .sensitive:
            // 個人情報を含む入力は端末の外に出さない
            return clients.filter { $0.tier == .onDevice }
        case .standard:
            return clients.filter { $0.tier <= .privateCloud }
        case .open:
            return clients
        }
    }
}
 
func withTimeout<T: Sendable>(
    seconds: TimeInterval,
    _ work: @escaping @Sendable () async throws -> T
) async throws -> T {
    try await withThrowingTaskGroup(of: T.self) { group in
        group.addTask { try await work() }
        group.addTask {
            try await Task.sleep(nanoseconds: UInt64(seconds * 1_000_000_000))
            throw AIRouterError.timedOut
        }
        guard let result = try await group.next() else {
            throw AIRouterError.allTiersFailed
        }
        group.cancelAll()
        return result
    }
}