@hed-hog/core 0.0.387 → 0.0.390

package/src/ai/ai.service.spec.ts

@@ -0,0 +1,280 @@
+import axios from 'axios';
+import { AiService } from './ai.service';
+
+jest.mock('axios');
+
+const mockedAxios = axios as jest.Mocked<typeof axios>;
+
+/**
+ * The point of these tests is regression: before model params existed, the
+ * OpenAI body was exactly `{ model, messages }` and the Gemini payload had no
+ * `generationConfig`. Some newer models reject `temperature`/`max_tokens`, so
+ * adding the feature must not change the wire format when nothing is set.
+ */
+describe('AiService — parâmetros de modelo', () => {
+  let service: AiService;
+  let promptResolver: { resolveMany: jest.Mock };
+
+  const aiProfile = {
+    apiKey: 'sk-test',
+    model: undefined as string | undefined,
+    timeoutMs: undefined as number | undefined,
+  };
+
+  beforeEach(() => {
+    const prisma = {} as any;
+    const settingService = { getSettingValues: jest.fn().mockResolvedValue({}) } as any;
+    const fileService = {} as any;
+    const aiExecution = {
+      start: jest.fn().mockResolvedValue(1),
+      recordStep: jest.fn().mockResolvedValue(undefined),
+      finish: jest.fn().mockResolvedValue(undefined),
+    } as any;
+    promptResolver = { resolveMany: jest.fn() };
+
+    service = new AiService(prisma, settingService, fileService, aiExecution, promptResolver as any);
+
+    // getAiProfile touches settings + integration_profile; stub the whole resolution.
+    jest.spyOn(service as any, 'getAiProfile').mockResolvedValue(aiProfile);
+    jest.spyOn(service as any, 'getDefaultProvider').mockResolvedValue('openai');
+    jest.spyOn(service as any, 'resolveAttachment').mockResolvedValue(null);
+
+    mockedAxios.post.mockResolvedValue({
+      data: {
+        choices: [{ message: { content: 'ok' } }],
+        candidates: [{ content: { parts: [{ text: 'ok' }] } }],
+      },
+    } as any);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+    mockedAxios.post.mockReset();
+  });
+
+  function lastBody(): Record<string, any> {
+    return mockedAxios.post.mock.calls.at(-1)?.[1] as Record<string, any>;
+  }
+
+  function lastUrl(): string {
+    return mockedAxios.post.mock.calls.at(-1)?.[0] as string;
+  }
+
+  describe('OpenAI', () => {
+    it('não envia temperature, max_tokens nem response_format quando não informados', async () => {
+      await service.chat({ message: 'oi', provider: 'openai' } as any);
+
+      const body = lastBody();
+      expect(Object.keys(body).sort()).toEqual(['messages', 'model']);
+      expect(body).not.toHaveProperty('temperature');
+      expect(body).not.toHaveProperty('max_tokens');
+      expect(body).not.toHaveProperty('response_format');
+    });
+
+    it('envia os parâmetros quando informados', async () => {
+      await service.chat({
+        message: 'oi',
+        provider: 'openai',
+        temperature: 0.3,
+        max_tokens: 500,
+        response_format: 'json_object',
+      } as any);
+
+      expect(lastBody()).toMatchObject({
+        temperature: 0.3,
+        max_tokens: 500,
+        response_format: { type: 'json_object' },
+      });
+    });
+
+    it('usa max_completion_tokens nos modelos de raciocínio', async () => {
+      await service.chat({
+        message: 'oi',
+        provider: 'openai',
+        model: 'o3-mini',
+        max_tokens: 500,
+      } as any);
+
+      const body = lastBody();
+      expect(body).toHaveProperty('max_completion_tokens', 500);
+      expect(body).not.toHaveProperty('max_tokens');
+    });
+
+    it('mantém o system prompt como primeira mensagem', async () => {
+      await service.chat({ message: 'oi', provider: 'openai', systemPrompt: 'seja breve' } as any);
+
+      expect(lastBody().messages[0]).toEqual({ role: 'system', content: 'seja breve' });
+    });
+  });
+
+  describe('Gemini', () => {
+    it('não cria generationConfig quando nada é informado', async () => {
+      await service.chat({ message: 'oi', provider: 'gemini' } as any);
+
+      expect(lastBody()).not.toHaveProperty('generationConfig');
+    });
+
+    it('mapeia max_tokens para maxOutputTokens e json_object para responseMimeType', async () => {
+      await service.chat({
+        message: 'oi',
+        provider: 'gemini',
+        temperature: 0.4,
+        max_tokens: 800,
+        response_format: 'json_object',
+      } as any);
+
+      expect(lastBody().generationConfig).toEqual({
+        temperature: 0.4,
+        maxOutputTokens: 800,
+        responseMimeType: 'application/json',
+      });
+    });
+
+    it('preserva systemInstruction ao aplicar os parâmetros', async () => {
+      await service.chat({
+        message: 'oi',
+        provider: 'gemini',
+        systemPrompt: 'seja breve',
+        temperature: 0.4,
+      } as any);
+
+      expect(lastBody().systemInstruction).toEqual({ parts: [{ text: 'seja breve' }] });
+    });
+  });
+
+  describe('DeepSeek', () => {
+    it('usa o endpoint do DeepSeek com o formato de corpo da OpenAI', async () => {
+      await service.chat({ message: 'oi', provider: 'deepseek' } as any);
+
+      expect(lastUrl()).toBe('https://api.deepseek.com/chat/completions');
+      expect(lastBody()).toEqual({
+        model: 'deepseek-chat',
+        messages: [{ role: 'user', content: 'oi' }],
+      });
+    });
+
+    it('respeita a base URL do perfil quando definida', async () => {
+      (service as any).getAiProfile.mockResolvedValueOnce({
+        ...aiProfile,
+        baseUrl: 'https://api.deepseek.com/beta',
+      });
+
+      await service.chat({ message: 'oi', provider: 'deepseek' } as any);
+
+      expect(lastUrl()).toBe('https://api.deepseek.com/beta/chat/completions');
+    });
+
+    it('não envia imagem como image_url (os modelos não têm visão)', async () => {
+      (service as any).resolveAttachment.mockResolvedValueOnce({
+        filename: 'foto.png',
+        mimeType: 'image/png',
+        buffer: Buffer.from('123'),
+      });
+
+      await service.chat({ message: 'oi', provider: 'deepseek', file_id: 1 } as any);
+
+      const content = lastBody().messages[0].content;
+      expect(typeof content).toBe('string');
+      expect(content).toContain('[Binary attachment: foto.png');
+    });
+
+    it('mapeia max_tokens e response_format como na OpenAI', async () => {
+      await service.chat({
+        message: 'oi',
+        provider: 'deepseek',
+        max_tokens: 500,
+        response_format: 'json_object',
+      } as any);
+
+      expect(lastBody()).toMatchObject({
+        max_tokens: 500,
+        response_format: { type: 'json_object' },
+      });
+    });
+  });
+
+  describe('chatWithPrompt', () => {
+    it('resolve os dois prompts numa consulta e devolve a origem de cada um', async () => {
+      promptResolver.resolveMany.mockResolvedValue({
+        'task.lms.quiz.generate.system': {
+          slug: 'task.lms.quiz.generate.system',
+          content: 'Você gera questionários.',
+          source: 'db',
+          model: null,
+          temperature: null,
+          maxTokens: null,
+        },
+        'task.lms.quiz.generate.user': {
+          slug: 'task.lms.quiz.generate.user',
+          content: 'Gere 5 questões.',
+          source: 'fallback',
+          model: null,
+          temperature: null,
+          maxTokens: null,
+        },
+      });
+
+      const result = await service.chatWithPrompt({
+        systemPromptSlug: 'task.lms.quiz.generate.system',
+        userPromptSlug: 'task.lms.quiz.generate.user',
+        provider: 'openai',
+      });
+
+      expect(promptResolver.resolveMany).toHaveBeenCalledTimes(1);
+      expect(result.promptSources).toEqual({
+        'task.lms.quiz.generate.system': 'db',
+        'task.lms.quiz.generate.user': 'fallback',
+      });
+
+      const body = lastBody();
+      expect(body.messages[0]).toEqual({ role: 'system', content: 'Você gera questionários.' });
+      expect(body.messages[1].content).toBe('Gere 5 questões.');
+    });
+
+    it('os parâmetros do registro sobrepõem os defaults do chamador', async () => {
+      promptResolver.resolveMany.mockResolvedValue({
+        'task.lms.quiz.generate.user': {
+          slug: 'task.lms.quiz.generate.user',
+          content: 'Gere 5 questões.',
+          source: 'db',
+          model: 'gpt-4o',
+          temperature: 0.9,
+          maxTokens: 2048,
+        },
+      });
+
+      const result = await service.chatWithPrompt({
+        userPromptSlug: 'task.lms.quiz.generate.user',
+        provider: 'openai',
+        params: { temperature: 0.1, maxTokens: 100 },
+      });
+
+      expect(result.model).toBe('gpt-4o');
+      expect(lastBody()).toMatchObject({ model: 'gpt-4o', temperature: 0.9, max_tokens: 2048 });
+    });
+
+    it('mantém os defaults do chamador quando o registro não define parâmetros', async () => {
+      promptResolver.resolveMany.mockResolvedValue({
+        'task.lms.quiz.generate.user': {
+          slug: 'task.lms.quiz.generate.user',
+          content: 'Gere 5 questões.',
+          source: 'fallback',
+          model: null,
+          temperature: null,
+          maxTokens: null,
+        },
+      });
+
+      await service.chatWithPrompt({
+        userPromptSlug: 'task.lms.quiz.generate.user',
+        provider: 'openai',
+        params: { temperature: 0.1, responseFormat: 'json_object' },
+      });
+
+      expect(lastBody()).toMatchObject({
+        temperature: 0.1,
+        response_format: { type: 'json_object' },
+      });
+    });
+  });
+});