Struct DefaultSkillExecutor 

pub struct DefaultSkillExecutor<T, H = NoOpHooks> { /* private fields */ }

Default skill executor that uses a Transport to execute tool calls.

This executor implements the standard skill execution flow:

1. Execute steps sequentially
2. Apply timeout and retry logic per step
3. Propagate outputs from earlier steps to later steps
4. Invoke lifecycle hooks at appropriate points

Type Parameters

• T - The transport type for executing tool calls
• H - The hooks type for lifecycle callbacks (defaults to NoOpHooks)

Example

use thulp_skills::{DefaultSkillExecutor, ExecutionContext, TracingHooks};

// With default no-op hooks
let executor = DefaultSkillExecutor::new(transport);

// With tracing hooks
let executor = DefaultSkillExecutor::with_hooks(transport, TracingHooks::new());

let mut context = ExecutionContext::new()
    .with_input("query", json!("test"));

let result = executor.execute(&skill, &mut context).await?;

Implementations

impl<T: Transport> DefaultSkillExecutor<T, NoOpHooks>

pub fn new(transport: T) -> Self

Create a new executor with the given transport and no-op hooks.

impl<T: Transport, H: ExecutionHooks> DefaultSkillExecutor<T, H>

pub fn with_hooks(transport: T, hooks: H) -> Self

Create a new executor with the given transport and hooks.

pub fn from_arcs(transport: Arc<T>, hooks: Arc<H>) -> Self

Create a new executor from Arc-wrapped transport and hooks.

This is useful when you want to share the transport or hooks across multiple executors.

pub fn transport(&self) -> &T

Get a reference to the transport.

pub fn hooks(&self) -> &H

Get a reference to the hooks.

Trait Implementations

impl<T: Transport, H: ExecutionHooks> SkillExecutor for DefaultSkillExecutor<T, H>

fn execute<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, skill: &'life1 Skill, context: &'life2 mut ExecutionContext, ) -> Pin<Box<dyn Future<Output = Result<SkillResult, SkillError>> + Send + 'async_trait>>

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

Execute a complete skill.

fn execute_step<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, step: &'life1 SkillStep, context: &'life2 mut ExecutionContext, ) -> Pin<Box<dyn Future<Output = Result<StepResult, SkillError>> + Send + 'async_trait>>

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

Execute a single step.