Agentic App Experiences with Dynamic Profiles

import FoundationModels
import SwiftUI

// MARK: - Session Property for shared summary
extension SessionPropertyValues {
    @SessionPropertyEntry var conversationSummary: String? = nil
}

// MARK: - Reusable DynamicInstructions component
struct CraftExpert: DynamicInstructions {
    var body: some DynamicInstructions {
        Instructions("You are an expert in paper crafts and textile arts.")
    }
}

// MARK: - Orchestrator using DynamicProfile
@Observable
class CraftOrchestrator {
    enum Mode { case brainstorm, review }
    var mode: Mode = .brainstorm
    var session: LanguageModelSession

    init() {
        session = LanguageModelSession {
            DynamicProfile { [mode] in
                switch mode {
                case .brainstorm:
                    CraftExpert()
                    Instructions("Suggest 3 creative craft project ideas based on the user's input.")
                    ModelConfiguration(PrivateCloudComputeLanguageModel.default)
                    Temperature(1.0)

                case .review:
                    CraftExpert()
                    Instructions("Give concise technique advice based on the user's in-progress photo description.")
                    ModelConfiguration(SystemLanguageModel.default)
                    // Trim history to tool calls only to stay within on-device context
                    HistoryTransform { entries in
                        entries.filter { $0.role != .tool }
                    }
                }
            }
            .onResponse { context in
                // After brainstorm response, store a summary and switch to review
                if context.session.properties.conversationSummary == nil {
                    context.session.properties.conversationSummary = "User brainstormed craft ideas."
                }
            }
        }
    }

    func brainstorm(prompt: String) async throws -> String {
        mode = .brainstorm
        let response = try await session.respond(to: prompt)
        return response.content
    }

    func review(prompt: String) async throws -> String {
        mode = .review
        let response = try await session.respond(to: prompt)
        return response.content
    }
}

// MARK: - SwiftUI View
struct CraftOrchestratorView: View {
    @State private var orchestrator = CraftOrchestrator()
    @State private var output = "Tap a button to start."
    @State private var isLoading = false

    var body: some View {
        VStack(spacing: 20) {
            Text(output)
                .padding()
                .frame(maxWidth: .infinity, alignment: .leading)
                .background(.secondarySystemBackground)
                .clipShape(RoundedRectangle(cornerRadius: 12))

            if isLoading { ProgressView() }

            Button("Brainstorm Ideas") {
                Task {
                    isLoading = true
                    output = (try? await orchestrator.brainstorm(
                        prompt: "I have coloured paper and yarn. What can I make?"
                    )) ?? "Error"
                    isLoading = false
                }
            }.buttonStyle(.borderedProminent)

            Button("Get Technique Advice") {
                Task {
                    isLoading = true
                    output = (try? await orchestrator.review(
                        prompt: "My paper crane wings look uneven. What should I check?"
                    )) ?? "Error"
                    isLoading = false
                }
            }.buttonStyle(.bordered)
        }
        .padding()
    }
}