Upload 9 files

.codex/auth.json

@@ -0,0 +1,11 @@
+{
+  "auth_mode": "chatgpt",
+  "OPENAI_API_KEY": null,
+  "tokens": {
+    "id_token": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImIxZGQzZjhmLTlhYWQtNDdmZS1iMGU3LWVkYjAwOTc3N2Q2YiIsInR5cCI6IkpXVCJ9.eyJhdF9oYXNoIjoiZ2VZMnVaUmc0alR6MW9RbHhUVFRtUSIsImF1ZCI6WyJhcHBfRU1vYW1FRVo3M2YwQ2tYYVhwN2hyYW5uIl0sImF1dGhfcHJvdmlkZXIiOiJnb29nbGUiLCJhdXRoX3RpbWUiOjE3ODA3MzU1NTksImVtYWlsIjoiZGV2YXJzaGlhNUBnbWFpbC5jb20iLCJlbWFpbF92ZXJpZmllZCI6dHJ1ZSwiZXhwIjoxNzgwNzM5MTYxLCJodHRwczovL2FwaS5vcGVuYWkuY29tL2F1dGgiOnsiY2hhdGdwdF9hY2NvdW50X2lkIjoiY2UwN2I3YzgtZGZlYy00M2EyLWE1YzctNDc0YjVmYjgwNTU0IiwiY2hhdGdwdF9wbGFuX3R5cGUiOiJnbyIsImNoYXRncHRfc3Vic2NyaXB0aW9uX2FjdGl2ZV9zdGFydCI6IjIwMjUtMTEtMDRUMTU6Mzg6MzUrMDA6MDAiLCJjaGF0Z3B0X3N1YnNjcmlwdGlvbl9hY3RpdmVfdW50aWwiOiIyMDI2LTA3LTA0VDE1OjM4OjM1KzAwOjAwIiwiY2hhdGdwdF9zdWJzY3JpcHRpb25fbGFzdF9jaGVja2VkIjoiMjAyNi0wNi0wNlQwODo0NTo1OS42MDAzODUrMDA6MDAiLCJjaGF0Z3B0X3VzZXJfaWQiOiJ1c2VyLWR6UFF0TmtBMlkxakFBcmlVWUhWTHR2bCIsImdyb3VwcyI6W10sImxvY2FsaG9zdCI6dHJ1ZSwib3JnYW5pemF0aW9ucyI6W3siaWQiOiJvcmctMlg0SUZveUJLTVpWMktkTDhYUW9PeXJtIiwiaXNfZGVmYXVsdCI6dHJ1ZSwicm9sZSI6Im93bmVyIiwidGl0bGUiOiJjdXJzZW9md2l0Y2hlciJ9LHsiaWQiOiJvcmctdXYyQWd3VHE2VkRjNkZaZFpiSWd6aTN6IiwiaXNfZGVmYXVsdCI6ZmFsc2UsInJvbGUiOiJvd25lciIsInRpdGxlIjoiUGVyc29uYWwifV0sInVzZXJfaWQiOiJ1c2VyLWR6UFF0TmtBMlkxakFBcmlVWUhWTHR2bCJ9LCJpYXQiOjE3ODA3MzU1NjEsImlzcyI6Imh0dHBzOi8vYXV0aC5vcGVuYWkuY29tIiwianRpIjoiYjBjMjE4MjUtMWQwZi00YzgxLThjMGMtNWQzNzhiOGRlODU1IiwibmFtZSI6IkFkaXR5YSBEZXZhcnNoaSIsInJhdCI6MTc4MDczNTU0OSwic2lkIjoiY2E0NzQzZmEtMmZlNS00OGNhLWI1NmEtMjEwY2Y0M2RhNmJmIiwic3ViIjoiZ29vZ2xlLW9hdXRoMnwxMTExNTE3MzYzMTIzOTgyNjg3OTcifQ.XCd2DYKUpnHW7DJroTNN3CR2-WzxFsJrZNOtPSZ_lJd4-HnqVN9KjzIcaIHrZKKOLEjJQraavI-FV9pM_2OqP_utp7y69gsaHiuEQFeL8tPikM388EWijFqjlqcsq5JyruLP64L3YKcl63ODr5STy9fukgaIZZJq-o5QzgJrYvhQnAlH-V_2qRbRcIFVI7RyRnsyYToT2Dbvl4eo4dZun6a7Xkh3glznYR0VYHfL2iz3hFuKxRLbtV39ce_v2Nc2JXp1VHVEW-9j6p07X_bHRAY92E41xmpS5oB5FMpKCC9L7Dn_MfMtvzWVXtIhIrTctdJvp8vV5MxBhPWCkymd0obR-FwzfKLw6oZsBHKY6Vq5xfgM7LfrJ6M6cyw3No3EbbDTiYQ5nccE7YrGZDKMplp7kYAW36Fj3FKVlGlgcLhFTxtEZRUK3uGGs4hP1p8DUCCnAkWlNLqmwUjUwrpOkM8DyUKH2RXLjCq2sV_NsqXdDrE17WySYsfaLq8aaN-4uqbJfKSSpc5XE4ZeOL4MKMpTO6UCTDYIFvP0m4rFhdg5mgptF1-lJja0WovQEPq8LXRY6m9NXd8ZKpYDz3JatgYYJJVsuhV3CaMTQ51TjQpg0_pA6XRMTmr8jqz7HQcQ-jAfIbLl48EgD-qpqjJT2nTc4qHPxX24Xa4M9pPnNpw",
+    "access_token": "eyJhbGciOiJSUzI1NiIsImtpZCI6IjE5MzQ0ZTY1LWJiYzktNDRkMS1hOWQwLWY5NTdiMDc5YmQwZSIsInR5cCI6IkpXVCJ9.eyJhdWQiOlsiaHR0cHM6Ly9hcGkub3BlbmFpLmNvbS92MSJdLCJjbGllbnRfaWQiOiJhcHBfRU1vYW1FRVo3M2YwQ2tYYVhwN2hyYW5uIiwiZXhwIjoxNzgxNTk5NTYyLCJodHRwczovL2FwaS5vcGVuYWkuY29tL2F1dGgiOnsiY2hhdGdwdF9hY2NvdW50X2lkIjoiY2UwN2I3YzgtZGZlYy00M2EyLWE1YzctNDc0YjVmYjgwNTU0IiwiY2hhdGdwdF9hY2NvdW50X3VzZXJfaWQiOiJ1c2VyLWR6UFF0TmtBMlkxakFBcmlVWUhWTHR2bF9fY2UwN2I3YzgtZGZlYy00M2EyLWE1YzctNDc0YjVmYjgwNTU0IiwiY2hhdGdwdF9jb21wdXRlX3Jlc2lkZW5jeSI6Im5vX2NvbnN0cmFpbnQiLCJjaGF0Z3B0X3BsYW5fdHlwZSI6ImdvIiwiY2hhdGdwdF91c2VyX2lkIjoidXNlci1kelBRdE5rQTJZMWpBQXJpVVlIVkx0dmwiLCJsb2NhbGhvc3QiOnRydWUsInVzZXJfaWQiOiJ1c2VyLWR6UFF0TmtBMlkxakFBcmlVWUhWTHR2bCJ9LCJodHRwczovL2FwaS5vcGVuYWkuY29tL3Byb2ZpbGUiOnsiZW1haWwiOiJkZXZhcnNoaWE1QGdtYWlsLmNvbSIsImVtYWlsX3ZlcmlmaWVkIjp0cnVlfSwiaWF0IjoxNzgwNzM1NTYxLCJpc3MiOiJodHRwczovL2F1dGgub3BlbmFpLmNvbSIsImp0aSI6ImIyNzQ5MmY1LTczODktNDRkYi1hMWI1LTU1OWRhZmFlMmFkNCIsIm5iZiI6MTc4MDczNTU2MSwicHdkX2F1dGhfdGltZSI6MTc4MDczNTU1OTYwMCwic2NwIjpbIm9wZW5pZCIsInByb2ZpbGUiLCJlbWFpbCIsIm9mZmxpbmVfYWNjZXNzIiwiYXBpLmNvbm5lY3RvcnMucmVhZCIsImFwaS5jb25uZWN0b3JzLmludm9rZSJdLCJzZXNzaW9uX2lkIjoiYXV0aHNlc3NfdVNNdGphSWJacVZqQW5xT254VzJWRUowIiwic2wiOnRydWUsInN1YiI6Imdvb2dsZS1vYXV0aDJ8MTExMTUxNzM2MzEyMzk4MjY4Nzk3In0.KvxgZQwe2_bSPwwIRsG0Xg5_GSWHdQru2xtVPXY1GOuYNaMgdbuaO6CDTtF1aEfhCXfzNpu1TTFvEMkHlsYCmZ_OK5leY3e4a01sQ7lUNdVCJ50E0QFsPxxfqPkziip7yzb76d_ufPwgkw0xUa_ierxNnc-fuaw2OgveQndp4yRT6u4WuHrmZfKVXgK9WgoZYiggmEzL-4D4SKpRv8T-IwlkT25J9hT1tb_Sdt19YLue2Xhpuaq0xtW6_G7g1gKp0CjSQGSF8-xzVfc6kJkqAnK_BQ-i3izQHFz2keFeSIRMoITA27PeDDKWhO0WnKR4IkWEEu8tOaLHO10GZMmi5P1vGIaJMbGM8USTVSGLFZtqZ1CAxvWxd7xp6QTdtXsjmwdmID4CrxvU-RgAReXqfcUp3dX5FxfFeWahwNo5d19UlbGVVz7gJ999rlSg2EQhcWy39omje8nifzEenEpnJX15tJ-AqCv6Wy2x68-STrZbmkPZAkPtFvRIRlsO1hcPnWak1wQ9sR2FhSyoCb8YWgVjghNKe6XKeTtjnJeZrg6gQ04q_OBZ62rQcqwIiyIJEg6pZGOEyHot7sL-Z1v7068MVZWUh4psa_WNb93m8nWMwfRI_7IrDhjywhHhnwB-iB6CfLJbhsWOa6wxNeAoAJCDe43pV2Ida0qU0wY0sbA",
+    "refresh_token": "rt.1.AAArhYuyl3xt4V7ysuMdJufBWZQKMmzT7yUQu3r_5GH74-rKwSqVqFqveZ4b0R0BrV6eYZ-3U2eRkXF95pqlWczEQmarc-hnZMhfYvAqJt-HCLbVW2_OOjNq00Ka20D2bHRtTJ1Mdktd59oSVbhY7ugyJJWXXnQtp5O3URFezLJqnGUFgV55VnfjIrVSdFNEAkzSyfy1-UbumyAELJcxKyRiWEUezEgURE8bVnA01dPgbh_8VeuGFt1zlZURqXCTm7ugatfhAj69qrVhA0JCp_QygWdRqLcvD_GQLnMSWPaOzsNEsmogX2MWAsYFByOdnKk",
+    "account_id": "ce07b7c8-dfec-43a2-a5c7-474b5fb80554"
+  },
+  "last_refresh": "2026-06-06T08:46:04.174823900Z"
+}

