@studious-lms/server 1.15.0 → 1.16.1

package/src/lib/chatAttachmentPrompt.ts

@@ -0,0 +1,270 @@
+/**
+ * Shared chat attachment handling for Newton + Lab pipelines.
+ *
+ * - Images + PDFs: inlined as multimodal parts (bytes from GCS).
+ * - Office docs, spreadsheets, slides, text, csv, json, html: text extracted
+ *   via officeparser / UTF-8 decode and appended to the user message.
+ * - Audio/video/zip: filename mention only (no extraction).
+ */
+import type { FilePart, ImagePart, ModelMessage, TextPart, UserContent } from 'ai';
+import { OfficeParser } from 'officeparser';
+import { bucket } from './googleCloudStorage.js';
+import { logger } from '../utils/logger.js';
+
+/** Model used for AI chats that may include document attachments. */
+export const AI_CHAT_MODEL = 'gpt-5.5';
+
+const MAX_EXTRACTED_CHARS = 80_000;
+const IMAGE_TYPE_PREFIX = 'image/';
+
+export type ChatAttachmentRef = {
+  id: string;
+  name: string;
+  type: string;
+  path: string;
+};
+
+export type LoadedChatAttachment = ChatAttachmentRef & {
+  data?: Uint8Array;
+  extractedText?: string;
+};
+
+export type ChatHistoryMessage = {
+  id?: string;
+  content: string;
+  senderId: string;
+  createdAt?: Date | string | number;
+  sender?: {
+    username?: string | null;
+    profile?: { displayName?: string | null } | null;
+  } | null;
+  attachments?: ChatAttachmentRef[];
+};
+
+type UserContentPart = TextPart | ImagePart | FilePart;
+
+const TEXT_DECODE_TYPES = new Set([
+  'text/plain',
+  'text/csv',
+  'text/markdown',
+  'text/html',
+  'application/json',
+]);
+
+const MENTION_ONLY_PREFIXES = ['audio/', 'video/'];
+const MENTION_ONLY_TYPES = new Set(['application/zip']);
+
+function extension(name: string): string {
+  return name.split('.').pop()?.toLowerCase() ?? '';
+}
+
+function isPdf(attachment: { type: string; name: string }): boolean {
+  return attachment.type === 'application/pdf' || extension(attachment.name) === 'pdf';
+}
+
+function isImage(attachment: { type: string }): boolean {
+  return attachment.type.startsWith(IMAGE_TYPE_PREFIX);
+}
+
+function isMentionOnly(attachment: { type: string; name: string }): boolean {
+  if (MENTION_ONLY_TYPES.has(attachment.type)) return true;
+  return MENTION_ONLY_PREFIXES.some((prefix) => attachment.type.startsWith(prefix));
+}
+
+function isUtf8Text(attachment: { type: string; name: string }): boolean {
+  if (TEXT_DECODE_TYPES.has(attachment.type)) return true;
+  const ext = extension(attachment.name);
+  return ['txt', 'csv', 'md', 'html', 'json'].includes(ext);
+}
+
+function shouldDownload(attachment: ChatAttachmentRef): boolean {
+  return Boolean(attachment.path) && !isMentionOnly(attachment);
+}
+
+async function extractTextFromBytes(
+  bytes: Uint8Array,
+  name: string,
+  type: string,
+): Promise<string | null> {
+  if (isUtf8Text({ type, name })) {
+    return new TextDecoder('utf-8', { fatal: false })
+      .decode(bytes)
+      .slice(0, MAX_EXTRACTED_CHARS);
+  }
+
+  if (isImage({ type }) || isPdf({ type, name })) {
+    return null;
+  }
+
+  if (isMentionOnly({ type, name })) {
+    return null;
+  }
+
+  try {
+    const ast = await OfficeParser.parseOffice(Buffer.from(bytes), {
+      includeRawContent: false,
+    });
+    const text = ast.toText().trim();
+    return text ? text.slice(0, MAX_EXTRACTED_CHARS) : null;
+  } catch (error) {
+    logger.warn('Failed to extract chat attachment text', { name, type, error });
+    return null;
+  }
+}
+
+/** Download bytes from GCS and extract text for every supported attachment type. */
+export async function loadChatAttachments(
+  attachments: ChatAttachmentRef[],
+): Promise<LoadedChatAttachment[]> {
+  return Promise.all(
+    attachments.map(async (attachment) => {
+      if (!shouldDownload(attachment)) {
+        return { ...attachment };
+      }
+
+      try {
+        const [bytes] = await bucket.file(attachment.path).download();
+        const data = new Uint8Array(bytes);
+        const extractedText =
+          (await extractTextFromBytes(data, attachment.name, attachment.type)) ??
+          undefined;
+        return { ...attachment, data, extractedText };
+      } catch (error) {
+        logger.warn('Failed to load chat attachment from storage', {
+          attachmentId: attachment.id,
+          path: attachment.path,
+          type: attachment.type,
+          error,
+        });
+        return { ...attachment };
+      }
+    }),
+  );
+}
+
+/** @deprecated Use {@link loadChatAttachments} */
+export const loadPromptAttachments = loadChatAttachments;
+
+export function buildUserMessageContentWithAttachments(
+  textContent: string,
+  attachments: LoadedChatAttachment[],
+): UserContent {
+  if (attachments.length === 0) {
+    return textContent;
+  }
+
+  const parts: UserContentPart[] = [];
+  let fullText = textContent;
+
+  for (const attachment of attachments) {
+    if (attachment.extractedText) {
+      fullText += `\n\n[Content of ${attachment.name}]:\n${attachment.extractedText}`;
+    }
+  }
+
+  const unhandled = attachments.filter((a) => {
+    if (a.extractedText) return false;
+    if (isImage(a) && a.data) return false;
+    if (isPdf(a) && a.data) return false;
+    return true;
+  });
+
+  if (unhandled.length > 0) {
+    const fileList = unhandled
+      .map((a) => `${a.name} (${a.type})`)
+      .join(', ');
+    fullText = fullText
+      ? `${fullText}\n[Attached files (content not extracted): ${fileList}]`
+      : `[Attached files (content not extracted): ${fileList}]`;
+  }
+
+  if (fullText.trim()) {
+    parts.push({ type: 'text', text: fullText });
+  }
+
+  for (const image of attachments) {
+    if (isImage(image) && image.data) {
+      parts.push({ type: 'image', image: image.data });
+    }
+  }
+
+  for (const file of attachments) {
+    if (isPdf(file) && file.data) {
+      parts.push({
+        type: 'file',
+        data: file.data,
+        mediaType: 'application/pdf',
+        filename: file.name,
+      });
+    }
+  }
+
+  if (parts.length === 0) {
+    return textContent || '[Attached files]';
+  }
+
+  if (parts.length === 1 && parts[0].type === 'text') {
+    return parts[0].text;
+  }
+
+  return parts;
+}
+
+export function sortChatMessagesChronologically<T extends ChatHistoryMessage>(
+  messages: T[],
+): T[] {
+  return messages
+    .map((message, index) => ({ message, index }))
+    .sort((left, right) => {
+      const leftTime = left.message.createdAt
+        ? new Date(left.message.createdAt).getTime()
+        : null;
+      const rightTime = right.message.createdAt
+        ? new Date(right.message.createdAt).getTime()
+        : null;
+
+      if (leftTime != null && rightTime != null) {
+        return leftTime - rightTime;
+      }
+      if (leftTime != null) return -1;
+      if (rightTime != null) return 1;
+      return left.index - right.index;
+    })
+    .map(({ message }) => message);
+}
+
+/** Build ModelMessage[] with shared attachment loading for Newton + Lab. */
+export async function buildChatModelMessages({
+  messages,
+  isAIUser,
+  defaultSenderLabel,
+}: {
+  messages: ChatHistoryMessage[];
+  isAIUser: (senderId: string) => boolean;
+  defaultSenderLabel: string;
+}): Promise<ModelMessage[]> {
+  const modelMessages: ModelMessage[] = [];
+
+  for (const message of sortChatMessagesChronologically(messages)) {
+    if (isAIUser(message.senderId)) {
+      modelMessages.push({ role: 'assistant', content: message.content });
+      continue;
+    }
+
+    const senderName =
+      message.sender?.profile?.displayName ||
+      message.sender?.username ||
+      defaultSenderLabel;
+    const label = message.content.trim()
+      ? `${senderName}: ${message.content}`
+      : senderName;
+    const attachments = await loadChatAttachments(message.attachments ?? []);
+
+    modelMessages.push({
+      role: 'user',
+      content: buildUserMessageContentWithAttachments(label, attachments),
+    });
+  }
+
+  return modelMessages;
+}

