[core] add optional status_code to error events (#6865)

We want to better uncover error status code for clients. Add an optional
status_code to error events (thread error, error, stream error) so app
server could uncover the status code from the client side later.

in event log:
```
< {
<   "method": "codex/event/stream_error",
<   "params": {
<     "conversationId": "019a9a32-f576-7292-9711-8e57e8063536",
<     "id": "0",
<     "msg": {
<       "message": "Reconnecting... 5/5",
<       "status_code": 401,
<       "type": "stream_error"
<     }
<   }
< }
< {
<   "method": "codex/event/error",
<   "params": {
<     "conversationId": "019a9a32-f576-7292-9711-8e57e8063536",
<     "id": "0",
<     "msg": {
<       "message": "exceeded retry limit, last status: 401 Unauthorized, request id: 9a0cb03a485067f7-SJC",
<       "status_code": 401,
<       "type": "error"
<     }
<   }
< }
```

codex-rs/core/src/error.rs

@@ -10,6 +10,7 @@ use chrono::Local;
 use chrono::Utc;
 use codex_async_utils::CancelErr;
 use codex_protocol::ConversationId;
+use codex_protocol::protocol::ErrorEvent;
 use codex_protocol::protocol::RateLimitSnapshot;
 use reqwest::StatusCode;
 use serde_json;
@@ -430,6 +431,37 @@ impl CodexErr {
     pub fn downcast_ref<T: std::any::Any>(&self) -> Option<&T> {
         (self as &dyn std::any::Any).downcast_ref::<T>()
     }
+
+    pub fn http_status_code(&self) -> Option<StatusCode> {
+        match self {
+            CodexErr::UnexpectedStatus(err) => Some(err.status),
+            CodexErr::RetryLimit(err) => Some(err.status),
+            CodexErr::UsageLimitReached(_) | CodexErr::UsageNotIncluded => {
+                Some(StatusCode::TOO_MANY_REQUESTS)
+            }
+            CodexErr::InternalServerError => Some(StatusCode::INTERNAL_SERVER_ERROR),
+            CodexErr::ResponseStreamFailed(err) => err.source.status(),
+            CodexErr::ConnectionFailed(err) => err.source.status(),
+            _ => None,
+        }
+    }
+
+    pub fn to_error_event(&self, message_prefix: Option<String>) -> ErrorEvent {
+        let error_message = self.to_string();
+        let message: String = match message_prefix {
+            Some(prefix) => format!("{prefix}: {error_message}"),
+            None => error_message,
+        };
+
+        ErrorEvent {
+            message,
+            http_status_code: http_status_code_value(self.http_status_code()),
+        }
+    }
+}
+
+pub fn http_status_code_value(http_status_code: Option<StatusCode>) -> Option<u16> {
+    http_status_code.as_ref().map(StatusCode::as_u16)
 }
 
 pub fn get_error_message_ui(e: &CodexErr) -> String {
@@ -775,4 +807,43 @@ mod tests {
             assert_eq!(err.to_string(), expected);
         });
     }
+
+    #[test]
+    fn error_event_includes_http_status_code_when_available() {
+        let err = CodexErr::UnexpectedStatus(UnexpectedResponseError {
+            status: StatusCode::BAD_REQUEST,
+            body: "oops".to_string(),
+            request_id: Some("req-1".to_string()),
+        });
+        let event = err.to_error_event(None);
+
+        assert_eq!(
+            event.message,
+            "unexpected status 400 Bad Request: oops, request id: req-1"
+        );
+        assert_eq!(
+            event.http_status_code,
+            Some(StatusCode::BAD_REQUEST.as_u16())
+        );
+    }
+
+    #[test]
+    fn error_event_omits_http_status_code_when_unknown() {
+        let event = CodexErr::Fatal("boom".to_string()).to_error_event(None);
+
+        assert_eq!(event.message, "Fatal error: boom");
+        assert_eq!(event.http_status_code, None);
+    }
+
+    #[test]
+    fn error_event_applies_message_wrapper() {
+        let event = CodexErr::Fatal("boom".to_string())
+            .to_error_event(Some("Error running remote compact task".to_string()));
+
+        assert_eq!(
+            event.message,
+            "Error running remote compact task: Fatal error: boom"
+        );
+        assert_eq!(event.http_status_code, None);
+    }
 }