compaction: stays on "Compacting" with no feedback when the provider fails or only sends SSE keepalives #61346

Activity

1. opencodejr commented on Nov 3, 2026

   

   opencodejrBot

   on Nov 3, 2026

   More actions

   Thanks for the detailed report. I reproduced the keepalive part on v2.2.5 and on the latest dev (3ba597f).

   The script below is a transport test in packages/ai. It sends one SSE data: event and then advances a test clock 20 virtual minutes:

   • Silence after the event: the request fails with "Timed out waiting for response data", as expected.
   • A : keepalive comment every minute: the request is still running after 20 minutes. The 15-minute chunk timeout in packages/ai/src/route/transport/http.ts is applied to the raw bytes before framing, so the comments keep resetting it.

   I confirmed the silent retries by reading the code; I didn't run a 503 case. deliver in packages/core/src/session/compaction.ts waits with Effect.sleep between retries and never publishes SessionEvent.RetryScheduled, which normal steps publish through SessionRunnerRetry.make().wait.

   Related: open PR #52866 moves the chunk timeout onto framed events, and #53747 reports steps hanging without a timeout.

   Reproduction script (keepalive-timeout.test.ts)

   // Reproduction for anomalyco/opencode#61346 (chunk timeout reset by SSE keepalive comments).
   // Copy into packages/ai/test/ of an opencode checkout and run:
   //   cd packages/ai && bun test test/keepalive-timeout.test.ts
   import { describe, expect } from "bun:test"
   import { Deferred, Effect, Fiber } from "effect"
   import * as TestClock from "effect/testing/TestClock"
   import { ai } from "../src/effect.js"
   import { LLMClient } from "../src/route.js"
   import { configure } from "../src/providers/openai.js"
   import { dynamicResponse } from "./lib/http.js"
   import { deltaChunk } from "./lib/openai-chunks.js"
   import { sseRaw } from "./lib/sse.js"
   import { it } from "./lib/effect.js"
   
   const model = configure({ baseURL: "https://api.openai.test/v1/", apiKey: "test" }).chat("gpt-4.1-mini")
   const SSE = { headers: { "content-type": "text/event-stream" } }
   const encoder = new TextEncoder()
   
   // Sends one `data:` event, then hands the controller to the test so it can push keepalive comments.
   const server = Effect.gen(function* () {
     const ready = yield* Deferred.make<ReadableStreamDefaultController<Uint8Array>>()
     const layer = dynamicResponse((input) =>
       Effect.sync(() =>
         input.respond(
           new ReadableStream<Uint8Array>({
             start(controller) {
               controller.enqueue(encoder.encode(sseRaw(`data: ${JSON.stringify(deltaChunk({ content: "Hi" }))}`)))
               Deferred.doneUnsafe(ready, Effect.succeed(controller))
             },
           }),
           SSE,
         ),
       ),
     )
     return { layer, ready }
   })
   
   const run = (keepalive: boolean) =>
     Effect.gen(function* () {
       const s = yield* server
       const fiber = yield* LLMClient.generate(ai.request({ model, prompt: "Hello" })).pipe(
         Effect.provide(s.layer),
         Effect.flip,
         Effect.forkChild({ startImmediately: true }),
       )
       const controller = yield* Deferred.await(s.ready)
       // 20 virtual minutes, one keepalive comment per minute (or silence).
       for (let i = 0; i < 20; i++) {
         if (keepalive) controller.enqueue(encoder.encode(": keepalive\n\n"))
         yield* Effect.promise(() => new Promise((r) => setTimeout(r, 5)))
         yield* TestClock.adjust("1 minute")
         yield* Effect.yieldNow
       }
       return fiber.pollUnsafe()
     })
   
   describe("#61346 chunk timeout vs SSE keepalives", () => {
     it.effect("control: data then silence times out within 20 minutes", () =>
       Effect.gen(function* () {
         const exit = yield* run(false)
         console.log("silence ->", exit ? JSON.stringify(exit) : "still running")
         expect(exit).toBeDefined()
       }),
     )
   
     it.effect("data then only keepalives should also time out within 20 minutes", () =>
       Effect.gen(function* () {
         const exit = yield* run(true)
         console.log("keepalive ->", exit ? JSON.stringify(exit) : "still running after 20 virtual minutes")
         expect(exit).toBeDefined()
       }),
     )
   })

   Run it: bun keepalive-timeout.test.ts
2. opencodejr

   added

   reproduced

   on Nov 3, 2026
3. deosiree commented on Nov 3, 2026

   

   deosiree

   on Nov 3, 2026

   Last edited by deosiree

   More actions

   I found the earlier closed PR #50757 covering the same compaction retry notice behavior. To avoid duplicating that work, I'm withdrawing this claim and will not submit another PR for this scope.
4. rome-xi commented on Nov 3, 2026

   

   rome-xi

   on Nov 3, 2026

   More actions

   I can reproduce the keepalive part on dev (3ba597f): the chunk timeout wraps the raw byte stream before SSE framing, so : keepalive comments keep resetting it. I'd like to take that part (transport only, not the compaction retry notice) with a test in http-timeout.test.ts.