Conditions Module - PraisonAI

Create flexible conditions for routing, filtering, and controlling agent workflow execution.

Quick Start

Create a Dictionary Condition

import { DictCondition } from 'praisonai';

const condition = new DictCondition({
  status: "active",
  priority: (v) => v > 5
});

const result = condition.evaluate({
  status: "active",
  priority: 8
});

console.log(result);  // true

Create an Expression Condition

import { ExpressionCondition } from 'praisonai';

const condition = new ExpressionCondition("score >= 80");

console.log(condition.evaluate({ score: 85 }));  // true
console.log(condition.evaluate({ score: 70 }));  // false

Condition Types

DictCondition

Match context values against expected values:

import { DictCondition } from 'praisonai';

// Simple equality
const simple = new DictCondition({
  role: "admin",
  active: true
});

// With functions
const withFunctions = new DictCondition({
  age: (v) => v >= 18,
  score: (v) => v > 50 && v < 100
});

// With regex
const withRegex = new DictCondition({
  email: /^[\w.-]+@[\w.-]+\.\w+$/
});

// OR operator (any condition matches)
const orCondition = new DictCondition({
  role: "admin",
  superuser: true
}, 'or');

ExpressionCondition

Evaluate string expressions:

import { ExpressionCondition } from 'praisonai';

// Comparison operators
const gt = new ExpressionCondition("count > 10");
const eq = new ExpressionCondition("status == 'active'");
const ne = new ExpressionCondition("error != null");

// Evaluate
gt.evaluate({ count: 15 });     // true
eq.evaluate({ status: "active" }); // true
ne.evaluate({ error: "failed" }); // true

FunctionCondition

Custom function-based conditions:

import { FunctionCondition } from 'praisonai';

const condition = new FunctionCondition(
  (ctx) => ctx.items.length > 0 && ctx.total > 100,
  "Has items and total > 100"
);

condition.evaluate({ items: [1, 2], total: 150 });  // true
condition.evaluate({ items: [], total: 200 });      // false

Condition Protocol

All conditions implement the ConditionProtocol:

interface ConditionProtocol {
  evaluate(context: Record<string, any>): boolean | Promise<boolean>;
  describe(): string;
}

Combining Conditions

AND Conditions

import { andConditions, DictCondition, ExpressionCondition } from 'praisonai';

const combined = andConditions([
  new DictCondition({ active: true }),
  new ExpressionCondition("score >= 50")
]);

combined.evaluate({ active: true, score: 75 });  // true
combined.evaluate({ active: true, score: 30 });  // false

OR Conditions

import { orConditions, DictCondition } from 'praisonai';

const combined = orConditions([
  new DictCondition({ role: "admin" }),
  new DictCondition({ role: "moderator" })
]);

combined.evaluate({ role: "admin" });     // true
combined.evaluate({ role: "moderator" }); // true
combined.evaluate({ role: "user" });      // false

NOT Condition

import { notCondition, DictCondition } from 'praisonai';

const isNotBanned = notCondition(
  new DictCondition({ banned: true })
);

isNotBanned.evaluate({ banned: false }); // true
isNotBanned.evaluate({ banned: true });  // false

Evaluate Condition Helper

import { evaluateCondition } from 'praisonai';

// With ConditionProtocol
const condition = new DictCondition({ active: true });
const result = await evaluateCondition(condition, { active: true });

// With function
const fnResult = await evaluateCondition(
  (ctx) => ctx.count > 0,
  { count: 5 }
);

// With object
const objResult = await evaluateCondition(
  { status: "ready" },
  { status: "ready" }
);

Create Condition Factory

import { createCondition } from 'praisonai';

// From object
const dictCond = createCondition({ active: true });

// From function
const fnCond = createCondition((ctx) => ctx.score > 50);

// From string expression
const exprCond = createCondition("count >= 10");

Common Patterns

Routing Condition
Validation
Feature Flags

import { DictCondition } from 'praisonai';

const routeToSupport = new DictCondition({
  category: "support",
  priority: (v) => v === "high"
});

const routeToSales = new DictCondition({
  category: "sales"
});

function routeRequest(request) {
  if (routeToSupport.evaluate(request)) {
    return "support-agent";
  } else if (routeToSales.evaluate(request)) {
    return "sales-agent";
  }
  return "general-agent";
}

import { andConditions, DictCondition, ExpressionCondition } from 'praisonai';

const isValidOrder = andConditions([
  new DictCondition({
    items: (v) => Array.isArray(v) && v.length > 0
  }),
  new ExpressionCondition("total > 0"),
  new DictCondition({
    customer: (v) => v?.email != null
  })
]);

const order = {
  items: [{ id: 1, qty: 2 }],
  total: 99.99,
  customer: { email: "[email protected]" }
};

if (isValidOrder.evaluate(order)) {
  processOrder(order);
}

import { DictCondition, orConditions } from 'praisonai';

const canAccessBeta = orConditions([
  new DictCondition({ role: "admin" }),
  new DictCondition({ betaTester: true }),
  new DictCondition({
    joinDate: (d) => new Date(d) < new Date("2024-01-01")
  })
]);

const user = { role: "user", betaTester: true };
if (canAccessBeta.evaluate(user)) {
  showBetaFeatures();
}

Best Practices

Use DictCondition for simple matching

For key-value comparisons, DictCondition is cleaner than custom functions.

Combine conditions for complex logic

Use andConditions and orConditions instead of nested if statements.

Add descriptions for debugging

Use describe() to get human-readable condition descriptions.

Router Agent

Route requests to different agents

Workflows

Build complex agent workflows

JavaScript

​Quick Start

​Condition Types

​DictCondition

​ExpressionCondition

​FunctionCondition

​Condition Protocol

​Combining Conditions

​AND Conditions

​OR Conditions

​NOT Condition

​Evaluate Condition Helper

​Create Condition Factory

​Common Patterns

​Best Practices

​Related