@agentsdock/server 1.0.11-beta.2 → 1.0.12-beta.1

package/server/session_unread.py

@@ -0,0 +1,184 @@
+"""Incremental unread provenance; journal recovery runs off the event loop."""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Callable, Iterable
+from transcript_reader import jsonl_records
+
+
+COUNTER = "latest_non_job_agent_event_seq"
+CHECKPOINT = "_non_job_agent_event_checkpoint_seq"
+PENDING_COUNTER = "_non_job_agent_event_pending_seq"
+LAST_RUN = "_non_job_agent_last_run"
+JOURNAL = "_non_job_agent_event_journal"
+
+
+def imported_event(event: dict[str, Any]) -> bool:
+    return event.get("imported") is True or str(event.get("run_id") or "").startswith("import_")
+
+
+def scheduled_event(event: dict[str, Any]) -> bool:
+    job = event.get("job")
+    return bool(
+        event.get("purpose") == "scheduled_job"
+        or str(event.get("job_id") or "").strip()
+        or isinstance(job, dict) and str(job.get("id") or "").strip()
+        or str(event.get("type") or "").startswith("job_")
+    )
+
+
+def project_event(
+    session: dict[str, Any], event: dict[str, Any], *,
+    visible: bool, run_metadata: dict[str, Any],
+) -> None:
+    """Apply an appended event without I/O or changing the ordinary read cursor."""
+    seq = int(event.get("seq") or 0)
+    if seq <= 0:
+        return
+    # Only a new journal can establish an empty baseline without recovery.
+    if seq == 1 and not int(session.get("latest_event_seq") or 0):
+        session.setdefault(COUNTER, 0)
+        session.setdefault(CHECKPOINT, 0)
+    known = isinstance(session.get(COUNTER), int) and CHECKPOINT in session
+    run_id = str(event.get("run_id") or "")
+    contexts: list[dict[str, Any]] = []
+    if event.get("type") == "turn_started" and run_id:
+        context = {"run_id": run_id, "scheduled_job": scheduled_event(event) or scheduled_event(run_metadata)}
+        session[LAST_RUN] = context
+        contexts.append(context)
+    else:
+        for candidate in (session.get("active_run"), session.get(LAST_RUN)):
+            if isinstance(candidate, dict) and run_id and candidate.get("run_id") == run_id:
+                contexts.append(candidate)
+    scheduled = scheduled_event(event) or scheduled_event(run_metadata) or any(
+        scheduled_event(context) or context.get("scheduled_job") is True for context in contexts
+    )
+    if scheduled and run_id and (session.get(LAST_RUN) or {}).get("run_id") == run_id:
+        session[LAST_RUN] = {"run_id": run_id, "scheduled_job": True}
+    if visible and not scheduled and not imported_event(event):
+        field = COUNTER if known else PENDING_COUNTER
+        session[field] = max(int(session.get(field) or 0), seq)
+    if known:
+        session[CHECKPOINT] = max(int(session.get(CHECKPOINT) or 0), seq)
+
+
+def recover_projection(
+    path: Path, snapshot: dict[str, Any], *,
+    visible: Callable[[str, dict[str, Any]], bool],
+    resume_offset: Callable[[Path, int], int],
+    prior_events: Callable[[], Iterable[dict[str, Any]]],
+    cancelled: Callable[[], bool],
+) -> dict[str, Any]:
+    """Project one fixed journal extent, then resolve missing run provenance once.
+
+    Legacy chats need one forward pass. A durable checkpoint resumes through the
+    existing sparse index; only an untagged tail run whose start precedes that
+    checkpoint requires a backwards provenance pass. No history is read by the
+    session-list endpoint or the live event projection.
+    """
+    known = isinstance(snapshot.get(COUNTER), int) and CHECKPOINT in snapshot
+    after = int(snapshot.get(CHECKPOINT) or 0) if known else 0
+    latest = int(snapshot.get(COUNTER) or 0) if known else 0
+    through = after
+    last_run = dict(snapshot.get(LAST_RUN) or {})
+    runs: dict[str, dict[str, Any]] = {}
+    unresolved: dict[str, list[dict[str, Any]]] = {}
+
+    def finish(run_id: str, run: dict[str, Any]) -> None:
+        nonlocal latest
+        if run["scheduled"] or not run["visible_seq"]:
+            return
+        if run["origin"]:
+            latest = max(latest, run["visible_seq"])
+        else:
+            unresolved.setdefault(run_id, []).append(run)
+
+    try:
+        source = path.open("rb")
+    except FileNotFoundError:
+        if after or int(snapshot.get("latest_event_seq") or 0):
+            raise
+        return {COUNTER: 0, CHECKPOINT: 0, LAST_RUN: {}}
+    with source:
+        extent = source.seek(0, 2)
+        inode = path.stat().st_ino
+        journal = snapshot.get(JOURNAL) or {}
+        if known and journal and (journal.get("inode") != inode or int(journal.get("offset") or 0) > extent):
+            after = latest = through = 0
+            last_run = {}
+        offset = int(journal.get("offset") or 0) if after and journal.get("inode") == inode else 0
+        source.seek(offset or (resume_offset(path, after) if after else 0))
+        complete_offset = source.tell()
+        for event, ending, raw in jsonl_records(
+            source, end=extent, project=False, require_newline=False, deadline=float("inf"), cancelled=cancelled,
+            max_records=float("inf"), max_nodes=None, max_depth=512,
+            retained_fields=frozenset({"seq", "type", "run_id", "purpose", "job_id", "job", "text", "result_text", "goal", "imported"}),
+        ):
+            if not raw.complete:
+                break  # Leave a concurrently written/crash fragment unclaimed.
+            complete_offset = ending
+            if not isinstance(event, dict):
+                continue
+            seq = int(event.get("seq") or 0)
+            if seq <= after:
+                continue
+            through = max(through, seq)
+            event_type = str(event.get("type") or "")
+            is_visible = visible(event_type, event) and not imported_event(event)
+            run_id = str(event.get("run_id") or "")
+            scheduled = scheduled_event(event)
+            if not run_id:
+                if is_visible and not scheduled:
+                    latest = max(latest, seq)
+                continue
+            if event_type == "turn_started" and run_id in runs:
+                finish(run_id, runs.pop(run_id))
+            run = runs.setdefault(run_id, {"first_seq": seq, "visible_seq": 0, "scheduled": False, "origin": False})
+            run["scheduled"] = run["scheduled"] or scheduled
+            if event_type == "turn_started":
+                run["origin"] = True
+                last_run = {"run_id": run_id, "scheduled_job": scheduled}
+            elif scheduled and last_run.get("run_id") == run_id:
+                last_run["scheduled_job"] = True
+            if is_visible:
+                run["visible_seq"] = max(run["visible_seq"], seq)
+            if event_type in {"turn_finished", "turn_stopped"} and (run["scheduled"] or not run["visible_seq"]):
+                # Completed cron runs do not accumulate with the schedule's
+                # history. A later untagged event is resolved by the single
+                # backwards provenance pass, just like a restart tail.
+                runs.pop(run_id, None)
+        for run_id, run in runs.items():
+            finish(run_id, run)
+    # One reverse pass resolves all tail runs together, including stripped raw
+    # provider events and a job_ran marker emitted after the provider's start.
+    if unresolved:
+        for event in prior_events():
+            if cancelled():
+                raise InterruptedError("unread projection cancelled")
+            run_id = str(event.get("run_id") or "")
+            candidates = unresolved.get(run_id)
+            if not candidates:
+                continue
+            seq = int(event.get("seq") or 0)
+            scheduled = scheduled_event(event)
+            if not scheduled and event.get("type") != "turn_started":
+                continue
+            remaining = []
+            for run in candidates:
+                if seq >= run["first_seq"]:
+                    remaining.append(run)
+                elif not scheduled:
+                    latest = max(latest, run["visible_seq"])
+            if remaining:
+                unresolved[run_id] = remaining
+            else:
+                unresolved.pop(run_id)
+            if not unresolved:
+                break
+        # Legacy output with no recorded job provenance remains ordinary;
+        # merely owning a schedule never suppresses a human conversation.
+        for candidates in unresolved.values():
+            for run in candidates:
+                latest = max(latest, run["visible_seq"])
+    return {COUNTER: latest, CHECKPOINT: through, LAST_RUN: last_run,
+            JOURNAL: {"inode": inode, "offset": complete_offset}}

