Features

Runtime   discover · probe · open · generate · plan_usage
Session   prompt · answer · configure · cancel · rollback · compact · close
Events    text · tools · plans · requests · status · usage · turn boundaries

let report = runtime.discover().await;
for agent in &report.agents {
    println!("{} at {}", agent.name, agent.executable_path.display());
}
for missing in &report.missing {
    println!("{} not installed: {}", missing.name, missing.install_hint);
}
let agent = report.require("claude")?;   // AgentError::NotInstalled if absent

let details = runtime.probe(&agent).await?;
match &details.auth {
    AuthStatus::Authenticated { kind, account } => {}       // Subscription | ApiKey | CloudProvider
    AuthStatus::Unauthenticated { login } => {
        for method in login {
            match method {
                LoginMethod::Terminal { command, .. } => ui.show_command(command),  // e.g. ["claude", "auth", "login"]
                LoginMethod::EnvVar { name } => ui.show_env_var(name),
                _ => {}
            }
        }
    }
    AuthStatus::Unknown => {}
}

let (session, events) = runtime
    .open(&agent, SessionOptions::in_dir("/path/to/repo"))
    .await?;

let delivery = session
    .prompt(Input::text("what's wrong here?").attach("screenshot.png"))
    .await?;
match delivery.kind {
    DeliveryKind::Started { turn_id } => {}      // session was idle; a turn began
    DeliveryKind::Steered { turn_id } => {}      // a turn was running; this went into it
    DeliveryKind::Queued { position } => {}      // a turn was running; this waits its turn
}

EventKind::RequestOpened(Request::Permission(r)) => {
    // r.tool is the ToolUpdate awaiting approval; r.options is what the agent accepts
    session.answer(r.id, Answer::Permission(PermissionChoice::AllowOnce)).await?;
}
EventKind::RequestOpened(Request::Question(r)) => {
    // one QuestionAnswer per question, in order; Choices(ids) or Text(string)
    let answers = r.questions.iter().map(|q| QuestionAnswer::Choices(vec![q.choices[0].id.clone()])).collect();
    session.answer(r.id, Answer::Question(answers)).await?;
}
EventKind::RequestClosed { request_id } => ui.clear(request_id),

session.cancel(false).await?;   // stop the turn, keep queued prompts
session.cancel(true).await?;    // stop the turn, drop the queue too
session.cancel_turn(turn_id, false).await?;  // only if that turn is still running

// at open: creation-only and live options alike
let options = SessionOptions::in_dir(".").configure("model", "sonnet").configure("effort", "low");

// mid-session: options with `live: true`
session.configure("fast", true).await?;

EventKind::StatusChanged(status) => ui.set_badge(thread, status),
let now = session.status();    // for a component that mounts late

let title = runtime
    .generate(&agent, SessionOptions::in_dir("."), "a five-word title for: fix the parser")
    .await?;

let token = session.info().resume_token.clone().unwrap();   // grab it while alive
// later, any process
let (session, events) = runtime
    .open(&agent, SessionOptions::in_dir(".").resume(token))
    .await?;

let options = SessionOptions::in_dir(".").fork_from(token, Some(message_id));  // None = from the end
let (branch, branch_events) = runtime.open(&agent, options).await?;

session.rollback(NonZeroU32::new(2).unwrap(), RollbackScope::Conversation).await?;
session.rollback(NonZeroU32::new(1).unwrap(), RollbackScope::ConversationAndFiles).await?;

session.compact().await?;

EventKind::ToolUpdated(tool) if tool.kind == ToolKind::Subagent => ui.open_child(tool.id),
// every event the child produces:
let parent = event.turn_info.as_ref().and_then(|t| t.parent_tool_id.clone());

let usage = runtime.plan_usage(&agent).await?;        // plan name, 5-hour and weekly windows, banked resets
let work = runtime.plan_usage_with(&agent, SessionOptions::in_dir(".").config_home("/logins/work")).await?;
for entry in runtime.plan_usage_all().await {          // every installed agent, for a dashboard
    ui.card(&entry.agent.name, entry.usage);
}

let options = SessionOptions::in_dir(".")
    .mcp_server(McpServer::stdio("local", "/usr/bin/my-server", ["--stdio"]))
    .mcp_server(McpServer::http("remote", "https://example.com/mcp").with("Authorization", "Bearer …"))
    .mcp_server(McpServer::sse("stream", "https://example.com/sse"));

SessionOptions::in_dir(".").record_wire("/tmp/claude.jsonl")

use anyagent::mock::{Script, Step, completed, permission, text};

let script = Script::default().turn(vec![
    Step::Emit(text("m1", "hello")),     // TextDelta
    Step::Emit(permission("p1")),        // RequestOpened
    Step::AwaitAnswer,                   // pause until your app answers
    Step::End(completed()),              // TurnEnded
]);
let runtime = Runtime::with_mock(script);
let agent = runtime.discover().await.require("mock")?.clone();