mixdog 0.9.95 → 0.9.97

package/src/runtime/agent/orchestrator/providers/openai-compat.mjs

@@ -1,6 +1,6 @@
 import { createRequire } from 'node:module';
 import { getAgentApiKey } from '../../../shared/provider-api-key.mjs';
-import { withRetry } from './retry-classifier.mjs';
+import { canFallbackNonStreaming, withRetry } from './retry-classifier.mjs';
 import { getLlmDispatcher, preconnect } from '../../../shared/llm/http-agent.mjs';
 import { sendViaWebSocket } from './openai-oauth-ws.mjs';
 import { _combineUsageWithWarmup } from './openai-ws-events.mjs';
@@ -69,6 +69,16 @@ function loadOpenAI() {
     return _OpenAI;
 }
 
+// Grok OAuth creates its credential-bound inner provider only when send() has
+// the final token and request headers. Let the process-wide provider warmup pay
+// the OpenAI SDK + undici pool load before that first request reaches the hot
+// path, without constructing a fake credential-bound client.
+export function preloadOpenAICompatRuntime() {
+    const OpenAI = loadOpenAI();
+    getLlmDispatcher();
+    return OpenAI;
+}
+
 function attachCompletedWarmup(err, warmup) {
     if (!err || !warmup?.usage) return err;
     try {
@@ -238,7 +248,8 @@ export class OpenAICompatProvider {
         // extraHeaders behave exactly as before.
         this.defaultHeaders = { ...(preset?.extraHeaders || {}), ...(config.extraHeaders || {}) };
         this.defaultModel = preset?.defaultModel || 'default';
-        this.client = new (loadOpenAI())({
+        const OpenAI = preloadOpenAICompatRuntime();
+        this.client = new OpenAI({
             baseURL,
             apiKey,
             defaultHeaders: this.defaultHeaders,
@@ -253,6 +264,12 @@ export class OpenAICompatProvider {
             // a harmless no-op then.
             fetchOptions: { dispatcher: getLlmDispatcher() },
         });
+        // Provider registry initialization normally runs during daemon warmup.
+        // Start the origin handshake there; the per-send call below remains as
+        // the TTL-gated rewarm after long idle gaps.
+        if (this.config?.preconnect !== false) {
+            try { this._preconnectFn(this.baseURL); } catch { /* best-effort */ }
+        }
     }
     get _preconnectFn() {
         return typeof this.config?.preconnectFn === 'function'
@@ -420,44 +437,52 @@ export class OpenAICompatProvider {
         params.stream_options = { include_usage: true };
         let assembled;
         try {
-            assembled = await withRetry(
-                async ({ signal: attemptSignal }) => {
-                    try { opts.onStageChange?.('requesting'); } catch { /* heartbeat best-effort */ }
-                    const stream = await withRetry(
-                        ({ signal: openSignal }) => this.client.chat.completions.create(params, { signal: openSignal }),
-                        {
+            try {
+                assembled = await withRetry(
+                    async ({ signal: attemptSignal }) => {
+                        try { opts.onStageChange?.('requesting'); } catch { /* heartbeat best-effort */ }
+                        const stream = await withRetry(
+                            ({ signal: openSignal }) => this.client.chat.completions.create(params, { signal: openSignal }),
+                            {
+                                signal: attemptSignal,
+                                // Single attempt: this inner wrapper exists only to
+                                // apply the first-byte per-attempt timeout. Retry is
+                                // owned by the outer withRetry — nesting retry loops
+                                // here multiplied tail latency (5x5).
+                                maxAttempts: 1,
+                                perAttemptTimeoutMs: PROVIDER_FIRST_BYTE_TIMEOUT_MS,
+                                perAttemptLabel: `${this.name} first byte`,
+                            },
+                        );
+                        try { opts.onStageChange?.('streaming'); } catch { /* heartbeat best-effort */ }
+                        return consumeCompatChatCompletionStream(stream, {
                             signal: attemptSignal,
-                            // Single attempt: this inner wrapper exists only to
-                            // apply the first-byte per-attempt timeout. Retry is
-                            // owned by the outer withRetry — nesting retry loops
-                            // here multiplied tail latency (5x5).
-                            maxAttempts: 1,
-                            perAttemptTimeoutMs: PROVIDER_FIRST_BYTE_TIMEOUT_MS,
-                            perAttemptLabel: `${this.name} first byte`,
+                            label: this.name,
+                            onStreamDelta: opts.onStreamDelta,
+                            onToolCall: opts.onToolCall,
+                            onTextDelta: opts.onTextDelta,
+                            parseToolCalls,
+                            // Known tool names for the leaked-tool-call guard:
+                            // recovered leaked calls only synthesize when they name
+                            // a tool actually offered to this request.
+                            knownToolNames: knownToolNamesFromOpenAITools(params.tools),
+                        });
+                    },
+                    {
+                        signal: totalSignal.signal,
+                        onRetry: ({ attempt, lastErr, delayMs, delayReason }) => {
+                            const delayLabel = Number.isFinite(Number(delayMs)) ? `, delay ${delayMs}ms${delayReason ? ` (${delayReason})` : ''}` : '';
+                            process.stderr.write(`[${this.name}] retry attempt ${attempt + 1} after ${lastErr?.message || lastErr?.code || 'transient error'}${delayLabel}\n`);
                         },
-                    );
-                    try { opts.onStageChange?.('streaming'); } catch { /* heartbeat best-effort */ }
-                    return consumeCompatChatCompletionStream(stream, {
-                        signal: attemptSignal,
-                        label: this.name,
-                        onStreamDelta: opts.onStreamDelta,
-                        onToolCall: opts.onToolCall,
-                        onTextDelta: opts.onTextDelta,
-                        parseToolCalls,
-                        // Known tool names for the leaked-tool-call guard:
-                        // recovered leaked calls only synthesize when they name
-                        // a tool actually offered to this request.
-                        knownToolNames: knownToolNamesFromOpenAITools(params.tools),
-                    });
-                },
-                {
-                    signal: totalSignal.signal,
-                    onRetry: ({ attempt, lastErr, delayMs, delayReason }) => {
-                        const delayLabel = Number.isFinite(Number(delayMs)) ? `, delay ${delayMs}ms${delayReason ? ` (${delayReason})` : ''}` : '';
-                        process.stderr.write(`[${this.name}] retry attempt ${attempt + 1} after ${lastErr?.message || lastErr?.code || 'transient error'}${delayLabel}\n`);
                     },
-                },
-            );
+                );
+            } catch (streamErr) {
+                const recovered = await this._recoverCompatNonStreaming({
+                    streamErr, params, opts, signal: totalSignal.signal, useModel,
+                });
+                if (!recovered) throw streamErr;
+                assembled = recovered;
+            }
         } finally {
             totalSignal.cleanup();
         }
@@ -567,6 +592,83 @@ export class OpenAICompatProvider {
             })() : undefined,
         };
     }
+    /**
+     * cc parity (claude.ts:2504): when a stream dies, re-issue the SAME request
+     * with `stream:false` rather than failing the turn. Narrower than cc on
+     * purpose — canFallbackNonStreaming() clears only a stream that exposed
+     * NOTHING, so an eagerly dispatched tool can never run twice and rendered
+     * text is never duplicated (that case belongs to the loop's retraction
+     * replay). Returns the same assembled shape the stream consumer produces,
+     * or null when the failure is ineligible or the fallback itself fails.
+     */
+    async _recoverCompatNonStreaming({ streamErr, params, opts, signal, useModel }) {
+        if (!canFallbackNonStreaming(streamErr, { signal })) return null;
+        const nonStreamParams = { ...params, stream: false };
+        delete nonStreamParams.stream_options;
+        let response;
+        try {
+            try { opts.onStageChange?.('requesting'); } catch { /* heartbeat best-effort */ }
+            response = await withRetry(
+                ({ signal: attemptSignal }) => this.client.chat.completions.create(
+                    nonStreamParams,
+                    { signal: attemptSignal },
+                ),
+                {
+                    signal,
+                    maxAttempts: 1,
+                    // A non-streaming call returns only when generation is done,
+                    // so the first-byte bound would false-abort it.
+                    perAttemptTimeoutMs: PROVIDER_GENERATE_TOTAL_TIMEOUT_MS,
+                    perAttemptLabel: `${this.name} non-streaming fallback`,
+                },
+            );
+        } catch {
+            return null;
+        }
+        const choice = response?.choices?.[0] || null;
+        if (!choice) return null;
+        const message = choice.message || {};
+        let toolCalls;
+        try {
+            toolCalls = parseToolCalls(choice, this.name);
+        } catch {
+            return null;
+        }
+        try {
+            process.stderr.write(
+                `[${this.name}] stream failed (${streamErr?.code || streamErr?.message || 'unknown'}); `
+                + `recovered via non-streaming request\n`,
+            );
+        } catch { /* best-effort */ }
+        try {
+            appendAgentTrace({
+                sessionId: opts?.sessionId || opts?.session?.id || null,
+                iteration: Number.isFinite(Number(opts?.iteration)) ? Number(opts.iteration) : null,
+                kind: 'transport_fallback',
+                provider: this.name,
+                model: useModel,
+                transport: 'non-streaming',
+                payload: {
+                    from: 'stream',
+                    to: 'non-streaming',
+                    reason: streamErr?.retryClassifier || streamErr?.code || streamErr?.message || 'stream_failed',
+                    error_code: streamErr?.code || null,
+                    error_http_status: Number(streamErr?.httpStatus || streamErr?.status || 0) || null,
+                    error_classifier: streamErr?.retryClassifier || streamErr?.midstreamClassifier || null,
+                },
+            });
+        } catch { /* best-effort */ }
+        return {
+            response,
+            model: response.model || useModel,
+            content: typeof message.content === 'string' ? message.content : '',
+            toolCalls,
+            stopReason: choice.finish_reason || null,
+            reasoningContent: typeof message.reasoning_content === 'string' ? message.reasoning_content : null,
+            rawUsage: response.usage || null,
+        };
+    }
+
     async _doSendXaiResponses(messages, useModel, tools, opts) {
         const signal = opts.signal || null;
         if (signal?.aborted) {
@@ -589,8 +691,11 @@ export class OpenAICompatProvider {
             // existing request bodies.
             store: false,
             include: ['reasoning.encrypted_content'],
-            prompt_cache_key: cacheRouting.key,
         };
+        // A null routing key means "omit the field" (cache scope 'none'):
+        // xAI's own client sends no prompt_cache_key and relies on the
+        // service's automatic prefix caching.
+        if (cacheRouting.key) params.prompt_cache_key = cacheRouting.key;
         if (previousResponseId) params.previous_response_id = previousResponseId;
         const nativeTools = nativeResponsesTools(opts);
         if (tools?.length || nativeTools.length) params.tools = [...nativeTools, ...toResponsesTools(tools || [], { provider: 'xai' })];
@@ -797,8 +902,8 @@ export class OpenAICompatProvider {
             input,
             store: false,
             include: ['reasoning.encrypted_content'],
-            prompt_cache_key: cacheRouting.key,
         };
+        if (cacheRouting.key) params.prompt_cache_key = cacheRouting.key;
         const instructions = xaiSystemInstructions(messages);
         if (previousResponseId) params.previous_response_id = previousResponseId;
         // xAI rejects instructions together with previous_response_id; the

package/src/runtime/agent/orchestrator/providers/openai-oauth-http-sse.mjs

@@ -38,6 +38,7 @@ import { createLeakGuard, createToolCallDedupe, dedupeToolCallList } from './ant
 import { customToolCallFromResponseItem } from './custom-tool-wire.mjs';
 import { CODEX_OAUTH_ORIGINATOR, CODEX_RESPONSES_URL, _displayCodexModel } from './openai-oauth.mjs';
 import { createActiveToolItemTracker } from './tool-stream-state.mjs';
+import { parseProviderJsonBatch } from './stream-json-pool.mjs';
 export { envPositiveInt as _envPositiveInt } from './lib/env-utils.mjs';
 
 // Public OpenAI Responses API endpoint for the api-key `openai` provider.
@@ -114,6 +115,18 @@ function _parseSseFrame(frame) {
     try { return JSON.parse(raw); } catch { return null; }
 }
 
+function _sseJsonPayload(frame) {
+    const lines = String(frame || '').split('\n');
+    const data = [];
+    for (const line of lines) {
+        if (!line || line.startsWith(':')) continue;
+        if (line.startsWith('data:')) data.push(line.slice(5).trimStart());
+    }
+    if (!data.length) return null;
+    const raw = data.join('\n').trim();
+    return !raw || raw === '[DONE]' ? null : raw;
+}
+
 function _incompleteReasonFromEvent(event) {
     const reasonObj = event?.response?.incomplete_details
         || event?.incomplete_details
@@ -1003,10 +1016,12 @@ export async function sendViaHttpSse({
             buffer += decoder.decode(value, { stream: true });
             const parsed = _sseEventsFromBuffer(buffer);
             buffer = parsed.rest;
-            for (const frame of parsed.frames) {
-                const event = _parseSseFrame(frame);
-                if (event) handleEvent(event);
-            }
+            const payloads = parsed.frames.map(_sseJsonPayload).filter((payload) => payload !== null);
+            // These bytes have already been delivered by reader.read(). Finish
+            // this bounded chunk before observing abort on the next read so
+            // visible text is never lost at the cancellation boundary.
+            const events = await parseProviderJsonBatch(payloads);
+            for (const event of events) handleEvent(event);
         }
         // The read() above can unblock via reader.cancel() as {done:true} on an
         // external/total-timeout abort. Surface that as the abort/timeout error
@@ -1014,10 +1029,9 @@ export async function sendViaHttpSse({
         if (_streamAbortReason) throw _streamAbortReason;
         buffer += decoder.decode();
         const parsed = _sseEventsFromBuffer(buffer + '\n\n');
-        for (const frame of parsed.frames) {
-            const event = _parseSseFrame(frame);
-            if (event) handleEvent(event);
-        }
+        const payloads = parsed.frames.map(_sseJsonPayload).filter((payload) => payload !== null);
+        const events = await parseProviderJsonBatch(payloads);
+        for (const event of events) handleEvent(event);
         // Flush any partial-sentinel tail held back mid-stream so legitimate
         // trailing text is never lost (streamed-text path).
         flushLeak();

package/src/runtime/agent/orchestrator/providers/openai-oauth.mjs

@@ -467,6 +467,20 @@ export class OpenAIOAuthProvider {
                 }
                 throw new Error(`OpenAI OAuth token refresh failed (${msg}). Re-authenticate via provider login.`);
             }
+        }, {
+            // OAuth refresh includes network exchange plus owner-only atomic
+            // persistence. Match the Anthropic/xAI lease: the generic 2s file
+            // lock timeout is too short under Windows ACL and process contention.
+            timeoutMs: 120_000,
+            staleMs: 120_000,
+            secret: true,
+        }, {
+            // OAuth refresh includes network exchange plus owner-only atomic
+            // persistence. Match the Anthropic/xAI lease: the generic 2s file
+            // lock timeout is too short under Windows ACL and process contention.
+            timeoutMs: 120_000,
+            staleMs: 120_000,
+            secret: true,
         }).finally(() => { _oauthRefreshInFlight = null; });
 
         this.tokens = await _oauthRefreshInFlight;
@@ -651,7 +665,7 @@ export class OpenAIOAuthProvider {
             // properties (instructions/tools/etc.) but never send the live
             // transcript/user input. The completed generate:false response is
             // retained by the WS transport and anchors the first real request.
-            warmupBody: _envFlag('MIXDOG_OPENAI_OAUTH_WS_WARMUP', true)
+            warmupBody: _envFlag('MIXDOG_OPENAI_OAUTH_WS_WARMUP', false)
                 ? { ...body, input: [], generate: false }
                 : null,
             _carriedWarmup: carriedWarmup,

package/src/runtime/agent/orchestrator/providers/openai-transport-policy.mjs

@@ -113,7 +113,7 @@ export function resolveResponsesTransportPolicy(env = process.env, capabilities
         mode,
         requestedMode,
         transport,
-        // Codex refs behavior: default/auto is WS-first but not WS-only. If the
+        // Reference behavior: default/auto is WS-first but not WS-only. If the
         // websocket path stalls/fails before emitting live output, callers may
         // replay the request over HTTP/SSE. Explicit ws-* modes remain pinned
         // for transport experiments; explicit http-sse bypasses WS entirely.

package/src/runtime/agent/orchestrator/providers/openai-ws-pool.mjs

@@ -323,10 +323,9 @@ function _buildHandshakeHeaders({ auth, sessionToken, turnState, cacheKey: _cach
             'chatgpt-account-id': auth.account_id || '',
             'originator': codexOriginator(),
             'OpenAI-Beta': 'responses_websockets=2026-02-06',
-            // codex-rs merges provider http_headers ("version") plus
-            // default_headers (User-Agent) into the WS handshake
-            // (client.rs:970-975, model-provider-info/src/lib.rs:339-343,
-            // login default_client.rs:289-305). The backend fingerprints
+            // The reference client merges provider http_headers ("version")
+            // plus default headers (User-Agent) into the WS handshake.
+            // The backend fingerprints
             // clients on these; missing them can route us onto a different
             // (colder) cache-node class than codex.
             'User-Agent': codexUserAgent(),

package/src/runtime/agent/orchestrator/providers/openai-ws-stream.mjs

@@ -535,12 +535,9 @@ export async function _streamResponse({
     // only) trips a short, named terminal StreamStalledError instead of coasting
     // to the 300s inter-chunk cap / 30-min agent watchdog.
     let semanticIdleTimer = null;
-    // WS gets its own shorter semantic-idle window. The shared SSE semantic
-    // timeout is intentionally near the 300s stall warning to protect Anthropic
-    // effort-mode "silent thinking"; using that value here lets a wedged WS
-    // request race the TUI 300s watchdog. Keep websocket stalls provider-owned:
-    // fail/retry/fallback here first, then let the TUI watchdog remain a final
-    // safety net only.
+    // WS owns its semantic-idle window. The TUI backstop is deliberately much
+    // longer, so this timeout can fail/retry/fallback at the provider boundary
+    // without racing an outer turn abort (Claude Code/Codex parity).
     const semanticIdleMs = PROVIDER_WS_SEMANTIC_IDLE_TIMEOUT_MS;
     const semanticIdleEnabled = PROVIDER_SSE_IDLE_WATCHDOG_ENABLED && semanticIdleMs > 0;
     // First-meaningful-frame watchdog timer + one-shot latch. Armed alongside

package/src/runtime/agent/orchestrator/providers/registry.mjs

@@ -35,7 +35,7 @@ let _initChain = Promise.resolve();
 let _inFlightPromise = null;
 let _inFlightSig = null;
 let _lastAppliedSig = null;
-// Provider instances are process-global inside the backend daemon. Catalog
+// Provider instances are process-global inside the daemon. Catalog
 // readers use this revision to share one raw model snapshot while still
 // rebuilding their cheap route/config projection after auth/config changes.
 let _providerCatalogRevision = 0;
@@ -367,7 +367,7 @@ function warmupCatalogs() {
     }
 }
 
-// Force-refresh each provider's /models catalog ONCE per backend-daemon
+// Force-refresh each provider's /models catalog once per daemon.
 // lifetime. Every session runtime joins this process-global promise and then
 // reads the same provider-instance caches. Unlike
 // warmupCatalogs (which calls listModels() and so respects the 24h provider

package/src/runtime/agent/orchestrator/providers/retry-classifier.mjs

@@ -104,6 +104,15 @@ export function classifyError(err) {
   if (err.truncatedStream === true || err.code === 'TRUNCATED_STREAM') return 'transient'
 
   if (TRANSIENT_STATUSES.has(status) || (status >= 500 && status < 600)) return 'transient'
+  // A stream that closed WITHOUT its terminal frame is a transport symptom,
+  // not a model verdict: the socket carries no HTTP status and no Node errno,
+  // so without this it classified as 'unknown' and no loop-level replay was
+  // ever attempted (observed live: pooled WS retired by the server between
+  // turns → close 1000 before response.created → the whole turn failed).
+  // Reference behavior retries the same disconnect (codex `CodexErr::Stream`
+  // is_retryable, cc falls back/retries the stream); the exposure deny above
+  // still fails closed for anything already relayed or dispatched.
+  if (isNonTerminalStreamClose(err)) return 'transient'
 
   // Socket-level codes (Node errno) — DNS / reset / refused / timeout are all
   // transient: we can retry the same request and may succeed.
@@ -124,6 +133,50 @@ const TRANSIENT_ERROR_CODES = new Set([
   'EPROVIDERTIMEOUT', 'EGEMINITIMEOUT', 'ESTREAMSTALL', 'EWSACQUIRETIMEOUT',
 ])
 
+// WebSocket close codes that can end a Responses stream BEFORE its terminal
+// frame. 1000/1001/1005 are "nominal" closes the server sends when it retires
+// a pooled socket; 1006/1011/1012 are abnormal/overload closes. None of them
+// is a completed turn, and all are safe to re-issue when nothing was exposed.
+// 4000 is our own local stall close and keeps the stall classification path.
+const NON_TERMINAL_STREAM_CLOSE_CODES = new Set([1000, 1001, 1005, 1006, 1011, 1012])
+
+/**
+ * True when the error describes a stream socket that closed without the
+ * provider's terminal frame (response.completed / message_stop). Replay
+ * PERMISSION is still owned by the stream-outcome contract; this predicate
+ * only answers "was this a transport-level disconnect".
+ */
+export function isNonTerminalStreamClose(err) {
+  if (!err || typeof err !== 'object') return false
+  const code = Number(err.wsCloseCode ?? err.streamCloseCode ?? 0) || 0
+  if (!NON_TERMINAL_STREAM_CLOSE_CODES.has(code)) return false
+  return readStreamOutcome(err).terminalObserved !== true
+}
+
+/**
+ * Should this failed stream be re-issued as a NON-STREAMING request?
+ *
+ * cc's last safety net: when a stream dies it repeats the same request with
+ * `stream:false` instead of failing the turn (claude.ts, gated off only when
+ * streaming tool execution could double-run a tool). MixDog dispatches tools
+ * eagerly, so this stays deliberately narrower than cc: only a stream that
+ * exposed NOTHING qualifies. An exposed stream is already covered by the
+ * loop-level retraction replay (send-with-recovery), which asks the owner to
+ * withdraw the rendered characters first.
+ */
+export function canFallbackNonStreaming(err, { signal } = {}) {
+  if (!err || signal?.aborted) return false
+  const outcome = readStreamOutcome(err)
+  // A completed turn needs no fallback; a user cancel must never be re-issued.
+  if (outcome.terminalObserved || outcome.userAbort) return false
+  // Exposure/dispatch fails closed — re-running would duplicate output or a
+  // side effect.
+  if (outcome.replaySafe !== true) return false
+  return classifyError(err) === 'transient'
+    || outcome.stallObserved === true
+    || outcome.truncatedStream === true
+}
+
 function boundedCauseChain(err) {
   const chain = []
   const seen = new Set()
@@ -435,11 +488,13 @@ function _classifyMidstreamWs(err, state, attemptIndex, policy) {
   }
   if (!state.sawResponseCreated) {
     const closeCode = Number(err?.wsCloseCode || state.wsCloseCode || 0)
-    // An abnormal close before response.created has not produced any response
-    // bytes to the caller. It is therefore safe to reconnect and replay under
-    // the normal ws_1006 bounded retry policy (text/tool emission was denied
-    // above before reaching this gate).
-    if (closeCode !== 1006 && closeCode !== 1011 && closeCode !== 1012) return null
+    // A close before response.created has not produced any response bytes to
+    // the caller, so it is safe to reconnect and replay under the bounded
+    // retry policy (text/tool emission was denied above before this gate).
+    // NOMINAL closes count too: a pooled socket the server retires between
+    // turns closes with 1000/1001/1005 and must reconnect fresh — treating
+    // that as terminal killed the turn instead of reissuing it.
+    if (!NON_TERMINAL_STREAM_CLOSE_CODES.has(closeCode)) return null
   }
   if (state.userAbort) return null
 
@@ -465,7 +520,11 @@ function _classifyMidstreamWs(err, state, attemptIndex, policy) {
   if (closeCode === 1012) return _allowMidstream('ws_1012', attemptIndex, policy)
   if (closeCode >= 4000 && closeCode < 5000 && closeCode !== 4000) return null
   if (closeCode === 4000) return _allowMidstream('ws_4000', attemptIndex, policy)
-  if (closeCode === 1000 && state.sawResponseCreated && !state.sawCompleted) return _allowMidstream('ws_1000', attemptIndex, policy)
+  // Nominal close without the terminal frame — before OR after
+  // response.created. Only a completed turn is terminal here.
+  if ((closeCode === 1000 || closeCode === 1001 || closeCode === 1005) && !state.sawCompleted) {
+    return _allowMidstream(`ws_${closeCode}`, attemptIndex, policy)
+  }
 
   const failed = err?.responseFailed || state.responseFailedPayload
   if (failed) {
@@ -536,7 +595,8 @@ function _classifyMidstreamSse(err, state, attemptIndex, policy) {
 const TRANSPORT_FALLBACK_CLASSIFIERS = new Set([
   'timeout', 'reset', 'dns', 'refused', 'network', 'acquire_timeout', 'http_5xx',
   'first_byte_timeout',
-  'ws_1006', 'ws_1011', 'ws_1012', 'ws_1000', 'ws_4000', 'agent_stall', 'stream_stalled',
+  'ws_1006', 'ws_1011', 'ws_1012', 'ws_1000', 'ws_1001', 'ws_1005', 'ws_4000',
+  'agent_stall', 'stream_stalled',
   'response_failed_disconnected', 'response_failed_network', 'response_failed_auth_expired',
   'ws_send_failed',
 ])