One post tagged with "Google AI Edge SDK"

data class GenerationParams(
    val maxOutputTokens: Int = 256,
    val temperature: Float = 0.2f, // deterministic summaries
    val systemInstruction: String? = null
)

sealed interface StreamEvent {
    data class Token(val text: String) : StreamEvent
    data class Complete(val fullText: String) : StreamEvent
    data class Error(val throwable: Throwable) : StreamEvent
}

interface TextGenerator {
    fun streamSummary(
        input: String,
        params: GenerationParams = GenerationParams()
    ): kotlinx.coroutines.flow.Flow<StreamEvent>
}

interface EdgeCapabilityChecker {
    suspend fun isOnDeviceReady(): Boolean
    suspend fun reasonIfUnavailable(): String? // optional details for analytics/UX
}

class EdgeTextGenerator(
    private val appContext: android.content.Context
) : TextGenerator {

    // Consider reusing a single client/session instance (lifecycle-aware) to amortize model load
    // cost and reduce memory thrash. Build it lazily and close when not needed.
    private val lock = Any()
    @Volatile private var client: /* Edge SDK text generation client type */ Any? = null

    private fun ensureClient(): /* client type */ Any {
        synchronized(lock) {
            val cached = client
            if (cached != null) return cached as /* client type */

            // TODO: Construct the Edge/Nano text generation client.
            // This typically requires:
            // - Obtaining an AICore/AI Edge SDK session bound to Gemini Nano
            // - Supplying generation configuration
            // - Handling model download/readiness if the SDK exposes it here

            val created = /* Edge client construction */
            client = created
            return created
        }
    }

    override fun streamSummary(
        input: String,
        params: GenerationParams
    ) = kotlinx.coroutines.flow.callbackFlow<StreamEvent> {
        try {
            val prompt = buildPromptForSummary(input)

            // TODO: Start streaming generation using the Edge SDK.
            // Pseudocode:
            // val session = ensureClient().startSession(params.toEdgeConfig())
            // session.generateStream(prompt).collect { token ->
            //     trySend(StreamEvent.Token(token))
            // }
            // trySend(StreamEvent.Complete(collectedText))

            // Make sure to respect coroutine cancellation (use isActive checks or the SDK’s cancel APIs)
        } catch (t: Throwable) {
            trySend(StreamEvent.Error(t))
        }
        awaitClose {
            // TODO: cancel active streaming request if the SDK supports it
        }
    }

    private fun buildPromptForSummary(input: String): String {
        // Keep prompts short and deterministic for on-device models
        return """
            Summarize the following note into 3 concise bullet points. 
            Focus on key facts and decisions. Avoid filler.

            Note:
            $input
        """.trimIndent()
    }
}

import com.google.ai.client.generativeai.GenerativeModel
import com.google.ai.client.generativeai.type.generationConfig
import com.google.ai.client.generativeai.type.content
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.callbackFlow
import kotlinx.coroutines.isActive

class CloudTextGenerator(
    apiKey: String,
    modelName: String = "gemini-1.5-flash"
) : TextGenerator {

    private val model = GenerativeModel(
        modelName = modelName,
        apiKey = apiKey
    )

    override fun streamSummary(
        input: String,
        params: GenerationParams
    ): Flow<StreamEvent> = callbackFlow {
        val prompt = buildPromptForSummary(input)
        val config = generationConfig {
            temperature = params.temperature.toDouble()
            maxOutputTokens = params.maxOutputTokens
        }
        val request = content { text(prompt) }

        // Streaming
        try {
            val sb = StringBuilder()
            val stream = model.generateContentStream(
                request,
                generationConfig = config
            )

            // Collect chunks; the SDK provides a Flow-like stream
            val job = kotlinx.coroutines.GlobalScope.launch {
                try {
                    stream.collect { chunk ->
                        if (!isActive) return@collect
                        val delta = chunk.text.orEmpty()
                        if (delta.isNotEmpty()) {
                            sb.append(delta)
                            trySend(StreamEvent.Token(delta))
                        }
                    }
                    trySend(StreamEvent.Complete(sb.toString()))
                } catch (t: Throwable) {
                    trySend(StreamEvent.Error(t))
                }
            }

            awaitClose { job.cancel() }
        } catch (t: Throwable) {
            trySend(StreamEvent.Error(t))
            close(t)
        }
    }

    private fun buildPromptForSummary(input: String): String {
        return """
            Summarize this note into 3 concise bullet points.
            Use neutral tone and keep each bullet under 20 words.

            Note:
            $input
        """.trimIndent()
    }
}

class SummarizerRepository(
    private val edgeChecker: EdgeCapabilityChecker,
    private val edge: TextGenerator,
    private val cloud: TextGenerator
) {

    fun streamSummary(input: String, params: GenerationParams): kotlinx.coroutines.flow.Flow<StreamEvent> =
        kotlinx.coroutines.flow.flow {
            // Guardrails
            val sanitized = sanitizeInput(input)
            require(sanitized.isNotBlank()) { "Input is empty after sanitization." }

            val useOnDevice = runCatching { edgeChecker.isOnDeviceReady() }.getOrElse { false }
            val source = if (useOnDevice) edge else cloud

            emitAll(source.streamSummary(sanitized, params))
        }

    private fun sanitizeInput(input: String): String {
        // Boundary control: prevent absurdly large prompts, avoid OOM
        val maxChars = 6_000 // tune for your app; align with token limits
        return input.trim().take(maxChars)
    }
}

