@studious-lms/server 1.16.0 → 1.16.1

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/integration/routers/newtonChat.test.ts

@@ -50,7 +50,7 @@ describe('Newton Chat Router', () => {
     conversationId = tutorConversation.conversationId;
   });
 
-  test('rejects attachment-only Newton chat posts', async () => {
+  test('allows attachment-only Newton chat posts', async () => {
     const [uploadTarget] = await user2Caller.message.getUploadUrls({
       conversationId,
       files: [
@@ -70,12 +70,13 @@ describe('Newton Chat Router', () => {
       },
     });
 
-    await expect(
-      user2Caller.newtonChat.postToNewtonChat({
-        newtonChatId,
-        content: '   ',
-        fileIds: [uploadTarget!.id],
-      }),
-    ).rejects.toThrow();
+    const message = await user2Caller.newtonChat.postToNewtonChat({
+      newtonChatId,
+      content: '   ',
+      fileIds: [uploadTarget!.id],
+    });
+
+    expect(message.attachments).toHaveLength(1);
+    expect(message.attachments[0]?.name).toBe('newton-attachment-only.pdf');
   });
 });

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

@@ -0,0 +1,135 @@
+import { describe, expect, it, vi } from 'vitest';
+import {
+  buildUserMessageContentWithAttachments,
+  loadChatAttachments,
+} from '../../../src/lib/chatAttachmentPrompt.js';
+
+const pdfBytes = new Uint8Array([0x25, 0x50, 0x44, 0x46]);
+const docxText = 'Unit 3 lesson plan content';
+
+vi.mock('officeparser', () => ({
+  OfficeParser: {
+    parseOffice: vi.fn(async () => ({
+      toText: () => docxText,
+    })),
+  },
+}));
+
+vi.mock('../../../src/lib/googleCloudStorage.js', () => ({
+  bucket: {
+    file: vi.fn((path: string) => ({
+      download: vi.fn(async () => {
+        if (path.includes('missing')) {
+          throw new Error('not found');
+        }
+        if (path.endsWith('.docx')) {
+          return [Buffer.from('fake-docx-bytes')];
+        }
+        return [Buffer.from(pdfBytes)];
+      }),
+    })),
+  },
+}));
+
+describe('buildUserMessageContentWithAttachments', () => {
+  it('returns plain text when there are no attachments', () => {
+    expect(buildUserMessageContentWithAttachments('Hello', [])).toBe('Hello');
+  });
+
+  it('includes PDFs as inline file parts with bytes', () => {
+    const content = buildUserMessageContentWithAttachments('Review this', [
+      {
+        id: '1',
+        name: 'essay.pdf',
+        type: 'application/pdf',
+        path: 'essay.pdf',
+        data: pdfBytes,
+      },
+    ]);
+
+    expect(content).toEqual([
+      { type: 'text', text: 'Review this' },
+      {
+        type: 'file',
+        data: pdfBytes,
+        mediaType: 'application/pdf',
+        filename: 'essay.pdf',
+      },
+    ]);
+  });
+
+  it('includes extracted docx text in the message body', () => {
+    const content = buildUserMessageContentWithAttachments('Summarize', [
+      {
+        id: '2',
+        name: 'plan.docx',
+        type: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        path: 'plan.docx',
+        extractedText: docxText,
+      },
+    ]);
+
+    expect(content).toBe(
+      `Summarize\n\n[Content of plan.docx]:\n${docxText}`,
+    );
+  });
+
+  it('lists unsupported file types when extraction failed', () => {
+    const content = buildUserMessageContentWithAttachments('Here', [
+      {
+        id: '3',
+        name: 'clip.mp4',
+        type: 'video/mp4',
+        path: 'clip.mp4',
+      },
+    ]);
+
+    expect(content).toBe(
+      'Here\n[Attached files (content not extracted): clip.mp4 (video/mp4)]',
+    );
+  });
+});
+
+describe('loadChatAttachments', () => {
+  it('loads bytes and extracts office document text', async () => {
+    const resolved = await loadChatAttachments([
+      {
+        id: '1',
+        name: 'plan.docx',
+        type: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        path: 'uploads/plan.docx',
+      },
+    ]);
+
+    expect(resolved[0]?.data).toBeDefined();
+    expect(resolved[0]?.extractedText).toBe(docxText);
+  });
+
+  it('loads pdf bytes without extracted text', async () => {
+    const resolved = await loadChatAttachments([
+      {
+        id: '2',
+        name: 'scan.pdf',
+        type: 'application/pdf',
+        path: 'uploads/scan.pdf',
+      },
+    ]);
+
+    expect(resolved[0]?.data).toEqual(pdfBytes);
+    expect(resolved[0]?.extractedText).toBeUndefined();
+  });
+
+  it('skips download for video attachments', async () => {
+    const resolved = await loadChatAttachments([
+      {
+        id: '3',
+        name: 'clip.mp4',
+        type: 'video/mp4',
+        path: 'uploads/clip.mp4',
+      },
+    ]);
+
+    expect(resolved[0]?.data).toBeUndefined();
+    expect(resolved[0]?.extractedText).toBeUndefined();
+  });
+});

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

@@ -30,4 +30,14 @@ describe('inferDocumentFormat', () => {
   it('defaults to pdf for generic handouts', () => {
     expect(inferDocumentFormat('Reading Guide', 'Chapter summary', 'pdf')).toBe('pdf');
   });
+
+  it('overrides pdf when content mentions a flowchart', () => {
+    expect(
+      inferDocumentFormat(
+        'Photosynthesis Overview',
+        'Include a flowchart of the light reactions.',
+        'pdf',
+      ),
+    ).toBe('png');
+  });
 });

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

@@ -17,8 +17,8 @@ describe("buildLabChatAgentSystemPrompt", () => {
 });
 
 describe("buildLabChatAgentMessages", () => {
-  test("folds the class context into the system prompt, not the message list", () => {
-    const { system, messages } = buildLabChatAgentMessages({
+  test("folds the class context into the system prompt, not the message list", async () => {
+    const { system, messages } = await buildLabChatAgentMessages({
       context: "Topic context",
       classContext: "CLASS: Biology",
       recentMessages: [
@@ -41,8 +41,8 @@ describe("buildLabChatAgentMessages", () => {
     ]);
   });
 
-  test("sorts timestamped history into chronological order before prompt assembly", () => {
-    const { messages } = buildLabChatAgentMessages({
+  test("sorts timestamped history into chronological order before prompt assembly", async () => {
+    const { messages } = await buildLabChatAgentMessages({
       context: "Topic context",
       classContext: "CLASS: Biology",
       recentMessages: [
@@ -76,8 +76,8 @@ describe("buildLabChatAgentMessages", () => {
     });
   });
 
-  test("keeps original order among messages without timestamps", () => {
-    const { messages } = buildLabChatAgentMessages({
+  test("keeps original order among messages without timestamps", async () => {
+    const { messages } = await buildLabChatAgentMessages({
       context: "Topic context",
       classContext: "CLASS: Biology",
       recentMessages: [

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',
+      },
+    ]);
+  });
+});