@programisto/edrm-exams 0.2.12 → 0.2.13

package/dist/modules/edrm-exams/lib/openai/correctQuestion.txt

@@ -1,10 +1,6 @@
-Tu est un correcteur de question de concours.
-Tu doit donner un score à cette question : ${instruction} dont la réponse donnée par le candidat est : ${response}.
-Il s'agissait d'une question de type ${questionType} (et si la question est de type MCQ alors les réponses possibles étaient les suivantes : ${possibleResponses})
-le score maximum pour cette question est ${maxScore}
-Tu doit donner un score entre 0 et ${maxScore} et un commentaire de correction.
-Tu dois répondre au format JSON : la reponse envoyer doit correspondre exactement à ce model json : 
-{
-    "score": score,
-    "comment": commentaire
-}
+Question : ${instruction}
+Type de question : ${questionType} 
+- si MCQ les réponses possibles étaient : ${possibleResponses}
+
+Réponse du candidat : ${response}
+Score à donner : De 0 à ${maxScore} avec un commentaire de correction

package/dist/modules/edrm-exams/lib/openai/createQuestion.txt

@@ -1,68 +1,6 @@
-Tu es un assistant qui crée des questions pour un test.
-    créer une question en fonction de du métier : ${job}, du niveau de seniorité : ${seniority}, de la categorie de question : ${category} et le niveau d'expertise de cette categorie : ${expertiseLevel} (allant de 1 à 10, de 1 à 3 = 'beginner', de 3 à 6 = 'intermediate', de 6 à 10 = 'advanced').
-    - la question doit être de type : ${questionType}.
-    - la question doit être dans la langue suivante : Français
-    - voici le model pour une question : 
-    const questionModel = new mongoose.Schema(
-    {
-        instruction:
-        {
-            type: String,
-            required: true
-        },
-        questionType:
-        {
-            type: String,
-            enum: 
-            ["MCQ", "free question", "exercice"],
-            required: true,
-        },
-        maxScore:
-        {
-            type: Number,
-            required: true,
-        },
-        possibleResponses: // only on MCQ (multiple choice responses)
-        {
-            type: 
-            [{
-                possibleResponse:
-                {
-                    type: String,
-                    required: true,
-                },
-                valid:
-                {
-                    type: Boolean,
-                    required: true
-                }
-            }],
-        },
-        time: // in secondes
-        {
-            type: Number,
-            required: true,
-        },
-        textType: //type d'input demandé à l'utilisateur 
-        {
-            type: String,
-            enum:
-            ["text", "code"],
-            required: false
-        }
-    });
-    - toutes les instruction et les réponses doivent toujours être compatible avec LaTeX pour être afficher dans des balises <MathJax>
-        voici un exemple : Voici une formule mathématique : \\( \\frac{a}{b} = c \\)
-    - voici des containtes pour chaque type de question : 
-    - MCQ
-        (il ne peut y avoir qu'une seule réponse juste sur quatre au total) le temps pour ces questions vont de 30 secondes à 1 minute
-    - free question ( ne rien mettre dans possibleResponses)
-        le temps pour ces questions vont de 30 secondes à 5 minutes en fonction de la complexité de la réponse attendue (à toi de juger)
-    - exercice ( ne rien mettre dans possibleResponses )
-        le temps pour ces questions vont de 3 à 20 minutes en fonction de la complexité de la réponse attendue (à toi de juger)
-    - les instruction et la difficulté doivent être en rapport avec targetJob et seniorityLevel de ${test}
-    - le temps pour répondre à la question dans time doit laisser le temps aux utilisateur d'y répondre, sans non plus lui laisser trop de temps pour qu'il triche (surtout sur les QCM).
-    - le format de la réponses doit être en json avec seulement les elements présent dans le model ci dessus et pas besoin d'ajouter d"_id".
-    - si la réponse attendue à une question de type free question ou exercice est un bout de code, alors remplit textType en "code", sinon laisse "text"
+Métier ciblé : ${job}
+Catégorie de la question : ${category} niveau ${expertiseLevel} 
+Type de question : ${questionType}
+Format : json
 
-    Pour ne pas faire de doublon, voici la liste des questions déjà présentes dans le test : ${otherQuestions}
+Voici la liste des questions déjà présentes dans le test (pour éviter les doublons) : ${otherQuestions}

package/dist/modules/edrm-exams/lib/openai.d.ts

@@ -33,4 +33,5 @@ interface ContextBuilder {
     }>;
 }
 export declare function generateLiveMessage(messageType: keyof ContextBuilder, params: CreateQuestionParams | CorrectQuestionParams, json?: boolean): Promise<string>;
