Changeset 38816 for gs3-extensions

Timestamp:

2024-03-02T23:03:08+13:00 (3 months ago)

Author:

davidb

Message:

A series of improvements to the code, up to having a routine that traverses the annotations that are included in the assistant reponse.

File:

• gs3-extensions/dl-chatgpt/trunk/src/react-gui/pages/api/chat.ts (modified) (9 diffs)

gs3-extensions/dl-chatgpt/trunk/src/react-gui/pages/api/chat.ts

@@ -18 +18 @@
 
 
-import { MessageCreateParams, MessageContentText } from 'openai/resources/beta/threads/messages/messages'
-
+import {
+    MessageContentText,
+    MessageCreateParams
+} from 'openai/resources/beta/threads/messages/messages'
 
 import type { NextApiRequest, NextApiResponse } from "next";
@@ -28 +30 @@
 });
 
-const threadByUserId = new Map<string, any>();
+let GS3AssistantLookup : any = null
+
+async function initGS3AssistantsLookup() {
+//const initGS3AssistantsLookup = async () => {
+    GS3AssistantLookup = new Map<string, any>();
+
+    console.log("Setting up GS3AssistantsLookup table");
+
+    console.log("  Retriving first page block, reverse order, so latest GS3 assistant IDs stored");
+    // AssistantsPage
+    //let assistants_list_cursor : CursorPage<Assistant> = await openai.beta.assistants.list({
+    let assistants_list_cursor = await openai.beta.assistants.list({
+    order: "asc",
+    limit: 20,
+    });
+    let paginated_items = assistants_list_cursor.getPaginatedItems();
+    
+    //while (assistants_list_cursor !== null) {
+    while (paginated_items.length > 0) {
+    let last_checked_assistant_id = "";
+    
+    for (const openai_assistant of paginated_items) {
+        const current_assistant_id = openai_assistant.id;
+        
+        const metadata : any = openai_assistant.metadata;
+        
+        if ("greenstone3" in metadata) {
+        if (metadata.greenstone3 === "True") {
+            console.log("    Processing Greenstone3 Assistant:");
+            //console.log(openai_assistant);
+            
+            const site_name = metadata.siteName;
+            const coll_name = metadata.collectionName;
+
+            //console.log(`    Adding entry for site: ${site_name}, collect: ${coll_name}`);
+            
+            if (!(site_name in GS3AssistantLookup)) {
+            GS3AssistantLookup[site_name] = new Map<string, any>();
+            }
+            else {
+            // site already setup and going ....
+            // check to see if pre-existign coll_name already there?
+            if (coll_name in GS3AssistantLookup[site_name]) {
+                console.error(`Warning: Overwriting pre-existing GS3 assistant for site: ${site_name}, collection: ${coll_name}`);
+            }
+            }
+            
+            console.log(`    Storing GS3AssistantsLook[${site_name}][${coll_name}]: ${current_assistant_id}`);
+            GS3AssistantLookup[site_name][coll_name] = current_assistant_id;
+
+        }       
+        }
+        last_checked_assistant_id = current_assistant_id;
+    }
+
+    
+    console.log("  Retrieving next page block, ordered by most recent assistants");
+    assistants_list_cursor = await openai.beta.assistants.list({
+        after: last_checked_assistant_id,
+        order: "asc",
+        limit: 20,
+    });
+    paginated_items = assistants_list_cursor.getPaginatedItems();
+    }
+    console.log("Finished setting up GS3AssistantsLookup table");
+}
+
+/*
+
+function processAnnotations(message_content)
+{
+    
+    annotations = message_content.annotations;
+
+    citations = [];
+
+    // Iterate over the annotations and add footnotes
+    for index, annotation in enumerate(annotations) {
+    //Replace the text with a footnote
+    message_content.value = message_content.value.replace(annotation.text, f' [{index}]')l
+
+    // Gather citations based on annotation attributes
+    if (file_citation := getattr(annotation, 'file_citation', None)) {
+            cited_file = client.files.retrieve(file_citation.file_id)
+            citations.append(f'[{index}] {file_citation.quote} from {cited_file.filename}')
+    }
+    elif (file_path := getattr(annotation, 'file_path', None)) {
+            cited_file = client.files.retrieve(file_path.file_id)
+            citations.append(f'[{index}] Click <here> to download {cited_file.filename}')
+            // Note: File download functionality not implemented above for brevity
+    }
+    }
+    
+    //Add footnotes to the end of the message before displaying to user
+    message_content.value += '\n' + '\n'.join(citations)
+}
+*/
+
+
+
+function processAnnotations(message : MessageContentText)
+{
+    console.log("Process Annotations");
+    
+    const messageContent = message.text;
+    const annotations    = messageContent.annotations;
+
+    const citations: string[] = [];
+    
+    // Iterate over the annotations and add footnotes
+    annotations.forEach(async (annotation, index) => {
+    // Replace the text with a footnote
+    console.log(`  Annotation[${index}: `, annotation);
+
+    messageContent.value = messageContent.value.replace(annotation.text, ` [${index}]`);
+    
+    // Gather citations based on annotation attributes
+    if ("file_citation" in annotation) {
+        const file_citation = annotation.file_citation;
+        console.log(`    Retrieving file_citation for ${file_citation.file_id}`);
+        const citedFile = await openai.files.retrieve(file_citation.file_id);
+        const quote_html = file_citation.quote;
+        const quote = quote_html.replace(/(<([^>]+)>)/g," ").replace(/(\\n|\n)/," ").replace(/\s+/g," ")
+        console.log(`    quote = ${quote}`);
+        
+        citations.push(`[${index}] ${file_citation.quote} from ${citedFile.filename}`);
+    }
+    else if ("file_path" in annotation) {
+        const file_path = annotation.file_path;
+        console.log(`    Retrieving file_path for ${annotation.file_path.file_id}`);
+        const citedFile = await openai.files.retrieve(annotation.file_path.file_id);
+        citations.push(`[${index}] Click <here> to download ${citedFile.filename}`);
+        // Note: File download functionality not implemented above for brevity
+    }
+    });
+    
+    // Add footnotes to the end of the message before displaying to the user
+    console.log("Citations: ", citations, '\n');
+    //console.log("Appending: " + citations.join('\n'));
+        
+    messageContent.value += '\n' + citations.join('\n');
+
+    //return messageContent.value;
+}
+
+
+    
+
+    
+const UserThreadIdLookup = new Map<string, any>();
 
 async function assistantHandler(
@@ -34 +185 @@
     res: NextApiResponse
 ) {    
-    const assistantIdToUse = process.env.ASSISTANT_ID || "";
-    // const assistantIdToUse = "asst_LwUi7f2YMkZG5qTIPtpyhCOD";
+    if (GS3AssistantLookup === null) {
+    await initGS3AssistantsLookup();
+    }
+
+
+    // const assistantIdToUse = process.env.ASSISTANT_ID || "";
+    // // const assistantIdToUse = "asst_LwUi7f2YMkZG5qTIPtpyhCOD";
+
+    const assistantIdToUse = GS3AssistantLookup["thewillow"]["community-contributions"];
     
     //const userId = req.body.userId; // You should include the user ID in the request
     const userId = "test_username";
+
     
     // Create a new thread if it's the user's first message
-    //if (!threadByUserId[userId]) {
-    if (!threadByUserId.has(userId)) {
+    //if (!UserThreadIdLookup[userId]) {
+    if (!UserThreadIdLookup.has(userId)) {
     try {
         const myThread = await openai.beta.threads.create();
@@ -48 +207 @@
         console.log(`Created new thread with ID: '${myThread.id}'"`);
         console.log("========")
-        //threadByUserId[userId] = myThread.id; // Store the thread ID for this user
-        
-        threadByUserId.set(userId,myThread.id); // Store the thread ID for this user
+        //UserThreadIdLookup[userId] = myThread.id; // Store the thread ID for this user
+        
+        UserThreadIdLookup.set(userId,myThread.id); // Store the thread ID for this user
     }
     catch (error) {
@@ -73 +232 @@
     try {
     console.log("  Retrieving thread for userId: " + userId);
-    const myThreadId = threadByUserId.get(userId);
+    const myThreadId = UserThreadIdLookup.get(userId);
     console.log("  myThreadId = " + myThreadId);
     console.log("");
@@ -84 +243 @@
     const myThreadMessage = await openai.beta.threads.messages.create(myThreadId,user_message);
 
-    console.log("This is the message object: ", myThreadMessage, "\n");
+    //console.log("This is the message object: ", myThreadMessage, "\n");
     
     // Run the Assistant
     console.log("Starting run for threadId: " + myThreadId);
     const myRun = await openai.beta.threads.runs.create(
-        //threadByUserId.get(userId),
+        //UserThreadIdLookup.get(userId),
         myThreadId,
         {
@@ -100 +259 @@
         }
     );
-    console.log("This is the run object: ", myRun, "\n");
+    //console.log("This is the run object: ", myRun, "\n");
+    console.log("myRun: ", myRun, "\n");
+
+    const checkStatusUntilCompleted = async (thread_id: string, run_id: string) => {
+        // Give a run that's just started some time to get going
+        await new Promise((resolve) => setTimeout(resolve, 5000));      
+        let run = await openai.beta.threads.runs.retrieve(thread_id,run_id);
+
+        let run_loop_count = 0;
+        while ((run.status === "queued") || (run.status === "in_progress")) {
+        run_loop_count++;
+        
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        console.log(`  ${thread_id} run_id ${run_id}: Getting update on progress [ ` + "=".repeat(run_loop_count)+"> ]");
+        run = await openai.beta.threads.runs.retrieve(thread_id,run_id);
+        console.log(`  ${thread_id} run_id ${run_id}: Status = ${run.status}`);
+        
+        // The following is not strictly necessary, but nice to have logged
+        if (run.status === "completed") {
+            console.log(`  ${thread_id} run_id ${run_id}: Completed!`);
+            console.log("--------");
+            break;
+        }
+        
+        }
+    }
     
     // Periodically retrieve the Run to check on its status
@@ -112 +296 @@
         
         while (myRun.status !== "completed") {
-        console.log(`    ${rrId}: Away to do runs.retrieve() when myRun id ${myRun.id} status is ${myRun.status}`);
+        //console.log(`    ${rrId}: Away to do runs.retrieve() when myRun id ${myRun.id} status is ${myRun.status}`);
         keepRetrievingRun = await openai.beta.threads.runs.retrieve(
-            //threadByUserId.get(userId), // Use the stored thread ID for this user
+            //UserThreadIdLookup.get(userId), // Use the stored thread ID for this user
             myThreadId,
             myRun.id
@@ -134 +318 @@
     // Retrieve the Messages added by the Assistant to the Thread
     const waitForAssistantMessage = async () => {
-        console.log("waitForAssistantMessage() away to call await retrieveRun()");
-        await retrieveRun("withinWait");
-        console.log("waitForAssistantMessage() returned from retrieveRun()");
+        console.log("waitForAssistantMessage() away to call await checkStatusUntilComplete()");
+        //await retrieveRun("withinWait");
+        await checkStatusUntilCompleted(myThreadId,myRun.id);
+        console.log("waitForAssistantMessage() returned from checkRunUntilComplete()");
         
         console.log(`Retrieving messages list for ${myThreadId}`);
         const allMessages = await openai.beta.threads.messages.list(
-        //threadByUserId.get(userId) // Use the stored thread ID for this user
+        //UserThreadIdLookup.get(userId) // Use the stored thread ID for this user
         myThreadId
         );
         
-        // Send the response back to the front end
-        /*
-        res.status(200).json({
-        response: allMessages.data[0].content[0].text.value,
-        });
-        */
         console.log(
-        "------------------------------------------------------------ \n"
+        "--------\n"
         );
 
         const user_request_message: MessageContentText = (myThreadMessage.content[0]) as MessageContentText;
-        const assistant_response_message = allMessages.data[0].content[0] as MessageContentText;
-    
+        const assistant_response_message = (allMessages.data[0].content[0]) as MessageContentText;
+
+        console.log("#####")
+        console.log("Assistant response message:", assistant_response_message, "\n");
+        console.log("#####")
+
+        processAnnotations(assistant_response_message);
+        
         console.log("User: ", user_request_message.text.value);
         console.log("Assistant: ", assistant_response_message.text.value);