feat: remove customGpts

api/server/routes/ask/askBingAI.js

@@ -0,0 +1,226 @@
+const express = require('express');
+const crypto = require('crypto');
+const router = express.Router();
+const { titleConvo, askBing } = require('../../../app');
+const { saveMessage, getConvoTitle, saveConvo, getConvo } = require('../../../models');
+const { handleError, sendMessage, createOnProgress, handleText } = require('./handlers');
+
+router.post('/', async (req, res) => {
+  const {
+    endpoint,
+    text,
+    messageId,
+    overrideParentMessageId = null,
+    parentMessageId,
+    conversationId: oldConversationId
+  } = req.body;
+  if (text.length === 0) return handleError(res, { text: 'Prompt empty or too short' });
+  if (endpoint !== 'bingAI') return handleError(res, { text: 'Illegal request' });
+
+  // build user message
+  const conversationId = oldConversationId || crypto.randomUUID();
+  const isNewConversation = !oldConversationId;
+  const userMessageId = messageId;
+  const userParentMessageId = parentMessageId || '00000000-0000-0000-0000-000000000000';
+  let userMessage = {
+    messageId: userMessageId,
+    sender: 'User',
+    text,
+    parentMessageId: userParentMessageId,
+    conversationId,
+    isCreatedByUser: true
+  };
+
+  // build endpoint option
+  let endpointOption = {};
+  if (req.body?.jailbreak)
+    endpointOption = {
+      jailbreak: req.body?.jailbreak || false,
+      jailbreakConversationId: req.body?.jailbreakConversationId || null,
+      systemMessage: req.body?.systemMessage || null,
+      context: req.body?.context || null,
+      toneStyle: req.body?.toneStyle || 'fast'
+    };
+  else
+    endpointOption = {
+      jailbreak: req.body?.jailbreak || false,
+      systemMessage: req.body?.systemMessage || null,
+      context: req.body?.context || null,
+      conversationSignature: req.body?.conversationSignature || null,
+      clientId: req.body?.clientId || null,
+      invocationId: req.body?.invocationId || null,
+      toneStyle: req.body?.toneStyle || 'fast'
+    };
+
+  console.log('ask log', {
+    userMessage,
+    endpointOption,
+    conversationId
+  });
+
+  if (!overrideParentMessageId) {
+    await saveMessage(userMessage);
+    await saveConvo(req?.session?.user?.username, {
+      ...userMessage,
+      ...endpointOption,
+      conversationId,
+      endpoint
+    });
+  }
+
+  // eslint-disable-next-line no-use-before-define
+  return await ask({
+    isNewConversation,
+    userMessage,
+    endpointOption,
+    conversationId,
+    preSendRequest: true,
+    overrideParentMessageId,
+    req,
+    res
+  });
+});
+
+const ask = async ({
+  isNewConversation,
+  userMessage,
+  endpointOption,
+  conversationId,
+  preSendRequest = true,
+  overrideParentMessageId = null,
+  req,
+  res
+}) => {
+  let { text, parentMessageId: userParentMessageId, messageId: userMessageId } = userMessage;
+
+  res.writeHead(200, {
+    Connection: 'keep-alive',
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache, no-transform',
+    'Access-Control-Allow-Origin': '*',
+    'X-Accel-Buffering': 'no'
+  });
+
+  if (preSendRequest) sendMessage(res, { message: userMessage, created: true });
+
+  try {
+    const progressCallback = createOnProgress();
+    const abortController = new AbortController();
+    res.on('close', () => abortController.abort());
+    let response = await askBing({
+      text,
+      parentMessageId: userParentMessageId,
+      conversationId,
+      ...endpointOption,
+      onProgress: progressCallback.call(null, {
+        res,
+        text,
+        parentMessageId: overrideParentMessageId || userMessageId
+      }),
+      abortController
+    });
+
+    console.log('BING RESPONSE', response);
+
+    // STEP1 generate response message
+    response.text = response.response || response.details.spokenText || '**Bing refused to answer.**';
+
+    let responseMessage = {
+      text: await handleText(response, true),
+      suggestions:
+        response.details.suggestedResponses && response.details.suggestedResponses.map(s => s.text),
+      jailbreak: endpointOption?.jailbreak
+    };
+    // // response.text = await handleText(response, true);
+    // response.suggestions =
+    //   response.details.suggestedResponses && response.details.suggestedResponses.map(s => s.text);
+
+    if (endpointOption?.jailbreak) {
+      responseMessage.conversationId = response.jailbreakConversationId;
+      responseMessage.messageId = response.messageId || response.details.messageId;
+      responseMessage.parentMessageId = overrideParentMessageId || response.parentMessageId || userMessageId;
+      responseMessage.sender = 'Sydney';
+    } else {
+      responseMessage.conversationId = response.conversationId;
+      responseMessage.messageId = response.messageId || response.details.messageId;
+      response.parentMessageId =
+        overrideParentMessageId || response.parentMessageId || response.details.requestId || userMessageId;
+      responseMessage.sender = 'BingAI';
+    }
+
+    await saveMessage(responseMessage);
+
+    // STEP2 update the convosation.
+
+    // First update conversationId if needed
+    // Note!
+    // Bing API will not use our conversationId at the first time,
+    // so change the placeholder conversationId to the real one.
+    // Attition: the api will also create new conversationId while using invalid userMessage.parentMessageId,
+    // but in this situation, don't change the conversationId, but create new convo.
+
+    let conversationUpdate = { conversationId, endpoint: 'bingAI' };
+    if (conversationId != responseMessage.conversationId && isNewConversation)
+      conversationUpdate = {
+        ...conversationUpdate,
+        conversationId: conversationId,
+        newConversationId: responseMessage.conversationId || conversationId
+      };
+    conversationId = responseMessage.conversationId || conversationId;
+
+    if (endpointOption?.jailbreak) {
+      conversationUpdate.jailbreak = true;
+      conversationUpdate.jailbreakConversationId = response.jailbreakConversationId;
+    } else {
+      conversationUpdate.jailbreak = false;
+      conversationUpdate.conversationSignature = response.conversationSignature;
+      conversationUpdate.clientId = response.clientId;
+      conversationUpdate.invocationId = response.invocationId;
+    }
+
+    await saveConvo(req?.session?.user?.username, conversationUpdate);
+
+    // STEP3 update the user message
+    userMessage.conversationId = conversationId;
+    userMessage.messageId = responseMessage.parentMessageId;
+
+    // If response has parentMessageId, the fake userMessage.messageId should be updated to the real one.
+    if (!overrideParentMessageId) {
+      const oldUserMessageId = userMessageId;
+      await saveMessage({ ...userMessage, messageId: oldUserMessageId, newMessageId: userMessage.messageId });
+    }
+    userMessageId = userMessage.messageId;
+
+    sendMessage(res, {
+      title: await getConvoTitle(req?.session?.user?.username, conversationId),
+      final: true,
+      conversation: await getConvo(req?.session?.user?.username, conversationId),
+      requestMessage: userMessage,
+      responseMessage: responseMessage
+    });
+    res.end();
+
+    if (userParentMessageId == '00000000-0000-0000-0000-000000000000') {
+      const title = await titleConvo({ endpoint: endpointOption?.endpoint, text, response });
+
+      await saveConvo(req?.session?.user?.username, {
+        conversationId: conversationId,
+        title
+      });
+    }
+  } catch (error) {
+    console.log(error);
+    const errorMessage = {
+      messageId: crypto.randomUUID(),
+      sender: endpointOption?.jailbreak ? 'Sydney' : 'BingAI',
+      conversationId,
+      parentMessageId: overrideParentMessageId || userMessageId,
+      error: true,
+      text: error.message
+    };
+    await saveBingMessage(errorMessage);
+    handleError(res, errorMessage);
+  }
+};
+
+module.exports = router;

api/server/routes/ask/askChatGPTBrowser.js

@@ -0,0 +1,162 @@
+const express = require('express');
+const crypto = require('crypto');
+const router = express.Router();
+const { titleConvo, browserClient } = require('../../../app/');
+const { saveMessage, getConvoTitle, saveConvo, updateConvo, getConvo } = require('../../../models');
+const { handleError, sendMessage, createOnProgress, handleText } = require('./handlers');
+
+router.post('/', async (req, res) => {
+  const {
+    endpoint,
+    text,
+    overrideParentMessageId = null,
+    parentMessageId,
+    conversationId: oldConversationId
+  } = req.body;
+  if (text.length === 0) return handleError(res, { text: 'Prompt empty or too short' });
+  if (endpoint !== 'chatGPTBrowser') return handleError(res, { text: 'Illegal request' });
+
+  // build user message
+  const conversationId = oldConversationId || crypto.randomUUID();
+  const userMessageId = crypto.randomUUID();
+  const userParentMessageId = parentMessageId || '00000000-0000-0000-0000-000000000000';
+  const userMessage = {
+    messageId: userMessageId,
+    sender: 'User',
+    text,
+    parentMessageId: userParentMessageId,
+    conversationId,
+    isCreatedByUser: true
+  };
+
+  // build endpoint option
+  const endpointOption = {
+    model: req.body?.model || 'text-davinci-002-render-sha'
+  };
+
+  console.log('ask log', {
+    userMessage,
+    endpointOption,
+    conversationId
+  });
+
+  if (!overrideParentMessageId) {
+    await saveMessage(userMessage);
+    await saveConvo(req?.session?.user?.username, {
+      ...userMessage,
+      ...endpointOption,
+      conversationId,
+      endpoint
+    });
+  }
+
+  // eslint-disable-next-line no-use-before-define
+  return await ask({
+    userMessage,
+    endpointOption,
+    conversationId,
+    preSendRequest: true,
+    overrideParentMessageId,
+    req,
+    res
+  });
+});
+
+const ask = async ({
+  userMessage,
+  endpointOption,
+  conversationId,
+  preSendRequest = true,
+  overrideParentMessageId = null,
+  req,
+  res
+}) => {
+  const { text, parentMessageId: userParentMessageId, messageId: userMessageId } = userMessage;
+
+  const client = browserClient;
+
+  res.writeHead(200, {
+    Connection: 'keep-alive',
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache, no-transform',
+    'Access-Control-Allow-Origin': '*',
+    'X-Accel-Buffering': 'no'
+  });
+
+  if (preSendRequest) sendMessage(res, { message: userMessage, created: true });
+
+  try {
+    const progressCallback = createOnProgress();
+    const abortController = new AbortController();
+    res.on('close', () => abortController.abort());
+    let gptResponse = await client({
+      text,
+      parentMessageId: userParentMessageId,
+      conversationId,
+      ...endpointOption,
+      onProgress: progressCallback.call(null, { res, text }),
+      abortController
+    });
+
+    gptResponse.text = gptResponse.response;
+    console.log('CLIENT RESPONSE', gptResponse);
+
+    if (!gptResponse.parentMessageId) {
+      gptResponse.parentMessageId = overrideParentMessageId || userMessageId;
+      delete gptResponse.response;
+    }
+
+    gptResponse.sender = 'ChatGPT';
+    // gptResponse.model = model;
+    gptResponse.text = await handleText(gptResponse);
+    // if (convo.chatGptLabel?.length > 0 && model === 'chatgptCustom') {
+    //   gptResponse.chatGptLabel = convo.chatGptLabel;
+    // }
+
+    // if (convo.promptPrefix?.length > 0 && model === 'chatgptCustom') {
+    //   gptResponse.promptPrefix = convo.promptPrefix;
+    // }
+
+    gptResponse.parentMessageId = overrideParentMessageId || userMessageId;
+
+    if (userParentMessageId.startsWith('000')) {
+      await saveMessage({ ...userMessage, conversationId: gptResponse.conversationId });
+    }
+
+    await saveMessage(gptResponse);
+    await updateConvo(req?.session?.user?.username, {
+      ...gptResponse,
+      oldConvoId: conversationId
+    });
+
+    sendMessage(res, {
+      title: await getConvoTitle(req?.session?.user?.username, conversationId),
+      final: true,
+      conversation: await getConvo(req?.session?.user?.username, conversationId),
+      requestMessage: userMessage,
+      responseMessage: gptResponse
+    });
+    res.end();
+
+    if (userParentMessageId == '00000000-0000-0000-0000-000000000000') {
+      const title = await titleConvo({ endpoint: endpointOption?.endpoint, text, response: gptResponse });
+      await updateConvo(req?.session?.user?.username, {
+        conversationId: gptResponse.conversationId,
+        title
+      });
+    }
+  } catch (error) {
+    const errorMessage = {
+      messageId: crypto.randomUUID(),
+      sender: 'ChatGPT',
+      conversationId,
+      parentMessageId: overrideParentMessageId || userMessageId,
+      error: true,
+      text: error.message
+    };
+    await saveMessage(errorMessage);
+    handleError(res, errorMessage);
+  }
+};
+
+module.exports = router;

api/server/routes/ask/askOpenAI.js

@@ -0,0 +1,174 @@
+const express = require('express');
+const crypto = require('crypto');
+const router = express.Router();
+const { titleConvo, askClient } = require('../../../app/');
+const { saveMessage, getConvoTitle, saveConvo, updateConvo, getConvo } = require('../../../models');
+const { handleError, sendMessage, createOnProgress, handleText } = require('./handlers');
+
+router.post('/', async (req, res) => {
+  const {
+    endpoint,
+    text,
+    overrideParentMessageId = null,
+    parentMessageId,
+    conversationId: oldConversationId
+  } = req.body;
+  if (text.length === 0) return handleError(res, { text: 'Prompt empty or too short' });
+  if (endpoint !== 'openAI') return handleError(res, { text: 'Illegal request' });
+
+  // build user message
+  const conversationId = oldConversationId || crypto.randomUUID();
+  const userMessageId = crypto.randomUUID();
+  const userParentMessageId = parentMessageId || '00000000-0000-0000-0000-000000000000';
+  const userMessage = {
+    messageId: userMessageId,
+    sender: 'User',
+    text,
+    parentMessageId: userParentMessageId,
+    conversationId,
+    isCreatedByUser: true
+  };
+
+  // build endpoint option
+  const endpointOption = {
+    model: req.body?.model || 'gpt-3.5-turbo',
+    chatGptLabel: req.body?.chatGptLabel || null,
+    promptPrefix: req.body?.promptPrefix || null,
+    temperature: req.body?.temperature || 1,
+    top_p: req.body?.top_p || 1,
+    presence_penalty: req.body?.presence_penalty || 0,
+    frequency_penalty: req.body?.frequency_penalty || 0
+  };
+
+  console.log('ask log', {
+    userMessage,
+    endpointOption,
+    conversationId
+  });
+
+  if (!overrideParentMessageId) {
+    await saveMessage(userMessage);
+    await saveConvo(req?.session?.user?.username, {
+      ...userMessage,
+      ...endpointOption,
+      conversationId,
+      endpoint
+    });
+  }
+
+  // eslint-disable-next-line no-use-before-define
+  return await ask({
+    userMessage,
+    endpointOption,
+    conversationId,
+    preSendRequest: true,
+    overrideParentMessageId,
+    req,
+    res
+  });
+});
+
+const ask = async ({
+  userMessage,
+  endpointOption,
+  conversationId,
+  preSendRequest = true,
+  overrideParentMessageId = null,
+  req,
+  res
+}) => {
+  let { text, parentMessageId: userParentMessageId, messageId: userMessageId } = userMessage;
+
+  const client = askClient;
+
+  res.writeHead(200, {
+    Connection: 'keep-alive',
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache, no-transform',
+    'Access-Control-Allow-Origin': '*',
+    'X-Accel-Buffering': 'no'
+  });
+
+  if (preSendRequest) sendMessage(res, { message: userMessage, created: true });
+
+  try {
+    const progressCallback = createOnProgress();
+    const abortController = new AbortController();
+    res.on('close', () => abortController.abort());
+    let response = await client({
+      text,
+      parentMessageId: userParentMessageId,
+      conversationId,
+      ...endpointOption,
+      onProgress: progressCallback.call(null, {
+        res,
+        text,
+        parentMessageId: overrideParentMessageId || userMessageId
+      }),
+      abortController
+    });
+
+    console.log('CLIENT RESPONSE', response);
+
+    // STEP1 generate response message
+    response.text = response.response || '**ChatGPT refused to answer.**';
+
+    let responseMessage = {
+      conversationId: response.conversationId,
+      messageId: response.messageId,
+      parentMessageId: overrideParentMessageId || userMessageId,
+      text: await handleText(response),
+      sender: endpointOption?.chatGptLabel || 'ChatGPT'
+    };
+
+    await saveMessage(responseMessage);
+
+    // STEP2 update the conversation
+    conversationId = responseMessage.conversationId || conversationId;
+    // it seems openAI will not change the conversationId.
+    // let conversationUpdate = { conversationId, endpoint: 'openAI' };
+    // await saveConvo(req?.session?.user?.username, conversationUpdate);
+
+    // STEP3 update the user message
+    userMessage.conversationId = conversationId;
+    userMessage.messageId = responseMessage.parentMessageId;
+
+    // If response has parentMessageId, the fake userMessage.messageId should be updated to the real one.
+    if (!overrideParentMessageId) {
+      const oldUserMessageId = userMessageId;
+      await saveMessage({ ...userMessage, messageId: oldUserMessageId, newMessageId: userMessage.messageId });
+    }
+    userMessageId = userMessage.messageId;
+
+    sendMessage(res, {
+      title: await getConvoTitle(req?.session?.user?.username, conversationId),
+      final: true,
+      conversation: await getConvo(req?.session?.user?.username, conversationId),
+      requestMessage: userMessage,
+      responseMessage: responseMessage
+    });
+    res.end();
+
+    if (userParentMessageId == '00000000-0000-0000-0000-000000000000') {
+      const title = await titleConvo({ endpoint: endpointOption?.endpoint, text, response });
+      await updateConvo(req?.session?.user?.username, {
+        conversationId: conversationId,
+        title
+      });
+    }
+  } catch (error) {
+    console.error(error);
+    const errorMessage = {
+      messageId: crypto.randomUUID(),
+      sender: endpointOption?.chatGptLabel || 'ChatGPT',
+      conversationId,
+      parentMessageId: overrideParentMessageId || userMessageId,
+      error: true,
+      text: error.message
+    };
+    await saveMessage(errorMessage);
+    handleError(res, errorMessage);
+  }
+};
+
+module.exports = router;

api/server/routes/ask/handlers.js

@@ -0,0 +1,95 @@
+const _ = require('lodash');
+const citationRegex = /\[\^\d+?\^]/g;
+const backtick = /(?<!`)[`](?!`)/g;
+// const singleBacktick = /(?<!`)[`](?!`)/;
+const cursorDefault = '<span className="result-streaming">█</span>';
+const { getCitations, citeText } = require('../../../app');
+
+const handleError = (res, message) => {
+  res.write(`event: error\ndata: ${JSON.stringify(message)}\n\n`);
+  res.end();
+};
+
+const sendMessage = (res, message) => {
+  if (message.length === 0) {
+    return;
+  }
+  res.write(`event: message\ndata: ${JSON.stringify(message)}\n\n`);
+};
+
+const createOnProgress = () => {
+  let i = 0;
+  let code = '';
+  let tokens = '';
+  let precode = '';
+  let blockCount = 0;
+  let codeBlock = false;
+  let cursor = cursorDefault;
+
+  const progressCallback = async (partial, { res, text, bing = false, ...rest }) => {
+    let chunk = partial === text ? '' : partial;
+    tokens += chunk;
+    precode += chunk;
+    tokens = tokens.replaceAll('[DONE]', '');
+
+    if (codeBlock) {
+      code += chunk;
+    }
+
+    if (precode.includes('```') && codeBlock) {
+      codeBlock = false;
+      cursor = cursorDefault;
+      precode = precode.replace(/```/g, '');
+      code = '';
+    }
+
+    if (precode.includes('```') && code === '') {
+      precode = precode.replace(/```/g, '');
+      codeBlock = true;
+      blockCount++;
+      cursor = blockCount > 1 ? '█\n\n```' : '█\n\n';
+    }
+
+    const backticks = precode.match(backtick);
+    if (backticks && !codeBlock && cursor === cursorDefault) {
+      precode = precode.replace(backtick, '');
+      cursor = '█';
+    }
+
+    if (tokens.match(/^\n/)) {
+      tokens = tokens.replace(/^\n/, '');
+    }
+
+    if (bing) {
+      tokens = citeText(tokens, true);
+    }
+
+    sendMessage(res, { text: tokens + cursor, message: true, initial: i === 0, ...rest });
+    i++;
+  };
+
+  const onProgress = opts => {
+    return _.partialRight(progressCallback, opts);
+  };
+
+  return onProgress;
+};
+
+const handleText = async (response, bing = false) => {
+  let { text } = response;
+  // text = await detectCode(text);
+  response.text = text;
+
+  if (bing) {
+    // const hasCitations = response.response.match(citationRegex)?.length > 0;
+    const links = getCitations(response);
+    if (response.text.match(citationRegex)?.length > 0) {
+      text = citeText(response);
+    }
+    text += links?.length > 0 ? `\n<small>${links}</small>` : '';
+  }
+
+  return text;
+};
+
+module.exports = { handleError, sendMessage, createOnProgress, handleText };

api/server/routes/ask/index.js

@@ -0,0 +1,13 @@
+const express = require('express');
+const router = express.Router();
+// const askAzureOpenAI = require('./askAzureOpenAI';)
+const askOpenAI = require('./askOpenAI');
+const askBingAI = require('./askBingAI');
+const askChatGPTBrowser = require('./askChatGPTBrowser');
+
+// router.use('/azureOpenAI', askAzureOpenAI);
+router.use('/openAI', askOpenAI);
+router.use('/bingAI', askBingAI);
+router.use('/chatGPTBrowser', askChatGPTBrowser);
+
+module.exports = router;