Enum ToolExpr 

pub enum ToolExpr {
    Call {
        tool: String,
        args: Value,
    },
    Sequence {
        steps: Vec<ToolExpr>,
        fail_fast: bool,
    },
    Parallel {
        branches: Vec<ToolExpr>,
        wait: ParallelWait,
    },
    Choice {
        condition: Condition,
        then_branch: Box<ToolExpr>,
        else_branch: Option<Box<ToolExpr>>,
    },
    Retry {
        expr: Box<ToolExpr>,
        max_attempts: u32,
        delay_ms: u64,
    },
    Let {
        var: String,
        expr: Box<ToolExpr>,
        body: Box<ToolExpr>,
    },
    Var(String),
}

Tool expression DSL for composing tool calls

This enum represents the AST (Abstract Syntax Tree) for the tool composition DSL. Each variant represents a different composition operation.

Variants

Call

Execute a single tool call

Fields

tool: String

Name of the tool to execute

args: Value

Arguments to pass to the tool (JSON object)

Sequence

Execute a sequence of expressions

Fields

steps: Vec<ToolExpr>

Steps to execute in order

fail_fast: bool

Whether to stop on first error (default: true)

Parallel

Execute branches in parallel

Fields

branches: Vec<ToolExpr>

Branches to execute concurrently

wait: ParallelWait

Wait strategy: All, First, or Any

Choice

Conditional execution

Fields

condition: Condition

Condition to evaluate

then_branch: Box<ToolExpr>

Expression to execute if condition is true

else_branch: Option<Box<ToolExpr>>

Expression to execute if condition is false

Retry

Retry with backoff

Fields

expr: Box<ToolExpr>

Expression to retry

max_attempts: u32

Maximum number of retry attempts (default: 3)

delay_ms: u64

Delay between retries in milliseconds (default: 1000)

Let

Variable binding

Fields

var: String

Variable name

expr: Box<ToolExpr>

Expression to bind

body: Box<ToolExpr>

Body expression that uses the variable

Var(String)

Variable reference

Implementations

impl ToolExpr

pub fn call(tool: impl Into<String>, args: Value) -> Self

Create a simple tool call expression

pub fn sequence(steps: Vec<ToolExpr>) -> Self

Create a sequence expression with fail_fast=true

pub fn sequence_with_fail_fast(steps: Vec<ToolExpr>, fail_fast: bool) -> Self

Create a sequence expression with custom fail_fast

pub fn parallel(branches: Vec<ToolExpr>) -> Self

Create a parallel expression

pub fn parallel_with_wait(branches: Vec<ToolExpr>, wait: ParallelWait) -> Self

Create a parallel expression with custom wait strategy

pub fn choice(condition: Condition, then_branch: ToolExpr) -> Self

Create a conditional expression

pub fn choice_with_else( condition: Condition, then_branch: ToolExpr, else_branch: ToolExpr, ) -> Self

Create a conditional expression with else branch

pub fn retry(expr: ToolExpr) -> Self

Create a retry expression with defaults

pub fn retry_with_params( expr: ToolExpr, max_attempts: u32, delay_ms: u64, ) -> Self

Create a retry expression with custom parameters

pub fn let_binding( var: impl Into<String>, expr: ToolExpr, body: ToolExpr, ) -> Self

Create a let binding expression

pub fn var(name: impl Into<String>) -> Self

Create a variable reference

pub fn to_yaml(&self) -> Result<String, Error>

Serialize to YAML string

pub fn from_yaml(yaml: &str) -> Result<Self, Error>

Deserialize from YAML string

pub fn to_json(&self) -> Result<String, Error>

Serialize to JSON string

pub fn from_json(json: &str) -> Result<Self, Error>

Deserialize from JSON string

Trait Implementations

impl Clone for ToolExpr

fn clone(&self) -> ToolExpr

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ToolExpr

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ToolExpr

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ToolExpr

fn eq(&self, other: &ToolExpr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ToolExpr

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ToolExpr