Struct AgentLoop 

pub struct AgentLoop<Phase: AgentPhase> {
    pub state: LoopState,
    pub config: LoopConfig,
    /* private fields */
}

The agent loop in a specific phase.

Each phase transition consumes self and produces the next phase, making invalid transitions a compile error.

Fields

state: LoopState

Mutable loop state carried across phases.

config: LoopConfig

Immutable loop configuration.

Implementations

impl AgentLoop<Reasoning>

pub fn new(state: LoopState, config: LoopConfig) -> Self

Create a new agent loop in the Reasoning phase.

pub async fn produce_output( self, provider: &dyn InferenceProvider, context_manager: &dyn ContextManager, ) -> Result<AgentLoop<PolicyCheck>, LoopTermination>

Run the reasoning step: invoke the inference provider and parse actions.

Consumes self and produces AgentLoop<PolicyCheck>.

impl AgentLoop<PolicyCheck>

pub fn proposed_actions(&self) -> Vec<ProposedAction>

Return a clone of the proposed actions from the reasoning phase. Used by the loop driver to emit ReasoningComplete journal events before the policy check consumes the data.

pub async fn check_policy( self, gate: &dyn ReasoningPolicyGate, ) -> Result<AgentLoop<ToolDispatching>, LoopTermination>

Evaluate all proposed actions against the policy gate.

Consumes self and produces AgentLoop<ToolDispatching>.

impl AgentLoop<ToolDispatching>

pub fn policy_summary(&self) -> (usize, usize)

Return (action_count, denied_count) from the policy phase.

pub async fn dispatch_tools( self, executor: &dyn ActionExecutor, circuit_breakers: &CircuitBreakerRegistry, ) -> Result<AgentLoop<Observing>, LoopTermination>

Dispatch approved actions through the executor.

Consumes self and produces AgentLoop<Observing>.

impl AgentLoop<Observing>

pub fn observation_count(&self) -> usize

Return observation count from the dispatch phase. Used by the loop driver to emit ObservationsCollected journal events.

pub fn observe_results(self) -> LoopContinuation

Collect observations and decide whether to continue or terminate.

Consumes self and returns either a new Reasoning phase or the final result.