package/server/shared_chat_analytics_web.py

@@ -0,0 +1,5 @@
+"""Generated from the limited shared-chat analytics entry; do not edit by hand."""
+import json
+
+SCRIPT = json.loads("\"/*! @noble/hashes\\nThe MIT License (MIT)\\n\\nCopyright (c) 2022 Paul Miller (https://paulmillr.com)\\n\\nPermission is hereby granted, free of charge, to any person obtaining a copy\\nof this software and associated documentation files (the “Software”), to deal\\nin the Software without restriction, including without limitation the rights\\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\\ncopies of the Software, and to permit persons to whom the Software is\\nfurnished to do so, subject to the following conditions:\\n\\nThe above copyright notice and this permission notice shall be included in\\nall copies or substantial portions of the Software.\\n\\nTHE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\\nTHE SOFTWARE.\\n*/(function(){\\\"use strict\\\";function H(e){return e instanceof Uint8Array||ArrayBuffer.isView(e)&&e.constructor.name===\\\"Uint8Array\\\"&&\\\"BYTES_PER_ELEMENT\\\"in e&&e.BYTES_PER_ELEMENT===1}function p(e,t,s=\\\"\\\"){const n=H(e),r=e?.length;if(!n||t!==void 0){const i=s&&`\\\"${s}\\\" `,o=\\\"\\\",f=n?`length=${r}`:`type=${typeof e}`,h=i+\\\"expected Uint8Array\\\"+o+\\\", got \\\"+f;throw n?new RangeError(h):new TypeError(h)}return e}function m(e,t=!0){if(e.destroyed)throw new Error(\\\"Hash instance has been destroyed\\\");if(t&&e.finished)throw new Error(\\\"Hash#digest() has already been called\\\")}function S(e,t){p(e,void 0,\\\"digestInto() output\\\");const s=t.outputLen;if(e.length<s)throw new RangeError('\\\"digestInto() output\\\" expected to be of length >='+s)}function y(...e){for(let t=0;t<e.length;t++)e[t].fill(0)}function _(e){return new DataView(e.buffer,e.byteOffset,e.byteLength)}function d(e,t){return e<<32-t|e>>>t}const T=typeof Uint8Array.from([]).toHex==\\\"function\\\"&&typeof Uint8Array.fromHex==\\\"function\\\",k=Array.from({length:256},(e,t)=>t.toString(16).padStart(2,\\\"0\\\"));function B(e){if(p(e),T)return e.toHex();let t=\\\"\\\";for(let s=0;s<e.length;s++)t+=k[e[s]];return t}function O(e){if(typeof e!=\\\"string\\\")throw new TypeError(\\\"string expected\\\");return new Uint8Array(new TextEncoder().encode(e))}function U(e,t={}){const s=(r,c)=>e(c).update(r).digest(),n=e(void 0);return s.outputLen=n.outputLen,s.blockLen=n.blockLen,s.canXOF=n.canXOF,s.create=r=>e(r),Object.assign(s,t),Object.freeze(s)}const v=e=>({oid:Uint8Array.from([6,9,96,134,72,1,101,3,4,2,e])});function C(e,t,s){return e&t^~e&s}function I(e,t,s){return e&t^e&s^t&s}class D{blockLen;outputLen;canXOF=!1;padOffset;isLE;buffer;view;finished=!1;length=0;pos=0;destroyed=!1;constructor(t,s,n,r){this.blockLen=t,this.outputLen=s,this.padOffset=n,this.isLE=r,this.buffer=new Uint8Array(t),this.view=_(this.buffer)}update(t){m(this),p(t);const{view:s,buffer:n,blockLen:r}=this,c=t.length;for(let i=0;i<c;){const o=Math.min(r-this.pos,c-i);if(o===r){const f=_(t);for(;r<=c-i;i+=r)this.process(f,i);continue}n.set(t.subarray(i,i+o),this.pos),this.pos+=o,i+=o,this.pos===r&&(this.process(s,0),this.pos=0)}return this.length+=t.length,this.roundClean(),this}digestInto(t){m(this),S(t,this),this.finished=!0;const{buffer:s,view:n,blockLen:r,isLE:c}=this;let{pos:i}=this;s[i++]=128,y(this.buffer.subarray(i)),this.padOffset>r-i&&(this.process(n,0),i=0);for(let a=i;a<r;a++)s[a]=0;n.setBigUint64(r-8,BigInt(this.length*8),c),this.process(n,0);const o=_(t),f=this.outputLen;if(f%4)throw new Error(\\\"_sha2: outputLen must be aligned to 32bit\\\");const h=f/4,l=this.get();if(h>l.length)throw new Error(\\\"_sha2: outputLen bigger than state\\\");for(let a=0;a<h;a++)o.setUint32(4*a,l[a],c)}digest(){const{buffer:t,outputLen:s}=this;this.digestInto(t);const n=t.slice(0,s);return this.destroy(),n}_cloneInto(t){t||=new this.constructor,t.set(...this.get());const{blockLen:s,buffer:n,length:r,finished:c,destroyed:i,pos:o}=this;return t.destroyed=i,t.finished=c,t.length=r,t.pos=o,r%s&&t.buffer.set(n),t}clone(){return this._cloneInto()}}const x=Uint32Array.from([1779033703,3144134277,1013904242,2773480762,1359893119,2600822924,528734635,1541459225]),N=Uint32Array.from([1116352408,1899447441,3049323471,3921009573,961987163,1508970993,2453635748,2870763221,3624381080,310598401,607225278,1426881987,1925078388,2162078206,2614888103,3248222580,3835390401,4022224774,264347078,604807628,770255983,1249150122,1555081692,1996064986,2554220882,2821834349,2952996808,3210313671,3336571891,3584528711,113926993,338241895,666307205,773529912,1294757372,1396182291,1695183700,1986661051,2177026350,2456956037,2730485921,2820302411,3259730800,3345764771,3516065817,3600352804,4094571909,275423344,430227734,506948616,659060556,883997877,958139571,1322822218,1537002063,1747873779,1955562222,2024104815,2227730452,2361852424,2428436474,2756734187,3204031479,3329325298]),u=new Uint32Array(64);class F extends D{constructor(t){super(64,t,8,!1)}get(){const{A:t,B:s,C:n,D:r,E:c,F:i,G:o,H:f}=this;return[t,s,n,r,c,i,o,f]}set(t,s,n,r,c,i,o,f){this.A=t|0,this.B=s|0,this.C=n|0,this.D=r|0,this.E=c|0,this.F=i|0,this.G=o|0,this.H=f|0}process(t,s){for(let a=0;a<16;a++,s+=4)u[a]=t.getUint32(s,!1);for(let a=16;a<64;a++){const g=u[a-15],b=u[a-2],L=d(g,7)^d(g,18)^g>>>3,w=d(b,17)^d(b,19)^b>>>10;u[a]=w+u[a-7]+L+u[a-16]|0}let{A:n,B:r,C:c,D:i,E:o,F:f,G:h,H:l}=this;for(let a=0;a<64;a++){const g=d(o,6)^d(o,11)^d(o,25),b=l+g+C(o,f,h)+N[a]+u[a]|0,w=(d(n,2)^d(n,13)^d(n,22))+I(n,r,c)|0;l=h,h=f,f=o,o=i+b|0,i=c,c=r,r=n,n=b+w|0}n=n+this.A|0,r=r+this.B|0,c=c+this.C|0,i=i+this.D|0,o=o+this.E|0,f=f+this.F|0,h=h+this.G|0,l=l+this.H|0,this.set(n,r,c,i,o,f,h,l)}roundClean(){y(u)}destroy(){this.destroyed=!0,this.set(0,0,0,0,0,0,0,0),y(this.buffer)}}class M extends F{A=x[0]|0;B=x[1]|0;C=x[2]|0;D=x[3]|0;E=x[4]|0;F=x[5]|0;G=x[6]|0;H=x[7]|0;constructor(){super(32)}}const V=U(()=>new M,v(1)),$=[\\\"shared_chat_snapshot_activated\\\",\\\"shared_chat_interactive_activated\\\",\\\"shared_chat_message_sent\\\"],E=\\\"agentsdock:shared-analytics-seen:v1\\\",A=new Set;function G(e,t,s=\\\"\\\"){try{if(!$.includes(e)||!/^\\\\/(?:interactive-chat\\\\/interactive_[a-f0-9]{32}|shared-chat\\\\/share_[a-f0-9]{32}|share\\\\/[A-Za-z0-9_-]{43})$/.test(t)||e===\\\"shared_chat_message_sent\\\"&&!/^[A-Za-z0-9_-]{16,128}$/.test(s)||navigator.doNotTrack===\\\"1\\\"||navigator.globalPrivacyControl||localStorage.getItem(\\\"agentsdock:analytics-consent:v1\\\")===\\\"denied\\\")return;const n=B(V(O(JSON.stringify([e,t,s])))),r=JSON.parse(sessionStorage.getItem(E)??\\\"[]\\\"),c=Array.isArray(r)?r.filter(f=>typeof f==\\\"string\\\"&&/^[a-f0-9]{64}$/.test(f)):[];if(A.has(n)||c.includes(n)||c.length>=4096)return;sessionStorage.setItem(E,JSON.stringify([...c,n])),A.add(n);const i=new AbortController,o=setTimeout(()=>i.abort(),5e3);try{fetch(\\\"https://api.mixpanel.com/track?ip=0\\\",{method:\\\"POST\\\",credentials:\\\"omit\\\",referrerPolicy:\\\"no-referrer\\\",headers:{\\\"Content-Type\\\":\\\"application/json\\\"},signal:i.signal,body:JSON.stringify([{event:e,properties:{token:\\\"66b4fef625e5750d5527870f0ca96d5e\\\",distinct_id:\\\"\\\",platform:\\\"shared_web\\\",time:Math.floor(Date.now()/1e3)}}])}).catch(()=>{}).finally(()=>clearTimeout(o))}catch{clearTimeout(o)}}catch{}}G(\\\"shared_chat_snapshot_activated\\\",location.pathname)})();\"")
+CSP_HASH = "mGoIxolAbIiMaBueHq0pZetv9HOC3PsCEy+QNKDYsaM="

