@plurnk/plurnk-providers 1.3.3 → 1.3.5

package/src/OpenAICompat.test.ts

@@ -25,8 +25,7 @@ const installFetch = (chunks: unknown[]) => {
     return calls;
 };
 
-// Fake fetch returning one non-streamed JSON body — for the paths the spine
-// demotes off SSE (a response_format grammar). Captures the request the same way.
+// Fake fetch returning one non-streamed JSON body. Captures the request too.
 const installFetchJson = (payload: unknown) => {
     const calls: { url: string; init: RequestInit }[] = [];
     mock.method(globalThis, "fetch", async (url: string, init: RequestInit) => {
@@ -235,17 +234,17 @@ test("identity getters and defaults", () => {
     assert.equal(p.contextWindow, null); // default
     assert.equal(p.countTokens(""), 0);
     assert.equal(p.countTokens("four"), 2); // default heuristic ceil(4/2) upper bound
-    assert.equal(p.costFor({ prompt: 9, completion: 9, reasoning: 0, cached: 0, total: 18 }), 0); // default free
+    assert.equal(p.calculateCost({ prompt: 9, completion: 9, reasoning: 0, cached: 0, total: 18 }), 0); // default free
 });
 
-test("injected countTokens and costFor are used", () => {
+test("injected countTokens and calculateCost are used", () => {
     const p = new OpenAICompatProvider({
         model: "m", url: "http://x", fetchTimeoutMs: 1000, temperature: 0.2, repeatPenalty: 1.15, retryDelayMs: 1, reasoning: { mode: "off", budget: null }, retryAttempts: 0,
         countTokens: (t) => t.length,
-        costFor: (u) => u.total * 2,
+        calculateCost: (u) => u.total * 2,
     });
     assert.equal(p.countTokens("abc"), 3);
-    assert.equal(p.costFor({ prompt: 1, completion: 1, reasoning: 0, cached: 0, total: 5 }), 10);
+    assert.equal(p.calculateCost({ prompt: 1, completion: 1, reasoning: 0, cached: 0, total: 5 }), 10);
 });
 
 test("generate maps a streamed response into ProviderResponse", async () => {
@@ -371,15 +370,14 @@ test("reasoningStyle 'effort_explicit': off SENDS none, adaptive OMITS (#403 —
 });
 
 test("the family temperature default rides every request; caller sampling overrides it (#30)", async () => {
-    const p = new OpenAICompatProvider({ model: "m", url: "http://x", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, retryDelayMs: 1, reasoning: { mode: "off", budget: null }, retryAttempts: 0, grammarStyle: "response_format" });
-    // default rides with the grammar (non-streamed demotion path)
-    let calls = installFetchJson(jsonChoice);
-    await p.generate({ workerId: "r", messages: [], grammar: 'root ::= "x"' });
+    const p = new OpenAICompatProvider({ model: "m", url: "http://x", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, retryDelayMs: 1, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
+    let calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
+    await p.generate({ workerId: "r", messages: [] });
     assert.equal(JSON.parse(calls[0].init.body as string).temperature, 0.2);
     mock.restoreAll();
     // explicit caller sampling wins over the default
-    calls = installFetchJson(jsonChoice);
-    await p.generate({ workerId: "r", messages: [], grammar: 'root ::= "x"', sampling: { temperature: 0.7 } });
+    calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
+    await p.generate({ workerId: "r", messages: [], sampling: { temperature: 0.7 } });
     assert.equal(JSON.parse(calls[0].init.body as string).temperature, 0.7);
     mock.restoreAll();
     // temperature is now the UNIVERSAL default: present without a grammar too
@@ -419,24 +417,6 @@ test("#567: DRY + repeat_last_n ride the llamacpp path when set; unset leaves th
     mock.restoreAll();
 });
 
-test("effort_explicit: intent maps IDENTICALLY with and without a grammar — the #32 clamp is lifted (reasoning+rails coexist)", async () => {
-    const warned: Array<string | Error> = [];
-    mock.method(process, "emitWarning", (msg: string | Error) => { warned.push(msg); });
-    const p = new OpenAICompatProvider({ model: "m", url: "http://x", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, retryDelayMs: 1, reasoning: { mode: "on", budget: 8192 }, retryAttempts: 0, reasoningStyle: "effort_explicit", grammarStyle: "response_format", source: "provider:test" });
-    // grammar transported → intent STILL flows through (canary-verified: the mask
-    // covers only content; clamping to "none" was the plan-less #331 regression)
-    let calls = installFetchJson(jsonChoice);
-    await p.generate({ workerId: "r", messages: [], grammar: 'root ::= "x"' });
-    assert.equal(JSON.parse(calls[0].init.body as string).reasoning_effort, "high");
-    assert.equal(warned.filter((w) => String(w).includes("clamped")).length, 0, "no clamp warning — the clamp is gone");
-    mock.restoreAll();
-    // no grammar → same mapping
-    const p2 = new OpenAICompatProvider({ model: "m", url: "http://x", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, retryDelayMs: 1, reasoning: { mode: "on", budget: 8192 }, retryAttempts: 0, reasoningStyle: "effort_explicit", grammarStyle: "response_format" });
-    calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
-    await p2.generate({ workerId: "r", messages: [] });
-    assert.equal(JSON.parse(calls[0].init.body as string).reasoning_effort, "high");
-});
-
 test("llamacpp grammar path: temperature default + the managed repeat-penalty floor", async () => {
     const p = new OpenAICompatProvider({ model: "m", url: "http://x", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, retryDelayMs: 1, reasoning: { mode: "off", budget: null }, retryAttempts: 0, grammarStyle: "llamacpp" });
     const calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
@@ -447,15 +427,9 @@ test("llamacpp grammar path: temperature default + the managed repeat-penalty fl
 });
 
 test("#426: the repeat penalty rides EVERY request rail-off, keyed per backend (cloud degeneration guard)", async () => {
-    // response_format cloud (fireworks) with NO grammar - the firefast case that went out bare
-    const fw = new OpenAICompatProvider({ model: "m", url: "http://x", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, retryDelayMs: 1, reasoning: { mode: "off", budget: null }, retryAttempts: 0, grammarStyle: "response_format" });
-    let calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
-    await fw.generate({ workerId: "r", messages: [] });
-    assert.equal(JSON.parse(calls[0].init.body as string).repetition_penalty, 1.15);
-    mock.restoreAll();
-    // llama.cpp with NO grammar carries its key too (unconstrained local is guarded now)
+    // llama.cpp with NO grammar carries its key too (unconstrained local is guarded)
     const llama = new OpenAICompatProvider({ model: "m", url: "http://x", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, retryDelayMs: 1, reasoning: { mode: "off", budget: null }, retryAttempts: 0, grammarStyle: "llamacpp" });
-    calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
+    let calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
     await llama.generate({ workerId: "r", messages: [] });
     assert.equal(JSON.parse(calls[0].init.body as string).repeat_penalty, 1.15);
     mock.restoreAll();
@@ -609,32 +583,6 @@ test("grammar transport 'llamacpp': top-level grammar + the repeat-penalty floor
     assert.equal("response_format" in body, false);
 });
 
-test("grammar transport 'response_format': response_format.grammar, no top-level grammar (Fireworks)", async () => {
-    const p = new OpenAICompatProvider({ model: "m", url: "http://x", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, retryDelayMs: 1, reasoning: { mode: "off", budget: null }, retryAttempts: 0, grammarStyle: "response_format" });
-    const calls = installFetchJson(jsonChoice);   // response_format grammar demotes off SSE
-    await p.generate({ workerId: "r", messages: [], grammar: 'root ::= "x"' });
-    const body = JSON.parse(calls[0].init.body as string);
-    assert.deepEqual(body.response_format, { type: "grammar", grammar: 'root ::= "x"' });
-    assert.equal("grammar" in body, false);          // not the llama.cpp shape
-    assert.equal("repeat_penalty" in body, false);   // llama.cpp spelling not used here
-    assert.equal(body.repetition_penalty, 1.15);     // the floor still rides (OpenAI-compat spelling, #20)
-});
-
-// A response_format grammar is the one case the spine drops streaming for, even
-// with streaming on (default): fireworks mislabels the streamed grammar output
-// as reasoning_content but returns it as content non-streamed (§13). The demotion
-// is per-request — a grammarless call on the same provider still streams.
-test("response_format grammar demotes THIS request off SSE; grammarless calls still stream", async () => {
-    const p = new OpenAICompatProvider({ model: "m", url: "http://x", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, retryDelayMs: 1, reasoning: { mode: "off", budget: null }, retryAttempts: 0, grammarStyle: "response_format" });
-    const jsonCalls = installFetchJson(jsonChoice);
-    await p.generate({ workerId: "r", messages: [], grammar: 'root ::= "x"' });
-    assert.equal("stream" in JSON.parse(jsonCalls[0].init.body as string), false);   // no SSE flag
-    mock.restoreAll();
-    const sseCalls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
-    await p.generate({ workerId: "r", messages: [] });                                   // no grammar → streams
-    assert.equal(JSON.parse(sseCalls[0].init.body as string).stream, true);           // SSE flag present
-});
-
 test("grammar transport 'none' (default): the grammar is never sent — no silent unconstrained", async () => {
     const p = new OpenAICompatProvider({ model: "m", url: "http://x", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, retryDelayMs: 1, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
     const calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);
@@ -756,31 +704,15 @@ test("gbnfDebug: an INVALID grammar throws before any wire call — it never rea
     assert.equal(calls.length, 0); // fail-hard before the fetch — grammar never transported
 });
 
-// — meta bag: pass-through extras + validated known keys (#23) —
+// — meta bag: verbatim provider metadata (#23) —
 
-test("meta: the spec's balance field is normalized to a validated meta.balancePico", async () => {
-    const p = new OpenAICompatProvider({ model: "m", url: "http://x", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, retryDelayMs: 1, reasoning: { mode: "off", budget: null }, retryAttempts: 0, streaming: false, balanceMetaKey: "balance_pico" });
-    installFetchJson({ ...jsonChoice, balance_pico: 4_200_000 });
-    const res = await p.generate({ workerId: "r", messages: [] });
-    assert.equal(res.meta?.balancePico, 4_200_000);
-    assert.equal("balance_pico" in (res.meta ?? {}), false); // raw key renamed to the canonical balancePico
-});
-
-test("meta: passes the backend's extra top-level fields through verbatim (every provider)", async () => {
-    const p = new OpenAICompatProvider({ model: "m", url: "http://x", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, retryDelayMs: 1, reasoning: { mode: "off", budget: null }, retryAttempts: 0, streaming: false }); // no balanceMetaKey
-    installFetchJson({ ...jsonChoice, balance_pico: 4_200_000, system_fingerprint: "fp_abc" });
+test("meta: passes backend fields through without reinterpreting monetary values", async () => {
+    const p = new OpenAICompatProvider({ model: "m", url: "http://x", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, retryDelayMs: 1, reasoning: { mode: "off", budget: null }, retryAttempts: 0, streaming: false });
+    const balance = { amount: "0.0000042", currency: "XMR" };
+    installFetchJson({ ...jsonChoice, balance, system_fingerprint: "fp_abc" });
     const res = await p.generate({ workerId: "r", messages: [] });
-    assert.equal(res.meta?.balance_pico, 4_200_000); // passed through raw — no balance contract on this provider
+    assert.deepEqual(res.meta?.balance, balance);
     assert.equal(res.meta?.system_fingerprint, "fp_abc");
-    assert.equal("balancePico" in (res.meta ?? {}), false); // not normalized without the key
-});
-
-test("meta: a non-numeric balance is dropped, never surfaced as balancePico (null-honest)", async () => {
-    const p = new OpenAICompatProvider({ model: "m", url: "http://x", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, retryDelayMs: 1, reasoning: { mode: "off", budget: null }, retryAttempts: 0, streaming: false, balanceMetaKey: "balance_pico" });
-    installFetchJson({ ...jsonChoice, balance_pico: "lots" });
-    const res = await p.generate({ workerId: "r", messages: [] });
-    assert.equal("balancePico" in (res.meta ?? {}), false);
-    assert.equal("balance_pico" in (res.meta ?? {}), false); // raw dropped too — the known key is validated away
 });
 
 // — first-party telemetry headers (attribution + client, SPEC §5) —
@@ -972,6 +904,74 @@ test("retry: a transient failure retries and a later success resolves", async ()
     assert.equal(calls.length, 3); // 429 → 503 → 200
 });
 
+test("#559: streamed-body silence retries and records the recovery in durable response metadata", async () => {
+    let calls = 0;
+    mock.method(globalThis, "fetch", async () => {
+        calls++;
+        if (calls === 1) {
+            return new Response(new ReadableStream({
+                start(controller) {
+                    controller.enqueue(new TextEncoder().encode('data: {"choices":[{"delta":{"content":"partial"}}]}\n\n'));
+                },
+            }), { status: 200 });
+        }
+        return new Response(new ReadableStream({
+            start(controller) {
+                controller.enqueue(new TextEncoder().encode('data: {"choices":[{"delta":{"content":"recovered"},"finish_reason":"stop"}]}\n\ndata: [DONE]\n\n'));
+                controller.close();
+            },
+        }), { status: 200 });
+    });
+    const p = new OpenAICompatProvider({
+        model: "m",
+        url: "http://x",
+        fetchTimeoutMs: 1000,
+        streamIdleTimeoutMs: 10,
+        temperature: 0.2,
+        repeatPenalty: 1.15,
+        retryDelayMs: 1,
+        reasoning: { mode: "off", budget: null },
+        retryAttempts: 1,
+        source: "provider:test",
+    });
+    const result = await p.generate({ workerId: "r", messages: [] });
+    assert.equal(result.assistant.content, "recovered");
+    assert.equal(calls, 2);
+    const retries = result.meta?.transportRetries as Array<Record<string, unknown>>;
+    assert.equal(retries.length, 1);
+    assert.equal(retries[0].attempt, 1);
+    assert.equal(retries[0].kind, "network_failure");
+    assert.equal(typeof retries[0].elapsedMs, "number");
+    assert.match(String(retries[0].message), /no body bytes for 10ms/);
+    mock.restoreAll();
+});
+
+test("#559: a zero stream-idle timeout permits a slow inter-chunk pause", async () => {
+    mock.method(globalThis, "fetch", async () => new Response(new ReadableStream({
+        async start(controller) {
+            controller.enqueue(new TextEncoder().encode('data: {"choices":[{"delta":{"content":"slow "}}]}\n\n'));
+            await new Promise((resolve) => setTimeout(resolve, 20));
+            controller.enqueue(new TextEncoder().encode('data: {"choices":[{"delta":{"content":"is valid"},"finish_reason":"stop"}]}\n\ndata: [DONE]\n\n'));
+            controller.close();
+        },
+    }), { status: 200 }));
+    const p = new OpenAICompatProvider({
+        model: "m",
+        url: "http://x",
+        fetchTimeoutMs: 1000,
+        streamIdleTimeoutMs: 0,
+        temperature: 0.2,
+        repeatPenalty: 1.15,
+        retryDelayMs: 1,
+        reasoning: { mode: "off", budget: null },
+        retryAttempts: 0,
+    });
+    const result = await p.generate({ workerId: "r", messages: [] });
+    assert.equal(result.assistant.content, "slow is valid");
+    assert.equal(result.meta?.transportRetries, undefined);
+    mock.restoreAll();
+});
+
 test("retry: exhausting the budget surfaces the classified ProviderError", async () => {
     const { ProviderError } = await import("./telemetry.ts");
     const calls = installFetchScript([{ status: 429, retryAfter: 0 }]); // always rate-limited

package/src/OpenAICompat.ts

@@ -29,23 +29,21 @@ import { emitWarningOnce } from "./warnings.ts";
 // (canary-verified; the #32 clamp is lifted — it caused the plan-less service#331).
 export type ReasoningStyle = "none" | "think" | "include_reasoning" | "effort" | "effort_explicit" | "template" | "anthropic";
 
-// How a caller-supplied GBNF grammar is carried on the wire — backends accept
-// different shapes for the SAME GBNF (probed/configured, never guessed; §13); the
-// wire shape per style lives in #grammarBody. "none" means the grammar is NOT sent
-// (never silently — so a constrained consumer can't mistake unconstrained output
-// for enforced).
-export type GrammarStyle = "none" | "llamacpp" | "response_format";
+// GBNF transport is a local llama-server capability. "none" means no
+// service-managed constrained sampling; endpoint-owned settings are not inferred.
+export type GrammarStyle = "none" | "llamacpp";
 
 export type OpenAICompatConfig = {
     model: string;
     url: string;                              // fully-resolved chat-completions URL
     fetchTimeoutMs: number;
+    streamIdleTimeoutMs?: number;             // streamed body inter-chunk deadline; zero/unset disables
     headers?: Record<string, string>;         // fully-resolved request headers (incl. auth); default {}
     fetch?: ProviderFetch;                    // per-instance request executor; default globalThis.fetch
     contextWindow?: number | null;              // default null; caller resolves-or-fails (#419), narrows to required with the interface
     reasoningStyle?: ReasoningStyle;          // default "none"
     countTokens?: (text: string) => number;   // default chars/2 upper-bound heuristic
-    costFor?: (usage: ProviderUsage) => number; // default () => 0
+    calculateCost?: (usage: ProviderUsage) => number; // default () => 0
     source?: string;                           // telemetry source, e.g. "provider:openai"; default "provider"
     grammarStyle?: GrammarStyle;               // how a GBNF grammar is carried; default "none" (not sent)
     // #518: send the OpenAI-standard `prompt_cache_key` set to workerId, so a
@@ -54,12 +52,14 @@ export type OpenAICompatConfig = {
     // false -- a backend that strict-validates unknown fields 400s, so enable only
     // where the field is accepted. Same identity that already drives slot affinity.
     promptCacheKey?: boolean;
+    // Optional provider-configured service tier. Unlike caller sampling, this is
+    // a fixed deployment choice and therefore wins on every request.
+    serviceTier?: string;
     gbnfDebug?: boolean;                        // PLURNK_PROVIDERS_GBNF_DEBUG: validate the grammar locally + throw on invalid, but DON'T transport it (run unconstrained); default false
     streaming?: boolean;                        // SSE transport (default true); false → one non-streamed JSON
     firstPartyMetadata?: boolean;              // forward per-turn attributions + client as Plurnk-* headers (plurnk only); default false
     apiKeyRejectedMessage?: string;            // #537: friendly hint when a PRESENT key is 401/403-rejected (distinct from unset); default undefined
     eosText?: string;                          // #539: server-reported eos_token, stripped from the content tail (--special renders it as text); default undefined
-    balanceMetaKey?: string;                    // top-level response field carrying account balance (pico-USD) → validated meta.balancePico (plurnk only, #23); default unset
     // Slot affinity wiring (provider-INTERNAL — never consumer-facing, #11).
     supportsSlotPinning?: boolean;             // backend accepts an `id_slot` body field (llama-server); default false
     slotCount?: number | null;                 // probed slot count for pinning backends; default null
@@ -238,6 +238,7 @@ export default class OpenAICompatProvider implements Provider {
     #model: string;
     #url: string;
     #fetchTimeoutMs: number;
+    #streamIdleTimeoutMs: number | undefined;
     #headers: Record<string, string>;
     #fetch: ProviderFetch;
     #hasApiKey = false;
@@ -255,14 +256,14 @@ export default class OpenAICompatProvider implements Provider {
     #retryDelayMs: number;
     #reasoningStyle: ReasoningStyle;
     #countTokens: (text: string) => number;
-    #costFor: (usage: ProviderUsage) => number;
+    #calculateCost: (usage: ProviderUsage) => number;
     #source: string;
     #grammarStyle: GrammarStyle;
     #promptCacheKey: boolean;
+    #serviceTier: string | undefined;
     #gbnfDebug: boolean;
     #streaming: boolean;
     #firstPartyMetadata: boolean;
-    #balanceMetaKey: string | undefined;
     #supportsSlotPinning: boolean;
     #slotCount: number | null;
     #retryAttempts: number;
@@ -284,6 +285,7 @@ export default class OpenAICompatProvider implements Provider {
         this.#model = config.model;
         this.#url = config.url;
         this.#fetchTimeoutMs = config.fetchTimeoutMs;
+        this.#streamIdleTimeoutMs = config.streamIdleTimeoutMs;
         this.#headers = config.headers ?? {};
         this.#fetch = config.fetch ?? ((input, init) => globalThis.fetch(input, init));
         this.#contextWindow = config.contextWindow ?? null;
@@ -305,17 +307,17 @@ export default class OpenAICompatProvider implements Provider {
         this.#retryAttempts = config.retryAttempts;
         this.#reasoningStyle = config.reasoningStyle ?? "none";
         this.#countTokens = config.countTokens ?? heuristicTokens;
-        this.#costFor = config.costFor ?? (() => 0);
+        this.#calculateCost = config.calculateCost ?? (() => 0);
         this.#source = config.source ?? "provider";
         this.#grammarStyle = config.grammarStyle ?? "none";
         this.#promptCacheKey = config.promptCacheKey ?? false;
+        this.#serviceTier = config.serviceTier;
         this.#gbnfDebug = config.gbnfDebug ?? false;
         this.#streaming = config.streaming ?? true;
         this.#firstPartyMetadata = config.firstPartyMetadata ?? false;
         this.#apiKeyRejectedMessage = config.apiKeyRejectedMessage;
         this.#eosText = config.eosText;
         this.#hasApiKey = "Authorization" in this.#headers;
-        this.#balanceMetaKey = config.balanceMetaKey;
         this.#supportsSlotPinning = config.supportsSlotPinning ?? false;
         this.#slotCount = config.slotCount ?? null;
         this.#topLogprobs = config.topLogprobs ?? null;
@@ -365,7 +367,7 @@ export default class OpenAICompatProvider implements Provider {
     get constrainsOutput(): boolean { return this.#grammarStyle !== "none"; }
 
     countTokens(text: string): number { return this.#countTokens(text); }
-    costFor(usage: ProviderUsage): number { return this.#costFor(usage); }
+    calculateCost(usage: ProviderUsage): number { return this.#calculateCost(usage); }
 
     // Maps the reasoning INTENT (off | adaptive | on+budget, #33) to the
     // backend's wire mechanism — including under a transported grammar. The #32
@@ -444,31 +446,25 @@ export default class OpenAICompatProvider implements Provider {
         return { id_slot: slot };
     }
 
-    // Grammar transport (SPEC §13): carry the caller-supplied GBNF in the shape
-    // the backend accepts. Same grammar, different wire field per backend; an
-    // unsupported/unknown backend sends NO field at all (cloud APIs 400 on
-    // unknowns, and a silent send would let a constrained consumer mistake
-    // unconstrained output for enforced).
+    // Optional local llama-server GBNF transport (SPEC §13). Unsupported
+    // backends receive no grammar-related field.
     #grammarBody(grammar: string | undefined): Record<string, unknown> {
         if (grammar === undefined) return {};
         switch (this.#grammarStyle) {
             // Greedy decoding under hard constraint loops without a repeat-penalty
-            // floor (#9, SPEC §13) — every grammar path carries it. llama.cpp spells
-            // it `repeat_penalty`; the OpenAI-compat (Fireworks) shape is `repetition_penalty`
-            // (verified honored live, #20).
+            // floor (#9, SPEC §13) — llama.cpp spells it `repeat_penalty`.
             case "llamacpp": return { grammar, repeat_penalty: this.#repeatPenalty };
-            case "response_format": return { response_format: { type: "grammar", grammar }, repetition_penalty: this.#repeatPenalty };
             case "none": return {};
         }
     }
 
     // Anti-degeneration DEFAULT on EVERY request (#426), keyed to the backend's wire
-    // convention - NOT grammar-bound. GBNF is a local rail (off for cloud), so a cloud
+    // convention - NOT grammar-bound. GBNF is a local constraint, so a cloud
     // alias runs the sampler bare: firefast (deepseek/fireworks) ran 4/86 bench turns
     // straight to the token cap on pure looped repetition (run52). Ships next to
     // temperature so caller `sampling` can tune it; the grammar path re-asserts it as a
-    // managed FLOOR in #grammarBody. Per backend: llama.cpp/response_format take the
-    // repeat_penalty MULTIPLIER; the plain cloud path ("none") can't, so it gets
+    // managed FLOOR in #grammarBody. llama.cpp takes the repeat_penalty
+    // MULTIPLIER; the plain cloud path ("none") can't, so it gets
     // frequency_penalty - OpenAI-standard, accepted by every OpenAI-compat backend (verified
     // live: together/deepinfra/fireworks; it is OpenAI's own param, so real OpenAI takes it too).
     #repetitionPenaltyBody(): Record<string, unknown> {
@@ -485,7 +481,6 @@ export default class OpenAICompatProvider implements Provider {
                     ...(this.#dryAllowedLength !== undefined ? { dry_allowed_length: this.#dryAllowedLength } : {}),
                 } : {}),
             };
-            case "response_format": return { repetition_penalty: this.#repeatPenalty };
             case "none": return this.#frequencyPenalty > 0 ? { frequency_penalty: this.#frequencyPenalty } : {};
         }
     }
@@ -568,18 +563,10 @@ export default class OpenAICompatProvider implements Provider {
     }
 
     // Per-turn metadata bag (#23): pass the backend's non-standard top-level fields
-    // (the transport's `chunkMetadata`) through VERBATIM, then normalize the known
-    // keys we hold a contract for — the spec's balance field → a validated
-    // `balancePico` (finite pico-USD; dropped if non-numeric), renamed off its raw
-    // key so the consumer reads one canonical name. Undefined when nothing's there;
-    // the service merges this into its Turn metadata and filters what reaches clients.
+    // through verbatim. Providers do not reinterpret vendor currency or account
+    // metadata; a monetary value carries its own amount and currency.
     #buildMeta(chunkMetadata: Record<string, unknown>): Record<string, unknown> | undefined {
         const meta: Record<string, unknown> = { ...chunkMetadata };
-        if (this.#balanceMetaKey !== undefined) {
-            const raw = meta[this.#balanceMetaKey];
-            delete meta[this.#balanceMetaKey];
-            if (typeof raw === "number" && Number.isFinite(raw)) meta.balancePico = raw;
-        }
         return Object.keys(meta).length > 0 ? meta : undefined;
     }
 
@@ -620,6 +607,7 @@ export default class OpenAICompatProvider implements Provider {
             // the router's per-model tuning must not be overridden by client floors.
             ...(this.#tuningFloors ? { temperature: this.#temperature, ...this.#repetitionPenaltyBody() } : {}),
             ...this.#samplingBody(sampling),
+            ...(this.#serviceTier !== undefined ? { service_tier: this.#serviceTier } : {}),
             model: this.#model,
             messages,
             ...this.#reasoningBody(),
@@ -640,23 +628,27 @@ export default class OpenAICompatProvider implements Provider {
         // signal spans them all. Retry only the transient classifications, prefer
         // a server Retry-After over the backoff, and let the caller's abort cut
         // through both the in-flight request and the backoff sleep.
-        // Stream by default, but fall back to one non-streamed JSON for the one
-        // case it breaks: a response_format grammar (fireworks) streams its
-        // constrained output mislabeled as reasoning_content, yet returns it as
-        // content non-streamed. The atomic dump is correct either way, so the
-        // demotion is scoped to exactly that request, not the whole provider.
-        const grammarBreaksStream = sendGrammar !== undefined && this.#grammarStyle === "response_format";
-        const transport = this.#streaming && !grammarBreaksStream ? chatCompletionStream : chatCompletion;
+        const transport = this.#streaming ? chatCompletionStream : chatCompletion;
 
         // Per-request headers = static auth/routing + any first-party telemetry.
         const metaHeaders = this.#metadataHeaders(attributions, client, strikes, workerId, primaryWorkerId, workspaceId, loop, turn);
         const headers = Object.keys(metaHeaders).length > 0 ? { ...this.#headers, ...metaHeaders } : this.#headers;
+        const transportRetries: Array<{ attempt: number; kind: string; elapsedMs: number; message: string }> = [];
         let raw;
         for (let attempt = 0; ; attempt++) {
+            const attemptStarted = performance.now();
             const timeoutSignal = AbortSignal.timeout(this.#fetchTimeoutMs);
             const effectiveSignal = signal !== undefined ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
             try {
-                raw = await transport({ url: this.#url, headers, body, signal: effectiveSignal, fetch: this.#fetch, captureRawBody: this.#rawBody });
+                raw = await transport({
+                    url: this.#url,
+                    headers,
+                    body,
+                    signal: effectiveSignal,
+                    fetch: this.#fetch,
+                    captureRawBody: this.#rawBody,
+                    streamIdleTimeoutMs: this.#streamIdleTimeoutMs,
+                });
                 break;
             } catch (err) {
                 // Caller-initiated abort is cancellation — never retried or wrapped.
@@ -677,6 +669,12 @@ export default class OpenAICompatProvider implements Provider {
                     }
                     throw pe;
                 }
+                transportRetries.push({
+                    attempt: attempt + 1,
+                    kind,
+                    elapsedMs: Math.round(performance.now() - attemptStarted),
+                    message: err instanceof Error ? err.message : String(err),
+                });
                 const retryAfter = err instanceof OpenAiHttpError ? err.retryAfter : null;
                 await sleepWithAbort(retryAfter ?? this.#retryDelayMs * 2 ** attempt, signal);
             }
@@ -728,7 +726,10 @@ export default class OpenAICompatProvider implements Provider {
         }
 
         const builtMeta = this.#buildMeta(raw.chunkMetadata);
-        const meta = railsMeta !== undefined ? { ...builtMeta, ...railsMeta } : builtMeta;
+        const retryMeta = transportRetries.length > 0 ? { transportRetries } : undefined;
+        const meta = railsMeta !== undefined || retryMeta !== undefined
+            ? { ...builtMeta, ...railsMeta, ...retryMeta }
+            : builtMeta;
 
         // #36: surface per-token logprobs + their mean when the backend returned
         // them (only possible when the flag requested them). Absent otherwise —

package/src/Pool.test.ts

@@ -28,7 +28,7 @@ const backend = (opts: FakeOpts = {}) => {
         ...(opts.completionReserve !== undefined ? { completionReserve: opts.completionReserve } : {}),
         ...(opts.tokenize ? { tokenize: async (t: string) => [t.length] } : {}),
         countTokens: (t: string) => t.length,
-        costFor: () => opts.cost ?? 0,
+        calculateCost: () => opts.cost ?? 0,
         generate: async (args: Parameters<Provider["generate"]>[0]): Promise<ProviderResponse> => {
             served.push(args.workerId);
             if (opts.throws !== undefined) throw opts.throws;
@@ -88,10 +88,10 @@ test("Pool: tokenize is exposed iff every backend has it", () => {
     assert.equal(new Pool([backend({ tokenize: true }).b, backend({ tokenize: false }).b]).tokenize, undefined);
 });
 
-test("Pool: countTokens + costFor delegate to a backend", () => {
+test("Pool: countTokens + calculateCost delegate to a backend", () => {
     const p = new Pool([backend({ cost: 42 }).b]);
     assert.equal(p.countTokens("abcd"), 4);
-    assert.equal(p.costFor({ prompt: 0, completion: 0, reasoning: 0, cached: 0, total: 0 }), 42);
+    assert.equal(p.calculateCost({ prompt: 0, completion: 0, reasoning: 0, cached: 0, total: 0 }), 42);
 });
 
 // --- dispatch: round-robin + affinity ---

package/src/Pool.ts

@@ -83,7 +83,7 @@ export default class Pool implements Provider {
     }
 
     countTokens(text: string): number { return this.#backends[0].countTokens(text); }
-    costFor(usage: ProviderUsage): number { return this.#backends[0].costFor(usage); }
+    calculateCost(usage: ProviderUsage): number { return this.#backends[0].calculateCost(usage); }
 
     // --- dispatch ---
 

package/src/ProviderRegistry.test.ts

@@ -2,7 +2,7 @@ import test, { mock } from "node:test";
 import { strict as assert } from "node:assert";
 import { instantiateProvider, loadActiveProvider, resetDiscoveryCache } from "./ProviderRegistry.ts";
 
-const fakeProvider = { contextWindow: 1, model: "m", countTokens: () => 0, costFor: () => 0, generate: async () => { throw new Error("unused"); } };
+const fakeProvider = { contextWindow: 1, model: "m", countTokens: () => 0, calculateCost: () => 0, generate: async () => { throw new Error("unused"); } };
 const mapOf = (entries: Record<string, string>, skipped: Record<string, string> = {}) =>
     async () => ({ registry: new Map(Object.entries(entries)), skipped: new Map(Object.entries(skipped)), attributions: new Map<string, string | string[]>() });
 
@@ -14,6 +14,7 @@ const mapOf = (entries: Record<string, string>, skipped: Record<string, string>
 
 const fullEnv = Object.freeze({
     PLURNK_PROVIDERS_FETCH_TIMEOUT: "600000",
+    PLURNK_PROVIDERS_STREAM_IDLE_TIMEOUT: "0",
     PLURNK_PROVIDERS_REASONING: "off", PLURNK_PROVIDERS_TEMPERATURE: "0.2", PLURNK_PROVIDERS_REPEAT_PENALTY: "1.15", PLURNK_PROVIDERS_FREQUENCY_PENALTY: "0.4", PLURNK_PROVIDERS_REASONING_RESERVE: "10%", PLURNK_PROVIDERS_COMPLETION_RESERVE: "25%", PLURNK_PROVIDERS_RETRY_DELAY: "1", PLURNK_PROVIDERS_PROBE_ATTEMPTS: "3", PLURNK_PROVIDERS_PROBE_DELAY: "1", PLURNK_PROVIDERS_RETRY_ATTEMPTS: "0",
     OPENAI_BASE_URL: "http://x",
 });
@@ -162,6 +163,34 @@ test("instantiateProvider: per-alias knobs scope through to the provider (per-al
     mock.restoreAll();
 });
 
+test("#622: two Fireworks aliases independently select default and priority service tiers", async () => {
+    const bodies: Record<string, unknown>[] = [];
+    mock.method(globalThis, "fetch", async (_url: string, init?: RequestInit) => {
+        bodies.push(JSON.parse(String(init?.body)) as Record<string, unknown>);
+        return new Response(JSON.stringify({ choices: [{ message: { content: "ok" }, finish_reason: "stop" }] }), { status: 200, headers: { "Content-Type": "application/json" } });
+    });
+    const env = {
+        ...fullEnv,
+        FIREWORKS_BASE_URL: "https://api.fireworks.ai/inference/v1",
+        FIREWORKS_API_KEY: "fw",
+        PLURNK_PROVIDERS_CONTEXT_WINDOW: "8192",
+        PLURNK_PROVIDERS_SERVICE_TIER_fast: "priority",
+        PLURNK_PROVIDERS_SERVICE_TIER_standard: "default",
+    };
+    const imports = async () => ({});
+    const discover = async () => ({ registry: new Map(), skipped: new Map(), attributions: new Map() });
+    const fast = await instantiateProvider("fireworks", env, "accounts/fireworks/routers/glm-5p2-fast", imports, discover, undefined, "fast");
+    const standard = await instantiateProvider("fireworks", env, "deepseek-v4-pro", imports, discover, undefined, "standard");
+    await fast.generate({ workerId: "fast-worker", messages: [] });
+    await standard.generate({ workerId: "standard-worker", messages: [] });
+    assert.deepEqual(bodies.map((body) => body.service_tier), ["priority", "default"]);
+    assert.deepEqual(bodies.map((body) => body.model), [
+        "accounts/fireworks/routers/glm-5p2-fast",
+        "accounts/fireworks/models/deepseek-v4-pro",
+    ]);
+    mock.restoreAll();
+});
+
 test("loadActiveProvider: resolves the alias cascade end-to-end via the scan", async () => {
     resetDiscoveryCache();
     const env = { ...fullEnv, PLURNK_MODEL: "opus", PLURNK_MODEL_opus: "openrouter/anthropic/claude-opus-latest" } as NodeJS.ProcessEnv;