Rork で Apple FoundationModels を使う — iOS 26 のオンデバイス LLM をプロダクトに組み込む実装ガイド

// FoundationModelsAvailability.swift
// アプリ起動直後 or 機能起動時に呼び出して、利用可否で UI を切り替える
import FoundationModels
 
enum LLMAvailability {
    case ready
    case appleIntelligenceOff   // 設定で無効化されている
    case downloading            // モデルファイルをダウンロード中
    case unsupportedDevice      // ハード非対応
    case unknown(String)
}
 
func checkLLMAvailability() -> LLMAvailability {
    let model = SystemLanguageModel.default
    switch model.availability {
    case .available:
        return .ready
    case .unavailable(let reason):
        switch reason {
        case .appleIntelligenceNotEnabled:
            return .appleIntelligenceOff
        case .modelNotReady:
            return .downloading
        case .deviceNotEligible:
            return .unsupportedDevice
        @unknown default:
            return .unknown(String(describing: reason))
        }
    }
}
 
// 期待される動作:
// iPhone 15 Pro / iOS 26+ かつ Apple Intelligence ON → .ready
// iPhone 13 → .unsupportedDevice
// 設定 OFF → .appleIntelligenceOff

// SimpleAskView.swift — 質問を投げて応答を表示する最小サンプル
import SwiftUI
import FoundationModels
 
struct SimpleAskView: View {
    @State private var prompt = ""
    @State private var answer = ""
    @State private var isLoading = false
    @State private var errorMessage: String?
 
    var body: some View {
        VStack(spacing: 16) {
            TextField("質問を入力", text: $prompt)
                .textFieldStyle(.roundedBorder)
            Button("送信") { Task { await ask() } }
                .disabled(prompt.isEmpty || isLoading)
            if let errorMessage { Text(errorMessage).foregroundStyle(.red) }
            ScrollView { Text(answer).padding() }
        }
        .padding()
    }
 
    @MainActor
    private func ask() async {
        isLoading = true
        defer { isLoading = false }
        errorMessage = nil
        do {
            let session = LanguageModelSession(instructions: "丁寧な日本語で簡潔に答えてください。")
            let response = try await session.respond(to: prompt)
            answer = response.content
        } catch {
            errorMessage = "応答に失敗しました: \(error.localizedDescription)"
        }
    }
}
 
// 期待される出力例:
// プロンプト: "Rork とは何ですか？"
// 応答: "Rork は AI を活用してアプリを生成するツールです。アイデアを伝えるだけで…"

// StreamingAskView.swift — チャンク単位で応答を表示する
import SwiftUI
import FoundationModels
 
@MainActor
final class StreamingAskViewModel: ObservableObject {
    @Published var partial = ""
    @Published var isStreaming = false
    @Published var errorMessage: String?
 
    private let session = LanguageModelSession(
        instructions: "丁寧な日本語で、3 段落以内で答えてください。"
    )
 
    func ask(prompt: String) async {
        partial = ""
        isStreaming = true
        errorMessage = nil
        defer { isStreaming = false }
        do {
            let stream = session.streamResponse(to: prompt)
            for try await snapshot in stream {
                // snapshot.content は累積された全文。差分ではなく全置換でよい
                partial = snapshot.content
            }
        } catch {
            errorMessage = "ストリーミングに失敗しました: \(error.localizedDescription)"
        }
    }
}
 
// 期待される動作:
// ユーザーが「Rork の長所を教えて」と送信 → 1 文字ずつテキストが追記されるように見える
// 平均で「初回の文字が表示されるまで」が 1.2 秒前後（A17 Pro 実測）

// TaskExtractor.swift — 自由記述から TODO の配列を生成する
import FoundationModels
 
@Generable
struct ExtractedTask {
    @Guide(description: "短いタスク名 (40 字以内)")
    let title: String
    @Guide(description: "優先度: high / medium / low のいずれか")
    let priority: String
    @Guide(description: "推奨される所要時間（分）。不明なら nil")
    let durationMinutes: Int?
}
 
@Generable
struct ExtractionResult {
    let tasks: [ExtractedTask]
}
 
func extractTasks(from memo: String) async throws -> [ExtractedTask] {
    let session = LanguageModelSession(
        instructions: "次のメモからタスクを抽出してください。日本語で返してください。"
    )
    let result = try await session.respond(
        to: memo,
        generating: ExtractionResult.self
    )
    return result.content.tasks
}
 
// 期待される入力 / 出力:
// 入力: "明日までに発表資料を仕上げる。買い物も。歯医者は来週。"
// 出力:
//   ExtractedTask(title: "発表資料を仕上げる", priority: "high", durationMinutes: 90)
//   ExtractedTask(title: "買い物", priority: "medium", durationMinutes: nil)
//   ExtractedTask(title: "歯医者の予約", priority: "low", durationMinutes: nil)

// TimerTool.swift — モデルから呼び出されるタイマーツール
import FoundationModels
 
struct TimerTool: Tool {
    let name = "scheduleTimer"
    let description = "ユーザーが指定した秒数後にローカル通知を発火します"
 
    @Generable
    struct Arguments {
        @Guide(description: "通知までの秒数 (1 〜 86400)")
        let seconds: Int
        @Guide(description: "通知に表示するタイトル")
        let title: String
    }
 
    @Generable
    struct Output {
        let scheduled: Bool
        let firesAt: String   // ISO 8601
    }
 
    func call(arguments: Arguments) async throws -> Output {
        guard (1...86400).contains(arguments.seconds) else {
            throw NSError(
                domain: "TimerTool",
                code: 1,
                userInfo: [NSLocalizedDescriptionKey: "秒数の範囲外です"]
            )
        }
        let fireDate = Date().addingTimeInterval(TimeInterval(arguments.seconds))
        await NotificationScheduler.shared.schedule(at: fireDate, title: arguments.title)
        let iso = ISO8601DateFormatter().string(from: fireDate)
        return Output(scheduled: true, firesAt: iso)
    }
}
 
// 利用例
let session = LanguageModelSession(tools: [TimerTool()])
let response = try await session.respond(
    to: "10 分後に『お風呂を見る』で通知して"
)
 
// 期待される動作:
// モデルは内部で TimerTool.call(.init(seconds: 600, title: "お風呂を見る")) を呼び、
// Output(scheduled: true, firesAt: "2026-04-26T20:25:00Z") を受け取り、
// 「10 分後に『お風呂を見る』で通知をセットしました」のような自然文を返す

// LLMRouter.swift — 入力の性質で端末側 / クラウドを振り分ける
import FoundationModels
 
enum LLMRoute { case onDevice, cloud }
 
struct RouterRequest {
    let kind: Kind
    let inputCharacters: Int
    let needsFreshness: Bool
    enum Kind { case extract, classify, summarise, rewrite, freeform }
}
 
func chooseRoute(for request: RouterRequest) -> LLMRoute {
    if request.needsFreshness { return .cloud }
    if request.kind == .freeform { return .cloud }
    if request.inputCharacters > 1500 { return .cloud }
    if checkLLMAvailability() != .ready { return .cloud }
    return .onDevice
}
 
// 期待される動作:
// 500 字のメモから TODO を抽出する → .onDevice
// 1000 字の記事を書く             → .cloud
// 「昨日 Apple は何を発表した？」  → .cloud（needsFreshness）
// iPhone 13 で実行                → .cloud（availability で弾かれる）