Trait TaskNode 

pub trait TaskNode:
    Send
    + Sync
    + DynClone
    + Any {
    type Input: NodeArg;
    type Output: NodeArg;
    type Error: Error + Send + Sync + 'static;

    // Required method
    fn evaluate<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        node_id: &'life1 DynNodeId<Self>,
        input: &'life2 Self::Input,
    ) -> Pin<Box<dyn Future<Output = Result<Self::Output, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
}

A typed step in a Task.

Implement this trait for your own domain-specific nodes when you want full control over how a task step runs. For lightweight closure nodes, use Task::register_node_fn, or Task::register_node_async_fn for async closures.

Required Associated Types

type Input: NodeArg

The input accepted by this node.

type Output: NodeArg

The output produced by this node.

type Error: Error + Send + Sync + 'static

The error returned when evaluation fails.

Required Methods

fn evaluate<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, node_id: &'life1 DynNodeId<Self>, input: &'life2 Self::Input, ) -> Pin<Box<dyn Future<Output = Result<Self::Output, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Evaluates the node with the current input.

Trait Implementations

impl<Input: NodeArg, Output: NodeArg, Error: Error + Send + Sync + 'static> TaskNode for Box<dyn TaskNode<Input = Input, Output = Output, Error = Error>>

type Input = Input

The input accepted by this node.

type Output = Output

The output produced by this node.

type Error = Error

The error returned when evaluation fails.

fn evaluate<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, node_id: &'life1 NodeId<dyn TaskNode<Input = Self::Input, Output = Self::Output, Error = Self::Error>>, input: &'life2 Self::Input, ) -> Pin<Box<dyn Future<Output = Result<Self::Output, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Evaluates the node with the current input.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl TaskNode for Arc<dyn ChatCompletion>

type Input = ChatCompletionRequest<'static>

type Output = ChatCompletionResponse

type Error = LanguageModelError

fn evaluate<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _node_id: &'life1 NodeId<dyn TaskNode<Input = Self::Input, Output = Self::Output, Error = Self::Error>>, input: &'life2 Self::Input, ) -> Pin<Box<dyn Future<Output = Result<Self::Output, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

impl TaskNode for Arc<dyn SimplePrompt>

type Input = Prompt

type Output = String

type Error = LanguageModelError

fn evaluate<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _node_id: &'life1 NodeId<dyn TaskNode<Input = Self::Input, Output = Self::Output, Error = Self::Error>>, input: &'life2 Self::Input, ) -> Pin<Box<dyn Future<Output = Result<Self::Output, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

impl TaskNode for Arc<dyn ToolExecutor>

type Input = Command

type Output = CommandOutput

type Error = CommandError

fn evaluate<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _node_id: &'life1 NodeId<dyn TaskNode<Input = Self::Input, Output = Self::Output, Error = Self::Error>>, input: &'life2 Self::Input, ) -> Pin<Box<dyn Future<Output = Result<Self::Output, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

impl TaskNode for Box<dyn ChatCompletion>

type Input = ChatCompletionRequest<'static>

type Output = ChatCompletionResponse

type Error = LanguageModelError

fn evaluate<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _node_id: &'life1 NodeId<dyn TaskNode<Input = Self::Input, Output = Self::Output, Error = Self::Error>>, input: &'life2 Self::Input, ) -> Pin<Box<dyn Future<Output = Result<Self::Output, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

impl TaskNode for Box<dyn SimplePrompt>

type Input = Prompt

type Output = String

type Error = LanguageModelError

fn evaluate<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _node_id: &'life1 NodeId<dyn TaskNode<Input = Self::Input, Output = Self::Output, Error = Self::Error>>, input: &'life2 Self::Input, ) -> Pin<Box<dyn Future<Output = Result<Self::Output, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

impl TaskNode for Box<dyn ToolExecutor>

type Input = Command

type Output = CommandOutput

type Error = CommandError

fn evaluate<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _node_id: &'life1 NodeId<dyn TaskNode<Input = Self::Input, Output = Self::Output, Error = Self::Error>>, input: &'life2 Self::Input, ) -> Pin<Box<dyn Future<Output = Result<Self::Output, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

impl<Input: NodeArg, Output: NodeArg, Error: Error + Send + Sync + 'static> TaskNode for Box<dyn TaskNode<Input = Input, Output = Output, Error = Error>>

type Input = Input

type Output = Output

type Error = Error

fn evaluate<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, node_id: &'life1 NodeId<dyn TaskNode<Input = Self::Input, Output = Self::Output, Error = Self::Error>>, input: &'life2 Self::Input, ) -> Pin<Box<dyn Future<Output = Result<Self::Output, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Implementors

impl<F, I, O, E> TaskNode for AsyncFn<F, I, O, E>

where F: for<'a> Fn(&'a I) -> Pin<Box<dyn Future<Output = Result<O, E>> + Send + 'a>> + Clone + Send + Sync + 'static, I: NodeArg + Clone, O: NodeArg + Clone, E: Error + Send + Sync + 'static,

type Input = I

type Output = O

type Error = E

impl<F, I, O, E> TaskNode for SyncFn<F, I, O, E>

where F: Fn(&I) -> Result<O, E> + Clone + Send + Sync + 'static, I: NodeArg + Clone, O: NodeArg + Clone, E: Error + Send + Sync + 'static,

type Input = I

type Output = O

type Error = E