Slogan generator iOS app

┌─────────────────────────────────┐
│      SwiftUI View Layer         │ ← User Interface
│  (ContentView, UI Components)   │
└────────────┬────────────────────┘
             │
┌────────────▼────────────────────┐
│     ViewModel Layer             │ ← Business Logic
│  (SloganViewModel, @Observable) │
└────────────┬────────────────────┘
             │
┌────────────▼────────────────────┐
│      LeapSDK Layer              │ ← AI Inference
│  (ModelRunner, Conversation)    │
└─────────────────────────────────┘

1. User enters "coffee shop" and taps Generate
   ↓
2. UI disables input and shows "Generating..."
   ↓
3. ViewModel creates prompt with business type
   ↓
4. ChatMessage is sent to Conversation
   ↓
5. LeapSDK starts model inference
   ↓
6. Tokens stream back one-by-one
   ├─ "Wake" → UI updates
   ├─ " up" → UI updates
   ├─ " to" → UI updates
   ├─ " flavor" → UI updates
   └─ "!" → UI updates
   ↓
7. .complete event fires
   ↓
8. UI re-enables input, shows final slogan

import Foundation
import SwiftUI
import LeapSDK
import Observation

@Observable
class SloganViewModel {
    // MARK: - Published State
    var isModelLoading = true
    var isGenerating = false
    var generatedSlogan = ""
    var errorMessage: String?
    
    // MARK: - Private Properties
    private var modelRunner: ModelRunner?
    private var conversation: Conversation?
    
    // MARK: - Initialization
    init() {
        // Model will be loaded when view appears
    }
    
    // MARK: - Model Management
    @MainActor
    func setupModel() async {
        isModelLoading = true
        errorMessage = nil
        
        do {
            guard let modelURL = Bundle.main.url(
                forResource: "qwen-0.6b",  // Change to match your bundle name
                withExtension: "bundle"
            ) else {
                errorMessage = "Model bundle not found in app bundle"
                isModelLoading = false
                return
            }
            
            modelRunner = try await Leap.load(url: modelURL)
            conversation = Conversation(
                modelRunner: modelRunner!,
                history: []
            )
            
            isModelLoading = false
        } catch {
            errorMessage = "Failed to load model: \(error.localizedDescription)"
            isModelLoading = false
        }
    }
    
    // MARK: - Generation
    @MainActor
    func generateSlogan(for businessType: String) async {
        guard let conversation = conversation,
              !isGenerating else { return }
        
        isGenerating = true
        generatedSlogan = ""
        errorMessage = nil
        
        let prompt = """
        Create a catchy, memorable slogan for a \(businessType) business. \
        Make it creative, concise, and impactful. \
        Return only the slogan, nothing else.
        """
        
        let userMessage = ChatMessage(
            role: .user,
            content: [.text(prompt)]
        )
        
        let stream = conversation.generateResponse(message: userMessage)
        
        do {
            for await response in stream {
                switch response {
                case .chunk(let text):
                    generatedSlogan += text
                    
                case .reasoningChunk(let reasoning):
                    print("Reasoning: \(reasoning)")
                    
                case .complete(let usage, let completeInfo):
                    print("✅ Generation complete!")
                    print("Tokens used: \(usage.totalTokens)")
                    isGenerating = false
                }
            }
        } catch {
            errorMessage = "Generation failed: \(error.localizedDescription)"
            isGenerating = false
        }
    }
}