Gemini API と Apple FoundationModels（iOS 26）を組み合わせる — オンデバイス優先のハイブリッド推論ルーティング実装メモ

enum InferenceTarget {
    case appleFoundationModels
    case geminiFlash
    case geminiPro
}
 
struct RoutingInput {
    let languageCode: String          // "ja" / "en" / "fr" など
    let estimatedInputTokens: Int
    let estimatedOutputTokens: Int
    let userPrefersQuality: Bool
    let modelStatus: LocalModelStatus
}
 
func decideTarget(_ input: RoutingInput) -> InferenceTarget {
    // 高品質モードは常にクラウド
    if input.userPrefersQuality {
        return input.estimatedInputTokens > 32_000
            ? .geminiPro
            : .geminiFlash
    }
 
    // ローカルが使えない / 言語非対応 / 入出力が長すぎる場合はクラウド
    let totalTokens = input.estimatedInputTokens + input.estimatedOutputTokens
    let isAppleLangSupported = ["en", "fr", "de", "es", "it", "pt"].contains(input.languageCode)
    let isWithinLocalLimit = totalTokens <= 1_500
 
    switch input.modelStatus {
    case .ready where isAppleLangSupported && isWithinLocalLimit:
        return .appleFoundationModels
    default:
        return input.estimatedInputTokens > 32_000
            ? .geminiPro
            : .geminiFlash
    }
}

import FoundationModels
 
@Generable
struct ShortPoem {
    @Guide(description: "Title in three to five words.")
    var title: String
 
    @Guide(description: "Body lines, six to ten lines total, each fewer than 12 words.")
    var lines: [String]
 
    @Guide(description: "Mood tag: calm, melancholic, hopeful, energetic.")
    var mood: String
}
 
actor LocalPoemGenerator {
    private var session: LanguageModelSession?
 
    func prepare() async throws {
        guard SystemLanguageModel.default.availability == .available else {
            throw PoemError.localUnavailable
        }
        if session == nil {
            session = LanguageModelSession(model: .default,
                                           instructions: """
                You are a quiet, observant poet. Use plain English.
                Avoid metaphors that depend on Japanese cultural cues.
                """)
        }
    }
 
    func generate(promptDescription: String) async throws -> ShortPoem {
        try await prepare()
        guard let session else { throw PoemError.localUnavailable }
        let response = try await session.respond(
            to: """
            Write a short poem inspired by the following scene.
            Scene: \(promptDescription)
            Keep the language sober and concrete.
            """,
            generating: ShortPoem.self,
            options: GenerationOptions(temperature: 0.7, maximumResponseTokens: 320)
        )
        return response.content
    }
}
 
enum PoemError: Error {
    case localUnavailable
    case schemaMismatch
    case timedOut
}

struct GeminiResponse: Decodable {
    struct Candidate: Decodable {
        struct Content: Decodable {
            struct Part: Decodable { let text: String }
            let parts: [Part]
        }
        let content: Content
    }
    let candidates: [Candidate]
}
 
actor GeminiPoemGenerator {
    private let apiKey: String
    private let session: URLSession
 
    init(apiKey: String, session: URLSession = .shared) {
        self.apiKey = apiKey
        self.session = session
    }
 
    func generate(promptDescription: String,
                  model: String = "gemini-2.5-flash") async throws -> ShortPoem {
        let endpoint = URL(string:
            "https://generativelanguage.googleapis.com/v1beta/models/\(model):generateContent?key=\(apiKey)")!
        let schema: [String: Any] = [
            "type": "OBJECT",
            "properties": [
                "title": ["type": "STRING"],
                "lines": ["type": "ARRAY", "items": ["type": "STRING"]],
                "mood": ["type": "STRING", "enum": ["calm", "melancholic", "hopeful", "energetic"]]
            ],
            "required": ["title", "lines", "mood"]
        ]
        let body: [String: Any] = [
            "contents": [[
                "parts": [["text": """
                    Write a short poem inspired by the scene below.
                    Output JSON that matches the schema. Six to ten lines.
                    Scene: \(promptDescription)
                """]]
            ]],
            "generationConfig": [
                "responseMimeType": "application/json",
                "responseSchema": schema,
                "temperature": 0.8,
                "maxOutputTokens": 512
            ]
        ]
        var request = URLRequest(url: endpoint)
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        request.httpBody = try JSONSerialization.data(withJSONObject: body)
        request.timeoutInterval = 8.0
 
        let (data, response) = try await session.data(for: request)
        guard let http = response as? HTTPURLResponse, (200..<300).contains(http.statusCode) else {
            throw PoemError.timedOut
        }
        let decoded = try JSONDecoder().decode(GeminiResponse.self, from: data)
        guard let jsonText = decoded.candidates.first?.content.parts.first?.text,
              let jsonData = jsonText.data(using: .utf8) else {
            throw PoemError.schemaMismatch
        }
        return try JSONDecoder().decode(ShortPoem.self, from: jsonData)
    }
}

final class PoemEngine {
    private let local: LocalPoemGenerator
    private let cloudFlash: GeminiPoemGenerator
    private let cloudPro: GeminiPoemGenerator
 
    init(geminiApiKey: String) {
        self.local = LocalPoemGenerator()
        self.cloudFlash = GeminiPoemGenerator(apiKey: geminiApiKey)
        self.cloudPro = GeminiPoemGenerator(apiKey: geminiApiKey)
    }
 
    func generate(scene: String,
                  languageCode: String,
                  estimatedInputTokens: Int = 220,
                  estimatedOutputTokens: Int = 320,
                  userPrefersQuality: Bool = false) async throws -> (ShortPoem, InferenceTarget) {
        let status = detectLocalModelStatus()
        let target = decideTarget(.init(
            languageCode: languageCode,
            estimatedInputTokens: estimatedInputTokens,
            estimatedOutputTokens: estimatedOutputTokens,
            userPrefersQuality: userPrefersQuality,
            modelStatus: status
        ))
 
        do {
            switch target {
            case .appleFoundationModels:
                return (try await local.generate(promptDescription: scene), target)
            case .geminiFlash:
                return (try await cloudFlash.generate(promptDescription: scene,
                                                      model: "gemini-2.5-flash"), target)
            case .geminiPro:
                return (try await cloudPro.generate(promptDescription: scene,
                                                    model: "gemini-2.5-pro"), target)
            }
        } catch PoemError.localUnavailable, PoemError.schemaMismatch {
            // ローカルが失敗した場合はクラウドへ静かにフォールバック
            return (try await cloudFlash.generate(promptDescription: scene), .geminiFlash)
        }
    }
}