feat: add provider stream idle timeout and error handling

- Introduced a new `provider_stream_idle_timeout` configuration to manage idle timeouts for provider streams.
- Enhanced error handling in the `ProviderRouter` to include specific timeout errors for both request and stream idle scenarios.
- Updated the `AnthropicProvider` and `OpenAiChatProvider` to utilize the new error handling functions for improved SSE error reporting.
- Added tests to verify the correct behavior of timeout handling and error extraction from provider events.

server/src/app.rs

@@ -40,6 +40,7 @@ impl App {
         let provider = std::sync::Arc::new(ProviderRouter::new(
             store.clone(),
             config.provider_request_timeout,
+            config.provider_stream_idle_timeout,
         ));
         let registry = TransportRegistry::with_web_cache(
             store.clone(),

server/src/config.rs

@@ -10,7 +10,8 @@ const DATA_DIR_NAME: &str = ".cursor-byok-v3";
 const DATABASE_FILE_NAME: &str = "cursor-byok.db";
 const V0049_DATA_DIR_NAME: &str = ".cursor-local-assistant-v2";
 const V0049_CONFIG_FILE_NAME: &str = "config.yaml";
-const DEFAULT_PROVIDER_REQUEST_TIMEOUT: Duration = Duration::from_secs(3000);
+const DEFAULT_PROVIDER_REQUEST_TIMEOUT: Duration = Duration::from_secs(60 * 60);
+const DEFAULT_PROVIDER_STREAM_IDLE_TIMEOUT: Duration = Duration::from_secs(30 * 60);
 
 pub fn managed_data_dir() -> Result<PathBuf> {
     let home_dir = dirs::home_dir()
@@ -52,6 +53,7 @@ pub struct Config {
     pub listen_addr: SocketAddr,
     pub database_url: String,
     pub provider_request_timeout: Duration,
+    pub provider_stream_idle_timeout: Duration,
     pub console: Option<ConsoleSource>,
     pub use_persisted_ports: bool,
 }
@@ -102,6 +104,7 @@ impl Config {
             listen_addr,
             database_url: database_url_from_env()?,
             provider_request_timeout: request_timeout,
+            provider_stream_idle_timeout: DEFAULT_PROVIDER_STREAM_IDLE_TIMEOUT,
             console,
             use_persisted_ports: false,
         })
@@ -114,6 +117,7 @@ impl Config {
                 .expect("desktop listen address is static"),
             database_url: default_database_url()?,
             provider_request_timeout: DEFAULT_PROVIDER_REQUEST_TIMEOUT,
+            provider_stream_idle_timeout: DEFAULT_PROVIDER_STREAM_IDLE_TIMEOUT,
             console: None,
             use_persisted_ports: true,
         })
@@ -142,3 +146,20 @@ fn database_url_for_dir(data_dir: &std::path::Path) -> Result<String> {
         .ok_or_else(|| Error::Config("database path is not valid UTF-8".into()))?;
     Ok(format!("sqlite://{database_path}"))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn provider_timeout_defaults_match_runtime_boundaries() {
+        assert_eq!(
+            DEFAULT_PROVIDER_STREAM_IDLE_TIMEOUT,
+            Duration::from_secs(30 * 60)
+        );
+        assert_eq!(
+            DEFAULT_PROVIDER_REQUEST_TIMEOUT,
+            Duration::from_secs(60 * 60)
+        );
+    }
+}

server/src/provider/anthropic.rs

@@ -12,7 +12,7 @@ use crate::{
 };
 
 use super::{
-    merge_extra_params,
+    map_sse_error, merge_extra_params, provider_event_error,
     recorder::recorded_headers,
     retry::{send_with_retry, Attempt, RetryPolicy},
     CallRecorder, FinishReason, ModelEvent, Provider, ProviderStream,
@@ -129,8 +129,11 @@ impl Provider for AnthropicProvider {
                 _ = cancellation.cancelled() => { return; }
                 event = source.next() => event,
             } {
-                let event = event.map_err(|error| Error::Provider(format!("Anthropic SSE: {error}")))?;
+                let event = event.map_err(|error| map_sse_error("Anthropic", error))?;
                 let value: Value = serde_json::from_str(&event.data)?;
+                if let Some(error) = provider_event_error("Anthropic", &value) {
+                    Err(error)?;
+                }
                 let data_kind = value.get("type").and_then(Value::as_str);
                 let kind = match event.event.as_str() {
                     "" | "message" => data_kind.unwrap_or(event.event.as_str()),
@@ -242,7 +245,6 @@ impl Provider for AnthropicProvider {
                         };
                         yield ModelEvent::Done(finish);
                     }
-                    "error" => Err(Error::Provider(format!("Anthropic stream error: {}", event.data)))?,
                     _ => {}
                 }
             }

server/src/provider/mod.rs

@@ -32,6 +32,123 @@ pub trait Provider: Send + Sync {
     ) -> ProviderStream;
 }
 
