OpenAI Responses reasoning-only stream failures retry forever and block parent tasks

[fanxing2501]

Description

An explore subagent using the official openai/gpt-5.6-sol Responses provider with the xhigh variant retried the same final LLM call indefinitely after all tool calls had completed. The parent task remained running until manual cancellation.

The final assistant message accumulated 25 attempts over about 63 minutes. A typical attempt produced reasoning for 110-117 seconds, emitted 13 reasoning items, then failed without any text or step-finish. The next request used the original stream input, so the model repeated the same planning instead of continuing from the partial reasoning.

Sanitized observations:

completed local tools: 15:23:56
final assistant message: text parts=0, step-finish parts=0
full attempts: usually 13 reasoning items and ~49k encrypted-reasoning characters
retry delays: 2s -> 4s -> 8s -> 16s -> 30s cap
parent task state: running until manually aborted at 16:27

AI_APICallError: Cannot connect to API: The socket connection was closed unexpectedly.

OpenCode caps this model's per-step output at 32k by default while the model advertises 128k. It is possible that xhigh reasoning consumed the request budget, but no normal response.incomplete / finish=length was recorded. At least one attempt logged the socket-close error above. A throttled 320-second HTTPS download through the same network path completed normally, so there was no general 120/300-second active TCP cutoff.

Expected behavior:

• A normal response.incomplete should finish the step as length and preserve partial output.
• A retryable transport failure should have a bounded retry count or elapsed-time budget.
• Exhausted retries must terminate the child task with an error so the parent does not wait forever.

Related but not identical: #12234 (unbounded retries), #29363 (32k reasoning with zero text), #11865 (OpenAI/xhigh subagents hang), and #21979 (Responses failures leave parents waiting).

Plugins

None

OpenCode version

1.18.2

Steps to reproduce

1. Use the official openai/gpt-5.6-sol provider with variant xhigh.
2. Start an explore subagent with a broad repository-analysis task that performs several tool calls and then needs to produce a detailed final report.
3. If the final Responses stream ends after partial reasoning without a terminal event, inspect the child session or logs.
4. Observe repeated stream providerID=openai ... agent=explore calls for the same assistant message, no final text/step-finish, and the parent task remaining running.

The upstream socket failure is intermittent, but once it occurs the session-level retry loop is deterministic and unbounded.

Screenshot and/or share link

No public share link because the session contains private repository context. Sanitized metrics and the exact error are included above.

Operating System

Ubuntu 26.04 LTS, Linux 7.0.0-27-generic

Terminal

OpenCode TUI over SSH (xterm-256color)

[github-actions]

This issue might be a duplicate of (or closely related to) several existing open issues. Please check:

• fix(session): SessionRetry.policy() retries forever with no max attempt count #21960: SessionRetry.policy() retries forever with no max attempt count — directly overlaps the unbounded retry behavior described here
• [Bug]: Session processor retries indefinitely with unbounded exponential backoff — no max retries or circuit breaker #17648: Session processor retries indefinitely with unbounded exponential backoff — no max retries or circuit breaker — same root cause area
• Task tool blocks parent session indefinitely when sub-agent LLM call fails #29952: Task tool blocks parent session indefinitely when sub-agent LLM call fails — same parent-task-hangs symptom
• Wrapped stream error chunks bypass retry and can leave parent sessions waiting forever #21979: Wrapped stream error chunks bypass retry and can leave parent sessions waiting forever — already cited in this issue; closely related stream-error path

The issues you referenced (#11865, #29363, #12234) are also relevant. If any of the above fully cover your report, consider commenting there instead. If this is a distinct scenario (e.g., reasoning-budget exhaustion producing a silent socket close rather than a proper error event), please clarify that distinction so it can be tracked separately.

[fanxing2501]

Thanks. This overlaps #21960 / #17648 on the unbounded retry policy, but the trigger and protocol outcome are different: the official OpenAI Responses stream successfully emits partial reasoning for about 110-117 seconds (usually 13 reasoning items), then ends without response.completed, response.incomplete, or step-finish and surfaces a socket-close error. #21960 / #17648 primarily cover persistent HTTP 429/5xx failures; #29952 covers a fatal no-retry zombie subagent; #21979 covers errors that bypass retry. In this case the error enters retry, replays the original stream input forever, and blocks the parent task. Bounded retries would mitigate the hang, but correct handling/propagation of this reasoning-only Responses termination may also be required. Happy to consolidate if a maintainer prefers.