@studious-lms/server 1.14.0 → 1.16.0

package/src/services/aiModifierTools.ts

@@ -14,9 +14,17 @@
  * `jsonSchema()` rather than the zod `tool()` helper to avoid the TS2589
  * "excessively deep" compiler blow-up on nested schemas.
  */
+import { randomUUID } from 'node:crypto';
 import { jsonSchema, type ToolSet } from 'ai';
+import type { JSONSchema7Definition } from 'json-schema';
+import type { WorksheetQuestionType } from '@prisma/client';
 import { updateAssignmentRecord } from './assignment.js';
-import { updateWorksheetRecord } from './worksheet.js';
+import {
+  addQuestionToWorksheet,
+  deleteWorksheetQuestionRecord,
+  updateWorksheetQuestionRecord,
+  updateWorksheetRecord,
+} from './worksheet.js';
 
 /** A single field write that was applied to a resource. */
 export interface ModifierFieldUpdate {
@@ -56,6 +64,52 @@ const WORKSHEET_FIELDS: Record<string, { label: string; type: 'string' }> = {
   name: { label: 'name', type: 'string' },
 };
 
+const WORKSHEET_QUESTION_TYPES = [
+  'MULTIPLE_CHOICE', 'TRUE_FALSE', 'SHORT_ANSWER', 'LONG_ANSWER', 'MATH_EXPRESSION', 'ESSAY',
+] as const;
+
+interface QuestionOptionInput {
+  text: string;
+  isCorrect?: boolean;
+}
+
+/** Attach stable ids to model-supplied MCQ options (matches the editor's shape). */
+function buildOptions(options: QuestionOptionInput[] | undefined) {
+  if (!options || options.length === 0) return undefined;
+  return options.map((o) => ({
+    id: randomUUID(),
+    text: o.text,
+    isCorrect: Boolean(o.isCorrect),
+  }));
+}
+
+const QUESTION_PROPERTIES: Record<string, JSONSchema7Definition> = {
+  question: { type: 'string', description: 'The question text shown to students.' },
+  answer: {
+    type: 'string',
+    description:
+      'The correct answer. For TRUE_FALSE use "true"/"false". For MULTIPLE_CHOICE leave it empty and mark the correct option instead.',
+  },
+  type: {
+    type: 'string',
+    enum: [...WORKSHEET_QUESTION_TYPES],
+    description: 'The question type.',
+  },
+  points: { type: 'number', description: 'Points the question is worth.' },
+  options: {
+    type: 'array',
+    description: 'Answer choices, only for MULTIPLE_CHOICE questions. Mark exactly one as correct.',
+    items: {
+      type: 'object',
+      properties: {
+        text: { type: 'string', description: 'The option text.' },
+        isCorrect: { type: 'boolean', description: 'Whether this option is the correct answer.' },
+      },
+      required: ['text'],
+    },
+  },
+};
+
 /** Coerce a model-supplied string value into the type a field expects. */
 function coerceValue(
   raw: string,
@@ -184,5 +238,104 @@ export function worksheetModifierTools(
         return `Updated ${spec.label}.`;
       },
     },
+    add_worksheet_question: {
+      description:
+        'Add a new question to the worksheet and save it immediately. ' +
+        'Call this once per question to add.',
+      inputSchema: jsonSchema({
+        type: 'object',
+        properties: QUESTION_PROPERTIES,
+        required: ['question', 'answer', 'type'],
+      }),
+      execute: async ({
+        question,
+        answer,
+        type,
+        points,
+        options,
+      }: {
+        question: string;
+        answer: string;
+        type: WorksheetQuestionType;
+        points?: number;
+        options?: QuestionOptionInput[];
+      }) => {
+        const created = await addQuestionToWorksheet(worksheetId, userId, {
+          question,
+          answer,
+          type,
+          points,
+          options: buildOptions(options),
+        });
+        await onFieldUpdate({
+          field: 'questions',
+          value: { action: 'added', questionId: created.id },
+          label: `question "${question.slice(0, 60)}"`,
+        });
+        return `Added question (id ${created.id}).`;
+      },
+    },
+    update_worksheet_question: {
+      description:
+        'Update an existing worksheet question by its Q_ID and save it immediately. ' +
+        'Only pass the fields that should change.',
+      inputSchema: jsonSchema({
+        type: 'object',
+        properties: {
+          questionId: { type: 'string', description: 'The Q_ID of the question to update.' },
+          ...QUESTION_PROPERTIES,
+        },
+        required: ['questionId'],
+      }),
+      execute: async ({
+        questionId,
+        question,
+        answer,
+        type,
+        points,
+        options,
+      }: {
+        questionId: string;
+        question?: string;
+        answer?: string;
+        type?: WorksheetQuestionType;
+        points?: number;
+        options?: QuestionOptionInput[];
+      }) => {
+        await updateWorksheetQuestionRecord(worksheetId, questionId, userId, {
+          ...(question !== undefined && { question }),
+          ...(answer !== undefined && { answer }),
+          ...(type !== undefined && { type }),
+          ...(points !== undefined && { points }),
+          ...(options !== undefined && { options: buildOptions(options) }),
+        });
+        await onFieldUpdate({
+          field: 'questions',
+          value: { action: 'updated', questionId },
+          label: 'a question',
+        });
+        return `Updated question ${questionId}.`;
+      },
+    },
+    delete_worksheet_question: {
+      description:
+        'Delete a worksheet question by its Q_ID. This is permanent.',
+      inputSchema: jsonSchema({
+        type: 'object',
+        properties: {
+          questionId: { type: 'string', description: 'The Q_ID of the question to delete.' },
+        },
+        required: ['questionId'],
+      }),
+      execute: async ({ questionId }: { questionId: string }) => {
+        await deleteWorksheetQuestionRecord(worksheetId, questionId, userId);
+        await onFieldUpdate({
+          field: 'questions',
+          value: { action: 'deleted', questionId },
+          label: 'a question',
+        });
+        return `Deleted question ${questionId}.`;
+      },
+    },
   };
 }

