Skip to content

armgit / avibe

Public Imported from GitHub
0

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.

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.py
index 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.py
index 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 terminal
return
+ 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.md
index 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 once
the 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.py
index 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_sour
assert 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"),