@studious-lms/server 1.25.0 → 1.27.0

package/src/routers/module.ts

@@ -0,0 +1,118 @@
+import { z } from "zod";
+import { CourseModuleItemType as ModuleItemType, ModuleItemRequirementType } from "@prisma/client";
+import {
+  createTRPCRouter,
+  protectedClassMemberProcedure,
+  protectedTeacherProcedure,
+} from "../trpc.js";
+import {
+  listModulesRecord,
+  createModuleRecord,
+  updateModuleRecord,
+  deleteModuleRecord,
+  reorderModulesRecord,
+  createModuleItemRecord,
+  updateModuleItemRecord,
+  deleteModuleItemRecord,
+  reorderModuleItemsRecord,
+  getStudentModulesState,
+  markItemViewedRecord,
+} from "../services/module.js";
+
+const itemTypeSchema = z.nativeEnum(ModuleItemType);
+const requirementTypeSchema = z.nativeEnum(ModuleItemRequirementType);
+
+export const moduleRouter = createTRPCRouter({
+  /** Teacher view: every module (published or not) with its items. */
+  list: protectedTeacherProcedure
+    .input(z.object({ classId: z.string() }))
+    .query(({ ctx, input }) => listModulesRecord(ctx.user!.id, input.classId)),
+
+  /** Student view: published modules with lock state and progress. */
+  getStudentState: protectedClassMemberProcedure
+    .input(z.object({ classId: z.string() }))
+    .query(({ ctx, input }) =>
+      getStudentModulesState(input.classId, ctx.user!.id)
+    ),
+
+  create: protectedTeacherProcedure
+    .input(
+      z.object({
+        classId: z.string(),
+        title: z.string().min(1),
+        unlockAt: z.coerce.date().nullish(),
+        requireSequential: z.boolean().optional(),
+      })
+    )
+    .mutation(({ ctx, input }) => createModuleRecord(ctx.user!.id, input)),
+
+  update: protectedTeacherProcedure
+    .input(
+      z.object({
+        classId: z.string(),
+        id: z.string(),
+        title: z.string().min(1).optional(),
+        unlockAt: z.coerce.date().nullable().optional(),
+        requireSequential: z.boolean().optional(),
+        published: z.boolean().optional(),
+        prerequisiteIds: z.array(z.string()).optional(),
+      })
+    )
+    .mutation(({ ctx, input }) => updateModuleRecord(ctx.user!.id, input)),
+
+  delete: protectedTeacherProcedure
+    .input(z.object({ classId: z.string(), id: z.string() }))
+    .mutation(({ ctx, input }) => deleteModuleRecord(ctx.user!.id, input)),
+
+  reorder: protectedTeacherProcedure
+    .input(z.object({ classId: z.string(), orderedIds: z.array(z.string()) }))
+    .mutation(({ ctx, input }) => reorderModulesRecord(ctx.user!.id, input)),
+
+  createItem: protectedTeacherProcedure
+    .input(
+      z.object({
+        classId: z.string(),
+        moduleId: z.string(),
+        itemType: itemTypeSchema,
+        itemId: z.string().optional(),
+        externalUrl: z.string().url().optional(),
+        title: z.string().optional(),
+        indent: z.number().int().min(0).max(4).optional(),
+        requirementType: requirementTypeSchema.optional(),
+        requiredScore: z.number().min(0).optional(),
+      })
+    )
+    .mutation(({ ctx, input }) => createModuleItemRecord(ctx.user!.id, input)),
+
+  updateItem: protectedTeacherProcedure
+    .input(
+      z.object({
+        classId: z.string(),
+        id: z.string(),
+        title: z.string().nullable().optional(),
+        externalUrl: z.string().url().optional(),
+        indent: z.number().int().min(0).max(4).optional(),
+        requirementType: requirementTypeSchema.nullable().optional(),
+        requiredScore: z.number().min(0).nullable().optional(),
+      })
+    )
+    .mutation(({ ctx, input }) => updateModuleItemRecord(ctx.user!.id, input)),
+
+  deleteItem: protectedTeacherProcedure
+    .input(z.object({ classId: z.string(), id: z.string() }))
+    .mutation(({ ctx, input }) => deleteModuleItemRecord(ctx.user!.id, input)),
+
+  reorderItems: protectedTeacherProcedure
+    .input(
+      z.object({
+        classId: z.string(),
+        items: z.array(z.object({ id: z.string(), moduleId: z.string() })),
+      })
+    )
+    .mutation(({ ctx, input }) => reorderModuleItemsRecord(ctx.user!.id, input)),
+
+  /** Record that a student viewed an item (completes VIEW requirements). */
+  markItemViewed: protectedClassMemberProcedure
+    .input(z.object({ classId: z.string(), itemId: z.string() }))
+    .mutation(({ ctx, input }) => markItemViewedRecord(ctx.user!.id, input)),
+});

