@studious-lms/server 1.4.2 → 1.4.4

package/src/models/worksheet.ts

@@ -4,6 +4,21 @@
 import { prisma } from "../lib/prisma.js";
 import type { WorksheetQuestionType, GenerationStatus } from "@prisma/client";
 
+const worksheetClassMemberWhere = (userId: string) => ({
+  class: {
+    OR: [
+      { teachers: { some: { id: userId } } },
+      { students: { some: { id: userId } } },
+    ],
+  },
+});
+
+const worksheetTeacherWhere = (userId: string) => ({
+  class: {
+    teachers: { some: { id: userId } },
+  },
+});
+
 /** @returns Worksheet with questions and class. */
 export function findWorksheetById(id: string) {
   return prisma.worksheet.findUnique({
@@ -22,6 +37,34 @@ export function findWorksheetByIdMinimal(id: string) {
   });
 }
 
+/** @returns Worksheet by ID for an authorized class member. */
+export function findWorksheetByIdForClassMember(id: string, userId: string) {
+  return prisma.worksheet.findFirst({
+    where: {
+      id,
+      ...worksheetClassMemberWhere(userId),
+    },
+    include: {
+      questions: { orderBy: { createdAt: "asc" as const } },
+      class: true,
+    },
+  });
+}
+
+/** @returns Worksheet by ID for an authorized teacher. */
+export function findWorksheetByIdForTeacher(id: string, userId: string) {
+  return prisma.worksheet.findFirst({
+    where: {
+      id,
+      ...worksheetTeacherWhere(userId),
+    },
+    include: {
+      questions: { orderBy: { createdAt: "asc" as const } },
+      class: true,
+    },
+  });
+}
+
 /** @returns Worksheets for a class. */
 export function findWorksheetsByClassId(classId: string) {
   return prisma.worksheet.findMany({
@@ -33,6 +76,26 @@ export function findWorksheetsByClassId(classId: string) {
   });
 }
 
+/** @returns Worksheet question by ID for an authorized teacher. */
+export function findWorksheetQuestionByIdForTeacher(id: string, userId: string) {
+  return prisma.worksheetQuestion.findFirst({
+    where: {
+      id,
+      worksheet: worksheetTeacherWhere(userId),
+    },
+  });
+}
+
+/** @returns Worksheet question scoped to a worksheet. */
+export function findWorksheetQuestionByIdInWorksheet(
+  id: string,
+  worksheetId: string
+) {
+  return prisma.worksheetQuestion.findFirst({
+    where: { id, worksheetId },
+  });
+}
+
 /** Create a worksheet. */
 export function createWorksheet(data: { classId: string; name: string }) {
   return prisma.worksheet.create({
@@ -72,6 +135,7 @@ export function createWorksheetQuestion(data: {
   points?: number;
   options?: object;
   markScheme?: object;
+  order?: number;
 }) {
   return prisma.worksheetQuestion.create({
     data,
@@ -118,6 +182,45 @@ export function findSubmissionById(id: string) {
   });
 }
 
+/** @returns Submission if requester is the owning student or a class teacher for the worksheet. */
+export function findSubmissionByIdForWorksheetAccess(
+  id: string,
+  worksheetId: string,
+  worksheetClassId: string,
+  userId: string
+) {
+  return prisma.submission.findFirst({
+    where: {
+      id,
+      assignment: {
+        classId: worksheetClassId,
+        worksheets: { some: { id: worksheetId } },
+      },
+      OR: [
+        {
+          studentId: userId,
+          assignment: {
+            class: {
+              students: { some: { id: userId } },
+            },
+          },
+        },
+        {
+          assignment: {
+            class: {
+              teachers: { some: { id: userId } },
+            },
+          },
+        },
+      ],
+    },
+    select: {
+      id: true,
+      studentId: true,
+    },
+  });
+}
+
 const worksheetResponseInclude = {
   responses: {
     include: {
@@ -182,6 +285,29 @@ export function findWorksheetResponseById(id: string) {
   });
 }
 
+/** @returns Worksheet response if requester is the owning student. */
+export function findWorksheetResponseByIdForStudent(id: string, userId: string) {
+  return prisma.studentWorksheetResponse.findFirst({
+    where: {
+      id,
+      studentId: userId,
+      worksheet: worksheetClassMemberWhere(userId),
+    },
+    include: { responses: true, worksheet: true },
+  });
+}
+
+/** @returns Worksheet response if requester is a class teacher. */
+export function findWorksheetResponseByIdForTeacher(id: string, userId: string) {
+  return prisma.studentWorksheetResponse.findFirst({
+    where: {
+      id,
+      worksheet: worksheetTeacherWhere(userId),
+    },
+    include: { responses: true, worksheet: true },
+  });
+}
+
 /** @returns Worksheet response with question responses. */
 export function findWorksheetResponseWithResponses(
   id: string,
@@ -197,6 +323,43 @@ export function findWorksheetResponseWithResponses(
   });
 }
 
+/** @returns Worksheet response with scoped responses if requester is the owning student. */
+export function findWorksheetResponseWithResponsesForStudent(
+  id: string,
+  userId: string,
+  questionId?: string
+) {
+  return prisma.studentWorksheetResponse.findFirst({
+    where: {
+      id,
+      studentId: userId,
+      worksheet: worksheetClassMemberWhere(userId),
+    },
+    include: {
+      worksheet: true,
+      responses: questionId ? { where: { questionId } } : true,
+    },
+  });
+}
+
+/** @returns Worksheet response with scoped responses if requester is a class teacher. */
+export function findWorksheetResponseWithResponsesForTeacher(
+  id: string,
+  userId: string,
+  questionId?: string
+) {
+  return prisma.studentWorksheetResponse.findFirst({
+    where: {
+      id,
+      worksheet: worksheetTeacherWhere(userId),
+    },
+    include: {
+      worksheet: true,
+      responses: questionId ? { where: { questionId } } : true,
+    },
+  });
+}
+
 /** @returns Worksheet question by ID. */
 export function findWorksheetQuestionById(id: string) {
   return prisma.worksheetQuestion.findUnique({
@@ -204,6 +367,46 @@ export function findWorksheetQuestionById(id: string) {
   });
 }
 
+/** @returns Student question progress if requester is a class teacher. */
+export function findStudentQuestionProgressByIdForTeacher(
+  id: string,
+  userId: string
+) {
+  return prisma.studentQuestionProgress.findFirst({
+    where: {
+      id,
+      question: {
+        worksheet: worksheetTeacherWhere(userId),
+      },
+    },
+    include: {
+      question: true,
+      studentWorksheetResponse: true,
+    },
+  });
+}
+
+/** @returns Student question progress by id and worksheet response if requester is a class teacher. */
+export function findStudentQuestionProgressByIdForTeacherAndResponse(
+  id: string,
+  studentWorksheetResponseId: string,
+  userId: string
+) {
+  return prisma.studentQuestionProgress.findFirst({
+    where: {
+      id,
+      studentWorksheetResponseId,
+      question: {
+        worksheet: worksheetTeacherWhere(userId),
+      },
+    },
+    include: {
+      question: true,
+      studentWorksheetResponse: true,
+    },
+  });
+}
+
 /** Update student's question progress. */
 export function updateStudentQuestionProgress(
   id: string,

package/src/pipelines/aiLabChat.ts

@@ -479,7 +479,15 @@ export const generateAndSendLabIntroduction = async (
     //   });
 
     const response = await withTimeout(
-      inference<LabChatResponse>(messages, labChatResponseSchema),
+      inference<LabChatResponse>(messages, labChatResponseSchema, {
+        reason: 'lab_chat_response',
+        metadata: {
+          labChatId,
+          conversationId,
+          classId: fullLabChat.classId,
+          ...(emitOptions?.messageId ? { messageId: emitOptions.messageId } : {}),
+        },
+      }),
       LAB_CHAT_RESPONSE_TIMEOUT_MS,
       "Lab chat response generation",
     );

package/src/pipelines/aiNewtonChat.ts

@@ -3,7 +3,7 @@
  * Uses assignment context and AI policy levels for tutoring.
  */
 import { prisma } from "../lib/prisma.js";
-import { inference, inferenceClient, openAIClient } from "../utils/inference.js";
+import { inference } from "../utils/inference.js";
 import { logger } from "../utils/logger.js";
 import { sendAIMessage } from "../utils/inference.js";
 import { isAIUser } from "../utils/aiUser.js";
@@ -132,20 +132,23 @@ export const generateAndSendNewtonIntroduction = async (
   
   Do not use markdown formatting in your responses - use plain text only.`;
   
-      const completion = await inferenceClient.chat.completions.create({
+      const response = await inference<string>([
+        { role: 'system', content: systemPrompt },
+        {
+          role: 'user',
+          content: 'Please introduce yourself to the student. Explain that you are Newton, their AI tutor, and you are here to help them with their assignment. Ask them what they would like help with.'
+        },
+      ], undefined, {
+        reason: 'newton_chat_introduction',
+        metadata: {
+          newtonChatId,
+          conversationId,
+          submissionId: submission.id,
+        },
         model: 'command-a-03-2025',
-        messages: [
-          { role: 'system', content: systemPrompt },
-          { 
-            role: 'user', 
-            content: 'Please introduce yourself to the student. Explain that you are Newton, their AI tutor, and you are here to help them with their assignment. Ask them what they would like help with.' 
-          },
-        ],
-        max_tokens: 300,
+        maxTokens: 300,
         temperature: 0.8,
       });
-  
-      const response = completion.choices[0]?.message?.content;
       
       if (!response) {
         throw new Error('No response generated from inference API');
@@ -320,7 +323,14 @@ export const generateAndSendNewtonIntroduction = async (
         content: `SYSTEM: ${formatAssignmentString(assignmentData)}`,
       });
   
-      const response = await inference<string>(messages);
+      const response = await inference<string>(messages, undefined, {
+        reason: 'newton_chat_response',
+        metadata: {
+          newtonChatId,
+          conversationId,
+          submissionId: submission.id,
+        },
+      });
       
       if (!response) {
         throw new Error('No response generated from inference API');
@@ -344,4 +354,4 @@ export const generateAndSendNewtonIntroduction = async (
       });
     }
   }
-  
+  

package/src/pipelines/gradeWorksheet.ts

@@ -97,6 +97,14 @@ const gradeWorksheetQuestion = async (worksheetResponseId: string, worksheetQues
                   })), // @note: this has to be converted to [id: string]: correct boolean
                 comments: z.array(z.string()),
             }),
+            {
+                reason: 'worksheet_autograde',
+                metadata: {
+                    worksheetResponseId: worksheetResponse.id,
+                    questionId: worksheetQuestionProgressId,
+                    studentId: worksheetResponse.studentId,
+                },
+            },
         ).catch((error) => {
             logger.error('Failed to grade worksheet response', { error });
             throw error;

package/src/pipelines/pdfToWorksheet.ts

@@ -0,0 +1,177 @@
+/**
+ * PDF URL → worksheet: send a remote PDF URL to structured inference,
+ * then persist a Worksheet and WorksheetQuestion rows.
+ */
+import { z } from "zod";
+import type { ResponseInput } from "openai/resources/responses/responses.js";
+import { prisma } from "../lib/prisma.js";
+import { inference } from "../utils/inference.js";
+import { logger } from "../utils/logger.js";
+
+/** Restrict remote fetches to Google-hosted object URLs. */
+function isProbablyGoogleCloudUrl(url: string): boolean {
+  try {
+    const host = new URL(url).hostname;
+    return (
+      host.endsWith("storage.googleapis.com") ||
+      host.endsWith("googleusercontent.com") ||
+      host.includes("storage.cloud.google.com")
+    );
+  } catch {
+    return false;
+  }
+}
+
+function getFilenameFromUrl(url: string): string {
+  try {
+    const parsed = new URL(url);
+    const lastSegment = parsed.pathname.split("/").filter(Boolean).pop();
+    return lastSegment && lastSegment.includes(".") ? lastSegment : "document.pdf";
+  } catch {
+    return "document.pdf";
+  }
+}
+
+function sanitizeUrlForLogs(url: string): string {
+  try {
+    const parsed = new URL(url);
+    return `${parsed.origin}${parsed.pathname}`;
+  } catch {
+    return 'invalid-url';
+  }
+}
+
+/** LLM output shape (validated by inference). */
+const worksheetDraftSchema = z.object({
+  title: z.string(),
+  questions: z
+    .array(
+      z.object({
+        type: z.enum([
+          "MULTIPLE_CHOICE",
+          "TRUE_FALSE",
+          "SHORT_ANSWER",
+          "LONG_ANSWER",
+          "MATH_EXPRESSION",
+          "ESSAY",
+        ]),
+        question: z.string(),
+        answer: z.string(),
+        options: z
+          .array(
+            z.object({
+              id: z.string(),
+              text: z.string(),
+              isCorrect: z.boolean(),
+            })
+          )
+          .optional()
+          .default([]),
+        markScheme: z
+          .array(
+              z.object({
+                id: z.string(),
+                points: z.number().transform((value) => Math.round(value)),
+                description: z.string(),
+              })
+          )
+          .optional()
+          .default([]),
+        points: z.number().optional().default(0),
+        order: z.number().transform((value) => Math.round(value)),
+      })
+    )
+    .default([]),
+});
+
+type WorksheetDraft = z.infer<typeof worksheetDraftSchema>;
+
+const schemaInstructions = `Return ONLY valid JSON matching this schema:
+{
+  "title": string,
+  "questions": [
+    {
+      "type": "MULTIPLE_CHOICE" | "TRUE_FALSE" | "SHORT_ANSWER" | "LONG_ANSWER" | "MATH_EXPRESSION" | "ESSAY",
+      "question": string,
+      "answer": string,
+      "options": [ { "id": string, "text": string, "isCorrect": boolean } ],
+      "markScheme": [ { "id": string, "points": number, "description": string } ],
+      "points": number,
+      "order": number
+    }
+  ]
+}
+Rules: "questions" is an array ([] if none). Non-MCQ "options" can be []. Use "order" 1,2,3,… in reading order. No markdown or extra keys.
+If no answer is provided for a multiple-choice or true/false question, determine the answer from the options.`;
+
+/**
+ * Sends a PDF URL to the model for remote retrieval, extracts a worksheet via
+ * structured inference, and inserts worksheet + questions in one DB transaction.
+ */
+export async function pdfToWorksheet(gcsUrl: string, classId: string) {
+  const sanitizedUrl = sanitizeUrlForLogs(gcsUrl);
+
+  if (!isProbablyGoogleCloudUrl(gcsUrl)) {
+    logger.warn("pdfToWorksheet: rejected unsupported PDF URL", {
+      sanitizedUrl,
+    });
+    throw new Error("Only Google Cloud Storage URLs are supported");
+  }
+
+  const filename = getFilenameFromUrl(gcsUrl);
+  const prompt = `Read the attached PDF and convert it into a single worksheet JSON object.\n\n${schemaInstructions}`;
+
+  // Force Responses API input types so we can pass a remote PDF via `file_url`.
+  const input: ResponseInput = [
+    {
+      role: "user",
+      content: [
+        { type: "input_text", text: prompt },
+        { type: "input_file", file_url: gcsUrl },
+      ],
+    },
+  ];
+
+  const draft = await inference<WorksheetDraft>(
+    input,
+    worksheetDraftSchema,
+    {
+      reason: 'pdf_to_worksheet_draft',
+      metadata: {
+        classId,
+        filename,
+      },
+    }
+  );
+
+  if (!draft) {
+    logger.warn("pdfToWorksheet: no model output", { filename });
+    return null;
+  }
+
+  return prisma.$transaction(async (tx) => {
+    const worksheet = await tx.worksheet.create({
+      data: { classId, name: draft.title },
+    });
+
+    if (draft.questions.length > 0) {
+      await tx.worksheetQuestion.createMany({
+        data: draft.questions.map((question) => ({
+          worksheetId: worksheet.id,
+          type: question.type,
+          question: question.question,
+          answer: question.answer,
+          points: Math.round(question.points ?? 0),
+          options: question.options ?? [],
+          markScheme: (question.markScheme ?? []).map((item) => ({
+            ...item,
+            points: Math.round(item.points),
+          })),
+          order: Math.round(question.order),
+        })),
+      });
+    }
+
+    return worksheet;
+  });
+}

package/src/routers/class.ts

@@ -46,7 +46,7 @@ export const classRouter = createTRPCRouter({
     getAllClasses(ctx.user?.id ?? "")
   ),
 
-  get: protectedProcedure
+  get: protectedClassMemberProcedure
     .input(z.object({ classId: z.string() }))
     .query(({ ctx, input }) =>
       getClass(ctx.user?.id ?? "", input.classId)
@@ -329,4 +329,4 @@ export const classRouter = createTRPCRouter({
     .mutation(({ ctx, input }) =>
       importClass(input.classId, ctx.user?.id ?? "", input.year, input.classData)
     ),
-});
+});

package/src/routers/labChat.ts

@@ -38,8 +38,9 @@ export const labChatRouter = createTRPCRouter({
     .input(
       z.object({
         labChatId: z.string(),
-        content: z.string().min(1).max(4000),
+        content: z.string().max(4000),
         mentionedUserIds: z.array(z.string()).optional(),
+        fileIds: z.array(z.string()).max(10).optional(),
       })
     )
     .mutation(({ ctx, input }) =>
@@ -47,6 +48,7 @@ export const labChatRouter = createTRPCRouter({
         labChatId: input.labChatId,
         content: input.content,
         mentionedUserIds: input.mentionedUserIds,
+        fileIds: input.fileIds,
       })
     ),
 

package/src/routers/message.ts

@@ -5,6 +5,8 @@ import {
   sendMessage,
   updateMessage,
   deleteMessage,
+  getMessageUploadUrls,
+  confirmMessageUpload,
   markAsRead,
   markMentionsAsRead,
   markSuggestionCreated,
@@ -32,8 +34,9 @@ export const messageRouter = createTRPCRouter({
     .input(
       z.object({
         conversationId: z.string(),
-        content: z.string().min(1).max(4000),
+        content: z.string().max(4000),
         mentionedUserIds: z.array(z.string()).optional(),
+        fileIds: z.array(z.string()).max(10).optional(),
       })
     )
     .mutation(({ ctx, input }) =>
@@ -41,9 +44,43 @@ export const messageRouter = createTRPCRouter({
         conversationId: input.conversationId,
         content: input.content,
         mentionedUserIds: input.mentionedUserIds,
+        fileIds: input.fileIds,
       })
     ),
 
+  getUploadUrls: protectedProcedure
+    .input(
+      z.object({
+        conversationId: z.string(),
+        files: z
+          .array(
+            z.object({
+              name: z.string().min(1),
+              type: z.string().min(1),
+              size: z.number().int().nonnegative(),
+            })
+          )
+          .min(1)
+          .max(10),
+      })
+    )
+    .mutation(({ ctx, input }) =>
+      getMessageUploadUrls(ctx.user!.id, input)
+    ),
+
+  confirmUpload: protectedProcedure
+    .input(
+      z.object({
+        conversationId: z.string(),
+        fileId: z.string(),
+        uploadSuccess: z.boolean(),
+        errorMessage: z.string().optional(),
+      })
+    )
+    .mutation(({ ctx, input }) =>
+      confirmMessageUpload(ctx.user!.id, input)
+    ),
+
   update: protectedProcedure
     .input(
       z.object({

package/src/routers/newtonChat.ts

@@ -21,8 +21,9 @@ export const newtonChatRouter = createTRPCRouter({
     .input(
       z.object({
         newtonChatId: z.string(),
-        content: z.string().min(1).max(4000),
+        content: z.string().max(4000),
         mentionedUserIds: z.array(z.string()).optional(),
+        fileIds: z.array(z.string()).max(10).optional(),
       })
     )
     .mutation(({ ctx, input }) =>
@@ -30,7 +31,8 @@ export const newtonChatRouter = createTRPCRouter({
         ctx.user!.id,
         input.newtonChatId,
         input.content,
-        input.mentionedUserIds ?? []
+        input.mentionedUserIds ?? [],
+        input.fileIds ?? []
       )
     ),
 });

package/src/routers/notifications.ts

@@ -15,7 +15,7 @@ export const notificationRouter = createTRPCRouter({
 
   get: protectedProcedure
     .input(z.object({ id: z.string() }))
-    .query(({ input }) => getNotification(input.id)),
+    .query(({ ctx, input }) => getNotification(ctx.user!.id, input.id)),
 
   sendTo: protectedProcedure
     .input(
@@ -39,5 +39,5 @@ export const notificationRouter = createTRPCRouter({
 
   markAsRead: protectedProcedure
     .input(z.object({ id: z.string() }))
-    .mutation(({ input }) => markAsRead(input.id)),
+    .mutation(({ ctx, input }) => markAsRead(ctx.user!.id, input.id)),
 });