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..0c51a943
--- /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);
+ },
+ );
+});
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