Hi, I'm Fredrik Jurgell

async waitForGPT(thread, assistant, instruction, interaction) {
      try {
        const run = await this.openai.beta.threads.runs.create(thread.id, {
          assistant_id: assistant.id,
          instructions: instruction,
        });
  
        let runStatus = await this.openai.beta.threads.runs.retrieve(thread.id, run.id);
  
        // Polling mechanism to see if runStatus is completed
        let isAvailable = true;
        let attempts = 0;
        while (runStatus.status !== 'completed' && attempts < 15) {
          if (this.dF) {
            this.dF.feedbackToDiscord(interaction, `runStatus: ${runStatus.status}...`);
          }
          runStatus = await this.openai.beta.threads.runs.retrieve(thread.id, run.id);
  
          // Check for requires_action status (tool call required)
          if (runStatus.status === 'requires_action') {
            if (isAvailable) {
            // Flow information
              console.log('


Called on attempt:', attempts, '


', 'available:', isAvailable, '


');
              isAvailable = false;
              await this.useTool(runStatus, thread, run, interaction);
              await this.getLatestMessage(thread.id);
              isAvailable = true;
              console.log(runStatus);
              continue;
            }
          }
  
          // Check for failed, cancelled, or expired status
          if (['failed', 'cancelled', 'expired'].includes(runStatus.status)) {
            console.log(
              `Run status is '${runStatus.status}'. Unable to complete request.`,
            );
            break;
          }
          console.log('runStatus:', runStatus.status);
          // Loop timer for 3 second
          await new Promise((resolve) => setTimeout(resolve, 3000));
          attempts++;
        }
  
        // Get the latest message
        const latestMessage = await this.getLatestMessage(thread.id);
        console.log('Latest message:', latestMessage?.content[0]?.text ?? 'No content found');
        if (latestMessage?.content[0]?.text?.value !== undefined) {
          if (this.dF) {
            this.dF.feedbackToDiscord(interaction, 'Done!');
          }
          return latestMessage.content[0].text.value;
        }
        else {
          if (this.dF) {
            this.dF.feedbackToDiscord(interaction, 'An error occurred');
          }
          return 'An error occurred while processing your request.';
        }
      }
      catch (error) {
        console.error('Error in waitForGPT:', error);
        if (this.dF) {
          await interaction.followUp(
            'An error occurred while processing your request.',
          );
        }
      }
    }

async login (req, res, next) {
        try {
          const user = await UserModel.authenticate(req.body.username, req.body.password);
    
          const payload = {
            username: user.username,
            email: user.email,
            userId: user._id
          };
    
          // Create the access token with the shorter lifespan.
          const accessToken = jwt.sign(payload, Buffer.from(process.env.ACCESS_TOKEN_SECRET, 'base64'), {
            algorithm: 'RS256',
            expiresIn: process.env.ACCESS_TOKEN_LIFE
          });
    
          res
            .status(201)
            .json({
              access_token: accessToken,
              userId: payload.userId,
              links: [
                {
                  rel: 'profile',
                  href: `${req.protocol}://${req.get("host")}/api/v1/users/${user._id}`
                }
              ]
            });
        } catch (error) {
          // Authentication failed.
          const err = createError(401, 'Credentials invalid or not provided.');
          next(err);
        }
      }