File size: 5,384 Bytes
f843101 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 | """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)
|