1use std::ffi::OsString;
2use std::path::PathBuf;
3
4use beez_policy::{HarnessOptions, HeadlessHarness};
5
6#[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 #[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 #[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 #[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 arguments.push(self.prompt);
62
63 (self.harness.name().into(), arguments)
64 }
65}
66
67fn headless_argument(harness: HeadlessHarness) -> &'static str {
69 match harness {
70 HeadlessHarness::Pi | HeadlessHarness::Omp | HeadlessHarness::Claude => "--print",
71 HeadlessHarness::Codex => "exec",
72 }
73}
74
75fn 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 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}