Documentation Index
Fetch the complete documentation index at: https://docs.praison.ai/llms.txt
Use this file to discover all available pages before exploring further.
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: "user@example.com" }
};
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();
}
API Reference
DictCondition
Dictionary-based condition
ExpressionCondition
Expression-based condition
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
