Build a basic iPhone app that generates a lesson plan with ChatGPT

LessonPlanBuilder (Xcode project)
  LessonPlanBuilderApp.swift
  ContentView.swift (replace)
  OpenAIClient.swift (new)
  OpenAIModels.swift (new)
  Secrets.xcconfig (Direct demo path; local only)

// DO NOT COMMIT THIS FILE.
// Add it to .gitignore.
// Direct-call demo only. For real apps, use a server/proxy.

OPENAI_API_KEY = sk-PASTE_YOUR_KEY_HERE

// Set a model string you have access to in your OpenAI project.
// Keep it in config so you can change later without code edits.
OPENAI_MODEL = gpt-5.2

import Foundation

// MARK: - Responses API request (minimal)
// POST https://api.openai.com/v1/responses
struct OpenAIResponsesRequest: Codable {
    let model: String
    let instructions: String?
    let input: String
    let max_output_tokens: Int?

    init(model: String, instructions: String? = nil, input: String, maxOutputTokens: Int? = 900) {
        self.model = model
        self.instructions = instructions
        self.input = input
        self.max_output_tokens = maxOutputTokens
    }
}

// MARK: - Responses API response (minimal parse)
// Responses API returns "output": [ ...items... ]
// One common item shape contains:
// { "type": "message", "content": [ { "type":"output_text", "text":"..." } ] }
struct OpenAIResponsesResponse: Codable {
    let id: String?
    let output: [OpenAIOutputItem]?
}

struct OpenAIOutputItem: Codable {
    let type: String?
    let content: [OpenAIContentItem]?
}

struct OpenAIContentItem: Codable {
    let type: String?
    let text: String?
}

import Foundation

enum OpenAIClientError: Error, LocalizedError {
    case missingConfig(String)
    case badURL
    case http(Int, String)
    case decode(String)

    var errorDescription: String? {
        switch self {
        case .missingConfig(let s): return s
        case .badURL: return "Bad URL."
        case .http(let code, let body): return "HTTP \(code): \(body)"
        case .decode(let s): return "Decode error: \(s)"
        }
    }
}

final class OpenAIClient {
    // Direct-call demo endpoint
    private let endpoint = URL(string: "https://api.openai.com/v1/responses")

    // Read values from Info.plist (which we map from Secrets.xcconfig)
    private var apiKey: String {
        (Bundle.main.object(forInfoDictionaryKey: "OPENAI_API_KEY") as? String)?
            .trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
    }

    private var model: String {
        (Bundle.main.object(forInfoDictionaryKey: "OPENAI_MODEL") as? String)?
            .trimmingCharacters(in: .whitespacesAndNewlines) ?? "gpt-5.2"
    }

    // IMPORTANT:
    // For Secrets.xcconfig values to be visible at runtime, you must map them into the target’s Info keys:
    // Target → Info tab:
    // OPENAI_API_KEY = $(OPENAI_API_KEY)
    // OPENAI_MODEL   = $(OPENAI_MODEL)

