data-primals-engine 1.2.6-rc3 → 1.3.0

package/src/modules/workflow.js

@@ -6,8 +6,8 @@ import crypto from "node:crypto";
 import ivm from 'isolated-vm';
 
 import {Logger} from "../gameObject.js";
-import {deleteData, insertData, patchData, scheduleAlerts, searchData} from "./data/index.js";
-import {emailDefaultConfig, maxExecutionsByStep, maxWorkflowSteps} from "../constants.js";
+import {deleteData, getModel, insertData, patchData, scheduleAlerts, searchData} from "./data/index.js";
+import {emailDefaultConfig, maxExecutionsByStep, maxWorkflowSteps, port} from "../constants.js";
 import {ChatOpenAI} from "@langchain/openai";
 import {ChatGoogleGenerativeAI} from "@langchain/google-genai";
 import {ChatPromptTemplate} from "@langchain/core/prompts";
@@ -16,7 +16,13 @@ import i18n from "../../src/i18n.js";
 import {sendEmail} from "../email.js";
 
 import * as workflowModule from './workflow.js';
-import util from "node:util";
+import {isConditionMet} from "../filter.js";
+import { services } from '../services/index.js';
+import {getEnv} from "./user.js";
+import {getHost} from "../constants.js";
+import {providers} from "./assistant/constants.js";
+import {ChatAnthropic} from "@langchain/anthropic";
+import {getAIProvider} from "./assistant/assistant.js";
 
 let logger = null;
 export async function onInit(defaultEngine) {
@@ -25,6 +31,51 @@ export async function onInit(defaultEngine) {
     await scheduleWorkflowTriggers();
 }
 
+
+
+/**
+ * Déclenche un workflow par son nom et lui passe des données de contexte.
+ * C'est la fonction clé à exposer aux endpoints pour lancer des processus métier.
+ *
+ * @param {string} name - Le nom du workflow à exécuter.
+ * @param {object} data - Les données à injecter dans context.triggerData.
+ * @param {object} user - L'objet utilisateur qui initie l'action.
+ * @returns {Promise<{success: boolean, message?: string, runId?: ObjectId}>}
+ */
+export async function runWorkflowByName(name, data, user) {
+    if (!name) {
+        return { success: false, message: "Workflow name is required." };
+    }
+
+    const dbCollection = await getCollectionForUser(user);
+
+    // 1. Trouver la définition du workflow par son nom
+    const workflowDefinition = await dbCollection.findOne({ _model: 'workflow', name });
+
+    if (!workflowDefinition) {
+        const msg = `Workflow with name "${name}" not found.`;
+        logger.error(`[runWorkflowByName] ${msg}`);
+        return { success: false, message: msg };
+    }
+
+    // 2. Créer le document workflowRun
+    const workflowRunData = {
+        _model: 'workflowRun',
+        _user: user._user || user.username,
+        workflow: workflowDefinition._id,
+        contextData: { triggerData: data }, // Les données passées deviennent le triggerData
+        status: 'pending',
+        startedAt: new Date()
+    };
+
+    const insertResult = await dbCollection.insertOne(workflowRunData);
+    logger.info(`[runWorkflowByName] Created workflowRun ${insertResult.insertedId} for workflow "${name}".`);
+
+    // 3. Lancer le traitement de manière asynchrone
+    await processWorkflowRun(insertResult.insertedId, user);
+
+    return { success: true, runId: insertResult.insertedId };
+}
 /**
  * Exécute une fonction de manière sécurisée en s'assurant qu'une seule instance
  * s'exécute à la fois, grâce à un système de verrouillage distribué basé sur la base de données.
@@ -218,13 +269,23 @@ export async function executeSafeJavascript(actionDef, context, user) {
             return new ivm.ExternalCopy(result.data?.[0] || null).copyInto();
         };
 
-        // 1. Build the sandboxed API
-        await jail.set('_db_create', new ivm.Reference((modelName, dataObject) => insertData(modelName, JSON.parse(dataObject), {}, user, false)));
+        // 1. Build the sandboxed API methods
+        await jail.set('_workflow_run', new ivm.Reference(async (name, contextData) => {
+            const result = await runWorkflowByName(name, JSON.parse(contextData), user);
+            return new ivm.ExternalCopy(result).copyInto();
+        }));
+        await jail.set('_db_create', new ivm.Reference(async (modelName, dataObject) => {
+            const result = await insertData(modelName, JSON.parse(dataObject), {}, user, false);
+            if (result.success && result.insertedIds) {
+                result.insertedIds = result.insertedIds.map(id => id.toString());
+            }
+            return new ivm.ExternalCopy(result).copyInto();
+        }));
         await jail.set('_db_find', new ivm.Reference(find));
         await jail.set('_db_findOne', new ivm.Reference(findOne));
 
-        await jail.set('_db_update', new ivm.Reference((modelName, filter, updateObject) => patchData(modelName, JSON.parse(filter), JSON.parse(updateObject), {}, user, false)));
-        await jail.set('_db_delete', new ivm.Reference((modelName, filter) => deleteData(modelName, JSON.parse(filter), user, false)));
+        await jail.set('_db_update', new ivm.Reference(async (modelName, filter, updateObject) => patchData(modelName, JSON.parse(filter), JSON.parse(updateObject), {}, user, false)));
+        await jail.set('_db_delete', new ivm.Reference(async (modelName, filter) => deleteData(modelName, JSON.parse(filter), user, false)));
 
         const createLoggerMethod = (level) => {
             return (...args) => {
@@ -247,12 +308,8 @@ export async function executeSafeJavascript(actionDef, context, user) {
             return new ivm.ExternalCopy(result.data?.[0]?.value || null).copyInto();
         }));
         await jail.set('_env_get_all', new ivm.Reference(async () => {
-            const result = await searchData({ model: 'env' }, user);
-            const envObject = result.data.reduce((acc, v) => {
-                acc[v.name] = v.value;
-                return acc;
-            }, {});
-            return new ivm.ExternalCopy(envObject).copyInto();
+            const result = await getEnv(user);
+            return new ivm.ExternalCopy(result).copyInto();
         }));
 
         // Contexte sécurisé
@@ -274,6 +331,10 @@ export async function executeSafeJavascript(actionDef, context, user) {
                 update: (...args) => _db_update.applySyncPromise(null, normalizeArgs(args)),
                 delete: (...args) => _db_delete.applySyncPromise(null, normalizeArgs(args))
             };
+            
+            const workflow = {
+                run: (...args) => _workflow_run.applySyncPromise(null, normalizeArgs(args))
+            };
 
             const logger = {
                 info: _log_info,
@@ -324,7 +385,7 @@ export async function executeSafeJavascript(actionDef, context, user) {
 }
 
 /**
- * Handles the 'Webhook' workflow action.
+ * Handles the 'HttpRequest' workflow action.
  * Sends an HTTP request to a specified URL with substituted data using native fetch.
  *
  * @param {object} actionDef - The definition of the 'Webhook' action.
@@ -333,17 +394,17 @@ export async function executeSafeJavascript(actionDef, context, user) {
  * @param {object} dbCollection - The MongoDB collection (moins pertinent ici, mais gardé pour la cohérence).
  * @returns {Promise<{success: boolean, message?: string, responseStatus?: number, responseBody?: any}>} - Result of the action.
  */
-async function handleWebhookAction(actionDef, contextData, user, dbCollection) {
+async function handleHttpRequestAction(actionDef, contextData, user, dbCollection) {
     const { name: actionName, _id: actionId, url, method = 'POST', headers: headersTemplate, body: bodyTemplate } = actionDef;
 
     // 1. Basic Validation
     if (!url) {
-        const msg = `[handleWebhookAction] Action ${actionName} (${actionId}): Missing 'url'.`;
+        const msg = `[handleHttpRequestAction] Action ${actionName} (${actionId}): Missing 'url'.`;
         logger.error(msg);
         return { success: false, message: msg };
     }
 
-    logger.info(`[handleWebhookAction] Action ${actionName} (${actionId}): Executing webhook. Method: ${method}`);
+    logger.info(`[handleHttpRequestAction] Action ${actionName} (${actionId}): Executing webhook. Method: ${method}`);
 
     try {
         // 2. Substitute Variables
@@ -360,7 +421,7 @@ async function handleWebhookAction(actionDef, contextData, user, dbCollection) {
             } else if (typeof headersTemplate === 'object') {
                 headersObject = await substituteVariables(headersTemplate, contextData, user);
             } else {
-                logger.warn(`[handleWebhookAction] Action ${actionName} (${actionId}): 'headers' has an invalid type (${typeof headersTemplate}). Ignoring.`);
+                logger.warn(`[handleHttpRequestAction] Action ${actionName} (${actionId}): 'headers' has an invalid type (${typeof headersTemplate}). Ignoring.`);
             }
         }
 
@@ -371,7 +432,7 @@ async function handleWebhookAction(actionDef, contextData, user, dbCollection) {
             } else if (typeof bodyTemplate === 'object') {
                 bodyObject = await substituteVariables(bodyTemplate, contextData, user);
             } else {
-                logger.warn(`[handleWebhookAction] Action ${actionName} (${actionId}): 'body' has an invalid type (${typeof bodyTemplate}). Ignoring.`);
+                logger.warn(`[handleHttpRequestAction] Action ${actionName} (${actionId}): 'body' has an invalid type (${typeof bodyTemplate}). Ignoring.`);
             }
         }
 
@@ -383,7 +444,7 @@ async function handleWebhookAction(actionDef, contextData, user, dbCollection) {
                     throw new Error("Parsed headers is not a valid object.");
                 }
             } catch (parseError) {
-                logger.error(`[handleWebhookAction] Action ${actionName} (${actionId}): Failed to parse substituted 'headers' JSON. Error: ${parseError.message}. Using default headers. Substituted string: ${substitutedHeadersString}`);
+                logger.error(`[handleHttpRequestAction] Action ${actionName} (${actionId}): Failed to parse substituted 'headers' JSON. Error: ${parseError.message}. Using default headers. Substituted string: ${substitutedHeadersString}`);
                 headersObject = { 'Content-Type': 'application/json' }; // Fallback
             }
         }
