Skip to main content

orch/engine/runner/agents/
codex.rs

1//! Codex agent runner.
2//!
3//! ## CLI invocation
4//!
5//! ```bash
6//! codex --model {model} \
7//!   exec \
8//!   -c 'sandbox_workspace_write.network_access=true' \
9//!   -c 'shell_environment_policy.inherit=all' \
10//!   --sandbox workspace-write \
11//!   -c 'approval_policy="never"' \
12//!   --json - < <(cat "{sys_file}" "{msg_file}")
13//! ```
14//!
15//! Note: all `-c` overrides must appear **after** the `exec` subcommand.
16//! Global `-c` flags before `exec` are parsed by the top-level codex CLI and do
17//! NOT propagate into the exec subcommand's sandbox — placing
18//! `sandbox_workspace_write.network_access=true` before `exec` silently fails,
19//! leaving the sandbox network-blocked.
20//!
21//! ## Output format (`exec --json`)
22//!
23//! NDJSON stream (one JSON object per line):
24//! ```jsonl
25//! {"type":"thread.started","thread_id":"..."}
26//! {"type":"turn.started"}
27//! {"type":"item.completed","item":{"type":"agent_message","text":"..."}}
28//! {"type":"item.completed","item":{"type":"command_execution","command":"..."}}
29//! {"type":"turn.completed"}
30//! ```
31//!
32//! ## Error events
33//!
34//! Rate limit:
35//! ```jsonl
36//! {"type":"error","message":"You've hit your usage limit..."}
37//! {"type":"turn.failed","error":{"message":"..."}}
38//! ```
39//!
40//! Model not found:
41//! ```jsonl
42//! {"type":"item.completed","item":{"type":"error","message":"Model metadata for `o3-mini` not found..."}}
43//! {"type":"error","message":"{\"detail\":\"The 'o3-mini' model is not supported...\"}"}
44//! {"type":"turn.failed","error":{"message":"..."}}
45//! ```
46
47use std::sync::LazyLock;
48
49use tokio::process::Command;
50
51use super::{
52    AgentError, AgentRunner, ParsedResponse, PermissionRules, SandboxLevel, StreamEvent,
53    json_error_message, json_str,
54};
55use crate::parser;
56
57/// Runner for Codex agent.
58#[derive(Debug)]
59pub struct CodexRunner;
60
61impl CodexRunner {
62    /// Extract the agent's response text from NDJSON events.
63    ///
64    /// Looks for `item.completed` events with `item.type == "agent_message"`.
65    /// Uses the **last** agent message that contains valid-looking JSON,
66    /// since earlier messages are often progress updates.
67    fn extract_agent_text(events: &[serde_json::Value]) -> Option<String> {
68        let mut texts = Vec::new();
69
70        for event in events {
71            let event_type = event.get("type").and_then(|v| v.as_str()).unwrap_or("");
72
73            if event_type == "item.completed"
74                && let Some(item) = event.get("item")
75            {
76                let item_type = item.get("type").and_then(|v| v.as_str()).unwrap_or("");
77
78                if item_type == "agent_message"
79                    && let Some(text) = item.get("text").and_then(|v| v.as_str())
80                {
81                    texts.push(text.to_string());
82                }
83            }
84        }
85
86        if texts.is_empty() {
87            return None;
88        }
89
90        // Prefer the last message that looks like JSON (contains `{` and `status`)
91        for text in texts.iter().rev() {
92            let trimmed = text.trim();
93            if trimmed.contains('{') && trimmed.contains("status") {
94                return Some(text.clone());
95            }
96        }
97
98        // Fall back to the last message
99        texts.pop()
100    }
101
102    /// Check for error events in the NDJSON stream.
103    ///
104    /// Scans ALL error events and returns the most specific one.
105    /// Priority: RateLimit > ModelUnavailable > Auth > ContextOverflow > AgentFailed
106    fn detect_error(events: &[serde_json::Value]) -> Option<AgentError> {
107        super::patterns::detect_ndjson_error(
108            events,
109            |event| {
110                let event_type = event.get("type").and_then(|v| v.as_str()).unwrap_or("");
111                match event_type {
112                    "turn.failed" => Some(
113                        event
114                            .get("error")
115                            .and_then(|e| e.get("message"))
116                            .and_then(|v| v.as_str())
117                            .unwrap_or("turn failed")
118                            .to_string(),
119                    ),
120                    "error" => Some(
121                        event
122                            .get("message")
123                            .and_then(|v| v.as_str())
124                            .unwrap_or("unknown error")
125                            .to_string(),
126                    ),
127                    "item.completed" => {
128                        let item = event.get("item")?;
129                        let item_type = item.get("type").and_then(|v| v.as_str()).unwrap_or("");
130                        if item_type == "error" {
131                            Some(
132                                item.get("message")
133                                    .and_then(|v| v.as_str())
134                                    .unwrap_or("item error")
135                                    .to_string(),
136                            )
137                        } else {
138                            None
139                        }
140                    }
141                    _ => None,
142                }
143            },
144            Self::classify_message,
145        )
146    }
147
148    /// Classify an error message into an AgentError variant.
149    fn classify_message(message: &str) -> AgentError {
150        let lower = message.to_lowercase();
151
152        // Rate limit — delegate to shared helper (covers "you've hit your", 429, 529, etc.)
153        if let Some(e) = super::patterns::detect_rate_limit(message) {
154            return e;
155        }
156
157        // Model not supported / not found (codex-specific patterns)
158        if lower.contains("model metadata")
159            || lower.contains("model is not supported")
160            || (lower.contains("not found")
161                && (lower.contains("model") || lower.contains("metadata")))
162        {
163            let model = extract_model_name(message).unwrap_or_default();
164            return AgentError::ModelUnavailable {
165                message: message.to_string(),
166                model,
167            };
168        }
169
170        // Auth errors — delegate to shared helper (includes HTTP 401/403, billing, etc.)
171        if let Some(e) = super::patterns::detect_auth_error(message) {
172            return e;
173        }
174
175        // Context overflow — delegate to shared helper
176        if let Some(e) = super::patterns::detect_context_overflow(message) {
177            return e;
178        }
179
180        // Connection/network errors — codex-specific transient patterns.
181        // Return NetworkError (not AgentFailed) so fallback.rs can route these
182        // into the dedicated network-retry loop with backoff and escalation.
183        if lower.contains("reconnecting")
184            || lower.contains("stream disconnected")
185            || lower.contains("event stream lagged")
186            || lower.contains("connection closed")
187            || lower.contains("websocket")
188            || lower.contains("econnreset")
189        {
190            return AgentError::NetworkError {
191                message: format!("codex network error: {message}"),
192            };
193        }
194        if let Some(e) = super::patterns::detect_network_error(message) {
195            return e;
196        }
197
198        AgentError::AgentFailed {
199            message: message.to_string(),
200        }
201    }
202}
203
204impl AgentRunner for CodexRunner {
205    #[cfg(test)]
206    fn name(&self) -> &'static str {
207        "codex"
208    }
209
210    fn stream_events(&self, event: &serde_json::Value) -> Vec<StreamEvent> {
211        stream_events(event)
212    }
213
214    fn extract_text(&self, raw: &str) -> Result<String, AgentError> {
215        let trimmed = raw.trim();
216        if trimmed.is_empty() {
217            return Ok(String::new());
218        }
219
220        let events = super::parse_ndjson(trimmed);
221        if events.is_empty() {
222            return Ok(trimmed.to_string());
223        }
224
225        // Propagate terminal errors (rate limit, auth) so the review pipeline
226        // can record cooldowns and abort cleanly.
227        if let Some(err) = Self::detect_error(&events) {
228            return Err(err);
229        }
230
231        // Return agent_message text, or fall back to the raw output.
232        Ok(Self::extract_agent_text(&events).unwrap_or_else(|| trimmed.to_string()))
233    }
234
235    fn build_command(
236        &self,
237        model: Option<&str>,
238        timeout_cmd: &str,
239        sys_file: &str,
240        msg_file: &str,
241        permissions: &PermissionRules,
242    ) -> String {
243        let model_flag = model
244            .map(|m| format!("--model {}", super::shell_single_quote(m)))
245            .unwrap_or_default();
246
247        // Codex permission mode (codex-cli 0.133.0+):
248        // - autonomous → --sandbox workspace-write -c 'approval_policy="never"'
249        // - supervised → -c 'approval_policy="on-request"' --sandbox {sandbox}
250        // - full access → --dangerously-bypass-approvals-and-sandbox
251        //
252        // Note: --ask-for-approval was removed in codex-cli 0.133.0.
253        // Use -c 'approval_policy="..."' instead.
254        // Note: --full-auto is deprecated as of codex 0.128.0 and does not
255        // reliably honour --add-dir entries under the new seatbelt policy.
256        let permission_flags = if permissions.autonomous {
257            match permissions.sandbox {
258                SandboxLevel::FullAccess | SandboxLevel::Os => {
259                    "--dangerously-bypass-approvals-and-sandbox".to_string()
260                }
261                SandboxLevel::ReadOnly => {
262                    r#"--sandbox read-only -c 'approval_policy="never"'"#.to_string()
263                }
264                _ => r#"--sandbox workspace-write -c 'approval_policy="never"'"#.to_string(),
265            }
266        } else {
267            let sandbox = match permissions.sandbox {
268                SandboxLevel::WorkspaceWrite | SandboxLevel::None => "workspace-write",
269                SandboxLevel::FullAccess | SandboxLevel::Os => "danger-full-access",
270                SandboxLevel::ReadOnly => "read-only",
271            };
272            format!(r#"-c 'approval_policy="on-request"' --sandbox {sandbox}"#)
273        };
274
275        // Extra writable dirs (e.g. the git common dir when running inside a
276        // worktree whose .git metadata lives outside the sandbox root).
277        let add_dir_flags: String = permissions
278            .extra_writable_dirs
279            .iter()
280            .map(|p| {
281                format!(
282                    "\\\n  --add-dir {}",
283                    super::shell_single_quote(&p.to_string_lossy())
284                )
285            })
286            .collect::<Vec<_>>()
287            .join(" ");
288
289        // All -c config overrides and permission flags must be placed AFTER the
290        // `exec` subcommand. Global -c flags before `exec` are parsed by the
291        // top-level CLI and do NOT propagate into the exec subcommand's sandbox
292        // initialisation — in particular, `sandbox_workspace_write.network_access=true`
293        // has no effect when placed before `exec`, causing outbound network to be
294        // blocked despite the documented contract. Place everything after `exec`.
295        // Feed both files via process substitution rather than a leading `cat |`
296        // pipe stage — a leading pipe would make `cat`, not codex, the first
297        // stage in the runner script's pipeline, so PIPESTATUS[0] there would
298        // always report cat's (always-zero) exit code instead of codex's.
299        format!(
300            r#"{timeout_cmd} codex {model_flag} \
301  exec \
302  -c 'sandbox_workspace_write.network_access=true' \
303  -c 'shell_environment_policy.inherit=all' \
304  {permission_flags} {add_dir_flags} --json - < <(cat "{sys_file}" "{msg_file}")"#,
305        )
306    }
307
308    fn parse_response(&self, raw: &str) -> Result<ParsedResponse, AgentError> {
309        let trimmed = raw.trim();
310        if trimmed.is_empty() {
311            return Err(AgentError::InvalidResponse { raw: String::new() });
312        }
313
314        let events = super::parse_ndjson(trimmed);
315
316        if events.is_empty() {
317            // Maybe it's direct JSON, not NDJSON
318            if let Ok(resp) = parser::parse(trimmed) {
319                return Ok(ParsedResponse {
320                    response: resp,
321                    input_tokens: None,
322                    output_tokens: None,
323                    cost_usd: None,
324                    duration_ms: None,
325                });
326            }
327            return Err(AgentError::InvalidResponse {
328                raw: trimmed.to_string(),
329            });
330        }
331
332        // Check for errors first
333        if let Some(err) = Self::detect_error(&events) {
334            return Err(err);
335        }
336
337        // Extract agent response text
338        let agent_text =
339            Self::extract_agent_text(&events).ok_or_else(|| AgentError::InvalidResponse {
340                raw: trimmed.to_string(),
341            })?;
342
343        // Parse the agent text through our standard parser
344        let response = match parser::parse(&agent_text) {
345            Ok(r) => r,
346            Err(_) => {
347                // Structured parse failed — try plain-text synthesis before
348                // giving up, same rescue path claude.rs uses (issue #3467).
349                super::synthesize_response_from_text(&agent_text).ok_or_else(|| {
350                    AgentError::InvalidResponse {
351                        raw: agent_text.clone(),
352                    }
353                })?
354            }
355        };
356
357        Ok(ParsedResponse {
358            response,
359            input_tokens: None,
360            output_tokens: None,
361            cost_usd: None,
362            duration_ms: None,
363        })
364    }
365
366    fn classify_error(&self, exit_code: i32, stdout: &str, stderr: &str) -> AgentError {
367        // Try parsing NDJSON events from stdout for structured errors
368        let events = super::parse_ndjson(stdout);
369        if let Some(err) = Self::detect_error(&events) {
370            return err;
371        }
372
373        // Fall back to pattern matching
374        let combined = format!("{stdout}\n{stderr}");
375        super::patterns::classify_from_text(exit_code, &combined)
376    }
377
378    fn router_command(&self, prompt: &str, model: Option<&str>) -> anyhow::Result<Command> {
379        let mut cmd = Command::new("codex");
380        cmd.arg("exec").arg("--json");
381        if let Some(m) = model {
382            cmd.arg("--model").arg(m);
383        }
384        cmd.arg(prompt);
385        Ok(cmd)
386    }
387}
388
389/// Try to extract a model name from an error message.
390///
391/// Looks for text quoted with backticks or single quotes:
392/// - "Model metadata for `o3-mini` not found"
393/// - "The 'o3-mini' model is not supported"
394fn extract_model_name(message: &str) -> Option<String> {
395    extract_quoted(message, '`').or_else(|| extract_quoted(message, '\''))
396}
397
398/// Extract text between matching `quote` characters.
399fn extract_quoted(text: &str, quote: char) -> Option<String> {
400    let start = text.find(quote)?;
401    let rest = &text[start + quote.len_utf8()..];
402    let end = rest.find(quote)?;
403    Some(rest[..end].to_string())
404}
405
406/// Extract a structured `AgentResult` from Codex NDJSON output.
407///
408/// Finds `item.completed` events with `type:agent_message` for the result text.
409/// Checks for `turn.failed`, `error`, and `item.completed` error events.
410///
411/// Returns `None` only if no parseable NDJSON events are found.
412pub fn find_codex_result(ndjson: &str) -> Option<super::AgentResult> {
413    let events = super::parse_ndjson(ndjson.trim());
414    if events.is_empty() {
415        return None;
416    }
417
418    // Check for errors first
419    let is_error;
420    let error_text;
421    if let Some(err) = CodexRunner::detect_error(&events) {
422        is_error = true;
423        error_text = Some(err.to_string());
424    } else {
425        is_error = false;
426        error_text = None;
427    }
428
429    let result_text = if is_error {
430        error_text.unwrap_or_default()
431    } else {
432        CodexRunner::extract_agent_text(&events).unwrap_or_default()
433    };
434
435    if result_text.is_empty() && !is_error {
436        return None;
437    }
438
439    Some(super::AgentResult {
440        is_error,
441        result_text,
442        input_tokens: None,
443        output_tokens: None,
444        cost_usd: None,
445        duration_ms: None,
446        truncated_by_length: false,
447    })
448}
449
450#[cfg(test)]
451mod tests {
452    use std::path::PathBuf;
453
454    use super::*;
455    use crate::engine::runner::agents::fixture;
456
457    fn runner() -> CodexRunner {
458        CodexRunner
459    }
460
461    #[test]
462    fn parse_codex_ndjson_success() {
463        let raw = r#"{"type":"thread.started","thread_id":"t1"}
464{"type":"turn.started"}
465{"type":"item.completed","item":{"type":"agent_message","text":"{\"status\":\"done\",\"summary\":\"hello\",\"accomplished\":[],\"remaining\":[],\"files\":[]}"}}
466{"type":"turn.completed"}"#;
467
468        let parsed = runner().parse_response(raw).unwrap();
469        assert_eq!(parsed.response.status, "done");
470        assert_eq!(parsed.response.summary, "hello");
471    }
472
473    #[test]
474    fn parse_codex_ndjson_rate_limit() {
475        let raw = r#"{"type":"error","message":"You've hit your usage limit for this billing period"}
476{"type":"turn.failed","error":{"message":"You've hit your usage limit"}}"#;
477
478        let err = runner().parse_response(raw).unwrap_err();
479        assert!(matches!(err, AgentError::RateLimit { .. }));
480    }
481
482    #[test]
483    fn parse_codex_model_not_found() {
484        let raw = r#"{"type":"item.completed","item":{"type":"error","message":"Model metadata for `o3-mini` not found"}}
485{"type":"error","message":"{\"detail\":\"The 'o3-mini' model is not supported\"}"}
486{"type":"turn.failed","error":{"message":"Model not supported"}}"#;
487
488        let err = runner().parse_response(raw).unwrap_err();
489        assert!(matches!(err, AgentError::ModelUnavailable { .. }));
490    }
491
492    /// Regression test for issue #3467: when codex's agent_message text is a
493    /// plain-prose completion summary (not JSON), parser::parse fails but
494    /// synthesize_response_from_text must rescue it instead of returning
495    /// InvalidResponse, mirroring the fallback claude.rs already has.
496    #[test]
497    fn parse_codex_plain_prose_completion_synthesizes_response() {
498        let raw = r#"{"type":"thread.started","thread_id":"t1"}
499{"type":"turn.started"}
500{"type":"item.completed","item":{"type":"agent_message","text":"Fixed the typo and corrected the deadline reference in the review."}}
501{"type":"turn.completed"}"#;
502
503        let parsed = runner()
504            .parse_response(raw)
505            .expect("plain-prose completion text must synthesize successfully");
506        assert_eq!(parsed.response.status, "done");
507    }
508
509    #[test]
510    fn parse_codex_empty_response() {
511        let err = runner().parse_response("").unwrap_err();
512        assert!(matches!(err, AgentError::InvalidResponse { .. }));
513    }
514
515    #[test]
516    fn extract_model_name_backtick() {
517        assert_eq!(
518            extract_model_name("Model metadata for `o3-mini` not found"),
519            Some("o3-mini".to_string())
520        );
521    }
522
523    #[test]
524    fn extract_model_name_single_quote() {
525        assert_eq!(
526            extract_model_name("The 'o3-mini' model is not supported"),
527            Some("o3-mini".to_string())
528        );
529    }
530
531    #[test]
532    fn parse_codex_multiple_agent_messages() {
533        let raw = r#"{"type":"thread.started","thread_id":"t1"}
534{"type":"turn.started"}
535{"type":"item.completed","item":{"type":"agent_message","text":"Working on it..."}}
536{"type":"item.completed","item":{"type":"command_execution","command":"echo hello"}}
537{"type":"item.completed","item":{"type":"agent_message","text":"{\"status\":\"done\",\"summary\":\"finished\",\"accomplished\":[\"did it\"],\"remaining\":[],\"files\":[\"a.rs\"]}"}}
538{"type":"turn.completed"}"#;
539
540        let parsed = runner().parse_response(raw).unwrap();
541        // The parser concatenates all agent messages; the last valid JSON wins
542        // Actually, parser::parse will try the concatenated text and find the JSON
543        assert_eq!(parsed.response.status, "done");
544    }
545
546    #[test]
547    fn classify_error_codex_ndjson() {
548        let stdout = r#"{"type":"error","message":"You've hit your usage limit"}"#;
549        let err = runner().classify_error(1, stdout, "");
550        assert!(matches!(err, AgentError::RateLimit { .. }));
551    }
552
553    #[test]
554    fn build_command_codex() {
555        let perms = PermissionRules::default();
556        let cmd = runner().build_command(
557            Some("gpt-4o"),
558            "timeout 1800",
559            "/tmp/sys.txt",
560            "/tmp/msg.txt",
561            &perms,
562        );
563        assert!(cmd.contains("codex"));
564        assert!(cmd.contains("--model 'gpt-4o'"));
565        assert!(cmd.contains("exec"));
566        assert!(cmd.contains("--json -"));
567        assert!(
568            cmd.contains("--sandbox workspace-write"),
569            "default autonomous codex should use --sandbox workspace-write, got: {cmd}"
570        );
571        assert!(
572            cmd.contains(r#"-c 'approval_policy="never"'"#),
573            "default autonomous codex should use -c approval_policy=never, got: {cmd}"
574        );
575        assert!(
576            !cmd.contains("--ask-for-approval"),
577            "--ask-for-approval was removed in codex 0.133.0 and must not appear, got: {cmd}"
578        );
579        assert!(
580            !cmd.contains("--full-auto"),
581            "--full-auto is deprecated and must not appear in the command, got: {cmd}"
582        );
583        // Regression: network_access and shell_environment_policy overrides must appear
584        // AFTER `exec`, not before it.  Global -c flags placed before `exec` are parsed
585        // by the top-level codex CLI and do NOT propagate into the exec subcommand's
586        // sandbox initialisation — the network would be blocked silently if misplaced.
587        assert!(
588            cmd.contains("sandbox_workspace_write.network_access=true"),
589            "network_access override must be present, got: {cmd}"
590        );
591        let exec_pos = cmd.find("exec").expect("exec must appear in command");
592        let network_pos = cmd
593            .find("sandbox_workspace_write.network_access=true")
594            .expect("network_access override must appear in command");
595        assert!(
596            network_pos > exec_pos,
597            "sandbox_workspace_write.network_access=true must appear AFTER exec, got: {cmd}"
598        );
599        // Regression: the command must not start with a `cat sys msg |` pipe
600        // stage. `build_runner_script` captures the agent's exit status via
601        // `PIPESTATUS[0]` of `{agent_cmd} | tee ...` — a leading `cat |` would
602        // make PIPESTATUS[0] always report cat's (always-zero) exit code
603        // instead of codex's real exit code. sys/msg files must be fed via
604        // input redirection instead.
605        assert!(
606            !cmd.trim_start().starts_with("cat "),
607            "codex command must not start with a `cat |` pipe stage, got: {cmd}"
608        );
609        assert!(
610            cmd.contains("< <(cat \"/tmp/sys.txt\" \"/tmp/msg.txt\")"),
611            "sys/msg files must be fed via process substitution, got: {cmd}"
612        );
613    }
614
615    #[test]
616    fn build_command_codex_full_access() {
617        let perms = PermissionRules {
618            autonomous: true,
619            sandbox: SandboxLevel::FullAccess,
620            disallowed_tools: vec![],
621            allowed_tools: vec![],
622            allowed_edit_paths: vec![],
623            deny_read_only: false,
624            extra_writable_dirs: vec![],
625        };
626        let cmd = runner().build_command(None, "", "/tmp/sys.txt", "/tmp/msg.txt", &perms);
627        assert!(
628            cmd.contains("--dangerously-bypass-approvals-and-sandbox"),
629            "full access codex should use dangerously-bypass, got: {cmd}"
630        );
631    }
632
633    #[test]
634    fn build_command_codex_in_the_os_sandbox_turns_its_own_off() {
635        let perms = PermissionRules {
636            autonomous: true,
637            sandbox: SandboxLevel::Os,
638            disallowed_tools: vec![],
639            allowed_tools: vec![],
640            allowed_edit_paths: vec![],
641            deny_read_only: false,
642            extra_writable_dirs: vec![],
643        };
644        let cmd = runner().build_command(None, "", "/tmp/sys.txt", "/tmp/msg.txt", &perms);
645        assert!(
646            cmd.contains("--dangerously-bypass-approvals-and-sandbox"),
647            "codex cannot nest its Seatbelt in the OS sandbox, got: {cmd}"
648        );
649    }
650
651    #[test]
652    fn build_command_codex_extra_writable_dirs() {
653        // When git metadata dirs are outside the worktree sandbox root, the
654        // runner adds them to extra_writable_dirs and build_command must emit
655        // --add-dir flags so Codex can create index.lock there.
656        let perms = PermissionRules {
657            autonomous: true,
658            sandbox: SandboxLevel::WorkspaceWrite,
659            disallowed_tools: vec![],
660            allowed_tools: vec![],
661            allowed_edit_paths: vec![],
662            deny_read_only: false,
663            extra_writable_dirs: vec![
664                PathBuf::from("/Users/gb/Projects/bean/.git"),
665                PathBuf::from("/Users/gb/Projects/bean/.git/worktrees/task-123"),
666            ],
667        };
668        let cmd = runner().build_command(None, "", "/tmp/sys.txt", "/tmp/msg.txt", &perms);
669        assert!(
670            cmd.contains("--add-dir"),
671            "should include --add-dir flag, got: {cmd}"
672        );
673        assert!(
674            cmd.contains("/Users/gb/Projects/bean/.git'"),
675            "should include git common dir path, got: {cmd}"
676        );
677        assert!(
678            cmd.contains("/Users/gb/Projects/bean/.git/worktrees/task-123"),
679            "should include git dir path, got: {cmd}"
680        );
681        assert_eq!(
682            cmd.matches("--add-dir ").count(),
683            2,
684            "should include two --add-dir flags, got: {cmd}"
685        );
686        assert!(
687            cmd.contains("--sandbox workspace-write"),
688            "autonomous codex with extra dirs should use --sandbox workspace-write, got: {cmd}"
689        );
690        assert!(
691            cmd.contains(r#"-c 'approval_policy="never"'"#),
692            "autonomous codex with extra dirs should use -c approval_policy=never, got: {cmd}"
693        );
694        assert!(
695            !cmd.contains("--ask-for-approval"),
696            "--ask-for-approval was removed in codex 0.133.0 and must not appear, got: {cmd}"
697        );
698        assert!(
699            !cmd.contains("--full-auto"),
700            "--full-auto is deprecated and must not appear, got: {cmd}"
701        );
702        assert!(
703            cmd.contains("exec") && cmd.contains("--json -"),
704            "should include exec and --json -, got: {cmd}"
705        );
706        let exec_pos = cmd.find("exec").expect("exec must appear in command");
707        let network_pos = cmd
708            .find("sandbox_workspace_write.network_access=true")
709            .expect("network_access override must appear in command");
710        assert!(
711            network_pos > exec_pos,
712            "sandbox_workspace_write.network_access=true must appear AFTER exec, got: {cmd}"
713        );
714    }
715
716    #[test]
717    fn build_command_codex_no_extra_writable_dirs() {
718        // With no extra_writable_dirs, --add-dir must not appear in the command.
719        let perms = PermissionRules::default();
720        let cmd = runner().build_command(None, "", "/tmp/sys.txt", "/tmp/msg.txt", &perms);
721        assert!(
722            !cmd.contains("--add-dir"),
723            "should not include --add-dir when no extra dirs, got: {cmd}"
724        );
725    }
726
727    // ── Fixture-based tests ─────────────────────────────────────
728
729    // ── Connection / transient error tests ────────────────────────
730
731    #[test]
732    fn classify_codex_stream_disconnected() {
733        let err = CodexRunner::classify_message("Reconnecting 3/5... stream disconnected");
734        assert!(
735            matches!(err, AgentError::NetworkError { .. }),
736            "expected NetworkError so fallback retries, got: {err:?}"
737        );
738    }
739
740    #[test]
741    fn classify_codex_websocket_error() {
742        let err = CodexRunner::classify_message("WebSocket connection closed unexpectedly");
743        assert!(
744            matches!(err, AgentError::NetworkError { .. }),
745            "expected NetworkError so fallback retries, got: {err:?}"
746        );
747    }
748
749    #[test]
750    fn classify_codex_event_stream_lagged() {
751        let err = CodexRunner::classify_message(
752            "in-process app-server event stream lagged; dropped 1 events",
753        );
754        assert!(
755            matches!(err, AgentError::NetworkError { .. }),
756            "expected NetworkError so fallback retries, got: {err:?}"
757        );
758    }
759
760    #[test]
761    fn classify_codex_econnreset() {
762        let err = CodexRunner::classify_message("ECONNRESET: connection reset by peer");
763        assert!(
764            matches!(err, AgentError::NetworkError { .. }),
765            "expected NetworkError so fallback retries, got: {err:?}"
766        );
767    }
768
769    // ── Production error patterns ─────────────────────────────────
770
771    #[test]
772    fn parse_codex_chatgpt_model_unsupported() {
773        // Real error: "The 'gpt-4.1' model is not supported when using Codex with a ChatGPT account."
774        let raw = r#"{"type":"error","message":"The 'gpt-4.1' model is not supported when using Codex with a ChatGPT account."}
775{"type":"turn.failed","error":{"message":"Model not supported"}}"#;
776
777        let err = runner().parse_response(raw).unwrap_err();
778        assert!(
779            matches!(err, AgentError::ModelUnavailable { .. }),
780            "got: {err:?}"
781        );
782        if let AgentError::ModelUnavailable { model, .. } = &err {
783            assert_eq!(model, "gpt-4.1");
784        }
785    }
786
787    #[test]
788    fn parse_codex_usage_limit_after_reconnect() {
789        // Real failure: stream disconnects, then usage limit hit.
790        // detect_error scans ALL events and prefers RateLimit over AgentFailed.
791        let raw = r#"{"type":"error","message":"Reconnecting 2/5"}
792{"type":"error","message":"Falling back from WebSockets to HTTPS transport"}
793{"type":"error","message":"You've hit your usage limit. Upgrade to Pro at https://..."}
794{"type":"turn.failed","error":{"message":"You've hit your usage limit"}}"#;
795
796        let err = runner().parse_response(raw).unwrap_err();
797        assert!(
798            matches!(err, AgentError::RateLimit { .. }),
799            "expected RateLimit (most specific), got: {err:?}"
800        );
801    }
802
803    #[test]
804    fn classify_error_chatgpt_model_unsupported() {
805        let stdout = r#"{"type":"error","message":"The 'gpt-4.1' model is not supported when using Codex with a ChatGPT account."}
806{"type":"turn.failed","error":{"message":"Model not supported"}}"#;
807
808        let err = runner().classify_error(1, stdout, "");
809        assert!(
810            matches!(err, AgentError::ModelUnavailable { .. }),
811            "got: {err:?}"
812        );
813    }
814
815    // ── Real output.json fixture tests ───────────────────────────
816
817    /// Real failure: websocket disconnections followed by usage limit.
818    /// RateLimit must take priority over AgentFailed (reconnect errors).
819    #[test]
820    fn fixture_codex_usage_limit() {
821        let raw = fixture::load(include_str!(
822            "../../../../tests/fixtures/codex_usage_limit.jsonl"
823        ));
824        let err = runner().parse_response(&raw.stdout).unwrap_err();
825        assert!(
826            matches!(err, AgentError::RateLimit { .. }),
827            "expected RateLimit (priority over reconnect errors), got: {err:?}"
828        );
829    }
830
831    /// Real failure: unsupported model with ChatGPT account.
832    #[test]
833    fn fixture_codex_model_unsupported() {
834        let raw = fixture::load(include_str!(
835            "../../../../tests/fixtures/codex_model_unsupported.jsonl"
836        ));
837        let err = runner().parse_response(&raw.stdout).unwrap_err();
838        assert!(
839            matches!(err, AgentError::ModelUnavailable { .. }),
840            "expected ModelUnavailable, got: {err:?}"
841        );
842        if let AgentError::ModelUnavailable { model, .. } = &err {
843            assert_eq!(model, "gpt-4.1");
844        }
845    }
846
847    // ── extract_text ─────────────────────────────────────────────
848
849    /// Codex: extract_text returns the agent_message text for review parsing.
850    #[test]
851    fn extract_text_returns_agent_message() {
852        let raw = concat!(
853            r#"{"type":"thread.started","thread_id":"t1"}"#,
854            "\n",
855            r#"{"type":"turn.started"}"#,
856            "\n",
857            r#"{"type":"item.completed","item":{"type":"reasoning","text":"Thinking..."}}"#,
858            "\n",
859            r#"{"type":"item.completed","item":{"type":"agent_message","text":"{\"decision\":\"approve\",\"notes\":\"LGTM\",\"test_results\":\"pass\",\"issues\":[]}"}}"#,
860            "\n",
861            r#"{"type":"turn.completed"}"#,
862        );
863        let text = runner().extract_text(raw).unwrap();
864        assert_eq!(
865            text,
866            r#"{"decision":"approve","notes":"LGTM","test_results":"pass","issues":[]}"#
867        );
868    }
869
870    /// Codex: extract_text propagates RateLimit for terminal errors.
871    #[test]
872    fn extract_text_rate_limit_propagates() {
873        let raw = concat!(
874            r#"{"type":"thread.started","thread_id":"t1"}"#,
875            "\n",
876            r#"{"type":"error","message":"You've hit your usage limit. Upgrade to continue."}"#,
877            "\n",
878            r#"{"type":"turn.failed","error":{"message":"usage limit exceeded"}}"#,
879        );
880        let err = runner().extract_text(raw).unwrap_err();
881        assert!(
882            matches!(err, AgentError::RateLimit { .. }),
883            "expected RateLimit, got: {err:?}"
884        );
885    }
886
887    /// Codex: extract_text propagates Auth error.
888    #[test]
889    fn extract_text_auth_error_propagates() {
890        let raw = concat!(
891            r#"{"type":"thread.started","thread_id":"t1"}"#,
892            "\n",
893            r#"{"type":"error","message":"401 Unauthorized: invalid api key"}"#,
894            "\n",
895            r#"{"type":"turn.failed","error":{"message":"auth failed"}}"#,
896        );
897        let err = runner().extract_text(raw).unwrap_err();
898        assert!(
899            matches!(err, AgentError::Auth { .. }),
900            "expected Auth, got: {err:?}"
901        );
902    }
903
904    /// Codex: extract_text on empty input returns empty string (not an error).
905    #[test]
906    fn extract_text_empty_input_returns_empty_ok() {
907        let text = runner().extract_text("").unwrap();
908        assert_eq!(text, "");
909    }
910
911    // ── find_codex_result ───────────────────────────────────────
912
913    #[test]
914    fn find_codex_result_success() {
915        let ndjson = concat!(
916            r#"{"type":"thread.started","thread_id":"t1"}"#,
917            "\n",
918            r#"{"type":"turn.started"}"#,
919            "\n",
920            r#"{"type":"item.completed","item":{"type":"agent_message","text":"{\"decision\":\"approve\",\"notes\":\"LGTM\"}"}}"#,
921            "\n",
922            r#"{"type":"turn.completed"}"#,
923        );
924        let result = find_codex_result(ndjson).expect("should find result");
925        assert!(!result.is_error);
926        assert!(result.result_text.contains("approve"));
927    }
928
929    #[test]
930    fn find_codex_result_error() {
931        let ndjson = concat!(
932            r#"{"type":"error","message":"You've hit your usage limit"}"#,
933            "\n",
934            r#"{"type":"turn.failed","error":{"message":"usage limit"}}"#,
935        );
936        let result = find_codex_result(ndjson).expect("should find error result");
937        assert!(result.is_error);
938        assert!(result.result_text.contains("rate limit"));
939    }
940
941    #[test]
942    fn find_codex_result_empty_returns_none() {
943        assert!(find_codex_result("").is_none());
944        assert!(find_codex_result("   ").is_none());
945    }
946
947    #[test]
948    fn find_codex_result_plain_text_returns_none() {
949        assert!(find_codex_result("just some plain text").is_none());
950    }
951
952    #[test]
953    fn find_codex_result_skips_reasoning_and_commands() {
954        let ndjson = concat!(
955            r#"{"type":"item.completed","item":{"type":"reasoning","text":"Thinking..."}}"#,
956            "\n",
957            r#"{"type":"item.completed","item":{"type":"command_execution","command":"cargo test"}}"#,
958            "\n",
959            r#"{"type":"item.completed","item":{"type":"agent_message","text":"All tests passed"}}"#,
960        );
961        let result = find_codex_result(ndjson).expect("should find result");
962        assert!(!result.is_error);
963        assert_eq!(result.result_text, "All tests passed");
964    }
965}
966
967// Codex wraps every command as `/bin/zsh -lc '<command>'` or `-lc "<command>"`
968static SHELL_WRAP: LazyLock<regex::Regex> = LazyLock::new(|| {
969    regex::Regex::new(r#"(?s)^\S*/(?:ba|z)?sh -l?c (?:'(.*)'|"(.*)")$"#)
970        .expect("shell wrap regex is valid")
971});
972
973/// Codex `--json`: each finished step is an `item.completed` event
974fn stream_events(v: &serde_json::Value) -> Vec<StreamEvent> {
975    match json_str(v, "/type") {
976        "item.completed" => item_events(&v["item"]),
977        "turn.completed" => vec![StreamEvent::Done(String::new())],
978        "turn.failed" | "error" => vec![StreamEvent::Error(json_error_message(v))],
979        _ => vec![],
980    }
981}
982
983fn item_events(item: &serde_json::Value) -> Vec<StreamEvent> {
984    let id = json_str(item, "/id").to_string();
985    let call = |name: &str, input: serde_json::Value| StreamEvent::ToolCall {
986        id: id.clone(),
987        name: name.to_string(),
988        input,
989    };
990    match json_str(item, "/type") {
991        "agent_message" => vec![StreamEvent::Text(json_str(item, "/text").to_string())],
992        "reasoning" => vec![StreamEvent::Thinking(json_str(item, "/text").to_string())],
993        "command_execution" => {
994            let command = json_str(item, "/command");
995            let command = SHELL_WRAP
996                .captures(command)
997                .and_then(|c| c.get(1).or(c.get(2)))
998                .map_or(command, |m| m.as_str());
999            vec![
1000                call("Bash", serde_json::json!({ "command": command })),
1001                StreamEvent::ToolResult {
1002                    id: id.clone(),
1003                    name: "Bash".to_string(),
1004                    output: json_str(item, "/aggregated_output").to_string(),
1005                    is_error: item["exit_code"].as_i64().is_some_and(|c| c != 0),
1006                },
1007            ]
1008        }
1009        "file_change" => item["changes"]
1010            .as_array()
1011            .into_iter()
1012            .flatten()
1013            .map(|c| call("Edit", serde_json::json!({ "path": c["path"] })))
1014            .collect(),
1015        "mcp_tool_call" => {
1016            let name = format!("{}.{}", json_str(item, "/server"), json_str(item, "/tool"));
1017            vec![call(&name, item["arguments"].clone())]
1018        }
1019        "web_search" => vec![call(
1020            "Search",
1021            serde_json::json!({ "query": json_str(item, "/query") }),
1022        )],
1023        "error" => vec![StreamEvent::Error(json_str(item, "/message").to_string())],
1024        _ => vec![],
1025    }
1026}
1027
1028#[cfg(test)]
1029mod stream_tests {
1030    use super::*;
1031    use serde_json::json;
1032
1033    fn events(line: &str) -> Vec<StreamEvent> {
1034        CodexRunner.stream_events(&serde_json::from_str(line).unwrap())
1035    }
1036
1037    #[test]
1038    fn message_and_reasoning() {
1039        let msg = r#"{"type":"item.completed","item":{"id":"i0","type":"agent_message","text":"Fixing."}}"#;
1040        assert_eq!(events(msg), vec![StreamEvent::Text("Fixing.".into())]);
1041        let think =
1042            r#"{"type":"item.completed","item":{"id":"i1","type":"reasoning","text":"**Plan**"}}"#;
1043        assert_eq!(
1044            events(think),
1045            vec![StreamEvent::Thinking("**Plan**".into())]
1046        );
1047    }
1048
1049    #[test]
1050    fn command_unwraps_shell_and_carries_result() {
1051        let line = r#"{"type":"item.completed","item":{"id":"i2","type":"command_execution","command":"/bin/zsh -lc 'git status --short'","aggregated_output":"M a.rs\n","exit_code":1}}"#;
1052        assert_eq!(
1053            events(line),
1054            vec![
1055                StreamEvent::ToolCall {
1056                    id: "i2".into(),
1057                    name: "Bash".into(),
1058                    input: json!({"command": "git status --short"}),
1059                },
1060                StreamEvent::ToolResult {
1061                    id: "i2".into(),
1062                    name: "Bash".into(),
1063                    output: "M a.rs\n".into(),
1064                    is_error: true,
1065                },
1066            ]
1067        );
1068    }
1069
1070    #[test]
1071    fn command_unwraps_double_quoted_shell() {
1072        let line = r#"{"type":"item.completed","item":{"id":"i4","type":"command_execution","command":"/bin/zsh -lc \"rg --files .github\"","aggregated_output":"","exit_code":0}}"#;
1073        assert_eq!(
1074            events(line)[0],
1075            StreamEvent::ToolCall {
1076                id: "i4".into(),
1077                name: "Bash".into(),
1078                input: json!({"command": "rg --files .github"}),
1079            }
1080        );
1081    }
1082
1083    #[test]
1084    fn file_change_is_an_edit_per_path() {
1085        let line = r#"{"type":"item.completed","item":{"id":"i3","type":"file_change","changes":[{"path":"a.rs","kind":"update"},{"path":"b.rs","kind":"add"}]}}"#;
1086        let calls: Vec<String> = events(line)
1087            .into_iter()
1088            .map(|e| match e {
1089                StreamEvent::ToolCall { name, input, .. } => format!("{name} {}", input["path"]),
1090                other => format!("{other:?}"),
1091            })
1092            .collect();
1093        assert_eq!(calls, vec![r#"Edit "a.rs""#, r#"Edit "b.rs""#]);
1094    }
1095
1096    #[test]
1097    fn errors_and_turn_end() {
1098        assert_eq!(
1099            events(r#"{"type":"error","message":"Reconnecting... 2/5"}"#),
1100            vec![StreamEvent::Error("Reconnecting... 2/5".into())]
1101        );
1102        assert_eq!(
1103            events(r#"{"type":"turn.failed","error":{"message":"quota exceeded"}}"#),
1104            vec![StreamEvent::Error("quota exceeded".into())]
1105        );
1106        assert_eq!(
1107            events(r#"{"type":"turn.completed","usage":{}}"#),
1108            vec![StreamEvent::Done(String::new())]
1109        );
1110    }
1111
1112    #[test]
1113    fn started_items_are_dropped() {
1114        let started =
1115            r#"{"type":"item.started","item":{"type":"command_execution","command":"ls"}}"#;
1116        let dropped = events(started);
1117        assert!(dropped.is_empty(), "{dropped:?}");
1118        let dropped = events(r#"{"type":"thread.started","thread_id":"t"}"#);
1119        assert!(dropped.is_empty(), "{dropped:?}");
1120    }
1121}