@studious-lms/server 1.4.0 → 1.4.1

package/src/services/labChat.ts

@@ -19,6 +19,7 @@ import {
 } from "../models/labChat.js";
 import { generateAndSendLabIntroduction, generateAndSendLabResponse } from "../pipelines/aiLabChat.js";
 import { isAIUser } from "../utils/aiUser.js";
+import { logger } from "../utils/logger.js";
 
 /** Create a lab chat with conversation and teacher members. Broadcasts via Pusher. */
 export async function createLabChat(
@@ -243,6 +244,7 @@ export async function postToLabChat(
         content,
         senderId: userId,
         conversationId: labChat.conversationId,
+        ...(isAIUser(userId) ? {} : { status: GenerationStatus.PENDING }),
       },
       include: {
         sender: {
@@ -296,10 +298,6 @@ 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,
@@ -309,11 +307,16 @@ export async function postToLabChat(
     } catch (error) {
       console.error("Failed to broadcast lab response pending:", error);
     }
-    generateAndSendLabResponse(
-      labChatId,
-      content,
-      labChat.conversationId,
-      { classId: labChat.classId, messageId: result.id }
+    generateAndSendLabResponse(labChatId, content, {
+      classId: labChat.classId,
+      messageId: result.id,
+    }).catch((error) =>
+      logger.error("Failed to generate lab response", {
+        error,
+        labChatId,
+        messageId: result.id,
+        conversationId: labChat.conversationId,
+      })
     );
   }
 
@@ -419,9 +422,15 @@ export async function rerunLastResponse(userId: string, labChatId: string) {
     });
   }
 
-  await prisma.message.delete({
-    where: { id: lastMessage.id },
-  });
+  await prisma.$transaction([
+    prisma.message.delete({
+      where: { id: lastMessage.id },
+    }),
+    prisma.message.update({
+      where: { id: teacherMessage.id },
+      data: { status: GenerationStatus.PENDING },
+    }),
+  ]);
 
   try {
     await pusher.trigger(chatChannel(labChat.conversationId), "message-deleted", {
@@ -432,11 +441,6 @@ export async function rerunLastResponse(userId: string, labChatId: string) {
   } 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,
@@ -447,11 +451,16 @@ export async function rerunLastResponse(userId: string, labChatId: string) {
     console.error("Failed to broadcast lab response pending:", error);
   }
 
-  generateAndSendLabResponse(
-    labChatId,
-    teacherMessage.content,
-    labChat.conversationId,
-    { classId: labChat.classId, messageId: teacherMessage.id }
+  generateAndSendLabResponse(labChatId, teacherMessage.content, {
+    classId: labChat.classId,
+    messageId: teacherMessage.id,
+  }).catch((error) =>
+    logger.error("Failed to generate lab response", {
+      error,
+      labChatId,
+      messageId: teacherMessage.id,
+      conversationId: labChat.conversationId,
+    })
   );
 
   return { success: true };

package/src/services/message.ts

@@ -363,6 +363,8 @@ const CREATED_INDICES_KEY: Record<"assignment" | "worksheet" | "section", string
   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,
@@ -393,61 +395,108 @@ export async function markSuggestionCreated(
     });
   }
 
-  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 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 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 },
+    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: { id: true, name: true, type: true } },
+          mentions: { select: { userId: 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[],
+      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,
+              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,
+          });
+        }
       }
-    );
-  } catch (error) {
-    logger.error("Failed to broadcast suggestion status via Pusher", {
-      error,
-      messageId,
-    });
+      return { success: true };
+    }
+
+    lastError = new Error("Concurrent update conflict");
   }
 
