Rust SDK advanced

use meerkat::AgentBuilder;

let mut agent = AgentBuilder::new()
    .model("claude-sonnet-4-6")
    .system_prompt("You are a helpful assistant.")
    .max_tokens_per_turn(4096)
    .temperature(0.7)
    .build(llm_client, tool_dispatcher, session_store)
    .await?;

use meerkat_core::lifecycle::run_primitive::{
    AnthropicCacheControlPolicy, AnthropicProviderTag, ProviderParamsOverride, ProviderTag,
};

let mut build_config = AgentBuildConfig::new("claude-sonnet-4-6".into());
build_config.provider_params = Some(ProviderParamsOverride {
    thinking_budget_tokens: Some(10_000),
    ..Default::default()
});

// Opt one agent out of the automatic Anthropic prompt cache. The same shape,
// nested under `provider_tag`, is what a mob profile or create-session request
// carries; a flat `cache_control` key fails the parse.
let mut cache_free = AgentBuildConfig::new("claude-sonnet-4-6".into());
cache_free.provider_params = Some(ProviderParamsOverride {
    provider_tag: Some(ProviderTag::Anthropic(AnthropicProviderTag {
        cache_control: Some(AnthropicCacheControlPolicy::Disabled),
        ..Default::default()
    })),
    ..Default::default()
});

use meerkat::BudgetLimits;
use std::time::Duration;

let budget = BudgetLimits::default()
    .with_max_tokens(100_000)
    // Agent lifetime, measured from construction and never re-armed.
    .with_max_duration(Duration::from_secs(300))
    // Aggregate wall-clock for each turn, re-armed at run entry.
    .with_max_turn_duration(Duration::from_secs(120))
    .with_max_tool_calls(50);

let mut build_config = AgentBuildConfig::new("claude-sonnet-4-6".into());
build_config.budget_limits = Some(budget);

use meerkat::RetryPolicy;
use std::time::Duration;

let retry = RetryPolicy {
    max_retries: 5,
    initial_delay: Duration::from_millis(500),
    max_delay: Duration::from_secs(30),
    multiplier: 2.0,
    // Hard per-call LLM timeout; `None` inherits the model-profile default.
    call_timeout: None,
    // Per-stream inactivity watchdog (default 300s, on). A stream that
    // reports no events for the window aborts with the retryable
    // `StreamStalled` failure. `None` disables the watchdog.
    stream_inactivity_timeout: Some(Duration::from_secs(300)),
};

use meerkat::{create_default_hook_engine, resolve_layered_hooks_config};

let config = meerkat::Config::load().await?;
let cwd = std::env::current_dir()?;

// Called internally by AgentFactory::build_agent().
// Layers user-root hooks under project (context-root) hooks.
let layered_hooks = resolve_layered_hooks_config(Some(&cwd), None, &config).await;
// Returns None when no hooks are configured.
let hook_engine = create_default_hook_engine(layered_hooks);

use meerkat_core::{EventInjector, HandlingMode, PlainEventSource};

let injector = service.event_injector(&session_id).await
    .expect("comms must be enabled");

injector.inject(
    "review PR #42".into(),
    PlainEventSource::Rpc,
    HandlingMode::Queue,
    None, // render metadata
)?;

use meerkat::{AgentFactory, Config, build_ephemeral_service};
use meerkat::{
    CreateSessionRequest, DeferredPromptPolicy, InitialTurnPolicy, SessionService,
    StartTurnRequest, StartTurnRuntimeSemantics, SystemPromptOverride,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = Config::load().await?;
    let factory = AgentFactory::new(std::env::current_dir()?);
    let service = build_ephemeral_service(factory, config, 64); // embedded/testing substrate only

    let result = service.create_session(CreateSessionRequest {
        model: "claude-sonnet-4-6".into(),
        prompt: "What is 25 * 17?".into(),
        injected_context: Vec::new(),
        system_prompt: SystemPromptOverride::Set("You are a helpful math assistant.".into()),
        max_tokens: Some(2048),
        event_tx: None,
        initial_turn: InitialTurnPolicy::RunImmediately,
        deferred_prompt_policy: DeferredPromptPolicy::Discard,
        build: None,
        labels: None,
    }).await?;

    println!("Response: {}", result.text);

    let result = service.start_turn(&result.session_id, StartTurnRequest {
        prompt: "Now divide that result by 5.".into(),
        injected_context: Vec::new(),
        system_prompt: None,
        event_tx: None,
        runtime: StartTurnRuntimeSemantics::default(),
    }).await?;

    println!("Follow-up: {}", result.text);

    let view = service.read(&result.session_id).await?;
    println!("Total tokens: {}", view.billing.total_tokens);

    Ok(())
}