Function llmQuestion

packages/queue/src/tasks/llm/index.ts:60–124

(payload: any, helpers: JobHelpers)

}

export const llmQuestion = async (payload: any, helpers: JobHelpers) => {
  const logger = new Logger(helpers.logger);

  logger.info(payload);

  try {
    const parsedPayload = z
      .object({
        accountId: z.string().uuid(),
        authorId: z.string().uuid(),
        channelId: z.string().uuid(),
        threadId: z.string().uuid(),
        communityName: z.string(),
      })
      .parse(payload);

    const { accountId, authorId, channelId, threadId, communityName } =
      parsedPayload;

    const thread = await prisma.threads.findUniqueOrThrow({
      include: { messages: true, channel: true },
      where: { id: threadId },
    });

    logger.info({ llm: `found thread ${thread.id}` });

    const llmResponse = await llmPredict({
      communityName,
      query: thread.messages.map((m) => m.body).join(' '),
      threadId: thread.id,
    });

    logger.info({ llm: `llm response ready` });

    const threadAccountId = thread.channel.accountId;

    if (threadAccountId) {
      const account = await prisma.accounts.findUnique({
        where: {
          id: threadAccountId,
        },
      });

      if (account) {
        const body = await parseBody(llmResponse, { account, communityName });

        logger.info({
          llm: `creating a new linen message for thread ${threadId}`,
        });

        await linenSdk.createNewMessage({
          accountId,
          authorId,
          body,
          channelId,
          externalMessageId: crypto.randomUUID(),
          threadId,
          messageFormat: MessageFormat.LINEN,