-  return { success: true };
+  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) {

package/src/services/studentProgress.ts

@@ -0,0 +1,390 @@
+/**
+ * Student progress service - assignment recommendations and progress chat.
+ */
+import { TRPCError } from "@trpc/server";
+import { prisma } from "../lib/prisma.js";
+import { inference } from "../utils/inference.js";
+import { logger } from "../utils/logger.js";
+import { isTeacherInClass } from "../models/class.js";
+import type { AssignmentType } from "@prisma/client";
+
+type ProgressChatMessage = {
+  role: "user" | "assistant";
+  content: string;
+};
+
+type GradeSubmission = {
+  id: string;
+  gradeReceived: number | null;
+  submitted: boolean | null;
+  returned: boolean | null;
+  submittedAt: Date | null;
+  assignment: {
+    id: string;
+    title: string;
+    dueDate: Date;
+    maxGrade: number | null;
+    weight: number;
+    type: AssignmentType;
+    section: { id: string; name: string } | null;
+  };
+};
+
+function calculatePercentage(submission: GradeSubmission) {
+  if (submission.gradeReceived == null || !submission.assignment.maxGrade)
+    return null;
+  return (
+    Math.round(
+      (submission.gradeReceived / submission.assignment.maxGrade) * 1000,
+    ) / 10
+  );
+}
+
+function calculateTrend(submissions: GradeSubmission[]) {
+  const graded = submissions
+    .filter(
+      (submission) =>
+        submission.gradeReceived != null && submission.assignment.maxGrade,
+    )
+    .sort((a, b) => {
+      const aTime = a.submittedAt?.getTime() ?? a.assignment.dueDate.getTime();
+      const bTime = b.submittedAt?.getTime() ?? b.assignment.dueDate.getTime();
+      return aTime - bTime;
+    })
+    .map((submission) => calculatePercentage(submission))
+    .filter((value): value is number => value != null);
+
+  if (graded.length < 2) return 0;
+  const midpoint = Math.floor(graded.length / 2);
+  const first = graded.slice(0, midpoint);
+  const second = graded.slice(midpoint);
+  const average = (values: number[]) =>
+    values.reduce((sum, value) => sum + value, 0) / values.length;
+  return Math.round((average(second) - average(first)) * 10) / 10;
+}
+
+function getOverallGrade(submissions: GradeSubmission[]) {
+  let totalWeighted = 0;
+  let totalWeight = 0;
+
+  for (const submission of submissions) {
+    if (
+      submission.gradeReceived != null &&
+      submission.assignment.maxGrade &&
+      submission.assignment.weight
+    ) {
+      totalWeighted +=
+        (submission.gradeReceived / submission.assignment.maxGrade) *
+        submission.assignment.weight;
+      totalWeight += submission.assignment.weight;
+    }
+  }
+
+  return totalWeight > 0
+    ? Math.round((totalWeighted / totalWeight) * 1000) / 10
+    : null;
+}
+
+async function loadStudentProgressContext(
+  viewerId: string,
+  classId: string,
+  studentId: string,
+) {
+  const isTeacher = await isTeacherInClass(classId, viewerId);
+  if (viewerId !== studentId && !isTeacher) {
+    throw new TRPCError({
+      code: "UNAUTHORIZED",
+      message: "You can only view your own progress",
+    });
+  }
+
+  const [classData, student, submissions] = await Promise.all([
+    prisma.class.findUnique({
+      where: { id: classId },
+      select: { id: true, name: true, subject: true },
+    }),
+    prisma.user.findFirst({
+      where: {
+        id: studentId,
+        studentIn: { some: { id: classId } },
+      },
+      select: {
+        id: true,
+        username: true,
+        profile: { select: { displayName: true } },
+      },
+    }),
+    prisma.submission.findMany({
+      where: {
+        studentId,
+        assignment: { classId, graded: true },
+      },
+      include: {
+        assignment: {
+          select: {
+            id: true,
+            title: true,
+            dueDate: true,
+            maxGrade: true,
+            weight: true,
+            type: true,
+            section: { select: { id: true, name: true } },
+          },
+        },
+      },
+      orderBy: { assignment: { dueDate: "asc" } },
+    }),
+  ]);
+
+  if (!classData) {
+    throw new TRPCError({ code: "NOT_FOUND", message: "Class not found" });
+  }
+
+  if (!student) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "Student not found in this class",
+    });
+  }
+
+  return { classData, student, submissions };
+}
+
+export async function getStudentProgressRecommendations(
+  viewerId: string,
+  classId: string,
+  studentId: string,
+) {
+  const { student, submissions } = await loadStudentProgressContext(
+    viewerId,
+    classId,
+    studentId,
+  );
+
+  const now = new Date();
+  const recommendationCandidates = submissions
+    .map((submission) => {
+      const percentage = calculatePercentage(submission);
+      const isMissing =
+        !submission.submitted &&
+        submission.assignment.dueDate.getTime() < now.getTime();
+      const isLowScore = percentage != null && percentage < 70;
+      const isUnreturned =
+        Boolean(submission.submitted) &&
+        submission.gradeReceived == null &&
+        !submission.returned;
+      const isUpcoming =
+        !Boolean(submission.submitted) &&
+        !submission.submittedAt &&
+        !submission.returned &&
+        submission.gradeReceived == null &&
+        submission.assignment.dueDate.getTime() >= now.getTime();
+      const reasons: string[] = [];
+      let priorityScore = 0;
+
+      if (isMissing) {
+        reasons.push("Missing past-due work");
+        priorityScore += 100;
+      }
+      if (isLowScore) {
+        reasons.push(`Scored ${percentage}%`);
+        priorityScore += 85 - (percentage ?? 0);
+      }
+      if (isUnreturned) {
+        reasons.push("Awaiting grade or feedback");
+        priorityScore += 15;
+      }
+      if (isUpcoming) {
+        reasons.push("Upcoming graded assignment");
+        priorityScore += 5;
+      }
+
+      return {
+        assignmentId: submission.assignment.id,
+        submissionId: submission.id,
+        title: submission.assignment.title,
+        type: submission.assignment.type,
+        sectionName: submission.assignment.section?.name ?? null,
+        dueDate: submission.assignment.dueDate,
+        gradeReceived: submission.gradeReceived,
+        maxGrade: submission.assignment.maxGrade,
+        percentage,
+        submitted: Boolean(submission.submitted),
+        returned: Boolean(submission.returned),
+        reasons,
+        priorityScore,
+      };
+    })
+    .filter((candidate) => candidate.priorityScore > 0)
+    .sort((a, b) => b.priorityScore - a.priorityScore)
+    .slice(0, 5);
+
+  const gradedPercentages = submissions
+    .map(calculatePercentage)
+    .filter((value): value is number => value != null);
+  const lowScoreCount = gradedPercentages.filter(
+    (percentage) => percentage < 70,
+  ).length;
+  const missingCount = submissions.filter(
+    (submission) =>
+      !submission.submitted &&
+      submission.assignment.dueDate.getTime() < now.getTime(),
+  ).length;
+  const trend = calculateTrend(submissions);
+  const overallGrade = getOverallGrade(submissions);
+
+  const nextSteps = [
+    missingCount > 0
+      ? `Prioritize ${missingCount} missing assignment${missingCount === 1 ? "" : "s"}.`
+      : null,
+    lowScoreCount > 0
+      ? `Review ${lowScoreCount} low-scoring assignment${lowScoreCount === 1 ? "" : "s"} before introducing new material.`
+      : null,
+    trend < -5
+      ? "Schedule a check-in because recent performance is trending down."
+      : null,
+    recommendationCandidates.length === 0
+      ? "No urgent assignment issues detected from the available grades."
+      : null,
+  ].filter((step): step is string => Boolean(step));
+
+  return {
+    student: {
+      id: student.id,
+      username: student.username,
+      displayName: student.profile?.displayName ?? student.username,
+    },
+    summary: {
+      overallGrade,
+      trend,
+      completedAssignments: submissions.filter((submission) =>
+        Boolean(submission.submitted),
+      ).length,
+      totalAssignments: submissions.length,
+      missingCount,
+      lowScoreCount,
+    },
+    recommendations: recommendationCandidates.map(
+      ({ priorityScore, ...candidate }) => candidate,
+    ),
+    nextSteps,
+  };
+}
+
+function buildProgressSummary(submissions: GradeSubmission[]) {
+  return submissions.map((submission) => ({
+    title: submission.assignment.title,
+    type: submission.assignment.type,
+    dueDate: submission.assignment.dueDate.toISOString(),
+    submitted: Boolean(submission.submitted),
+    returned: Boolean(submission.returned),
+    gradeReceived: submission.gradeReceived,
+    maxGrade: submission.assignment.maxGrade,
+    percentage: calculatePercentage(submission),
+    section: submission.assignment.section?.name ?? null,
+  }));
+}
+
+export async function chatAboutStudentProgress(
+  viewerId: string,
+  input: {
+    classId: string;
+    studentId: string;
+    message: string;
+    history?: ProgressChatMessage[];
+  },
+) {
+  const { classData, student, submissions } = await loadStudentProgressContext(
+    viewerId,
+    input.classId,
+    input.studentId,
+  );
+
+  const displayName = student.profile?.displayName ?? student.username;
+  const summary = {
+    overallGrade: getOverallGrade(submissions),
+    trend: calculateTrend(submissions),
+    assignments: buildProgressSummary(submissions),
+  };
+
+  const messages = [
+    {
+      role: "system" as const,
+      content:
+        "You are an educational progress assistant for teachers and students. Use only the provided class and grade context. Be concise, specific, supportive, and avoid fabricating grades or assignments.",
+    },
+    {
+      role: "user" as const,
+      content: JSON.stringify({
+        class: classData,
+        student: { id: student.id, username: student.username, displayName },
+        progress: summary,
+      }),
+    },
+    ...(input.history ?? []).slice(-8).map((message) => ({
+      role: message.role,
+      content: message.content,
+    })),
+    { role: "user" as const, content: input.message },
+  ];
+
+  try {
+    const response = await inference<string>(messages);
+    if (typeof response !== "string" || response.trim().length === 0) {
+      throw new Error("Student progress chat returned an empty response");
+    }
+    return { message: response, isFallback: false };
+  } catch (error) {
+    logger.error("Failed to generate student progress chat response", {
+      error,
+      classId: input.classId,
+      studentId: input.studentId,
+    });
+
+    const overall =
+      summary.overallGrade == null
+        ? "not enough graded work"
+        : `${summary.overallGrade}%`;
+    const missingItems = summary.assignments.filter(
+      (assignment) =>
+        !assignment.submitted &&
+        new Date(assignment.dueDate).getTime() < Date.now(),
+    ).length;
+    const lowScores = summary.assignments.filter(
+      (assignment) =>
+        assignment.percentage != null && assignment.percentage < 70,
+    ).length;
+    const awaitingFeedback = summary.assignments.filter(
+      (assignment) =>
+        assignment.submitted &&
+        assignment.gradeReceived == null &&
+        !assignment.returned,
+    ).length;
+    const trendLabel =
+      summary.overallGrade == null
+        ? "not enough graded work to determine a recent trend"
+        : summary.trend > 5
+        ? "improving"
+        : summary.trend < -5
+          ? "declining"
+          : "stable";
+    const advice = [
+      missingItems > 0
+        ? `Review ${missingItems} missing assignment${missingItems === 1 ? "" : "s"}.`
+        : null,
+      lowScores > 0
+        ? `Use targeted practice for ${lowScores} low-scoring assignment${lowScores === 1 ? "" : "s"}.`
+        : null,
+      awaitingFeedback > 0
+        ? `Check back after feedback is returned for ${awaitingFeedback} submitted assignment${awaitingFeedback === 1 ? "" : "s"}.`
+        : null,
+      missingItems === 0 && lowScores === 0 && awaitingFeedback === 0
+        ? "Check upcoming work and ask for feedback as new grades are returned."
+        : null,
+    ].filter((item): item is string => Boolean(item));
+    return {
+      message: `${displayName}'s current overall progress is ${overall}, with ${trendLabel}. ${advice.join(" ")}`,
+      isFallback: true,
+    };
+  }
+}

