429 lines
16 KiB
Python
429 lines
16 KiB
Python
"""
|
||
app/services/error_metadata.py - 标准异常元数据与响应构建器
|
||
|
||
职责:
|
||
- 解耦业务特定错误码(如 Arena / Gemini / Claude 拒绝与失败码)与主执行流
|
||
- 提供标准化的 ErrorMetadata 数据结构
|
||
- 提供基于元数据的 422 / 非可重试错误识别与统一 JSONResponse 构造
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import dataclasses
|
||
from typing import Any, Dict, Optional, Set
|
||
from fastapi.responses import JSONResponse
|
||
|
||
from app.services.arena_image_generation import (
|
||
ARENA_NON_RETRYABLE_CODES,
|
||
ARENA_PROMPT_REJECTED_CODE,
|
||
)
|
||
from app.core.workflow.arena_send_watchdog import (
|
||
ARENA_PAGE_ERROR,
|
||
ARENA_SEND_NO_TARGET_AFTER_RETRY,
|
||
)
|
||
|
||
|
||
@dataclasses.dataclass(frozen=True)
|
||
class ErrorMetadata:
|
||
code: str
|
||
message: str
|
||
status_code: int = 422
|
||
retryable: bool = False
|
||
error_type: str = "invalid_request_error"
|
||
param: Optional[str] = None
|
||
extra: Optional[Dict[str, Any]] = None
|
||
|
||
|
||
_MANUAL_TERMINATE_REASONS: Set[str] = {
|
||
"manual_terminate",
|
||
"manual_terminate_from_tab_pool",
|
||
}
|
||
|
||
_CANCEL_REASONS: Set[str] = {
|
||
"manual_terminate",
|
||
"manual_terminate_from_tab_pool",
|
||
"client_disconnected",
|
||
"coroutine_cancelled",
|
||
"cleanup",
|
||
"stream_done",
|
||
"stop_sequence",
|
||
"audio_media_fast_return",
|
||
"request_cancelled",
|
||
}
|
||
|
||
_PROMPT_REJECTION_CODES: Set[str] = {
|
||
ARENA_PROMPT_REJECTED_CODE,
|
||
"prompt_rejected",
|
||
}
|
||
|
||
_KNOWN_NON_RETRYABLE_CODES: Set[str] = {
|
||
*ARENA_NON_RETRYABLE_CODES,
|
||
ARENA_SEND_NO_TARGET_AFTER_RETRY,
|
||
ARENA_PAGE_ERROR,
|
||
*_PROMPT_REJECTION_CODES,
|
||
}
|
||
|
||
|
||
def is_manual_terminate(reason_or_ctx: Any) -> bool:
|
||
"""Check if the cancellation is due to manual termination."""
|
||
if hasattr(reason_or_ctx, "cancel_reason"):
|
||
reason = getattr(reason_or_ctx, "cancel_reason")
|
||
else:
|
||
reason = reason_or_ctx
|
||
return str(reason or "").strip() in _MANUAL_TERMINATE_REASONS
|
||
|
||
|
||
def is_prompt_rejection_code(code: Any) -> bool:
|
||
"""Check if code matches known prompt rejection codes."""
|
||
return str(code or "").strip() in _PROMPT_REJECTION_CODES
|
||
|
||
|
||
def _parse_bool(val: Any, default: bool = False) -> bool:
|
||
if val is None:
|
||
return default
|
||
if isinstance(val, bool):
|
||
return val
|
||
if isinstance(val, str):
|
||
s = val.strip().lower()
|
||
if s in {"1", "true", "yes"}:
|
||
return True
|
||
if s in {"0", "false", "no"}:
|
||
return False
|
||
return bool(val)
|
||
|
||
|
||
def _parse_int(val: Any, default: int = 422) -> int:
|
||
if val is None:
|
||
return default
|
||
try:
|
||
return int(val)
|
||
except (ValueError, TypeError):
|
||
return default
|
||
|
||
|
||
def _extract_json_dict_from_text(text: str) -> Optional[Dict[str, Any]]:
|
||
"""尝试从文本中提取最外层的 JSON 字典对象。"""
|
||
import json
|
||
if not text or "{" not in text or "}" not in text:
|
||
return None
|
||
start_idx = text.find("{")
|
||
end_idx = text.rfind("}")
|
||
if start_idx == -1 or end_idx == -1 or end_idx <= start_idx:
|
||
return None
|
||
candidate = text[start_idx : end_idx + 1].strip()
|
||
try:
|
||
data = json.loads(candidate)
|
||
if isinstance(data, dict):
|
||
return data
|
||
except Exception:
|
||
pass
|
||
return None
|
||
|
||
|
||
def _extract_status_code_from_text(text: str) -> Optional[int]:
|
||
"""从错误字符串中提取 HTTP 状态码。"""
|
||
import re
|
||
if not text:
|
||
return None
|
||
# 模式 1: 带有明确上下文前缀
|
||
match = re.search(
|
||
r"\b(?:http(?:\s+status)?\s+|status(?:\s*code)?\s*[:=]?\s*|failed\s+to\s+fetch(?:\s+image)?:\s*|code\s*[:=]\s*)([45]\d{2})\b",
|
||
text,
|
||
re.IGNORECASE,
|
||
)
|
||
if match:
|
||
try:
|
||
return int(match.group(1))
|
||
except Exception:
|
||
pass
|
||
# 模式 2: 常见 HTTP 状态码 + 描述词组合(如 "400 Bad Request", "429 Too Many Requests", "502 Bad Gateway")
|
||
match_status_desc = re.search(
|
||
r"\b([45]\d{2})\s+(?:Bad\s+Request|Unauthorized|Forbidden|Not\s+Found|Unprocessable\s+Entity|Too\s+Many\s+Requests|Internal\s+Server\s+Error|Bad\s+Gateway|Service\s+Unavailable|Gateway\s+Timeout)\b",
|
||
text,
|
||
re.IGNORECASE,
|
||
)
|
||
if match_status_desc:
|
||
try:
|
||
return int(match_status_desc.group(1))
|
||
except Exception:
|
||
pass
|
||
return None
|
||
|
||
|
||
def resolve_error_metadata(
|
||
reason_or_payload: Any,
|
||
default_message: Optional[str] = None,
|
||
) -> Optional[ErrorMetadata]:
|
||
"""Extract standard ErrorMetadata from a context, cancel reason, exception, or payload dict."""
|
||
if reason_or_payload is None:
|
||
return None
|
||
|
||
# Handle Exception objects
|
||
if isinstance(reason_or_payload, BaseException):
|
||
code = getattr(reason_or_payload, "code", None) or getattr(reason_or_payload, "error_code", None)
|
||
msg = (
|
||
getattr(reason_or_payload, "message", None)
|
||
or getattr(reason_or_payload, "error_msg", None)
|
||
or str(reason_or_payload)
|
||
)
|
||
if code:
|
||
return resolve_error_metadata(str(code), default_message=str(msg))
|
||
return resolve_error_metadata(str(reason_or_payload), default_message=default_message)
|
||
|
||
# Handle RequestContext-like objects
|
||
if hasattr(reason_or_payload, "cancel_reason"):
|
||
raw_reason = str(getattr(reason_or_payload, "cancel_reason") or "").strip()
|
||
if not raw_reason:
|
||
return None
|
||
if raw_reason in _CANCEL_REASONS:
|
||
return None
|
||
if raw_reason in _PROMPT_REJECTION_CODES:
|
||
return ErrorMetadata(
|
||
code=raw_reason,
|
||
message=default_message or "Arena 拒绝了该提示词:内容违反 Terms of Use",
|
||
status_code=422,
|
||
retryable=False,
|
||
error_type="invalid_request_error",
|
||
)
|
||
if raw_reason in _KNOWN_NON_RETRYABLE_CODES:
|
||
return ErrorMetadata(
|
||
code=raw_reason,
|
||
message=default_message or "Arena 图片生成失败,响应不可重试",
|
||
status_code=422,
|
||
retryable=False,
|
||
error_type="invalid_request_error",
|
||
)
|
||
return resolve_error_metadata(raw_reason, default_message=default_message)
|
||
|
||
# Handle payload dict like {"error": {...}} or SSE payload dict
|
||
if isinstance(reason_or_payload, dict):
|
||
error = reason_or_payload.get("error") if "error" in reason_or_payload else reason_or_payload
|
||
if isinstance(error, dict):
|
||
code = str(error.get("code") or "").strip()
|
||
msg = str(error.get("message") or "").strip()
|
||
raw_status_code = error.get("status_code")
|
||
raw_retryable = error.get("retryable")
|
||
param = error.get("param")
|
||
extra = {
|
||
k: v for k, v in error.items()
|
||
if k not in {"message", "type", "code", "status_code", "retryable", "param"}
|
||
}
|
||
status_code = _parse_int(raw_status_code, 422) if raw_status_code is not None else 422
|
||
retryable = _parse_bool(raw_retryable, False) if raw_retryable is not None else False
|
||
error_type = str(error.get("type") or "invalid_request_error").strip()
|
||
|
||
# If inner message itself contains a serialized JSON error or terminal error prefix, resolve it
|
||
if msg and ("{" in msg or "stream_terminal_error:" in msg):
|
||
nested_meta = resolve_error_metadata(msg, default_message=default_message)
|
||
if nested_meta:
|
||
merged_extra = dict(nested_meta.extra or {})
|
||
if extra:
|
||
merged_extra.update(extra)
|
||
return ErrorMetadata(
|
||
code=code if (code and code not in {"error", "workflow_failed", "arena_page_error"}) else nested_meta.code,
|
||
message=nested_meta.message,
|
||
status_code=status_code if raw_status_code is not None else nested_meta.status_code,
|
||
retryable=retryable if raw_retryable is not None else nested_meta.retryable,
|
||
error_type=error_type if error_type not in {"execution_error", "invalid_request_error"} else nested_meta.error_type,
|
||
param=param if param is not None else nested_meta.param,
|
||
extra=merged_extra or None,
|
||
)
|
||
|
||
if code in _PROMPT_REJECTION_CODES:
|
||
return ErrorMetadata(
|
||
code=code or ARENA_PROMPT_REJECTED_CODE,
|
||
message=msg or default_message or "Arena 拒绝了该提示词:内容违反 Terms of Use",
|
||
status_code=status_code,
|
||
retryable=retryable,
|
||
error_type=error_type,
|
||
param=param,
|
||
extra=extra or None,
|
||
)
|
||
if code in _KNOWN_NON_RETRYABLE_CODES:
|
||
return ErrorMetadata(
|
||
code=code,
|
||
message=msg or default_message or "Arena 图片生成失败,响应不可重试",
|
||
status_code=status_code,
|
||
retryable=retryable,
|
||
error_type=error_type,
|
||
param=param,
|
||
extra=extra or None,
|
||
)
|
||
if (raw_retryable is not None and not retryable) or (raw_status_code is not None and status_code in {400, 401, 403, 422}):
|
||
return ErrorMetadata(
|
||
code=code or "invalid_request_error",
|
||
message=msg or default_message or "请求不可重试",
|
||
status_code=status_code,
|
||
retryable=False,
|
||
error_type=error_type,
|
||
param=param,
|
||
extra=extra or None,
|
||
)
|
||
if msg or code:
|
||
return ErrorMetadata(
|
||
code=code or "error",
|
||
message=msg or default_message or "请求处理失败",
|
||
status_code=status_code if raw_status_code is not None else 500,
|
||
retryable=retryable,
|
||
error_type=error_type,
|
||
param=param,
|
||
extra=extra or None,
|
||
)
|
||
return None
|
||
|
||
# Handle string code / error message
|
||
if isinstance(reason_or_payload, str):
|
||
raw_str = reason_or_payload.strip()
|
||
if not raw_str:
|
||
return None
|
||
if raw_str in _CANCEL_REASONS:
|
||
return None
|
||
|
||
# 剥离内部标识前缀(支持多层嵌套剥离)
|
||
changed = True
|
||
while changed:
|
||
changed = False
|
||
for prefix in ("stream_terminal_error:", "execution_error:", "执行错误:", "[错误]", "[error]"):
|
||
if raw_str.lower().startswith(prefix.lower()):
|
||
raw_str = raw_str[len(prefix):].strip()
|
||
changed = True
|
||
break
|
||
|
||
# 1. 尝试从文本中解析嵌套的 JSON 对象
|
||
json_obj = _extract_json_dict_from_text(raw_str)
|
||
if json_obj:
|
||
nested_error = json_obj.get("error") if isinstance(json_obj.get("error"), dict) else json_obj
|
||
if isinstance(nested_error, dict):
|
||
extracted_msg = str(nested_error.get("message") or "").strip()
|
||
extracted_code = str(nested_error.get("code") or "").strip()
|
||
extracted_type = str(nested_error.get("type") or "").strip()
|
||
extracted_param = nested_error.get("param")
|
||
extra = {
|
||
k: v for k, v in nested_error.items()
|
||
if k not in {"message", "type", "code", "status_code", "retryable", "param"}
|
||
}
|
||
detected_status = _extract_status_code_from_text(raw_str) or _parse_int(nested_error.get("status_code"), 400)
|
||
is_retryable = detected_status >= 500 and extracted_code not in {"moderation_blocked", "content_policy_violation"}
|
||
|
||
return ErrorMetadata(
|
||
code=extracted_code or "upstream_error",
|
||
message=extracted_msg or raw_str or (default_message or "上游服务报错"),
|
||
status_code=detected_status or 400,
|
||
retryable=is_retryable,
|
||
error_type=extracted_type or "invalid_request_error",
|
||
param=str(extracted_param) if extracted_param is not None else None,
|
||
extra=extra or None,
|
||
)
|
||
|
||
# 2. 检查已知错误代码
|
||
if raw_str in _PROMPT_REJECTION_CODES:
|
||
return ErrorMetadata(
|
||
code=raw_str,
|
||
message=default_message or "Arena 拒绝了该提示词:内容违反 Terms of Use",
|
||
status_code=422,
|
||
retryable=False,
|
||
error_type="invalid_request_error",
|
||
)
|
||
if raw_str in _KNOWN_NON_RETRYABLE_CODES:
|
||
return ErrorMetadata(
|
||
code=raw_str,
|
||
message=default_message or "Arena 图片生成失败,响应不可重试",
|
||
status_code=422,
|
||
retryable=False,
|
||
error_type="invalid_request_error",
|
||
)
|
||
|
||
# 3. 检查是否含有 HTTP 状态码
|
||
status_code = _extract_status_code_from_text(raw_str)
|
||
if status_code is not None:
|
||
if status_code == 429:
|
||
return ErrorMetadata(
|
||
code="rate_limit_exceeded",
|
||
message=raw_str,
|
||
status_code=429,
|
||
retryable=False,
|
||
error_type="rate_limit_error",
|
||
)
|
||
if status_code in {400, 422}:
|
||
return ErrorMetadata(
|
||
code="bad_request" if status_code == 400 else "unprocessable_entity",
|
||
message=raw_str,
|
||
status_code=status_code,
|
||
retryable=False,
|
||
error_type="invalid_request_error",
|
||
)
|
||
if status_code in {401, 403}:
|
||
return ErrorMetadata(
|
||
code="permission_denied",
|
||
message=raw_str,
|
||
status_code=status_code,
|
||
retryable=False,
|
||
error_type="permission_error",
|
||
)
|
||
if status_code >= 500:
|
||
return ErrorMetadata(
|
||
code="upstream_service_error",
|
||
message=raw_str,
|
||
status_code=status_code,
|
||
retryable=True,
|
||
error_type="api_error",
|
||
)
|
||
|
||
# 4. 普通纯字符串
|
||
return ErrorMetadata(
|
||
code="workflow_failed",
|
||
message=raw_str or (default_message or "请求处理失败"),
|
||
status_code=500,
|
||
retryable=False,
|
||
error_type="execution_error",
|
||
)
|
||
|
||
return None
|
||
|
||
|
||
def is_non_retryable_error(reason_or_payload: Any) -> bool:
|
||
"""Check if a given reason or error payload represents a non-retryable 4xx error."""
|
||
meta = resolve_error_metadata(reason_or_payload)
|
||
return meta is not None and not meta.retryable and meta.status_code in {400, 401, 403, 422}
|
||
|
||
|
||
def build_error_response(
|
||
metadata: ErrorMetadata,
|
||
headers: Optional[Dict[str, str]] = None,
|
||
) -> JSONResponse:
|
||
"""Build a standard JSONResponse from ErrorMetadata."""
|
||
response_headers = dict(headers or {})
|
||
if not metadata.retryable:
|
||
response_headers["x-should-retry"] = "false"
|
||
|
||
error_body: Dict[str, Any] = {
|
||
"message": metadata.message,
|
||
"type": metadata.error_type,
|
||
"code": metadata.code,
|
||
"status_code": metadata.status_code,
|
||
"retryable": metadata.retryable,
|
||
}
|
||
if metadata.param is not None:
|
||
error_body["param"] = metadata.param
|
||
if metadata.extra:
|
||
for k, v in metadata.extra.items():
|
||
if k not in error_body:
|
||
error_body[k] = v
|
||
|
||
return JSONResponse(
|
||
content={
|
||
"error": error_body
|
||
},
|
||
status_code=metadata.status_code,
|
||
headers=response_headers,
|
||
)
|
||
|
||
|
||
class BrowserExecutionError(RuntimeError):
|
||
"""An upstream browser failure is not assistant text for tool parsing."""
|
||
def __init__(self, error):
|
||
error = error if isinstance(error, dict) else {"message": str(error)}
|
||
self.code = str(error.get("code") or "browser_execution_failed")
|
||
self.message = str(error.get("message") or self.code)
|
||
super().__init__(self.message)
|