feat(message): map stream response gpt3.5turbo

Author: lambiengcode

.gitignore

@@ -13,3 +13,4 @@
 .externalNativeBuild
 .cxx
 local.properties
+/app/google-services.json

app/build.gradle

@@ -8,6 +8,8 @@ plugins {
     // DI
     id 'kotlin-kapt'
     id 'com.google.dagger.hilt.android'
+
+    id 'kotlinx-serialization'
 }
 
 android {
@@ -91,6 +93,14 @@ dependencies {
     kapt "com.google.dagger:hilt-compiler:2.44"
     implementation 'com.google.code.gson:gson:2.9.0'
     implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4'
+
+    // Networking
+    def retrofit_version = '2.9.0'
+    def okhttp_version = '4.10.0'
+    implementation "com.squareup.retrofit2:retrofit:$retrofit_version"
+    implementation "com.squareup.retrofit2:converter-gson:$retrofit_version"
+    implementation "com.squareup.okhttp3:okhttp:$okhttp_version"
+    implementation "com.squareup.okhttp3:logging-interceptor:$okhttp_version"
 }
 
 // Allow references to generated code

app/src/main/java/com/chatgptlite/wanted/MainActivity.kt

@@ -74,8 +74,6 @@ class MainActivity : ComponentActivity() {
                                     scope.launch {
                                         drawerState.close()
                                     }
-
-                                    println(it)
                                 },
                                 onNewChatClicked = {
                                     scope.launch {

app/src/main/java/com/chatgptlite/wanted/MainViewModel.kt

@@ -1,10 +1,8 @@
 package com.chatgptlite.wanted
 
-import androidx.activity.compose.BackHandler
 import androidx.lifecycle.ViewModel
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.launch
 
 /**
  * Used to communicate between screens.

app/src/main/java/com/chatgptlite/wanted/constants/ApiEndpoints.kt

@@ -0,0 +1,5 @@
+package com.chatgptlite.wanted.constants
+
+const val baseUrlOpenAI = "https://api.openai.com/"
+const val textCompletionsEndpoint = "v1/completions"
+const val textCompletionsTurboEndpoint = "v1/chat/completions"

app/src/main/java/com/chatgptlite/wanted/constants/Constants.kt

@@ -1,6 +1,10 @@
 package com.chatgptlite.wanted.constants
 
+const val openAIApiKey = "api_key_here"
+
 const val urlToImageAppIcon = "https://res.cloudinary.com/apideck/image/upload/v1672442492/marketplaces/ckhg56iu1mkpc0b66vj7fsj3o/listings/-4-ans_frontend_assets.images.poe.app_icon.png-26-8aa0a2e5f237894d_tbragv.png"
 const val urlToImageAuthor = "https://avatars.githubusercontent.com/u/60530946?v=4"
 const val urlToAvatarGPT = "https://gptapk.com/wp-content/uploads/2023/02/chatgpt-icon.png"
-const val urlToGithub = "https://github.com/lambiengcode"
+const val urlToGithub = "https://github.com/lambiengcode"
+
+const val matchResultTurboString = "\"content\":"

app/src/main/java/com/chatgptlite/wanted/data/api/OpenAIApi.kt

@@ -0,0 +1,13 @@
+package com.chatgptlite.wanted.data.api
+
+import com.chatgptlite.wanted.constants.textCompletionsTurboEndpoint
+import com.google.gson.JsonObject
+import okhttp3.ResponseBody
+import retrofit2.Call
+import retrofit2.http.*
+
+interface OpenAIApi {
+    @POST(textCompletionsTurboEndpoint)
+    @Streaming
+    fun textCompletionsWithStream(@Body body: JsonObject): Call<ResponseBody>
+}

app/src/main/java/com/chatgptlite/wanted/data/remote/MessageRepositoryImpl.kt

@@ -3,6 +3,7 @@ package com.chatgptlite.wanted.data.remote
 import com.chatgptlite.wanted.constants.messageCollection
 import com.chatgptlite.wanted.models.MessageModel
 import com.google.firebase.firestore.FirebaseFirestore
+import com.google.firebase.firestore.Query
 import com.google.firebase.firestore.QuerySnapshot
 import kotlinx.coroutines.channels.awaitClose
 import kotlinx.coroutines.flow.Flow
@@ -16,7 +17,7 @@ class MessageRepositoryImpl @Inject constructor(
     override fun fetchMessages(conversationId: String): Flow<List<MessageModel>> = callbackFlow {
         val result: QuerySnapshot =
             fsInstance.collection(messageCollection).whereEqualTo("conversationId", conversationId)
-                .get().await()
+                .orderBy("createdAt", Query.Direction.DESCENDING).get().await()
 
         if (result.documents.isNotEmpty()) {
             val documents = result.documents

app/src/main/java/com/chatgptlite/wanted/data/remote/OpenAIRepository.kt

@@ -0,0 +1,8 @@
+package com.chatgptlite.wanted.data.remote
+
+import com.chatgptlite.wanted.models.TextCompletionsParam
+import kotlinx.coroutines.flow.Flow
+
+interface OpenAIRepository {
+    fun textCompletionsWithStream(params: TextCompletionsParam): Flow<String>
+}

app/src/main/java/com/chatgptlite/wanted/data/remote/OpenAIRepositoryImpl.kt

@@ -0,0 +1,103 @@
+package com.chatgptlite.wanted.data.remote
+
+import com.chatgptlite.wanted.constants.matchResultTurboString
+import com.chatgptlite.wanted.data.api.OpenAIApi
+import com.chatgptlite.wanted.models.TextCompletionsParam
+import com.chatgptlite.wanted.models.toJson
+import com.google.gson.Gson
+import com.google.gson.JsonObject
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.channels.awaitClose
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.callbackFlow
+import kotlinx.coroutines.withContext
+import okio.IOException
+import org.json.JSONException
+import org.json.JSONObject
+import javax.inject.Inject
+
+
+@Suppress("UNREACHABLE_CODE")
+class OpenAIRepositoryImpl @Inject constructor(
+    private val openAIApi: OpenAIApi,
+): OpenAIRepository {
+    override fun textCompletionsWithStream(params: TextCompletionsParam): Flow<String> = callbackFlow {
+        withContext(Dispatchers.IO) {
+            val response = openAIApi.textCompletionsWithStream(params.toJson()).execute()
+
+            if (response.isSuccessful) {
+                val input = response.body()?.byteStream()?.bufferedReader() ?: throw Exception()
+                try {
+                    while (true) {
+                        val line =
+                            withContext(Dispatchers.IO) {
+                                input.readLine()
+                            } ?: continue
+                        if (line == "data: [DONE]") {
+                            close()
+                        } else if (line.startsWith("data:")) {
+                            try {
+                                // Handle & convert data -> emit to client
+                                val value = lookupDataFromResponseTurbo(line)
+                                trySend(value)
+                            } catch (e: Exception) {
+                                e.printStackTrace()
+                            }
+                        }
+                    }
+                } catch (e: IOException) {
+                    throw Exception(e)
+                } finally {
+                    withContext(Dispatchers.IO) {
+                        input.close()
+                    }
+
+                    awaitClose {
+                        close()
+                    }
+                }
+            } else {
+                if (!response.isSuccessful) {
+                    var jsonObject: JSONObject? = null
+                    try {
+                        jsonObject = JSONObject(response.errorBody()!!.string())
+                    } catch (e: JSONException) {
+                        e.printStackTrace()
+                    }
+                }
+                trySend("Failure! Try again.")
+                awaitClose {
+                    close()
+                }
+            }
+        }
+        close()
+    }
+
+    private fun lookupDataFromResponseTurbo(jsonString: String): String {
+        val splitsJsonString = jsonString.split("[{")
+
+        val indexOfResult: Int = splitsJsonString.indexOfLast {
+            it.contains(matchResultTurboString)
+        }
+
+        val textSplits = if (indexOfResult == -1) listOf() else splitsJsonString[indexOfResult].split(",")
+
+        val indexOfText: Int = textSplits.indexOfLast {
+            it.contains(matchResultTurboString)
+        }
+
+        if (indexOfText != -1) {
+            try {
+                val gson = Gson()
+                val jsonObject = gson.fromJson("{${textSplits[indexOfText]}}", JsonObject::class.java)
+
+                return jsonObject.getAsJsonObject("delta").get("content").asString
+            } catch (e: java.lang.Exception) {
+                println(e.localizedMessage)
+            }
+        }
+
+        return ""
+    }
+}