@@ -425,7 +486,7 @@ async function handleWebhookAction(actionDef, contextData, user, dbCollection) {
         }
 
         // 5. Execute Fetch Request using native fetch
-        logger.info(`[handleWebhookAction] Action ${actionName} (${actionId}): Calling URL: ${substitutedUrl}`);
+        logger.info(`[handleHttpRequestAction] Action ${actionName} (${actionId}): Calling URL: ${substitutedUrl}`);
         const response = await fetch(substitutedUrl, fetchOptions); // Utilisation de fetch natif
 
         // 6. Process Response
@@ -438,7 +499,7 @@ async function handleWebhookAction(actionDef, contextData, user, dbCollection) {
                 responseBody = await response.text();
             }
         } catch (responseParseError) {
-            logger.error(`[handleWebhookAction] Action ${actionName} (${actionId}): Failed to parse response body. Error: ${responseParseError.message}`);
+            logger.error(`[handleHttpRequestAction] Action ${actionName} (${actionId}): Failed to parse response body. Error: ${responseParseError.message}`);
             // Try reading as text again in case of error during json parsing
             try {
                 responseBody = await response.text();
@@ -447,7 +508,7 @@ async function handleWebhookAction(actionDef, contextData, user, dbCollection) {
             }
         }
 
-        logger.info(`[handleWebhookAction] Action ${actionName} (${actionId}): Received response. Status: ${response.status}`);
+        logger.info(`[handleHttpRequestAction] Action ${actionName} (${actionId}): Received response. Status: ${response.status}`);
 
         // 7. Return Result
         if (response.ok) { // Status code 200-299
@@ -455,13 +516,13 @@ async function handleWebhookAction(actionDef, contextData, user, dbCollection) {
                 success: true,
                 message: `Webhook executed successfully. Status: ${response.status}`,
                 responseStatus: response.status,
-                responseBody: responseBody
-                // updatedContext: { webhookResponse: responseBody } // Optionnel: Ajouter la réponse au contexte
+                responseBody: responseBody,
+                updatedContext: { httpResponse: responseBody }
             };
         } else {
             // Handle non-successful responses (4xx, 5xx)
             const errorMsg = `Webhook execution failed. Status: ${response.status}. Response: ${typeof responseBody === 'string' ? responseBody : JSON.stringify(responseBody)}`;
-            logger.error(`[handleWebhookAction] Action ${actionName} (${actionId}): ${errorMsg}`);
+            logger.error(`[handleHttpRequestAction] Action ${actionName} (${actionId}): ${errorMsg}`);
             return {
                 success: false,
                 message: errorMsg,
@@ -472,7 +533,7 @@ async function handleWebhookAction(actionDef, contextData, user, dbCollection) {
 
     } catch (error) {
         // Catch network errors or other unexpected errors during the process
-        const msg = `[handleWebhookAction] Action ${actionName} (${actionId}): Unexpected error during webhook execution. Error: ${error.message}`;
+        const msg = `[handleHttpRequestAction] Action ${actionName} (${actionId}): Unexpected error during webhook execution. Error: ${error.message}`;
         logger.error(msg, error.stack);
         return { success: false, message: msg };
     }
@@ -778,6 +839,52 @@ async function handleDeleteDataAction(actionDef, contextData, user, dbCollection
     }
 }
 
+/**
+ * Handles the 'ExecuteServiceFunction' workflow action.
+ * Acts as a secure bridge between the workflow engine and native service modules.
+ *
+ * @param {object} actionDef - The action definition.
+ * @param {object} contextData - The current workflow context.
+ * @param {object} user - The user object.
+ * @returns {Promise<{success: boolean, message?: string, updatedContext?: object}>}
+ */
+async function handleExecuteServiceFunction(actionDef, contextData, user) {
+    const { serviceName, functionName, args: argsTemplate } = actionDef;
+
+    if (!serviceName || !functionName) {
+        return { success: false, message: "Action requires 'serviceName' and 'functionName'." };
+    }
+
+    const service = services[serviceName];
+    if (!service) {
+        return { success: false, message: `Service '${serviceName}' not found in the registry.` };
+    }
+
+    const func = service[functionName];
+    if (typeof func !== 'function') {
+        return { success: false, message: `Function '${functionName}' not found in service '${serviceName}'.` };
+    }
+
+    try {
+        // Substitute variables in the arguments array
+        const substitutedArgs = Array.isArray(argsTemplate)
+            ? await substituteVariables(argsTemplate, contextData, user)
+            : [];
+
+        logger.info(`[Service Call] Calling ${serviceName}.${functionName} with ${substitutedArgs.length} argument(s).`);
+        const result = await func(...substitutedArgs, user);
+
+        return {
+            success: true,
+            updatedContext: { serviceResult: result } // Store result in context
+        };
+    } catch (error) {
+        const msg = `Error executing ${serviceName}.${functionName}: ${error.message}`;
+        logger.error(`[Service Call] ${msg}`, error.stack);
+        return { success: false, message: msg };
+    }
+}
+
 // Dans workflow.js
 export async function executeStepAction(actionDef, contextData, user, dbCollection) {
     logger.info(`[executeStepAction] Executing action type ${actionDef.type} for action ${actionDef._id} (${actionDef.name})`);
@@ -789,8 +896,8 @@ export async function executeStepAction(actionDef, contextData, user, dbCollecti
             logger.info(`[Workflow Log Action] Action: ${actionDef.name}. Contexte:`, contextData);
             result = { success: true, message: 'Log action executed successfully.' }; // <--- CORRECTION
             break;
-        case 'Webhook':
-            result = await handleWebhookAction(actionDef, contextData, user, dbCollection);
+        case 'HttpRequest':
+            result = await handleHttpRequestAction(actionDef, contextData, user, dbCollection);
             break;
         case 'CreateData':
             result = await handleCreateDataAction(actionDef, contextData, user, dbCollection);
@@ -813,6 +920,9 @@ export async function executeStepAction(actionDef, contextData, user, dbCollecti
         case 'ExecuteScript':
             result = await executeSafeJavascript(actionDef, contextData, user);
             break;
+        case 'ExecuteServiceFunction':
+            result = await handleExecuteServiceFunction(actionDef, contextData, user);
+            break;
         default:
             logger.error(`[executeStepAction] Unknown action type: ${actionDef.type}`);
             return { success: false, message: `Unknown action type: ${actionDef.type}` };
@@ -1027,6 +1137,8 @@ export async function substituteVariables(template, contextData, user) {
             return new Date().toISOString();
         } else if (path === 'randomUUID') {
             return crypto.randomUUID();
+        } else if( path === "baseUrl" ){
+            return process.env.NODE_ENV === 'production' ? 'https://'+getHost()+'/' : 'http://localhost:/'+port;
         }
 
         // Détecter si le chemin est complexe (contient plus d'un point)
@@ -1099,102 +1211,96 @@ export async function substituteVariables(template, contextData, user) {
 }
 
 /**
- * Déclenche l'instanciation d'un workflowRun si les conditions sont remplies.
- * Vérifie le type d'événement et le filtre de données du déclencheur.
- * Crée un document 'workflowRun' pour une exécution asynchrone ultérieure.
+ * Triggers the instantiation of a workflowRun if conditions are met.
+ * Checks the event type and trigger's data filter.
+ * Creates a 'workflowRun' document for later asynchronous execution.
  *
- * @param {object} triggerData - La donnée qui a déclenché le(s) workflow(s) (peut être un document de données ou un document de modèle).
- * @param {object} user - L'utilisateur associé.
- * @param {'DataAdded' | 'DataEdited' | 'DataDeleted' | 'ModelAdded' | 'ModelEdited' | 'ModelDeleted'} eventType - Le type d'événement.
+ * @param {object} triggerData - The data that triggered the workflow(s) (can be a data document or model document).
+ * @param {object} user - The associated user.
+ * @param {'DataAdded' | 'DataEdited' | 'DataDeleted' | 'ModelAdded' | 'ModelEdited' | 'ModelDeleted'} eventType - The event type.
  */
-export async function triggerWorkflows(triggerData, user, eventType)  {
-    const dataId = eventType.startsWith('Model') ? null : triggerData._id;
-
+export async function triggerWorkflows(triggerData, user, eventType) {
     const trigger = async (triggerData, user, eventType) => {
-
         // Basic validation
         if (!triggerData || !user || !eventType) {
-            console.warn("triggerWorkflows: Appel invalide - triggerData, user, ou eventType manquant.", { hasTriggerData: !!triggerData, hasUser: !!user, eventType });
+            console.warn("triggerWorkflows: Invalid call - missing triggerData, user, or eventType.", {
+                hasTriggerData: !!triggerData,
+                hasUser: !!user,
+                eventType
+            });
             return;
         }
-        // Determine the model name and data ID based on the event type
+
+        // Determine model name and data ID based on event type
         const targetModelName = eventType.startsWith('Model') ? triggerData.name : triggerData._model;
-        const dataId = eventType.startsWith('Model') ? null : triggerData._id; // ID only relevant for data events
+        const dataId = eventType.startsWith('Model') ? null : triggerData._id;
 
         if (!targetModelName) {
-            console.warn(`triggerWorkflows: Impossible de déterminer le nom du modèle pour l'événement ${eventType}.`, triggerData);
+            console.warn(`triggerWorkflows: Cannot determine model name for event ${eventType}.`, triggerData);
             return;
         }
 
         console.log(`[Workflow Trigger] Event: ${eventType}, Model: ${targetModelName}${dataId ? `, Data ID: ${dataId}` : ''}, User: ${user.username}`);
 
         try {
-            const dbCollection = await getCollectionForUser(user); // Collection des données utilisateur
+            const dbCollection = await getCollectionForUser(user);
 
-            // 1. Trouver les WorkflowTriggers pertinents
+            // 1. Find relevant WorkflowTriggers
             const workflowTriggers = await dbCollection.find({
                 _model: 'workflowTrigger',
                 targetModel: targetModelName,
                 isActive: true,
-                onEvent: eventType, // Assurez-vous que le champ s'appelle bien 'onEvent' dans votre modèle
+                onEvent: eventType,
                 $or: [{_user: user._user}, {_user: user.username}]
             }).toArray();
 
             if (workflowTriggers.length === 0) {
-                console.debug(`[Workflow Trigger] Aucun déclencheur actif trouvé pour ${targetModelName} / ${eventType}.`);
+                console.debug(`[Workflow Trigger] No active triggers found for ${targetModelName}/${eventType}.`);
                 return;
             }
-            console.debug(`[Workflow Trigger] Trouvé ${workflowTriggers.length} déclencheur(s) potentiel(s) pour ${targetModelName} / ${eventType}.`);
+            console.debug(`[Workflow Trigger] Found ${workflowTriggers.length} potential trigger(s) for ${targetModelName}/${eventType}.`);
 
-            // 2. Pour chaque déclencheur trouvé, vérifier le filtre de données et créer un workflowRun
+            // 2. For each trigger, verify data filter and create workflowRun
             for (const trigger of workflowTriggers) {
-                console.debug(`[Workflow Trigger] Vérification du déclencheur ${trigger._id} (${trigger.name || 'Sans nom'})...`);
+                console.debug(`[Workflow Trigger] Evaluating trigger ${trigger._id} (${trigger.name || 'Unnamed'})...`);
 
-                // 3. Vérifier le filtre de données (dataFilter) si applicable
-                if (eventType.startsWith('Data') && trigger.dataFilter && dataId) {
+                // 3. Check data filter if applicable
+                if (eventType.startsWith('Data') && trigger.dataFilter) {
                     let dataFilterCondition = null;
                     try {
-                        // dataFilter est supposé être stocké comme un objet (ou une string JSON valide)
+                        // dataFilter is expected to be stored as an object or valid JSON string
                         if (typeof trigger.dataFilter === 'string') {
                             dataFilterCondition = JSON.parse(trigger.dataFilter);
                         } else if (typeof trigger.dataFilter === 'object' && trigger.dataFilter !== null) {
                             dataFilterCondition = trigger.dataFilter;
                         }
                     } catch (parseError) {
-                        console.error(`[Workflow Trigger] Erreur de parsing JSON pour dataFilter du trigger ${trigger._id}:`, parseError);
-                        continue; // Passer au trigger suivant si le filtre est invalide
+                        console.error(`[Workflow Trigger] JSON parsing error for dataFilter in trigger ${trigger._id}:`, parseError);
+                        continue; // Skip to next trigger if filter is invalid
                     }
 
                     try {
-                        const finalFilter = {
-                            '$and': [
-                                {"_id": { "$toObjectId": triggerData._id.toString() }},
-                                dataFilterCondition                      // Applique la condition du trigger
-                            ]
-                        };
-
-
-                        console.debug(`[Workflow Trigger] Vérification dataFilter pour trigger ${trigger._id} avec filtre combiné:`, JSON.stringify(finalFilter));
-                        const match = await searchData({ model: triggerData._model, filter: finalFilter, limit: 1 }, user);
-                        if (!match.count) {
-                            console.debug(`[Workflow Trigger] Trigger ${trigger._id}: dataFilter non satisfait par la donnée ${dataId}. WorkflowRun non créé.`);
-                            continue; // Passer au trigger suivant
-                        } else {
-                            console.debug(`[Workflow Trigger] Trigger ${trigger._id}: dataFilter satisfait par la donnée ${dataId}.`);
+                        const mod = await getModel(targetModelName, user);
+                        const filterMatches = isConditionMet(mod, dataFilterCondition, triggerData, [], user);
+
+                        if (!filterMatches) {
+                            console.debug(`[Workflow Trigger] Trigger ${trigger._id}: dataFilter not satisfied by data. Skipping workflowRun creation.`);
+                            continue;
                         }
+                        console.debug(`[Workflow Trigger] Trigger ${trigger._id}: dataFilter satisfied.`);
                     } catch (filterError) {
-                        console.error(`[Workflow Trigger] Erreur lors de la conversion ou de l'exécution du dataFilter pour le trigger ${trigger._id}:`, filterError);
-                        continue; // Ne pas créer en cas d'erreur de filtre
+                        console.error(`[Workflow Trigger] Error evaluating dataFilter for trigger ${trigger._id}:`, filterError);
+                        continue;
                     }
-                } // Fin de la vérification dataFilter
+                }
 
-                // 4. Si les filtres (eventType, dataFilter) sont passés, créer l'instance workflowRun
+                // 4. If filters passed, create workflowRun instance
                 if (!trigger.workflow || !isObjectId(trigger.workflow)) {
-                    console.warn(`[Workflow Trigger] Trigger ${trigger._id} n'a pas de workflow valide associé.`);
+                    console.warn(`[Workflow Trigger] Trigger ${trigger._id} has no valid associated workflow.`);
                     continue;
                 }
 
-                // a. Récupérer la définition du Workflow (juste pour vérifier qu'il existe)
+                // a. Verify workflow exists
                 const workflowDefinition = await dbCollection.findOne({
                     _id: new ObjectId(trigger.workflow),
                     _model: 'workflow',
@@ -1202,21 +1308,20 @@ export async function triggerWorkflows(triggerData, user, eventType)  {
                 });
 
                 if (!workflowDefinition) {
-                    console.warn(`[Workflow Trigger] Workflow ${trigger.workflow} associé au trigger ${trigger._id} non trouvé.`);
+                    console.warn(`[Workflow Trigger] Workflow ${trigger.workflow} associated with trigger ${trigger._id} not found.`);
                     continue;
                 }
 
-                // b. Créer le document workflowRun
+                // b. Create workflowRun document
                 const workflowRunData = {
                     _model: 'workflowRun',
                     _user: user._user || user.username,
-                    workflow: workflowDefinition._id, // Référence au workflow parent
-                    contextData: {                        // Contexte initial
-                        triggerDataModel: targetModelName,// Modèle de la donnée déclencheuse
-                        triggerData: triggerData      // Inclure la donnée déclencheuse
-                        // Vous pourriez ajouter d'autres infos ici si nécessaire
+                    workflow: workflowDefinition._id,
+                    contextData: {
+                        triggerDataModel: targetModelName,
+                        triggerData: triggerData
                     },
-                    status: 'pending',                // Statut initial
+                    status: 'pending',
                     owner: null,
                     startedAt: new Date()
                 };
@@ -1224,30 +1329,25 @@ export async function triggerWorkflows(triggerData, user, eventType)  {
                 try {
                     const insertResult = await dbCollection.insertOne(workflowRunData);
                     if (insertResult.insertedId) {
-                        console.info(`[Workflow Trigger] WorkflowRun ${insertResult.insertedId} créé pour le workflow ${workflowDefinition.name} (ID: ${workflowDefinition._id}) déclenché par ${trigger._id}.`);
-
+                        console.info(`[Workflow Trigger] Created workflowRun ${insertResult.insertedId} for workflow ${workflowDefinition.name} (ID: ${workflowDefinition._id}) triggered by ${trigger._id}.`);
                         await workflowModule.processWorkflowRun(insertResult.insertedId, user);
                     } else {
-                        console.error(`[Workflow Trigger] Échec de la création du WorkflowRun pour le workflow ${workflowDefinition._id} (Trigger: ${trigger._id}).`);
+                        console.error(`[Workflow Trigger] Failed to create workflowRun for workflow ${workflowDefinition._id} (Trigger: ${trigger._id}).`);
                     }
                 } catch (insertError) {
-                    console.error(`[Workflow Trigger] Erreur lors de l'insertion du WorkflowRun pour le workflow ${workflowDefinition._id} (Trigger: ${trigger._id}):`, insertError);
+                    console.error(`[Workflow Trigger] Error creating workflowRun for workflow ${workflowDefinition._id} (Trigger: ${trigger._id}):`, insertError);
                 }
-
-            } // Fin de la boucle des triggers
-
+            }
         } catch (error) {
-            console.error(`[Workflow Trigger] Erreur générale dans triggerWorkflows pour ${targetModelName}${dataId ? ` ID: ${dataId}` : ''} (Event: ${eventType}):`, error);
+            console.error(`[Workflow Trigger] General error in triggerWorkflows for ${targetModelName}${dataId ? ` ID: ${dataId}` : ''} (Event: ${eventType}):`, error);
         }
     }
 
     return new Promise((resolve) => setTimeout(async () => {
         await trigger(triggerData, user, eventType);
         resolve();
-    }, 0)
-    );
+    }, 0));
 }
-
 /**
  * Processes a workflowRun instance step-by-step.
  * Fetches the run, evaluates conditions, executes actions, and transitions
@@ -1483,12 +1583,7 @@ async function executeGenerateAIContentAction(action, context, user) {
     // 1. Retrieve the API key (User Environment > Machine Environment)
     let apiKey;
 
-    const providers = {
-        "OpenAI" : "OPENAI_API_KEY",
-        "Google": "GOOGLE_API_KEY",
-        "DeepSeek": "DEEPSEEK_API_KEY"
-    }
-    const envKeyName = providers[aiProvider];
+    const envKeyName = providers[aiProvider].key;
     if( !envKeyName ) {
         return {success: false, message: i18n.t('aiContent.env', `API key for provider ${aiProvider} (${envKeyName}) not found in user environment.`)};
     }
@@ -1512,22 +1607,8 @@ async function executeGenerateAIContentAction(action, context, user) {
     }
 
     // 2. Initialize the LLM client with LangChain
-    let llm;
-    try {
-        switch (aiProvider) {
-        case 'OpenAI':
-            llm = new ChatOpenAI({ apiKey, model: aiModel, temperature: 0.7 });
-            break;
-        case 'Google':
-            llm = new ChatGoogleGenerativeAI({ apiKey, model: aiModel, temperature: 0.7 });
-            break;
-        case 'DeepSeek':
-            llm = new ChatDeepSeek({ apiKey, model: aiModel, temperature: 0.7 });
-            break;
-        default:
-            throw new Error(`Unsupported AI provider: ${aiProvider}`);
-        }
-    } catch (initError) {
+    let llm = getAIProvider(aiProvider, aiModel, apiKey);
+    if( !llm ) {
         const message = `Failed to initialize AI client for ${aiProvider}: ${initError.message}`;
         logger.error(`[AI Action] ${message}`);
         return { success: false, message };