@studious-lms/server 1.3.0 → 1.4.0

package/src/services/labChat.ts

@@ -3,6 +3,7 @@
  * trigger AI responses, and broadcast via Pusher.
  */
 import { TRPCError } from "@trpc/server";
+import { GenerationStatus } from "@prisma/client";
 import { prisma } from "../lib/prisma.js";
 import { chatChannel, teacherChannel, pusher } from "../lib/pusher.js";
 import {
@@ -166,7 +167,20 @@ export async function getLabChat(userId: string, labChatId: string) {
     });
   }
 
-  return labChat;
+  const pendingMessage = await prisma.message.findFirst({
+    where: {
+      conversationId: labChat.conversationId,
+      status: GenerationStatus.PENDING,
+      senderId: { not: "AI_ASSISTANT" },
+    },
+    orderBy: { createdAt: "desc" },
+    select: { id: true },
+  });
+
+  return {
+    ...labChat,
+    pendingGenerationMessageId: pendingMessage?.id ?? null,
+  };
 }
 
 export async function listLabChats(userId: string, classId: string) {
@@ -282,10 +296,24 @@ export async function postToLabChat(
   }
 
   if (!isAIUser(userId)) {
+    await prisma.message.update({
+      where: { id: result.id },
+      data: { status: GenerationStatus.PENDING },
+    });
+    try {
+      await pusher.trigger(teacherChannel(labChat.classId), "lab-response-pending", {
+        labChatId,
+        messageId: result.id,
+        conversationId: labChat.conversationId,
+      });
+    } catch (error) {
+      console.error("Failed to broadcast lab response pending:", error);
+    }
     generateAndSendLabResponse(
       labChatId,
       content,
-      labChat.conversationId
+      labChat.conversationId,
+      { classId: labChat.classId, messageId: result.id }
     );
   }
 
@@ -350,3 +378,81 @@ 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. */
+export async function rerunLastResponse(userId: string, labChatId: string) {
+  const labChat = await findLabChatForPost(labChatId, userId);
+  if (!labChat) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Lab chat not found or access denied",
+    });
+  }
+
+  const messages = await prisma.message.findMany({
+    where: { conversationId: labChat.conversationId },
+    orderBy: { createdAt: "desc" },
+    take: 10,
+    select: { id: true, content: true, senderId: true, createdAt: true },
+  });
+
+  const lastMessage = messages[0];
+  if (!lastMessage) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "No messages to rerun",
+    });
+  }
+
+  if (!isAIUser(lastMessage.senderId)) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "Last message is not from AI – nothing to rerun",
+    });
+  }
+
+  const teacherMessage = messages.find((m) => !isAIUser(m.senderId));
+  if (!teacherMessage) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "No teacher message found to rerun from",
+    });
+  }
+
+  await prisma.message.delete({
+    where: { id: lastMessage.id },
+  });
+
+  try {
+    await pusher.trigger(chatChannel(labChat.conversationId), "message-deleted", {
+      messageId: lastMessage.id,
+      conversationId: labChat.conversationId,
+      senderId: lastMessage.senderId,
+    });
+  } catch (error) {
+    console.error("Failed to broadcast message deletion:", error);
+  }
+
+  await prisma.message.update({
+    where: { id: teacherMessage.id },
+    data: { status: GenerationStatus.PENDING },
+  });
+  try {
+    await pusher.trigger(teacherChannel(labChat.classId), "lab-response-pending", {
+      labChatId,
+      messageId: teacherMessage.id,
+      conversationId: labChat.conversationId,
+    });
+  } catch (error) {
+    console.error("Failed to broadcast lab response pending:", error);
+  }
+
+  generateAndSendLabResponse(
+    labChatId,
+    teacherMessage.content,
+    labChat.conversationId,
+    { classId: labChat.classId, messageId: teacherMessage.id }
+  );
+
+  return { success: true };
+}

package/src/services/message.ts

@@ -357,6 +357,99 @@ export async function deleteMessage(userId: string, messageId: string) {
   return { success: true, messageId };
 }
 
+const CREATED_INDICES_KEY: Record<"assignment" | "worksheet" | "section", string> = {
+  assignment: "assignments",
+  worksheet: "worksheets",
+  section: "sections",
+};
+
+/** Mark an AI-suggested item as created. Stores in message meta for fast reads. */
+export async function markSuggestionCreated(
+  userId: string,
+  input: {
+    messageId: string;
+    type: "assignment" | "worksheet" | "section";
+    index: number;
+  }
+) {
+  const { messageId, type, index } = input;
+
+  const existingMessage = await findMessageByIdMinimal(messageId);
+  if (!existingMessage) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Message not found",
+    });
+  }
+
+  const membership = await findConversationMembership(
+    existingMessage.conversationId,
+    userId
+  );
+  if (!membership) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Not a member of this conversation",
+    });
+  }
+
+  const currentMeta = (existingMessage.meta as Record<string, unknown>) ?? {};
+  const createdIndices = (currentMeta.createdIndices as Record<string, number[]>) ?? {};
+  const typeIndices = createdIndices[CREATED_INDICES_KEY[type]] ?? [];
+  if (typeIndices.includes(index)) return { success: true };
+
+  const newTypeIndices = [...typeIndices, index].sort((a, b) => a - b);
+  const newMeta = {
+    ...currentMeta,
+    createdIndices: {
+      ...createdIndices,
+      [CREATED_INDICES_KEY[type]]: newTypeIndices,
+    },
+  };
+
+  const updated = await prisma.message.update({
+    where: { id: messageId },
+    data: { meta: newMeta as object },
+    include: {
+      sender: {
+        select: {
+          id: true,
+          username: true,
+          profile: {
+            select: { displayName: true, profilePicture: true },
+          },
+        },
+      },
+      attachments: { select: { id: true, name: true, type: true } },
+    },
+  });
+
+  try {
+    await pusher.trigger(
+      chatChannel(existingMessage.conversationId),
+      "message-updated",
+      {
+        id: updated.id,
+        content: updated.content,
+        senderId: updated.senderId,
+        conversationId: updated.conversationId,
+        createdAt: updated.createdAt,
+        sender: updated.sender,
+        attachments: updated.attachments ?? [],
+        meta: newMeta,
+        mentionedUserIds: [] as string[],
+      }
+    );
+  } catch (error) {
+    logger.error("Failed to broadcast suggestion status via Pusher", {
+      error,
+      messageId,
+    });
+  }
+
+  return { success: true };
+}
+
 export async function markAsRead(userId: string, conversationId: string) {
   const membership = await findConversationMembership(conversationId, userId);
   if (!membership) {