feat: openai/codex mark transport sse parse errors as retryable (#2566)

Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Co-authored-by: Amit Singh <amitksingh1490@gmail.com>

Author: 3 people

crates/forge_repo/src/provider/openai_responses/repository.rs

@@ -249,7 +249,7 @@ impl<T: HttpInfra> OpenAIResponsesProvider<T> {
                             Err(e) => Some(Err(e)),
                         }
                     }
-                    Err(e) => Some(Err(anyhow::anyhow!("SSE parse error: {}", e))),
+                    Err(e) => Some(Err(into_sse_parse_error(e))),
                 }
             });
 
@@ -259,6 +259,20 @@ impl<T: HttpInfra> OpenAIResponsesProvider<T> {
     }
 }
 
+fn into_sse_parse_error<E>(error: eventsource_stream::EventStreamError<E>) -> anyhow::Error
+where
+    E: std::fmt::Debug + std::fmt::Display + Send + Sync + 'static,
+{
+    let is_retryable = matches!(&error, eventsource_stream::EventStreamError::Transport(_));
+    let error = anyhow::anyhow!("SSE parse error: {}", error);
+
+    if is_retryable {
+        forge_domain::Error::Retryable(error).into()
+    } else {
+        error
+    }
+}
+
 /// Derives an API base URL suitable for OpenAI Responses API from a configured
 /// endpoint URL.
 ///
@@ -382,6 +396,12 @@ mod tests {
     use super::*;
     use crate::provider::mock_server::MockServer;
 
+    fn is_retryable(error: &anyhow::Error) -> bool {
+        error
+            .downcast_ref::<forge_domain::Error>()
+            .is_some_and(|error| matches!(error, forge_domain::Error::Retryable(_)))
+    }
+
     fn make_credential(provider_id: ProviderId, key: &str) -> Option<forge_domain::AuthCredential> {
         Some(forge_domain::AuthCredential {
             id: provider_id,
@@ -803,6 +823,33 @@ mod tests {
         assert_eq!(headers[1].1, "value");
     }
 
+    #[test]
+    fn test_into_sse_parse_error_marks_transport_errors_retryable() {
+        let error = into_sse_parse_error(eventsource_stream::EventStreamError::Transport(
+            anyhow::anyhow!("error decoding response body"),
+        ));
+
+        assert!(is_retryable(&error));
+        assert_eq!(
+            error.to_string(),
+            "SSE parse error: Transport error: error decoding response body"
+        );
+    }
+
+    #[test]
+    fn test_into_sse_parse_error_keeps_utf8_errors_non_retryable() {
+        let error =
+            into_sse_parse_error(eventsource_stream::EventStreamError::<anyhow::Error>::Utf8(
+                String::from_utf8(vec![0xFF]).unwrap_err(),
+            ));
+
+        assert!(!is_retryable(&error));
+        assert_eq!(
+            error.to_string(),
+            "SSE parse error: UTF8 error: invalid utf-8 sequence of 1 bytes from index 0"
+        );
+    }
+
     #[test]
     fn test_get_headers_without_credential() {
         let provider = Provider {