Struct InMemoryAgenticLoop 

pub struct InMemoryAgenticLoop { /* private fields */ }

In-memory agentic loop for testing and prototyping

Bundles all in-memory stores and atoms into a convenient interface for running agent turns without external dependencies.

Example

use everruns_core::in_memory_loop::InMemoryAgenticLoop;

// Simple usage with simulated LLM
let mut loop_runner = InMemoryAgenticLoop::builder()
    .system_prompt("You are a helpful assistant.")
    .with_simulated_response("Hello! I can help you with that.")
    .build()
    .await?;

let result = loop_runner.run_turn("Hi there!").await?;
assert!(result.success);
println!("Response: {}", result.response);

// With real LLM (requires API key)
let mut loop_runner = InMemoryAgenticLoop::builder()
    .with_real_llm()
    .tool(MyCustomTool)
    .build()
    .await?;

Implementations

impl InMemoryAgenticLoop

pub fn builder() -> InMemoryAgenticLoopBuilder

Create a new builder

pub fn agent_id(&self) -> AgentId

Get the agent ID

pub fn session_id(&self) -> SessionId

Get the session ID

pub async fn run_turn( &self, input: impl Into<InputMessage>, ) -> Result<TurnResult>

Run a turn with the given user input

Accepts either a string or an InputMessage for full control over message options like reasoning effort.

This executes the full agentic loop using the TurnStateMachine:

1. Add user message
2. Record input (InputAtom)
3. Reason loop (ReasonAtom → ActAtom → repeat until done)

The TurnStateMachine ensures consistent orchestration logic, proper error handling (checking success flag), and turn ID management.

Examples

// Simple string input
let result = runner.run_turn("Hello").await?;

// Full InputMessage with controls
let input = InputMessage {
    role: MessageRole::User,
    content: vec![ContentPart::text("What is 2+2?")],
    controls: Some(Controls {
        model_id: None,
        reasoning: Some(ReasoningConfig { effort: Some("medium".into()) }),
    }),
    metadata: None,
    tags: vec![],
};
let result = runner.run_turn(input).await?;

pub async fn run_conversation( &self, messages: &[&str], ) -> Result<Vec<TurnResult>>

Run multiple turns in sequence

pub async fn messages(&self) -> Result<Vec<Message>>

Get all messages in the session

pub async fn events(&self) -> Vec<Event>

Get all emitted events

pub async fn events_by_type(&self, event_type: &str) -> Vec<Event>

Get events of a specific type

pub async fn message_count(&self) -> Result<usize>

Get the count of messages

pub async fn event_count(&self) -> usize

Get the count of events

pub async fn clear_events(&self)

Clear all events (useful between tests)

pub async fn clear_messages(&self)

Clear all messages (starts a fresh conversation)

pub async fn reset(&self)

Reset the loop (clear messages and events)

pub async fn conversation_string(&self) -> Result<String>

Get conversation as a formatted string

pub fn message_retriever(&self) -> &InMemoryMessageRetriever

Access the message retriever directly

pub fn tool_registry(&self) -> &ToolRegistry

Access the tool registry directly

impl InMemoryAgenticLoop

pub async fn with_fixed_response(response: impl Into<String>) -> Result<Self>

Create a simple loop with a fixed simulated response

Example

let runner = InMemoryAgenticLoop::with_fixed_response("Hello!").await?;
let result = runner.run_turn("Hi").await?;
assert_eq!(result.response, "Hello!");

pub async fn with_echo() -> Result<Self>

Create a loop that echoes user input

Example

let runner = InMemoryAgenticLoop::with_echo().await?;
let result = runner.run_turn("Hello").await?;
assert!(result.response.contains("Hello"));

pub async fn with_sequence(responses: Vec<impl Into<String>>) -> Result<Self>

Create a loop with sequence of responses

Example

let runner = InMemoryAgenticLoop::with_sequence(vec![
    "First response",
    "Second response",
]).await?;

let r1 = runner.run_turn("msg1").await?;
let r2 = runner.run_turn("msg2").await?;
assert_eq!(r1.response, "First response");
assert_eq!(r2.response, "Second response");

pub async fn with_tool_calls( response: impl Into<String>, tool_calls: Vec<ToolCall>, ) -> Result<Self>

Create a loop with tool call simulation

Example

use everruns_core::ToolCall;
use serde_json::json;

let tool_call = ToolCall {
    id: "call_1".to_string(),
    name: "get_weather".to_string(),
    arguments: json!({"city": "NYC"}),
};

let runner = InMemoryAgenticLoop::with_tool_calls(
    "Let me check that.",
    vec![tool_call],
).await?;