fix(usage): 修复含失败信号的 pending 请求被误判为活跃的问题

- pending/streaming 状态含 status_code >= 400 或 error_message 时视为 failed
- 候选状态派生改为 failed 优先于 stale pending/streaming
- 活跃请求轮询时保留失败信号字段的更新
- 图片流支持 partial_image 事件转发及从 response.completed 读取最终图片

apps/aether-gateway/src/handlers/admin/observability/monitoring/tests/trace.rs

@@ -76,6 +76,51 @@ async fn admin_monitoring_trace_request_returns_local_payload() {
     assert_eq!(payload["candidates"][0]["status_code"], json!(502));
 }
 
+#[tokio::test]
+async fn admin_monitoring_trace_final_status_prefers_failed_over_stale_pending() {
+    let request_candidates = Arc::new(InMemoryRequestCandidateRepository::seed(vec![
+        sample_candidate(
+            "cand-stale-pending",
+            "request-1",
+            0,
+            RequestCandidateStatus::Pending,
+            None,
+            None,
+            None,
+        ),
+        sample_candidate(
+            "cand-failed",
+            "request-1",
+            1,
+            RequestCandidateStatus::Failed,
+            Some(101),
+            Some(33),
+            Some(502),
+        ),
+    ]));
+    let provider_catalog = Arc::new(InMemoryProviderCatalogReadRepository::seed(
+        vec![sample_provider()],
+        vec![sample_endpoint()],
+        vec![sample_key()],
+    ));
+    let state = AppState::new()
+        .expect("state should build")
+        .with_decision_trace_data_readers_for_tests(request_candidates, provider_catalog);
+    let context = request_context(http::Method::GET, "/api/admin/monitoring/trace/request-1");
+
+    let response = local_monitoring_response(&state, &context)
+        .await
+        .expect("handler should not error")
+        .expect("route should be handled locally");
+
+    assert_eq!(response.status(), http::StatusCode::OK);
+    let body = to_bytes(response.into_body(), usize::MAX)
+        .await
+        .expect("body should read");
+    let payload: serde_json::Value = serde_json::from_slice(&body).expect("json body should parse");
+    assert_eq!(payload["final_status"], json!("failed"));
+}
+
 #[tokio::test]
 async fn admin_monitoring_trace_request_keeps_format_conversion_disabled_candidates_visible() {
     let mut format_disabled_candidate = sample_candidate(

apps/aether-gateway/src/handlers/admin/observability/usage/summary_routes.rs

@@ -6,10 +6,11 @@ use crate::handlers::admin::shared::query_param_value;
 use crate::GatewayError;
 use aether_admin::observability::usage::{
     admin_usage_bad_request_response, admin_usage_data_unavailable_response,
-    admin_usage_has_fallback, admin_usage_matches_search, admin_usage_matches_username,
-    admin_usage_parse_ids, admin_usage_parse_limit, admin_usage_parse_offset,
-    build_admin_usage_active_requests_response, build_admin_usage_records_response,
-    build_admin_usage_summary_stats_response_from_summary, ADMIN_USAGE_DATA_UNAVAILABLE_DETAIL,
+    admin_usage_has_fallback, admin_usage_is_failed, admin_usage_matches_search,
+    admin_usage_matches_username, admin_usage_parse_ids, admin_usage_parse_limit,
+    admin_usage_parse_offset, build_admin_usage_active_requests_response,
+    build_admin_usage_records_response, build_admin_usage_summary_stats_response_from_summary,
+    ADMIN_USAGE_DATA_UNAVAILABLE_DETAIL,
 };
 use aether_data_contracts::repository::usage::{
     StoredRequestUsageAudit, UsageAuditKeywordSearchQuery, UsageAuditListQuery,
@@ -305,6 +306,14 @@ pub(super) async fn maybe_build_local_admin_usage_summary_response(
                     })
                     .await?
             };
+            let items = if requested_ids.is_some() {
+                items
+            } else {
+                items
+                    .into_iter()
+                    .filter(|item| !admin_usage_is_failed(item))
+                    .collect::<Vec<_>>()
+            };
             let api_key_names = admin_usage_api_key_names(state, &items).await?;
             let provider_key_names = admin_usage_provider_key_names(state, &items).await?;
 

apps/aether-gateway/src/handlers/public/support/user_me_usage.rs

@@ -404,6 +404,8 @@ fn build_users_me_usage_active_payload(item: &StoredRequestUsageAudit) -> serde_
         "rate_multiplier": item.settlement_rate_multiplier(),
         "response_time_ms": item.response_time_ms,
         "first_byte_time_ms": item.first_byte_time_ms,
+        "status_code": item.status_code,
+        "error_message": item.error_message,
         "api_format": item.api_format,
         "endpoint_api_format": item.endpoint_api_format,
         "is_stream": item.is_stream,
@@ -435,6 +437,24 @@ fn build_users_me_usage_active_payload(item: &StoredRequestUsageAudit) -> serde_
     payload
 }
 
+fn users_me_usage_is_failed(item: &StoredRequestUsageAudit) -> bool {
+    let has_failure_signal = item.status_code.is_some_and(|value| value >= 400)
+        || item
+            .error_message
+            .as_deref()
+            .is_some_and(|value| !value.trim().is_empty());
+    let status = item.status.trim().to_ascii_lowercase();
+    if status.is_empty() {
+        return has_failure_signal;
+    }
+    match status.as_str() {
+        "completed" | "cancelled" => false,
+        "pending" | "streaming" => has_failure_signal,
+        "failed" => true,
+        _ => false,
+    }
+}
+
 fn build_users_me_usage_summary_by_model(
     rows: &[StoredUsageBreakdownSummaryRow],
     include_actual_cost: bool,
@@ -997,6 +1017,15 @@ pub(super) async fn handle_users_me_usage_active_get(
         },
     };
 
+    let items = if ids.is_some() {
+        items
+    } else {
+        items
+            .into_iter()
+            .filter(|item| !users_me_usage_is_failed(item))
+            .collect::<Vec<_>>()
+    };
+
     Json(json!({
         "requests": items
             .iter()
@@ -1233,7 +1262,8 @@ mod tests {
 
     use super::{
         build_users_me_usage_active_payload, build_users_me_usage_record_payload,
-        users_me_usage_client_is_stream, users_me_usage_upstream_is_stream,
+        users_me_usage_client_is_stream, users_me_usage_is_failed,
+        users_me_usage_upstream_is_stream,
     };
 
     fn sample_usage(status: &str) -> StoredRequestUsageAudit {
@@ -1310,6 +1340,17 @@ mod tests {
         assert_eq!(payload["cache_creation_ephemeral_1h_input_tokens"], 6);
     }
 
+    #[test]
+    fn user_usage_active_pending_with_failure_signal_is_not_active() {
+        let item = StoredRequestUsageAudit {
+            status_code: Some(503),
+            error_message: Some("upstream failed".to_string()),
+            ..sample_usage("pending")
+        };
+
+        assert!(users_me_usage_is_failed(&item));
+    }
+
     #[test]
     fn user_usage_payloads_include_symmetric_stream_fields() {
         let item = StoredRequestUsageAudit {