Skip to main content

beez_process/
harness.rs

1use std::ffi::OsString;
2use std::path::PathBuf;
3
4use beez_policy::{HarnessOptions, HeadlessHarness};
5
6/// Sends one prompt through a harness's non-interactive interface.
7#[derive(Clone, Debug, Eq, PartialEq)]
8pub struct HarnessCall {
9    harness: HeadlessHarness,
10    prompt: OsString,
11    model: Option<OsString>,
12    effort: Option<OsString>,
13}
14
15impl HarnessCall {
16    /// Uses the harness's default program with its default model and effort.
17    #[must_use]
18    pub fn new(harness: HeadlessHarness, prompt: impl Into<OsString>) -> Self {
19        Self {
20            harness,
21            prompt: prompt.into(),
22            model: None,
23            effort: None,
24        }
25    }
26
27    /// Uses the model and the effort the options name.
28    ///
29    /// An option that names neither keeps the harness default.
30    #[must_use]
31    pub fn options(mut self, options: &HarnessOptions) -> Self {
32        if let Some(model) = options.model() {
33            self.model = Some(model.into());
34        }
35        if let Some(effort) = options.effort() {
36            self.effort = Some(effort.into());
37        }
38        self
39    }
40
41    /// The harness that receives the prompt.
42    #[must_use]
43    pub fn harness(&self) -> HeadlessHarness {
44        self.harness
45    }
46
47    pub(crate) fn into_parts(self) -> (PathBuf, Vec<OsString>) {
48        let mut arguments = Vec::with_capacity(7);
49        arguments.push(headless_argument(self.harness).into());
50        if let Some(model) = self.model {
51            arguments.push("--model".into());
52            arguments.push(model);
53        }
54        if let Some(effort) = self.effort {
55            append_effort_arguments(&mut arguments, self.harness, effort);
56        }
57        if self.prompt.as_encoded_bytes().starts_with(b"-") {
58            arguments.push("--".into());
59        }
60        // The prompt stays last because harnesses read it as a positional argument.
61        arguments.push(self.prompt);
62
63        (self.harness.name().into(), arguments)
64    }
65}
66
67/// Codex takes a subcommand here where the other harnesses take a flag.
68fn headless_argument(harness: HeadlessHarness) -> &'static str {
69    match harness {
70        HeadlessHarness::Pi | HeadlessHarness::Omp | HeadlessHarness::Claude => "--print",
71        HeadlessHarness::Codex => "exec",
72    }
73}
74
75/// Each harness names the reasoning effort differently.
76fn append_effort_arguments(
77    arguments: &mut Vec<OsString>,
78    harness: HeadlessHarness,
79    effort: OsString,
80) {
81    match harness {
82        HeadlessHarness::Pi | HeadlessHarness::Claude => {
83            arguments.push("--effort".into());
84            arguments.push(effort);
85        }
86        HeadlessHarness::Omp => {
87            arguments.push("--thinking".into());
88            arguments.push(effort);
89        }
90        HeadlessHarness::Codex => {
91            let mut override_value = OsString::from("model_reasoning_effort=");
92            override_value.push(effort);
93            arguments.push("-c".into());
94            arguments.push(override_value);
95        }
96    }
97}
98
99#[cfg(test)]
100mod tests {
101    use std::path::PathBuf;
102
103    use beez_policy::{HarnessOptions, HeadlessHarness};
104
105    use super::HarnessCall;
106
107    /// A call that names the model and the effort a test needs.
108    fn call(
109        harness: HeadlessHarness,
110        prompt: &str,
111        model: Option<&str>,
112        effort: Option<&str>,
113    ) -> HarnessCall {
114        HarnessCall::new(harness, prompt).options(&HarnessOptions::new(
115            model.map(str::to_owned),
116            effort.map(str::to_owned),
117        ))
118    }
119
120    #[test]
121    fn omits_the_model_and_effort_when_unset() {
122        let sut = HarnessCall::new(HeadlessHarness::Pi, "inspect the repository");
123
124        let (program, arguments) = sut.into_parts();
125
126        assert_eq!(program, PathBuf::from("pi"));
127        assert_eq!(arguments, ["--print", "inspect the repository"]);
128    }
129
130    #[test]
131    fn places_the_model_before_the_prompt() {
132        let sut = call(
133            HeadlessHarness::Pi,
134            "inspect the repository",
135            Some("opus"),
136            None,
137        );
138
139        let (_, arguments) = sut.into_parts();
140
141        assert_eq!(
142            arguments,
143            ["--print", "--model", "opus", "inspect the repository"]
144        );
145    }
146
147    #[test]
148    fn places_the_effort_before_the_prompt() {
149        let sut = call(
150            HeadlessHarness::Pi,
151            "inspect the repository",
152            None,
153            Some("high"),
154        );
155
156        let (_, arguments) = sut.into_parts();
157
158        assert_eq!(
159            arguments,
160            ["--print", "--effort", "high", "inspect the repository"]
161        );
162    }
163
164    #[test]
165    fn sends_the_effort_to_omp_as_a_thinking_level() {
166        let sut = call(
167            HeadlessHarness::Omp,
168            "inspect the repository",
169            None,
170            Some("high"),
171        );
172
173        let (program, arguments) = sut.into_parts();
174
175        assert_eq!(program, PathBuf::from("omp"));
176        assert_eq!(
177            arguments,
178            ["--print", "--thinking", "high", "inspect the repository"]
179        );
180    }
181
182    #[test]
183    fn prints_from_claude_code_with_a_model_and_effort() {
184        let sut = call(
185            HeadlessHarness::Claude,
186            "inspect the repository",
187            Some("opus"),
188            Some("high"),
189        );
190
191        let (program, arguments) = sut.into_parts();
192
193        assert_eq!(program, PathBuf::from("claude"));
194        assert_eq!(
195            arguments,
196            [
197                "--print",
198                "--model",
199                "opus",
200                "--effort",
201                "high",
202                "inspect the repository"
203            ]
204        );
205    }
206
207    #[test]
208    fn runs_codex_through_exec_and_sends_the_effort_as_a_config_override() {
209        let sut = call(
210            HeadlessHarness::Codex,
211            "inspect the repository",
212            Some("gpt-5"),
213            Some("high"),
214        );
215
216        let (program, arguments) = sut.into_parts();
217
218        assert_eq!(program, PathBuf::from("codex"));
219        assert_eq!(
220            arguments,
221            [
222                "exec",
223                "--model",
224                "gpt-5",
225                "-c",
226                "model_reasoning_effort=high",
227                "inspect the repository"
228            ]
229        );
230    }
231
232    #[test]
233    fn places_the_model_and_effort_before_the_prompt() {
234        let sut = call(
235            HeadlessHarness::Omp,
236            "inspect the repository",
237            Some("opus"),
238            Some("high"),
239        );
240
241        let (_, arguments) = sut.into_parts();
242
243        assert_eq!(
244            arguments,
245            [
246                "--print",
247                "--model",
248                "opus",
249                "--thinking",
250                "high",
251                "inspect the repository"
252            ]
253        );
254    }
255
256    #[test]
257    fn separates_a_hyphenated_prompt_after_the_model_and_effort() {
258        let sut = call(
259            HeadlessHarness::Pi,
260            "--inspect the repository",
261            Some("opus"),
262            Some("high"),
263        );
264
265        let (_, arguments) = sut.into_parts();
266
267        assert_eq!(
268            arguments,
269            [
270                "--print",
271                "--model",
272                "opus",
273                "--effort",
274                "high",
275                "--",
276                "--inspect the repository"
277            ]
278        );
279    }
280
281    #[test]
282    fn separates_a_hyphenated_prompt_for_every_harness() {
283        for (harness, expected_program, expected_headless_argument) in [
284            (HeadlessHarness::Pi, "pi", "--print"),
285            (HeadlessHarness::Omp, "omp", "--print"),
286            (HeadlessHarness::Claude, "claude", "--print"),
287            (HeadlessHarness::Codex, "codex", "exec"),
288        ] {
289            let (program, arguments) =
290                HarnessCall::new(harness, "--inspect the repository").into_parts();
291
292            assert_eq!(program, PathBuf::from(expected_program));
293            assert_eq!(
294                arguments,
295                [expected_headless_argument, "--", "--inspect the repository"]
296            );
297        }
298    }
299}