Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.
Python agentagent-osaiai-agentsai-partnerchatopsclaudeclaude-codecodexdevtoolsdiscord-botlark-botllmlocal-firstlong-term-memoryopencodeslack-botvibe-codingvibeywechat
fix(agent-core): classify Model Hub relay failures as server errors (#2436)
Call Whitec32902595dec
diff --git a/core/agent_core/ai/errors.py b/core/agent_core/ai/errors.pyindex dd3621e38..f25c3a554 100644--- a/core/agent_core/ai/errors.py+++ b/core/agent_core/ai/errors.py@@ -262,13 +262,18 @@ def _classify_kind("internal_server_error","bad_gateway","service_unavailable",+ "service_unavailable_error",+ # A Model Hub relay's own failure, its upstream's status folded away.+ "upstream_error","internal","api_error","unavailable","deadline_exceeded","aborted",}:- return "server"+ # The same rule as a 5xx status: OpenAI's capacity shed is a+ # service_unavailable_error that says it is overloaded.+ return "overloaded" if "overloaded" in message.lower() else "server"if normalized_code in {"context_length_exceeded", "request_too_large"}:return "overflow"if is_overflow_message(message, status=status):diff --git a/core/agent_core/ai/openai_responses.py b/core/agent_core/ai/openai_responses.pyindex 40f0ee602..4d9aa85a4 100644--- a/core/agent_core/ai/openai_responses.py+++ b/core/agent_core/ai/openai_responses.py@@ -349,6 +349,11 @@ class OpenAIResponsesAdapter(ProviderAdapter):if terminal is not None:yield terminalreturn+ if event.event == "response.failed" and "type" not in chunk and _has_response_error(chunk):+ # Some OpenAI-compatible relays keep the event name but omit the+ # duplicated `type`; the name and the response's error object still+ # identify the failure, as Model Hub's stream observer accepts it.+ chunk = {**chunk, "type": "response.failed"}try:event_type = dispatch_wire_event(chunk,@@ -1565,6 +1570,11 @@ def _responses_error_shape_error(value: Any, label: str) -> str | None:return None+def _has_response_error(chunk: Mapping[str, Any]) -> bool:+ response = chunk.get("response")+ return isinstance(response, Mapping) and isinstance(response.get("error"), Mapping)++def _responses_error_body(error: Mapping[str, Any]) -> str:return json.dumps({"error": dict(error)}, ensure_ascii=False)diff --git a/docs/plans/agent-core-contracts/conversion-tables.md b/docs/plans/agent-core-contracts/conversion-tables.mdindex b0e56530c..ba6c78053 100644--- a/docs/plans/agent-core-contracts/conversion-tables.md+++ b/docs/plans/agent-core-contracts/conversion-tables.md@@ -119,7 +119,7 @@ ignored without parsing.| `response.output_text.done`, `response.reasoning_summary_text.done`, `response.reasoning_text.done` | none | `output_index: non-negative integer` || `response.content_part.added`, `response.content_part.done` | none | `output_index: non-negative integer`, `part: object` || `response.completed`, `response.incomplete` | `response: object` | `response.status: string`, `output: array`, `usage: object`, `incomplete_details: object`, `error: object` |-| `response.failed` | `type: string` | `response: object`, `response.error: object`, `response.usage: object` |+| `response.failed` | `type: string`, or the SSE event name `response.failed` with `response.error: object` (relays that omit the duplicated `type`) | `response: object`, `response.error: object`, `response.usage: object` || top-level `error` | `error: object` or `message: string` | `error.type`/`error.message: string`, `error.code: string or integer` |`response.output` is validated even when empty. If it is present and is not an@@ -137,8 +137,11 @@ or extracted message/code pair that its wire format makes available.| Anthropic | `authentication_error`, `invalid_api_key`, `permission_error`, `permission` | `rate_limit_error` | `overloaded_error` → `overloaded`; `api_error` → `server` | `invalid_request_error` with context text; `context_length_exceeded` → `overflow` || OpenAI Chat | `authentication_error`, `invalid_api_key`, `permission` | `rate_limit_error`, `too_many_requests` | `server_error`, `api_error` | `context_length_exceeded`, `request_too_large` || OpenAI Responses | `unauthenticated`, `permission_denied`, `invalid_api_key` | `rate_limit`, `rate_limit_error` | `overloaded`, `server_error`, `service_unavailable` | `context_length_exceeded`, `request_too_large` |+| Model Hub relays, any protocol | | | `upstream_error`, `service_unavailable_error` → `server` | |HTTP `401/403` always map to `auth`, `413` to `overflow`, `429` to-`rate_limit` with `Retry-After`, and `5xx` to `server` or `overloaded`.+`rate_limit` with `Retry-After`, and `5xx` to `server` or `overloaded`. A server code follows the same rule as a+`5xx`: it is `overloaded` when its message says overloaded (OpenAI's capacity shed is a `service_unavailable_error`+that says so), otherwise `server`.Transport errors map to `network`, and the silence bound to `stalled`. Every classification is non-retryable oncethe assembler has emitted visible content or a tool-call event.diff --git a/tests/agent_core/ai/test_provider_adapters.py b/tests/agent_core/ai/test_provider_adapters.pyindex 581ff631f..dc7b53869 100644--- a/tests/agent_core/ai/test_provider_adapters.py+++ b/tests/agent_core/ai/test_provider_adapters.py@@ -4391,6 +4391,94 @@ async def test_provider_error_envelope_is_classified_identically_from_every_sourassert events[0].retryable == (kind == "server")+# Failure frames a Model Hub relay writes into an HTTP 200 stream that has+# already started, so only the frame says what failed. sub2api writes the first+# three (`handler/gateway_handler.go` and `handler/openai_gateway_handler.go`+# `handleStreamingAwareErrorWithCode`, `handler/stream_error_event.go`+# `writeResponsesFailedSSE`, `mapUpstreamError` for the messages); the+# Anthropic frame is the one Claude Code reported through a relay. Some relays+# keep the `response.failed` event name but omit the duplicated JSON `type`+# (Model Hub's `stream_wire.py` accepts that envelope). OpenAI's own capacity+# shed sends `service_unavailable_error` in an error frame, which relays pass on.+ ("adapter_type", "protocol", "body", "message", "kind"),+ [+ (+ AnthropicAdapter,+ "anthropic",+ 'data: {"type":"error","error":{"type":"upstream_error","message":"Upstream request failed"}}\n\n',+ "Upstream request failed",+ "server",+ ),+ (+ OpenAIChatAdapter,+ "openai_chat",+ 'event: error\ndata: {"error":{"type":"upstream_error",'+ '"message":"Upstream authentication failed, please contact administrator"}}\n\n',+ "Upstream authentication failed, please contact administrator",+ "server",+ ),+ (+ OpenAIChatAdapter,+ "openai_chat",+ 'event: error\ndata: {"error":{"type":"upstream_error",'+ '"message":"Upstream service overloaded, please retry later"}}\n\n',+ "Upstream service overloaded, please retry later",+ "overloaded",+ ),+ (+ OpenAIResponsesAdapter,+ "openai_responses",+ 'event: response.failed\ndata: {"type":"response.failed","sequence_number":0,'+ '"response":{"id":"resp_0f3c","object":"response","created_at":1760140800,"model":"gpt-5",'+ '"status":"failed","output":[],'+ '"error":{"code":"upstream_error","message":"Upstream service temporarily unavailable"}}}\n\n',+ "Upstream service temporarily unavailable",+ "server",+ ),+ (+ OpenAIResponsesAdapter,+ "openai_responses",+ 'event: response.failed\ndata: {"response":{"error":{"code":"upstream_error",'+ '"message":"response protection is unavailable"}}}\n\n',+ "response protection is unavailable",+ "server",+ ),+ (+ OpenAIResponsesAdapter,+ "openai_responses",+ 'event: response.failed\ndata: {"type":"response.failed","response":{"status":"failed",'+ '"error":{"code":"service_unavailable_error","message":"Service temporarily unavailable"}}}\n\n',+ "Service temporarily unavailable",+ "server",+ ),+ (+ OpenAIResponsesAdapter,+ "openai_responses",+ 'event: error\ndata: {"type":"error","error":{"type":"service_unavailable_error",'+ '"message":"Our servers are currently overloaded. Please try again later."}}\n\n',+ "Our servers are currently overloaded. Please try again later.",+ "overloaded",+ ),+ ],+)+async def test_a_relay_failure_frame_before_output_is_a_retryable_server_failure(+ adapter_type: Any, protocol: str, body: str, message: str, kind: str,+) -> None:+ def handler(_: httpx.Request) -> httpx.Response:+ return httpx.Response(200, headers={"content-type": "text/event-stream"}, text=body)++ async with httpx.AsyncClient(transport=httpx.MockTransport(handler)) as client:+ events = await _events(adapter_type(client), _request(protocol))++ assert len(events) == 1+ error = events[0]+ assert isinstance(error, ProviderError)+ assert (error.kind, error.retryable) == (kind, True)+ assert error.message == message++@pytest.mark.asyncio@pytest.mark.parametrize(("adapter_type", "protocol", "body", "outcome", "stop_reason", "error_kind", "partial"),