iOS SDK — RoadieKit

dependencies: [
    .package(url: "https://github.com/paroaria/roadiekit.git", from: "0.2.0"),
],
targets: [
    .target(name: "YourApp", dependencies: [
        .product(name: "RoadieKit", package: "roadiekit"),
    ]),
]

import RoadieKit

func makeRoadie() -> Roadie {
    let config = RoadieConfig(
        baseURL: URL(string: "https://gateway.roadie.paroaria.ai")!,
        publishableKey: "rd_pk_…"   // used only by App Attest device auth
    )

    let tokenProvider: any TokenProvider
    if let token = ProcessInfo.processInfo.environment["ROADIE_STATIC_TOKEN"],
       !token.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
        // Local dev / simulator: an rd_sk_… secret key or a pre-minted client token.
        tokenProvider = StaticTokenProvider(token: token)
    } else {
        // Production: App Attest silently mints a per-device client token.
        tokenProvider = AppAttestTokenProvider(config: config)
    }

    return Roadie(config: config, tokenProvider: tokenProvider)
}

let roadie = makeRoadie()

let response = try await roadie.chat.create(
    ChatRequest(
        model: "openai/gpt-4o",
        messages: [
            .system("You are a concise assistant."),
            .user("Give me one tip for shipping an iOS app."),
        ]
    )
)

print(response.text)                // the assistant reply
print(response.usage.totalTokens)   // token accounting

var reply = ""
for try await event in roadie.chat.stream(
    ChatRequest(model: "openai/gpt-4o", messages: [.user("Write a haiku about Swift.")])
) {
    switch event {
    case .contentDelta(let chunk):
        reply += chunk                       // append to your UI
    case .messageEnd(let finishReason, let usage, let cost):
        break                                // finished normally
    case .error(let error):
        throw error                          // a mid-stream failure — terminal
    case .messageStart, .toolCallDelta, .usage:
        break
    }
}

let response = try await roadie.embeddings.create(
    EmbeddingRequest(model: "openai/text-embedding-3-small", input: ["hello", "world"])
)

let vectors = response.vectors      // [[Double]] — one per input, in input order

// `sourceImage` and `mask` are PNG bytes (Data). `mask` may be nil.
let outputPNG: Data = try await roadie.images.edit(
    image: sourceImage,
    mask: mask,
    prompt: "Replace the background with a sunlit forest.",
    size: .auto,
    background: .transparent,
    quality: .high
)

let image = UIImage(data: outputPNG)

let png = try await roadie.images.generate(
    prompt: "A watercolor fox on a transparent background.",
    size: .square,
    background: .transparent,
    quality: .high
)

public protocol TokenProvider: Sendable {
    func authorizationToken() async throws -> String
    func invalidateToken() async   // default: no-op
}

do {
    let response = try await roadie.chat.create(request)
    // …use response.text…
} catch let error as RoadieError {
    switch error.kind {
    case .insufficientQuota:
        // The device crossed its free tier — show your paywall.
        break
    case .rateLimited:
        // Over the tier's rate limit — back off and retry shortly.
        break
    case .contentRejected:
        // The prompt was declined by the content policy.
        break
    case .tokenUnavailable:
        // No token: set ROADIE_STATIC_TOKEN (dev) or enable App Attest (prod).
        break
    default:
        // .unauthorized / .forbidden / .notFound / .invalidRequest /
        // .server / .timedOut / .network / .decoding
        break
    }
} catch {
    // CancellationError — the surrounding task was cancelled.
}