data class SummaryUiState(
    val inProgress: Boolean = false,
    val streamedText: String = "",
    val error: String? = null
)

@dagger.hilt.android.lifecycle.HiltViewModel
class SummaryViewModel @javax.inject.Inject constructor(
    private val repository: SummarizerRepository,
    @javax.inject.Named("defaultParams") private val defaultParams: GenerationParams
) : androidx.lifecycle.ViewModel() {

    private val _state = kotlinx.coroutines.flow.MutableStateFlow(SummaryUiState())
    val state: kotlinx.coroutines.flow.StateFlow<SummaryUiState> = _state

    private var currentJob: kotlinx.coroutines.Job? = null

    fun summarize(note: String) {
        currentJob?.cancel()
        _state.value = SummaryUiState(inProgress = true)

        currentJob = viewModelScope.launch {
            // Optional timeout for UX responsiveness (tune as needed)
            withTimeoutOrNull(15_000L) {
                repository.streamSummary(note, defaultParams)
                    .collect { event ->
                        when (event) {
                            is StreamEvent.Token -> {
                                _state.update { it.copy(streamedText = it.streamedText + event.text) }
                            }
                            is StreamEvent.Complete -> {
                                _state.update { it.copy(inProgress = false, streamedText = event.fullText) }
                            }
                            is StreamEvent.Error -> {
                                _state.update { it.copy(inProgress = false, error = event.throwable.message) }
                            }
                        }
                    }
            } ?: run {
                _state.update { it.copy(inProgress = false, error = "Timed out. Try again.") }
            }
        }
    }

    fun cancel() {
        currentJob?.cancel()
        _state.update { it.copy(inProgress = false) }
    }

    override fun onCleared() {
        currentJob?.cancel()
    }
}

@Composable
fun SummarizeNoteScreen(
    viewModel: SummaryViewModel = androidx.hilt.navigation.compose.hiltViewModel()
) {
    val state by viewModel.state.collectAsState()
    var noteText by remember { mutableStateOf("") }

    Column(modifier = Modifier.padding(16.dp)) {
        OutlinedTextField(
            value = noteText,
            onValueChange = { noteText = it },
            label = { Text("Paste note") },
            modifier = Modifier.fillMaxWidth().weight(1f, fill = false),
            minLines = 6
        )
        Spacer(Modifier.height(12.dp))
        Row {
            Button(
                onClick = { viewModel.summarize(noteText) },
                enabled = noteText.isNotBlank() && !state.inProgress
            ) { Text("Summarize") }

            Spacer(Modifier.width(8.dp))

            OutlinedButton(
                onClick = { viewModel.cancel() },
                enabled = state.inProgress
            ) { Text("Cancel") }
        }
        Spacer(Modifier.height(16.dp))

        when {
            state.inProgress -> {
                LinearProgressIndicator(modifier = Modifier.fillMaxWidth())
                Spacer(Modifier.height(8.dp))
                Text(
                    text = state.streamedText.ifBlank { "Generating..." },
                    style = MaterialTheme.typography.bodyLarge
                )
            }
            state.error != null -> {
                Text(
                    text = state.error ?: "Something went wrong",
                    color = MaterialTheme.colorScheme.error
                )
            }
            state.streamedText.isNotBlank() -> {
                Text(
                    text = state.streamedText,
                    style = MaterialTheme.typography.bodyLarge
                )
            }
        }
    }
}

@Module
@InstallIn(SingletonComponent::class)
object AiModule {

    @Provides
    @Singleton
    fun provideEdgeCapabilityChecker(
        app: Application
    ): EdgeCapabilityChecker = object : EdgeCapabilityChecker {
        override suspend fun isOnDeviceReady(): Boolean {
            // Prefer AI Edge SDK’s official readiness check, which may expose:
            // - model availability
            // - version compatibility
            // - minimum device capabilities
            // Avoid guessing via package manager.
            // return edgeSdk.checkModelReady(model = GeminiNano)

            // Placeholder until you wire the real call:
            return false
        }

        override suspend fun reasonIfUnavailable(): String? = null
    }

    @Provides
    @Singleton
    @Named("defaultParams")
    fun provideDefaultParams(): GenerationParams = GenerationParams(
        maxOutputTokens = 256,
        temperature = 0.2f
    )

    @Provides
    @Singleton
    fun provideEdgeTextGenerator(app: Application): TextGenerator =
        EdgeTextGenerator(app)

    @Provides
    @Singleton
    fun provideCloudTextGenerator(): TextGenerator =
        CloudTextGenerator(
            apiKey = BuildConfig.GEMINI_API_KEY,
            modelName = "gemini-1.5-flash"
        )

    @Provides
    @Singleton
    fun provideSummarizerRepository(
        checker: EdgeCapabilityChecker,
        edge: TextGenerator,
        cloud: TextGenerator
    ): SummarizerRepository = SummarizerRepository(checker, edge, cloud)
}