use super::*; use base64::Engine; use codex_http_client::RetryAfter; use codex_protocol::protocol::CodexErrorInfo; use codex_protocol::protocol::RateLimitReachedType; use pretty_assertions::assert_eq; #[test] fn map_api_error_maps_server_overloaded() { let err = map_api_error(ApiError::ServerOverloaded { retry_after: None }); assert!(matches!(err.details(), CodexErrorDetails::ServerOverloaded)); } #[tokio::test(start_paused = true)] async fn http_policy_capacity_preserves_retry_advice_and_terminal_behavior() { use std::time::Duration; for (code, expected) in [ ( "policy_capacity_unavailable", CodexErrorInfo::PolicyCapacityUnavailable, ), ("server_is_overloaded", CodexErrorInfo::ServerOverloaded), ] { for advice in [RetryAfter::from_delay(Duration::from_secs(3)), None] { let error = map_api_error(ApiError::Transport(TransportError::Http { status: http::StatusCode::SERVICE_UNAVAILABLE, url: None, headers: None, body: Some( serde_json::json!({"error": { "code": code, "type": "service_unavailable_error", }}) .to_string(), ), retry_after: advice, })); assert_eq!( ( error.to_codex_protocol_error(), error.retry_after(), error.retry_delay(/*retry_count*/ 1) ), ( expected.clone(), advice, advice.map(|_| Duration::from_secs(3)) ) ); } } } #[test] fn map_api_error_preserves_content_filter_retry_and_public_error() { let err = map_api_error(ApiError::ContentFilter); assert!(matches!(err.details(), CodexErrorDetails::ContentFilter)); assert_eq!( ( err.retry_delay(/*retry_count*/ 1).is_some(), err.to_codex_protocol_error(), err.to_string(), ), ( true, CodexErrorInfo::Other, "stream disconnected before completion: Incomplete response returned, reason: content_filter" .to_string(), ) ); } #[tokio::test(start_paused = true)] async fn map_api_error_preserves_retry_delay() { let retry_delay = std::time::Duration::from_secs(17); let retry_after = RetryAfter::from_delay(retry_delay).expect("retry advice"); for (error, expected_code, expected_message) in [ ( ApiError::Retryable { message: "retry later".to_string(), retry_after: Some(retry_after), }, CodexErrorInfo::Other, "stream disconnected before completion: retry later", ), ( ApiError::RateLimitExceeded { message: "retry later".to_string(), retry_after: Some(retry_after), }, CodexErrorInfo::RateLimitExceeded, "rate limit exceeded: retry later", ), ] { let err = map_api_error(error); assert_eq!( ( err.to_codex_protocol_error(), err.retry_delay(/*retry_count*/ 1), err.retry_after(), err.server_retry_delay(), err.http_status_code_value(), err.to_string(), ), ( expected_code, Some(retry_delay), Some(retry_after), Some(retry_delay), None, expected_message.to_string(), ) ); } } /// Mapping a new error category preserves elapsed advice without making hard failures retryable. #[tokio::test(start_paused = true)] async fn http_retry_deadline_survives_mapping_and_respects_terminal_errors() { use std::time::Duration; let advice = RetryAfter::from_delay(Duration::from_secs(10)).expect("retry advice"); tokio::time::advance(Duration::from_secs(4)).await; for (status, code, retryable) in [ (503, "server_is_overloaded", true), (429, "rate_limit_exceeded", true), (429, "insufficient_quota", false), (429, "usage_limit_reached", false), (400, "cyber_policy", false), ] { let error = map_api_error(ApiError::Transport(TransportError::Http { status: http::StatusCode::from_u16(status).unwrap(), url: None, headers: None, body: Some(serde_json::json!({"error": {"type": code, "code": code, "message": "sensitive upstream detail"}}).to_string()), retry_after: Some(advice), })); assert_eq!( (error.retry_after(), error.server_retry_delay()), (Some(advice), Some(Duration::from_secs(6))), "{code}", ); assert_eq!( error.retry_delay(/*retry_count*/ 1), retryable.then_some(Duration::from_secs(6)), "{code}", ); if status == 429 && retryable { assert_eq!( ( error.to_codex_protocol_error(), error.http_status_code_value(), error.to_string() ), ( CodexErrorInfo::ResponseTooManyFailedAttempts { http_status_code: Some(429), }, Some(429), "exceeded retry limit, last status: 429 Too Many Requests".to_string(), ), ); } } } #[test] fn map_http_error_classifies_provider_codes() { use CodexErrorInfo::ModelNotFound; for (status, code, expected, retryable) in [ ( 503, "server_is_overloaded", CodexErrorInfo::ServerOverloaded, false, ), (503, "slow_down", CodexErrorInfo::RateLimitExceeded, true), ( 503, "unknown_error", CodexErrorInfo::HttpConnectionFailed { http_status_code: Some(503), }, true, ), (400, "model_not_found", ModelNotFound, false), ( 400, "budget_reached", CodexErrorInfo::SessionBudgetExceeded, false, ), (403, "model_not_found", ModelNotFound, false), (404, "model_not_found", ModelNotFound, false), ( 404, "resource_not_found", CodexErrorInfo::HttpConnectionFailed { http_status_code: Some(404), }, true, ), ] { let err = map_api_error(ApiError::Transport(TransportError::Http { retry_after: None, status: http::StatusCode::from_u16(status).unwrap(), url: None, headers: None, body: Some( serde_json::json!({"error": {"code": code, "message": "retry later"}}).to_string(), ), })); if expected == ModelNotFound { assert_eq!(err.http_status_code_value(), Some(status)); } assert_eq!( ( err.to_codex_protocol_error(), err.retry_delay(/*retry_count*/ 1).is_some() ), (expected, retryable) ); } } #[test] fn map_api_error_maps_cloudflare_blocked_response_to_user_message() { let mut headers = HeaderMap::new(); headers.insert(CF_RAY_HEADER, http::HeaderValue::from_static("ray-id")); let err = map_api_error(ApiError::Transport(TransportError::Http { retry_after: None, status: http::StatusCode::FORBIDDEN, url: Some("http://example.com/blocked".to_string()), headers: Some(headers), body: Some( "Cloudflare error: Sorry, you have been blocked".to_string(), ), })); let CodexErrorDetails::UnexpectedStatus(err) = err.details() else { panic!("expected CodexErrorDetails::UnexpectedStatus, got {err:?}"); }; assert_eq!( err.user_message.as_deref(), Some( "Access blocked by Cloudflare. This usually happens when connecting from a restricted region (status 403 Forbidden)" ) ); assert_eq!( err.to_string(), "Access blocked by Cloudflare. This usually happens when connecting from a restricted region (status 403 Forbidden), url: http://example.com/blocked, cf-ray: ray-id" ); } #[test] fn map_api_error_maps_cyber_policy_from_400_body() { let body = serde_json::json!({ "error": { "message": "This request has been flagged for potentially high-risk cyber activity.", "type": "invalid_request", "param": null, "code": "cyber_policy" } }) .to_string(); let err = map_api_error(ApiError::Transport(TransportError::Http { retry_after: None, status: http::StatusCode::BAD_REQUEST, url: Some("http://example.com/v1/responses".to_string()), headers: None, body: Some(body), })); let CodexErrorDetails::CyberPolicy { message } = err.details() else { panic!("expected CodexErrorDetails::CyberPolicy, got {err:?}"); }; assert_eq!( message, "This request has been flagged for potentially high-risk cyber activity." ); } #[test] fn map_api_error_maps_wrapped_websocket_cyber_policy_from_400_body() { let body = serde_json::json!({ "type": "error", "status": 400, "error": { "message": "This websocket request was flagged.", "type": "invalid_request", "code": "cyber_policy" } }) .to_string(); let err = map_api_error(ApiError::Transport(TransportError::Http { retry_after: None, status: http::StatusCode::BAD_REQUEST, url: Some("ws://example.com/v1/responses".to_string()), headers: None, body: Some(body), })); let CodexErrorDetails::CyberPolicy { message } = err.details() else { panic!("expected CodexErrorDetails::CyberPolicy, got {err:?}"); }; assert_eq!(message, "This websocket request was flagged."); } #[test] fn map_api_error_uses_cyber_policy_fallback_for_missing_message() { let body = serde_json::json!({ "error": { "code": "cyber_policy" } }) .to_string(); let err = map_api_error(ApiError::Transport(TransportError::Http { retry_after: None, status: http::StatusCode::BAD_REQUEST, url: Some("http://example.com/v1/responses".to_string()), headers: None, body: Some(body), })); let CodexErrorDetails::CyberPolicy { message } = err.details() else { panic!("expected CodexErrorDetails::CyberPolicy, got {err:?}"); }; assert_eq!( message, "This request has been flagged for possible cybersecurity risk." ); } #[test] fn map_api_error_preserves_typed_errors() { let message = "This request was rejected."; for (error, expected_info) in [ ( ApiError::InferenceHookDenied { message: message.to_string(), }, CodexErrorInfo::InferenceHookDenied, ), ( ApiError::BioPolicy { message: message.to_string(), }, CodexErrorInfo::BioPolicy, ), ( ApiError::InvalidPrompt { message: message.to_string(), }, CodexErrorInfo::InvalidPrompt, ), ] { let err = map_api_error(error); assert_eq!(err.to_codex_protocol_error(), expected_info); assert_eq!(err.to_string(), message); assert_eq!(err.retry_delay(/*retry_count*/ 1), None); } } #[test] fn map_api_error_maps_http_and_wrapped_websocket_typed_errors() { for (status, code, expected_info, fallback) in [ ( http::StatusCode::BAD_REQUEST, "content_policy_violation", CodexErrorInfo::InvalidPrompt, "The input was rejected by the content policy.", ), ( http::StatusCode::BAD_REQUEST, "bio_policy", CodexErrorInfo::BioPolicy, "This content was flagged for possible biological risk.", ), ( http::StatusCode::BAD_REQUEST, "invalid_prompt", CodexErrorInfo::InvalidPrompt, "Invalid request.", ), ( http::StatusCode::FORBIDDEN, "inference_hook_denied", CodexErrorInfo::InferenceHookDenied, "Your workspace inference hook blocked this request.", ), ] { for wrapped in [false, true] { for (message, expected) in [ ( Some("This request was rejected."), "This request was rejected.", ), (None, fallback), (Some(""), fallback), (Some(" "), fallback), ] { let mut body = serde_json::json!({"error": {"code": code}}); if let Some(message) = message { body["error"]["message"] = serde_json::json!(message); } if wrapped { body["type"] = serde_json::json!("error"); body["status"] = serde_json::json!(status.as_u16()); } let err = map_api_error(ApiError::Transport(TransportError::Http { retry_after: None, status, url: None, headers: None, body: Some(body.to_string()), })); assert_eq!(err.to_string(), expected); assert_eq!(err.to_codex_protocol_error(), expected_info); assert_eq!(err.retry_delay(/*retry_count*/ 1), None); } } } } #[test] fn map_api_error_maps_misalignment_policy_violation_from_400_body() { assert_misalignment_policy_violation_from_http_body(http::StatusCode::BAD_REQUEST); } #[test] fn map_api_error_maps_misalignment_policy_violation_from_403_body() { assert_misalignment_policy_violation_from_http_body(http::StatusCode::FORBIDDEN); } fn assert_misalignment_policy_violation_from_http_body(status: http::StatusCode) { let body = serde_json::json!({ "error": { "message": "This request violated the misalignment policy.", "type": "invalid_request_error", "code": "misalignment_policy_violation" } }) .to_string(); let err = map_api_error(ApiError::Transport(TransportError::Http { retry_after: None, status, url: Some("http://example.com/v1/responses".to_string()), headers: None, body: Some(body), })); let CodexErrorDetails::MisalignmentPolicyViolation { message, misalignment, } = err.details() else { panic!("expected CodexErrorDetails::MisalignmentPolicyViolation, got {err:?}"); }; assert_eq!(message, "This request violated the misalignment policy."); assert_eq!(misalignment, &None); assert_eq!(err.retry_delay(/*retry_count*/ 1), None); } #[test] fn map_api_error_preserves_misalignment_details_from_403_body() { let body = serde_json::json!({ "error": { "message": "This request violated the misalignment policy.", "code": "misalignment_policy_violation", "misalignment": { "error_type": "unauthorized_data_transfer", "review_target": " RB/opaque== ", "detailed_explanation": "The agent attempted an external transfer.", "steer": { "message": "Do not transfer the user's files." } } } }) .to_string(); let err = map_api_error(ApiError::Transport(TransportError::Http { retry_after: None, status: http::StatusCode::FORBIDDEN, url: Some("http://example.com/v1/responses".to_string()), headers: None, body: Some(body), })); let CodexErrorDetails::MisalignmentPolicyViolation { message, misalignment, } = err.details() else { panic!("expected CodexErrorDetails::MisalignmentPolicyViolation, got {err:?}"); }; assert_eq!(message, "This request violated the misalignment policy."); assert_eq!( misalignment, &Some(MisalignmentErrorDetails { error_type: Some("unauthorized_data_transfer".to_string()), review_target: Some(" RB/opaque== ".to_string()), detailed_explanation: Some("The agent attempted an external transfer.".to_string()), steer: Some(codex_protocol::protocol::MisalignmentSteer { message: "Do not transfer the user's files.".to_string(), }), }) ); assert_eq!(err.retry_delay(/*retry_count*/ 1), None); } #[test] fn map_api_error_preserves_misalignment_details_from_wrapped_websocket_error() { let body = serde_json::json!({ "type": "error", "status": 403, "error": { "message": "This websocket request violated the misalignment policy.", "code": "misalignment_policy_violation", "misalignment": { "error_type": "future_safety_category", "review_target": " RB/opaque== ", "detailed_explanation": "The agent attempted an external transfer.", "steer": { "message": "Do not transfer the user's files." } } } }) .to_string(); let err = map_api_error(ApiError::Transport(TransportError::Http { retry_after: None, status: http::StatusCode::FORBIDDEN, url: Some("ws://example.com/v1/responses".to_string()), headers: None, body: Some(body), })); let CodexErrorDetails::MisalignmentPolicyViolation { message, misalignment, } = err.details() else { panic!("expected CodexErrorDetails::MisalignmentPolicyViolation, got {err:?}"); }; assert_eq!( message, "This websocket request violated the misalignment policy." ); assert_eq!( misalignment, &Some(MisalignmentErrorDetails { error_type: Some("future_safety_category".to_string()), review_target: Some(" RB/opaque== ".to_string()), detailed_explanation: Some("The agent attempted an external transfer.".to_string()), steer: Some(codex_protocol::protocol::MisalignmentSteer { message: "Do not transfer the user's files.".to_string(), }), }) ); assert_eq!(err.retry_delay(/*retry_count*/ 1), None); } #[test] fn map_api_error_keeps_other_400_errors_generic() { for code in ["invalid_request", "some_other_policy"] { let body = serde_json::json!({ "error": { "message": "Some other bad request.", "code": code } }) .to_string(); let err = map_api_error(ApiError::Transport(TransportError::Http { retry_after: None, status: http::StatusCode::BAD_REQUEST, url: Some("http://example.com/v1/responses".to_string()), headers: None, body: Some(body.clone()), })); let CodexErrorDetails::InvalidRequest(message) = err.details() else { panic!("expected CodexErrorDetails::InvalidRequest, got {err:?}"); }; assert_eq!(message, &body); } } #[test] fn map_api_error_distinguishes_http_quota_errors_from_rate_limits() { use CodexErrorInfo::ApiKeySpendLimitExceeded; use CodexErrorInfo::OrganizationSpendLimitExceeded; use CodexErrorInfo::ProjectSpendLimitExceeded; use CodexErrorInfo::UsageLimitExceeded; let rate_limit = CodexErrorInfo::ResponseTooManyFailedAttempts { http_status_code: Some(429), }; for (error, expected) in [ ( serde_json::json!({"type": "insufficient_quota"}), UsageLimitExceeded, ), ( serde_json::json!({"code": "insufficient_quota"}), UsageLimitExceeded, ), ( serde_json::json!({"code": "credit_balance_exhausted"}), UsageLimitExceeded, ), ( serde_json::json!({"type": "insufficient_quota", "code": "api_key_spend_limit_exceeded"}), ApiKeySpendLimitExceeded, ), ( serde_json::json!({"type": "insufficient_quota", "code": "organization_spend_limit_exceeded"}), OrganizationSpendLimitExceeded, ), ( serde_json::json!({"type": "insufficient_quota", "code": "project_spend_limit_exceeded"}), ProjectSpendLimitExceeded, ), ( serde_json::json!({"code": "organization_usage_limit_exceeded"}), UsageLimitExceeded, ), ( serde_json::json!({"type": "rate_limit_error", "code": "rate_limit_exceeded"}), rate_limit.clone(), ), ( serde_json::json!({"type": "rate_limit_error", "code": "slow_down"}), rate_limit, ), ] { let err = map_api_error(ApiError::Transport(TransportError::Http { retry_after: None, status: http::StatusCode::TOO_MANY_REQUESTS, url: None, headers: None, body: Some(serde_json::json!({"error": error}).to_string()), })); assert_eq!(err.to_codex_protocol_error(), expected, "{error}"); } } #[test] fn map_api_error_preserves_optional_usage_limit_window() { let cases = [ (None, None), (Some(serde_json::json!(null)), None), (Some(serde_json::json!(300)), Some(300)), (Some(serde_json::json!(10080)), Some(10080)), (Some(serde_json::json!(-1)), None), (Some(serde_json::json!(65536)), None), (Some(serde_json::json!("300")), None), (Some(serde_json::json!({"minutes": 300})), None), ]; for (window, expected) in cases { let mut body = serde_json::json!({ "error": { "type": "usage_limit_reached", "plan_type": "pro", } }); if let Some(window) = window.as_ref() { body["error"]["limit_window_minutes"] = window.clone(); } let err = map_api_error(ApiError::Transport(TransportError::Http { retry_after: None, status: http::StatusCode::TOO_MANY_REQUESTS, url: None, headers: None, body: Some(body.to_string()), })); let CodexErrorDetails::UsageLimitReached(usage_limit) = err.details() else { panic!("expected usage-limit error for {window:?}, got {err:?}"); }; assert_eq!(usage_limit.limit_window_minutes, expected, "{window:?}"); assert_eq!( err.to_codex_protocol_error(), CodexErrorInfo::UsageLimitExceeded ); } } #[test] fn map_api_error_maps_usage_limit_limit_name_header() { let mut headers = HeaderMap::new(); headers.insert( ACTIVE_LIMIT_HEADER, http::HeaderValue::from_static("codex_other"), ); headers.insert( "x-codex-other-limit-name", http::HeaderValue::from_static("codex_other"), ); let body = serde_json::json!({ "error": { "type": "usage_limit_reached", "plan_type": "pro", } }) .to_string(); let err = map_api_error(ApiError::Transport(TransportError::Http { retry_after: None, status: http::StatusCode::TOO_MANY_REQUESTS, url: Some("http://example.com/v1/responses".to_string()), headers: Some(headers), body: Some(body), })); let CodexErrorDetails::UsageLimitReached(usage_limit) = err.details() else { panic!("expected CodexErrorDetails::UsageLimitReached, got {err:?}"); }; assert_eq!( usage_limit .rate_limits .as_ref() .and_then(|snapshot| snapshot.limit_name.as_deref()), Some("codex_other") ); } #[test] fn map_api_error_does_not_fallback_limit_name_to_limit_id() { let mut headers = HeaderMap::new(); headers.insert( ACTIVE_LIMIT_HEADER, http::HeaderValue::from_static("codex_other"), ); let body = serde_json::json!({ "error": { "type": "usage_limit_reached", "plan_type": "pro", } }) .to_string(); let err = map_api_error(ApiError::Transport(TransportError::Http { retry_after: None, status: http::StatusCode::TOO_MANY_REQUESTS, url: Some("http://example.com/v1/responses".to_string()), headers: Some(headers), body: Some(body), })); let CodexErrorDetails::UsageLimitReached(usage_limit) = err.details() else { panic!("expected CodexErrorDetails::UsageLimitReached, got {err:?}"); }; assert_eq!( usage_limit .rate_limits .as_ref() .and_then(|snapshot| snapshot.limit_name.as_deref()), None ); } #[test] fn map_api_error_copies_rate_limit_reached_type_to_usage_limit_snapshot() { for (active_limit, expected_limit_id) in [(None, "codex"), (Some("codex_other"), "codex_other")] { let mut headers = HeaderMap::new(); if let Some(active_limit) = active_limit { headers.insert( ACTIVE_LIMIT_HEADER, http::HeaderValue::from_static(active_limit), ); } for (name, value) in [ ("x-codex-credits-has-credits", "true"), ("x-codex-credits-unlimited", "false"), ("x-codex-credits-balance", ""), ( "x-codex-rate-limit-reached-type", "workspace_member_usage_limit_reached", ), ] { headers.insert(name, http::HeaderValue::from_static(value)); } let body = serde_json::json!({ "error": { "type": "usage_limit_reached", "plan_type": "pro", } }) .to_string(); let err = map_api_error(ApiError::Transport(TransportError::Http { retry_after: None, status: http::StatusCode::TOO_MANY_REQUESTS, url: Some("http://example.com/v1/responses".to_string()), headers: Some(headers), body: Some(body), })); let CodexErrorDetails::UsageLimitReached(usage_limit) = err.details() else { panic!("expected CodexErrorDetails::UsageLimitReached, got {err:?}"); }; assert_eq!( usage_limit.rate_limit_reached_type, Some(RateLimitReachedType::WorkspaceMemberUsageLimitReached) ); let snapshot = usage_limit .rate_limits .as_ref() .expect("usage limit snapshot"); assert_eq!(snapshot.limit_id.as_deref(), Some(expected_limit_id)); assert_eq!( snapshot.rate_limit_reached_type, Some(RateLimitReachedType::WorkspaceMemberUsageLimitReached) ); assert_eq!( snapshot.credits.as_ref().map(|credits| ( credits.has_credits, credits.unlimited, credits.balance.as_deref() )), Some((true, false, None)) ); } } #[test] fn map_api_error_ignores_unparseable_rate_limit_reached_type_headers() { let values = [ http::HeaderValue::from_static("future_rate_limit_reached_type"), http::HeaderValue::from_bytes(&[0xff]).expect("valid opaque header value"), ]; for value in values { let mut headers = HeaderMap::new(); headers.insert("x-codex-rate-limit-reached-type", value); let body = serde_json::json!({ "error": { "type": "usage_limit_reached", "plan_type": "pro", } }) .to_string(); let err = map_api_error(ApiError::Transport(TransportError::Http { retry_after: None, status: http::StatusCode::TOO_MANY_REQUESTS, url: Some("http://example.com/v1/responses".to_string()), headers: Some(headers), body: Some(body), })); let CodexErrorDetails::UsageLimitReached(usage_limit) = err.details() else { panic!("expected CodexErrorDetails::UsageLimitReached, got {err:?}"); }; assert_eq!(usage_limit.rate_limit_reached_type, None); } } #[test] fn only_an_explicit_workspace_403_stops_retries() { use http::StatusCode; let provider = r#"{"error":{"code":"invalid_workspace_selected"}}"#; let detail = r#"{"detail":{"code":"invalid_workspace_selected"}}"#; let access_denied = r#"{"detail":{"code":"codex_workspace_access_denied"}}"#; let other = r#"{"detail":{"code":"route_rate_limited"}}"#; let workspace_header = http::HeaderValue::from_str(&base64::engine::general_purpose::STANDARD.encode(provider)) .unwrap(); for (status, body, with_header, terminal) in [ (StatusCode::FORBIDDEN, detail, false, true), (StatusCode::FORBIDDEN, access_denied, false, true), (StatusCode::SERVICE_UNAVAILABLE, access_denied, false, false), (StatusCode::FORBIDDEN, provider, false, true), (StatusCode::FORBIDDEN, "", true, true), (StatusCode::FORBIDDEN, "", false, false), ( StatusCode::FORBIDDEN, "invalid_workspace_selected", false, false, ), (StatusCode::FORBIDDEN, other, true, false), (StatusCode::UNAUTHORIZED, detail, true, false), ] { let mut headers = HeaderMap::new(); headers.insert(REQUEST_ID_HEADER, http::HeaderValue::from_static("req-403")); if with_header { headers.insert(X_ERROR_JSON_HEADER, workspace_header.clone()); } let err = map_api_error(ApiError::Transport(TransportError::Http { status, headers: Some(headers), body: Some(body.to_owned()), url: None, retry_after: None, })); assert_eq!( matches!(err.details(), CodexErrorDetails::WorkspaceAccessDenied(_)), terminal, "{err}" ); assert_eq!( err.retry_delay(/*retry_count*/ 1).is_none(), terminal, "{err}" ); assert_eq!(err.http_status_code_value(), Some(status.as_u16())); assert!(err.to_string().contains("req-403")); } } #[test] fn map_api_error_extracts_identity_auth_details_from_headers() { let mut headers = HeaderMap::new(); headers.insert(REQUEST_ID_HEADER, http::HeaderValue::from_static("req-401")); headers.insert(CF_RAY_HEADER, http::HeaderValue::from_static("ray-401")); headers.insert( X_OPENAI_AUTHORIZATION_ERROR_HEADER, http::HeaderValue::from_static("missing_authorization_header"), ); let x_error_json = base64::engine::general_purpose::STANDARD.encode(r#"{"error":{"code":"token_expired"}}"#); headers.insert( X_ERROR_JSON_HEADER, http::HeaderValue::from_str(&x_error_json).expect("valid x-error-json header"), ); let err = map_api_error(ApiError::Transport(TransportError::Http { retry_after: None, status: http::StatusCode::UNAUTHORIZED, url: Some("https://chatgpt.com/backend-api/codex/models".to_string()), headers: Some(headers), body: Some(r#"{"detail":"Unauthorized"}"#.to_string()), })); let CodexErrorDetails::UnexpectedStatus(err) = err.details() else { panic!("expected CodexErrorDetails::UnexpectedStatus, got {err:?}"); }; assert_eq!(err.request_id.as_deref(), Some("req-401")); assert_eq!(err.cf_ray.as_deref(), Some("ray-401")); assert_eq!( err.identity_authorization_error.as_deref(), Some("missing_authorization_header") ); assert_eq!(err.identity_error_code.as_deref(), Some("token_expired")); } #[test] fn runtime_auth_denials_stop_retries_without_losing_http_diagnostics() { for (status, code, retryable) in [ (403, "runtime_assertion_invalid", false), (403, "runtime_instance_paused", false), (403, "runtime_instance_revoked", false), (401, "invalid_agent_instance_assertion", false), (503, "runtime_verification_unavailable", true), (503, "agent_instance_authentication_unavailable", true), (401, "token_expired", true), (403, "ordinary_policy_denial", true), ] { for in_header in [false, true] { let status = http::StatusCode::from_u16(status).unwrap(); let details = serde_json::json!({"error": {"code": code}}).to_string(); let mut headers = http::HeaderMap::from_iter([( "x-request-id".parse().unwrap(), "request-runtime".parse().unwrap(), )]); let body = if in_header { headers.insert( X_ERROR_JSON_HEADER, base64::engine::general_purpose::STANDARD .encode(details) .parse() .unwrap(), ); r#"{"detail":"Unauthorized"}"#.to_owned() } else { details }; let error = map_api_error(ApiError::Transport(TransportError::Http { status, retry_after: None, url: Some("https://api.openai.com/v1/responses".into()), headers: Some(headers), body: Some(body.clone()), })); assert_eq!( error.retry_delay(/*retry_count*/ 1).is_some(), retryable, "{code}, in_header={in_header}" ); let CodexErrorDetails::UnexpectedStatus(details) = error.details() else { panic!("missing HTTP diagnostics: {error:?}"); }; assert_eq!( (&details.body, details.status, details.request_id.as_deref()), (&body, status, Some("request-runtime")) ); } } }