@studious-lms/server 1.5.0 → 1.7.0

package/src/services/conversation.ts

@@ -8,6 +8,7 @@ import {
   countUnreadMessages,
   countUnreadMentions,
   findUserByUsername,
+  searchInstitutionConversationMembers,
   findDmConversationsByUserId,
   findUsersByIdsOrUsernames,
   createConversation,
@@ -17,6 +18,11 @@ import {
   deleteConversationMember,
 } from "../models/conversation.js";
 
+/** Maximum number of member suggestions returned for conversation search. */
+const MAX_MEMBER_SEARCH_RESULTS = 10;
+/** Minimum non-whitespace characters required before running member search. */
+const MIN_MEMBER_SEARCH_QUERY_LENGTH = 2;
+
 /** List user's conversations with unread and mention counts. */
 export async function listConversations(userId: string) {
   const conversations = await findConversationsByUserId(userId);
@@ -89,6 +95,30 @@ export async function hideConversation(userId: string, conversationId: string) {
   return { success: true };
 }
 
+/**
+ * Search active school peers that can be selected for a new conversation.
+ *
+ * Blank or one-character input returns an empty list instead of searching all
+ * institution members, which keeps typeahead callers from issuing broad result
+ * queries.
+ */
+export async function searchConversationMembers(userId: string, query: string) {
+  const trimmedQuery = query.trim();
+
+  if (
+    !trimmedQuery ||
+    trimmedQuery.length < MIN_MEMBER_SEARCH_QUERY_LENGTH
+  ) {
+    return [];
+  }
+
+  return searchInstitutionConversationMembers(
+    userId,
+    trimmedQuery,
+    MAX_MEMBER_SEARCH_RESULTS
+  );
+}
+
 /** Create a DM or group conversation with the given members. */
 export async function createConversationRecord(
   userId: string,

package/src/services/labChat.ts

@@ -17,9 +17,10 @@ import {
   findLabChatForDelete,
   findMentionedMemberships,
 } from "../models/labChat.js";
-import { generateAndSendLabIntroduction, generateAndSendLabResponse } from "../pipelines/aiLabChat.js";
-import { isAIUser } from "../utils/aiUser.js";
+import { getAIUserId, isAIUser } from "../utils/aiUser.js";
+import { createPendingAIMessage } from "../utils/inference.js";
 import { logger } from "../utils/logger.js";
+import { enqueueRunJob } from "../workers/queues.js";
 import {
   claimMessageAttachments,
   ensureMessageHasContentOrAttachments,
@@ -125,12 +126,23 @@ export async function createLabChat(
     return labChat;
   });
 
-  generateAndSendLabIntroduction(
-    result.id,
-    result.conversationId,
-    context,
-    classWithTeachers.subject || "Lab"
-  );
+  // Create the AI introduction placeholder *outside* the transaction (the
+  // helper triggers Pusher and we don't want a tx rollback to leave a
+  // dangling broadcast). The pipeline will fill this row in.
+  try {
+    const aiPlaceholder = await createPendingAIMessage(result.conversationId);
+    await enqueueRunJob(
+      "AI_LAB_CHAT",
+      { conversationId: result.conversationId, aiMessageId: aiPlaceholder.id },
+      { classId, userId },
+    );
+  } catch (error) {
+    logger.error("Failed to enqueue lab chat introduction", {
+      error,
+      labChatId: result.id,
+      conversationId: result.conversationId,
+    });
+  }
 
   try {
     await pusher.trigger(teacherChannel(classId), "lab-chat-created", {
@@ -172,11 +184,13 @@ export async function getLabChat(userId: string, labChatId: string) {
     });
   }
 
+  // The AI placeholder row IS the pending generation marker now — its
+  // status flips PENDING → COMPLETED / FAILED as the pipeline runs.
   const pendingMessage = await prisma.message.findFirst({
     where: {
       conversationId: labChat.conversationId,
       status: JobStatus.PENDING,
-      senderId: { not: "AI_ASSISTANT" },
+      senderId: getAIUserId(),
     },
     orderBy: { createdAt: "desc" },
     select: { id: true },
@@ -252,7 +266,6 @@ export async function postToLabChat(
         content: normalizedContent,
         senderId: userId,
         conversationId: labChat.conversationId,
-        ...(isAIUser(userId) ? {} : { status: JobStatus.PENDING }),
       },
     });
 
@@ -309,6 +322,7 @@ export async function postToLabChat(
         content: result.content,
         senderId: result.senderId,
         conversationId: result.conversationId,
+        status: result.status,
         createdAt: result.createdAt,
         sender: result.sender,
         attachments: result.attachments ?? [],
@@ -321,26 +335,49 @@ export async function postToLabChat(
   }
 
   if (!isAIUser(userId)) {
+    // Create the AI placeholder post-tx so a transaction rollback can never
+    // leave a dangling PENDING bubble. The placeholder broadcast IS the
+    // "AI is thinking..." indicator inline in the chat; the teacher-channel
+    // event below drives the lab list "AI busy in this lab" pill.
+    let aiPlaceholderId: string | null = null;
+    try {
+      const aiPlaceholder = await createPendingAIMessage(labChat.conversationId);
+      aiPlaceholderId = aiPlaceholder.id;
+    } catch (error) {
+      logger.error("Failed to create AI placeholder for lab response", {
+        error,
+        labChatId,
+        teacherMessageId: result.id,
+        conversationId: labChat.conversationId,
+      });
+    }
+
     try {
       await pusher.trigger(teacherChannel(labChat.classId), "lab-response-pending", {
         labChatId,
-        messageId: result.id,
+        messageId: aiPlaceholderId ?? result.id,
         conversationId: labChat.conversationId,
       });
     } catch (error) {
       console.error("Failed to broadcast lab response pending:", error);
     }
-    generateAndSendLabResponse(labChatId, normalizedContent, {
-      classId: labChat.classId,
-      messageId: result.id,
-    }).catch((error) =>
-      logger.error("Failed to generate lab response", {
-        error,
-        labChatId,
-        messageId: result.id,
-        conversationId: labChat.conversationId,
-      })
-    );
+
+    if (aiPlaceholderId) {
+      try {
+        await enqueueRunJob(
+          "AI_LAB_CHAT",
+          { conversationId: labChat.conversationId, aiMessageId: aiPlaceholderId },
+          { classId: labChat.classId, userId },
+        );
+      } catch (error) {
+        logger.error("Failed to enqueue lab response", {
+          error,
+          labChatId,
+          aiMessageId: aiPlaceholderId,
+          conversationId: labChat.conversationId,
+        });
+      }
+    }
   }
 
   return {
@@ -348,6 +385,7 @@ export async function postToLabChat(
     content: result.content,
     senderId: result.senderId,
     conversationId: result.conversationId,
+    status: result.status,
     createdAt: result.createdAt,
     sender: result.sender,
     attachments: result.attachments ?? [],
@@ -406,7 +444,13 @@ export async function deleteLabChat(userId: string, labChatId: string) {
   return { success: true };
 }
 
-/** Rerun the last AI response for a lab chat. Deletes the last AI message and regenerates. */
+/**
+ * Rerun the last AI response in a lab chat.
+ *
+ * The AI message bubble is reused (not deleted): we flip it back to
+ * PENDING and clear its content so the existing message id stays stable
+ * for the client. The pipeline then refills it.
+ */
 export async function rerunLastResponse(userId: string, labChatId: string) {
   const labChat = await findLabChatForPost(labChatId, userId);
   if (!labChat) {
@@ -446,46 +490,62 @@ export async function rerunLastResponse(userId: string, labChatId: string) {
     });
   }
 
-  await prisma.$transaction([
-    prisma.message.delete({
-      where: { id: lastMessage.id },
-    }),
-    prisma.message.update({
-      where: { id: teacherMessage.id },
-      data: { status: JobStatus.PENDING },
-    }),
-  ]);
+  const reusedAiMessage = await prisma.message.update({
+    where: { id: lastMessage.id },
+    data: {
+      content: "",
+      status: JobStatus.PENDING,
+      meta: {},
+    },
+    select: { id: true, conversationId: true, status: true, content: true, senderId: true, createdAt: true },
+  });
 
+  // Tell the chat UI the existing AI bubble is regenerating — content
+  // cleared, status flipped back to PENDING, same id.
   try {
-    await pusher.trigger(chatChannel(labChat.conversationId), "message-deleted", {
-      messageId: lastMessage.id,
-      conversationId: labChat.conversationId,
-      senderId: lastMessage.senderId,
+    await pusher.trigger(chatChannel(labChat.conversationId), "message-updated", {
+      id: reusedAiMessage.id,
+      content: reusedAiMessage.content,
+      senderId: reusedAiMessage.senderId,
+      conversationId: reusedAiMessage.conversationId,
+      status: reusedAiMessage.status,
+      createdAt: reusedAiMessage.createdAt,
+      sender: {
+        id: reusedAiMessage.senderId,
+        username: 'Newton_AI',
+        profile: { displayName: 'Newton AI', profilePicture: null },
+      },
+      mentionedUserIds: [],
+      meta: {},
+      attachments: [],
     });
   } catch (error) {
-    console.error("Failed to broadcast message deletion:", error);
+    console.error("Failed to broadcast AI message rerun reset:", error);
   }
   try {
     await pusher.trigger(teacherChannel(labChat.classId), "lab-response-pending", {
       labChatId,
-      messageId: teacherMessage.id,
+      messageId: reusedAiMessage.id,
       conversationId: labChat.conversationId,
     });
   } catch (error) {
     console.error("Failed to broadcast lab response pending:", error);
   }
 
-  generateAndSendLabResponse(labChatId, teacherMessage.content, {
-    classId: labChat.classId,
-    messageId: teacherMessage.id,
-  }).catch((error) =>
-    logger.error("Failed to generate lab response", {
+  try {
+    await enqueueRunJob(
+      "AI_LAB_CHAT",
+      { conversationId: labChat.conversationId, aiMessageId: reusedAiMessage.id },
+      { classId: labChat.classId, userId },
+    );
+  } catch (error) {
+    logger.error("Failed to enqueue lab response rerun", {
       error,
       labChatId,
-      messageId: teacherMessage.id,
+      aiMessageId: reusedAiMessage.id,
       conversationId: labChat.conversationId,
-    })
-  );
+    });
+  }
 
   return { success: true };
 }

package/src/services/message.ts

@@ -192,6 +192,7 @@ export async function listMessages(
       conversationId: message.conversationId,
       createdAt: message.createdAt,
       sender: message.sender,
+      status: message.status,
       attachments: message.attachments.map((a) => ({
         id: a.id,
         name: a.name,
@@ -316,6 +317,7 @@ export async function sendMessage(
         content: result.content,
         senderId: result.senderId,
         conversationId: result.conversationId,
+        status: result.status,
         createdAt: result.createdAt,
         sender: result.sender,
         attachments: result.attachments ?? [],
@@ -336,6 +338,7 @@ export async function sendMessage(
     content: result.content,
     senderId: result.senderId,
     conversationId: result.conversationId,
+    status: result.status,
     createdAt: result.createdAt,
     sender: result.sender,
     attachments: result.attachments ?? [],
@@ -440,6 +443,7 @@ export async function updateMessage(
         content: updatedMessage.content,
         senderId: updatedMessage.senderId,
         conversationId: updatedMessage.conversationId,
+        status: updatedMessage.status,
         createdAt: updatedMessage.createdAt,
         sender: updatedMessage.sender,
         attachments: updatedMessage.attachments ?? [],
@@ -460,6 +464,7 @@ export async function updateMessage(
     content: updatedMessage.content,
     senderId: updatedMessage.senderId,
     conversationId: updatedMessage.conversationId,
+    status: updatedMessage.status,
     createdAt: updatedMessage.createdAt,
     sender: updatedMessage.sender,
     mentionedUserIds,
@@ -633,6 +638,7 @@ export async function markSuggestionCreated(
               content: updated.content,
               senderId: updated.senderId,
               conversationId: updated.conversationId,
+              status: updated.status,
               createdAt: updated.createdAt,
               sender: updated.sender,
               attachments: updated.attachments ?? [],

package/src/services/newtonChat.ts

@@ -6,7 +6,8 @@ import { TRPCError } from "@trpc/server";
 import { logger } from "../utils/logger.js";
 import { chatChannel, pusher } from "../lib/pusher.js";
 import { isAIUser } from "../utils/aiUser.js";
-import { generateAndSendNewtonIntroduction, generateAndSendNewtonResponse } from "../pipelines/aiNewtonChat.js";
+import { createPendingAIMessage } from "../utils/inference.js";
+import { enqueueRunJob } from "../workers/queues.js";
 import {
   claimMessageAttachments,
   ensureMessageHasContentOrAttachments,
@@ -44,7 +45,7 @@ export async function getTutorConversation(
     });
   }
 
-  const result = await prisma.$transaction(async (tx) => {
+  const { chat, isNew } = await prisma.$transaction(async (tx) => {
     const existingNewtonChat = await tx.newtonChat.findFirst({
       where: { submissionId: submission.id },
       include: {
@@ -60,7 +61,7 @@ export async function getTutorConversation(
     });
 
     if (existingNewtonChat && existingNewtonChat.conversation.members.length > 0) {
-      return existingNewtonChat;
+      return { chat: existingNewtonChat, isNew: false };
     }
 
     if (existingNewtonChat) {
@@ -71,7 +72,7 @@ export async function getTutorConversation(
           role: "MEMBER",
         },
       });
-      return existingNewtonChat;
+      return { chat: existingNewtonChat, isNew: false };
     }
 
     const conversation = await tx.conversation.create({
@@ -98,23 +99,31 @@ export async function getTutorConversation(
       },
     });
 
-    generateAndSendNewtonIntroduction(
-      newtonChat.id,
-      newtonChat.conversationId,
-      submission.id
-    ).catch((error) => {
-      logger.error("Failed to generate AI introduction:", {
+    return { chat: newtonChat, isNew: true };
+  });
+
+  if (isNew) {
+    // Create the AI introduction placeholder and enqueue OUTSIDE the
+    // transaction — a tx rollback would otherwise orphan a job pointing at
+    // a non-existent NewtonChat / Message row.
+    try {
+      const aiPlaceholder = await createPendingAIMessage(chat.conversationId);
+      await enqueueRunJob(
+        "AI_NEWTON_CHAT",
+        { conversationId: chat.conversationId, aiMessageId: aiPlaceholder.id },
+        { userId },
+      );
+    } catch (error) {
+      logger.error("Failed to enqueue Newton introduction", {
         error,
-        newtonChatId: newtonChat.id,
+        newtonChatId: chat.id,
       });
-    });
-
-    return newtonChat;
-  });
+    }
+  }
 
   return {
-    conversationId: result.conversationId,
-    newtonChatId: result.id,
+    conversationId: chat.conversationId,
+    newtonChatId: chat.id,
   };
 }
 
@@ -218,6 +227,7 @@ export async function postToNewtonChat(
         content: result.content,
         senderId: result.senderId,
         conversationId: result.conversationId,
+        status: result.status,
         createdAt: result.createdAt,
         sender: result.sender,
         attachments: result.attachments ?? [],
@@ -230,14 +240,23 @@ export async function postToNewtonChat(
   }
 
   if (!isAIUser(userId)) {
-    generateAndSendNewtonResponse(
-      newtonChatId,
-      normalizedContent,
-      newtonChat.conversationId,
-      newtonChat.submission
-    ).catch((error) => {
-      logger.error("Failed to generate AI response:", { error });
-    });
+    // Create the AI placeholder post-tx (so a rollback can't broadcast a
+    // ghost bubble); the pipeline fills it in.
+    try {
+      const aiPlaceholder = await createPendingAIMessage(newtonChat.conversationId);
+      await enqueueRunJob(
+        "AI_NEWTON_CHAT",
+        { conversationId: newtonChat.conversationId, aiMessageId: aiPlaceholder.id },
+        { userId },
+      );
+    } catch (error) {
+      logger.error("Failed to enqueue Newton response", {
+        error,
+        newtonChatId,
+        studentMessageId: result.id,
+        conversationId: newtonChat.conversationId,
+      });
+    }
   }
 
   return {
@@ -245,6 +264,7 @@ export async function postToNewtonChat(
     content: result.content,
     senderId: result.senderId,
     conversationId: result.conversationId,
+    status: result.status,
     createdAt: result.createdAt,
     sender: result.sender,
     attachments: result.attachments ?? [],

package/src/services/worksheet.ts

@@ -7,7 +7,8 @@ import { JobStatus, type WorksheetQuestionType } from "@prisma/client";
 import { prisma } from "../lib/prisma.js";
 import { getFileUrl } from "../lib/fileUpload.js";
 import { cancelGradePipeline, regradeWorksheetPipeline } from "../pipelines/gradeWorksheet.js";
-import { pdfToWorksheet } from "../pipelines/pdfToWorksheet.js";
+import { enqueueRunJob } from "../workers/queues.js";
+import { logger } from "../utils/logger.js";
 import {
   findWorksheetByIdMinimal,
   findWorksheetByIdForClassMember,
@@ -170,21 +171,77 @@ export async function duplicateWorksheetRecord(
 }
 
 /**
- * Create a worksheet by converting a PDF (URL) into structured questions.
- * Uses the `pdfToWorksheet` pipeline to do inference + persistence.
+ * Kick off PDF-to-worksheet conversion asynchronously.
+ *
+ * We synchronously create a placeholder Worksheet row (status PENDING) so the
+ * caller has an id to navigate to immediately, then enqueue a BullMQ job that
+ * fills in the real title and questions. Progress is broadcast on the
+ * per-worksheet job Pusher channel; clients should subscribe there to drive
+ * loading UI.
  */
 export async function createWorksheetFromPdf(
   classId: string,
-  url: string
+  url: string,
+  userId?: string,
+  options: { name?: string } = {},
 ) {
-  const created = await pdfToWorksheet(url, classId);
-  if (!created) {
+  const placeholder = await prisma.worksheet.create({
+    data: {
+      classId,
+      name: options.name?.trim() || "Converting PDF…",
+      status: JobStatus.PENDING,
+    },
+  });
+
+  try {
+    const { runJobId } = await enqueueRunJob(
+      "PDF_TO_WORKSHEET",
+      { gcsUrl: url, classId, worksheetId: placeholder.id },
+      { classId, userId: userId ?? null },
+    );
+
+    await prisma.worksheet
+      .update({
+        where: { id: placeholder.id },
+        data: { runJobId },
+      })
+      .catch((linkError) => {
+        logger.error(
+          "createWorksheetFromPdf: failed to link RunJob to Worksheet",
+          {
+            worksheetId: placeholder.id,
+            runJobId,
+            error:
+              linkError instanceof Error
+                ? linkError.message
+                : String(linkError),
+          },
+        );
+      });
+
+    return {
+      ...placeholder,
+      runJobId,
+    };
+  } catch (error) {
+    await prisma.worksheet
+      .update({
+        where: { id: placeholder.id },
+        data: { status: JobStatus.FAILED },
+      })
+      .catch(() => undefined);
+
+    logger.error("createWorksheetFromPdf: failed to enqueue conversion", {
+      worksheetId: placeholder.id,
+      classId,
+      error: error instanceof Error ? error.message : String(error),
+    });
+
     throw new TRPCError({
       code: "INTERNAL_SERVER_ERROR",
-      message: "Failed to create worksheet from PDF",
+      message: "Failed to start worksheet conversion",
     });
   }
-  return created;
 }
 
 /**
@@ -193,7 +250,8 @@ export async function createWorksheetFromPdf(
 export async function createWorksheetFromUploadedPdf(
   classId: string,
   fileId: string,
-  userId: string
+  userId: string,
+  options: { name?: string } = {},
 ) {
   const file = await prisma.file.findFirst({
     where: {
@@ -205,6 +263,7 @@ export async function createWorksheetFromUploadedPdf(
       id: true,
       path: true,
       type: true,
+      name: true,
     },
   });
 
@@ -225,7 +284,9 @@ export async function createWorksheetFromUploadedPdf(
   }
 
   const signedUrl = await getFileUrl(file.path);
-  return createWorksheetFromPdf(classId, signedUrl);
+  return createWorksheetFromPdf(classId, signedUrl, userId, {
+    name: options.name ?? file.name ?? undefined,
+  });
 }
 
 export async function addQuestionToWorksheet(