package/server/side_questions.py

@@ -27,10 +27,11 @@ from fastapi import APIRouter, HTTPException, Request
 from fastapi.responses import JSONResponse
 
 
-MAX_QUESTION_CHARS = 8000
 MAX_HISTORY_ITEMS = 32
 MAX_HISTORY_CHARS = 60000
 MAX_REQUEST_BYTES = 512 * 1024
+# The streamed body limit bounds input; avoid a second, smaller model-text cap.
+MAX_QUESTION_CHARS = MAX_REQUEST_BYTES
 MAX_CONTEXT_CHARS = 60000
 MAX_LOG_BYTES = 4 * 1024 * 1024
 MAX_OUTPUT_BYTES = 1024 * 1024
@@ -369,11 +370,6 @@ class _NativeConversation:
     closed: bool = False
     timer: object = None
     close_task: asyncio.Task | None = None
-
-
-NATIVE_IDLE_SECONDS = 30 * 60
-
-
 class SideQuestions:
     def __init__(self, answer=None, *, native_factory=None, storage_path=None, notify=None, admission_check=None, runtime_settings_for_session=None):
         self.answer = answer
@@ -396,6 +392,43 @@ class SideQuestions:
     def active_work_labels(self):
         return [f"Side chat in {session_id}" for session_id in sorted(self.active_session_ids())]
 
