@studious-lms/server 1.26.0 → 1.27.0

package/src/services/message.ts

@@ -4,6 +4,9 @@
  */
 import type { AppTransactionClient } from "../lib/prisma.js";
 import { TRPCError } from "@trpc/server";
+import { JobStatus, type AiMessageFeedback } from "@prisma/client";
+import { isAIUser } from "../utils/aiUser.js";
+import { enqueueRunJob } from "../workers/queues.js";
 import { prisma } from "../lib/prisma.js";
 import { chatChannel, pusher } from "../lib/pusher.js";
 import {
@@ -181,6 +184,7 @@ export async function listMessages(
       createdAt: message.createdAt,
       sender: message.sender,
       status: message.status,
+      aiFeedback: message.aiFeedback,
       attachments: message.attachments,
       meta: message.meta as Record<string, unknown>,
       mentions: message.mentions.map((m) => ({ user: m.user })),
@@ -512,148 +516,6 @@ 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",
-};
-
-const MARK_SUGGESTION_MAX_RETRIES = 5;
-
-/** 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 conversationId = existingMessage.conversationId;
-  let lastError: Error | null = null;
-
-  for (let attempt = 0; attempt < MARK_SUGGESTION_MAX_RETRIES; attempt++) {
-    const msg = await prisma.message.findUnique({
-      where: { id: messageId },
-      select: { meta: true },
-    });
-    if (!msg) {
-      throw new TRPCError({
-        code: "NOT_FOUND",
-        message: "Message not found",
-      });
-    }
-
-    const currentMeta = (msg.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 newMetaJson = JSON.stringify(newMeta);
-    const currentMetaJson = msg.meta === null ? null : JSON.stringify(msg.meta);
-
-    const updatedCount =
-      currentMetaJson === null
-        ? await prisma.$executeRaw`
-            UPDATE "Message" SET meta = ${newMetaJson}::jsonb
-            WHERE id = ${messageId} AND meta IS NULL
-          `
-        : await prisma.$executeRaw`
-            UPDATE "Message" SET meta = ${newMetaJson}::jsonb
-            WHERE id = ${messageId} AND meta = ${currentMetaJson}::jsonb
-          `;
-
-    if (Number(updatedCount) > 0) {
-      const updated = await prisma.message.findUnique({
-        where: { id: messageId },
-        include: {
-          sender: {
-            select: {
-              id: true,
-              username: true,
-              profile: {
-                select: { displayName: true, profilePicture: true },
-              },
-            },
-          },
-          attachments: { select: messageFileSelect },
-          mentions: { select: { userId: true } },
-        },
-      });
-
-      if (updated) {
-        const mentionedUserIds = updated.mentions.map((m) => m.userId);
-        try {
-          await pusher.trigger(
-            chatChannel(conversationId),
-            "message-updated",
-            {
-              id: updated.id,
-              content: updated.content,
-              senderId: updated.senderId,
-              conversationId: updated.conversationId,
-              status: updated.status,
-              createdAt: updated.createdAt,
-              sender: updated.sender,
-              attachments: updated.attachments ?? [],
-              meta: newMeta,
-              mentionedUserIds,
-            }
-          );
-        } catch (error) {
-          logger.error("Failed to broadcast suggestion status via Pusher", {
-            error,
-            messageId,
-          });
-        }
-      }
-      return { success: true };
-    }
-
-    lastError = new Error("Concurrent update conflict");
-  }
-
-  logger.error("markSuggestionCreated failed after retries", {
-    messageId,
-    type,
-    index,
-    error: lastError,
-  });
-  throw new TRPCError({
-    code: "CONFLICT",
-    message: "Failed to update suggestion status after retries due to concurrent updates",
-  });
-}
 
 export async function markAsRead(userId: string, conversationId: string) {
   const membership = await findConversationMembership(conversationId, userId);
@@ -757,3 +619,204 @@ export async function getUnreadCount(
 
   return { unreadCount, unreadMentionCount };
 }
+
+/**
+ * Regenerate an AI response in a lab or Newton chat.
+ *
+ * The existing AI bubble is reused (not deleted): the row flips back to
+ * PENDING with cleared content/meta/feedback so the message id stays stable
+ * for the client, then the matching pipeline refills it. Only the latest
+ * message in the conversation can be regenerated — the pipelines build
+ * their context from the messages preceding the placeholder.
+ */
+export async function regenerateAIResponse(userId: string, messageId: string) {
+  const message = await prisma.message.findUnique({
+    where: { id: messageId },
+    select: {
+      id: true,
+      senderId: true,
+      conversationId: true,
+      status: true,
+      conversation: {
+        select: {
+          labChat: { select: { id: true, classId: true } },
+          newtonChat: { select: { id: true } },
+        },
+      },
+    },
+  });
+  if (!message) {
+    throw new TRPCError({ code: "NOT_FOUND", message: "Message not found" });
+  }
+
+  const membership = await findConversationMembership(
+    message.conversationId,
+    userId
+  );
+  if (!membership) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Not a member of this conversation",
+    });
+  }
+
+  if (!isAIUser(message.senderId)) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "Only AI messages can be regenerated",
+    });
+  }
+
+  const { labChat, newtonChat } = message.conversation;
+  if (!labChat && !newtonChat) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "This conversation has no AI pipeline to regenerate with",
+    });
+  }
+
+  if (message.status === JobStatus.PENDING) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "This response is still being generated",
+    });
+  }
+
+  const latestMessage = await prisma.message.findFirst({
+    where: { conversationId: message.conversationId },
+    orderBy: { createdAt: "desc" },
+    select: { id: true },
+  });
+  if (latestMessage?.id !== message.id) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "Only the latest AI response can be regenerated",
+    });
+  }
+
+  const reusedAiMessage = await prisma.message.update({
+    where: { id: message.id },
+    data: {
+      content: "",
+      status: JobStatus.PENDING,
+      meta: {},
+      aiFeedback: null,
+    },
+    select: {
+      id: true,
+      content: true,
+      senderId: true,
+      conversationId: true,
+      status: 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(message.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) {
+    logger.error("Failed to broadcast AI regenerate reset", {
+      error,
+      messageId,
+    });
+  }
+
+  try {
+    if (labChat) {
+      await enqueueRunJob(
+        "AI_LAB_CHAT",
+        { conversationId: message.conversationId, aiMessageId: reusedAiMessage.id },
+        { classId: labChat.classId, userId }
+      );
+    } else {
+      await enqueueRunJob(
+        "AI_NEWTON_CHAT",
+        { conversationId: message.conversationId, aiMessageId: reusedAiMessage.id },
+        { userId }
+      );
+    }
+  } catch (error) {
+    logger.error("Failed to enqueue AI regeneration", {
+      error,
+      messageId,
+      conversationId: message.conversationId,
+    });
+    throw new TRPCError({
+      code: "INTERNAL_SERVER_ERROR",
+      message: "Failed to start regeneration",
+    });
+  }
+
+  return { success: true, messageId: reusedAiMessage.id };
+}
+
+/** Record (or clear) thumbs up/down feedback on an AI message. */
+export async function setAIMessageFeedback(
+  userId: string,
+  input: {
+    messageId: string;
+    feedback: AiMessageFeedback | null;
+  }
+) {
+  const message = await prisma.message.findUnique({
+    where: { id: input.messageId },
+    select: { id: true, senderId: true, conversationId: true, status: true },
+  });
+  if (!message) {
+    throw new TRPCError({ code: "NOT_FOUND", message: "Message not found" });
+  }
+
+  const membership = await findConversationMembership(
+    message.conversationId,
+    userId
+  );
+  if (!membership) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Not a member of this conversation",
+    });
+  }
+
+  if (!isAIUser(message.senderId)) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "Feedback can only be left on AI messages",
+    });
+  }
+
+  if (message.status !== JobStatus.COMPLETED) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "Feedback can only be left on completed AI responses",
+    });
+  }
+
+  const updated = await prisma.message.update({
+    where: { id: message.id },
+    data: { aiFeedback: input.feedback },
+    select: { id: true, aiFeedback: true },
+  });
+
+  return { success: true, messageId: updated.id, feedback: updated.aiFeedback };
+}

