[NA] [CI] fix: serve both LLM wire protocols in the E2E mock

The nightly E2E started failing on 2026-08-01 without any change to this
repo. A rolling nousresearch/hermes-agent:latest rebuild began honoring the
openai-api provider's declared codex_responses transport, switching the wire
from POST /v1/chat/completions to POST /v1/responses. The mock only spoke
Chat Completions, so the stream never emitted a terminal event and every turn
died after three retries with no tool call — surfacing as 'trace has no
output' and 'no tool spans' across all three E2E jobs.

Serve both protocols rather than pinning the image: the nightly cron exists to
catch exactly this upstream drift, so pinning would silence the detector. The
Chat Completions handler is unchanged, so older Hermes images keep passing.

Also replace the catch-all 200 for unknown POST routes with a 501. The benign
200 let an unimplemented protocol masquerade as a hung stream, which is what
made this break hard to diagnose.

Verified against v2026.7.20, v2026.7.30 (chat_completions) and :latest
(codex_responses): all three E2E jobs pass, 113 unit tests pass.

Author: JetoPistola

e2e/mock_llm_server.py

@@ -1,16 +1,32 @@
 """Mock OpenAI-compatible LLM for E2E.
 
-The Hermes openai-api provider (as configured here) calls the **Chat
-Completions** API with streaming: POST /v1/chat/completions, and consumes
-`data: {"choices":[{"delta":{...}}]}` SSE chunks terminated by `data: [DONE]`.
+Serves **both** wire protocols the Hermes openai-api provider may pick, because
+which one it uses is upstream's choice and has changed under us before:
+
+  * **Chat Completions** — POST /v1/chat/completions, consuming
+    `data: {"choices":[{"delta":{...}}]}` SSE chunks terminated by `data: [DONE]`.
+  * **Responses** — POST /v1/responses, consuming typed SSE events
+    (`response.output_item.added/done`, `response.output_text.delta`) and
+    terminated by `response.completed`. Hermes calls this its `codex_responses`
+    api_mode; the openai-api provider declares that transport, and a rolling
+    `nousresearch/hermes-agent:latest` rebuild started honoring it (2026-08-02),
+    which is what made a chat-only mock fail with "Codex Responses stream did
+    not emit a terminal response".
+
+Both are kept so the suite passes against old and new Hermes images alike.
+
 It also probes GET /v1/models and POST /api/show (Ollama-style).
 
-Deterministic two-step interaction:
-  call 1  -> a tool_call delta  (Hermes runs a tool  -> tool span)
-  call 2+ -> a content delta     (turn completes)
+Deterministic two-step interaction, identical on either protocol:
+  call 1  -> a tool call      (Hermes runs a tool  -> tool span)
+  call 2+ -> assistant text   (turn completes)
 
 That yields one LLM -> tool -> LLM cycle: a root trace with two LLM spans and
 one tool span. No real model, no key, no external network.
+
+Unknown POST routes return 501 rather than a benign 200: a silent 200 makes an
+unimplemented protocol look like a hung stream, which is exactly how the
+2026-08-02 breakage disguised itself.
 """
 
 from __future__ import annotations
@@ -60,6 +76,61 @@ def _final_chunks():
     yield {**base, "choices": [{"index": 0, "delta": {}, "finish_reason": "stop"}], "usage": _USAGE}
 
 
+_RESPONSES_USAGE = {"input_tokens": 20, "output_tokens": 8, "total_tokens": 28}
+
+
+def _responses_tool_events():
+    """Emit a function_call item, then response.completed.
+
+    Hermes marks `has_tool_calls` from the `output_item.added` event and
+    collects the executable item from `output_item.done`; both are required.
+    """
+    item = {
+        "id": "fc_mock_1",
+        "type": "function_call",
+        "status": "completed",
+        "call_id": "call_mock_1",
+        "name": "execute_code",
+        "arguments": json.dumps({"code": "print(2**10)"}),
+    }
+    yield "response.output_item.added", {"output_index": 0, "item": item}
+    yield "response.output_item.done", {"output_index": 0, "item": item}
+    yield "response.completed", {
+        "response": {
+            "id": "resp_mock1",
+            "status": "completed",
+            "output": [item],
+            "usage": _RESPONSES_USAGE,
+        }
+    }
+
+
+def _responses_final_events():
+    """Emit assistant text deltas, then response.completed."""
+    text = "The answer is 1024."
+    item = {
+        "id": "msg_mock_1",
+        "type": "message",
+        "status": "completed",
+        "role": "assistant",
+        "content": [{"type": "output_text", "text": text}],
+    }
+    yield "response.output_item.added", {
+        "output_index": 0,
+        "item": {**item, "status": "in_progress", "content": []},
+    }
+    yield "response.output_text.delta", {"output_index": 0, "delta": text}
+    yield "response.output_item.done", {"output_index": 0, "item": item}
+    yield "response.completed", {
+        "response": {
+            "id": "resp_mock2",
+            "status": "completed",
+            "output": [item],
+            "usage": _RESPONSES_USAGE,
+        }
+    }
+
+
 class Handler(BaseHTTPRequestHandler):
     def log_message(self, *args):
         pass
@@ -83,6 +154,22 @@ def _sse(self, chunks):
         self.wfile.write(b"data: [DONE]\n\n")
         self.wfile.flush()
 
+    def _sse_typed(self, events):
+        """SSE for the Responses API: named events carrying a `type` field.
+
+        Unlike Chat Completions there is no `[DONE]` sentinel — the stream ends
+        at the terminal `response.completed` event.
+        """
+        self.send_response(200)
+        self.send_header("Content-Type", "text/event-stream")
+        self.send_header("Cache-Control", "no-cache")
+        self.end_headers()
+        for seq, (event_type, payload) in enumerate(events):
+            frame = {"type": event_type, "sequence_number": seq, **payload}
+            self.wfile.write(f"event: {event_type}\n".encode())
+            self.wfile.write(f"data: {json.dumps(frame)}\n\n".encode())
+            self.wfile.flush()
+
     def do_GET(self):
         # /v1/models and health probes
         self._json({"object": "list", "data": [{"id": "gpt-5", "object": "model"}]})
@@ -97,7 +184,25 @@ def do_POST(self):
             self._json({"model": "gpt-5", "details": {"family": "gpt"}})
             return
 
-        # Chat Completions (the path Hermes uses here).
+        # Responses API (codex_responses api_mode).
+        if self.path.rstrip("/").endswith("/responses"):
+            _STATE["calls"] += 1
+            events = (
+                _responses_tool_events()
+                if _STATE["calls"] == 1
+                else _responses_final_events()
+            )
+            wants_stream = b'"stream": true' in body or b'"stream":true' in body
+            if wants_stream:
+                self._sse_typed(events)
+            else:
+                # Non-streaming fallback: the terminal event's response object
+                # is already the full non-streamed body.
+                terminal = list(events)[-1][1]
+                self._json({"object": "response", "model": "gpt-5", **terminal["response"]})
+            return
+
+        # Chat Completions (the other wire Hermes may pick).
         if "chat/completions" in self.path:
             _STATE["calls"] += 1
             chunks = _tool_call_chunks() if _STATE["calls"] == 1 else _final_chunks()
@@ -118,8 +223,14 @@ def do_POST(self):
                 )
             return
 
-        # Anything else → benign 200.
-        self._json({"ok": True})
+        # An unimplemented *inference* route must fail loudly. Returning 200
+        # here would let Hermes hang until its retries expire and surface as a
+        # vague stream error, hiding the real cause (a protocol we don't serve).
+        print(f"UNIMPLEMENTED inference route: {self.path}", flush=True)
+        self._json(
+            {"error": {"message": f"mock-llm does not implement {self.path}", "type": "not_implemented"}},
+            code=501,
+        )
 
 
 if __name__ == "__main__":