@memberjunction/ai-prompts 2.44.0 → 2.45.0

package/dist/AIPromptRunner.js

@@ -1,4 +1,7 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LoadAIPromptRunner = exports.AIPromptRunner = exports.AIPromptRunResult = exports.AIPromptParams = void 0;
 const ai_1 = require("@memberjunction/ai");
@@ -8,6 +11,7 @@ const templates_1 = require("@memberjunction/templates");
 const ExecutionPlanner_1 = require("./ExecutionPlanner");
 const ParallelExecutionCoordinator_1 = require("./ParallelExecutionCoordinator");
 const aiengine_1 = require("@memberjunction/aiengine");
+const ajv_1 = __importDefault(require("ajv"));
 class AIPromptParams {
 }
 exports.AIPromptParams = AIPromptParams;
@@ -20,10 +24,34 @@ class AIPromptRunner {
         this._templateEngine = templates_1.TemplateEngineServer.Instance;
         this._executionPlanner = new ExecutionPlanner_1.ExecutionPlanner();
         this._parallelCoordinator = new ParallelExecutionCoordinator_1.ParallelExecutionCoordinator();
+        if (!AIPromptRunner._ajvInstance) {
+            AIPromptRunner._ajvInstance = new ajv_1.default({ allErrors: true, verbose: true });
+        }
+        this._ajv = AIPromptRunner._ajvInstance;
+    }
+    static clearSchemaCache() {
+        AIPromptRunner._schemaCache.clear();
+        (0, core_1.LogStatus)('Cleared global JSON schema cache');
+    }
+    static getSchemaCacheStats() {
+        return {
+            size: AIPromptRunner._schemaCache.size,
+            keys: Array.from(AIPromptRunner._schemaCache.keys())
+        };
     }
     async ExecutePrompt(params) {
         const startTime = new Date();
-        let promptRun = null;
+        const promptRun = null;
+        if (params.cancellationToken?.aborted) {
+            return {
+                success: false,
+                status: 'cancelled',
+                cancelled: true,
+                cancellationReason: 'user_requested',
+                errorMessage: 'Prompt execution was cancelled before starting',
+                executionTimeMS: 0,
+            };
+        }
         try {
             const prompt = params.prompt;
             if (!prompt) {
@@ -32,21 +60,28 @@ class AIPromptRunner {
             if (prompt.Status !== 'Active') {
                 throw new Error(`Prompt ${prompt.Name} is not active (Status: ${prompt.Status})`);
             }
-            await this._templateEngine.Config(false, params.contextUser);
-            const template = await this.loadTemplate(prompt.TemplateID, params.contextUser);
-            if (!template) {
-                throw new Error(`Template with ID ${prompt.TemplateID} not found for prompt ${prompt.Name}`);
+            let renderedPromptText = '';
+            if (prompt.TemplateID && (!params.conversationMessages || params.templateMessageRole !== 'none')) {
+                await this._templateEngine.Config(false, params.contextUser);
+                const template = await this.loadTemplate(prompt.TemplateID, params.contextUser);
+                if (!template) {
+                    throw new Error(`Template with ID ${prompt.TemplateID} not found for prompt ${prompt.Name}`);
+                }
+                const renderedPrompt = await this.renderPromptTemplate(template, params.data, params.templateData);
+                if (!renderedPrompt.Success) {
+                    throw new Error(`Failed to render template for prompt ${prompt.Name}: ${renderedPrompt.Message}`);
+                }
+                renderedPromptText = renderedPrompt.Output;
             }
-            const renderedPrompt = await this.renderPromptTemplate(template, params.data, params.templateData);
-            if (!renderedPrompt.Success) {
-                throw new Error(`Failed to render template for prompt ${prompt.Name}: ${renderedPrompt.Message}`);
+            if (params.cancellationToken?.aborted) {
+                throw new Error('Prompt execution was cancelled during template rendering');
             }
             const shouldUseParallelExecution = prompt.ParallelizationMode && prompt.ParallelizationMode !== 'None';
             if (shouldUseParallelExecution) {
-                return await this.executePromptInParallel(prompt, renderedPrompt.Output, params, startTime);
+                return await this.executePromptInParallel(prompt, renderedPromptText, params, startTime);
             }
             else {
-                return await this.executeSinglePrompt(prompt, renderedPrompt.Output, params, startTime);
+                return await this.executeSinglePrompt(prompt, renderedPromptText, params, startTime);
             }
         }
         catch (error) {
@@ -66,21 +101,29 @@ class AIPromptRunner {
                 success: false,
                 errorMessage: error.message,
                 promptRun,
-                executionTimeMS
+                executionTimeMS,
             };
         }
     }
     async executeSinglePrompt(prompt, renderedPromptText, params, startTime) {
+        if (params.cancellationToken?.aborted) {
+            throw new Error('Prompt execution was cancelled before model selection');
+        }
         const selectedModel = await this.selectModel(prompt, params.modelId, params.contextUser, params.configurationId, params.vendorId);
         if (!selectedModel) {
             throw new Error(`No suitable model found for prompt ${prompt.Name}`);
         }
+        if (params.cancellationToken?.aborted) {
+            throw new Error('Prompt execution was cancelled after model selection');
+        }
         const promptRun = await this.createPromptRun(prompt, selectedModel, params, startTime, params.vendorId);
-        const modelResult = await this.executeModel(selectedModel, renderedPromptText, prompt, params.contextUser);
-        const parsedResult = await this.parseAndValidateResult(modelResult, prompt, params.skipValidation);
+        if (params.cancellationToken?.aborted) {
+            throw new Error('Prompt execution was cancelled before model execution');
+        }
+        const { modelResult, parsedResult, validationAttempts } = await this.executeWithValidationRetries(selectedModel, renderedPromptText, prompt, params, promptRun);
         const endTime = new Date();
         const executionTimeMS = endTime.getTime() - startTime.getTime();
-        await this.updatePromptRun(promptRun, modelResult, parsedResult, endTime, executionTimeMS);
+        await this.updatePromptRun(promptRun, modelResult, parsedResult, endTime, executionTimeMS, validationAttempts);
         const chatResult = modelResult;
         return {
             success: true,
@@ -89,23 +132,30 @@ class AIPromptRunner {
             promptRun,
             executionTimeMS,
             tokensUsed: chatResult.data?.usage?.totalTokens,
-            validationResult: parsedResult.validationResult
+            validationResult: parsedResult.validationResult,
+            validationAttempts,
         };
     }
     async executePromptInParallel(prompt, renderedPromptText, params, startTime) {
+        if (params.cancellationToken?.aborted) {
+            throw new Error('Parallel execution was cancelled before starting');
+        }
         await aiengine_1.AIEngine.Instance.Config(false, params.contextUser);
-        const promptModels = aiengine_1.AIEngine.Instance.PromptModels.filter(pm => pm.PromptID === prompt.ID &&
+        const promptModels = aiengine_1.AIEngine.Instance.PromptModels.filter((pm) => pm.PromptID === prompt.ID &&
             (pm.Status === 'Active' || pm.Status === 'Preview') &&
             (!params.configurationId || !pm.ConfigurationID || pm.ConfigurationID === params.configurationId));
-        const executionTasks = this._executionPlanner.createExecutionPlan(prompt, promptModels, aiengine_1.AIEngine.Instance.Models, renderedPromptText, params.contextUser, params.configurationId);
+        const executionTasks = this._executionPlanner.createExecutionPlan(prompt, promptModels, aiengine_1.AIEngine.Instance.Models, renderedPromptText, params.contextUser, params.configurationId, params.conversationMessages, params.templateMessageRole || 'system');
         if (executionTasks.length === 0) {
             throw new Error(`No execution tasks created for parallel execution of prompt ${prompt.Name}`);
         }
-        const parallelResult = await this._parallelCoordinator.executeTasksInParallel(executionTasks);
+        if (params.cancellationToken?.aborted) {
+            throw new Error('Parallel execution was cancelled before task execution');
+        }
+        const parallelResult = await this._parallelCoordinator.executeTasksInParallel(executionTasks, undefined, undefined, params.cancellationToken);
         if (!parallelResult.success) {
             throw new Error(`Parallel execution failed: ${parallelResult.errors.join(', ')}`);
         }
-        const successfulResults = parallelResult.taskResults.filter(r => r.success);
+        const successfulResults = parallelResult.taskResults.filter((r) => r.success);
         if (successfulResults.length === 0) {
             throw new Error(`No successful results from parallel execution`);
         }
@@ -113,9 +163,9 @@ class AIPromptRunner {
         if (successfulResults.length > 1 && prompt.ResultSelectorPromptID) {
             const selectionConfig = {
                 method: 'PromptSelector',
-                selectorPromptId: prompt.ResultSelectorPromptID
+                selectorPromptId: prompt.ResultSelectorPromptID,
             };
-            const aiSelectedResult = await this._parallelCoordinator.selectBestResult(successfulResults, selectionConfig);
+            const aiSelectedResult = await this._parallelCoordinator.selectBestResult(successfulResults, selectionConfig, undefined, params.cancellationToken);
             if (aiSelectedResult) {
                 selectedResult = aiSelectedResult;
             }
@@ -132,27 +182,68 @@ class AIPromptRunner {
             successfulTasks: parallelResult.successCount,
             failedTasks: parallelResult.failureCount,
             selectedTaskId: selectedResult.task.taskId,
-            executionGroups: Array.from(parallelResult.groupResults.keys())
+            executionGroups: Array.from(parallelResult.groupResults.keys()),
         };
         if (params.data || params.templateData || parallelMetadata) {
             consolidatedPromptRun.Messages = JSON.stringify({
                 data: params.data,
                 templateData: params.templateData,
-                parallelExecution: parallelMetadata
+                parallelExecution: parallelMetadata,
             });
         }
         const saveResult = await consolidatedPromptRun.Save();
         if (!saveResult) {
             (0, core_1.LogError)(`Failed to save consolidated AIPromptRun: ${consolidatedPromptRun.LatestResult?.Message || 'Unknown error'}`);
         }
+        const additionalResults = [];
+        const sortedResults = successfulResults.sort((a, b) => {
+            if (a.ranking && b.ranking) {
+                return a.ranking - b.ranking;
+            }
+            return 0;
+        });
+        for (const result of sortedResults) {
+            if (result.task.taskId !== selectedResult.task.taskId) {
+                const { result: parsedResultData, validationResult, validationErrors } = await this.parseAndValidateResultEnhanced(result.modelResult, prompt, params.skipValidation);
+                const parsedResult = { result: parsedResultData, validationResult };
+                additionalResults.push({
+                    success: result.success,
+                    rawResult: result.rawResult,
+                    result: parsedResult.result,
+                    executionTimeMS: result.executionTimeMS,
+                    tokensUsed: result.tokensUsed,
+                    validationResult: parsedResult.validationResult,
+                    ranking: result.ranking,
+                    judgeRationale: result.judgeRationale,
+                    modelInfo: {
+                        modelId: result.task.model.ID,
+                        modelName: result.task.model.Name,
+                        vendorId: undefined,
+                        vendorName: result.task.model.Vendor,
+                    },
+                });
+            }
+        }
+        const { result: selectedResultData, validationResult: selectedValidationResult } = await this.parseAndValidateResultEnhanced(selectedResult.modelResult, prompt, params.skipValidation);
+        const selectedParsedResult = { result: selectedResultData, validationResult: selectedValidationResult };
         return {
             success: true,
             rawResult: selectedResult.rawResult,
-            result: selectedResult.parsedResult,
+            result: selectedParsedResult.result,
             promptRun: consolidatedPromptRun,
             executionTimeMS: parallelResult.totalExecutionTimeMS,
             tokensUsed: parallelResult.totalTokensUsed,
-            validationResult: selectedResult.validationResult
+            validationResult: selectedParsedResult.validationResult,
+            additionalResults: additionalResults.length > 0 ? additionalResults : undefined,
+            ranking: selectedResult.ranking || 1,
+            judgeRationale: selectedResult.judgeRationale,
+            modelInfo: {
+                modelId: selectedResult.task.model.ID,
+                modelName: selectedResult.task.model.Name,
+                vendorId: undefined,
+                vendorName: selectedResult.task.model.Vendor,
+            },
+            judgeMetadata: selectedResult.judgeMetadata,
         };
     }
     async loadTemplate(templateId, _contextUser) {
@@ -175,7 +266,7 @@ class AIPromptRunner {
                     const vendorResult = await rv.RunView({
                         EntityName: 'AI Vendors',
                         ExtraFilter: `ID='${vendorId}'`,
-                        ResultType: 'entity_object'
+                        ResultType: 'entity_object',
                     });
                     if (vendorResult.Results && vendorResult.Results.length > 0) {
                         vendorName = vendorResult.Results[0].Name;
@@ -189,33 +280,29 @@ class AIPromptRunner {
                 }
             }
             if (explicitModelId) {
-                const model = aiengine_1.AIEngine.Instance.Models.find(m => m.ID === explicitModelId &&
-                    (!vendorName || m.Vendor === vendorName));
+                const model = aiengine_1.AIEngine.Instance.Models.find((m) => m.ID === explicitModelId && (!vendorName || m.Vendor === vendorName));
                 if (model && model.IsActive) {
                     return model;
                 }
                 (0, core_1.LogError)(`Explicit model ${explicitModelId} not found, inactive, or not from specified vendor, using prompt model selection`);
             }
-            const promptModels = aiengine_1.AIEngine.Instance.PromptModels.filter(pm => pm.PromptID === prompt.ID &&
-                (pm.Status === 'Active' ||
-                    pm.Status === 'Preview') &&
+            const promptModels = aiengine_1.AIEngine.Instance.PromptModels.filter((pm) => pm.PromptID === prompt.ID &&
+                (pm.Status === 'Active' || pm.Status === 'Preview') &&
                 (!configurationId || !pm.ConfigurationID || pm.ConfigurationID === configurationId));
             let candidateModels = [];
             if (promptModels.length > 0) {
                 candidateModels = promptModels
-                    .map(pm => aiengine_1.AIEngine.Instance.Models.find(m => m.ID === pm.ModelID))
-                    .filter(m => m &&
-                    m.IsActive &&
-                    (!vendorName || m.Vendor === vendorName));
+                    .map((pm) => aiengine_1.AIEngine.Instance.Models.find((m) => m.ID === pm.ModelID))
+                    .filter((m) => m && m.IsActive && (!vendorName || m.Vendor === vendorName));
                 candidateModels.sort((a, b) => {
-                    const aPriority = promptModels.find(pm => pm.ModelID === a.ID)?.Priority || 0;
-                    const bPriority = promptModels.find(pm => pm.ModelID === b.ID)?.Priority || 0;
+                    const aPriority = promptModels.find((pm) => pm.ModelID === a.ID)?.Priority || 0;
+                    const bPriority = promptModels.find((pm) => pm.ModelID === b.ID)?.Priority || 0;
                     return bPriority - aPriority;
                 });
             }
             else {
                 const minPowerRank = prompt.MinPowerRank || 0;
-                candidateModels = aiengine_1.AIEngine.Instance.Models.filter(m => m.IsActive &&
+                candidateModels = aiengine_1.AIEngine.Instance.Models.filter((m) => m.IsActive &&
                     m.PowerRank >= minPowerRank &&
                     (!prompt.AIModelTypeID || m.AIModelTypeID === prompt.AIModelTypeID) &&
                     (!vendorName || m.Vendor === vendorName));
@@ -253,8 +340,7 @@ class AIPromptRunner {
                 promptRun.VendorID = vendorId;
             }
             else {
-                const promptModels = aiengine_1.AIEngine.Instance.PromptModels.filter(pm => pm.ModelID === model.ID)
-                    .sort((a, b) => b.Priority - a.Priority);
+                const promptModels = aiengine_1.AIEngine.Instance.PromptModels.filter((pm) => pm.ModelID === model.ID).sort((a, b) => b.Priority - a.Priority);
                 if (promptModels.length > 0) {
                     const highestPriorityModel = promptModels[0];
                     promptRun.VendorID = highestPriorityModel.VendorID;
@@ -265,7 +351,7 @@ class AIPromptRunner {
             if (params.data || params.templateData) {
                 promptRun.Messages = JSON.stringify({
                     data: params.data,
-                    templateData: params.templateData
+                    templateData: params.templateData,
                 });
             }
             const saveResult = await promptRun.Save();
@@ -295,27 +381,408 @@ class AIPromptRunner {
             throw error;
         }
     }
-    async executeModel(model, renderedPrompt, prompt, _contextUser) {
+    async executeModel(model, renderedPrompt, prompt, _contextUser, conversationMessages, templateMessageRole = 'system', cancellationToken) {
         try {
             const apiKey = (0, ai_1.GetAIAPIKey)(model.DriverClass);
             const llm = global_1.MJGlobal.Instance.ClassFactory.CreateInstance(ai_1.BaseLLM, model.DriverClass, apiKey);
             const params = new ai_1.ChatParams();
             params.model = model.APIName;
-            params.messages = [
-                {
-                    role: ai_1.ChatMessageRole.user,
-                    content: renderedPrompt
-                }
-            ];
+            params.cancellationToken = cancellationToken;
+            params.messages = this.buildMessageArray(renderedPrompt, conversationMessages, templateMessageRole);
             if (prompt.ResponseFormat && prompt.ResponseFormat !== 'Any') {
             }
-            return await llm.ChatCompletion(params);
+            if (cancellationToken) {
+                return await Promise.race([
+                    llm.ChatCompletion(params),
+                    new Promise((_, reject) => {
+                        if (cancellationToken.aborted) {
+                            reject(new Error('Chat completion was cancelled'));
+                        }
+                        else {
+                            cancellationToken.addEventListener('abort', () => {
+                                reject(new Error('Chat completion was cancelled'));
+                            });
+                        }
+                    }),
+                ]);
+            }
+            else {
+                return await llm.ChatCompletion(params);
+            }
         }
         catch (error) {
             (0, core_1.LogError)(`Error executing model ${model.Name}: ${error.message}`);
             throw error;
         }
     }
+    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 executeWithValidationRetries(selectedModel, renderedPromptText, prompt, params, promptRun) {
+        const validationAttempts = [];
+        const maxRetries = Math.max(0, prompt.MaxRetries || 0);
+        let lastError = null;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                if (params.cancellationToken?.aborted) {
+                    throw new Error('Execution was cancelled during validation retries');
+                }
+                if (attempt > 0) {
+                    (0, core_1.LogStatus)(`🔄 Retrying execution due to validation failure, attempt ${attempt + 1}/${maxRetries + 1}`);
+                    await this.applyRetryDelay(prompt, attempt);
+                }
+                const modelResult = await this.executeModel(selectedModel, renderedPromptText, prompt, params.contextUser, params.conversationMessages, params.templateMessageRole || 'system', params.cancellationToken);
+                const { result, validationResult, validationErrors } = await this.parseAndValidateResultEnhanced(modelResult, prompt, params.skipValidation);
+                const validationAttempt = {
+                    attemptNumber: attempt + 1,
+                    success: validationResult?.Success || false,
+                    errorMessage: validationErrors?.length ? validationErrors.map(e => e.Message).join('; ') : undefined,
+                    validationErrors,
+                    rawOutput: modelResult.data?.choices?.[0]?.message?.content || '',
+                    parsedOutput: result,
+                    timestamp: new Date(),
+                };
+                validationAttempts.push(validationAttempt);
+                await this.updatePromptRunWithValidationAttempt(promptRun, validationAttempt, attempt + 1, maxRetries + 1);
+                if (validationResult?.Success !== false) {
+                    (0, core_1.LogStatus)(`✅ Validation succeeded on attempt ${attempt + 1}/${maxRetries + 1}`);
+                    return {
+                        modelResult,
+                        parsedResult: { result, validationResult },
+                        validationAttempts,
+                    };
+                }
+                if (prompt.ValidationBehavior === 'Strict' && attempt < maxRetries) {
+                    lastError = new Error(`Validation failed: ${validationErrors?.map(e => e.Message).join('; ')}`);
+                    (0, core_1.LogStatus)(`❌ Validation failed on attempt ${attempt + 1}, will retry (Strict mode)`);
+                    continue;
+                }
+                else {
+                    const reason = prompt.ValidationBehavior !== 'Strict'
+                        ? `${prompt.ValidationBehavior} mode - continuing with invalid output`
+                        : 'max retries exceeded';
+                    (0, core_1.LogStatus)(`⚠️ Validation failed on attempt ${attempt + 1}, stopping retries (${reason})`);
+                    return {
+                        modelResult,
+                        parsedResult: { result, validationResult },
+                        validationAttempts,
+                    };
+                }
+            }
+            catch (error) {
+                lastError = error;
+                (0, core_1.LogError)(`Execution attempt ${attempt + 1} failed: ${error.message}`);
+                const validationAttempt = {
+                    attemptNumber: attempt + 1,
+                    success: false,
+                    errorMessage: error.message,
+                    rawOutput: '',
+                    timestamp: new Date(),
+                };
+                validationAttempts.push(validationAttempt);
+                await this.updatePromptRunWithValidationAttempt(promptRun, validationAttempt, attempt + 1, maxRetries + 1);
+                if (attempt === maxRetries) {
+                    throw error;
+                }
+            }
+        }
+        throw lastError || new Error('Execution failed after all retry attempts');
+    }
+    async applyRetryDelay(prompt, attemptNumber) {
+        const baseDelay = prompt.RetryDelayMS || 1000;
+        let delay = baseDelay;
+        switch (prompt.RetryStrategy) {
+            case 'Fixed':
+                delay = baseDelay;
+                break;
+            case 'Linear':
+                delay = baseDelay * attemptNumber;
+                break;
+            case 'Exponential':
+                delay = baseDelay * Math.pow(2, attemptNumber - 1);
+                break;
+            default:
+                delay = baseDelay;
+        }
+        (0, core_1.LogStatus)(`Applying retry delay: ${delay}ms (strategy: ${prompt.RetryStrategy})`);
+        await new Promise(resolve => setTimeout(resolve, delay));
+    }
+    async updatePromptRunWithValidationAttempt(promptRun, attempt, currentAttempt, totalAttempts) {
+        try {
+            const currentMessages = promptRun.Messages ? JSON.parse(promptRun.Messages) : {};
+            if (!currentMessages.validationAttempts) {
+                currentMessages.validationAttempts = [];
+            }
+            currentMessages.validationAttempts.push({
+                attempt: currentAttempt,
+                totalAttempts,
+                success: attempt.success,
+                timestamp: attempt.timestamp.toISOString(),
+                errorMessage: attempt.errorMessage,
+                validationErrorCount: attempt.validationErrors?.length || 0,
+                rawOutput: attempt.rawOutput?.substring(0, 500) + (attempt.rawOutput?.length > 500 ? '...' : ''),
+                parsedOutput: attempt.parsedOutput ? JSON.stringify(attempt.parsedOutput).substring(0, 500) : undefined,
+                validationErrors: attempt.validationErrors?.map(e => ({
+                    source: e.Source,
+                    message: e.Message,
+                    type: e.Type,
+                    value: typeof e.Value === 'string' ? e.Value.substring(0, 100) : e.Value
+                })) || []
+            });
+            promptRun.Messages = JSON.stringify(currentMessages);
+            (0, core_1.LogStatus)(`Recorded validation attempt ${currentAttempt}/${totalAttempts} for prompt run ${promptRun.ID}`);
+        }
+        catch (error) {
+            (0, core_1.LogError)(`Error updating prompt run with validation attempt: ${error.message}`);
+        }
+    }
+    getValidationDecisionDescription(finalSuccess, totalAttempts, validationBehavior) {
+        if (finalSuccess) {
+            return totalAttempts === 1
+                ? 'Validation passed on first attempt'
+                : `Validation passed after ${totalAttempts} attempts`;
+        }
+        else {
+            switch (validationBehavior) {
+                case 'Strict':
+                    return `Validation failed after ${totalAttempts} attempts - execution marked as failed (Strict mode)`;
+                case 'Warn':
+                    return `Validation failed after ${totalAttempts} attempts - warning logged, execution continued (Warn mode)`;
+                case 'None':
+                    return `Validation skipped or ignored (None mode)`;
+                default:
+                    return `Validation failed after ${totalAttempts} attempts - behavior: ${validationBehavior}`;
+            }
+        }
+    }
+    generateSchemaFromExample(example) {
+        if (typeof example !== 'object' || example === null) {
+            return { type: 'object' };
+        }
+        const schema = {
+            type: 'object',
+            properties: {},
+            required: [],
+            additionalProperties: false,
+        };
+        for (const [key, value] of Object.entries(example)) {
+            schema.properties[key] = this.generateSchemaForValue(value);
+            schema.required.push(key);
+        }
+        return schema;
+    }
+    generateSchemaForValue(value) {
+        if (value === null) {
+            return { type: 'null' };
+        }
+        switch (typeof value) {
+            case 'string':
+                return { type: 'string' };
+            case 'number':
+                return { type: 'number' };
+            case 'boolean':
+                return { type: 'boolean' };
+            case 'object':
+                if (Array.isArray(value)) {
+                    if (value.length > 0) {
+                        return {
+                            type: 'array',
+                            items: this.generateSchemaForValue(value[0]),
+                        };
+                    }
+                    else {
+                        return { type: 'array' };
+                    }
+                }
+                else {
+                    return this.generateSchemaFromExample(value);
+                }
+            default:
+                return { type: 'string' };
+        }
+    }
+    async parseAndValidateResultEnhanced(modelResult, prompt, skipValidation = false) {
+        const validationErrors = [];
+        try {
+            if (!modelResult.success) {
+                throw new Error(`Model execution failed: ${modelResult.errorMessage}`);
+            }
+            const rawOutput = modelResult.data?.choices?.[0]?.message?.content;
+            if (!rawOutput) {
+                throw new Error('No output received from model');
+            }
+            let parsedResult = rawOutput;
+            try {
+                switch (prompt.OutputType) {
+                    case 'string':
+                        parsedResult = rawOutput.toString();
+                        break;
+                    case 'number': {
+                        const numberResult = parseFloat(rawOutput);
+                        if (isNaN(numberResult)) {
+                            const error = new core_1.ValidationErrorInfo('output', `Expected number output but got: ${rawOutput}`, rawOutput, core_1.ValidationErrorType.Failure);
+                            validationErrors.push(error);
+                            throw new Error(error.Message);
+                        }
+                        parsedResult = numberResult;
+                        break;
+                    }
+                    case 'boolean': {
+                        const lowerOutput = rawOutput.toLowerCase().trim();
+                        if (['true', 'yes', '1'].includes(lowerOutput)) {
+                            parsedResult = true;
+                        }
+                        else if (['false', 'no', '0'].includes(lowerOutput)) {
+                            parsedResult = false;
+                        }
+                        else {
+                            const error = new core_1.ValidationErrorInfo('output', `Expected boolean output but got: ${rawOutput}`, rawOutput, core_1.ValidationErrorType.Failure);
+                            validationErrors.push(error);
+                            throw new Error(error.Message);
+                        }
+                        break;
+                    }
+                    case 'date': {
+                        const dateResult = new Date(rawOutput);
+                        if (isNaN(dateResult.getTime())) {
+                            const error = new core_1.ValidationErrorInfo('output', `Expected date output but got: ${rawOutput}`, rawOutput, core_1.ValidationErrorType.Failure);
+                            validationErrors.push(error);
+                            throw new Error(error.Message);
+                        }
+                        parsedResult = dateResult;
+                        break;
+                    }
+                    case 'object':
+                        try {
+                            parsedResult = JSON.parse(rawOutput);
+                        }
+                        catch (jsonError) {
+                            const error = new core_1.ValidationErrorInfo('output', `Expected JSON object but got invalid JSON: ${rawOutput}`, rawOutput, core_1.ValidationErrorType.Failure);
+                            validationErrors.push(error);
+                            throw new Error(error.Message);
+                        }
+                        break;
+                    default:
+                        parsedResult = rawOutput;
+                }
+            }
+            catch (parseError) {
+                const validationResult = new core_1.ValidationResult();
+                validationResult.Success = false;
+                validationResult.Errors = validationErrors;
+                return { result: rawOutput, validationResult, validationErrors };
+            }
+            if (!skipValidation && prompt.OutputExample && prompt.OutputType === 'object' && parsedResult) {
+                try {
+                    const schemaValidationErrors = await this.validateAgainstSchema(parsedResult, prompt.OutputExample, prompt.ID);
+                    validationErrors.push(...schemaValidationErrors);
+                }
+                catch (schemaError) {
+                    const error = new core_1.ValidationErrorInfo('schema', `Schema validation failed: ${schemaError.message}`, undefined, core_1.ValidationErrorType.Failure);
+                    validationErrors.push(error);
+                }
+            }
+            const validationResult = new core_1.ValidationResult();
+            validationResult.Success = validationErrors.length === 0;
+            validationResult.Errors = validationErrors;
+            return { result: parsedResult, validationResult, validationErrors };
+        }
+        catch (error) {
+            (0, core_1.LogError)(`Error parsing/validating result: ${error.message}`);
+            const validationResult = new core_1.ValidationResult();
+            validationResult.Success = false;
+            validationResult.Errors = validationErrors.length > 0 ? validationErrors : [
+                new core_1.ValidationErrorInfo('general', error.message, undefined, core_1.ValidationErrorType.Failure)
+            ];
+            switch (prompt.ValidationBehavior) {
+                case 'Strict':
+                    return { result: undefined, validationResult, validationErrors: validationResult.Errors };
+                case 'Warn':
+                    (0, core_1.LogError)(`Validation warning for prompt ${prompt.Name}: ${error.message}`);
+                    return { result: modelResult.data?.choices?.[0]?.message?.content, validationResult, validationErrors: validationResult.Errors };
+                case 'None':
+                default:
+                    validationResult.Success = true;
+                    return { result: modelResult.data?.choices?.[0]?.message?.content, validationResult, validationErrors: [] };
+            }
+        }
+    }
+    async validateAgainstSchema(parsedResult, outputExample, promptId) {
+        const validationErrors = [];
+        try {
+            let validator = AIPromptRunner._schemaCache.get(promptId);
+            if (!validator) {
+                let exampleObject;
+                try {
+                    exampleObject = JSON.parse(outputExample);
+                }
+                catch (parseError) {
+                    const error = new core_1.ValidationErrorInfo('outputExample', `Invalid OutputExample JSON: ${parseError.message}`, outputExample, core_1.ValidationErrorType.Failure);
+                    validationErrors.push(error);
+                    return validationErrors;
+                }
+                const schema = this.generateSchemaFromExample(exampleObject);
+                try {
+                    validator = this._ajv.compile(schema);
+                    AIPromptRunner._schemaCache.set(promptId, validator);
+                    const cacheStats = AIPromptRunner.getSchemaCacheStats();
+                    (0, core_1.LogStatus)(`📋 Compiled and cached JSON schema for prompt ${promptId} (global cache size: ${cacheStats.size})`);
+                }
+                catch (compileError) {
+                    const error = new core_1.ValidationErrorInfo('schema', `Failed to compile schema: ${compileError.message}`, schema, core_1.ValidationErrorType.Failure);
+                    validationErrors.push(error);
+                    return validationErrors;
+                }
+            }
+            const isValid = validator(parsedResult);
+            if (!isValid && validator.errors) {
+                for (const ajvError of validator.errors) {
+                    const fieldPath = ajvError.instancePath || ajvError.schemaPath || 'root';
+                    const message = `${ajvError.instancePath || 'root'}: ${ajvError.message}`;
+                    const error = new core_1.ValidationErrorInfo(fieldPath, message, ajvError.data, core_1.ValidationErrorType.Failure);
+                    validationErrors.push(error);
+                }
+            }
+            if (validationErrors.length === 0) {
+                (0, core_1.LogStatus)(`✅ Schema validation passed for prompt ${promptId}`);
+            }
+            else {
+                (0, core_1.LogStatus)(`❌ Schema validation found ${validationErrors.length} errors for prompt ${promptId}:`);
+                validationErrors.forEach((error, index) => {
+                    (0, core_1.LogStatus)(`   ${index + 1}. ${error.Source}: ${error.Message}`);
+                });
+            }
+        }
+        catch (error) {
+            const validationError = new core_1.ValidationErrorInfo('validation', `Unexpected validation error: ${error.message}`, undefined, core_1.ValidationErrorType.Failure);
+            validationErrors.push(validationError);
+        }
+        return validationErrors;
+    }
     async parseAndValidateResult(modelResult, prompt, skipValidation = false) {
         try {
             if (!modelResult.success) {
@@ -330,13 +797,15 @@ class AIPromptRunner {
                 case 'string':
                     parsedResult = rawOutput.toString();
                     break;
-                case 'number':
-                    parsedResult = parseFloat(rawOutput);
-                    if (isNaN(parsedResult)) {
+                case 'number': {
+                    const numberResult = parseFloat(rawOutput);
+                    if (isNaN(numberResult)) {
                         throw new Error(`Expected number output but got: ${rawOutput}`);
                     }
+                    parsedResult = numberResult;
                     break;
-                case 'boolean':
+                }
+                case 'boolean': {
                     const lowerOutput = rawOutput.toLowerCase().trim();
                     if (['true', 'yes', '1'].includes(lowerOutput)) {
                         parsedResult = true;
@@ -348,12 +817,15 @@ class AIPromptRunner {
                         throw new Error(`Expected boolean output but got: ${rawOutput}`);
                     }
                     break;
-                case 'date':
-                    parsedResult = new Date(rawOutput);
-                    if (isNaN(parsedResult.getTime())) {
+                }
+                case 'date': {
+                    const dateResult = new Date(rawOutput);
+                    if (isNaN(dateResult.getTime())) {
                         throw new Error(`Expected date output but got: ${rawOutput}`);
                     }
+                    parsedResult = dateResult;
                     break;
+                }
                 case 'object':
                     try {
                         parsedResult = JSON.parse(rawOutput);
@@ -385,18 +857,45 @@ class AIPromptRunner {
             }
         }
     }
-    async updatePromptRun(promptRun, modelResult, parsedResult, endTime, executionTimeMS) {
+    async updatePromptRun(promptRun, modelResult, parsedResult, endTime, executionTimeMS, validationAttempts) {
         try {
             promptRun.CompletedAt = endTime;
             promptRun.ExecutionTimeMS = executionTimeMS;
-            promptRun.Result = typeof parsedResult.result === 'string'
-                ? parsedResult.result
-                : JSON.stringify(parsedResult.result);
+            promptRun.Result = typeof parsedResult.result === 'string' ? parsedResult.result : JSON.stringify(parsedResult.result);
             if (modelResult.data?.usage) {
                 promptRun.TokensUsed = modelResult.data.usage.totalTokens;
                 promptRun.TokensPrompt = modelResult.data.usage.promptTokens;
                 promptRun.TokensCompletion = modelResult.data.usage.completionTokens;
             }
+            if (validationAttempts && validationAttempts.length > 0) {
+                try {
+                    const currentMessages = promptRun.Messages ? JSON.parse(promptRun.Messages) : {};
+                    currentMessages.validationSummary = {
+                        totalAttempts: validationAttempts.length,
+                        successfulAttempts: validationAttempts.filter(a => a.success).length,
+                        finalValidationSuccess: parsedResult.validationResult?.Success || false,
+                        validationBehavior: promptRun.Messages ? 'Logged during execution' : 'Updated at completion',
+                        outputType: currentMessages.data?.prompt?.OutputType || 'unknown',
+                        hasOutputExample: !!(currentMessages.data?.prompt?.OutputExample),
+                        schemaValidationUsed: !!(currentMessages.data?.prompt?.OutputExample && currentMessages.data?.prompt?.OutputType === 'object'),
+                        retryStrategy: currentMessages.data?.prompt?.RetryStrategy || 'Fixed',
+                        maxRetries: currentMessages.data?.prompt?.MaxRetries || 0,
+                        finalValidationErrors: parsedResult.validationResult?.Errors?.map(e => ({
+                            source: e.Source,
+                            message: e.Message,
+                            type: e.Type,
+                            value: e.Value
+                        })) || [],
+                        validationDecision: this.getValidationDecisionDescription(parsedResult.validationResult?.Success || false, validationAttempts.length, currentMessages.data?.prompt?.ValidationBehavior || 'Warn')
+                    };
+                    promptRun.Messages = JSON.stringify(currentMessages);
+                    (0, core_1.LogStatus)(`Updated prompt run ${promptRun.ID} with ${validationAttempts.length} validation attempts`);
+                }
+                catch (jsonError) {
+                    (0, core_1.LogError)(`Error updating Messages field with validation info: ${jsonError.message}`);
+                }
+            }
+            promptRun.Success = modelResult.success && (parsedResult.validationResult?.Success !== false);
             const saveResult = await promptRun.Save();
             if (!saveResult) {
                 (0, core_1.LogError)(`Failed to update AIPromptRun with results: ${promptRun.LatestResult?.Message || 'Unknown error'}`);
@@ -408,6 +907,8 @@ class AIPromptRunner {
     }
 }
 exports.AIPromptRunner = AIPromptRunner;
+AIPromptRunner._schemaCache = new Map();
+AIPromptRunner._ajvInstance = null;
 function LoadAIPromptRunner() {
 }
 exports.LoadAIPromptRunner = LoadAIPromptRunner;