quick/start

Lash is not on crates.io yet. Pull the crates straight from the monorepo by git URL:

[dependencies]
lash                 = { git = "https://github.com/SamGalanakis/lash.git" }
lash-provider-openai = { git = "https://github.com/SamGalanakis/lash.git" }
anyhow = "1"
tokio  = { version = "1", features = ["full"] }

Cargo resolves each name against packages inside that repo. Pin to a commit with rev = "..." or a tag with tag = "..." for reproducible builds.

For ordinary projects the bundled facade and provider crates cover the common ground. Drop down to lash-core only when you need runtime-host plumbing such as custom PluginHost instances or shared TokioSessionTaskExecutor values.

LashCore

Cloneable shared configuration: provider, model, installed modes, tools, plugins. One per app, cloned freely.

SessionSpec

Reusable session configuration overlay for provider, model, mode, prompt layer, max context tokens, and max turns. The ergonomic builder methods update the same spec.

PluginStack

Mutable list of plugin factories. LashCore::standard() and LashCore::rlm() start with the runtime defaults; LashCore::builder() is explicit and starts empty.

LashSession

One logical conversation or task, opened from a LashCore by a stable session id.

TurnInput

Semantic input to a turn — text plus image references. Use TurnInput::text(...) for the common case.

TurnBuilder

Per-turn configuration returned by session.turn(input). Call .run() for a collected result, .stream(&sink) for live events.

ProviderHandle

A typed adapter around a provider crate. lash_providers_builtin::register_all() wires the OpenAI / Anthropic / Codex / Google factories into the global registry once at process start.

use lash::{provider::ProviderHandle, LashCore, TurnEvent, TurnInput};
use lash_provider_openai::{OPENROUTER_BASE_URL, OpenAiCompatibleProvider};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Build a provider handle. Substitute your own creds + base URL.
    let api_key = std::env::var("OPENROUTER_API_KEY")?;
    let provider = ProviderHandle::new(
        OpenAiCompatibleProvider::new(api_key, OPENROUTER_BASE_URL).into_components(),
    );

    // One LashCore per app, cloned freely.
    let core = LashCore::standard()
        .provider(provider)
        .model("anthropic/claude-sonnet-4.6", None)
        .max_context_tokens(200_000)
        .build()?;

    // One session per chat / task.
    let session = core.session("hello-1").open().await?;

    // Run one turn; collect prose from the activity stream.
    let result = session
        .turn(TurnInput::text("Say hi in one short sentence."))
        .run()
        .await?;

    let prose: String = result.activities.iter().filter_map(|a| match &a.event {
        TurnEvent::AssistantProseDelta { text } => Some(text.as_str()),
        _ => None,
    }).collect();

    println!("{prose}");
    Ok(())
}

That's the whole flow: LashCore for shared configuration, LashSession for one logical conversation, TurnBuilder::run() for a single collected turn. Nothing more is required.