core: context-only limit leaves compaction using conflicting window sizes #60648

Activity

1. opencodejr commented on Oct 30, 2026

   

   opencodejrBot

   on Oct 30, 2026

   Contributor

   More actions

   Thanks for the detailed report. I can confirm the /compact part on v2.2.3, and it still happens on the latest dev (da87c475a).

   What I did, with a simulated model whose limits match your setup (context 256,000 from the override, input 922,000 from the catalog, output 128,000) and compaction: { auto: true, buffer: 40000 }:

   1. Sent a message whose reply reported about 225k prompt tokens, then sent a second message. Automatic compaction did not start, and normal turns went out with max_completion_tokens: 128000.
   2. Ran /compact. The summary request, and its retry, went out with max_completion_tokens: 1024.
   3. With input left out of the limit (context-only 256k), the same summary requests got 40000.

   The script below reproduces it and logs the output limit of each request.

   From the code, the cause looks like this: the compaction threshold and the summary request size come from limit.input (922k − 40k buffer = 882k), but the summary's output room is worked out against limit.context (256k). That gives negative room, which is clamped to the 1,024 minimum.

   On automatic compaction not starting: the code uses the input limit for that by design. The missing docs for this are tracked in #52954. The 1,024 cap on the summary, though, is a real bug.

   Until it's fixed, setting input to the same value as context in your override should make compaction work again. Related: #52954 (which limit sets the threshold), #59110 (reasoning tokens using up the summary budget, which makes a 1,024 cap worse), and #58492 (open PR changing the threshold calculation).

   Reproduction script (drive.ts)

   // Repro for anomalyco/opencode#60648: a context-only limit override (context 256k < catalog input 922k)
   // makes manual /compact send a tiny max output limit (clamped to the 1,024 minimum).
   // The simulated model's merged limits mirror the report: catalog input=922,000 kept, context overridden to 256,000.
   import { Effect, Stream } from "effect"
   import { appendFileSync, writeFileSync } from "node:fs"
   import { Llm, OpenCodeDriver } from "opencode-drive"
   
   const LOG = "/workspace/repro/requests.log"
   writeFileSync(LOG, "")
   
   export default OpenCodeDriver.use(
     {
       ...(process.env.OC_DEV ? { opencode: { dev: process.env.OC_DEV } } : {}),
       tui: { recording: true },
       config: {
         compaction: { auto: true, buffer: 40000 },
         providers: {
           simulation: {
             models: {
               "gpt-sim-model": { limit: { context: 256_000, ...(process.env.NO_INPUT ? {} : { input: 922_000 }), output: 128_000 } },
             },
           },
         },
       },
     },
     ({ ui, llm }) =>
       Effect.gen(function* () {
         yield* llm.serve((request, index) => {
           const body = request.body as Record<string, unknown>
           const text = JSON.stringify(body)
           const isSummary = /summar/i.test(JSON.stringify(body.messages ?? "").slice(-4000))
           appendFileSync(
             LOG,
             `#${index} max_tokens=${body.max_tokens} max_completion_tokens=${body.max_completion_tokens} bodyChars=${text.length} summaryLike=${isSummary} last=${JSON.stringify((body.messages as any[])?.at(-1)).slice(0,300)}\n`,
           )
           if (index === 0)
             return Stream.make(
               Llm.text("Reply one: the session is now large."),
               Llm.raw({ choices: [], usage: { prompt_tokens: 225_000, completion_tokens: 200, total_tokens: 225_200 } }),
             )
           return Stream.make(
             Llm.text(`Response ${index}: ## Summary of the conversation so far.`),
             Llm.raw({ choices: [], usage: { prompt_tokens: 1000, completion_tokens: 50, total_tokens: 1050 } }),
           )
         })
         yield* ui.submit("Hello, grow the session")
         yield* ui.waitFor("Reply one")
         yield* Effect.sleep(1500)
         yield* ui.screenshot("after-first-reply")
         yield* ui.submit("Another message after the large turn")
         yield* ui.waitFor("Response 1")
         yield* Effect.sleep(1500)
         yield* ui.screenshot("no-auto-compaction")
         yield* ui.submit("/compact")
         yield* Effect.sleep(6000)
         yield* ui.screenshot("after-compact")
       }),
   )

   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. opencodejr

   added

   reproduced

   on Oct 30, 2026
3. wannesdecraene commented on Oct 30, 2026

   

   wannesdecraene

   on Oct 30, 2026

   Author

   More actions

   I'd like to work on the summary-budget bug: with context=256000 and inherited input=922000, manual compaction incorrectly requests only 1024 output tokens. I'll add a regression test and keep changes to automatic-compaction policy separate. Is this scope sensible given #58492 and #59226? Later I could add the missing docs as the autocompaction not starting is by design.
4. rekram1-node

   closed this as completedin #60660on Oct 30, 2026