package/src/services/aiProposalTools.ts

@@ -23,7 +23,6 @@ import type {
   SectionToCreate,
   DocToCreate,
 } from '../pipelines/aiLabChatContract.js';
-import type { DocumentBlock } from '../lib/jsonStyles.js';
 
 export interface LabProposals {
   assignments: AssignmentToCreate[];
@@ -85,7 +84,8 @@ interface ProposeAssignmentArgs {
 
 interface GenerateDocumentArgs {
   title: string;
-  blocks: DocumentBlock[];
+  content: string;
+  format?: string;
 }
 
 /**
@@ -237,35 +237,36 @@ export function labProposalTools(proposals: LabProposals): ToolSet {
 
     generate_document: {
       description:
-        'Generate a document (rendered to a PDF and attached to the message). Provide the document title and an ordered list of formatting blocks.',
+        'Generate a downloadable file and attach it to this message. You are NOT limited to PDF — pick the best format for the request (pptx for slides/presentations, xlsx/csv for data, docx for editable handouts, pdf for print-ready docs, png for diagrams, etc.). Always set format explicitly.',
       inputSchema: jsonSchema({
         type: 'object',
         properties: {
-          title: { type: 'string' },
-          blocks: {
-            type: 'array',
-            description: 'Ordered list of document formatting blocks',
-            items: {
-              type: 'object',
-              properties: {
-                format: { type: 'number', description: 'Block format id (0-12)' },
-                content: {
-                  description: 'String, or array of strings for list blocks',
-                },
-                metadata: {
-                  type: 'object',
-                  description: 'Optional styling metadata',
-                },
-              },
-              required: ['format', 'content'],
-            },
+          format: {
+            type: 'string',
+            description:
+              'Output file type. REQUIRED. pptx=slides/presentation, xlsx/csv=spreadsheet/data, docx=Word handout, pdf=printable doc, md/txt/html=text, png/jpeg/gif=image, py/js/ts=code.',
+            enum: [
+              'pdf', 'docx', 'doc', 'xlsx', 'pptx', 'csv', 'md', 'html', 'txt',
+              'json', 'xml', 'tex', 'png', 'jpeg', 'jpg', 'gif', 'zip', 'tar',
+              'py', 'js', 'ts', 'css', 'sh',
+            ],
+          },
+          title: { type: 'string', description: 'Document title' },
+          content: {
+            type: 'string',
+            description: 'Full body — markdown or plain text with headings, lists, tables, slide notes, etc.',
           },
         },
-        required: ['title', 'blocks'],
+        required: ['title', 'content', 'format'],
       }),
-      execute: async ({ title, blocks }: GenerateDocumentArgs) => {
-        proposals.docs.push({ title, blocks } as unknown as DocToCreate);
-        return `Document "${title}" queued for generation.`;
+      execute: async ({ title, content, format }: GenerateDocumentArgs) => {
+        proposals.docs.push({
+          title,
+          content: content.trim(),
+          format: (format ?? 'pdf') as DocToCreate['format'],
+        });
+        const ext = (format ?? 'pdf').toUpperCase();
+        return `Document "${title}" queued for ${ext} generation.`;
       },
     },
   };

package/src/services/assignment.ts

@@ -937,6 +937,9 @@ export async function updateSubmissionAsTeacherRecord(
     );
   }
 
+  // Index submission for RAG search after teacher grades/feedback
+  enqueueEmbedding(input.classId, 'SUBMISSION', submissionId);
+
   return updated;
 }
 

package/src/services/class.ts

@@ -6,6 +6,7 @@ import { SessionType } from "@prisma/client";
 import { TRPCError } from "@trpc/server";
 import { prisma } from "../lib/prisma.js";
 import { generateInviteCode } from "../utils/generateInviteCode.js";
+import { enqueueEmbedding } from "./embedding.js";
 import {
   findTeacherClasses,
   findStudentClasses,
@@ -626,10 +627,15 @@ export async function updateSyllabus(classId: string, contents: string) {
       message: "Missing key contents",
     });
   }
-  return prisma.class.update({
+  const updated = await prisma.class.update({
     where: { id: classId },
     data: { syllabus: contents },
   });
+
+  // Index syllabus for RAG search
+  enqueueEmbedding(classId, 'SYLLABUS', classId);
+
+  return updated;
 }
 
 export async function listLabDrafts(classId: string, teacherId: string) {

package/src/services/discussion.ts

@@ -6,6 +6,7 @@ import { discussionChannel, pusher } from "../lib/pusher.js";
 import { logger } from "../utils/logger.js";
 import { classMemberOrSchoolAdminWhere, classTeacherOrSchoolAdminWhere } from "../models/access.js";
 import { sendNotification } from "./notification.js";
+import { enqueueEmbedding } from "./embedding.js";
 
 const authorSelect = {
   id: true,
@@ -441,6 +442,10 @@ export async function createDiscussion(userId: string, input: {
 
   triggerDiscussionEvent(input.classId, "discussion-created", { discussion: serializeDiscussion(discussion, userId) });
   await notifyMentionedUsers(input.classId, userId, input.body, `/class/${input.classId}/discussions/${discussion.id}`);
+
+  // Auto-index discussion for RAG search
+  enqueueEmbedding(input.classId, 'DISCUSSION', discussion.id);
+
   return { discussion: serializeDiscussion(discussion, userId) };
 }
 
@@ -471,6 +476,10 @@ export async function updateDiscussion(userId: string, input: {
     include: discussionInclude,
   });
   triggerDiscussionEvent(updated.classId, "discussion-updated", { discussion: serializeDiscussion(updated, userId) });
+
+  // Re-index discussion for RAG search after update
+  enqueueEmbedding(updated.classId, 'DISCUSSION', updated.id);
+
   return { discussion: serializeDiscussion(updated, userId) };
 }
 
@@ -526,6 +535,10 @@ export async function replyToDiscussion(userId: string, input: {
     notifyMentionedUsers(discussion.classId, userId, input.body, link),
   ]);
   triggerDiscussionEvent(discussion.classId, "reply-created", { discussionId: discussion.id, reply: serializeReply(reply, userId) });
+
+  // Re-index discussion for RAG search (includes new reply)
+  enqueueEmbedding(discussion.classId, 'DISCUSSION', discussion.id);
+
   return { reply: serializeReply(reply, userId) };
 }
 

package/src/services/embedding.ts

@@ -193,28 +193,38 @@ export async function removeEmbeddings(params: {
 }
 
 /**
- * Index an assignment (title + instructions) into the vector store.
+ * Index an assignment (title + instructions + attached file names) into the vector store.
  */
 export async function indexAssignment(classId: string, assignmentId: string): Promise<void> {
   const assignment = await prisma.assignment.findUnique({
     where: { id: assignmentId },
-    select: { title: true, instructions: true, type: true },
+    select: {
+      title: true,
+      instructions: true,
+      type: true,
+      attachments: { select: { name: true, type: true } },
+    },
   });
 
   if (!assignment) return;
 
-  const text = [
+  const parts = [
     `Title: ${assignment.title}`,
     `Type: ${assignment.type}`,
     assignment.instructions ? `Instructions: ${assignment.instructions}` : '',
-  ].filter(Boolean).join('\n');
+  ];
+
+  if (assignment.attachments.length > 0) {
+    const fileList = assignment.attachments.map((f) => `${f.name} (${f.type})`).join(', ');
+    parts.push(`Attached files: ${fileList}`);
+  }
 
   await indexContent({
     classId,
     sourceType: 'ASSIGNMENT',
     sourceId: assignmentId,
-    text,
-    metadata: { title: assignment.title, type: assignment.type },
+    text: parts.filter(Boolean).join('\n'),
+    metadata: { title: assignment.title, type: assignment.type, fileCount: assignment.attachments.length },
   });
 }
 
@@ -269,6 +279,157 @@ export async function indexAnnouncement(classId: string, announcementId: string)
   });
 }
 