package/src/services/parentPortal.ts

@@ -85,6 +85,91 @@ export async function linkParentToStudent(
   return { link };
 }
 
+export async function addParentToStudent(
+  userId: string,
+  input: { schoolId: string; studentUserId: string; parentIdentifier: string }
+) {
+  await requireSchoolAdmin(input.schoolId, userId);
+
+  const studentMembership = await findSchoolMembership(
+    input.schoolId,
+    input.studentUserId
+  );
+  if (
+    !studentMembership ||
+    studentMembership.status !== "ACTIVE" ||
+    studentMembership.role !== "STUDENT"
+  ) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "studentUserId must be an active STUDENT member",
+    });
+  }
+
+  const identifier = input.parentIdentifier.trim();
+  const parentUser = await prisma.user.findFirst({
+    where: {
+      OR: [{ email: identifier }, { username: identifier }],
+    },
+    select: { id: true },
+  });
+  if (!parentUser) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "No account found with that email or username",
+    });
+  }
+  if (parentUser.id === input.studentUserId) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "A student cannot be their own parent",
+    });
+  }
+
+  const parentMembership = await findSchoolMembership(
+    input.schoolId,
+    parentUser.id
+  );
+  if (!parentMembership) {
+    await prisma.schoolMembership.create({
+      data: {
+        schoolId: input.schoolId,
+        userId: parentUser.id,
+        role: "PARENT",
+        status: "ACTIVE",
+      },
+    });
+  } else if (parentMembership.role !== "PARENT") {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "That account already belongs to this school with another role",
+    });
+  } else if (parentMembership.status !== "ACTIVE") {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "Parent must be an active school member",
+    });
+  }
+
+  const link = await prisma.parentStudentLink.upsert({
+    where: {
+      schoolId_parentUserId_studentUserId: {
+        schoolId: input.schoolId,
+        parentUserId: parentUser.id,
+        studentUserId: input.studentUserId,
+      },
+    },
+    update: {},
+    create: {
+      schoolId: input.schoolId,
+      parentUserId: parentUser.id,
+      studentUserId: input.studentUserId,
+    },
+  });
+
+  return { link };
+}
+
 export async function unlinkParentFromStudent(
   userId: string,
   input: { schoolId: string; parentUserId: string; studentUserId: string }

package/src/services/studentProgress.ts

@@ -6,6 +6,7 @@ import type { AssignmentType } from "@prisma/client";
 import { z } from "zod";
 import { prisma } from "../lib/prisma.js";
 import { isTeacherInClass } from "../models/class.js";
+import { createAssignmentRecord } from "./assignment.js";
 import { inference } from "../utils/inference.js";
 import { logger } from "../utils/logger.js";
 import {
@@ -617,6 +618,140 @@ export async function dismissStudentRecommendation(
   return { success: true };
 }
 
+const followUpAssignmentSchema = z.object({
+  title: z.string().min(1).max(200),
+  instructions: z.string().min(1),
+});
+
+export type FollowUpAssignmentDraft = z.infer<typeof followUpAssignmentSchema>;
+
+export async function generateFollowUpAssignment(
+  viewerId: string,
+  input: {
+    classId: string;
+    studentId: string;
+    submissionId: string;
+    prompt: string;
+    dueDate?: string;
+  },
+) {
+  const teacherInClass = await isTeacherInClass(input.classId, viewerId);
+  if (!teacherInClass) {
+    throw new TRPCError({
+      code: "UNAUTHORIZED",
+      message: "Only teachers can generate follow-up assignments",
+    });
+  }
+
+  const submission = await prisma.submission.findFirst({
+    where: {
+      id: input.submissionId,
+      studentId: input.studentId,
+      assignment: { classId: input.classId },
+    },
+    select: {
+      id: true,
+      gradeReceived: true,
+      teacherComments: true,
+      student: {
+        select: {
+          id: true,
+          username: true,
+          profile: { select: { displayName: true } },
+        },
+      },
+      assignment: {
+        select: {
+          id: true,
+          title: true,
+          instructions: true,
+          type: true,
+          maxGrade: true,
+          weight: true,
+          section: { select: { id: true, name: true } },
+        },
+      },
+    },
+  });
+
+  if (!submission) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Submission not found for this student in this class",
+    });
+  }
+
+  const displayName =
+    submission.student.profile?.displayName ?? submission.student.username;
+  const percentage =
+    submission.gradeReceived != null && submission.assignment.maxGrade
+      ? Math.round(
+          (submission.gradeReceived / submission.assignment.maxGrade) * 1000,
+        ) / 10
+      : null;
+
+  const draft = await inference<FollowUpAssignmentDraft>(
+    [
+      {
+        role: "system" as const,
+        content:
+          "You are an experienced teacher creating a targeted follow-up assignment for one student. Ground the task in the source assignment and the teacher's request. Do not fabricate material beyond the source assignment's topic. Return a concise title and clear, student-facing instructions.",
+      },
+      {
+        role: "user" as const,
+        content: JSON.stringify({
+          student: { displayName },
+          sourceAssignment: {
+            title: submission.assignment.title,
+            instructions: submission.assignment.instructions,
+            type: submission.assignment.type,
+            maxGrade: submission.assignment.maxGrade,
+            section: submission.assignment.section?.name ?? null,
+          },
+          submission: {
+            gradeReceived: submission.gradeReceived,
+            percentage,
+            teacherFeedback: submission.teacherComments,
+          },
+        }),
+      },
+      { role: "user" as const, content: input.prompt },
+    ],
+    followUpAssignmentSchema,
+    {
+      reason: "student_progress_follow_up_assignment",
+      metadata: {
+        viewerId,
+        classId: input.classId,
+        studentId: input.studentId,
+        submissionId: input.submissionId,
+      },
+      attribution: { userId: viewerId, classId: input.classId },
+    },
+  );
+
+  const dueDate =
+    input.dueDate ??
+    new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString();
+
+  const assignment = await createAssignmentRecord(viewerId, {
+    classId: input.classId,
+    title: draft.title,
+    instructions: draft.instructions,
+    dueDate,
+    studentIds: [input.studentId],
+    maxGrade: submission.assignment.maxGrade ?? 100,
+    graded: true,
+    weight: submission.assignment.weight || 1,
+    sectionId: submission.assignment.section?.id ?? undefined,
+    type: normalizeAssignmentType(submission.assignment.type),
+    acceptExtendedResponse: true,
+    sourceAssignmentId: submission.assignment.id,
+  });
+
+  return { assignment, draft };
+}
+
 function buildProgressSummary(submissions: GradeSubmission[]) {
   return submissions.map((submission) => ({
     title: submission.assignment.title,

package/src/utils/inference.ts

@@ -476,6 +476,77 @@ export async function completePendingAIMessage(
   };
 }
 
+/**
+ * Persist the partial output of a cancelled generation and flip the AI
+ * message to CANCELLED. Whatever text/tool parts streamed before the stop
+ * are kept on the row (content + meta) so they survive reloads. Broadcasts
+ * `message-updated` so clients patch the bubble in place.
+ */
+export async function cancelPendingAIMessage(
+  messageId: string,
+  content: string,
+  options: {
+    meta?: Record<string, any>;
+    customSender?: AIMessageSenderInfo;
+  } = {},
+): Promise<void> {
+  try {
+    const updated = await prisma.message.update({
+      where: { id: messageId },
+      data: {
+        content,
+        status: JobStatus.CANCELLED,
+        ...(options.meta !== undefined && {
+          meta: options.meta as Prisma.InputJsonValue,
+        }),
+      },
+      include: {
+        attachments: true,
+      },
+    });
+
+    logger.info('AI message cancelled', {
+      messageId: updated.id,
+      conversationId: updated.conversationId,
+      contentLength: content.length,
+    });
+
+    const senderInfo = buildAISenderInfo(options.customSender);
+
+    try {
+      await pusher.trigger(chatChannel(updated.conversationId), 'message-updated', {
+        id: updated.id,
+        content: updated.content,
+        senderId: updated.senderId,
+        conversationId: updated.conversationId,
+        status: updated.status,
+        createdAt: updated.createdAt,
+        sender: senderInfo,
+        mentionedUserIds: [],
+        meta: updated.meta ?? {},
+        attachments: updated.attachments.map((attachment) => ({
+          id: attachment.id,
+          attachmentId: attachment.id,
+          name: attachment.name,
+          type: attachment.type,
+          size: attachment.size,
+          path: attachment.path,
+        })),
+      });
+    } catch (broadcastError) {
+      logger.error('Failed to broadcast cancelled AI message:', {
+        error: broadcastError,
+        messageId,
+      });
+    }
+  } catch (error) {
+    logger.error('Failed to mark AI message as cancelled:', {
+      error,
+      messageId,
+    });
+  }
+}
+
 /**
  * Flip a PENDING AI message to FAILED and broadcast the status change.
  * Does NOT throw — failure paths in the pipelines call this in catch blocks
@@ -486,6 +557,20 @@ export async function failPendingAIMessage(
   options: { reason?: string } = {},
 ): Promise<void> {
   try {
+    const current = await prisma.message.findUnique({
+      where: { id: messageId },
+      select: { status: true },
+    });
+    // A message the user already cancelled must stay CANCELLED — late
+    // failures from the aborted pipeline are a consequence of the cancel.
+    if (current?.status === JobStatus.CANCELLED) {
+      logger.info('Skipping FAILED flip; AI message already cancelled', {
+        messageId,
+        reason: options.reason,
+      });
+      return;
+    }
+
     const updated = await prisma.message.update({
       where: { id: messageId },
       data: { status: JobStatus.FAILED },