Integrating AS3 with OpenAI API (ChatGPT) for Simple Querying

Share:

OpenAI offers developers an impressive tool with the ChatGPT model, capable of understanding context, answering queries, and even generating human-like text. While the official OpenAI website provides integration guides for several languages, ActionScript 3 (AS3) isn’t among them. This doesn’t mean AS3 developers are left out in the cold. Despite Adobe no longer supporting AS3, a significant number of developers continue to use it for Adobe Air applications, thanks to Harman’s dedicated maintenance of Adobe Air SDK.

Recognizing this need, we created a simple but powerful AS3 class to provide an easy bridge between AS3 applications and the OpenAI API. The objective here is to offer AS3 developers the means to make quick queries to the OpenAI API, specifically to the GPT-3 model, without the need to figure out the intricacies of the API. The class serves as a basic foundation that can be easily built upon or modified to suit the unique requirements of your application.

Remember, to use the OpenAI API, you’ll need a paid subscription from OpenAI, as per their usage policy. But with the subscription and our handy AS3 class, you’ll be ready to bring the power of GPT-3 (and later models) to your AS3 applications in no time. Happy coding!

 

The Class

package com.codeandvisual.integrations.gpt {
 import flash.events.Event;
 import flash.events.IOErrorEvent;
 import flash.net.URLLoader;
 import flash.net.URLRequest;
 import flash.net.URLRequestHeader;
 import flash.net.URLRequestMethod;
 
 public class OpenAIDemo {
  // Static variables to hold API configuration parameters
  public static var key:String
  public static var endpoint:String
  public static var model:String
  public static var temperature:Number
  public static var callback:Function
  
  // Constructor
  public function OpenAIDemo():void {
   //Intentionally blank  
  }
  
  // Function to initialize the API configuration parameters
  public static function init(thisKey:String, thisTemperature:Number = 0.7, thisEndPoint:String = "https://api.openai.com/v1/chat/completions", thisModel:String = "gpt-3.5-turbo"):void {
   key = thisKey
   temperature = thisTemperature
   endpoint = thisEndPoint
   model = thisModel
  }
  
  // Function to send a request to the API and handle the response
  public static function getResponse(thisInput:String ,thisCallback:Function, thisTemperature:Number = NaN, thisEndPoint:String = "", thisModel:String = ""):void {
   callback = thisCallback
   var myTemperature:Number = isNaN(thisTemperature) ? temperature : thisTemperature;
   var myEndPoint:String = thisEndPoint == "" ? endpoint : thisEndPoint;
   var myModel:String = thisModel == "" ? model : thisModel;
   var myHeaders:Array = [];
   myHeaders.push(new URLRequestHeader("Content-Type", "application/json"));
   myHeaders.push(new URLRequestHeader("Authorization", "Bearer " + key));
   
   // Variables to be sent in the API request
   var myVariables:Object = {}
   myVariables["model"] = model;
   myVariables["messages"] = [{"role": "user", "content": thisInput}];
   myVariables["temperature"] = myTemperature;
   var myLoader:URLLoader = post(myEndPoint, JSON.stringify(myVariables), myHeaders)
  }
  
  // Function to send a POST request to the API
  public static function post(thisPath:String, thisJSONData:String, thisHeaders:Array ):URLLoader {
   var myLoader:URLLoader =  new URLLoader();
   var myRequest:URLRequest
   myRequest = new URLRequest(thisPath);
   myRequest.method = URLRequestMethod.POST;
   myRequest.requestHeaders = thisHeaders
   myRequest.data = thisJSONData;
   
   // Add listeners to handle the API response
   myLoader.addEventListener(IOErrorEvent.IO_ERROR, doError);
   myLoader.addEventListener(Event.COMPLETE, doSuccess);
   
   // Send the API request
   myLoader.load(myRequest);
   return myLoader
  }
  
  // Callback function for successful API response
  public static function doSuccess(e:Event):void {
   var myLoader:URLLoader = e.currentTarget as URLLoader
   removeListeners(myLoader)
   var myData:String = myLoader.data
   var myObject:Object = JSON.parse(myData)
   trace("OpenAI - Response Success")
   callback(myObject);
   callback = null
  }
  
  // Callback function for unsuccessful API response
  public static function doError(e:IOErrorEvent):void {
   var myLoader:URLLoader = e.currentTarget as URLLoader
   removeListeners(myLoader)
   trace("OpenAI - Response Fail: " + myLoader.data)
   callback = null
  }
  // Function to remove listeners after a response is received
  public static function removeListeners(thisLoader:URLLoader):void {
   thisLoader.removeEventListener(IOErrorEvent.IO_ERROR, doError);
   thisLoader.removeEventListener(Event.COMPLETE, doSuccess);
  }
 }
}

You can download it directly here: OpenAIDemo

 

Example Usage:

 

Using the OpenAIDemo class is designed to be straightforward and intuitive. Here’s how you can get started:

// Import our custom OpenAIDemo class
import com.codeandvisual.integrations.gpt.OpenAIDemo;

// Initialize with the required argument - OpenAI API Key
OpenAIDemo.init("YOUR_OPENAI_API_KEY");

// Define the callback function to handle the API's response
function handleResponse(response:Object):void {
 // Handle the API's response here.
 trace(response);
}

// Make a request to the API
OpenAIDemo.getResponse("Translate the following English text to French: 'Hello, world!'", handleResponse);

 

Example Usage Breakdown:

 

After saving the class to the appropriate folder in your src directory (your-src-path/com/codeandvisual/integrations/gpt) and importing it,  you can access the static functions directly. 

First, initialize your OpenAI API settings using the init() function. Replace “<your-openai-api-key>” with your actual OpenAI API key.

OpenAIDemo.init("<your-openai-api-key>", 0.7, "https://api.openai.com/v1/chat/completions", "gpt-3.5-turbo");

In the init() function, the parameters are your OpenAI key, the temperature for the API (which controls the randomness of the AI’s responses), the endpoint for OpenAI’s API, and the model you wish to use (in this case, gpt-3.5-turbo).

Only the first argument is required, you can leave the others blank to use defaults.

Next, define a callback function that will handle the response from the OpenAI API. This function should accept one argument, which will be the object returned by the API. In this example, we’ll simply trace the content of the response.

// Define the callback function to handle the API's response
function handleResponse(response:Object):void {
 // Handle the API's response here.
 trace(response);
}

Now that the callback function is set up, you can use the getResponse() function to send a message to the API.

OpenAIDemo.getResponse("Translate the following English text to French: '{\"text\": \"Hello, world!\"}'", handleResponse);

In this example, we’re asking the API to translate “Hello, world!” from English to French. The getResponse() function sends this message to the API and then uses the handleResponse() function to handle the response. For now, the response from the OpenAI API will be traced in the console.

 

Have fun!

 

And that’s it! You’ve just made a request to the OpenAI API from your AS3 codebase. With this simple setup, you can now start leveraging the power of OpenAI’s models in your application.

Share: