compass.js

/**
 * Compass is the Assistant all users interact with in threads.
 *
 * @see https://tools.slack.dev/bolt-js/reference#agents--assistants
 */

const { Assistant } = require("@slack/bolt");
const blockKitBuilder = require("./classes/utilities/BlockKitBuilder");
const intentionHandler = require("./classes/utilities/IntentionHandler");
const openai = require("./classes/apis/OpenAI");
const pinecone = require("./classes/apis/Pinecone");
const {
  COMPASS_BRIEFING,
  FIRST_SUGGESTED_PROMPTS,
  GENERATE_TITLE_PROMPT,
  SUMMARIZE_CHAT_PROMPT,
} = require("./prompts");

/**
 * Initiate the Assistant.
 */
const compass = new Assistant({
  /**
   * The `threadStarted` event is triggered when a new thread is created.
   */
  threadStarted: async ({ say, setSuggestedPrompts }) => {
    await say("Ahoy, waar kan ik je mee helpen?");

    await setSuggestedPrompts({
      prompts: FIRST_SUGGESTED_PROMPTS,
      title: "Hier wat suggesties:",
    });
  },

  /**
   * The `userMessage` event is triggered when a user sends a message in a thread.
   */
  userMessage: async ({
    client,
    logger,
    message,
    say,
    setStatus,
    setTitle,
    getThreadContext,
  }) => {
    try {
      const { text, channel, thread_ts } = message;
      const userMessage = { role: "user", content: text };
      let threadContext;
      let prompts;

      await setStatus("leest je vraag...");
      const intention = await intentionHandler.analyseIntent(text);

      logger.info(
        `Received message with intention: ${JSON.stringify(intention)}`
      );
      logger.info("Preparing channel history for OpenAI completion.");

      if (intention.intent === "summarize_chat") {
        await setStatus("is het actieve kanaal aan het lezen...");
        threadContext = await getThreadContext();

        try {
          channelHistory = await client.conversations.history({
            channel: threadContext.channel_id,
            limit: intention.limit || 50,
          });
        } catch (error) {
          // If the bot is not in the channel, join it and try again.
          if (e.data.error === "not_in_channel") {
            await client.conversations.join({
              channel: threadContext.channel_id,
            });
            channelHistory = await client.conversations.history({
              channel: threadContext.channel_id,
              limit: intention.limit || 50,
            });
          } else {
            console.error(`Error fetching channel history: ${error}`);
            throw error;
          }
        }

        let prompt = `${SUMMARIZE_CHAT_PROMPT} <#${threadContext.channel_id}>:`;

        for (const m of channelHistory.messages.reverse()) {
          if (m.user) prompt += `\n<@${m.user}> says: ${m.text}`;
        }

        prompts = [{ role: "user", content: prompt }];
      } else {
        channelHistory = await client.conversations.replies({
          channel,
          ts: thread_ts,
          oldest: thread_ts,
        });

        prompts = channelHistory.messages.map((message) => ({
          role: message.bot_id ? "assistant" : "user",
          content: message.text,
        }));

        prompts.push(userMessage);

        // const embeddingResponse = await openai.createEmbedding({
        //   text: text,
        // });

        // const index = await pinecone.getIndex("kompas-index");
        // const searchResults = await index.query({
        //   vector: embeddingResponse,
        //   topK: 4,
        //   includeMetadata: true,
        // });

        // const pineconeResults = searchResults.matches;

        // if (pineconeResults.length > 0) {
        //   context = "Hier is wat ik heb gevonden:\n";
        //   pineconeResults.forEach((result, index) => {
        //     context += `*Resultaat ${index + 1}:*\nTitle: ${
        //       result.metadata.title
        //     }\nContent: ${result.metadata.content}\n\n`;
        //   });
        // }

        // prompts.push({ role: "system", content: context });
      }

      const messages = [
        { role: "system", content: COMPASS_BRIEFING },
        ...prompts,
      ];

      await setStatus("is aan het nadenken...");
      const completion = await openai.createCompletion({ messages });

      logger.info("Sending back OpenAI completion.");

      await setStatus("is aan het typen...");
      await say({
        blocks: [blockKitBuilder.addSection({ text: completion })],
        text: completion,
      });

      const titlePrompt = [
        { role: "system", content: `${GENERATE_TITLE_PROMPT} ${completion}.` },
      ];

      const generatedTitle = await openai.createCompletion({
        messages: titlePrompt,
      });

      return await setTitle(generatedTitle);
    } catch (e) {
      logger.error(`Error processing message: ${e}`);
      await say("Er is iets misgegaan bij het verwerken van je verzoek.");
    }
  },
});

module.exports = {
  compass,
};