cut"),
+ ];
+ for (const e of errors) {
+ const said = failureMessage(e.message);
+ assert.ok(!said.includes(".."), said);
+ assert.match(said, /^Conversion failed: /);
+ assert.match(said, /You can try again\.$/);
+ }
+});
diff --git a/test/empty-stream-retry.test.ts b/test/empty-stream-retry.test.ts
new file mode 100644
index 00000000..74b2607f
--- /dev/null
+++ b/test/empty-stream-retry.test.ts
@@ -0,0 +1,343 @@
+// A response stream that opens, sends nothing, and closes (issue #480: a user's document
+// failed with "0 chars received, no message_stop and no stop_reason", and the whole
+// conversion was lost).
+//
+// The distinction every test here turns on is between a stream that ended SHORT and one
+// that ended EMPTY. They used to share one message and one outcome, and they are opposite
+// diagnoses:
+//
+// - Ended short: a document is in hand, missing its end. Sending it again would have to
+// discard what was generated or resume mid-document, so it fails — and must keep
+// failing, which is what the "not retried" tests below pin.
+// - Ended empty: nothing is in hand. Nothing to discard, nothing that can ship short, and
+// nothing about the request the upstream objected to — so it is sent again.
+//
+// Two things are pinned as hard as the retry itself, because both are ways a retry does
+// damage rather than good. A stalled call must not become a retried one: it would double
+// the time a wedged session takes to fail, and `expired` is checked before the completeness
+// check that raises this, which is what makes that true. And the abandoned attempt's token
+// counts must survive into the surviving attempt's report: the Anthropic stream reports the
+// prompt's counts in `message_start`, so an attempt that got that far and closed was billed,
+// and a call that paid for two prompts must not be logged as having paid for one.
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { BedrockProvider } from "../src/providers/bedrock.ts";
+import { OpenRouterProvider } from "../src/providers/openrouter.ts";
+import { EmptyStreamError, StalledStreamError, type Usage } from "../src/providers/types.ts";
+
+const encode = (o: unknown) => new TextEncoder().encode(JSON.stringify(o));
+const messageStart = (usage?: Record second time second time ok converse converse whole whole half")],
+ async (calls) => {
+ await assert.rejects(
+ () => openrouter().complete(openrouterReq),
+ (e: Error) => {
+ assert.ok(!(e instanceof EmptyStreamError));
+ assert.match(e.message, /7 chars received/);
+ return true;
+ },
+ );
+ assert.equal(calls(), 1);
+ },
+ );
+});
+
+test("an OpenRouter upstream that answers three times with nothing fails, naming the attempts", async () => {
+ // Three, not two, because this adapter's retry budget is its own (MAX_ATTEMPTS) and the
+ // empty stream joins it rather than bringing a budget of its own.
+ await withFetch(
+ () => [],
+ async (calls) => {
+ await assert.rejects(
+ () => openrouter().complete(openrouterReq),
+ (e: Error) => {
+ assert.ok(e instanceof EmptyStreamError);
+ assert.equal(e.attempts, 3);
+ assert.match(e.message, /Sent 3 times/);
+ assert.doesNotMatch(e.message, /partial document/);
+ return true;
+ },
+ );
+ assert.equal(calls(), 3);
+ },
+ );
+});
From ec94b08689cd41496378f50b74764cb6353fbc2c Mon Sep 17 00:00:00 2001
From: Blake Bertuccelli-Booth <46652+bbertucc@users.noreply.github.com>
Date: Thu, 24 Sep 2026 18:05:24 -0400
Subject: [PATCH 2/3] fix(providers): the empty-stream message is short, and
the retry's cost is stated from the logs
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Answers the three review notes on this branch, and corrects one claim the
production logs disprove.
The message. The demo reads it aloud in a live region and then adds its own "You
can try again." It had grown to 97 words and ended by saying "try again" twice.
It now says what happened and how many sends it took, in about 30 words. It keeps
"ended without completing", which is what people already search run logs for. A
test pins one "again" and at most 40 words.
The ellipsis. `failureMessage` did not treat `…` as the end of a sentence, and the
test that said it did could not fail, because `….` never contains `..`. `…` is in
the pattern now and the test asserts the exact string. It fails on the old pattern.
design-notes.md said Bedrock has no retry loop on purpose. It has one narrow loop
now, so the paragraph says so and gives the worst case: 6 wire attempts instead
of 3.
The claim. The code said an empty stream closes "quickly". On the UIC deployment
all three empty streams came from us.openai.gpt-5.6-luna, after 42, 82 and 83
seconds. The comment now says so, and that a retry can add up to 120 s to a page.
Co-Authored-By: Claude Opus 5.5 Whole
"), messageDelta("end_turn")],
+ );
+ const [res, said] = await capturingWarnings(() => bedrock.complete(bedrockReq));
+ assert.equal(res.text, "Whole
");
+ assert.equal(sends.count(), 2);
+ // A call that succeeds on its second attempt is otherwise invisible — the `model_call`
+ // line reports one call with a longer duration — so the warning is the run's only record
+ // that this deployment is meeting the failure at all, and its frequency is the whole
+ // question a reader would have.
+ assert.equal(said.length, 1);
+ assert.match(said[0], /sent nothing at all/);
+ assert.match(said[0], /paid for, a second time/);
+});
+
+test("a Bedrock stream that closes after message_start alone is still empty, and still retried", async () => {
+ // The likelier shape of #480 on this API, and the one that decides whether the retry is
+ // reachable at all in production: `message_start` has arrived, so the prompt has been read
+ // and billed, and only then does the stream close. Nothing was GENERATED, which is the
+ // condition — a guard written on "has this call cost anything" instead would refuse to
+ // retry exactly the case the issue was filed about.
+ const bedrock = new BedrockProvider({ default_model: "m" });
+ const sends = stubSends(bedrock, (send) =>
+ send === 1
+ ? [messageStart({ input_tokens: 900 })]
+ : [messageStart({ input_tokens: 900 }), textDelta("half a document")]);
+ await assert.rejects(
+ () => bedrock.complete(bedrockReq),
+ (e: Error) => {
+ assert.ok(!(e instanceof EmptyStreamError));
+ assert.match(e.message, /30 chars received/);
+ assert.match(e.message, /partial document/);
+ return true;
+ },
+ );
+ assert.equal(sends.count(), 1);
+});
+
+test("a Bedrock call that stalls before any output is a stall, not an empty stream", async () => {
+ // The other safety pin, and the reason the retry cannot lengthen a wedged session: a call
+ // abandoned by our own clock has also received 0 characters, so if the completeness check
+ // were reached first it would look identical to #480 and be sent again — turning a
+ // 120-second failure into a 240-second one. `expired` is checked first, and this is what
+ // says so.
+ const bedrock = new BedrockProvider({ default_model: "m" }, { firstOutputTimeoutMs: 50 });
+ let sends = 0;
+ (bedrock as unknown as { client: unknown }).client = {
+ send: async (_cmd: unknown, opts: { abortSignal: AbortSignal }) => {
+ sends++;
+ return {
+ body: (async function* () {
+ // Silent until the first-output clock fires, then end without throwing — the
+ // abort shape that reaches the completeness check rather than the catch.
+ await new Promise About
const why = String(error || '').trim() || 'unknown error';
// A closing quote or bracket may follow the stop — a message that ends by quoting
// what an upstream said ("…decrease input length or `max_tokens` and try again.")
- // is still a finished sentence.
- const ended = /[.!?]["'`)\]]?$/.test(why);
+ // is still a finished sentence. `…` is its own character, not three dots, so it is
+ // listed: an upstream message forwarded verbatim can end in one.
+ const ended = /[.!?…]["'`)\]]?$/.test(why);
return 'Conversion failed: ' + why + (ended ? '' : '.') + ' You can try again.';
}
async function pollStatus() {
diff --git a/src/providers/bedrock.ts b/src/providers/bedrock.ts
index a6e69552..1c19071a 100644
--- a/src/providers/bedrock.ts
+++ b/src/providers/bedrock.ts
@@ -807,9 +807,16 @@ export class BedrockProvider implements ModelProvider {
// Safe in the two ways the note above `BedrockProvider` says a mid-stream retry usually
// is not. Nothing is discarded: `EmptyStreamError` is raised only when not one character
// arrived, so there is no partial document to throw away and no risk of a passage
- // shipping twice. And it cannot lengthen a stall, because a stalled attempt is a
- // `StalledStreamError` — checked before the completeness check that raises this — so the
- // attempt this follows is always one that closed cleanly and, being empty, quickly.
+ // shipping twice. And a stalled attempt is never retried: a stall is a `StalledStreamError`,
+ // checked before the completeness check that raises this, so the attempt this follows is
+ // one the upstream closed itself.
+ //
+ // "Closed itself" does not mean "closed quickly". On the UIC deployment every empty stream
+ // came from one model, us.openai.gpt-5.6-luna on Converse, after 42, 82 and 83 seconds of
+ // silence (3 of its 308 page calls from 2026-09-01 to 09-24; the same model also hit the
+ // 120 s first-output stall 10 times, and no other model did either). So the retry can add up
+ // to one more first-output window, 120 s, to a page. That is the price of not losing the
+ // document, and it stays inside MAX_TOTAL_MS.
//
// Not free, though, and the cost is worth stating: the Anthropic stream reports the
// prompt's counts in `message_start`, so an attempt that got that far and then closed was
diff --git a/src/providers/types.ts b/src/providers/types.ts
index a33cc029..7bb257e8 100644
--- a/src/providers/types.ts
+++ b/src/providers/types.ts
@@ -492,23 +492,24 @@ export class StalledStreamError extends Error {
// `attempts` is what makes the surviving message honest about cost — a re-sent call was
// billed for its prompt more than once — and is the one line in a run log that says the
// retry was reached and did not help.
+//
+// Short on purpose. This message is what the demo reads out in a live region, followed by
+// its own "You can try again." (public/demo.html, `failureMessage`), so it says what
+// happened and stops. Advice to send it again would be said twice, and the reasoning above
+// is for whoever reads this file, not for someone whose document just failed.
export class EmptyStreamError extends Error {
readonly provider: string;
readonly model: string;
readonly attempts: number;
constructor(args: { provider: string; model: string; attempts: number; detail: string }) {
+ // "ended without completing" is kept from the old message on purpose: it is what anyone
+ // searching run logs for this failure already searches for.
super(
`${args.provider}: the response stream ended without completing on ${args.model}, ` +
- `having delivered nothing at all — no content, ${args.detail}. ` +
- (args.attempts > 1
- ? `Sent ${args.attempts} times in all, since a stream that produced nothing cannot ` +
- `deliver a document twice over, and every attempt ended the same way. `
- : ``) +
- `Nothing partial arrived, so no part of a document is at risk of shipping short: ` +
- `what failed is the upstream closing a 200 response before saying anything, which ` +
- `is not something the request can be at fault for. Sending the document again is ` +
- `the remedy.`,
+ `having sent nothing (${args.detail}).` +
+ (args.attempts > 1 ? ` Sent ${args.attempts} times, and each ended the same way.` : ``) +
+ ` Nothing partial was kept.`,
);
this.name = "EmptyStreamError";
this.provider = args.provider;
diff --git a/test/demo-error-sentence.test.ts b/test/demo-error-sentence.test.ts
index f7f71053..0aaec785 100644
--- a/test/demo-error-sentence.test.ts
+++ b/test/demo-error-sentence.test.ts
@@ -62,11 +62,27 @@ test("an ellipsis, a question and a quoted ending are all already finished", ()
"bedrock: decrease input length or `max_tokens` and try again.",
"openrouter: is the model name right?",
]) {
- assert.ok(!failureMessage(why).includes(".."), why);
- assert.match(failureMessage(why), /You can try again\.$/);
+ // The exact string, not "contains no `..`": `…` is one character, so `….` never contains
+ // `..` and that check passed on the very input it names.
+ assert.equal(failureMessage(why), `Conversion failed: ${why} You can try again.`, why);
}
});
+test("the #480 failure is read out once, briefly, and says to try again only once", () => {
+ // This is what a screen-reader user hears in a live region. A retry that fails twice used to
+ // announce 97 words ending in two ways of saying "try again".
+ const e = new EmptyStreamError({
+ provider: "bedrock",
+ model: "us.openai.gpt-5.6-luna",
+ attempts: 2,
+ detail: "no message_stop and no stop_reason",
+ });
+ const said = failureMessage(e.message);
+ assert.equal(said.match(/again/gi)?.length, 1, said);
+ const words = said.split(/\s+/).length;
+ assert.ok(words <= 40, `${words} words: ${said}`);
+});
+
test("no error, an empty one, or a blank one still says something", () => {
// A `failed` session with no `error` recorded is the shape this fallback exists for, and
// "Conversion failed: . You can try again." would be the alternative.
diff --git a/test/empty-stream-retry.test.ts b/test/empty-stream-retry.test.ts
index 74b2607f..0c51a943 100644
--- a/test/empty-stream-retry.test.ts
+++ b/test/empty-stream-retry.test.ts
@@ -160,7 +160,7 @@ test("two empty Bedrock streams fail, saying so, and do not describe a document
// second attempt's own, which says nothing about the first.
assert.match(e.message, /Sent 2 times/);
assert.match(e.message, /ended without completing/);
- assert.match(e.message, /nothing at all/);
+ assert.match(e.message, /having sent nothing/);
// The old message's wording, which was the actual defect in #480: an operator
// reading "a partial document" about a response of zero characters is being
// pointed at a truncation that did not happen.
From d8073f3e2bbd698aa6147bf45123d9fe1fdc7a9b Mon Sep 17 00:00:00 2001
From: Blake Bertuccelli-Booth <46652+bbertucc@users.noreply.github.com>
Date: Thu, 24 Sep 2026 18:20:53 -0400
Subject: [PATCH 3/3] docs(bedrock): the empty-stream retry is not capped by
MAX_TOTAL_MS
Each send arms its own total timer, so the retry gets a fresh 15 minutes.
The comment said the retry stays inside MAX_TOTAL_MS; it now says what
the worst case is.
Co-Authored-By: Claude Opus 5.5