@plurnk/plurnk-providers 1.3.3 → 1.3.5

package/src/aiSdkAdapter.spike.test.ts

@@ -0,0 +1,242 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { APICallError, streamText } from "ai";
+
+const encoder = new TextEncoder();
+
+const sseResponse = (...chunks: object[]): Response => new Response(
+    new ReadableStream({
+        start(controller) {
+            for (const chunk of chunks) {
+                controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunk)}\n\n`));
+            }
+            controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+            controller.close();
+        },
+    }),
+    { headers: { "content-type": "text/event-stream" } },
+);
+
+describe("AI SDK adapter spike", () => {
+    it("preserves PLURNK request extensions and complete stream evidence", async () => {
+        let requestBody: Record<string, unknown> | undefined;
+        const rawChunks = [
+            {
+                id: "response-1",
+                object: "chat.completion.chunk",
+                created: 1,
+                model: "test-model",
+                choices: [{
+                    index: 0,
+                    delta: { role: "assistant", reasoning_content: "because " },
+                    finish_reason: null,
+                }],
+            },
+            {
+                id: "response-1",
+                object: "chat.completion.chunk",
+                created: 1,
+                model: "test-model",
+                choices: [{
+                    index: 0,
+                    delta: { content: "answer" },
+                    finish_reason: null,
+                }],
+            },
+            {
+                id: "response-1",
+                object: "chat.completion.chunk",
+                created: 1,
+                model: "test-model",
+                choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
+                usage: {
+                    prompt_tokens: 3,
+                    completion_tokens: 5,
+                    total_tokens: 8,
+                    completion_tokens_details: { reasoning_tokens: 2 },
+                },
+            },
+        ];
+        const provider = createOpenAICompatible({
+            name: "spike",
+            baseURL: "https://example.test/v1",
+            apiKey: "test-key",
+            includeUsage: true,
+            fetch: async (_input, init) => {
+                requestBody = JSON.parse(String(init?.body)) as Record<string, unknown>;
+                return sseResponse(...rawChunks);
+            },
+        });
+
+        const result = streamText({
+            model: provider("test-model"),
+            messages: [{ role: "user", content: "question" }],
+            maxOutputTokens: 64,
+            temperature: 0.25,
+            maxRetries: 0,
+            timeout: { totalMs: 1_000, chunkMs: 500 },
+            includeRawChunks: true,
+            providerOptions: {
+                spike: {
+                    grammar: "root ::= \"answer\"",
+                    id_slot: 2,
+                    enable_thinking: true,
+                    service_tier: "flex",
+                },
+            },
+        });
+        const parts = [];
+        for await (const part of result.fullStream) parts.push(part);
+
+        assert.equal(requestBody?.model, "test-model");
+        assert.equal(requestBody?.max_tokens, 64);
+        assert.equal(requestBody?.temperature, 0.25);
+        assert.equal(requestBody?.grammar, "root ::= \"answer\"");
+        assert.equal(requestBody?.id_slot, 2);
+        assert.equal(requestBody?.enable_thinking, true);
+        assert.equal(requestBody?.service_tier, "flex");
+        assert.equal(requestBody?.stream, true);
+        assert.deepEqual(requestBody?.stream_options, { include_usage: true });
+
+        assert.equal(await result.text, "answer");
+        assert.equal(await result.reasoningText, "because ");
+        assert.equal(await result.finishReason, "stop");
+        assert.equal(await result.rawFinishReason, "stop");
+        const usage = await result.usage;
+        assert.equal(usage.inputTokens, 3);
+        assert.equal(usage.outputTokens, 5);
+        assert.equal(usage.outputTokenDetails.reasoningTokens, 2);
+        assert.equal(usage.outputTokenDetails.textTokens, 3);
+        assert.equal(usage.totalTokens, 8);
+        assert.deepEqual(
+            parts.filter((part) => part.type === "raw").map((part) => part.rawValue),
+            rawChunks,
+        );
+    });
+
+    it("surfaces typed HTTP failures without retrying", async () => {
+        let requests = 0;
+        const provider = createOpenAICompatible({
+            name: "spike",
+            baseURL: "https://example.test/v1",
+            apiKey: "test-key",
+            fetch: async () => {
+                requests += 1;
+                return new Response(
+                    JSON.stringify({ error: { message: "rate limited", type: "rate_limit" } }),
+                    {
+                        status: 429,
+                        headers: {
+                            "content-type": "application/json",
+                            "retry-after": "3",
+                            "x-request-id": "request-1",
+                        },
+                    },
+                );
+            },
+        });
+        const result = streamText({
+            model: provider("test-model"),
+            prompt: "question",
+            maxRetries: 0,
+            onError: () => {},
+        });
+
+        const parts = [];
+        for await (const part of result.fullStream) parts.push(part);
+        const errorPart = parts.find((part) => part.type === "error");
+        assert.ok(errorPart?.type === "error");
+        assert.ok(APICallError.isInstance(errorPart.error));
+        assert.equal(errorPart.error.statusCode, 429);
+        assert.equal(errorPart.error.isRetryable, true);
+        assert.equal(errorPart.error.responseHeaders?.["retry-after"], "3");
+        assert.equal(errorPart.error.responseHeaders?.["x-request-id"], "request-1");
+        assert.match(errorPart.error.responseBody ?? "", /rate limited/);
+        assert.equal(requests, 1);
+    });
+
+    it("enforces stream-idle timeout through the transport contract", async () => {
+        const provider = createOpenAICompatible({
+            name: "spike",
+            baseURL: "https://example.test/v1",
+            apiKey: "test-key",
+            fetch: async () => new Response(
+                new ReadableStream({
+                    start(controller) {
+                        controller.enqueue(encoder.encode(`data: ${JSON.stringify({
+                            id: "response-1",
+                            object: "chat.completion.chunk",
+                            created: 1,
+                            model: "test-model",
+                            choices: [{
+                                index: 0,
+                                delta: { role: "assistant", content: "started" },
+                                finish_reason: null,
+                            }],
+                        })}\n\n`));
+                        setTimeout(() => controller.close(), 100);
+                    },
+                }),
+                { headers: { "content-type": "text/event-stream" } },
+            ),
+        });
+        const result = streamText({
+            model: provider("test-model"),
+            prompt: "question",
+            maxRetries: 0,
+            timeout: { totalMs: 500, chunkMs: 25 },
+            onError: () => {},
+        });
+
+        await assert.rejects(
+            () => Promise.resolve(result.text),
+            (error: unknown) => {
+                assert.match(String(error), /timed out|timeout/i);
+                return true;
+            },
+        );
+    });
+
+    it("propagates caller cancellation into the injected transport", async () => {
+        const caller = new AbortController();
+        let transportAborted = false;
+        const provider = createOpenAICompatible({
+            name: "spike",
+            baseURL: "https://example.test/v1",
+            apiKey: "test-key",
+            fetch: async (_input, init) => {
+                const transportSignal = init?.signal as AbortSignal;
+                return await new Promise<Response>((_resolve, reject) => {
+                    transportSignal.addEventListener(
+                        "abort",
+                        () => {
+                            transportAborted = true;
+                            reject(transportSignal.reason);
+                        },
+                        { once: true },
+                    );
+                });
+            },
+        });
+        const result = streamText({
+            model: provider("test-model"),
+            prompt: "question",
+            maxRetries: 0,
+            abortSignal: caller.signal,
+            onError: () => {},
+        });
+        const partsPromise = (async () => {
+            const parts = [];
+            for await (const part of result.fullStream) parts.push(part);
+            return parts;
+        })();
+
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        caller.abort(new Error("caller stopped"));
+        const parts = await partsPromise;
+
+        assert.equal(transportAborted, true);
+        assert.ok(parts.some((part) => part.type === "abort"));
+    });
+});

package/src/env.test.ts

@@ -166,6 +166,14 @@ test("#399: the shipped floor activates reasoning by default (adaptive — owner
     assert.ok(!defaults.match(/^PLURNK_PROVIDERS_REASONING_BUDGET=/m), "no shipped magnitude — budget is on-mode only");
 });
 
+test("#567: the shipped DRY floor stays off while retaining the measured alias-safe shape", async () => {
+    const { readFileSync } = await import("node:fs");
+    const defaults = readFileSync(new URL("../.env.defaults", import.meta.url), "utf8");
+    assert.match(defaults, /^PLURNK_PROVIDERS_DRY_MULTIPLIER=0$/m, "one-model tuning is not a universal sampler floor");
+    assert.match(defaults, /^PLURNK_PROVIDERS_DRY_BASE=1\.75$/m);
+    assert.match(defaults, /^PLURNK_PROVIDERS_DRY_ALLOWED_LENGTH=32$/m, "the measured identifier-safe shape remains available for alias opt-in");
+});
+
 // -- #507: envelope reserves (owner-ruled migration from PLURNK_SERVICE_*) --
 
 test("#507 envelopeFromEnv: percentages and absolutes parse; missing/invalid fail hard", async () => {

package/src/env.ts

@@ -163,10 +163,12 @@ export const PROVIDERS_KNOBS = Object.freeze([
     "PLURNK_PROVIDERS_CONTEXT_WINDOW",
     "PLURNK_PROVIDERS_RETRY_ATTEMPTS",
     "PLURNK_PROVIDERS_FETCH_TIMEOUT",
+    "PLURNK_PROVIDERS_STREAM_IDLE_TIMEOUT",
     "PLURNK_PROVIDERS_LLAMA_SERVER",
     "PLURNK_PROVIDERS_TEMPERATURE",
     "PLURNK_PROVIDERS_REPEAT_PENALTY",
     "PLURNK_PROVIDERS_FREQUENCY_PENALTY",
+    "PLURNK_PROVIDERS_SERVICE_TIER",
     "PLURNK_PROVIDERS_REPEAT_LAST_N",
     "PLURNK_PROVIDERS_DRY_MULTIPLIER",
     "PLURNK_PROVIDERS_DRY_BASE",

package/src/index.ts

@@ -36,11 +36,11 @@ export type { OpenAICompatConfig, ReasoningStyle, GrammarStyle } from "./OpenAIC
 // worker-sticky for KV-cache reuse, overflow to a healthy sibling; the blend
 // DECISION stays the consumer's, by choosing which pool to call.
 export { default as Pool } from "./Pool.ts";
-export { chatCompletionStream, chatCompletion, OpenAiHttpError } from "./openaiStream.ts";
+export { chatCompletionStream, chatCompletion, OpenAiHttpError, StreamIdleError } from "./openaiStream.ts";
 export type { StreamResponse, EncryptedReasoningItem, ProviderFetch } from "./openaiStream.ts";
 export { parseRequiredInt, parseOptionalInt, parseRequiredFloat, parseOptionalFloat, requireEnv, reasoningFromEnv, scopeEnvToAlias, dataCaptureFromEnv, contextWindowFromEnv, envelopeFromEnv, resolveReserve } from "./env.ts";
 export type { Reasoning, ReasoningMode, ReserveSpec } from "./env.ts";
-export { normalizeUsage, computeCost } from "./usage.ts";
+export { normalizeUsage, calculateCostUsd } from "./usage.ts";
 export type { RawUsage, TokenRates } from "./usage.ts";
 export { ProviderError, classifyProviderError, toProviderError, providerSource } from "./telemetry.ts";
 export type { TelemetryEvent, ProviderTelemetryKind } from "./telemetry.ts";

package/src/openai.ts

@@ -1,6 +1,6 @@
 export { default as OpenAICompatProvider, effortFromBudget } from "./OpenAICompat.ts";
 export type { GrammarStyle, OpenAICompatConfig, ReasoningStyle } from "./OpenAICompat.ts";
-export { chatCompletion, chatCompletionStream, OpenAiHttpError } from "./openaiStream.ts";
+export { chatCompletion, chatCompletionStream, OpenAiHttpError, StreamIdleError } from "./openaiStream.ts";
 export type {
     EncryptedReasoningItem,
     ProviderFetch,

package/src/openaiStream.ts

@@ -13,6 +13,9 @@ type StreamRequest = {
     // #36: assemble the verbatim wire body onto StreamResponse.rawBody. Off by
     // default so a serving turn never pays the reassembly/retention cost.
     captureRawBody?: boolean;
+    // Maximum silence between streamed response-body chunks. Undefined/zero
+    // disables this clock; the caller's signal still owns the total deadline.
+    streamIdleTimeoutMs?: number;
 };
 
 import type { RawUsage } from "./usage.ts";
@@ -122,6 +125,15 @@ export class OpenAiHttpError extends Error {
     }
 }
 
+export class StreamIdleError extends Error {
+    readonly timeoutMs: number;
+    constructor(timeoutMs: number) {
+        super(`stream received no body bytes for ${timeoutMs}ms`);
+        this.name = "StreamIdleError";
+        this.timeoutMs = timeoutMs;
+    }
+}
+
 const parseRetryAfter = (header: string | null): number | null => {
     if (header === null) return null;
     const asInt = Number.parseInt(header, 10);
@@ -170,7 +182,7 @@ export const chatCompletion = async ({ url, headers, body, signal, fetch, captur
     };
 };
 
-export const chatCompletionStream = async ({ url, headers, body, signal, fetch, captureRawBody }: StreamRequest): Promise<StreamResponse> => {
+export const chatCompletionStream = async ({ url, headers, body, signal, fetch, captureRawBody, streamIdleTimeoutMs }: StreamRequest): Promise<StreamResponse> => {
     const requestBody = { ...body, stream: true, stream_options: { include_usage: true } };
 
     const response = await fetch(url, {
@@ -206,7 +218,23 @@ export const chatCompletionStream = async ({ url, headers, body, signal, fetch,
     let encryptedNoKey = 0;
 
     while (true) {
-        const { done, value } = await reader.read();
+        const read = reader.read();
+        let timer: ReturnType<typeof setTimeout> | undefined;
+        const idle = streamIdleTimeoutMs !== undefined && streamIdleTimeoutMs > 0
+            ? new Promise<never>((_resolve, reject) => {
+                timer = setTimeout(() => reject(new StreamIdleError(streamIdleTimeoutMs)), streamIdleTimeoutMs);
+            })
+            : null;
+        let result: Awaited<ReturnType<typeof reader.read>>;
+        try {
+            result = idle === null ? await read : await Promise.race([read, idle]);
+        } catch (err) {
+            if (err instanceof StreamIdleError) void reader.cancel(err).catch(() => undefined);
+            throw err;
+        } finally {
+            if (timer !== undefined) clearTimeout(timer);
+        }
+        const { done, value } = result;
         if (done) break;
         buffer += decoder.decode(value, { stream: true });
         const lines = buffer.split("\n");

package/src/standardProviders.test.ts

@@ -6,7 +6,7 @@ import { STANDARD_PROVIDERS, isStandardProvider, standardProviderFromEnv } from
 // defaults for the providers exercised outside the coverage loop. `openai` is
 // deliberately omitted so its missing-base fail-hard test still fires.
 const baseEnv = Object.freeze({
-    PLURNK_PROVIDERS_FETCH_TIMEOUT: "600000", 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",
+    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",
     GROQ_BASE_URL: "https://api.groq.com/openai/v1",
     DEEPINFRA_BASE_URL: "https://api.deepinfra.com/v1/openai",
     FIREWORKS_BASE_URL: "https://api.fireworks.ai/inference/v1",
@@ -298,10 +298,10 @@ test("openai: a garbage PLURNK_PROVIDERS_LLAMA_SERVER value fails hard", async (
     );
 });
 
-test("constrainsOutput: fireworks (static response_format) reports true; groq reports false", async () => {
+test("constrainsOutput: cloud providers do not claim local GBNF transport", async () => {
     mockEndpoint();
     const fw = await standardProviderFromEnv("fireworks", { ...baseEnv, FIREWORKS_API_KEY: "k", PLURNK_PROVIDERS_CONTEXT_WINDOW: "8192" }, "m");
-    assert.equal(fw!.constrainsOutput, true);
+    assert.equal(fw!.constrainsOutput, false);
     const gq = await standardProviderFromEnv("groq", { ...baseEnv, GROQ_API_KEY: "k", PLURNK_PROVIDERS_CONTEXT_WINDOW: "8192" }, "m");
     assert.equal(gq!.constrainsOutput, false);
 });
@@ -550,7 +550,7 @@ test("bedrock: contextWindow resolves from the catalog via the inference-profile
     // MECHANISM (non-null, positive), never the literal - a catalog refresh must not break the build.
     assert.ok(p!.contextWindow !== null && p!.contextWindow > 0, `expected a catalog-resolved window, got ${p!.contextWindow}`);
     // cost is NOT taken from the native anthropic rate (bedrock marks up) — stays 0
-    assert.equal(p!.costFor({ prompt: 1_000_000, completion: 1_000_000, reasoning: 0, cached: 0, total: 2_000_000 }), 0);
+    assert.equal(p!.calculateCost({ prompt: 1_000_000, completion: 1_000_000, reasoning: 0, cached: 0, total: 2_000_000 }), 0);
 });
 
 test("bedrock: a publisher the catalog lacks (meta) fails hard (cloud, no probe); PLURNK_PROVIDERS_CONTEXT_WINDOW still wins", async () => {
@@ -585,11 +585,11 @@ test("standard provider: a catalog hit fills contextWindow + cost when there's n
     assert.ok(p !== null);
     assert.equal(p.contextWindow, info.contextWindow); // catalog window, no probe needed
     if (info.cost !== undefined) {
-        // 1M output tokens → outputPer1M USD, in pico-USD (per-1M ×1e6 per token).
-        const c = p.costFor({ prompt: 0, completion: 1_000_000, reasoning: 0, cached: 0, total: 1_000_000 });
-        assert.equal(c, Math.round(info.cost.outputPer1M * 1e6 * 1_000_000));
+        // One million output tokens cost exactly the catalog's per-million USD rate.
+        const c = p.calculateCost({ prompt: 0, completion: 1_000_000, reasoning: 0, cached: 0, total: 1_000_000 });
+        assert.equal(c, info.cost.outputPer1M);
     } else {
-        assert.equal(p.costFor({ prompt: 1, completion: 1, reasoning: 0, cached: 0, total: 2 }), 0);
+        assert.equal(p.calculateCost({ prompt: 1, completion: 1, reasoning: 0, cached: 0, total: 2 }), 0);
     }
 });
 
@@ -828,27 +828,17 @@ test("plurnk: a set-but-rejected key (401) surfaces the distinct #537 rejected h
     assert.equal(seen.filter((s) => s.url.endsWith("/chat/completions")).length, 1); // terminal — never retried, distinct message
 });
 
-test("plurnk: normalizes the endpoint's balance_pico into meta.balancePico (#23)", async () => {
+test("plurnk: passes currency-explicit balance metadata through (#23)", async () => {
     mock.method(globalThis, "fetch", async (url: string) => {
         const u = String(url);
         if (u.endsWith("/models")) return new Response(JSON.stringify({ data: [{ id: "plurnk", meta: { n_ctx: 49152 } }] }), { status: 200 });
         // plurnk has detectLlamaServer:false → streams; balance rides as a top-level field on a chunk.
-        const sse = 'data: {"choices":[{"delta":{"content":"hi"},"finish_reason":"stop"}],"balance_pico":880000000}\n\ndata: [DONE]';
+        const sse = 'data: {"choices":[{"delta":{"content":"hi"},"finish_reason":"stop"}],"balance":{"amount":"0.00000088","currency":"XMR"}}\n\ndata: [DONE]';
         return new Response(new ReadableStream({ start(c) { c.enqueue(new TextEncoder().encode(sse)); c.close(); } }), { status: 200 });
     });
     const p = await standardProviderFromEnv("plurnk", { ...baseEnv, PLURNK_API_KEY: "pk-test" }, "plurnk");
     const res = await p!.generate({ workerId: "r", messages: [] });
-    assert.equal(res.meta?.balancePico, 880000000);
-    mock.restoreAll();
-});
-
-test("a third-party (non-plurnk) provider never NORMALIZES balancePico — only plurnk holds that contract", async () => {
-    mock.method(globalThis, "fetch", async () =>
-        new Response(new ReadableStream({ start(c) { c.enqueue(new TextEncoder().encode('data: {"choices":[{"delta":{"content":"hi"}}],"balance_pico":880000000}\n\ndata: [DONE]')); c.close(); } }), { status: 200 }));
-    const p = await standardProviderFromEnv("groq", { ...baseEnv, GROQ_API_KEY: "k", PLURNK_PROVIDERS_CONTEXT_WINDOW: "8192" }, "m");
-    const res = await p!.generate({ workerId: "r", messages: [] });
-    assert.equal("balancePico" in (res.meta ?? {}), false); // groq has no balanceMetaKey — no normalization
-    assert.equal(res.meta?.balance_pico, 880000000);          // but the raw field still passes through (every-provider meta)
+    assert.deepEqual(res.meta?.balance, { amount: "0.00000088", currency: "XMR" });
     mock.restoreAll();
 });
 
@@ -868,9 +858,7 @@ test("plurnk: reads its window from upstream but stays a plain OpenAI client —
     mock.restoreAll();
 });
 
-// — fireworks carries GBNF via response_format.grammar (cloud GBNF, #grammarStyle) —
-
-test("fireworks: a grammar transports as response_format.grammar (not the llama.cpp top-level field)", async () => {
+test("fireworks: caller GBNF is not transported to the cloud API", async () => {
     let body = "";
     mock.method(globalThis, "fetch", async (url: string, init?: RequestInit) => {
         if (String(url).endsWith("/chat/completions")) { body = String(init?.body); return new Response(JSON.stringify({ choices: [{ message: { content: "ok" }, finish_reason: "stop" }] }), { status: 200, headers: { "Content-Type": "application/json" } }); }
@@ -879,31 +867,57 @@ test("fireworks: a grammar transports as response_format.grammar (not the llama.
     const p = await standardProviderFromEnv("fireworks", { ...baseEnv, FIREWORKS_API_KEY: "fw" }, "accounts/fireworks/models/deepseek-v4-pro");
     await p!.generate({ workerId: "r", messages: [], grammar: 'root ::= "ok"' });
     const b = JSON.parse(body);
-    assert.deepEqual(b.response_format, { type: "grammar", grammar: 'root ::= "ok"' });
+    assert.equal("response_format" in b, false);
     assert.equal("grammar" in b, false);
     mock.restoreAll();
 });
 
 // — fireworks modelPrefix: the alias carries only the distinctive tail —
 
-const fireworksWireModel = async (alias: string): Promise<string> => {
+const fireworksWireBody = async (model: string, env: NodeJS.ProcessEnv = {}): Promise<Record<string, unknown>> => {
     let body = "";
     mock.method(globalThis, "fetch", async (url: string, init?: RequestInit) => {
         if (String(url).endsWith("/chat/completions")) { body = String(init?.body); return new Response(JSON.stringify({ choices: [{ message: { content: "ok" }, finish_reason: "stop" }] }), { status: 200, headers: { "Content-Type": "application/json" } }); }
         return new Response("{}", { status: 200 });
     });
-    const p = await standardProviderFromEnv("fireworks", { ...baseEnv, FIREWORKS_API_KEY: "fw" }, alias);
+    const p = await standardProviderFromEnv("fireworks", { ...baseEnv, FIREWORKS_API_KEY: "fw", ...env }, model);
     await p!.generate({ workerId: "r", messages: [] });
     mock.restoreAll();
-    return JSON.parse(body).model;
+    return JSON.parse(body) as Record<string, unknown>;
 };
 
 test("fireworks: a bare alias is prefixed with accounts/fireworks/models/ on the wire", async () => {
-    assert.equal(await fireworksWireModel("deepseek-v4-pro"), "accounts/fireworks/models/deepseek-v4-pro");
+    assert.equal((await fireworksWireBody("deepseek-v4-pro")).model, "accounts/fireworks/models/deepseek-v4-pro");
+});
+
+test("fireworks: fully qualified model and router ids are preserved verbatim", async () => {
+    assert.equal((await fireworksWireBody("accounts/fireworks/models/deepseek-v4-pro")).model, "accounts/fireworks/models/deepseek-v4-pro");
+    assert.equal((await fireworksWireBody("accounts/fireworks/routers/glm-5p2-fast")).model, "accounts/fireworks/routers/glm-5p2-fast");
 });
 
-test("fireworks: an already-prefixed id is left unchanged (idempotent prepend)", async () => {
-    assert.equal(await fireworksWireModel("accounts/fireworks/models/deepseek-v4-pro"), "accounts/fireworks/models/deepseek-v4-pro");
+test("fireworks: configured service tier is fixed on the wire and invalid values fail hard", async () => {
+    const body = await fireworksWireBody("deepseek-v4-pro", { PLURNK_PROVIDERS_SERVICE_TIER: "priority" });
+    assert.equal(body.service_tier, "priority");
+    assert.equal((await fireworksWireBody("deepseek-v4-pro", { PLURNK_PROVIDERS_SERVICE_TIER: "flex" })).service_tier, "flex");
+    await assert.rejects(
+        standardProviderFromEnv("fireworks", { ...baseEnv, FIREWORKS_API_KEY: "fw", PLURNK_PROVIDERS_SERVICE_TIER: "urgent" }, "deepseek-v4-pro"),
+        /PLURNK_PROVIDERS_SERVICE_TIER must be one of "auto", "default", "flex", "priority"/,
+    );
+});
+
+test("fireworks: configured tier wins over per-call sampling; unset retains per-call intent", async () => {
+    let 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 fixed = await standardProviderFromEnv("fireworks", { ...baseEnv, FIREWORKS_API_KEY: "fw", PLURNK_PROVIDERS_SERVICE_TIER: "priority" }, "deepseek-v4-pro");
+    await fixed!.generate({ workerId: "r", messages: [], sampling: { service_tier: "default" } });
+    const flexible = await standardProviderFromEnv("fireworks", { ...baseEnv, FIREWORKS_API_KEY: "fw" }, "deepseek-v4-pro");
+    await flexible!.generate({ workerId: "r", messages: [], sampling: { service_tier: "priority" } });
+    assert.deepEqual(bodies.map((body) => body.service_tier), ["priority", "priority"]);
+    bodies = [];
+    mock.restoreAll();
 });
 
 test("#518 prompt_cache_key: default-ON for a standard provider (workerId), OFF for anthropic (cache_control)", async () => {