| """Small synchronous reference HTTP server. Put behind a managed reverse proxy. |
| |
| One resident model, serialized requests, bounded bodies, no request-content logs. |
| This is an integration reference, not a qualified high-throughput serving stack. |
| """ |
| import hmac |
| import io |
| import json |
| import uuid |
| from http.server import BaseHTTPRequestHandler, HTTPServer |
|
|
| from .decisions import MODEL_ID, validate_request |
|
|
| MAX_BODY_BYTES = 1024 * 1024 |
|
|
|
|
| class HTTPError(Exception): |
| def __init__(self, status, detail): |
| self.status, self.detail = status, detail |
|
|
|
|
| def _unique_object(pairs): |
| result = {} |
| for key, value in pairs: |
| if key in result: |
| raise ValueError('Duplicate JSON keys are unsupported') |
| result[key] = value |
| return result |
|
|
|
|
| def create_server(model, address=('127.0.0.1', 8000), *, api_key=None): |
| class Handler(BaseHTTPRequestHandler): |
| def setup(self): |
| super().setup() |
| self.connection.settimeout(30) |
|
|
| def log_message(self, *_): |
| pass |
|
|
| def respond(self, status, body): |
| data = json.dumps(body, ensure_ascii=False, allow_nan=False).encode('utf-8') |
| self.send_response(status) |
| self.send_header('Content-Type', 'application/json; charset=utf-8') |
| self.send_header('Content-Length', str(len(data))) |
| self.send_header('x-typesafe-request-id', str(uuid.uuid4())) |
| self.end_headers() |
| self.wfile.write(data) |
|
|
| def authorize(self): |
| if api_key and not hmac.compare_digest( |
| self.headers.get('Authorization', '').encode(), ('Bearer ' + api_key).encode()): |
| raise HTTPError(401, 'Invalid bearer token') |
|
|
| def do_GET(self): |
| try: |
| self.authorize() |
| if self.path == '/v1/models': |
| self.respond(200, {'models': [{'name': MODEL_ID, 'description': |
| 'Fev-4B text decisions: Choice, Noul and Score; zero generated tokens.', |
| 'release_date': '2026-10-24'}]}) |
| else: |
| raise HTTPError(404, 'Unknown endpoint') |
| except HTTPError as error: |
| self.respond(error.status, {'detail': error.detail}) |
|
|
| def read_payload(self): |
| if self.headers.get('Transfer-Encoding'): |
| raise HTTPError(400, 'Chunked request bodies are unsupported') |
| if len(self.headers.get_all('Content-Length', [])) != 1: |
| raise HTTPError(411, 'One Content-Length header is required') |
| try: |
| size = int(self.headers['Content-Length']) |
| except ValueError: |
| raise HTTPError(400, 'Invalid Content-Length') from None |
| if not 0 < size <= MAX_BODY_BYTES: |
| raise HTTPError(413, 'Request body exceeds the 1 MiB limit') |
| if self.headers.get_content_type() != 'application/json': |
| raise HTTPError(415, 'Content-Type must be application/json') |
| data = self.rfile.read(size) |
| if len(data) != size: |
| raise HTTPError(400, 'Incomplete request body') |
| encoding = self.headers.get('Content-Encoding', 'identity').lower() |
| if encoding == 'zstd': |
| import zstandard |
| try: |
| with zstandard.ZstdDecompressor(max_window_size=1024).stream_reader(io.BytesIO(data)) as stream: |
| data = stream.read(MAX_BODY_BYTES + 1) |
| except zstandard.ZstdError: |
| raise HTTPError(400, 'Invalid or oversized zstd frame') from None |
| if len(data) > MAX_BODY_BYTES: |
| raise HTTPError(413, 'Decoded request exceeds the 1 MiB limit') |
| elif encoding != 'identity': |
| raise HTTPError(415, 'Supported Content-Encoding: identity, zstd') |
| return json.loads(data.decode('utf-8'), object_pairs_hook=_unique_object, |
| parse_constant=lambda _: (_ for _ in ()).throw(ValueError('Non-finite JSON'))) |
|
|
| def do_POST(self): |
| try: |
| self.authorize() |
| if self.path != '/v1/systemone': |
| raise HTTPError(404, 'Unknown endpoint') |
| payload = self.read_payload() |
| if not isinstance(payload, dict) or set(payload) != {'model', 'state', 'questions'}: |
| raise ValueError('Expected exactly model, state and questions; assets are unsupported') |
| if payload['model'] != MODEL_ID: |
| raise ValueError('Only model fev-4b is available') |
| request = validate_request({'state': payload['state'], 'questions': payload['questions']}) |
| self.respond(200, model.decide(request)) |
| except HTTPError as error: |
| self.respond(error.status, {'detail': error.detail}) |
| except (ValueError, UnicodeError, RecursionError): |
| self.respond(422, {'detail': 'Invalid request or context limit exceeded; see API.md'}) |
| except (TimeoutError, ConnectionError): |
| self.close_connection = True |
| except Exception: |
| self.respond(500, {'detail': 'Inference failed; no partial answers were returned'}) |
|
|
| return HTTPServer(address, Handler) |
|
|
