@studious-lms/server 1.14.0 → 1.15.0

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,37 @@ 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'],
-            },
+          title: { type: 'string', description: 'Document title' },
+          content: {
+            type: 'string',
+            description:
+              'Full body — markdown or plain text with headings, lists, tables, slide notes, etc.',
+          },
+          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',
+            ],
           },
         },
-        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/aiTools.ts

@@ -251,7 +251,7 @@ export function aiTools(classId: string): ToolSet {
           const client = new OpenAI();
           const response = await client.responses.create({
             model: 'gpt-4o-mini',
-            tools: [{ type: 'web_search_preview' }],
+            tools: [{ type: 'web_search' }],
             input: query,
           });
 

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/auth.ts

@@ -10,6 +10,7 @@ import { sendMail } from "../utils/email.js";
 import { prismaWrapper } from "../utils/prismaWrapper.js";
 import { env } from "../lib/config/env.js";
 import { logger } from "../utils/logger.js";
+import { CURRENT_TERMS_VERSION } from "../lib/legal.js";
 import {
   findUserByUsername,
   findUserByUsernameOrEmail,
@@ -32,8 +33,17 @@ export async function register(input: {
   username: string;
   email: string;
   password: string;
+  agreeToTerms: true;
+  termsVersion: string;
 }) {
-  const { username, email, password } = input;
+  const { username, email, password, termsVersion } = input;
+
+  if (termsVersion !== CURRENT_TERMS_VERSION) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "Please accept the current Terms of Service and Privacy Policy.",
+    });
+  }
 
   const existingUser = await prismaWrapper.findFirst(
     () => findUserByUsernameOrEmail(username, email),
@@ -70,7 +80,9 @@ export async function register(input: {
         username,
         email,
         password: await hash(password, 10),
-        verified: true,
+        verified: false,
+        termsAcceptedAt: new Date(),
+        termsVersion,
       }),
     "creating new user during registration"
   );

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({

package/src/services/marketing.ts

@@ -4,7 +4,7 @@
 import { v4 } from "uuid";
 import {
   createSchoolDevelopmentProgram,
-  findSchoolDevelopmentProgramById,
+  findSchoolDevelopmentProgramStatusById,
   createEarlyAccessRequest,
 } from "../models/marketing.js";
 
@@ -42,9 +42,9 @@ export async function createSchoolDevelopmentProgramRecord(input: {
   return { id: program.id };
 }
 
-/** Look up a school development program by ID. */
+/** Public application status lookup (no contact PII). */
 export async function searchSchoolDevelopmentPrograms(id: string) {
-  return findSchoolDevelopmentProgramById(id);
+  return findSchoolDevelopmentProgramStatusById(id);
 }
 
 /** Create an early access request. */