@studious-lms/server 1.13.0 → 1.15.0

package/tests/integration/routers/auth.test.ts

@@ -6,6 +6,7 @@ import { test, expect, describe } from 'vitest';
 import { appRouter } from '../../../src/routers/_app';
 import { createTRPCContext } from '../../../src/trpc';
 import { prisma } from '../../../src/lib/prisma';
+import { registerInput } from '../../helpers/registerInput.js';
 import {
   caller,
   login1,
@@ -64,12 +65,9 @@ describe('Auth Router', () => {
   test('check fails when unauthenticated', () => expectUnauth((c) => c.auth.check()));
 
   test('resendVerificationEmail succeeds for existing user', async () => {
-    await caller.auth.register({
-      username: 'resendtest',
-      email: 'resend@studious.sh',
-      password: 'password_is_1234',
-      confirmPassword: 'password_is_1234',
-    });
+    await caller.auth.register(
+      registerInput({ username: 'resendtest', email: 'resend@studious.sh' }),
+    );
     const result = await caller.auth.resendVerificationEmail({
       email: 'resend@studious.sh',
     });
@@ -227,23 +225,20 @@ describe('Auth Router', () => {
 
   test('register fails when username already exists', async () => {
     await expect(
-      caller.auth.register({
-        username: 'testuser1',
-        email: 'newemail@studious.sh',
-        password: 'password_is_1234',
-        confirmPassword: 'password_is_1234',
-      })
+      caller.auth.register(
+        registerInput({
+          username: 'testuser1',
+          email: 'newemail@studious.sh',
+        }),
+      )
     ).rejects.toThrow();
   });
 
   test('register fails when email already exists', async () => {
     await expect(
-      caller.auth.register({
-        username: 'newuser',
-        email: 'test@studious.sh',
-        password: 'password_is_1234',
-        confirmPassword: 'password_is_1234',
-      })
+      caller.auth.register(
+        registerInput({ username: 'newuser', email: 'test@studious.sh' }),
+      )
     ).rejects.toThrow();
   });
 

package/tests/unit/lib/inferDocumentFormat.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+import { inferDocumentFormat } from '../../../src/lib/inferDocumentFormat.js';
+
+describe('inferDocumentFormat', () => {
+  it('respects explicit non-pdf format', () => {
+    expect(inferDocumentFormat('Title', 'body', 'xlsx')).toBe('xlsx');
+  });
+
+  it('overrides model pdf when title says presentation', () => {
+    expect(
+      inferDocumentFormat(
+        'Volume of Revolution Presentation',
+        'Slide 1: intro',
+        'pdf',
+      ),
+    ).toBe('pptx');
+  });
+
+  it('uses teacher message for format when model picked pdf', () => {
+    expect(
+      inferDocumentFormat(
+        'Calculus Unit 3',
+        'Content here',
+        'pdf',
+        'Can you make a PowerPoint for this lesson?',
+      ),
+    ).toBe('pptx');
+  });
+
+  it('defaults to pdf for generic handouts', () => {
+    expect(inferDocumentFormat('Reading Guide', 'Chapter summary', 'pdf')).toBe('pdf');
+  });
+});

package/tests/unit/pipelines/aiLabChatContract.test.ts

@@ -1,32 +1,49 @@
 import { describe, expect, test } from "vitest";
-import { labChatArrayFieldInstructions, labChatResponseFormat, labChatResponseSchema } from "../../../src/pipelines/aiLabChatContract.js";
+import {
+  assignmentToCreateSchema,
+  sectionToCreateSchema,
+  worksheetQuestionSchema,
+} from "../../../src/pipelines/aiLabChatContract.js";
 
 describe("aiLabChat contract", () => {
-  test("defaults worksheet and section collections to empty arrays", () => {
-    const parsed = labChatResponseSchema.parse({
-      text: "Summary",
-      docs: null,
-      assignmentsToCreate: null,
+  test("worksheet questions default options, mark scheme, and points", () => {
+    const parsed = worksheetQuestionSchema.parse({
+      type: "SHORT_ANSWER",
+      question: "What is osmosis?",
+      answer: "Diffusion of water across a membrane",
+      order: 0,
     });
 
-    expect(parsed.worksheetsToCreate).toEqual([]);
-    expect(parsed.sectionsToCreate).toEqual([]);
+    expect(parsed.options).toEqual([]);
+    expect(parsed.markScheme).toEqual([]);
+    expect(parsed.points).toBe(0);
   });
 
-  test("rejects null worksheet and section collections", () => {
-    expect(() => labChatResponseSchema.parse({
-      text: "Summary",
-      docs: null,
-      worksheetsToCreate: null,
-      sectionsToCreate: null,
-      assignmentsToCreate: null,
-    })).toThrow();
+  test("section color must be a hex value when provided", () => {
+    expect(() => sectionToCreateSchema.parse({ name: "Unit 1", color: "blue" })).toThrow();
+    expect(sectionToCreateSchema.parse({ name: "Unit 1", color: "#3B82F6" }).color).toBe(
+      "#3B82F6",
+    );
+    expect(sectionToCreateSchema.parse({ name: "Unit 1" }).color).toBeUndefined();
   });
 
-  test("prompt instructions require arrays for worksheet and section fields", () => {
-    expect(labChatResponseFormat).toContain(`"worksheetsToCreate": array`);
-    expect(labChatResponseFormat).toContain(`"sectionsToCreate": array`);
-    expect(labChatArrayFieldInstructions).toContain(`Use [] when there are no worksheets to create.`);
-    expect(labChatArrayFieldInstructions).toContain(`Use [] when there are no sections to create.`);
+  test("assignment requires an ISO datetime due date", () => {
+    const base = {
+      title: "Osmosis Quiz",
+      instructions: "Answer all questions.",
+      acceptFiles: false,
+      acceptExtendedResponse: false,
+      acceptWorksheet: true,
+      maxGrade: 10,
+      worksheetIds: [],
+      studentIds: [],
+      type: "QUIZ" as const,
+      attachments: [],
+    };
+
+    expect(() => assignmentToCreateSchema.parse({ ...base, dueDate: "not-a-date" })).toThrow();
+    expect(
+      assignmentToCreateSchema.parse({ ...base, dueDate: "2026-04-08T12:00:00Z" }).dueDate,
+    ).toBe("2026-04-08T12:00:00Z");
   });
 });

package/tests/unit/pipelines/labChatPrompt.test.ts

@@ -1,26 +1,24 @@
 import { describe, expect, test } from "vitest";
 
 import {
-  buildLabChatResponseMessages,
-  buildLabChatSystemPrompt,
+  buildLabChatAgentMessages,
+  buildLabChatAgentSystemPrompt,
 } from "../../../src/pipelines/labChatPrompt";
-import { labChatArrayFieldInstructions, labChatResponseFormat } from "../../../src/pipelines/aiLabChatContract";
 
-describe("buildLabChatSystemPrompt", () => {
-  test("requires arrays for worksheet and section structured output fields", () => {
-    const prompt = buildLabChatSystemPrompt("Context");
+describe("buildLabChatAgentSystemPrompt", () => {
+  test("instructs the model to create content via proposal tools", () => {
+    const prompt = buildLabChatAgentSystemPrompt("Context");
 
-    expect(prompt).toContain(labChatResponseFormat);
-    expect(prompt).toContain(labChatArrayFieldInstructions);
-    expect(prompt).toContain('Do not return null for "worksheetsToCreate" or "sectionsToCreate".');
-    expect(prompt).not.toContain('"worksheetsToCreate": null | array');
-    expect(prompt).not.toContain('"sectionsToCreate": null | array');
+    expect(prompt).toContain("Context");
+    expect(prompt).toContain("HOW TO CREATE CONTENT (TOOLS):");
+    expect(prompt).toContain("propose_assignment");
+    expect(prompt).toContain("propose_worksheet");
   });
 });
 
-describe("buildLabChatResponseMessages", () => {
-  test("builds response messages from history without replaying the latest teacher turn", () => {
-    const messages = buildLabChatResponseMessages({
+describe("buildLabChatAgentMessages", () => {
+  test("folds the class context into the system prompt, not the message list", () => {
+    const { system, messages } = buildLabChatAgentMessages({
       context: "Topic context",
       classContext: "CLASS: Biology",
       recentMessages: [
@@ -32,30 +30,19 @@ describe("buildLabChatResponseMessages", () => {
             profile: { displayName: "Ms Patel" },
           },
         },
-        {
-          senderId: "ai-user",
-          content: "I can do that.",
-        },
       ],
       isAIUser: (senderId) => senderId === "ai-user",
     });
 
-    const teacherTurns = messages.filter(
-      (message) =>
-        message.role === "user" &&
-        typeof message.content === "string" &&
-        message.content.includes("Create a quiz on osmosis"),
-    );
-
-    expect(teacherTurns).toHaveLength(1);
-    expect(messages.at(-2)).toMatchObject({
-      role: "developer",
-      content: expect.stringContaining("CLASS CONTEXT"),
-    });
+    expect(system).toContain("CLASS CONTEXT");
+    expect(system).toContain("CLASS: Biology");
+    expect(messages).toEqual([
+      { role: "user", content: "Ms Patel: Create a quiz on osmosis" },
+    ]);
   });
 
   test("sorts timestamped history into chronological order before prompt assembly", () => {
-    const messages = buildLabChatResponseMessages({
+    const { messages } = buildLabChatAgentMessages({
       context: "Topic context",
       classContext: "CLASS: Biology",
       recentMessages: [
@@ -79,18 +66,18 @@ describe("buildLabChatResponseMessages", () => {
       isAIUser: (senderId) => senderId === "ai-user",
     });
 
-    expect(messages[1]).toMatchObject({
+    expect(messages[0]).toMatchObject({
       role: "user",
       content: "Ms Patel: First request",
     });
-    expect(messages[2]).toMatchObject({
+    expect(messages[1]).toMatchObject({
       role: "assistant",
       content: "Second response",
     });
   });
 
   test("keeps original order among messages without timestamps", () => {
-    const messages = buildLabChatResponseMessages({
+    const { messages } = buildLabChatAgentMessages({
       context: "Topic context",
       classContext: "CLASS: Biology",
       recentMessages: [
@@ -114,11 +101,11 @@ describe("buildLabChatResponseMessages", () => {
       isAIUser: () => false,
     });
 
-    expect(messages[1]).toMatchObject({
+    expect(messages[0]).toMatchObject({
       role: "user",
       content: "Ms Patel: First untimed request",
     });
-    expect(messages[2]).toMatchObject({
+    expect(messages[1]).toMatchObject({
       role: "user",
       content: "Ms Patel: Second untimed request",
     });

package/tests/unit/services/aiChatStream.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, it } from 'vitest';
+import {
+  enrichStreamPartsWithGeneratedFiles,
+  finalizeDeferredToolParts,
+} from '../../../src/services/aiChatStream.js';
+
+describe('enrichStreamPartsWithGeneratedFiles', () => {
+  it('links generated files to generate_document tool parts by title', () => {
+    const parts = enrichStreamPartsWithGeneratedFiles(
+      [
+        { type: 'text', text: 'Here is your worksheet.' },
+        {
+          type: 'tool',
+          toolCallId: 'tc-1',
+          toolName: 'generate_document',
+          title: 'Algebra Review',
+          status: 'completed',
+        },
+      ],
+      [{ title: 'Algebra Review', fileId: 'file-1', fileName: 'Algebra_Review.pdf' }],
+    );
+
+    expect(parts[1]).toMatchObject({
+      type: 'tool',
+      fileId: 'file-1',
+      fileName: 'Algebra_Review.pdf',
+    });
+  });
+
+  it('falls back to order when titles do not match', () => {
+    const parts = enrichStreamPartsWithGeneratedFiles(
+      [
+        {
+          type: 'tool',
+          toolCallId: 'tc-1',
+          toolName: 'generate_document',
+          status: 'completed',
+        },
+      ],
+      [{ title: 'Doc A', fileId: 'file-a', fileName: 'doc_a.pdf' }],
+    );
+
+    expect(parts[0]).toMatchObject({ fileId: 'file-a' });
+  });
+
+  it('marks linked generate_document tools completed', () => {
+    const parts = enrichStreamPartsWithGeneratedFiles(
+      [
+        {
+          type: 'tool',
+          toolCallId: 'tc-1',
+          toolName: 'generate_document',
+          title: 'Slides',
+          status: 'executing',
+        },
+      ],
+      [{ title: 'Slides', fileId: 'file-1', fileName: 'slides.pptx' }],
+    );
+
+    expect(parts[0]).toMatchObject({ status: 'completed', fileId: 'file-1' });
+  });
+});
+
+describe('finalizeDeferredToolParts', () => {
+  it('marks generate_document without a file as failed', () => {
+    const parts = finalizeDeferredToolParts([
+      {
+        type: 'tool',
+        toolCallId: 'tc-1',
+        toolName: 'generate_document',
+        title: 'Missing',
+        status: 'executing',
+      },
+    ]);
+
+    expect(parts[0]).toMatchObject({ status: 'failed' });
+  });
+
+  it('leaves other tools unchanged', () => {
+    const parts = finalizeDeferredToolParts([
+      {
+        type: 'tool',
+        toolCallId: 'tc-1',
+        toolName: 'propose_assignment',
+        title: 'HW',
+        status: 'completed',
+      },
+    ]);
+
+    expect(parts[0]).toMatchObject({ status: 'completed' });
+  });
+});

package/tests/unit/services/openaiDocumentGen.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, it } from 'vitest';
+import {
+  extractContainerGeneratedFiles,
+  mimeTypeForFormat,
+  normalizeDocumentFormat,
+} from '../../../src/services/openaiDocumentGen.js';
+import type { Response } from 'openai/resources/responses/responses.js';
+
+describe('openaiDocumentGen', () => {
+  it('normalizes unknown formats to pdf', () => {
+    expect(normalizeDocumentFormat('docx')).toBe('docx');
+    expect(normalizeDocumentFormat('.PDF')).toBe('pdf');
+    expect(normalizeDocumentFormat('bogus')).toBe('pdf');
+  });
+
+  it('maps formats to mime types', () => {
+    expect(mimeTypeForFormat('pdf')).toBe('application/pdf');
+    expect(mimeTypeForFormat('xlsx')).toBe(
+      'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    );
+    expect(mimeTypeForFormat('png')).toBe('image/png');
+  });
+
+  it('collects container_file_citation annotations for the requested extension', () => {
+    const response = {
+      output: [
+        {
+          type: 'message',
+          content: [
+            {
+              type: 'output_text',
+              text: 'Here is your spreadsheet.',
+              annotations: [
+                {
+                  type: 'container_file_citation',
+                  container_id: 'cntr_1',
+                  file_id: 'cfile_1',
+                  filename: 'Grades.xlsx',
+                  start_index: 0,
+                  end_index: 0,
+                },
+                {
+                  type: 'container_file_citation',
+                  container_id: 'cntr_1',
+                  file_id: 'cfile_2',
+                  filename: 'Notes.pdf',
+                  start_index: 0,
+                  end_index: 0,
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    } as unknown as Response;
+
+    expect(extractContainerGeneratedFiles(response, 'xlsx')).toEqual([
+      {
+        containerId: 'cntr_1',
+        fileId: 'cfile_1',
+        filename: 'Grades.xlsx',
+      },
+    ]);
+  });
+});