execution/runtime

Background work (subagents and async tool calls) is described in Background Work below. Either protocol can spawn handles when a process registry is installed; RLM additionally discovers visible runs via processes.list and resolves handles with await.

LashCore

Cloneable shared core: runtime env, default session policy, one protocol plugin, effect host, session store factory, attachment store, trace sink, residency, and termination policy. Use LashCore::standard_builder() or LashCore::rlm_builder(factory) for built-in protocols; use LashCore::builder() only with an explicit custom protocol plugin.

LashCore::rlm_builder(factory)

Sugar entry point that installs the RLM protocol and Lashlang process engine from a host-configured RlmProtocolPluginFactory (projection resolver, deferred tool resolver, and a required Lashlang artifact store), plus the default runtime plugin stack.

LashSession

One conversation. Parked/resumable handle exposing run(...), turn(...), read_view(), observe(), and admin(). Carries an optional parent session id.

TurnBuilder

Per-turn config: cancellation token, mode options, plugin input, RLM bindings. .stream_to(&sink) drives against a TurnActivitySink; .stream() returns a pull-style futures_util::Stream; .run() returns a TurnOutput with terminal result and ordered activities.

TurnInput

Text plus image refs. Hosts resolve UI syntax like @path before constructing the turn.

TurnActivity

Semantic activity records with stable ids and correlation ids. Raw session events are runtime/tracing internals.

SessionObservation

Current session read view plus opaque cursor. Recent session observation events can be replayed for reconnect; persistent hosts should use subscribe_and_recover, which yields recoverable live replay gaps and resubscribes from the latest cursor.

let core = lash::LashCore::standard_builder()
    .provider(provider)
    .model(
        lash::ModelSpec::from_token_limits("anthropic/claude-sonnet-4.6", None, 200_000, None)
            .expect("valid model metadata"),
    )
    .store_factory(store_factory)
    .effect_host(std::sync::Arc::new(
        lash::durability::InlineEffectHost::default(),
    ))
    .attachment_store(std::sync::Arc::new(
        lash::persistence::FileAttachmentStore::new(data_dir.join("attachments")),
    ))
    .build()?;

let session = core.session(chat_id).open().await?;
let result = session
    .turn(TurnInput::text(user_text))
    .stream_to(&events)
    .await?;

The public subagent entry is lash_subagents::spawn_agent_tool_definition; the per-session RlmSubagentToolsProvider is crate-private. Generic process admins expose processes.list and processes.cancel, while start <tool> is the single way to run any ordinary tool as a durable process. A child can fail terminally with await tools.submit_error({ reason: reason })? (defined in lash-subagents), which surfaces back to the parent through the spawn_agent result.