scripts/ctx_ab_deterministic_bridge.py

"""Deterministic, loopback-only provider bridge for local A/B plumbing tests.

This bridge is test infrastructure, not production-provider evidence.  Its token
accounting rule is intentionally simple and fully reproducible: one token is
each non-overlapping group of up to four UTF-8 bytes.  Input tokens cover the
exact HTTP request body, output tokens cover the configured assistant text,
cached input is always zero, and total tokens are input plus output.

Only ``POST /v1/chat/completions`` is implemented.  A request is accepted only
when either ``X-CTX-Bridge-Approval-SHA256`` or the standard
``Authorization: Bearer`` API-key field exactly carries the lowercase SHA-256
digest supplied by the caller when constructing the bridge.  If both are
present, both must match.  The server binds only to an IP loopback literal and
independently rejects non-loopback peers.  It never opens an outbound
connection.
"""

from __future__ import annotations

import hashlib
import hmac
import ipaddress
import json
import socket
import threading
from dataclasses import dataclass
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from typing import Any, ClassVar, Literal


APPROVAL_DIGEST_HEADER = "X-CTX-Bridge-Approval-SHA256"
_CHAT_COMPLETIONS_PATH: Literal["/v1/chat/completions"] = "/v1/chat/completions"
_SHA256_HEXDIGEST_LENGTH = 64
_MAX_CONTENT_LENGTH_DIGITS = 20


@dataclass(frozen=True, slots=True)
class CapturedMessage:
    """The message fields relevant to deterministic pair verification."""

    role: str
    content: str


@dataclass(frozen=True, slots=True)
class TokenUsage:
    """Exact usage under the deterministic four-UTF-8-byte accounting rule."""

    input_tokens: int
    cached_input_tokens: int
    uncached_input_tokens: int
    output_tokens: int
    total_tokens: int


@dataclass(frozen=True, slots=True)
class RequestRecord:
    """Immutable HTTP-body evidence for one accepted provider request."""

    request_body_bytes: bytes
    request_body_sha256: str
    approval_digest: str
    method: Literal["POST"]
    path: Literal["/v1/chat/completions"]
    model: str
    messages: tuple[CapturedMessage, ...]
    usage: TokenUsage
    response_status: Literal[200]
    response_body_bytes: bytes
    response_body_sha256: str


def deterministic_token_count(payload: bytes) -> int:
    """Count one token per non-empty group of at most four bytes."""

    return (len(payload) + 3) // 4


def _is_canonical_sha256(value: object) -> bool:
    return (
        isinstance(value, str)
        and len(value) == _SHA256_HEXDIGEST_LENGTH
        and all(character in "0123456789abcdef" for character in value)
    )


def _validate_sha256(value: str) -> str:
    if not _is_canonical_sha256(value):
        raise ValueError("approval_digest must be a lowercase SHA-256 hex digest")
    return value


def _unique_object(pairs: list[tuple[str, Any]]) -> dict[str, Any]:
    result: dict[str, Any] = {}
    for key, value in pairs:
        if key in result:
            raise ValueError(f"duplicate JSON key: {key}")
        result[key] = value
    return result


def _reject_nonfinite(constant: str) -> None:
    raise ValueError(f"non-finite JSON number: {constant}")


class _BridgeHTTPServer(ThreadingHTTPServer):
    daemon_threads = False
    block_on_close = True
    allow_reuse_address = False

    bridge: DeterministicProviderBridge

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        self._active_requests: set[socket.socket | tuple[bytes, socket.socket]] = set()
        self._active_requests_lock = threading.Lock()
        super().__init__(*args, **kwargs)

    def process_request(
        self,
        request: socket.socket | tuple[bytes, socket.socket],
        client_address: Any,
    ) -> None:
        with self._active_requests_lock:
            self._active_requests.add(request)
        try:
            super().process_request(request, client_address)
        except BaseException:
            with self._active_requests_lock:
                self._active_requests.discard(request)
            raise

    def process_request_thread(
        self,
        request: socket.socket | tuple[bytes, socket.socket],
        client_address: Any,
    ) -> None:
        try:
            super().process_request_thread(request, client_address)
        finally:
            with self._active_requests_lock:
                self._active_requests.discard(request)

    def close_active_requests(self) -> None:
        """Interrupt request reads after the accept loop has stopped."""

        with self._active_requests_lock:
            requests = tuple(self._active_requests)
        for request in requests:
            connection = request[1] if isinstance(request, tuple) else request
            try:
                connection.shutdown(socket.SHUT_RDWR)
            except OSError:
                pass


