Skip to content

The agent that grows with you

4.8 KB
Raw Blame
"""Opaque reasoning records survive both collectors and durable replay."""

import json
import threading
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer

import pytest
from openai import OpenAI
from openai.types.chat import ChatCompletion

from agent.chat_completion_helpers import build_assistant_message, interruptible_streaming_api_call
from agent.chat_completion_helpers_relay import RelayChatAccumulator
from agent.transports.chat_completions import ChatCompletionsTransport
from hermes_state import SessionDB
from run_agent import AIAgent


@pytest.mark.parametrize("collector", ["main", "relay"])
@pytest.mark.parametrize("delivery", ["final", "multiple", "absent"])
def test_stream_reasoning_details_survive_replay(tmp_path, collector, delivery):
    details = [
        {"type": "opaque.native", "version": 1, "messages": [
            {"type": "thinking", "signature": " signed+/=\n", "thinking": "α"},
            {"type": "text", "text": "hello"},
            {"type": "redacted_thinking", "data": "AA+/=="}],
         "projection": {"content": "hello world", "tool_calls": []}},
        {"type": "opaque.future", "index": 7, "unknown": [None, False, {"signature": "\r\n"}]},
    ] if delivery != "absent" else []
    deltas = [{"role": "assistant", "content": "hello"}, {"content": " world"}]
    if delivery == "multiple":
        deltas[0]["reasoning_details"] = details[:1]
        deltas.append({"reasoning_details": []})
        deltas.append({"reasoning_details": details[1:]})
    elif delivery == "final":
        deltas.append({"reasoning_details": details})
    requests = []

    class Handler(BaseHTTPRequestHandler):
        def log_message(self, *_args):
            pass

        def do_POST(self):
            body = json.loads(self.rfile.read(int(self.headers.get("Content-Length", 0))))
            if not self.path.endswith("/chat/completions"):
                self.send_response(404)
                self.end_headers()
                return
            requests.append(body)
            self.send_response(200)
            self.send_header("Content-Type", "text/event-stream")
            self.end_headers()
            for index, delta in enumerate(deltas):
                chunk = {"id": "local-proof", "object": "chat.completion.chunk", "created": 1,
                         "model": "test-model", "choices": [{"index": 0, "delta": delta,
                         "finish_reason": "stop" if index == len(deltas) - 1 else None}]}
                self.wfile.write(f"data: {json.dumps(chunk)}\n\n".encode())
                self.wfile.flush()
            self.wfile.write(b"data: [DONE]\n\n")

    server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
    thread = threading.Thread(target=server.serve_forever, daemon=True)
    thread.start()
    base_url = f"http://127.0.0.1:{server.server_port}/v1"
    agent = AIAgent(api_key="local-test", base_url=base_url, provider="custom", model="test-model",
                    platform="subagent", quiet_mode=True, skip_memory=True, skip_context_files=True,
                    enabled_toolsets=[], save_trajectories=False)
    kwargs = {"model": "test-model", "messages": [{"role": "user", "content": "hi"}]}
    try:
        if collector == "main":
            response = interruptible_streaming_api_call(agent, kwargs)
        else:
            acc = RelayChatAccumulator()
            with OpenAI(api_key="local-test", base_url=base_url) as client:
                with client.chat.completions.create(**kwargs, stream=True) as stream:
                    for chunk in stream:
                        acc.observe(chunk.model_dump(mode="json"))
            recorded = acc.finalize()
            recorded["choices"][0]["index"] = 0
            response = ChatCompletion.model_validate({"id": "local-proof", "created": 1,
                "object": "chat.completion", **recorded})
        assert requests and all(request["stream"] is True for request in requests)
        assert response.choices[0].message.content == "hello world"
        assert getattr(response.choices[0].message, "reasoning_details", None) == (details or None)
        normalized = ChatCompletionsTransport().normalize_response(response)
        assert normalized.reasoning_details == (details or None)
        message = build_assistant_message(agent, normalized, normalized.finish_reason)
        assert message.get("reasoning_details") == (details or None)
        db_path = tmp_path / "replay.db"
        with SessionDB(db_path=db_path) as db:
            db.create_session("reasoning-proof", source="cli")
            db.append_messages_batch("reasoning-proof", [message])
        with SessionDB(db_path=db_path) as db:
            replay = db.get_messages_as_conversation("reasoning-proof")
            assert replay[0].get("reasoning_details") == (details or None)
    finally:
        server.shutdown()
        server.server_close()
        thread.join(timeout=5)