Android SDK — Roadie

import ai.paroaria.roadie.Roadie
import ai.paroaria.roadie.RoadieConfig
import ai.paroaria.roadie.auth.StaticTokenProvider
import ai.paroaria.roadie.auth.TokenProvider
import ai.paroaria.roadie.playintegrity.PlayIntegrityOptions
import ai.paroaria.roadie.playintegrity.PlayIntegrityTokenProvider

fun makeRoadie(context: Context): Roadie {
    val config = RoadieConfig(
        baseUrl = "https://gateway.roadie.paroaria.ai",
        publishableKey = "rd_pk_…", // used only by Play Integrity device auth
    )

    val tokenProvider: TokenProvider = if (BuildConfig.DEBUG) {
        // Local dev: an rd_sk_… secret key or a pre-minted client token.
        StaticTokenProvider(BuildConfig.ROADIE_STATIC_TOKEN)
    } else {
        // Production: Play Integrity silently mints a per-device client token.
        PlayIntegrityTokenProvider(
            context = context,
            config = config,
            options = PlayIntegrityOptions(cloudProjectNumber = 123456789012L),
        )
    }

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

import ai.paroaria.roadie.chat.ChatMessage
import ai.paroaria.roadie.chat.ChatRequest

val response = roadie.chat.create(
    ChatRequest(
        model = "smart",
        messages = listOf(
            ChatMessage.system("You are a concise assistant."),
            ChatMessage.user("In one sentence, what is Roadie?"),
        ),
        temperature = 0.7,
        maxOutputTokens = 256,
    ),
)

println(response.text)
println("${response.usage.totalTokens} tokens · ${response.cost?.estimatedUsd} USD · ${response.requestId}")

import ai.paroaria.roadie.chat.ChatStreamEvent

val builder = StringBuilder()

roadie.chat.stream(
    ChatRequest(model = "smart", messages = listOf(ChatMessage.user("Tell me a haiku about roads.")))
).collect { event ->
    when (event) {
        is ChatStreamEvent.ContentDelta -> builder.append(event.delta)
        is ChatStreamEvent.MessageEnd -> println("\ndone: ${event.finishReason} · ${event.usage}")
        is ChatStreamEvent.Error -> throw event.error // terminal; yielded, not thrown by the flow
        else -> Unit // MessageStart, ToolCallDelta, UsageEvent
    }
}

import ai.paroaria.roadie.embeddings.EmbeddingRequest

val response = roadie.embeddings.create(
    EmbeddingRequest(model = "embed", input = listOf("hello", "world")),
)

val vectors: List<List<Double>> = response.vectors // one per input, in order
println("${vectors.size} vectors of ${vectors.first().size} dims · ${response.usage.totalTokens} tokens")

import android.graphics.BitmapFactory
import ai.paroaria.roadie.images.ImageBackground
import ai.paroaria.roadie.images.ImageQuality
import ai.paroaria.roadie.images.ImageSize

// Generate from a prompt alone.
val generated: ByteArray = roadie.images.generate(
    prompt = "A watercolor fox on a transparent background.",
    size = ImageSize.SQUARE,
    background = ImageBackground.TRANSPARENT,
    quality = ImageQuality.HIGH,
)
val bitmap = BitmapFactory.decodeByteArray(generated, 0, generated.size)

// Edit a source image (PNG bytes). `mask` is optional; when present, only the masked region changes.
val edited: ByteArray = roadie.images.edit(
    image = sourcePng,
    mask = maskPng, // or null
    prompt = "Replace the background with a sunlit forest.",
    size = ImageSize.AUTO,
    background = ImageBackground.TRANSPARENT,
    quality = ImageQuality.HIGH,
)

import ai.paroaria.roadie.feedback.FeedbackRating

roadie.feedback.submit(
    requestId = response.requestId,
    rating = FeedbackRating.UP,
    comment = "Great answer.",
)

public interface TokenProvider {
    suspend fun authorizationToken(): String
    suspend fun invalidateToken() {} // default: no-op
}

val provider = PlayIntegrityTokenProvider(context, config, PlayIntegrityOptions(/* … */))
// e.g. when presenting a paywall after a quota error:
provider.refreshAttestation()

import ai.paroaria.roadie.QuotaException
import ai.paroaria.roadie.RateLimitException
import ai.paroaria.roadie.RoadieConfigurationException
import ai.paroaria.roadie.RoadieException

try {
    val response = roadie.chat.create(request)
    // …use response.text…
} catch (e: QuotaException) {
    // The device crossed its free tier — show your paywall.
} catch (e: RateLimitException) {
    // Over the tier's rate limit — back off and retry after e.retryAfter seconds.
} catch (e: RoadieConfigurationException) {
    // No token could be produced: set the static token (dev) or enable Play Integrity (prod).
} catch (e: RoadieException) {
    // AuthenticationException / PermissionException / NotFoundException / InvalidRequestException /
    // BudgetException / ProviderException / IdempotencyException / InternalException /
    // ApiConnectionException / ApiConnectionTimeoutException / ApiDecodingException.
    logError(e.status, e.code, e.requestId)
}
// A CancellationException propagates out — the surrounding coroutine was cancelled.