    func generateLessonPlan(grade: String, topic: String, minutes: Int, standards: String, constraints: String) async throws -> String {
        guard let url = endpoint else { throw OpenAIClientError.badURL }
        if apiKey.isEmpty {
            throw OpenAIClientError.missingConfig("Missing OPENAI_API_KEY. Set it in Secrets.xcconfig and map it into Target → Info.")
        }
        if model.isEmpty {
            throw OpenAIClientError.missingConfig("Missing OPENAI_MODEL. Set it in Secrets.xcconfig and map it into Target → Info.")
        }

        let sys = """
You are an expert instructional designer. Produce a practical lesson plan that a teacher can run immediately.
Output must be plain text with headings. No markdown code fences. No references to policies.
"""

        let input = buildPrompt(grade: grade, topic: topic, minutes: minutes, standards: standards, constraints: constraints)

        let reqBody = OpenAIResponsesRequest(
            model: model,
            instructions: sys,
            input: input,
            maxOutputTokens: 900
        )

        var req = URLRequest(url: url)
        req.httpMethod = "POST"
        req.setValue("application/json", forHTTPHeaderField: "Content-Type")
        req.setValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
        req.httpBody = try JSONEncoder().encode(reqBody)

        let (data, resp) = try await URLSession.shared.data(for: req)
        guard let http = resp as? HTTPURLResponse else {
            throw OpenAIClientError.http(-1, "No HTTP response.")
        }

        if !(200...299).contains(http.statusCode) {
            let body = String(data: data, encoding: .utf8) ?? ""
            throw OpenAIClientError.http(http.statusCode, String(body.prefix(1600)))
        }

        do {
            let decoded = try JSONDecoder().decode(OpenAIResponsesResponse.self, from: data)
            let text = extractOutputText(decoded)
            if text.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
                return "No text returned. Check model access and response format."
            }
            return text
        } catch {
            let raw = String(data: data, encoding: .utf8) ?? ""
            throw OpenAIClientError.decode("Could not decode Responses API payload. Raw: \(raw.prefix(1600))")
        }
    }

    private func extractOutputText(_ resp: OpenAIResponsesResponse) -> String {
        let items = resp.output ?? []
        var parts: [String] = []
        for item in items {
            let content = item.content ?? []
            for c in content {
                if c.type == "output_text", let t = c.text, !t.isEmpty {
                    parts.append(t)
                }
            }
        }
        return parts.joined(separator: "\n")
    }

    private func buildPrompt(grade: String, topic: String, minutes: Int, standards: String, constraints: String) -> String {
        // Deterministic and workshop-friendly. This is not a general chatbot.
        var s = ""
        s += "Create a lesson plan.\n"
        s += "Grade band: \(grade)\n"
        s += "Topic: \(topic)\n"
        s += "Duration: \(minutes) minutes\n"
        if !standards.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
            s += "Standards (optional): \(standards)\n"
        }
        if !constraints.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
            s += "Constraints (optional): \(constraints)\n"
        }

        s += "\nOutput format (exact headings):\n"
        s += "1) Learning Objective\n"
        s += "2) Materials\n"
        s += "3) Warm-Up (5 min)\n"
        s += "4) Direct Instruction\n"
        s += "5) Guided Practice\n"
        s += "6) Independent Practice\n"
        s += "7) Differentiation\n"
        s += "8) Check for Understanding\n"
        s += "9) Exit Ticket\n"
        s += "10) Homework / Extension (optional)\n"

        s += "\nRules:\n"
        s += "- Use teacher-ready language.\n"
        s += "- Include approximate minute-by-minute pacing aligned to the total.\n"
        s += "- Provide at least 3 CFU questions.\n"
        s += "- Provide an exit ticket with 3 prompts.\n"
        return s
    }
}

import SwiftUI

struct ContentView: View {
    @State private var grade: String = "6–8"
    @State private var topic: String = "Photosynthesis"
    @State private var minutesText: String = "45"
    @State private var standards: String = ""
    @State private var constraints: String = "No worksheets; discussion + small group activity."

    @State private var output: String = "Ready."
    @State private var isBusy: Bool = false
    @State private var errorText: String = ""

    private let client = OpenAIClient()