package/tests/lib/aiLabChatContract.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, test } from "vitest";
+import { labChatArrayFieldInstructions, labChatResponseFormat, labChatResponseSchema } from "../../src/pipelines/aiLabChatContract.js";
+
+describe("aiLabChat contract", () => {
+  test("defaults worksheet and section collections to empty arrays", () => {
+    const parsed = labChatResponseSchema.parse({
+      text: "Summary",
+      docs: null,
+      assignmentsToCreate: null,
+    });
+
+    expect(parsed.worksheetsToCreate).toEqual([]);
+    expect(parsed.sectionsToCreate).toEqual([]);
+  });
+
+  test("rejects null worksheet and section collections", () => {
+    expect(() => labChatResponseSchema.parse({
+      text: "Summary",
+      docs: null,
+      worksheetsToCreate: null,
+      sectionsToCreate: null,
+      assignmentsToCreate: null,
+    })).toThrow();
+  });
+
+  test("prompt instructions require arrays for worksheet and section fields", () => {
+    expect(labChatResponseFormat).toContain(`"worksheetsToCreate": array`);
+    expect(labChatResponseFormat).toContain(`"sectionsToCreate": array`);
+    expect(labChatArrayFieldInstructions).toContain(`Use [] when there are no worksheets to create.`);
+    expect(labChatArrayFieldInstructions).toContain(`Use [] when there are no sections to create.`);
+  });
+});