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