Quick Start

dependencies {
  implementation("ai.liquid.leap:leap-sdk:0.10.7")
  implementation("ai.liquid.leap:leap-model-downloader:0.10.7") // Android background downloads

  // Optional: OpenAI-compatible cloud chat client
  // implementation("ai.liquid.leap:leap-openai-client:0.10.7")

  // Optional: Voice assistant widget (Compose Multiplatform)
  // implementation("ai.liquid.leap:leap-ui:0.10.7")
}

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
<uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
<uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />

plugins {
    kotlin("jvm") version "2.3.20"
    application
}

repositories {
    mavenCentral()
}

dependencies {
    implementation("ai.liquid.leap:leap-sdk:0.10.7")

    // Optional:
    // implementation("ai.liquid.leap:leap-openai-client:0.10.7")
    // implementation("ai.liquid.leap:leap-ui:0.10.7") // Compose for Desktop voice widget
}

// settings.gradle.kts
pluginManagement {
    repositories { mavenCentral(); gradlePluginPortal() }
}
dependencyResolutionManagement {
    repositories { mavenCentral() }
}

// build.gradle.kts
plugins {
    kotlin("multiplatform") version "2.3.20"
    id("ai.liquid.leap.nativelibs") version "0.10.7"
}

dependencies {
    implementation("ai.liquid.leap:leap-sdk:0.10.7")
}

kotlin {
    linuxX64 { binaries.executable() }
    // linuxArm64 { binaries.executable() }
    // mingwX64  { binaries.executable() }
}

import android.app.Application
import androidx.lifecycle.AndroidViewModel
import androidx.lifecycle.viewModelScope
import ai.liquid.leap.Conversation
import ai.liquid.leap.ModelRunner
import ai.liquid.leap.downloader.LeapModelDownloader
import ai.liquid.leap.downloader.LeapModelDownloaderNotificationConfig
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking

class ChatViewModel(application: Application) : AndroidViewModel(application) {
    private val modelDownloader = LeapModelDownloader(
        application,
        notificationConfig = LeapModelDownloaderNotificationConfig.build {
            notificationTitleDownloading = "Downloading AI model..."
            notificationTitleDownloaded = "Model ready!"
            notificationContentDownloadingTemplate = "Please wait while the model downloads"
        }
    )

    private var modelRunner: ModelRunner? = null
    private var conversation: Conversation? = null

    private val _isLoading = MutableStateFlow(false)
    val isLoading: StateFlow<Boolean> = _isLoading.asStateFlow()

    private val _downloadProgress = MutableStateFlow(0f)
    val downloadProgress: StateFlow<Float> = _downloadProgress.asStateFlow()

    fun loadModel() {
        viewModelScope.launch {
            _isLoading.value = true
            try {
                modelRunner = modelDownloader.loadModel(
                    modelName = "LFM2-1.2B",
                    quantizationType = "Q5_K_M",
                    progress = { _downloadProgress.value = it.progress }
                )
                conversation = modelRunner?.createConversation()
            } finally {
                _isLoading.value = false
            }
        }
    }

    override fun onCleared() {
        super.onCleared()
        runBlocking(Dispatchers.IO) { modelRunner?.unload() }
    }
}

import ai.liquid.leap.manifest.LeapDownloader
import ai.liquid.leap.manifest.LeapDownloaderConfig
import ai.liquid.leap.message.ChatMessage
import ai.liquid.leap.message.MessageResponse
import kotlinx.coroutines.runBlocking
import java.nio.file.Paths

fun main() = runBlocking {
    // Linux/macOS: ~/.cache/leap   ·   Windows: %LOCALAPPDATA%\leap
    val cacheDir = Paths.get(System.getProperty("user.home"), ".cache", "leap").toString()

    val downloader = LeapDownloader(config = LeapDownloaderConfig(saveDir = cacheDir))

    val runner = downloader.loadModel(
        modelName = "LFM2-1.2B",
        quantizationType = "Q5_K_M",
        progress = { p -> println("Downloading: ${(p.progress * 100).toInt()}%") },
    )

    val conversation = runner.createConversation(systemPrompt = "You are a helpful assistant.")

    conversation.generateResponse(
        ChatMessage(ChatMessage.Role.USER, "Hello!")
    ).collect { resp ->
        when (resp) {
            is MessageResponse.Chunk -> print(resp.text)
            is MessageResponse.Complete -> println("\n[done]")
            else -> {}
        }
    }

    runner.unload()
}

val runner = downloader.loadSimpleModel(
    model = ModelSource(
        modelPath = "/path/to/lfm2-1_2b-q4_k_m.gguf",
        modelName = "LFM2-1.2B-Instruct",
        quantizationId = "Q4_K_M"
    )
)

fun generateResponse(userMessage: String) {
    viewModelScope.launch {
        conversation?.generateResponse(userMessage)
            ?.onEach { response ->
                when (response) {
                    is MessageResponse.Chunk -> _responseText.value += response.text
                    is MessageResponse.ReasoningChunk -> Log.d(TAG, "Reasoning: ${response.reasoning}")
                    is MessageResponse.FunctionCalls -> handleFunctionCalls(response.functionCalls)
                    is MessageResponse.AudioSample -> audioRenderer.enqueue(response.samples, response.sampleRate)
                    is MessageResponse.Complete -> Log.d(TAG, "Done. Stats: ${response.stats}")
                }
            }
            ?.onCompletion { _isGenerating.value = false }
            ?.catch { e -> _errorMessage.value = "Generation failed: ${e.message}" }
            ?.collect()
    }
}

// Text + image (vision-capable model)
val imageMessage = ChatMessage(
    role = ChatMessage.Role.USER,
    content = listOf(
        ChatMessageContent.Text("Describe what you see."),
        ChatMessageContent.Image(jpegBytes)
    )
)

// Text + WAV audio (audio-capable model)
val wavMessage = ChatMessage(
    role = ChatMessage.Role.USER,
    content = listOf(
        ChatMessageContent.Text("Transcribe and summarize this clip."),
        ChatMessageContent.Audio(wavBytes)
    )
)

// Text + raw PCM samples (audio-capable model)
val pcmMessage = ChatMessage(
    role = ChatMessage.Role.USER,
    content = listOf(
        ChatMessageContent.Text("Give feedback on my pronunciation."),
        ChatMessageContent.AudioPcmF32(samples, sampleRate = 16000)
    )
)