mirror of
https://github.com/fawney19/Aether.git
synced 2026-09-17 00:17:46 +08:00
fix(conversion): improve stream failures and diagnostic exports
This commit is contained in:
elky
@@ -58,6 +58,7 @@ async fn admin_monitoring_trace_request_returns_local_payload() {
|
||||
.expect("route should be handled locally");
|
||||
|
||||
assert_eq!(response.status(), http::StatusCode::OK);
|
||||
assert!(response.headers().contains_key("x-aether-build-version"));
|
||||
let body = to_bytes(response.into_body(), usize::MAX)
|
||||
.await
|
||||
.expect("body should read");
|
||||
@@ -93,6 +94,15 @@ async fn admin_monitoring_trace_request_resolves_usage_id_to_header_trace_id() {
|
||||
Some(33),
|
||||
Some(200),
|
||||
),
|
||||
sample_candidate(
|
||||
"cand-other-attempt",
|
||||
"trace-1",
|
||||
1,
|
||||
RequestCandidateStatus::Failed,
|
||||
Some(100),
|
||||
Some(20),
|
||||
Some(502),
|
||||
),
|
||||
]));
|
||||
let provider_catalog = Arc::new(InMemoryProviderCatalogReadRepository::seed(
|
||||
vec![sample_provider()],
|
||||
@@ -110,6 +120,8 @@ async fn admin_monitoring_trace_request_resolves_usage_id_to_header_trace_id() {
|
||||
100,
|
||||
);
|
||||
usage.id = "usage-row-1".to_string();
|
||||
usage.request_body_state = Some(UsageBodyCaptureState::Reference);
|
||||
usage.response_body_state = Some(UsageBodyCaptureState::Reference);
|
||||
usage.candidate_id = Some("cand-used".to_string());
|
||||
usage.request_headers = Some(json!({
|
||||
"x-trace-id": "trace-1"
|
||||
@@ -140,6 +152,17 @@ async fn admin_monitoring_trace_request_resolves_usage_id_to_header_trace_id() {
|
||||
.expect("body should read");
|
||||
let payload: serde_json::Value = serde_json::from_slice(&body).expect("json body should parse");
|
||||
assert_eq!(payload["request_id"], json!("trace-1"));
|
||||
assert_eq!(payload["diagnostic_request"]["usage_id"], "usage-row-1");
|
||||
assert_eq!(
|
||||
payload["candidates"][0]["extra_data"]["diagnostic_context"]["usage_id"],
|
||||
"usage-row-1"
|
||||
);
|
||||
assert_eq!(
|
||||
payload["candidates"][0]["extra_data"]["diagnostic_context"]["body_states"]
|
||||
["response_body"],
|
||||
"reference"
|
||||
);
|
||||
assert!(payload["candidates"][1]["extra_data"]["diagnostic_context"].is_null());
|
||||
assert_eq!(payload["candidates"][0]["id"], json!("cand-used"));
|
||||
assert_eq!(
|
||||
payload["candidates"][0]["extra_data"]["first_byte_time_ms"],
|
||||
|
||||
@@ -67,13 +67,19 @@ pub(super) async fn build_admin_monitoring_trace_request_response(
|
||||
let key_accounts =
|
||||
build_admin_monitoring_key_account_display_map(admin_state, &resolved.trace).await?;
|
||||
|
||||
Ok(
|
||||
build_admin_monitoring_trace_request_payload_response_with_key_accounts(
|
||||
&resolved.trace,
|
||||
resolved.usage.as_ref(),
|
||||
&key_accounts,
|
||||
),
|
||||
)
|
||||
let mut response = build_admin_monitoring_trace_request_payload_response_with_key_accounts(
|
||||
&resolved.trace,
|
||||
resolved.usage.as_ref(),
|
||||
&key_accounts,
|
||||
);
|
||||
if let Ok(version) = axum::http::HeaderValue::from_str(
|
||||
option_env!("AETHER_BUILD_VERSION").unwrap_or(env!("CARGO_PKG_VERSION")),
|
||||
) {
|
||||
response
|
||||
.headers_mut()
|
||||
.insert("x-aether-build-version", version);
|
||||
}
|
||||
Ok(response)
|
||||
}
|
||||
|
||||
async fn resolve_admin_monitoring_trace(
|
||||
|
||||
@@ -312,6 +312,10 @@ pub fn build_admin_monitoring_trace_request_payload_response_with_key_accounts(
|
||||
"total_candidates": trace.total_candidates,
|
||||
"final_status": trace.final_status,
|
||||
"total_latency_ms": trace.total_latency_ms,
|
||||
"diagnostic_request": usage.filter(|usage| admin_monitoring_usage_matches_trace(usage, &trace.request_id)).map(|usage| json!({
|
||||
"usage_id": usage.id,
|
||||
"body_state": usage.request_body_state.map(|state| state.as_str()),
|
||||
})),
|
||||
"candidates": candidates,
|
||||
}))
|
||||
.into_response()
|
||||
@@ -337,6 +341,7 @@ pub fn build_admin_monitoring_trace_request_candidate_payload_with_key_accounts(
|
||||
item.sanitize_for_admin();
|
||||
let candidate = &item.candidate;
|
||||
let sanitized_extra_data = build_admin_monitoring_trace_candidate_extra_data(
|
||||
&candidate.id,
|
||||
candidate.extra_data.as_ref(),
|
||||
candidate.status_code,
|
||||
usage,
|
||||
@@ -518,6 +523,7 @@ fn build_admin_monitoring_trace_candidate_ranking(existing: Option<&Value>) -> V
|
||||
}
|
||||
|
||||
fn build_admin_monitoring_trace_candidate_extra_data(
|
||||
candidate_id: &str,
|
||||
existing: Option<&Value>,
|
||||
candidate_status_code: Option<u16>,
|
||||
usage: Option<&StoredRequestUsageAudit>,
|
||||
@@ -527,6 +533,19 @@ fn build_admin_monitoring_trace_candidate_extra_data(
|
||||
|
||||
if let Some(usage) = usage {
|
||||
let extra_object = extra_data.get_or_insert_with(serde_json::Map::new);
|
||||
if usage.routing_candidate_id() == Some(candidate_id) {
|
||||
extra_object.insert("diagnostic_context".to_string(), json!({
|
||||
"usage_id": usage.id,
|
||||
"model": usage.model,
|
||||
"target_model": usage.target_model,
|
||||
"body_states": {
|
||||
"request_body": usage.request_body_state.map(|state| state.as_str()),
|
||||
"provider_request_body": usage.provider_request_body_state.map(|state| state.as_str()),
|
||||
"response_body": usage.response_body_state.map(|state| state.as_str()),
|
||||
"client_response_body": usage.client_response_body_state.map(|state| state.as_str()),
|
||||
}
|
||||
}));
|
||||
}
|
||||
if let Some(first_byte_time_ms) = usage.first_byte_time_ms {
|
||||
extra_object
|
||||
.entry("first_byte_time_ms".to_string())
|
||||
@@ -577,8 +596,21 @@ fn build_admin_monitoring_trace_candidate_extra_data(
|
||||
}
|
||||
}
|
||||
|
||||
sanitize_request_candidate_extra_data_for_persistence(extra_data.map(Value::Object))
|
||||
.unwrap_or(Value::Null)
|
||||
let diagnostic_context = extra_data
|
||||
.as_mut()
|
||||
.and_then(|extra| extra.remove("diagnostic_context"));
|
||||
let mut sanitized =
|
||||
sanitize_request_candidate_extra_data_for_persistence(extra_data.map(Value::Object))
|
||||
.and_then(|value| value.as_object().cloned())
|
||||
.unwrap_or_default();
|
||||
if let Some(context) = diagnostic_context {
|
||||
sanitized.insert("diagnostic_context".to_string(), context);
|
||||
}
|
||||
if sanitized.is_empty() {
|
||||
Value::Null
|
||||
} else {
|
||||
Value::Object(sanitized)
|
||||
}
|
||||
}
|
||||
|
||||
fn admin_monitoring_trace_response_data(
|
||||
|
||||
@@ -238,3 +238,124 @@ impl fmt::Display for FormatError {
|
||||
}
|
||||
|
||||
impl Error for FormatError {}
|
||||
|
||||
impl FormatError {
|
||||
pub fn diagnostic(&self) -> Value {
|
||||
let (code, operation, field, reason) = match self {
|
||||
Self::UnsupportedFormat(_) => ("unsupported_format", "select_format", None, None),
|
||||
Self::RequestParseFailed { .. } => {
|
||||
("request_parse_failed", "parse_request", None, None)
|
||||
}
|
||||
Self::RequestEmitFailed { .. } => ("request_emit_failed", "emit_request", None, None),
|
||||
Self::ResponseParseFailed { .. } => {
|
||||
("response_parse_failed", "parse_response", None, None)
|
||||
}
|
||||
Self::ResponseEmitFailed { .. } => {
|
||||
("response_emit_failed", "emit_response", None, None)
|
||||
}
|
||||
Self::UnsupportedField { field, reason, .. } => {
|
||||
("unsupported_field", "validate", Some(field), Some(reason))
|
||||
}
|
||||
Self::UnauditedField { field, reason, .. } => {
|
||||
("unaudited_field", "validate", Some(field), Some(reason))
|
||||
}
|
||||
Self::InvalidEnumValue { field, .. } => {
|
||||
("invalid_enum_value", "validate", Some(field), None)
|
||||
}
|
||||
Self::LossyConversionBlocked { field, reason, .. } => (
|
||||
"lossy_conversion_blocked",
|
||||
"convert",
|
||||
Some(field),
|
||||
Some(reason),
|
||||
),
|
||||
Self::InvalidTargetField { field, reason, .. } => (
|
||||
"invalid_target_field",
|
||||
"validate_target",
|
||||
Some(field),
|
||||
Some(reason),
|
||||
),
|
||||
};
|
||||
let path = field.map(|field| {
|
||||
let path = if field.starts_with('$') {
|
||||
field.clone()
|
||||
} else {
|
||||
format!("$.{field}")
|
||||
};
|
||||
path.replace("[]", "[*]")
|
||||
});
|
||||
let mut diagnostic = json!({
|
||||
"code": code,
|
||||
"operation": operation,
|
||||
"path": path.as_deref().unwrap_or("$"),
|
||||
"path_source": if path.is_some() { "structured" } else { "unavailable" },
|
||||
"reason": reason,
|
||||
"expected": reason,
|
||||
"actual": null,
|
||||
"missing_context": if path.is_some() { vec![] } else { vec!["field_path", "underlying_cause"] }
|
||||
});
|
||||
if let Self::InvalidEnumValue { value, .. } = self {
|
||||
diagnostic["actual"] = json!(value);
|
||||
}
|
||||
match self {
|
||||
Self::UnsupportedFormat(format)
|
||||
| Self::RequestParseFailed { format }
|
||||
| Self::RequestEmitFailed { format }
|
||||
| Self::ResponseParseFailed { format }
|
||||
| Self::ResponseEmitFailed { format }
|
||||
| Self::UnsupportedField { format, .. }
|
||||
| Self::InvalidEnumValue { format, .. }
|
||||
| Self::InvalidTargetField { format, .. } => diagnostic["format"] = json!(format),
|
||||
_ => {}
|
||||
}
|
||||
if let Self::UnauditedField {
|
||||
source_format,
|
||||
target_format,
|
||||
..
|
||||
}
|
||||
| Self::LossyConversionBlocked {
|
||||
source_format,
|
||||
target_format,
|
||||
..
|
||||
} = self
|
||||
{
|
||||
diagnostic["source_format"] = json!(source_format);
|
||||
diagnostic["target_format"] = json!(target_format);
|
||||
}
|
||||
diagnostic
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod diagnostic_tests {
|
||||
use super::FormatError;
|
||||
use serde_json::json;
|
||||
|
||||
#[test]
|
||||
fn enum_diagnostic_retains_full_path_and_actual_value() {
|
||||
let diagnostic = FormatError::InvalidEnumValue {
|
||||
format: "openai:chat".to_string(),
|
||||
field: "choices[].finish_reason".to_string(),
|
||||
value: "future_reason".to_string(),
|
||||
}
|
||||
.diagnostic();
|
||||
assert_eq!(diagnostic["code"], "invalid_enum_value");
|
||||
assert_eq!(diagnostic["path"], "$.choices[*].finish_reason");
|
||||
assert_eq!(diagnostic["actual"], "future_reason");
|
||||
assert_eq!(diagnostic["format"], "openai:chat");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn generic_parse_failure_reports_missing_cause_without_a_fake_path() {
|
||||
let diagnostic = FormatError::ResponseParseFailed {
|
||||
format: "claude:messages".to_string(),
|
||||
}
|
||||
.diagnostic();
|
||||
assert_eq!(diagnostic["code"], "response_parse_failed");
|
||||
assert_eq!(diagnostic["operation"], "parse_response");
|
||||
assert_eq!(diagnostic["path_source"], "unavailable");
|
||||
assert_eq!(
|
||||
diagnostic["missing_context"],
|
||||
json!(["field_path", "underlying_cause"])
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -23,6 +23,9 @@ use crate::formats::shared::stream_core::common::{
|
||||
};
|
||||
use crate::formats::shared::AiSurfaceFinalizeError;
|
||||
|
||||
const PROVIDER_STREAM_FINISH_ERROR_MESSAGE: &str =
|
||||
"Upstream stream ended with finish reason: error";
|
||||
|
||||
#[derive(Default)]
|
||||
pub struct StreamingStandardFormatMatrix {
|
||||
provider: Option<ProviderStreamParser>,
|
||||
@@ -129,7 +132,7 @@ impl StreamingStandardFormatMatrix {
|
||||
{
|
||||
if !canonical_stream_finish_reason_is_supported(finish_reason) {
|
||||
self.terminated = true;
|
||||
out.extend(client.emit_unsupported_finish_reason(finish_reason)?);
|
||||
out.extend(client.emit_finish_reason_error(finish_reason)?);
|
||||
break;
|
||||
}
|
||||
}
|
||||
@@ -388,7 +391,13 @@ impl StreamingStandardTerminalObserver {
|
||||
if let Some(parser_error) = finish_reason
|
||||
.as_deref()
|
||||
.filter(|reason| !canonical_stream_finish_reason_is_supported(reason))
|
||||
.map(|reason| format!("unsupported provider stream finish reason: {reason}"))
|
||||
.map(|reason| {
|
||||
if reason.trim() == "error" {
|
||||
PROVIDER_STREAM_FINISH_ERROR_MESSAGE.to_string()
|
||||
} else {
|
||||
format!("unsupported provider stream finish reason: {reason}")
|
||||
}
|
||||
})
|
||||
{
|
||||
summary.parser_error.get_or_insert(parser_error);
|
||||
}
|
||||
@@ -660,17 +669,28 @@ impl ClientStreamEmitter {
|
||||
self.emit_error(error_body)
|
||||
}
|
||||
|
||||
fn emit_unsupported_finish_reason(
|
||||
fn emit_finish_reason_error(
|
||||
&mut self,
|
||||
finish_reason: &str,
|
||||
) -> Result<Vec<u8>, AiSurfaceFinalizeError> {
|
||||
let (message, code) = if finish_reason.trim() == "error" {
|
||||
(
|
||||
PROVIDER_STREAM_FINISH_ERROR_MESSAGE.to_string(),
|
||||
"stream_terminal_error",
|
||||
)
|
||||
} else {
|
||||
(
|
||||
format!(
|
||||
"Unsupported provider stream finish reason cannot be converted losslessly: field $.finish_reason = {}",
|
||||
serde_json::json!(finish_reason)
|
||||
),
|
||||
"unsupported_finish_reason",
|
||||
)
|
||||
};
|
||||
let Some(error_body) = build_core_error_body_for_client_format(
|
||||
self.api_format(),
|
||||
&format!(
|
||||
"Unsupported provider stream finish reason cannot be converted losslessly: field $.finish_reason = {}",
|
||||
serde_json::json!(finish_reason)
|
||||
),
|
||||
Some("unsupported_finish_reason"),
|
||||
&message,
|
||||
Some(code),
|
||||
LocalCoreSyncErrorKind::ServerError,
|
||||
) else {
|
||||
return Ok(Vec::new());
|
||||
@@ -2121,6 +2141,163 @@ mod tests {
|
||||
assert!(sse.contains("\"stop_reason\":\"tool_use\""), "{sse}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn terminal_observer_treats_claude_error_finish_reason_as_upstream_failure() {
|
||||
for upstream_message in [None, Some("Provider temporarily overloaded")] {
|
||||
let context = report_context("claude:messages", "claude:messages");
|
||||
let mut observer = StreamingStandardTerminalObserver::default();
|
||||
observer
|
||||
.push_line(
|
||||
&context,
|
||||
data_line(json!({
|
||||
"type": "message_start",
|
||||
"message": {
|
||||
"id": "msg_error_finish",
|
||||
"model": "claude-sonnet-4-5",
|
||||
"usage": {
|
||||
"input_tokens": 22,
|
||||
"cache_read_input_tokens": 7,
|
||||
"cache_creation_input_tokens": 3,
|
||||
"cache_creation": { "ephemeral_5m_input_tokens": 3 }
|
||||
}
|
||||
}
|
||||
})),
|
||||
)
|
||||
.expect("message start should be observed");
|
||||
if let Some(message) = upstream_message {
|
||||
observer
|
||||
.push_line(
|
||||
&context,
|
||||
data_line(json!({
|
||||
"type": "error",
|
||||
"error": { "type": "overloaded_error", "message": message }
|
||||
})),
|
||||
)
|
||||
.expect("upstream error should be observed");
|
||||
}
|
||||
observer
|
||||
.push_line(
|
||||
&context,
|
||||
data_line(json!({
|
||||
"type": "message_delta",
|
||||
"delta": { "stop_reason": "error" },
|
||||
"usage": { "output_tokens": 5 }
|
||||
})),
|
||||
)
|
||||
.expect("error finish reason should be observed");
|
||||
let summary = observer
|
||||
.finish(&context)
|
||||
.expect("terminal observation should finish")
|
||||
.expect("failed stream should have a summary");
|
||||
|
||||
assert!(summary.observed_finish);
|
||||
assert_eq!(summary.finish_reason.as_deref(), Some("error"));
|
||||
assert_eq!(
|
||||
summary.parser_error.as_deref(),
|
||||
Some(upstream_message.unwrap_or("Upstream stream ended with finish reason: error"))
|
||||
);
|
||||
let usage = summary
|
||||
.standardized_usage
|
||||
.expect("usage should be retained");
|
||||
assert_eq!(usage.input_tokens, 22);
|
||||
assert_eq!(usage.output_tokens, 5);
|
||||
assert_eq!(usage.cache_read_tokens, 7);
|
||||
assert_eq!(usage.cache_creation_tokens, 3);
|
||||
assert_eq!(usage.cache_creation_ephemeral_5m_tokens, 3);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn transforms_claude_error_finish_reason_to_terminal_errors() {
|
||||
let cases = [
|
||||
(
|
||||
"openai:chat",
|
||||
"data: {\"error\":",
|
||||
"\"code\":\"stream_terminal_error\"",
|
||||
),
|
||||
(
|
||||
"openai:responses",
|
||||
"event: response.failed\n",
|
||||
"\"code\":\"stream_terminal_error\"",
|
||||
),
|
||||
(
|
||||
"claude:messages",
|
||||
"event: error\n",
|
||||
"\"code\":\"stream_terminal_error\"",
|
||||
),
|
||||
(
|
||||
"gemini:generate_content",
|
||||
"data: {\"error\":",
|
||||
"\"status\":\"INTERNAL\"",
|
||||
),
|
||||
];
|
||||
for (client_api_format, prefix, marker) in cases {
|
||||
let context = report_context("claude:messages", client_api_format);
|
||||
let mut matrix = StreamingStandardFormatMatrix::default();
|
||||
let mut output = matrix
|
||||
.transform_line(
|
||||
&context,
|
||||
data_line(json!({
|
||||
"type": "content_block_delta",
|
||||
"index": 0,
|
||||
"delta": { "type": "text_delta", "text": "Partial answer" }
|
||||
})),
|
||||
)
|
||||
.expect("partial response should be emitted");
|
||||
output.extend(
|
||||
matrix
|
||||
.transform_line(
|
||||
&context,
|
||||
data_line(json!({
|
||||
"type": "message_delta",
|
||||
"delta": { "stop_reason": "error" },
|
||||
"usage": { "output_tokens": 5 }
|
||||
})),
|
||||
)
|
||||
.expect("error finish reason should emit a terminal error"),
|
||||
);
|
||||
let sse = String::from_utf8(output).expect("sse should be utf8");
|
||||
|
||||
assert!(sse.contains("Partial answer"), "{client_api_format}: {sse}");
|
||||
assert!(sse.contains(prefix), "{client_api_format}: {sse}");
|
||||
assert!(sse.contains(marker), "{client_api_format}: {sse}");
|
||||
assert!(
|
||||
sse.contains("Upstream stream ended with finish reason: error"),
|
||||
"{client_api_format}: {sse}"
|
||||
);
|
||||
assert!(
|
||||
!sse.contains("unsupported_finish_reason"),
|
||||
"{client_api_format}: {sse}"
|
||||
);
|
||||
assert!(
|
||||
!sse.contains("response.completed"),
|
||||
"{client_api_format}: {sse}"
|
||||
);
|
||||
assert!(
|
||||
!sse.contains("\"stop_reason\":\"end_turn\""),
|
||||
"{client_api_format}: {sse}"
|
||||
);
|
||||
assert!(
|
||||
!sse.contains("\"finish_reason\":\"stop\""),
|
||||
"{client_api_format}: {sse}"
|
||||
);
|
||||
assert!(matrix
|
||||
.transform_line(
|
||||
&context,
|
||||
data_line(json!({
|
||||
"type": "message_delta",
|
||||
"delta": { "stop_reason": "end_turn" }
|
||||
}))
|
||||
)
|
||||
.expect("events after the error should be ignored")
|
||||
.is_empty());
|
||||
assert!(matrix
|
||||
.finish(&context)
|
||||
.expect("failed matrix should stay terminated")
|
||||
.is_empty());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn transforms_unknown_stream_finish_reasons_to_visible_client_errors() {
|
||||
let cases = [
|
||||
|
||||
@@ -34,6 +34,7 @@ pub struct CandidateFailureDiagnostic {
|
||||
client_api_format: Option<String>,
|
||||
provider_api_format: Option<String>,
|
||||
safe_to_show: bool,
|
||||
details: Option<Value>,
|
||||
}
|
||||
|
||||
impl CandidateFailureDiagnostic {
|
||||
@@ -50,6 +51,7 @@ impl CandidateFailureDiagnostic {
|
||||
client_api_format: None,
|
||||
provider_api_format: None,
|
||||
safe_to_show: true,
|
||||
details: None,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -58,6 +60,11 @@ impl CandidateFailureDiagnostic {
|
||||
self
|
||||
}
|
||||
|
||||
pub fn details(mut self, details: Value) -> Self {
|
||||
self.details = Some(details);
|
||||
self
|
||||
}
|
||||
|
||||
pub fn formats(
|
||||
mut self,
|
||||
client_api_format: impl Into<String>,
|
||||
@@ -219,6 +226,10 @@ impl CandidateFailureDiagnostic {
|
||||
"client_api_format": self.client_api_format,
|
||||
"provider_api_format": self.provider_api_format,
|
||||
"safe_to_show": self.safe_to_show,
|
||||
"details": self.details,
|
||||
"stage": "request",
|
||||
"source_format": self.client_api_format,
|
||||
"target_format": self.provider_api_format,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
@@ -224,6 +224,7 @@ fn diagnostic_from_format_error(
|
||||
format_error_path(error),
|
||||
format_error_message(error, client_api_format, provider_api_format),
|
||||
)
|
||||
.details(error.diagnostic())
|
||||
}
|
||||
|
||||
fn format_error_path(error: &FormatError) -> String {
|
||||
@@ -982,6 +983,23 @@ mod tests {
|
||||
"request_conversion"
|
||||
);
|
||||
assert_eq!(diagnostic["failure_diagnostic"]["path"], "$.n");
|
||||
assert_eq!(diagnostic["failure_diagnostic"]["stage"], "request");
|
||||
assert_eq!(
|
||||
diagnostic["failure_diagnostic"]["details"]["code"],
|
||||
"lossy_conversion_blocked"
|
||||
);
|
||||
assert_eq!(
|
||||
diagnostic["failure_diagnostic"]["details"]["path_source"],
|
||||
"structured"
|
||||
);
|
||||
assert_eq!(
|
||||
diagnostic["failure_diagnostic"]["source_format"],
|
||||
"openai:chat"
|
||||
);
|
||||
assert_eq!(
|
||||
diagnostic["failure_diagnostic"]["target_format"],
|
||||
"openai:responses"
|
||||
);
|
||||
assert_eq!(diagnostic["request_conversion_error"]["path"], "$.n");
|
||||
assert!(diagnostic["failure_diagnostic"]["message"]
|
||||
.as_str()
|
||||
|
||||
@@ -857,7 +857,18 @@ pub fn sanitize_request_candidate_extra_data_for_persistence(
|
||||
("error_flow", &["message"][..]),
|
||||
(
|
||||
"failure_diagnostic",
|
||||
&["path", "field_path", "message", "type", "reason"][..],
|
||||
&[
|
||||
"path",
|
||||
"field_path",
|
||||
"message",
|
||||
"type",
|
||||
"reason",
|
||||
"details",
|
||||
"stage",
|
||||
"source_format",
|
||||
"target_format",
|
||||
"safe_to_show",
|
||||
][..],
|
||||
),
|
||||
(
|
||||
"request_conversion_error",
|
||||
@@ -2445,7 +2456,7 @@ mod tests {
|
||||
let raw = json!({
|
||||
"upstream_response": {"status_code": 400, "body": "错误内容".repeat(20_000)},
|
||||
"error_flow": {"status_code": 400, "message": "private upstream failure"},
|
||||
"failure_diagnostic": {"path": "$.input", "message": "private conversion failure"},
|
||||
"failure_diagnostic": {"path": "$.input", "message": "private conversion failure", "safe_to_show": false, "stage": "request", "details": {"code": "invalid_enum_value", "actual": "private-value"}},
|
||||
"request_body": {"input": "private prompt"}
|
||||
});
|
||||
let admin = super::sanitize_request_candidate_extra_data_for_persistence(Some(raw))
|
||||
@@ -2456,6 +2467,12 @@ mod tests {
|
||||
assert!(body.len() <= 65_536);
|
||||
assert!(body.ends_with("...[truncated]"));
|
||||
assert!(admin.get("request_body").is_none());
|
||||
assert_eq!(admin["failure_diagnostic"]["safe_to_show"], false);
|
||||
assert_eq!(admin["failure_diagnostic"]["stage"], "request");
|
||||
assert_eq!(
|
||||
admin["failure_diagnostic"]["details"]["code"],
|
||||
"invalid_enum_value"
|
||||
);
|
||||
assert_eq!(
|
||||
super::sanitize_request_candidate_extra_data_for_persistence(Some(admin.clone())),
|
||||
Some(admin.clone()),
|
||||
|
||||
@@ -0,0 +1,42 @@
|
||||
# 格式转换失败诊断导出
|
||||
|
||||
## 使用方法
|
||||
|
||||
在请求详情的失败或跳过节点中，点击「失败诊断」面板的复制按钮。
|
||||
复制时才会读取已采集的正文；页面预览本身不会批量加载正文。
|
||||
请分享整个 JSON，而不是只分享 `summary`。复制成功标志仅在剪贴板写入成功后出现。
|
||||
|
||||
## Schema v2
|
||||
|
||||
- `diagnostic`：错误码、请求/响应/流式阶段、源/目标格式、转换器标识、完整 JSON 路径及期望约束/实际值。
|
||||
- `path_source`：`structured` 是后端结构化路径，`message_inference` 是历史文案推断，`protocol_inference` 是根据上游协议推断的原始字段路径，`unavailable` 表示没有可靠字段路径。通用 `$.finish_reason` 会按协议定位到具体原始字段，同时保留 `reported_path`。
|
||||
- `stage_source`：区分后端阶段信息与历史记录推断。请求转换方向为客户端到上游；响应/流式转换方向相反。
|
||||
- `versions`：前端版本、导出时网关版本、失败时运行版本。历史记录没有运行版本时保留 `null`，不能把导出版本当作失败版本。
|
||||
- `request` / `node`：请求、候选、重试、模型及时间等定位信息。
|
||||
- `reproduction.sources`：脱敏正文片段、字段样本和流式失败事件窗口。数组通配路径的样本带具体下标。
|
||||
- `reproduction.missing_context`：未采集、无权限、正文过大、读取失败、缺少失败事件或路径等缺口。
|
||||
|
||||
后端只为明确匹配 `candidate_id` 的候选提供上游正文记录。历史记录仅有候选索引时，不把最后一次重试的正文猜成当前失败的正文。
|
||||
原始客户端请求可在同一请求内共享，但不会把其他候选的上游请求/响应当作失败现场。
|
||||
`body_ref` 不是下载地址；前端不访问其中的 URL，而是使用现有、受权限保护的正文接口。
|
||||
|
||||
## 完整性与安全边界
|
||||
|
||||
- `not_loaded`：尚未补取上下文。
|
||||
- `sanitized_context`：必要来源已取得，但仍然经过脱敏、大小限制或事件窗口裁剪。
|
||||
- `insufficient_context`：还缺少明确列出的信息，不能据此假设能够完整复现。
|
||||
- `replay_ready: false`：导出的是供排查的证据包，不是可以无条件自动执行的请求。修改前应根据样本建立最小回归测试。
|
||||
|
||||
每份正文的下载/解码处理上限为 1 MiB，读取超时为 5 秒；导出 JSON 上限为 64 Ki 字符。
|
||||
字符串、数组、对象深度与节点数量也有限制。流式窗口保留匹配失败的事件、帧序号及邻近事件；匹配不到时明确标记，而不是认定流尾就是故障点。
|
||||
|
||||
默认移除常见认证头、密钥、令牌、Cookie、密码、签名 URL 参数、正文文本和二进制数据。
|
||||
脱敏是规则化处理，分享前仍需检查自定义字段和错误消息是否含业务敏感信息。
|
||||
不会为了诊断绕过正文采集策略、授权或存储限制；也不会把 `error` 或未知结束原因映射成正常成功。
|
||||
|
||||
## 建议处理流程
|
||||
|
||||
1. 检查 `diagnostic.stage`、`path_source` 和 `missing_context`，区分转换器缺陷、合法的无损转换拒绝和上游失败。
|
||||
2. 对照源/目标格式以及字段样本，建立最小失败输入；流式问题同时保留必要的前序事件。
|
||||
3. 先补失败回归测试，再修复转换规则。
|
||||
4. 验证原有正常映射、失败闭合以及凭据脱敏没有回退。
|
||||
@@ -4,6 +4,7 @@ const { getMock } = vi.hoisted(() => ({ getMock: vi.fn() }))
|
||||
vi.mock('@/api/client', () => ({ default: { get: getMock } }))
|
||||
|
||||
import { dashboardApi } from '@/api/dashboard'
|
||||
import { requestTraceApi } from '@/api/requestTrace'
|
||||
import { cache } from '@/utils/cache'
|
||||
|
||||
beforeEach(() => {
|
||||
@@ -13,6 +14,20 @@ beforeEach(() => {
|
||||
})
|
||||
|
||||
describe('dashboard body loading', () => {
|
||||
it('reports download progress so diagnostic exports can abort oversized bodies', async () => {
|
||||
const onProgress = vi.fn()
|
||||
getMock.mockResolvedValue({ data: new ArrayBuffer(0), headers: { 'x-aether-body-encoding': 'json', 'x-aether-usage-id': 'usage-1', 'x-aether-body-field': 'response_body' } })
|
||||
await dashboardApi.getRequestBody('usage-1', 'response_body', undefined, onProgress)
|
||||
getMock.mock.calls[0][1].onDownloadProgress({ loaded: 2 * 1024 * 1024 })
|
||||
expect(onProgress).toHaveBeenCalledWith(2 * 1024 * 1024)
|
||||
})
|
||||
|
||||
it('records the gateway version at export without confusing it with failure-time metadata', async () => {
|
||||
getMock.mockResolvedValue({ data: { request_id: 'request-1', candidates: [] }, headers: { 'x-aether-build-version': 'test-build' } })
|
||||
expect(await requestTraceApi.getRequestTrace('request-1')).toMatchObject({ gateway_version: 'test-build' })
|
||||
getMock.mockResolvedValue({ data: { request_id: 'request-1', candidates: [] } })
|
||||
expect(await requestTraceApi.getRequestTrace('request-1')).toMatchObject({ gateway_version: null })
|
||||
})
|
||||
it('requests opaque body bytes, outside the JSON detail cache', async () => {
|
||||
const bytes = new ArrayBuffer(20)
|
||||
const controller = new AbortController()
|
||||
|
||||
@@ -481,11 +481,12 @@ export const dashboardApi = {
|
||||
return options.signal ? fetchDetail() : cachedRequest(cacheKey, fetchDetail, cacheTtlMs)
|
||||
},
|
||||
|
||||
async getRequestBody(requestId: string, field: RequestBodyField, signal?: AbortSignal) {
|
||||
async getRequestBody(requestId: string, field: RequestBodyField, signal?: AbortSignal, onProgress?: (loaded: number) => void) {
|
||||
const response = await apiClient.get<ArrayBuffer>(`/api/admin/usage/${requestId}`, {
|
||||
params: { include_bodies: true, body_field: field, body_format: 'raw' },
|
||||
responseType: 'arraybuffer',
|
||||
signal,
|
||||
...(onProgress ? { onDownloadProgress: (event: { loaded: number }) => onProgress(event.loaded) } : {}),
|
||||
})
|
||||
const encoding = response.headers['x-aether-body-encoding']
|
||||
if ((encoding !== 'gzip' && encoding !== 'json') || response.headers['x-aether-usage-id'] !== requestId || response.headers['x-aether-body-field'] !== field) {
|
||||
|
||||
@@ -121,6 +121,8 @@ export interface CandidateRecord {
|
||||
}
|
||||
|
||||
export interface RequestTrace {
|
||||
gateway_version?: string | null
|
||||
diagnostic_request?: { usage_id: string, body_state?: string | null } | null
|
||||
request_id: string
|
||||
request_path?: string
|
||||
request_query_string?: string
|
||||
@@ -154,7 +156,7 @@ export const requestTraceApi = {
|
||||
const response = await apiClient.get<RequestTrace>(`/api/admin/monitoring/trace/${requestId}`, {
|
||||
params: { attempted_only: attemptedOnly },
|
||||
})
|
||||
return response.data
|
||||
return { ...response.data, gateway_version: response.headers?.['x-aether-build-version'] ?? response.data.gateway_version ?? null }
|
||||
},
|
||||
|
||||
/**
|
||||
|
||||
@@ -506,19 +506,30 @@
|
||||
empty-message="无上游响应"
|
||||
/>
|
||||
</div>
|
||||
<div
|
||||
v-if="currentAttemptRequestError.diagnostic"
|
||||
class="error-json error-diagnostic-json"
|
||||
>
|
||||
<JsonContentPanel
|
||||
:data="currentAttemptRequestError.diagnostic"
|
||||
:is-dark="isDark"
|
||||
title="失败诊断"
|
||||
empty-message="无失败诊断信息"
|
||||
/>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div
|
||||
v-if="diagnosticDisplay"
|
||||
class="error-json error-diagnostic-json"
|
||||
>
|
||||
<JsonContentPanel
|
||||
:data="diagnosticDisplay"
|
||||
:is-dark="isDark"
|
||||
:custom-copy="true"
|
||||
:copied="diagnosticCopied"
|
||||
:copy-disabled="diagnosticCopying"
|
||||
title="失败诊断"
|
||||
empty-message="无失败诊断信息"
|
||||
@copy="copyFailureDiagnostic"
|
||||
/>
|
||||
</div>
|
||||
<p
|
||||
v-if="diagnosticDisplay"
|
||||
class="text-xs text-muted-foreground mt-1"
|
||||
>
|
||||
{{ diagnosticCopying ? '正在读取并脱敏诊断上下文…' : '复制时补取已采集的正文并脱敏；未采集、无权限或超限的信息会明确标注。分享前请检查诊断内容。' }}
|
||||
</p>
|
||||
|
||||
<!-- 额外数据 -->
|
||||
<details
|
||||
v-if="currentAttemptExtraDataDisplay"
|
||||
@@ -572,6 +583,9 @@ import { formatTokens } from '@/utils/format'
|
||||
import { formatApiFormat } from '@/api/endpoints/types/api-format'
|
||||
import { useDarkMode } from '@/composables/useDarkMode'
|
||||
import { resolveTimelineFinalStatus } from '../utils/status'
|
||||
import { useClipboard } from '@/composables/useClipboard'
|
||||
import { buildFailureDiagnosticBundle, diagnosticPathFromMessage, visibleFailureRecords } from '../utils/failureDiagnostic'
|
||||
import { prepareDiagnosticExport, sanitizeDiagnostic } from '../utils/diagnosticExport'
|
||||
import {
|
||||
buildPoolGroupVisibleAttempts,
|
||||
buildPoolParticipatedCandidates,
|
||||
@@ -1442,6 +1456,7 @@ const currentAttemptFailureDiagnostic = computed<{
|
||||
const attempt = currentAttempt.value
|
||||
if (!attempt) return null
|
||||
const extra = extractObject(attempt.extra_data)
|
||||
if (extractObject(extra?.failure_diagnostic)?.safe_to_show === false) return null
|
||||
const failureDiagnostic = extractVisibleFailureDiagnostic(extra)
|
||||
const error = failureDiagnostic
|
||||
? failureDiagnostic
|
||||
@@ -1462,12 +1477,20 @@ const currentAttemptFailureDiagnostic = computed<{
|
||||
const isGenericExecutionRuntimeStatusMessage = (message: string): boolean =>
|
||||
/execution runtime (stream )?returned non-success status \d+/i.test(message)
|
||||
|
||||
const isStreamTerminalDiagnosticMessage = (message: string): boolean =>
|
||||
/(?:unsupported provider stream finish reason|upstream stream ended with finish reason)\s*:/i.test(message)
|
||||
|
||||
const isStreamFinishErrorDiagnostic = (message: string): boolean =>
|
||||
/(?:unsupported provider stream finish reason|upstream stream ended with finish reason)\s*:\s*error(?:[ \t]*(?:$|\r?\n)|["')])/i.test(message)
|
||||
|
||||
const isLocalSyncFinalizeDiagnostic = (message: string): boolean =>
|
||||
/local sync attempt failed before terminal finalization/i.test(message)
|
||||
|| /unsupported provider stream (event|finish reason)/i.test(message)
|
||||
|
||||
const isActionableDiagnosticMessage = (message: string): boolean =>
|
||||
isLocalSyncFinalizeDiagnostic(message) || isConversionDiagnosticMessage(message)
|
||||
isLocalSyncFinalizeDiagnostic(message)
|
||||
|| isStreamTerminalDiagnosticMessage(message)
|
||||
|| isConversionDiagnosticMessage(message)
|
||||
|
||||
const extractVisibleFailureDiagnostic = (
|
||||
extra: Record<string, unknown> | null | undefined,
|
||||
@@ -1480,10 +1503,8 @@ const extractVisibleFailureDiagnostic = (
|
||||
const extractVisibleDiagnosticObjects = (
|
||||
extra: Record<string, unknown> | null | undefined,
|
||||
): Array<Record<string, unknown>> => [
|
||||
extractVisibleFailureDiagnostic(extra),
|
||||
extractObject(extra?.request_conversion_error),
|
||||
extractObject(extra?.request_body_build_error),
|
||||
].filter((value): value is Record<string, unknown> => Boolean(value))
|
||||
...visibleFailureRecords(extra ?? {}),
|
||||
]
|
||||
|
||||
const extractVisibleDiagnosticMessage = (
|
||||
extra: Record<string, unknown> | null | undefined,
|
||||
@@ -1555,6 +1576,10 @@ const formatUnsupportedStreamEventMessage = (message: string): string => {
|
||||
}
|
||||
|
||||
const formatUnsupportedFinishReasonMessage = (message: string): string => {
|
||||
const terminalMatch = message.match(/^unsupported provider stream finish reason\s*:\s*(.+)$/i)
|
||||
if (terminalMatch?.[1]) {
|
||||
return `流式终态校验失败：上游返回了当前不支持的 finish reason（${terminalMatch[1].trim()}），已按失败处理`
|
||||
}
|
||||
const fieldDetail = extractFieldDetail(message)
|
||||
const legacyMatch = message.match(/unsupported provider stream finish reason\s+(.+?)\s+cannot be converted losslessly/i)
|
||||
const detail = fieldDetail || (legacyMatch?.[1]
|
||||
@@ -1569,7 +1594,7 @@ const formatKnownConversionErrorMessage = (message: string): string => {
|
||||
return `格式转换失败：${formatConversionPair(lossy[1], lossy[2])} 在字段 ${normalizeDiagnosticFieldPath(lossy[3])} 会丢失信息：${lossy[4].trim()}`
|
||||
}
|
||||
|
||||
const unaudited = message.match(/^unaudited field\s+(.+?)\s+in\s+(.+?)\s+cannot be converted to\s+([^:]+):\s*(.+)$/i)
|
||||
const unaudited = message.match(/^unaudited field\s+(.+?)\s+in\s+(.+?)\s+cannot be converted to\s+(\S+):\s*(.+)$/i)
|
||||
if (unaudited) {
|
||||
return `格式转换失败：${formatConversionPair(unaudited[2], unaudited[3])} 的字段 ${normalizeDiagnosticFieldPath(unaudited[1])} 尚未审计，不能安全转换：${unaudited[4].trim()}`
|
||||
}
|
||||
@@ -1579,7 +1604,7 @@ const formatKnownConversionErrorMessage = (message: string): string => {
|
||||
return `格式转换失败：${formatApiFormat(unsupportedField[2])} 不支持字段 ${normalizeDiagnosticFieldPath(unsupportedField[1])}：${unsupportedField[3].trim()}`
|
||||
}
|
||||
|
||||
const invalidEnum = message.match(/^invalid enum value\s+(.+?)\s+for\s+(.+)\.([^.\s]+)$/i)
|
||||
const invalidEnum = message.match(/^invalid enum value\s+(.+?)\s+for\s+([\w:-]+)\.(.+)$/i)
|
||||
if (invalidEnum) {
|
||||
return `格式转换失败：${formatApiFormat(invalidEnum[2])} 字段 ${normalizeDiagnosticFieldPath(invalidEnum[3])} 的枚举值 ${invalidEnum[1].trim()} 无效`
|
||||
}
|
||||
@@ -1606,7 +1631,7 @@ const formatKnownConversionErrorMessage = (message: string): string => {
|
||||
|
||||
const isConversionDiagnosticMessage = (message: string): boolean => {
|
||||
const normalized = message.trim()
|
||||
if (!normalized) return false
|
||||
if (!normalized || isStreamTerminalDiagnosticMessage(normalized)) return false
|
||||
return /conversion|converted|convertible|cannot be converted|lossy conversion|unsupported field|unaudited field|invalid enum value|invalid target field|unsupported ai format|failed to (parse|emit) .+ (request|response)|unsupported provider stream (event|finish reason)|转换|无损|字段 .*不支持/i
|
||||
.test(normalized)
|
||||
}
|
||||
@@ -1622,6 +1647,9 @@ const formatAttemptErrorMessage = (message: string, statusCode?: number): string
|
||||
if (localSyncInternal?.[1]) {
|
||||
return formatAttemptErrorMessage(decodeRustDebugString(localSyncInternal[1]), statusCode)
|
||||
}
|
||||
if (isStreamFinishErrorDiagnostic(normalized)) {
|
||||
return '上游流式响应异常终止：上游返回了错误结束原因（error），已按失败处理'
|
||||
}
|
||||
if (/unsupported provider stream event cannot be converted losslessly/i.test(normalized)) {
|
||||
return formatUnsupportedStreamEventMessage(normalized)
|
||||
}
|
||||
@@ -1645,9 +1673,7 @@ const shouldShowAttemptMessageWithUpstreamResponse = (
|
||||
if (!upstreamResponse || !hasRenderableValue(upstreamResponse.body)) return true
|
||||
const normalized = rawMessage.trim()
|
||||
if (!normalized) return false
|
||||
if (isLocalSyncFinalizeDiagnostic(normalized)) return true
|
||||
if (isConversionDiagnosticMessage(normalized)) return true
|
||||
return false
|
||||
return isActionableDiagnosticMessage(normalized)
|
||||
}
|
||||
|
||||
const currentAttemptRequestError = computed<{
|
||||
@@ -1691,8 +1717,7 @@ const currentAttemptRequestError = computed<{
|
||||
const visibleDiagnosticObjects = extractVisibleDiagnosticObjects(extra)
|
||||
const shouldAttachDiagnostic = Boolean(
|
||||
visibleDiagnosticObjects.length
|
||||
|| isLocalSyncFinalizeDiagnostic(rawMessage)
|
||||
|| isConversionDiagnosticMessage(rawMessage),
|
||||
|| isActionableDiagnosticMessage(rawMessage),
|
||||
)
|
||||
const diagnostic = shouldAttachDiagnostic
|
||||
? buildAttemptDiagnosticPayload(
|
||||
@@ -1736,21 +1761,7 @@ const diagnosticPathFromObject = (value: unknown): string => {
|
||||
|| ''
|
||||
}
|
||||
|
||||
const diagnosticFieldPathFromMessage = (message: string): string => {
|
||||
const normalized = message.trim()
|
||||
if (!normalized) return ''
|
||||
const fieldMatch = normalized.match(/field\s+([^;=]+?)\s*(?:=|is unsupported|不支持)/i)
|
||||
if (fieldMatch?.[1]) return normalizeDiagnosticFieldPath(fieldMatch[1])
|
||||
const lossyMatch = normalized.match(/lossy conversion blocked from\s+\S+\s+to\s+\S+\s+at\s+([^:]+):/i)
|
||||
if (lossyMatch?.[1]) return normalizeDiagnosticFieldPath(lossyMatch[1])
|
||||
const invalidTargetMatch = normalized.match(/invalid target field\s+(.+?)\s+for\s+/i)
|
||||
if (invalidTargetMatch?.[1]) return normalizeDiagnosticFieldPath(invalidTargetMatch[1])
|
||||
const unsupportedFieldMatch = normalized.match(/unsupported field\s+(.+?)\s+in\s+/i)
|
||||
if (unsupportedFieldMatch?.[1]) return normalizeDiagnosticFieldPath(unsupportedFieldMatch[1])
|
||||
const invalidEnumMatch = normalized.match(/invalid enum value\s+.+?\s+for\s+.+\.([^.\s]+)$/i)
|
||||
if (invalidEnumMatch?.[1]) return normalizeDiagnosticFieldPath(invalidEnumMatch[1])
|
||||
return ''
|
||||
}
|
||||
const diagnosticFieldPathFromMessage = diagnosticPathFromMessage
|
||||
|
||||
function resolveAttemptDiagnosticBreakpoint(attempt: CandidateRecord, rawMessageOverride = ''): string {
|
||||
const extra = extractObject(attempt.extra_data)
|
||||
@@ -1766,11 +1777,13 @@ function resolveAttemptDiagnosticBreakpoint(attempt: CandidateRecord, rawMessage
|
||||
readStringField(requestBodyBuildError ?? {}, 'message') ?? '',
|
||||
typeof attempt.error_message === 'string' ? attempt.error_message : '',
|
||||
].find(item => item.trim()) ?? ''
|
||||
const streamFinishReasonPath = isStreamTerminalDiagnosticMessage(rawMessage) ? '$.finish_reason' : ''
|
||||
|
||||
return diagnosticPathFromObject(failureDiagnostic)
|
||||
|| diagnosticPathFromObject(requestConversionError)
|
||||
|| diagnosticPathFromObject(requestBodyBuildError)
|
||||
|| diagnosticFieldPathFromMessage(rawMessage)
|
||||
|| streamFinishReasonPath
|
||||
|| '$'
|
||||
}
|
||||
|
||||
@@ -1814,6 +1827,12 @@ function buildAttemptDiagnosticPayload(
|
||||
: currentAttemptFormatDisplay.value
|
||||
const analysisHint = (() => {
|
||||
const raw = `${summary}\n${rawMessageForBreakpoint}\n${attempt.error_message ?? ''}`.toLowerCase()
|
||||
if (isStreamFinishErrorDiagnostic(raw)) {
|
||||
return '上游通过结束原因报告了流式错误：检查原始 SSE 中的 error/message 及上游日志；保持失败状态，不要映射为正常结束。'
|
||||
}
|
||||
if (isStreamTerminalDiagnosticMessage(raw)) {
|
||||
return '断点在上游流式终态校验：检查原始结束原因及协议兼容性；该错误不代表发生了格式转换，不能确认成功时保持失败闭合。'
|
||||
}
|
||||
if (raw.includes('unsupported provider stream event')) {
|
||||
return '断点在上游流式事件解析/转换矩阵：先按 breakpoint 对应字段确认 event type，再决定是补 canonical mapping 还是加入 known noop。'
|
||||
}
|
||||
@@ -1823,7 +1842,7 @@ function buildAttemptDiagnosticPayload(
|
||||
if (raw.includes('lossy conversion') || raw.includes('无损') || raw.includes('丢失信息') || raw.includes('request_conversion')) {
|
||||
return '断点在请求/响应格式转换器：检查 breakpoint 字段是否能被目标格式表达，不能表达就需要拒绝、降级或新增显式映射策略。'
|
||||
}
|
||||
return '先从 breakpoint 字段开始回放；若 breakpoint 为 $，优先查看 raw.failure_diagnostic / raw.error_message 和 upstream_response。'
|
||||
return '先从 breakpoint 字段开始回放；若 breakpoint 为 $，优先查看 raw.failure_diagnostic / node.error_message 和 upstream_response。'
|
||||
})()
|
||||
|
||||
const payload = {
|
||||
@@ -1853,15 +1872,82 @@ function buildAttemptDiagnosticPayload(
|
||||
},
|
||||
raw: {
|
||||
failure_diagnostic: rawFailureDiagnostic,
|
||||
request_conversion_error: rawRequestConversionError,
|
||||
request_body_build_error: rawRequestBodyBuildError,
|
||||
request_conversion_error: rawFailureDiagnostic?.safe_to_show === false || extractObject(extra?.failure_diagnostic)?.safe_to_show === false ? null : rawRequestConversionError,
|
||||
request_body_build_error: rawFailureDiagnostic?.safe_to_show === false || extractObject(extra?.failure_diagnostic)?.safe_to_show === false ? null : rawRequestBodyBuildError,
|
||||
error_flow: extractObject(extra?.error_flow),
|
||||
upstream_response: upstreamResponseDisplay ?? normalizeUpstreamResponseDisplay(extra?.upstream_response),
|
||||
},
|
||||
}
|
||||
return payload
|
||||
return buildFailureDiagnosticBundle(payload, attempt, trace.value, rawMessageForBreakpoint)
|
||||
}
|
||||
|
||||
const { copyToClipboard } = useClipboard()
|
||||
const diagnosticCopying = ref(false)
|
||||
const diagnosticCopied = ref(false)
|
||||
const exportedDiagnostic = ref<Record<string, unknown> | null>(null)
|
||||
let diagnosticController: AbortController | null = null
|
||||
let diagnosticCopyTimer: ReturnType<typeof setTimeout> | undefined
|
||||
const currentAttemptDiagnostic = computed(() => {
|
||||
const attempt = currentAttempt.value
|
||||
if (!attempt) return null
|
||||
if (attempt.status === 'failed') return currentAttemptRequestError.value?.diagnostic ?? null
|
||||
if (attempt.status !== 'skipped' || !currentAttemptFailureDiagnostic.value) return null
|
||||
return buildAttemptDiagnosticPayload(
|
||||
attempt,
|
||||
currentAttemptFailureDiagnostic.value.message,
|
||||
attempt.status_code,
|
||||
normalizeUpstreamResponseDisplay(attempt.extra_data?.upstream_response),
|
||||
extractVisibleDiagnosticMessage(attempt.extra_data),
|
||||
)
|
||||
})
|
||||
const diagnosticDisplay = computed(() => exportedDiagnostic.value
|
||||
?? (currentAttemptDiagnostic.value ? sanitizeDiagnostic(currentAttemptDiagnostic.value) as Record<string, unknown> : null))
|
||||
|
||||
function resetDiagnosticCopy() {
|
||||
diagnosticController?.abort()
|
||||
diagnosticController = null
|
||||
clearTimeout(diagnosticCopyTimer)
|
||||
diagnosticCopying.value = false
|
||||
diagnosticCopied.value = false
|
||||
exportedDiagnostic.value = null
|
||||
}
|
||||
|
||||
async function copyFailureDiagnostic() {
|
||||
if (!currentAttemptDiagnostic.value || !currentAttempt.value || diagnosticCopying.value) return
|
||||
const bundle = JSON.parse(JSON.stringify(currentAttemptDiagnostic.value)) as Record<string, unknown>
|
||||
const attempt = JSON.parse(JSON.stringify(currentAttempt.value)) as CandidateRecord
|
||||
const currentTrace = trace.value ? { ...trace.value, candidates: [] } : null
|
||||
const controller = new AbortController()
|
||||
diagnosticController = controller
|
||||
diagnosticCopying.value = true
|
||||
diagnosticCopied.value = false
|
||||
try {
|
||||
const diagnostic = await prepareDiagnosticExport(bundle, attempt, currentTrace, controller.signal)
|
||||
if (controller.signal.aborted) return
|
||||
exportedDiagnostic.value = diagnostic
|
||||
const copied = await copyToClipboard(JSON.stringify(diagnostic, null, 2))
|
||||
if (controller.signal.aborted) return
|
||||
diagnosticCopied.value = copied
|
||||
if (copied) diagnosticCopyTimer = setTimeout(() => { diagnosticCopied.value = false }, 2000)
|
||||
} catch {
|
||||
if (controller.signal.aborted) return
|
||||
const fallback = sanitizeDiagnostic({
|
||||
...bundle,
|
||||
reproduction: { status: 'insufficient_context', missing_context: ['export_failed'] },
|
||||
}) as Record<string, unknown>
|
||||
exportedDiagnostic.value = fallback
|
||||
diagnosticCopied.value = await copyToClipboard(JSON.stringify(fallback, null, 2))
|
||||
} finally {
|
||||
if (diagnosticController === controller) {
|
||||
diagnosticCopying.value = false
|
||||
diagnosticController = null
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
watch([() => props.requestId, () => currentAttempt.value?.id, () => currentAttempt.value?.error_message], resetDiagnosticCopy)
|
||||
onBeforeUnmount(resetDiagnosticCopy)
|
||||
|
||||
const currentAttemptExtraDataDisplay = computed<Record<string, unknown> | null>(() => {
|
||||
const extra = extractObject(currentAttempt.value?.extra_data)
|
||||
if (!extra) return null
|
||||
|
||||
+111
-2
@@ -8,6 +8,13 @@ const requestTraceApiMock = vi.hoisted(() => ({
|
||||
getRequestTrace: vi.fn(),
|
||||
}))
|
||||
|
||||
const diagnosticCopyMock = vi.hoisted(() => ({ prepare: vi.fn(), copy: vi.fn() }))
|
||||
vi.mock('@/composables/useClipboard', () => ({ useClipboard: () => ({ copyToClipboard: diagnosticCopyMock.copy }) }))
|
||||
vi.mock('@/features/usage/utils/diagnosticExport', async importOriginal => ({
|
||||
...await importOriginal<typeof import('@/features/usage/utils/diagnosticExport')>(),
|
||||
prepareDiagnosticExport: diagnosticCopyMock.prepare,
|
||||
}))
|
||||
|
||||
vi.mock('@/api/requestTrace', () => ({
|
||||
requestTraceApi: requestTraceApiMock,
|
||||
}))
|
||||
@@ -62,9 +69,16 @@ vi.mock('../JsonContentPanel.vue', async () => {
|
||||
type: String,
|
||||
default: 'JSON',
|
||||
},
|
||||
customCopy: Boolean,
|
||||
copyDisabled: Boolean,
|
||||
copied: Boolean,
|
||||
},
|
||||
setup(props) {
|
||||
return () => h('pre', { 'data-title': props.title }, JSON.stringify(props.data))
|
||||
emits: ['copy'],
|
||||
setup(props, { emit }) {
|
||||
return () => h('div', [
|
||||
h('pre', { 'data-title': props.title }, JSON.stringify(props.data)),
|
||||
props.customCopy ? h('button', { 'data-copy-diagnostic': '', 'data-copied': props.copied, disabled: props.copyDisabled, onClick: () => emit('copy') }) : null,
|
||||
])
|
||||
},
|
||||
}),
|
||||
}
|
||||
@@ -173,6 +187,8 @@ function mountTimelineFromApi(
|
||||
|
||||
afterEach(() => {
|
||||
requestTraceApiMock.getRequestTrace.mockReset()
|
||||
diagnosticCopyMock.prepare.mockReset()
|
||||
diagnosticCopyMock.copy.mockReset()
|
||||
vi.useRealTimers()
|
||||
for (const { app, root } of mountedApps.splice(0)) {
|
||||
app.unmount()
|
||||
@@ -181,6 +197,50 @@ afterEach(() => {
|
||||
})
|
||||
|
||||
describe('HorizontalRequestTimeline', () => {
|
||||
it('exports a skipped conversion failure with context only after clicking copy', async () => {
|
||||
diagnosticCopyMock.prepare.mockImplementation(async bundle => ({ ...bundle, reproduction: { status: 'sanitized_context' } }))
|
||||
diagnosticCopyMock.copy.mockResolvedValue(true)
|
||||
const root = mountTimeline(buildTrace([buildCandidate({
|
||||
status: 'skipped', skip_reason: 'provider_request_body_build_failed',
|
||||
extra_data: { failure_diagnostic: { kind: 'request_conversion', path: '$.n', message: 'lossy conversion blocked from openai:chat to claude:messages at n: multiple outputs' } },
|
||||
})]))
|
||||
await nextTick()
|
||||
expect(diagnosticCopyMock.prepare).not.toHaveBeenCalled()
|
||||
const button = root.querySelector<HTMLButtonElement>('[data-copy-diagnostic]')!
|
||||
expect(button).not.toBeNull()
|
||||
button.click()
|
||||
await flushPendingUpdates()
|
||||
expect(diagnosticCopyMock.prepare).toHaveBeenCalledTimes(1)
|
||||
expect(JSON.parse(diagnosticCopyMock.copy.mock.calls[0][0])).toMatchObject({ schema_version: 2, breakpoint: '$.n', reproduction: { status: 'sanitized_context' } })
|
||||
expect(button.dataset.copied).toBe('true')
|
||||
})
|
||||
|
||||
it('does not report copy success when the clipboard rejects it', async () => {
|
||||
diagnosticCopyMock.prepare.mockImplementation(async bundle => bundle)
|
||||
diagnosticCopyMock.copy.mockResolvedValue(false)
|
||||
const root = mountTimeline(buildTrace([buildCandidate({ error_message: 'unsupported provider stream finish reason: error' })]))
|
||||
await nextTick()
|
||||
const button = root.querySelector<HTMLButtonElement>('[data-copy-diagnostic]')!
|
||||
button.click()
|
||||
await flushPendingUpdates()
|
||||
expect(button.dataset.copied).toBe('false')
|
||||
})
|
||||
|
||||
it('cancels in-flight diagnostic exports on unmount', async () => {
|
||||
let finish: (value: Record<string, unknown>) => void = () => undefined
|
||||
diagnosticCopyMock.prepare.mockImplementation(() => new Promise(resolve => { finish = resolve }))
|
||||
const root = mountTimeline(buildTrace([buildCandidate({ error_message: 'unsupported provider stream finish reason: error' })]))
|
||||
await nextTick()
|
||||
root.querySelector<HTMLButtonElement>('[data-copy-diagnostic]')!.click()
|
||||
await nextTick()
|
||||
mountedApps.splice(mountedApps.findIndex(item => item.root === root), 1)[0].app.unmount()
|
||||
root.remove()
|
||||
const signal = diagnosticCopyMock.prepare.mock.calls[0][3] as AbortSignal
|
||||
expect(signal.aborted).toBe(true)
|
||||
finish({ reproduction: { status: 'sanitized_context' } })
|
||||
await flushPendingUpdates()
|
||||
expect(diagnosticCopyMock.copy).not.toHaveBeenCalled()
|
||||
})
|
||||
it('only renders allowlisted provider website protocols', async () => {
|
||||
const unsafeRoot = mountTimeline(buildTrace([
|
||||
buildCandidate({ provider_website: 'javascript:alert(document.cookie)' }),
|
||||
@@ -849,6 +909,55 @@ describe('HorizontalRequestTimeline', () => {
|
||||
expect(diagnosticText).toContain('"breakpoint":"$.finish_reason"')
|
||||
})
|
||||
|
||||
it.each([
|
||||
'unsupported provider stream finish reason: error',
|
||||
'Upstream stream ended with finish reason: error',
|
||||
])('shows an upstream terminal failure rather than a conversion error for %s', async (errorMessage) => {
|
||||
const trace = buildTrace([
|
||||
buildCandidate({
|
||||
status: 'failed',
|
||||
status_code: 200,
|
||||
error_type: 'stream_terminal_error',
|
||||
error_message: errorMessage,
|
||||
extra_data: {
|
||||
client_api_format: 'claude:messages',
|
||||
provider_api_format: 'claude:messages',
|
||||
upstream_response: { status_code: 200, body_state: 'reference' },
|
||||
},
|
||||
}),
|
||||
])
|
||||
const root = mountTimeline(trace, { requestApiFormat: 'claude:messages' })
|
||||
await nextTick()
|
||||
|
||||
expect(root.querySelector('.error-msg')?.textContent).toContain('上游流式响应异常终止')
|
||||
expect(root.querySelector('.error-msg')?.textContent).not.toContain('格式转换失败')
|
||||
const diagnostic = JSON.parse(root.querySelector('.error-diagnostic-json')?.textContent ?? '{}')
|
||||
expect(diagnostic.breakpoint).toBe('$.delta.stop_reason')
|
||||
expect(diagnostic.analysis_hint).toContain('不要映射为正常结束')
|
||||
expect(diagnostic.analysis_hint).not.toContain('finish_reason 映射')
|
||||
expect(diagnostic.node.status_code).toBe(200)
|
||||
expect(diagnostic.node.error_message).toBe(errorMessage)
|
||||
})
|
||||
|
||||
it('distinguishes terminal validation from an actual finish reason conversion failure', async () => {
|
||||
const trace = buildTrace([
|
||||
buildCandidate({
|
||||
status_code: 200,
|
||||
error_type: 'stream_terminal_error',
|
||||
error_message: 'unsupported provider stream finish reason: future_reason',
|
||||
}),
|
||||
])
|
||||
const root = mountTimeline(trace)
|
||||
await nextTick()
|
||||
|
||||
expect(root.querySelector('.error-msg')?.textContent).toContain('流式终态校验失败')
|
||||
expect(root.querySelector('.error-msg')?.textContent).toContain('future_reason')
|
||||
expect(root.querySelector('.error-msg')?.textContent).not.toContain('格式转换失败')
|
||||
const diagnostic = JSON.parse(root.querySelector('.error-diagnostic-json')?.textContent ?? '{}')
|
||||
expect(diagnostic.breakpoint).toBe('$.finish_reason')
|
||||
expect(diagnostic.analysis_hint).toContain('上游流式终态校验')
|
||||
})
|
||||
|
||||
it('uses conversion messages from error_flow as the diagnostic breakpoint source', async () => {
|
||||
const trace = buildTrace([
|
||||
buildCandidate({
|
||||
|
||||
@@ -0,0 +1,119 @@
|
||||
import { describe, expect, it, vi } from 'vitest'
|
||||
import type { CandidateRecord, RequestTrace } from '@/api/requestTrace'
|
||||
import { diagnosticSamples, prepareDiagnosticExport, sanitizeDiagnostic } from '../diagnosticExport'
|
||||
|
||||
const candidate = (extra: Record<string, unknown> = {}): CandidateRecord => ({
|
||||
id: 'failed-candidate', request_id: 'request-1', candidate_index: 0, retry_index: 0,
|
||||
status: 'failed', is_cached: false, created_at: '2026-09-08T00:00:00Z', extra_data: extra,
|
||||
})
|
||||
const trace: RequestTrace = {
|
||||
request_id: 'request-1', final_status: 'failed', total_candidates: 1, total_latency_ms: 0, candidates: [],
|
||||
diagnostic_request: { usage_id: 'usage-1', body_state: 'reference' },
|
||||
}
|
||||
const bundle = (stage = 'response', path = '$.stop_reason', actual: unknown = 'future') => ({
|
||||
schema_version: 2, summary: 'conversion failed', request: { request_id: 'request-1' },
|
||||
diagnostic: { stage, path, actual, code: 'invalid_enum_value', missing_context: [] },
|
||||
})
|
||||
const context = { usage_id: 'usage-1', body_states: { request_body: 'reference', provider_request_body: 'disabled', response_body: 'reference' } }
|
||||
|
||||
describe('diagnostic export', () => {
|
||||
it('loads only the matched usage and preserves concrete field evidence', async () => {
|
||||
const loader = vi.fn(async (_usageId: string, field: string) => field === 'request_body'
|
||||
? { messages: [{ role: 'user', content: 'private customer text' }] }
|
||||
: { stop_reason: 'future', authorization: 'opaque-secret', message: 'failed with opaque-secret' })
|
||||
const result = await prepareDiagnosticExport(bundle(), candidate({ diagnostic_context: context }), trace, new AbortController().signal, loader)
|
||||
expect(loader.mock.calls).toEqual([['usage-1', 'request_body', expect.any(AbortSignal)], ['usage-1', 'response_body', expect.any(AbortSignal)]])
|
||||
expect(result.reproduction).toMatchObject({ status: 'sanitized_context', replay_ready: false, sources: {
|
||||
response_body: { field_samples: [{ path: '$.stop_reason', value: { stop_reason: 'future' } }] },
|
||||
} })
|
||||
expect(JSON.stringify(result)).not.toContain('opaque-secret')
|
||||
expect(JSON.stringify(result)).not.toContain('private customer text')
|
||||
})
|
||||
|
||||
it('never substitutes the final attempt response for a different failed candidate', async () => {
|
||||
const loader = vi.fn(async () => ({ messages: [] }))
|
||||
const result = await prepareDiagnosticExport(bundle(), candidate(), trace, new AbortController().signal, loader)
|
||||
expect(loader).toHaveBeenCalledTimes(1)
|
||||
expect(loader).toHaveBeenCalledWith('usage-1', 'request_body', expect.any(AbortSignal))
|
||||
expect(result.reproduction).toMatchObject({ status: 'insufficient_context', missing_context: ['response_body'], sources: { response_body: { status: 'unavailable' } } })
|
||||
})
|
||||
|
||||
it('does not follow body_ref URLs or fetch disabled bodies', async () => {
|
||||
const loader = vi.fn()
|
||||
const result = await prepareDiagnosticExport(bundle(), candidate({
|
||||
upstream_response: { body_ref: 'https://untrusted.example/private' },
|
||||
diagnostic_context: { usage_id: 'usage-1', body_states: { request_body: 'disabled', response_body: 'disabled', provider_request_body: 'disabled' } },
|
||||
}), null, new AbortController().signal, loader)
|
||||
expect(loader).not.toHaveBeenCalled()
|
||||
expect(result.reproduction).toMatchObject({ status: 'insufficient_context', sources: { response_body: { status: 'disabled' } } })
|
||||
})
|
||||
|
||||
it.each([[403, 'forbidden'], [404, 'missing'], [500, 'load_failed']])('exports an explicit gap for HTTP %s', async (status, expected) => {
|
||||
const loader = vi.fn().mockRejectedValue({ response: { status } })
|
||||
const result = await prepareDiagnosticExport(bundle(), candidate({ diagnostic_context: context }), trace, new AbortController().signal, loader)
|
||||
expect(result.reproduction).toMatchObject({ status: 'insufficient_context', sources: { response_body: { status: expected } } })
|
||||
})
|
||||
|
||||
it('keeps the failing SSE event, frame index and preceding context without leaking text', async () => {
|
||||
const raw = [
|
||||
['message_start', { type: 'message_start', message: { id: 'msg-1' } }],
|
||||
['content_block_delta', { type: 'content_block_delta', delta: { type: 'text_delta', text: 'confidential content' } }],
|
||||
['message_delta', { type: 'message_delta', delta: { stop_reason: 'error' } }],
|
||||
['message_stop', { type: 'message_stop' }],
|
||||
].map(([event, payload]) => `event: ${event}\ndata: ${JSON.stringify(payload)}\n\n`).join('')
|
||||
const result = await prepareDiagnosticExport(bundle('stream', '$.delta.stop_reason', 'error'), candidate({ upstream_response: { body: { raw_response: raw } } }), null, new AbortController().signal, vi.fn())
|
||||
expect(result.reproduction).toMatchObject({ status: 'sanitized_context', sources: { response_body: { sample: { failure_frame_index: 2, selection: 'matched_failure', captured_frames: 4 } } } })
|
||||
expect(JSON.stringify(result)).toContain('message_start')
|
||||
expect(JSON.stringify(result)).not.toContain('confidential content')
|
||||
})
|
||||
|
||||
it('marks a truncated stream without the failing event as incomplete', async () => {
|
||||
const result = await prepareDiagnosticExport(bundle('stream', '$.type', 'future.event'), candidate({ upstream_response: { body: { raw_response: 'event: message_start\ndata: {"type":"message_start"}\n\n' } } }), null, new AbortController().signal, vi.fn())
|
||||
expect(result.reproduction).toMatchObject({ status: 'insufficient_context', missing_context: ['failed_stream_event'] })
|
||||
})
|
||||
|
||||
it('cancels instead of copying another candidate after navigation', async () => {
|
||||
const controller = new AbortController()
|
||||
const loader = vi.fn(async () => { controller.abort(); return {} })
|
||||
await expect(prepareDiagnosticExport(bundle(), candidate({ diagnostic_context: context }), trace, controller.signal, loader)).rejects.toMatchObject({ name: 'AbortError' })
|
||||
})
|
||||
|
||||
it('identifies the actual failing element beyond the initial excerpt', () => {
|
||||
const choices = Array.from({ length: 50 }, (_value, index) => ({ finish_reason: index === 40 ? 'future' : 'stop' }))
|
||||
expect(diagnosticSamples({ choices }, '$.choices[*].finish_reason', 'future')).toEqual([{ path: '$.choices[40].finish_reason', value: { finish_reason: 'future' } }])
|
||||
})
|
||||
|
||||
it('redacts credentials, signed URLs, private text and error echoes', () => {
|
||||
const result = sanitizeDiagnostic({
|
||||
diagnostic: { path: '$.api_key', actual: 'plain-secret-value' },
|
||||
summary: 'invalid enum value "plain-secret-value" for api_key',
|
||||
raw: { headers: { Authorization: 'Bearer authorization-private-value', Cookie: 'session=abc', 'x-api-key': 'plain-secret-value', 'x-goog-api-key': 'google-private-key', 'x-auth-token': 'provider-private-token' },
|
||||
error: 'Bearer other-token https://user:password@example.com/test?token=abc admin@example.com',
|
||||
content: 'private customer text',
|
||||
},
|
||||
})
|
||||
const output = JSON.stringify(result)
|
||||
for (const privateValue of ['plain-secret-value', 'authorization-private-value', 'session=abc', 'other-token', 'password@', 'token=abc', 'admin@example.com', 'private customer text', 'google-private-key', 'provider-private-token']) expect(output).not.toContain(privateValue)
|
||||
})
|
||||
|
||||
it('bounds the exported payload even for very large inline responses', async () => {
|
||||
const body = Object.fromEntries(Array.from({ length: 64 }, (_value, index) => [`field${index}`, 'value'.repeat(10000)]))
|
||||
const result = await prepareDiagnosticExport(bundle(), candidate({ upstream_response: { body } }), null, new AbortController().signal, vi.fn())
|
||||
expect(JSON.stringify(result, null, 2).length).toBeLessThanOrEqual(64 * 1024)
|
||||
expect(result.reproduction).toMatchObject({ status: 'insufficient_context' })
|
||||
})
|
||||
|
||||
it('never drops the failure frame when many earlier block starts match', async () => {
|
||||
const events = Array.from({ length: 30 }, () => ({ type: 'content_block_start', index: 0 }))
|
||||
const raw = [...events, { type: 'content_block_delta', index: 0, delta: { type: 'future_delta' } }]
|
||||
.map(payload => `event: ${payload.type}\ndata: ${JSON.stringify(payload)}\n\n`).join('')
|
||||
const result = await prepareDiagnosticExport(bundle('stream', '$.delta.type', 'future_delta'), candidate({ upstream_response: { body: { raw_response: raw } } }), null, new AbortController().signal, vi.fn())
|
||||
expect(JSON.stringify(result)).toContain('future_delta')
|
||||
expect(JSON.stringify(result)).toContain('"frame_index":30')
|
||||
})
|
||||
|
||||
it.each(['too_large', 'decode_failed', 'timeout'])('retains the specific body failure code %s', async code => {
|
||||
const result = await prepareDiagnosticExport(bundle(), candidate({ diagnostic_context: context }), trace, new AbortController().signal, vi.fn().mockRejectedValue(new Error(code)))
|
||||
expect(result.reproduction).toMatchObject({ status: 'insufficient_context', sources: { response_body: { status: code } } })
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,97 @@
|
||||
import { describe, expect, it } from 'vitest'
|
||||
import type { CandidateRecord } from '@/api/requestTrace'
|
||||
import { buildFailureDiagnosticBundle, diagnosticPathFromMessage, visibleFailureRecords } from '../failureDiagnostic'
|
||||
|
||||
const candidate = (overrides: Partial<CandidateRecord> = {}): CandidateRecord => ({
|
||||
id: 'candidate-1', request_id: 'request-1', candidate_index: 0, retry_index: 0,
|
||||
status: 'failed', is_cached: false, created_at: '2026-09-08T00:00:00Z',
|
||||
error_type: 'local_sync_attempt_aborted', ...overrides,
|
||||
})
|
||||
|
||||
const payload = {
|
||||
breakpoint: '$',
|
||||
request: { client_api_format: 'openai:chat', provider_api_format: 'claude:messages' },
|
||||
}
|
||||
|
||||
describe('failure diagnostic paths', () => {
|
||||
it.each([
|
||||
['invalid enum value "future" for claude:messages.content[2].type', '$.content[2].type'],
|
||||
['invalid enum value "future" for openai:chat.choices[].finish_reason', '$.choices[*].finish_reason'],
|
||||
['unaudited field metadata.private in openai:responses cannot be converted to claude:messages: no mapping', '$.metadata.private'],
|
||||
['lossy conversion blocked from openai:chat to claude:messages at messages[1].content[0].type: cannot preserve', '$.messages[1].content[0].type'],
|
||||
['Internal("invalid enum value \\"future\\" for claude:messages.content[2].type")', '$.content[2].type'],
|
||||
['Local sync attempt failed before terminal finalization: Internal("invalid enum value \\"future\\" for claude:messages.content[2].type")', '$.content[2].type'],
|
||||
['unsupported field tools[12].function.strict in claude:messages: unsupported', '$.tools[12].function.strict'],
|
||||
['failed to parse claude:messages response', ''],
|
||||
])('extracts the complete path from %s', (message, path) => {
|
||||
expect(diagnosticPathFromMessage(message)).toBe(path)
|
||||
})
|
||||
|
||||
it('prefers structured diagnostics over legacy text and preserves the actual value', () => {
|
||||
const result = buildFailureDiagnosticBundle(payload, candidate({
|
||||
status: 'skipped',
|
||||
error_message: 'failed to parse claude:messages request',
|
||||
extra_data: { failure_diagnostic: {
|
||||
stage: 'request', source: 'request_converter', path: '$.tools[3].type',
|
||||
details: { code: 'invalid_enum_value', actual: 'future', path: '$.tools[3].type' },
|
||||
} },
|
||||
}))
|
||||
expect(result.schema_version).toBe(2)
|
||||
expect(result.diagnostic).toMatchObject({
|
||||
code: 'invalid_enum_value', stage: 'request', stage_source: 'structured',
|
||||
path: '$.tools[3].type', path_source: 'structured', actual: 'future',
|
||||
source_format: 'openai:chat', target_format: 'claude:messages', converter: 'request_converter',
|
||||
})
|
||||
})
|
||||
|
||||
it('uses the reverse format direction for response conversion', () => {
|
||||
const result = buildFailureDiagnosticBundle(payload, candidate({ error_message: 'invalid enum value "future" for claude:messages.stop_reason' }))
|
||||
expect(result.diagnostic).toMatchObject({
|
||||
stage: 'response', path_source: 'message_inference', actual: 'future',
|
||||
source_format: 'claude:messages', target_format: 'openai:chat',
|
||||
})
|
||||
})
|
||||
|
||||
it.each([
|
||||
['claude:messages', '$.delta.stop_reason'],
|
||||
['openai:chat', '$.choices[*].finish_reason'],
|
||||
['gemini:generate_content', '$.candidates[*].finishReason'],
|
||||
])('resolves canonical finish reasons to the %s source field', (providerFormat, path) => {
|
||||
const result = buildFailureDiagnosticBundle({
|
||||
breakpoint: '$.finish_reason',
|
||||
request: { client_api_format: 'claude:messages', provider_api_format: providerFormat },
|
||||
}, candidate({ error_type: 'stream_terminal_error', error_message: 'unsupported provider stream finish reason: future_reason' }))
|
||||
expect(result.diagnostic).toMatchObject({
|
||||
stage: 'stream', code: 'unsupported_finish_reason', actual: 'future_reason',
|
||||
reported_path: '$.finish_reason', path, path_source: 'protocol_inference',
|
||||
})
|
||||
})
|
||||
|
||||
it('does not replace a structured finish reason path with a protocol guess', () => {
|
||||
const result = buildFailureDiagnosticBundle(payload, candidate({
|
||||
error_type: 'stream_terminal_error', error_message: 'unsupported provider stream finish reason: future_reason',
|
||||
extra_data: { failure_diagnostic: { stage: 'stream', path: '$.message.stop_reason' } },
|
||||
}))
|
||||
expect(result.diagnostic).toMatchObject({ path: '$.message.stop_reason', path_source: 'structured' })
|
||||
})
|
||||
|
||||
it('keeps generic parse failures explicitly incomplete instead of inventing a path', () => {
|
||||
const result = buildFailureDiagnosticBundle(payload, candidate({ error_message: 'failed to parse claude:messages response' }))
|
||||
expect(result.diagnostic).toMatchObject({ code: 'response_parse_failed', path: '$', path_source: 'unavailable', missing_context: ['field_path'] })
|
||||
expect(result.reproduction).toMatchObject({ status: 'not_loaded' })
|
||||
})
|
||||
|
||||
it('uses the selected error-flow message rather than a generic fallback', () => {
|
||||
const result = buildFailureDiagnosticBundle(payload, candidate({ error_message: 'execution runtime returned non-success status 500' }), null,
|
||||
'unaudited field metadata.private in claude:messages cannot be converted to openai:chat: no mapping')
|
||||
expect(result.diagnostic).toMatchObject({ code: 'unaudited_field', path: '$.metadata.private' })
|
||||
})
|
||||
|
||||
it('does not expose hidden diagnostics through compatibility aliases', () => {
|
||||
expect(visibleFailureRecords({
|
||||
failure_diagnostic: { safe_to_show: false, message: 'private' },
|
||||
request_conversion_error: { message: 'private' },
|
||||
request_body_build_error: { message: 'private' },
|
||||
})).toEqual([])
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,262 @@
|
||||
import { dashboardApi, type RequestBodyField } from '@/api/dashboard'
|
||||
import type { CandidateRecord, RequestTrace } from '@/api/requestTrace'
|
||||
import { decodeBody } from './body-document-engine'
|
||||
import { diagnosticObject } from './failureDiagnostic'
|
||||
|
||||
const MAX_SOURCE_BYTES = 1024 * 1024
|
||||
const MAX_EXPORT_CHARS = 64 * 1024
|
||||
const SECRET_KEY = /^(?:authorization|proxy[-_]authorization|cookie|set[-_]cookie|(?:x[-_])?api[-_]?key|x[-_]goog[-_]api[-_]key|(?:openai|anthropic)[-_]api[-_]?key|(?:x[-_])?auth[-_]token|api[-_]secret|secret[-_]key|session(?:[-_]id)?|key|token|access[-_]token|refresh[-_]token|id[-_]token|client[-_]secret|secret|password|passwd|credential|credentials|private[-_]key)$/i
|
||||
const CONTENT_KEY = /^(?:text|content|prompt|system|instructions|input|arguments|partial_json|thinking|signature|data|image|url|image_url|audio|video|raw_response|body|description|refusal)$/i
|
||||
|
||||
function redactString(value: string): string {
|
||||
return value
|
||||
.replace(/\b(?:Bearer|Basic)\s+[A-Za-z0-9_+./=:-]+/gi, '[REDACTED_AUTH]')
|
||||
.replace(/\b(?:sk-[A-Za-z0-9_-]{6,}|AIza[A-Za-z0-9_-]+|eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+)/g, '[REDACTED_TOKEN]')
|
||||
.replace(/\b(api[_-]?key|access_token|refresh_token|password|secret)\s*[=:]\s*[^\s&,;"']+/gi, '$1=[REDACTED]')
|
||||
.replace(/https?:\/\/[^\s"<>]+/gi, value => {
|
||||
try {
|
||||
const url = new URL(value)
|
||||
url.username = ''
|
||||
url.password = ''
|
||||
if (url.search) url.search = '?REDACTED'
|
||||
url.hash = ''
|
||||
return url.toString()
|
||||
} catch { return '[REDACTED_URL]' }
|
||||
})
|
||||
.replace(/[\w.+-]+@[\w.-]+\.[a-z]{2,}/gi, '[REDACTED_EMAIL]')
|
||||
.replace(/data:[^;\s]+;base64,[A-Za-z0-9+/=]+/gi, '[REDACTED_BINARY]')
|
||||
}
|
||||
|
||||
export function sanitizeDiagnostic(value: unknown): unknown {
|
||||
const secrets = new Set<string>()
|
||||
let scanned = 2500
|
||||
const collect = (input: unknown, key = '', depth = 0) => {
|
||||
if (--scanned < 0 || depth > 16) return
|
||||
if (SECRET_KEY.test(key) && typeof input === 'string') secrets.add(input.slice(0, 4096))
|
||||
if (Array.isArray(input)) input.slice(0, 64).forEach(child => collect(child, key, depth + 1))
|
||||
else if (input && typeof input === 'object') Object.entries(input).slice(0, 64).forEach(([name, child]) => collect(child, name, depth + 1))
|
||||
}
|
||||
collect(value)
|
||||
const originalDiagnostic = diagnosticObject(diagnosticObject(value).diagnostic)
|
||||
if (typeof originalDiagnostic.path === 'string' && originalDiagnostic.path.split(/[.[\]]/).some(part => SECRET_KEY.test(part))) {
|
||||
if (typeof originalDiagnostic.actual === 'string') secrets.add(originalDiagnostic.actual)
|
||||
}
|
||||
let remaining = 1200
|
||||
const visit = (input: unknown, key = '', depth = 0): unknown => {
|
||||
if (--remaining < 0 || depth > 16) return '[TRUNCATED]'
|
||||
if (SECRET_KEY.test(key)) return '[REDACTED]'
|
||||
if (typeof input === 'string') {
|
||||
if (CONTENT_KEY.test(key)) return `[REDACTED_TEXT length=${input.length}]`
|
||||
let redacted = input.slice(0, 2048)
|
||||
for (const secret of secrets) {
|
||||
if (secret.length >= 4) {
|
||||
const prefix = secret.slice(0, 32)
|
||||
for (let count = 0; count < 16; count++) {
|
||||
const index = redacted.indexOf(prefix)
|
||||
if (index < 0) break
|
||||
redacted = `${redacted.slice(0, index)}[REDACTED]${redacted.slice(index + secret.length)}`
|
||||
}
|
||||
}
|
||||
else if (secret && redacted === secret) redacted = '[REDACTED]'
|
||||
}
|
||||
redacted = redactString(redacted)
|
||||
return input.length > 2048 ? `${redacted}[TRUNCATED]` : redacted
|
||||
}
|
||||
if (Array.isArray(input)) {
|
||||
const output = input.slice(0, 32).map(item => visit(item, key, depth + 1))
|
||||
if (input.length > 32) output.push(`[TRUNCATED ${input.length - 32} items]`)
|
||||
return output
|
||||
}
|
||||
if (input && typeof input === 'object') {
|
||||
const entries = Object.entries(input).slice(0, 64)
|
||||
const output: Record<string, unknown> = {}
|
||||
for (const [name, child] of entries) {
|
||||
if (['__proto__', 'constructor', 'prototype'].includes(name)) continue
|
||||
output[redactString(name.slice(0, 128))] = visit(child, name, depth + 1)
|
||||
}
|
||||
if (Object.keys(input).length > 64) output.__truncated__ = true
|
||||
return output
|
||||
}
|
||||
return input
|
||||
}
|
||||
const sanitized = visit(value)
|
||||
const safe = diagnosticObject(sanitized)
|
||||
const diagnostic = diagnosticObject(safe.diagnostic)
|
||||
if (typeof diagnostic.path === 'string' && diagnostic.path.split(/[.[\]]/).some(part => SECRET_KEY.test(part))) {
|
||||
diagnostic.actual = '[REDACTED]'
|
||||
}
|
||||
return sanitized
|
||||
}
|
||||
|
||||
export function diagnosticSamples(body: unknown, path: string, actual?: unknown): Array<{ path: string, value: unknown }> {
|
||||
if (!/^\$(?:\.[\w:-]+|\[(?:\d+|\*)\])+$/.test(path)) return []
|
||||
const parts = path.slice(1).replace(/\[(\d+|\*)\]/g, '.$1').split('.').filter(Boolean)
|
||||
let matches: Array<{ path: string, value: unknown }> = [{ path: '$', value: body }]
|
||||
for (const part of parts) {
|
||||
matches = matches.flatMap(match => {
|
||||
if (part === '*' && Array.isArray(match.value)) {
|
||||
return match.value.slice(0, 64).map((value, index) => ({ path: `${match.path}[${index}]`, value }))
|
||||
}
|
||||
if (match.value === null || typeof match.value !== 'object' || !Object.prototype.hasOwnProperty.call(match.value, part)) return []
|
||||
const value = (match.value as Record<string, unknown>)[part]
|
||||
return [{ path: Array.isArray(match.value) ? `${match.path}[${part}]` : `${match.path}.${part}`, value }]
|
||||
}).slice(0, 64)
|
||||
}
|
||||
return matches.filter(match => actual == null || Object.is(match.value, actual)).slice(0, 8).map(match => ({
|
||||
path: match.path,
|
||||
value: match.path.split(/[.[\]]/).some(part => SECRET_KEY.test(part)) ? '[REDACTED]' : sanitizeDiagnostic({ [parts[parts.length - 1] ?? 'value']: match.value }),
|
||||
}))
|
||||
}
|
||||
|
||||
function streamEvidence(body: unknown, path: string, actual: unknown): Record<string, unknown> | null {
|
||||
const object = diagnosticObject(body)
|
||||
const raw = typeof body === 'string' ? body : object.raw_response ?? object.sse
|
||||
if (typeof raw !== 'string' || !/(?:^|\n)(?:event|data):/.test(raw)) return null
|
||||
const events = raw.slice(0, MAX_SOURCE_BYTES).split(/\r?\n\r?\n/).flatMap((block, index) => {
|
||||
const lines = block.split(/\r?\n/)
|
||||
const data = lines.filter(line => line.startsWith('data:')).map(line => line.slice(5).trimStart()).join('\n')
|
||||
if (!data || data === '[DONE]') return []
|
||||
let payload: unknown
|
||||
try { payload = JSON.parse(data) } catch { payload = { unparsed: true, bytes: data.length } }
|
||||
return [{ frame_index: index, event: lines.find(line => line.startsWith('event:'))?.slice(6).trim() ?? diagnosticObject(payload).type ?? null, payload }]
|
||||
})
|
||||
const targetIndex = events.findIndex(event => {
|
||||
const payload = diagnosticObject(event.payload)
|
||||
if (actual !== null && actual !== undefined) {
|
||||
const samples = diagnosticSamples(payload, path, actual)
|
||||
if (samples.some(sample => Object.values(diagnosticObject(sample.value)).some(value => value === actual))) return true
|
||||
}
|
||||
return event.event === 'error' || event.event === 'response.failed' || Boolean(payload.error)
|
||||
})
|
||||
const center = targetIndex >= 0 ? targetIndex : Math.max(0, events.length - 1)
|
||||
const selected = new Set([0])
|
||||
for (let index = Math.max(0, center - 3); index <= Math.min(events.length - 1, center + 1); index++) selected.add(index)
|
||||
const target = diagnosticObject(events[center]?.payload)
|
||||
for (let index = center - 1; index >= 0; index--) {
|
||||
const event = events[index]
|
||||
if (event.event === 'content_block_start' && diagnosticObject(event.payload).index === target.index) {
|
||||
selected.add(index)
|
||||
break
|
||||
}
|
||||
}
|
||||
return {
|
||||
captured_frames: events.length,
|
||||
source_truncated: raw.length > MAX_SOURCE_BYTES,
|
||||
failure_frame_index: targetIndex >= 0 ? events[targetIndex]?.frame_index : null,
|
||||
selection: targetIndex >= 0 ? 'matched_failure' : 'unmatched_tail',
|
||||
windowed: selected.size < events.length,
|
||||
events: [...selected].sort((left, right) => left - right).slice(0, 12).map(index => events[index]).filter(Boolean),
|
||||
}
|
||||
}
|
||||
|
||||
type BodyLoader = (usageId: string, field: RequestBodyField, signal: AbortSignal) => Promise<unknown>
|
||||
|
||||
async function loadBody(usageId: string, field: RequestBodyField, signal: AbortSignal): Promise<unknown> {
|
||||
const controller = new AbortController()
|
||||
let tooLarge = false
|
||||
const abort = () => controller.abort()
|
||||
signal.addEventListener('abort', abort, { once: true })
|
||||
const timer = setTimeout(abort, 5000)
|
||||
try {
|
||||
if (signal.aborted) throw new DOMException('Aborted', 'AbortError')
|
||||
const response = await dashboardApi.getRequestBody(usageId, field, controller.signal, loaded => {
|
||||
if (loaded > MAX_SOURCE_BYTES) {
|
||||
tooLarge = true
|
||||
controller.abort()
|
||||
}
|
||||
})
|
||||
if (response.bytes.byteLength > MAX_SOURCE_BYTES) throw new Error('too_large')
|
||||
return (await decodeBody(response.bytes, response.encoding, MAX_SOURCE_BYTES)).value
|
||||
} catch (error) {
|
||||
if (tooLarge) throw new Error('too_large')
|
||||
if (controller.signal.aborted && !signal.aborted) throw new Error('timeout')
|
||||
throw error
|
||||
} finally {
|
||||
clearTimeout(timer)
|
||||
signal.removeEventListener('abort', abort)
|
||||
}
|
||||
}
|
||||
|
||||
export async function prepareDiagnosticExport(
|
||||
bundle: Record<string, unknown>,
|
||||
attempt: CandidateRecord,
|
||||
trace: RequestTrace | null,
|
||||
signal: AbortSignal,
|
||||
loader: BodyLoader = loadBody,
|
||||
): Promise<Record<string, unknown>> {
|
||||
const diagnostic = diagnosticObject(bundle.diagnostic)
|
||||
const stage = diagnostic.stage
|
||||
const context = diagnosticObject(attempt.extra_data?.diagnostic_context)
|
||||
const states = diagnosticObject(context.body_states)
|
||||
const primary = stage === 'request' ? 'request_body' : 'response_body'
|
||||
const fields: RequestBodyField[] = stage === 'request' ? ['request_body', 'provider_request_body'] : ['request_body', 'provider_request_body', 'response_body']
|
||||
const sources: Record<string, unknown> = {}
|
||||
const missing = Array.isArray(diagnostic.missing_context) ? [...diagnostic.missing_context] : []
|
||||
for (const field of fields) {
|
||||
if (signal.aborted) throw new DOMException('Aborted', 'AbortError')
|
||||
const usageId = field === 'request_body' ? trace?.diagnostic_request?.usage_id ?? context.usage_id : context.usage_id
|
||||
const state = field === 'request_body' ? trace?.diagnostic_request?.body_state ?? states[field] : states[field]
|
||||
const inline = field === 'response_body' ? diagnosticObject(attempt.extra_data?.upstream_response).body : undefined
|
||||
if (inline === undefined && (typeof usageId !== 'string' || !usageId || ['disabled', 'none'].includes(String(state)))) {
|
||||
sources[field] = { status: state === 'disabled' ? 'disabled' : 'unavailable', candidate_matched: Boolean(context.usage_id) }
|
||||
if (field === primary) missing.push(field)
|
||||
continue
|
||||
}
|
||||
try {
|
||||
const body = inline !== undefined ? inline : await loader(usageId as string, field, signal)
|
||||
if (signal.aborted) throw new DOMException('Aborted', 'AbortError')
|
||||
const sse = field === 'response_body' && stage === 'stream' ? streamEvidence(body, String(diagnostic.path ?? '$'), diagnostic.actual) : null
|
||||
const samples = field === primary ? diagnosticSamples(body, String(diagnostic.path ?? '$'), diagnostic.actual) : []
|
||||
sources[field] = {
|
||||
status: 'captured',
|
||||
origin: inline !== undefined ? 'candidate_inline' : 'stored_body',
|
||||
usage_id: usageId ?? null,
|
||||
sample: sse ?? body,
|
||||
field_samples: samples,
|
||||
}
|
||||
if (field === primary && stage === 'stream' && (!sse || sse.failure_frame_index === null)) missing.push('failed_stream_event')
|
||||
if (sse?.source_truncated) missing.push('body_size_limit')
|
||||
if (field === primary && state === 'truncated') missing.push('body_capture_truncated')
|
||||
if (field === primary && stage !== 'stream' && diagnostic.path !== '$' && samples.length === 0) missing.push('field_not_found_in_source')
|
||||
} catch (error) {
|
||||
if (signal.aborted) throw new DOMException('Aborted', 'AbortError')
|
||||
const response = diagnosticObject(diagnosticObject(error).response)
|
||||
const status = response.status
|
||||
const cause = diagnosticObject(response.headers)['x-aether-body-error'] ?? diagnosticObject(error).code ?? (error instanceof Error ? error.message : '')
|
||||
const code = status === 403 ? 'forbidden' : status === 404 ? 'missing' : ['too_large', 'decode_failed', 'timeout', 'missing', 'storage_unavailable'].includes(String(cause)) ? String(cause) : 'load_failed'
|
||||
sources[field] = { status: code }
|
||||
if (field === primary) missing.push(field)
|
||||
}
|
||||
}
|
||||
const result = sanitizeDiagnostic({
|
||||
...bundle,
|
||||
reproduction: {
|
||||
status: missing.length ? 'insufficient_context' : 'sanitized_context',
|
||||
replay_ready: false,
|
||||
missing_context: [...new Set(missing)],
|
||||
redaction: 'Credentials, private text, URLs and binary data are removed; samples may be truncated. Review before sharing.',
|
||||
source_limit_bytes: MAX_SOURCE_BYTES,
|
||||
sources,
|
||||
},
|
||||
}) as Record<string, unknown>
|
||||
if (JSON.stringify(result, null, 2).length > MAX_EXPORT_CHARS) {
|
||||
const reproduction = diagnosticObject(result.reproduction)
|
||||
reproduction.status = 'insufficient_context'
|
||||
reproduction.missing_context = [...new Set([...missing, 'export_size_limit'])]
|
||||
for (const source of Object.values(diagnosticObject(reproduction.sources))) {
|
||||
const object = diagnosticObject(source)
|
||||
object.sample = '[TRUNCATED_EXPORT_SIZE_LIMIT]'
|
||||
object.field_samples = '[TRUNCATED_EXPORT_SIZE_LIMIT]'
|
||||
}
|
||||
result.raw = '[TRUNCATED_EXPORT_SIZE_LIMIT]'
|
||||
if (JSON.stringify(result, null, 2).length > MAX_EXPORT_CHARS) {
|
||||
return {
|
||||
schema_version: 2,
|
||||
summary: '[TRUNCATED_EXPORT_SIZE_LIMIT]',
|
||||
diagnostic: { code: diagnosticObject(result.diagnostic).code, stage: diagnosticObject(result.diagnostic).stage, path: diagnosticObject(result.diagnostic).path },
|
||||
reproduction: { status: 'insufficient_context', missing_context: ['export_size_limit'] },
|
||||
}
|
||||
}
|
||||
}
|
||||
return result
|
||||
}
|
||||
@@ -0,0 +1,168 @@
|
||||
import type { CandidateRecord, RequestTrace } from '@/api/requestTrace'
|
||||
|
||||
type JsonObject = Record<string, unknown>
|
||||
|
||||
export const diagnosticObject = (value: unknown): JsonObject =>
|
||||
value !== null && typeof value === 'object' && !Array.isArray(value) ? value as JsonObject : {}
|
||||
|
||||
const text = (value: unknown): string => typeof value === 'string' ? value.trim() : ''
|
||||
|
||||
export function unwrapDiagnosticMessage(message: string): string {
|
||||
let result = message.trim()
|
||||
for (let depth = 0; depth < 4; depth++) {
|
||||
const wrapped = result.match(/^(?:local sync attempt failed before terminal finalization:\s*)?Internal\("((?:\\.|[^"\\])*)"\)$/i)
|
||||
if (!wrapped) break
|
||||
try {
|
||||
result = JSON.parse(`"${wrapped[1]}"`) as string
|
||||
} catch {
|
||||
break
|
||||
}
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
export function normalizeFailurePath(field: string): string {
|
||||
const normalized = field.trim().replace(/\[\]/g, '[*]')
|
||||
return !normalized || normalized === '$' ? '$' : normalized.startsWith('$') ? normalized : `$.${normalized}`
|
||||
}
|
||||
|
||||
export function diagnosticPathFromMessage(message: string): string {
|
||||
const normalized = unwrapDiagnosticMessage(message)
|
||||
const patterns = [
|
||||
/\bfield\s+([^;=]+?)\s*(?:=|is unsupported|不支持)/i,
|
||||
/lossy conversion blocked from\s+\S+\s+to\s+\S+\s+at\s+([^:]+):/i,
|
||||
/(?:unsupported|unaudited) field\s+(.+?)\s+in\s+/i,
|
||||
/invalid target field\s+(.+?)\s+for\s+/i,
|
||||
/invalid enum value\s+.+?\s+for\s+[\w:-]+\.(.+)$/i,
|
||||
]
|
||||
for (const pattern of patterns) {
|
||||
const match = normalized.match(pattern)
|
||||
if (match?.[1]) return normalizeFailurePath(match[1])
|
||||
}
|
||||
return ''
|
||||
}
|
||||
|
||||
export function visibleFailureRecords(extra: JsonObject): JsonObject[] {
|
||||
if (diagnosticObject(extra.failure_diagnostic).safe_to_show === false) return []
|
||||
return ['failure_diagnostic', 'request_conversion_error', 'request_body_build_error']
|
||||
.map(key => diagnosticObject(extra[key]))
|
||||
.filter(record => Object.keys(record).length > 0 && record.safe_to_show !== false)
|
||||
}
|
||||
|
||||
export function buildFailureDiagnosticBundle(
|
||||
payload: JsonObject,
|
||||
attempt: CandidateRecord,
|
||||
trace?: RequestTrace | null,
|
||||
rawMessage = '',
|
||||
): JsonObject {
|
||||
const extra = diagnosticObject(attempt.extra_data)
|
||||
const structured = visibleFailureRecords(extra)[0] ?? {}
|
||||
const details = diagnosticObject(structured.details)
|
||||
const request = diagnosticObject(payload.request)
|
||||
const diagnosticContext = diagnosticObject(extra.diagnostic_context)
|
||||
const message = unwrapDiagnosticMessage(rawMessage || text(structured.message) || text(attempt.error_message) || text(payload.summary))
|
||||
const clientFormat = text(request.client_api_format) || text(structured.client_api_format)
|
||||
const providerFormat = text(request.provider_api_format) || text(structured.provider_api_format) || text(attempt.endpoint_name)
|
||||
let stage = text(structured.stage)
|
||||
if (!['request', 'response', 'stream'].includes(stage)) stage = ''
|
||||
const stageSource = stage ? 'structured' : 'inferred'
|
||||
if (!stage) {
|
||||
if (/stream/i.test(attempt.error_type ?? '') || /provider stream|stream ended/i.test(message)) stage = 'stream'
|
||||
else if (attempt.status === 'skipped' || /request|body_rules|header_rules/.test(text(structured.kind)) || /failed to (?:parse|emit) .+ request/i.test(message)) stage = 'request'
|
||||
else if (/local_sync|finaliz|response/i.test(attempt.error_type ?? '') || /failed to (?:parse|emit) .+ response/i.test(message)) stage = 'response'
|
||||
else stage = 'unknown'
|
||||
}
|
||||
const conversionPair = message.match(/(?:lossy conversion blocked from|unaudited field .+? in)\s+(\S+)\s+(?:to|cannot be converted to)\s+([^\s:]+:[^\s:]+(?:[:][^\s:]+)?)/i)
|
||||
if (stage === 'unknown' && conversionPair && clientFormat !== providerFormat) {
|
||||
if (conversionPair[1] === clientFormat && conversionPair[2] === providerFormat) stage = 'request'
|
||||
else if (conversionPair[1] === providerFormat && conversionPair[2] === clientFormat) stage = 'response'
|
||||
}
|
||||
let code = text(details.code) || text(structured.code)
|
||||
if (!code) {
|
||||
const patterns: Array<[RegExp, string]> = [
|
||||
[/(?:unsupported provider stream finish reason|upstream stream ended with finish reason):\s*error\s*$/i, 'stream_terminal_error'],
|
||||
[/unsupported provider stream finish reason/i, 'unsupported_finish_reason'],
|
||||
[/unsupported provider stream event/i, 'unsupported_stream_event'],
|
||||
[/lossy conversion blocked/i, 'lossy_conversion_blocked'],
|
||||
[/unaudited field/i, 'unaudited_field'],
|
||||
[/invalid enum value/i, 'invalid_enum_value'],
|
||||
[/invalid target field/i, 'invalid_target_field'],
|
||||
[/unsupported field/i, 'unsupported_field'],
|
||||
[/failed to parse .+ request/i, 'request_parse_failed'],
|
||||
[/failed to emit .+ request/i, 'request_emit_failed'],
|
||||
[/failed to parse .+ response/i, 'response_parse_failed'],
|
||||
[/failed to emit .+ response/i, 'response_emit_failed'],
|
||||
]
|
||||
code = patterns.find(([pattern]) => pattern.test(message))?.[1] || attempt.error_type || text(structured.kind) || 'unknown_failure'
|
||||
}
|
||||
const structuredPath = text(details.path) || text(structured.path)
|
||||
const parsedPath = diagnosticPathFromMessage(message)
|
||||
const reportedPath = normalizeFailurePath(structuredPath && structuredPath !== '$' ? structuredPath : parsedPath || text(payload.breakpoint))
|
||||
const streamFinishPaths: Record<string, string> = {
|
||||
'claude:messages': '$.delta.stop_reason',
|
||||
'openai:chat': '$.choices[*].finish_reason',
|
||||
'gemini:generate_content': '$.candidates[*].finishReason',
|
||||
}
|
||||
const protocolPath = stage === 'stream' && /finish reason/i.test(message)
|
||||
&& (!structuredPath || structuredPath === '$') && ['$', '$.finish_reason'].includes(reportedPath)
|
||||
? streamFinishPaths[providerFormat] : undefined
|
||||
const path = protocolPath ?? reportedPath
|
||||
const missing = Array.isArray(details.missing_context) ? [...details.missing_context] : []
|
||||
if (path === '$' && !missing.includes('field_path')) missing.push('field_path')
|
||||
if (stage === 'unknown') missing.push('failure_stage')
|
||||
if (!clientFormat || !providerFormat) missing.push('api_formats')
|
||||
let actual: unknown = details.actual ?? null
|
||||
if (actual === null) {
|
||||
const enumMatch = message.match(/invalid enum value\s+(.+?)\s+for\s+/i)
|
||||
const fieldMatch = message.match(/\bfield\s+[^;=]+?\s*=\s*([^;]+)(?:;|$)/i)
|
||||
const finishMatch = message.match(/(?:unsupported provider stream finish reason|upstream stream ended with finish reason):\s*(.+?)\s*$/i)
|
||||
const literal = enumMatch?.[1] ?? fieldMatch?.[1] ?? finishMatch?.[1]
|
||||
if (literal) {
|
||||
try { actual = JSON.parse(literal) } catch { actual = literal }
|
||||
}
|
||||
if (code === 'stream_terminal_error' && /finish reason/.test(message)) actual = 'error'
|
||||
}
|
||||
return {
|
||||
...payload,
|
||||
schema_version: 2,
|
||||
breakpoint: path,
|
||||
diagnostic: {
|
||||
code,
|
||||
stage,
|
||||
stage_source: stageSource,
|
||||
operation: details.operation ?? null,
|
||||
reported_format: details.format ?? null,
|
||||
reported_path: reportedPath,
|
||||
path,
|
||||
path_source: path === '$' ? 'unavailable' : structuredPath && structuredPath !== '$' ? 'structured' : protocolPath ? 'protocol_inference' : 'message_inference',
|
||||
source_format: details.source_format ?? structured.source_format ?? conversionPair?.[1] ?? (stage === 'request' ? clientFormat : stage !== 'unknown' ? providerFormat : null),
|
||||
target_format: details.target_format ?? structured.target_format ?? conversionPair?.[2] ?? (stage === 'request' ? providerFormat : stage !== 'unknown' ? clientFormat : null),
|
||||
converter: structured.source ?? null,
|
||||
expected: details.expected ?? details.reason ?? null,
|
||||
actual,
|
||||
missing_context: missing,
|
||||
},
|
||||
versions: {
|
||||
frontend: typeof __APP_VERSION__ === 'string' ? __APP_VERSION__ : null,
|
||||
gateway_at_export: trace?.gateway_version ?? null,
|
||||
runtime_at_failure: structured.runtime_version ?? null,
|
||||
},
|
||||
node: {
|
||||
...diagnosticObject(payload.node),
|
||||
candidate_id: attempt.id,
|
||||
provider_id: attempt.provider_id ?? null,
|
||||
endpoint_id: attempt.endpoint_id ?? null,
|
||||
key_id: attempt.key_id ?? null,
|
||||
},
|
||||
request: {
|
||||
...request,
|
||||
client_api_format: clientFormat || null,
|
||||
provider_api_format: providerFormat || null,
|
||||
model: diagnosticContext.model ?? extra.model ?? null,
|
||||
target_model: diagnosticContext.target_model ?? extra.target_model ?? null,
|
||||
created_at: attempt.created_at,
|
||||
started_at: attempt.started_at ?? null,
|
||||
},
|
||||
reproduction: { status: 'not_loaded', sources: {}, missing_context: [...missing, 'source_body'] },
|
||||
}
|
||||
}
|
||||
@@ -1214,12 +1214,18 @@ export const legacyUiEnglishMessages: Record<string, string> = {
|
||||
'未知失败': 'Unknown failure',
|
||||
'未知请求格式': 'Unknown request format',
|
||||
'未知上游格式': 'Unknown upstream format',
|
||||
'正在读取并脱敏诊断上下文…': 'Loading and redacting diagnostic context…',
|
||||
'复制时补取已采集的正文并脱敏；未采集、无权限或超限的信息会明确标注。分享前请检查诊断内容。': 'Copy loads and redacts captured bodies. Missing, forbidden, or oversized context is marked explicitly. Review the diagnostic before sharing.',
|
||||
'上游流式响应异常终止：上游返回了错误结束原因（error），已按失败处理': 'The upstream stream ended with an error finish reason (error) and is marked as failed.',
|
||||
'上游通过结束原因报告了流式错误：检查原始 SSE 中的 error/message 及上游日志；保持失败状态，不要映射为正常结束。': 'The upstream finish reason reports a streaming error. Inspect error/message in the raw SSE and upstream logs. Keep the request failed; do not map it to a normal completion.',
|
||||
'断点在上游流式终态校验：检查原始结束原因及协议兼容性；该错误不代表发生了格式转换，不能确认成功时保持失败闭合。': 'The failure is in upstream stream terminal validation. Check the raw finish reason and protocol compatibility. This does not imply format conversion; keep the request failed unless success can be confirmed.',
|
||||
'断点在上游流式事件解析/转换矩阵：先按 breakpoint 对应字段确认 event type，再决定是补 canonical mapping 还是加入 known noop。': 'The failure is in upstream streaming event parsing or conversion. Check the event type at the breakpoint, then add a canonical mapping or a known no-op.',
|
||||
'断点在 finish_reason 映射：确认该结束原因是否可等价映射；不能无损映射时保持失败闭合。': 'The failure is in finish_reason mapping. Check whether an equivalent mapping exists. Keep the request failed if a lossless mapping is unavailable.',
|
||||
'无损': 'Lossless',
|
||||
'丢失信息': 'Information loss',
|
||||
'断点在请求/响应格式转换器：检查 breakpoint 字段是否能被目标格式表达，不能表达就需要拒绝、降级或新增显式映射策略。': 'The failure is in request or response conversion. Check whether the target format supports the breakpoint field. Otherwise, reject, downgrade, or define an explicit mapping.',
|
||||
'先从 breakpoint 字段开始回放；若 breakpoint 为 $，优先查看 raw.failure_diagnostic / raw.error_message 和 upstream_response。': 'Start replaying from the breakpoint field. If the breakpoint is $, inspect raw.failure_diagnostic, raw.error_message, and upstream_response first.',
|
||||
'先从 breakpoint 字段开始回放；若 breakpoint 为 $，优先查看 raw.failure_diagnostic / node.error_message 和 upstream_response。': 'Start replaying from the breakpoint field. If the breakpoint is $, inspect raw.failure_diagnostic, node.error_message, and upstream_response first.',
|
||||
'随机 (平分)': 'Random (equal weight)',
|
||||
'上游跳过': 'Upstream skipped',
|
||||
'未知 Key': 'Unknown key',
|
||||
|
||||
Reference in New Issue
Block a user