OTA 模型更新：保持裝置端 AI 始終最新

{
  "current_version": "2.1.0",
  "models": {
    "1b": {
      "url": "https://cdn.example.com/models/v2.1.0/model-1b-q4.gguf",
      "size_bytes": 612000000,
      "sha256": "a1b2c3d4e5f6...",
      "min_app_version": "3.0.0",
      "release_notes": "Improved classification accuracy"
    },
    "3b": {
      "url": "https://cdn.example.com/models/v2.1.0/model-3b-q4.gguf",
      "size_bytes": 1740000000,
      "sha256": "f6e5d4c3b2a1...",
      "min_app_version": "3.0.0",
      "release_notes": "Better conversation quality"
    }
  },
  "rollback_version": "2.0.0",
  "rollback_url_1b": "https://cdn.example.com/models/v2.0.0/model-1b-q4.gguf",
  "rollback_url_3b": "https://cdn.example.com/models/v2.0.0/model-3b-q4.gguf"
}

[應用程式啟動] -> [從 CDN 取得清單]
  -> [比較本地版本和清單版本]
  -> [如果有更新版本]:
      -> [檢查 WiFi + 足夠儲存空間]
      -> [背景下載新模型]
      -> [驗證 SHA256]
      -> [下次工作階段啟動時切換模型]
  -> [如果版本一致]: [無操作]

// iOS：檢查模型更新
class ModelUpdater {
    private let manifestURL = URL(string: "https://cdn.example.com/manifest.json")!

    func checkForUpdate() async -> ModelUpdate? {
        guard let data = try? await URLSession.shared.data(from: manifestURL).0,
              let manifest = try? JSONDecoder().decode(ModelManifest.self, from: data)
        else { return nil }

        let currentVersion = UserDefaults.standard.string(forKey: "model_version") ?? "0.0.0"

        if manifest.currentVersion > currentVersion {
            return ModelUpdate(
                version: manifest.currentVersion,
                url: manifest.models[selectedTier]!.url,
                size: manifest.models[selectedTier]!.sizeBytes,
                hash: manifest.models[selectedTier]!.sha256
            )
        }
        return nil
    }
}

// Android：應用程式啟動時檢查更新
class ModelUpdater(private val context: Context) {
    suspend fun checkForUpdate(): ModelUpdate? = withContext(Dispatchers.IO) {
        val manifest = fetchManifest() ?: return@withContext null
        val currentVersion = prefs.getString("model_version", "0.0.0")

        if (manifest.currentVersion > currentVersion) {
            val model = manifest.models[selectedTier]
            ModelUpdate(
                version = manifest.currentVersion,
                url = model.url,
                sizeBytes = model.sizeBytes,
                sha256 = model.sha256
            )
        } else null
    }
}

func downloadUpdate(_ update: ModelUpdate) {
    let config = URLSessionConfiguration.background(
        withIdentifier: "com.app.model-download"
    )
    let session = URLSession(configuration: config, delegate: self, delegateQueue: nil)
    let task = session.downloadTask(with: update.url)
    task.resume()
}

// 即使應用程式被掛起，Delegate 也會處理完成事件
func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask,
                didFinishDownloadingTo location: URL) {
    let destination = modelDirectory.appendingPathComponent("model-new.gguf")
    try? FileManager.default.moveItem(at: location, to: destination)

    if verifyHash(destination, expected: pendingUpdate.sha256) {
        // 下次工作階段啟動時切換
        UserDefaults.standard.set(pendingUpdate.version, forKey: "pending_model_version")
    } else {
        try? FileManager.default.removeItem(at: destination)
    }
}

class ModelDownloadWorker(
    context: Context, params: WorkerParameters
) : CoroutineWorker(context, params) {

    override suspend fun doWork(): Result {
        val url = inputData.getString("url") ?: return Result.failure()
        val expectedHash = inputData.getString("hash") ?: return Result.failure()

        val tempFile = File(applicationContext.cacheDir, "model-new.gguf")

        // 下載
        downloadFile(url, tempFile) { progress ->
            setProgress(workDataOf("progress" to progress))
        }

        // 驗證
        if (tempFile.sha256() != expectedHash) {
            tempFile.delete()
            return Result.failure()
        }

        // 暫存待切換
        val destination = File(applicationContext.filesDir, "model-pending.gguf")
        tempFile.renameTo(destination)

        return Result.success()
    }
}

// 排程下載
fun scheduleModelDownload(url: String, hash: String) {
    val request = OneTimeWorkRequestBuilder<ModelDownloadWorker>()
        .setConstraints(
            Constraints.Builder()
                .setRequiredNetworkType(NetworkType.UNMETERED) // 僅 WiFi
                .setRequiresStorageNotLow(true)
                .build()
        )
        .setInputData(workDataOf("url" to url, "hash" to hash))
        .build()

    WorkManager.getInstance(context).enqueue(request)
}

func swapModelIfPending() throws {
    let pendingPath = modelDirectory.appendingPathComponent("model-pending.gguf")
    let currentPath = modelDirectory.appendingPathComponent("model-current.gguf")
    let previousPath = modelDirectory.appendingPathComponent("model-previous.gguf")

    guard FileManager.default.fileExists(atPath: pendingPath.path) else { return }

    // 卸載當前模型
    engine.unload()

    // 輪轉檔案
    try? FileManager.default.removeItem(at: previousPath) // 移除舊備份
    try? FileManager.default.moveItem(at: currentPath, to: previousPath) // 備份當前
    try FileManager.default.moveItem(at: pendingPath, to: currentPath) // 提升待切換

    // 嘗試載入新模型
    do {
        try engine.load(at: currentPath.path)
        // 成功：更新版本號
        UserDefaults.standard.set(pendingVersion, forKey: "model_version")
    } catch {
        // 回滾
        try? FileManager.default.removeItem(at: currentPath)
        try? FileManager.default.moveItem(at: previousPath, to: currentPath)
        try engine.load(at: currentPath.path)
    }
}