ai: preserve diagnostics for mid-stream HTTP decode failures #42482

Activity

1. JavaGT commented on Aug 21, 2026

   

   JavaGT

   on Aug 21, 2026

   More actions

   Confirming this at production scale, and it's worse for multi-agent workflows than the log line suggests.

   Environment

   • opencode version: 0.0.0-beta-17793
   • OS: macOS (Darwin arm64)
   • Terminal: tmux / xterm-256color
   • Shell: /bin/zsh
   • Install/channel: beta
   • Active plugins: none configured

   Production evidence (single day, one machine)

   From the server log (Failed to drain Session entries), all against https://opencode.ai/zen/v1/chat/completions:

   • 116 × AI.Error: RequestExecutor.read: Decode error (200 POST https://opencode.ai/zen/v1/chat/completions)
   • 32 × AI.Error: RequestExecutor.read: ECONNRESET: The socket connection was closed unexpectedly

   All of them fatal to the turn. Zero retried. The generic message is the only signal — there is no way to tell from the persisted error whether the provider truncated the body, sent malformed SSE, or the local socket died, which is exactly the diagnostic loss this issue describes.

   Why sub-agents make this acute

   This machine runs a long-running multi-agent program (~90 sub-agent sessions/day through the Zen free models). For orchestrators, each one of these failures is a worker that dies silently:

   • No terminal event reaches the parent session — from the coordinator's point of view the sub-agent is indistinguishable from "still working" or "stalled", so completion signals can't be trusted and the repo state has to be polled as ground truth.
   • Whatever the dead turn had in flight is lost; re-dispatching means re-running the whole task from scratch, not resuming.
   • Human operators fall back to manually nudging sessions with "continue" to kick a fresh request.

   The failure rate scales with fleet size, so heavy sub-agent users absorb this superlinearly. Preserving the native cause + stream-progress metadata (as the PR does) would let tooling distinguish provider-side truncation from local transport faults and route retries accordingly — that distinction is exactly what's missing today.
2. Dante-dan commented on Oct 27, 2026

   

   Dante-dan

   on Oct 27, 2026

   Contributor

   More actions

   #52634 already fixes the generic decode message and native-cause unwrapping. I implemented the stream-progress part of this report in a focused reference patch.

   It counts chunks/bytes, decoded frames, terminal observation and monotonic elapsed time; records the last normalized LLM event tag and allowlisted content type/encoding; and projects these optional fields into persisted session errors. One new diagnostic logs only status, operation and this progress metadata.

   The regression emits two valid SSE chunks before rejecting the stream, checks persistence projection, and verifies generated text, native messages and arbitrary headers stay out of the new progress object and diagnostic. Validation: 1,938 AI tests passed (28 skipped), 13 session-error tests passed, and all 35 typecheck tasks passed. Lint passed with warnings.

   This addresses progress metadata; existing raw error/cause/header handling and bounded native cause-chain normalization remain outside this patch.
3. opencodejr commented on Oct 28, 2026

   

   opencodejrBot

   on Oct 28, 2026

   Contributor

   More actions

   Thanks for the detailed write-up. I reproduced this with a test against RequestExecutor.stream: a mocked HTTP 200 response sends two valid SSE chunks, then the ReadableStream fails. The script below sets this up.

   Before #52634 (317dfbc): a failure whose cause has no string message produced exactly Decode error (200 POST https://chatgpt.com/backend-api/codex/responses) with code DecodeError, as you describe.

   On latest dev (651032b): that generic message is gone. Reads now fail with Connection lost while reading the response[: code: detail], and the HTTP 200 status and the native cause object are kept. Some diagnostics are still lost:

   • Undici-style TypeError("terminated") with a cause carrying UND_ERR_SOCKET: works; the message and code include UND_ERR_SOCKET.
   • Three-level chain with the code (ECONNRESET) on the innermost error: message is Connection lost while reading the response: terminated and code is undefined.
   • Error with a code (ERR_STREAM_PREMATURE_CLOSE) but no string message: message is just Connection lost while reading the response and code is undefined.
   • No chunk, byte or event progress metadata is recorded, and the session error still keeps only the message and status.

   The root cause is that nativeTransportFailure only decodes a { message: string } shape and looks at most one cause deep.

   Reproduction script (repro.sh)

   #!/usr/bin/env bash
   # Run from a checkout of anomalyco/opencode (dev) after `bun install`: bash repro.sh /path/to/repo
   set -euo pipefail
   REPO=${1:-.}
   cat > "$REPO/packages/ai/test/mid-stream-decode.test.ts" <<'EOF'
   // Copy into packages/ai/test/ and run: cd packages/ai && bun test test/mid-stream-decode.test.ts
   import { describe, expect } from "bun:test"
   import { Effect, Stream } from "effect"
   import { HttpClientRequest } from "effect/http"
   import { AIError } from "../src/effect.js"
   import { RequestExecutor } from "../src/route.js"
   import { systemError, truncatedStream } from "./lib/http.js"
   import { it } from "./lib/effect.js"
   
   const req = HttpClientRequest.post("https://chatgpt.com/backend-api/codex/responses")
   const chunks = ['data: {"type":"response.reasoning_summary_text.delta"}\n\n', 'data: {"type":"response.reasoning_summary_text.delta"}\n\n']
   
   const run = (name: string, error: Error) =>
     it.effect(name, () =>
       Effect.gen(function* () {
         const executor = yield* RequestExecutor.Service
         let n = 0
         const err = yield* RequestExecutor.stream(executor, req).pipe(
           Stream.runForEach(() => Effect.sync(() => n++)),
           Effect.flip,
         )
         expect(err).toBeInstanceOf(AIError)
         const r = (err as AIError).reason as any
         console.log(name, JSON.stringify({ chunksRead: n, message: err.message, code: r.code, status: r.http?.status, keys: Object.keys(r) }))
       }).pipe(Effect.provide(truncatedStream(chunks, error))),
     )
   
   describe("mid-stream body read failure diagnostics", () => {
     run("shallow undici", new TypeError("terminated", { cause: systemError("UND_ERR_SOCKET", "other side closed") }))
     run("3-deep chain", new TypeError("terminated", { cause: new Error("wrapped", { cause: systemError("ECONNRESET", "reset") }) }))
     run("non-message cause", Object.assign(new Error(), { message: undefined as any, code: "ERR_STREAM_PREMATURE_CLOSE" }))
   })
   EOF
   cd "$REPO/packages/ai" && bun test test/mid-stream-decode.test.ts

   Run it: bash repro.sh
4. opencodejr

   added

   reproduced

   on Oct 28, 2026