compaction: reasoning tokens consume the summary budget, so compaction fails with "reached the output token limit" #59110

Activity

1. opencode-agent commented on Oct 26, 2026

   

   opencode-agentBot

   on Oct 26, 2026 – with OpenCode Agent

   Contributor

   More actions

   Thanks for the detailed report. I can confirm this on v2.1.4, and it still happens on the latest dev (08ac673ab).

   What I did, with a simulated model (128k context, 16k output limit) and compaction: { auto: true, keep: { tokens: 6000 }, buffer: 2048 }:

   1. Sent one message. That turn's request went out with max_completion_tokens: 16000.
   2. Ran /compact. The summary request went out with max_completion_tokens: 2048, exactly the buffer value.
   3. Had the simulated model answer with reasoning only until it hit the limit, as a reasoning model would. Compaction then failed with "Compaction summary reached the output token limit".

   So compaction.buffer does more than reserve headroom: it also becomes the summary's output cap. That fits what you saw (output: 0, reasoning: 2048). The script and recording below reproduce it.

   Until this is fixed, the workarounds you found avoid the problem: a non-reasoning variant for the compaction agent (agents.compaction.model: "deepseek/deepseek-flash#none"), or a larger buffer.

   Related: #56772 (summaries without the session's reasoning variant) and #57220 (retry compaction on the output limit with less reasoning).

   recording.mp4

   

   Reproduction script (drive.ts)

   // Reproduces anomalyco/opencode#59110: `compaction.buffer` caps the summary's output tokens.
   // The simulated model has a 128k context window and a 16k output limit. With `compaction.buffer: 2048`,
   // the /compact request is sent with max_tokens = 2048 (normal turns get 16000), so a reasoning model
   // can use the whole budget thinking and finish with `length` -> "Compaction summary reached the output token limit".
   import { Effect, Stream } from "effect"
   import { Llm, OpenCodeDriver } from "opencode-drive"
   
   const seen: Array<{ index: number; max: unknown; compaction: boolean }> = []
   
   export default OpenCodeDriver.use(
     {
       ...(process.env.OC_DEV ? { opencode: { dev: process.env.OC_DEV } } : {}),
       tui: { recording: true },
       config: { compaction: { auto: true, keep: { tokens: 6000 }, buffer: 2048 } } as any,
     },
     ({ ui, llm }) =>
       Effect.gen(function* () {
         yield* llm.serve((request: any, index: number) => {
           const body = request?.body ?? request
           const max = body?.max_completion_tokens ?? body?.max_tokens
           const text = JSON.stringify(body?.messages ?? "")
           const title = text.includes("Reply with only the title")
           const compaction = !title && /structured summary|summary template/.test(text)
           seen.push({ index, max, compaction })
           console.log(`[request ${index}] max_tokens=${max} title=${title} compaction=${compaction} last=${text.slice(-160)}`)
           if (title) return Stream.make(Llm.text("Greeting"))
           if (!compaction) return Stream.make(Llm.text(`Hello! (this turn was sent with max_tokens=${max})`))
           // The summary request: the model spends its whole budget reasoning, as a reasoning model would.
           return Stream.make(
             Llm.reasoning("Let me think carefully about everything in this conversation... ".repeat(20)),
             Llm.finish("length"),
           )
         })
         yield* ui.submit("Hi there")
         yield* ui.waitFor("max_tokens=", { timeout: 20_000 } as any)
         yield* ui.screenshot("normal-turn")
         yield* ui.submit("/compact")
         yield* ui.waitFor("output token limit", { timeout: 30_000 } as any)
         yield* Effect.sleep("1 second")
         yield* ui.screenshot("compaction-failed")
         console.log("REQUESTS " + JSON.stringify(seen))
       }),
   )

   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.
2. opencode-agent

   added

   reproduced

   on Oct 26, 2026
3. r266-tech commented on Nov 1, 2026

   

   r266-tech

   on Nov 1, 2026

   Contributor

   More actions

   I rechecked this against the current dev (296074aab29138dd94af7d82e70b3513e28746ea). The specific coupling reported here — compaction.buffer becoming the summary request's output cap — is addressed in dev by 6709f5646de29460a7caf8e4f553369a130413b7 (fix(core): give compaction summaries the same output limit as normal turns).

   Current source evidence:

   • packages/core/src/session/model-request.ts#L90-L99 computes the normal model output limit without a separate small compaction cap.
   • packages/core/src/session/compaction.ts#L1193-L1205 fits the summary request to the room left and preserves a 32k floor where the estimate margin would otherwise cut it down; buffer: 2048 is therefore no longer used as max_tokens: 2048 for the summary.
   • The residual failure mode is still visible at compaction.ts#L812-L816: a provider length finish is reported as Compaction summary reached the output token limit. The existing open #57220 proposes the separate follow-up of lowering reasoning and retrying that finish, so I am not duplicating it here.

   This means the original buffer-as-cap report should be retested on a release containing #57564; the remaining reasoning-token exhaustion should remain tracked by #57220 unless maintainers prefer to fold it into this issue. I have not run a live provider call or changed any recording.

   AI disclosure: this source comparison and comment were prepared by an AI coding agent under standing authorization; no human reviewed the implementation.