Struct DirectProviderActionExecutor 

pub struct DirectProviderActionExecutor { /* private fields */ }

Backward-compatible GraphActionExecutor that directly calls provider + tools.

This is the “no AgentLoop integration” path — used when StateGraphExecutor is constructed via with_direct_provider(). It mimics the original behavior:

• LlmInfer: calls provider.infer() with a basic request (no hooks, no domain pack)
• ToolCall: calls tool.execute() directly (no permission, no hooks)
• SwitchParadigm: updates state.active_paradigm (no paradigm config)
• parse_decision: simple ContentBlock-based parsing

For full AgentLoop integration, use AgentLoopGraphActionExecutor from oneai-agent.

Implementations

impl DirectProviderActionExecutor

pub fn new( provider: Arc<dyn LlmProvider>, tools: Arc<RwLock<HashMap<String, Arc<dyn Tool>>>>, ) -> Self

Create a new direct executor with provider and tools.

pub fn with_permission_resolver( self, resolver: Arc<dyn PermissionResolver>, ) -> Self

Attach a domain permission resolver so ToolCall nodes honour DomainPack deny_by_default policy on this stateless path too.

Trait Implementations

impl GraphActionExecutor for DirectProviderActionExecutor

fn execute_llm_infer<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, action: &'life1 NodeAction, state: &'life2 mut GraphState, ) -> Pin<Box<dyn Future<Output = Result<ActionResult>> + Send + 'async_trait>>

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

Execute an LLM inference node — using full AgentLoop infrastructure.

fn execute_tool_call<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, tool_name: &'life1 str, args: &'life2 Value, state: &'life3 mut GraphState, ) -> Pin<Box<dyn Future<Output = Result<ActionResult>> + Send + 'async_trait>>

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

Execute a tool call node — using AgentLoop’s permission and hooks.

fn execute_paradigm_switch<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, paradigm: &'life1 str, state: &'life2 mut GraphState, ) -> Pin<Box<dyn Future<Output = Result<ActionResult>> + Send + 'async_trait>>

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

Execute a paradigm switch node.

fn parse_decision<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, response: &'life1 InferenceResponse, state: &'life2 mut GraphState, ) -> Pin<Box<dyn Future<Output = Result<GraphDecision>> + Send + 'async_trait>>

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

Parse an LLM response into a GraphDecision.