fix(agentflow): prevent ConditionAgent silent failure when no scenario matches (#5760)

* fix(agentflow): prevent ConditionAgent from silently dropping when no scenario matches

the ConditionAgent was doing strict exact string matching against
scenario descriptions, but LLMs often return abbreviated or slightly
different versions of the scenario text. when nothing matched, all
branches got marked as unfulfilled and the flow silently terminated
with no response.

added fallback matching (startsWith, includes) so partial matches
still route correctly, plus a last-resort else branch so the flow
never just dies silently. also added a safety net in the execution
engine to catch the case where all conditions are unfulfilled.

fixes #5620

* refactor: normalize output once and drop unnecessary any casts

- normalize calledOutputName once before all matching steps instead of
  calling toLowerCase().trim() repeatedly
- remove explicit any types where inference handles it

* test(agentflow): cover ConditionAgent scenario matching fallbacks

* Update matchScenario.test.ts

* Update matchScenario.ts

---------

Co-authored-by: Henry Heng <henryheng@flowiseai.com>

Author: aviu16

packages/components/nodes/agentflow/ConditionAgent/ConditionAgent.ts

@@ -9,6 +9,7 @@ import {
 } from '../utils'
 import { CONDITION_AGENT_SYSTEM_PROMPT, DEFAULT_SUMMARIZER_TEMPLATE } from '../prompt'
 import { BaseChatModel } from '@langchain/core/language_models/chat_models'
+import { findBestScenarioIndex } from './matchScenario'
 
 class ConditionAgent_Agentflow implements INode {
     label: string
@@ -406,10 +407,7 @@ class ConditionAgent_Agentflow implements INode {
                 }
             }
 
-            // Find the first exact match
-            const matchedScenarioIndex = _conditionAgentScenarios.findIndex(
-                (scenario) => calledOutputName.toLowerCase() === scenario.scenario.toLowerCase()
-            )
+            const matchedScenarioIndex = findBestScenarioIndex(_conditionAgentScenarios, calledOutputName)
 
             const conditions = _conditionAgentScenarios.map((scenario, index) => {
                 return {

packages/components/nodes/agentflow/ConditionAgent/matchScenario.test.ts

@@ -0,0 +1,29 @@
+import { findBestScenarioIndex } from './matchScenario'
+
+describe('findBestScenarioIndex', () => {
+    const scenarios = [{ scenario: 'billing issue' }, { scenario: 'technical support' }, { scenario: 'other' }]
+
+    it('matches exact scenario (case-insensitive)', () => {
+        expect(findBestScenarioIndex(scenarios, 'Technical Support')).toBe(1)
+    })
+
+    it('matches exact scenario with surrounding whitespace', () => {
+        expect(findBestScenarioIndex(scenarios, '  billing issue  ')).toBe(0)
+    })
+
+    it('matches abbreviated output using startsWith fallback', () => {
+        expect(findBestScenarioIndex(scenarios, 'tech')).toBe(1)
+    })
+
+    it('matches substring output in either direction', () => {
+        expect(findBestScenarioIndex(scenarios, 'need help with billing issue today')).toBe(0)
+    })
+
+    it('falls back to last scenario when no match is found', () => {
+        expect(findBestScenarioIndex(scenarios, 'completely unrelated')).toBe(2)
+    })
+
+    it('returns -1 for empty scenarios list', () => {
+        expect(findBestScenarioIndex([], 'anything')).toBe(-1)
+    })
+})

packages/components/nodes/agentflow/ConditionAgent/matchScenario.ts

@@ -0,0 +1,30 @@
+export type ConditionScenario = { scenario: string }
+
+export const findBestScenarioIndex = (scenarios: ConditionScenario[], calledOutputName: string): number => {
+    if (!Array.isArray(scenarios) || scenarios.length === 0) return -1
+
+    const normalizedOutput = calledOutputName.toLowerCase().trim()
+
+    // try exact match first
+    let matchedScenarioIndex = scenarios.findIndex((scenario) => scenario.scenario.toLowerCase() === normalizedOutput)
+
+    // fallback: check if LLM returned a partial/abbreviated scenario name
+    if (matchedScenarioIndex === -1) {
+        matchedScenarioIndex = scenarios.findIndex((scenario) => scenario.scenario.toLowerCase().startsWith(normalizedOutput))
+    }
+
+    // further fallback: substring match in either direction
+    if (matchedScenarioIndex === -1) {
+        matchedScenarioIndex = scenarios.findIndex(
+            (scenario) =>
+                scenario.scenario.toLowerCase().includes(normalizedOutput) || normalizedOutput.includes(scenario.scenario.toLowerCase())
+        )
+    }
+
+    // last resort: if still no match, use the last scenario as an "else" branch
+    if (matchedScenarioIndex === -1) {
+        matchedScenarioIndex = scenarios.length - 1
+    }
+
+    return matchedScenarioIndex
+}

packages/server/src/utils/buildAgentflow.ts

@@ -769,12 +769,20 @@ async function determineNodesToIgnore(
     if (isDecisionNode && result.output?.conditions) {
         const outputConditions: ICondition[] = result.output.conditions
 
+        // safety net: if no conditions were fulfilled, don't ignore ALL children
+        // treat the last condition as an else/default fallback
+        const anyFulfilled = outputConditions.some((c) => c.isFulfilled === true)
+        if (!anyFulfilled && outputConditions.length > 0) {
+            // mark the last condition as fulfilled so at least one branch executes
+            outputConditions[outputConditions.length - 1].isFulfilled = true
+        }
+
         // Find indexes of unfulfilled conditions
         const unfulfilledIndexes = outputConditions
-            .map((condition: any, index: number) =>
+            .map((condition, index) =>
                 condition.isFulfilled === false || !Object.prototype.hasOwnProperty.call(condition, 'isFulfilled') ? index : -1
             )
-            .filter((index: number) => index !== -1)
+            .filter((index) => index !== -1)
 
         // Find nodes to ignore based on unfulfilled conditions
         for (const index of unfulfilledIndexes) {