diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
new file mode 100644
index 0000000..9fe10f6
--- /dev/null
+++ b/.github/workflows/ci.yaml
@@ -0,0 +1,37 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - "**"
+  workflow_dispatch:
+    inputs:
+      sdk_git_ref:
+        type: string
+        description: "Which git ref of the SDK to build"
+
+concurrency:
+  group: build-android-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  sdk:
+    name: "SDK"
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.inputs.sdk_git_ref || github.ref }}
+
+      - name: "Install Java"
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Build core SDK
+        run: ./gradlew :rtvi-client-android:assembleRelease
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..10cfdbf
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,10 @@
+*.iml
+.gradle
+/local.properties
+/.idea
+.DS_Store
+/build
+/captures
+.externalNativeBuild
+.cxx
+local.properties
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..0ac7369
--- /dev/null
+++ b/README.md
@@ -0,0 +1,39 @@
+# Real-Time Voice Inference Android Client SDK
+
+[RTVI](https://github.com/rtvi-ai/) is an open standard for Real-Time Voice (and Video) Inference.
+
+This Android library contains the core components and types needed to set up an RTVI session.
+
+When building an RTVI application, you should use the transport-specific client library (see
+[here](https://rtvi.mintlify.app/api-reference/transports/introduction) for available first-party
+packages.) The base `VoiceClient` has no transport included.
+
+## Usage
+
+Add the following dependency to your `build.gradle` file:
+
+```
+ai.rtvi:rtvi-client-android:0.1.0
+```
+
+Then instantiate the `VoiceClient` from your code, specifying the backend `baseUrl` and transport.
+
+```kotlin
+val callbacks = object : VoiceEventCallbacks() {
+
+    override fun onBackendError(message: String) {
+        Log.e(TAG, "Error from backend: $message")
+    }
+    
+    // ...
+}
+
+val client = VoiceClient(baseUrl, transport, callbacks)
+
+client.start().withCallback {
+    // ...
+}
+```
+
+`client.start()` (and other APIs) return a `Future`, which can give callbacks, or be awaited
+using Kotlin Coroutines (`client.start().await()`).
diff --git a/build.gradle.kts b/build.gradle.kts
new file mode 100644
index 0000000..e8f55f6
--- /dev/null
+++ b/build.gradle.kts
@@ -0,0 +1,5 @@
+plugins {
+    alias(libs.plugins.android.library) apply false
+    alias(libs.plugins.jetbrains.kotlin.android) apply false
+    alias(libs.plugins.jetbrains.dokka) apply true
+}
diff --git a/gradle.properties b/gradle.properties
new file mode 100644
index 0000000..20e2a01
--- /dev/null
+++ b/gradle.properties
@@ -0,0 +1,23 @@
+# Project-wide Gradle settings.
+# IDE (e.g. Android Studio) users:
+# Gradle settings configured through the IDE *will override*
+# any settings specified in this file.
+# For more details on how to configure your build environment visit
+# http://www.gradle.org/docs/current/userguide/build_environment.html
+# Specifies the JVM arguments used for the daemon process.
+# The setting is particularly useful for tweaking memory settings.
+org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
+# When configured, Gradle will run in incubating parallel mode.
+# This option should only be used with decoupled projects. For more details, visit
+# https://developer.android.com/r/tools/gradle-multi-project-decoupled-projects
+# org.gradle.parallel=true
+# AndroidX package structure to make it clearer which packages are bundled with the
+# Android operating system, and which are packaged with your app's APK
+# https://developer.android.com/topic/libraries/support-library/androidx-rn
+android.useAndroidX=true
+# Kotlin code style for this project: "official" or "obsolete":
+kotlin.code.style=official
+# Enables namespacing of each library's R class so that its R class includes only the
+# resources declared in the library itself and none from the library's dependencies,
+# thereby reducing the size of the R class for that library
+android.nonTransitiveRClass=true
\ No newline at end of file
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
new file mode 100644
index 0000000..835b803
--- /dev/null
+++ b/gradle/libs.versions.toml
@@ -0,0 +1,25 @@
+[versions]
+agp = "8.5.1"
+kotlin = "2.0.0"
+coreKtx = "1.13.1"
+junit = "4.13.2"
+junitVersion = "1.2.1"
+appcompat = "1.7.0"
+kotlinxSerializationJson = "1.7.1"
+kotlinxSerializationPlugin = "2.0.0"
+okhttp = "4.12.0"
+dokka = "1.9.20"
+
+[libraries]
+androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
+junit = { group = "junit", name = "junit", version.ref = "junit" }
+androidx-junit = { group = "androidx.test.ext", name = "junit", version.ref = "junitVersion" }
+androidx-appcompat = { group = "androidx.appcompat", name = "appcompat", version.ref = "appcompat" }
+kotlinx-serialization-json = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "kotlinxSerializationJson" }
+okhttp = { group = "com.squareup.okhttp3", name = "okhttp", version.ref = "okhttp" }
+
+[plugins]
+android-library = { id = "com.android.library", version.ref = "agp" }
+jetbrains-kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
+jetbrains-kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlinxSerializationPlugin" }
+jetbrains-dokka = { id = "org.jetbrains.dokka", version.ref = "dokka" }
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 0000000..e708b1c
Binary files /dev/null and b/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 0000000..35c800a
--- /dev/null
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,6 @@
+#Mon Aug 05 13:01:27 BST 2024
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
diff --git a/gradlew b/gradlew
new file mode 100755
index 0000000..4f906e0
--- /dev/null
+++ b/gradlew
@@ -0,0 +1,185 @@
+#!/usr/bin/env sh
+
+#
+# Copyright 2015 the original author or authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+    echo "$*"
+}
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=`expr $i + 1`
+    done
+    case $i in
+        0) set -- ;;
+        1) set -- "$args0" ;;
+        2) set -- "$args0" "$args1" ;;
+        3) set -- "$args0" "$args1" "$args2" ;;
+        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
+}
+APP_ARGS=`save "$@"`
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+exec "$JAVACMD" "$@"
diff --git a/gradlew.bat b/gradlew.bat
new file mode 100644
index 0000000..107acd3
--- /dev/null
+++ b/gradlew.bat
@@ -0,0 +1,89 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega
diff --git a/rtvi-client-android/.gitignore b/rtvi-client-android/.gitignore
new file mode 100644
index 0000000..42afabf
--- /dev/null
+++ b/rtvi-client-android/.gitignore
@@ -0,0 +1 @@
+/build
\ No newline at end of file
diff --git a/rtvi-client-android/build.gradle.kts b/rtvi-client-android/build.gradle.kts
new file mode 100644
index 0000000..95d5173
--- /dev/null
+++ b/rtvi-client-android/build.gradle.kts
@@ -0,0 +1,48 @@
+plugins {
+    alias(libs.plugins.android.library)
+    alias(libs.plugins.jetbrains.kotlin.android)
+    alias(libs.plugins.jetbrains.kotlin.serialization)
+    alias(libs.plugins.jetbrains.dokka)
+    `maven-publish`
+}
+
+android {
+    namespace = "ai.rtvi.client"
+    compileSdk = 34
+
+    defaultConfig {
+        minSdk = 24
+    }
+
+    buildTypes {
+        release {
+            isMinifyEnabled = false
+            proguardFiles(
+                getDefaultProguardFile("proguard-android-optimize.txt"),
+                "proguard-rules.pro"
+            )
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_1_8
+        targetCompatibility = JavaVersion.VERSION_1_8
+    }
+
+    lint {
+        targetSdk = 35
+    }
+
+    kotlinOptions {
+        jvmTarget = "1.8"
+    }
+}
+
+dependencies {
+    implementation(libs.androidx.core.ktx)
+    implementation(libs.androidx.appcompat)
+    implementation(libs.okhttp)
+    implementation(libs.kotlinx.serialization.json)
+    testImplementation(libs.junit)
+    androidTestImplementation(libs.androidx.junit)
+}
diff --git a/rtvi-client-android/proguard-rules.pro b/rtvi-client-android/proguard-rules.pro
new file mode 100644
index 0000000..481bb43
--- /dev/null
+++ b/rtvi-client-android/proguard-rules.pro
@@ -0,0 +1,21 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/AndroidManifest.xml b/rtvi-client-android/src/main/AndroidManifest.xml
new file mode 100644
index 0000000..568741e
--- /dev/null
+++ b/rtvi-client-android/src/main/AndroidManifest.xml
@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest />
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/VoiceClient.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/VoiceClient.kt
new file mode 100644
index 0000000..6d03e47
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/VoiceClient.kt
@@ -0,0 +1,493 @@
+package ai.rtvi.client
+
+import ai.rtvi.client.helper.RegisteredVoiceClient
+import ai.rtvi.client.helper.VoiceClientHelper
+import ai.rtvi.client.result.Future
+import ai.rtvi.client.result.Promise
+import ai.rtvi.client.result.Result
+import ai.rtvi.client.result.VoiceError
+import ai.rtvi.client.result.VoiceException
+import ai.rtvi.client.result.resolvedPromiseErr
+import ai.rtvi.client.result.withPromise
+import ai.rtvi.client.result.withTimeout
+import ai.rtvi.client.transport.AuthBundle
+import ai.rtvi.client.transport.MsgClientToServer
+import ai.rtvi.client.transport.MsgServerToClient
+import ai.rtvi.client.transport.Transport
+import ai.rtvi.client.transport.TransportContext
+import ai.rtvi.client.transport.TransportFactory
+import ai.rtvi.client.types.ActionDescription
+import ai.rtvi.client.types.Config
+import ai.rtvi.client.types.MediaDeviceId
+import ai.rtvi.client.types.Option
+import ai.rtvi.client.types.RegisteredHelper
+import ai.rtvi.client.types.ServiceConfig
+import ai.rtvi.client.types.ServiceConfigDescription
+import ai.rtvi.client.types.Transcript
+import ai.rtvi.client.types.TransportState
+import ai.rtvi.client.types.Value
+import ai.rtvi.client.utils.ConnectionBundle
+import ai.rtvi.client.utils.JSON_INSTANCE
+import ai.rtvi.client.utils.ThreadRef
+import ai.rtvi.client.utils.post
+import android.util.Log
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.decodeFromJsonElement
+import kotlinx.serialization.json.jsonObject
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.RequestBody.Companion.toRequestBody
+
+/**
+ * An RTVI client. Connects to an RTVI backend and handles bidirectional audio and video
+ * streaming.
+ *
+ * The client must be cleaned up using the [release] method when it is no longer required.
+ *
+ * @param baseUrl URL of the RTVI backend.
+ * @param transport Transport for media streaming.
+ * @param callbacks Callbacks invoked when changes occur in the voice session.
+ * @param options Additional options for configuring the client and backend.
+ */
+@Suppress("unused")
+open class VoiceClient(
+    private val baseUrl: String,
+    transport: TransportFactory,
+    callbacks: VoiceEventCallbacks,
+    private var options: VoiceClientOptions = VoiceClientOptions()
+) {
+    companion object {
+        private const val TAG = "VoiceClient"
+    }
+
+    /**
+     * The thread used by the VoiceClient for callbacks and other operations.
+     */
+    val thread = ThreadRef.forCurrent()
+
+    private val callbacks = CallbackInterceptor(object : VoiceEventCallbacks() {
+        override fun onBackendError(message: String) {}
+
+        override fun onDisconnected() {
+            discardWaitingResponses()
+            connection?.ready?.resolveErr(VoiceError.OperationCancelled)
+            connection = null
+        }
+    }, callbacks)
+
+    private val helpers = mutableMapOf<String, RegisteredHelper>()
+
+    private val awaitingServerResponse =
+        mutableMapOf<String, (Result<JsonElement, VoiceError>) -> Unit>()
+
+    private inline fun handleResponse(
+        msg: MsgServerToClient,
+        action: ((Result<JsonElement, VoiceError>) -> Unit) -> Unit
+    ) {
+        val id = msg.id ?: throw Exception("${msg.type} missing ID")
+
+        val respondTo = awaitingServerResponse.remove(id)
+            ?: throw Exception("${msg.type}: no responder for $id")
+
+        action(respondTo)
+    }
+
+    private val transportCtx = object : TransportContext {
+
+        override val options
+            get() = this@VoiceClient.options
+
+        override val callbacks
+            get() = this@VoiceClient.callbacks
+
+        override val thread = this@VoiceClient.thread
+
+        override fun onMessage(msg: MsgServerToClient) = thread.runOnThread {
+
+            Log.i(TAG, "onMessage($msg)")
+
+            try {
+                when (msg.type) {
+                    MsgServerToClient.Type.BotReady -> {
+
+                        val data =
+                            JSON_INSTANCE.decodeFromJsonElement<MsgServerToClient.Data.BotReady>(msg.data)
+
+                        this@VoiceClient.transport.setState(TransportState.Ready)
+
+                        connection?.ready?.resolveOk(Unit)
+
+                        callbacks.onBotReady(
+                            version = data.version,
+                            config = data.config
+                        )
+                    }
+
+                    MsgServerToClient.Type.Error -> {
+                        val data =
+                            JSON_INSTANCE.decodeFromJsonElement<MsgServerToClient.Data.Error>(msg.data)
+                        callbacks.onBackendError(data.error)
+                    }
+
+                    MsgServerToClient.Type.ErrorResponse -> {
+                        handleResponse(msg) { respondTo ->
+                            val data =
+                                JSON_INSTANCE.decodeFromJsonElement<MsgServerToClient.Data.Error>(
+                                    msg.data
+                                )
+                            respondTo(Result.Err(VoiceError.ErrorResponse(data.error)))
+                        }
+                    }
+
+                    MsgServerToClient.Type.ActionResponse,
+                    MsgServerToClient.Type.DescribeActionsResponse,
+                    MsgServerToClient.Type.DescribeConfigResponse,
+                    MsgServerToClient.Type.GetOrUpdateConfigResponse -> {
+                        handleResponse(msg) { respondTo ->
+                            respondTo(Result.Ok(msg.data))
+                        }
+                    }
+
+                    MsgServerToClient.Type.UserTranscription -> {
+                        val data = JSON_INSTANCE.decodeFromJsonElement<Transcript>(msg.data)
+                        callbacks.onUserTranscript(data)
+                    }
+
+                    MsgServerToClient.Type.BotTranscription -> {
+                        val text = (msg.data.jsonObject.get("text") as JsonPrimitive).content
+                        callbacks.onBotTranscript(text)
+                    }
+
+                    MsgServerToClient.Type.UserStartedSpeaking -> {
+                        callbacks.onUserStartedSpeaking()
+                    }
+
+                    MsgServerToClient.Type.UserStoppedSpeaking -> {
+                        callbacks.onUserStoppedSpeaking()
+                    }
+
+                    else -> {
+
+                        var match = false
+
+                        helpers.values
+                            .filter { it.supportedMessages.contains(msg.type) }
+                            .forEach { entry ->
+                                match = true
+                                entry.helper.handleMessage(msg)
+                            }
+
+                        if (!match) {
+                            Log.w(TAG, "Unexpected message type '${msg.type}'")
+
+                            callbacks.onGenericMessage(msg)
+                        }
+                    }
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "Exception while handling VoiceMessage", e)
+            }
+        }
+    }
+
+    private val transport: Transport = transport.createTransport(transportCtx)
+
+    private inner class Connection {
+        val ready = Promise<Unit, VoiceError>(thread)
+    }
+
+    private var connection: Connection? = null
+
+    /**
+     * Initialize local media devices such as camera and microphone.
+     *
+     * @return A Future, representing the asynchronous result of this operation.
+     */
+    fun initDevices(): Future<Unit, VoiceError> = transport.initDevices()
+
+    /**
+     * Initiate an RTVI session, connecting to the backend.
+     */
+    fun start(): Future<Unit, VoiceError> = thread.runOnThreadReturningFuture {
+
+        if (connection != null) {
+            return@runOnThreadReturningFuture resolvedPromiseErr(
+                thread,
+                VoiceError.PreviousConnectionStillActive
+            )
+        }
+
+        transport.setState(TransportState.Authorizing)
+
+        // Send POST request to the provided base_url to connect and start the bot
+
+        val body = JSON_INSTANCE.encodeToString(
+            ConnectionBundle.serializer(),
+            ConnectionBundle(
+                services = options.services.associate { it.service to it.value },
+                config = options.config
+            )
+        ).toRequestBody("application/json".toMediaType())
+
+        val currentConnection = Connection().apply { connection = this }
+
+        return@runOnThreadReturningFuture post(
+            thread = thread,
+            url = baseUrl,
+            body = body,
+            customHeaders = options.customHeaders
+        )
+            .mapError<VoiceError> {
+                VoiceError.FailedToFetchAuthBundle(it)
+            }
+            .chain { authBundle ->
+                if (currentConnection == connection) {
+                    transport.connect(AuthBundle(authBundle))
+                } else {
+                    resolvedPromiseErr(thread, VoiceError.OperationCancelled)
+                }
+            }
+            .chain { currentConnection.ready }
+            .withTimeout(30000)
+            .withErrorCallback {
+                disconnect()
+            }
+    }
+
+    /**
+     * Disconnect an active RTVI session.
+     *
+     * @return A Future, representing the asynchronous result of this operation.
+     */
+    fun disconnect(): Future<Unit, VoiceError> {
+        return transport.disconnect()
+    }
+
+    /**
+     * Directly send a message to the bot via the transport.
+     */
+    fun sendMessage(msg: MsgClientToServer) = transport.sendMessage(msg)
+
+    private fun discardWaitingResponses() {
+
+        thread.assertCurrent()
+
+        awaitingServerResponse.values.forEach {
+            it(Result.Err(VoiceError.OperationCancelled))
+        }
+
+        awaitingServerResponse.clear()
+    }
+
+    /**
+     * Registers a new helper with the client.
+     *
+     * @param service Target service for this helper
+     * @param helper Helper instance
+     */
+    @Throws(VoiceException::class)
+    fun <E : VoiceClientHelper> registerHelper(service: String, helper: E): E {
+
+        thread.assertCurrent()
+
+        if (helpers.containsKey(service)) {
+            throw VoiceException(VoiceError.OtherError("Helper targeting service '$service' already registered"))
+        }
+
+        helper.registerVoiceClient(RegisteredVoiceClient(this, service))
+
+        val entry = RegisteredHelper(
+            helper = helper,
+            supportedMessages = HashSet(helper.getMessageTypes())
+        )
+
+        helpers[service] = entry
+
+        return helper
+    }
+
+    /**
+     * Unregisters a helper from the client.
+     */
+    @Throws(VoiceException::class)
+    fun unregisterHelper(service: String) {
+
+        thread.assertCurrent()
+
+        val entry = helpers.remove(service)
+            ?: throw VoiceException(VoiceError.OtherError("Helper targeting service '$service' not found"))
+
+        entry.helper.unregisterVoiceClient()
+    }
+
+    private inline fun <reified M, R> sendWithResponse(
+        msg: MsgClientToServer,
+        crossinline filter: (M) -> R
+    ): Future<R, VoiceError> = withPromise(thread) { promise ->
+        thread.runOnThread {
+
+            awaitingServerResponse[msg.id] = { result ->
+                when (result) {
+                    is Result.Err -> promise.resolveErr(result.error)
+                    is Result.Ok -> {
+                        val data = JSON_INSTANCE.decodeFromJsonElement<M>(result.value)
+                        promise.resolveOk(filter(data))
+                    }
+                }
+            }
+
+            transport.sendMessage(msg).withErrorCallback {
+                awaitingServerResponse.remove(msg.id)
+                promise.resolveErr(it)
+            }
+        }
+    }.withTimeout(10000)
+
+    /**
+     * Instruct a backend service to perform an action.
+     */
+    fun action(
+        service: String,
+        action: String,
+        arguments: List<Option> = emptyList()
+    ): Future<Value, VoiceError> = sendWithResponse<MsgServerToClient.Data.ActionResponse, Value>(
+        MsgClientToServer.Action(
+            service = service,
+            action = action,
+            arguments = arguments
+        ),
+    ) { it.result }
+
+    /**
+     * Gets the current config from the server.
+     */
+    fun getConfig(): Future<Config, VoiceError> =
+        sendWithResponse<MsgServerToClient.Data.GetOrUpdateConfigResponse, Config>(
+            MsgClientToServer.GetConfig()
+        ) { Config(it.config) }
+
+    /**
+     * Updates the config on the server.
+     */
+    fun updateConfig(update: List<ServiceConfig>): Future<Config, VoiceError> =
+        sendWithResponse<MsgServerToClient.Data.GetOrUpdateConfigResponse, Config>(
+            MsgClientToServer.UpdateConfig(update)
+        ) { Config(it.config) }
+
+    /**
+     * Returns the expected structure of the server config.
+     */
+    fun describeConfig(): Future<List<ServiceConfigDescription>, VoiceError> =
+        sendWithResponse<MsgServerToClient.Data.DescribeConfigResponse, List<ServiceConfigDescription>>(
+            MsgClientToServer.DescribeConfig()
+        ) { it.config }
+
+    /**
+     * Returns a list of supported actions.
+     */
+    fun describeActions(): Future<List<ActionDescription>, VoiceError> =
+        sendWithResponse<MsgServerToClient.Data.DescribeActionsResponse, List<ActionDescription>>(
+            MsgClientToServer.DescribeActions()
+        ) { it.actions }
+
+    /**
+     * The current state of the session.
+     */
+    val state
+        get() = transport.state()
+
+    /**
+     * Returns a list of available audio input devices.
+     */
+    fun getAllMics() = transport.getAllMics()
+
+    /**
+     * Returns a list of available video input devices.
+     */
+    fun getAllCams() = transport.getAllCams()
+
+    /**
+     * Returns the selected audio input device.
+     */
+    val selectedMic
+        get() = transport.selectedMic()
+
+    /**
+     * Returns the selected video input device.
+     */
+    val selectedCam
+        get() = transport.selectedCam()
+
+    /**
+     * Use the specified audio input device.
+     *
+     * @return A Future, representing the asynchronous result of this operation.
+     */
+    fun updateMic(micId: MediaDeviceId) = transport.updateMic(micId)
+
+    /**
+     * Use the specified video input device.
+     *
+     * @return A Future, representing the asynchronous result of this operation.
+     */
+    fun updateCam(camId: MediaDeviceId) = transport.updateCam(camId)
+
+    /**
+     * Enables or disables the audio input device.
+     *
+     * @return A Future, representing the asynchronous result of this operation.
+     */
+    fun enableMic(enable: Boolean) = transport.enableMic(enable)
+
+    /**
+     * Enables or disables the video input device.
+     *
+     * @return A Future, representing the asynchronous result of this operation.
+     */
+    fun enableCam(enable: Boolean) = transport.enableCam(enable)
+
+    /**
+     * Returns true if the microphone is enabled, false otherwise.
+     */
+    val isMicEnabled
+        get() = transport.isMicEnabled()
+
+    /**
+     * Returns true if the camera is enabled, false otherwise.
+     */
+    val isCamEnabled
+        get() = transport.isCamEnabled()
+
+    /**
+     * Returns a list of participant media tracks.
+     */
+    val tracks
+        get() = transport.tracks()
+
+    /**
+     * Destroys this VoiceClient and cleans up any allocated resources.
+     */
+    fun release() {
+        thread.assertCurrent()
+        discardWaitingResponses()
+        transport.release()
+    }
+
+    private inline fun assertReadyOrReturn(
+        returnAction: (Future<Unit, VoiceError>) -> Nothing
+    ) {
+        thread.assertCurrent()
+
+        if (state != TransportState.Ready) {
+            returnAction(
+                resolvedPromiseErr(
+                    thread,
+                    VoiceError.InvalidState(
+                        expected = TransportState.Ready,
+                        actual = state
+                    )
+                )
+            )
+        }
+    }
+}
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/VoiceClientOptions.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/VoiceClientOptions.kt
new file mode 100644
index 0000000..69b0e5e
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/VoiceClientOptions.kt
@@ -0,0 +1,38 @@
+package ai.rtvi.client
+
+import ai.rtvi.client.types.ServiceConfig
+import ai.rtvi.client.types.ServiceRegistration
+
+/**
+ * Configuration options when instantiating a [VoiceClient].
+ */
+data class VoiceClientOptions(
+    /**
+     * Enable the user mic input.
+     *
+     * Defaults to true.
+     */
+    val enableMic: Boolean = true,
+
+    /**
+     * Enable user cam input.
+     *
+     * Defaults to false.
+     */
+    val enableCam: Boolean = false,
+
+    /**
+     * A list of services to use on the backend.
+     */
+    val services: List<ServiceRegistration> = emptyList(),
+
+    /**
+     * Further configuration options for the backend.
+     */
+    val config: List<ServiceConfig> = emptyList(),
+
+    /**
+     * Custom HTTP headers to be sent with the POST request to baseUrl.
+     */
+    val customHeaders: List<Pair<String, String>> = emptyList()
+)
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/VoiceEventCallbacks.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/VoiceEventCallbacks.kt
new file mode 100644
index 0000000..50aaf2a
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/VoiceEventCallbacks.kt
@@ -0,0 +1,227 @@
+package ai.rtvi.client
+
+import ai.rtvi.client.transport.MsgServerToClient
+import ai.rtvi.client.types.MediaDeviceInfo
+import ai.rtvi.client.types.Participant
+import ai.rtvi.client.types.PipecatMetrics
+import ai.rtvi.client.types.ServiceConfig
+import ai.rtvi.client.types.Transcript
+import ai.rtvi.client.types.TransportState
+
+/**
+ * Callbacks invoked when changes occur in the voice session.
+ */
+@Suppress("unused")
+abstract class VoiceEventCallbacks {
+
+    /**
+     * Invoked when the underlying transport has connected.
+     */
+    open fun onConnected() {}
+
+    /**
+     * Invoked when the underlying transport has disconnected.
+     */
+    open fun onDisconnected() {}
+
+    /**
+     * Invoked when the session state has changed.
+     */
+    open fun onTransportStateChanged(state: TransportState) {}
+
+    /**
+     * Invoked when the bot has connected to the session.
+     */
+    open fun onBotConnected(participant: Participant) {}
+
+    /**
+     * Invoked when the bot has indicated it is ready for commands.
+     */
+    open fun onBotReady(
+        version: String,
+        config: List<ServiceConfig>
+    ) {}
+
+    /**
+     * An error has occurred in the RTVI backend.
+     */
+    abstract fun onBackendError(message: String)
+
+    /**
+     * Invoked when the bot has disconnected from the session.
+     */
+    open fun onBotDisconnected(participant: Participant) {}
+
+    /**
+     * Invoked when a participant has joined the session.
+     */
+    open fun onParticipantJoined(participant: Participant) {}
+
+    /**
+     * Invoked when a participant has left the session.
+     */
+    open fun onParticipantLeft(participant: Participant) {}
+
+    /**
+     * Invoked when the list of available cameras has changed.
+     */
+    open fun onAvailableCamsUpdated(cams: List<MediaDeviceInfo>) {}
+
+    /**
+     * Invoked when the list of available microphones has updated.
+     */
+    open fun onAvailableMicsUpdated(mics: List<MediaDeviceInfo>) {}
+
+    /**
+     * Invoked regularly with the volume of the locally captured audio.
+     */
+    open fun onUserAudioLevel(level: Float) {}
+
+    /**
+     * Invoked regularly with the audio volume of each remote participant.
+     */
+    open fun onRemoteAudioLevel(level: Float, participant: Participant) {}
+
+    /**
+     * Invoked when the bot starts talking.
+     */
+    open fun onBotStartedSpeaking(participant: Participant) {}
+
+    /**
+     * Invoked when the bot stops talking.
+     */
+    open fun onBotStoppedSpeaking(participant: Participant) {}
+
+    /**
+     * Invoked when the local user starts talking.
+     */
+    open fun onUserStartedSpeaking() {}
+
+    /**
+     * Invoked when the local user stops talking.
+     */
+    open fun onUserStoppedSpeaking() {}
+
+    /**
+     * Invoked when session metrics are received.
+     */
+    open fun onPipecatMetrics(data: PipecatMetrics) {}
+
+    /**
+     * Invoked when user transcript data is avaiable.
+     */
+    open fun onUserTranscript(data: Transcript) {}
+
+    /**
+     * Invoked when bot transcript data is avaiable.
+     */
+    open fun onBotTranscript(text: String) {}
+
+    /**
+     * Invoked when a message from the backend is received which was not handled
+     * by the VoiceClient or a registered helper.
+     */
+    open fun onGenericMessage(msg: MsgServerToClient) {}
+
+    /**
+     * Invoked when the state of the input devices changes.
+     */
+    open fun onInputsUpdated(camera: Boolean, mic: Boolean) {}
+}
+
+internal class CallbackInterceptor(vararg listeners: VoiceEventCallbacks): VoiceEventCallbacks() {
+    
+    private val callbacks = listeners.toMutableList()
+    
+    fun addListener(listener: VoiceEventCallbacks) {
+        callbacks.add(listener)
+    }
+    
+    override fun onConnected() {
+        callbacks.forEach { it.onConnected() }
+    }
+
+    override fun onDisconnected() {
+        callbacks.forEach { it.onDisconnected() }
+    }
+
+    override fun onTransportStateChanged(state: TransportState) {
+        callbacks.forEach { it.onTransportStateChanged(state) }
+    }
+
+    override fun onBotConnected(participant: Participant) {
+        callbacks.forEach { it.onBotConnected(participant) }
+    }
+
+    override fun onBotReady(version: String, config: List<ServiceConfig>) {
+        callbacks.forEach { it.onBotReady(version, config) }
+    }
+
+    override fun onBackendError(message: String) {
+        callbacks.forEach { it.onBackendError(message) }
+    }
+
+    override fun onBotDisconnected(participant: Participant) {
+        callbacks.forEach { it.onBotDisconnected(participant) }
+    }
+
+    override fun onParticipantJoined(participant: Participant) {
+        callbacks.forEach { it.onParticipantJoined(participant) }
+    }
+
+    override fun onParticipantLeft(participant: Participant) {
+        callbacks.forEach { it.onParticipantLeft(participant) }
+    }
+
+    override fun onAvailableCamsUpdated(cams: List<MediaDeviceInfo>) {
+        callbacks.forEach { it.onAvailableCamsUpdated(cams) }
+    }
+
+    override fun onAvailableMicsUpdated(mics: List<MediaDeviceInfo>) {
+        callbacks.forEach { it.onAvailableMicsUpdated(mics) }
+    }
+
+    override fun onUserAudioLevel(level: Float) {
+        callbacks.forEach { it.onUserAudioLevel(level) }
+    }
+
+    override fun onRemoteAudioLevel(level: Float, participant: Participant) {
+        callbacks.forEach { it.onRemoteAudioLevel(level, participant) }
+    }
+
+    override fun onBotStartedSpeaking(participant: Participant) {
+        callbacks.forEach { it.onBotStartedSpeaking(participant) }
+    }
+
+    override fun onBotStoppedSpeaking(participant: Participant) {
+        callbacks.forEach { it.onBotStoppedSpeaking(participant) }
+    }
+
+    override fun onUserStartedSpeaking() {
+        callbacks.forEach { it.onUserStartedSpeaking() }
+    }
+
+    override fun onUserStoppedSpeaking() {
+        callbacks.forEach { it.onUserStoppedSpeaking() }
+    }
+
+    override fun onPipecatMetrics(data: PipecatMetrics) {
+        callbacks.forEach { it.onPipecatMetrics(data) }
+    }
+
+    override fun onUserTranscript(data: Transcript) {
+        callbacks.forEach { it.onUserTranscript(data) }
+    }
+
+    override fun onBotTranscript(text: String) {
+        callbacks.forEach { it.onBotTranscript(text) }
+    }
+
+    override fun onGenericMessage(msg: MsgServerToClient) {
+        callbacks.forEach { it.onGenericMessage(msg) }
+    }
+
+    override fun onInputsUpdated(camera: Boolean, mic: Boolean) {
+        callbacks.forEach { it.onInputsUpdated(camera = camera, mic = mic) }
+    }
+}
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/helper/LLMHelper.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/helper/LLMHelper.kt
new file mode 100644
index 0000000..bea3fe8
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/helper/LLMHelper.kt
@@ -0,0 +1,218 @@
+package ai.rtvi.client.helper
+
+import ai.rtvi.client.result.Future
+import ai.rtvi.client.result.VoiceError
+import ai.rtvi.client.result.resolvedPromiseErr
+import ai.rtvi.client.transport.MsgClientToServer
+import ai.rtvi.client.transport.MsgServerToClient
+import ai.rtvi.client.types.Option
+import ai.rtvi.client.types.TransportState
+import ai.rtvi.client.types.Value
+import ai.rtvi.client.utils.JSON_INSTANCE
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonNull
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.decodeFromJsonElement
+import kotlinx.serialization.json.encodeToJsonElement
+import kotlinx.serialization.json.jsonPrimitive
+
+/**
+ * Helper for interacting with an LLM service.
+ */
+class LLMHelper(private val callbacks: Callbacks) : VoiceClientHelper() {
+
+    companion object {
+        const val TAG = "LLMHelper"
+    }
+
+    abstract class Callbacks {
+        fun onLLMJsonCompletion(jsonString: String) {}
+
+        /**
+         * Invoked when the LLM attempts to invoke a function. The provided callback must be
+         * provided with a return value.
+         *
+         * @param func Details of the function call
+         * @param onResult Invoke this callback to provide a return value to the LLM
+         */
+        fun onLLMFunctionCall(func: LLMFunctionCall, onResult: (Value) -> Unit) {
+            onResult(Value.Object("error" to Value.Str("no handler registered")))
+        }
+    }
+
+    override fun handleMessage(msg: MsgServerToClient) {
+        when (msg.type) {
+            LLMMessageType.Incoming.LLMJsonCompletion -> {
+                callbacks.onLLMJsonCompletion(msg.data.jsonPrimitive.content)
+            }
+
+            LLMMessageType.Incoming.LLMFunctionCall -> {
+                val data = JSON_INSTANCE.decodeFromJsonElement<LLMFunctionCall>(msg.data)
+
+                callbacks.onLLMFunctionCall(data) { result ->
+                    client?.client?.sendMessage(
+                        MsgClientToServer(
+                            type = LLMMessageType.Outgoing.LLMFunctionCallResult,
+                            data = JSON_INSTANCE.encodeToJsonElement(
+                                LLMFunctionCallResult(
+                                    functionName = data.functionName,
+                                    toolCallId = data.toolCallId,
+                                    args = data.args,
+                                    result = result
+                                )
+                            )
+                        )
+                    )?.logError(TAG, "function call response")
+                }
+            }
+        }
+    }
+
+    override fun getMessageTypes() = setOf(
+        LLMMessageType.Incoming.LLMFunctionCall,
+        LLMMessageType.Incoming.LLMJsonCompletion
+    )
+
+    /**
+     * Returns the bot's current LLM context. Bot must be in the ready state.
+     */
+    fun getContext(): Future<LLMContext, VoiceError> = withClient {
+        it.ensureReady {
+            it.action("get_context")
+                .map { result -> JSON_INSTANCE.decodeFromJsonElement<LLMContext>(result.asJsonElement()) }
+        }
+    }
+
+    /**
+     * Update the bot's LLM context.
+     *
+     * @param context The new context
+     * @param interrupt Whether to interrupt the bot, or wait until it has finished speaking
+     */
+    fun setContext(
+        context: LLMContext,
+        interrupt: Boolean = false
+    ): Future<Unit, VoiceError> = withClient {
+        it.ensureReady {
+            it.action(
+                "set_context",
+                listOf(
+                    "messages" setTo (context.messages ?: emptyList()).convertToRtviValue(),
+                    "interrupt" setTo interrupt
+                )
+            ).throwAwayResult()
+        }
+    }
+
+    /**
+     * Append a new message to the LLM context.
+     *
+     * @param message The message
+     * @param runImmediately If false, wait until pipeline is idle before running
+     */
+    fun appendToMessages(
+        message: LLMContextMessage,
+        runImmediately: Boolean = false
+    ): Future<Unit, VoiceError> = withClient {
+        it.ensureReady {
+            it.action(
+                "append_to_messages",
+                listOf(
+                    "messages" setTo listOf(message.convertToRtviValue()),
+                    "run_immediately" setTo runImmediately
+                )
+            ).throwAwayResult()
+        }
+    }
+
+    /**
+     * Run the bot's current LLM context.
+     *
+     * Useful when appending messages to the context without runImmediately set to true.
+     *
+     * Will do nothing if the bot is not in the ready state.
+     *
+     * @param interrupt boolean - Whether to interrupt the bot, or wait until it has finished speaking
+     */
+    fun run(interrupt: Boolean = false): Future<Unit, VoiceError> = withClient {
+        it.ensureReady {
+            it.action("run", listOf("interrupt" setTo interrupt)).throwAwayResult()
+        }
+    }
+}
+
+@Serializable
+data class LLMFunctionCall(
+    @SerialName("function_name")
+    val functionName: String,
+    @SerialName("tool_call_id")
+    val toolCallId: String,
+    val args: Value,
+)
+
+@Serializable
+data class LLMFunctionCallResult(
+    @SerialName("function_name")
+    val functionName: String,
+    @SerialName("tool_call_id")
+    val toolCallId: String,
+    val args: Value,
+    val result: Value,
+)
+
+@Serializable
+data class LLMContextMessage(
+    val role: String,
+    val content: String
+)
+
+@Serializable
+data class LLMContext(
+    val messages: List<LLMContextMessage>? = null
+)
+
+private object LLMMessageType {
+    object Incoming {
+        const val LLMFunctionCall = "llm-function-call"
+        const val LLMJsonCompletion = "llm-json-completion"
+    }
+
+    object Outgoing {
+        const val LLMFunctionCallResult = "llm-function-call-result"
+    }
+}
+
+private infix fun String.setTo(value: Value) = Option(this, value)
+private infix fun String.setTo(value: Boolean) = Option(this, value)
+private infix fun String.setTo(value: String) = Option(this, value)
+private infix fun String.setTo(value: List<Value>) = Option(this, value)
+
+private inline fun <reified E> E.convertToRtviValue() =
+    JSON_INSTANCE.encodeToJsonElement(this).asRtviValue()
+
+private fun JsonElement.asRtviValue(): Value = JSON_INSTANCE.decodeFromJsonElement(this)
+
+private fun Value.asJsonElement(): JsonElement = when (this) {
+    is Value.Array -> JsonArray(value.map(Value::asJsonElement))
+    is Value.Object -> JsonObject(value.mapValues { it.value.asJsonElement() })
+    is Value.Bool -> JsonPrimitive(value)
+    is Value.Number -> JsonPrimitive(value)
+    is Value.Str -> JsonPrimitive(value)
+    Value.Null -> JsonNull
+}
+
+private fun <V> RegisteredVoiceClient.ensureReady(action: () -> Future<V, VoiceError>): Future<V, VoiceError> =
+    if (client.state == TransportState.Ready) {
+        action()
+    } else {
+        resolvedPromiseErr(
+            client.thread,
+            VoiceError.InvalidState(expected = TransportState.Ready, actual = client.state)
+        )
+    }
+
+private fun Future<Value, VoiceError>.throwAwayResult() = map {}
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/helper/VoiceClientHelper.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/helper/VoiceClientHelper.kt
new file mode 100644
index 0000000..b94288f
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/helper/VoiceClientHelper.kt
@@ -0,0 +1,64 @@
+package ai.rtvi.client.helper
+
+import ai.rtvi.client.VoiceClient
+import ai.rtvi.client.result.Future
+import ai.rtvi.client.result.VoiceError
+import ai.rtvi.client.result.VoiceException
+import ai.rtvi.client.result.resolvedPromiseErr
+import ai.rtvi.client.transport.MsgServerToClient
+import ai.rtvi.client.types.Option
+import ai.rtvi.client.utils.ThreadRef
+import java.util.concurrent.atomic.AtomicReference
+
+abstract class VoiceClientHelper {
+
+    private val voiceClient = AtomicReference<RegisteredVoiceClient?>(null)
+
+    protected fun <R> withClient(
+        action: (RegisteredVoiceClient) -> Future<R, VoiceError>
+    ): Future<R, VoiceError> {
+
+        val client = voiceClient.get() ?: return resolvedPromiseErr(
+            ThreadRef.forMain(),
+            VoiceError.HelperNotRegistered
+        )
+
+        return client.client.thread.runOnThreadReturningFuture { action(client) }
+    }
+
+    protected val client: RegisteredVoiceClient?
+        get() = voiceClient.get()
+
+    /**
+     * Handle a message received from the backend.
+     */
+    abstract fun handleMessage(msg: MsgServerToClient)
+
+    /**
+     * Returns a list of message types supported by this helper. Messages received from the
+     * backend which have these types will be passed to [handleMessage].
+     */
+    abstract fun getMessageTypes(): Set<String>
+
+    @Throws(VoiceException::class)
+    internal fun registerVoiceClient(client: RegisteredVoiceClient) {
+        if (!this.voiceClient.compareAndSet(null, client)) {
+            throw VoiceException(VoiceError.OtherError("Helper is already registered to a client"))
+        }
+    }
+
+    @Throws(VoiceException::class)
+    internal fun unregisterVoiceClient() {
+        if (voiceClient.getAndSet(null) == null) {
+            throw VoiceException(VoiceError.OtherError("Helper is not registered to a client"))
+        }
+    }
+}
+
+class RegisteredVoiceClient(
+    val client: VoiceClient,
+    val service: String,
+) {
+    fun action(action: String, args: List<Option> = emptyList()) =
+        client.action(service = service, action = action, arguments = args)
+}
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/result/Callback.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/result/Callback.kt
new file mode 100644
index 0000000..df82b1e
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/result/Callback.kt
@@ -0,0 +1,11 @@
+package ai.rtvi.client.result
+
+/**
+ * A callback function receiving a value.
+ */
+fun interface Callback<T> {
+    fun onComplete(value: T)
+}
+
+
+
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/result/Future.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/result/Future.kt
new file mode 100644
index 0000000..aa1300b
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/result/Future.kt
@@ -0,0 +1,117 @@
+package ai.rtvi.client.result
+
+import ai.rtvi.client.utils.ThreadRef
+import android.util.Log
+import kotlin.coroutines.resume
+import kotlin.coroutines.suspendCoroutine
+
+/**
+ * The output of an asynchronous operation.
+ *
+ * When the operation completes, it may return an error.
+ */
+interface Future<V, E> {
+
+    val thread: ThreadRef
+
+    /**
+     * Give a callback when the Future completes.
+     */
+    fun withCallback(callback: ResultCallback<V, E>): Future<V, E>
+
+    /**
+     * Give a callback if the Future returns an error.
+     */
+    fun withErrorCallback(callback: Callback<E>) = withCallback {
+        if (it is Result.Err) {
+            callback.onComplete(it.error)
+        }
+    }
+
+    /**
+     * If the Future returns successfully, transform the result to another type.
+     */
+    fun <V2> map(filter: (V) -> V2): Future<V2, E> = withPromise(thread) { promise ->
+        withCallback { result ->
+            promise.resolve(result.map(filter))
+        }
+    }
+
+    /**
+     * If the Future returns an error, transform the error to another type.
+     */
+    fun <E2> mapError(filter: (E) -> E2): Future<V, E2> = withPromise(thread) { promise ->
+        withCallback { result ->
+            promise.resolve(result.mapError(filter))
+        }
+    }
+
+    /**
+     * When this Future completes, run another async operation.
+     *
+     * @return A Future that will resolve when both operations have completed.
+     */
+    fun <V2> chain(action: (V) -> Future<V2, E>): Future<V2, E> {
+        val promise = Promise<V2, E>(thread)
+
+        withCallback { firstResult ->
+
+            when (firstResult) {
+                is Result.Err -> promise.resolve(firstResult)
+                is Result.Ok -> {
+                    action(firstResult.value).withCallback { secondResult ->
+                        promise.resolve(secondResult)
+                    }
+                }
+            }
+        }
+
+        return promise
+    }
+
+    /**
+     * Wait for the Future to complete using Kotlin Coroutines. Will return
+     * errors rather than throwing an exception.
+     */
+    suspend fun awaitNoThrow(): Result<V, E> {
+        return suspendCoroutine { continuation ->
+            withCallback {
+                continuation.resume(it)
+            }
+        }
+    }
+
+    /**
+     * Wait for the Future to complete using Kotlin Coroutines, and throw
+     * a VoiceException if the operation failed.
+     */
+    @Throws(VoiceException::class)
+    suspend fun await() = awaitNoThrow().throwError()
+
+    /**
+     * If this operation fails, log an error.
+     */
+    fun logError(tag: String, description: String) = withErrorCallback {
+        Log.e(tag, "Operation $description failed: $it")
+    }
+}
+
+/**
+ * Returns a new `Future` which times out after the specified duration.
+ *
+ * @param durationMs Timeout in milliseconds.
+ */
+fun <V> Future<V, VoiceError>.withTimeout(durationMs: Long): Future<V, VoiceError> =
+    withPromise(thread) { promise ->
+
+        val timeoutEvent = Runnable {
+            promise.resolveErr(VoiceError.Timeout)
+        }
+
+        this.withCallback {
+            promise.resolve(it)
+            thread.handler.removeCallbacks(timeoutEvent)
+        }
+
+        thread.handler.postDelayed(timeoutEvent, durationMs)
+    }
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/result/HttpError.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/result/HttpError.kt
new file mode 100644
index 0000000..e7ddb1a
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/result/HttpError.kt
@@ -0,0 +1,33 @@
+package ai.rtvi.client.result
+
+/**
+ * An error occurring due to an HTTP request failing.
+ */
+sealed interface HttpError {
+
+    /**
+     * A humaan-readable description of the error.
+     */
+    val description: String
+
+    /**
+     * The HTTP request returned an invalid status code.
+     */
+    data class BadStatusCode(val code: Int) : HttpError {
+        override val description = "Server returned status code $code"
+    }
+
+    /**
+     * An exception was thrown during the HTTP request.
+     */
+    data class ExceptionThrown(val e: Exception) : HttpError {
+        override val description = "An exception was thrown ($e)"
+    }
+
+    /**
+     * The HTTP response was expected to have a body.
+     */
+    data object MissingResponseBody : HttpError {
+        override val description = "The response had no body data"
+    }
+}
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/result/Promise.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/result/Promise.kt
new file mode 100644
index 0000000..31edcb3
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/result/Promise.kt
@@ -0,0 +1,80 @@
+package ai.rtvi.client.result
+
+import ai.rtvi.client.utils.ThreadRef
+
+/**
+ * Represents an ongoing asynchronous operation.
+ *
+ * Promise implements the Future interface, which means it can be returned from
+ * functions performing asynchronous operations to provide callers a flexible way
+ * to wait for the response.
+ */
+class Promise<V, E>(override val thread: ThreadRef) : Future<V, E> {
+
+    private var value: Result<V, E>? = null
+    private val pendingCallbacks = mutableListOf<ResultCallback<V, E>>()
+
+    /**
+     * Resolve the promise, notifying any pending callbacks.
+     *
+     * If a promise is resolved twice, the second invocation of resolve() will be ignored.
+     */
+    fun resolve(value: Result<V, E>) {
+        thread.runOnThread {
+            if (this.value == null) {
+                this.value = value
+                pendingCallbacks.forEach {
+                    it.onResult(value)
+                }
+            }
+        }
+    }
+
+    /**
+     * Convenience method to resolve a promise with a success value.
+     */
+    fun resolveOk(value: V) = resolve(Result.Ok(value))
+
+    /**
+     * Convenience method to resolve a promise with an error.
+     */
+    fun resolveErr(error: E) = resolve(Result.Err(error))
+
+    override fun withCallback(callback: ResultCallback<V, E>): Future<V, E> {
+        thread.runOnThread {
+            val currentVal = value
+
+            if (currentVal != null) {
+                callback.onResult(currentVal)
+            } else {
+                pendingCallbacks.add(callback)
+            }
+        }
+        return this
+    }
+}
+
+/**
+ * Convenience method to create and return a Promise.
+ */
+fun <V, E> withPromise(thread: ThreadRef, action: (Promise<V, E>) -> Unit): Future<V, E> {
+    return Promise<V, E>(thread).apply(action)
+}
+
+/**
+ * Returns a Future which has already resolved successfully.
+ */
+fun <V, E> resolvedPromiseOk(thread: ThreadRef, value: V): Future<V, E> {
+    return Promise<V, E>(thread).apply {
+        resolveOk(value)
+    }
+}
+
+/**
+ * Returns a Future which has already resolved with an error.
+ */
+fun <V, E> resolvedPromiseErr(thread: ThreadRef, error: E): Future<V, E> {
+    return Promise<V, E>(thread).apply {
+        resolveErr(error)
+    }
+}
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/result/Result.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/result/Result.kt
new file mode 100644
index 0000000..07c1883
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/result/Result.kt
@@ -0,0 +1,90 @@
+package ai.rtvi.client.result
+
+/**
+ * The result of an operation: either Result.Ok or Result.Err.
+ */
+sealed interface Result<out V, out E> {
+
+    /**
+     * The operation completed successfully.
+     */
+    data class Ok<V>(
+        /**
+         * The return value of the operation.
+         */
+        val value: V
+    ) : Result<V, Nothing>
+
+    /**
+     * The operation failed.
+     */
+    data class Err<E>(
+        /**
+         * The error returned by the operation.
+         */
+        val error: E
+    ) : Result<Nothing, E>
+
+    /**
+     * If the result is a success, this method transforms the value to a different type.
+     */
+    fun <V2> map(filter: (V) -> V2) = when (this) {
+        is Err -> this
+        is Ok -> Ok(filter(value))
+    }
+
+    /**
+     * If the result is an error, this method transforms the error to a different type.
+     */
+    fun <E2> mapError(filter: (E) -> E2) = when (this) {
+        is Err -> Err(filter(error))
+        is Ok -> this
+    }
+
+    /**
+     * If the operation failed, throw a VoiceException, otherwise return the result.
+     */
+    @Throws(VoiceException::class)
+    fun throwError(): V = when(this) {
+        is Err -> throw VoiceException.from(error)
+        is Ok -> value
+    }
+
+    /**
+     * Returns true if the operation succeeded, or false if there was an error.
+     */
+    val ok
+        get() = this is Ok
+
+    /**
+     * If the operation was successful, this is the return value. Otherwise this is null.
+     */
+    val valueOrNull: V?
+        get() = (this as? Ok)?.value
+
+    /**
+     * If the operation failed, this is the error. Otherwise this is null.
+     */
+    val errorOrNull: E?
+        get() = (this as? Err)?.error
+}
+
+/**
+ * Kotlin convenience method: return the value if Ok, otherwise invoke the callback with the error.
+ */
+inline fun <V, E> Result<V, E>.orError(onError: (E) -> Nothing): V {
+    return when (this) {
+        is Result.Err -> onError(error)
+        is Result.Ok -> value
+    }
+}
+
+/**
+ * Kotlin convenience method: invoke the callback if the result is an error.
+ */
+inline fun <V, E> Result<V, E>.ifError(onError: (E) -> Unit) {
+    when (this) {
+        is Result.Err -> onError(error)
+        is Result.Ok -> {}
+    }
+}
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/result/ResultCallback.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/result/ResultCallback.kt
new file mode 100644
index 0000000..0b1e524
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/result/ResultCallback.kt
@@ -0,0 +1,8 @@
+package ai.rtvi.client.result
+
+/**
+ * A callback function receiving a Result value.
+ */
+fun interface ResultCallback<V, E> {
+    fun onResult(value: Result<V, E>)
+}
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/result/VoiceError.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/result/VoiceError.kt
new file mode 100644
index 0000000..4fa8708
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/result/VoiceError.kt
@@ -0,0 +1,93 @@
+package ai.rtvi.client.result
+
+import ai.rtvi.client.types.TransportState
+
+/**
+ * An error occurring during an operation.
+ */
+abstract class VoiceError {
+
+    /**
+     * A human-readable description of the error.
+     */
+    abstract val description: String
+
+    /**
+     * If the error was caused by an exception, this value is set.
+     */
+    open val exception: Exception? = null
+
+    override fun toString() = description
+
+    /**
+     * Failed to fetch the authentication bundle from the RTVI backend.
+     */
+    data class FailedToFetchAuthBundle(val error: HttpError) : VoiceError() {
+        override val description = "Failed to fetch the auth bundle: ${error.description}"
+    }
+
+    /**
+     * An exception was thrown.
+     */
+    data class ExceptionThrown(override val exception: Exception) : VoiceError() {
+        override val description = "An exception was thrown ($exception)"
+    }
+
+    /**
+     * An unknown error occurred.
+     */
+    data class OtherError(val message: String) : VoiceError() {
+        override val description = message
+    }
+
+    /**
+     * Operation cannot be performed because the transport is not initialized.
+     */
+    data object TransportNotInitialized : VoiceError() {
+        override val description = "Transport not initialized"
+    }
+
+    /**
+     * Operation cannot be performed in this state.
+     */
+    data class InvalidState(
+        val expected: TransportState,
+        val actual: TransportState
+    ) : VoiceError() {
+        override val description = "Invalid state: expected ${expected.name}, actual ${actual.name}"
+    }
+
+    /**
+     * The operation was cancelled before it could complete.
+     */
+    data object OperationCancelled : VoiceError() {
+        override val description = "The operation was cancelled"
+    }
+
+    data class ErrorResponse(
+        val message: String
+    ) : VoiceError() {
+        override val description = "Received error response from backend: $message"
+    }
+
+    /**
+     * The operation timed out before it could complete.
+     */
+    data object Timeout : VoiceError() {
+        override val description = "The operation timed out"
+    }
+
+    /**
+     * The previous connection is still active.
+     */
+    data object PreviousConnectionStillActive : VoiceError() {
+        override val description = "The previous connection is still active"
+    }
+
+    /**
+     * This helper is not registered to a VoiceClient.
+     */
+    data object HelperNotRegistered : VoiceError() {
+        override val description = "This helper is not registered to a VoiceClient"
+    }
+}
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/result/VoiceException.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/result/VoiceException.kt
new file mode 100644
index 0000000..9b14770
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/result/VoiceException.kt
@@ -0,0 +1,12 @@
+package ai.rtvi.client.result
+
+class VoiceException(
+    val error: VoiceError
+) : Exception(error.description, error.exception) {
+
+    companion object {
+        internal fun <E> from(e: E) = VoiceException(
+            (e as? VoiceError) ?: VoiceError.OtherError(e.toString())
+        )
+    }
+}
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/transport/AuthBundle.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/transport/AuthBundle.kt
new file mode 100644
index 0000000..a1cf2c3
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/transport/AuthBundle.kt
@@ -0,0 +1,8 @@
+package ai.rtvi.client.transport
+
+/**
+ * A bundle of initialization data received from the RTVI backend.
+ */
+data class AuthBundle(
+    val data: String
+)
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/transport/MsgClientToServer.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/transport/MsgClientToServer.kt
new file mode 100644
index 0000000..5e19fc1
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/transport/MsgClientToServer.kt
@@ -0,0 +1,89 @@
+package ai.rtvi.client.transport
+
+import ai.rtvi.client.types.Option
+import ai.rtvi.client.types.ServiceConfig
+import ai.rtvi.client.utils.JSON_INSTANCE
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.encodeToJsonElement
+import java.util.UUID
+
+/**
+ * An RTVI control message sent to the backend.
+ */
+@Suppress("DataClassPrivateConstructor")
+@Serializable
+data class MsgClientToServer private constructor(
+    val id: String,
+    val label: String,
+    val type: String,
+    val data: JsonElement?
+) {
+
+    constructor(
+        type: String,
+        data: JsonElement?,
+        id: String = UUID.randomUUID().toString()
+    ) : this(
+        id = id,
+        label = "rtvi-ai",
+        type = type,
+        data = data
+    )
+
+    object Type {
+        const val DescribeConfig = "describe-config"
+        const val GetConfig = "get-config"
+        const val UpdateConfig = "update-config"
+        const val DescribeActions = "describe-actions"
+        const val Action = "action"
+    }
+
+    object Data {
+
+        @Serializable
+        data class Action(
+            val service: String,
+            val action: String,
+            val arguments: List<Option>
+        )
+    }
+
+    @Suppress("FunctionName")
+    companion object {
+
+        // Functions not values, as these generate a new ID every time
+        fun DescribeConfig() = MsgClientToServer(
+            type = Type.DescribeConfig,
+            data = null
+        )
+
+        fun GetConfig() = MsgClientToServer(
+            type = Type.GetConfig,
+            data = null
+        )
+
+        fun UpdateConfig(update: List<ServiceConfig>) = MsgClientToServer(
+            type = Type.UpdateConfig,
+            data = JSON_INSTANCE.encodeToJsonElement(update)
+        )
+
+        fun DescribeActions() = MsgClientToServer(
+            type = Type.DescribeActions,
+            data = null
+        )
+
+        fun Action(
+            service: String,
+            action: String,
+            arguments: List<Option>
+        ) = MsgClientToServer(
+            type = Type.Action,
+            data = JSON_INSTANCE.encodeToJsonElement(Data.Action(
+                service = service,
+                action = action,
+                arguments = arguments
+            ))
+        )
+    }
+}
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/transport/MsgServerToClient.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/transport/MsgServerToClient.kt
new file mode 100644
index 0000000..65dbc9e
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/transport/MsgServerToClient.kt
@@ -0,0 +1,68 @@
+package ai.rtvi.client.transport
+
+import ai.rtvi.client.types.ActionDescription
+import ai.rtvi.client.types.ServiceConfig
+import ai.rtvi.client.types.ServiceConfigDescription
+import ai.rtvi.client.types.Value
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonNull
+
+/**
+ * An RTVI control message sent to the client.
+ */
+@Serializable
+data class MsgServerToClient(
+    val id: String? = null,
+    val label: String,
+    val type: String,
+    val data: JsonElement = JsonNull
+) {
+    object Type {
+        const val BotReady = "bot-ready"
+        const val Error = "error"
+        const val ErrorResponse = "error-response"
+        const val DescribeConfigResponse = "config-available"
+        const val GetOrUpdateConfigResponse = "config"
+        const val DescribeActionsResponse = "actions-available"
+        const val ActionResponse = "action-response"
+        const val UserTranscription = "user-transcription"
+        const val BotTranscription = "tts-text"
+        const val UserStartedSpeaking = "user-started-speaking"
+        const val UserStoppedSpeaking = "user-stopped-speaking"
+    }
+
+    object Data {
+
+        @Serializable
+        data class BotReady(
+            val version: String,
+            val config: List<ServiceConfig>
+        )
+
+        @Serializable
+        data class Error(
+            val error: String
+        )
+
+        @Serializable
+        data class DescribeConfigResponse(
+            val config: List<ServiceConfigDescription>
+        )
+
+        @Serializable
+        data class GetOrUpdateConfigResponse(
+            val config: List<ServiceConfig>
+        )
+
+        @Serializable
+        data class DescribeActionsResponse(
+            val actions: List<ActionDescription>
+        )
+
+        @Serializable
+        data class ActionResponse(
+            val result: Value
+        )
+    }
+}
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/transport/Transport.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/transport/Transport.kt
new file mode 100644
index 0000000..9287ac6
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/transport/Transport.kt
@@ -0,0 +1,43 @@
+package ai.rtvi.client.transport
+
+import ai.rtvi.client.result.Future
+import ai.rtvi.client.result.VoiceError
+import ai.rtvi.client.types.MediaDeviceId
+import ai.rtvi.client.types.MediaDeviceInfo
+import ai.rtvi.client.types.Tracks
+import ai.rtvi.client.types.TransportState
+
+/**
+ * An RTVI transport.
+ */
+abstract class Transport {
+
+    abstract fun initDevices(): Future<Unit, VoiceError>
+    abstract fun release()
+
+    abstract fun connect(authBundle: AuthBundle): Future<Unit, VoiceError>
+
+    abstract fun disconnect(): Future<Unit, VoiceError>
+
+    abstract fun getAllMics(): Future<List<MediaDeviceInfo>, VoiceError>
+    abstract fun getAllCams(): Future<List<MediaDeviceInfo>, VoiceError>
+
+    abstract fun updateMic(micId: MediaDeviceId): Future<Unit, VoiceError>
+    abstract fun updateCam(camId: MediaDeviceId): Future<Unit, VoiceError>
+
+    abstract fun selectedMic(): MediaDeviceInfo?
+    abstract fun selectedCam(): MediaDeviceInfo?
+
+    abstract fun enableMic(enable: Boolean): Future<Unit, VoiceError>
+    abstract fun enableCam(enable: Boolean): Future<Unit, VoiceError>
+
+    abstract fun isCamEnabled(): Boolean
+    abstract fun isMicEnabled(): Boolean
+
+    abstract fun sendMessage(message: MsgClientToServer): Future<Unit, VoiceError>
+
+    abstract fun state(): TransportState
+    abstract fun setState(state: TransportState)
+
+    abstract fun tracks(): Tracks
+}
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/transport/TransportContext.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/transport/TransportContext.kt
new file mode 100644
index 0000000..c5abdb8
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/transport/TransportContext.kt
@@ -0,0 +1,20 @@
+package ai.rtvi.client.transport
+
+import ai.rtvi.client.VoiceClientOptions
+import ai.rtvi.client.VoiceEventCallbacks
+import ai.rtvi.client.utils.ThreadRef
+
+/**
+ * Context for an RTVI transport.
+ */
+interface TransportContext {
+
+    val options: VoiceClientOptions
+    val callbacks: VoiceEventCallbacks
+    val thread: ThreadRef
+
+    /**
+     * Invoked by the transport when an RTVI message is received.
+     */
+    fun onMessage(msg: MsgServerToClient)
+}
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/transport/TransportFactory.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/transport/TransportFactory.kt
new file mode 100644
index 0000000..7e92b7b
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/transport/TransportFactory.kt
@@ -0,0 +1,8 @@
+package ai.rtvi.client.transport
+
+/**
+ * A creator of Transport objects.
+ */
+fun interface TransportFactory {
+    fun createTransport(context: TransportContext): Transport
+}
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/types/ActionDescription.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/types/ActionDescription.kt
new file mode 100644
index 0000000..7b04d62
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/types/ActionDescription.kt
@@ -0,0 +1,11 @@
+package ai.rtvi.client.types
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class ActionDescription(
+    val service: String,
+    val action: String,
+    val arguments: List<OptionDescription>,
+    val result: Type
+)
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/types/Config.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/types/Config.kt
new file mode 100644
index 0000000..3d70c4e
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/types/Config.kt
@@ -0,0 +1,5 @@
+package ai.rtvi.client.types
+
+data class Config(
+    val config: List<ServiceConfig>
+)
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/types/MediaDeviceId.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/types/MediaDeviceId.kt
new file mode 100644
index 0000000..66dafae
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/types/MediaDeviceId.kt
@@ -0,0 +1,8 @@
+package ai.rtvi.client.types
+
+/**
+ * A unique identifier for a media device.
+ */
+data class MediaDeviceId(
+    val id: String
+)
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/types/MediaDeviceInfo.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/types/MediaDeviceInfo.kt
new file mode 100644
index 0000000..e46dc08
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/types/MediaDeviceInfo.kt
@@ -0,0 +1,9 @@
+package ai.rtvi.client.types
+
+/**
+ * Information about a media device.
+ */
+data class MediaDeviceInfo(
+    val id: MediaDeviceId,
+    val name: String,
+)
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/types/MediaTrackId.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/types/MediaTrackId.kt
new file mode 100644
index 0000000..f36471e
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/types/MediaTrackId.kt
@@ -0,0 +1,8 @@
+package ai.rtvi.client.types
+
+/**
+ * An identifier for a media track.
+ */
+data class MediaTrackId(
+    val id: String
+)
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/types/Option.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/types/Option.kt
new file mode 100644
index 0000000..0c4e59f
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/types/Option.kt
@@ -0,0 +1,23 @@
+package ai.rtvi.client.types
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class Option(
+    val name: String,
+    val value: Value
+) {
+    constructor(name: String, value: String) : this(name = name, value = Value.Str(value))
+
+    constructor(name: String, value: Boolean) : this(name = name, value = Value.Bool(value))
+
+    constructor(name: String, value: Double) : this(name = name, value = Value.Number(value))
+
+    constructor(name: String, value: List<Value>) : this(name = name, value = Value.Array(value))
+
+    constructor(name: String, value: Map<String, Value>) : this(
+        name = name,
+        value = Value.Object(value)
+    )
+
+}
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/types/OptionDescription.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/types/OptionDescription.kt
new file mode 100644
index 0000000..ee7f2e9
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/types/OptionDescription.kt
@@ -0,0 +1,9 @@
+package ai.rtvi.client.types
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class OptionDescription(
+    val name: String,
+    val type: Type
+)
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/types/Participant.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/types/Participant.kt
new file mode 100644
index 0000000..220a823
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/types/Participant.kt
@@ -0,0 +1,14 @@
+package ai.rtvi.client.types
+
+/**
+ * Information about a session participant.
+ */
+data class Participant(
+    val id: ParticipantId,
+    val name: String?,
+
+    /**
+     * True if this participant represents the local user, false otherwise.
+     */
+    val local: Boolean
+)
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/types/ParticipantId.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/types/ParticipantId.kt
new file mode 100644
index 0000000..7ebf53c
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/types/ParticipantId.kt
@@ -0,0 +1,8 @@
+package ai.rtvi.client.types
+
+/**
+ * A unique identifier for a session participant.
+ */
+data class ParticipantId(
+    val id: String
+)
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/types/ParticipantTracks.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/types/ParticipantTracks.kt
new file mode 100644
index 0000000..7aa5c78
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/types/ParticipantTracks.kt
@@ -0,0 +1,9 @@
+package ai.rtvi.client.types
+
+/**
+ * Media tracks associated with a participant.
+ */
+data class ParticipantTracks(
+    val audio: MediaTrackId?,
+    val video: MediaTrackId?,
+)
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/types/PipecatMetrics.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/types/PipecatMetrics.kt
new file mode 100644
index 0000000..cd19415
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/types/PipecatMetrics.kt
@@ -0,0 +1,12 @@
+package ai.rtvi.client.types
+
+import kotlinx.serialization.Serializable
+
+/**
+ * Metrics received from a Pipecat instance.
+ */
+@Serializable
+data class PipecatMetrics(
+    val processing: List<PipecatMetricsData>? = null,
+    val ttfb: List<PipecatMetricsData>? = null,
+)
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/types/PipecatMetricsData.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/types/PipecatMetricsData.kt
new file mode 100644
index 0000000..e26ba53
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/types/PipecatMetricsData.kt
@@ -0,0 +1,12 @@
+package ai.rtvi.client.types
+
+import kotlinx.serialization.Serializable
+
+/**
+ * Metrics data received from a Pipecat instance.
+ */
+@Serializable
+data class PipecatMetricsData(
+    val processor: String,
+    val value: Double
+)
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/types/RegisteredHelper.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/types/RegisteredHelper.kt
new file mode 100644
index 0000000..02a142b
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/types/RegisteredHelper.kt
@@ -0,0 +1,8 @@
+package ai.rtvi.client.types
+
+import ai.rtvi.client.helper.VoiceClientHelper
+
+internal class RegisteredHelper(
+    val helper: VoiceClientHelper,
+    val supportedMessages: Set<String>
+)
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/types/ServiceConfig.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/types/ServiceConfig.kt
new file mode 100644
index 0000000..4e9cfa8
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/types/ServiceConfig.kt
@@ -0,0 +1,9 @@
+package ai.rtvi.client.types
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class ServiceConfig(
+    val service: String,
+    val options: List<Option>
+)
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/types/ServiceConfigDescription.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/types/ServiceConfigDescription.kt
new file mode 100644
index 0000000..593eb8d
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/types/ServiceConfigDescription.kt
@@ -0,0 +1,9 @@
+package ai.rtvi.client.types
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class ServiceConfigDescription(
+    val name: String,
+    val options: List<OptionDescription>
+)
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/types/ServiceRegistration.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/types/ServiceRegistration.kt
new file mode 100644
index 0000000..0ff9d34
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/types/ServiceRegistration.kt
@@ -0,0 +1,9 @@
+package ai.rtvi.client.types
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class ServiceRegistration(
+    val service: String,
+    val value: String
+)
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/types/Tracks.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/types/Tracks.kt
new file mode 100644
index 0000000..d1a66d8
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/types/Tracks.kt
@@ -0,0 +1,9 @@
+package ai.rtvi.client.types
+
+/**
+ * Media tracks for the local user and remote bot.
+ */
+data class Tracks(
+    val local: ParticipantTracks,
+    val bot: ParticipantTracks?,
+)
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/types/Transcript.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/types/Transcript.kt
new file mode 100644
index 0000000..fa7c8b9
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/types/Transcript.kt
@@ -0,0 +1,16 @@
+package ai.rtvi.client.types
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+/**
+ * A written transcript of some spoken words.
+ */
+@Serializable
+data class Transcript(
+    val text: String,
+    val final: Boolean,
+    val timestamp: String,
+    @SerialName("user_id")
+    val userId: String
+)
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/types/TransportState.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/types/TransportState.kt
new file mode 100644
index 0000000..89879e2
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/types/TransportState.kt
@@ -0,0 +1,16 @@
+package ai.rtvi.client.types
+
+/**
+ * The current state of the session transport.
+ */
+enum class TransportState {
+    Idle,
+    Initializing,
+    Initialized,
+    Authorizing,
+    Connecting,
+    Connected,
+    Ready,
+    Disconnected,
+    Error
+}
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/types/Type.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/types/Type.kt
new file mode 100644
index 0000000..8d0dd91
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/types/Type.kt
@@ -0,0 +1,22 @@
+package ai.rtvi.client.types
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+enum class Type {
+    @SerialName("string")
+    Str,
+
+    @SerialName("bool")
+    Bool,
+
+    @SerialName("number")
+    Number,
+
+    @SerialName("array")
+    Array,
+
+    @SerialName("object")
+    Object,
+}
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/types/Value.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/types/Value.kt
new file mode 100644
index 0000000..b7862a0
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/types/Value.kt
@@ -0,0 +1,153 @@
+package ai.rtvi.client.types
+
+import kotlinx.serialization.DeserializationStrategy
+import kotlinx.serialization.ExperimentalSerializationApi
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.builtins.ListSerializer
+import kotlinx.serialization.builtins.MapSerializer
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonContentPolymorphicSerializer
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonNull
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.booleanOrNull
+import kotlinx.serialization.json.doubleOrNull
+
+@Serializable(with = ValueSerializer::class)
+sealed interface Value {
+
+    @Serializable(with = ValueNullSerializer::class)
+    object Null : Value
+
+    @Serializable
+    @JvmInline
+    value class Str(val value: String) : Value
+
+    @Serializable
+    @JvmInline
+    value class Bool(val value: Boolean) : Value
+
+    @Serializable
+    @JvmInline
+    value class Number(val value: Double) : Value
+
+    @Serializable(with = ValueArraySerializer::class)
+    @JvmInline
+    value class Array(val value: List<Value>) : Value {
+        constructor(vararg values: Value) : this(value = values.toList())
+    }
+
+    @Serializable(with = ValueObjectSerializer::class)
+    @JvmInline
+    value class Object(val value: Map<String, Value>) : Value {
+        constructor(vararg values: Pair<String, Value>) : this(value = values.toMap())
+    }
+}
+
+internal object ValueSerializer :
+    JsonContentPolymorphicSerializer<Value>(
+        Value::class
+    ) {
+    override fun selectDeserializer(element: JsonElement): DeserializationStrategy<Value> {
+
+        return when (element) {
+            is JsonArray -> Value.Array.serializer()
+            is JsonObject -> Value.Object.serializer()
+            is JsonPrimitive -> {
+
+                if (element is JsonNull) {
+                    return Value.Null.serializer()
+                }
+
+                if (element.isString) {
+                    return Value.Str.serializer()
+                }
+
+                element.doubleOrNull?.apply {
+                    return Value.Number.serializer()
+                }
+
+                element.booleanOrNull?.apply {
+                    return Value.Bool.serializer()
+                }
+
+                throw RuntimeException("Unknown type: $element")
+            }
+        }
+    }
+}
+
+@OptIn(ExperimentalSerializationApi::class)
+internal object ValueNullSerializer : KSerializer<Value.Null> {
+
+    override val descriptor: SerialDescriptor
+        get() = PrimitiveSerialDescriptor("Value.Null", PrimitiveKind.STRING)
+
+    override fun deserialize(decoder: Decoder): Value.Null {
+
+        if (decoder.decodeNotNullMark()) {
+            throw RuntimeException("Expecting 'null'")
+        }
+
+        decoder.decodeNull()
+
+        return Value.Null
+    }
+
+    override fun serialize(encoder: Encoder, value: Value.Null) {
+        encoder.encodeNull()
+    }
+}
+
+internal object ValueArraySerializer : KSerializer<Value.Array> {
+
+    private val innerSerializer = ListSerializer(Value.serializer())
+
+    override val descriptor: SerialDescriptor
+        get() = innerSerializer.descriptor
+
+    override fun deserialize(decoder: Decoder): Value.Array {
+        return Value.Array(innerSerializer.deserialize(decoder))
+    }
+
+    override fun serialize(encoder: Encoder, value: Value.Array) {
+        innerSerializer.serialize(encoder, value.value)
+    }
+}
+
+internal object ValueObjectSerializer : KSerializer<Value.Object> {
+
+    private val innerSerializer = MapSerializer(ValueObjectKeySerializer, Value.serializer())
+
+    override val descriptor: SerialDescriptor
+        get() = innerSerializer.descriptor
+
+    override fun deserialize(decoder: Decoder): Value.Object {
+        return Value.Object(innerSerializer.deserialize(decoder))
+    }
+
+    override fun serialize(encoder: Encoder, value: Value.Object) {
+        innerSerializer.serialize(encoder, value.value)
+    }
+}
+
+internal object ValueObjectKeySerializer : KSerializer<String> {
+
+    override val descriptor: SerialDescriptor
+        get() = PrimitiveSerialDescriptor("Value.Object.Key", PrimitiveKind.STRING)
+
+    override fun deserialize(decoder: Decoder): String {
+        return decoder.decodeString()
+    }
+
+    override fun serialize(encoder: Encoder, value: String) {
+        encoder.encodeString(value)
+    }
+}
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/utils/ConnectionBundle.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/utils/ConnectionBundle.kt
new file mode 100644
index 0000000..b8a285f
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/utils/ConnectionBundle.kt
@@ -0,0 +1,10 @@
+package ai.rtvi.client.utils
+
+import ai.rtvi.client.types.ServiceConfig
+import kotlinx.serialization.Serializable
+
+@Serializable
+internal data class ConnectionBundle(
+    val services: Map<String, String>,
+    val config: List<ServiceConfig>
+)
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/utils/Http.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/utils/Http.kt
new file mode 100644
index 0000000..7d5ba26
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/utils/Http.kt
@@ -0,0 +1,56 @@
+package ai.rtvi.client.utils
+
+import ai.rtvi.client.result.Future
+import ai.rtvi.client.result.HttpError
+import ai.rtvi.client.result.withPromise
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody
+import java.util.concurrent.TimeUnit
+import kotlin.concurrent.thread
+
+private val httpClient = OkHttpClient.Builder()
+    .readTimeout(30, TimeUnit.SECONDS)
+    .writeTimeout(30, TimeUnit.SECONDS)
+    .connectTimeout(30, TimeUnit.SECONDS)
+    .build()
+
+internal fun post(
+    thread: ThreadRef,
+    url: String,
+    body: RequestBody,
+    customHeaders: List<Pair<String, String>>
+): Future<String, HttpError> {
+
+    return withPromise(thread) { promise ->
+        thread {
+            val result = try {
+                val request = Request.Builder().url(url).post(body).apply {
+                    customHeaders.forEach {
+                        header(it.first, it.second)
+                    }
+                }.build()
+
+                httpClient.newCall(request).execute()
+
+            } catch (e: Exception) {
+                promise.resolveErr(HttpError.ExceptionThrown(e))
+                return@thread
+            }
+
+            if (result.code != 200) {
+                promise.resolveErr(HttpError.BadStatusCode(result.code))
+                return@thread
+            }
+
+            val resultBody = result.body?.string()
+
+            if (resultBody == null) {
+                promise.resolveErr(HttpError.MissingResponseBody)
+                return@thread
+            }
+
+            promise.resolveOk(resultBody)
+        }
+    }
+}
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/utils/Json.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/utils/Json.kt
new file mode 100644
index 0000000..ce9a9a9
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/utils/Json.kt
@@ -0,0 +1,5 @@
+package ai.rtvi.client.utils
+
+import kotlinx.serialization.json.Json
+
+internal val JSON_INSTANCE = Json { ignoreUnknownKeys = true }
\ No newline at end of file
diff --git a/rtvi-client-android/src/main/java/ai/rtvi/client/utils/ThreadRef.kt b/rtvi-client-android/src/main/java/ai/rtvi/client/utils/ThreadRef.kt
new file mode 100644
index 0000000..f56c209
--- /dev/null
+++ b/rtvi-client-android/src/main/java/ai/rtvi/client/utils/ThreadRef.kt
@@ -0,0 +1,70 @@
+package ai.rtvi.client.utils
+
+import ai.rtvi.client.result.Future
+import ai.rtvi.client.result.withPromise
+import android.os.Handler
+import android.os.Looper
+
+/**
+ * The thread used by the VoiceClient for callbacks and other operations.
+ */
+class ThreadRef(
+    val thread: Thread,
+    val handler: Handler,
+) {
+    companion object {
+        fun forCurrent() = ThreadRef(
+            Thread.currentThread(),
+            Handler(
+                Looper.myLooper()
+                    ?: throw Exception("Must be called from the main thread, or a thread with a registered Looper")
+            )
+        )
+
+        fun forMain() = ThreadRef(
+            Looper.getMainLooper().thread,
+            Handler(Looper.getMainLooper())
+        )
+    }
+
+    /**
+     * Returns true if this thread is the current thread.
+     */
+    fun isCurrent() = thread == Thread.currentThread()
+
+    /**
+     * Runs the specified Runnable on this thread. If this thread is the current thread,
+     * this will be executed immediately.
+     */
+    fun runOnThread(action: Runnable) {
+        if (isCurrent()) {
+            action.run()
+        } else {
+            handler.post(action)
+        }
+    }
+
+    /**
+     * Runs the specified action on this thread, returning a `Future` to the original thread.
+     */
+    fun <V, E> runOnThreadReturningFuture(action: () -> Future<V, E>): Future<V, E> =
+        withPromise(this) { promise ->
+            runOnThread {
+                action().withCallback(promise::resolve)
+            }
+        }
+
+    /**
+     * Throws an exception if this thread is not the current thread.
+     */
+    fun assertCurrent() {
+        if (!isCurrent()) {
+            throw Exception("Must be invoked from the same thread as the constructor")
+        }
+    }
+
+    fun <R> assertCurrent(action: () -> R): R {
+        assertCurrent()
+        return action()
+    }
+}
\ No newline at end of file
diff --git a/settings.gradle.kts b/settings.gradle.kts
new file mode 100644
index 0000000..5241a38
--- /dev/null
+++ b/settings.gradle.kts
@@ -0,0 +1,23 @@
+pluginManagement {
+    repositories {
+        google {
+            content {
+                includeGroupByRegex("com\\.android.*")
+                includeGroupByRegex("com\\.google.*")
+                includeGroupByRegex("androidx.*")
+            }
+        }
+        mavenCentral()
+        gradlePluginPortal()
+    }
+}
+dependencyResolutionManagement {
+    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+    repositories {
+        google()
+        mavenCentral()
+    }
+}
+
+rootProject.name = "RTVI Client"
+include(":rtvi-client-android")