v2: WebSocket idle-timeout bypasses the 3-timeout retry cap, so a dead stream can hold a step for hours #57127

Activity

1. opencode-agent commented on Oct 19, 2026

   

   opencode-agentBot

   on Oct 19, 2026 – with OpenCode Agent

   Contributor

   More actions

   Thanks for the detailed report and the pointers into the code. I can confirm this.

   I tested the session retry policy directly. I fed it repeated failures with the same idle-timeout error that model-transport.ts raises when the WebSocket stream goes silent, and compared that with an HTTP Timeout:

   • HTTP Timeout: retried 3 times, then stopped (MAX_TIMEOUT_RETRIES).
   • WebSocket idle-timeout: retried 10 times under the general allowance, then stopped.

   Since each idle-timeout attempt waits 30 minutes before failing, one step can be held for hours. That goes against the reason the comment above the cap gives for having it. The results were the same on v2.0.32 and on the latest dev (ce15cd8). The test script below reproduces it.

   Related:

   • fix(core): cap gateway timeouts and log scheduled retries #54544 (open PR) widens the same timeout cap to gateway 504s, but currently keeps WebSocket idle timeouts under the full allowance, so the two need to be reconciled.
   • fix(core): count websocket stream failures #50955 (open PR) counts idle timeouts toward the WebSocket-to-HTTP fallback.

   Reproduction script (idle-timeout-retry.test.ts)

   // Copy into packages/core/test/ of an opencode checkout and run: bun test test/idle-timeout-retry.test.ts (from packages/core)
   import { describe, expect } from "bun:test"
   import { AIError, TransportError } from "@opencode/ai"
   import { Agent } from "@opencode/schema/agent"
   import { Model } from "@opencode/schema/model"
   import { Provider } from "@opencode/core/provider"
   import { SessionSchema } from "@opencode/core/session/schema"
   import { SessionRunnerRetry } from "@opencode/core/session/runner/retry"
   import { toSessionError } from "@opencode/core/session/to-session-error"
   import { Effect } from "effect"
   import { it } from "./lib/effect"
   
   const httpTimeout = new AIError({
     reason: new TransportError({ message: "Timed out", transport: "http", operation: "request", code: "Timeout" }),
   })
   // Same shape model-transport.ts produces after the 30-minute WebSocket IDLE_TIMEOUT.
   const wsIdle = new AIError({
     reason: new TransportError({
       message: "Timed out waiting for WebSocket data",
       transport: "websocket",
       operation: "read",
       code: "idle-timeout",
       phase: "receive",
       delivery: "accepted",
     } as any),
   })
   
   const input = (cause: AIError) => ({
     cause,
     error: toSessionError(cause),
     agent: Agent.ID.make("build"),
     model: Model.Ref.make({ id: Model.ID.make("model"), providerID: Provider.ID.make("provider") }),
     hook: () => Effect.void,
     retry: SessionRunnerRetry.isRetryable(cause),
   })
   
   const decisions = (cause: AIError, count: number) =>
     Effect.gen(function* () {
       const policy = yield* SessionRunnerRetry.policy(SessionSchema.ID.make("ses_retry"))
       const results: boolean[] = []
       for (let i = 0; i < count; i++) results.push((yield* policy(input(cause))).retry)
       return results
     })
   
   describe("timeout cap", () => {
     it.effect("http Timeout is capped at 3 retries", () =>
       Effect.gen(function* () {
         const r = yield* decisions(httpTimeout, 11)
         console.log("http Timeout   :", JSON.stringify(r))
         expect(r.slice(0, 4)).toEqual([true, true, true, false])
       }),
     )
     it.effect("websocket idle-timeout should be capped at 3 retries too", () =>
       Effect.gen(function* () {
         const r = yield* decisions(wsIdle, 11)
         console.log("ws idle-timeout:", JSON.stringify(r), "retryable:", SessionRunnerRetry.isRetryable(wsIdle))
         expect(r.slice(0, 4)).toEqual([true, true, true, false])
       }),
     )
   })

   Run it: bun idle-timeout-retry.test.ts
2. opencode-agent

   added

   reproduced

   on Oct 19, 2026
3. HootRock commented on Oct 19, 2026

   

   HootRock

   on Oct 19, 2026

   More actions

   I reproduced this on dev 367c8fb and pushed a scoped fix: two-file diff, commit a2162bf.

   idle-timeout now shares the existing three-timeout counter with HTTP Timeout. Regressions cover repeated idle timeouts, mixed transport timeouts and the unchanged connection-failure allowance. The two regressions fail before the fix; 50 repeated policy tests and 46 related tests pass afterward. Independent review found no actionable issues, and lint/all 34 typecheck tasks pass. The Windows full-suite comparison has the same 151 failures on both versions, plus the two expected regression failures before the fix.

   GitHub currently blocks my new PR with this repository's three-open-PR limit. The tested branch is available for review; no PR has been created, and I will retain my existing PRs.

   AI-assisted; reviewed and tested locally.