swiftide_agents::tasks::node

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

Required Associated Types§

type Input: NodeArg

type Output: NodeArg

type Error: Error + Send + Sync + 'static

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,

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

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,

Implementations on Foreign Types§

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 TaskNode for Box<dyn ChatCompletion>

type Input = ChatCompletionRequest

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 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 Arc<dyn ChatCompletion>

type Input = ChatCompletionRequest

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<I: NodeArg, O: NodeArg, E: Error + Send + Sync + 'static> TaskNode for fn(&I) -> Result<O, E>

type Input = I

type Output = O

type Error = E

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 TaskNode for TaskAgent

A ‘default’ implementation for an agent where there is no output

TODO: Make this nicer :))

type Input = Prompt

type Output = ()

type Error = AgentError

impl<Context: NodeArg + Clone> TaskNode for NoopNode<Context>

type Output = ()

type Input = Context

type Error = NodeError

impl<F, I, O> TaskNode for SyncClosureTaskNode<F, I, O>
where F: Fn(&I) -> Result<O, NodeError> + Clone + Send + Sync + 'static, I: NodeArg + Clone, O: NodeArg + Clone,

type Input = I

type Output = O

type Error = NodeError