@falai/agent 2.2.4 → 2.4.2

package/src/utils/condition.ts

@@ -11,6 +11,113 @@ type ConditionTemplate<TContext = unknown, TData = unknown> =
   | ((params: TemplateContext<TContext, TData>) => boolean | Promise<boolean>)
   | ConditionTemplate<TContext, TData>[];
 
+export interface WhenConditionGroups {
+  positive: string[];
+  negative: string[];
+}
+
+function emptyWhenConditionGroups(): WhenConditionGroups {
+  return { positive: [], negative: [] };
+}
+
+function pushWhenCondition(groups: WhenConditionGroups, value: string): void {
+  const condition = value.trim();
+  if (!condition) {
+    return;
+  }
+
+  if (condition.startsWith("!")) {
+    const negative = condition.slice(1).trim();
+    if (negative) {
+      groups.negative.push(negative);
+    }
+    return;
+  }
+
+  groups.positive.push(condition);
+}
+
+/**
+ * Evaluate code (`if`) predicates with AND semantics and short-circuit.
+ *
+ * Shared by branch and signal evaluation — both define `if` as one predicate
+ * or an array of predicates over their respective contexts. A predicate that
+ * throws is logged at ERROR (with `label` and index) and treated as false,
+ * so a failing predicate only inhibits its own entry.
+ */
+export async function evaluateIfPredicates<TCtx>(
+  predicates:
+    | ((ctx: TCtx) => boolean | Promise<boolean>)
+    | Array<(ctx: TCtx) => boolean | Promise<boolean>>,
+  ctx: TCtx,
+  label: string,
+): Promise<boolean> {
+  const predicateArray = Array.isArray(predicates) ? predicates : [predicates];
+
+  for (let i = 0; i < predicateArray.length; i++) {
+    try {
+      const result = await predicateArray[i](ctx);
+      if (!result) {
+        return false;
+      }
+    } catch (error) {
+      logger.error(
+        `[${label}] Predicate at index ${i} threw: ${error instanceof Error ? error.message : String(error)}`,
+      );
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Split AI-evaluated `when` strings into positive alternatives and negative
+ * exclusions. Positive entries are OR alternatives. `!`-prefixed entries are
+ * stripped and treated as OR exclusions, where any match inhibits the condition.
+ */
+export function splitWhenConditions(
+  when: string | string[] | undefined | null
+): WhenConditionGroups {
+  const groups = emptyWhenConditionGroups();
+  if (when == null) {
+    return groups;
+  }
+
+  const entries: unknown[] = Array.isArray(when) ? when : [when];
+  for (const entry of entries) {
+    if (typeof entry === "string") {
+      pushWhenCondition(groups, entry);
+    }
+  }
+
+  return groups;
+}
+
+function splitConditionTemplate<TContext = unknown, TData = unknown>(
+  condition: ConditionTemplate<TContext, TData> | undefined | null
+): WhenConditionGroups {
+  const groups = emptyWhenConditionGroups();
+  if (condition == null) {
+    return groups;
+  }
+
+  if (Array.isArray(condition)) {
+    for (const subCondition of condition) {
+      const subGroups = splitConditionTemplate(subCondition);
+      groups.positive.push(...subGroups.positive);
+      groups.negative.push(...subGroups.negative);
+    }
+    return groups;
+  }
+
+  if (typeof condition === "string") {
+    pushWhenCondition(groups, condition);
+  }
+
+  return groups;
+}
+
 /**
  * Utility class for evaluating ConditionTemplate instances.
  * Handles mixed string/function conditions and separates programmatic
@@ -34,6 +141,7 @@ export class ConditionEvaluator<TContext = unknown, TData = unknown> {
     const result: ConditionEvaluationResult = {
       programmaticResult: logic === 'AND' ? true : false,
       aiContextStrings: [],
+      aiExclusionStrings: [],
       hasProgrammaticConditions: false,
       evaluationDetails: []
     };
@@ -49,7 +157,9 @@ export class ConditionEvaluator<TContext = unknown, TData = unknown> {
 
     // Handle string conditions (AI context only)
     if (typeof condition === 'string') {
-      result.aiContextStrings.push(condition);
+      const groups = splitWhenConditions(condition);
+      result.aiContextStrings.push(...groups.positive);
+      result.aiExclusionStrings?.push(...groups.negative);
       result.evaluationDetails?.push({
         condition: condition,
         type: 'string'
@@ -100,6 +210,7 @@ export class ConditionEvaluator<TContext = unknown, TData = unknown> {
     const result: ConditionEvaluationResult = {
       programmaticResult: logic === 'AND' ? true : false,
       aiContextStrings: [],
+      aiExclusionStrings: [],
       hasProgrammaticConditions: false,
       evaluationDetails: [{
         condition: `Array[${conditions.length}]`,
@@ -114,6 +225,7 @@ export class ConditionEvaluator<TContext = unknown, TData = unknown> {
 
       // Collect AI context strings
       result.aiContextStrings.push(...conditionResult.aiContextStrings);
+      result.aiExclusionStrings?.push(...(conditionResult.aiExclusionStrings ?? []));
 
       // Track if we have programmatic conditions
       if (conditionResult.hasProgrammaticConditions) {
@@ -163,22 +275,7 @@ export function createConditionEvaluator<TContext = unknown, TData = unknown>(
 export function extractAIContextStrings<TContext = unknown, TData = unknown>(
   condition: ConditionTemplate<TContext, TData>
 ): string[] {
-  const contextStrings: string[] = [];
-
-  if (!condition) {
-    return contextStrings;
-  }
-
-  if (Array.isArray(condition)) {
-    for (const subCondition of condition) {
-      contextStrings.push(...extractAIContextStrings(subCondition));
-    }
-  } else if (typeof condition === 'string') {
-    contextStrings.push(condition);
-  }
-  // Functions don't contribute to AI context
-
-  return contextStrings;
+  return splitConditionTemplate(condition).positive;
 }
 
 /**
@@ -196,4 +293,4 @@ export function hasProgrammaticConditions<TContext = unknown, TData = unknown>(
   }
 
   return typeof condition === 'function';
-}
+}

package/src/utils/session.ts

@@ -306,6 +306,7 @@ export function sessionDataToStep<TData = Record<string, unknown>>(
     currentFlow?: string;
     currentStep?: string;
     collectedData?: CollectedStateData<TData>;
+    version?: number;
   }
 ): SessionState<TData> {
   const collectedData: CollectedStateData<TData> = data.collectedData || {
@@ -337,6 +338,7 @@ export function sessionDataToStep<TData = Record<string, unknown>>(
     flowHistory: collectedData.flowHistory || [],
     history: collectedData.history || [],
     metadata: collectedData.metadata || {},
+    version: data.version,
   };
 
   // Restore pendingDirective if present (ignore any legacy pendingTransition — per Req 12.3)