+    def background_work_scopes(self):
+        handles = [(key[1], conversation.handle) for key, conversation in self.conversations.items()
+                   if not conversation.closed and conversation.handle is not None]
+        if self.synced is not None:
+            handles.extend((key[1], handle) for key, handle in self.synced.handles.items())
+        scopes = []
+        for session_id, handle in handles:
+            inspect = getattr(handle, "background_work_scope", None)
+            scope = inspect() if callable(inspect) else None
+            if scope is not None:
+                scopes.append((session_id, handle, scope))
+        return tuple(scopes)
+
+    async def prepare_background_work_snapshot(self, *, timeout_seconds=5.0):
+        scopes = self.background_work_scopes()
+
+        async def inspect(session_id, handle, _scope):
+            try:
+                active = await handle.has_background_work()
+            except Exception:
+                return f"Side chat provider state unknown in {session_id}"
+            return f"Side chat background work in {session_id}" if active else None
+
+        try:
+            values = await asyncio.wait_for(asyncio.gather(*(inspect(*scope) for scope in scopes)),
+                                            timeout=timeout_seconds)
+            labels = tuple(sorted(set(value for value in values if value)))
+        except asyncio.TimeoutError:
+            labels = tuple(f"Side chat provider state unknown in {session_id}" for session_id, _, _ in scopes)
+        return {"scopes": scopes, "labels": labels}
+
+    def background_work_labels_from_snapshot(self, snapshot):
+        scopes = self.background_work_scopes()
+        if snapshot.get("scopes", ()) != scopes:
+            return ["Side chat provider state changed during inspection"]
+        return list(snapshot.get("labels", ()))
+
     async def _close_conversation(self, conversation):
         conversation.closed = True
         if conversation.timer is not None:
