The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
"""Bound chat upload request bodies before FastAPI parses, spools or buffers them."""
from __future__ import annotations
from starlette.datastructures import Headers
from starlette.formparsers import MultiPartException
from starlette.responses import JSONResponse
from starlette.types import ASGIApp, Message, Receive, Scope, Send
from hermes_cli.web_server_surface import policy
from hermes_constants import WEBAPP_ATTACHMENT_MAX_BYTES
# The file cap remains exact in the handler; allow ordinary multipart headers
# and boundaries without letting arbitrary extra parts consume unbounded disk.
CHAT_FILE_BODY_MAX_BYTES = WEBAPP_ATTACHMENT_MAX_BYTES + 64 * 1024
# Largest decoded image /api/chat/image-upload stores. The image arrives base64-encoded in a JSON
# body, which FastAPI reads whole before the handler checks the image: bound the body to that
# image's base64 length plus room for the JSON around it, so an oversized paste is never buffered.
CHAT_IMAGE_MAX_BYTES = 25 * 1024 * 1024
CHAT_IMAGE_BODY_MAX_BYTES = 4 * -(-CHAT_IMAGE_MAX_BYTES // 3) + 64 * 1024
_BODY_MAX_BYTES = {
"/api/chat/file-upload": CHAT_FILE_BODY_MAX_BYTES,
"/api/chat/image-upload": CHAT_IMAGE_BODY_MAX_BYTES,
}
class ChatFileUploadLimitMiddleware:
"""Refuse a chat file or image upload with 413 once its body passes the route's cap: at once
when Content-Length declares more, else at the first chunk past it. Only on the surfaces whose
policy serves the browser's file routes (the Webapp); elsewhere uploads reach their handlers
as on main."""
def __init__(self, app: ASGIApp):
self.app = app
async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
path = scope.get("path", "")
root = scope.get("root_path", "")
if root and path.startswith(root + "/"):
path = path[len(root) :]
body_max = _BODY_MAX_BYTES.get(path)
if (scope["type"] != "http" or scope["method"] != "POST" or body_max is None
or not policy(getattr(scope.get("app"), "state", None)).browser_files):
await self.app(scope, receive, send)
return
rejection = JSONResponse(status_code=413, content={"detail": "Upload request is too large"})
length = Headers(scope=scope).get("content-length", "").lstrip("0") or "0"
if (
length.isascii()
and length.isdecimal()
and (len(length) > len(str(body_max)) or int(length) > body_max)
):
await rejection(scope, receive, send)
return
received = 0
exceeded = False
async def limited_receive() -> Message:
nonlocal received, exceeded
message = await receive()
if message["type"] == "http.request":
received += len(message.get("body", b""))
if received > body_max:
exceeded = True
# This exception is deliberate: Starlette's multipart parser
# closes *all* open spools on MultiPartException, unlike an
# HTTPException or cancellation. The rejected chunk never
# reaches the parser. Request._get_form converts it to 400,
# as FastAPI does for a JSON body whose read fails.
raise MultiPartException("Upload request is too large")
return message
async def limited_send(message: Message) -> None:
if not exceeded:
await send(message)
elif message["type"] == "http.response.start":
# Replace the parser's 400 (including its Content-Length) with
# 413, after its cleanup, and suppress the original body.
await rejection(scope, receive, send)
await self.app(scope, limited_receive, limited_send)