+fn map_sse_error(
+    label: &str,
+    error: eventsource_stream::EventStreamError<crate::Error>,
+) -> crate::Error {
+    match error {
+        eventsource_stream::EventStreamError::Transport(error) => error,
+        eventsource_stream::EventStreamError::Utf8(error) => {
+            crate::Error::Provider(format!("{label} SSE UTF-8 error: {error}"))
+        }
+        eventsource_stream::EventStreamError::Parser(error) => {
+            crate::Error::Provider(format!("{label} SSE parse error: {error}"))
+        }
+    }
+}
+
+fn provider_event_error(label: &str, value: &serde_json::Value) -> Option<crate::Error> {
+    let kind = value.get("type").and_then(serde_json::Value::as_str);
+    let direct_error = value.get("error").filter(|error| !error.is_null());
+    if !matches!(kind, Some("error" | "response.failed")) && direct_error.is_none() {
+        return None;
+    }
+
+    let message = value
+        .get("message")
+        .and_then(serde_json::Value::as_str)
+        .or_else(|| {
+            value
+                .pointer("/error/message")
+                .and_then(serde_json::Value::as_str)
+        })
+        .or_else(|| {
+            value
+                .pointer("/response/error/message")
+                .and_then(serde_json::Value::as_str)
+        })
+        .or_else(|| direct_error.and_then(serde_json::Value::as_str))
+        .or_else(|| {
+            value
+                .pointer("/response/error")
+                .and_then(serde_json::Value::as_str)
+        })
+        .unwrap_or("provider returned an error event without a message");
+
+    Some(crate::Error::Provider(format!("{label} error: {message}")))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn sse_transport_errors_are_not_relabelled_as_parse_errors() {
+        let error = map_sse_error(
+            "test provider",
+            eventsource_stream::EventStreamError::Transport(crate::Error::Provider(
+                "connection closed".into(),
+            )),
+        );
+
+        let crate::Error::Provider(message) = error else {
+            panic!("transport error category must be preserved");
+        };
+        assert_eq!(message, "connection closed");
+    }
+
+    #[test]
+    fn provider_error_events_extract_flat_and_nested_messages() {
+        assert_provider_error(
+            "OpenAI Responses",
+            serde_json::json!({
+                "type": "error",
+                "message": "Internal error during token generation"
+            }),
+            "OpenAI Responses error: Internal error during token generation",
+        );
+        assert_provider_error(
+            "OpenAI Chat",
+            serde_json::json!({
+                "error": {"message": "quota exceeded", "type": "server_error"}
+            }),
+            "OpenAI Chat error: quota exceeded",
+        );
+        assert_provider_error(
+            "Anthropic",
+            serde_json::json!({
+                "type": "error",
+                "error": {"type": "overloaded_error", "message": "Overloaded"}
+            }),
+            "Anthropic error: Overloaded",
+        );
+        assert_provider_error(
+            "OpenAI Responses",
+            serde_json::json!({
+                "type": "response.failed",
+                "response": {"error": {"message": "generation failed"}}
+            }),
+            "OpenAI Responses error: generation failed",
+        );
+    }
+
+    #[test]
+    fn successful_provider_events_are_not_errors() {
+        assert!(provider_event_error(
+            "OpenAI Responses",
+            &serde_json::json!({"type": "response.completed", "error": null})
+        )
+        .is_none());
+    }
+
+    fn assert_provider_error(label: &str, value: serde_json::Value, expected: &str) {
+        let Some(crate::Error::Provider(message)) = provider_event_error(label, &value) else {
+            panic!("expected provider error");
+        };
+        assert_eq!(message, expected);
+    }
+}
+
 fn merge_extra_params(body: &mut serde_json::Value, extra: &serde_json::Value) -> Result<()> {
     let extra = extra
         .as_object()

server/src/provider/openai_chat.rs

@@ -17,7 +17,7 @@ use crate::{
 };
 
 use super::{
-    apply_openai_prompt_cache_key, merge_extra_params,
+    apply_openai_prompt_cache_key, map_sse_error, merge_extra_params, provider_event_error,
     recorder::recorded_headers,
     retry::{send_with_retry, Attempt, RetryPolicy},
     CallRecorder, FinishReason, ModelEvent, Provider, ProviderStream,
@@ -146,12 +146,14 @@ impl Provider for OpenAiChatProvider {
                     break;
                 };
                 let event = event.map_err(|error| {
-                    let err_msg = error.to_string();
                     tracing::debug!(iteration = loop_iteration, error = %error, "OpenAI Chat SSE event failed");
-                    Error::Provider(format!("OpenAI Chat SSE: {err_msg}"))
+                    map_sse_error("OpenAI Chat", error)
                 })?;
                 if event.data == "[DONE]" { saw_done_marker = true; break; }
                 let value: Value = serde_json::from_str(&event.data)?;
+                if let Some(error) = provider_event_error("OpenAI Chat", &value) {
+                    Err(error)?;
+                }
                 if let Some(usage) = value.get("usage").filter(|value| !value.is_null()) {
                     final_usage = Some(openai_usage(usage));
                 }

server/src/provider/openai_responses.rs

@@ -14,7 +14,7 @@ use crate::{
 };
 
 use super::{
-    apply_openai_prompt_cache_key, merge_extra_params,
+    apply_openai_prompt_cache_key, map_sse_error, merge_extra_params, provider_event_error,
     recorder::recorded_headers,
     retry::{send_with_retry, Attempt, RetryPolicy},
     CallRecorder, FinishReason, ModelEvent, Provider, ProviderStream,
@@ -126,9 +126,12 @@ impl Provider for OpenAiResponsesProvider {
                     event = source.next() => event,
                 };
                 let Some(event) = event else { break };
-                let event = event.map_err(|error| Error::Provider(format!("OpenAI Responses SSE: {error}")))?;
+                let event = event.map_err(|error| map_sse_error("OpenAI Responses", error))?;
                 if event.data == "[DONE]" { break; }
                 let value: Value = serde_json::from_str(&event.data)?;
+                if let Some(error) = provider_event_error("OpenAI Responses", &value) {
+                    Err(error)?;
+                }
                 let kind = value.get("type").and_then(Value::as_str).unwrap_or(&event.event);
                 match kind {
                     "response.output_text.delta" => {
@@ -247,7 +250,6 @@ impl Provider for OpenAiResponsesProvider {
                         terminal = true;
                         yield ModelEvent::Done(FinishReason::Length);
                     }
-                    "response.failed" => Err(Error::Provider(format!("OpenAI Responses failed: {}", event.data)))?,
                     _ => {}
                 }
             }

server/src/provider/router.rs

@@ -20,13 +20,15 @@ use super::{
 pub struct ProviderRouter {
     store: Store,
     request_timeout: Duration,
+    stream_idle_timeout: Duration,
 }
 
 impl ProviderRouter {
-    pub fn new(store: Store, request_timeout: Duration) -> Self {
+    pub fn new(store: Store, request_timeout: Duration, stream_idle_timeout: Duration) -> Self {
         Self {
             store,
             request_timeout,
+            stream_idle_timeout,
         }
     }
 }
@@ -39,6 +41,7 @@ impl Provider for ProviderRouter {
     ) -> ProviderStream {
         let store = self.store.clone();
         let request_timeout = self.request_timeout;
+        let stream_idle_timeout = self.stream_idle_timeout;
         Box::pin(try_stream! {
             let selected = invocation.request.model.model_id.clone();
             let model = store
@@ -96,12 +99,29 @@ impl Provider for ProviderRouter {
             tracing::debug!(
                 model = %selected,
                 provider_type = ?provider_type,
-                timeout_ms = config.request_timeout.as_millis() as u64,
+                request_timeout_ms = config.request_timeout.as_millis() as u64,
+                stream_idle_timeout_ms = stream_idle_timeout.as_millis() as u64,
                 "provider stream created"
             );
             let mut last_event_time = std::time::Instant::now();
             let mut event_count: u64 = 0;
-            while let Some(event) = stream.next().await {
+            loop {
+                let event = match next_provider_event(&mut stream, stream_idle_timeout).await {
+                    Ok(Some(event)) => event,
+                    Ok(None) => break,
+                    Err(_) => {
+                        let elapsed_ms = stream_started.elapsed().as_millis() as u64;
+                        let error = stream_idle_timeout_error(stream_idle_timeout);
+                        tracing::warn!(
+                            error = %error,
+                            elapsed_ms,
+                            event_count,
+                            idle_timeout_ms = stream_idle_timeout.as_millis() as u64,
+                            "provider stream idle timeout"
+                        );
+                        Err(error)
+                    }
+                };
                 let now = std::time::Instant::now();
                 let gap_ms = now.duration_since(last_event_time).as_millis() as u64;
                 let elapsed_ms = now.duration_since(stream_started).as_millis() as u64;
@@ -137,6 +157,7 @@ impl Provider for ProviderRouter {
                         yield event;
                     }
                     Err(error) => {
+                        let error = normalize_provider_stream_error(error, request_timeout);
                         tracing::debug!(
                             error = %error,
                             elapsed_ms,
@@ -169,6 +190,48 @@ impl Provider for ProviderRouter {
     }
 }
 
+async fn next_provider_event(
+    stream: &mut ProviderStream,
+    idle_timeout: Duration,
+) -> std::result::Result<Option<Result<super::ModelEvent>>, tokio::time::error::Elapsed> {
+    tokio::time::timeout(idle_timeout, stream.next()).await
+}
+
+fn stream_idle_timeout_error(idle_timeout: Duration) -> Error {
+    Error::Provider(format!(
+        "provider stream idle timeout: no events received for {} seconds ({} minutes)",
+        idle_timeout.as_secs(),
+        idle_timeout.as_secs() / 60
+    ))
+}
+
+fn request_timeout_error(request_timeout: Duration) -> Error {
+    Error::Provider(format!(
+        "provider request timed out after {} seconds ({} minutes)",
+        request_timeout.as_secs(),
+        request_timeout.as_secs() / 60
+    ))
+}
+
+fn normalize_provider_stream_error(error: Error, request_timeout: Duration) -> Error {
+    match error {
+        Error::Http(source) if source.is_timeout() => request_timeout_error(request_timeout),
+        Error::Http(source) if source.is_body() => Error::Provider(format!(
+            "provider stream transport failed while reading the response body: {}",
+            root_error_message(&source)
+        )),
+        error => error,
+    }
+}
+
+fn root_error_message(error: &(dyn std::error::Error + 'static)) -> String {
+    let mut current = error;
+    while let Some(source) = current.source() {
+        current = source;
+    }
+    current.to_string()
+}
+
 fn custom_headers(value: &serde_json::Value) -> Result<reqwest::header::HeaderMap> {
     let object = value
         .as_object()
@@ -223,3 +286,36 @@ fn build_inner(
     };
     Ok(Arc::new(NormalizedProvider::new(provider)))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn pending_provider_event_hits_the_idle_timeout() {
+        let mut stream: ProviderStream = Box::pin(futures_util::stream::pending());
+
+        let result = next_provider_event(&mut stream, Duration::from_millis(1)).await;
+
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn timeout_errors_state_the_boundary_and_duration() {
+        let Error::Provider(idle) = stream_idle_timeout_error(Duration::from_secs(30 * 60)) else {
+            panic!("idle timeout must be a provider error");
+        };
+        assert_eq!(
+            idle,
+            "provider stream idle timeout: no events received for 1800 seconds (30 minutes)"
+        );
+
+        let Error::Provider(request) = request_timeout_error(Duration::from_secs(60 * 60)) else {
+            panic!("request timeout must be a provider error");
+        };
+        assert_eq!(
+            request,
+            "provider request timed out after 3600 seconds (60 minutes)"
+        );
+    }
+}