13. Real Use Cases

import FoundationModels

// Setiap "agent" adalah session dengan instruksi spesifik
actor DocumentProcessingPipeline {
    // Agent 1: Ekstraksi struktur dokumen
    private let structureAgent = LanguageModelSession(
        instructions: Instructions("""
        Kamu spesialis mengidentifikasi struktur dokumen.
        Ekstrak: judul, seksi, dan hierarki konten.
        Jangan menganalisis konten — hanya struktur.
        """)
    )

    // Agent 2: Analisis konten per seksi
    private let contentAgent = LanguageModelSession(
        instructions: Instructions("""
        Kamu analis konten teknis.
        Beri rating kompleksitas dan identifikasi konsep kunci.
        Respons singkat dan terstruktur.
        """)
    )

    // Agent 3: Quality check dan summary akhir
    private let qcAgent = LanguageModelSession(
        instructions: Instructions("""
        Kamu quality assurance untuk analisis dokumen.
        Verifikasi konsistensi analisis dan buat summary eksekutif.
        """)
    )

    @Generable
    struct DocumentStructure {
        @Guide(description: "Judul dokumen")
        var title: String
        @Guide(description: "Daftar nama seksi utama")
        var sections: [String]
        @Guide(description: "Tipe dokumen: technical, business, legal, atau educational")
        var documentType: String
    }

    @Generable
    struct SectionAnalysis {
        @Guide(description: "Nama seksi")
        var sectionName: String
        @Guide(description: "Konsep kunci yang dibahas, maksimal 4")
        var keyConcepts: [String]
        @Guide(description: "Kompleksitas: beginner, intermediate, atau advanced")
        var complexity: String
    }

    @Generable
    struct ProcessedDocument {
        @Guide(description: "Judul dokumen")
        var title: String
        @Guide(description: "Ringkasan eksekutif 2-3 kalimat")
        var executiveSummary: String
        @Guide(description: "Skor kualitas keseluruhan dari 1 sampai 10")
        var qualityScore: Int
        @Guide(description: "Rekomendasi pembaca target")
        var targetAudience: String
    }

    func process(document: String) async throws -> ProcessedDocument {
        // Step 1: Ekstrak struktur
        let structure = try await structureAgent.respond(
            to: "Analisis struktur dokumen:\n\n\(document.truncatedForAI(maxCharacters: 2000))",
            generating: DocumentStructure.self
        ).content

        // Step 2: Analisis setiap seksi (paralel untuk performa)
        var sectionAnalyses: [SectionAnalysis] = []
        try await withThrowingTaskGroup(of: SectionAnalysis.self) { group in
            for section in structure.sections.prefix(5) {
                group.addTask {
                    // Session baru per analisis — stateless untuk task ini
                    let session = LanguageModelSession(
                        instructions: Instructions("Kamu analis konten teknis. Respons singkat dan terstruktur.")
                    )
                    return try await session.respond(
                        to: "Analisis seksi '\(section)' dari dokumen \(structure.documentType):",
                        generating: SectionAnalysis.self
                    ).content
                }
            }
            for try await analysis in group {
                sectionAnalyses.append(analysis)
            }
        }

        // Step 3: QC dan final summary
        let analysisContext = sectionAnalyses.map {
            "Seksi '\($0.sectionName)': \($0.keyConcepts.joined(separator: ", ")), level \($0.complexity)"
        }.joined(separator: "\n")

        return try await qcAgent.respond(
            to: """
            Buat laporan akhir untuk dokumen '\(structure.title)'.
            Tipe: \(structure.documentType)
            Analisis seksi:\n\(analysisContext)
            """,
            generating: ProcessedDocument.self
        ).content
    }
}

import FoundationModels

@Generable
struct ExtractedFormData {
    @Guide(description: "Nama lengkap dari teks pengguna")
    var fullName: String

    @Guide(description: "Tanggal lahir dalam format YYYY-MM-DD, nil jika tidak disebutkan")
    var birthDate: String?

    @Guide(description: "Nomor KTP 16 digit, nil jika tidak ada")
    var nationalId: String?

    @Guide(description: "Kota domisili saat ini")
    var city: String

    @Guide(description: "Pekerjaan atau profesi")
    var occupation: String

    @Guide(description: "Field yang masih kosong atau tidak jelas yang perlu ditanyakan ke user")
    var missingFields: [String]
}

@Observable
class SmartFormViewModel {
    var userNarrative = ""
    var extractedData: ExtractedFormData?
    var clarificationQuestion = ""
    var isProcessing = false

