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 _ => 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 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 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 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 if let Some(err) = Self::detect_error(&events) {
330 return Err(err);
331 }
332
333 let agent_text =
335 Self::extract_agent_text(&events).ok_or_else(|| AgentError::InvalidResponse {
336 raw: trimmed.to_string(),
337 })?;
338
339 let response = match parser::parse(&agent_text) {
341 Ok(r) => r,
342 Err(_) => {
343 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 let events = super::parse_ndjson(stdout);
365 if let Some(err) = Self::detect_error(&events) {
366 return err;
367 }
368
369 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
385fn extract_model_name(message: &str) -> Option<String> {
391 extract_quoted(message, '`').or_else(|| extract_quoted(message, '\''))
392}
393
394fn 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
402pub 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 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 #[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 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 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 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 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 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 #[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 #[test]
768 fn parse_codex_chatgpt_model_unsupported() {
769 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 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 #[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 #[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 #[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 #[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 #[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 #[test]
902 fn extract_text_empty_input_returns_empty_ok() {
903 let text = runner().extract_text("").unwrap();
904 assert_eq!(text, "");
905 }
906
907 #[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
963static 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
969fn 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}