App Server explodes websocket frames with mandatory generated image data #21988

Activity

1. github-actions

   added

   bugSomething isn't workingSomething isn't working

   appIssues related to the Codex desktop appIssues related to the Codex desktop app

   app-serverIssues involving app server protocol or interfacesIssues involving app server protocol or interfaces

   imagen

   performance

   on May 10, 2026
2. github-actions commented on May 10, 2026

   

   github-actionsbot

   on May 10, 2026 – with GitHub Actions

   Contributor

   More actions

   Potential duplicates detected. Please review them and close your issue if it is a duplicate.

   • Codex Desktop becomes unusable on long active threads due to app-server/renderer memory and TRACE log churn #21134
   • Codex App freezes / becomes Not Responding when opening image-heavy projects with many generated images #21232
   • Large active session causes global freezes with no UI attribution #21948
   • Codex Desktop freezes when opening mini/popout windows; image-heavy histories are much worse than long text-heavy sessions #20544

   Powered by Codex Action
3. etraut-openai

   removed

   appIssues related to the Codex desktop appIssues related to the Codex desktop app

   imagen

   on May 10, 2026
4. DrSeedon commented on Aug 24, 2026

   

   DrSeedon

   on Aug 24, 2026

   More actions

   Linux/stdin-stdout reproduction: default thread/resume emits a 23 MB JSONL record

   I reproduced the same generated-image frame amplification through the app-server's stdio transport,
   where it becomes a connection/recovery failure rather than only a RAM/traffic problem.

   Environment:

   • codex-cli 0.149.0
   • Linux 7.0.0-30-generic x86_64
   • codex app-server --stdio (newline-delimited JSON-RPC)
   • ChatGPT-auth production thread, replayed from a disposable clone without auth.json

   The stored thread had exactly seven completed image_generation_end records. Their serialized
   rollout records totaled 22,612,401 bytes; the corresponding paired large tool-output records totaled
   22,608,258 bytes. No prompt, path, image bytes, or raw history was retained in the measurement.

   Request sequence:

   1. initialize, request id=1
   2. initialized
   3. thread/resume, request id=2, default parameters (excludeTurns absent)

   Measured stdout records:

   Record	Bytes
   initialize response (id=1)	214
   configWarning	500
   remoteControl/status/changed	207
   thread/status/changed	149
   thread/resume response (id=2)	23,159,303

   The oversized record is a response envelope (id=2, no method), not an item/turn notification.
   A client with a bounded 16 MiB line reader cannot parse the envelope or resolve the pending resume
   request. Discarding the record is not recovery because this is the only required response.

   The existing experimental API is an effective control. With
   initialize.capabilities.experimentalApi=true and thread/resume(excludeTurns=true), the exact same
   thread returned a 5,104-byte id=2 response (99.978% smaller). It retained the matching thread id,
   status={"type":"idle"}, preview and runtime/config metadata, and returned turns=[]. Without the
   initialize capability, 0.149.0 correctly returned -32600:
   thread/resume.excludeTurns requires experimentalApi capability.

   This is consistent with the current source comment that thread/resume can include large MCP and
   image-generation payloads, while response redaction is limited to the two ChatGPT mobile remote
   client names:
   https://github.com/openai/codex/blob/main/codex-rs/app-server/src/request_processors/thread_resume_redaction.rs

   Expected behavior:

   • Default resume/read responses should not inline unbounded generated-image bytes into one transport
     frame.
   • Large binary results should be omitted, externalized, or referenced by saved path/content id.
   • The bounded metadata-only resume contract should remain available without reconstructing full turn
     payloads, and clients should be able to negotiate it deterministically.

   Related current report: #39148 shows read_thread returning multi-megabyte imageGeneration.result
   despite includeOutputs:false and maxOutputCharsPerItem.

   We mitigated the client side by negotiating experimentalApi, using excludeTurns:true for stored
   native resumes, and treating any lost oversized JSONL record as terminal transport corruption rather
   than continuing with unresolved request correlation
   (metadata-only resume and typed failure).
   This avoids the crash, but it does not remove the upstream unbounded default response.

   Minimal response-size scanner

   Run only against a disposable CODEX_HOME containing an image-heavy test thread. It does not start a
   model turn and never retains the response payload; it reports envelope id/method and byte length.

   import asyncio
   import json
   import os
   import re
   import sys
   
   
   async def main() -> None:
       thread_id = sys.argv[1]
       exclude_turns = "--exclude-turns" in sys.argv[2:]
       proc = await asyncio.create_subprocess_exec(
           "codex", "app-server", "--stdio",
           stdin=asyncio.subprocess.PIPE,
           stdout=asyncio.subprocess.PIPE,
           stderr=asyncio.subprocess.DEVNULL,
           env=os.environ.copy(),
       )
   
       async def send(payload: dict) -> None:
           proc.stdin.write((json.dumps(payload, separators=(",", ":")) + "\n").encode())
           await proc.stdin.drain()
   
       buffered = b""
   
       async def next_record() -> tuple[int | None, str | None, int]:
           nonlocal buffered
           size = 0
           prefix = bytearray()
           while True:
               if b"\n" in buffered:
                   part, buffered = buffered.split(b"\n", 1)
                   size += len(part) + 1
                   prefix.extend(part[: max(0, 1024 - len(prefix))])
                   text = prefix.decode("utf-8", "replace")
                   rid = re.search(r'"id"\s*:\s*(\d+)', text)
                   method = re.search(r'"method"\s*:\s*"([^"]+)"', text)
                   return (
                       int(rid.group(1)) if rid else None,
                       method.group(1) if method else None,
                       size,
                   )
               if buffered:
                   size += len(buffered)
                   prefix.extend(buffered[: max(0, 1024 - len(prefix))])
                   buffered = b""
               buffered = await proc.stdout.read(65536)
               if not buffered:
                   raise EOFError("app-server closed stdout")
   
       capabilities = {"experimentalApi": True} if exclude_turns else {}
       await send({
           "method": "initialize",
           "id": 1,
           "params": {
               "clientInfo": {"name": "resume-size-probe", "title": "probe", "version": "1"},
               "capabilities": capabilities,
           },
       })
       while (await next_record())[0] != 1:
           pass
       await send({"method": "initialized", "params": {}})
       params = {"threadId": thread_id}
       if exclude_turns:
           params["excludeTurns"] = True
       await send({"method": "thread/resume", "id": 2, "params": params})
       while True:
           record_id, method, size = await next_record()
           if record_id == 2:
               print({"id": record_id, "method": method, "bytes": size})
               break
       proc.terminate()
       await proc.wait()
   
   
   asyncio.run(main())

   Expected on the measured test thread:

   $ CODEX_HOME=/path/to/disposable-copy python resume_size.py THREAD_ID
   {'id': 2, 'method': None, 'bytes': 23159303}
   $ CODEX_HOME=/path/to/disposable-copy python resume_size.py THREAD_ID --exclude-turns
   {'id': 2, 'method': None, 'bytes': 5104}
   
5. DrSeedon commented on Aug 24, 2026

   

   DrSeedon

   on Aug 24, 2026

   More actions

   I also opened #40362 for the distinct bounded-stdio/RPC-recovery failure mode: the mandatory thread/resume response exceeds a line-framed client limit, so response correlation is lost and reconnect repeats the same frame. The measurements and scanner above are mirrored there.