Ballerina for AI as a Service

service / on new http:Listener(9090) {
    resource function post products() returns int|error {
        // Get the product details from the last inserted row of the Google Sheet.
        sheets:Range range = check gsheets->getRange(googleSheetId, "Sheet1", "A2:F");
        var [name, benefits, features, productType] = getProduct(range);

        // Generate a product description from OpenAI for a given product name.
        string query = string `generate a product descirption in 250 words about ${name}`;
        chat:CreateChatCompletionRequest request = {
            model: "gpt-4o",
            messages: [
                {
                    "role": "user",
                    "content": query
                }
            ],
            max_tokens: 100
        };

        chat:CreateChatCompletionResponse completionRes = check openAIChat->/chat/completions.post(request);

        // Generate a product image from OpenAI for the given product.
        images:CreateImageRequest imagePrmt = {prompt: string `${name}, ${benefits}, ${features}`};
        images:ImagesResponse imageRes = check openAIImages->/images/generations.post(imagePrmt);

        // Create a product in Shopify.
        shopify:CreateProduct product = {
            product: {
                title: name,
                body_html: completionRes.choices[0].message.content,
                tags: features,
                product_type: productType,
                images: [{src: imageRes.data[0].url}]
            }
        };
        shopify:ProductObject prodObj = check shopify->createProduct(product);
        int? pid = prodObj?.product?.id;
        if pid is () {
            return error("Error in creating product in Shopify");
        }
        return pid;
    }
}

public function main(string audioURL, string toLanguage) returns error? {
    // Creates a HTTP client to download the audio file
    http:Client audioEP = check new (audioURL);
    http:Response httpResp = check audioEP->get("");
    byte[] audioBytes = check httpResp.getBinaryPayload();
    check io:fileWriteBytes(AUDIO_FILE_PATH, audioBytes);

    // Creates a request to translate the audio file to text (English)
    audio:CreateTranslationRequest translationsReq = {
        file: {fileContent: check io:fileReadBytes(AUDIO_FILE_PATH), fileName: AUDIO_FILE},
        model: "whisper-1"
    };

    // Translates the audio file to text (English)
    audio:Client openAIAudio = check new ({auth: {token: openAIToken}});
    audio:CreateTranscriptionResponse transcriptionRes = check openAIAudio->/audio/translations.post(translationsReq);
    io:println("Audio text in English: ", transcriptionRes.text);

    final chat:Client openAIChat = check new ({
        auth: {
            token: openAIToken
        }
    });

    string query = string `Translate the following text from English to ${toLanguage} : ${transcriptionRes.text}`;

    // Creates a request to translate the text from English to another language
    chat:CreateChatCompletionRequest request = {
        model: "gpt-4o",
        messages: [
            {
                "role": "user",
                "content": query
            }
        ],
        temperature: 0.7,
        max_tokens: 256,
        top_p: 1,
        frequency_penalty: 0,
        presence_penalty: 0
    };

    // Translates the text from English to another language
    chat:CreateChatCompletionResponse response = check openAIChat->/chat/completions.post(request);
    string? translatedText = response.choices[0].message.content;

    if translatedText is () {
        return error("Failed to translate the given audio.");
    }
    io:println("Translated text: ", translatedText);
}

public function main(string podcastURL) returns error? {
    // Creates a HTTP client to download the audio file
    http:Client podcastEP = check new (podcastURL);
    http:Response httpResp = check podcastEP->get("");
    byte[] audioBytes = check httpResp.getBinaryPayload();
    check io:fileWriteBytes(AUDIO_FILE_PATH, audioBytes);

    // Creates a request to translate the audio file to text (English)
    audio:CreateTranscriptionRequest transcriptionsReq = {
        file: {fileContent: (check io:fileReadBytes(AUDIO_FILE_PATH)), fileName: AUDIO_FILE},
        model: "whisper-1"
    };

    // Converts the audio file to text (English) using OpenAI speach to text API
    audio:Client openAIAudio = check new ({auth: {token: openAIToken}});
    audio:CreateTranscriptionResponse transcriptionsRes = check openAIAudio->/audio/transcriptions.post(transcriptionsReq);
    io:println("Text from the audio :", transcriptionsRes.text);

    // Creates a request to summarize the text
    chat:CreateChatCompletionRequest request = {
        model: "gpt-4o-mini",
        messages: [
            {
                role: "user",
                content: string `Summarize the following text to 100 characters : ${transcriptionsRes.text}`
            }
        ],
        temperature: 0.7,
        max_tokens: 256,
        top_p: 1,
        frequency_penalty: 0,
        presence_penalty: 0
    };

    // Summarizes the text using OpenAI text completion API
    final chat:Client openAIChat = check new ({auth: {token: openAIToken}});
    chat:CreateChatCompletionResponse completionRes = check openAIChat->/chat/completions.post(request);

    string? summerizedText = completionRes.choices[0].message.content;
    if summerizedText is () {
        return error("Failed to summarize the given audio.");
    }
    io:println("Summarized text: ", summerizedText);

    // Tweet it out!
    final twitter:Client twitter = check new ({auth: {token: token}});
    twitter:TweetCreateResponse tweet = check twitter->/tweets.post({text: summerizedText});
    io:println("Tweet: ", tweet);
}