.codex/config.toml

@@ -0,0 +1 @@
+personality = "pragmatic"

app.py

@@ -17,11 +17,13 @@ Sessions: pass `X-Session-Id` (or the OpenAI `user` field) for a persistent
 workdir at /data/sessions/<id>/workspace + Codex thread resume. None -> ephemeral.
 """
 
+import asyncio
 import json
 import os
 import re
 import time
 import uuid
+from contextlib import aclosing
 from pathlib import Path
 from typing import Any, Optional
 
@@ -51,11 +53,68 @@ API_TOKEN = os.environ.get("API_TOKEN", "")  # HF secret; if empty, auth is OPEN
 DEFAULT_SANDBOX = os.environ.get("CODEX_SANDBOX", "workspace-write")  # or read-only
 CODEX_MODEL = os.environ.get("CODEX_MODEL", "").strip()  # optional override
 READ_TIMEOUT = float(os.environ.get("CODEX_TIMEOUT", "180"))  # per-output-gap secs
+# Max Codex turns running at once across all sessions (each is a heavy process).
+MAX_CONCURRENCY = int(os.environ.get("CODEX_MAX_CONCURRENCY", "4"))
+# How long a request may wait in the queue before we give up with 429.
+QUEUE_TIMEOUT = float(os.environ.get("CODEX_QUEUE_TIMEOUT", "90"))
 DEFAULT_MODEL_NAME = "codex"
 
 SESSION_ID_RE = re.compile(r"[^A-Za-z0-9_.-]")
 
-app = FastAPI(title="Codex-as-API", version="2.0.0")
+app = FastAPI(title="Codex-as-API", version="2.1.0")
+
+# --------------------------------------------------------------------------- #
+# Concurrency control
+#   - _GLOBAL_SEM caps total simultaneous Codex processes (resource guard).
+#   - _SESSION_LOCKS serialize requests that share a session id, so two calls
+#     never resume/operate on the same thread + workspace at once (corruption).
+#   Different sessions still run fully in parallel (up to the global cap).
+# --------------------------------------------------------------------------- #
+_GLOBAL_SEM = asyncio.Semaphore(MAX_CONCURRENCY)
+_SESSION_LOCKS: dict[str, asyncio.Lock] = {}
+
+
+def _session_lock(session_id: Optional[str]) -> Optional[asyncio.Lock]:
+    if not session_id:
+        return None  # ephemeral request: unique workspace, no shared state
+    # setdefault is atomic between awaits in asyncio's single thread.
+    return _SESSION_LOCKS.setdefault(session_id, asyncio.Lock())
+
+
+class _TurnGuard:
+    """Acquire (session lock -> global slot) with a bounded wait; release both."""
+
+    def __init__(self, session_id: Optional[str]):
+        self._lock = _session_lock(session_id)
+        self._have_lock = False
+        self._have_slot = False
+
+    async def acquire(self) -> None:
+        loop = asyncio.get_event_loop()
+        deadline = loop.time() + QUEUE_TIMEOUT
+        try:
+            if self._lock is not None:
+                await asyncio.wait_for(
+                    self._lock.acquire(), timeout=QUEUE_TIMEOUT
+                )
+                self._have_lock = True
+            remaining = max(0.1, deadline - loop.time())
+            await asyncio.wait_for(_GLOBAL_SEM.acquire(), timeout=remaining)
+            self._have_slot = True
+        except (asyncio.TimeoutError, TimeoutError):
+            self.release()
+            raise HTTPException(
+                status_code=429,
+                detail="Server busy (concurrency/session limit). Retry shortly.",
+            )
+
+    def release(self) -> None:
+        if self._have_slot:
+            self._have_slot = False
+            _GLOBAL_SEM.release()
+        if self._have_lock:
+            self._have_lock = False
+            self._lock.release()
 
 
 # --------------------------------------------------------------------------- #
@@ -197,6 +256,8 @@ async def health():
         "auth_required": bool(API_TOKEN),
         "sandbox": DEFAULT_SANDBOX,
         "engine": "app-server",
+        "max_concurrency": MAX_CONCURRENCY,
+        "active_sessions": len(_SESSION_LOCKS),
     }
 
 
@@ -233,6 +294,11 @@ async def chat_completions(
     if not prompt:
         raise HTTPException(status_code=400, detail="Empty prompt after parsing.")
 
+    # Acquire concurrency guard BEFORE starting work, so we can fail fast with
+    # 429 (for streaming, headers are sent once we return — can't 429 later).
+    guard = _TurnGuard(session_id)
+    await guard.acquire()
+
     turn = run_turn(
         codex_bin=CODEX_BIN,
         codex_home=CODEX_HOME,
@@ -246,8 +312,9 @@ async def chat_completions(
 
     if req.stream:
         include_usage = bool((req.stream_options or {}).get("include_usage"))
+        # _sse_stream owns the guard from here and releases it when done.
         return StreamingResponse(
-            _sse_stream(turn, model_name, session_dir, include_usage),
+            _sse_stream(turn, model_name, session_dir, include_usage, guard),
             media_type="text/event-stream",
         )
 
@@ -255,22 +322,29 @@ async def chat_completions(
     content_parts: list[str] = []
     usage = {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}
     try:
-        async for evt in turn:
-            if evt["type"] == "delta":
-                content_parts.append(evt["text"])
-            elif evt["type"] == "final":
-                if evt.get("text"):
-                    content_parts = [evt["text"]]  # authoritative full text
-                usage = evt.get("usage", usage)
-                _persist_thread(session_dir, evt.get("thread_id"))
+        async with aclosing(turn) as t:
+            async for evt in t:
+                if evt["type"] == "delta":
+                    content_parts.append(evt["text"])
+                elif evt["type"] == "final":
+                    if evt.get("text"):
+                        content_parts = [evt["text"]]  # authoritative full text
+                    usage = evt.get("usage", usage)
+                    _persist_thread(session_dir, evt.get("thread_id"))
     except CodexError as e:
         raise HTTPException(status_code=502, detail=f"Codex engine: {e}")
+    finally:
+        guard.release()
 
     return JSONResponse(_completion_payload("".join(content_parts), model_name, usage))
 
 
-async def _sse_stream(turn, model: str, session_dir, include_usage: bool):
-    """OpenAI-compatible SSE: role chunk, live content deltas, finish, [DONE]."""
+async def _sse_stream(turn, model: str, session_dir, include_usage: bool, guard):
+    """OpenAI-compatible SSE: role chunk, live content deltas, finish, [DONE].
+
+    Owns `guard`: releases the concurrency slot/session lock when the turn ends
+    OR the client disconnects (aclosing -> run_turn finally kills the process).
+    """
     cid = f"chatcmpl-{uuid.uuid4().hex}"
     created = int(time.time())
 
@@ -289,15 +363,18 @@ async def _sse_stream(turn, model: str, session_dir, include_usage: bool):
     yield chunk({"role": "assistant"})
     final_usage = {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0}
     try:
-        async for evt in turn:
-            if evt["type"] == "delta":
-                yield chunk({"content": evt["text"]})
-            elif evt["type"] == "final":
-                final_usage = evt.get("usage", final_usage)
-                _persist_thread(session_dir, evt.get("thread_id"))
+        async with aclosing(turn) as t:
+            async for evt in t:
+                if evt["type"] == "delta":
+                    yield chunk({"content": evt["text"]})
+                elif evt["type"] == "final":
+                    final_usage = evt.get("usage", final_usage)
+                    _persist_thread(session_dir, evt.get("thread_id"))
     except CodexError as e:
         # Surface the error inside the stream, then close cleanly.
         yield chunk({"content": f"\n\n[codex error: {e}]"})
+    finally:
+        guard.release()
 
     yield chunk({}, finish="stop")
     if include_usage: