ChatGPT fails on Python and ZIP and Throws ClientError

Environment

  • Surface: Web
  • Browser or app version: Latest Web Version
  • Affected feature and model, if relevant: Python, Zip

Bug

Working with ChatGPT Premium on Reverse Engineering something

Chat me:
ok, i got another session made, can you decompile them now or does this still not work? if it does not work, whats causing it, and can you fix it or do we need to make a new chat?

ChatGPT:
Worked for 4m 25s
Analysis paused
Analysis errored
Analysis errored

It still does not work in this chat, but I can now pin down the cause much more confidently.

Your new upload itself arrived correctly: redacted_capture(20260927-024126).zip is 91,567,357 bytes. The failure is not currently evidence of a corrupt ZIP.

I tested three things:

  • opening the exact mounted ZIP path with Python → ClientError
  • opening it through the container runtime → ClientError
  • running the completely unrelated Python command print(“hello”) → the same ClientError

So the problem is the code-execution sandbox for this conversation, not ZIP decompression, not zipfile, and not your capture. The execution environment is failing before my code even starts.

Can I fix it here?

Unfortunately I don’t have a control that restarts or resets this chat’s execution sandbox. We’ve now seen the same failure repeatedly across many turns, so I would start a new chat. That should give us a fresh Python/container runtime and is the best chance of clearing it.

You do not need to redo the live-server capture.

In the new chat:

  1. Upload redacted_capture(20260927-024126).zip.
  2. Tell me:

Continue my redacted-server reverse-engineering project. The previous chat’s Python/container sandbox was broken with ClientError even on print(“hello”). Please first test this ZIP with zipfile.testzip(), list/extract it, then analyze/decode the new live-server session. We are currently at Stage28 after completing the 179-recipe census.

so i opened a completely new Chat and Uploaded my Files, but i get this:

Worked for 4m 11s
Analysis errored
Analysis errored

The problem is still the execution environment, not evidence of a bad ZIP. I tried the normal container, private Python, and the separate visible Python runtime. All three currently fail with ClientError even on a trivial command. The file service can store/read the ZIP itself but does not expose files inside a ZIP, so I cannot honestly claim any packet findings from 030445 yet.

Reproduction

Steps or a minimal example prompt:

Asking ChatGPT to unpack a few *.ZIP Files and Examine Python Scripts and Java Files, but it seems ChatGPT’s Python is completely Broken, he cant even unpack the ZIP Files.

Diagnostics

Exact error or screenshot:

print(“python-ok”)
import os, zipfile, json, pathlib, re, struct, hashlib, collections, statistics
paths = [
“/mnt/data/Pasted text(20260927-030017).txt”,
“/mnt/data/bin(1).zip”,
“/mnt/data/redacted(3).zip”,
“/mnt/data/redacted_capture(20260927-030445).zip”
]
[(p, os.path.exists(p), os.path.getsize(p) if os.path.exists(p) else None) for p in paths]

Encountered exception: <class ‘caas.internal.errors.ClientError’>.

from pathlib import Path
import zipfile, os, json, hashlib, collections, re, struct