+/**
+ * Index a discussion (title + body + replies) into the vector store.
+ */
+export async function indexDiscussion(classId: string, discussionId: string): Promise<void> {
+  const discussion = await prisma.discussion.findUnique({
+    where: { id: discussionId },
+    select: {
+      title: true,
+      body: true,
+      type: true,
+      author: { select: { username: true, profile: { select: { displayName: true } } } },
+      replies: {
+        select: { body: true, author: { select: { username: true, profile: { select: { displayName: true } } } } },
+        orderBy: { createdAt: 'asc' },
+        take: 20,
+      },
+    },
+  });
+
+  if (!discussion) return;
+
+  const authorName = discussion.author.profile?.displayName || discussion.author.username;
+  const parts = [
+    `Discussion: ${discussion.title}`,
+    `Type: ${discussion.type}`,
+    `Author: ${authorName}`,
+    `Body: ${discussion.body}`,
+  ];
+
+  if (discussion.replies.length > 0) {
+    parts.push('Replies:');
+    for (const reply of discussion.replies) {
+      const replyAuthor = reply.author.profile?.displayName || reply.author.username;
+      parts.push(`  ${replyAuthor}: ${reply.body.slice(0, 300)}`);
+    }
+  }
+
+  await indexContent({
+    classId,
+    sourceType: 'DISCUSSION',
+    sourceId: discussionId,
+    text: parts.join('\n'),
+    metadata: { title: discussion.title, type: discussion.type, replyCount: discussion.replies.length },
+  });
+}
+
+/**
+ * Index a submission (grade + feedback + file attachments + extended response) into the vector store.
+ */
+export async function indexSubmission(classId: string, submissionId: string): Promise<void> {
+  const submission = await prisma.submission.findUnique({
+    where: { id: submissionId },
+    select: {
+      gradeReceived: true,
+      teacherComments: true,
+      extendedResponse: true,
+      returned: true,
+      student: { select: { username: true, profile: { select: { displayName: true } } } },
+      assignment: { select: { title: true, maxGrade: true, type: true } },
+      attachments: { select: { name: true, type: true } },
+      annotations: { select: { name: true, type: true } },
+    },
+  });
+
+  if (!submission) return;
+
+  const studentName = submission.student.profile?.displayName || submission.student.username;
+  const parts = [
+    `Submission for: ${submission.assignment.title}`,
+    `Student: ${studentName}`,
+    `Assignment type: ${submission.assignment.type}`,
+  ];
+
+  if (submission.gradeReceived != null) {
+    parts.push(`Grade: ${submission.gradeReceived}/${submission.assignment.maxGrade ?? '?'}`);
+  }
+  if (submission.teacherComments) {
+    parts.push(`Teacher feedback: ${submission.teacherComments}`);
+  }
+  if (submission.extendedResponse) {
+    parts.push(`Student response: ${submission.extendedResponse.slice(0, 500)}`);
+  }
+  if (submission.attachments.length > 0) {
+    parts.push(`Submitted files: ${submission.attachments.map((f) => f.name).join(', ')}`);
+  }
+  if (submission.annotations.length > 0) {
+    parts.push(`Teacher annotations: ${submission.annotations.map((f) => f.name).join(', ')}`);
+  }
+
+  await indexContent({
+    classId,
+    sourceType: 'SUBMISSION',
+    sourceId: submissionId,
+    text: parts.join('\n'),
+    metadata: { studentName, assignmentTitle: submission.assignment.title, grade: submission.gradeReceived },
+  });
+}
+
+/**
+ * Index a class syllabus into the vector store.
+ * Uses classId as both classId and sourceId since syllabus is a field on the class.
+ */
+export async function indexSyllabus(classId: string): Promise<void> {
+  const cls = await prisma.class.findUnique({
+    where: { id: classId },
+    select: { name: true, subject: true, syllabus: true },
+  });
+
+  if (!cls?.syllabus) return;
+
+  const text = [
+    `Syllabus for ${cls.name} (${cls.subject})`,
+    cls.syllabus,
+  ].join('\n\n');
+
+  await indexContent({
+    classId,
+    sourceType: 'SYLLABUS',
+    sourceId: classId,
+    text,
+    metadata: { className: cls.name, subject: cls.subject },
+  });
+}
+
+/**
+ * Index a file (name + type + path) into the vector store.
+ * For text-based content, PDF extraction would be added here in the future.
+ */
+export async function indexFile(classId: string, fileId: string): Promise<void> {
+  const file = await prisma.file.findUnique({
+    where: { id: fileId },
+    select: { name: true, path: true, type: true, size: true },
+  });
+
+  if (!file) return;
+
+  const text = [
+    `File: ${file.name}`,
+    `Type: ${file.type}`,
+    `Path: ${file.path}`,
+  ].join('\n');
+
+  await indexContent({
+    classId,
+    sourceType: 'FILE',
+    sourceId: fileId,
+    text,
+    metadata: { name: file.name, type: file.type, size: file.size },
+  });
+}
+
 /**
  * Fire-and-forget: enqueue a background job to embed content.
  * Safe to call from service functions after a create/update.

package/src/services/folder.ts

@@ -28,6 +28,7 @@ import {
   type DirectFileData,
   confirmDirectUpload,
 } from "../lib/fileUpload.js";
+import { enqueueEmbedding } from "./embedding.js";
 import {
   type AccessLevel,
   getScopeDefault,
@@ -421,9 +422,39 @@ export async function confirmFolderUpload(
     input.uploadSuccess,
     input.errorMessage
   );
+
+  // Index file for RAG search if it belongs to a class folder
+  if (input.uploadSuccess) {
+    const file = await prisma.file.findUnique({
+      where: { id: input.fileId },
+      select: { folderId: true },
+    });
+    if (file?.folderId) {
+      const classId = await resolveFileClassId(file.folderId);
+      if (classId) {
+        enqueueEmbedding(classId, 'FILE', input.fileId);
+      }
+    }
+  }
+
   return { success: true };
 }
 
+/** Walk up folder tree to find classId, if any. */
+async function resolveFileClassId(folderId: string): Promise<string | null> {
+  let currentId: string | null = folderId;
+  while (currentId) {
+    const folder = await prisma.folder.findUnique({
+      where: { id: currentId },
+      select: { classId: true, parentFolderId: true },
+    });
+    if (!folder) return null;
+    if (folder.classId) return folder.classId;
+    currentId = folder.parentFolderId;
+  }
+  return null;
+}
+
 /** What scopes can this user pick from in cloud-storage UIs? */
 export async function listUserScopes(userId: string) {
   const memberships = await prisma.schoolMembership.findMany({