@@ -415,7 +448,7 @@ class SideQuestions:
             await asyncio.shield(conversation.close_task)
 
     def _expire_conversation(self, key, conversation):
-        if self.conversations.get(key) is not conversation or conversation.busy:
+        if self.conversations.get(key) is not conversation or conversation.busy or not conversation.closed:
             return
         self.conversations.pop(key, None)
         task = asyncio.create_task(self._close_conversation(conversation), name="side-chat-expiry")
@@ -461,8 +494,9 @@ class SideQuestions:
             raise
         finally:
             conversation.busy = False
-            conversation.timer = asyncio.get_running_loop().call_later(
-                NATIVE_IDLE_SECONDS, self._expire_conversation, key, conversation)
+            if conversation.closed:
+                conversation.timer = asyncio.get_running_loop().call_later(
+                    RECEIPT_TTL_SECONDS, self._expire_conversation, key, conversation)
 
     async def close_conversation(self, owner, session_id, side_chat_id):
         key = (owner, session_id, side_chat_id)
@@ -473,7 +507,7 @@ class SideQuestions:
                 await self.cancel(*receipt_key)
         await self._close_conversation(conversation)
         conversation.timer = asyncio.get_running_loop().call_later(
-            NATIVE_IDLE_SECONDS, self._expire_conversation, key, conversation)
+            RECEIPT_TTL_SECONDS, self._expire_conversation, key, conversation)
 
     def _prune(self):
         now = time.monotonic()