paths = [
Path(“/mnt/data/recovered_uploads/redacted_capture(20260927-030445).zip”),
Path(“/mnt/data/recovered_uploads/bin(1).zip”),
Path(“/mnt/data/recovered_uploads/redacted(3).zip”),
]
print(“visible-python-ok”)
for p in paths:
print(“\nZIP:”, p.name, “exists=”, p.exists(), “size=”, p.stat().st_size if p.exists() else None)
if p.exists():
with zipfile.ZipFile(p) as z:
print(" testzip:“, z.testzip())
print(” entries:“, len(z.infolist()))
for zi in z.infolist()[:40]:
print(f” {zi.file_size:10d} {zi.filename}“)
if len(z.infolist()) > 40:
print(” …")

Encountered exception: <class ‘caas.internal.errors.ClientError’>.

When it happened (with timezone) and how often: 05:21 Sunday, 27 September 2026 (CEST), on 2 Different Chats

Same issue here. It’s been happening to me for several hours. I tried starting new chats and even switching projects, but the ClientError still happens whenever ChatGPT tries to use Python or work with ZIP files. Nothing seems to fix it on my side.

can we get a fix for this, im stuck forever on working on my projects

I am experiencing a persistent failure of ChatGPT’s code/container execution environment in a long-running technical conversation.

The failure appears to occur at the execution/runtime service layer, before the requested shell or Python process actually starts.

Main error

Execution calls repeatedly fail with:

ClientError

and the underlying exception shown by ChatGPT is:

caas.internal.errors.ClientError

In the UI I have also seen:

Error in input stream

Affected execution mechanisms

The issue is not limited to one command, programming language, working directory, or file.

ChatGPT tested multiple independent execution entry points and all of them failed in the same way:

  • normal container/shell execution

  • a fresh interactive shell

  • trivial /bin/echo / true-style health checks

  • private Python execution

  • user-visible Python/Jupyter execution

The failure occurs even for commands that do not access any project files.

For example, previously working tests equivalent to:

/bin/echo test

or:

print("python-visible-ok")

now fail before producing any command output.

This strongly suggests the problem is not an error inside the user’s code, ZIP archive, Python script, shell command, filesystem path, or working directory.

Context before the failure

This conversation is analyzing large game-network capture archives for a private-server reverse-engineering project.

One relevant archive is approximately 115 MB compressed and contains about 400,000 packet files plus a decoded.jsonl file.

Before the runtime became unavailable, ChatGPT successfully:

  1. materialized the uploaded ZIP into /mnt/data

  2. accessed it with native unzip

  3. listed ZIP members successfully

  4. streamed decoded.jsonl out of the ZIP

  5. created:

/mnt/data/salem_work/extracted_sep28/decoded.jsonl

  1. verified the extracted file as:
  • 64,701,802 bytes

  • 400,954 lines

A successful command produced output similar to:

400954 /mnt/data/salem_work/extracted_sep28/decoded.jsonl

and successfully read the beginning of the JSONL.

Therefore the archive itself had already been demonstrated to be readable and valid.

Interesting behavior / intermittent recovery

The failure has been intermittent.

At one point the ordinary container execution backend was failing, while the alternate user-visible Python/Jupyter runtime still worked.

ChatGPT successfully used that alternate runtime to launch native unzip as a subprocess and extract the JSONL.

Shortly afterward the normal container also became functional again.

Later, however, both execution backends began returning the same caas.internal.errors.ClientError.

At the moment, every available execution method appears affected.

This means the failure can transition between:

  1. container unavailable, alternate Python runtime available

  2. both available

  3. all execution runtimes unavailable

without changes to the user’s files or commands.

Why this does not appear to be resource-specific

The same failure occurs with:

  • no ZIP access

  • no large file access

  • no subprocess pipeline

  • no special working directory

  • trivial Python

  • trivial shell commands

Attempts with fresh shell sessions and minimal commands also fail.

Therefore the large archive may have coincided with the issue, but it does not appear to be necessary to reproduce it.

Files/search systems still work

Interestingly, ChatGPT’s non-execution file/library retrieval functionality continues working.

It is still able to:

  • search files in the ChatGPT Library

  • read indexed text files

  • retrieve source-code snippets

while container/Python execution fails.

This may help isolate the affected backend: the file/library service remains functional while the CAAS/code-execution service is unavailable.

Impact

This blocks all programmatic analysis of the user’s uploaded capture.

The conversation requires shell/Python processing of a roughly 65 MB JSONL file containing approximately 401,000 records.

The file has already been extracted successfully, so the work could resume immediately if the execution runtime became available.

The assistant cannot currently continue because all execution calls fail before the process starts.

What has already been ruled out

The following have effectively been ruled out as the primary cause:

  • corrupted ZIP

  • malformed JSONL

  • incorrect archive path

  • parentheses/spaces in filename

  • bad shell quoting

  • bad current working directory

  • Python zipfile behavior

  • memory-heavy ZIP parsing

  • a particular Python script

  • a particular shell command

There was one normal shell-quoting error while testing a filename containing parentheses, but after correctly quoting the path the archive extraction succeeded. That error is separate from the persistent caas.internal.errors.ClientError.

Suggested investigation

It would be useful to inspect the CAAS/execution-session logs for this conversation/account around September 28, 2026.

In particular, please check:

  • container allocation/start failures

  • execution-session lifecycle/state

  • failed process-launch requests

  • Jupyter/kernel allocation failures

  • communication/input-stream failures between ChatGPT and the execution backend

  • whether a stale/dead execution session is being reused

  • whether /mnt/data session state or a previous large-file operation caused the execution environment to enter an unrecoverable state

  • whether there are quota/resource/container scheduling failures that are being surfaced only as the generic caas.internal.errors.ClientError

If internal request/runtime IDs are available to Support from the conversation logs, those should hopefully provide a more specific backend exception.

Reproduction currently

Within this conversation:

  1. Ask ChatGPT to execute a trivial shell command.

  2. The request fails with caas.internal.errors.ClientError.

  3. Ask ChatGPT to execute trivial private Python.

  4. Same failure.

  5. Ask ChatGPT to execute trivial user-visible Python.

  6. Same failure.

No project files need to be accessed for the failure to occur.

Desired behavior

A new or repaired execution/container session should be allocated so that shell and Python commands can execute normally again, ideally while preserving access to the conversation’s /mnt/data files.

If preserving the existing container is impossible, a fresh execution environment would still be sufficient because the original uploaded ZIP files remain available in the conversation/library and can be materialized again.

Possibly related, but my failure appears to happen earlier, during reasoning/context recovery rather than inside Python/container execution.

Environment

  • ChatGPT Plus
  • Web, Microsoft Edge on Windows
  • 29 September 2026
  • GPT-5.6 Sol

Symptoms

  • Existing long-running development chat showed Analysis paused.
  • Later turns displayed Analyzed repeatedly on separate lines, with no substantive response.
  • Some attempts then showed only the pulsing activity circle and never progressed.
  • I reproduced the same behaviour in a brand-new chat, so this does not appear to be caused solely by a long conversation.
  • Both Instant and Medium thinking modes were affected.
  • The fresh chat contained only a handover/seed prompt, one previous-build ZIP, and two small screenshots.

Important detail

I manually stopped one stalled turn. ChatGPT then reported from its execution trail:

“I did not get as far as modifying Build 100, running tests, or packaging a new build. I stalled in reasoning/context-recovery.”

So in this case the turn appears to be stalling before file modification or tool execution begins, rather than failing while Python/container code is already running.

Observed pattern

The system intermittently recovers and can complete small graphical/code changes successfully, then later falls back into the same stalled state.

This looks related to the execution/orchestration problems reported here, but possibly at an earlier stage in the pipeline. A fresh chat did not reliably clear it.

Happy to provide screenshots/timestamps if useful.

This is still an issue. I’ve hit a persistent ChatGPT code-execution/file-generation problem while developing a Python/OpenCV/YOLO application in a ChatGPT Project.

The project has been developed iteratively through several working Python versions. ChatGPT had previously been able to read the existing source, modify it, generate a new .py file, syntax/compile-check it, and provide the resulting file for download. We successfully used that workflow through development of the current V6.2 detector.

When we attempted to generate V6.3, the execution environment started failing. ChatGPT could still read and analyse the source code, logs, CSV output, screenshots and other project files, and could specify the required code changes, but attempts to actually execute Python or generate/validate the new Python file failed with execution/runtime errors. Some attempts reported the code execution state resetting or a client error; others simply remained stuck on “Working” for a very long time.

We tried to isolate whether the problem was caused by the existing conversation. A new chat inside the same Project also failed, suggesting it wasn’t just a corrupted conversation. We then tried a normal chat outside the Project, where execution initially worked: it successfully generated V6.2 and performed Python compile/AST/static checks. That demonstrated the source code itself and the requested workflow were valid.

Unfortunately, subsequent attempts to generate V6.3 outside the Project also became unreliable. We tried fresh chats, reduced the amount of evidence supplied, supplied the authoritative V6.2 source plus logs/CSV separately, and even removed video analysis as a prerequisite so the task was simply “modify this known-good Python file according to this specification, create V6.3 and compile-check it.” Those attempts either failed execution, had file/video-transfer problems, or sat indefinitely on “Working.”

Importantly, the Python application itself is not what is failing here. V6.2 compile-checks and runs successfully on the local Mac and has been running against the live camera feed for hours. It is generating logs, CSV data, evidence images and Pushover notifications normally. We also have a well-defined V6.3 specification based on live testing. The blocker is specifically getting ChatGPT’s execution/file-generation environment to produce and validate the next .py file.

We have now set up an hourly ChatGPT task that attempts a minimal execution test: create a small text file, read it back, create a trivial Python file and compile-check it. It stays silent while execution remains unavailable and is supposed to notify us when the complete test succeeds.

Current status: the Project and all the engineering evidence remain intact, and ChatGPT can continue analysing the project normally, but reliable code execution/file generation is still unavailable. The next version is effectively waiting on that environment rather than on further debugging or design work.

This has persisted across multiple chats and enough different test cases that it doesn’t appear to be a single bad prompt, oversized video, broken Python source file, or one stalled conversation. The particularly frustrating part is that the coding project itself is currently running successfully—the hosted execution environment needed to produce the next revision is the thing preventing development from continuing.

Still going on, now constantly for 48h without any recovery…

retry?

Worked for 2m 13s

Retried again just now, and the execution backend is still failing immediately with the same ClientError before it can even run a basic shell command.

So it still hasn’t recovered. Your correct 447 MB xxxx ZIP is still available, and you do not need to upload it again.