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(model-hub): read a Responses stream error's class nested under `error` (#2460)

Call Whiteaf682d6445d6
diff --git a/core/handlers/model_hub/stream_wire.py b/core/handlers/model_hub/stream_wire.py
index 3336342b7..089d2f8b4 100644
--- a/core/handlers/model_hub/stream_wire.py
+++ b/core/handlers/model_hub/stream_wire.py
@@ -631,11 +631,14 @@ PROTOCOL_STREAM_TAXONOMY: Final[Mapping[str, ProtocolStreamTaxonomy]] = {
),
ProtocolTerminalEnvelope(
# https://platform.openai.com/docs/api-reference/responses-streaming/error
+ # The reference carries the class at the root, as this hub's own
+ # terminal frame does. CLIProxyAPI nests it under `error`
+ # (sdk/api/handlers/openai_responses_stream_error.go).
"error",
("type",),
"error",
"failed_terminal",
- ((),),
+ ((), ("error",)),
),
ProtocolTerminalEnvelope(
# https://platform.openai.com/docs/api-reference/responses-streaming/response/failed
diff --git a/tests/test_model_hub_runtime.py b/tests/test_model_hub_runtime.py
index 328333089..61adeb7ed 100644
--- a/tests/test_model_hub_runtime.py
+++ b/tests/test_model_hub_runtime.py
@@ -6713,6 +6713,113 @@ def test_engine_client_requires_a_protocol_terminal_event_before_clean_eof(
asyncio.run(run())
+# CPA's Responses stream failures, byte for byte. Its error builder nests the class
+# under `error` (sdk/api/handlers/openai_responses_stream_error.go); a Codex caller gets
+# the same class under `response.failed`. A Codex upstream that closes before
+# response.completed is reported as request_timeout / server_error.
+_CPA_RESPONSES_DISCONNECT = (
+ b'{"code":"request_timeout","message":"stream error: stream disconnected before completion: '
+ b'stream closed before response.completed","param":null,"type":"server_error"}'
+)
+_RESPONSES_STREAM_FAILURES = {
+ "cpa-error": b'\nevent: error\ndata: {"type":"error","error":' + _CPA_RESPONSES_DISCONNECT
+ + b',"sequence_number":%d}\n\n',
+ "cpa-codex-response-failed": b'\nevent: response.failed\ndata: {"type":"response.failed",'
+ b'"sequence_number":%d,"response":{"status":"failed","error":' + _CPA_RESPONSES_DISCONNECT + b"}}\n\n",
+ # OpenAI's documented `error` event carries the class at the root.
+ "openai-root-error": b'event: error\ndata: {"type":"error","code":"server_error",'
+ b'"message":"The server had an error while processing your request.","param":null,'
+ b'"sequence_number":%d}\n\n',
+}
+_RESPONSES_REASONING_PRELUDE = (
+ b'event: response.created\ndata: {"type":"response.created","sequence_number":0,'
+ b'"response":{"id":"resp_1","object":"response","status":"in_progress","output":[]}}\n\n',
+ b'event: response.output_item.added\ndata: {"type":"response.output_item.added","sequence_number":1,'
+ b'"output_index":0,"item":{"id":"rs_1","type":"reasoning","summary":[]}}\n\n',
+ b'event: response.reasoning_summary_text.delta\ndata: {"type":"response.reasoning_summary_text.delta",'
+ b'"sequence_number":2,"item_id":"rs_1","output_index":0,"summary_index":0,"delta":"**Checking**"}\n\n',
+)
+
+
[email protected]("failure", sorted(_RESPONSES_STREAM_FAILURES))
[email protected]("after_reasoning", [False, True], ids=["before-output", "after-reasoning"])
+def test_engine_client_reads_the_class_of_a_responses_stream_failure_wherever_it_is_nested(
+ monkeypatch: pytest.MonkeyPatch,
+ failure: str,
+ after_reasoning: bool,
+) -> None:
+ """A dropped Responses stream is the Source's server failure, not a request the upstream rejected."""
+
+ async def run() -> None:
+ prelude = _RESPONSES_REASONING_PRELUDE if after_reasoning else _RESPONSES_REASONING_PRELUDE[:1]
+ body = [*prelude, _RESPONSES_STREAM_FAILURES[failure] % len(prelude)]
+ chunks = list(body)
+
+ class Content:
+ async def read(self, _size: int) -> bytes:
+ return chunks.pop(0) if chunks else b""
+
+ async def iter_chunked(self, _size: int):
+ while chunks:
+ yield chunks.pop(0)
+
+ class Response:
+ status = 200
+ content = Content()
+ headers = {"Content-Type": "text/event-stream"}
+
+ def close(self) -> None:
+ return None
+
+ class Session:
+ async def post(self, *_args, **_kwargs):
+ return Response()
+
+ async def close(self) -> None:
+ return None
+
+ monkeypatch.setattr(client_module.aiohttp, "ClientSession", lambda **_kwargs: Session())
+ source = SourceRecord(
+ source_id="src_fixture123",
+ vendor="custom",
+ protocol="openai_responses",
+ base_url="https://api.example.test/v1",
+ credential_ref="cred_fixture123",
+ allowed_origins=(),
+ model_ids=("model-a",),
+ prefix="source-fixture123",
+ )
+ handle = await EngineClient(
+ EngineConnection(
+ base_url="http://127.0.0.1:15220",
+ management_key="management-key",
+ gateway_token="gateway-token",
+ )
+ ).invoke(source, "model-a", {}, stream=True, request_protocol="openai_responses")
+ if after_reasoning:
+ assert handle.stream is not None
+ assert b"".join([chunk async for chunk in handle.stream]) == b"".join(body)
+ else:
+ assert handle.stream is None
+ outcome = await handle.outcome()
+
+ assert outcome.kind is RawOutcomeKind.HTTP_ERROR
+ assert outcome.stream_started is after_reasoning
+ assert "server_error" in outcome.error_candidates
+ assert "processing your request" in outcome.upstream_detail if failure == "openai-root-error" else (
+ "stream disconnected before completion" in outcome.upstream_detail
+ )
+ decision = classify_outcome(outcome)
+ assert (decision.reason, decision.cooldown_seconds) == ("server_error", 30)
+ if after_reasoning:
+ # Output reached the caller, so the drop is terminal for the Turn.
+ assert (decision.action, decision.error_code) == ("surface", "stream_interrupted")
+ else:
+ assert decision.action == "fallback"
+
+ asyncio.run(run())
+
+
@pytest.mark.parametrize("invalid_type", [None, [], {}])
def test_engine_client_ignores_non_string_stream_event_types(
monkeypatch: pytest.MonkeyPatch,
diff --git a/tests/test_model_hub_structure_guards.py b/tests/test_model_hub_structure_guards.py
index 088621150..1bfc93dac 100644
--- a/tests/test_model_hub_structure_guards.py
+++ b/tests/test_model_hub_structure_guards.py
@@ -144,7 +144,9 @@ STREAM_ENVELOPE_FIXTURES = (
"event_name": "error",
"selector_path": ("type",),
"selector_value": "error",
- "error_paths": ((),),
+ # The reference carries the class at the root; Model Hub's engine nests it under `error`:
+ # https://github.com/router-for-me/CLIProxyAPI/blob/v7.3.16/sdk/api/handlers/openai_responses_stream_error.go
+ "error_paths": ((), ("error",)),
"payload": b'{"type":"error","code":"permission_error"}',
"source": "https://platform.openai.com/docs/api-reference/responses-streaming/error",
},
@@ -1703,7 +1705,7 @@ def test_cancelled_sse_observation_drains_its_worker_before_settlement() -> None
@pytest.mark.parametrize(
("event_name", "payload", "expected_outcome"),
(
- ("error", b'{"type":"error","error":{"code":"permission_error"}}', "failed_terminal"),
+ ("error", b'{"type":"error","response":{"error":{"code":"permission_error"}}}', "failed_terminal"),
("response.failed", b'{"type":"response.failed","code":"permission_error","response":{}}', "failed_terminal"),
("response.incomplete", b'{"type":"response.incomplete","response":{"error":null}}', "served"),
("response.incomplete", b'{"type":"response.incomplete","response":{"error":{}}}', "served"),
@@ -1717,7 +1719,7 @@ def test_responses_terminal_trust_roots_ignore_unofficial_error_locations(
state = ProtocolSSEState("openai_responses")
state.observe(b"event: " + event_name.encode() + b"\ndata: " + payload + b"\n\n")
assert state.terminal_outcome == expected_outcome
- assert state.error_envelope_paths in {((),), (), (("response", "error"),)}
+ assert state.error_envelope_paths in {((), ("error",)), (), (("response", "error"),)}
from vibe.model_hub_runtime.client import _raw_error_fields