@studious-lms/server 1.14.0 → 1.15.0

package/src/routers/embedding.ts

@@ -4,12 +4,17 @@
  */
 import { z } from 'zod';
 import { createTRPCRouter, protectedProcedure } from '../trpc.js';
-import { searchEmbeddings, indexAssignment, indexWorksheet, indexAnnouncement } from '../services/embedding.js';
+import { searchEmbeddings } from '../services/embedding.js';
 import { enqueueRunJob } from '../workers/queues.js';
 import { prisma } from '../lib/prisma.js';
 import { TRPCError } from '@trpc/server';
 import type { EmbeddingSourceType } from '@prisma/client';
 
+const sourceTypeEnum = z.enum([
+  'FILE', 'ASSIGNMENT', 'WORKSHEET', 'ANNOUNCEMENT',
+  'SECTION', 'DISCUSSION', 'SUBMISSION', 'SYLLABUS',
+]);
+
 export const embeddingRouter = createTRPCRouter({
   /**
    * Semantic search over class materials.
@@ -19,10 +24,9 @@ export const embeddingRouter = createTRPCRouter({
       classId: z.string(),
       query: z.string().min(1).max(500),
       limit: z.number().min(1).max(20).default(5),
-      sourceTypes: z.array(z.enum(['FILE', 'ASSIGNMENT', 'WORKSHEET', 'ANNOUNCEMENT', 'SECTION'])).optional(),
+      sourceTypes: z.array(sourceTypeEnum).optional(),
     }))
     .query(async ({ input, ctx }) => {
-      // Verify user has access to the class
       const userInClass = await prisma.class.findFirst({
         where: {
           id: input.classId,
@@ -54,11 +58,10 @@ export const embeddingRouter = createTRPCRouter({
   reindex: protectedProcedure
     .input(z.object({
       classId: z.string(),
-      sourceType: z.enum(['FILE', 'ASSIGNMENT', 'WORKSHEET', 'ANNOUNCEMENT', 'SECTION']),
+      sourceType: sourceTypeEnum,
       sourceId: z.string(),
     }))
     .mutation(async ({ input, ctx }) => {
-      // Verify teacher access
       const teacherInClass = await prisma.class.findFirst({
         where: {
           id: input.classId,
@@ -102,48 +105,46 @@ export const embeddingRouter = createTRPCRouter({
         throw new TRPCError({ code: 'FORBIDDEN', message: 'Teacher access required' });
       }
 
-      // Enqueue all assignments
-      const assignments = await prisma.assignment.findMany({
-        where: { classId: input.classId },
-        select: { id: true },
-      });
-
-      // Enqueue all worksheets
-      const worksheets = await prisma.worksheet.findMany({
-        where: { classId: input.classId },
-        select: { id: true },
-      });
-
-      // Enqueue all announcements
-      const announcements = await prisma.announcement.findMany({
-        where: { classId: input.classId },
-        select: { id: true },
-      });
+      const [assignments, worksheets, announcements, discussions, submissions, classData, classFiles] = await Promise.all([
+        prisma.assignment.findMany({ where: { classId: input.classId }, select: { id: true } }),
+        prisma.worksheet.findMany({ where: { classId: input.classId }, select: { id: true } }),
+        prisma.announcement.findMany({ where: { classId: input.classId }, select: { id: true } }),
+        prisma.discussion.findMany({ where: { classId: input.classId }, select: { id: true } }),
+        prisma.submission.findMany({
+          where: { assignment: { classId: input.classId }, gradeReceived: { not: null } },
+          select: { id: true },
+        }),
+        prisma.class.findUnique({ where: { id: input.classId }, select: { syllabus: true } }),
+        prisma.folder.findUnique({
+          where: { classId: input.classId },
+          select: { files: { select: { id: true }, where: { uploadStatus: 'COMPLETED' } } },
+        }),
+      ]);
 
       const jobs: Promise<unknown>[] = [];
+      const opts = { classId: input.classId, userId: ctx.user!.id };
 
       for (const a of assignments) {
-        jobs.push(enqueueRunJob('EMBED_CONTENT', {
-          classId: input.classId,
-          sourceType: 'ASSIGNMENT',
-          sourceId: a.id,
-        }, { classId: input.classId, userId: ctx.user!.id }));
+        jobs.push(enqueueRunJob('EMBED_CONTENT', { classId: input.classId, sourceType: 'ASSIGNMENT', sourceId: a.id }, opts));
       }
-
       for (const w of worksheets) {
-        jobs.push(enqueueRunJob('EMBED_CONTENT', {
-          classId: input.classId,
-          sourceType: 'WORKSHEET',
-          sourceId: w.id,
-        }, { classId: input.classId, userId: ctx.user!.id }));
+        jobs.push(enqueueRunJob('EMBED_CONTENT', { classId: input.classId, sourceType: 'WORKSHEET', sourceId: w.id }, opts));
       }
-
       for (const ann of announcements) {
-        jobs.push(enqueueRunJob('EMBED_CONTENT', {
-          classId: input.classId,
-          sourceType: 'ANNOUNCEMENT',
-          sourceId: ann.id,
-        }, { classId: input.classId, userId: ctx.user!.id }));
+        jobs.push(enqueueRunJob('EMBED_CONTENT', { classId: input.classId, sourceType: 'ANNOUNCEMENT', sourceId: ann.id }, opts));
+      }
+      for (const d of discussions) {
+        jobs.push(enqueueRunJob('EMBED_CONTENT', { classId: input.classId, sourceType: 'DISCUSSION', sourceId: d.id }, opts));
+      }
+      for (const s of submissions) {
+        jobs.push(enqueueRunJob('EMBED_CONTENT', { classId: input.classId, sourceType: 'SUBMISSION', sourceId: s.id }, opts));
+      }
+      if (classData?.syllabus) {
+        jobs.push(enqueueRunJob('EMBED_CONTENT', { classId: input.classId, sourceType: 'SYLLABUS', sourceId: input.classId }, opts));
+      }
+      const files = classFiles?.files ?? [];
+      for (const f of files) {
+        jobs.push(enqueueRunJob('EMBED_CONTENT', { classId: input.classId, sourceType: 'FILE', sourceId: f.id }, opts));
       }
 
       await Promise.allSettled(jobs);
@@ -153,6 +154,10 @@ export const embeddingRouter = createTRPCRouter({
           assignments: assignments.length,
           worksheets: worksheets.length,
           announcements: announcements.length,
+          discussions: discussions.length,
+          submissions: submissions.length,
+          syllabus: classData?.syllabus ? 1 : 0,
+          files: files.length,
         },
       };
     }),

package/src/routers/user.ts

@@ -1,3 +1,4 @@
+import { TRPCError } from "@trpc/server";
 import { z } from "zod";
 import { createTRPCRouter, protectedProcedure } from "../trpc.js";
 import {
@@ -5,6 +6,10 @@ import {
   updateProfile,
   getUploadUrl,
 } from "../services/user.js";
+import {
+  deleteUserAccount,
+  exportUserData,
+} from "../services/userPrivacy.js";
 
 const fileUploadSchema = z.object({
   filePath: z.string().min(1, "File path is required"),
@@ -79,4 +84,25 @@ export const userRouter = createTRPCRouter({
     .mutation(({ ctx, input }) =>
       getUploadUrl(ctx.user!.id, input.fileName, input.fileType)
     ),
+
+  exportData: protectedProcedure.query(({ ctx }) =>
+    exportUserData(ctx.user!.id),
+  ),
+
+  deleteAccount: protectedProcedure
+    .input(
+      z.object({
+        confirmUsername: z.string().min(1),
+      }),
+    )
+    .mutation(async ({ ctx, input }) => {
+      const profile = await getProfile(ctx.user!.id);
+      if (profile.username !== input.confirmUsername) {
+        throw new TRPCError({
+          code: "BAD_REQUEST",
+          message: "Username confirmation does not match",
+        });
+      }
+      return deleteUserAccount(ctx.user!.id);
+    }),
 });

package/src/routes/aiStream.ts

@@ -20,7 +20,11 @@ import { pusher, chatChannel, teacherChannel } from '../lib/pusher.js';
 import { getAIUserId, ensureAIUserExists, isAIUser } from '../utils/aiUser.js';
 import { JobStatus } from '@prisma/client';
 import { updateAssignmentRecord } from '../services/assignment.js';
-import { updateWorksheetRecord } from '../services/worksheet.js';
+import {
+  restoreWorksheetQuestions,
+  updateWorksheetRecord,
+  type WorksheetQuestionSnapshot,
+} from '../services/worksheet.js';
 
 export const aiStreamRouter = Router();
 
@@ -105,7 +109,7 @@ aiStreamRouter.post('/chat/stream', async (req: Request, res: Response) => {
     return res.status(400).json({ error: 'Unable to determine class context' });
   }
 
-  // Build message history from DB
+  // Build message history from DB (include attachments so the LLM can see them)
   const recentMessages = await prisma.message.findMany({
     where: { conversationId, status: { not: JobStatus.PENDING } },
     orderBy: { createdAt: 'asc' },
@@ -114,15 +118,23 @@ aiStreamRouter.post('/chat/stream', async (req: Request, res: Response) => {
       content: true,
       senderId: true,
       status: true,
+      attachments: {
+        select: { id: true, name: true, type: true, path: true },
+      },
     },
   });
 
   const messages: ModelMessage[] = recentMessages
     .filter((m) => m.content && m.content.length > 0)
-    .map((m) => ({
-      role: isAIUser(m.senderId) ? 'assistant' as const : 'user' as const,
-      content: m.content,
-    }));
+    .map((m) => {
+      const role = isAIUser(m.senderId) ? 'assistant' as const : 'user' as const;
+      if (role === 'assistant' || m.attachments.length === 0) {
+        return { role, content: m.content };
+      }
+      // Append file descriptions to user messages
+      const fileList = m.attachments.map((a) => `${a.name} (${a.type})`).join(', ');
+      return { role, content: `${m.content}\n[Attached files: ${fileList}]` };
+    });
 
   // Build system prompt based on context type
   let systemPrompt: string;
@@ -370,6 +382,16 @@ aiStreamRouter.post('/modify/stream', async (req: Request, res: Response) => {
     resourceContext = buildWorksheetContext(worksheet);
     preEditSnapshot = {
       name: worksheet.name,
+      questions: worksheet.questions.map((q) => ({
+        id: q.id,
+        type: q.type,
+        question: q.question,
+        answer: q.answer,
+        options: q.options,
+        markScheme: q.markScheme,
+        points: q.points,
+        order: q.order,
+      })),
     };
   }
 
@@ -461,7 +483,7 @@ aiStreamRouter.post('/modify/stream', async (req: Request, res: Response) => {
       tools,
       temperature: 0.3,
       maxOutputTokens: 8192,
-      stopWhen: stepCountIs(8),
+      stopWhen: stepCountIs(16),
     });
 
     // Drain the stream. Field writes happen inside the tools' execute (which
@@ -601,7 +623,15 @@ aiStreamRouter.post('/modify/undo', async (req: Request, res: Response) => {
         ...fields,
       });
     } else {
-      await updateWorksheetRecord(resourceId, user.id, parsed.snapshot);
+      const { questions, ...fields } = parsed.snapshot;
+      await updateWorksheetRecord(resourceId, user.id, fields);
+      if (Array.isArray(questions)) {
+        await restoreWorksheetQuestions(
+          resourceId,
+          user.id,
+          questions as WorksheetQuestionSnapshot[],
+        );
+      }
     }
 
     // Remove the snapshot so undo can only be used once
@@ -707,14 +737,21 @@ RULES:
 
 HOW TO EDIT: You change the worksheet by CALLING TOOLS — never by printing the new value as text.
 - Call \`update_worksheet_field\` for the field the teacher wants changed (currently: name).
+- Call \`add_worksheet_question\` once per new question. Question types:
+  MULTIPLE_CHOICE|TRUE_FALSE|SHORT_ANSWER|LONG_ANSWER|MATH_EXPRESSION|ESSAY.
+  For MULTIPLE_CHOICE provide \`options\` with exactly one \`isCorrect: true\`.
+- Call \`update_worksheet_question\` / \`delete_worksheet_question\` with the question's
+  Q_ID (shown in the worksheet context) to edit or remove existing questions.
 - Use \`search_materials\` first only if you need class context.
 
 RULES:
 - Only change what the teacher asked about.
 - Each tool call saves immediately and is shown to the teacher live.
+- Write real, pedagogically sound question content with correct answers — never placeholders.
 - After making all the changes, write a brief conversational summary of what you did.
   Be human and specific — mention the actual values. For example:
-  "Done — I've renamed the worksheet to 'Unit 3 Practice Problems'."
+  "Done — I've renamed the worksheet to 'Unit 3 Practice Problems' and added two
+  questions on volumes of revolution."
   Do NOT dump the full worksheet contents — just summarize naturally.`;
 }
 
@@ -771,6 +808,7 @@ function buildWorksheetContext(worksheet: any): string {
   let context = `WORKSHEET_NAME: ${worksheet.name}\nQUESTIONS_START`;
 
   for (const q of worksheet.questions) {
+    context += `\nQ_ID: ${q.id}`;
     context += `\nQ_TYPE: ${q.type}`;
     context += `\nQ_TEXT: ${q.question}`;
     context += `\nQ_ANSWER: ${q.answer}`;

package/src/services/aiChatStream.ts

@@ -47,17 +47,123 @@ export type StreamPart =
       toolName: string;
       /** Concrete entity label (e.g. assignment title / search query), if any. */
       title?: string;
+      /** Requested output type from the tool args (pdf, pptx, xlsx, …). */
+      format?: string;
+      /** Set after generated files are persisted on the message. */
+      fileId?: string;
+      fileName?: string;
       status: 'executing' | 'completed' | 'failed';
     };
 
+export interface GeneratedDocFileLink {
+  title: string;
+  fileId: string;
+  fileName: string;
+  format?: string;
+}
+
+/** Apply pipeline-resolved formats onto generate_document tool parts. */
+export function applyResolvedFormatsToStreamParts(
+  parts: StreamPart[],
+  docs: Array<{ title: string; format: string }>,
+): StreamPart[] {
+  if (docs.length === 0) return parts;
+
+  const pending = [...docs];
+  const takeDoc = (title?: string) => {
+    if (title) {
+      const idx = pending.findIndex(
+        (d) => d.title.trim().toLowerCase() === title.trim().toLowerCase(),
+      );
+      if (idx >= 0) return pending.splice(idx, 1)[0];
+    }
+    return pending.shift();
+  };
+
+  return parts.map((part) => {
+    if (part.type !== 'tool' || part.toolName !== 'generate_document') return part;
+    const doc = takeDoc(part.title);
+    return doc ? { ...part, format: doc.format } : part;
+  });
+}
+
+/** Tools that queue async work after the model stream; UI stays loading until the pipeline finishes. */
+const DEFERRED_COMPLETION_TOOLS = new Set(['generate_document']);
+
+function isDeferredCompletionTool(toolName: string): boolean {
+  return DEFERRED_COMPLETION_TOOLS.has(toolName);
+}
+
+/** Attach file IDs to `generate_document` tool parts for inline download chips. */
+export function enrichStreamPartsWithGeneratedFiles(
+  parts: StreamPart[],
+  files: GeneratedDocFileLink[],
+): StreamPart[] {
+  if (files.length === 0) return parts;
+
+  const docToolIndices = parts
+    .map((part, index) => ({ part, index }))
+    .filter(
+      ({ part }) =>
+        part.type === 'tool' && part.toolName === 'generate_document',
+    );
+
+  const unmatched = [...files];
+  const fileForTool = (toolTitle?: string): GeneratedDocFileLink | undefined => {
+    if (toolTitle) {
+      const idx = unmatched.findIndex(
+        (f) => f.title.trim().toLowerCase() === toolTitle.trim().toLowerCase(),
+      );
+      if (idx >= 0) return unmatched.splice(idx, 1)[0];
+    }
+    return unmatched.shift();
+  };
+
+  const fileByIndex = new Map<number, GeneratedDocFileLink>();
+  for (const { part, index } of docToolIndices) {
+    if (part.type !== 'tool') continue;
+    const file = fileForTool(part.title);
+    if (file) fileByIndex.set(index, file);
+  }
+
+  return parts.map((part, index) => {
+    const file = fileByIndex.get(index);
+    if (!file || part.type !== 'tool') return part;
+    return {
+      ...part,
+      fileId: file.fileId,
+      fileName: file.fileName,
+      status: 'completed',
+      ...(file.format ? { format: file.format } : {}),
+    };
+  });
+}
+
+/** Mark deferred tools completed (file linked) or failed (generation did not produce a file). */
+export function finalizeDeferredToolParts(parts: StreamPart[]): StreamPart[] {
+  return parts.map((part) => {
+    if (part.type !== 'tool' || !isDeferredCompletionTool(part.toolName)) {
+      return part;
+    }
+    if (part.fileId) return { ...part, status: 'completed' };
+    if (part.status === 'executing') return { ...part, status: 'failed' };
+    return part;
+  });
+}
+
+function toolFieldFromInput(input: unknown, key: string): string | undefined {
+  if (input && typeof input === 'object') {
+    const val = (input as Record<string, unknown>)[key];
+    if (typeof val === 'string' && val.trim()) return val.trim();
+  }
+  return undefined;
+}
+
 /** Pull a human-meaningful label out of a tool's input args, if present. */
 function toolTitleFromInput(input: unknown): string | undefined {
-  if (input && typeof input === 'object') {
-    const obj = input as Record<string, unknown>;
-    for (const key of ['title', 'name', 'query'] as const) {
-      const val = obj[key];
-      if (typeof val === 'string' && val.trim()) return val.trim();
-    }
+  for (const key of ['title', 'name', 'query'] as const) {
+    const val = toolFieldFromInput(input, key);
+    if (val) return val;
   }
   return undefined;
 }
@@ -163,12 +269,14 @@ export async function streamChatResponse(
         }
         case 'tool-call': {
           const title = toolTitleFromInput(part.input);
+          const format = toolFieldFromInput(part.input, 'format');
           toolPartIndexById.set(part.toolCallId, parts.length);
           parts.push({
             type: 'tool',
             toolCallId: part.toolCallId,
             toolName: part.toolName,
             ...(title ? { title } : {}),
+            ...(format ? { format } : {}),
             status: 'executing',
           });
           await broadcast('message-tool-call', {
@@ -176,30 +284,44 @@ export async function streamChatResponse(
             toolCallId: part.toolCallId,
             toolName: part.toolName,
             ...(title ? { title } : {}),
+            ...(format ? { format } : {}),
             status: 'executing',
           });
           break;
         }
         case 'tool-result':
         case 'tool-error': {
-          const status: 'completed' | 'failed' =
-            part.type === 'tool-error' ? 'failed' : 'completed';
+          const failed = part.type === 'tool-error';
+          const deferred = isDeferredCompletionTool(part.toolName);
+          // Deferred tools (e.g. generate_document) only queue work during the
+          // stream — keep the spinner until the pipeline attaches a file.
+          const status: 'executing' | 'completed' | 'failed' = failed
+            ? 'failed'
+            : deferred
+              ? 'executing'
+              : 'completed';
+          const title = toolTitleFromInput(part.input);
+          const format = toolFieldFromInput(part.input, 'format');
           const idx = toolPartIndexById.get(part.toolCallId);
           if (idx !== undefined) {
             const existing = parts[idx];
-            if (existing && existing.type === 'tool') existing.status = status;
+            if (existing && existing.type === 'tool') {
+              existing.status = status;
+              if (format) existing.format = format;
+            }
           }
           toolCalls.push({
             toolName: part.toolName,
             input: part.input,
             output: part.type === 'tool-result' ? part.output : undefined,
-            status,
+            status: failed ? 'failed' : 'completed',
           });
           await broadcast('message-tool-call', {
             messageId: aiMessageId,
             toolCallId: part.toolCallId,
             toolName: part.toolName,
-            ...(toolTitleFromInput(part.input) ? { title: toolTitleFromInput(part.input) } : {}),
+            ...(title ? { title } : {}),
+            ...(format ? { format } : {}),
             status,
           });
           break;

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}.`;
+      },
+    },
   };
 }