class _IPv6BridgeHTTPServer(_BridgeHTTPServer):
    address_family = socket.AF_INET6


class _BridgeRequestHandler(BaseHTTPRequestHandler):
    protocol_version = "HTTP/1.1"
    server: _BridgeHTTPServer

    def handle_one_request(self) -> None:
        """Bound unexpected application errors without leaking their details."""

        try:
            super().handle_one_request()
        except Exception:  # BaseHTTPRequestHandler retains its own parser limits.
            self.close_connection = True
            try:
                self.server.bridge._send_error(
                    self,
                    400,
                    "malformed_request",
                    "request could not be processed",
                )
            except Exception:
                # A peer that has already disconnected cannot receive a response.
                pass

    def do_POST(self) -> None:  # noqa: N802 - BaseHTTPRequestHandler API
        self.server.bridge._handle_post(self)

    def do_GET(self) -> None:  # noqa: N802 - BaseHTTPRequestHandler API
        self.server.bridge._handle_other_method(self)

    def do_PUT(self) -> None:  # noqa: N802 - BaseHTTPRequestHandler API
        self.server.bridge._handle_other_method(self)

    def do_DELETE(self) -> None:  # noqa: N802 - BaseHTTPRequestHandler API
        self.server.bridge._handle_other_method(self)

    def log_message(self, format: str, *args: object) -> None:  # noqa: A002
        return


class DeterministicProviderBridge:
    """A context-managed local OpenAI-compatible deterministic HTTP endpoint."""

    _ERROR_TYPE: ClassVar[str] = "invalid_request_error"

    def __init__(
        self,
        *,
        approval_digest: str,
        token_budget: int,
        response_content: str = "deterministic response",
        bind_host: str = "127.0.0.1",
        bind_port: int = 0,
        max_request_bytes: int = 1_048_576,
    ) -> None:
        try:
            bind_address = ipaddress.ip_address(bind_host)
        except ValueError as error:
            raise ValueError("bind_host must be a loopback IP literal") from error
        if not bind_address.is_loopback:
            raise ValueError("bind_host must be a loopback IP literal")
        if (
            isinstance(bind_port, bool)
            or not isinstance(bind_port, int)
            or not 0 <= bind_port <= 65535
        ):
            raise ValueError("bind_port must be an integer from 0 through 65535")
        if isinstance(token_budget, bool) or not isinstance(token_budget, int) or token_budget <= 0:
            raise ValueError("token_budget must be a positive integer")
        if (
            isinstance(max_request_bytes, bool)
            or not isinstance(max_request_bytes, int)
            or max_request_bytes <= 0
        ):
            raise ValueError("max_request_bytes must be a positive integer")
        if not isinstance(response_content, str):
            raise TypeError("response_content must be a string")

        self._approval_digest = _validate_sha256(approval_digest)
        self._token_budget = token_budget
        self._response_content = response_content
        self._bind_address = bind_address
        self._bind_port = bind_port
        self._max_request_bytes = max_request_bytes
        self._records: list[RequestRecord] = []
        self._records_lock = threading.Lock()
        self._lifecycle_condition = threading.Condition()
        self._lifecycle: Literal["new", "running", "closing", "closed"] = "new"
        self._server: _BridgeHTTPServer | None = None
        self._thread: threading.Thread | None = None

    @property
    def base_url(self) -> str:
        """Return the loopback URL after the bridge has started."""

        with self._lifecycle_condition:
            server = self._server
            if self._lifecycle != "running" or server is None:
                raise RuntimeError("deterministic provider bridge is not running")
        host = str(self._bind_address)
        if self._bind_address.version == 6:
            host = f"[{host}]"
        return f"http://{host}:{server.server_port}"

    @property
    def records(self) -> tuple[RequestRecord, ...]:
        """Return an immutable point-in-time snapshot of accepted requests."""

        with self._records_lock:
            return tuple(self._records)

    def start(self) -> DeterministicProviderBridge:
        """Bind and start the background server exactly once."""

        with self._lifecycle_condition:
            if self._lifecycle == "running":
                raise RuntimeError("deterministic provider bridge is already running")
            if self._lifecycle == "closing":
                raise RuntimeError("deterministic provider bridge is closing")
            if self._lifecycle == "closed":
                raise RuntimeError("deterministic provider bridge is closed")
            server_type = (
                _IPv6BridgeHTTPServer if self._bind_address.version == 6 else _BridgeHTTPServer
            )
            server = server_type(
                (str(self._bind_address), self._bind_port),
                _BridgeRequestHandler,
            )
            server.bridge = self
            thread = threading.Thread(
                target=server.serve_forever,
                name="ctx-ab-deterministic-bridge",
                daemon=True,
            )
            self._server = server
            self._thread = thread
            try:
                thread.start()
            except BaseException:
                try:
                    if thread.is_alive():
                        server.shutdown()
                finally:
                    server.close_active_requests()
                    server.server_close()
                    if thread.is_alive():
                        thread.join(timeout=5)
                    self._server = None
                    self._thread = None
                    self._lifecycle = "closed"
                    self._lifecycle_condition.notify_all()
                raise
            self._lifecycle = "running"
        return self

    def close(self) -> None:
        """Stop the server; repeated closes are harmless."""

        with self._lifecycle_condition:
            while self._lifecycle == "closing":
                self._lifecycle_condition.wait()
            if self._lifecycle == "closed":
                return
            if self._lifecycle == "new":
                self._lifecycle = "closed"
                self._lifecycle_condition.notify_all()
                return
            server = self._server
            thread = self._thread
            self._lifecycle = "closing"
        assert server is not None
        try:
            try:
                server.shutdown()
            finally:
                server.close_active_requests()
                server.server_close()
            if thread is not None:
                thread.join(timeout=5)
                if thread.is_alive():
                    raise RuntimeError("deterministic provider bridge did not stop")
        finally:
            with self._lifecycle_condition:
                self._server = None
                self._thread = None
                self._lifecycle = "closed"
                self._lifecycle_condition.notify_all()

    def __enter__(self) -> DeterministicProviderBridge:
        return self.start()

    def __exit__(self, exc_type: object, exc_value: object, traceback: object) -> None:
        self.close()

    @staticmethod
    def _peer_is_loopback(handler: _BridgeRequestHandler) -> bool:
        try:
            return ipaddress.ip_address(str(handler.client_address[0])).is_loopback
        except ValueError:
            return False

    def _handle_other_method(self, handler: _BridgeRequestHandler) -> None:
        if not self._peer_is_loopback(handler):
            self._send_error(handler, 403, "remote_peer_rejected", "remote peer rejected")
            return
        self._send_error(handler, 405, "method_not_allowed", "method not allowed")

    def _handle_post(self, handler: _BridgeRequestHandler) -> None:
        if not self._peer_is_loopback(handler):
            self._send_error(handler, 403, "remote_peer_rejected", "remote peer rejected")
            return
        if handler.path != _CHAT_COMPLETIONS_PATH:
            self._send_error(handler, 404, "unknown_path", "unknown path")
            return

        if not self._request_is_approved(handler):
            self._send_error(
                handler,
                403,
                "approval_digest_mismatch",
                "approval digest mismatch",
            )
            return

        content_type = handler.headers.get("Content-Type", "")
        if content_type.split(";", 1)[0].strip().lower() != "application/json":
            self._send_error(
                handler,
                415,
                "unsupported_media_type",
                "Content-Type must be application/json",
            )
            return
        if handler.headers.get("Transfer-Encoding") is not None:
            self._send_error(
                handler,
                400,
                "invalid_content_length",
                "transfer encoding is not supported",
            )
            return
        lengths = handler.headers.get_all("Content-Length", failobj=[])
        if len(lengths) != 1:
            self._send_error(
                handler,
                400,
                "invalid_content_length",
                "one decimal Content-Length is required",
            )
            return
        raw_content_length = lengths[0]
        if (
            len(raw_content_length) > _MAX_CONTENT_LENGTH_DIGITS
            or not raw_content_length.isascii()
            or not raw_content_length.isdecimal()
        ):
            self._send_error(
                handler,
                400,
                "invalid_content_length",
                "one decimal Content-Length is required",
            )
            return
        content_length = int(raw_content_length)
        if content_length > self._max_request_bytes:
            self._send_error(handler, 413, "request_too_large", "request body is too large")
            return
        request_bytes = handler.rfile.read(content_length)
        if len(request_bytes) != content_length:
            self._send_error(handler, 400, "truncated_request", "request body is truncated")
            return

        try:
            payload = json.loads(
                request_bytes.decode("utf-8"),
                object_pairs_hook=_unique_object,
                parse_constant=_reject_nonfinite,
            )
        except (UnicodeDecodeError, json.JSONDecodeError, ValueError):
            self._send_error(handler, 400, "malformed_json", "request body is not strict JSON")
            return
        if not isinstance(payload, dict):
            self._send_error(handler, 422, "invalid_request", "request body must be an object")
            return

        parsed = self._parse_request(handler, payload)
        if parsed is None:
            return
        model, messages, request_output_budget = parsed
        usage = self._usage(request_bytes)
        if request_output_budget is not None and usage.output_tokens > request_output_budget:
            self._send_error(
                handler,
                413,
                "request_output_budget_exceeded",
                "configured output exceeds request output budget",
            )
            return
        if usage.total_tokens > self._token_budget:
            self._send_error(
                handler,
                413,
                "token_budget_exceeded",
                "request exceeds bridge token budget",
            )
            return

        response_bytes = self._completion_bytes(
            model=model,
            request_sha256=hashlib.sha256(request_bytes).hexdigest(),
            usage=usage,
        )
        record = RequestRecord(
            request_body_bytes=request_bytes,
            request_body_sha256=hashlib.sha256(request_bytes).hexdigest(),
            approval_digest=self._approval_digest,
            method="POST",
            path=_CHAT_COMPLETIONS_PATH,
            model=model,
            messages=messages,
            usage=usage,
            response_status=200,
            response_body_bytes=response_bytes,
            response_body_sha256=hashlib.sha256(response_bytes).hexdigest(),
        )
        with self._records_lock:
            self._records.append(record)
        self._send_bytes(handler, 200, response_bytes)

    def _request_is_approved(self, handler: _BridgeRequestHandler) -> bool:
        explicit_values = handler.headers.get_all(APPROVAL_DIGEST_HEADER, failobj=[])
        authorization_values = handler.headers.get_all("Authorization", failobj=[])
        if len(explicit_values) > 1 or len(authorization_values) > 1:
            return False

        submitted: list[str] = list(explicit_values)
        if authorization_values:
            authorization = authorization_values[0]
            prefix = "Bearer "
            if not authorization.startswith(prefix):
                return False
            submitted.append(authorization.removeprefix(prefix))
        return bool(submitted) and all(
            _is_canonical_sha256(value)
            and hmac.compare_digest(value.encode("ascii"), self._approval_digest.encode("ascii"))
            for value in submitted
        )

    def _parse_request(
        self,
        handler: _BridgeRequestHandler,
        payload: dict[str, Any],
    ) -> tuple[str, tuple[CapturedMessage, ...], int | None] | None:
        model = payload.get("model")
        raw_messages = payload.get("messages")
        if not isinstance(model, str) or not model.strip():
            self._send_error(handler, 422, "invalid_request", "model must be a non-empty string")
            return None
        if not isinstance(raw_messages, list):
            self._send_error(handler, 422, "invalid_request", "messages must be a list")
            return None
        messages: list[CapturedMessage] = []
        for raw_message in raw_messages:
            if not isinstance(raw_message, dict):
                self._send_error(handler, 422, "invalid_request", "message must be an object")
                return None
            role = raw_message.get("role")
            content = raw_message.get("content")
            if not isinstance(role, str) or not role.strip() or not isinstance(content, str):
                self._send_error(
                    handler,
                    422,
                    "invalid_request",
                    "message role and content must be strings",
                )
                return None
            messages.append(CapturedMessage(role=role, content=content))
        if payload.get("stream", False) is not False:
            self._send_error(
                handler,
                422,
                "streaming_not_supported",
                "streaming is not supported",
            )
            return None

        budget_fields = [
            value
            for value in (payload.get("max_tokens"), payload.get("max_completion_tokens"))
            if value is not None
        ]
        for value in budget_fields:
            if isinstance(value, bool) or not isinstance(value, int) or value < 0:
                self._send_error(
                    handler,
                    422,
                    "invalid_request",
                    "output token budgets must be non-negative integers",
                )
                return None
        request_output_budget = min(budget_fields) if budget_fields else None
        return model, tuple(messages), request_output_budget

    def _usage(self, request_bytes: bytes) -> TokenUsage:
        input_tokens = deterministic_token_count(request_bytes)
        output_tokens = deterministic_token_count(self._response_content.encode("utf-8"))
        return TokenUsage(
            input_tokens=input_tokens,
            cached_input_tokens=0,
            uncached_input_tokens=input_tokens,
            output_tokens=output_tokens,
            total_tokens=input_tokens + output_tokens,
        )

    def _completion_bytes(
        self,
        *,
        model: str,
        request_sha256: str,
        usage: TokenUsage,
    ) -> bytes:
        response = {
            "choices": [
                {
                    "finish_reason": "stop",
                    "index": 0,
                    "message": {"content": self._response_content, "role": "assistant"},
                }
            ],
            "created": 0,
            "id": f"chatcmpl-ctx-{request_sha256[:24]}",
            "model": model,
            "object": "chat.completion",
            "usage": {
                "cached_input_tokens": usage.cached_input_tokens,
                "completion_tokens": usage.output_tokens,
                "input_tokens": usage.input_tokens,
                "output_tokens": usage.output_tokens,
                "prompt_tokens": usage.input_tokens,
                "prompt_tokens_details": {"cached_tokens": usage.cached_input_tokens},
                "total_tokens": usage.total_tokens,
                "uncached_input_tokens": usage.uncached_input_tokens,
            },
        }
        return json.dumps(
            response,
            allow_nan=False,
            ensure_ascii=False,
            separators=(",", ":"),
            sort_keys=True,
        ).encode("utf-8")

    def _send_error(
        self,
        handler: _BridgeRequestHandler,
        status: int,
        code: str,
        message: str,
    ) -> None:
        payload = {
            "error": {
                "code": code,
                "message": message,
                "type": self._ERROR_TYPE,
            }
        }
        body = json.dumps(payload, separators=(",", ":"), sort_keys=True).encode("utf-8")
        self._send_bytes(handler, status, body)

    @staticmethod
    def _send_bytes(handler: _BridgeRequestHandler, status: int, body: bytes) -> None:
        handler.close_connection = True
        handler.send_response(status)
        handler.send_header("Content-Type", "application/json")
        handler.send_header("Content-Length", str(len(body)))
        handler.send_header("Cache-Control", "no-store")
        handler.send_header("Connection", "close")
        handler.end_headers()
        handler.wfile.write(body)


__all__ = [
    "APPROVAL_DIGEST_HEADER",
    "CapturedMessage",
    "DeterministicProviderBridge",
    "RequestRecord",
    "TokenUsage",
    "deterministic_token_count",
]