core: request accumulates 52 images, exceeds provider max of 50 #47721

Activity

1. github-actions

   assigned

   neriousy

   on Sep 7, 2026
2. github-actions commented on Sep 7, 2026

   

   github-actionsBot

   on Sep 7, 2026 – with GitHub Actions

   Contributor

   More actions

   This issue might be a duplicate of existing issues. Please check:

   • [BUG] Agent accumulated 51 images via read tool, session bricked by provider 50-image count limit with no recovery #47487: Agent accumulated 51 images via read tool, session bricked by provider 50-image count limit with no recovery — nearly identical scenario (read tool accumulating images, session stuck at the 50-image cap)
   • Image-count 400s (Azure: "Exceeded maximum number of images (50)") are not classified as context overflow, so media-strip compaction never triggers #39677: Image-count 400s are not classified as context overflow, so media-strip compaction never triggers — same root cause (provider image limit not triggering compaction/recovery)
3. opencode-agent

   added

   2.0

   on Sep 7, 2026
4. Sugamsss commented on Oct 14, 2026

   

   Sugamsss

   on Oct 14, 2026

   More actions

   We ran into this on 2.0 as well and traced the exact core mechanism on current dev:

   1. boundImages() in packages/core/src/session/model-request.ts triggers only on bytes (>25 MiB). It enforces no count check, so 51 small screenshots (e.g. 50 KB each) still get sent and trigger provider 400 errors.
   2. packages/ai/src/provider-error.ts doesn’t classify image-count errors as context overflow, so automatic recovery never runs.
   3. When core does remove an image, its placeholder is a blind stub without the file path, so the model cannot re-read it.

   Proposed fix:

   • Add an image count ceiling to boundImages().
   • Keep the file path in the removal placeholder so the model has actionable recall via read.
   • Add image-count patterns to provider-error.ts so recovery kicks in.

   We have a working standalone implementation in opencode-prune-images and have this patch ready if you would like a core PR.
5. neriousy

   marked pdf: multiple PDF reads accumulate images exceeding provider limit, causing unrecoverable error #48781 as a duplicate of this issue on Oct 20, 2026
6. opencodejr commented on Oct 28, 2026

   

   opencodejrBot

   on Oct 28, 2026

   Contributor

   More actions

   Thanks for the detailed report. I reproduced this on @opencode/[email protected] with a simulated model.

   Steps:

   • The agent read about 50 tiny PNGs (a few bytes each, so nowhere near the image-size limit) one at a time over two prompts.
   • Each model request carried every image read so far: 1, 2, … 50, then 51. OpenCode only limits the total size of images in a request, not how many there are.
   • A mock provider answered the 51-image request with the error from your report. OpenCode showed Error: Upstream request failed: [invalid_request_error] request contains 51 images, exceeding the maximum of 50 allowed per request and didn't compact or drop old images, so the session can't recover. The screenshot below shows it.

   In an earlier run that stopped at 50 images, a follow-up text-only prompt was sent with all 50 images again. That's why plain text prompts fail once a session is over the limit.

   I ran out of time before re-running this on the latest dev, but the code there still has no count limit. Open PR #59303 targets this problem. Related: #55060 (same problem on 2.0, closed as a duplicate of this issue), #47487 and #39677 (the same problem on v1), #48781 (the same thing through PDF pages).

   

   Reproduction script (drive.ts)

   // Repro for #47721: v2 sends every image in history to the model, with no count cap.
   // 52 tiny PNGs (~70 bytes each, far below the 25 MiB byte bound) are read one by one,
   // then a plain text prompt is sent. We count the images carried in each model request.
   import { Effect, Stream } from "effect"
   import { Llm, OpenCodeDriver } from "opencode-drive"
   
   const N = Number(process.env.N ?? 56)
   // 1x1 PNG
   const PNG = Buffer.from(
     "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==",
     "base64",
   )
   const files: Record<string, Uint8Array> = {}
   for (let i = 0; i < N; i++) files[`shots/shot-${i}.png`] = PNG
   
   const countImages = (req: unknown) => {
     const s = JSON.stringify(req)
     return (s.match(/"type":"image_url"/g) ?? []).length
   }
   const counts: number[] = []
   let shot = 0
   let turn2 = false
   // Wait on the model requests themselves (the TUI's matches RPC stalls with many images on screen).
   const waitRequests = (n: number) =>
     Effect.gen(function* () {
       for (let i = 0; i < 600 && counts.length < n; i++) yield* Effect.sleep(250)
     })
   
   export default OpenCodeDriver.use(
     {
       ...(process.env.OC_DEV ? { opencode: { dev: process.env.OC_DEV } } : {}),
       project: { git: true, files },
       tui: { recording: true },
       // Give the simulated model image input, like the Console models in the report.
       config: {
         providers: { simulation: { models: { "gpt-sim-model": { capabilities: { tools: true, input: ["text", "image"], output: ["text"] } } } } },
       },
     },
     ({ ui, llm }) =>
       Effect.gen(function* () {
         yield* llm.serve((request, index) => {
           const n = countImages(request)
           if (index === 3 && process.env.DUMP) require("fs").writeFileSync("/tmp/opencode/req3.json", JSON.stringify(request, null, 1))
           // Stand-in for the provider's documented 50-image cap: reject like Console does.
           if (n > 50)
             return Stream.make(
               Llm.raw({ error: { type: "invalid_request_error", message: `Upstream request failed: [invalid_request_error] request contains ${n} images, exceeding the maximum of 50 allowed per request` } }),
             )
           counts.push(n)
           console.log(`[repro] model request #${index}: ${n} image(s)`)
           // Turn 1 reads shots 0-29, turn 2 reads shots 30-51 (stays under the per-turn step limit).
           if (shot < N && !(shot === 30 && !turn2)) {
             const i = shot++
             return Stream.make(
               Llm.toolCall({ index: 0, id: `call_${i}`, name: "read", input: { path: `shots/shot-${i}.png` } }),
               Llm.finish("tool-calls"),
             )
           }
           return Stream.make(Llm.text(`REQUEST_${index}_CARRIED_${n}_IMAGES`))
         })
         yield* ui.submit("Read every screenshot in shots/ one at a time")
         yield* waitRequests(31)
         turn2 = true
         yield* ui.submit("Now read the rest")
         yield* waitRequests(N + 2)
         yield* Effect.sleep(3000)
         yield* ui.screenshot("after-52-reads")
         yield* ui.submit("Text only: stop sending images and just say hi")
         yield* Effect.sleep(8000)
         yield* waitRequests(N + 4)
         yield* ui.screenshot("text-only-prompt")
         console.log(`[repro] image counts per request: ${counts.join(",")}`)
         console.log(`[repro] max images in one request: ${Math.max(...counts)} (provider cap in report: 50)`)
       }),
   )

   Run it with opencode-drive: opencode-drive run ./drive.ts. It drives opencode from your PATH; set OC_DEV to the path of an OpenCode checkout to run that from source instead.
7. opencodejr

   added

   reproduced

   on Oct 28, 2026
8. iEsclyOrg commented on Nov 12, 2026

   

   iEsclyOrg

   on Nov 12, 2026

   More actions

   Hey Im having the same issue. I tried compacting but it didn't worked. Currently on opencode latest version for windows desktop(2.2.7)

   I'm using api from Nvidia model: minimax m3.1 flash