@memberjunction/ai-prompts 2.118.0 → 2.119.0

package/dist/AIPromptRunner.js

@@ -770,222 +770,284 @@ class AIPromptRunner {
         }
     }
     buildModelVendorCandidates(prompt, explicitModelId, configurationId, preferredVendorId, verbose) {
+        if (explicitModelId) {
+            return this.buildCandidatesForExplicitModel(explicitModelId, prompt, preferredVendorId);
+        }
+        if (prompt.SelectionStrategy === 'Specific') {
+            return this.buildCandidatesForSpecificStrategy(prompt, configurationId, verbose);
+        }
+        return this.buildCandidatesForGeneralSelection(prompt, configurationId, preferredVendorId, verbose);
+    }
+    buildCandidatesForExplicitModel(explicitModelId, prompt, preferredVendorId) {
+        const model = aiengine_1.AIEngine.Instance.Models.find(m => m.ID === explicitModelId);
+        if (!model || !model.IsActive) {
+            return [];
+        }
+        if (prompt.AIModelTypeID && model.AIModelTypeID !== prompt.AIModelTypeID) {
+            return [];
+        }
+        const candidates = this.createCandidatesForModel(model, 20000, 'explicit', preferredVendorId);
+        candidates.sort((a, b) => b.priority - a.priority);
+        return candidates;
+    }
+    buildCandidatesForSpecificStrategy(prompt, configurationId, verbose) {
+        const allPromptModels = aiengine_1.AIEngine.Instance.PromptModels.filter(pm => pm.PromptID === prompt.ID && (pm.Status === 'Active' || pm.Status === 'Preview'));
+        const promptModels = this.filterPromptModelsByConfiguration(allPromptModels, configurationId);
+        const sortedPromptModels = this.sortPromptModelsForSpecificStrategy(promptModels, configurationId);
+        const candidates = this.buildCandidatesFromPromptModels(sortedPromptModels);
+        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) {
+            (0, core_1.LogStatus)(`Using SelectionStrategy='Specific' with ${sortedPromptModels.length} AIPromptModel entries, generated ${candidates.length} candidates`);
+        }
+        return candidates;
+    }
+    buildCandidatesForGeneralSelection(prompt, configurationId, preferredVendorId, verbose) {
         const preferredVendorName = preferredVendorId ?
             aiengine_1.AIEngine.Instance.Vendors.find(v => v.ID === preferredVendorId)?.Name : undefined;
-        const createCandidatesForModel = (model, basePriority, source, promptModelPriority) => {
-            const modelCandidates = [];
-            const modelVendors = aiengine_1.AIEngine.Instance.ModelVendors
-                .filter(mv => mv.ModelID === model.ID && mv.Status === 'Active' && this.isInferenceProvider(mv))
-                .sort((a, b) => b.Priority - a.Priority);
-            if (preferredVendorId) {
-                const preferredVendor = modelVendors.find(mv => 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,
-                        source
-                    });
-                }
-            }
-            for (const vendor of modelVendors) {
-                if (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 (modelCandidates.length === 0 && model.DriverClass) {
-                modelCandidates.push({
-                    model,
-                    driverClass: model.DriverClass,
-                    apiName: model.APIName,
-                    supportsEffortLevel: model.SupportsEffortLevel ?? false,
-                    isPreferredVendor: false,
-                    priority: basePriority,
-                    source
-                });
-            }
-            if (promptModelPriority !== undefined) {
-                modelCandidates.forEach(c => c.priority += promptModelPriority * 10);
-            }
-            return modelCandidates;
-        };
-        const createSpecificCandidatesForModel = (model, promptModel, preferredVendorId) => {
-            const modelCandidates = [];
-            const basePriority = 10000 + (promptModel.Priority || 0) * 100;
-            const modelVendors = aiengine_1.AIEngine.Instance.ModelVendors
-                .filter(mv => mv.ModelID === model.ID && mv.Status === 'Active' && this.isInferenceProvider(mv));
-            const pmPreferredVendorId = promptModel.VendorID || preferredVendorId;
-            if (pmPreferredVendorId) {
-                const preferredVendor = modelVendors.find(mv => mv.VendorID === pmPreferredVendorId);
-                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,
-                        source: 'prompt-model'
-                    });
-                }
+        const promptModels = this.getPromptModelsForConfiguration(prompt, configurationId);
+        const candidates = [];
+        if (promptModels.length > 0) {
+            this.addPromptSpecificCandidates(candidates, promptModels, preferredVendorId);
+            if (configurationId) {
+                this.addConfigurationFallbackCandidates(candidates, prompt, configurationId, preferredVendorId, verbose);
             }
-            for (const vendor of modelVendors) {
-                if (vendor.VendorID !== pmPreferredVendorId) {
-                    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) * 10,
-                        source: 'prompt-model'
-                    });
+        }
+        else {
+            this.addStrategyBasedCandidates(candidates, prompt, preferredVendorName);
+        }
+        candidates.sort((a, b) => b.priority - a.priority);
+        return candidates;
+    }
+    filterPromptModelsByConfiguration(allPromptModels, configurationId) {
+        if (configurationId) {
+            return allPromptModels.filter(pm => pm.ConfigurationID === configurationId || pm.ConfigurationID === null);
+        }
+        else {
+            return allPromptModels.filter(pm => pm.ConfigurationID === null);
+        }
+    }
+    sortPromptModelsForSpecificStrategy(promptModels, configurationId) {
+        return promptModels.sort((a, b) => {
+            const aIsConfigMatch = configurationId && a.ConfigurationID === configurationId ? 1 : 0;
+            const bIsConfigMatch = configurationId && b.ConfigurationID === configurationId ? 1 : 0;
+            if (aIsConfigMatch !== bIsConfigMatch) {
+                return bIsConfigMatch - aIsConfigMatch;
+            }
+            return (b.Priority || 0) - (a.Priority || 0);
+        });
+    }
+    buildCandidatesFromPromptModels(promptModels) {
+        const candidates = [];
+        for (const pm of promptModels) {
+            const model = aiengine_1.AIEngine.Instance.Models.find(m => m.ID === pm.ModelID);
+            if (!model || !model.IsActive)
+                continue;
+            if (pm.VendorID) {
+                const candidate = this.createCandidateForSpecificVendor(model, pm);
+                if (candidate) {
+                    candidates.push(candidate);
                 }
             }
-            if (modelCandidates.length === 0 && model.DriverClass) {
-                modelCandidates.push({
-                    model,
-                    driverClass: model.DriverClass,
-                    apiName: model.APIName,
-                    supportsEffortLevel: model.SupportsEffortLevel ?? false,
-                    isPreferredVendor: false,
-                    priority: basePriority,
-                    source: 'prompt-model'
-                });
+            else {
+                const vendorCandidates = this.createCandidatesForAllVendors(model);
+                candidates.push(...vendorCandidates);
             }
-            return modelCandidates;
+        }
+        return candidates;
+    }
+    createCandidateForSpecificVendor(model, promptModel) {
+        const modelVendor = aiengine_1.AIEngine.Instance.ModelVendors.find(mv => mv.ModelID === promptModel.ModelID &&
+            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,
+            isPreferredVendor: false,
+            priority: 0,
+            source: 'prompt-model'
         };
-        if (explicitModelId) {
-            const model = aiengine_1.AIEngine.Instance.Models.find(m => m.ID === explicitModelId);
-            if (model && model.IsActive) {
-                if (!prompt.AIModelTypeID || model.AIModelTypeID === prompt.AIModelTypeID) {
-                    const candidates = createCandidatesForModel(model, 20000, 'explicit');
-                    candidates.sort((a, b) => b.priority - a.priority);
-                    return candidates;
-                }
-            }
-            return [];
+    }
+    createCandidatesForAllVendors(model) {
+        const vendors = aiengine_1.AIEngine.Instance.ModelVendors
+            .filter(mv => mv.ModelID === model.ID &&
+            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: 0,
+                source: 'prompt-model'
+            });
+        }
+        if (candidates.length === 0 && model.DriverClass) {
+            candidates.push({
+                model,
+                driverClass: model.DriverClass,
+                apiName: model.APIName,
+                supportsEffortLevel: model.SupportsEffortLevel ?? false,
+                isPreferredVendor: false,
+                priority: 0,
+                source: 'prompt-model'
+            });
         }
-        let promptModels = [];
+        return candidates;
+    }
+    getPromptModelsForConfiguration(prompt, configurationId) {
         if (configurationId) {
-            promptModels = aiengine_1.AIEngine.Instance.PromptModels.filter(pm => pm.PromptID === prompt.ID &&
+            const promptModels = aiengine_1.AIEngine.Instance.PromptModels.filter(pm => pm.PromptID === prompt.ID &&
                 (pm.Status === 'Active' || pm.Status === 'Preview') &&
                 pm.ConfigurationID === configurationId);
             if (promptModels.length === 0) {
                 (0, core_1.LogStatus)(`No models found for configuration "${configurationId}", falling back to default models`);
-                promptModels = aiengine_1.AIEngine.Instance.PromptModels.filter(pm => pm.PromptID === prompt.ID &&
+                return aiengine_1.AIEngine.Instance.PromptModels.filter(pm => pm.PromptID === prompt.ID &&
                     (pm.Status === 'Active' || pm.Status === 'Preview') &&
                     !pm.ConfigurationID);
             }
+            return promptModels;
         }
         else {
-            promptModels = aiengine_1.AIEngine.Instance.PromptModels.filter(pm => pm.PromptID === prompt.ID &&
+            return aiengine_1.AIEngine.Instance.PromptModels.filter(pm => pm.PromptID === prompt.ID &&
                 (pm.Status === 'Active' || pm.Status === 'Preview') &&
                 !pm.ConfigurationID);
         }
-        if (prompt.SelectionStrategy === 'Specific' && promptModels.length > 0) {
-            const candidates = [];
-            promptModels.sort((a, b) => (b.Priority || 0) - (a.Priority || 0));
-            for (const pm of promptModels) {
-                const model = aiengine_1.AIEngine.Instance.Models.find(m => m.ID === pm.ModelID);
-                if (model && model.IsActive) {
-                    const modelCandidates = createSpecificCandidatesForModel(model, pm, preferredVendorId);
-                    candidates.push(...modelCandidates);
-                }
-            }
-            if (candidates.length > 0) {
-                candidates.sort((a, b) => b.priority - a.priority);
-                if (verbose) {
-                    (0, core_1.LogStatus)(`Using SelectionStrategy='Specific' with ${promptModels.length} AIPromptModel entries, generated ${candidates.length} candidates`);
-                }
-                return candidates;
-            }
-            if (verbose) {
-                (0, core_1.LogStatus)(`SelectionStrategy='Specific' specified but no usable candidates from AIPromptModel entries, falling back to general selection`);
+    }
+    addPromptSpecificCandidates(candidates, promptModels, preferredVendorId) {
+        for (const pm of promptModels) {
+            const model = aiengine_1.AIEngine.Instance.Models.find(m => m.ID === pm.ModelID);
+            if (model && model.IsActive) {
+                const modelCandidates = this.createCandidatesForModel(model, 5000, 'prompt-model', preferredVendorId, pm.Priority);
+                candidates.push(...modelCandidates);
             }
         }
-        const candidates = [];
-        if (promptModels.length > 0 && prompt.SelectionStrategy !== 'Specific') {
-            for (const pm of promptModels) {
-                const model = aiengine_1.AIEngine.Instance.Models.find(m => m.ID === pm.ModelID);
-                if (model && model.IsActive) {
-                    const modelCandidates = createCandidatesForModel(model, 5000, 'prompt-model', pm.Priority);
-                    candidates.push(...modelCandidates);
-                }
-            }
-            if (configurationId) {
-                const nullConfigModels = aiengine_1.AIEngine.Instance.PromptModels.filter(pm => pm.PromptID === prompt.ID &&
-                    (pm.Status === 'Active' || pm.Status === 'Preview') &&
-                    !pm.ConfigurationID);
-                if (nullConfigModels.length > 0 && verbose) {
-                    (0, core_1.LogStatus)(`Adding ${nullConfigModels.length} NULL configuration models as fallback candidates`);
-                }
-                for (const pm of nullConfigModels) {
-                    const model = aiengine_1.AIEngine.Instance.Models.find(m => m.ID === pm.ModelID);
-                    if (model && model.IsActive) {
-                        const modelCandidates = createCandidatesForModel(model, 2000, 'prompt-model', pm.Priority);
-                        candidates.push(...modelCandidates);
-                    }
-                }
+    }
+    addConfigurationFallbackCandidates(candidates, prompt, configurationId, preferredVendorId, verbose) {
+        const nullConfigModels = aiengine_1.AIEngine.Instance.PromptModels.filter(pm => pm.PromptID === prompt.ID &&
+            (pm.Status === 'Active' || pm.Status === 'Preview') &&
+            !pm.ConfigurationID);
+        if (nullConfigModels.length > 0 && verbose) {
+            (0, core_1.LogStatus)(`Adding ${nullConfigModels.length} NULL configuration models as fallback candidates`);
+        }
+        for (const pm of nullConfigModels) {
+            const model = aiengine_1.AIEngine.Instance.Models.find(m => m.ID === pm.ModelID);
+            if (model && model.IsActive) {
+                const modelCandidates = this.createCandidatesForModel(model, 2000, 'prompt-model', preferredVendorId, pm.Priority);
+                candidates.push(...modelCandidates);
             }
         }
+    }
+    addStrategyBasedCandidates(candidates, prompt, preferredVendorName) {
+        let modelPool = this.getModelPoolForStrategy(prompt, preferredVendorName);
+        modelPool = this.sortModelPoolByStrategy(modelPool, prompt);
+        modelPool.forEach((model, index) => {
+            const basePriority = 1000 - index * 10;
+            const source = prompt.SelectionStrategy === 'ByPower' ? 'power-rank' : 'model-type';
+            candidates.push(...this.createCandidatesForModel(model, basePriority, source));
+        });
+    }
+    getModelPoolForStrategy(prompt, preferredVendorName) {
+        return aiengine_1.AIEngine.Instance.Models.filter(m => m.IsActive &&
+            (!prompt.AIModelTypeID || m.AIModelTypeID === prompt.AIModelTypeID) &&
+            (!preferredVendorName ||
+                aiengine_1.AIEngine.Instance.ModelVendors.some(mv => mv.ModelID === m.ID &&
+                    mv.Status === 'Active' &&
+                    mv.Vendor === preferredVendorName &&
+                    this.isInferenceProvider(mv))));
+    }
+    sortModelPoolByStrategy(modelPool, prompt) {
+        if (prompt.SelectionStrategy === 'ByPower') {
+            return this.sortByPowerPreference(modelPool, prompt.PowerPreference);
+        }
         else {
-            let modelPool = aiengine_1.AIEngine.Instance.Models.filter(m => m.IsActive &&
-                (!prompt.AIModelTypeID || m.AIModelTypeID === prompt.AIModelTypeID) &&
-                (!preferredVendorName ||
-                    aiengine_1.AIEngine.Instance.ModelVendors.some(mv => mv.ModelID === m.ID &&
-                        mv.Status === 'Active' &&
-                        mv.Vendor === preferredVendorName &&
-                        this.isInferenceProvider(mv))));
-            switch (prompt.SelectionStrategy) {
-                case 'ByPower':
-                    switch (prompt.PowerPreference) {
-                        case 'Highest':
-                            modelPool.sort((a, b) => b.PowerRank - a.PowerRank);
-                            break;
-                        case 'Lowest':
-                            modelPool.sort((a, b) => a.PowerRank - b.PowerRank);
-                            break;
-                        case 'Balanced':
-                            const avgPower = modelPool.reduce((sum, m) => sum + m.PowerRank, 0) / modelPool.length;
-                            modelPool.sort((a, b) => Math.abs(a.PowerRank - avgPower) - Math.abs(b.PowerRank - avgPower));
-                            break;
-                    }
-                    break;
-                case 'Specific':
-                case 'Default':
-                default:
-                    const minPowerRank = prompt.MinPowerRank || 0;
-                    modelPool = modelPool.filter(m => m.PowerRank >= minPowerRank);
-                    modelPool.sort((a, b) => b.PowerRank - a.PowerRank);
-                    break;
+            const minPowerRank = prompt.MinPowerRank || 0;
+            return modelPool
+                .filter(m => m.PowerRank >= minPowerRank)
+                .sort((a, b) => b.PowerRank - a.PowerRank);
+        }
+    }
+    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);
+        }
+    }
+    createCandidatesForModel(model, basePriority, source, preferredVendorId, promptModelPriority) {
+        const modelCandidates = [];
+        const modelVendors = aiengine_1.AIEngine.Instance.ModelVendors
+            .filter(mv => mv.ModelID === model.ID && mv.Status === 'Active' && this.isInferenceProvider(mv))
+            .sort((a, b) => b.Priority - a.Priority);
+        if (preferredVendorId) {
+            const preferredVendor = modelVendors.find(mv => 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,
+                    source
+                });
             }
-            modelPool.forEach((model, index) => {
-                const basePriority = 1000 - index * 10;
-                candidates.push(...createCandidatesForModel(model, basePriority, prompt.SelectionStrategy === 'ByPower' ? 'power-rank' : 'model-type'));
+        }
+        for (const vendor of modelVendors) {
+            if (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 (modelCandidates.length === 0 && model.DriverClass) {
+            modelCandidates.push({
+                model,
+                driverClass: model.DriverClass,
+                apiName: model.APIName,
+                supportsEffortLevel: model.SupportsEffortLevel ?? false,
+                isPreferredVendor: false,
+                priority: basePriority,
+                source
             });
         }
-        candidates.sort((a, b) => b.priority - a.priority);
-        return candidates;
+        if (promptModelPriority !== undefined) {
+            modelCandidates.forEach(c => c.priority += promptModelPriority * 10);
+        }
+        return modelCandidates;
     }
     createSelectionInfo(data) {
         const info = new ai_core_plus_1.AIModelSelectionInfo();
@@ -1282,39 +1344,33 @@ class AIPromptRunner {
     }
     async executeModelWithFailover(model, renderedPrompt, prompt, params, vendorId, conversationMessages, templateMessageRole = 'system', cancellationToken, allCandidates, promptRun, vendorDriverClass, vendorApiName, vendorSupportsEffortLevel) {
         const failoverConfig = this.getFailoverConfiguration(prompt);
-        if (failoverConfig.strategy === 'None') {
+        if (!allCandidates || allCandidates.length === 0 || failoverConfig.strategy === 'None') {
             return this.executeModel(model, renderedPrompt, prompt, params, vendorId, conversationMessages, templateMessageRole, cancellationToken, vendorDriverClass, vendorApiName, vendorSupportsEffortLevel);
         }
         const failoverAttempts = [];
         let lastError = null;
-        let currentModel = model;
-        let currentVendorId = vendorId;
-        let attemptNumber = 0;
-        if (!allCandidates || allCandidates.length === 0) {
-            allCandidates = await this.buildFailoverCandidates(prompt);
-        }
-        while (attemptNumber <= failoverConfig.maxAttempts) {
-            attemptNumber++;
+        for (let i = 0; i < allCandidates.length; i++) {
+            const candidate = allCandidates[i];
             const attemptStartTime = Date.now();
             try {
-                if (attemptNumber > 1) {
-                    const vendorName = currentVendorId
-                        ? aiengine_1.AIEngine.Instance.Vendors.find(v => v.ID === currentVendorId)?.Name || 'Unknown'
-                        : 'default';
+                if (i > 0) {
+                    const vendorName = candidate.vendorName || 'default';
                     (0, core_1.LogStatusEx)({
-                        message: `🔄 Failover attempt ${attemptNumber} with model ${currentModel.Name} (vendor: ${currentVendorId || 'default'})`,
+                        message: `🔄 Trying candidate ${i + 1}/${allCandidates.length}: ${candidate.model.Name} via ${vendorName}`,
                         category: 'AI',
                         additionalArgs: [{
                                 promptId: prompt.ID,
-                                modelId: currentModel.ID,
-                                vendorId: currentVendorId,
-                                attemptNumber
+                                modelId: candidate.model.ID,
+                                model: candidate.model.Name,
+                                vendorId: candidate.vendorId,
+                                vendor: candidate.vendorName,
+                                attemptNumber: i + 1
                             }]
                     });
                 }
-                const result = await this.executeModel(currentModel, renderedPrompt, prompt, params, currentVendorId, conversationMessages, templateMessageRole, cancellationToken, vendorDriverClass, vendorApiName, vendorSupportsEffortLevel);
+                const result = await this.executeModel(candidate.model, renderedPrompt, prompt, params, candidate.vendorId || null, conversationMessages, templateMessageRole, cancellationToken, candidate.driverClass, candidate.apiName, candidate.supportsEffortLevel);
                 if (failoverAttempts.length > 0 && promptRun) {
-                    this.updatePromptRunWithFailoverSuccess(promptRun, failoverAttempts, currentModel, currentVendorId);
+                    this.updatePromptRunWithFailoverSuccess(promptRun, failoverAttempts, candidate.model, candidate.vendorId || null);
                 }
                 return result;
             }
@@ -1323,34 +1379,39 @@ class AIPromptRunner {
                 lastError = error;
                 const errorAnalysis = ai_1.ErrorAnalyzer.analyzeError(lastError);
                 const failoverAttempt = {
-                    attemptNumber,
-                    modelId: currentModel.ID,
-                    vendorId: currentVendorId,
+                    attemptNumber: i + 1,
+                    modelId: candidate.model.ID,
+                    vendorId: candidate.vendorId,
                     error: lastError,
                     errorType: errorAnalysis.errorType,
                     duration: attemptDuration,
                     timestamp: new Date()
                 };
                 failoverAttempts.push(failoverAttempt);
-                allCandidates = this.filterAuthenticationFailedVendor(errorAnalysis.errorType, currentVendorId, allCandidates);
-                const shouldContinueRateLimit = await this.handleRateLimitRetry(errorAnalysis, currentModel, currentVendorId, failoverAttempts, prompt, attemptNumber, failoverConfig.maxAttempts, failoverAttempt);
-                if (shouldContinueRateLimit) {
-                    continue;
+                if (errorAnalysis.errorType === 'Authentication') {
+                    allCandidates = this.filterAuthenticationFailedVendor(errorAnalysis.errorType, candidate.vendorId, allCandidates);
                 }
-                const shouldFailover = this.shouldAttemptFailover(lastError, failoverConfig, attemptNumber);
-                if (!shouldFailover) {
+                const isLastCandidate = i === allCandidates.length - 1;
+                if (errorAnalysis.severity === 'Fatal') {
                     this.logFailoverAttempt(prompt.ID, failoverAttempt, false);
                     break;
                 }
-                const transitionResult = await this.transitionToNextCandidate(currentModel, currentVendorId, failoverConfig, allCandidates, failoverAttempts, prompt.ID, failoverAttempt, attemptNumber);
-                if (!transitionResult) {
+                if (errorAnalysis.errorType === 'InvalidRequest') {
+                    this.logFailoverAttempt(prompt.ID, failoverAttempt, false);
+                    break;
+                }
+                if (failoverConfig.errorScope && failoverConfig.errorScope !== 'All') {
+                    const matchesScope = this.errorMatchesScope(errorAnalysis.errorType, failoverConfig.errorScope);
+                    if (!matchesScope) {
+                        this.logFailoverAttempt(prompt.ID, failoverAttempt, false);
+                        break;
+                    }
+                }
+                if (isLastCandidate) {
+                    this.logFailoverAttempt(prompt.ID, failoverAttempt, false);
                     break;
                 }
-                currentModel = transitionResult.model;
-                currentVendorId = transitionResult.vendorId;
-                vendorDriverClass = transitionResult.driverClass;
-                vendorApiName = transitionResult.apiName;
-                vendorSupportsEffortLevel = transitionResult.supportsEffortLevel;
+                this.logFailoverAttempt(prompt.ID, failoverAttempt, true);
             }
         }
         if (promptRun && failoverAttempts.length > 0) {
@@ -2420,6 +2481,19 @@ class AIPromptRunner {
                 return true;
         }
     }
+    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;
+        }
+    }
     calculateFailoverDelay(attemptNumber, baseDelaySeconds) {
         const exponentialDelay = baseDelaySeconds * Math.pow(2, attemptNumber - 1);
         const jitter = exponentialDelay * 0.25 * Math.random();