package/src/lib/inferDocumentFormat.ts

@@ -9,7 +9,7 @@ const FORMAT_RULES: FormatRule[] = [
   { format: 'xlsx', pattern: /\b(spreadsheet|excel|workbook|xlsx|gradebook|grade book|\.xlsx)\b/i },
   { format: 'csv', pattern: /\b(csv|comma[- ]separated|\.csv)\b/i },
   { format: 'docx', pattern: /\b(word doc(ument)?|docx|editable handout|\.docx)\b/i },
-  { format: 'png', pattern: /\b(diagram|chart|graph|plot|figure|infographic|\.png)\b/i },
+  { format: 'png', pattern: /\b(diagram|flowchart|chart|graph|plot|figure|infographic|visual|illustration|mind ?map|timeline|\.png)\b/i },
   { format: 'md', pattern: /\b(markdown|readme|\.md)\b/i },
   { format: 'html', pattern: /\b(html|web ?page|\.html)\b/i },
   { format: 'txt', pattern: /\b(plain text|text file|\.txt)\b/i },

package/src/pipelines/aiLabChat.ts

@@ -12,15 +12,15 @@ import {
 } from "../utils/inference.js";
 import { logger } from "../utils/logger.js";
 import { v4 } from "uuid";
-import { bucket, getSignedUrl } from "../lib/googleCloudStorage.js";
+import { bucket } from "../lib/googleCloudStorage.js";
 import {
   generateDocumentWithOpenAI,
   normalizeDocumentFormat,
 } from "../services/openaiDocumentGen.js";
 import { inferDocumentFormat } from "../lib/inferDocumentFormat.js";
 import { broadcastTextChunks, broadcastStreamComplete } from "../utils/streamBroadcast.js";
+import { AI_CHAT_MODEL } from "../lib/chatAttachmentPrompt.js";
 import { buildLabChatAgentMessages } from "./labChatPrompt.js";
-import type { ConversationMessage } from "./labChatPrompt.js";
 import {
   applyResolvedFormatsToStreamParts,
   enrichStreamPartsWithGeneratedFiles,
@@ -213,42 +213,6 @@ const loadRecentLabChatMessages = async (
     .slice(0, limit);
 };
 
-/**
- * Resolves signed URLs for image attachments in messages so the LLM can see them.
- * Non-image files are passed as text descriptions only.
- */
-async function resolveAttachmentUrls(
-  messages: RecentLabChatMessage[],
-): Promise<ConversationMessage[]> {
-  const resolved: ConversationMessage[] = [];
-
-  for (const msg of messages) {
-    const attachments = msg.attachments ?? [];
-    if (attachments.length === 0) {
-      resolved.push({ ...msg, attachments: [] });
-      continue;
-    }
-
-    const withUrls = await Promise.all(
-      attachments.map(async (a) => {
-        if (a.type.startsWith('image/')) {
-          try {
-            const url = await getSignedUrl(a.path);
-            return { id: a.id, name: a.name, type: a.type, url };
-          } catch {
-            return { id: a.id, name: a.name, type: a.type };
-          }
-        }
-        return { id: a.id, name: a.name, type: a.type };
-      }),
-    );
-
-    resolved.push({ ...msg, attachments: withUrls });
-  }
-
-  return resolved;
-}
-
 /**
  * Builds schema-aware context for the AI from class data.
  * Formats entities with IDs so the model can reference them when creating assignments.
@@ -511,13 +475,10 @@ export const generateAndSendLabIntroduction = async (
         assignments: classData.assignments,
       });
 
-      // Resolve signed URLs for image attachments so the LLM can see them
-      const messagesWithAttachments = await resolveAttachmentUrls(recentMessages.reverse());
-
-      const { system, messages } = buildLabChatAgentMessages({
+      const { system, messages } = await buildLabChatAgentMessages({
         context: fullLabChat.context,
         classContext,
-        recentMessages: messagesWithAttachments,
+        recentMessages: recentMessages.reverse(),
         isAIUser,
       });
 
@@ -535,6 +496,7 @@ export const generateAndSendLabIntroduction = async (
         streamChatResponse({
           conversationId,
           aiMessageId: emitOptions.aiMessageId,
+          model: AI_CHAT_MODEL,
           system,
           messages,
           tools,

package/src/pipelines/aiNewtonChat.ts

@@ -13,9 +13,10 @@ import { isAIUser } from "../utils/aiUser.js";
 import { broadcastStreamComplete } from "../utils/streamBroadcast.js";
 import { streamChatResponse } from "../services/aiChatStream.js";
 import { aiTools } from "../services/aiTools.js";
-import type { ModelMessage } from "ai";
-
-
+import {
+  AI_CHAT_MODEL,
+  buildChatModelMessages,
+} from "../lib/chatAttachmentPrompt.js";
 
 // AI Policy Levels Configuration
 // Used across assignment creation, editing, and display
@@ -148,6 +149,7 @@ export const generateAndSendNewtonIntroduction = async (
       const { text: response } = await streamChatResponse({
         conversationId,
         aiMessageId,
+        model: AI_CHAT_MODEL,
         system: systemPrompt,
         messages: [
           {
@@ -222,7 +224,6 @@ export const generateAndSendNewtonIntroduction = async (
    */
   export const generateAndSendNewtonResponse = async (
     newtonChatId: string,
-    studentMessage: string,
     conversationId: string,
     submission: {
       id: string;
@@ -258,6 +259,14 @@ export const generateAndSendNewtonIntroduction = async (
               },
             },
           },
+          attachments: {
+            select: {
+              id: true,
+              name: true,
+              type: true,
+              path: true,
+            },
+          },
         },
         orderBy: {
           createdAt: 'desc',
@@ -302,26 +311,13 @@ export const generateAndSendNewtonIntroduction = async (
   
   IMPORTANT:
   - Keep responses conversational and educational
-  - Focus on helping the student learn, not just completing the assignment`;
-  
-      const modelMessages: ModelMessage[] = [];
-  
-      // Add recent conversation history
-      recentMessages.reverse().forEach(msg => {
-        const role = isAIUser(msg.senderId) ? 'assistant' : 'user';
-        const senderName = msg.sender?.profile?.displayName || msg.sender?.username || 'Student';
-        const content = isAIUser(msg.senderId) ? msg.content : `${senderName}: ${msg.content}`;
-        
-        modelMessages.push({
-          role: role as 'user' | 'assistant',
-          content,
-        });
-      });
+  - Focus on helping the student learn, not just completing the assignment
+  - When the student attaches files (PDFs, images), read and reference them in your reply`;
   
-      // Add the new student message
-      modelMessages.push({
-        role: 'user',
-        content: `Student: ${studentMessage}`,
+      const modelMessages = await buildChatModelMessages({
+        messages: [...recentMessages].reverse(),
+        isAIUser,
+        defaultSenderLabel: 'Student',
       });
 
       const combinedSystem = [
@@ -337,6 +333,7 @@ export const generateAndSendNewtonIntroduction = async (
       const { text: response, parts: streamParts } = await streamChatResponse({
         conversationId,
         aiMessageId,
+        model: AI_CHAT_MODEL,
         system: combinedSystem,
         messages: modelMessages,
         ...(newtonClassId ? { tools: aiTools(newtonClassId), maxSteps: 5 } : {}),

package/src/pipelines/gradeWorksheet.ts

@@ -20,6 +20,65 @@ const removeAllPreviousAIComments = async (worksheetQuestionProgressId: string)
     });
 };
 
+type MarkSchemeItem = { id: string; points: number; description?: string; text?: string };
+
+const gradingResponseSchema = z.object({
+    isCorrect: z.boolean(),
+    points: z.number(),
+    markschemeState: z.array(z.object({
+        id: z.string(),
+        correct: z.boolean(),
+    })),
+    comments: z.array(z.string()),
+    annotations: z.array(z.object({
+        quote: z.string().describe('An exact substring from the student response that is relevant to this criterion.'),
+        markSchemeId: z.string().describe('The id of the mark scheme criterion this quote relates to.'),
+        criterion: z.string().describe('Short label describing what this mark scheme criterion evaluates.'),
+        met: z.boolean().describe('Whether the quoted text satisfies this criterion.'),
+    })).describe('Highlight specific parts of the student response and map each to a mark scheme criterion.'),
+});
+
+function buildGradingPrompt(
+    question: { question: string; answer: string; type: WorksheetQuestionType; points: number; markScheme: unknown },
+    responseText: string,
+): string {
+    const markSchemeItems = Array.isArray(question.markScheme) ? question.markScheme as MarkSchemeItem[] : [];
+    const markSchemeBlock = markSchemeItems.length > 0
+        ? markSchemeItems.map((item, i) =>
+            `  ${i + 1}. [id="${item.id}", ${item.points} pts] ${item.description || item.text || `Criterion ${i + 1}`}`
+        ).join('\n')
+        : '  No mark scheme provided — grade based on correctness and completeness.';
+
+    const maxPoints = question.points || markSchemeItems.reduce((sum, item) => sum + (item.points || 0), 0);
+
+    return `Grade the following student response.
+
+Question type: ${question.type}
+Maximum points: ${maxPoints}
+
+QUESTION:
+${question.question}
+
+CORRECT ANSWER:
+${question.answer || 'No answer key provided.'}
+
+MARK SCHEME:
+${markSchemeBlock}
+
+STUDENT RESPONSE:
+${responseText}
+
+INSTRUCTIONS:
+- Evaluate the student response against each mark scheme criterion.
+- Total points must not exceed ${maxPoints}.
+- In markschemeState, use the EXACT "id" string from the MARK SCHEME items above (e.g. "${markSchemeItems[0]?.id || 'ms-xxx'}"). Do NOT invent new IDs.
+- In annotations, use the same EXACT mark scheme id for "markSchemeId".
+- For each criterion, find the exact substring in the student's response that is relevant (the "quote" field). Copy the text verbatim — do not paraphrase.
+- If no part of the response addresses a criterion, still include an annotation with an empty quote and met=false.
+- Provide constructive feedback comments.
+- Mark isCorrect=true only if the student earned full or near-full marks.`;
+}
+
 const gradeWorksheetQuestion = async (worksheetResponseId: string, worksheetQuestionProgressId: string) => {
 
     await removeAllPreviousAIComments(worksheetQuestionProgressId);
@@ -83,38 +142,12 @@ const gradeWorksheetQuestion = async (worksheetResponseId: string, worksheetQues
         return updatedProgress;
     }
 
-    const comments = studentQuestionProgress.comments;
-
     try {
+        const prompt = buildGradingPrompt(question, responseText);
+
         const apiResponse = await inference(
-            `Grade the following worksheet response:
-            
-            Question: ${question.question}
-            Response: ${responseText}
-
-            Comments: ${comments.map((comment) => comment.content).join('\n')}
-            Mark Scheme: ${JSON.stringify(question.markScheme)}
-            
-            Justify your reasoning by including comment(s) and mark the question please.         
-            Return ONLY JSON in the following format (fill in the values as per the question):
-           {
-            "isCorrect": <boolean>,
-            "points": <number>,
-            "markschemeState": [
-                { "id": <string>, "correct": <boolean> }
-            ],
-            "comments": [<string>, ...]
-            }
-            `,
-            z.object({
-                isCorrect: z.boolean(),
-                points: z.number(),
-                markschemeState: z.array(z.object({
-                    id: z.string(),
-                    correct: z.boolean(),
-                  })), // @note: this has to be converted to [id: string]: correct boolean
-                comments: z.array(z.string()),
-            }),
+            prompt,
+            gradingResponseSchema,
             {
                 reason: 'worksheet_autograde',
                 metadata: {
@@ -128,6 +161,47 @@ const gradeWorksheetQuestion = async (worksheetResponseId: string, worksheetQues
             throw error;
         });
 
+        const maxPoints = question.points || 0;
+        const clampedPoints = Math.max(0, Math.min(Math.round((apiResponse as { points: number }).points), maxPoints));
+
+        const markSchemeItems = Array.isArray(question.markScheme) ? question.markScheme as MarkSchemeItem[] : [];
+        const validMarkSchemeIds = new Set(markSchemeItems.map(item => item.id));
+
+        const aiMarkschemeState = (apiResponse as {
+            markschemeState: { id: string; correct: boolean }[];
+        }).markschemeState;
+
+        const allIdsValid = aiMarkschemeState.length > 0 &&
+            aiMarkschemeState.every(entry => validMarkSchemeIds.has(entry.id));
+
+        let resolvedState: Record<string, boolean | unknown[]> = {};
+
+        if (allIdsValid) {
+            resolvedState = aiMarkschemeState.reduce((acc, curr) => {
+                acc["item-" + curr.id] = curr.correct;
+                return acc;
+            }, {} as Record<string, boolean>);
+        } else if (markSchemeItems.length > 0) {
+            logger.warn('AI returned mismatched markscheme IDs, falling back to index mapping', {
+                expected: markSchemeItems.map(i => i.id),
+                received: aiMarkschemeState.map(i => i.id),
+            });
+            for (let i = 0; i < markSchemeItems.length; i++) {
+                const aiEntry = aiMarkschemeState[i];
+                resolvedState["item-" + markSchemeItems[i].id] = aiEntry?.correct ?? false;
+            }
+        }
+
+        const annotations = (apiResponse as {
+            annotations: { quote: string; markSchemeId: string; criterion: string; met: boolean }[];
+        }).annotations
+            .filter(a => a.quote.length === 0 || responseText.includes(a.quote));
+
+        // Store annotations separately so the boolean-only markschemeState
+        // isn't broken by non-boolean values (the frontend parser rejects
+        // the entire object if any value isn't a boolean).
+        resolvedState['_annotations'] = annotations;
+
         const updatedStudentQuestionProgress = await prisma.studentQuestionProgress.update({
             where: { id: studentQuestionProgress.id, status: {
                 not: {
@@ -137,13 +211,8 @@ const gradeWorksheetQuestion = async (worksheetResponseId: string, worksheetQues
             data: {
                 status: JobStatus.COMPLETED,
                 isCorrect: (apiResponse as { isCorrect: boolean }).isCorrect,
-                points: (apiResponse as { points: number }).points,
-                markschemeState: (apiResponse as {
-                    markschemeState: { id: string; correct: boolean }[];
-                }).markschemeState.reduce((acc, curr) => {
-                    acc["item-" + curr.id] = curr.correct;
-                    return acc;
-                }, {} as Record<string, boolean>),
+                points: clampedPoints,
+                markschemeState: resolvedState,
                 comments: {
                     create: (apiResponse as {
                         comments: string[];
@@ -279,7 +348,14 @@ export const gradeWorksheetPipeline = async (worksheetResponseId: string) => {
             continue;
         }
 
-        await gradeWorksheetQuestion(worksheetResponseId, response.id);
+        try {
+            await gradeWorksheetQuestion(worksheetResponseId, response.id);
+        } catch (questionError) {
+            logger.error('Failed to grade individual question, continuing with remaining questions', {
+                questionId: response.questionId,
+                error: questionError,
+            });
+        }
 
     };
 };
@@ -311,6 +387,63 @@ export const cancelGradePipeline = async (worksheetResponseId: string, worksheet
     return updatedStudentQuestionProgress;
 };
 
+export const regradeAllPipeline = async (worksheetResponseId: string) => {
+    logger.info('Regrading all questions for worksheet response', { worksheetResponseId });
+    const worksheetResponse = await prisma.studentWorksheetResponse.findUnique({
+        where: { id: worksheetResponseId },
+        include: {
+            worksheet: true,
+            responses: {
+                where: {
+                    question: {
+                        type: {
+                            not: {
+                                in: [WorksheetQuestionType.MULTIPLE_CHOICE, WorksheetQuestionType.TRUE_FALSE],
+                            },
+                        },
+                    },
+                },
+                include: {
+                    question: true,
+                    comments: true,
+                },
+            },
+        },
+    });
+
+    if (!worksheetResponse) {
+        logger.error('Worksheet response not found');
+        throw new Error('Worksheet response not found');
+    }
+
+    // Reset all non-cancelled responses to PENDING
+    for (const response of worksheetResponse.responses) {
+        await prisma.studentQuestionProgress.updateMany({
+            where: {
+                id: response.id,
+                status: { not: JobStatus.CANCELLED },
+            },
+            data: { status: JobStatus.PENDING },
+        });
+
+        pusher.trigger(worksheetChannel(worksheetResponse.id), `set-pending`, {
+            id: response.id,
+        });
+    }
+
+    // Re-grade each question sequentially
+    for (const response of worksheetResponse.responses) {
+        try {
+            await gradeWorksheetQuestion(worksheetResponseId, response.id);
+        } catch (questionError) {
+            logger.error('Failed to regrade question, continuing with remaining', {
+                questionId: response.questionId,
+                error: questionError,
+            });
+        }
+    }
+};
+
 export const regradeWorksheetPipeline = async (worksheetResponseId: string, worksheetQuestionProgressId: string) => {
     logger.info('Regrading worksheet response', { worksheetResponseId, worksheetQuestionProgressId });
     try {