Struct InMemoryAgenticLoopBuilder 

pub struct InMemoryAgenticLoopBuilder { /* private fields */ }

Builder for creating an InMemoryAgenticLoop

Implementations

impl InMemoryAgenticLoopBuilder

pub fn new() -> Self

Create a new builder with defaults (uses simulated LLM)

pub fn reasoning_effort_handle(self, handle: ReasoningEffortHandle) -> Self

Share a live reasoning-effort handle (EVE-595) across the loop’s ReasonAtom and ActAtom. Tools receive a clone via their ToolContext and can mutate it mid-turn so subsequent LLM steps in the same run_turn observe the new effort.

pub fn agent_name(self, name: impl Into<String>) -> Self

Set the agent name

pub fn system_prompt(self, prompt: impl Into<String>) -> Self

Set the system prompt

pub fn with_simulated_response(self, response: impl Into<String>) -> Self

Use a simulated LLM with a fixed response (no real API calls)

pub fn with_llm_sim(self, config: LlmSimConfig) -> Self

Use a simulated LLM with custom configuration

pub fn model(self, model: ResolvedModel) -> Self

Set the LLM model to use

Example

use everruns_core::traits::ResolvedModel;
use everruns_core::provider::DriverId;

let model = ResolvedModel {
    model: "claude-sonnet-4-20250514".to_string(),
    provider_type: DriverId::Anthropic,
    api_key: Some(std::env::var("ANTHROPIC_API_KEY").unwrap()),
    base_url: None,
};

let runner = InMemoryAgenticLoop::builder()
    .model(model)
    .driver_registry(driver_registry)
    .build()
    .await?;

pub fn driver_registry(self, driver_registry: DriverRegistry) -> Self

Set the driver registry for LLM providers

Example

use everruns_core::driver_registry::DriverRegistry;

let mut driver_registry = DriverRegistry::new();
everruns_anthropic::register_driver(&mut driver_registry);

let runner = InMemoryAgenticLoop::builder()
    .model(model)
    .driver_registry(driver_registry)
    .build()
    .await?;

pub fn tool<T: Tool + 'static>(self, tool: T) -> Self

Add a tool

pub fn capability<C: Capability + 'static>(self, capability: C) -> Self

Add a capability (which may provide tools and system prompt additions)

Capabilities provide a way to bundle related tools and functionality. For example, the current_time capability provides a get_current_time tool.

Example

use everruns_core::capabilities::current_time::CurrentTimeCapability;

let runner = InMemoryAgenticLoop::builder()
    .capability(CurrentTimeCapability)
    .build()
    .await?;

pub fn max_iterations(self, max: usize) -> Self

Set maximum iterations per turn

pub fn parallel_tool_calls(self, parallel_tool_calls: Option<bool>) -> Self

Set the request-level parallel tool calling preference (EVE-598).

Some(true) signals the provider that parallel tool calls are wanted; Some(false) requests at most one tool call per turn and forces serial execution. None (default) preserves provider defaults.

pub async fn build(self) -> Result<InMemoryAgenticLoop>

Build the agentic loop

Trait Implementations

impl Default for InMemoryAgenticLoopBuilder

fn default() -> Self

Returns the “default value” for a type.