Enum LoopInterrupt 

pub enum LoopInterrupt {
    ApprovalRequest(PendingApproval),
    AwaitingInput(InputRequest),
    AfterToolResult(ToolRoundInfo),
}

An interrupt that pauses the agent loop until the host resolves it.

The loop returns an interrupt inside LoopStep::Interrupt whenever it cannot proceed autonomously. Each variant carries a handle with resolution methods so callers can resolve the interrupt directly.

Example

use agentkit_loop::{LoopInterrupt, LoopStep};

match driver.next().await? {
    LoopStep::Interrupt(LoopInterrupt::ApprovalRequest(pending)) => {
        println!("Tool {} needs approval: {}", pending.request.request_kind, pending.request.summary);
        pending.approve(driver)?;
    }
    LoopStep::Interrupt(LoopInterrupt::AwaitingInput(pending)) => {
        println!("Waiting for input: {}", pending.reason);
        // ... call pending.submit(driver, items)
    }
    LoopStep::Interrupt(LoopInterrupt::AfterToolResult(info)) => {
        // Cooperative yield between tool rounds.  Optionally call
        // driver.submit_input(...) to interject a user message, then
        // call driver.next() to resume the turn.
        let _ = info;
    }
    LoopStep::Finished(result) => {
        println!("Turn finished: {:?}", result.finish_reason);
    }
}

Variants

ApprovalRequest(PendingApproval)

A tool call requires explicit approval before it can execute.

AwaitingInput(InputRequest)

The driver has no pending input and needs the host to supply some.

AfterToolResult(ToolRoundInfo)

A tool round finished: all tool calls from the previous assistant message now have results in the transcript, and the driver is about to invoke the model again. The host may interject user messages via the ToolRoundInfo::submit handle before calling LoopDriver::next to resume.

This is a non-blocking interrupt: callers that do not care about mid-turn interjection can treat it as a no-op (_ => continue) and the next next() call resumes the turn.

Implementations

impl LoopInterrupt

pub fn is_blocking(&self) -> bool

Returns true if the interrupt must be explicitly resolved before the loop can make progress. Approvals are blocking; AwaitingInput and AfterToolResult are cooperative and can be ignored by calling LoopDriver::next again.

Trait Implementations

impl Clone for LoopInterrupt

fn clone(&self) -> LoopInterrupt

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LoopInterrupt

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LoopInterrupt

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for LoopInterrupt

fn eq(&self, other: &LoopInterrupt) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for LoopInterrupt

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for LoopInterrupt

impl StructuralPartialEq for LoopInterrupt