Struct Registry 

pub struct Registry { /* private fields */ }

An open set of harnesses. Build it with the ones you want — the built-ins (Bob/Claude/Codex) and/or your own:

use harness::Registry;
let reg = Registry::new()
    .register(harness::Bob::new());
    // .register(MyCustomHarness::new())   // your own impl Harness
assert!(reg.by_id("bob").is_some());

Implementations

impl Registry

pub fn new() -> Self

An empty registry.

Examples found in repository

examples/custom_harness.rs (line 176)

fn main() -> Result<(), String> {
    // Register your harness alongside (or instead of) the built-ins — no fork.
    let reg = Registry::new().register(EchoHarness);
    let h = reg.by_id(ECHO_ID).expect("registered");
    println!("harness: {} — {}", h.info().display_name, h.info().description);

    let (tx, rx) = sync_channel::<RunEvent>(64);
    let on_event: RunCallback = Arc::new(move |ev| {
        let _ = tx.send(ev);
    });
    let _handle = h.run(
        RunRequest {
            run_id: "demo".into(),
            prompt: "hello".into(),
            cwd: None,
            mode: RunMode::Ask,
            tuning: RunTuning::default(),
            resume: None,
        },
        on_event,
    )
    .map_err(|e| e.to_string())?;

    // One normalized stream — same as for any built-in harness.
    for ev in rx {
        match ev {
            RunEvent::Session { model, .. } => println!("[session] model={model:?}"),
            RunEvent::Text { delta, .. } => println!("[answer] {delta}"),
            RunEvent::Exited { exit_code, .. } => {
                println!("[exited] {exit_code:?}");
                break;
            }
            other => println!("{other:?}"),
        }
    }
    Ok(())
}

pub fn register(self, harness: impl Harness + 'static) -> Self

Add a harness. Chainable. Registration order is preserved (it’s the UI display order; the first registered is the conventional default).

Examples found in repository

examples/custom_harness.rs (line 176)

fn main() -> Result<(), String> {
    // Register your harness alongside (or instead of) the built-ins — no fork.
    let reg = Registry::new().register(EchoHarness);
    let h = reg.by_id(ECHO_ID).expect("registered");
    println!("harness: {} — {}", h.info().display_name, h.info().description);

    let (tx, rx) = sync_channel::<RunEvent>(64);
    let on_event: RunCallback = Arc::new(move |ev| {
        let _ = tx.send(ev);
    });
    let _handle = h.run(
        RunRequest {
            run_id: "demo".into(),
            prompt: "hello".into(),
            cwd: None,
            mode: RunMode::Ask,
            tuning: RunTuning::default(),
            resume: None,
        },
        on_event,
    )
    .map_err(|e| e.to_string())?;

    // One normalized stream — same as for any built-in harness.
    for ev in rx {
        match ev {
            RunEvent::Session { model, .. } => println!("[session] model={model:?}"),
            RunEvent::Text { delta, .. } => println!("[answer] {delta}"),
            RunEvent::Exited { exit_code, .. } => {
                println!("[exited] {exit_code:?}");
                break;
            }
            other => println!("{other:?}"),
        }
    }
    Ok(())
}

pub fn by_id(&self, id: &str) -> Option<&dyn Harness>

Resolve a harness by its HarnessInfo::id.

Examples found in repository

examples/custom_harness.rs (line 177)

fn main() -> Result<(), String> {
    // Register your harness alongside (or instead of) the built-ins — no fork.
    let reg = Registry::new().register(EchoHarness);
    let h = reg.by_id(ECHO_ID).expect("registered");
    println!("harness: {} — {}", h.info().display_name, h.info().description);

    let (tx, rx) = sync_channel::<RunEvent>(64);
    let on_event: RunCallback = Arc::new(move |ev| {
        let _ = tx.send(ev);
    });
    let _handle = h.run(
        RunRequest {
            run_id: "demo".into(),
            prompt: "hello".into(),
            cwd: None,
            mode: RunMode::Ask,
            tuning: RunTuning::default(),
            resume: None,
        },
        on_event,
    )
    .map_err(|e| e.to_string())?;

    // One normalized stream — same as for any built-in harness.
    for ev in rx {
        match ev {
            RunEvent::Session { model, .. } => println!("[session] model={model:?}"),
            RunEvent::Text { delta, .. } => println!("[answer] {delta}"),
            RunEvent::Exited { exit_code, .. } => {
                println!("[exited] {exit_code:?}");
                break;
            }
            other => println!("{other:?}"),
        }
    }
    Ok(())
}

examples/verify_enrichment.rs (line 22)

fn main() -> Result<(), String> {
    let id = std::env::args().nth(1).unwrap_or_else(|| "claude".to_owned());
    let prompt = std::env::args().nth(2).unwrap_or_else(|| default_prompt(&id));

    let reg = default_registry();
    let h = reg
        .by_id(&id)
        .ok_or_else(|| format!("unknown/disabled harness: {id}"))?;

    // Cheapest viable settings (per the "don't burn tokens" rule).
    let tuning = match id.as_str() {
        "claude" => RunTuning { model: Some("haiku".to_owned()), ..RunTuning::default() },
        "codex" => RunTuning { effort: Some(ReasoningEffort::Low), ..RunTuning::default() },
        _ => RunTuning::default(),
    };

    let (tx, rx) = sync_channel::<RunEvent>(256);
    let on_event: RunCallback = Arc::new(move |ev| {
        let _ = tx.send(ev);
    });

    eprintln!("── running {id} ──");
    let _handle = h.run(
        RunRequest {
            run_id: "verify".into(),
            prompt,
            cwd: Some(std::env::current_dir().map_err(|e| e.to_string())?),
            mode: RunMode::Ask,
            tuning,
            resume: None,
        },
        on_event,
    )
    .map_err(|e| e.to_string())?;

    let (mut session, mut tool_input, mut tool_output, mut usage) = (false, false, false, false);
    for ev in rx {
        print_event(&ev);
        match &ev {
            RunEvent::Session { session_id, model, .. } => {
                session = session_id.is_some() || model.is_some();
            }
            RunEvent::ToolStart { input, .. } => tool_input |= input.is_some(),
            RunEvent::ToolEnd { output, .. } => tool_output |= output.is_some(),
            RunEvent::Usage { input_tokens, output_tokens, total_tokens, .. } => {
                usage = input_tokens.is_some() || output_tokens.is_some() || total_tokens.is_some();
            }
            RunEvent::Exited { .. } => break,
            _ => {}
        }
    }
    eprintln!(
        "\n── enrichment seen from real {id}: session={session} tool_input={tool_input} tool_output={tool_output} usage={usage}"
    );
    Ok(())
}

pub fn catalog(&self) -> Vec<HarnessInfo>

Metadata for every registered harness, in registration order.

pub fn ids(&self) -> Vec<String>

The ids of every registered harness, in registration order.

Trait Implementations

impl Default for Registry

fn default() -> Registry

Returns the “default value” for a type.