@studious-lms/server 1.5.0 → 1.7.0

package/src/pipelines/aiLabChat.ts

@@ -4,10 +4,13 @@
  */
 import { isAIUser } from "../utils/aiUser.js";
 import { prisma } from "../lib/prisma.js";
-import { JobStatus } from "@prisma/client";
 import { pusher, teacherChannel } from "../lib/pusher.js";
 import type { Assignment, Class, File, Section, User } from "@prisma/client";
-import { inference, sendAIMessage } from "../utils/inference.js";
+import {
+  inference,
+  completePendingAIMessage,
+  failPendingAIMessage,
+} from "../utils/inference.js";
 import { logger } from "../utils/logger.js";
 import { createPdf } from "../lib/jsonConversion.js";
 import { v4 } from "uuid";
@@ -328,52 +331,53 @@ export const getBaseSystemPrompt = (
 
 
 /**
- * Generate and send AI introduction for lab chat
- * Uses the stored context directly from database
+ * Fill the AI introduction placeholder for a brand-new lab chat.
+ *
+ * The caller (service layer) must have already created a PENDING AI Message
+ * row — `aiMessageId` is that placeholder. This function flips it to
+ * COMPLETED with the intro content, or to FAILED on a hard error.
  */
 export const generateAndSendLabIntroduction = async (
     labChatId: string,
     conversationId: string,
     _contextString: string,
-    subject: string
+    _subject: string,
+    aiMessageId: string,
   ): Promise<void> => {
-    try {
-      const introMessage =
-        "Hello teaching team! I'm your AI assistant for course material development. I'll help you create educational content - when you have a clear request, I'll produce it directly. I only ask questions when I need to clarify the topic or scope. What would you like to work on?";
+    const introMessage =
+      "Hello teaching team! I'm your AI assistant for course material development. I'll help you create educational content - when you have a clear request, I'll produce it directly. I only ask questions when I need to clarify the topic or scope. What would you like to work on?";
 
-      await sendAIMessage(introMessage, conversationId, { subject });
-  
-      logger.info('AI Introduction sent', { labChatId, conversationId });
-  
+    try {
+      await completePendingAIMessage(aiMessageId, introMessage);
+      logger.info('AI Introduction sent', { labChatId, conversationId, aiMessageId });
     } catch (error) {
-      logger.error('Failed to generate AI introduction:', { error, labChatId });
-      
-      // Send fallback introduction
-      try {
-        const fallbackIntro = `Hello teaching team! I'm your AI assistant for course material development. I'll help you create educational content - when you have a clear request, I'll produce it directly. I only ask questions when I need to clarify the topic or scope. What would you like to work on?`;
-        
-        await sendAIMessage(fallbackIntro, conversationId, {
-          subject,
-        });
-  
-        logger.info('Fallback AI introduction sent', { labChatId });
-  
-      } catch (fallbackError) {
-        logger.error('Failed to send fallback AI introduction:', { error: fallbackError, labChatId });
-      }
+      logger.error('Failed to complete AI introduction placeholder:', {
+        error,
+        labChatId,
+        aiMessageId,
+      });
+      await failPendingAIMessage(aiMessageId, { reason: 'lab_intro_complete_failed' });
     }
   }
   
   /**
-   * Generate and send AI response to teacher message
-   * Uses the stored context directly from database
-   * @param emitOptions - When provided, emits lab-response-completed/failed on teacher channel
-   * `_teacherMessage` is retained for caller compatibility while generation is anchored by `emitOptions.messageId`.
+   * Fill the AI response placeholder for a teacher reply in a lab chat.
+   *
+   * `aiMessageId` is the PENDING AI Message row created by the service
+   * layer; the pipeline flips it to COMPLETED with content / attachments /
+   * meta, or FAILED on error.  Teacher-channel `lab-response-{pending,
+   * completed,failed}` events fire alongside the chat-channel status flips
+   * (which `completePendingAIMessage` / `failPendingAIMessage` already
+   * broadcast) so the lab list "AI busy" indicator stays accurate.
+   *
+   * `_teacherMessage` is retained for caller compatibility — the actual
+   * conversation history is reloaded from the DB anchored on the AI
+   * placeholder.
    */
   export const generateAndSendLabResponse = async (
     labChatId: string,
     _teacherMessage: string,
-    emitOptions?: { classId: string; messageId: string }
+    emitOptions: { classId: string; aiMessageId: string }
   ): Promise<void> => {
     try {
       // Get lab context from database
@@ -395,9 +399,15 @@ export const generateAndSendLabIntroduction = async (
   
       const conversationId = fullLabChat.conversationId;
   
-      const recentMessages = await loadRecentLabChatMessages(
+      // Anchor history on the AI placeholder — the slice will include the
+      // placeholder itself (empty content) at the top; drop it so the model
+      // does not see an empty assistant turn at the very end.
+      const anchoredMessages = await loadRecentLabChatMessages(
         conversationId,
-        emitOptions?.messageId,
+        emitOptions.aiMessageId,
+      );
+      const recentMessages = anchoredMessages.filter(
+        (msg) => msg.id !== emitOptions.aiMessageId,
       );
   
       const classData = await prisma.class.findUnique({
@@ -486,7 +496,7 @@ export const generateAndSendLabIntroduction = async (
           labChatId,
           conversationId,
           classId: fullLabChat.classId,
-          ...(emitOptions?.messageId ? { messageId: emitOptions.messageId } : {}),
+          aiMessageId: emitOptions.aiMessageId,
         },
       }),
       LAB_CHAT_RESPONSE_TIMEOUT_MS,
@@ -567,8 +577,7 @@ export const generateAndSendLabIntroduction = async (
           }
         }
   
-        // Send the text response to the conversation
-        await sendAIMessage(jsonData.text, conversationId, {
+        await completePendingAIMessage(emitOptions.aiMessageId, jsonData.text, {
           attachments: {
             connect: attachmentIds.map(id => ({ id })),
           },
@@ -586,32 +595,24 @@ export const generateAndSendLabIntroduction = async (
               id: v4(),
             })) || null,
           },
-          subject: fullLabChat.class?.subject || 'Lab',
         });
       } catch (parseError) {
         logger.error('Failed to parse AI response or generate PDF:', { error: parseError, labChatId });
-        // Fallback: send the raw response if parsing fails
-        await sendAIMessage(response.text, conversationId, {
-          subject: fullLabChat.class?.subject || 'Lab',
-        });
+        // Fallback: complete the placeholder with the raw text so the
+        // teacher still sees something useful instead of FAILED.
+        await completePendingAIMessage(emitOptions.aiMessageId, response.text);
       }
 
-      if (emitOptions) {
-        await prisma.message.update({
-          where: { id: emitOptions.messageId },
-          data: { status: JobStatus.COMPLETED },
+      try {
+        await pusher.trigger(teacherChannel(emitOptions.classId), "lab-response-completed", {
+          labChatId,
+          messageId: emitOptions.aiMessageId,
         });
-        try {
-          await pusher.trigger(teacherChannel(emitOptions.classId), "lab-response-completed", {
-            labChatId,
-            messageId: emitOptions.messageId,
-          });
-        } catch (broadcastError) {
-          logger.error("Failed to broadcast lab response completed:", { error: broadcastError });
-        }
+      } catch (broadcastError) {
+        logger.error("Failed to broadcast lab response completed:", { error: broadcastError });
       }
 
-      logger.info('AI response sent', { labChatId, conversationId });
+      logger.info('AI response sent', { labChatId, conversationId, aiMessageId: emitOptions.aiMessageId });
 
     } catch (error) {
       console.error('Full error object:', error);
@@ -621,31 +622,22 @@ export const generateAndSendLabIntroduction = async (
           stack: error.stack,
           name: error.name
         } : error,
-        labChatId
+        labChatId,
+        aiMessageId: emitOptions.aiMessageId,
       });
 
-      if (emitOptions) {
-        try {
-          await prisma.message.update({
-            where: { id: emitOptions.messageId },
-            data: { status: JobStatus.FAILED },
-          });
-        } catch (statusError) {
-          logger.error("Failed to set message status FAILED:", {
-            error: statusError,
-            labChatId,
-            messageId: emitOptions.messageId,
-          });
-        }
-        try {
-          await pusher.trigger(teacherChannel(emitOptions.classId), "lab-response-failed", {
-            labChatId,
-            messageId: emitOptions.messageId,
-            error: "AI response generation failed",
-          });
-        } catch (broadcastError) {
-          logger.error("Failed to broadcast lab response failed:", { error: broadcastError });
-        }
+      await failPendingAIMessage(emitOptions.aiMessageId, {
+        reason: 'lab_response_generation_failed',
+      });
+
+      try {
+        await pusher.trigger(teacherChannel(emitOptions.classId), "lab-response-failed", {
+          labChatId,
+          messageId: emitOptions.aiMessageId,
+          error: "AI response generation failed",
+        });
+      } catch (broadcastError) {
+        logger.error("Failed to broadcast lab response failed:", { error: broadcastError });
       }
 
       throw error; // Re-throw to see the full error in the calling function

package/src/pipelines/aiNewtonChat.ts

@@ -3,11 +3,13 @@
  * Uses assignment context and AI policy levels for tutoring.
  */
 import { prisma } from "../lib/prisma.js";
-import { inference } from "../utils/inference.js";
+import {
+  inference,
+  completePendingAIMessage,
+  failPendingAIMessage,
+} from "../utils/inference.js";
 import { logger } from "../utils/logger.js";
-import { sendAIMessage } from "../utils/inference.js";
 import { isAIUser } from "../utils/aiUser.js";
-import { Assignment } from "@prisma/client";
 
 
 // AI Policy Levels Configuration
@@ -79,12 +81,18 @@ export interface AIPolicyLevel {
   ];
   
 /**
- * Generate and send AI introduction for Newton chat
+ * Fill the Newton tutor introduction placeholder.
+ *
+ * `aiMessageId` is the PENDING AI Message row created by the service layer
+ * (see `getTutorConversation`). On success we flip it to COMPLETED with the
+ * generated intro; on failure we fall back to a hardcoded greeting before
+ * marking the placeholder FAILED only as a last resort.
  */
 export const generateAndSendNewtonIntroduction = async (
     newtonChatId: string,
     conversationId: string,
-    submissionId: string
+    submissionId: string,
+    aiMessageId: string,
   ): Promise<void> => {
     try {
       // Get submission details for context
@@ -144,6 +152,7 @@ export const generateAndSendNewtonIntroduction = async (
           newtonChatId,
           conversationId,
           submissionId: submission.id,
+          aiMessageId,
         },
         model: 'command-a-03-2025',
         maxTokens: 300,
@@ -154,28 +163,22 @@ export const generateAndSendNewtonIntroduction = async (
         throw new Error('No response generated from inference API');
       }
   
-      // Send AI introduction using centralized sender
-      await sendAIMessage(response, conversationId, {
-        subject: submission.assignment.class.subject || 'Assignment',
-      });
+      await completePendingAIMessage(aiMessageId, response);
   
-      logger.info('AI Introduction sent', { newtonChatId, conversationId });
+      logger.info('AI Introduction sent', { newtonChatId, conversationId, aiMessageId });
   
     } catch (error) {
-      logger.error('Failed to generate AI introduction:', { error, newtonChatId });
+      logger.error('Failed to generate AI introduction:', { error, newtonChatId, aiMessageId });
       
-      // Send fallback introduction
+      // Fallback: still complete the placeholder so the student isn't stuck
+      // staring at an empty bubble.
       try {
         const fallbackIntro = `Hello! I'm Newton, your AI tutor. I'm here to help you with your assignment. I can answer questions, explain concepts, and guide you through your work. What would you like help with today?`;
-        
-        await sendAIMessage(fallbackIntro, conversationId, {
-          subject: 'Assignment',
-        });
-  
-        logger.info('Fallback AI introduction sent', { newtonChatId });
-  
+        await completePendingAIMessage(aiMessageId, fallbackIntro);
+        logger.info('Fallback AI introduction sent', { newtonChatId, aiMessageId });
       } catch (fallbackError) {
-        logger.error('Failed to send fallback AI introduction:', { error: fallbackError, newtonChatId });
+        logger.error('Failed to send fallback AI introduction:', { error: fallbackError, newtonChatId, aiMessageId });
+        await failPendingAIMessage(aiMessageId, { reason: 'newton_intro_fallback_failed' });
       }
     }
   }
@@ -209,7 +212,11 @@ export const generateAndSendNewtonIntroduction = async (
   };
   
   /**
-   * Generate and send AI response to student message
+   * Fill the Newton AI response placeholder for a student turn.
+   *
+   * `aiMessageId` is the PENDING AI Message row the service created post-tx;
+   * the pipeline flips it to COMPLETED with the generated content (the
+   * helper broadcasts `message-updated` on the chat channel) or to FAILED.
    */
   export const generateAndSendNewtonResponse = async (
     newtonChatId: string,
@@ -225,13 +232,17 @@ export const generateAndSendNewtonIntroduction = async (
           subject: string | null;
         };
       };
-    }
+    },
+    aiMessageId: string,
   ): Promise<void> => {
     try {
-      // Get recent conversation history
+      // Get recent conversation history (excluding the empty AI placeholder
+      // we just created — otherwise the model sees a blank assistant turn at
+      // the very end of the transcript).
       const recentMessages = await prisma.message.findMany({
         where: {
           conversationId,
+          id: { not: aiMessageId },
         },
         include: {
           sender: {
@@ -329,6 +340,7 @@ export const generateAndSendNewtonIntroduction = async (
           newtonChatId,
           conversationId,
           submissionId: submission.id,
+          aiMessageId,
         },
       });
       
@@ -336,13 +348,10 @@ export const generateAndSendNewtonIntroduction = async (
         throw new Error('No response generated from inference API');
       }
   
-      // Send the text response to the conversation
-      await sendAIMessage(response, conversationId, {
-        subject: submission.assignment.class.subject || 'Assignment',
-      });
-  
-      logger.info('AI response sent', { newtonChatId, conversationId });
-  
+      await completePendingAIMessage(aiMessageId, response);
+
+      logger.info('AI response sent', { newtonChatId, conversationId, aiMessageId });
+
     } catch (error) {
       logger.error('Failed to generate AI response:', { 
         error: error instanceof Error ? {
@@ -350,8 +359,15 @@ export const generateAndSendNewtonIntroduction = async (
           stack: error.stack,
           name: error.name
         } : error,
-        newtonChatId 
+        newtonChatId,
+        aiMessageId,
       });
+
+      await failPendingAIMessage(aiMessageId, {
+        reason: 'newton_response_generation_failed',
+      });
+
+      throw error;
     }
   }