    private let session = LanguageModelSession(
        instructions: Instructions("""
        Kamu membantu mengisi formulir registrasi dari deskripsi pengguna.
        Ekstrak informasi sebanyak mungkin dari narasi.
        Identifikasi field yang masih kurang untuk ditanyakan.
        Gunakan bahasa yang ramah dan natural saat meminta klarifikasi.
        """)
    )

    func processNarrative() async {
        guard !userNarrative.trimmingCharacters(in: .whitespaces).isEmpty else { return }
        isProcessing = true
        defer { isProcessing = false }

        do {
            // Ekstrak data dari narasi
            let extracted = try await session.respond(
                to: "Ekstrak data formulir dari narasi pengguna:\n\"\(userNarrative)\"",
                generating: ExtractedFormData.self
            ).content
            extractedData = extracted

            // Jika ada field kosong, minta klarifikasi
            if !extracted.missingFields.isEmpty {
                clarificationQuestion = try await session.respond(
                    to: "Buat satu pertanyaan natural untuk mendapatkan: \(extracted.missingFields.joined(separator: " dan "))"
                ).content
            }
        } catch {
            clarificationQuestion = "Maaf, terjadi kesalahan. Bisa ceritakan ulang informasi Anda?"
        }
    }

    func submitClarification(_ answer: String) async {
        userNarrative += " \(answer)"
        await processNarrative()
    }
}

import FoundationModels

@Generable
enum IssueSeverity: String {
    case critical, warning, suggestion, info
}

@Generable
struct CodeIssue {
    @Guide(description: "Deskripsi masalah yang ditemukan")
    var description: String

    @Guide(description: "Tingkat keparahan")
    var severity: IssueSeverity

    @Guide(description: "Baris atau fungsi yang bermasalah")
    var location: String

    @Guide(description: "Saran perbaikan konkret")
    var suggestion: String
}

@Generable
struct CodeReview {
    @Guide(description: "Daftar masalah yang ditemukan, kosong jika tidak ada")
    var issues: [CodeIssue]

    @Guide(description: "Poin positif dari kode yang sudah baik")
    var positives: [String]

    @Guide(description: "Skor kualitas keseluruhan 1-10")
    var score: Int

    @Guide(description: "Apakah kode siap untuk review lanjut atau perlu revisi dulu")
    var readyForMerge: Bool
}

actor CodeReviewSession {
    private let session: LanguageModelSession
    private var reviewedFiles: [String] = []

    init(projectContext: String) {
        session = LanguageModelSession(
            instructions: Instructions("""
            Kamu senior Swift/iOS engineer melakukan code review.
            Konteks project: \(projectContext)
            
            Fokus pada: Swift best practices, memory safety, concurrency, performance.
            Berikan feedback yang konstruktif dan actionable.
            Ingat file-file yang sudah kamu review untuk konsistensi.
            """)
        )
    }

    func review(fileName: String, code: String) async throws -> CodeReview {
        reviewedFiles.append(fileName)

        let context = reviewedFiles.count > 1
            ? "File yang sudah direviu sebelumnya: \(reviewedFiles.dropLast().joined(separator: ", "))\n\n"
            : ""

        return try await session.respond(
            to: "\(context)Review file '\(fileName)':\n\n```swift\n\(code)\n```",
            generating: CodeReview.self
        ).content
    }

    func askFollowUp(question: String) async throws -> String {
        try await session.respond(to: question).content
    }

    func generateConsolidatedReport() async throws -> String {
        let files = reviewedFiles.joined(separator: ", ")
        return try await session.respond(
            to: "Buat laporan konsolidasi dari semua file yang sudah direviu (\(files)). Highlight pattern masalah yang berulang dan rekomendasi prioritas."
        ).content
    }
}

// Penggunaan
let reviewer = CodeReviewSession(projectContext: "App e-commerce iOS dengan SwiftUI + SwiftData")

let reviewResult1 = try await reviewer.review(
    fileName: "CartViewModel.swift",
    code: cartViewModelCode
)

let reviewResult2 = try await reviewer.review(
    fileName: "CheckoutService.swift",
    code: checkoutServiceCode
)

// Session ingat konteks dari review sebelumnya
let followUp = try await reviewer.askFollowUp(
    "Apakah CartViewModel dan CheckoutService sudah thread-safe secara konsisten?"
)

let finalReport = try await reviewer.generateConsolidatedReport()