use std::ffi::OsString;
use std::path::PathBuf;
use beez_policy::{HarnessOptions, HeadlessHarness};
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct HarnessCall {
harness: HeadlessHarness,
prompt: OsString,
model: Option<OsString>,
effort: Option<OsString>,
}
impl HarnessCall {
#[must_use]
pub fn new(harness: HeadlessHarness, prompt: impl Into<OsString>) -> Self {
Self {
harness,
prompt: prompt.into(),
model: None,
effort: None,
}
}
#[must_use]
pub fn options(mut self, options: &HarnessOptions) -> Self {
if let Some(model) = options.model() {
self.model = Some(model.into());
}
if let Some(effort) = options.effort() {
self.effort = Some(effort.into());
}
self
}
#[must_use]
pub fn harness(&self) -> HeadlessHarness {
self.harness
}
pub(crate) fn into_parts(self) -> (PathBuf, Vec<OsString>) {
let mut arguments = Vec::with_capacity(7);
arguments.push(headless_argument(self.harness).into());
if let Some(model) = self.model {
arguments.push("--model".into());
arguments.push(model);
}
if let Some(effort) = self.effort {
append_effort_arguments(&mut arguments, self.harness, effort);
}
if self.prompt.as_encoded_bytes().starts_with(b"-") {
arguments.push("--".into());
}
arguments.push(self.prompt);
(self.harness.name().into(), arguments)
}
}
fn headless_argument(harness: HeadlessHarness) -> &'static str {
match harness {
HeadlessHarness::Pi | HeadlessHarness::Omp | HeadlessHarness::Claude => "--print",
HeadlessHarness::Codex => "exec",
}
}
fn append_effort_arguments(
arguments: &mut Vec<OsString>,
harness: HeadlessHarness,
effort: OsString,
) {
match harness {
HeadlessHarness::Pi | HeadlessHarness::Claude => {
arguments.push("--effort".into());
arguments.push(effort);
}
HeadlessHarness::Omp => {
arguments.push("--thinking".into());
arguments.push(effort);
}
HeadlessHarness::Codex => {
let mut override_value = OsString::from("model_reasoning_effort=");
override_value.push(effort);
arguments.push("-c".into());
arguments.push(override_value);
}
}
}
#[cfg(test)]
mod tests {
use std::path::PathBuf;
use beez_policy::{HarnessOptions, HeadlessHarness};
use super::HarnessCall;
fn call(
harness: HeadlessHarness,
prompt: &str,
model: Option<&str>,
effort: Option<&str>,
) -> HarnessCall {
HarnessCall::new(harness, prompt).options(&HarnessOptions::new(
model.map(str::to_owned),
effort.map(str::to_owned),
))
}
#[test]
fn omits_the_model_and_effort_when_unset() {
let sut = HarnessCall::new(HeadlessHarness::Pi, "inspect the repository");
let (program, arguments) = sut.into_parts();
assert_eq!(program, PathBuf::from("pi"));
assert_eq!(arguments, ["--print", "inspect the repository"]);
}
#[test]
fn places_the_model_before_the_prompt() {
let sut = call(
HeadlessHarness::Pi,
"inspect the repository",
Some("opus"),
None,
);
let (_, arguments) = sut.into_parts();
assert_eq!(
arguments,
["--print", "--model", "opus", "inspect the repository"]
);
}
#[test]
fn places_the_effort_before_the_prompt() {
let sut = call(
HeadlessHarness::Pi,
"inspect the repository",
None,
Some("high"),
);
let (_, arguments) = sut.into_parts();
assert_eq!(
arguments,
["--print", "--effort", "high", "inspect the repository"]
);
}
#[test]
fn sends_the_effort_to_omp_as_a_thinking_level() {
let sut = call(
HeadlessHarness::Omp,
"inspect the repository",
None,
Some("high"),
);
let (program, arguments) = sut.into_parts();
assert_eq!(program, PathBuf::from("omp"));
assert_eq!(
arguments,
["--print", "--thinking", "high", "inspect the repository"]
);
}
#[test]
fn prints_from_claude_code_with_a_model_and_effort() {
let sut = call(
HeadlessHarness::Claude,
"inspect the repository",
Some("opus"),
Some("high"),
);
let (program, arguments) = sut.into_parts();
assert_eq!(program, PathBuf::from("claude"));
assert_eq!(
arguments,
[
"--print",
"--model",
"opus",
"--effort",
"high",
"inspect the repository"
]
);
}
#[test]
fn runs_codex_through_exec_and_sends_the_effort_as_a_config_override() {
let sut = call(
HeadlessHarness::Codex,
"inspect the repository",
Some("gpt-5"),
Some("high"),
);
let (program, arguments) = sut.into_parts();
assert_eq!(program, PathBuf::from("codex"));
assert_eq!(
arguments,
[
"exec",
"--model",
"gpt-5",
"-c",
"model_reasoning_effort=high",
"inspect the repository"
]
);
}
#[test]
fn places_the_model_and_effort_before_the_prompt() {
let sut = call(
HeadlessHarness::Omp,
"inspect the repository",
Some("opus"),
Some("high"),
);
let (_, arguments) = sut.into_parts();
assert_eq!(
arguments,
[
"--print",
"--model",
"opus",
"--thinking",
"high",
"inspect the repository"
]
);
}
#[test]
fn separates_a_hyphenated_prompt_after_the_model_and_effort() {
let sut = call(
HeadlessHarness::Pi,
"--inspect the repository",
Some("opus"),
Some("high"),
);
let (_, arguments) = sut.into_parts();
assert_eq!(
arguments,
[
"--print",
"--model",
"opus",
"--effort",
"high",
"--",
"--inspect the repository"
]
);
}
#[test]
fn separates_a_hyphenated_prompt_for_every_harness() {
for (harness, expected_program, expected_headless_argument) in [
(HeadlessHarness::Pi, "pi", "--print"),
(HeadlessHarness::Omp, "omp", "--print"),
(HeadlessHarness::Claude, "claude", "--print"),
(HeadlessHarness::Codex, "codex", "exec"),
] {
let (program, arguments) =
HarnessCall::new(harness, "--inspect the repository").into_parts();
assert_eq!(program, PathBuf::from(expected_program));
assert_eq!(
arguments,
[expected_headless_argument, "--", "--inspect the repository"]
);
}
}
}