@studious-lms/server 1.4.2 → 1.4.3

package/tests/utils/inference.test.ts

@@ -0,0 +1,218 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { z } from 'zod';
+
+const {
+  chatCreateMock,
+  responseParseMock,
+  modelsListMock,
+  prismaMocks,
+  logger,
+} = vi.hoisted(() => ({
+  chatCreateMock: vi.fn(),
+  responseParseMock: vi.fn(),
+  modelsListMock: vi.fn(),
+  prismaMocks: {
+    aiUsageLog: {
+      create: vi.fn(),
+    },
+    message: {
+      create: vi.fn(),
+    },
+  },
+  logger: {
+    info: vi.fn(),
+    error: vi.fn(),
+  },
+}));
+
+vi.mock('openai', () => ({
+  default: class OpenAI {
+    chat = {
+      completions: {
+        create: chatCreateMock,
+      },
+    };
+
+    responses = {
+      parse: responseParseMock,
+    };
+
+    models = {
+      list: modelsListMock,
+    };
+  },
+}));
+
+vi.mock('openai/helpers/zod', () => ({
+  zodTextFormat: vi.fn((schema, name) => ({ schema, name })),
+}));
+
+vi.mock('../../src/lib/prisma.js', () => ({
+  prisma: prismaMocks,
+}));
+
+vi.mock('../../src/utils/logger.js', () => ({
+  logger,
+}));
+
+vi.mock('../../src/lib/pusher.js', () => ({
+  chatChannel: vi.fn(),
+  pusher: {
+    trigger: vi.fn(),
+  },
+}));
+
+vi.mock('../../src/utils/aiUser.js', () => ({
+  ensureAIUserExists: vi.fn(),
+  getAIUserId: vi.fn(() => 'AI_ASSISTANT'),
+}));
+
+vi.mock('../../src/lib/config/env.js', () => ({
+  env: {
+    INFERENCE_API_KEY: 'test-key',
+    INFERENCE_API_BASE_URL: 'http://localhost:11434/v1',
+    OPENAI_API_KEY: 'test-openai-key',
+  },
+}));
+
+import { estimateTokenCount, inference } from '../../src/utils/inference.js';
+
+describe('inference', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    prismaMocks.aiUsageLog.create.mockResolvedValue({ id: 'log-1' });
+  });
+
+  test('logs chat completion usage with the provided reason', async () => {
+    chatCreateMock.mockResolvedValue({
+      choices: [{ message: { content: 'Hello back' } }],
+      usage: {
+        prompt_tokens: 12,
+        completion_tokens: 8,
+        total_tokens: 20,
+      },
+    });
+
+    const result = await inference<string>('Hello there', undefined, {
+      reason: 'student_progress_chat',
+      metadata: { classId: 'class-1', studentId: 'student-1' },
+    });
+
+    expect(result).toBe('Hello back');
+    expect(prismaMocks.aiUsageLog.create).toHaveBeenCalledWith({
+      data: expect.objectContaining({
+        reason: 'student_progress_chat',
+        operation: 'chat.completions',
+        success: true,
+        promptTokens: 12,
+        completionTokens: 8,
+        totalTokens: 20,
+        estimatedInputTokens: estimateTokenCount('Hello there'),
+        metadata: { classId: 'class-1', studentId: 'student-1' },
+      }),
+    });
+    expect(logger.info).toHaveBeenCalledWith(
+      'AI usage logged',
+      expect.objectContaining({
+        reason: 'student_progress_chat',
+        totalTokens: 20,
+      }),
+    );
+    expect(chatCreateMock).toHaveBeenCalledWith({
+      model: 'gpt-5-nano',
+      messages: [{ role: 'user', content: 'Hello there' }],
+    });
+  });
+
+  test('passes optional chat completion settings through the helper', async () => {
+    chatCreateMock.mockResolvedValue({
+      choices: [{ message: { content: 'Configured response' } }],
+      usage: {
+        prompt_tokens: 10,
+        completion_tokens: 5,
+        total_tokens: 15,
+      },
+    });
+
+    const result = await inference<string>('Introduce yourself', undefined, {
+      reason: 'newton_chat_introduction',
+      metadata: { conversationId: 'conversation-1' },
+      model: 'command-a-03-2025',
+      maxTokens: 300,
+      temperature: 0.8,
+    });
+
+    expect(result).toBe('Configured response');
+    expect(chatCreateMock).toHaveBeenCalledWith({
+      model: 'command-a-03-2025',
+      messages: [{ role: 'user', content: 'Introduce yourself' }],
+      max_tokens: 300,
+      temperature: 0.8,
+    });
+    expect(prismaMocks.aiUsageLog.create).toHaveBeenCalledWith({
+      data: expect.objectContaining({
+        reason: 'newton_chat_introduction',
+        model: 'command-a-03-2025',
+        metadata: { conversationId: 'conversation-1' },
+      }),
+    });
+  });
+
+  test('logs structured response usage for parsed responses', async () => {
+    responseParseMock.mockResolvedValue({
+      output_parsed: { score: 4 },
+      usage: {
+        input_tokens: 30,
+        output_tokens: 10,
+        total_tokens: 40,
+      },
+    });
+
+    const schema = z.object({ score: z.number() });
+    const result = await inference<{ score: number }>('Grade this', schema, {
+      reason: 'worksheet_autograde',
+      metadata: { worksheetResponseId: 'response-1' },
+    });
+
+    expect(result).toEqual({ score: 4 });
+    expect(prismaMocks.aiUsageLog.create).toHaveBeenCalledWith({
+      data: expect.objectContaining({
+        reason: 'worksheet_autograde',
+        operation: 'responses.parse',
+        success: true,
+        promptTokens: 30,
+        completionTokens: 10,
+        totalTokens: 40,
+        metadata: { worksheetResponseId: 'response-1' },
+      }),
+    });
+  });
+
+  test('logs failed attempts before rethrowing', async () => {
+    chatCreateMock.mockRejectedValue(new Error('OpenAI unavailable'));
+
+    await expect(
+      inference<string>('Hello there', undefined, {
+        reason: 'newton_chat_response',
+        metadata: { conversationId: 'conversation-1' },
+      }),
+    ).rejects.toThrow('OpenAI unavailable');
+
+    expect(prismaMocks.aiUsageLog.create).toHaveBeenCalledWith({
+      data: expect.objectContaining({
+        reason: 'newton_chat_response',
+        operation: 'chat.completions',
+        success: false,
+        estimatedInputTokens: estimateTokenCount('Hello there'),
+        error: 'OpenAI unavailable',
+        metadata: { conversationId: 'conversation-1' },
+      }),
+    });
+    expect(logger.error).toHaveBeenCalledWith(
+      'Failed to generate inference response',
+      expect.objectContaining({
+        reason: 'newton_chat_response',
+      }),
+    );
+  });
+});