SwiftData × Gemini API オフラインキャッシュ設計 — レスポンスを永続化して再利用するアーキテクチャ

import Foundation
import CryptoKit
import SwiftData
 
@Model
final class CachedGeminiResponse {
    @Attribute(.unique) var cacheKey: String
    var promptDigest: String          // 検索表示用に最初の 200 文字を保存
    var modelName: String
    var responseText: String
    var responseSchemaHash: String?   // structured output 用
    var inputTokens: Int
    var outputTokens: Int
    var finishReason: String
    var createdAt: Date
    var lastAccessedAt: Date
    var hitCount: Int
 
    init(
        cacheKey: String,
        promptDigest: String,
        modelName: String,
        responseText: String,
        responseSchemaHash: String?,
        inputTokens: Int,
        outputTokens: Int,
        finishReason: String
    ) {
        self.cacheKey = cacheKey
        self.promptDigest = promptDigest
        self.modelName = modelName
        self.responseText = responseText
        self.responseSchemaHash = responseSchemaHash
        self.inputTokens = inputTokens
        self.outputTokens = outputTokens
        self.finishReason = finishReason
        self.createdAt = .now
        self.lastAccessedAt = .now
        self.hitCount = 0
    }
}
 
enum CacheKeyBuilder {
    static func make(prompt: String, model: String, schemaJSON: String?) -> String {
        let normalized = prompt
            .trimmingCharacters(in: .whitespacesAndNewlines)
            .replacingOccurrences(of: "\r\n", with: "\n")
        let raw = [normalized, model, schemaJSON ?? ""].joined(separator: "::")
        let digest = SHA256.hash(data: Data(raw.utf8))
        return digest.map { String(format: "%02x", $0) }.joined()
    }
}

@MainActor
final class ResponseCacheStore {
    private let context: ModelContext
    init(context: ModelContext) { self.context = context }
 
    func find(key: String) throws -> CachedGeminiResponse? {
        var descriptor = FetchDescriptor<CachedGeminiResponse>(
            predicate: #Predicate { $0.cacheKey == key }
        )
        descriptor.fetchLimit = 1
        guard let hit = try context.fetch(descriptor).first else { return nil }
        hit.hitCount += 1
        hit.lastAccessedAt = .now
        try context.save()
        return hit
    }
 
    func upsert(_ record: CachedGeminiResponse) throws {
        if let existing = try find(key: record.cacheKey) {
            existing.responseText = record.responseText
            existing.outputTokens = record.outputTokens
            existing.finishReason = record.finishReason
            existing.lastAccessedAt = .now
        } else {
            context.insert(record)
        }
        try context.save()
    }
 
    func evict(olderThan days: Int) throws {
        let cutoff = Calendar.current.date(byAdding: .day, value: -days, to: .now)!
        let descriptor = FetchDescriptor<CachedGeminiResponse>(
            predicate: #Predicate { $0.lastAccessedAt < cutoff }
        )
        for record in try context.fetch(descriptor) {
            context.delete(record)
        }
        try context.save()
    }
}

struct CachePolicy {
    var ttl: TimeInterval        // 例: 7 日
    var allowedModel: String     // 例: "gemini-2.5-pro"
    var schemaHash: String?      // structured output のスキーマが変わったら無効
    var forceRefresh: Bool       // ユーザーが「再生成」を押したら true
}
 
@MainActor
final class GeminiResponder {
    private let store: ResponseCacheStore
    private let client: GeminiClient
 
    init(store: ResponseCacheStore, client: GeminiClient) {
        self.store = store
        self.client = client
    }
 
    func respond(prompt: String, policy: CachePolicy) async throws -> String {
        let key = CacheKeyBuilder.make(
            prompt: prompt,
            model: policy.allowedModel,
            schemaJSON: policy.schemaHash
        )
 
        if !policy.forceRefresh,
           let cached = try store.find(key: key),
           cached.modelName == policy.allowedModel,
           cached.responseSchemaHash == policy.schemaHash,
           cached.createdAt.timeIntervalSinceNow > -policy.ttl {
            return cached.responseText
        }
 
        let result = try await client.generate(
            prompt: prompt,
            model: policy.allowedModel
        )
 
        let record = CachedGeminiResponse(
            cacheKey: key,
            promptDigest: String(prompt.prefix(200)),
            modelName: policy.allowedModel,
            responseText: result.text,
            responseSchemaHash: policy.schemaHash,
            inputTokens: result.usage.input,
            outputTokens: result.usage.output,
            finishReason: result.finishReason
        )
        try store.upsert(record)
        return result.text
    }
}

import Network
 
actor ConnectivityMonitor {
    private var isOnline: Bool = true
    private let monitor = NWPathMonitor()
 
    init() {
        monitor.pathUpdateHandler = { [weak self] path in
            Task { await self?.update(isOnline: path.status == .satisfied) }
        }
        monitor.start(queue: .global(qos: .background))
    }
 
    func currentlyOnline() -> Bool { isOnline }
    private func update(isOnline: Bool) { self.isOnline = isOnline }
}

enum CacheSchemaV1: VersionedSchema {
    static var versionIdentifier = Schema.Version(1, 0, 0)
    static var models: [any PersistentModel.Type] { [CachedGeminiResponse.self] }
}
 
enum CacheSchemaV2: VersionedSchema {
    static var versionIdentifier = Schema.Version(2, 0, 0)
    static var models: [any PersistentModel.Type] { [CachedGeminiResponse.self] }
}
 
enum CacheMigrationPlan: SchemaMigrationPlan {
    static var schemas: [any VersionedSchema.Type] {
        [CacheSchemaV1.self, CacheSchemaV2.self]
    }
    static var stages: [MigrationStage] {
        [.lightweight(fromVersion: CacheSchemaV1.self, toVersion: CacheSchemaV2.self)]
    }
}
 
let container = try ModelContainer(
    for: CachedGeminiResponse.self,
    migrationPlan: CacheMigrationPlan.self,
    configurations: ModelConfiguration(cloudKitDatabase: .none)
)