codex-rs/codex-api/src/api_bridge_tests.rs

use super::*;
use base64::Engine;
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);
    assert!(matches!(err.details(), CodexErrorDetails::ServerOverloaded));
}

#[test]
fn map_api_error_preserves_retry_delay() {
    let retry_delay = std::time::Duration::from_secs(17);
    for (error, expected_code, expected_message) in [
        (
            ApiError::Retryable {
                message: "retry later".to_string(),
                delay: Some(retry_delay),
            },
            CodexErrorInfo::Other,
            "stream disconnected before completion: retry later",
        ),
        (
            ApiError::RateLimitExceeded {
                message: "retry later".to_string(),
                delay: Some(retry_delay),
            },
            CodexErrorInfo::RateLimitExceeded,
            "rate limit exceeded: retry later",
        ),
    ] {
        let err = map_api_error(error);
        assert_eq!(
            (
                err.to_codex_protocol_error(),
                err.retry_delay(),
                err.is_retryable(),
                err.http_status_code_value(),
                err.to_string(),
            ),
            (
                expected_code,
                Some(retry_delay),
                true,
                None,
                expected_message.to_string(),
            )
        );
    }
}

#[test]
fn map_api_error_distinguishes_capacity_from_slow_down() {
    for (code, expected, retryable) in [
        (
            "server_is_overloaded",
            CodexErrorInfo::ServerOverloaded,
            false,
        ),
        ("slow_down", CodexErrorInfo::RateLimitExceeded, true),
        ("unknown_error", CodexErrorInfo::Other, true),
    ] {
        let err = map_api_error(ApiError::Transport(TransportError::Http {
            status: http::StatusCode::SERVICE_UNAVAILABLE,
            url: None,
            headers: None,
            body: Some(
                serde_json::json!({"error": {"code": code, "message": "retry later"}}).to_string(),
            ),
        }));
        assert_eq!(
            (err.to_codex_protocol_error(), err.is_retryable()),
            (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 {
        status: http::StatusCode::FORBIDDEN,
        url: Some("http://example.com/blocked".to_string()),
        headers: Some(headers),
        body: Some(
            "<html><body>Cloudflare error: Sorry, you have been blocked</body></html>".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 {
        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 {
        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 {
        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_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 {
        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!(!err.is_retryable());
}

#[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",
                "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 {
        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()),
            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!(!err.is_retryable());
}

#[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",
                "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 {
        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()),
            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!(!err.is_retryable());
}

#[test]
fn map_api_error_keeps_unknown_400_errors_generic() {
    let body = serde_json::json!({
        "error": {
            "message": "Some other bad request.",
            "code": "some_other_policy"
        }
    })
    .to_string();
    let err = map_api_error(ApiError::Transport(TransportError::Http {
        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() {
    for error in [
        serde_json::json!({"type": "insufficient_quota"}),
        serde_json::json!({"code": "insufficient_quota"}),
        serde_json::json!({"code": "credit_balance_exhausted"}),
        serde_json::json!({"code": "organization_spend_limit_exceeded"}),
        serde_json::json!({"code": "project_spend_limit_exceeded"}),
        serde_json::json!({"code": "organization_usage_limit_exceeded"}),
        serde_json::json!({"type": "rate_limit_error", "code": "rate_limit_exceeded"}),
        serde_json::json!({"type": "rate_limit_error", "code": "slow_down"}),
    ] {
        let expected = if error["type"] == "rate_limit_error" {
            CodexErrorInfo::ResponseTooManyFailedAttempts {
                http_status_code: Some(429),
            }
        } else {
            CodexErrorInfo::UsageLimitExceeded
        };
        let err = map_api_error(ApiError::Transport(TransportError::Http {
            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_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 {
        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 {
        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 {
            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 {
            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 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 {
        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"));
}