Crate everruns_runtime

Expand description

Public in-process runtime for embedding Everruns.

The runtime crate exposes an in-memory execution surface that runs the same core atoms (input, reason, act) used elsewhere in the system, but without the durable engine, gRPC worker boundary, or control-plane server. It is part of the Everruns ecosystem.

This is the intended public entrypoint for embedders who want to:

run sessions in their own process
provide their own platform definition (capabilities, drivers, harnesses)
seed harnesses, agents, sessions, and workspace files directly in code
replace the default in-memory stores with custom runtime backends
inspect the assembled turn context before or after executing a turn
reuse runtime-owned host phase execution from durable or server-backed hosts
map plan_next_host_turn(...) onto their own queue, retry, or in-memory host

For a runnable example, see:

cargo run -p everruns-runtime --example in_process_runtime
cargo run -p everruns-runtime --example inspect_context

§Example

use everruns_core::{
    CapabilityRegistry, DriverRegistry, InputMessage, LlmProviderType, ModelWithProvider,
    PlatformDefinition,
};
use everruns_core::capabilities::TestMathCapability;
use everruns_runtime::InProcessRuntimeBuilder;

let mut capabilities = CapabilityRegistry::new();
capabilities.register(TestMathCapability);

let platform = PlatformDefinition::new(capabilities, DriverRegistry::new());

let runtime = InProcessRuntimeBuilder::new()
    .platform_definition(platform)
    .single_session(|s| {
        s.harness("math", "You are a calculator.")
            .harness_display_name("Math")
            .with_capability("test_math")
            .agent("math-agent", "Use tools when needed.")
            .agent_display_name("Math Agent")
            .agent_max_iterations(8)
            .session_title("Math Session")
    })
    .llm_sim(everruns_core::llmsim_driver::LlmSimConfig::fixed("4"))
    .default_model(ModelWithProvider {
        model: "llmsim-model".into(),
        provider_type: LlmProviderType::LlmSim,
        api_key: Some("fake-key".into()),
        base_url: None,
    })
    .build()
    .await?;

let session_id = runtime.default_session_id().expect("single_session id");
let result = runtime
    .run_turn(
        session_id,
        InputMessage::user("What is 2 + 2?"),
    )
    .await?;
assert!(result.success);

§Real-disk workspace

Embedders who want built-in capabilities (file_system, agent_instructions, skills, …) to read and write a real directory on disk can configure RealDiskSessionFileSystemFactory on their PlatformDefinition. Every capability that goes through ToolContext.file_store or SystemPromptContext.file_store picks it up automatically.

See the runnable examples for the full wiring:

cargo run -p everruns-runtime --example real_disk_agent_instructions
cargo run -p everruns-runtime --example real_disk_file_system_tools

And specs/file-store.md for the trait contract.

Structs§

AgentBuilder: Builds an Agent with runtime-friendly defaults.
ApprovalGatingFileStore: Gate destructive operations through an embedder-supplied FileApprovalGate. Reads pass through.
AssembledTurnContext: Public snapshot of the assembled turn context used by reason-phase hosts.
HarnessBuilder: Builds a Harness with runtime-friendly defaults.
InMemorySessionFileStore: In-memory implementation of the session virtual filesystem.
InMemorySessionFileSystemFactory: Factory for the runtime’s in-memory session filesystem.
InMemorySessionStorageStore: In-memory implementation of session key/value and secret storage.
InMemorySessionStore: In-memory SessionStore + SessionMutator for embedded runtimes.
InProcessRuntime: Public in-process runtime backed by either in-memory or custom stores.
InProcessRuntimeBuilder: Builder for the public in-process runtime.
RealDiskFileStore: A SessionFileSystem rooted at a real host directory.
RealDiskSessionFileSystemFactory: Factory for real-disk session files rooted at a fixed host directory.
RuntimeActPlan: Runtime-owned act scheduling payload.
RuntimeBackends: Non-filesystem backend bundle supplied to the embedded runtime.
RuntimeHostTurnContext: Turn context loaded in one batched call for runtime host execution.
RuntimeSessionLifecycle: Shared lifecycle helper for runtime-backed hosts.
RuntimeTurnState: Host-owned state carried across turn phases.
SessionBuilder: Builds a Session with runtime-friendly defaults.
SingleSessionBuilder: High-level builder for seeding one harness, one agent, and one session.
TurnResult
WriteBlocklistFileStore: Reject writes into vendored / build directories at any depth.

Enums§

RuntimeTurnPlan: Generic next-step decision for a host turn.

Constants§

DEFAULT_WRITE_BLOCKLIST: Default vendored / build directory names that WriteBlocklistFileStore rejects writes into. Embedders can override via with_blocklist.

Traits§

EventBus: Event sink that supports emission and optional collection.
FileApprovalGate: Embedder-supplied approval callback used by ApprovalGatingFileStore.
RuntimeAgentStore: Agent store contract for runtime seeding and lookup.
RuntimeHarnessStore: Harness store contract for runtime seeding and lookup.
RuntimeHostAdapter: Public adapter contract for server-backed or durable runtime hosts.
RuntimeMessageStore: Message store contract for runtime persistence and lookup.
RuntimeProviderStore: Provider store contract for runtime lookup and default-model configuration.
RuntimeSessionStore: Session store contract for runtime seeding, lookup, and mutation.

Functions§

detect_dependency_blocker
execute_act_activity
execute_input_activity
execute_reason_activity
plan_next_host_turn: Determine the next host step after an activity finishes.