@memberjunction/ai-prompts 2.44.0 → 2.45.0

package/dist/ParallelExecutionCoordinator.js

@@ -1,29 +1,151 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ParallelExecutionCoordinator = void 0;
 const core_1 = require("@memberjunction/core");
 const global_1 = require("@memberjunction/global");
 const ai_1 = require("@memberjunction/ai");
+const aiengine_1 = require("@memberjunction/aiengine");
+class ParallelProgressTracker {
+    constructor(totalTasks, totalGroups, progressCallbacks) {
+        this.completedTasks = 0;
+        this.successfulTasks = 0;
+        this.failedTasks = 0;
+        this.cancelledTasks = 0;
+        this.currentGroup = 0;
+        this.activeTasks = [];
+        this.totalTokenUsage = {};
+        this.totalTasks = totalTasks;
+        this.totalGroups = totalGroups;
+        this.startTime = new Date();
+        this.progressCallbacks = progressCallbacks;
+    }
+    updateProgress(currentGroup) {
+        this.currentGroup = currentGroup;
+        this.sendProgressUpdate();
+    }
+    addActiveTask(taskId) {
+        if (!this.activeTasks.includes(taskId)) {
+            this.activeTasks.push(taskId);
+        }
+    }
+    removeActiveTask(taskId) {
+        const index = this.activeTasks.indexOf(taskId);
+        if (index > -1) {
+            this.activeTasks.splice(index, 1);
+        }
+    }
+    taskCompleted(result) {
+        this.completedTasks++;
+        this.removeActiveTask(result.task.taskId);
+        if (result.success) {
+            this.successfulTasks++;
+            if (result.tokensUsed) {
+                this.totalTokenUsage.totalTokens = (this.totalTokenUsage.totalTokens || 0) + result.tokensUsed;
+            }
+        }
+        else if (result.cancelled) {
+            this.cancelledTasks++;
+        }
+        else {
+            this.failedTasks++;
+        }
+        if (this.progressCallbacks?.getStreamingConfig()?.enabled) {
+            const config = this.progressCallbacks.getStreamingConfig();
+            if (config.callbacks?.OnTaskComplete) {
+                config.callbacks.OnTaskComplete(result, this.getCurrentProgress());
+            }
+        }
+        this.sendProgressUpdate();
+    }
+    getCurrentProgress() {
+        return {
+            completedTasks: this.completedTasks,
+            totalTasks: this.totalTasks,
+            successfulTasks: this.successfulTasks,
+            failedTasks: this.failedTasks,
+            cancelledTasks: this.cancelledTasks,
+            currentGroup: this.currentGroup,
+            totalGroups: this.totalGroups,
+            totalTokenUsage: this.totalTokenUsage,
+            totalElapsedTimeMS: new Date().getTime() - this.startTime.getTime(),
+            activeTasks: [...this.activeTasks],
+        };
+    }
+    sendProgressUpdate() {
+        if (this.progressCallbacks?.getStreamingConfig()?.enabled) {
+            const config = this.progressCallbacks.getStreamingConfig();
+            if (config.callbacks?.OnParallelProgress) {
+                config.callbacks.OnParallelProgress(this.getCurrentProgress());
+            }
+        }
+    }
+}
 class ParallelExecutionCoordinator {
     constructor() {
+        this._metadata = new core_1.Metadata();
         this._defaultConfig = {
             maxConcurrentExecutions: 5,
             taskTimeoutMS: 30000,
             failFast: false,
             collectPartialResults: true,
             maxRetries: 3,
-            retryDelayMS: 1000
+            retryDelayMS: 1000,
         };
     }
-    async executeTasksInParallel(tasks, config) {
+    async executeTasksInParallel(tasks, config, parentPromptRunId, cancellationToken, progressCallbacks) {
         const startTime = new Date();
         const executionConfig = { ...this._defaultConfig, ...config };
+        if (cancellationToken?.aborted) {
+            (0, core_1.LogStatus)('Parallel execution cancelled before starting');
+            return {
+                success: false,
+                taskResults: [],
+                groupResults: new Map(),
+                totalExecutionTimeMS: 0,
+                successCount: 0,
+                failureCount: 0,
+                cancelledCount: tasks.length,
+                totalTokensUsed: 0,
+                errors: ['Execution was cancelled before starting'],
+                startTime,
+                endTime: new Date(),
+            };
+        }
         (0, core_1.LogStatus)(`Starting parallel execution of ${tasks.length} tasks with config: ${JSON.stringify(executionConfig)}`);
         try {
+            if (cancellationToken) {
+                tasks.forEach((task) => {
+                    task.cancellationToken = cancellationToken;
+                });
+            }
             const executionGroups = this.groupTasksByExecutionGroup(tasks);
-            const allResults = await this.executeGroupsSequentially(executionGroups, executionConfig);
+            const progressTracker = new ParallelProgressTracker(tasks.length, executionGroups.length, progressCallbacks);
+            const allResults = await this.executeGroupsSequentially(executionGroups, executionConfig, parentPromptRunId, cancellationToken, progressTracker);
             const result = this.aggregateResults(allResults, startTime, new Date());
-            (0, core_1.LogStatus)(`Parallel execution completed: ${result.successCount}/${tasks.length} tasks successful`);
+            (0, core_1.LogStatus)(`Parallel execution completed: ${result.successCount}/${tasks.length} tasks successful, ${result.failureCount} failed, ${result.cancelledCount} cancelled`);
             return result;
         }
         catch (error) {
@@ -35,14 +157,15 @@ class ParallelExecutionCoordinator {
                 totalExecutionTimeMS: new Date().getTime() - startTime.getTime(),
                 successCount: 0,
                 failureCount: tasks.length,
+                cancelledCount: 0,
                 totalTokensUsed: 0,
                 errors: [error.message],
                 startTime,
-                endTime: new Date()
+                endTime: new Date(),
             };
         }
     }
-    async selectBestResult(results, config) {
+    async selectBestResult(results, config, parentPromptRunId, cancellationToken) {
         if (results.length === 0) {
             return null;
         }
@@ -56,7 +179,7 @@ class ParallelExecutionCoordinator {
             case 'Random':
                 return this.selectRandomResult(results);
             case 'PromptSelector':
-                return await this.selectResultWithPrompt(results, config.selectorPromptId);
+                return await this.selectResultWithPrompt(results, config.selectorPromptId, parentPromptRunId, cancellationToken);
             case 'Consensus':
                 return this.selectConsensusResult(results);
             default:
@@ -78,60 +201,109 @@ class ParallelExecutionCoordinator {
             groupTasks.sort((a, b) => b.priority - a.priority);
             groups.push({
                 groupNumber,
-                tasks: groupTasks
+                tasks: groupTasks,
             });
         }
         groups.sort((a, b) => a.groupNumber - b.groupNumber);
         (0, core_1.LogStatus)(`Grouped ${tasks.length} tasks into ${groups.length} execution groups`);
         return groups;
     }
-    async executeGroupsSequentially(groups, config) {
+    async executeGroupsSequentially(groups, config, parentPromptRunId, cancellationToken, progressTracker) {
         const allResults = [];
         for (const group of groups) {
+            if (cancellationToken?.aborted) {
+                (0, core_1.LogStatus)(`Group execution cancelled at group ${group.groupNumber}`);
+                const cancelledResults = group.tasks.map((task) => ({
+                    task,
+                    success: false,
+                    cancelled: true,
+                    errorMessage: 'Task cancelled',
+                    executionTimeMS: 0,
+                    startTime: new Date(),
+                    endTime: new Date(),
+                }));
+                allResults.push(...cancelledResults);
+                break;
+            }
             (0, core_1.LogStatus)(`Executing group ${group.groupNumber} with ${group.tasks.length} tasks`);
-            const groupResults = await this.executeGroupInParallel(group, config);
+            progressTracker?.updateProgress(group.groupNumber);
+            const groupResults = await this.executeGroupInParallel(group, config, parentPromptRunId, cancellationToken, progressTracker);
             allResults.push(...groupResults);
-            if (config.failFast && groupResults.some(r => !r.success)) {
-                const failedTasks = groupResults.filter(r => !r.success);
+            if (config.failFast && groupResults.some((r) => !r.success)) {
+                const failedTasks = groupResults.filter((r) => !r.success);
                 (0, core_1.LogError)(`Failing fast due to ${failedTasks.length} failed tasks in group ${group.groupNumber}`);
                 break;
             }
         }
         return allResults;
     }
-    async executeGroupInParallel(group, config) {
+    async executeGroupInParallel(group, config, parentPromptRunId, cancellationToken, progressTracker) {
         const maxConcurrent = Math.min(config.maxConcurrentExecutions, group.tasks.length);
         const results = [];
         const executing = [];
         let taskIndex = 0;
+        let executionOrder = 0;
         while (taskIndex < group.tasks.length || executing.length > 0) {
+            if (cancellationToken?.aborted) {
+                (0, core_1.LogStatus)(`Task execution cancelled in group ${group.groupNumber}`);
+                while (taskIndex < group.tasks.length) {
+                    const task = group.tasks[taskIndex++];
+                    results.push({
+                        task,
+                        success: false,
+                        cancelled: true,
+                        errorMessage: 'Task cancelled',
+                        executionTimeMS: 0,
+                        startTime: new Date(),
+                        endTime: new Date(),
+                    });
+                }
+                break;
+            }
             while (executing.length < maxConcurrent && taskIndex < group.tasks.length) {
                 const task = group.tasks[taskIndex++];
-                const execution = this.executeTask(task, config);
+                progressTracker?.addActiveTask(task.taskId);
+                const execution = this.executeTask(task, config, parentPromptRunId, executionOrder++);
                 executing.push(execution);
             }
             if (executing.length > 0) {
                 const result = await Promise.race(executing);
                 results.push(result);
-                const completedIndex = executing.findIndex(p => p === Promise.resolve(result));
+                progressTracker?.taskCompleted(result);
+                const completedIndex = executing.findIndex((p) => p === Promise.resolve(result));
                 if (completedIndex !== -1) {
                     executing.splice(completedIndex, 1);
                 }
             }
         }
-        (0, core_1.LogStatus)(`Group ${group.groupNumber} completed: ${results.filter(r => r.success).length}/${results.length} successful`);
+        const successfulResults = results.filter((r) => r.success);
+        const cancelledResults = results.filter((r) => r.cancelled);
+        (0, core_1.LogStatus)(`Group ${group.groupNumber} completed: ${successfulResults.length}/${results.length} successful, ${cancelledResults.length} cancelled`);
         return results;
     }
-    async executeTask(task, config) {
+    async executeTask(task, config, parentPromptRunId, executionOrder) {
         const startTime = new Date();
         let lastError = null;
         for (let attempt = 0; attempt <= config.maxRetries; attempt++) {
             try {
+                if (task.cancellationToken?.aborted) {
+                    const endTime = new Date();
+                    (0, core_1.LogStatus)(`Task ${task.taskId} cancelled before attempt ${attempt + 1}`);
+                    return {
+                        task,
+                        success: false,
+                        cancelled: true,
+                        errorMessage: 'Task cancelled',
+                        executionTimeMS: endTime.getTime() - startTime.getTime(),
+                        startTime,
+                        endTime,
+                    };
+                }
                 if (attempt > 0) {
                     await this.delay(config.retryDelayMS * attempt);
                     (0, core_1.LogStatus)(`Retrying task ${task.taskId}, attempt ${attempt + 1}/${config.maxRetries + 1}`);
                 }
-                const result = await this.executeSingleTask(task, config.taskTimeoutMS);
+                const result = await this.executeSingleTask(task, config.taskTimeoutMS, parentPromptRunId, executionOrder);
                 result.startTime = startTime;
                 result.endTime = new Date();
                 return result;
@@ -151,31 +323,53 @@ class ParallelExecutionCoordinator {
             errorMessage: lastError?.message || 'Unknown error',
             executionTimeMS: endTime.getTime() - startTime.getTime(),
             startTime,
-            endTime
+            endTime,
         };
     }
-    async executeSingleTask(task, timeoutMS) {
+    async executeSingleTask(task, timeoutMS, parentPromptRunId, executionOrder) {
         const startTime = new Date();
+        let childPromptRun = null;
         try {
+            if (parentPromptRunId) {
+                childPromptRun = await this.createChildPromptRun(task, startTime, parentPromptRunId, executionOrder);
+            }
             const apiKey = (0, ai_1.GetAIAPIKey)(task.model.DriverClass);
             const llm = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(ai_1.BaseLLM, task.model.DriverClass, apiKey);
             const params = new ai_1.ChatParams();
             params.model = task.model.APIName;
-            params.messages = [
-                {
-                    role: ai_1.ChatMessageRole.user,
-                    content: task.renderedPrompt
-                }
-            ];
+            params.cancellationToken = task.cancellationToken;
+            if (task.streamingConfig?.enabled && task.streamingConfig.callbacks?.OnContent) {
+                params.streaming = true;
+                params.streamingCallbacks = {
+                    OnContent: task.streamingConfig.callbacks.OnContent,
+                    OnComplete: task.streamingConfig.callbacks.OnComplete,
+                    OnError: task.streamingConfig.callbacks.OnError,
+                };
+            }
+            params.messages = this.buildMessageArray(task.renderedPrompt, task.conversationMessages, task.templateMessageRole || 'system');
             if (task.modelParameters) {
                 Object.assign(params, task.modelParameters);
             }
-            const modelResult = await Promise.race([
-                llm.ChatCompletion(params),
-                new Promise((_, reject) => setTimeout(() => reject(new Error('Task execution timeout')), timeoutMS))
-            ]);
+            const racePromises = [llm.ChatCompletion(params)];
+            racePromises.push(new Promise((_, reject) => setTimeout(() => reject(new Error('Task execution timeout')), timeoutMS)));
+            if (task.cancellationToken) {
+                racePromises.push(new Promise((_, reject) => {
+                    if (task.cancellationToken.aborted) {
+                        reject(new Error('Task execution cancelled'));
+                    }
+                    else {
+                        task.cancellationToken.addEventListener('abort', () => {
+                            reject(new Error('Task execution cancelled'));
+                        });
+                    }
+                }));
+            }
+            const modelResult = (await Promise.race(racePromises));
             const endTime = new Date();
             const executionTimeMS = endTime.getTime() - startTime.getTime();
+            if (childPromptRun) {
+                await this.updateChildPromptRun(childPromptRun, modelResult, endTime, executionTimeMS);
+            }
             return {
                 task,
                 success: modelResult.success,
@@ -184,11 +378,34 @@ class ParallelExecutionCoordinator {
                 tokensUsed: modelResult.data?.usage?.totalTokens,
                 modelResult,
                 startTime,
-                endTime
+                endTime,
+                promptRun: childPromptRun,
             };
         }
         catch (error) {
             const endTime = new Date();
+            const executionTimeMS = endTime.getTime() - startTime.getTime();
+            const isCancelled = error.message.includes('cancelled');
+            if (childPromptRun) {
+                childPromptRun.CompletedAt = endTime;
+                childPromptRun.ExecutionTimeMS = executionTimeMS;
+                childPromptRun.Success = false;
+                childPromptRun.ErrorMessage = error.message;
+                childPromptRun.Result = `ERROR: ${error.message}`;
+                await childPromptRun.Save();
+            }
+            if (isCancelled) {
+                return {
+                    task,
+                    success: false,
+                    cancelled: true,
+                    errorMessage: error.message,
+                    executionTimeMS,
+                    startTime,
+                    endTime,
+                    promptRun: childPromptRun,
+                };
+            }
             throw new Error(`Task execution failed: ${error.message}`);
         }
     }
@@ -197,6 +414,7 @@ class ParallelExecutionCoordinator {
         const errors = [];
         let totalTokensUsed = 0;
         let successCount = 0;
+        let cancelledCount = 0;
         for (const result of taskResults) {
             const groupNumber = result.task.executionGroup;
             if (!groupResults.has(groupNumber)) {
@@ -208,6 +426,9 @@ class ParallelExecutionCoordinator {
                 totalTokensUsed += result.tokensUsed || 0;
             }
             else {
+                if (result.cancelled) {
+                    cancelledCount++;
+                }
                 if (result.errorMessage) {
                     errors.push(result.errorMessage);
                 }
@@ -219,11 +440,12 @@ class ParallelExecutionCoordinator {
             groupResults,
             totalExecutionTimeMS: endTime.getTime() - startTime.getTime(),
             successCount,
-            failureCount: taskResults.length - successCount,
+            failureCount: taskResults.length - successCount - cancelledCount,
+            cancelledCount,
             totalTokensUsed,
             errors,
             startTime,
-            endTime
+            endTime,
         };
     }
     selectFirstResult(results) {
@@ -233,9 +455,121 @@ class ParallelExecutionCoordinator {
         const randomIndex = Math.floor(Math.random() * results.length);
         return results[randomIndex];
     }
-    async selectResultWithPrompt(results, selectorPromptId) {
-        (0, core_1.LogStatus)(`AI-based result selection not yet implemented, returning first result`);
-        return results[0];
+    async selectResultWithPrompt(results, selectorPromptId, parentPromptRunId, _cancellationToken) {
+        try {
+            const { AIPromptRunner } = await Promise.resolve().then(() => __importStar(require('./AIPromptRunner')));
+            await aiengine_1.AIEngine.Instance.Config(false);
+            const judgePrompt = aiengine_1.AIEngine.Instance.Prompts.find((p) => p.ID === selectorPromptId);
+            if (!judgePrompt) {
+                (0, core_1.LogError)(`Judge prompt with ID ${selectorPromptId} not found`);
+                return results[0];
+            }
+            const judgeData = this.formatResultsForJudge(results);
+            const conversationMessages = [
+                {
+                    role: ai_1.ChatMessageRole.system,
+                    content: 'You are an expert AI judge tasked with ranking multiple AI responses to determine the best one. Analyze each response for quality, accuracy, completeness, and relevance to the original prompt.',
+                },
+                {
+                    role: ai_1.ChatMessageRole.user,
+                    content: JSON.stringify(judgeData, null, 2),
+                },
+            ];
+            let resultSelectorPromptRun = null;
+            if (parentPromptRunId) {
+                resultSelectorPromptRun = await this.createResultSelectorPromptRun(judgePrompt, judgeData, parentPromptRunId, results.length);
+            }
+            const judgeRunner = new AIPromptRunner();
+            const judgeStartTime = Date.now();
+            const judgeResult = await judgeRunner.ExecutePrompt({
+                prompt: judgePrompt,
+                data: judgeData,
+                conversationMessages,
+            });
+            const judgeEndTime = Date.now();
+            const judgeExecutionTimeMS = judgeEndTime - judgeStartTime;
+            if (resultSelectorPromptRun && judgeResult.promptRun) {
+                resultSelectorPromptRun.CompletedAt = new Date(judgeEndTime);
+                resultSelectorPromptRun.ExecutionTimeMS = judgeExecutionTimeMS;
+                resultSelectorPromptRun.Success = judgeResult.success;
+                resultSelectorPromptRun.Result = judgeResult.rawResult || '';
+                if (judgeResult.tokensUsed) {
+                    resultSelectorPromptRun.TokensUsed = judgeResult.tokensUsed;
+                }
+                await resultSelectorPromptRun.Save();
+            }
+            if (!judgeResult.success || !judgeResult.rawResult) {
+                (0, core_1.LogError)(`Judge prompt execution failed: ${judgeResult.errorMessage}`);
+                return results[0];
+            }
+            const rankings = this.parseJudgeResult(judgeResult.rawResult);
+            if (!rankings || rankings.length === 0) {
+                (0, core_1.LogError)('Failed to parse judge rankings');
+                return results[0];
+            }
+            this.applyRankingsToResults(results, rankings);
+            const bestCandidateId = rankings.find((r) => r.rank === 1)?.candidateId;
+            const bestResultIndex = results.findIndex((r) => r.task.taskId === bestCandidateId);
+            const bestResult = bestResultIndex >= 0 ? results[bestResultIndex] : results[0];
+            bestResult.judgeMetadata = {
+                judgePromptId: selectorPromptId,
+                judgeExecutionTimeMS,
+                judgeTokensUsed: judgeResult.tokensUsed,
+            };
+            (0, core_1.LogStatus)(`Judge selected candidate ${bestCandidateId} as the best result`);
+            return bestResult;
+        }
+        catch (error) {
+            (0, core_1.LogError)(`Error in AI judge selection: ${error.message}`);
+            return results[0];
+        }
+    }
+    formatResultsForJudge(results) {
+        return {
+            originalPrompt: results[0]?.task.renderedPrompt || 'Original prompt not available',
+            candidates: results.map((result) => ({
+                candidateId: result.task.taskId,
+                modelName: result.task.model.Name,
+                vendorName: result.task.model.Vendor || 'Unknown',
+                response: result.rawResult || '',
+                executionTimeMS: result.executionTimeMS,
+                tokensUsed: result.tokensUsed || 0,
+            })),
+            instructions: {
+                task: 'Rank these AI responses from best to worst (1 = best)',
+                format: "Return valid JSON with 'rankings' array containing objects with 'candidateId', 'rank', and 'rationale' fields",
+                criteria: ['Quality', 'Accuracy', 'Completeness', 'Relevance', 'Clarity'],
+            },
+        };
+    }
+    parseJudgeResult(judgeResult) {
+        try {
+            const jsonMatch = judgeResult.match(/\{[\s\S]*\}/);
+            const jsonString = jsonMatch ? jsonMatch[0] : judgeResult;
+            const parsed = JSON.parse(jsonString);
+            if (parsed.rankings && Array.isArray(parsed.rankings)) {
+                return parsed.rankings.map((ranking) => ({
+                    candidateId: ranking.candidateId,
+                    rank: ranking.rank,
+                    rationale: ranking.rationale || 'No rationale provided',
+                }));
+            }
+            (0, core_1.LogError)('Judge result does not contain valid rankings array');
+            return null;
+        }
+        catch (error) {
+            (0, core_1.LogError)(`Failed to parse judge result: ${error.message}`);
+            return null;
+        }
+    }
+    applyRankingsToResults(results, rankings) {
+        for (const result of results) {
+            const ranking = rankings.find((r) => r.candidateId === result.task.taskId);
+            if (ranking) {
+                result.ranking = ranking.rank;
+                result.judgeRationale = ranking.rationale;
+            }
+        }
     }
     selectConsensusResult(results) {
         const resultGroups = new Map();
@@ -254,8 +588,127 @@ class ParallelExecutionCoordinator {
         }
         return largestGroup[0];
     }
+    buildMessageArray(renderedPrompt, conversationMessages, templateMessageRole = 'system') {
+        const messages = [];
+        if (renderedPrompt && templateMessageRole !== 'none') {
+            messages.push({
+                role: templateMessageRole === 'system' ? ai_1.ChatMessageRole.system : ai_1.ChatMessageRole.user,
+                content: renderedPrompt,
+            });
+        }
+        if (conversationMessages && conversationMessages.length > 0) {
+            messages.push(...conversationMessages);
+        }
+        if ((!conversationMessages || conversationMessages.length === 0) && templateMessageRole !== 'user' && renderedPrompt) {
+            if (templateMessageRole === 'system') {
+                messages.push({
+                    role: ai_1.ChatMessageRole.user,
+                    content: 'Please proceed with the above instructions.',
+                });
+            }
+        }
+        else if ((!conversationMessages || conversationMessages.length === 0) && !renderedPrompt) {
+            messages.push({
+                role: ai_1.ChatMessageRole.user,
+                content: 'Hello',
+            });
+        }
+        return messages;
+    }
+    async createChildPromptRun(task, startTime, parentPromptRunId, executionOrder) {
+        try {
+            const promptRun = await this._metadata.GetEntityObject('MJ: AI Prompt Runs', task.contextUser);
+            promptRun.NewRecord();
+            promptRun.PromptID = task.prompt.ID;
+            promptRun.ModelID = task.model.ID;
+            promptRun.RunAt = startTime;
+            promptRun.RunType = 'ParallelChild';
+            promptRun.ParentID = parentPromptRunId;
+            if (executionOrder !== undefined) {
+                promptRun.ExecutionOrder = executionOrder;
+            }
+            if (task.promptModel?.VendorID) {
+                promptRun.VendorID = task.promptModel.VendorID;
+            }
+            if (task.configurationId) {
+                promptRun.ConfigurationID = task.configurationId;
+            }
+            const messagesData = {
+                renderedPrompt: task.renderedPrompt,
+                conversationMessages: task.conversationMessages,
+                modelParameters: task.modelParameters,
+                taskId: task.taskId,
+            };
+            promptRun.Messages = JSON.stringify(messagesData);
+            const saveResult = await promptRun.Save();
+            if (!saveResult) {
+                const error = `Failed to save child AIPromptRun: ${promptRun.LatestResult?.Message || 'Unknown error'}`;
+                (0, core_1.LogError)(error);
+                throw new Error(error);
+            }
+            return promptRun;
+        }
+        catch (error) {
+            (0, core_1.LogError)(`Error creating child prompt run record: ${error.message}`);
+            throw error;
+        }
+    }
+    async updateChildPromptRun(promptRun, modelResult, endTime, executionTimeMS) {
+        try {
+            promptRun.CompletedAt = endTime;
+            promptRun.ExecutionTimeMS = executionTimeMS;
+            promptRun.Success = modelResult.success;
+            if (modelResult.success) {
+                promptRun.Result = modelResult.data?.choices?.[0]?.message?.content || '';
+                if (modelResult.data?.usage) {
+                    promptRun.TokensUsed = modelResult.data.usage.totalTokens;
+                    promptRun.TokensPrompt = modelResult.data.usage.promptTokens;
+                    promptRun.TokensCompletion = modelResult.data.usage.completionTokens;
+                }
+            }
+            else {
+                promptRun.ErrorMessage = modelResult.errorMessage;
+                promptRun.Result = `ERROR: ${modelResult.errorMessage}`;
+            }
+            const saveResult = await promptRun.Save();
+            if (!saveResult) {
+                (0, core_1.LogError)(`Failed to update child AIPromptRun with results: ${promptRun.LatestResult?.Message || 'Unknown error'}`);
+            }
+        }
+        catch (error) {
+            (0, core_1.LogError)(`Error updating child prompt run: ${error.message}`);
+        }
+    }
+    async createResultSelectorPromptRun(judgePrompt, judgeData, parentPromptRunId, executionOrder) {
+        try {
+            const promptRun = await this._metadata.GetEntityObject('MJ: AI Prompt Runs');
+            promptRun.NewRecord();
+            promptRun.PromptID = judgePrompt.ID;
+            promptRun.RunAt = new Date();
+            promptRun.RunType = 'ResultSelector';
+            promptRun.ParentID = parentPromptRunId;
+            promptRun.ExecutionOrder = executionOrder;
+            promptRun.Messages = JSON.stringify({
+                judgeData,
+                candidateCount: Array.isArray(judgeData.candidates)
+                    ? judgeData.candidates.length
+                    : 0,
+            });
+            const saveResult = await promptRun.Save();
+            if (!saveResult) {
+                const error = `Failed to save ResultSelector AIPromptRun: ${promptRun.LatestResult?.Message || 'Unknown error'}`;
+                (0, core_1.LogError)(error);
+                throw new Error(error);
+            }
+            return promptRun;
+        }
+        catch (error) {
+            (0, core_1.LogError)(`Error creating result selector prompt run record: ${error.message}`);
+            throw error;
+        }
+    }
     delay(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
+        return new Promise((resolve) => setTimeout(resolve, ms));
     }
 }
 exports.ParallelExecutionCoordinator = ParallelExecutionCoordinator;