package/src/routers/parent.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { createTRPCRouter, protectedProcedure } from "../trpc.js";
 import {
+  addParentToStudent,
   getChildAttendance,
   getChildGrades,
   linkParentToStudent,
@@ -20,6 +21,16 @@ export const parentRouter = createTRPCRouter({
     )
     .mutation(({ ctx, input }) => linkParentToStudent(ctx.user!.id, input)),
 
+  addToStudent: protectedProcedure
+    .input(
+      z.object({
+        schoolId: z.string(),
+        studentUserId: z.string(),
+        parentIdentifier: z.string().min(1),
+      })
+    )
+    .mutation(({ ctx, input }) => addParentToStudent(ctx.user!.id, input)),
+
   unlinkStudent: protectedProcedure
     .input(
       z.object({

package/src/routers/studentProgress.ts

@@ -7,6 +7,7 @@ import {
 import {
   chatAboutStudentProgress,
   dismissStudentRecommendation,
+  generateFollowUpAssignment,
   getClassProgressRecommendations,
   getStudentProgressFocus,
   getStudentProgressForecast,
@@ -66,6 +67,20 @@ export const studentProgressRouter = createTRPCRouter({
       dismissStudentRecommendation(ctx.user!.id, input),
     ),
 
+  generateFollowUpAssignment: protectedTeacherProcedure
+    .input(
+      z.object({
+        classId: z.string(),
+        studentId: z.string(),
+        submissionId: z.string(),
+        prompt: z.string().min(1).max(2000),
+        dueDate: z.string().datetime().optional(),
+      }),
+    )
+    .mutation(({ ctx, input }) =>
+      generateFollowUpAssignment(ctx.user!.id, input),
+    ),
+
   chat: protectedClassMemberProcedure
     .input(
       progressInputSchema.extend({

package/src/routes/aiStream.ts

@@ -453,6 +453,33 @@ aiStreamRouter.post('/modify/stream', async (req: Request, res: Response) => {
     Connection: 'keep-alive',
   });
 
+  // Narration is mirrored to other open editors as batched `modifier-chunk`
+  // events so their overlay streams live without a Pusher trigger per token.
+  const CHUNK_FLUSH_INTERVAL_MS = 250;
+  const CHUNK_FLUSH_MAX_CHARS = 500;
+  let chunkBuffer = '';
+  let lastChunkFlush = 0;
+  const flushChunks = async (force = false) => {
+    if (!chunkBuffer) return;
+    const now = Date.now();
+    if (
+      !force &&
+      now - lastChunkFlush < CHUNK_FLUSH_INTERVAL_MS &&
+      chunkBuffer.length < CHUNK_FLUSH_MAX_CHARS
+    ) {
+      return;
+    }
+    const payload = chunkBuffer;
+    chunkBuffer = '';
+    lastChunkFlush = now;
+    await pusher.trigger(channel, 'modifier-chunk', {
+      resourceId,
+      chunk: payload,
+    }).catch((err: unknown) => {
+      logger.warn('Failed to broadcast modifier-chunk', { err, resourceId });
+    });
+  };
+
   // Called after a tool persists a single field — apply it live everywhere.
   const onFieldUpdate = async (update: ModifierFieldUpdate) => {
     await pusher.trigger(channel, 'modifier-field-updated', {
@@ -466,6 +493,8 @@ aiStreamRouter.post('/modify/stream', async (req: Request, res: Response) => {
     });
     // Human-readable progress for the requesting client's bar.
     res.write(`Updated ${update.label}.\n`);
+    chunkBuffer += `Updated ${update.label}.\n`;
+    await flushChunks();
   };
 
   try {
@@ -490,7 +519,10 @@ aiStreamRouter.post('/modify/stream', async (req: Request, res: Response) => {
     // call onFieldUpdate); any narration text is forwarded to the SSE client.
     for await (const chunk of result.textStream) {
       res.write(chunk);
+      chunkBuffer += chunk;
+      await flushChunks();
     }
+    await flushChunks(true);
 
     // Clean up Redis flag and broadcast completion
     if (redis) {

package/src/seedDatabase.ts

@@ -1653,14 +1653,119 @@ export const seedDatabase = async () => {
             createdAt: hoursFromNow(-3, now),
         },
     });
+    // AI reply with creation proposals in all three states (pending card,
+    // approved row, dismissed row) so the approval flow is demo-able.
+    const labIntroText =
+        "Here's what I put together for the organelle functions unit. I drafted a 10-question quiz worksheet, and I'm proposing a graded quiz assignment plus a new section to keep the unit organized:";
+    const labProposals = [
+        {
+            id: "seed-proposal-worksheet",
+            kind: "worksheet",
+            title: "Organelle Functions Quiz (10 MCQs)",
+            status: "approved",
+            createdId: geneticsWorksheet.id,
+            payload: {
+                title: "Organelle Functions Quiz (10 MCQs)",
+                questions: Array.from({ length: 10 }, (_, i) => ({
+                    type: "MULTIPLE_CHOICE",
+                    question: `Organelle question ${i + 1}`,
+                    answer: "A",
+                    options: [],
+                    markScheme: [],
+                    points: 1,
+                    order: i,
+                })),
+            },
+        },
+        {
+            id: "seed-proposal-assignment",
+            kind: "assignment",
+            title: "Organelle Functions Quiz",
+            status: "pending",
+            payload: {
+                title: "Organelle Functions Quiz",
+                instructions:
+                    "Complete the 10-question multiple choice quiz on organelle functions. One attempt, 20 minutes.",
+                dueDate: hoursFromNow(7 * 24, now).toISOString(),
+                acceptFiles: false,
+                acceptExtendedResponse: false,
+                acceptWorksheet: true,
+                maxGrade: 10,
+                worksheetIds: [],
+                studentIds: [],
+                type: "QUIZ",
+                attachments: [],
+            },
+        },
+        {
+            id: "seed-proposal-section",
+            kind: "section",
+            title: "Unit 3: Cell Structure",
+            status: "dismissed",
+            payload: { name: "Unit 3: Cell Structure" },
+        },
+        {
+            id: "seed-proposal-assignment-update",
+            kind: "assignmentUpdate",
+            title: geneticsAssignment.title,
+            status: "pending",
+            payload: {
+                id: geneticsAssignment.id,
+                targetTitle: geneticsAssignment.title,
+                dueDate: hoursFromNow(10 * 24, now).toISOString(),
+                maxGrade: 15,
+            },
+        },
+    ];
     await prisma.message.create({
         data: {
-            content:
-                "Sure! Here are 10 AP-level MCQs on organelle functions, with explanations on each. Want me to also generate a 4-criterion rubric for grading short-answer follow-ups?",
+            content: labIntroText,
             senderId: aiUserId,
             conversationId: labConversation.id,
             createdAt: hoursFromNow(-2.95, now),
             status: JobStatus.COMPLETED,
+            meta: {
+                pendingCreations: labProposals,
+                streamParts: [
+                    { type: "text", text: labIntroText },
+                    {
+                        type: "tool",
+                        toolCallId: "seed-tool-worksheet",
+                        toolName: "propose_worksheet",
+                        title: "Organelle Functions Quiz (10 MCQs)",
+                        proposalId: "seed-proposal-worksheet",
+                        status: "completed",
+                    },
+                    {
+                        type: "tool",
+                        toolCallId: "seed-tool-assignment",
+                        toolName: "propose_assignment",
+                        title: "Organelle Functions Quiz",
+                        proposalId: "seed-proposal-assignment",
+                        status: "completed",
+                    },
+                    {
+                        type: "tool",
+                        toolCallId: "seed-tool-section",
+                        toolName: "propose_section",
+                        title: "Unit 3: Cell Structure",
+                        proposalId: "seed-proposal-section",
+                        status: "completed",
+                    },
+                    {
+                        type: "tool",
+                        toolCallId: "seed-tool-assignment-update",
+                        toolName: "propose_update_assignment",
+                        title: geneticsAssignment.title,
+                        proposalId: "seed-proposal-assignment-update",
+                        status: "completed",
+                    },
+                    {
+                        type: "text",
+                        text: "Approve whichever you'd like me to create — nothing is added to the class until you do.",
+                    },
+                ],
+            },
         },
     });
 

package/src/services/adminUser.ts

@@ -70,15 +70,18 @@ export async function getUserForAdmin(id: string) {
         },
       },
       sessions: {
+        where: { type: 'AUTH' },
         orderBy: { createdAt: 'desc' },
         take: 10,
-        select: { id: true, type: true, createdAt: true, expiresAt: true },
+        // Session.id is the bearer token — never return it from admin APIs.
+        select: { type: true, createdAt: true, expiresAt: true },
       },
       _count: {
         select: {
           teacherIn: true,
           studentIn: true,
-          sessions: true,
+          // Keep the count consistent with the AUTH-only session list above.
+          sessions: { where: { type: 'AUTH' } },
           submissions: true,
           files: true,
         },

package/src/services/aiChatStream.ts

@@ -14,12 +14,34 @@
 import { streamText, stepCountIs, type ModelMessage, type ToolSet } from 'ai';
 import { openai } from '@ai-sdk/openai';
 import { getRedis } from '../lib/redis.js';
+import { prisma } from '../lib/prisma.js';
 import { pusher, chatChannel } from '../lib/pusher.js';
 import { logger } from '../utils/logger.js';
 import { logInferenceUsage, type AiUsageAttribution } from '../utils/inference.js';
 
 const STREAM_REDIS_TTL = 600; // 10 minutes
 const STREAM_KEY_PREFIX = 'stream:';
+const CANCEL_KEY_PREFIX = 'stream:cancel:';
+const CANCEL_CHECK_INTERVAL_MS = 1_000;
+
+function streamCancelKey(aiMessageId: string): string {
+  return `${CANCEL_KEY_PREFIX}${aiMessageId}`;
+}
+
+/**
+ * Flag an in-flight stream for cancellation. `streamChatResponse` polls this
+ * key between chunks and aborts the model stream when it appears. The worker
+ * may run in a different process from the API, so the signal goes through
+ * Redis rather than an in-memory AbortController registry.
+ */
+export async function requestStreamCancellation(
+  aiMessageId: string,
+): Promise<void> {
+  const redis = getRedis();
+  if (redis) {
+    await redis.set(streamCancelKey(aiMessageId), '1', 'EX', STREAM_REDIS_TTL);
+  }
+}
 
 /** Default streaming model — matches the existing streamAIResponse path. */
 export const DEFAULT_STREAM_MODEL = 'gpt-4o-mini';
@@ -53,6 +75,10 @@ export type StreamPart =
       /** Set after generated files are persisted on the message. */
       fileId?: string;
       fileName?: string;
+      /** Links a propose_* tool call to its pending creation in message meta. */
+      proposalId?: string;
+      /** Class-files folder the generated file was saved into, if any. */
+      folderId?: string;
       status: 'executing' | 'completed' | 'failed';
     };
 
@@ -61,6 +87,7 @@ export interface GeneratedDocFileLink {
   fileId: string;
   fileName: string;
   format?: string;
+  folderId?: string;
 }
 
 /** Apply pipeline-resolved formats onto generate_document tool parts. */
@@ -136,6 +163,7 @@ export function enrichStreamPartsWithGeneratedFiles(
       fileName: file.fileName,
       status: 'completed',
       ...(file.format ? { format: file.format } : {}),
+      ...(file.folderId ? { folderId: file.folderId } : {}),
     };
   });
 }
@@ -162,7 +190,7 @@ function toolFieldFromInput(input: unknown, key: string): string | undefined {
 
 /** Pull a human-meaningful label out of a tool's input args, if present. */
 function toolTitleFromInput(input: unknown): string | undefined {
-  for (const key of ['title', 'name', 'query'] as const) {
+  for (const key of ['targetTitle', 'title', 'name', 'query'] as const) {
     const val = toolFieldFromInput(input, key);
     if (val) return val;
   }
@@ -191,6 +219,9 @@ export interface StreamChatResult {
   toolCalls: StreamedToolCall[];
   /** Ordered text/tool parts, in the exact order the model produced them. */
   parts: StreamPart[];
+  /** True when the stream was stopped by a cancellation request; `text` and
+   *  `parts` hold whatever was produced before the abort. */
+  cancelled: boolean;
 }
 
 /**
@@ -218,11 +249,39 @@ export async function streamChatResponse(
 
   const redis = getRedis();
   const streamKey = `${STREAM_KEY_PREFIX}${aiMessageId}`;
+  const cancelKey = streamCancelKey(aiMessageId);
   if (redis) {
     await redis.set(streamKey, '', 'EX', STREAM_REDIS_TTL);
+    // A stale flag from a previously cancelled run on the same message id
+    // (e.g. a rerun) must not kill this stream instantly.
+    await redis.del(cancelKey).catch(() => {});
   }
 
   let fullText = '';
+  let cancelled = false;
+  let lastCancelCheck = 0;
+  const abortController = new AbortController();
+
+  // Poll the cancel flag at most once a second: Redis when available,
+  // otherwise the message row (the cancel mutation flips it to CANCELLED).
+  const checkCancelled = async (): Promise<boolean> => {
+    if (cancelled) return true;
+    const now = Date.now();
+    if (now - lastCancelCheck < CANCEL_CHECK_INTERVAL_MS) return false;
+    lastCancelCheck = now;
+    if (redis) {
+      const flag = await redis.get(cancelKey).catch(() => null);
+      if (flag) cancelled = true;
+    } else {
+      const row = await prisma.message
+        .findUnique({ where: { id: aiMessageId }, select: { status: true } })
+        .catch(() => null);
+      if (row?.status === 'CANCELLED') cancelled = true;
+    }
+    if (cancelled) abortController.abort();
+    return cancelled;
+  };
+
   const parts: StreamPart[] = [];
   const toolCalls: StreamedToolCall[] = [];
   // Map AI SDK toolCallId -> index in `parts` so the executing indicator can
@@ -256,13 +315,20 @@ export async function streamChatResponse(
       temperature,
       maxOutputTokens,
       stopWhen: stepCountIs(maxSteps),
+      abortSignal: abortController.signal,
     });
 
     // `fullStream` yields text deltas AND tool events in a single, correctly
     // ordered sequence — this is what makes inline tool calls possible. We
     // build an ordered `parts` list and broadcast each event as it happens.
-    for await (const part of result.fullStream) {
-      switch (part.type) {
+    try {
+      for await (const part of result.fullStream) {
+        if (await checkCancelled()) break;
+        if (part.type === 'abort') {
+          cancelled = true;
+          break;
+        }
+        switch (part.type) {
         case 'text-delta': {
           appendText(part.text);
           if (redis) {
@@ -333,10 +399,19 @@ export async function streamChatResponse(
           });
           break;
         }
-        default:
-          // ignore reasoning/source/step/finish/raw parts
-          break;
+          default:
+            // ignore reasoning/source/step/finish/raw parts
+            break;
+        }
       }
+    } catch (streamError) {
+      // Aborting the model stream mid-iteration surfaces as an error from
+      // `fullStream`; when it is our own cancellation, keep the partials.
+      if (!cancelled) throw streamError;
+    }
+
+    if (cancelled) {
+      logger.info('AI chat stream cancelled', { aiMessageId, conversationId });
     }
 
     const usage = await Promise.resolve(result.totalUsage).catch(() => undefined);
@@ -356,7 +431,7 @@ export async function streamChatResponse(
       attribution,
     });
 
-    return { text: fullText, toolCalls, parts };
+    return { text: fullText, toolCalls, parts, cancelled };
   } catch (error) {
     await logInferenceUsage({
       model,
@@ -371,6 +446,7 @@ export async function streamChatResponse(
   } finally {
     if (redis) {
       await redis.del(streamKey).catch(() => {});
+      await redis.del(cancelKey).catch(() => {});
     }
   }
 }

package/src/services/aiGeneration.ts

@@ -0,0 +1,92 @@
+/**
+ * AI generation cancellation service.
+ *
+ * Cancels an in-flight AI chat generation (lab chat / Newton chat): flags the
+ * stream for abort via Redis so the worker's `streamChatResponse` loop stops,
+ * marks the linked RunJob CANCELLED (so a still-queued job never runs), and
+ * flips the placeholder message to CANCELLED immediately. The pipeline then
+ * persists whatever partial text/tool parts had already streamed.
+ */
+import { TRPCError } from "@trpc/server";
+import { JobStatus } from "@prisma/client";
+import { prisma } from "../lib/prisma.js";
+import { chatChannel, pusher } from "../lib/pusher.js";
+import { isAIUser } from "../utils/aiUser.js";
+import { requestStreamCancellation } from "./aiChatStream.js";
+import { logger } from "../utils/logger.js";
+
+export async function cancelAiGeneration(userId: string, messageId: string) {
+  const message = await prisma.message.findFirst({
+    where: {
+      id: messageId,
+      conversation: { members: { some: { userId } } },
+    },
+    select: {
+      id: true,
+      senderId: true,
+      status: true,
+      conversationId: true,
+    },
+  });
+
+  if (!message || !isAIUser(message.senderId)) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "AI message not found or access denied",
+    });
+  }
+
+  if (message.status !== JobStatus.PENDING) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "No generation in progress for this message",
+    });
+  }
+
+  // Signal the in-flight stream (worker process) to abort.
+  await requestStreamCancellation(messageId);
+
+  // Mark the backing RunJob CANCELLED so a queued-but-not-started job is
+  // skipped by the worker, and the audit record reflects the stop.
+  await prisma.runJob.updateMany({
+    where: {
+      status: { in: ["PENDING", "RUNNING"] },
+      input: { path: ["aiMessageId"], equals: messageId },
+    },
+    data: {
+      status: "CANCELLED",
+      error: "Cancelled by user",
+      finishedAt: new Date(),
+    },
+  });
+
+  // Flip the placeholder to CANCELLED right away: this is both the instant
+  // UI signal and the durable cancel marker the stream loop falls back to
+  // when Redis is unavailable. The pipeline later fills in partial content.
+  const updated = await prisma.message.update({
+    where: { id: messageId },
+    data: { status: JobStatus.CANCELLED },
+    select: { id: true, conversationId: true, status: true },
+  });
+
+  logger.info("AI generation cancellation requested", {
+    messageId,
+    conversationId: message.conversationId,
+    userId,
+  });
+
+  try {
+    await pusher.trigger(chatChannel(updated.conversationId), "message-updated", {
+      id: updated.id,
+      conversationId: updated.conversationId,
+      status: updated.status,
+    });
+  } catch (broadcastError) {
+    logger.error("Failed to broadcast cancelled AI generation:", {
+      error: broadcastError,
+      messageId,
+    });
+  }
+
+  return { success: true };
+}