@memberjunction/ai-prompts 2.47.0 → 2.49.0

package/dist/AIPromptRunner.js

@@ -3,7 +3,7 @@ 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;
+exports.LoadAIPromptRunner = exports.AIPromptRunner = exports.AIPromptParams = void 0;
 const ai_1 = require("@memberjunction/ai");
 const core_1 = require("@memberjunction/core");
 const global_1 = require("@memberjunction/global");
@@ -12,12 +12,9 @@ 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;
-class AIPromptRunResult {
-}
-exports.AIPromptRunResult = AIPromptRunResult;
+const SystemPlaceholders_1 = require("./SystemPlaceholders");
+var types_1 = require("./types");
+Object.defineProperty(exports, "AIPromptParams", { enumerable: true, get: function () { return types_1.AIPromptParams; } });
 class AIPromptRunner {
     constructor() {
         this._metadata = new core_1.Metadata();
@@ -43,7 +40,7 @@ class AIPromptRunner {
         const startTime = new Date();
         const promptRun = null;
         if (params.cancellationToken?.aborted) {
-            return {
+            const result = {
                 success: false,
                 status: 'cancelled',
                 cancelled: true,
@@ -51,7 +48,10 @@ class AIPromptRunner {
                 errorMessage: 'Prompt execution was cancelled before starting',
                 executionTimeMS: 0,
                 chatResult: { success: false, errorMessage: 'Prompt execution was cancelled before starting' },
+                tokensUsed: 0,
+                combinedTokensUsed: 0
             };
+            return result;
         }
         try {
             const prompt = params.prompt;
@@ -62,13 +62,28 @@ class AIPromptRunner {
                 throw new Error(`Prompt ${prompt.Name} is not active (Status: ${prompt.Status})`);
             }
             let renderedPromptText = '';
-            if (prompt.TemplateID && (!params.conversationMessages || params.templateMessageRole !== 'none')) {
+            let parentPromptRun;
+            let selectedModel;
+            let childTemplateRenderingResult;
+            if (params.childPrompts && params.childPrompts.length > 0) {
+                (0, core_1.LogStatus)(`🌳 Composing prompt with ${params.childPrompts.length} child templates in hierarchical mode`);
+                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}`);
+                }
+                parentPromptRun = await this.createPromptRun(prompt, selectedModel, params, startTime, params.vendorId);
+                (0, core_1.LogStatus)(`📝 Created prompt run ${parentPromptRun.ID} for hierarchical template composition`);
+                childTemplateRenderingResult = await this.renderChildPromptTemplates(params.childPrompts, params, params.cancellationToken);
+                renderedPromptText = await this.renderPromptWithChildTemplates(prompt, params, childTemplateRenderingResult.renderedTemplates);
+                (0, core_1.LogStatus)(`✅ Hierarchical template composition completed with ${Object.keys(childTemplateRenderingResult.renderedTemplates).length} child templates embedded`);
+            }
+            else 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);
+                const renderedPrompt = await this.renderPromptTemplate(template, params);
                 if (!renderedPrompt.Success) {
                     throw new Error(`Failed to render template for prompt ${prompt.Name}: ${renderedPrompt.Message}`);
                 }
@@ -78,12 +93,14 @@ class AIPromptRunner {
                 throw new Error('Prompt execution was cancelled during template rendering');
             }
             const shouldUseParallelExecution = prompt.ParallelizationMode && prompt.ParallelizationMode !== 'None';
+            let result;
             if (shouldUseParallelExecution) {
-                return await this.executePromptInParallel(prompt, renderedPromptText, params, startTime);
+                result = await this.executePromptInParallel(prompt, renderedPromptText, params, startTime, parentPromptRun);
             }
             else {
-                return await this.executeSinglePrompt(prompt, renderedPromptText, params, startTime);
+                result = await this.executeSinglePrompt(prompt, renderedPromptText, params, startTime, parentPromptRun, selectedModel);
             }
+            return result;
         }
         catch (error) {
             (0, core_1.LogError)(error);
@@ -98,27 +115,30 @@ class AIPromptRunner {
                     (0, core_1.LogError)(`Failed to save error to AIPromptRun: ${promptRun.LatestResult?.Message || 'Unknown error'}`);
                 }
             }
-            return {
+            const errorResult = {
                 success: false,
                 errorMessage: error.message,
                 promptRun,
                 executionTimeMS,
                 chatResult: { success: false, errorMessage: error.message },
+                tokensUsed: 0,
+                combinedTokensUsed: 0
             };
+            return errorResult;
         }
     }
-    async executeSinglePrompt(prompt, renderedPromptText, params, startTime) {
+    async executeSinglePrompt(prompt, renderedPromptText, params, startTime, existingPromptRun, existingModel) {
         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);
+        const selectedModel = existingModel || 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 promptRun = existingPromptRun || await this.createPromptRun(prompt, selectedModel, params, startTime, params.vendorId);
         if (params.cancellationToken?.aborted) {
             throw new Error('Prompt execution was cancelled before model execution');
         }
@@ -127,6 +147,7 @@ class AIPromptRunner {
         const executionTimeMS = endTime.getTime() - startTime.getTime();
         await this.updatePromptRun(promptRun, modelResult, parsedResult, endTime, executionTimeMS, validationAttempts);
         const chatResult = modelResult;
+        const usage = chatResult.data?.usage;
         return {
             success: true,
             rawResult: chatResult.data?.choices?.[0]?.message?.content,
@@ -134,12 +155,17 @@ class AIPromptRunner {
             chatResult,
             promptRun,
             executionTimeMS,
-            tokensUsed: chatResult.data?.usage?.totalTokens,
+            promptTokens: usage?.promptTokens,
+            completionTokens: usage?.completionTokens,
+            tokensUsed: (usage?.promptTokens || 0) + (usage?.completionTokens || 0),
+            cost: usage?.cost,
+            costCurrency: usage?.costCurrency,
             validationResult: parsedResult.validationResult,
             validationAttempts,
+            combinedTokensUsed: (usage?.promptTokens || 0) + (usage?.completionTokens || 0)
         };
     }
-    async executePromptInParallel(prompt, renderedPromptText, params, startTime) {
+    async executePromptInParallel(prompt, renderedPromptText, params, startTime, existingPromptRun) {
         if (params.cancellationToken?.aborted) {
             throw new Error('Parallel execution was cancelled before starting');
         }
@@ -154,7 +180,7 @@ class AIPromptRunner {
         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);
+        const parallelResult = await this._parallelCoordinator.executeTasksInParallel(executionTasks, undefined, undefined, params.cancellationToken, undefined, params.agentRunId);
         if (!parallelResult.success) {
             throw new Error(`Parallel execution failed: ${parallelResult.errors.join(', ')}`);
         }
@@ -173,12 +199,38 @@ class AIPromptRunner {
                 selectedResult = aiSelectedResult;
             }
         }
-        const consolidatedPromptRun = await this.createPromptRun(prompt, selectedResult.task.model, params, startTime, params.vendorId);
+        let totalPromptTokens = 0;
+        let totalCompletionTokens = 0;
+        let totalCost = 0;
+        let hasCost = false;
+        for (const result of successfulResults) {
+            const usage = result.modelResult?.data?.usage;
+            if (usage) {
+                totalPromptTokens += usage.promptTokens || 0;
+                totalCompletionTokens += usage.completionTokens || 0;
+                if (usage.cost !== undefined) {
+                    totalCost += usage.cost;
+                    hasCost = true;
+                }
+            }
+        }
+        const consolidatedPromptRun = existingPromptRun || await this.createPromptRun(prompt, selectedResult.task.model, params, startTime, params.vendorId);
         const endTime = new Date();
         consolidatedPromptRun.CompletedAt = endTime;
         consolidatedPromptRun.ExecutionTimeMS = parallelResult.totalExecutionTimeMS;
         consolidatedPromptRun.Result = selectedResult.rawResult || '';
         consolidatedPromptRun.TokensUsed = parallelResult.totalTokensUsed;
+        const selectedResultUsage = selectedResult.modelResult?.data?.usage;
+        if (selectedResultUsage) {
+            consolidatedPromptRun.TokensPrompt = selectedResultUsage.promptTokens;
+            consolidatedPromptRun.TokensCompletion = selectedResultUsage.completionTokens;
+            if (selectedResultUsage.cost !== undefined) {
+                consolidatedPromptRun.Cost = selectedResultUsage.cost;
+            }
+            if (selectedResultUsage.costCurrency !== undefined) {
+                consolidatedPromptRun.CostCurrency = selectedResultUsage.costCurrency;
+            }
+        }
         const parallelMetadata = {
             parallelizationMode: prompt.ParallelizationMode,
             totalTasks: executionTasks.length,
@@ -194,6 +246,12 @@ class AIPromptRunner {
                 parallelExecution: parallelMetadata,
             });
         }
+        consolidatedPromptRun.TokensPromptRollup = totalPromptTokens;
+        consolidatedPromptRun.TokensCompletionRollup = totalCompletionTokens;
+        consolidatedPromptRun.TokensUsedRollup = totalPromptTokens + totalCompletionTokens;
+        if (hasCost) {
+            consolidatedPromptRun.TotalCost = totalCost;
+        }
         const saveResult = await consolidatedPromptRun.Save();
         if (!saveResult) {
             (0, core_1.LogError)(`Failed to save consolidated AIPromptRun: ${consolidatedPromptRun.LatestResult?.Message || 'Unknown error'}`);
@@ -209,13 +267,18 @@ class AIPromptRunner {
             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 };
+                const resultUsage = result.modelResult?.data?.usage;
                 additionalResults.push({
                     success: result.success,
                     rawResult: result.rawResult,
                     result: parsedResult.result,
                     chatResult: result.modelResult,
                     executionTimeMS: result.executionTimeMS,
-                    tokensUsed: result.tokensUsed,
+                    promptTokens: resultUsage?.promptTokens,
+                    completionTokens: resultUsage?.completionTokens,
+                    tokensUsed: (resultUsage?.promptTokens || 0) + (resultUsage?.completionTokens || 0),
+                    cost: resultUsage?.cost,
+                    costCurrency: resultUsage?.costCurrency,
                     validationResult: parsedResult.validationResult,
                     ranking: result.ranking,
                     judgeRationale: result.judgeRationale,
@@ -225,11 +288,13 @@ class AIPromptRunner {
                         vendorId: undefined,
                         vendorName: result.task.model.Vendor,
                     },
+                    combinedTokensUsed: (resultUsage?.promptTokens || 0) + (resultUsage?.completionTokens || 0)
                 });
             }
         }
         const { result: selectedResultData, validationResult: selectedValidationResult } = await this.parseAndValidateResultEnhanced(selectedResult.modelResult, prompt, params.skipValidation);
         const selectedParsedResult = { result: selectedResultData, validationResult: selectedValidationResult };
+        const selectedUsage = selectedResult.modelResult?.data?.usage;
         return {
             success: true,
             rawResult: selectedResult.rawResult,
@@ -237,7 +302,15 @@ class AIPromptRunner {
             chatResult: selectedResult.modelResult,
             promptRun: consolidatedPromptRun,
             executionTimeMS: parallelResult.totalExecutionTimeMS,
-            tokensUsed: parallelResult.totalTokensUsed,
+            promptTokens: selectedUsage?.promptTokens,
+            completionTokens: selectedUsage?.completionTokens,
+            tokensUsed: (selectedUsage?.promptTokens || 0) + (selectedUsage?.completionTokens || 0),
+            cost: selectedUsage?.cost,
+            costCurrency: selectedUsage?.costCurrency,
+            combinedPromptTokens: totalPromptTokens,
+            combinedCompletionTokens: totalCompletionTokens,
+            combinedTokensUsed: totalPromptTokens + totalCompletionTokens,
+            combinedCost: hasCost ? totalCost : undefined,
             validationResult: selectedParsedResult.validationResult,
             additionalResults: additionalResults.length > 0 ? additionalResults : undefined,
             ranking: selectedResult.ranking || 1,
@@ -261,6 +334,115 @@ class AIPromptRunner {
             return null;
         }
     }
+    async renderChildPromptTemplates(childPrompts, params, cancellationToken) {
+        if (!childPrompts || childPrompts.length === 0) {
+            return {
+                renderedTemplates: {}
+            };
+        }
+        if (cancellationToken?.aborted) {
+            throw new Error('Child prompt execution was cancelled');
+        }
+        (0, core_1.LogStatus)(`🔄 Rendering ${childPrompts.length} child prompt templates in parallel`);
+        const childRenderingPromises = childPrompts.map(async (childParam) => {
+            try {
+                if (cancellationToken?.aborted) {
+                    throw new Error('Child prompt template rendering was cancelled');
+                }
+                let childData = { ...childParam.childPrompt.data };
+                if (childParam.childPrompt.childPrompts && childParam.childPrompt.childPrompts.length > 0) {
+                    const grandchildResults = await this.renderChildPromptTemplates(childParam.childPrompt.childPrompts, params, cancellationToken);
+                    childData = { ...childData, ...grandchildResults.renderedTemplates };
+                }
+                (0, core_1.LogStatus)(`  🔹 Rendering child prompt template: ${childParam.childPrompt.prompt.Name} -> ${childParam.parentPlaceholder}`);
+                const childPrompt = childParam.childPrompt.prompt;
+                let renderedChildTemplate = '';
+                if (childPrompt.TemplateID) {
+                    await this._templateEngine.Config(false, params.contextUser);
+                    const template = await this.loadTemplate(childPrompt.TemplateID, params.contextUser);
+                    if (!template) {
+                        throw new Error(`Template with ID ${childPrompt.TemplateID} not found for child prompt ${childPrompt.Name}`);
+                    }
+                    const mergedChildData = {
+                        ...params.data,
+                        ...childData,
+                        ...childParam.childPrompt.templateData
+                    };
+                    const childRenderResult = await this.renderPromptTemplate(template, {
+                        ...params,
+                        data: mergedChildData,
+                        templateData: childParam.childPrompt.templateData
+                    });
+                    if (!childRenderResult.Success) {
+                        throw new Error(`Failed to render child template for prompt ${childPrompt.Name}: ${childRenderResult.Message}`);
+                    }
+                    renderedChildTemplate = childRenderResult.Output;
+                }
+                else {
+                    renderedChildTemplate = '';
+                }
+                return {
+                    placeholder: childParam.parentPlaceholder,
+                    renderedTemplate: renderedChildTemplate,
+                    success: true
+                };
+            }
+            catch (error) {
+                (0, core_1.LogError)(`Error rendering child prompt template for placeholder ${childParam.parentPlaceholder}: ${error.message}`);
+                return {
+                    placeholder: childParam.parentPlaceholder,
+                    renderedTemplate: `ERROR: ${error.message}`,
+                    success: false
+                };
+            }
+        });
+        const childResults = await Promise.all(childRenderingPromises);
+        const failedChildren = childResults.filter(r => !r.success);
+        if (failedChildren.length > 0) {
+            (0, core_1.LogError)(`${failedChildren.length} out of ${childResults.length} child prompt templates failed to render`);
+        }
+        const renderedTemplatesMap = {};
+        for (const childResult of childResults) {
+            renderedTemplatesMap[childResult.placeholder] = childResult.renderedTemplate;
+        }
+        (0, core_1.LogStatus)(`✅ Completed rendering of ${childResults.length} child prompt templates`);
+        return {
+            renderedTemplates: renderedTemplatesMap
+        };
+    }
+    async renderPromptWithChildTemplates(prompt, params, childTemplates) {
+        if (!prompt.TemplateID) {
+            return '';
+        }
+        try {
+            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 systemPlaceholders = await SystemPlaceholders_1.SystemPlaceholderManager.resolveAllPlaceholders(params);
+            const mergedData = {
+                ...systemPlaceholders,
+                ...params.data,
+                ...childTemplates,
+                ...params.templateData
+            };
+            (0, core_1.LogStatus)(`🔧 Rendering prompt template with ${Object.keys(childTemplates).length} child templates and ${Object.keys(systemPlaceholders).length} system placeholders`);
+            for (const [placeholder, template] of Object.entries(childTemplates)) {
+                const truncatedTemplate = template.length > 100 ? template.substring(0, 100) + '...' : template;
+                (0, core_1.LogStatus)(`  📝 ${placeholder} -> ${truncatedTemplate}`);
+            }
+            const renderedPrompt = await this._templateEngine.RenderTemplate(template, template.GetHighestPriorityContent(), mergedData);
+            if (!renderedPrompt.Success) {
+                throw new Error(`Failed to render template for prompt ${prompt.Name}: ${renderedPrompt.Message}`);
+            }
+            return renderedPrompt.Output;
+        }
+        catch (error) {
+            (0, core_1.LogError)(`Error rendering prompt with child templates: ${error.message}`);
+            throw error;
+        }
+    }
     async selectModel(prompt, explicitModelId, contextUser, configurationId, vendorId) {
         try {
             await aiengine_1.AIEngine.Instance.Config(false, contextUser);
@@ -336,8 +518,8 @@ class AIPromptRunner {
         }
     }
     async createPromptRun(prompt, model, params, startTime, vendorId) {
+        const promptRun = await this._metadata.GetEntityObject('MJ: AI Prompt Runs', params.contextUser);
         try {
-            const promptRun = await this._metadata.GetEntityObject('MJ: AI Prompt Runs', params.contextUser);
             promptRun.NewRecord();
             promptRun.PromptID = prompt.ID;
             promptRun.ModelID = model.ID;
@@ -353,6 +535,12 @@ class AIPromptRunner {
             }
             promptRun.ConfigurationID = params.configurationId;
             promptRun.RunAt = startTime;
+            if (params.agentRunId) {
+                promptRun.AgentRunID = params.agentRunId;
+            }
+            if (params.parentPromptRunId) {
+                promptRun.ParentID = params.parentPromptRunId;
+            }
             if (params.data || params.templateData) {
                 promptRun.Messages = JSON.stringify({
                     data: params.data,
@@ -368,17 +556,24 @@ class AIPromptRunner {
             return promptRun;
         }
         catch (error) {
-            (0, core_1.LogError)(`Error creating prompt run record: ${error.message}`);
-            throw error;
+            const msg = `Error creating prompt run record: ${error.message} - ${promptRun?.LatestResult?.Message} - ${promptRun?.LatestResult?.Errors[0]?.Message}`;
+            (0, core_1.LogError)(msg);
+            throw new Error(msg);
         }
     }
-    async renderPromptTemplate(template, data, templateData) {
+    async renderPromptTemplate(template, params) {
         try {
             const templateContent = template.GetHighestPriorityContent();
             if (!templateContent) {
                 throw new Error(`No content found for template ${template.Name}`);
             }
-            const mergedData = { ...data, ...templateData };
+            const systemPlaceholders = await SystemPlaceholders_1.SystemPlaceholderManager.resolveAllPlaceholders(params);
+            const mergedData = {
+                ...systemPlaceholders,
+                ...params.data,
+                ...params.templateData
+            };
+            (0, core_1.LogStatus)(`🔧 Rendering template '${template.Name}' with ${Object.keys(systemPlaceholders).length} system placeholders`);
             return await this._templateEngine.RenderTemplate(template, templateContent, mergedData);
         }
         catch (error) {
@@ -474,7 +669,6 @@ class AIPromptRunner {
                 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 },
@@ -683,7 +877,7 @@ class AIPromptRunner {
                     }
                     case 'object':
                         try {
-                            parsedResult = JSON.parse(rawOutput);
+                            parsedResult = JSON.parse((0, global_1.CleanJSON)(rawOutput));
                         }
                         catch (jsonError) {
                             const error = new core_1.ValidationErrorInfo('output', `Expected JSON object but got invalid JSON: ${rawOutput}`, rawOutput, core_1.ValidationErrorType.Failure);
@@ -788,80 +982,6 @@ class AIPromptRunner {
         }
         return validationErrors;
     }
-    async parseAndValidateResult(modelResult, prompt, skipValidation = false) {
-        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;
-            switch (prompt.OutputType) {
-                case 'string':
-                    parsedResult = rawOutput.toString();
-                    break;
-                case 'number': {
-                    const numberResult = parseFloat(rawOutput);
-                    if (isNaN(numberResult)) {
-                        throw new Error(`Expected number output but got: ${rawOutput}`);
-                    }
-                    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 {
-                        throw new Error(`Expected boolean output but got: ${rawOutput}`);
-                    }
-                    break;
-                }
-                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);
-                    }
-                    catch (jsonError) {
-                        throw new Error(`Expected JSON object but got invalid JSON: ${rawOutput}`);
-                    }
-                    break;
-                default:
-                    parsedResult = rawOutput;
-            }
-            const validationResult = new core_1.ValidationResult();
-            validationResult.Success = true;
-            if (!skipValidation && prompt.OutputExample && prompt.OutputType === 'object') {
-            }
-            return { result: parsedResult, validationResult };
-        }
-        catch (error) {
-            (0, core_1.LogError)(`Error parsing/validating result: ${error.message}`);
-            switch (prompt.ValidationBehavior) {
-                case 'Strict':
-                    throw error;
-                case 'Warn':
-                    (0, core_1.LogError)(`Validation warning for prompt ${prompt.Name}: ${error.message}`);
-                    return { result: modelResult.data?.choices?.[0]?.message?.content };
-                case 'None':
-                default:
-                    return { result: modelResult.data?.choices?.[0]?.message?.content };
-            }
-        }
-    }
     async updatePromptRun(promptRun, modelResult, parsedResult, endTime, executionTimeMS, validationAttempts) {
         try {
             promptRun.CompletedAt = endTime;
@@ -871,6 +991,12 @@ class AIPromptRunner {
                 promptRun.TokensUsed = modelResult.data.usage.totalTokens;
                 promptRun.TokensPrompt = modelResult.data.usage.promptTokens;
                 promptRun.TokensCompletion = modelResult.data.usage.completionTokens;
+                if (modelResult.data.usage.cost !== undefined) {
+                    promptRun.Cost = modelResult.data.usage.cost;
+                }
+                if (modelResult.data.usage.costCurrency !== undefined) {
+                    promptRun.CostCurrency = modelResult.data.usage.costCurrency;
+                }
             }
             if (validationAttempts && validationAttempts.length > 0) {
                 try {
@@ -901,6 +1027,12 @@ class AIPromptRunner {
                 }
             }
             promptRun.Success = modelResult.success && (parsedResult.validationResult?.Success !== false);
+            promptRun.TokensPromptRollup = promptRun.TokensPrompt;
+            promptRun.TokensCompletionRollup = promptRun.TokensCompletion;
+            promptRun.TokensUsedRollup = promptRun.TokensUsed;
+            if (promptRun.Cost !== undefined) {
+                promptRun.TotalCost = promptRun.Cost;
+            }
             const saveResult = await promptRun.Save();
             if (!saveResult) {
                 (0, core_1.LogError)(`Failed to update AIPromptRun with results: ${promptRun.LatestResult?.Message || 'Unknown error'}`);