Merge branch 'master' into exception-wrappers

Author: CJCrafter

build.gradle.kts

@@ -1,7 +1,7 @@
 import com.github.breadmoirai.githubreleaseplugin.GithubReleaseTask
 
 group = "com.cjcrafter"
-version = "1.2.1"
+version = "1.2.2"
 
 plugins {
     `java-library`

src/main/kotlin/com/cjcrafter/openai/OpenAI.kt

@@ -65,12 +65,12 @@ class OpenAI @JvmOverloads constructor(
      * @throws IllegalArgumentException If the input arguments are invalid.
      */
     @Throws(IOException::class)
-    fun generateResponse(request: ChatRequest): ChatResponse {
+    fun createChatCompletion(request: ChatRequest): ChatResponse {
         request.stream = false // use streamResponse for stream=true
         val httpRequest = buildRequest(request)
 
         // Save the JsonObject to check for errors
-        var rootObject: JsonObject? = null
+        var rootObject: JsonObject?
         try {
             client.newCall(httpRequest).execute().use { response ->
 
@@ -86,7 +86,7 @@ class OpenAI @JvmOverloads constructor(
     }
 
     /**
-     * This is a helper method that calls [streamResponse], which lets you use
+     * This is a helper method that calls [streamChatCompletion], which lets you use
      * the generated tokens in real time (As ChatGPT generates them).
      *
      * This method does not block the thread. Method calls to [onResponse] are
@@ -112,8 +112,8 @@ class OpenAI @JvmOverloads constructor(
      * @param onResponse The method to call for each chunk.
      * @since 1.2.0
      */
-    fun streamResponseKotlin(request: ChatRequest, onResponse: ChatResponseChunk.() -> Unit) {
-        streamResponse(request, { it.onResponse() })
+    fun streamChatCompletionKotlin(request: ChatRequest, onResponse: ChatResponseChunk.() -> Unit) {
+        streamChatCompletion(request, { it.onResponse() })
     }
 
     /**
@@ -122,7 +122,7 @@ class OpenAI @JvmOverloads constructor(
      * to update the user without long delays between their input and OpenAI's
      * response.
      *
-     * For *"simpler"* calls, you can use [generateResponse] which will block
+     * For *"simpler"* calls, you can use [createChatCompletion] which will block
      * the thread until the entire response is generated.
      *
      * Instead of using the [ChatResponse], this method uses [ChatResponseChunk].
@@ -137,16 +137,17 @@ class OpenAI @JvmOverloads constructor(
      * @param onResponse The method to call for each chunk.
      * @param onFailure  The method to call if the HTTP fails. This method will
      *                   not be called if OpenAI returns an error.
-     * @see generateResponse
-     * @see streamResponseKotlin
+     * @see createChatCompletion
+     * @see streamChatCompletionKotlin
      * @since 1.2.0
      */
     @JvmOverloads
-    fun streamResponse(
+    fun streamChatCompletion(
         request: ChatRequest,
         onResponse: Consumer<ChatResponseChunk>, // use Consumer instead of Kotlin for better Java syntax
         onFailure: Consumer<IOException> = Consumer { it.printStackTrace() }
     ) {
+        @Suppress("DEPRECATION")
         request.stream = true // use requestResponse for stream=false
         val httpRequest = buildRequest(request)
 

src/test/java/JavaChatStreamTest.java

@@ -1,3 +1,4 @@
+import com.cjcrafter.openai.OpenAI;
 import com.cjcrafter.openai.chat.*;
 import io.github.cdimascio.dotenv.Dotenv;
 
@@ -9,27 +10,31 @@ public class JavaChatStreamTest {
 
     public static void main(String[] args) {
         Scanner scan = new Scanner(System.in);
+
+        // Prepare the ChatRequest
+        ChatMessage prompt = ChatMessage.toSystemMessage("Be as unhelpful as possible");
+        List<ChatMessage> messages = new ArrayList<>(List.of(prompt));
+        ChatRequest request = ChatRequest.builder()
+                .model("gpt-3.5-turbo")
+                .messages(messages).build();
+
+        // Load TOKEN from .env file
         String key = Dotenv.load().get("OPENAI_TOKEN");
+        OpenAI openai = new OpenAI(key);
+
+        // Ask the user for input
+        System.out.println("Enter text below:\n\n");
+        String input = scan.nextLine();
+
+        // Stream the response. Print out each 'delta' (new tokens)
+        messages.add(new ChatMessage(ChatUser.USER, input));
+        openai.streamChatCompletion(request, message -> {
+            System.out.print(message.get(0).getDelta());
 
-        // Create the initial prompt, we will reuse it later.
-        String initialPrompt = "You are a customer support chat-bot. Write brief summaries of the user's questions so that agents can easily find the answer in a database.";
-        List<ChatMessage> messages = new ArrayList<>(List.of(new ChatMessage(ChatUser.SYSTEM, initialPrompt)));
-        ChatRequest request = new ChatRequest("gpt-3.5-turbo", messages);
-        ChatBot bot = new ChatBot(key);
-
-        while (true) {
-            System.out.println("Enter text below:\n\n");
-            String input = scan.nextLine();
-
-            // Generate a response, and print it to the user.
-            messages.add(new ChatMessage(ChatUser.USER, input));
-            bot.streamResponse(request, message -> {
-                System.out.print(message.get(0).getDelta());
-
-                if (message.get(0).getFinishReason() != null) {
-                    messages.add(message.get(0).getMessage());
-                }
-            });
-        }
+            // Once the message is complete, we should save the message to our
+            // conversation (In case you want to generate more responses).
+            if (message.get(0).getFinishReason() != null)
+                messages.add(message.get(0).getMessage());
+        });
     }
 }

src/test/java/JavaChatTest.java

@@ -1,3 +1,4 @@
+import com.cjcrafter.openai.OpenAI;
 import com.cjcrafter.openai.chat.*;
 import io.github.cdimascio.dotenv.Dotenv;
 
@@ -10,24 +11,44 @@ public class JavaChatTest {
 
     public static void main(String[] args) throws IOException {
         Scanner scan = new Scanner(System.in);
-        String key = Dotenv.load().get("OPENAI_TOKEN");
 
-        // Create the initial prompt, we will reuse it later.
-        String initialPrompt = "You are a customer support chat-bot. Write brief summaries of the user's questions so that agents can easily find the answer in a database.";
-        List<ChatMessage> messages = new ArrayList<>(List.of(new ChatMessage(ChatUser.SYSTEM, initialPrompt)));
-        ChatRequest request = new ChatRequest("gpt-3.5-turbo", messages);
-        ChatBot bot = new ChatBot(key);
+        // This is the prompt that the bot will refer back to for every message.
+        ChatMessage prompt = ChatMessage.toSystemMessage("You are a customer support chat-bot. Write brief summaries of the user's questions so that agents can easily find the answer in a database.");
+
+        // Use a mutable (modifiable) list! Always! You should be reusing the
+        // ChatRequest variable, so in order for a conversation to continue
+        // you need to be able to modify the list.
+        List<ChatMessage> messages = new ArrayList<>(List.of(prompt));
 
+        // ChatRequest is the request we send to OpenAI API. You can modify the
+        // model, temperature, maxTokens, etc. This should be saved, so you can
+        // reuse it for a conversation.
+        ChatRequest request = ChatRequest.builder()
+                .model("gpt-3.5-turbo")
+                .messages(messages).build();
+
+        // Loads the API key from the .env file in the root directory.
+        String key = Dotenv.load().get("OPENAI_TOKEN");
+        OpenAI openai = new OpenAI(key);
+
+        // The conversation lasts until the user quits the program
         while (true) {
+
+            // Prompt the user to enter a response
             System.out.println("Enter text below:\n\n");
             String input = scan.nextLine();
 
-            // Generate a response, and print it to the user.
-            messages.add(new ChatMessage(ChatUser.USER, input));
-            ChatResponse response = bot.generateResponse(request);
+            // Add the newest user message to the conversation
+            messages.add(ChatMessage.toUserMessage(input));
+
+            // Use the OpenAI API to generate a response to the current
+            // conversation. Print the resulting message.
+            ChatResponse response = openai.createChatCompletion(request);
             System.out.println("\n" + response.get(0).getMessage().getContent());
 
-            // Save the generated message to the bot's conversational memory
+            // Save the generated message to the conversational memory. It is
+            // crucial to save this message, otherwise future requests will be
+            // confused that there was no response.
             messages.add(response.get(0).getMessage());
         }
     }

src/test/kotlin/KotlinChatStreamTest.kt

@@ -1,4 +1,4 @@
-import com.cjcrafter.openai.chat.ChatBot
+import com.cjcrafter.openai.OpenAI
 import com.cjcrafter.openai.chat.ChatMessage.Companion.toSystemMessage
 import com.cjcrafter.openai.chat.ChatMessage.Companion.toUserMessage
 import com.cjcrafter.openai.chat.ChatRequest
@@ -7,26 +7,28 @@ import java.util.*
 
 fun main(args: Array<String>) {
     val scan = Scanner(System.`in`)
-    val key = dotenv()["OPENAI_TOKEN"]
 
-    // Create the initial prompt, we will reuse it later.
-    val initialPrompt = "Follow the users instructions"
-    val messages = mutableListOf(initialPrompt.toSystemMessage())
-    val request = ChatRequest("gpt-3.5-turbo", messages)
-    val bot = ChatBot(key)
+    // Prepare the ChatRequest
+    val prompt = "Be as unhelpful as possible"
+    val messages = mutableListOf(prompt.toSystemMessage())
+    val request = ChatRequest(model="gpt-3.5-turbo", messages=messages)
+
+    // Loads the API key from the .env file in the root directory.
+    val key = dotenv()["OPENAI_TOKEN"]
+    val openai = OpenAI(key)
 
-    while (true) {
-        println("Enter text below:\n")
-        val input = scan.nextLine()
+    // Ask the user for input
+    println("Enter text below:\n")
+    val input = scan.nextLine()
 
-        // Generate a response, and print it to the user.
-        messages.add(input.toUserMessage())
-        bot.streamResponseKotlin(request) {
-            print(choices[0].delta)
+    // Generate a response, and print it to the user.
+    messages.add(input.toUserMessage())
+    openai.streamChatCompletionKotlin(request) {
+        print(choices[0].delta)
 
-            if (choices[0].finishReason != null) {
-                messages.add(choices[0].message)
-            }
-        }
+        // Once the message is complete, we should save the message to our
+        // conversation (In case you want to generate more responses).
+        if (choices[0].finishReason != null)
+            messages.add(choices[0].message)
     }
 }

src/test/kotlin/KotlinChatTest.kt

@@ -1,4 +1,4 @@
-import com.cjcrafter.openai.chat.ChatBot
+import com.cjcrafter.openai.OpenAI
 import com.cjcrafter.openai.chat.ChatMessage.Companion.toSystemMessage
 import com.cjcrafter.openai.chat.ChatMessage.Companion.toUserMessage
 import com.cjcrafter.openai.chat.ChatRequest
@@ -7,24 +7,42 @@ import java.util.*
 
 fun main(args: Array<String>) {
     val scan = Scanner(System.`in`)
-    val key = dotenv()["OPENAI_TOKEN"]
 
-    // Create the initial prompt, we will reuse it later.
-    val initialPrompt = "You are a customer support chat-bot. Write brief summaries of the user's questions so that agents can easily find the answer in a database."
-    val messages = mutableListOf(initialPrompt.toSystemMessage())
-    val request = ChatRequest("gpt-3.5-turbo", messages)
-    val bot = ChatBot(key)
+    // This is the prompt that the bot will refer back to for every message.
+    val prompt = "You are a customer support chat-bot. Write brief summaries of the user's questions so that agents can easily find the answer in a database."
+
+    // Use a mutable (modifiable) list! Always! You should be reusing the
+    // ChatRequest variable, so in order for a conversation to continue you
+    // need to be able to modify the list.
+    val messages = mutableListOf(prompt.toSystemMessage())
 
+    // ChatRequest is the request we send to OpenAI API. You can modify the
+    // model, temperature, maxTokens, etc. This should be saved, so you can
+    // reuse it for a conversation.
+    val request = ChatRequest(model="gpt-3.5-turbo", messages=messages)
+
+    // Loads the API key from the .env file in the root directory.
+    val key = dotenv()["OPENAI_TOKEN"]
+    val openai = OpenAI(key)
+
+    // The conversation lasts until the user quits the program
     while (true) {
+
+        // Prompt the user to enter a response
         println("Enter text below:\n")
         val input = scan.nextLine()
 
-        // Generate a response, and print it to the user.
+        // Add the newest user message to the conversation
         messages.add(input.toUserMessage())
-        val response = bot.generateResponse(request)
+
+        // Use the OpenAI API to generate a response to the current
+        // conversation. Print the resulting message.
+        val response = openai.createChatCompletion(request)
         println("\n${response[0].message.content}\n")
 
-        // Save the generated message to the bot's conversational memory
+        // Save the generated message to the conversational memory. It is
+        // crucial to save this message, otherwise future requests will be
+        // confused that there was no response.
         messages.add(response[0].message)
     }
 }