OpenAI ChatGPT Integration

/*

TAG script that takes values from all inputElements with defined TAG, construct prompt with them and gets response
from OpenAI ChatGPS via API.
*/

// Prompt that will be sent to openAi will have this structure:
// “PROMPT [inputElement.getValue()] [inputElement.getValue()]…”
const PROMPT = ”;

const OUTPUT_TAG = ”;
//const OUTPUT_TAG = ‘ai_object_search_output’;
const IS_SELECTABLE_ELEMENT = false;

const OPENAI_API_KEY = ”;

getResponseFromOpenAI(PROMPT, OUTPUT_TAG, IS_SELECTABLE_ELEMENT, OPENAI_API_KEY);

/**
* Retrieves responses from OpenAI’s API based on the values of elements with specified tags in a document.
* It constructs a prompt using the values of input elements, sends this prompt to the OpenAI API, and sets the response
* as the value for output elements.
* @param outputTag
* @param prompt
* @param isSelectableElement
* @param apiKey
*/
function getResponseFromOpenAI(prompt, outputTag, isSelectableElement, apiKey) {
// MAIN
const outputElements = getElementsByTag(outputTag);
const uniqueTags = getTagsFromPrompt(PROMPT);
const tagValueMap = getValuesForTags(uniqueTags);
const completedPrompt = constructPrompt(PROMPT, tagValueMap);

let response = makeApiCallToOpenAI(completedPrompt, apiKey);

if(isSelectableElement){
response = parseResponseToQuestionElement(outputElements[0], response);
}

setValueOfOutputElements(outputElements, response);

// FUNCTIONS
function parseResponseToQuestionElement(outputElement, response){
const options = outputElement.getItems();
let optionsIndexes = [];
for(let option in options){
optionsIndexes.push(option);
}

LEGITO.debug.log(optionsIndexes);
LEGITO.debug.log(options);
let i = 0;
for (let index in options) {
let option = options[index];
let value = Object.values(option).join(”);
LEGITO.debug.log(value + ‘ === ‘ + response);
if (value === response ) {
response = optionsIndexes[i];
LEGITO.debug.log(response);
LEGITO.debug.log(options);
return response;
}
i++;
}
return response;
}

function setValueOfOutputElements(outputElements, value) {
for (let element of outputElements) {
element.setValue(value + ”);
}
}

function getElementsByTag(tag) {
const elementFinder = LEGITO.documentBuilder.event.createElementFinder();
const tags = LEGITO.documentBuilder.getTagsByName(tag);
return elementFinder.findElementsByTagsGlobal(tags);
}

function makeApiCallToOpenAI(prompt, apiKey) {
const restClient = LEGITO.restClient.create();

const headers = {
“Authorization”: “Bearer ” + apiKey, “Content-Type”: “application/json”
};

const body = {
model: “gpt-3.5-turbo”, messages: [{“role”: “system”, “content”: prompt}]
};

const response = restClient.post(‘https://api.openai.com/v1/chat/completions’, body, headers);
if (!response) {
throw new Error(‘ERROR: Error while calling API call, didnt recitative response’);
}

return response.data.choices[0].message.content;
}

function getTagsFromPrompt(prompt) {
const regex = /\[([^\]]+)\]/g;
let matches;
const tags = [];

while ((matches = regex.exec(prompt)) !== null) {
tags.push(matches[1]);
}

return […new Set(tags)];
}

function getValuesForTags(tags) {
let tagValueMap = new Map();

LEGITO.debug.log(tags);

for (let tag of tags) {
const elementFinder = LEGITO.documentBuilder.event.createElementFinder();
const tagsInner = LEGITO.documentBuilder.getTagsByName(tag);
LEGITO.debug.log(tagsInner);
const elements = elementFinder.findElementsByTagsGlobal(tagsInner);

LEGITO.debug.log(elements);

if (elements !== null && elements.length > 0) {
if(elements[0].getElementName() === ‘MoneyElement’){
const value = elements[0].getValue()[0] + ‘ ‘ + elements[0].getValue()[5];
tagValueMap.set(tag, value);
}

if(elements[0].getElementName() === ‘TextElement’){
const value = elements[0].getValue() + ”;
tagValueMap.set(tag, value);
}
} else {
LEGITO.debug.log(‘No elements found for tag ‘ + tag);
}
}

return tagValueMap;
}

function constructPrompt(prompt, tagValueMap) {
return prompt.replace(/\[([^\]]+)\]/g, (match, tag) => {
const value = tagValueMap.get(tag);
return value !== undefined ? value : match;
});
}
}