1use 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#[derive(Debug)]
59pub struct CodexRunner;
60
61impl CodexRunner {
62 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 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 texts.pop()
100 }
101
102 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 fn classify_message(message: &str) -> AgentError {
150 let lower = message.to_lowercase();
151
152 if let Some(e) = super::patterns::detect_rate_limit(message) {
154 return e;
155 }
156
157 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 if let Some(e) = super::patterns::detect_auth_error(message) {
172 return e;
173 }
174
175 if let Some(e) = super::patterns::detect_context_overflow(message) {
177 return e;
178 }
179
180 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 if let Some(err) = Self::detect_error(&events) {
228 return Err(err);
229 }
230
231 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 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 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 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 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 if let Some(err) = Self::detect_error(&events) {
334 return Err(err);
335 }
336
337 let agent_text =
339 Self::extract_agent_text(&events).ok_or_else(|| AgentError::InvalidResponse {
340 raw: trimmed.to_string(),
341 })?;
342
343 let response = match parser::parse(&agent_text) {
345 Ok(r) => r,
346 Err(_) => {
347 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 let events = super::parse_ndjson(stdout);
369 if let Some(err) = Self::detect_error(&events) {
370 return err;
371 }
372
373 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
389fn extract_model_name(message: &str) -> Option<String> {
395 extract_quoted(message, '`').or_else(|| extract_quoted(message, '\''))
396}
397
398fn 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
406pub 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 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 #[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 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 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 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 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 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 #[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 #[test]
772 fn parse_codex_chatgpt_model_unsupported() {
773 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 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 #[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 #[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 #[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 #[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 #[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 #[test]
906 fn extract_text_empty_input_returns_empty_ok() {
907 let text = runner().extract_text("").unwrap();
908 assert_eq!(text, "");
909 }
910
911 #[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
967static 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
973fn 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}