> ## Documentation Index
> Fetch the complete documentation index at: https://praison.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Conditions Module

> Create dynamic routing conditions for agent workflows

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

```mermaid theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
graph LR
    subgraph "Condition Evaluation"
        A[📥 Context] --> B{🔍 Condition}
        B -->|True| C[✅ Action A]
        B -->|False| D[❌ Action B]
    end
    
    classDef context fill:#6366F1,stroke:#7C90A0,color:#fff
    classDef condition fill:#F59E0B,stroke:#7C90A0,color:#fff
    classDef action fill:#10B981,stroke:#7C90A0,color:#fff
    
    class A context
    class B condition
    class C,D action
    classDef agent fill:#8B0000,color:#fff
    classDef tool fill:#189AB4,color:#fff
```

## Quick Start

**1. Create a Dictionary Condition**

```typescript theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
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**

```typescript theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
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

```mermaid theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
graph TB
    subgraph "Choose Your Condition Type"
        A{What do you need?}
        A -->|Key-value matching| B[📋 DictCondition]
        A -->|Expression evaluation| C[📝 ExpressionCondition]
        A -->|Custom logic| D[⚙️ FunctionCondition]
    end
    
    classDef question fill:#6366F1,stroke:#7C90A0,color:#fff
    classDef dict fill:#10B981,stroke:#7C90A0,color:#fff
    classDef expr fill:#F59E0B,stroke:#7C90A0,color:#fff
    classDef func fill:#189AB4,stroke:#7C90A0,color:#fff
    
    class A question
    class B dict
    class C expr
    class D func
```

### DictCondition

Match context values against expected values:

```typescript theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
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:

```typescript theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
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:

```typescript theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
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`:

```typescript theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
interface ConditionProtocol {
  evaluate(context: Record<string, any>): boolean | Promise<boolean>;
  describe(): string;
}
```

***

## Combining Conditions

### AND Conditions

```typescript theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
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

```typescript theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
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

```typescript theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
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

```typescript theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
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

```typescript theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
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

> [tab] Routing Condition
>
> ```typescript theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
> 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";
> }
> ```

> [tab] Validation
>
> ```typescript theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
> 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);
> }
> ```

> [tab] Feature Flags
>
> ```typescript theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
> 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

> [card] [DictCondition](https://praison.ai/docs/sdk/reference/typescript/classes/DictCondition.md)
>
> Dictionary-based condition

> [card] [ExpressionCondition](https://praison.ai/docs/sdk/reference/typescript/classes/ExpressionCondition.md)
>
> Expression-based condition

***

## Best Practices

> [accordion] Use DictCondition for simple matching
>
> For key-value comparisons, `DictCondition` is cleaner than custom functions.

> [accordion] Combine conditions for complex logic
>
> Use `andConditions` and `orConditions` instead of nested if statements.

> [accordion] Add descriptions for debugging
>
> Use `describe()` to get human-readable condition descriptions.

***

## Related

> [card] [Router Agent](https://praison.ai/docs/js/router-agent.md)
>
> Route requests to different agents

> [card] [Workflows](https://praison.ai/docs/js/workflows.md)
>
> Build complex agent workflows


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.