Skip to main content
Create flexible conditions for routing, filtering, and controlling agent workflow execution.

​
Quick Start

1

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
2

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

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";
}

​
API Reference

DictCondition

Dictionary-based condition

ExpressionCondition

Expression-based condition

​
Best Practices

For key-value comparisons, DictCondition is cleaner than custom functions.
Use andConditions and orConditions instead of nested if statements.
Use describe() to get human-readable condition descriptions.

Router Agent

Route requests to different agents

Workflows

Build complex agent workflows