    var body: some View {
        NavigationView {
            ScrollView {
                VStack(alignment: .leading, spacing: 12) {
                    header

                    GroupBox("Inputs") {
                        VStack(alignment: .leading, spacing: 10) {
                            Picker("Grade band", selection: $grade) {
                                Text("K–2").tag("K–2")
                                Text("3–5").tag("3–5")
                                Text("6–8").tag("6–8")
                                Text("9–12").tag("9–12")
                            }
                            .pickerStyle(.segmented)

                            TextField("Topic (example: Fractions, Civil War, Photosynthesis)", text: $topic)
                                .textFieldStyle(.roundedBorder)

                            TextField("Minutes (example: 45)", text: $minutesText)
                                .keyboardType(.numberPad)
                                .textFieldStyle(.roundedBorder)

                            TextField("Standards (optional)", text: $standards)
                                .textFieldStyle(.roundedBorder)

                            TextField("Constraints (optional)", text: $constraints)
                                .textFieldStyle(.roundedBorder)
                        }
                        .padding(.vertical, 6)
                    }

                    Button(action: generate) {
                        HStack {
                            Spacer()
                            Text(isBusy ? "Generating..." : "Generate lesson plan")
                                .fontWeight(.bold)
                            Spacer()
                        }
                    }
                    .buttonStyle(.borderedProminent)
                    .disabled(isBusy || topic.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty)

                    if !errorText.isEmpty {
                        Text(errorText)
                            .foregroundColor(.red)
                            .font(.footnote)
                            .padding(.top, 2)
                    }

                    GroupBox("Lesson plan output") {
                        Text(output)
                            .font(.system(.body, design: .default))
                            .textSelection(.enabled)
                            .frame(maxWidth: .infinity, alignment: .leading)
                            .padding(.vertical, 6)
                    }

                    GroupBox("Notes") {
                        VStack(alignment: .leading, spacing: 8) {
                            Text("• This app is a baseline demo: minimal UI, single request, single output.")
                            Text("• Demo-only: Direct API calls from mobile are not secure for real distribution.")
                            Text("• Real architecture: call your own proxy/server; keep the API key off-device.")
                            Text("• Do not enter sensitive student data.")
                        }
                        .font(.footnote)
                        .foregroundColor(.secondary)
                        .padding(.vertical, 6)
                    }
                }
                .padding()
            }
            .navigationTitle("Lesson Plan Builder")
        }
    }

    private var header: some View {
        VStack(alignment: .leading, spacing: 6) {
            Text("AI Lesson Plan Builder")
                .font(.title2).bold()
            Text("Enter inputs and generate a teacher-ready plan.")
                .foregroundColor(.secondary)
        }
    }

    private func generate() {
        errorText = ""
        output = "Working..."
        isBusy = true

        let minutes = Int(minutesText.trimmingCharacters(in: .whitespacesAndNewlines)) ?? 45
        let topicClean = topic.trimmingCharacters(in: .whitespacesAndNewlines)

        Task {
            do {
                let plan = try await client.generateLessonPlan(
                    grade: grade,
                    topic: topicClean,
                    minutes: max(10, min(minutes, 180)),
                    standards: standards,
                    constraints: constraints
                )
                await MainActor.run {
                    output = plan
                    isBusy = false
                }
            } catch {
                await MainActor.run {
                    errorText = (error as? LocalizedError)?.errorDescription ?? error.localizedDescription
                    output = "Failed."
                    isBusy = false
                }
            }
        }
    }
}

// In Xcode: select your TARGET → Info tab → add these rows:

OPENAI_API_KEY  (String)  $(OPENAI_API_KEY)
OPENAI_MODEL    (String)  $(OPENAI_MODEL)

# Never commit secrets
Secrets.xcconfig

// Cloudflare Worker: lesson-plan-proxy.js
// Store OPENAI_API_KEY as a Worker secret (not in code).
// This worker exposes: POST /lessonplan
// Client sends: { model, instructions, input, max_output_tokens }
// Worker forwards to: https://api.openai.com/v1/responses

export default {
  async fetch(request, env) {
    const url = new URL(request.url);

    if (url.pathname !== "/lessonplan") {
      return new Response("Not found", { status: 404 });
    }
    if (request.method !== "POST") {
      return new Response("Method not allowed", { status: 405 });
    }

    let body;
    try {
      body = await request.json();
    } catch {
      return new Response("Bad JSON", { status: 400 });
    }

    // Minimal validation
    const model = (body.model || "gpt-5.2").toString();
    const input = (body.input || "").toString();
    const instructions = (body.instructions || "").toString();
    const max_output_tokens = Number(body.max_output_tokens || 900);

    if (!input.trim()) {
      return new Response(JSON.stringify({ error: "Missing input" }), {
        status: 400,
        headers: { "Content-Type": "application/json" },
      });
    }

    const openaiResp = await fetch("https://api.openai.com/v1/responses", {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "Authorization": `Bearer ${env.OPENAI_API_KEY}`,
      },
      body: JSON.stringify({
        model,
        instructions: instructions || undefined,
        input,
        max_output_tokens,
      }),
    });

    const text = await openaiResp.text();
    return new Response(text, {
      status: openaiResp.status,
      headers: { "Content-Type": "application/json" },
    });
  },
};