@@ -874,8 +908,6 @@ class SyncedSideChats:
                     self.cleanup_tasks.discard(cleanup)
             if self.tasks.get(key) is asyncio.current_task():
                 self.tasks.pop(key, None)
-                if not self.stopping:
-                    self.timers[key] = asyncio.get_running_loop().call_later(NATIVE_IDLE_SECONDS, self._expire, key)
 
     async def _finish(self, key, side_chat_id, request_id, status, **result):
         async with self._lock(key):
@@ -1053,7 +1085,7 @@ def create_side_question_router(*, authorize, session_exists, runtime: SideQuest
         if not isinstance(request_id, str) or not IDENTIFIER.fullmatch(request_id):
             raise HTTPException(400, "Invalid side question request ID")
         if not isinstance(question, str) or not question.strip() or len(question) > MAX_QUESTION_CHARS:
-            raise HTTPException(400, "Question must contain 1 to 8000 characters")
+            raise HTTPException(400, f"Question must contain 1 to {MAX_QUESTION_CHARS} characters")
         try:
             question.encode("utf-8")
         except UnicodeEncodeError:
@@ -1152,7 +1184,7 @@ def create_side_question_router(*, authorize, session_exists, runtime: SideQuest
                 raise HTTPException(400, "Invalid side conversation ID")
         question = value["question"]
         if not isinstance(question, str) or not question.strip() or len(question) > MAX_QUESTION_CHARS:
-            raise HTTPException(400, "Question must contain 1 to 8000 characters")
+            raise HTTPException(400, f"Question must contain 1 to {MAX_QUESTION_CHARS} characters")
         try:
             question.encode("utf-8")
         except UnicodeEncodeError: