@memberjunction/ai-prompts 6.1.4 → 6.2.0-edge.1

package/dist/AIPromptRunner.js

@@ -1,16 +1,18 @@
-import { BaseLLM, ChatParams, ChatMessageRole, GetAIAPIKey, ErrorAnalyzer, ResolveFileInputStrategy, EncodeToolTurnsAsText } from '@memberjunction/ai';
+import { BaseLLM, ChatParams, ChatMessageRole, ErrorAnalyzer, ResolveFileInputStrategy, EncodeToolTurnsAsText } from '@memberjunction/ai';
+import { BaseModelRunner, } from './BaseModelRunner.js';
 import { GetToolCallingDecision, GetToolCallingMode, RecordToolCallingDecision, RecordToolCallingMode, ResolveNativeToolCalling } from './nativeToolCallingGate.js';
 import { AIModelRunner } from './AIModelRunner.js';
 import { AIModelSelectionInfo } from '@memberjunction/ai-core-plus';
-import { BaseEntitySaveQueue, LogErrorEx, LogStatus, LogStatusEx, IsVerboseLoggingEnabled, Metadata } from '@memberjunction/core';
+import { LogStatus, IsVerboseLoggingEnabled, Metadata } from '@memberjunction/core';
 import { CleanJSON, RepairJSONEscaping, MJGlobal, JSONValidator, ValidationResult, ValidationErrorInfo, ValidationErrorType, UUIDsEqual, NormalizeUUID } from '@memberjunction/global';
-import { CredentialEngine } from '@memberjunction/credentials';
 import { TemplateEngineServer } from '@memberjunction/templates';
 import { ExecutionPlanner } from './ExecutionPlanner.js';
 import { AIPromptTimeoutError } from './AIPromptTimeoutError.js';
+import { ParseManifestEntryMime, TrimSpacesAndTabs } from './linearTextScan.js';
 import { AIEngine } from '@memberjunction/aiengine';
 import { AIEngineBase } from '@memberjunction/ai-engine-base';
 import { SystemPlaceholderManager } from '@memberjunction/ai-core-plus';
+import { ResolvePromptRunUserID } from '@memberjunction/ai-core-plus';
 // json5 is a CJS module: under this package's ESM output its import namespace has no
 // `parse` — only the default export does. `import * as JSON5` made JSON5.parse
 // undefined at runtime ("JSON5.parse is not a function"), silently disabling the
@@ -30,7 +32,17 @@ function mimeFromBlockType(type) {
         default: return 'application/octet-stream';
     }
 }
-export class AIPromptRunner {
+export class AIPromptRunner extends BaseModelRunner {
+    /**
+     * The model type this runner requires. Returns 'LLM' for AIPromptRunner.
+     */
+    get RequiredModelType() {
+        return 'LLM';
+    }
+    /** Keeps this runner's uncategorized errors logged under `AIPromptRunner`, as before the base class existed. */
+    get DefaultLogCategory() {
+        return 'AIPromptRunner';
+    }
     /**
      * Process-wide cache of parsed `OutputExample` JSON, keyed by the raw example string.
      * A prompt's OutputExample is a static string reused across every run and every validation
@@ -46,29 +58,8 @@ export class AIPromptRunner {
      * already been selected. See the DECISION note in {@link selectModelWithAPIKeyTracked}.
      */
     static { this.NOT_EVALUATED_REASON = 'Not evaluated (a higher-priority candidate was already selected; set AIPromptParams.forceFullModelEvaluation to probe all)'; }
-    /**
-     * Optional metadata provider override. Callers should set
-     * `instance.Provider = providerToUse` before invoking run methods
-     * in multi-provider contexts. Falls back to the global default provider when unset.
-     */
-    get Provider() {
-        return this._provider ?? this._metadata;
-    }
-    set Provider(value) {
-        this._provider = value;
-    }
     constructor() {
-        this._provider = null;
-        /**
-         * Fire-and-forget AIPromptRun persistence. Prompt-run logging never blocks the execution path on a
-         * DB round-trip; the shared {@link BaseEntitySaveQueue} sequences saves for the SAME entity (the
-         * initial 'Running' INSERT always completes before the finalize UPDATE, and the finalize mutation
-         * runs INSIDE the post-INSERT task so a slow INSERT can never clobber the finalized row). Failures
-         * stay in this runner's structured log stream via the queue's `onError` hook.
-         */
-        this._promptRunQueue = new BaseEntitySaveQueue({
-            onError: (message) => this.logError(message, { category: 'PromptRunSave' }),
-        });
+        super();
         this._metadata = this._provider ?? new Metadata();
         this._templateEngine = TemplateEngineServer.Instance;
         this._executionPlanner = new ExecutionPlanner();
@@ -109,324 +100,6 @@ export class AIPromptRunner {
     get ModelRunner() {
         return this._modelRunner;
     }
-    /**
-     * Performs robust validation of an API key
-     * @returns true if the API key is valid (not null, undefined, or empty/whitespace)
-     */
-    isValidAPIKey(apiKey) {
-        if (apiKey === undefined || apiKey === null) {
-            return false;
-        }
-        // Check if it's just whitespace
-        const trimmed = apiKey.trim();
-        return trimmed.length > 0;
-    }
-    /**
-     * Internal logging helper that wraps LogStatusEx with verbose control
-     * @param message The message to log
-     * @param verboseOnly Whether this is a verbose-only message
-     * @param params Optional prompt parameters for custom verbose check
-     */
-    logStatus(message, verboseOnly = false, params) {
-        if (verboseOnly) {
-            LogStatusEx({
-                message,
-                verboseOnly: true,
-                isVerboseEnabled: () => params?.verbose === true || IsVerboseLoggingEnabled()
-            });
-        }
-        else {
-            LogStatus(message);
-        }
-    }
-    /**
-     * Helper method for enhanced error logging with metadata
-     */
-    logError(error, options) {
-        let errorMessage = error instanceof Error ? error.message : error;
-        const errorObj = error instanceof Error ? error : undefined;
-        // Truncate extremely long error messages (like Groq's failed_generation JSON dumps)
-        // Only truncate if maxErrorLength is explicitly set
-        if (options?.maxErrorLength !== undefined && errorMessage.length > options.maxErrorLength) {
-            errorMessage = errorMessage.substring(0, options.maxErrorLength) + '... [truncated]';
-        }
-        const metadata = {
-            ...options?.metadata
-        };
-        // Add prompt information if available
-        if (options?.prompt) {
-            metadata.promptId = options.prompt.ID;
-            metadata.promptName = options.prompt.Name;
-        }
-        // Add model information if available
-        if (options?.model) {
-            metadata.modelId = options.model.ID;
-            metadata.modelName = options.model.Name;
-        }
-        LogErrorEx({
-            message: errorMessage,
-            error: errorObj,
-            category: options?.category || 'AIPromptRunner',
-            severity: options?.severity || 'error',
-            metadata: Object.keys(metadata).length > 0 ? metadata : undefined
-        });
-    }
-    /**
-     * Checks if a model vendor is configured as an inference provider.
-     * Delegates to the memoized {@link AIEngine.IsInferenceProvider} helper so the
-     * "Inference Provider" vendor-type lookup happens once per engine load rather than on
-     * every candidate in every selection pass.
-     * @param modelVendor The model vendor to check
-     * @returns true if the vendor is an inference provider
-     */
-    isInferenceProvider(modelVendor) {
-        return AIEngine.Instance.IsInferenceProvider(modelVendor);
-    }
-    /**
-     * Resolves credentials for AI model execution using a hierarchical resolution system.
-     *
-     * Resolution priority (highest to lowest):
-     * 1. Per-request override: params.credentialId
-     * 2. Prompt-Model specific: AIPromptModel.CredentialID
-     * 3. Model-Vendor specific: AIModelVendor.CredentialID
-     * 4. Vendor default: AIVendor.CredentialID
-     * 5. Legacy: params.apiKeys[] array
-     * 6. Legacy: AI_VENDOR_API_KEY__<DRIVER> environment variables
-     *
-     * IMPORTANT: When ANY credential ID is found (priorities 1-4), the system uses
-     * the Credentials path and ignores legacy methods (priorities 5-6).
-     *
-     * @param driverClass - The driver class name (e.g., 'OpenAILLM')
-     * @param promptId - The prompt ID for looking up AIPromptModel credentials
-     * @param modelId - The model ID for looking up AIPromptModel and AIModelVendor credentials
-     * @param vendorId - The vendor ID for looking up AIModelVendor and AIVendor credentials
-     * @param params - The prompt execution parameters containing contextUser and optional credentialId
-     * @returns The API key/configuration string to pass to the LLM constructor
-     */
-    async resolveCredentialForExecution(driverClass, promptId, modelId, vendorId, params) {
-        const verbose = params.verbose === true || IsVerboseLoggingEnabled();
-        // Priority 1: Per-request override - no failover, explicit choice
-        if (params.credentialId) {
-            return await this.resolveCredentialById(params.credentialId, 'per-request override', params, verbose);
-        }
-        // Ensure CredentialEngine is configured for binding lookups
-        await CredentialEngine.Instance.Config(false, params.contextUser);
-        // Priority 2: PromptModel bindings (most specific) - with failover
-        if (promptId && modelId) {
-            const promptModel = AIEngine.Instance.PromptModels.find(pm => UUIDsEqual(pm.PromptID, promptId) && UUIDsEqual(pm.ModelID, modelId));
-            if (promptModel) {
-                const bindings = AIEngine.Instance.GetCredentialBindingsForTarget('PromptModel', promptModel.ID);
-                const result = await this.tryCredentialBindingsWithFailover(bindings, 'AICredentialBinding(PromptModel)', params, verbose);
-                if (result)
-                    return result;
-            }
-        }
-        // Priority 3: ModelVendor bindings - with failover
-        if (modelId && vendorId) {
-            const modelVendor = AIEngine.Instance.ModelVendorsByModelID.get(NormalizeUUID(modelId))
-                ?.find(mv => UUIDsEqual(mv.VendorID, vendorId) && mv.Status === 'Active');
-            if (modelVendor) {
-                const bindings = AIEngine.Instance.GetCredentialBindingsForTarget('ModelVendor', modelVendor.ID);
-                const result = await this.tryCredentialBindingsWithFailover(bindings, 'AICredentialBinding(ModelVendor)', params, verbose);
-                if (result)
-                    return result;
-            }
-        }
-        // Priority 4: Vendor bindings - with failover
-        if (vendorId) {
-            const bindings = AIEngine.Instance.GetCredentialBindingsForTarget('Vendor', vendorId);
-            const result = await this.tryCredentialBindingsWithFailover(bindings, 'AICredentialBinding(Vendor)', params, verbose);
-            if (result)
-                return result;
-        }
-        // Priority 5: Type-based default credential
-        // If the vendor declares a CredentialTypeID, try to find a default credential of that type
-        if (vendorId) {
-            const vendor = AIEngine.Instance.VendorsByID.get(NormalizeUUID(vendorId));
-            if (vendor?.CredentialTypeID) {
-                const defaultCredential = this.findDefaultCredentialByType(vendor.CredentialTypeID);
-                if (defaultCredential) {
-                    const result = await this.tryResolveCredential(defaultCredential, 'type-based default', params, verbose);
-                    if (result)
-                        return result;
-                }
-            }
-        }
-        // No credential bindings found - fall back to legacy methods
-        if (verbose) {
-            this.logStatus(`   Using legacy API key resolution for driver ${driverClass}`, true, params);
-        }
-        // Priority 6 & 7: Legacy apiKeys array and environment variables
-        return GetAIAPIKey(driverClass, params.apiKeys, verbose);
-    }
-    /**
-     * Attempts to resolve credentials from bindings with priority-based failover.
-     * Tries each binding in priority order until one succeeds.
-     */
-    async tryCredentialBindingsWithFailover(bindings, source, params, verbose) {
-        if (bindings.length === 0)
-            return null;
-        for (let i = 0; i < bindings.length; i++) {
-            const binding = bindings[i];
-            const credential = CredentialEngine.Instance.getCredentialById(binding.CredentialID);
-            if (!credential) {
-                if (verbose) {
-                    this.logStatus(`   ⚠️ Credential ${binding.CredentialID} not found (priority ${binding.Priority}), trying next...`, true, params);
-                }
-                continue;
-            }
-            const result = await this.tryResolveCredential(credential, `${source} priority ${binding.Priority}`, params, verbose, i < bindings.length - 1 // hasMoreBindings
-            );
-            if (result)
-                return result;
-        }
-        return null;
-    }
-    /**
-     * Attempts to resolve a single credential, returning null on failure for failover support.
-     */
-    async tryResolveCredential(credential, source, params, verbose, hasMoreBindings = false) {
-        try {
-            // Check if credential is active and not expired
-            if (!credential.IsActive) {
-                if (verbose) {
-                    this.logStatus(`   ⚠️ Credential "${credential.Name}" is inactive, trying next...`, true, params);
-                }
-                return null;
-            }
-            if (credential.ExpiresAt && new Date(credential.ExpiresAt) < new Date()) {
-                if (verbose) {
-                    this.logStatus(`   ⚠️ Credential "${credential.Name}" has expired, trying next...`, true, params);
-                }
-                return null;
-            }
-            // Resolve the credential values
-            const resolved = await CredentialEngine.Instance.getCredential(credential.Name, {
-                credentialId: credential.ID,
-                contextUser: params.contextUser,
-                subsystem: 'AIPromptRunner'
-            });
-            if (verbose) {
-                this.logStatus(`   🔐 Using credential from ${source}: "${credential.Name}"`, true, params);
-            }
-            return JSON.stringify(resolved.values);
-        }
-        catch (error) {
-            if (hasMoreBindings) {
-                // More bindings to try - log warning and continue
-                if (verbose) {
-                    this.logStatus(`   ⚠️ Failed to resolve credential "${credential.Name}" from ${source}: ${error instanceof Error ? error.message : String(error)}, trying next...`, true, params);
-                }
-                return null;
-            }
-            else {
-                // No more bindings - log error but still return null for legacy fallback
-                this.logError(error instanceof Error ? error : new Error(String(error)), {
-                    category: 'CredentialResolution',
-                    severity: 'warning',
-                    metadata: {
-                        credentialId: credential.ID,
-                        credentialName: credential.Name,
-                        source
-                    },
-                    maxErrorLength: params.maxErrorLength
-                });
-                return null;
-            }
-        }
-    }
-    /**
-     * Resolves a credential by its explicit ID (used for per-request override).
-     * This does not support failover since it's an explicit choice.
-     */
-    async resolveCredentialById(credentialId, source, params, verbose) {
-        await CredentialEngine.Instance.Config(false, params.contextUser);
-        const credential = CredentialEngine.Instance.getCredentialById(credentialId);
-        if (!credential) {
-            throw new Error(`Credential with ID ${credentialId} not found`);
-        }
-        const resolved = await CredentialEngine.Instance.getCredential(credential.Name, {
-            credentialId,
-            contextUser: params.contextUser,
-            subsystem: 'AIPromptRunner'
-        });
-        if (verbose) {
-            this.logStatus(`   🔐 Using credential from ${source}: "${credential.Name}"`, true, params);
-        }
-        return JSON.stringify(resolved.values);
-    }
-    /**
-     * Finds a default credential matching a specific credential type.
-     */
-    findDefaultCredentialByType(credentialTypeId) {
-        const credentials = CredentialEngine.Instance.Credentials;
-        return credentials.find(c => UUIDsEqual(c.CredentialTypeID, credentialTypeId) &&
-            c.IsDefault === true &&
-            c.IsActive === true &&
-            (!c.ExpiresAt || new Date(c.ExpiresAt) > new Date())) || null;
-    }
-    /**
-     * Checks if credentials are available for a given model-vendor combination.
-     * This is a pre-flight check used during model selection to determine which
-     * candidates have valid authentication configured.
-     *
-     * Checks the credential hierarchy:
-     * 1. Per-request override: params.credentialId
-     * 2. PromptModel bindings: AICredentialBinding WHERE BindingType='PromptModel'
-     * 3. ModelVendor bindings: AICredentialBinding WHERE BindingType='ModelVendor'
-     * 4. Vendor bindings: AICredentialBinding WHERE BindingType='Vendor'
-     * 5. Type-based default: Credential.IsDefault=1 matching AIVendor.CredentialTypeID
-     * 6. Legacy: params.apiKeys[] array
-     * 7. Legacy: AI_VENDOR_API_KEY__<DRIVER> environment variables
-     *
-     * @param driverClass - The driver class name (e.g., 'OpenAILLM')
-     * @param promptId - The prompt ID for looking up AIPromptModel bindings
-     * @param modelId - The model ID for looking up AIPromptModel and AIModelVendor bindings
-     * @param vendorId - The vendor ID for looking up AIModelVendor and AIVendor bindings
-     * @param params - The prompt execution parameters
-     * @returns true if credentials are available, false otherwise
-     */
-    hasCredentialsAvailable(driverClass, promptId, modelId, vendorId, params) {
-        // Priority 1: Per-request override
-        if (params?.credentialId) {
-            // Assume valid if credential ID is provided - will be validated at execution time
-            return true;
-        }
-        // Priority 2: PromptModel bindings
-        if (promptId && modelId) {
-            const promptModel = AIEngine.Instance.PromptModels.find(pm => UUIDsEqual(pm.PromptID, promptId) && UUIDsEqual(pm.ModelID, modelId));
-            if (promptModel && AIEngine.Instance.HasCredentialBindings('PromptModel', promptModel.ID)) {
-                return true;
-            }
-        }
-        // Priority 3: ModelVendor bindings
-        if (modelId && vendorId) {
-            const modelVendor = AIEngine.Instance.ModelVendorsByModelID.get(NormalizeUUID(modelId))
-                ?.find(mv => UUIDsEqual(mv.VendorID, vendorId) && mv.Status === 'Active');
-            if (modelVendor && AIEngine.Instance.HasCredentialBindings('ModelVendor', modelVendor.ID)) {
-                return true;
-            }
-        }
-        // Priority 4: Vendor bindings
-        if (vendorId) {
-            if (AIEngine.Instance.HasCredentialBindings('Vendor', vendorId)) {
-                return true;
-            }
-        }
-        // Priority 5: Type-based default credential
-        if (vendorId) {
-            const vendor = AIEngine.Instance.VendorsByID.get(NormalizeUUID(vendorId));
-            if (vendor?.CredentialTypeID) {
-                const defaultCredential = this.findDefaultCredentialByType(vendor.CredentialTypeID);
-                if (defaultCredential) {
-                    return true;
-                }
-            }
-        }
-        // Priority 6 & 7: Legacy methods - check if API key is available
-        const apiKey = GetAIAPIKey(driverClass, params?.apiKeys, params?.verbose);
-        return this.isValidAPIKey(apiKey);
-    }
     /**
      * Executes an AI prompt with full support for templates, model selection, and validation.
      *
@@ -518,7 +191,7 @@ export class AIPromptRunner {
                 // selected candidate's AIPromptModel bag. Resolving without those skips the two layers the
                 // capability is normally declared on and silently inverts the decision.
                 if (params.tools?.length) {
-                    const nativeDecision = this.resolveNativeToolCallingDecision(prompt, params, selection.model, selection.selectionInfo?.vendorSelected?.ID ?? params.override?.vendorId ?? null, selection.promptModelConfiguration);
+                    const nativeDecision = this.ResolveNativeToolCallingDecision(prompt, params, selection.model, selection.selectionInfo?.vendorSelected?.ID ?? params.override?.vendorId ?? null, selection.promptModelConfiguration);
                     params.data = {
                         ...(params.data ?? {}),
                         _NATIVE_TOOL_CALLING: nativeDecision.useNativeTools,
@@ -533,8 +206,10 @@ export class AIPromptRunner {
                     this.logStatus(`   Using system prompt override for prompt "${prompt.Name}" (bypassing hierarchical template rendering)`, true, params);
                 }
                 else {
-                    // Render all child prompt templates recursively
-                    childTemplateRenderingResult = await this.renderChildPromptTemplates(params.childPrompts, params, params.cancellationToken);
+                    // Render all child prompt templates recursively (or reuse pre-rendered templates)
+                    childTemplateRenderingResult = params.PreRenderedChildTemplates
+                        ? { renderedTemplates: params.PreRenderedChildTemplates }
+                        : await this.renderChildPromptTemplates(params.childPrompts, params, params.cancellationToken);
                     // Render the parent prompt with child templates embedded
                     renderedPromptText = await this.renderPromptWithChildTemplates(prompt, params, childTemplateRenderingResult.renderedTemplates);
                 }
@@ -678,7 +353,7 @@ export class AIPromptRunner {
         let promptModelConfiguration = existingSelection?.promptModelConfiguration;
         let allCandidates = existingSelection?.allCandidates ?? [];
         // Credential probes already done during selection — reused by failover so it doesn't
-        // recompute hasCredentialsAvailable for the prefix it walks before the selected candidate.
+        // recompute HasCredentialsAvailable for the prefix it walks before the selected candidate.
         let credentialAvailability = existingSelection?.credentialAvailability;
         if (!selectedModel) {
             // Determine which prompt to use for model selection
@@ -706,7 +381,7 @@ export class AIPromptRunner {
             throw new Error('Prompt execution was cancelled after model selection');
         }
         // Use existing prompt run if provided (hierarchical case) or create new one
-        const promptRun = existingPromptRun || await this.createPromptRun(prompt, selectedModel, params, renderedPromptText, startTime, params.override?.vendorId, modelSelectionInfo);
+        const promptRun = existingPromptRun || await this.createPromptRun(prompt, selectedModel, params, renderedPromptText, startTime, params.override?.vendorId, modelSelectionInfo, params.RunType);
         // Check for cancellation before model execution
         if (params.cancellationToken?.aborted) {
             throw new Error('Prompt execution was cancelled before model execution');
@@ -808,22 +483,43 @@ export class AIPromptRunner {
                 modelSelectionPrompt = params.modelSelectionPrompt;
                 this.logStatus(`   Using prompt "${modelSelectionPrompt.Name}" for model selection in parallel execution`, true, params);
             }
+            // Apply this runner's model-type floor to everything the planner may choose from: a prompt
+            // typed differently fails here, and neither the model pool nor the prompt's bindings can admit
+            // a model of another type (the planner's own filters treat an empty AIModelTypeID as "any").
+            this.AssertPromptMatchesRequiredType(prompt);
+            if (modelSelectionPrompt !== prompt) {
+                this.AssertPromptMatchesRequiredType(modelSelectionPrompt);
+            }
+            const requiredTypeId = this.RequiredModelTypeID();
+            const typedModels = AIEngine.Instance.Models.filter(m => UUIDsEqual(m.AIModelTypeID, requiredTypeId));
             // Get prompt-specific model associations using the model selection prompt
             const promptModels = AIEngine.Instance.PromptModels.filter((pm) => UUIDsEqual(pm.PromptID, modelSelectionPrompt.ID) &&
                 (pm.Status === 'Active' || pm.Status === 'Preview') &&
-                (!params.configurationId || !pm.ConfigurationID || UUIDsEqual(pm.ConfigurationID, params.configurationId)));
+                (!params.configurationId || !pm.ConfigurationID || UUIDsEqual(pm.ConfigurationID, params.configurationId)) &&
+                UUIDsEqual(AIEngine.Instance.ModelsByID.get(NormalizeUUID(pm.ModelID))?.AIModelTypeID, requiredTypeId));
             // Create execution plan using the modelSelectionPrompt for model configurations
-            executionTasks = this._executionPlanner.createExecutionPlan(modelSelectionPrompt, promptModels, AIEngine.Instance.Models, renderedPromptText, params.contextUser, params.configurationId, params.conversationMessages, params.templateMessageRole || 'system');
+            executionTasks = this._executionPlanner.createExecutionPlan(modelSelectionPrompt, promptModels, typedModels, 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 parallelUserId = ResolvePromptRunUserID({ UserID: params.UserID, ContextUser: params.contextUser }) ?? undefined;
+        for (const task of executionTasks) {
+            task.AgentID = params.agentId;
+            task.UserID = parallelUserId;
+        }
         // Check for cancellation before executing tasks
         if (params.cancellationToken?.aborted) {
             throw new Error('Parallel execution was cancelled before task execution');
         }
-        // Execute tasks in parallel
-        const parallelResult = await this.ParallelCoordinator.executeTasksInParallel(params, executionTasks, undefined, undefined, params.cancellationToken);
+        // 1. Create (or reuse existingPromptRun) the consolidated parent BEFORE parallel tasks run (§5.1).
+        // Use the first task's model for the initial ModelID; after selection, set ModelID/VendorID to the selected arm's.
+        const initialModel = existingSelection?.model || executionTasks[0].model;
+        const consolidatedPromptRun = existingPromptRun || await this.createPromptRun(prompt, initialModel, params, renderedPromptText, startTime, params.override?.vendorId, existingSelection?.selectionInfo, 'ParallelParent');
+        consolidatedPromptRun.RunType = 'ParallelParent';
+        consolidatedPromptRun.WasSelectedResult = false;
+        // Execute tasks in parallel - pass consolidatedPromptRun.ID as parentPromptRunId
+        const parallelResult = await this.ParallelCoordinator.executeTasksInParallel(params, executionTasks, undefined, consolidatedPromptRun.ID, params.cancellationToken);
         if (!parallelResult.success) {
             throw new Error(`Parallel execution failed: ${parallelResult.errors.join(', ')}`);
         }
@@ -833,17 +529,30 @@ export class AIPromptRunner {
             throw new Error(`No successful results from parallel execution`);
         }
         let selectedResult = successfulResults[0]; // Default to first
-        // Use result selector if configured
+        // Use result selector if configured - pass consolidatedPromptRun.ID and contextUser
         if (successfulResults.length > 1 && prompt.ResultSelectorPromptID) {
             const selectionConfig = {
                 method: 'PromptSelector',
                 selectorPromptId: prompt.ResultSelectorPromptID,
             };
-            const aiSelectedResult = await this.ParallelCoordinator.selectBestResult(successfulResults, selectionConfig, undefined, params.cancellationToken);
+            const aiSelectedResult = await this.ParallelCoordinator.selectBestResult(successfulResults, selectionConfig, consolidatedPromptRun.ID, params.cancellationToken, params.contextUser);
             if (aiSelectedResult) {
                 selectedResult = aiSelectedResult;
             }
         }
+        // Update parent with selected arm's model and vendor
+        consolidatedPromptRun.ModelID = selectedResult.task.model.ID;
+        if (selectedResult.task.vendorId) {
+            consolidatedPromptRun.VendorID = selectedResult.task.vendorId;
+        }
+        else if (selectedResult.task.promptModel?.VendorID) {
+            consolidatedPromptRun.VendorID = selectedResult.task.promptModel.VendorID;
+        }
+        // Ensure selectedResult child is marked WasSelectedResult = true
+        if (selectedResult.promptRun) {
+            selectedResult.promptRun.WasSelectedResult = true;
+            await selectedResult.promptRun.Save();
+        }
         // Calculate total tokens and costs from all parallel executions
         let totalPromptTokens = 0;
         let totalCompletionTokens = 0;
@@ -866,9 +575,6 @@ export class AIPromptRunner {
                 }
             }
         }
-        // Use existing prompt run if provided (hierarchical case) or create new one
-        // Use the model selection info if provided (from hierarchical execution)
-        const consolidatedPromptRun = existingPromptRun || await this.createPromptRun(prompt, selectedResult.task.model, params, renderedPromptText, startTime, params.override?.vendorId, existingSelection?.selectionInfo);
         // Update with parallel execution metadata
         const endTime = new Date();
         consolidatedPromptRun.CompletedAt = endTime;
@@ -890,9 +596,8 @@ export class AIPromptRunner {
             // prices the full input including cached tokens rather than dropping them.
             consolidatedPromptRun.TokensCacheRead = selectedResultUsage.cacheReadTokens ?? 0;
             consolidatedPromptRun.TokensCacheWrite = selectedResultUsage.cacheWriteTokens ?? 0;
-            if (selectedResultUsage.cost !== undefined) {
-                consolidatedPromptRun.Cost = selectedResultUsage.cost;
-            }
+            // NOTE (§5.1): On the parent, do NOT assign Cost from the selected arm. Leave Cost = null.
+            // TotalCost is maintained by server-side TriggerParentCostRollup.
             if (selectedResultUsage.costCurrency !== undefined) {
                 consolidatedPromptRun.CostCurrency = selectedResultUsage.costCurrency;
             }
@@ -914,18 +619,19 @@ export class AIPromptRunner {
                 messages: params.conversationMessages || [],
             });
         }
-        // For parallel execution, set rollup fields to match totals (no child execution to roll up)
+        // For parallel execution, set rollup fields to match totals
         consolidatedPromptRun.TokensPromptRollup = totalPromptTokens;
         consolidatedPromptRun.TokensCompletionRollup = totalCompletionTokens;
         consolidatedPromptRun.TokensUsedRollup = totalPromptTokens + totalCompletionTokens;
         consolidatedPromptRun.TokensCacheReadRollup = totalCacheReadTokens;
         consolidatedPromptRun.TokensCacheWriteRollup = totalCacheWriteTokens;
         if (hasCost) {
+            consolidatedPromptRun.DescendantCost = totalCost;
             consolidatedPromptRun.TotalCost = totalCost;
         }
         // Set Status and WasSelectedResult for parallel execution
         consolidatedPromptRun.Status = parallelResult.successCount > 0 ? 'Completed' : 'Failed';
-        consolidatedPromptRun.WasSelectedResult = true; // This is the consolidated result chosen by judge
+        consolidatedPromptRun.WasSelectedResult = false; // WasSelectedResult stays on the selected child, not the parent
         // Persist the consolidated run fire-and-forget; the finalize UPDATE chains after its INSERT via
         // the save queue. These fields are set after all the awaited parallel work, so the INSERT has long
         // landed — a plain Update (no post-INSERT callback) is race-safe here.
@@ -1060,6 +766,24 @@ export class AIPromptRunner {
      * @param cancellationToken - Cancellation token for aborting rendering
      * @returns Promise with rendered templates map
      */
+    /**
+     * Render a set of child prompt templates WITHOUT executing anything, returning the rendered text
+     * keyed by each child's parent placeholder — exactly what the hierarchical execution path embeds
+     * into the parent template.
+     *
+     * Exposed for callers that need a child's rendered text before the run: the loop agent uses it to
+     * relocate a volatile specialization into the trailing runtime-state message (see
+     * `ResolveSpecializationPlacement` in `@memberjunction/ai-agents`) while the system prompt renders a
+     * stub in its place. Rendering is deterministic for the same inputs, so a subsequent execution of
+     * the same params reproduces the same text.
+     *
+     * @param childPrompts The child prompt params, as they would be passed in `AIPromptParams.childPrompts`.
+     * @param params The parent params (context user, data, template data) the children render against.
+     * @param cancellationToken Optional abort signal.
+     */
+    async RenderChildPromptTemplates(childPrompts, params, cancellationToken) {
+        return this.renderChildPromptTemplates(childPrompts, params, cancellationToken);
+    }
     async renderChildPromptTemplates(childPrompts, params, cancellationToken) {
         if (!childPrompts || childPrompts.length === 0) {
             return {
@@ -1268,7 +992,7 @@ export class AIPromptRunner {
     }
     /**
      * Selects the appropriate AI model based on prompt configuration and parameters.
-     * Uses the unified buildModelVendorCandidates method to create an ordered list of candidates,
+     * Uses the unified BuildModelVendorCandidates method to create an ordered list of candidates,
      * then selects the first one with an available API key.
      */
     async selectModel(prompt, explicitModelId, contextUser, configurationId, vendorId, params) {
@@ -1295,7 +1019,7 @@ export class AIPromptRunner {
                 configurationName = configuration?.Name;
             }
             // Build unified list of model-vendor candidates
-            const candidates = this.buildModelVendorCandidates(prompt, explicitModelId, configurationId, vendorId, params.verbose);
+            const candidates = this.BuildModelVendorCandidates(prompt, explicitModelId, configurationId, vendorId, params?.verbose);
             // Track all models considered for selection info
             const modelsConsidered = [];
             if (candidates.length === 0) {
@@ -1422,525 +1146,6 @@ export class AIPromptRunner {
             };
         }
     }
-    /**
-     * Builds a unified, ordered list of model-vendor candidates based on all selection criteria.
-     * Uses a 3-phase approach to properly handle SelectionStrategy='Specific' with AIPromptModel priorities.
-     *
-     * Phase 1: Handle explicit model ID (highest priority)
-     * Phase 2: Check if SelectionStrategy='Specific' with AIPromptModel entries - use ONLY those with AIPromptModel priorities
-     * Phase 3: Use general selection strategy (fallback) - blended priorities from legacy behavior
-     *
-     * @param prompt - The AI prompt with selection criteria
-     * @param explicitModelId - Explicitly specified model ID (highest priority)
-     * @param configurationId - Configuration ID for filtering
-     * @param preferredVendorId - Preferred vendor ID
-     * @returns Ordered array of model-vendor candidates (highest priority first)
-     */
-    buildModelVendorCandidates(prompt, explicitModelId, configurationId, preferredVendorId, verbose) {
-        // PHASE 1: Handle explicit model ID (highest priority)
-        if (explicitModelId) {
-            return this.buildCandidatesForExplicitModel(explicitModelId, prompt, preferredVendorId);
-        }
-        // PHASE 2: SelectionStrategy='Specific' - Use explicit AIPromptModel configuration
-        if (prompt.SelectionStrategy === 'Specific') {
-            return this.buildCandidatesForSpecificStrategy(prompt, configurationId, verbose);
-        }
-        // PHASE 3: Build candidates with configuration-aware fallback hierarchy
-        // (SelectionStrategy='Default' or 'ByPower')
-        return this.buildCandidatesForGeneralSelection(prompt, configurationId, preferredVendorId, verbose);
-    }
-    /**
-     * PHASE 1: Build candidates for explicitly specified model ID.
-     * Returns candidates for the single model if it's active and compatible.
-     */
-    buildCandidatesForExplicitModel(explicitModelId, prompt, preferredVendorId) {
-        const model = AIEngine.Instance.ModelsByID.get(NormalizeUUID(explicitModelId));
-        if (!model || !model.IsActive) {
-            return [];
-        }
-        // Check model type compatibility
-        if (prompt.AIModelTypeID && !UUIDsEqual(model.AIModelTypeID, prompt.AIModelTypeID)) {
-            return [];
-        }
-        const candidates = this.createCandidatesForModel(model, 20000, 'explicit', preferredVendorId);
-        candidates.sort((a, b) => b.priority - a.priority);
-        return candidates;
-    }
-    /**
-     * PHASE 2: Build candidates for 'Specific' selection strategy.
-     * Uses AIPromptModel configuration with clean ranking:
-     * 1. Config-matching models first (by priority DESC)
-     * 2. Then universal (null config) models (by priority DESC)
-     */
-    buildCandidatesForSpecificStrategy(prompt, configurationId, verbose) {
-        // Get all active AIPromptModel records for this prompt
-        const allPromptModels = AIEngine.Instance.PromptModels.filter(pm => UUIDsEqual(pm.PromptID, prompt.ID) && (pm.Status === 'Active' || pm.Status === 'Preview'));
-        // Filter by configuration matching rules
-        const promptModels = this.filterPromptModelsByConfiguration(allPromptModels, configurationId);
-        // Sort: config-specific before universal, then by priority DESC within each group
-        const sortedPromptModels = this.sortPromptModelsForSpecificStrategy(promptModels, configurationId);
-        // Build candidates maintaining order
-        const candidates = this.buildCandidatesFromPromptModels(sortedPromptModels);
-        // If RequireSpecificModels is true (or no candidates at all), enforce strict behavior
-        if (candidates.length === 0 && prompt.RequireSpecificModels) {
-            const configInfo = configurationId ? ` with configuration "${configurationId}"` : '';
-            throw new Error(`SelectionStrategy is 'Specific' but no valid AIPromptModel candidates found for prompt "${prompt.Name}"${configInfo}. ` +
-                `Please configure AIPromptModel records for this prompt.`);
-        }
-        // When RequireSpecificModels is false, append power-matched fallback candidates
-        // so that if none of the specific models have valid credentials, the system
-        // gracefully falls back to other available models at a similar power level.
-        if (!prompt.RequireSpecificModels) {
-            this.appendPowerMatchedFallbackCandidates(candidates, prompt, sortedPromptModels, verbose);
-        }
-        if (candidates.length === 0) {
-            const configInfo = configurationId ? ` with configuration "${configurationId}"` : '';
-            throw new Error(`SelectionStrategy is 'Specific' but no valid AIPromptModel candidates found for prompt "${prompt.Name}"${configInfo}. ` +
-                `Please configure AIPromptModel records for this prompt.`);
-        }
-        if (verbose) {
-            LogStatus(`Using SelectionStrategy='Specific' with ${sortedPromptModels.length} AIPromptModel entries, generated ${candidates.length} candidates`);
-        }
-        return candidates;
-    }
-    /**
-     * Appends fallback candidates from the global model pool, sorted by proximity to the
-     * average power rank of the originally configured models. This ensures that when
-     * specific models lack credentials, the fallback uses models of similar capability
-     * rather than defaulting to the most or least powerful available model.
-     *
-     * Fallback candidates are given lower priority than any specific candidate so
-     * configured models are always preferred when their credentials are available.
-     */
-    appendPowerMatchedFallbackCandidates(candidates, prompt, configuredPromptModels, verbose) {
-        // Compute target power rank from the configured models
-        const targetPowerRank = this.computeTargetPowerRank(configuredPromptModels);
-        // Get all active models matching the prompt's model type, excluding already-present models
-        const existingModelIds = new Set(candidates.map(c => c.model.ID));
-        const fallbackPool = AIEngine.Instance.Models.filter(m => m.IsActive &&
-            !existingModelIds.has(m.ID) &&
-            (!prompt.AIModelTypeID || UUIDsEqual(m.AIModelTypeID, prompt.AIModelTypeID)));
-        if (fallbackPool.length === 0)
-            return;
-        // Sort by proximity to the target power rank
-        const sorted = this.sortByPowerProximity(fallbackPool, targetPowerRank);
-        // Assign priorities below the lowest specific candidate
-        const lowestSpecificPriority = candidates.length > 0
-            ? Math.min(...candidates.map(c => c.priority))
-            : 1000;
-        const fallbackBasePriority = lowestSpecificPriority - 100;
-        sorted.forEach((model, index) => {
-            const modelCandidates = this.createCandidatesForModel(model, fallbackBasePriority - index * 10, 'power-match-fallback');
-            candidates.push(...modelCandidates);
-        });
-        if (verbose && sorted.length > 0) {
-            LogStatus(`Appended ${sorted.length} power-matched fallback models (target PowerRank: ${targetPowerRank}) ` +
-                `for prompt "${prompt.Name}" since RequireSpecificModels is false`);
-        }
-    }
-    /**
-     * Computes the target power rank from configured AIPromptModel records.
-     * Uses the weighted average (by priority) of the configured models' power ranks,
-     * so higher-priority models have more influence on the target.
-     * Falls back to simple average if priorities are all zero.
-     */
-    computeTargetPowerRank(promptModels) {
-        if (promptModels.length === 0)
-            return 0;
-        const modelsWithPower = promptModels
-            .map(pm => {
-            const model = AIEngine.Instance.ModelsByID.get(NormalizeUUID(pm.ModelID));
-            return { powerRank: model?.PowerRank ?? 0, priority: pm.Priority || 1 };
-        });
-        const totalWeight = modelsWithPower.reduce((sum, m) => sum + m.priority, 0);
-        if (totalWeight === 0) {
-            // All priorities are 0, use simple average
-            return Math.round(modelsWithPower.reduce((sum, m) => sum + m.powerRank, 0) / modelsWithPower.length);
-        }
-        const weightedSum = modelsWithPower.reduce((sum, m) => sum + m.powerRank * m.priority, 0);
-        return Math.round(weightedSum / totalWeight);
-    }
-    /**
-     * Sorts models by proximity to a target power rank (closest first).
-     * When two models are equidistant, the higher-powered one is preferred.
-     */
-    sortByPowerProximity(models, targetPowerRank) {
-        return [...models].sort((a, b) => {
-            const distA = Math.abs((a.PowerRank ?? 0) - targetPowerRank);
-            const distB = Math.abs((b.PowerRank ?? 0) - targetPowerRank);
-            if (distA !== distB)
-                return distA - distB; // Closer to target first
-            return (b.PowerRank ?? 0) - (a.PowerRank ?? 0); // Tie-break: higher power first
-        });
-    }
-    /**
-     * PHASE 3: Build candidates for general selection strategies ('Default' or 'ByPower').
-     * Uses configuration-aware fallback hierarchy with legacy blended priority calculation.
-     */
-    buildCandidatesForGeneralSelection(prompt, configurationId, preferredVendorId, verbose) {
-        const preferredVendorName = preferredVendorId ?
-            AIEngine.Instance.VendorsByID.get(NormalizeUUID(preferredVendorId))?.Name : undefined;
-        // Get prompt models for configuration
-        const promptModels = this.getPromptModelsForConfiguration(prompt, configurationId);
-        const candidates = [];
-        if (promptModels.length > 0) {
-            // Use prompt-specific models with blended priorities
-            this.addPromptSpecificCandidates(candidates, promptModels, preferredVendorId);
-            // Add configuration fallback candidates if needed
-            if (configurationId) {
-                this.addConfigurationFallbackCandidates(candidates, prompt, configurationId, preferredVendorId, verbose);
-            }
-        }
-        else if (this.hasAnyPromptModelBindings(prompt)) {
-            // Bindings exist for this prompt but none are Active/Preview (e.g. deliberately deactivated) —
-            // do NOT silently fall back to the global model pool, which would mask an intentional
-            // "no model available for this prompt" state. Leave candidates empty so the caller surfaces
-            // a "no suitable model found" failure instead of succeeding against an unrelated model.
-        }
-        else {
-            // No prompt-specific bindings were ever configured, use the general selection strategy
-            this.addStrategyBasedCandidates(candidates, prompt, preferredVendorName);
-        }
-        // Sort all candidates by priority (highest first)
-        candidates.sort((a, b) => b.priority - a.priority);
-        return candidates;
-    }
-    /**
-     * Helper: Filter prompt models by configuration matching rules.
-     * Supports configuration inheritance - includes models from the entire inheritance chain.
-     */
-    filterPromptModelsByConfiguration(allPromptModels, configurationId) {
-        if (configurationId) {
-            // Get the configuration inheritance chain
-            const chain = AIEngine.Instance.GetConfigurationChain(configurationId);
-            const chainIds = new Set(chain.map(c => NormalizeUUID(c.ID)));
-            // Include models matching any config in the chain, plus null-config (universal fallback)
-            return allPromptModels.filter(pm => (pm.ConfigurationID && chainIds.has(NormalizeUUID(pm.ConfigurationID))) ||
-                pm.ConfigurationID === null);
-        }
-        else {
-            // No config specified - only include null-config models
-            return allPromptModels.filter(pm => pm.ConfigurationID === null);
-        }
-    }
-    /**
-     * Helper: Sort prompt models for 'Specific' strategy.
-     * Respects configuration inheritance chain - child configs first, then parents, then null-config.
-     * Within each config level, sorts by priority DESC.
-     */
-    sortPromptModelsForSpecificStrategy(promptModels, configurationId) {
-        if (!configurationId) {
-            // No config specified - just sort by priority
-            return promptModels.sort((a, b) => (b.Priority || 0) - (a.Priority || 0));
-        }
-        // Get the configuration inheritance chain and create position map
-        const chain = AIEngine.Instance.GetConfigurationChain(configurationId);
-        const chainOrder = new Map(chain.map((c, index) => [c.ID, index]));
-        return promptModels.sort((a, b) => {
-            // Primary: Chain position (lower index = higher priority, null config = last)
-            const aChainPos = a.ConfigurationID ? (chainOrder.get(a.ConfigurationID) ?? 999) : 1000;
-            const bChainPos = b.ConfigurationID ? (chainOrder.get(b.ConfigurationID) ?? 999) : 1000;
-            if (aChainPos !== bChainPos) {
-                return aChainPos - bChainPos; // Lower chain position first (child before parent)
-            }
-            // Secondary: Higher priority first within same config level
-            return (b.Priority || 0) - (a.Priority || 0);
-        });
-    }
-    /**
-     * Helper: Build candidates from sorted AIPromptModel records.
-     * Expands VendorID=null to all vendors for that model.
-     */
-    buildCandidatesFromPromptModels(promptModels) {
-        const candidates = [];
-        for (let i = 0; i < promptModels.length; i++) {
-            const pm = promptModels[i];
-            // Compute priority as inverse of array position so highest-priority (first) gets the largest number
-            const computedPriority = promptModels.length - i;
-            const model = AIEngine.Instance.ModelsByID.get(NormalizeUUID(pm.ModelID));
-            if (!model || !model.IsActive)
-                continue;
-            if (pm.VendorID) {
-                // Specific vendor specified - create single candidate
-                const candidate = this.createCandidateForSpecificVendor(model, pm, computedPriority);
-                if (candidate) {
-                    candidates.push(candidate);
-                }
-            }
-            else {
-                // No vendor specified - create candidates for all vendors
-                const vendorCandidates = this.createCandidatesForAllVendors(model, computedPriority);
-                candidates.push(...vendorCandidates);
-            }
-        }
-        return candidates;
-    }
-    /**
-     * Helper: Create candidate for specific vendor from AIPromptModel.
-     */
-    createCandidateForSpecificVendor(model, promptModel, computedPriority = 0) {
-        // Use the model's precomputed ModelVendors (grouped at engine load) instead of scanning
-        // the global ModelVendors array — model.ID === promptModel.ModelID here.
-        const modelVendor = model.ModelVendors.find(mv => UUIDsEqual(mv.VendorID, promptModel.VendorID) &&
-            mv.Status === 'Active' &&
-            this.isInferenceProvider(mv));
-        if (!modelVendor)
-            return null;
-        return {
-            model,
-            vendorId: modelVendor.VendorID,
-            vendorName: modelVendor.Vendor,
-            driverClass: modelVendor.DriverClass || model.DriverClass,
-            apiName: modelVendor.APIName || model.APIName,
-            supportsEffortLevel: modelVendor.SupportsEffortLevel ?? model.SupportsEffortLevel ?? false,
-            effortLevel: promptModel.EffortLevel ?? undefined, // Model-specific effort level override
-            promptModelConfiguration: promptModel.PromptConfigurationObject,
-            isPreferredVendor: false,
-            priority: computedPriority,
-            source: 'prompt-model'
-        };
-    }
-    /**
-     * Helper: Create candidates for all vendors of a model, sorted by vendor priority.
-     */
-    createCandidatesForAllVendors(model, computedPriority = 0) {
-        const vendors = model.ModelVendors
-            .filter(mv => mv.Status === 'Active' &&
-            this.isInferenceProvider(mv))
-            .sort((a, b) => (b.Priority || 0) - (a.Priority || 0));
-        const candidates = [];
-        for (const vendor of vendors) {
-            candidates.push({
-                model,
-                vendorId: vendor.VendorID,
-                vendorName: vendor.Vendor,
-                driverClass: vendor.DriverClass || model.DriverClass,
-                apiName: vendor.APIName || model.APIName,
-                supportsEffortLevel: vendor.SupportsEffortLevel ?? model.SupportsEffortLevel ?? false,
-                isPreferredVendor: false,
-                priority: computedPriority,
-                source: 'prompt-model'
-            });
-        }
-        // If no vendors found, use model defaults
-        if (candidates.length === 0 && model.DriverClass) {
-            candidates.push({
-                model,
-                driverClass: model.DriverClass,
-                apiName: model.APIName,
-                supportsEffortLevel: model.SupportsEffortLevel ?? false,
-                isPreferredVendor: false,
-                priority: computedPriority,
-                source: 'prompt-model'
-            });
-        }
-        return candidates;
-    }
-    /**
-     * Helper: true if this prompt has any AIPromptModel bindings at all, regardless of Status or
-     * ConfigurationID. Distinguishes "no bindings were ever configured" (general selection strategy
-     * should apply) from "bindings exist but are all Inactive" (no model should be selected).
-     */
-    hasAnyPromptModelBindings(prompt) {
-        return AIEngine.Instance.PromptModels.some(pm => UUIDsEqual(pm.PromptID, prompt.ID));
-    }
-    /**
-     * Helper: Get prompt models for configuration with inheritance chain fallback.
-     * Walks the configuration inheritance chain looking for prompt models.
-     * Returns models from the first config in the chain that has any, or falls back to null-config.
-     */
-    getPromptModelsForConfiguration(prompt, configurationId) {
-        if (configurationId) {
-            // Get the configuration inheritance chain (child -> parent -> grandparent -> ...)
-            const chain = AIEngine.Instance.GetConfigurationChain(configurationId);
-            // Walk the chain looking for prompt models
-            for (const config of chain) {
-                const promptModels = AIEngine.Instance.PromptModels.filter(pm => UUIDsEqual(pm.PromptID, prompt.ID) &&
-                    (pm.Status === 'Active' || pm.Status === 'Preview') &&
-                    UUIDsEqual(pm.ConfigurationID, config.ID));
-                if (promptModels.length > 0) {
-                    return promptModels;
-                }
-            }
-            // No match in chain, fall back to NULL config models
-            LogStatus(`No models found in configuration chain for "${configurationId}", falling back to default models`);
-        }
-        // Return null-config (universal) models
-        return AIEngine.Instance.PromptModels.filter(pm => UUIDsEqual(pm.PromptID, prompt.ID) &&
-            (pm.Status === 'Active' || pm.Status === 'Preview') &&
-            !pm.ConfigurationID);
-    }
-    /**
-     * Helper: Add prompt-specific candidates with blended priorities (legacy behavior).
-     */
-    addPromptSpecificCandidates(candidates, promptModels, preferredVendorId) {
-        for (const pm of promptModels) {
-            const model = AIEngine.Instance.ModelsByID.get(NormalizeUUID(pm.ModelID));
-            if (model && model.IsActive) {
-                const modelCandidates = this.createCandidatesForModel(model, 5000, 'prompt-model', preferredVendorId, pm.Priority);
-                candidates.push(...modelCandidates);
-            }
-        }
-    }
-    /**
-     * Helper: Add configuration fallback candidates from the inheritance chain.
-     * Adds models from parent configs (with decreasing priority) and null-config models as final fallback.
-     */
-    addConfigurationFallbackCandidates(candidates, prompt, configurationId, preferredVendorId, verbose) {
-        const chain = AIEngine.Instance.GetConfigurationChain(configurationId);
-        // Add models from parent configs (skip index 0 which is the direct config, already handled)
-        for (let i = 1; i < chain.length; i++) {
-            const parentConfig = chain[i];
-            const parentModels = AIEngine.Instance.PromptModels.filter(pm => UUIDsEqual(pm.PromptID, prompt.ID) &&
-                (pm.Status === 'Active' || pm.Status === 'Preview') &&
-                UUIDsEqual(pm.ConfigurationID, parentConfig.ID));
-            if (parentModels.length > 0 && verbose) {
-                LogStatus(`Adding ${parentModels.length} models from parent config "${parentConfig.Name}" as fallback`);
-            }
-            for (const pm of parentModels) {
-                const model = AIEngine.Instance.ModelsByID.get(NormalizeUUID(pm.ModelID));
-                if (model && model.IsActive) {
-                    // Decrease base priority for each level up the chain (3000, 2500, 2000, etc.)
-                    const basePriority = 3000 - (i * 500);
-                    const modelCandidates = this.createCandidatesForModel(model, basePriority, 'prompt-model', preferredVendorId, pm.Priority);
-                    candidates.push(...modelCandidates);
-                }
-            }
-        }
-        // Finally add NULL config models (universal fallback) with lowest priority
-        const nullConfigModels = AIEngine.Instance.PromptModels.filter(pm => UUIDsEqual(pm.PromptID, prompt.ID) &&
-            (pm.Status === 'Active' || pm.Status === 'Preview') &&
-            !pm.ConfigurationID);
-        if (nullConfigModels.length > 0 && verbose) {
-            LogStatus(`Adding ${nullConfigModels.length} NULL configuration models as universal fallback`);
-        }
-        for (const pm of nullConfigModels) {
-            const model = AIEngine.Instance.ModelsByID.get(NormalizeUUID(pm.ModelID));
-            if (model && model.IsActive) {
-                const modelCandidates = this.createCandidatesForModel(model, 1000, // Lowest priority tier
-                'prompt-model', preferredVendorId, pm.Priority);
-                candidates.push(...modelCandidates);
-            }
-        }
-    }
-    /**
-     * Helper: Add strategy-based candidates when no prompt models exist.
-     */
-    addStrategyBasedCandidates(candidates, prompt, preferredVendorName) {
-        let modelPool = this.getModelPoolForStrategy(prompt, preferredVendorName);
-        modelPool = this.sortModelPoolByStrategy(modelPool, prompt);
-        // Create candidates for each model in the pool
-        modelPool.forEach((model, index) => {
-            const basePriority = 1000 - index * 10; // Decrease priority by position
-            const source = prompt.SelectionStrategy === 'ByPower' ? 'power-rank' : 'model-type';
-            candidates.push(...this.createCandidatesForModel(model, basePriority, source));
-        });
-    }
-    /**
-     * Helper: Get model pool filtered for strategy.
-     */
-    getModelPoolForStrategy(prompt, preferredVendorName) {
-        return AIEngine.Instance.Models.filter(m => m.IsActive &&
-            (!prompt.AIModelTypeID || UUIDsEqual(m.AIModelTypeID, prompt.AIModelTypeID)) &&
-            (!preferredVendorName ||
-                m.ModelVendors.some(mv => mv.Status === 'Active' &&
-                    mv.Vendor === preferredVendorName &&
-                    this.isInferenceProvider(mv))));
-    }
-    /**
-     * Helper: Sort model pool by selection strategy.
-     */
-    sortModelPoolByStrategy(modelPool, prompt) {
-        if (prompt.SelectionStrategy === 'ByPower') {
-            return this.sortByPowerPreference(modelPool, prompt.PowerPreference);
-        }
-        else {
-            // Default strategy
-            const minPowerRank = prompt.MinPowerRank || 0;
-            return modelPool
-                .filter(m => m.PowerRank >= minPowerRank)
-                .sort((a, b) => b.PowerRank - a.PowerRank);
-        }
-    }
-    /**
-     * Helper: Sort models by power preference.
-     */
-    sortByPowerPreference(modelPool, powerPreference) {
-        const pool = [...modelPool];
-        switch (powerPreference) {
-            case 'Highest':
-                return pool.sort((a, b) => b.PowerRank - a.PowerRank);
-            case 'Lowest':
-                return pool.sort((a, b) => a.PowerRank - b.PowerRank);
-            case 'Balanced':
-                const avgPower = pool.reduce((sum, m) => sum + m.PowerRank, 0) / pool.length;
-                return pool.sort((a, b) => Math.abs(a.PowerRank - avgPower) - Math.abs(b.PowerRank - avgPower));
-            default:
-                return pool.sort((a, b) => b.PowerRank - a.PowerRank);
-        }
-    }
-    /**
-     * Helper: Create candidates for a model with AIModelVendor priorities (legacy behavior).
-     */
-    createCandidatesForModel(model, basePriority, source, preferredVendorId, promptModelPriority) {
-        const modelCandidates = [];
-        // Get all vendors for this model - filter for inference providers only.
-        // Uses the model's precomputed ModelVendors (grouped at engine load) rather than scanning
-        // the global ModelVendors array.
-        const modelVendors = model.ModelVendors
-            .filter(mv => mv.Status === 'Active' && this.isInferenceProvider(mv))
-            .sort((a, b) => b.Priority - a.Priority);
-        // First, add preferred vendor if it exists
-        if (preferredVendorId) {
-            const preferredVendor = modelVendors.find(mv => UUIDsEqual(mv.VendorID, preferredVendorId));
-            if (preferredVendor) {
-                modelCandidates.push({
-                    model,
-                    vendorId: preferredVendor.VendorID,
-                    vendorName: preferredVendor.Vendor,
-                    driverClass: preferredVendor.DriverClass || model.DriverClass,
-                    apiName: preferredVendor.APIName || model.APIName,
-                    supportsEffortLevel: preferredVendor.SupportsEffortLevel ?? model.SupportsEffortLevel ?? false,
-                    isPreferredVendor: true,
-                    priority: basePriority + 1000, // Boost priority for preferred vendor
-                    source
-                });
-            }
-        }
-        // Then add other vendors in priority order
-        for (const vendor of modelVendors) {
-            if (!UUIDsEqual(vendor.VendorID, preferredVendorId)) {
-                modelCandidates.push({
-                    model,
-                    vendorId: vendor.VendorID,
-                    vendorName: vendor.Vendor,
-                    driverClass: vendor.DriverClass || model.DriverClass,
-                    apiName: vendor.APIName || model.APIName,
-                    supportsEffortLevel: vendor.SupportsEffortLevel ?? model.SupportsEffortLevel ?? false,
-                    isPreferredVendor: false,
-                    priority: basePriority + (vendor.Priority || 0),
-                    source
-                });
-            }
-        }
-        // If no vendors found, add model with its default driver
-        if (modelCandidates.length === 0 && model.DriverClass) {
-            modelCandidates.push({
-                model,
-                driverClass: model.DriverClass,
-                apiName: model.APIName,
-                supportsEffortLevel: model.SupportsEffortLevel ?? false,
-                isPreferredVendor: false,
-                priority: basePriority,
-                source
-            });
-        }
-        // Apply prompt model priority if provided (legacy blended approach)
-        if (promptModelPriority !== undefined) {
-            modelCandidates.forEach(c => c.priority += promptModelPriority * 10);
-        }
-        return modelCandidates;
-    }
     /**
      * Creates a properly typed AIModelSelectionInfo instance.
      * TypeScript requires instantiating the class to get the getValidCandidates() method.
@@ -1968,7 +1173,7 @@ export class AIPromptRunner {
         // DECISION (performance): candidates are ordered by priority, and we only need the
         // highest-priority candidate that has working credentials. So once we find that first
         // hit, we STOP credential-probing the remaining candidates and record them as
-        // "not-evaluated" rather than running a `hasCredentialsAvailable` check (which does
+        // "not-evaluated" rather than running a `HasCredentialsAvailable` check (which does
         // env-var lookups + binding scans) for every configured model on every prompt run.
         // The remaining candidates are still kept in `consideredModels` (and in the returned
         // `allCandidates` from selectModel, which is the FULL ordered list) so failover and the
@@ -2001,7 +1206,7 @@ export class AIPromptRunner {
             }
             else {
                 // Check for credentials using hierarchical resolution
-                hasCredentials = this.hasCredentialsAvailable(candidate.driverClass, promptId, candidate.model.ID, candidate.vendorId, params);
+                hasCredentials = this.HasCredentialsAvailable(candidate.driverClass, promptId, candidate.model.ID, candidate.vendorId, params);
                 credentialCache.set(cacheKey, hasCredentials);
             }
             // Track this model as considered with availability status
@@ -2050,6 +1255,11 @@ export class AIPromptRunner {
      */
     buildNoModelFoundMessage(promptName, selectionInfo) {
         const base = `No suitable model found for prompt ${promptName}`;
+        // A selection step that threw (for example the model-type floor) records its error here; show it
+        // rather than the generic "no candidates" text. Every other reason keeps its detailed message below.
+        if (selectionInfo?.selectionReason?.startsWith('Error during model selection:')) {
+            return `${base}. ${selectionInfo.selectionReason}`;
+        }
         if (!selectionInfo?.modelsConsidered || selectionInfo.modelsConsidered.length === 0) {
             return `${base}. No model-vendor candidates were available. Please ensure AI models are configured for this prompt.`;
         }
@@ -2067,244 +1277,6 @@ export class AIPromptRunner {
         }
         return `${base}. ${selectionInfo.selectionReason || 'Unknown reason'}`;
     }
-    /**
-     * Creates an AIPromptRun entity for execution tracking
-     */
-    /**
-     * Resolves the scalar inference parameters for a run: each value is the per-request override
-     * from `additionalParameters` when supplied, otherwise the prompt's configured default. This
-     * is the single source of truth for parameter precedence so {@link executeModel} (ChatParams)
-     * and {@link createPromptRun} (the persisted record) stay in lockstep. Stop sequences and
-     * assistant prefill are intentionally excluded — their representations differ per target.
-     */
-    resolveScalarInferenceParams(prompt, additionalParameters) {
-        const pick = (override, promptDefault) => override !== undefined ? override : (promptDefault != null ? promptDefault : undefined);
-        const ap = additionalParameters;
-        return {
-            temperature: pick(ap?.temperature, prompt.Temperature),
-            topP: pick(ap?.topP, prompt.TopP),
-            topK: pick(ap?.topK, prompt.TopK),
-            minP: pick(ap?.minP, prompt.MinP),
-            frequencyPenalty: pick(ap?.frequencyPenalty, prompt.FrequencyPenalty),
-            presencePenalty: pick(ap?.presencePenalty, prompt.PresencePenalty),
-            seed: pick(ap?.seed, prompt.Seed),
-            includeLogProbs: pick(ap?.includeLogProbs, prompt.IncludeLogProbs),
-            topLogProbs: pick(ap?.topLogProbs, prompt.TopLogProbs),
-        };
-    }
-    /**
-     * Awaits all in-flight prompt-run saves queued by this runner instance. The normal execution path
-     * does NOT call this — prompt-run persistence is intentionally fire-and-forget. Exposed for tests
-     * and for callers that need the AIPromptRun rows durably written before proceeding.
-     */
-    async WaitForPendingPromptRunSaves() {
-        await this._promptRunQueue.Flush();
-    }
-    async createPromptRun(prompt, model, params, systemPromptText, startTime, vendorId, modelSelectionInfo) {
-        const provider = params.provider ?? Metadata.Provider;
-        const promptRun = await provider.GetEntityObject('MJ: AI Prompt Runs', params.contextUser);
-        try {
-            promptRun.NewRecord();
-            promptRun.PromptID = prompt.ID;
-            promptRun.ModelID = model.ID;
-            // Attribute the run to the agent that caused it, when there is one. PromptID alone cannot do
-            // this: agents share agent-type-level prompts, so a parent and its sub-agent produce runs of
-            // the SAME prompt. See AIPromptParams.agentId for why this was previously always null.
-            if (params.agentId) {
-                promptRun.AgentID = params.agentId;
-            }
-            // Set ChildPromptID if this is a hierarchical execution with child prompts
-            if (params.childPrompts && params.childPrompts.length > 0) {
-                promptRun.ChildPromptID = params.childPrompts[0].childPrompt.prompt.ID;
-            }
-            // Set initial status and tracking fields
-            promptRun.Status = 'Running';
-            promptRun.Cancelled = false;
-            promptRun.CacheHit = false;
-            promptRun.StreamingEnabled = !!params.onStreaming;
-            promptRun.WasSelectedResult = false;
-            // Set model selection tracking fields
-            if (modelSelectionInfo) {
-                // Convert the rich entity objects to simple IDs/names for database storage
-                const dbSelectionInfo = {
-                    configurationId: modelSelectionInfo.aiConfiguration?.ID,
-                    configurationName: modelSelectionInfo.aiConfiguration?.Name,
-                    modelsConsidered: modelSelectionInfo.modelsConsidered.map(mc => ({
-                        modelId: mc.model.ID,
-                        modelName: mc.model.Name,
-                        vendorId: mc.vendor?.ID,
-                        vendorName: mc.vendor?.Name || 'default',
-                        priority: mc.priority,
-                        available: mc.available,
-                        unavailableReason: mc.unavailableReason
-                    })),
-                    modelSelected: modelSelectionInfo.modelSelected?.ID,
-                    vendorSelected: modelSelectionInfo.vendorSelected?.ID,
-                    selectionReason: modelSelectionInfo.selectionReason,
-                    fallbackUsed: modelSelectionInfo.fallbackUsed,
-                    selectionStrategy: modelSelectionInfo.selectionStrategy
-                };
-                promptRun.ModelSelection = JSON.stringify(dbSelectionInfo);
-                promptRun.SelectionStrategy = modelSelectionInfo.selectionStrategy || 'Default';
-                // Set ModelPowerRank if available
-                if (model.PowerRank != null) {
-                    promptRun.ModelPowerRank = model.PowerRank;
-                }
-            }
-            // Set original model tracking for failover
-            promptRun.OriginalModelID = model.ID;
-            promptRun.OriginalRequestStartTime = startTime;
-            // Initialize failover tracking fields
-            promptRun.FailoverAttempts = 0;
-            promptRun.FailoverErrors = null;
-            promptRun.FailoverDurations = null;
-            promptRun.TotalFailoverDuration = 0;
-            // Check if model has pre-selected vendor info from selectModel
-            const modelWithVendor = model;
-            if (modelSelectionInfo) {
-                promptRun.VendorID = modelSelectionInfo.vendorSelected?.ID || vendorId || modelWithVendor._selectedVendorId;
-            }
-            else if (vendorId) {
-                // Explicit vendor ID provided
-                promptRun.VendorID = vendorId;
-            }
-            else if (modelWithVendor._selectedVendorId) {
-                // Use vendor selected during model selection (with API key verification)
-                promptRun.VendorID = modelWithVendor._selectedVendorId;
-            }
-            else {
-                // Fallback: grab the highest priority AI Model Vendor record for this model (inference providers only)
-                const modelVendors = model.ModelVendors
-                    .filter((mv) => mv.Status === 'Active' && this.isInferenceProvider(mv))
-                    .sort((a, b) => b.Priority - a.Priority);
-                if (modelVendors.length > 0) {
-                    promptRun.VendorID = modelVendors[0].VendorID;
-                }
-            }
-            promptRun.ConfigurationID = params.configurationId;
-            promptRun.RunAt = startTime;
-            // Resolve and save the effort level used (same precedence as ChatParams resolution).
-            // EffortLevel is a numeric column with a CHECK (1-100), so a provider-named level such as
-            // 'xhigh' is deliberately not persisted here — it still reaches the driver via ChatParams.
-            if (typeof params.effortLevel === 'number') {
-                promptRun.EffortLevel = params.effortLevel;
-            }
-            else if (prompt.EffortLevel !== undefined && prompt.EffortLevel !== null) {
-                promptRun.EffortLevel = prompt.EffortLevel;
-            }
-            // If neither is set, EffortLevel remains null (provider default was used)
-            // Set ParentID for hierarchical prompt execution tracking
-            if (params.parentPromptRunId) {
-                promptRun.ParentID = params.parentPromptRunId;
-            }
-            // Set RerunFromPromptRunID if this is a rerun
-            if (params.rerunFromPromptRunID) {
-                promptRun.RerunFromPromptRunID = params.rerunFromPromptRunID;
-            }
-            // Always save the response format from the prompt if it exists
-            if (prompt.ResponseFormat && prompt.ResponseFormat !== 'Any') {
-                promptRun.ResponseFormat = prompt.ResponseFormat;
-            }
-            // Save the actual values that will be used (prompt defaults overridden by additionalParameters).
-            // Uses the shared resolver so the persisted record matches what executeModel sends to the model.
-            const resolvedParams = this.resolveScalarInferenceParams(prompt, params.additionalParameters);
-            if (resolvedParams.temperature !== undefined)
-                promptRun.Temperature = resolvedParams.temperature;
-            if (resolvedParams.topP !== undefined)
-                promptRun.TopP = resolvedParams.topP;
-            if (resolvedParams.topK !== undefined)
-                promptRun.TopK = resolvedParams.topK;
-            if (resolvedParams.minP !== undefined)
-                promptRun.MinP = resolvedParams.minP;
-            if (resolvedParams.frequencyPenalty !== undefined)
-                promptRun.FrequencyPenalty = resolvedParams.frequencyPenalty;
-            if (resolvedParams.presencePenalty !== undefined)
-                promptRun.PresencePenalty = resolvedParams.presencePenalty;
-            if (resolvedParams.seed !== undefined)
-                promptRun.Seed = resolvedParams.seed;
-            if (resolvedParams.includeLogProbs !== undefined)
-                promptRun.LogProbs = resolvedParams.includeLogProbs;
-            if (resolvedParams.topLogProbs !== undefined)
-                promptRun.TopLogProbs = resolvedParams.topLogProbs;
-            // Stop sequences + assistant prefill: stored from the prompt, with the additionalParameters
-            // array (JSON-encoded) taking precedence when supplied.
-            if (prompt.StopSequences)
-                promptRun.StopSequences = prompt.StopSequences;
-            if (prompt.AssistantPrefill)
-                promptRun.AssistantPrefill = prompt.AssistantPrefill;
-            if (params.additionalParameters?.stopSequences !== undefined && params.additionalParameters.stopSequences.length > 0) {
-                promptRun.StopSequences = JSON.stringify(params.additionalParameters.stopSequences);
-            }
-            // Store the input data/context as JSON in Messages field.
-            // Also capture callers that supply conversationMessages directly (e.g. templateMessageRole='none',
-            // no rendered system prompt) — otherwise their assembled prompt would never be persisted.
-            if (params.data || params.templateData || systemPromptText || (params.conversationMessages?.length ?? 0) > 0) {
-                const messages = [];
-                if (systemPromptText) {
-                    // Build the system prompt content, including prefill fallback if applicable
-                    let systemContent = systemPromptText;
-                    if (prompt.AssistantPrefill && prompt.PrefillFallbackMode === 'SystemInstruction') {
-                        const fallbackTemplate = this.resolvePrefillFallbackText(model, vendorId);
-                        // Function replacement: prefill text is authored content that routinely
-                        // contains `$` (LaTeX `$$`, currency, JSON fragments), and a string
-                        // replacement would expand it. See issue #3171.
-                        const prefill = prompt.AssistantPrefill;
-                        const fallbackInstruction = fallbackTemplate.replace(/\{\{prefill\}\}/g, () => prefill);
-                        systemContent += '\n\n' + fallbackInstruction;
-                    }
-                    messages.push({
-                        role: 'system',
-                        content: systemContent
-                    });
-                }
-                // Always include any caller-supplied conversation messages (previously only recorded when a
-                // template system prompt was present, which dropped them for the pure-conversationMessages path).
-                messages.push(...(params.conversationMessages || []));
-                promptRun.Messages = JSON.stringify({
-                    data: params.data,
-                    templateData: params.templateData,
-                    messages: messages || [],
-                });
-            }
-            // Populate new retry tracking columns with initial values
-            promptRun.ValidationBehavior = prompt.ValidationBehavior || 'Warn';
-            promptRun.RetryStrategy = prompt.RetryStrategy || 'Fixed';
-            promptRun.MaxRetriesConfigured = prompt.MaxRetries || 0;
-            promptRun.FirstAttemptAt = startTime;
-            promptRun.ValidationAttemptCount = 0; // Will be updated during execution
-            promptRun.SuccessfulValidationCount = 0;
-            promptRun.FinalValidationPassed = false; // Will be updated after execution
-            // Persist the initial 'Running' record fire-and-forget. The ID was already assigned by
-            // NewRecord() above, so callers (and the onPromptRunCreated callback) have it immediately —
-            // we don't block the model call on the INSERT. The finalize UPDATE chains after this INSERT
-            // via the instance-keyed save queue, so ordering is guaranteed.
-            this._promptRunQueue.Insert(promptRun);
-            // Invoke callback if provided. The ID is available without awaiting the save (client-generated
-            // by NewRecord()), so agent-run/step linking that depends on it works immediately.
-            if (params.onPromptRunCreated) {
-                try {
-                    await params.onPromptRunCreated(promptRun.ID);
-                }
-                catch (callbackError) {
-                    LogStatus(`Error in onPromptRunCreated callback: ${callbackError.message}`);
-                    // Don't fail the execution if callback fails
-                }
-            }
-            return promptRun;
-        }
-        catch (error) {
-            const msg = `Error creating prompt run record: ${error.message} - ${promptRun?.LatestResult?.CompleteMessage} - ${promptRun?.LatestResult?.Errors[0]?.Message}`;
-            this.logError(msg, {
-                category: 'PromptRunSave',
-                metadata: {
-                    promptRunId: promptRun.ID,
-                    saveError: promptRun.LatestResult?.CompleteMessage
-                },
-                maxErrorLength: params.maxErrorLength
-            });
-            throw new Error(msg);
-        }
-    }
     /**
      * Renders the prompt template with provided data
      */
@@ -2363,12 +1335,12 @@ export class AIPromptRunner {
      * capabilities. It will attempt to execute with different models/vendors according
      * to the configured failover strategy when errors occur.
      *
-     * The method calls several smaller, focused helper methods:
-     * - buildFailoverCandidates: Creates candidate models based on type restrictions
-     * - createCandidatesFromModels: Converts models to vendor-specific candidates
-     * - updatePromptRunWithFailoverSuccess: Records successful failover metadata
-     * - updatePromptRunWithFailoverFailure: Records failed failover metadata
-     * - createFailoverErrorResult: Creates standardized error response
+     * Candidates come from model selection (`allCandidates`), already filtered to the prompt's
+     * model type by ID. When failover applies, the loop itself is
+     * {@link BaseModelRunner.ExecuteWithFailover}: this method supplies the chat call on each candidate
+     * (`executeModel` with that candidate's model, vendor, driver, effort level and prompt-model
+     * configuration) and the final error result (`createFailoverErrorResult`). The base records
+     * failover success or failure on the prompt run.
      */
     async executeModelWithFailover(model, renderedPrompt, prompt, params, vendorId, conversationMessages, templateMessageRole = 'system', cancellationToken, allCandidates, promptRun, vendorDriverClass, vendorApiName, vendorSupportsEffortLevel, modelEffortLevel, credentialAvailability, promptModelConfiguration) {
         // Get failover configuration (used for errorScope filtering)
@@ -2377,224 +1349,7 @@ export class AIPromptRunner {
         if (!allCandidates || allCandidates.length === 0 || failoverConfig.strategy === 'None') {
             return this.executeModel(model, renderedPrompt, prompt, params, vendorId, conversationMessages, templateMessageRole, cancellationToken, vendorDriverClass, vendorApiName, vendorSupportsEffortLevel, modelEffortLevel, promptModelConfiguration);
         }
-        // Track failover attempts
-        const failoverAttempts = [];
-        let lastError = null;
-        // Cache credential availability per driver:model:vendor for the duration of this failover
-        // scan so we don't repeat env-var / binding lookups while walking the candidate list.
-        //
-        // PERF: seed it with the probes model SELECTION already performed (same key format). Selection
-        // walks the priority list until it finds the first credentialed candidate, so this map holds
-        // the prefix it rejected (known false) PLUS the selected candidate (known true) — which is
-        // exactly the segment failover re-walks on the happy path. Reusing those results means the
-        // common case (and any caller looping failover) does ZERO redundant hasCredentialsAvailable
-        // calls. The not-evaluated tail is intentionally absent, so failover still lazily probes it
-        // only if a real failure forces it to walk down there.
-        const failoverCredentialCache = credentialAvailability
-            ? new Map(credentialAvailability)
-            : new Map();
-        const candidateHasCredentials = (c) => {
-            const key = `${c.driverClass}:${c.model.ID}:${c.vendorId || 'default'}`;
-            let has = failoverCredentialCache.get(key);
-            if (has === undefined) {
-                has = this.hasCredentialsAvailable(c.driverClass, prompt.ID, c.model.ID, c.vendorId, params);
-                failoverCredentialCache.set(key, has);
-            }
-            return has;
-        };
-        let skippedForCredentials = 0;
-        // Iterate through all candidates in priority order with instant failover
-        for (let i = 0; i < allCandidates.length; i++) {
-            const candidate = allCandidates[i];
-            const attemptStartTime = Date.now();
-            // Skip candidates with no credentials configured. `allCandidates` is intentionally the
-            // FULL priority-ordered list (see the DECISION note in selectModelWithAPIKeyTracked),
-            // so it can include vendors that have no API key in this environment. Firing a live
-            // request at one of those produces a misleading "401 invalid API key" — and because an
-            // Authentication error is treated as fatal, it would halt failover before any
-            // credentialed candidate is ever reached. Skipping here makes failover land on the
-            // first candidate that can actually authenticate (mirroring model selection's own
-            // highest-priority-with-credentials rule).
-            if (!candidateHasCredentials(candidate)) {
-                skippedForCredentials++;
-                continue;
-            }
-            try {
-                // Log the attempt if not the first one
-                if (i > 0) {
-                    const vendorName = candidate.vendorName || 'default';
-                    LogStatusEx({
-                        message: `🔄 Trying candidate ${i + 1}/${allCandidates.length}: ${candidate.model.Name} via ${vendorName}`,
-                        category: 'AI',
-                        additionalArgs: [{
-                                promptId: prompt.ID,
-                                modelId: candidate.model.ID,
-                                model: candidate.model.Name,
-                                vendorId: candidate.vendorId,
-                                vendor: candidate.vendorName,
-                                attemptNumber: i + 1
-                            }]
-                    });
-                }
-                // Execute the model with this candidate
-                const result = await this.executeModel(candidate.model, renderedPrompt, prompt, params, candidate.vendorId || null, conversationMessages, templateMessageRole, cancellationToken, candidate.driverClass, candidate.apiName, candidate.supportsEffortLevel, candidate.effortLevel, candidate.promptModelConfiguration);
-                // CRITICAL FIX: Check if result failed but is retriable (network errors, rate limits, etc.)
-                // Provider drivers (GeminiLLM, OpenAILLM, etc.) catch errors internally and return ChatResult{success: false}
-                // instead of throwing, so we must check result.success here.
-                if (!result.success && result.errorInfo?.canFailover) {
-                    lastError = result.exception || new Error(result.errorMessage || 'Model execution failed');
-                    // Use shared failover error handling logic
-                    const decision = await this.processFailoverError(lastError, result.errorInfo, candidate, attemptStartTime, i, allCandidates, failoverAttempts, prompt, failoverConfig);
-                    // Update candidates list (may have been filtered)
-                    allCandidates = decision.updatedCandidates;
-                    if (decision.shouldRetry) {
-                        i--; // Retry same model/vendor
-                        continue;
-                    }
-                    if (decision.shouldContinue) {
-                        continue; // Try next candidate
-                    }
-                    // Otherwise break (fatal error or last candidate)
-                    break;
-                }
-                // If we reach here, the result was successful
-                // Update promptRun with failover information if we had prior failures
-                if (failoverAttempts.length > 0 && promptRun) {
-                    this.updatePromptRunWithFailoverSuccess(promptRun, failoverAttempts, candidate.model, candidate.vendorId || null);
-                }
-                return result;
-            }
-            catch (error) {
-                lastError = error;
-                // Analyze error to get error info
-                const errorInfo = ErrorAnalyzer.analyzeError(lastError);
-                // Use shared failover error handling logic
-                const decision = await this.processFailoverError(lastError, errorInfo, candidate, attemptStartTime, i, allCandidates, failoverAttempts, prompt, failoverConfig);
-                // Update candidates list (may have been filtered)
-                allCandidates = decision.updatedCandidates;
-                if (decision.shouldRetry) {
-                    i--; // Retry same model/vendor
-                    continue;
-                }
-                if (decision.shouldContinue) {
-                    continue; // Try next candidate
-                }
-                // Otherwise break (fatal error or last candidate)
-                break;
-            }
-        }
-        // All candidates failed
-        if (promptRun && failoverAttempts.length > 0) {
-            this.updatePromptRunWithFailoverFailure(promptRun, failoverAttempts);
-        }
-        // If every candidate was skipped for missing credentials we never attempted a call and
-        // have no underlying error to report — surface an actionable message instead of null.
-        if (!lastError && failoverAttempts.length === 0 && skippedForCredentials > 0) {
-            lastError = new Error(`No API credentials configured for any of the ${skippedForCredentials} candidate model-vendor combination(s) for prompt "${prompt.Name}".`);
-        }
-        return this.createFailoverErrorResult(lastError, failoverAttempts);
-    }
-    /**
-     * Builds failover candidates for a prompt based on available models and type restrictions
-     */
-    async buildFailoverCandidates(prompt) {
-        const aiEngine = AIEngine.Instance;
-        // Get all models, filtered by type if specified
-        let allModels;
-        if (prompt.AIModelTypeID) {
-            // Find the model type from the prompt
-            const modelType = aiEngine.ModelTypes.find(mt => UUIDsEqual(mt.ID, prompt.AIModelTypeID));
-            if (!modelType) {
-                throw new Error(`Model type ${prompt.AIModelTypeID} not found`);
-            }
-            // Get all models of this specific type
-            const targetTypeName = modelType.Name.trim().toLowerCase();
-            allModels = aiEngine.Models.filter(m => {
-                // Guard against AIModelType being non-string (defensive coding for data issues)
-                const mType = typeof m.AIModelType === 'string' ? m.AIModelType.trim().toLowerCase() : '';
-                return mType === targetTypeName;
-            });
-        }
-        else {
-            // No type restriction - get all models
-            allModels = aiEngine.Models;
-        }
-        return this.createCandidatesFromModels(allModels);
-    }
-    /**
-     * Creates model-vendor candidates from a list of models
-     */
-    createCandidatesFromModels(models) {
-        const candidates = [];
-        for (const model of models) {
-            const vendors = model.ModelVendors || [];
-            if (vendors.length === 0) {
-                // Model without specific vendors
-                candidates.push({
-                    model: model,
-                    vendorId: undefined,
-                    vendorName: undefined,
-                    driverClass: model.DriverClass,
-                    apiName: model.APIName,
-                    supportsEffortLevel: model.SupportsEffortLevel ?? false,
-                    isPreferredVendor: false,
-                    priority: model.PowerRank || 0,
-                    source: 'power-rank'
-                });
-            }
-            else {
-                // Add each vendor as a separate candidate
-                for (const vendor of vendors) {
-                    candidates.push({
-                        model: model,
-                        vendorId: vendor.VendorID,
-                        vendorName: vendor.Vendor,
-                        driverClass: vendor.DriverClass || model.DriverClass,
-                        apiName: vendor.APIName || model.APIName,
-                        supportsEffortLevel: vendor.SupportsEffortLevel ?? model.SupportsEffortLevel ?? false,
-                        isPreferredVendor: vendor.Priority > 0,
-                        priority: (model.PowerRank || 0) + (vendor.Priority || 0),
-                        source: 'power-rank'
-                    });
-                }
-            }
-        }
-        return candidates;
-    }
-    /**
-     * Updates prompt run with successful failover tracking data
-     */
-    updatePromptRunWithFailoverSuccess(promptRun, failoverAttempts, currentModel, currentVendorId) {
-        promptRun.FailoverAttempts = failoverAttempts.length;
-        promptRun.FailoverErrors = JSON.stringify(failoverAttempts.map(a => ({
-            model: a.modelId,
-            vendor: a.vendorId,
-            error: a.error.message,
-            errorType: a.errorType
-        })));
-        promptRun.FailoverDurations = JSON.stringify(failoverAttempts.map(a => a.duration));
-        promptRun.TotalFailoverDuration = failoverAttempts.reduce((sum, a) => sum + a.duration, 0);
-        // Update ModelID if we ended up using a different model
-        if (!UUIDsEqual(currentModel.ID, promptRun.OriginalModelID)) {
-            promptRun.ModelID = currentModel.ID;
-        }
-        if (currentVendorId && !UUIDsEqual(currentVendorId, promptRun.VendorID)) {
-            promptRun.VendorID = currentVendorId;
-        }
-    }
-    /**
-     * Updates prompt run with failover failure tracking data
-     */
-    updatePromptRunWithFailoverFailure(promptRun, failoverAttempts) {
-        promptRun.FailoverAttempts = failoverAttempts.length;
-        promptRun.FailoverErrors = JSON.stringify(failoverAttempts.map(a => ({
-            model: a.modelId,
-            vendor: a.vendorId,
-            error: a.error.message,
-            errorType: a.errorType
-        })));
-        promptRun.FailoverDurations = JSON.stringify(failoverAttempts.map(a => a.duration));
-        promptRun.TotalFailoverDuration = failoverAttempts.reduce((sum, a) => sum + a.duration, 0);
+        return this.ExecuteWithFailover(prompt, params, allCandidates, failoverConfig, (candidate) => this.executeModel(candidate.model, renderedPrompt, prompt, params, candidate.vendorId || null, conversationMessages, templateMessageRole, cancellationToken, candidate.driverClass, candidate.apiName, candidate.supportsEffortLevel, candidate.effortLevel, candidate.promptModelConfiguration), (lastError, failoverAttempts) => this.createFailoverErrorResult(lastError, failoverAttempts), promptRun, credentialAvailability);
     }
     /**
      * Creates an error result for failed failover attempts
@@ -2658,7 +1413,7 @@ export class AIPromptRunner {
      * Never throws: the gate is an opt-in enhancement and must not be able to fail a run that would
      * otherwise succeed, so any configuration problem resolves to the path that has always worked.
      */
-    resolveNativeToolCallingDecision(prompt, params, model, vendorId, promptModelConfiguration) {
+    ResolveNativeToolCallingDecision(prompt, params, model, vendorId, promptModelConfiguration) {
         try {
             return ResolveNativeToolCalling({
                 catalogConfiguration: AIEngine.Instance.GetEffectiveModelConfiguration(model.ID, vendorId
@@ -2667,7 +1422,7 @@ export class AIPromptRunner {
                     // order. Picking the developer row merges an empty config layer and silently drops any
                     // per-serving-path LLM.* knob (notably the SupportsNativeToolCalling kill switch).
                     ? model.ModelVendors?.find(mv => UUIDsEqual(mv.VendorID, vendorId)
-                        && mv.Status === 'Active' && this.isInferenceProvider(mv))?.ID
+                        && mv.Status === 'Active' && this.IsInferenceProvider(mv))?.ID
                     : undefined),
                 promptConfiguration: prompt.PromptConfigurationObject,
                 promptModelConfiguration,
@@ -2683,8 +1438,12 @@ export class AIPromptRunner {
             return { useNativeTools: false, mode: 'Envelope', controlFlow: 'envelope', toolResults: false };
         }
     }
+    /** @deprecated Use {@link ResolveNativeToolCallingDecision}. */
+    resolveNativeToolCallingDecision(prompt, params, model, vendorId, promptModelConfiguration) {
+        return this.ResolveNativeToolCallingDecision(prompt, params, model, vendorId, promptModelConfiguration);
+    }
     applyNativeToolCalling(chatParams, prompt, params, model, vendorId, promptModelConfiguration) {
-        const decision = this.resolveNativeToolCallingDecision(prompt, params, model, vendorId, promptModelConfiguration);
+        const decision = this.ResolveNativeToolCallingDecision(prompt, params, model, vendorId, promptModelConfiguration);
         if (decision.warning) {
             console.warn(`AIPromptRunner: ${decision.warning} (prompt "${prompt.Name}", model "${model.Name}"` +
                 `${vendorId ? `, vendor ${vendorId}` : ''})`);
@@ -2790,7 +1549,7 @@ export class AIPromptRunner {
                 supportsEffortLevel = model.SupportsEffortLevel ?? false;
                 if (vendorId) {
                     // Find the AIModelVendor record for this specific vendor - must be an inference provider
-                    const modelVendor = model.ModelVendors.find((mv) => UUIDsEqual(mv.VendorID, vendorId) && mv.Status === 'Active' && this.isInferenceProvider(mv));
+                    const modelVendor = model.ModelVendors.find((mv) => UUIDsEqual(mv.VendorID, vendorId) && mv.Status === 'Active' && this.IsInferenceProvider(mv));
                     if (modelVendor) {
                         driverClass = modelVendor.DriverClass || driverClass;
                         apiName = modelVendor.APIName || apiName;
@@ -2804,7 +1563,7 @@ export class AIPromptRunner {
                 }
             }
             // Resolve credentials using hierarchical resolution (Credentials system with legacy fallback)
-            const apiKey = await this.resolveCredentialForExecution(driverClass, prompt.ID, model.ID, vendorId ?? undefined, params);
+            const apiKey = await this.ResolveCredentialForExecution(driverClass, prompt.ID, model.ID, vendorId ?? undefined, params);
             // Create LLM instance with vendor-specific driver class
             llm = MJGlobal.Instance.ClassFactory.CreateInstance(BaseLLM, driverClass, apiKey);
             // Prepare chat parameters
@@ -2841,7 +1600,7 @@ export class AIPromptRunner {
             // Stop sequences are handled separately: the prompt value is comma-delimited and gated by
             // driver support; additionalParameters supplies a ready-made array that overrides it.
             if (prompt.StopSequences && this.shouldApplyStopSequences(prompt, model, vendorId, llm)) {
-                chatParams.stopSequences = prompt.StopSequences.split(',').map((s) => s.replace(AIPromptRunner.STOP_SEQUENCE_TRIM_REGEX, '')).filter((s) => s.length > 0);
+                chatParams.stopSequences = prompt.StopSequences.split(',').map((s) => TrimSpacesAndTabs(s)).filter((s) => s.length > 0);
             }
             if (params.additionalParameters?.stopSequences !== undefined) {
                 chatParams.stopSequences = params.additionalParameters.stopSequences;
@@ -2986,85 +1745,6 @@ export class AIPromptRunner {
             executionBound.Dispose();
         }
     }
-    /**
-     * Engine-level default model-call timeout, in milliseconds, applied when the caller supplies no
-     * `AIPromptParams.timeoutMS`. `undefined` (the default) means NO implicit bound — a prompt run
-     * with neither a timeout nor a cancellation token stays unbounded, exactly as before, so this
-     * change is behavior-preserving for existing callers.
-     *
-     * Subclasses (or a host application's runner subclass) can override this to impose a global
-     * safety ceiling on every prompt call.
-     */
-    get DefaultPromptTimeoutMS() {
-        return undefined;
-    }
-    /**
-     * Resolves the per-model-call timeout: the caller's `AIPromptParams.timeoutMS`, else the runner's
-     * {@link DefaultPromptTimeoutMS}. Non-positive / non-numeric values mean "no timeout".
-     *
-     * The bound is applied PER MODEL CALL (not per prompt execution), which mirrors the parallel
-     * path's existing `taskTimeoutMS` semantics: each failover candidate / validation retry gets a
-     * fresh budget rather than sharing one wall-clock window.
-     *
-     * NOTE (issue #3064): there is deliberately NO prompt-entity source here yet — the `AIPrompt`
-     * table has no `TimeoutMS` column today. Once a migration adds one and CodeGen regenerates the
-     * entity, this becomes `prompt.TimeoutMS ?? params.timeoutMS ?? this.DefaultPromptTimeoutMS`
-     * and every bound below starts honoring the per-prompt configuration with no other change.
-     */
-    getEffectiveTimeoutMS(params) {
-        const timeoutMS = params.timeoutMS ?? this.DefaultPromptTimeoutMS;
-        return typeof timeoutMS === 'number' && timeoutMS > 0 ? timeoutMS : undefined;
-    }
-    /**
-     * Composes the caller-supplied cancellation token with the resolved model-call timeout into a
-     * single {@link AbortSignal} that bounds one model call. NEITHER bound is discarded:
-     *
-     * - caller token only  → the caller's signal is used directly (behavior unchanged)
-     * - timeout only       → an internal controller aborts after the timeout elapses
-     * - both               → an internal controller relays the caller's abort AND fires on timeout;
-     *                        whichever happens first wins
-     * - neither            → `Signal` is undefined and the call runs unbounded (legacy behavior)
-     *
-     * Implemented with an AbortController + relay listener rather than `AbortSignal.any()` so it works
-     * on Node 18 (where `AbortSignal.any` does not exist — it landed in Node 20.3).
-     */
-    createExecutionBound(prompt, params, cancellationToken) {
-        const timeoutMS = this.getEffectiveTimeoutMS(params);
-        if (timeoutMS === undefined) {
-            // No prompt timeout: use the caller's token as-is (or nothing at all).
-            return { Signal: cancellationToken, TimeoutMS: undefined, TimedOut: () => false, Dispose: () => { } };
-        }
-        const controller = new AbortController();
-        let timedOut = false;
-        const relayCallerAbort = () => {
-            if (!controller.signal.aborted) {
-                controller.abort(cancellationToken?.reason ?? 'Chat completion was cancelled');
-            }
-        };
-        if (cancellationToken) {
-            if (cancellationToken.aborted) {
-                relayCallerAbort();
-            }
-            else {
-                cancellationToken.addEventListener('abort', relayCallerAbort, { once: true });
-            }
-        }
-        const timer = setTimeout(() => {
-            if (!controller.signal.aborted) {
-                timedOut = true;
-                controller.abort(new AIPromptTimeoutError(prompt.Name, timeoutMS));
-            }
-        }, timeoutMS);
-        return {
-            Signal: controller.signal,
-            TimeoutMS: timeoutMS,
-            TimedOut: () => timedOut,
-            Dispose: () => {
-                clearTimeout(timer);
-                cancellationToken?.removeEventListener('abort', relayCallerAbort);
-            },
-        };
-    }
     /**
      * Runs the model call, racing it against the composed execution bound so a hung provider surfaces
      * as a rejected promise the caller's failover/retry logic can act on.
@@ -3183,7 +1863,6 @@ export class AIPromptRunner {
         const result = [];
         let inManifest = false;
         let mutated = false;
-        const entryRegex = /^\*\*[A-Z]+\*\* — .+? \[(?<mime>[^\]]+)\]/;
         for (const line of lines) {
             if (line.startsWith('## Available Artifacts')) {
                 inManifest = true;
@@ -3196,10 +1875,11 @@ export class AIPromptRunner {
             result.push(line);
             if (!inManifest)
                 continue;
-            const match = entryRegex.exec(line);
-            if (!match)
+            // `**A** — name [mime]`; parsed linearly (CodeQL js/polynomial-redos flagged the regex form).
+            const entryMime = ParseManifestEntryMime(line);
+            if (entryMime === null)
                 continue;
-            const mime = (match.groups?.mime ?? '').toLowerCase();
+            const mime = entryMime.toLowerCase();
             const modality = mime.split('/')[0];
             if (modality !== 'image' && modality !== 'audio' && modality !== 'video')
                 continue;
@@ -3315,23 +1995,6 @@ export class AIPromptRunner {
         }
         return messages;
     }
-    /**
-     * Default fallback instruction text used when no PrefillFallbackText is configured
-     * at any level of the AIModelType → AIModel → AIModelVendor cascade.
-     */
-    static { this.DEFAULT_PREFILL_FALLBACK = '# **CRITICAL**\nYour response must start with exactly: {{prefill}}\nDo not add quotes, markdown formatting, or any other characters before it.'; }
-    /**
-     * Regex used to trim only horizontal whitespace (spaces and tabs) from the start and end
-     * of each stop sequence token after comma-splitting.
-     *
-     * We intentionally do NOT use String.trim() here because stop sequences can legitimately
-     * begin or end with newline characters. For example, the sequence "\n```" is designed to
-     * match only a closing code fence (preceded by a newline), distinguishing it from an
-     * opening "```json" fence that does not start with a newline. Using trim() would strip
-     * that leading "\n", turning "\n```" into "```" and causing the stop to fire on the
-     * opening fence instead — producing an empty response for non-native prefill providers.
-     */
-    static { this.STOP_SEQUENCE_TRIM_REGEX = /^[ \t]+|[ \t]+$/g; }
     /**
      * Substrings that mark a provider failure as TOOLS-specific, so the native call is worth one
      * envelope retry (see {@link AIPromptRunner.isToolSpecificFailure}). Drawn from how the
@@ -3429,28 +2092,6 @@ export class AIPromptRunner {
         }
         return supportsPrefill;
     }
-    /**
-     * Resolves the prefill fallback instruction text using the cascade:
-     * AIModelType → AIModel → AIModelVendor (most specific non-null wins).
-     * Falls back to DEFAULT_PREFILL_FALLBACK if none are configured.
-     */
-    resolvePrefillFallbackText(model, vendorId) {
-        // Start with model type default
-        const modelType = AIEngine.Instance.ModelTypesByID.get(NormalizeUUID(model.AIModelTypeID));
-        let fallbackText = modelType?.PrefillFallbackText ?? null;
-        // Model-level override
-        if (model.PrefillFallbackText != null) {
-            fallbackText = model.PrefillFallbackText;
-        }
-        // Vendor-level override
-        if (vendorId) {
-            const modelVendor = model.ModelVendors.find(mv => UUIDsEqual(mv.VendorID, vendorId) && mv.Status === 'Active');
-            if (modelVendor?.PrefillFallbackText != null) {
-                fallbackText = modelVendor.PrefillFallbackText;
-            }
-        }
-        return fallbackText ?? AIPromptRunner.DEFAULT_PREFILL_FALLBACK;
-    }
     /**
      * Applies assistant prefill to ChatParams based on prompt configuration and provider support.
      * Handles the full prefill resolution logic including fallback to system instructions.
@@ -3490,6 +2131,33 @@ export class AIPromptRunner {
         }
         // 'Ignore' and 'None' — silently skip, no action needed
     }
+    /**
+     * Default fallback instruction text used when no PrefillFallbackText is configured
+     * at any level of the AIModelType → AIModel → AIModelVendor cascade.
+     */
+    static { this.DEFAULT_PREFILL_FALLBACK = '# **CRITICAL**\nYour response must start with exactly: {{prefill}}\nDo not add quotes, markdown formatting, or any other characters before it.'; }
+    /**
+     * Resolves the prefill fallback instruction text using the cascade:
+     * AIModelType → AIModel → AIModelVendor (most specific non-null wins).
+     * Falls back to DEFAULT_PREFILL_FALLBACK if none are configured.
+     */
+    resolvePrefillFallbackText(model, vendorId) {
+        // Start with model type default
+        const modelType = AIEngine.Instance.ModelTypesByID.get(NormalizeUUID(model.AIModelTypeID));
+        let fallbackText = modelType?.PrefillFallbackText ?? null;
+        // Model-level override
+        if (model.PrefillFallbackText != null) {
+            fallbackText = model.PrefillFallbackText;
+        }
+        // Vendor-level override
+        if (vendorId) {
+            const modelVendor = model.ModelVendors.find(mv => UUIDsEqual(mv.VendorID, vendorId) && mv.Status === 'Active');
+            if (modelVendor?.PrefillFallbackText != null) {
+                fallbackText = modelVendor.PrefillFallbackText;
+            }
+        }
+        return fallbackText ?? AIPromptRunner.DEFAULT_PREFILL_FALLBACK;
+    }
     /**
      * Executes the model with retry logic for validation failures
      */
@@ -3509,7 +2177,7 @@ export class AIPromptRunner {
                 }
                 if (attempt > 0) {
                     LogStatus(`   🔄 Retrying execution due to validation failure, attempt ${attempt + 1}/${maxRetries + 1}`);
-                    await this.applyRetryDelay(prompt, attempt);
+                    await this.ApplyRetryDelay(prompt, attempt);
                 }
                 // Execute the AI model with failover support
                 const modelResult = await this.executeModelWithFailover(selectedModel, renderedPromptText, prompt, params, promptRun.VendorID, params.conversationMessages, params.templateMessageRole || 'system', params.cancellationToken, allCandidates, // Pass the candidates from initial selection
@@ -3576,15 +2244,16 @@ export class AIPromptRunner {
                 }
                 // Validation failed, check if we should retry
                 // BUG FIX: Only retry in Strict mode, not in Warn or None modes
-                if (prompt.ValidationBehavior === 'Strict' && attempt < maxRetries) {
+                const effectiveValidationBehavior = params?.validationBehavior || prompt.ValidationBehavior;
+                if (effectiveValidationBehavior === 'Strict' && attempt < maxRetries) {
                     lastError = new Error(`Validation failed: ${validationErrors?.map(e => e.Message).join('; ')}`);
                     LogStatus(`   ⚠️ Validation failed on attempt ${attempt + 1}, will retry (Strict mode)`);
                     continue; // Retry
                 }
                 else {
                     // Either not strict mode or no more retries, return what we have
-                    const reason = prompt.ValidationBehavior !== 'Strict'
-                        ? `${prompt.ValidationBehavior || 'None'} mode - continuing with invalid output (no retry)`
+                    const reason = effectiveValidationBehavior !== 'Strict'
+                        ? `${effectiveValidationBehavior || 'None'} mode - continuing with invalid output (no retry)`
                         : 'max retries exceeded';
                     LogStatus(`   ⚠️ Validation failed on attempt ${attempt + 1}, stopping retries (${reason})`);
                     return {
@@ -3628,166 +2297,6 @@ export class AIPromptRunner {
         // Should not reach here, but just in case
         throw lastError || new Error('Execution failed after all retry attempts');
     }
-    /**
-     * Applies retry delay based on the prompt's retry strategy
-     */
-    /**
-     * Calculates retry delay for rate limit and other retriable errors.
-     * Uses the prompt's RetryStrategy and can respect suggested delays from provider.
-     */
-    calculateRetryDelay(prompt, attemptNumber, suggestedDelaySeconds) {
-        // Use provider's suggested delay if available
-        if (suggestedDelaySeconds && suggestedDelaySeconds > 0) {
-            return suggestedDelaySeconds * 1000; // Convert to milliseconds
-        }
-        const baseDelay = prompt.RetryDelayMS || 1000; // Default 1 second
-        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;
-        }
-        return delay;
-    }
-    async applyRetryDelay(prompt, attemptNumber, suggestedDelaySeconds) {
-        const delay = this.calculateRetryDelay(prompt, attemptNumber, suggestedDelaySeconds);
-        const delaySeconds = (delay / 1000).toFixed(1);
-        LogStatus(`   Waiting ${delaySeconds}s before retry (strategy: ${prompt.RetryStrategy || 'Fixed'})...`);
-        await new Promise(resolve => setTimeout(resolve, delay));
-    }
-    /**
-     * Filters out all candidates from a vendor when a vendor-level error occurs.
-     * Vendor-level errors affect all models from that vendor:
-     * - Authentication: Invalid API key
-     * - VendorValidationError: API schema/validation requirements
-     */
-    filterVendorCandidates(errorType, currentVendorId, allCandidates) {
-        if (errorType !== 'Authentication' && errorType !== 'VendorValidationError') {
-            return allCandidates; // No filtering needed for non-vendor-level errors
-        }
-        const failedVendorId = currentVendorId || 'default';
-        const beforeCount = allCandidates.length;
-        // Filter out ALL candidates from this vendor
-        const filteredCandidates = allCandidates.filter(c => (c.vendorId || 'default') !== failedVendorId);
-        const removedCount = beforeCount - filteredCandidates.length;
-        if (removedCount > 0) {
-            const vendorName = AIEngine.Instance.VendorsByID.get(NormalizeUUID(failedVendorId))?.Name || failedVendorId;
-            const remainingCount = filteredCandidates.length;
-            // Log appropriate message based on error type
-            let reason;
-            let icon;
-            if (errorType === 'Authentication') {
-                reason = 'Invalid API key';
-                icon = '🔒';
-            }
-            else if (errorType === 'VendorValidationError') {
-                reason = 'API schema incompatibility';
-                icon = '⚠️';
-            }
-            else {
-                reason = 'Vendor-level error';
-                icon = '❌';
-            }
-            this.logStatus(`   ${icon} ${reason} for ${vendorName} - excluding ${removedCount} model${removedCount === 1 ? '' : 's'} from this vendor (${remainingCount} remaining)`, true);
-        }
-        return filteredCandidates;
-    }
-    /**
-     * Handles rate limit errors by retrying the same model/vendor with backoff.
-     * Returns true if the caller should continue (retry), false if should proceed to failover.
-     */
-    async handleRateLimitRetry(errorAnalysis, currentModel, currentVendorId, failoverAttempts, prompt, attemptNumber, maxAttempts, failoverAttempt) {
-        const isRateLimit = errorAnalysis.errorType === 'RateLimit';
-        if (!isRateLimit) {
-            return false; // Not a rate limit error
-        }
-        // Count how many times we've retried this specific model/vendor for rate limits
-        const rateLimitRetryCount = failoverAttempts.filter(a => UUIDsEqual(a.modelId, currentModel.ID) &&
-            UUIDsEqual(a.vendorId, currentVendorId) &&
-            a.errorType === 'RateLimit').length;
-        // Use MaxRetries from prompt configuration, default to 3 if not set
-        const maxRetries = prompt.MaxRetries ?? 3;
-        // Retry up to MaxRetries times before giving up and failing over
-        const shouldRetry = rateLimitRetryCount <= maxRetries;
-        if (shouldRetry) {
-            const modelName = currentModel.Name;
-            const vendorName = currentVendorId
-                ? AIEngine.Instance.VendorsByID.get(NormalizeUUID(currentVendorId))?.Name || 'default'
-                : 'default';
-            this.logStatus(`   ⏳ Rate limit hit - retrying ${modelName} (${vendorName}) with backoff (attempt ${rateLimitRetryCount}/${maxRetries})`, true);
-            this.logFailoverAttempt(prompt.ID, failoverAttempt, true);
-            // Apply backoff delay before retry
-            if (attemptNumber < maxAttempts) {
-                await this.applyRetryDelay(prompt, rateLimitRetryCount, errorAnalysis.suggestedRetryDelaySeconds);
-            }
-            return true; // Signal to continue with same model/vendor
-        }
-        return false; // Too many retries, proceed to failover
-    }
-    /**
-     * Processes a failover error (either from catch block or from failed ChatResult).
-     * Handles vendor filtering, rate limit retries, fatal error detection, and failover logic.
-     *
-     * @returns Decision object indicating whether to retry same model, continue to next candidate, or stop
-     */
-    async processFailoverError(error, errorInfo, candidate, attemptStartTime, attemptIndex, allCandidates, failoverAttempts, prompt, failoverConfig) {
-        const attemptDuration = Date.now() - attemptStartTime;
-        // Create failover attempt record
-        const failoverAttempt = {
-            attemptNumber: attemptIndex + 1,
-            modelId: candidate.model.ID,
-            vendorId: candidate.vendorId,
-            error: error,
-            errorType: errorInfo.errorType,
-            duration: attemptDuration,
-            timestamp: new Date()
-        };
-        failoverAttempts.push(failoverAttempt);
-        // Vendor-level errors: filter out all candidates from this vendor
-        let updatedCandidates = allCandidates;
-        if (errorInfo.errorType === 'Authentication' || errorInfo.errorType === 'VendorValidationError') {
-            updatedCandidates = this.filterVendorCandidates(errorInfo.errorType, candidate.vendorId, allCandidates);
-        }
-        const isLastCandidate = attemptIndex === updatedCandidates.length - 1;
-        // Fatal errors: stop immediately
-        if (errorInfo.severity === 'Fatal') {
-            const errorMessage = error?.message || 'Unknown error';
-            LogErrorEx(`Stopping failover: Fatal error (${errorInfo.errorType}): ${errorMessage}`);
-            this.logFailoverAttempt(prompt.ID, failoverAttempt, false);
-            return { shouldRetry: false, shouldContinue: false, updatedCandidates };
-        }
-        // Check errorScope filter if configured
-        if (failoverConfig.errorScope && failoverConfig.errorScope !== 'All') {
-            const matchesScope = this.errorMatchesScope(errorInfo.errorType, failoverConfig.errorScope);
-            if (!matchesScope) {
-                this.logFailoverAttempt(prompt.ID, failoverAttempt, false);
-                return { shouldRetry: false, shouldContinue: false, updatedCandidates };
-            }
-        }
-        // Rate limit errors: check if we should retry the same model before failing over
-        if (errorInfo.errorType === 'RateLimit') {
-            const shouldRetry = await this.handleRateLimitRetry(errorInfo, candidate.model, candidate.vendorId, failoverAttempts, prompt, attemptIndex, updatedCandidates.length, failoverAttempt);
-            if (shouldRetry) {
-                return { shouldRetry: true, shouldContinue: false, updatedCandidates };
-            }
-        }
-        // If this is the last candidate, we're done
-        if (isLastCandidate) {
-            this.logFailoverAttempt(prompt.ID, failoverAttempt, false);
-            return { shouldRetry: false, shouldContinue: false, updatedCandidates };
-        }
-        // Log and signal to continue to next candidate
-        this.logFailoverAttempt(prompt.ID, failoverAttempt, true);
-        return { shouldRetry: false, shouldContinue: true, updatedCandidates };
-    }
     /**
      * Transitions to the next failover candidate.
      * Returns the next candidate info or null if no candidates are available.
@@ -3816,28 +2325,6 @@ export class AIPromptRunner {
             supportsEffortLevel: nextCandidate.supportsEffortLevel || false
         };
     }
-    /**
-     * Provides a human-readable description of the validation decision
-     */
-    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}`;
-            }
-        }
-    }
     /**
      * Generates a JSON schema from an example object for validation
      */
@@ -4064,7 +2551,8 @@ export class AIPromptRunner {
             validationResult.Errors = validationErrors.length > 0 ? validationErrors : [
                 new ValidationErrorInfo('general', error.message, undefined, ValidationErrorType.Failure)
             ];
-            switch (prompt.ValidationBehavior) {
+            const effectiveValidationBehavior = params?.validationBehavior || prompt.ValidationBehavior;
+            switch (effectiveValidationBehavior) {
                 case 'Strict':
                     return { result: undefined, validationResult, validationErrors: validationResult.Errors };
                 case 'Warn':
@@ -4319,7 +2807,12 @@ export class AIPromptRunner {
                         ERROR_MESSAGE: trueError,
                         MALFORMED_JSON: rawOutput
                     },
-                    skipValidation: true // don't want to validate as this would cause recursive infinity scenario if the JSON is invalid. Just one shot, fix or no fix
+                    skipValidation: true, // one shot, fix or no fix: no validation retries on the repair itself.
+                    // attemptJSONRepair is deliberately NOT set, so a repair can never start a repair of its own.
+                    // That keeps every run within two levels of an agent step's target, which is as far as
+                    // vwAIUsageFacts looks for the agent run (pinned by the nesting-depth tests).
+                    agentId: params.agentId,
+                    UserID: ResolvePromptRunUserID({ UserID: params.UserID, ContextUser: params.contextUser }) ?? undefined,
                 });
                 if (!repairResult.success || !repairResult.result) {
                     throw new Error('AI-based JSON repair failed' + (repairResult.errorMessage ? `: ${repairResult.errorMessage}` : ''));
@@ -4468,496 +2961,343 @@ export class AIPromptRunner {
         }
         return validationErrors;
     }
+    // ==================== PROMPT RUN LIFECYCLE ====================
     /**
-     * Updates the AIPromptRun entity with execution results
+     * Creates an AIPromptRun entity for execution tracking
      */
-    async updatePromptRun(promptRun, prompt, modelResult, parsedResult, endTime, executionTimeMS, validationAttempts, cumulativeTokens) {
-        // Fire-and-forget finalize UPDATE. The field mutations run INSIDE the post-INSERT task (after the
-        // 'Running' INSERT + its finalizeSave reload land), so the reload can never revert them and the
-        // chained UPDATE persists the finalized state — the "stuck at Running" race is structurally
-        // impossible. The execution flow does NOT await the save.
-        this._promptRunQueue.Update(promptRun, () => this.applyFinalizedPromptRunFields(promptRun, prompt, modelResult, parsedResult, endTime, executionTimeMS, validationAttempts, cumulativeTokens));
+    async createPromptRun(prompt, model, params, systemPromptText, startTime, vendorId, modelSelectionInfo, runType) {
+        return this.CreateRunRecord(prompt, model, params, startTime, vendorId, modelSelectionInfo, (promptRun) => {
+            this.applyChatRequestFields(promptRun, prompt, model, params, systemPromptText, startTime, vendorId);
+            // An explicit run type (the consolidated parallel parent) wins over params.RunType.
+            if (runType) {
+                promptRun.RunType = runType;
+            }
+        });
     }
     /**
-     * Populates a prompt-run's finalized fields (result, tokens, cost, timing, rollups) from the model
-     * result. Runs INSIDE the post-INSERT save task — see {@link updatePromptRun}. Errors here are
-     * logged (non-fatal): the AIPromptRun is observability, not part of the prompt's success contract.
-     */
-    applyFinalizedPromptRunFields(promptRun, prompt, modelResult, parsedResult, endTime, executionTimeMS, validationAttempts, cumulativeTokens) {
-        try {
-            promptRun.CompletedAt = endTime;
-            promptRun.ExecutionTimeMS = executionTimeMS;
-            // Determine what to save as the result
-            let resultToSave;
-            const rawResult = modelResult.data?.choices?.[0]?.message?.content || '';
-            if (parsedResult.result === undefined ||
-                parsedResult.result === null ||
-                (typeof parsedResult.result === 'string' && parsedResult.result.trim().length === 0)) {
-                // Use raw result as fallback when parsed result is undefined, null, or empty string
-                resultToSave = rawResult;
-                // Also set error message when we have to fall back to raw result
-                if (!promptRun.ErrorMessage) {
-                    const validationErrors = parsedResult.validationResult?.Errors;
-                    if (validationErrors && validationErrors.length > 0) {
-                        promptRun.ErrorMessage = `JSON parsing/validation failed: ${validationErrors.map(e => e.Message).join('; ')}`;
-                    }
-                    else {
-                        promptRun.ErrorMessage = 'Failed to parse result into expected format; raw output saved instead';
-                    }
-                }
-            }
-            else if (typeof parsedResult.result === 'string') {
-                resultToSave = parsedResult.result;
-            }
-            else {
-                resultToSave = JSON.stringify(parsedResult.result);
-            }
-            promptRun.Result = resultToSave;
-            // Extract token usage and cost - use cumulative if retries occurred
-            if (cumulativeTokens && validationAttempts && validationAttempts.length > 1) {
-                // Multiple attempts occurred, use cumulative totals. cumulativeTokens.promptTokens is the
-                // UNCACHED ("net-new") input summed across attempts; cache reads/writes are NOT summed (the
-                // re-sent prefix would over-count) and are persisted from the final model result below.
-                // TokensUsed must equal TokensPrompt + TokensCompletion (AIPromptRun invariant), so it does
-                // NOT include the cache buckets — those live in TokensCacheRead/TokensCacheWrite.
-                promptRun.TokensPrompt = cumulativeTokens.promptTokens;
-                promptRun.TokensCompletion = cumulativeTokens.completionTokens;
-                promptRun.TokensUsed = cumulativeTokens.promptTokens + cumulativeTokens.completionTokens;
-                promptRun.Cost = cumulativeTokens.totalCost;
-                // Cost currency from the last model result
-                if (modelResult.data?.usage?.costCurrency !== undefined) {
-                    promptRun.CostCurrency = modelResult.data.usage.costCurrency;
+     * Sets a prompt-run's chat-specific request fields: messages, prefill, sampling parameters,
+     * response format, streaming, effort level, child prompt and the validation/retry columns. Called by
+     * {@link BaseModelRunner.CreateRunRecord} just before the INSERT is queued.
+     */
+    applyChatRequestFields(promptRun, prompt, model, params, systemPromptText, startTime, vendorId) {
+        // Set ChildPromptID if this is a hierarchical execution with child prompts
+        if (params.childPrompts && params.childPrompts.length > 0) {
+            promptRun.ChildPromptID = params.childPrompts[0].childPrompt.prompt.ID;
+        }
+        promptRun.StreamingEnabled = !!params.onStreaming;
+        // Resolve and save the effort level used (same precedence as ChatParams resolution).
+        // EffortLevel is a numeric column with a CHECK (1-100), so a provider-named level such as
+        // 'xhigh' is deliberately not persisted here — it still reaches the driver via ChatParams.
+        if (typeof params.effortLevel === 'number') {
+            promptRun.EffortLevel = params.effortLevel;
+        }
+        else if (prompt.EffortLevel !== undefined && prompt.EffortLevel !== null) {
+            promptRun.EffortLevel = prompt.EffortLevel;
+        }
+        // If neither is set, EffortLevel remains null (provider default was used)
+        // Always save the response format from the prompt if it exists
+        if (prompt.ResponseFormat && prompt.ResponseFormat !== 'Any') {
+            promptRun.ResponseFormat = prompt.ResponseFormat;
+        }
+        // Save the actual values that will be used (prompt defaults overridden by additionalParameters).
+        // Uses the shared resolver so the persisted record matches what executeModel sends to the model.
+        const resolvedParams = this.resolveScalarInferenceParams(prompt, params.additionalParameters);
+        if (resolvedParams.temperature !== undefined)
+            promptRun.Temperature = resolvedParams.temperature;
+        if (resolvedParams.topP !== undefined)
+            promptRun.TopP = resolvedParams.topP;
+        if (resolvedParams.topK !== undefined)
+            promptRun.TopK = resolvedParams.topK;
+        if (resolvedParams.minP !== undefined)
+            promptRun.MinP = resolvedParams.minP;
+        if (resolvedParams.frequencyPenalty !== undefined)
+            promptRun.FrequencyPenalty = resolvedParams.frequencyPenalty;
+        if (resolvedParams.presencePenalty !== undefined)
+            promptRun.PresencePenalty = resolvedParams.presencePenalty;
+        if (resolvedParams.seed !== undefined)
+            promptRun.Seed = resolvedParams.seed;
+        if (resolvedParams.includeLogProbs !== undefined)
+            promptRun.LogProbs = resolvedParams.includeLogProbs;
+        if (resolvedParams.topLogProbs !== undefined)
+            promptRun.TopLogProbs = resolvedParams.topLogProbs;
+        // Stop sequences + assistant prefill: stored from the prompt, with the additionalParameters
+        // array (JSON-encoded) taking precedence when supplied.
+        if (prompt.StopSequences)
+            promptRun.StopSequences = prompt.StopSequences;
+        if (prompt.AssistantPrefill)
+            promptRun.AssistantPrefill = prompt.AssistantPrefill;
+        if (params.additionalParameters?.stopSequences !== undefined && params.additionalParameters.stopSequences.length > 0) {
+            promptRun.StopSequences = JSON.stringify(params.additionalParameters.stopSequences);
+        }
+        // Store the input data/context as JSON in Messages field.
+        // Also capture callers that supply conversationMessages directly (e.g. templateMessageRole='none',
+        // no rendered system prompt) — otherwise their assembled prompt would never be persisted.
+        if (params.data || params.templateData || systemPromptText || (params.conversationMessages?.length ?? 0) > 0) {
+            const messages = [];
+            if (systemPromptText) {
+                // Build the system prompt content, including prefill fallback if applicable
+                let systemContent = systemPromptText;
+                if (prompt.AssistantPrefill && prompt.PrefillFallbackMode === 'SystemInstruction') {
+                    const fallbackTemplate = this.resolvePrefillFallbackText(model, vendorId);
+                    // Function replacement: prefill text is authored content that routinely
+                    // contains `$` (LaTeX `$$`, currency, JSON fragments), and a string
+                    // replacement would expand it. See issue #3171.
+                    const prefill = prompt.AssistantPrefill;
+                    const fallbackInstruction = fallbackTemplate.replace(/\{\{prefill\}\}/g, () => prefill);
+                    systemContent += '\n\n' + fallbackInstruction;
                 }
+                messages.push({
+                    role: 'system',
+                    content: systemContent
+                });
             }
-            else if (modelResult.data?.usage) {
-                // Single attempt, use standard token tracking
-                promptRun.TokensUsed = modelResult.data.usage.totalTokens;
-                promptRun.TokensPrompt = modelResult.data.usage.promptTokens;
-                promptRun.TokensCompletion = modelResult.data.usage.completionTokens;
-                // Save cost information if available
-                if (modelResult.data.usage.cost !== undefined) {
-                    promptRun.Cost = modelResult.data.usage.cost;
-                }
-                if (modelResult.data.usage.costCurrency !== undefined) {
-                    promptRun.CostCurrency = modelResult.data.usage.costCurrency;
-                }
-                // Save timing information if available
-                if (modelResult.data.usage.queueTime !== undefined) {
-                    promptRun.QueueTime = modelResult.data.usage.queueTime;
-                }
-                if (modelResult.data.usage.promptTime !== undefined) {
-                    promptRun.PromptTime = modelResult.data.usage.promptTime;
+            // Always include any caller-supplied conversation messages (previously only recorded when a
+            // template system prompt was present, which dropped them for the pure-conversationMessages path).
+            messages.push(...(params.conversationMessages || []));
+            promptRun.Messages = JSON.stringify({
+                data: params.data,
+                templateData: params.templateData,
+                messages: messages || [],
+            });
+        }
+        // Populate new retry tracking columns with initial values
+        promptRun.ValidationBehavior = params.validationBehavior || prompt.ValidationBehavior || 'Warn';
+        promptRun.RetryStrategy = prompt.RetryStrategy || 'Fixed';
+        promptRun.MaxRetriesConfigured = prompt.MaxRetries || 0;
+        promptRun.FirstAttemptAt = startTime;
+        promptRun.ValidationAttemptCount = 0; // Will be updated during execution
+        promptRun.SuccessfulValidationCount = 0;
+        promptRun.FinalValidationPassed = false; // Will be updated after execution
+    }
+    /**
+     * Updates the AIPromptRun entity with execution results
+     */
+    async updatePromptRun(promptRun, prompt, modelResult, parsedResult, endTime, executionTimeMS, validationAttempts, cumulativeTokens) {
+        // A chat run succeeds only if the model call succeeded AND its output did not fail validation.
+        const success = modelResult.success && (parsedResult.validationResult?.Success !== false);
+        return this.FinalizeRunRecord(promptRun, success, endTime, executionTimeMS, (run) => this.applyChatResultFields(run, prompt, modelResult, parsedResult, endTime, executionTimeMS, validationAttempts, cumulativeTokens));
+    }
+    /**
+     * Populates a prompt-run's chat-specific finalized fields (result, tokens, cost, timing, validation)
+     * from the model result. Runs INSIDE the post-INSERT save task — see {@link BaseModelRunner.FinalizeRunRecord},
+     * which sets the completion timing, `Success` and `Status` before this runs and the rollups after it,
+     * and logs (non-fatal) any error thrown here: the AIPromptRun is observability, not part of the
+     * prompt's success contract.
+     */
+    applyChatResultFields(promptRun, prompt, modelResult, parsedResult, endTime, executionTimeMS, validationAttempts, cumulativeTokens) {
+        // Determine what to save as the result
+        let resultToSave;
+        const rawResult = modelResult.data?.choices?.[0]?.message?.content || '';
+        if (parsedResult.result === undefined ||
+            parsedResult.result === null ||
+            (typeof parsedResult.result === 'string' && parsedResult.result.trim().length === 0)) {
+            // Use raw result as fallback when parsed result is undefined, null, or empty string
+            resultToSave = rawResult;
+            // Also set error message when we have to fall back to raw result
+            if (!promptRun.ErrorMessage) {
+                const validationErrors = parsedResult.validationResult?.Errors;
+                if (validationErrors && validationErrors.length > 0) {
+                    promptRun.ErrorMessage = `JSON parsing/validation failed: ${validationErrors.map(e => e.Message).join('; ')}`;
                 }
-                if (modelResult.data.usage.completionTime !== undefined) {
-                    promptRun.CompletionTime = modelResult.data.usage.completionTime;
+                else {
+                    promptRun.ErrorMessage = 'Failed to parse result into expected format; raw output saved instead';
                 }
             }
-            // Provider prompt-cache token counts (informational; no cost is derived here). Taken from the
-            // final model result in both the single-attempt and retry paths — cache reads are best
-            // represented by the final call rather than summed across retries (which would over-count the
-            // re-sent prefix). 0 means "no cache activity reported", consistent with ModelUsage defaults.
-            if (modelResult.data?.usage) {
-                promptRun.TokensCacheRead = modelResult.data.usage.cacheReadTokens ?? 0;
-                promptRun.TokensCacheWrite = modelResult.data.usage.cacheWriteTokens ?? 0;
+        }
+        else if (typeof parsedResult.result === 'string') {
+            resultToSave = parsedResult.result;
+        }
+        else {
+            resultToSave = JSON.stringify(parsedResult.result);
+        }
+        promptRun.Result = resultToSave;
+        // Extract token usage and cost - use cumulative if retries occurred
+        if (cumulativeTokens && validationAttempts && validationAttempts.length > 1) {
+            // Multiple attempts occurred, use cumulative totals. cumulativeTokens.promptTokens is the
+            // UNCACHED ("net-new") input summed across attempts; cache reads/writes are NOT summed (the
+            // re-sent prefix would over-count) and are persisted from the final model result below.
+            // TokensUsed must equal TokensPrompt + TokensCompletion (AIPromptRun invariant), so it does
+            // NOT include the cache buckets — those live in TokensCacheRead/TokensCacheWrite.
+            promptRun.TokensPrompt = cumulativeTokens.promptTokens;
+            promptRun.TokensCompletion = cumulativeTokens.completionTokens;
+            promptRun.TokensUsed = cumulativeTokens.promptTokens + cumulativeTokens.completionTokens;
+            promptRun.Cost = cumulativeTokens.totalCost;
+            // Cost currency from the last model result
+            if (modelResult.data?.usage?.costCurrency !== undefined) {
+                promptRun.CostCurrency = modelResult.data.usage.costCurrency;
+            }
+        }
+        else if (modelResult.data?.usage) {
+            // Single attempt, use standard token tracking
+            promptRun.TokensUsed = modelResult.data.usage.totalTokens;
+            promptRun.TokensPrompt = modelResult.data.usage.promptTokens;
+            promptRun.TokensCompletion = modelResult.data.usage.completionTokens;
+            // Save cost information if available
+            if (modelResult.data.usage.cost !== undefined) {
+                promptRun.Cost = modelResult.data.usage.cost;
+            }
+            if (modelResult.data.usage.costCurrency !== undefined) {
+                promptRun.CostCurrency = modelResult.data.usage.costCurrency;
+            }
+            // Save timing information if available
+            if (modelResult.data.usage.queueTime !== undefined) {
+                promptRun.QueueTime = modelResult.data.usage.queueTime;
+            }
+            if (modelResult.data.usage.promptTime !== undefined) {
+                promptRun.PromptTime = modelResult.data.usage.promptTime;
+            }
+            if (modelResult.data.usage.completionTime !== undefined) {
+                promptRun.CompletionTime = modelResult.data.usage.completionTime;
+            }
+        }
+        // Provider prompt-cache token counts (informational; no cost is derived here). Taken from the
+        // final model result in both the single-attempt and retry paths — cache reads are best
+        // represented by the final call rather than summed across retries (which would over-count the
+        // re-sent prefix). 0 means "no cache activity reported", consistent with ModelUsage defaults.
+        if (modelResult.data?.usage) {
+            promptRun.TokensCacheRead = modelResult.data.usage.cacheReadTokens ?? 0;
+            promptRun.TokensCacheWrite = modelResult.data.usage.cacheWriteTokens ?? 0;
+        }
+        // Save model-specific response details if available
+        if (modelResult.modelSpecificResponseDetails) {
+            promptRun.ModelSpecificResponseDetails = JSON.stringify(modelResult.modelSpecificResponseDetails);
+        }
+        // Populate retry tracking columns
+        if (validationAttempts && validationAttempts.length > 0) {
+            // Update retry tracking columns
+            promptRun.ValidationAttemptCount = validationAttempts.length;
+            promptRun.SuccessfulValidationCount = validationAttempts.filter(a => a.success).length;
+            promptRun.FinalValidationPassed = parsedResult.validationResult?.Success === true;
+            promptRun.LastAttemptAt = endTime;
+            // Calculate total retry duration (excluding first attempt)
+            if (validationAttempts.length > 1) {
+                const firstAttemptTime = validationAttempts[0].timestamp;
+                const lastAttemptTime = validationAttempts[validationAttempts.length - 1].timestamp;
+                promptRun.TotalRetryDurationMS = lastAttemptTime.getTime() - firstAttemptTime.getTime();
             }
-            // Save model-specific response details if available
-            if (modelResult.modelSpecificResponseDetails) {
-                promptRun.ModelSpecificResponseDetails = JSON.stringify(modelResult.modelSpecificResponseDetails);
+            else {
+                promptRun.TotalRetryDurationMS = 0;
             }
-            // Populate retry tracking columns
-            if (validationAttempts && validationAttempts.length > 0) {
-                // Update retry tracking columns
-                promptRun.ValidationAttemptCount = validationAttempts.length;
-                promptRun.SuccessfulValidationCount = validationAttempts.filter(a => a.success).length;
-                promptRun.FinalValidationPassed = parsedResult.validationResult?.Success === true;
-                promptRun.LastAttemptAt = endTime;
-                // Calculate total retry duration (excluding first attempt)
-                if (validationAttempts.length > 1) {
-                    const firstAttemptTime = validationAttempts[0].timestamp;
-                    const lastAttemptTime = validationAttempts[validationAttempts.length - 1].timestamp;
-                    promptRun.TotalRetryDurationMS = lastAttemptTime.getTime() - firstAttemptTime.getTime();
-                }
-                else {
-                    promptRun.TotalRetryDurationMS = 0;
-                }
-                // Get final validation error if any
-                const finalAttempt = validationAttempts[validationAttempts.length - 1];
-                if (!finalAttempt.success && finalAttempt.errorMessage) {
-                    promptRun.FinalValidationError = finalAttempt.errorMessage.substring(0, 500); // Truncate to fit column
-                    promptRun.ValidationErrorCount = finalAttempt.validationErrors?.length || 0;
-                }
-                // Find most common validation error
-                if (validationAttempts.some(a => !a.success)) {
-                    const errorCounts = new Map();
-                    validationAttempts.forEach(attempt => {
-                        if (!attempt.success && attempt.errorMessage) {
-                            const count = errorCounts.get(attempt.errorMessage) || 0;
-                            errorCounts.set(attempt.errorMessage, count + 1);
-                        }
-                    });
-                    if (errorCounts.size > 0) {
-                        const [commonError] = [...errorCounts.entries()].sort((a, b) => b[1] - a[1])[0];
-                        promptRun.CommonValidationError = commonError.substring(0, 255); // Truncate to fit column
+            // Get final validation error if any
+            const finalAttempt = validationAttempts[validationAttempts.length - 1];
+            if (!finalAttempt.success && finalAttempt.errorMessage) {
+                promptRun.FinalValidationError = finalAttempt.errorMessage.substring(0, 500); // Truncate to fit column
+                promptRun.ValidationErrorCount = finalAttempt.validationErrors?.length || 0;
+            }
+            // Find most common validation error
+            if (validationAttempts.some(a => !a.success)) {
+                const errorCounts = new Map();
+                validationAttempts.forEach(attempt => {
+                    if (!attempt.success && attempt.errorMessage) {
+                        const count = errorCounts.get(attempt.errorMessage) || 0;
+                        errorCounts.set(attempt.errorMessage, count + 1);
                     }
-                }
-                // Store detailed attempts in JSON columns
-                promptRun.ValidationAttempts = JSON.stringify(validationAttempts.map(a => ({
-                    attemptNumber: a.attemptNumber,
-                    success: a.success,
-                    errorMessage: a.errorMessage,
-                    validationErrorCount: a.validationErrors?.length || 0,
-                    timestamp: a.timestamp.toISOString(),
-                    outputLength: a.rawOutput?.length || 0
-                })));
+                });
+                if (errorCounts.size > 0) {
+                    const [commonError] = [...errorCounts.entries()].sort((a, b) => b[1] - a[1])[0];
+                    promptRun.CommonValidationError = commonError.substring(0, 255); // Truncate to fit column
+                }
+            }
+            // Store detailed attempts in JSON columns
+            promptRun.ValidationAttempts = JSON.stringify(validationAttempts.map(a => ({
+                attemptNumber: a.attemptNumber,
+                success: a.success,
+                errorMessage: a.errorMessage,
+                validationErrorCount: a.validationErrors?.length || 0,
+                timestamp: a.timestamp.toISOString(),
+                outputLength: a.rawOutput?.length || 0
+            })));
+            promptRun.ValidationSummary = JSON.stringify({
+                totalAttempts: validationAttempts.length,
+                successfulAttempts: validationAttempts.filter(a => a.success).length,
+                finalSuccess: parsedResult.validationResult?.Success || false,
+                validationBehavior: promptRun.ValidationBehavior,
+                retryStrategy: promptRun.RetryStrategy,
+                maxRetriesConfigured: promptRun.MaxRetriesConfigured,
+                actualRetriesUsed: validationAttempts.length - 1,
+                totalDurationMS: executionTimeMS,
+                retryDurationMS: promptRun.TotalRetryDurationMS || 0,
+                outputType: prompt.OutputType || 'unknown',
+                hasOutputExample: !!(prompt.OutputExample),
+                schemaValidationUsed: !!(prompt.OutputExample && prompt.OutputType === 'object'),
+                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, promptRun.ValidationBehavior || 'Warn'),
+                jsonRepairInfo: promptRun._jsonRepairInfo || null
+            });
+        }
+        else {
+            // No validation attempts (possibly skipped validation)
+            promptRun.ValidationAttemptCount = 1; // At least one attempt was made
+            promptRun.SuccessfulValidationCount = parsedResult.validationResult?.Success !== false ? 1 : 0;
+            promptRun.FinalValidationPassed = parsedResult.validationResult?.Success !== false;
+            promptRun.LastAttemptAt = endTime;
+            promptRun.TotalRetryDurationMS = 0;
+            // Even without validation, persist JSON repair info if a repair occurred
+            if (promptRun._jsonRepairInfo) {
                 promptRun.ValidationSummary = JSON.stringify({
-                    totalAttempts: validationAttempts.length,
-                    successfulAttempts: validationAttempts.filter(a => a.success).length,
-                    finalSuccess: parsedResult.validationResult?.Success || false,
-                    validationBehavior: promptRun.ValidationBehavior,
-                    retryStrategy: promptRun.RetryStrategy,
-                    maxRetriesConfigured: promptRun.MaxRetriesConfigured,
-                    actualRetriesUsed: validationAttempts.length - 1,
-                    totalDurationMS: executionTimeMS,
-                    retryDurationMS: promptRun.TotalRetryDurationMS || 0,
-                    outputType: prompt.OutputType || 'unknown',
-                    hasOutputExample: !!(prompt.OutputExample),
-                    schemaValidationUsed: !!(prompt.OutputExample && prompt.OutputType === 'object'),
-                    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, promptRun.ValidationBehavior || 'Warn'),
-                    jsonRepairInfo: promptRun._jsonRepairInfo || null
+                    jsonRepairInfo: promptRun._jsonRepairInfo
                 });
             }
-            else {
-                // No validation attempts (possibly skipped validation)
-                promptRun.ValidationAttemptCount = 1; // At least one attempt was made
-                promptRun.SuccessfulValidationCount = parsedResult.validationResult?.Success !== false ? 1 : 0;
-                promptRun.FinalValidationPassed = parsedResult.validationResult?.Success !== false;
-                promptRun.LastAttemptAt = endTime;
-                promptRun.TotalRetryDurationMS = 0;
-                // Even without validation, persist JSON repair info if a repair occurred
-                if (promptRun._jsonRepairInfo) {
-                    promptRun.ValidationSummary = JSON.stringify({
-                        jsonRepairInfo: promptRun._jsonRepairInfo
-                    });
-                }
-            }
-            // Set Success flag based on validation result
-            promptRun.Success = modelResult.success && (parsedResult.validationResult?.Success !== false);
-            // Set final Status based on success
-            promptRun.Status = promptRun.Success ? 'Completed' : 'Failed';
-            // Set ErrorDetails if failed
-            if (!promptRun.Success) {
-                if (!modelResult.success && modelResult.errorMessage) {
-                    promptRun.ErrorDetails = modelResult.errorMessage;
-                }
-                else if (parsedResult.validationResult?.Success === false) {
-                    promptRun.ErrorDetails = `Validation failed: ${parsedResult.validationResult.Errors?.map(e => e.Message).join(', ')}`;
-                }
+        }
+        // Success and Status were set by FinalizeRunRecord from the outcome updatePromptRun passed it.
+        // Set ErrorDetails if failed
+        if (!promptRun.Success) {
+            if (!modelResult.success && modelResult.errorMessage) {
+                promptRun.ErrorDetails = modelResult.errorMessage;
             }
-            // Note: Failover tracking fields are now updated directly in executeModelWithFailover
-            // The promptRun entity already has the failover information set
-            // With template composition, we only execute once so rollup equals regular fields
-            promptRun.TokensPromptRollup = promptRun.TokensPrompt;
-            promptRun.TokensCompletionRollup = promptRun.TokensCompletion;
-            promptRun.TokensUsedRollup = promptRun.TokensUsed;
-            promptRun.TokensCacheReadRollup = promptRun.TokensCacheRead;
-            promptRun.TokensCacheWriteRollup = promptRun.TokensCacheWrite;
-            if (promptRun.Cost !== undefined) {
-                promptRun.TotalCost = promptRun.Cost;
+            else if (parsedResult.validationResult?.Success === false) {
+                promptRun.ErrorDetails = `Validation failed: ${parsedResult.validationResult.Errors?.map(e => e.Message).join(', ')}`;
             }
         }
-        catch (error) {
-            this.logError(error, {
-                category: 'PromptRunUpdate',
-                metadata: {
-                    promptRunId: promptRun.ID
-                }
-            });
-        }
-    }
-    // ==================== CONTEXT LENGTH METHODS ====================
-    /**
-     * Estimates the number of tokens in a rendered prompt and conversation messages.
-     * This is a rough estimation based on character count and typical token ratios.
-     *
-     * @param renderedPrompt - The rendered prompt text
-     * @param conversationMessages - Optional conversation messages
-     * @returns Estimated token count
-     */
-    // ==================== FAILOVER METHODS ====================
-    /**
-     * Retrieves failover configuration from the prompt entity.
-     *
-     * @param prompt - The AI prompt entity containing failover settings
-     * @returns FailoverConfiguration object with strategy and settings
-     *
-     * @remarks
-     * This method extracts failover configuration from the prompt entity and provides
-     * default values when configuration is not specified. Override this method to
-     * implement custom failover configuration logic.
-     */
-    getFailoverConfiguration(prompt) {
-        return {
-            strategy: prompt.FailoverStrategy || 'None',
-            maxAttempts: prompt.FailoverMaxAttempts || 3,
-            delaySeconds: prompt.FailoverDelaySeconds || 1,
-            modelStrategy: prompt.FailoverModelStrategy || 'PreferSameModel',
-            errorScope: prompt.FailoverErrorScope || 'All'
-        };
-    }
-    /**
-     * Determines whether a failover attempt should be made based on the error and configuration.
-     *
-     * @param error - The error that occurred during execution
-     * @param config - The failover configuration
-     * @param attemptNumber - The current attempt number (1-based)
-     * @returns True if failover should be attempted, false otherwise
-     *
-     * @remarks
-     * This method uses the ErrorAnalyzer to classify errors and determine if they are
-     * eligible for failover based on the configured error scope. Override this method
-     * to implement custom failover decision logic.
-     */
-    shouldAttemptFailover(error, config, attemptNumber) {
-        // Don't failover if strategy is None or we've exceeded max attempts
-        if (config.strategy === 'None' || attemptNumber > config.maxAttempts) {
-            return false;
-        }
-        // Analyze the error to determine if it's eligible for failover
-        const errorAnalysis = ErrorAnalyzer.analyzeError(error);
-        // Check if error analysis allows failover
-        if (!errorAnalysis.canFailover) {
-            return false;
-        }
-        // Check error scope configuration
-        switch (config.errorScope) {
-            case 'NetworkOnly':
-                return errorAnalysis.errorType === 'NetworkError';
-            case 'RateLimitOnly':
-                return errorAnalysis.errorType === 'RateLimit';
-            case 'ServiceErrorOnly':
-                return errorAnalysis.errorType === 'ServiceUnavailable' ||
-                    errorAnalysis.errorType === 'InternalServerError';
-            case 'All':
-            default:
-                return true;
-        }
-    }
-    /**
-     * Checks if an error type matches the configured error scope
-     *
-     * @param errorType - The error type from ErrorAnalyzer
-     * @param scope - The configured error scope
-     * @returns True if the error matches the scope
-     */
-    errorMatchesScope(errorType, scope) {
-        switch (scope) {
-            case 'NetworkOnly':
-                return errorType === 'NetworkError';
-            case 'RateLimitOnly':
-                return errorType === 'RateLimit';
-            case 'ServiceErrorOnly':
-                return errorType === 'ServiceUnavailable' || errorType === 'InternalServerError';
-            case 'All':
-            default:
-                return true;
-        }
     }
     /**
-     * Calculates the delay before the next failover attempt.
-     *
-     * @param attemptNumber - The current attempt number (1-based)
-     * @param baseDelaySeconds - The base delay in seconds from configuration
-     * @param previousError - The error from the previous attempt
-     * @returns Delay in milliseconds before the next attempt
-     *
-     * @remarks
-     * Implements exponential backoff with jitter by default. The delay increases
-     * exponentially with each attempt and includes random jitter to prevent
-     * thundering herd problems. Override this method to implement custom delay logic.
-     */
-    calculateFailoverDelay(attemptNumber, baseDelaySeconds) {
-        // Exponential backoff: delay = base * 2^(attempt-1)
-        const exponentialDelay = baseDelaySeconds * Math.pow(2, attemptNumber - 1);
-        // Add jitter (0-25% of delay) to prevent thundering herd
-        const jitter = exponentialDelay * 0.25 * Math.random();
-        // Cap at 30 seconds to prevent excessive delays
-        const totalDelay = Math.min(exponentialDelay + jitter, 30);
-        return totalDelay * 1000; // Convert to milliseconds
-    }
-    /**
-     * Selects candidate models for failover based on the strategy and current failure.
-     *
-     * @param currentModel - The model that just failed
-     * @param currentVendorId - The vendor ID that just failed
-     * @param strategy - The failover strategy to use
-     * @param modelStrategy - The model selection preference
-     * @param allCandidates - All available model-vendor candidates
-     * @param attemptHistory - History of previous failover attempts
-     * @returns Array of candidates sorted by priority (highest first)
-     *
-     * @remarks
-     * This method implements different strategies for selecting failover candidates:
-     * - SameModelDifferentVendor: Try the same model with different vendors
-     * - NextBestModel: Try different models in order of preference
-     * - PowerRank: Use the global power ranking of models
-     *
-     * Override this method to implement custom candidate selection logic.
+     * Provides a human-readable description of the validation decision
      */
-    selectFailoverCandidates(currentModel, currentVendorId, strategy, modelStrategy, allCandidates, attemptHistory) {
-        // Filter out candidates that have already failed
-        // Note: Authentication errors are already filtered from allCandidates upstream,
-        // so we only need to filter out specific model/vendor pairs that have failed
-        const failedPairs = new Set(attemptHistory.map(a => `${a.modelId}:${a.vendorId || 'default'}`));
-        const availableCandidates = allCandidates.filter(c => {
-            const key = `${c.model.ID}:${c.vendorId || 'default'}`;
-            return !failedPairs.has(key);
-        });
-        // Check if we have context length exceeded errors in the attempt history
-        const hasContextLengthError = attemptHistory.some(a => a.errorType === 'ContextLengthExceeded' ||
-            ErrorAnalyzer.analyzeError(a.error).errorType === 'ContextLengthExceeded');
-        // Apply strategy-specific filtering and sorting
-        let candidates;
-        switch (strategy) {
-            case 'SameModelDifferentVendor':
-                // Only consider same model with different vendors
-                candidates = availableCandidates.filter(c => UUIDsEqual(c.model.ID, currentModel.ID) && !UUIDsEqual(c.vendorId, currentVendorId));
-                break;
-            case 'NextBestModel':
-                // Consider all models, apply model strategy preference
-                candidates = availableCandidates;
-                if (modelStrategy === 'RequireSameModel') {
-                    candidates = candidates.filter(c => UUIDsEqual(c.model.ID, currentModel.ID));
-                }
-                else if (modelStrategy === 'PreferSameModel') {
-                    // Sort to put same model first
-                    candidates.sort((a, b) => {
-                        const aSameModel = UUIDsEqual(a.model.ID, currentModel.ID) ? 1 : 0;
-                        const bSameModel = UUIDsEqual(b.model.ID, currentModel.ID) ? 1 : 0;
-                        return bSameModel - aSameModel;
-                    });
-                }
-                else if (modelStrategy === 'PreferDifferentModel') {
-                    // Sort to put different models first
-                    candidates.sort((a, b) => {
-                        const aDiffModel = !UUIDsEqual(a.model.ID, currentModel.ID) ? 1 : 0;
-                        const bDiffModel = !UUIDsEqual(b.model.ID, currentModel.ID) ? 1 : 0;
-                        return bDiffModel - aDiffModel;
-                    });
-                }
-                break;
-            case 'PowerRank':
-                // Use all candidates, they're already sorted by power rank
-                candidates = availableCandidates;
-                break;
-            default:
-                candidates = [];
-        }
-        // If we have context length errors, prioritize models with larger context windows
-        if (hasContextLengthError) {
-            const currentMaxTokens = currentModel.ModelVendors?.length > 0 ?
-                Math.max(...currentModel.ModelVendors.map(mv => mv.MaxInputTokens || 0)) : 0;
-            // Filter out models with same or smaller context windows
-            candidates = candidates.filter(c => {
-                const candidateMaxTokens = c.model.ModelVendors?.length > 0 ?
-                    Math.max(...c.model.ModelVendors.map(mv => mv.MaxInputTokens || 0)) : 0;
-                return candidateMaxTokens > currentMaxTokens;
-            });
-            // If no larger models exist, this is a fatal error - return empty to stop retrying
-            if (candidates.length === 0) {
-                LogStatusEx({
-                    message: `❌ Context length exceeded and no models with larger context windows available. Current model: ${currentModel.Name} (${currentMaxTokens} max tokens). This is a fatal error.`,
-                    category: 'AI',
-                    additionalArgs: [{
-                            currentModel: currentModel.Name,
-                            currentMaxTokens,
-                            availableModels: allCandidates.map(c => c.model.Name).join(', '),
-                            reason: 'No models with larger context windows available for failover'
-                        }]
-                });
-                // Return empty array - caller will see no candidates and stop retrying
-                return [];
-            }
-            // Sort by priority first (existing algorithm), then by context window size as tiebreaker
-            candidates.sort((a, b) => {
-                // Primary sort: priority (higher is better) - maintains existing algorithm
-                if (a.priority !== b.priority) {
-                    return b.priority - a.priority;
-                }
-                // Secondary sort: context window size (largest first) - only as tiebreaker
-                const aMaxTokens = a.model.ModelVendors?.length > 0 ?
-                    Math.max(...a.model.ModelVendors.map((mv) => mv.MaxInputTokens || 0)) : 0;
-                const bMaxTokens = b.model.ModelVendors?.length > 0 ?
-                    Math.max(...b.model.ModelVendors.map((mv) => mv.MaxInputTokens || 0)) : 0;
-                return bMaxTokens - aMaxTokens;
-            });
-            // Log context-aware failover selection
-            const bestCandidate = candidates[0];
-            const bestCandidateMaxTokens = bestCandidate.model.ModelVendors?.length > 0 ?
-                Math.max(...bestCandidate.model.ModelVendors.map((mv) => mv.MaxInputTokens || 0)) : 0;
-            LogStatusEx({
-                message: `🔄 Context-aware failover: Selected model ${bestCandidate.model.Name} with ${bestCandidateMaxTokens} max input tokens (vs ${currentMaxTokens} for failed model)`,
-                category: 'AI',
-                additionalArgs: [{
-                        currentModel: currentModel.Name,
-                        currentMaxTokens,
-                        selectedModel: bestCandidate.model.Name,
-                        selectedMaxTokens: bestCandidateMaxTokens,
-                        candidateCount: candidates.length
-                    }]
-            });
+    getValidationDecisionDescription(finalSuccess, totalAttempts, validationBehavior) {
+        if (finalSuccess) {
+            return totalAttempts === 1
+                ? 'Validation passed on first attempt'
+                : `Validation passed after ${totalAttempts} attempts`;
         }
         else {
-            // Final sort by priority (higher is better) for non-context-length errors
-            candidates.sort((a, b) => b.priority - a.priority);
+            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}`;
+            }
         }
-        return candidates;
     }
     /**
-     * Logs a failover attempt for tracking and debugging.
-     *
-     * @param promptId - The ID of the prompt being executed
-     * @param attempt - The failover attempt details
-     * @param willRetry - Whether another attempt will be made
-     *
-     * @remarks
-     * This method logs detailed information about each failover attempt to help with
-     * debugging and monitoring. Override this method to implement custom logging or
-     * integrate with external monitoring systems.
+     * Resolves the scalar inference parameters for a run: each value is the per-request override
+     * from `additionalParameters` when supplied, otherwise the prompt's configured default. This
+     * is the single source of truth for parameter precedence so {@link executeModel} (ChatParams)
+     * and {@link createPromptRun} (the persisted record) stay in lockstep. Stop sequences and
+     * assistant prefill are intentionally excluded — their representations differ per target.
      */
-    logFailoverAttempt(promptId, attempt, willRetry) {
-        const message = `Failover attempt ${attempt.attemptNumber} for prompt ${promptId}`;
-        const metadata = {
-            promptId,
-            attemptNumber: attempt.attemptNumber,
-            modelId: attempt.modelId,
-            vendorId: attempt.vendorId,
-            errorType: attempt.errorType,
-            duration: attempt.duration,
-            willRetry,
-            error: attempt.error.message
+    resolveScalarInferenceParams(prompt, additionalParameters) {
+        const pick = (override, promptDefault) => override !== undefined ? override : (promptDefault != null ? promptDefault : undefined);
+        const ap = additionalParameters;
+        return {
+            temperature: pick(ap?.temperature, prompt.Temperature),
+            topP: pick(ap?.topP, prompt.TopP),
+            topK: pick(ap?.topK, prompt.TopK),
+            minP: pick(ap?.minP, prompt.MinP),
+            frequencyPenalty: pick(ap?.frequencyPenalty, prompt.FrequencyPenalty),
+            presencePenalty: pick(ap?.presencePenalty, prompt.PresencePenalty),
+            seed: pick(ap?.seed, prompt.Seed),
+            includeLogProbs: pick(ap?.includeLogProbs, prompt.IncludeLogProbs),
+            topLogProbs: pick(ap?.topLogProbs, prompt.TopLogProbs),
         };
-        if (willRetry) {
-            LogStatusEx({
-                message: `⚡ ${message}`,
-                category: 'AI',
-                additionalArgs: [metadata]
-            });
-        }
-        else {
-            LogErrorEx({
-                message: message,
-                error: attempt.error,
-                category: 'AI',
-                severity: 'error',
-                metadata: metadata
-            });
-        }
     }
 }
 //# sourceMappingURL=AIPromptRunner.js.map