@cascadeflow/n8n-nodes-cascadeflow 0.6.7 → 0.7.0

package/dist/nodes/LmChatCascadeFlow/LmChatCascadeFlow.node.js

@@ -1,76 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LmChatCascadeFlow = void 0;
+exports.LmChatCascadeFlow = exports.CascadeChatModel = void 0;
 const n8n_workflow_1 = require("n8n-workflow");
 const chat_models_1 = require("@langchain/core/language_models/chat_models");
 const outputs_1 = require("@langchain/core/outputs");
-// =============================================================================
-// DOMAIN CONSTANTS - All 16 supported domains
-// =============================================================================
-const DOMAINS = {
-    CODE: 'code',
-    DATA: 'data',
-    STRUCTURED: 'structured',
-    RAG: 'rag',
-    CONVERSATION: 'conversation',
-    TOOL: 'tool',
-    CREATIVE: 'creative',
-    SUMMARY: 'summary',
-    TRANSLATION: 'translation',
-    MATH: 'math',
-    SCIENCE: 'science',
-    MEDICAL: 'medical',
-    LEGAL: 'legal',
-    FINANCIAL: 'financial',
-    MULTIMODAL: 'multimodal',
-    GENERAL: 'general',
-};
-// Domain display names for n8n UI
-const DOMAIN_DISPLAY_NAMES = {
-    code: 'Code',
-    data: 'Data Analysis',
-    structured: 'Structured Output',
-    rag: 'RAG (Retrieval)',
-    conversation: 'Conversation',
-    tool: 'Tool Calling',
-    creative: 'Creative Writing',
-    summary: 'Summarization',
-    translation: 'Translation',
-    math: 'Mathematics',
-    science: 'Science',
-    medical: 'Medical',
-    legal: 'Legal',
-    financial: 'Financial',
-    multimodal: 'Multimodal',
-    general: 'General',
-};
-// Domain descriptions for n8n UI
-const DOMAIN_DESCRIPTIONS = {
-    code: 'Programming, debugging, code generation',
-    data: 'Data analysis, statistics, pandas/SQL',
-    structured: 'JSON, XML, structured data extraction',
-    rag: 'Retrieval-augmented generation, document Q&A',
-    conversation: 'Chat, dialogue, multi-turn conversations',
-    tool: 'Function calling, tool use, API interactions',
-    creative: 'Creative writing, stories, poetry',
-    summary: 'Text summarization, condensing content',
-    translation: 'Language translation, multilingual',
-    math: 'Mathematical reasoning, calculations, proofs',
-    science: 'Scientific knowledge, research, experiments',
-    medical: 'Healthcare, medical knowledge, clinical',
-    legal: 'Legal documents, contracts, regulations',
-    financial: 'Finance, accounting, investment analysis',
-    multimodal: 'Images, audio, video understanding',
-    general: 'General purpose, fallback domain',
-};
-// Quality validation, cost tracking, routing, and circuit breaker - optional import
+const config_1 = require("./config");
+const cascade_metadata_1 = require("./cascade-metadata");
+// Quality validation, cost tracking, and routing - optional import
 let QualityValidator;
 let CASCADE_QUALITY_CONFIG;
 let CostCalculator;
 let ComplexityDetector;
 let PreRouter;
-let DomainDetector;
-let CircuitBreaker;
+let DomainRouter;
 try {
     const cascadeCore = require('@cascadeflow/core');
     QualityValidator = cascadeCore.QualityValidator;
@@ -78,8 +20,7 @@ try {
     CostCalculator = cascadeCore.CostCalculator;
     ComplexityDetector = cascadeCore.ComplexityDetector;
     PreRouter = cascadeCore.PreRouter;
-    DomainDetector = cascadeCore.DomainDetector;
-    CircuitBreaker = cascadeCore.CircuitBreaker;
+    DomainRouter = cascadeCore.DomainRouter;
 }
 catch (e) {
     // @cascadeflow/core not available - use simple validation and estimates
@@ -90,10 +31,11 @@ catch (e) {
  * and implements intelligent domain-aware cascading logic with cost tracking
  */
 class CascadeChatModel extends chat_models_1.BaseChatModel {
-    constructor(drafterModel, verifierModelGetter, qualityThreshold = 0.7, useSemanticValidation = true, useAlignmentScoring = true, useComplexityRouting = true, useDomainRouting = false, enabledDomains = [], domainModelGetters = new Map(), domainConfigs = new Map(), useCircuitBreaker = true) {
+    constructor(drafterModelGetter, verifierModelGetter, qualityThreshold = 0.7, useSemanticValidation = true, useAlignmentScoring = true, useComplexityRouting = true, useComplexityThresholds = true, useDomainRouting = false, enabledDomains = [], domainModelGetters = new Map(), domainConfigs = new Map(), confidenceThresholds) {
         super({});
         // Domain-specific models and configurations
         this.domainModels = new Map();
+        this.domainModelGetters = new Map();
         this.domainConfigs = new Map();
         this.enabledDomains = [];
         // Cost tracking
@@ -103,14 +45,17 @@ class CascadeChatModel extends chat_models_1.BaseChatModel {
         this.drafterCount = 0;
         this.verifierCount = 0;
         this.domainCounts = new Map();
-        this.drafterModel = drafterModel;
+        this.drafterModelGetter = drafterModelGetter;
         this.verifierModelGetter = verifierModelGetter;
         this.qualityThreshold = qualityThreshold;
         this.enabledDomains = enabledDomains;
         this.domainConfigs = domainConfigs;
+        this.domainModelGetters = domainModelGetters;
+        this.confidenceThresholds = confidenceThresholds;
+        this.useComplexityThresholds = useComplexityThresholds;
+        this.useComplexityRouting = useComplexityRouting;
         // Store domain model getters for lazy loading
-        for (const [domain, getter] of domainModelGetters.entries()) {
-            // Lazy load domain models
+        for (const [domain] of domainModelGetters.entries()) {
             this.domainModels.set(domain, undefined);
         }
         // Initialize quality validator with CASCADE-optimized config + semantic validation
@@ -119,6 +64,7 @@ class CascadeChatModel extends chat_models_1.BaseChatModel {
                 this.qualityValidator = new QualityValidator({
                     ...CASCADE_QUALITY_CONFIG,
                     minConfidence: qualityThreshold,
+                    confidenceThresholds: useComplexityThresholds ? confidenceThresholds : undefined,
                     useSemanticValidation,
                     useAlignmentScoring,
                     semanticThreshold: 0.5,
@@ -154,10 +100,10 @@ class CascadeChatModel extends chat_models_1.BaseChatModel {
             this.costCalculator = null;
         }
         // Initialize complexity detector and domain detector
-        if (useComplexityRouting && ComplexityDetector) {
+        if ((useComplexityRouting || useComplexityThresholds) && ComplexityDetector) {
             try {
                 this.complexityDetector = new ComplexityDetector();
-                console.log('🧠 CascadeFlow complexity-based routing enabled');
+                console.log('🧠 CascadeFlow complexity detector initialized');
             }
             catch (e) {
                 console.warn('⚠️  Complexity detector initialization failed');
@@ -167,38 +113,20 @@ class CascadeChatModel extends chat_models_1.BaseChatModel {
         else {
             this.complexityDetector = null;
         }
-        // Initialize domain detector if domain routing is enabled
-        if (useDomainRouting && DomainDetector && enabledDomains.length > 0) {
+        // Initialize domain router if domain routing is enabled
+        if (useDomainRouting && DomainRouter && enabledDomains.length > 0) {
             try {
-                this.domainDetector = new DomainDetector({ enabledDomains });
+                this.domainDetector = new DomainRouter();
                 console.log(`🎯 CascadeFlow domain routing enabled for: ${enabledDomains.join(', ')}`);
             }
             catch (e) {
-                console.warn('⚠️  Domain detector initialization failed');
+                console.warn('⚠️  Domain router initialization failed');
                 this.domainDetector = null;
             }
         }
         else {
             this.domainDetector = null;
         }
-        // Initialize circuit breaker for fault tolerance
-        if (useCircuitBreaker && CircuitBreaker) {
-            try {
-                this.circuitBreaker = new CircuitBreaker({
-                    failureThreshold: 3,
-                    recoveryTimeout: 30000, // 30 seconds
-                    halfOpenMaxCalls: 2,
-                });
-                console.log('🛡️  CascadeFlow circuit breaker enabled');
-            }
-            catch (e) {
-                console.warn('⚠️  Circuit breaker initialization failed');
-                this.circuitBreaker = null;
-            }
-        }
-        else {
-            this.circuitBreaker = null;
-        }
     }
     async getVerifierModel() {
         if (!this.verifierModel) {
@@ -210,15 +138,72 @@ class CascadeChatModel extends chat_models_1.BaseChatModel {
         return this.verifierModel;
     }
     /**
-     * Get domain-specific model if available, falls back to drafter
+     * Agent helper: force a direct verifier call (bypasses cascade logic) while still
+     * attaching the same `response_metadata` fields as the standard flows.
+     */
+    async invokeVerifierDirect(messages, options, runManager) {
+        const verifierModel = await this.getVerifierModel();
+        const verifierInfo = this.getModelInfo(verifierModel);
+        await runManager?.handleText(`⚡ Agent route: using verifier directly (${verifierInfo})\n`);
+        const start = Date.now();
+        const verifierMessage = await verifierModel.invoke(messages, options);
+        const latency = Date.now() - start;
+        const verifierCost = await this.calculateMessageCost(verifierMessage, verifierModel);
+        const costBreakdown = {
+            drafter: 0,
+            verifier: verifierCost,
+            total: verifierCost,
+        };
+        if (!verifierMessage.response_metadata) {
+            verifierMessage.response_metadata = {};
+        }
+        verifierMessage.response_metadata.cascadeflow = {
+            flow: 'agent_verifier_direct',
+            model_used: 'verifier',
+            latency_ms: latency,
+            cost_usd: verifierCost,
+        };
+        this.attachCascadeMetadata(verifierMessage, (0, cascade_metadata_1.buildCascadeMetadata)({
+            modelUsed: 'verifier',
+            domain: null,
+            costs: costBreakdown,
+            baselineCost: verifierCost,
+        }));
+        return verifierMessage;
+    }
+    /**
+     * Lazy-load drafter model (so n8n highlights it only when actually used).
+     */
+    async getDrafterModel() {
+        if (!this.drafterModel) {
+            this.drafterModel = await this.drafterModelGetter();
+        }
+        return this.drafterModel;
+    }
+    /**
+     * Get a connected domain-specific model (lazy-loaded).
+     * Returns undefined if no domain model is connected.
      */
     async getDomainModel(domain) {
         const existingModel = this.domainModels.get(domain);
         if (existingModel) {
             return existingModel;
         }
-        // Fallback to drafter if no domain-specific model
-        return this.drafterModel;
+        const getter = this.domainModelGetters.get(domain);
+        if (!getter) {
+            return undefined;
+        }
+        try {
+            const model = await getter();
+            if (model) {
+                this.domainModels.set(domain, model);
+                return model;
+            }
+        }
+        catch {
+            // Treat as "not connected"
+        }
+        return undefined;
     }
     /**
      * Helper to get model info string (type and name)
@@ -228,6 +213,76 @@ class CascadeChatModel extends chat_models_1.BaseChatModel {
         const modelName = model.modelName || model.model || 'unknown';
         return `${type} (${modelName})`;
     }
+    /**
+     * Detect query complexity using whichever detector API is available.
+     */
+    async detectComplexity(queryText) {
+        if (!this.complexityDetector) {
+            return {};
+        }
+        try {
+            if (typeof this.complexityDetector.detectComplexity === 'function') {
+                const result = await this.complexityDetector.detectComplexity(queryText);
+                return {
+                    level: result.level ?? result.complexity,
+                    confidence: result.confidence,
+                };
+            }
+            if (typeof this.complexityDetector.detect === 'function') {
+                const result = await this.complexityDetector.detect(queryText);
+                return {
+                    level: result.complexity ?? result.level,
+                    confidence: result.confidence,
+                };
+            }
+        }
+        catch (e) {
+            console.warn('Complexity detection failed, using normal flow');
+        }
+        return {};
+    }
+    /**
+     * Get effective confidence threshold for a given complexity tier.
+     */
+    getThresholdForComplexity(complexity) {
+        if (!complexity || !this.useComplexityThresholds || !this.confidenceThresholds) {
+            return this.qualityThreshold;
+        }
+        switch (complexity) {
+            case 'trivial':
+                return this.confidenceThresholds.trivial ?? this.qualityThreshold;
+            case 'simple':
+                return this.confidenceThresholds.simple ?? this.qualityThreshold;
+            case 'moderate':
+                return this.confidenceThresholds.moderate ?? this.qualityThreshold;
+            case 'hard':
+                return this.confidenceThresholds.hard ?? this.qualityThreshold;
+            case 'expert':
+                return this.confidenceThresholds.expert ?? this.qualityThreshold;
+            default:
+                return this.qualityThreshold;
+        }
+    }
+    /**
+     * Estimate baseline cost for a different model using the same token usage.
+     */
+    async estimateAlternateModelCost(message, model) {
+        if (!model) {
+            return undefined;
+        }
+        try {
+            return await this.calculateMessageCost(message, model);
+        }
+        catch (e) {
+            return undefined;
+        }
+    }
+    attachCascadeMetadata(message, metadata) {
+        if (!message.response_metadata) {
+            message.response_metadata = {};
+        }
+        message.response_metadata.cf = metadata;
+    }
     /**
      * Detect the domain of a query using semantic detection
      */
@@ -328,7 +383,7 @@ class CascadeChatModel extends chat_models_1.BaseChatModel {
     /**
      * Simple quality validation fallback (when @cascadeflow/core not available)
      */
-    simpleQualityCheck(responseText) {
+    simpleQualityCheck(responseText, threshold) {
         const wordCount = responseText.split(/\s+/).length;
         let confidence = 0.75;
         if (wordCount < 5) {
@@ -345,10 +400,10 @@ class CascadeChatModel extends chat_models_1.BaseChatModel {
         if (hasUncertainty) {
             confidence -= 0.20;
         }
-        const passed = confidence >= this.qualityThreshold;
+        const passed = confidence >= threshold;
         const reason = passed
-            ? `Simple check passed (confidence: ${confidence.toFixed(2)} >= ${this.qualityThreshold})`
-            : `Simple check failed (confidence: ${confidence.toFixed(2)} < ${this.qualityThreshold})`;
+            ? `Simple check passed (confidence: ${confidence.toFixed(2)} >= ${threshold})`
+            : `Simple check failed (confidence: ${confidence.toFixed(2)} < ${threshold})`;
         return { passed, confidence, score: confidence, reason };
     }
     _llmType() {
@@ -363,10 +418,10 @@ class CascadeChatModel extends chat_models_1.BaseChatModel {
             if (this.enabledDomains.length > 0) {
                 detectedDomain = await this.detectDomain(queryText);
                 if (detectedDomain) {
-                    const domainConfig = this.domainConfigs.get(detectedDomain);
-                    if (domainConfig?.model) {
-                        domainModel = domainConfig.model;
-                        await runManager?.handleText(`🎯 Domain: ${DOMAIN_DISPLAY_NAMES[detectedDomain]} → Using domain-specific model\n`);
+                    const connectedDomainModel = await this.getDomainModel(detectedDomain);
+                    if (connectedDomainModel) {
+                        domainModel = connectedDomainModel;
+                        await runManager?.handleText(`🎯 Domain: ${config_1.DOMAIN_DISPLAY_NAMES[detectedDomain]} → Using domain-specific model\n`);
                     }
                 }
             }
@@ -374,9 +429,9 @@ class CascadeChatModel extends chat_models_1.BaseChatModel {
             let complexity;
             let shouldSkipDrafter = false;
             if (this.complexityDetector) {
-                try {
-                    const complexityResult = await this.complexityDetector.detectComplexity(queryText);
-                    complexity = complexityResult.level;
+                const complexityResult = await this.detectComplexity(queryText);
+                complexity = complexityResult.level;
+                if (complexity && this.useComplexityRouting) {
                     if (complexity === 'hard' || complexity === 'expert') {
                         shouldSkipDrafter = true;
                         await runManager?.handleText(`🧠 Complexity: ${complexity} → Routing directly to verifier (skip drafter)\n`);
@@ -387,27 +442,22 @@ class CascadeChatModel extends chat_models_1.BaseChatModel {
                         console.log(`🧠 Complexity: ${complexity} → Drafter route`);
                     }
                 }
-                catch (e) {
-                    console.warn('Complexity detection failed, using normal flow');
-                }
             }
-            // Step 3: Execute with circuit breaker protection if available
-            const executeWithProtection = async (model, modelType) => {
-                if (this.circuitBreaker) {
-                    return await this.circuitBreaker.execute(modelType, async () => await model.invoke(messages, options));
-                }
-                return await model.invoke(messages, options);
-            };
-            // Step 3a: If complexity routing says skip drafter, go directly to verifier
+            // Step 3: If complexity routing says skip drafter, go directly to verifier
             if (shouldSkipDrafter) {
                 const verifierModel = await this.getVerifierModel();
                 const verifierInfo = this.getModelInfo(verifierModel);
                 await runManager?.handleText(`⚡ Direct route: Using verifier for ${complexity} query\n`);
                 const verifierStartTime = Date.now();
-                const verifierMessage = await executeWithProtection(verifierModel, 'verifier');
+                const verifierMessage = await verifierModel.invoke(messages, options);
                 const verifierLatency = Date.now() - verifierStartTime;
                 this.verifierCount++;
                 const verifierCost = await this.calculateMessageCost(verifierMessage, verifierModel);
+                const costBreakdown = {
+                    drafter: 0,
+                    verifier: verifierCost,
+                    total: verifierCost,
+                };
                 const flowLog = `
 ┌────────────────────────────────────────────┐
 │  ⚡ FLOW: DIRECT VERIFIER (SMART ROUTE)  │
@@ -433,6 +483,11 @@ class CascadeChatModel extends chat_models_1.BaseChatModel {
                     model_used: 'verifier',
                     reason: `Query complexity (${complexity}) warranted direct verifier routing`
                 };
+                this.attachCascadeMetadata(verifierMessage, (0, cascade_metadata_1.buildCascadeMetadata)({
+                    modelUsed: 'verifier',
+                    domain: detectedDomain,
+                    costs: costBreakdown,
+                }));
                 return {
                     generations: [{
                             text: verifierMessage.content.toString(),
@@ -441,13 +496,13 @@ class CascadeChatModel extends chat_models_1.BaseChatModel {
                 };
             }
             // Step 4: Try domain-specific model first if available
-            const modelToUse = domainModel || this.drafterModel;
+            const modelToUse = domainModel || (await this.getDrafterModel());
             const modelType = domainModel ? `domain:${detectedDomain}` : 'drafter';
             const modelInfo = this.getModelInfo(modelToUse);
             await runManager?.handleText(`🎯 CascadeFlow: Trying ${modelType} model: ${modelInfo}\n`);
             console.log(`🎯 CascadeFlow: Trying ${modelType} model: ${modelInfo}`);
             const drafterStartTime = Date.now();
-            const drafterMessage = await executeWithProtection(modelToUse, modelType);
+            const drafterMessage = await modelToUse.invoke(messages, options);
             const drafterLatency = Date.now() - drafterStartTime;
             if (domainModel && detectedDomain) {
                 this.domainCounts.set(detectedDomain, (this.domainCounts.get(detectedDomain) || 0) + 1);
@@ -469,7 +524,7 @@ class CascadeChatModel extends chat_models_1.BaseChatModel {
    Query → ${modelType} → Tool Calls (${toolCallsCount}) → Response
    ⚡ Tool calling: ${modelType} generated tool calls
    Model used: ${modelInfo}
-   ${detectedDomain ? `Domain: ${DOMAIN_DISPLAY_NAMES[detectedDomain]}` : ''}
+   ${detectedDomain ? `Domain: ${config_1.DOMAIN_DISPLAY_NAMES[detectedDomain]}` : ''}
    Latency: ${drafterLatency}ms
    📊 Stats: ${this.drafterCount} drafter, ${this.verifierCount} verifier
 `;
@@ -486,6 +541,20 @@ class CascadeChatModel extends chat_models_1.BaseChatModel {
                     latency_ms: drafterLatency,
                     model_used: modelType
                 };
+                const drafterCost = await this.calculateMessageCost(drafterMessage, modelToUse);
+                const baselineCost = await this.estimateAlternateModelCost(drafterMessage, this.verifierModel);
+                const costBreakdown = {
+                    drafter: drafterCost,
+                    verifier: 0,
+                    total: drafterCost,
+                    ...(detectedDomain ? { domain: drafterCost } : {}),
+                };
+                this.attachCascadeMetadata(drafterMessage, (0, cascade_metadata_1.buildCascadeMetadata)({
+                    modelUsed: modelType,
+                    domain: detectedDomain,
+                    costs: costBreakdown,
+                    baselineCost,
+                }));
                 return {
                     generations: [{
                             text: drafterMessage.content.toString(),
@@ -495,15 +564,15 @@ class CascadeChatModel extends chat_models_1.BaseChatModel {
             }
             // Step 6: Quality check with domain-aware threshold
             const responseText = drafterMessage.content.toString();
-            const effectiveThreshold = detectedDomain
-                ? (this.domainConfigs.get(detectedDomain)?.threshold ?? this.qualityThreshold)
-                : this.qualityThreshold;
+            const domainThreshold = detectedDomain
+                ? this.domainConfigs.get(detectedDomain)?.threshold
+                : undefined;
+            const effectiveThreshold = domainThreshold ?? this.getThresholdForComplexity(complexity);
             let validationResult;
             if (this.qualityValidator) {
                 try {
-                    validationResult = await this.qualityValidator.validate(responseText, queryText);
-                    validationResult.passed = validationResult.confidence >= effectiveThreshold;
-                    const qualityLog = `   📊 Quality validation: confidence=${validationResult.confidence.toFixed(2)}, threshold=${effectiveThreshold}, method=${validationResult.method}\n`;
+                    validationResult = await this.qualityValidator.validate(responseText, queryText, undefined, complexity, domainThreshold);
+                    const qualityLog = `   📊 Quality validation: confidence=${validationResult.confidence.toFixed(2)}, threshold=${effectiveThreshold}, method=${validationResult.method}${complexity ? `, complexity=${complexity}` : ''}\n`;
                     await runManager?.handleText(qualityLog);
                     console.log(qualityLog);
                     if (validationResult.details?.alignmentScore) {
@@ -516,13 +585,11 @@ class CascadeChatModel extends chat_models_1.BaseChatModel {
                     const errorLog = `   ⚠️  Quality validator error, using simple check: ${e}\n`;
                     await runManager?.handleText(errorLog);
                     console.warn(errorLog);
-                    validationResult = this.simpleQualityCheck(responseText);
-                    validationResult.passed = validationResult.confidence >= effectiveThreshold;
+                    validationResult = this.simpleQualityCheck(responseText, effectiveThreshold);
                 }
             }
             else {
-                validationResult = this.simpleQualityCheck(responseText);
-                validationResult.passed = validationResult.confidence >= effectiveThreshold;
+                validationResult = this.simpleQualityCheck(responseText, effectiveThreshold);
                 const simpleLog = `   📊 Simple quality check: confidence=${validationResult.confidence.toFixed(2)}\n`;
                 await runManager?.handleText(simpleLog);
                 console.log(simpleLog);
@@ -530,6 +597,13 @@ class CascadeChatModel extends chat_models_1.BaseChatModel {
             // Step 7: If quality is sufficient, return response
             if (validationResult.passed) {
                 const drafterCost = await this.calculateMessageCost(drafterMessage, modelToUse);
+                const baselineCost = await this.estimateAlternateModelCost(drafterMessage, this.verifierModel);
+                const costBreakdown = {
+                    drafter: drafterCost,
+                    verifier: 0,
+                    total: drafterCost,
+                    ...(detectedDomain ? { domain: drafterCost } : {}),
+                };
                 const flowLog = `
 ┌─────────────────────────────────────────┐
 │  ✅ FLOW: ${modelType.toUpperCase()} ACCEPTED (FAST PATH) │
@@ -537,7 +611,7 @@ class CascadeChatModel extends chat_models_1.BaseChatModel {
    Query → ${detectedDomain ? `Domain(${detectedDomain}) → ` : ''}${modelType} → Quality Check ✅ → Response
    ⚡ Fast & Cheap: Used ${modelType} model only
    Model used: ${modelInfo}
-   ${detectedDomain ? `Domain: ${DOMAIN_DISPLAY_NAMES[detectedDomain]}` : ''}
+   ${detectedDomain ? `Domain: ${config_1.DOMAIN_DISPLAY_NAMES[detectedDomain]}` : ''}
    Confidence: ${validationResult.confidence.toFixed(2)} (threshold: ${effectiveThreshold})
    Quality score: ${validationResult.score.toFixed(2)}
    Latency: ${drafterLatency}ms
@@ -558,6 +632,13 @@ class CascadeChatModel extends chat_models_1.BaseChatModel {
                     cost_usd: drafterCost,
                     model_used: modelType
                 };
+                this.attachCascadeMetadata(drafterMessage, (0, cascade_metadata_1.buildCascadeMetadata)({
+                    modelUsed: modelType,
+                    domain: detectedDomain,
+                    confidence: validationResult.confidence,
+                    costs: costBreakdown,
+                    baselineCost,
+                }));
                 return {
                     generations: [{
                             text: drafterMessage.content.toString(),
@@ -582,18 +663,19 @@ class CascadeChatModel extends chat_models_1.BaseChatModel {
             const verifierStartTime = Date.now();
             const verifierModel = await this.getVerifierModel();
             const verifierInfo = this.getModelInfo(verifierModel);
-            const verifierMessage = await executeWithProtection(verifierModel, 'verifier');
+            const verifierMessage = await verifierModel.invoke(messages, options);
             const verifierLatency = Date.now() - verifierStartTime;
             this.verifierCount++;
             const verifierCost = await this.calculateMessageCost(verifierMessage, verifierModel);
-            const totalCost = verifierCost;
+            const drafterCost = await this.calculateMessageCost(drafterMessage, modelToUse);
+            const totalCost = drafterCost + verifierCost;
             const totalLatency = drafterLatency + verifierLatency;
             const acceptanceRate = (this.drafterCount / (this.drafterCount + this.verifierCount) * 100).toFixed(1);
             const completionLog = `   ✅ Verifier completed successfully
    Model used: ${verifierInfo}
    Verifier latency: ${verifierLatency}ms
    Total latency: ${totalLatency}ms (${modelType}: ${drafterLatency}ms + verifier: ${verifierLatency}ms)
-   💰 Cost: $${totalCost.toFixed(6)} (verifier only, ${modelType} attempt wasted)
+   💰 Cost: $${totalCost.toFixed(6)} (drafter $${drafterCost.toFixed(6)} + verifier $${verifierCost.toFixed(6)})
    📊 Stats: ${this.drafterCount} drafter (${acceptanceRate}%), ${this.verifierCount} verifier
 `;
             await runManager?.handleText(completionLog);
@@ -612,6 +694,19 @@ class CascadeChatModel extends chat_models_1.BaseChatModel {
                 model_used: 'verifier',
                 reason: validationResult.reason
             };
+            const costBreakdown = {
+                drafter: drafterCost,
+                verifier: verifierCost,
+                total: totalCost,
+                ...(detectedDomain ? { domain: drafterCost } : {}),
+            };
+            this.attachCascadeMetadata(verifierMessage, (0, cascade_metadata_1.buildCascadeMetadata)({
+                modelUsed: 'verifier',
+                domain: detectedDomain,
+                confidence: validationResult.confidence,
+                costs: costBreakdown,
+                baselineCost: totalCost,
+            }));
             return {
                 generations: [{
                         text: verifierMessage.content.toString(),
@@ -620,15 +715,13 @@ class CascadeChatModel extends chat_models_1.BaseChatModel {
             };
         }
         catch (error) {
-            // Handle circuit breaker open state
             const errorMsg = error instanceof Error ? error.message : String(error);
-            const isCircuitOpen = errorMsg.includes('Circuit breaker') || errorMsg.includes('circuit is open');
             const errorLog = `
 ┌─────────────────────────────────────────────┐
-│  ❌ FLOW: ${isCircuitOpen ? 'CIRCUIT OPEN' : 'DRAFTER ERROR'} - FALLBACK PATH    │
+│  ❌ FLOW: DRAFTER ERROR - FALLBACK PATH     │
 └─────────────────────────────────────────────┘
-   Query → Drafter ❌ ${isCircuitOpen ? 'CIRCUIT OPEN' : 'ERROR'} → Verifier → Response
-   🔄 Fallback: ${isCircuitOpen ? 'Circuit breaker open' : 'Drafter failed'}, using verifier as backup
+   Query → Drafter ❌ ERROR → Verifier → Response
+   🔄 Fallback: Drafter failed, using verifier as backup
    Error: ${errorMsg}
    🔄 Loading verifier model...
 `;
@@ -638,9 +731,10 @@ class CascadeChatModel extends chat_models_1.BaseChatModel {
             const verifierInfo = this.getModelInfo(verifierModel);
             const verifierMessage = await verifierModel.invoke(messages, options);
             this.verifierCount++;
+            const verifierCost = await this.calculateMessageCost(verifierMessage, verifierModel);
             const fallbackCompleteLog = `   ✅ Verifier fallback completed successfully
    Model used: ${verifierInfo}
-   💰 Cost: Full verifier cost (fallback due to ${isCircuitOpen ? 'circuit open' : 'error'})
+   💰 Cost: $${verifierCost.toFixed(6)} (fallback due to error)
 `;
             await runManager?.handleText(fallbackCompleteLog);
             console.log(fallbackCompleteLog);
@@ -648,11 +742,23 @@ class CascadeChatModel extends chat_models_1.BaseChatModel {
                 verifierMessage.response_metadata = {};
             }
             verifierMessage.response_metadata.cascadeflow = {
-                flow: isCircuitOpen ? 'circuit_breaker_fallback' : 'error_fallback',
+                flow: 'error_fallback',
                 error: errorMsg,
                 cost_savings_percent: 0,
-                model_used: 'verifier'
+                model_used: 'verifier',
+                cost_usd: verifierCost
+            };
+            const costBreakdown = {
+                drafter: 0,
+                verifier: verifierCost,
+                total: verifierCost,
             };
+            this.attachCascadeMetadata(verifierMessage, (0, cascade_metadata_1.buildCascadeMetadata)({
+                modelUsed: 'verifier',
+                domain: null,
+                costs: costBreakdown,
+                baselineCost: verifierCost,
+            }));
             return {
                 generations: [{
                         text: verifierMessage.content.toString(),
@@ -669,18 +775,28 @@ class CascadeChatModel extends chat_models_1.BaseChatModel {
             const queryText = messages.map(m => m.content.toString()).join(' ');
             // Detect domain for streaming
             let detectedDomain = null;
-            let modelToUse = this.drafterModel;
+            let complexity;
+            let modelToUse = null;
+            let usingDomainModel = false;
             if (this.enabledDomains.length > 0) {
                 detectedDomain = await this.detectDomain(queryText);
                 if (detectedDomain) {
-                    const domainConfig = this.domainConfigs.get(detectedDomain);
-                    if (domainConfig?.model) {
-                        modelToUse = domainConfig.model;
+                    const connectedDomainModel = await this.getDomainModel(detectedDomain);
+                    if (connectedDomainModel) {
+                        modelToUse = connectedDomainModel;
+                        usingDomainModel = true;
                     }
                 }
             }
+            if (this.complexityDetector && this.useComplexityThresholds) {
+                const complexityResult = await this.detectComplexity(queryText);
+                complexity = complexityResult.level;
+            }
+            if (!modelToUse) {
+                modelToUse = await this.getDrafterModel();
+            }
             const modelInfo = this.getModelInfo(modelToUse);
-            const modelType = detectedDomain ? `domain:${detectedDomain}` : 'drafter';
+            const modelType = usingDomainModel && detectedDomain ? `domain:${detectedDomain}` : 'drafter';
             await runManager?.handleText(`🎯 CascadeFlow (Streaming): Trying ${modelType} model: ${modelInfo}\n`);
             console.log(`🎯 CascadeFlow (Streaming): Trying ${modelType} model: ${modelInfo}`);
             const drafterStartTime = Date.now();
@@ -697,7 +813,12 @@ class CascadeChatModel extends chat_models_1.BaseChatModel {
                 yield generationChunk;
             }
             const drafterLatency = Date.now() - drafterStartTime;
-            this.drafterCount++;
+            if (usingDomainModel && detectedDomain) {
+                this.domainCounts.set(detectedDomain, (this.domainCounts.get(detectedDomain) || 0) + 1);
+            }
+            else {
+                this.drafterCount++;
+            }
             if (lastChunk && this.hasToolCalls(lastChunk.message)) {
                 const toolCallsCount = this.getToolCallsCount(lastChunk.message);
                 const toolLog = `\n🔧 Tool calls detected (${toolCallsCount}) - cascade complete\n`;
@@ -706,24 +827,22 @@ class CascadeChatModel extends chat_models_1.BaseChatModel {
                 return;
             }
             await runManager?.handleText(`\n📊 Running quality check...\n`);
-            const effectiveThreshold = detectedDomain
-                ? (this.domainConfigs.get(detectedDomain)?.threshold ?? this.qualityThreshold)
-                : this.qualityThreshold;
+            const domainThreshold = detectedDomain
+                ? this.domainConfigs.get(detectedDomain)?.threshold
+                : undefined;
+            const effectiveThreshold = domainThreshold ?? this.getThresholdForComplexity(complexity);
             let validationResult;
             if (this.qualityValidator) {
                 try {
-                    validationResult = await this.qualityValidator.validate(fullDrafterContent, queryText);
-                    validationResult.passed = validationResult.confidence >= effectiveThreshold;
+                    validationResult = await this.qualityValidator.validate(fullDrafterContent, queryText, undefined, complexity, domainThreshold);
                     await runManager?.handleText(`   Confidence: ${validationResult.confidence.toFixed(2)} (threshold: ${effectiveThreshold})\n`);
                 }
                 catch (e) {
-                    validationResult = this.simpleQualityCheck(fullDrafterContent);
-                    validationResult.passed = validationResult.confidence >= effectiveThreshold;
+                    validationResult = this.simpleQualityCheck(fullDrafterContent, effectiveThreshold);
                 }
             }
             else {
-                validationResult = this.simpleQualityCheck(fullDrafterContent);
-                validationResult.passed = validationResult.confidence >= effectiveThreshold;
+                validationResult = this.simpleQualityCheck(fullDrafterContent, effectiveThreshold);
             }
             if (validationResult.passed) {
                 await runManager?.handleText(`✅ Quality check passed - cascade complete (${modelType} accepted)\n`);
@@ -764,6 +883,7 @@ class CascadeChatModel extends chat_models_1.BaseChatModel {
         }
     }
 }
+exports.CascadeChatModel = CascadeChatModel;
 // =============================================================================
 // Generate dynamic inputs based on enabled domains
 // =============================================================================
@@ -785,7 +905,7 @@ function generateDomainInputs(enabledDomains) {
     // Add domain-specific model inputs for each enabled domain
     for (const domain of enabledDomains) {
         baseInputs.push({
-            displayName: `${DOMAIN_DISPLAY_NAMES[domain]} Model`,
+            displayName: `${config_1.DOMAIN_DISPLAY_NAMES[domain]} Model`,
             type: 'ai_languageModel',
             maxConnections: 1,
             required: false,
@@ -797,10 +917,18 @@ function generateDomainInputs(enabledDomains) {
 // Generate domain toggle properties for n8n UI
 // =============================================================================
 function generateDomainProperties() {
-    const domainOptions = Object.entries(DOMAINS).map(([key, value]) => ({
-        name: DOMAIN_DISPLAY_NAMES[value],
+    const domainOptions = Object.entries(config_1.DOMAINS).map(([key, value]) => ({
+        name: config_1.DOMAIN_DISPLAY_NAMES[value],
         value: value,
-        description: DOMAIN_DESCRIPTIONS[value],
+        description: config_1.DOMAIN_DESCRIPTIONS[value],
+    }));
+    const domainToggleProperties = config_1.DOMAIN_UI_CONFIGS.map(({ domain, toggleName }) => ({
+        displayName: `Enable ${config_1.DOMAIN_DISPLAY_NAMES[domain]} Domain`,
+        name: toggleName,
+        type: 'boolean',
+        default: false,
+        displayOptions: { show: { enableDomainRouting: [true] } },
+        description: `Whether to enable ${config_1.DOMAIN_DESCRIPTIONS[domain]}. When enabled, adds a "${config_1.DOMAIN_DISPLAY_NAMES[domain]} Model" input port.`,
     }));
     return [
         {
@@ -811,70 +939,7 @@ function generateDomainProperties() {
             description: 'Whether to enable intelligent routing based on detected query domain (math, code, legal, etc.)',
         },
         // Individual domain toggles - each one adds its own model input port
-        {
-            displayName: 'Enable Code Domain',
-            name: 'enableCodeDomain',
-            type: 'boolean',
-            default: false,
-            displayOptions: { show: { enableDomainRouting: [true] } },
-            description: 'Whether to enable code domain routing. When enabled, adds a "Code Model" input port.',
-        },
-        {
-            displayName: 'Enable Math Domain',
-            name: 'enableMathDomain',
-            type: 'boolean',
-            default: false,
-            displayOptions: { show: { enableDomainRouting: [true] } },
-            description: 'Whether to enable math domain routing. When enabled, adds a "Math Model" input port.',
-        },
-        {
-            displayName: 'Enable Data Domain',
-            name: 'enableDataDomain',
-            type: 'boolean',
-            default: false,
-            displayOptions: { show: { enableDomainRouting: [true] } },
-            description: 'Whether to enable data analysis domain routing. When enabled, adds a "Data Model" input port.',
-        },
-        {
-            displayName: 'Enable Creative Domain',
-            name: 'enableCreativeDomain',
-            type: 'boolean',
-            default: false,
-            displayOptions: { show: { enableDomainRouting: [true] } },
-            description: 'Whether to enable creative writing domain routing. When enabled, adds a "Creative Model" input port.',
-        },
-        {
-            displayName: 'Enable Legal Domain',
-            name: 'enableLegalDomain',
-            type: 'boolean',
-            default: false,
-            displayOptions: { show: { enableDomainRouting: [true] } },
-            description: 'Whether to enable legal domain routing. When enabled, adds a "Legal Model" input port.',
-        },
-        {
-            displayName: 'Enable Medical Domain',
-            name: 'enableMedicalDomain',
-            type: 'boolean',
-            default: false,
-            displayOptions: { show: { enableDomainRouting: [true] } },
-            description: 'Whether to enable medical domain routing. When enabled, adds a "Medical Model" input port.',
-        },
-        {
-            displayName: 'Enable Financial Domain',
-            name: 'enableFinancialDomain',
-            type: 'boolean',
-            default: false,
-            displayOptions: { show: { enableDomainRouting: [true] } },
-            description: 'Whether to enable financial domain routing. When enabled, adds a "Financial Model" input port.',
-        },
-        {
-            displayName: 'Enable Science Domain',
-            name: 'enableScienceDomain',
-            type: 'boolean',
-            default: false,
-            displayOptions: { show: { enableDomainRouting: [true] } },
-            description: 'Whether to enable science domain routing. When enabled, adds a "Science Model" input port.',
-        },
+        ...domainToggleProperties,
         {
             displayName: 'Domain-Specific Settings',
             name: 'domainSettings',
@@ -905,7 +970,7 @@ function generateDomainProperties() {
                             displayName: 'Quality Threshold',
                             name: 'threshold',
                             type: 'number',
-                            default: 0.64,
+                            default: 0.4,
                             typeOptions: {
                                 minValue: 0,
                                 maxValue: 1,
@@ -980,26 +1045,50 @@ class LmChatCascadeFlow {
         if (params?.enableCodeDomain) {
           inputs.push({ displayName: 'Code', type: 'ai_languageModel', maxConnections: 1, required: false });
         }
-        if (params?.enableMathDomain) {
-          inputs.push({ displayName: 'Math', type: 'ai_languageModel', maxConnections: 1, required: false });
-        }
         if (params?.enableDataDomain) {
-          inputs.push({ displayName: 'Data', type: 'ai_languageModel', maxConnections: 1, required: false });
+          inputs.push({ displayName: 'Data Analysis', type: 'ai_languageModel', maxConnections: 1, required: false });
+        }
+        if (params?.enableStructuredDomain) {
+          inputs.push({ displayName: 'Structured Output', type: 'ai_languageModel', maxConnections: 1, required: false });
+        }
+        if (params?.enableRagDomain) {
+          inputs.push({ displayName: 'RAG (Retrieval)', type: 'ai_languageModel', maxConnections: 1, required: false });
+        }
+        if (params?.enableConversationDomain) {
+          inputs.push({ displayName: 'Conversation', type: 'ai_languageModel', maxConnections: 1, required: false });
+        }
+        if (params?.enableToolDomain) {
+          inputs.push({ displayName: 'Tool Calling', type: 'ai_languageModel', maxConnections: 1, required: false });
         }
         if (params?.enableCreativeDomain) {
           inputs.push({ displayName: 'Creative', type: 'ai_languageModel', maxConnections: 1, required: false });
         }
-        if (params?.enableLegalDomain) {
-          inputs.push({ displayName: 'Legal', type: 'ai_languageModel', maxConnections: 1, required: false });
+        if (params?.enableSummaryDomain) {
+          inputs.push({ displayName: 'Summary', type: 'ai_languageModel', maxConnections: 1, required: false });
+        }
+        if (params?.enableTranslationDomain) {
+          inputs.push({ displayName: 'Translation', type: 'ai_languageModel', maxConnections: 1, required: false });
+        }
+        if (params?.enableMathDomain) {
+          inputs.push({ displayName: 'Math', type: 'ai_languageModel', maxConnections: 1, required: false });
+        }
+        if (params?.enableScienceDomain) {
+          inputs.push({ displayName: 'Science', type: 'ai_languageModel', maxConnections: 1, required: false });
         }
         if (params?.enableMedicalDomain) {
           inputs.push({ displayName: 'Medical', type: 'ai_languageModel', maxConnections: 1, required: false });
         }
+        if (params?.enableLegalDomain) {
+          inputs.push({ displayName: 'Legal', type: 'ai_languageModel', maxConnections: 1, required: false });
+        }
         if (params?.enableFinancialDomain) {
           inputs.push({ displayName: 'Financial', type: 'ai_languageModel', maxConnections: 1, required: false });
         }
-        if (params?.enableScienceDomain) {
-          inputs.push({ displayName: 'Science', type: 'ai_languageModel', maxConnections: 1, required: false });
+        if (params?.enableMultimodalDomain) {
+          inputs.push({ displayName: 'Multimodal', type: 'ai_languageModel', maxConnections: 1, required: false });
+        }
+        if (params?.enableGeneralDomain) {
+          inputs.push({ displayName: 'General', type: 'ai_languageModel', maxConnections: 1, required: false });
         }
       }
 
@@ -1013,13 +1102,85 @@ class LmChatCascadeFlow {
                     displayName: 'Quality Threshold',
                     name: 'qualityThreshold',
                     type: 'number',
-                    default: 0.64,
+                    default: 0.4,
+                    typeOptions: {
+                        minValue: 0,
+                        maxValue: 1,
+                        numberPrecision: 2,
+                    },
+                    description: 'Minimum quality score (0-1) to accept drafter response when complexity thresholds are disabled',
+                },
+                {
+                    displayName: 'Use Complexity Thresholds',
+                    name: 'useComplexityThresholds',
+                    type: 'boolean',
+                    default: true,
+                    description: 'Whether to use per-complexity confidence thresholds (trivial → expert) to match CascadeFlow Python defaults',
+                },
+                {
+                    displayName: 'Trivial Threshold',
+                    name: 'trivialThreshold',
+                    type: 'number',
+                    default: 0.25,
+                    displayOptions: { show: { useComplexityThresholds: [true] } },
                     typeOptions: {
                         minValue: 0,
                         maxValue: 1,
                         numberPrecision: 2,
                     },
-                    description: 'Minimum quality score (0-1) to accept drafter response. Lower = more cost savings, higher = better quality.',
+                    description: 'Minimum confidence for trivial queries',
+                },
+                {
+                    displayName: 'Simple Threshold',
+                    name: 'simpleThreshold',
+                    type: 'number',
+                    default: 0.4,
+                    displayOptions: { show: { useComplexityThresholds: [true] } },
+                    typeOptions: {
+                        minValue: 0,
+                        maxValue: 1,
+                        numberPrecision: 2,
+                    },
+                    description: 'Minimum confidence for simple queries',
+                },
+                {
+                    displayName: 'Moderate Threshold',
+                    name: 'moderateThreshold',
+                    type: 'number',
+                    default: 0.55,
+                    displayOptions: { show: { useComplexityThresholds: [true] } },
+                    typeOptions: {
+                        minValue: 0,
+                        maxValue: 1,
+                        numberPrecision: 2,
+                    },
+                    description: 'Minimum confidence for moderate queries',
+                },
+                {
+                    displayName: 'Hard Threshold',
+                    name: 'hardThreshold',
+                    type: 'number',
+                    default: 0.7,
+                    displayOptions: { show: { useComplexityThresholds: [true] } },
+                    typeOptions: {
+                        minValue: 0,
+                        maxValue: 1,
+                        numberPrecision: 2,
+                    },
+                    description: 'Minimum confidence for hard queries',
+                },
+                {
+                    displayName: 'Expert Threshold',
+                    name: 'expertThreshold',
+                    type: 'number',
+                    default: 0.8,
+                    displayOptions: { show: { useComplexityThresholds: [true] } },
+                    typeOptions: {
+                        minValue: 0,
+                        maxValue: 1,
+                        numberPrecision: 2,
+                    },
+                    description: 'Minimum confidence for expert queries',
                 },
                 {
                     displayName: 'Enable Alignment Scoring',
@@ -1035,13 +1196,6 @@ class LmChatCascadeFlow {
                     default: true,
                     description: 'Whether to route queries directly to the verifier based on detected complexity',
                 },
-                {
-                    displayName: 'Enable Circuit Breaker',
-                    name: 'useCircuitBreaker',
-                    type: 'boolean',
-                    default: true,
-                    description: 'Whether to use circuit breaker for fault tolerance (auto-fallback on repeated failures)',
-                },
                 // Domain routing settings
                 ...generateDomainProperties(),
             ],
@@ -1049,41 +1203,30 @@ class LmChatCascadeFlow {
     }
     async supplyData() {
         // Get core parameters
-        const qualityThreshold = this.getNodeParameter('qualityThreshold', 0, 0.64);
+        const qualityThreshold = this.getNodeParameter('qualityThreshold', 0, config_1.DEFAULT_COMPLEXITY_THRESHOLDS.simple);
         const useSemanticValidation = false; // Disabled - loads heavy ML model causing OOM in n8n
         const useAlignmentScoring = this.getNodeParameter('useAlignmentScoring', 0, true);
         const useComplexityRouting = this.getNodeParameter('useComplexityRouting', 0, true);
-        const useCircuitBreaker = this.getNodeParameter('useCircuitBreaker', 0, true);
+        const useComplexityThresholds = this.getNodeParameter('useComplexityThresholds', 0, true);
+        const confidenceThresholds = useComplexityThresholds
+            ? {
+                trivial: this.getNodeParameter('trivialThreshold', 0, config_1.DEFAULT_COMPLEXITY_THRESHOLDS.trivial),
+                simple: this.getNodeParameter('simpleThreshold', 0, config_1.DEFAULT_COMPLEXITY_THRESHOLDS.simple),
+                moderate: this.getNodeParameter('moderateThreshold', 0, config_1.DEFAULT_COMPLEXITY_THRESHOLDS.moderate),
+                hard: this.getNodeParameter('hardThreshold', 0, config_1.DEFAULT_COMPLEXITY_THRESHOLDS.hard),
+                expert: this.getNodeParameter('expertThreshold', 0, config_1.DEFAULT_COMPLEXITY_THRESHOLDS.expert),
+            }
+            : undefined;
         // Get domain routing parameters
         const enableDomainRouting = this.getNodeParameter('enableDomainRouting', 0, false);
         // Build enabledDomains array from individual toggle parameters
         const enabledDomains = [];
         if (enableDomainRouting) {
-            // Check each domain toggle and build the array in the same order as the inputs template
-            if (this.getNodeParameter('enableCodeDomain', 0, false)) {
-                enabledDomains.push('code');
-            }
-            if (this.getNodeParameter('enableMathDomain', 0, false)) {
-                enabledDomains.push('math');
-            }
-            if (this.getNodeParameter('enableDataDomain', 0, false)) {
-                enabledDomains.push('data');
-            }
-            if (this.getNodeParameter('enableCreativeDomain', 0, false)) {
-                enabledDomains.push('creative');
-            }
-            if (this.getNodeParameter('enableLegalDomain', 0, false)) {
-                enabledDomains.push('legal');
-            }
-            if (this.getNodeParameter('enableMedicalDomain', 0, false)) {
-                enabledDomains.push('medical');
-            }
-            if (this.getNodeParameter('enableFinancialDomain', 0, false)) {
-                enabledDomains.push('financial');
-            }
-            if (this.getNodeParameter('enableScienceDomain', 0, false)) {
-                enabledDomains.push('science');
+            const toggleParams = {};
+            for (const { toggleName } of config_1.DOMAIN_UI_CONFIGS) {
+                toggleParams[toggleName] = this.getNodeParameter(toggleName, 0, false);
             }
+            enabledDomains.push(...(0, config_1.getEnabledDomains)(toggleParams));
         }
         // Get domain-specific settings
         const domainSettingsRaw = this.getNodeParameter('domainSettings', 0, { domainConfig: [] });
@@ -1097,12 +1240,15 @@ class LmChatCascadeFlow {
                 });
             }
         }
-        // Get the drafter model (index 1 - bottom port, labeled "Drafter")
-        const drafterData = await this.getInputConnectionData('ai_languageModel', 1);
-        const drafterModel = (Array.isArray(drafterData) ? drafterData[0] : drafterData);
-        if (!drafterModel) {
-            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Drafter model is required. Please connect your DRAFTER model to the BOTTOM port (labeled "Drafter").');
-        }
+        // Lazy loader for drafter (index 1 - bottom port, labeled "Drafter")
+        const drafterModelGetter = async () => {
+            const drafterData = await this.getInputConnectionData('ai_languageModel', 1);
+            const drafterModel = (Array.isArray(drafterData) ? drafterData[0] : drafterData);
+            if (!drafterModel) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Drafter model is required. Please connect your DRAFTER model to the BOTTOM port (labeled "Drafter").');
+            }
+            return drafterModel;
+        };
         // Create lazy loader for verifier (index 0 - top port, labeled "Verifier")
         const verifierModelGetter = async () => {
             const verifierData = await this.getInputConnectionData('ai_languageModel', 0);
@@ -1127,50 +1273,33 @@ class LmChatCascadeFlow {
                     try {
                         const domainData = await this.getInputConnectionData('ai_languageModel', domainIndex);
                         const domainModel = (Array.isArray(domainData) ? domainData[0] : domainData);
-                        if (domainModel) {
-                            // Store in domain config
-                            const config = domainConfigs.get(domain) || {
-                                enabled: true,
-                                threshold: qualityThreshold,
-                                temperature: 0.7,
-                            };
-                            config.model = domainModel;
-                            domainConfigs.set(domain, config);
-                            return domainModel;
-                        }
+                        return domainModel || undefined;
                     }
-                    catch (e) {
-                        console.log(`No ${domain} model connected, using drafter as fallback`);
+                    catch {
+                        return undefined;
                     }
                     return undefined;
                 });
             }
         }
-        // Eagerly load domain models
-        for (const [domain, getter] of domainModelGetters.entries()) {
-            await getter();
-        }
-        // Debug info
-        const getDrafterInfo = () => {
-            const type = typeof drafterModel._llmType === 'function' ? drafterModel._llmType() : 'unknown';
-            const modelName = drafterModel.modelName || drafterModel.model || 'unknown';
-            return `${type} (${modelName})`;
-        };
         console.log('🚀 CascadeFlow v2 initialized');
         console.log(`   PORT MAPPING:`);
         console.log(`   ├─ TOP port (labeled "Verifier") → VERIFIER model: lazy-loaded`);
-        console.log(`   └─ BOTTOM port (labeled "Drafter") → DRAFTER model: ${getDrafterInfo()}`);
+        console.log(`   └─ BOTTOM port (labeled "Drafter") → DRAFTER model: lazy-loaded`);
         console.log(`   Quality threshold: ${qualityThreshold}`);
         console.log(`   Semantic validation: ${useSemanticValidation ? 'enabled' : 'disabled'}`);
         console.log(`   Alignment scoring: ${useAlignmentScoring ? 'enabled' : 'disabled'}`);
         console.log(`   Complexity routing: ${useComplexityRouting ? 'enabled' : 'disabled'}`);
-        console.log(`   Circuit breaker: ${useCircuitBreaker ? 'enabled' : 'disabled'}`);
+        console.log(`   Complexity thresholds: ${useComplexityThresholds ? 'enabled' : 'disabled'}`);
         console.log(`   Domain routing: ${enableDomainRouting ? 'enabled' : 'disabled'}`);
         if (enabledDomains.length > 0) {
             console.log(`   Enabled domains: ${enabledDomains.join(', ')}`);
         }
+        if (useComplexityThresholds && confidenceThresholds) {
+            console.log(`   Thresholds: ${JSON.stringify(confidenceThresholds)}`);
+        }
         // Create and return the cascade model
-        const cascadeModel = new CascadeChatModel(drafterModel, verifierModelGetter, qualityThreshold, useSemanticValidation, useAlignmentScoring, useComplexityRouting, enableDomainRouting, enabledDomains, domainModelGetters, domainConfigs, useCircuitBreaker);
+        const cascadeModel = new CascadeChatModel(drafterModelGetter, verifierModelGetter, qualityThreshold, useSemanticValidation, useAlignmentScoring, useComplexityRouting, useComplexityThresholds, enableDomainRouting, enabledDomains, domainModelGetters, domainConfigs, confidenceThresholds);
         return {
             response: cascadeModel,
         };