Struct LoopDetectionSimCase 

pub struct LoopDetectionSimCase {
    pub n_steps: usize,
    pub looping_tool: String,
    pub loop_starts_at: usize,
    pub window_size: usize,
    pub expect_detection: bool,
    /* private fields */
}

Simulates a sequence of tool calls and checks that the loop detection algorithm fires at the expected iteration.

Models the exact VecDeque-based sliding-window logic used in TaskAgent::execute(): when the last window_size tool calls all share the same name, a loop is detected.

Fields

n_steps: usize

Total number of simulated tool-call steps.

looping_tool: String

Name of the tool that will be repeated to trigger the loop.

loop_starts_at: usize

At which step the looping tool starts repeating (1-based).

window_size: usize

Window size used by the loop detector. Default: 5.

expect_detection: bool

Whether the test expects detection to fire (true = a loop IS expected).

Implementations

impl LoopDetectionSimCase

pub fn should_detect( n_steps: usize, looping_tool: impl Into<String>, loop_starts_at: usize, window_size: usize, ) -> Self

Create a scenario that expects the loop detector to fire.

The looping tool repeats from loop_starts_at to the end of the n_steps sequence.

pub fn should_not_detect(n_steps: usize, window_size: usize) -> Self

Create a scenario that expects the loop detector NOT to fire (diverse enough tool sequence).

Trait Implementations

impl Clone for LoopDetectionSimCase

fn clone(&self) -> LoopDetectionSimCase

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LoopDetectionSimCase

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

Formats the value using the given formatter.

impl EvaluationCase for LoopDetectionSimCase

fn name(&self) -> &str

Short identifier used in reports and log output.

fn category(&self) -> &str

Category label for grouping (e.g. "smoke", "adversarial", "budget_stress").

fn run<'life0, 'async_trait>( &'life0 self, trial_id: usize, ) -> Pin<Box<dyn Future<Output = Result<TrialResult>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Execute one trial and return its result.