+export declare function generateLiveMessageAssistant(assistantId: string, messageType: keyof ContextBuilder, params: CreateQuestionParams | CorrectQuestionParams, json?: boolean): Promise<string>;
 export {};

package/dist/modules/edrm-exams/lib/openai.js

@@ -74,6 +74,59 @@ export async function generateLiveMessage(messageType, params, json) {
     }
     return 'Brain freezed, I cannot generate a live message right now.';
 }
+export async function generateLiveMessageAssistant(assistantId, messageType, params, json) {
+    const MAX_RETRY = 2;
+    let retryCount = 0;
+    // Construire le contexte pour le message
+    const context = await contextBuilder[messageType](params);
+    const text = fs.readFileSync(path.join(__dirname, 'openai', `${messageType}.txt`), 'utf8');
+    const message = text.replace(/\${(.*?)}/g, (_, v) => context[v]);
+    while (retryCount <= MAX_RETRY) {
+        try {
+            // Créer un thread avec l'assistant
+            const thread = await openai.beta.threads.create();
+            // Ajouter le message avec le contexte
+            await openai.beta.threads.messages.create(thread.id, {
+                role: 'user',
+                content: message
+            });
+            // Exécuter l'assistant
+            const run = await openai.beta.threads.runs.create(thread.id, {
+                assistant_id: assistantId
+            });
+            // Attendre que l'exécution soit terminée
+            let runStatus = await openai.beta.threads.runs.retrieve(thread.id, run.id);
+            while (runStatus.status === 'in_progress' || runStatus.status === 'queued') {
+                await new Promise(resolve => setTimeout(resolve, 1000));
+                runStatus = await openai.beta.threads.runs.retrieve(thread.id, run.id);
+            }
+            if (runStatus.status === 'failed') {
+                throw new Error('Assistant execution failed');
+            }
+            // Récupérer les messages de réponse
+            const messages = await openai.beta.threads.messages.list(thread.id);
+            const lastMessage = messages.data[0]; // Le premier message est le plus récent
+            if (!lastMessage || !lastMessage.content || lastMessage.content.length === 0) {
+                throw new Error('No content in response');
+            }
+            const content = lastMessage.content[0];
+            if (content.type === 'text') {
+                return removeQuotes(content.text.value);
+            }
+            else {
+                throw new Error('Unexpected content type');
+            }
+        }
+        catch (error) {
+            retryCount++;
+            console.log(error);
+            if (retryCount > MAX_RETRY) {
+                return 'Brain freezed, I cannot generate a live message right now.';
+            }
+        }
+    }
+    return 'Brain freezed, I cannot generate a live message right now.';
+}
 function removeQuotes(str) {
     if (str.startsWith('"') && str.endsWith('"')) {
         return str.substring(1, str.length - 1);

package/dist/modules/edrm-exams/listeners/correct.listener.js

@@ -1,6 +1,6 @@
 import { enduranceListener, enduranceEventTypes, enduranceEmitter } from '@programisto/endurance-core';
 import TestQuestion from '../models/test-question.model.js';
-import { generateLiveMessage } from '../lib/openai.js';
+import { generateLiveMessageAssistant } from '../lib/openai.js';
 import TestResult, { TestState } from '../models/test-result.model.js';
 import CandidateModel from '../models/candidate.model.js';
 import ContactModel from '../models/contact.model.js';
@@ -31,7 +31,7 @@ async function correctTest(options) {
                 continue;
             }
             maxScore += question.maxScore;
-            const scoreResponse = await generateLiveMessage('correctQuestion', {
+            const scoreResponse = await generateLiveMessageAssistant(process.env.OPENAI_ASSISTANT_ID_CORRECT_QUESTION || '', 'correctQuestion', {
                 question: {
                     _id: question._id.toString(),
                     instruction: question.instruction,
@@ -80,7 +80,7 @@ async function correctTest(options) {
                         lastname: contact.lastname,
                         score: result.score,
                         testName: test?.title || '',
-                        testLink: testLink
+                        testLink
                     }
                 });
             }

package/dist/modules/edrm-exams/routes/exams.router.d.ts

@@ -1,6 +1,7 @@
 import { EnduranceRouter } from '@programisto/endurance-core';
 declare class ExamsRouter extends EnduranceRouter {
     constructor();
+    private generateAndSaveQuestion;
     setupRoutes(): void;
 }
 declare const router: ExamsRouter;

package/dist/modules/edrm-exams/routes/exams.router.js

@@ -5,11 +5,52 @@ import TestResult from '../models/test-result.model.js';
 import TestCategory from '../models/test-category.models.js';
 import Candidate from '../models/candidate.model.js';
 import ContactModel from '../models/contact.model.js';
-import { generateLiveMessage } from '../lib/openai.js';
+import { generateLiveMessage, generateLiveMessageAssistant } from '../lib/openai.js';
 class ExamsRouter extends EnduranceRouter {
     constructor() {
         super(EnduranceAuthMiddleware.getInstance());
     }
+    async generateAndSaveQuestion(test, categoryInfo, useAssistant = false) {
+        try {
+            const categoryDoc = await TestCategory.findById(categoryInfo.categoryId);
+            if (!categoryDoc) {
+                console.error('Catégorie non trouvée:', categoryInfo.categoryId);
+                return null;
+            }
+            // Récupérer les questions existantes pour éviter les doublons
+            const otherQuestionsIds = test.questions.map(question => question.questionId);
+            const otherQuestions = await TestQuestion.find({ _id: { $in: otherQuestionsIds } });
+            const questionParams = {
+                job: test.targetJob,
+                seniority: test.seniorityLevel,
+                category: categoryDoc.name,
+                questionType: ['MCQ', 'free question', 'exercice'][Math.floor(Math.random() * 3)],
+                expertiseLevel: categoryInfo.expertiseLevel,
+                otherQuestions: otherQuestions.map(question => question.instruction).join('\n')
+            };
+            let generatedQuestion;
+            if (useAssistant) {
+                generatedQuestion = await generateLiveMessageAssistant(process.env.OPENAI_ASSISTANT_ID_CREATE_QUESTION || '', 'createQuestion', questionParams, true);
+            }
+            else {
+                generatedQuestion = await generateLiveMessage('createQuestion', questionParams, true);
+            }
+            if (generatedQuestion === 'Brain freezed, I cannot generate a live message right now.') {
+                console.error('Échec de génération de question pour la catégorie:', categoryDoc.name);
+                return null;
+            }
+            const question = new TestQuestion(JSON.parse(generatedQuestion));
+            await question.save();
+            // Ajouter la question au test et sauvegarder immédiatement
+            test.questions.push({ questionId: question._id, order: test.questions.length });
+            await test.save();
+            return question;
+        }
+        catch (error) {
+            console.error('Erreur lors de la génération/sauvegarde de la question:', error);
+            return null;
+        }
+    }
     setupRoutes() {
         const authenticatedOptions = {
             requireAuth: false,
@@ -437,7 +478,7 @@ class ExamsRouter extends EnduranceRouter {
                 }
                 const otherQuestionsIds = test.questions.map(question => question.questionId);
                 const otherQuestions = await TestQuestion.find({ _id: { $in: otherQuestionsIds } });
-                const generatedQuestion = await generateLiveMessage('createQuestion', {
+                const generatedQuestion = await generateLiveMessageAssistant(process.env.OPENAI_ASSISTANT_ID_CREATE_QUESTION || '', 'createQuestion', {
                     job: test.targetJob,
                     seniority: test.seniorityLevel,
                     questionType,
@@ -715,7 +756,7 @@ class ExamsRouter extends EnduranceRouter {
                     const question = await TestQuestion.findById(response.questionId);
                     if (!question)
                         continue;
-                    const score = await generateLiveMessage('correctQuestion', {
+                    const score = await generateLiveMessageAssistant(process.env.OPENAI_ASSISTANT_ID_CORRECT_QUESTION || '', 'correctQuestion', {
                         question: {
                             _id: question._id.toString(),
                             instruction: question.instruction,
@@ -819,45 +860,32 @@ class ExamsRouter extends EnduranceRouter {
                 }
                 const generatedQuestions = [];
                 let questionsGenerated = 0;
-                // Mélanger les catégories pour une répartition aléatoire
-                const shuffledCategories = [...categoriesToUse].sort(() => Math.random() - 0.5);
-                for (const categoryInfo of shuffledCategories) {
-                    // Arrêter si on a déjà généré le nombre de questions demandé
-                    if (questionsGenerated >= numberOfQuestions)
-                        break;
-                    const categoryDoc = await TestCategory.findById(categoryInfo.categoryId);
-                    if (!categoryDoc)
-                        continue;
-                    const otherQuestionsIds = test.questions.map(question => question.questionId);
-                    const otherQuestions = await TestQuestion.find({ _id: { $in: otherQuestionsIds } });
-                    // Calculer combien de questions générer pour cette catégorie
-                    const remainingQuestions = numberOfQuestions - questionsGenerated;
-                    const questionsForThisCategory = Math.min(remainingQuestions, Math.ceil(numberOfQuestions / categoriesToUse.length));
-                    for (let i = 0; i < questionsForThisCategory; i++) {
-                        const generatedQuestion = await generateLiveMessage('createQuestion', {
-                            job: test.targetJob,
-                            seniority: test.seniorityLevel,
-                            category: categoryDoc.name,
-                            questionType: ['MCQ', 'free question', 'exercice'][Math.floor(Math.random() * 3)],
-                            expertiseLevel: categoryInfo.expertiseLevel,
-                            otherQuestions: otherQuestions.map(question => question.instruction).join('\n')
-                        }, true);
-                        // Vérifier si la réponse est un JSON valide
-                        if (generatedQuestion === 'Brain freezed, I cannot generate a live message right now.') {
-                            console.error('Échec de génération de question pour la catégorie:', categoryDoc.name);
-                            continue; // Passer à la question suivante
-                        }
-                        try {
-                            const question = new TestQuestion(JSON.parse(generatedQuestion));
-                            await question.save();
+                let attempts = 0;
+                const maxAttempts = numberOfQuestions * 3; // Limite pour éviter les boucles infinies
+                // Si on spécifie une catégorie, on génère toutes les questions pour cette catégorie
+                if (category && category !== 'ALL') {
+                    const categoryInfo = categoriesToUse[0];
+                    while (questionsGenerated < numberOfQuestions && attempts < maxAttempts) {
+                        attempts++;
+                        const question = await this.generateAndSaveQuestion(test, categoryInfo, true);
+                        if (question) {
                             generatedQuestions.push(question);
-                            test.questions.push({ questionId: question._id, order: test.questions.length });
                             questionsGenerated++;
                         }
-                        catch (parseError) {
-                            console.error('Erreur lors du parsing de la question générée:', parseError);
-                            console.error('Réponse reçue:', generatedQuestion);
-                            continue; // Passer à la question suivante
+                    }
+                }
+                else {
+                    // Pour ALL, répartition aléatoire sur toutes les catégories
+                    const shuffledCategories = [...categoriesToUse].sort(() => Math.random() - 0.5);
+                    while (questionsGenerated < numberOfQuestions && attempts < maxAttempts) {
+                        attempts++;
+                        // Sélectionner une catégorie aléatoire
+                        const randomCategoryIndex = Math.floor(Math.random() * shuffledCategories.length);
+                        const categoryInfo = shuffledCategories[randomCategoryIndex];
+                        const question = await this.generateAndSaveQuestion(test, categoryInfo, true);
+                        if (question) {
+                            generatedQuestions.push(question);
+                            questionsGenerated++;
                         }
                     }
                 }
@@ -867,7 +895,6 @@ class ExamsRouter extends EnduranceRouter {
                         message: 'Aucune question n\'a pu être générée. Veuillez réessayer plus tard.'
                     });
                 }
-                await test.save();
                 res.status(200).json({
                     message: `${generatedQuestions.length} question(s) générée(s) avec succès`,
                     questions: generatedQuestions,

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@programisto/edrm-exams",
-  "version": "0.2.12",
+  "version": "0.2.13",
   "publishConfig": {
     "access": "public"
   },