rshankras/claude-code-apple-skills/foundation-models

import FoundationModels
 
struct IntelligentView: View {
    private var model = SystemLanguageModel.default
 
    var body: some View {
        switch model.availability {
        case .available:
            ContentView()
        case .unavailable(.deviceNotEligible):
            UnsupportedDeviceView()
        case .unavailable(.appleIntelligenceNotEnabled):
            EnableIntelligenceView()
        case .unavailable(.modelNotReady):
            ModelDownloadingView()
        case .unavailable(let reason):
            ErrorView(reason: reason)
        }
    }
}

// Simple session
let session = LanguageModelSession()
 
// Session with instructions
let session = LanguageModelSession(instructions: """
    You are a helpful cooking assistant.
    Provide concise, practical advice for home cooks.
    """)

let response = try await session.respond(to: "What's a quick dinner idea?")
print(response.content)

[Role] + [Task] + [Style] + [Safety]

let instructions = """
    You are a fitness coach specializing in home workouts.
    Help users create exercise routines based on their equipment and goals.
    Keep responses under 100 words and use bullet points for exercises.
    Decline requests for medical advice and suggest consulting a doctor.
    """

let prompt = "What are three ways to reduce food waste at home?"

let prompt = "Create a weekly meal plan for a family of four, budget-friendly."

let prompt = """
    Extract the following from this email:
    - Sender name
    - Meeting date
    - Action items
 
    Email: \(emailContent)
    """

let prompt = "Rewrite this text to be more formal: \(casualText)"

@Generable(description: "A recipe suggestion")
struct Recipe {
    var name: String
 
    @Guide(description: "Cooking time in minutes", .range(5...180))
    var cookingTime: Int
 
    @Guide(description: "Difficulty level", .options(["Easy", "Medium", "Hard"]))
    var difficulty: String
 
    @Guide(description: "List of ingredients", .count(3...15))
    var ingredients: [String]
 
    @Guide(description: "Step-by-step instructions")
    var instructions: [String]
}

let session = LanguageModelSession(instructions: """
    You are a recipe assistant. Generate practical, home-cook friendly recipes.
    """)
 
let recipe = try await session.respond(
    to: "Suggest a quick pasta dish",
    generating: Recipe.self
)
 
print("Recipe: \(recipe.content.name)")
print("Time: \(recipe.content.cookingTime) minutes")
print("Ingredients: \(recipe.content.ingredients.joined(separator: ", "))")

@Generable(description: "A travel itinerary")
struct Itinerary {
    var destination: String
 
    @Guide(description: "Daily activities for the trip")
    var days: [DayPlan]
}
 
@Generable(description: "Activities for one day")
struct DayPlan {
    var dayNumber: Int
 
    @Guide(description: "Morning activity")
    var morning: String
 
    @Guide(description: "Afternoon activity")
    var afternoon: String
 
    @Guide(description: "Evening activity")
    var evening: String
}

struct WeatherTool: Tool {
    let name = "getWeather"                              // verb, short, no abbreviations
    let description = "Get current weather for a location"  // ~one sentence
 
    @Generable
    struct Arguments {
        @Guide(description: "City name")
        var location: String
    }
 
    func call(arguments: Arguments) async throws -> ToolOutput {
        let weather = await WeatherService.shared.fetch(for: arguments.location)
        return ToolOutput("Temperature: \(weather.temp)°F, Conditions: \(weather.conditions)")
    }
}

let weatherTool = WeatherTool()
let session = LanguageModelSession(
    instructions: "You help users plan outdoor activities based on weather.",
    tools: [weatherTool]
)
 
// Model automatically calls tool when needed
let response = try await session.respond(
    to: "Should I go hiking in San Francisco today?"
)

do {
    let response = try await session.respond(to: prompt)
} catch let error as LanguageModelSession.ToolCallError {
    print("Tool '\(error.tool.name)' failed: \(error.underlyingError)")
} catch {
    print("Generation error: \(error)")
}

@Generable
struct StoryIdea {
    var title: String
 
    @Guide(description: "A brief plot summary")
    var plot: String
 
    @Guide(description: "Main characters", .count(2...4))
    var characters: [String]
}
 
struct StreamingView: View {
    @State private var partial: StoryIdea.PartiallyGenerated?
    @State private var isGenerating = false
 
    var body: some View {
        VStack(alignment: .leading) {
            if let partial {
                if let title = partial.title {
                    Text(title).font(.headline)
                }
                if let plot = partial.plot {
                    Text(plot)
                }
                if let characters = partial.characters {
                    ForEach(characters, id: \.self) { char in
                        Text("• \(char)")
                    }
                }
            }
 
            Button("Generate Story Idea") {
                Task { await generateStory() }
            }
            .disabled(isGenerating)
        }
    }
 
    func generateStory() async {
        isGenerating = true
        defer { isGenerating = false }
 
        let session = LanguageModelSession()
        let stream = session.streamResponse(
            to: "Create a sci-fi story idea",
            generating: StoryIdea.self
        )
 
        for try await snapshot in stream {
            partial = snapshot
        }
    }
}

@Observable
final class ChatViewModel {
    private var session: LanguageModelSession?
    var messages: [ChatMessage] = []
 
    func startConversation() {
        session = LanguageModelSession(instructions: """
            You are a helpful assistant. Remember context from earlier in our conversation.
            """)
    }
 
    func send(_ message: String) async throws {
        guard let session else { return }
 
        messages.append(ChatMessage(role: .user, content: message))
 
        let response = try await session.respond(to: message)
 
        messages.append(ChatMessage(role: .assistant, content: response.content))
    }
}