Error reference

Generated from source. The error enums below are emitted from the Rust core (core/extentos-core/src/types/errors.rs), which is codegen'd into the Kotlin and Swift SDKs. The same variants exist on both platforms; Kotlin uses the PascalCase names shown, Swift the lowerCamelCase equivalents (TransportFailure → .transportFailure).

How errors surface

Lifecycle operations don't throw — they return an ExtentosResult<S, F> with a typed failure variant. This is DAT's own convention and avoids coroutine-cancellation footguns. Pattern-match the result; don't wrap it in runCatching (which only catches thrown exceptions and would mask the typed error):

when (val r = glasses.camera.capturePhoto()) {
    is ExtentosResult.Ok  -> render(r.value)          // Photo
    is ExtentosResult.Err -> when (val e = r.error) {  // CaptureError
        is CaptureError.PermissionDenied -> requestCameraPermission()
        is CaptureError.ThermalCritical  -> toast("Glasses too hot — let them cool")
        is CaptureError.DisabledByUser   -> explainToggle(e.toggle)
        else                             -> log(e)
    }
}

Helpers on the Kotlin ExtentosResult: .map { }, .flatMap { }, .valueOrNull(), .errorOrNull().

The Swift shape differs in names, not model — ExtentosResult is .success(Success) / .failure(Failure), with map / flatMap and optional success / failure properties instead of valueOrNull() / errorOrNull():

switch await glasses.camera.capturePhoto() {
case .success(let photo): render(photo)
case .failure(let error): // CaptureError
    switch error {
    case .permissionDenied: requestCameraPermission()
    case .thermalCritical:  toast("Glasses too hot — let them cool")
    default:                log(error)
    }
}

The code + message carried by the PlatformError / TransportFailure variants is the shell's stable machine tag for a native-origin failure (the original native exception is logged to the event log at the catch site, not carried across the FFI).

Connection errors

ConnectError

Returned by glasses.connection.connect().

Capture errors

CaptureError

Returned by glasses.camera.capturePhoto() / captureVideo().

Audio errors

AudioError

Returned by glasses.audio.recordDiscrete() / speak().

Transport errors

TransportError

Surfaced by the underlying transport (simulator WebSocket or Meta DAT). WebsocketClosed.code is the WebSocket close code.

The umbrella type

ExtentosError

ExtentosError wraps the four per-area errors plus a catch-all, for APIs that surface any failure.

Meta DAT device-session errors

DeviceSessionError

Surfaced by the Meta DAT bridge (RealMetaTransport) when starting a device session on real hardware.

Assistant errors (Phase 4)

The Phase-4 assistant runtime (glasses.assistant.*) uses a shell-level AssistantError type (not a Rust core enum) with the same six variants on both platforms: a Kotlin sealed class thrown wrapped in AssistantException (com.extentos:glasses, since 1.4.0 — see SDK install) and a Swift AssistantError enum in GlassesCore (lowerCamelCase cases — .noApiKey, .providerError(code:message:)).

There is no DisplayError

Display (glasses.display.*) has no returned error type — show() degrades gracefully and never throws (a transport with no display path simply no-ops). Display delivery problems surface as runtime log events on glasses.runtime.events (display.video_delivery_failed, display.image_delivery_failed, display.video_error) and on the errors chip in the simulator event log (they are warn severity). See the display capability docs.

Related