@plurnk/plurnk-providers 1.4.0 → 1.6.0

package/src/catalogProvider.test.ts

@@ -1,5 +1,7 @@
 import test, { mock } from "node:test";
 import { strict as assert } from "node:assert";
+import { once } from "node:events";
+import { createServer } from "node:http";
 import { catalogProviderFromEnv } from "./catalogProvider.ts";
 import { resetEmittedWarnings } from "./warnings.ts";
 
@@ -7,6 +9,8 @@ const env = {
     OPENAI_API_KEY: "test-key",
     OPENAI_BASE_URL: "https://api.openai.com/v1",
     PLURNK_PROVIDERS_FETCH_TIMEOUT: "1000",
+    PLURNK_PROVIDERS_OPERATION_TIMEOUT: "3000",
+    PLURNK_PROVIDERS_FIRST_CONTENT_TIMEOUT: "1000",
     PLURNK_PROVIDERS_STREAM_IDLE_TIMEOUT: "0",
     PLURNK_PROVIDERS_REASONING: "off",
     PLURNK_PROVIDERS_TEMPERATURE: "0.2",
@@ -16,7 +20,8 @@ const env = {
     PLURNK_PROVIDERS_COMPLETION_RESERVE: "25%",
     PLURNK_PROVIDERS_RETRY_ATTEMPTS: "0",
     PLURNK_PROVIDERS_ERROR_DETAIL_LIMIT: "512",
-    PLURNK_PROVIDERS_PROMPT_CACHE_KEY: "1",
+    PLURNK_PROVIDERS_CACHE_AFFINITY: "1",
+    PLURNK_PROVIDERS_CACHE_WRITE_POLICY: "stable-system",
 };
 
 test.afterEach(() => {
@@ -31,13 +36,6 @@ test("catalog provider resolves model physics and Models.dev USD rates", () => {
     assert.equal(provider?.contextWindow, 1_047_576);
     assert.equal(provider?.reasoningReserve, 16_384);
     assert.equal(provider?.completionReserve, 32_768);
-    assert.ok((provider?.calculateCost({
-        prompt: 1_000_000,
-        completion: 1_000_000,
-        reasoning: 0,
-        cached: 0,
-        total: 2_000_000,
-    }) ?? 0) > 0);
 });
 
 test("an operator context window caps catalog physics and percentage reserves derive from the cap", () => {
@@ -96,7 +94,11 @@ test("official AI SDK provider owns the native request while PLURNK owns call se
     });
 
     assert.equal(result?.assistant.content, "done");
-    assert.equal(result?.assistant.usage.total, 3);
+    assert.equal(result?.accounting[0]?.usage?.totalTokens, 3);
+    assert.deepEqual(result?.accounting[0]?.cost, {
+        kind: "unknown",
+        reason: "the provider response omitted a token category with a distinct Models.dev rate",
+    });
     assert.equal(calls.length, 1);
     assert.equal(calls[0]?.url, "https://api.openai.com/v1/chat/completions");
     assert.equal(calls[0]?.body.model, "gpt-4.1-mini");
@@ -104,6 +106,227 @@ test("official AI SDK provider owns the native request while PLURNK owns call se
     assert.equal(calls[0]?.body.top_p, 0.8);
     assert.equal(calls[0]?.body.seed, 7);
     assert.equal(calls[0]?.body.max_tokens, 64);
+    assert.equal(calls[0]?.body.prompt_cache_key, "worker", "the official OpenAI SDK projects the documented affinity key");
+});
+
+test("Cerebras explicit reasoning activation needs no operator effort or token budget", async () => {
+    let body: Record<string, unknown> | undefined;
+    mock.method(globalThis, "fetch", async (_input: string | URL | Request, init?: RequestInit) => {
+        body = JSON.parse(String(init?.body)) as Record<string, unknown>;
+        return new Response([
+            `data: ${JSON.stringify({
+                id: "chatcmpl-cerebras",
+                object: "chat.completion.chunk",
+                created: 1,
+                model: "gemma-4-31b",
+                choices: [{ index: 0, delta: { reasoning: "consider" }, finish_reason: null }],
+            })}`,
+            `data: ${JSON.stringify({
+                id: "chatcmpl-cerebras",
+                object: "chat.completion.chunk",
+                created: 2,
+                model: "gemma-4-31b",
+                choices: [{ index: 0, delta: { content: "done" }, finish_reason: "stop" }],
+            })}`,
+            `data: ${JSON.stringify({
+                id: "chatcmpl-cerebras",
+                object: "chat.completion.chunk",
+                created: 3,
+                model: "gemma-4-31b",
+                choices: [],
+                usage: {
+                    prompt_tokens: 2,
+                    completion_tokens: 2,
+                    total_tokens: 4,
+                    completion_tokens_details: { reasoning_tokens: 1 },
+                },
+            })}`,
+            "data: [DONE]",
+        ].join("\n\n"), { headers: { "content-type": "text/event-stream" } });
+    });
+
+    const provider = catalogProviderFromEnv("cerebras", {
+        ...env,
+        CEREBRAS_API_KEY: "test-key",
+        PLURNK_PROVIDERS_REASONING: "on",
+    }, "gemma-4-31b");
+    const result = await provider?.generate({
+        workerId: "worker",
+        messages: [{ role: "user", content: "hello" }],
+    });
+
+    assert.equal(body?.reasoning_effort, "medium", "the native SDK projects unqualified on to its enabled posture");
+    assert.equal("thinking_budget_tokens" in (body ?? {}), false, "activation does not invent a token budget");
+    assert.equal(result?.assistant.reasoning, "consider");
+    assert.equal(result?.accounting[0]?.usage?.outputTokenDetails?.reasoningTokens, 1);
+});
+
+test("Google adaptive reasoning requests and preserves readable thought summaries", async () => {
+    const bodies: Array<{
+        generationConfig?: { thinkingConfig?: { includeThoughts?: boolean } };
+    }> = [];
+    mock.method(globalThis, "fetch", async (_input: string | URL | Request, init?: RequestInit) => {
+        bodies.push(JSON.parse(String(init?.body)) as typeof bodies[number]);
+        return new Response(`data: ${JSON.stringify({
+            responseId: "response-gemini",
+            candidates: [{
+                content: {
+                    role: "model",
+                    parts: [
+                        { text: "consider", thought: true },
+                        { text: "done" },
+                    ],
+                },
+                finishReason: "STOP",
+            }],
+            usageMetadata: {
+                promptTokenCount: 2,
+                candidatesTokenCount: 1,
+                thoughtsTokenCount: 1,
+                totalTokenCount: 4,
+            },
+        })}\n\n`, {
+            headers: { "content-type": "text/event-stream" },
+        });
+    });
+
+    const provider = catalogProviderFromEnv("google", {
+        ...env,
+        GEMINI_API_KEY: "test-key",
+        PLURNK_PROVIDERS_REASONING: "adaptive",
+    }, "gemini-3.7-flash");
+    const result = await provider?.generate({
+        workerId: "worker",
+        messages: [{ role: "user", content: "hello" }],
+    });
+
+    assert.deepEqual(bodies[0]?.generationConfig?.thinkingConfig, {
+        includeThoughts: true,
+    }, "adaptive leaves thinking depth to Google while requesting its readable summary");
+    assert.equal(result?.assistant.reasoning, "consider");
+    assert.equal(result?.assistant.content, "done");
+    assert.equal(result?.accounting[0]?.usage?.outputTokenDetails?.reasoningTokens, 1);
+
+    const disabled = catalogProviderFromEnv("google", {
+        ...env,
+        GEMINI_API_KEY: "test-key",
+        PLURNK_PROVIDERS_REASONING: "off",
+    }, "gemini-3.7-flash");
+    await disabled?.generate({
+        workerId: "worker",
+        messages: [{ role: "user", content: "hello" }],
+    });
+    assert.equal(
+        bodies[1]?.generationConfig?.thinkingConfig?.includeThoughts,
+        undefined,
+        "off does not request readable thoughts",
+    );
+});
+
+test("native provider routes project their documented cache controls through the actual SDK request", async (t) => {
+    const calls: Array<{ url: string; headers: Headers; body: Record<string, unknown> }> = [];
+    mock.method(globalThis, "fetch", async (input: string | URL | Request, init?: RequestInit) => {
+        calls.push({
+            url: String(input),
+            headers: new Headers(init?.headers),
+            body: JSON.parse(String(init?.body)) as Record<string, unknown>,
+        });
+        return new Response([
+            `data: ${JSON.stringify({
+                id: "response",
+                object: "chat.completion.chunk",
+                created: 1,
+                model: "served",
+                choices: [{ index: 0, delta: { content: "ok" }, finish_reason: "stop" }],
+            })}`,
+            `data: ${JSON.stringify({
+                id: "response",
+                object: "chat.completion.chunk",
+                created: 2,
+                model: "served",
+                choices: [],
+                usage: { prompt_tokens: 2, completion_tokens: 1, total_tokens: 3 },
+            })}`,
+            "data: [DONE]",
+        ].join("\n\n"), { headers: { "content-type": "text/event-stream" } });
+    });
+
+    await t.test("DeepInfra native options become prompt_cache_key", async () => {
+        const provider = catalogProviderFromEnv("deepinfra", {
+            ...env,
+            DEEPINFRA_API_KEY: "test-key",
+        }, "zai-org/GLM-5.2");
+        await provider?.generate({
+            workerId: "deepinfra-worker",
+            messages: [{ role: "user", content: "hello" }],
+        });
+        assert.equal(calls.at(-1)?.body.prompt_cache_key, "deepinfra-worker");
+    });
+
+    await t.test("OpenRouter carries session affinity and an Anthropic system breakpoint", async () => {
+        let call: { headers: Headers; body: Record<string, unknown> } | undefined;
+        const server = createServer(async (request, response) => {
+            const chunks: Buffer[] = [];
+            for await (const chunk of request) chunks.push(Buffer.from(chunk));
+            call = {
+                headers: new Headers(request.headers as Record<string, string>),
+                body: JSON.parse(Buffer.concat(chunks).toString("utf8")) as Record<string, unknown>,
+            };
+            response.writeHead(200, { "content-type": "text/event-stream" });
+            response.end([
+                `data: ${JSON.stringify({
+                    id: "response",
+                    object: "chat.completion.chunk",
+                    created: 1,
+                    model: "served",
+                    choices: [{ index: 0, delta: { content: "ok" }, finish_reason: "stop" }],
+                })}`,
+                `data: ${JSON.stringify({
+                    id: "response",
+                    object: "chat.completion.chunk",
+                    created: 2,
+                    model: "served",
+                    choices: [],
+                    usage: { prompt_tokens: 2, completion_tokens: 1, total_tokens: 3 },
+                })}`,
+                "data: [DONE]",
+            ].join("\n\n"));
+        });
+        server.listen(0, "127.0.0.1");
+        await once(server, "listening");
+        t.after(() => new Promise<void>((resolve, reject) => {
+            server.close((error) => error === undefined ? resolve() : reject(error));
+        }));
+        const address = server.address();
+        if (address === null || typeof address === "string") {
+            throw new Error("OpenRouter request-capture server did not bind a TCP address");
+        }
+
+        const provider = catalogProviderFromEnv("openrouter", {
+            ...env,
+            OPENROUTER_API_KEY: "test-key",
+        }, "anthropic/claude-sonnet-4.6", `http://127.0.0.1:${address.port}/api/v1`);
+        await provider?.generate({
+            workerId: "openrouter-worker",
+            messages: [
+                { role: "system", content: "stable system packet" },
+                { role: "user", content: "changing user packet" },
+            ],
+        });
+        assert.equal(call?.headers.get("x-session-id"), "openrouter-worker");
+        assert.deepEqual((call?.body.messages as unknown[] | undefined)?.[0], {
+            role: "system",
+            content: [{
+                type: "text",
+                text: "stable system packet",
+                cache_control: { type: "ephemeral" },
+            }],
+        });
+        assert.deepEqual((call?.body.messages as unknown[] | undefined)?.[1], {
+            role: "user",
+            content: "changing user packet",
+        });
+    });
 });
 
 test("cataloged unknown model fails unless its context is explicit", () => {
@@ -119,22 +342,46 @@ test("cataloged unknown model fails unless its context is explicit", () => {
     assert.equal(provider?.contextWindow, 8192);
 });
 
-test("explicit operator rates price out-of-snapshot models and override catalog rates", () => {
-    const priced = {
+test("Models.dev is the only fallback rate table", async () => {
+    mock.method(globalThis, "fetch", async () => new Response([
+        `data: ${JSON.stringify({
+            id: "response",
+            model: "served",
+            choices: [{ delta: { content: "ok" }, finish_reason: "stop" }],
+        })}`,
+        `data: ${JSON.stringify({
+            id: "response",
+            model: "served",
+            choices: [],
+            usage: {
+                prompt_tokens: 1_000,
+                prompt_tokens_details: { cached_tokens: 400 },
+                completion_tokens: 100,
+                total_tokens: 1_150,
+            },
+        })}`,
+        "data: [DONE]",
+    ].join("\n\n"), { headers: { "content-type": "text/event-stream" } }));
+    const cataloged = catalogProviderFromEnv("deepseek", {
+        ...env,
+        DEEPSEEK_API_KEY: "test-key",
+    }, "deepseek-v4-flash");
+    assert.notEqual(cataloged, null);
+    const catalogedResponse = await cataloged!.generate({ workerId: "cataloged", messages: [] });
+    assert.deepEqual(catalogedResponse.accounting[0]?.cost, {
+        kind: "estimated",
+        amount: { amount: "0.00012712", currency: "USD" },
+        source: "Models.dev catalog rates",
+    });
+
+    const uncataloged = catalogProviderFromEnv("xai", {
         ...env,
         XAI_API_KEY: "test-key",
         PLURNK_PROVIDERS_CONTEXT_WINDOW: "8192",
-        PLURNK_PROVIDERS_INPUT_USD_PER_MILLION: "2",
-        PLURNK_PROVIDERS_CACHE_READ_USD_PER_MILLION: "0.5",
-        PLURNK_PROVIDERS_OUTPUT_USD_PER_MILLION: "8",
-    };
-    const usage = {
-        prompt: 1_000_000,
-        cached: 250_000,
-        completion: 500_000,
-        reasoning: 500_000,
-        total: 2_000_000,
-    };
-    assert.equal(catalogProviderFromEnv("xai", priced, "not-in-the-catalog")?.calculateCost(usage), 9.625);
-    assert.equal(catalogProviderFromEnv("openai", priced, "gpt-4.1-mini")?.calculateCost(usage), 9.625);
+    }, "not-in-the-catalog");
+    const uncatalogedResponse = await uncataloged!.generate({ workerId: "uncataloged", messages: [] });
+    assert.deepEqual(uncatalogedResponse.accounting[0]?.cost, {
+        kind: "unknown",
+        reason: "Models.dev has no complete rate for this model",
+    });
 });

package/src/catalogProvider.ts

@@ -6,22 +6,23 @@ import {
     envelopeFromEnv,
     parseRequiredFloat,
     parseRequiredInt,
-    promptCacheKeyFromEnv,
+    parseTimeoutMs,
+    cacheAffinityFromEnv,
+    cacheWritePolicyFromEnv,
     reasoningFromEnv,
     reasoningResponseStyleFromEnv,
     resolveReserve,
-    tokenRatesFromEnv,
     type ReserveSpec,
 } from "./env.ts";
 import AiSdkProvider, { type ReasoningStyle } from "./AiSdkProvider.ts";
 import { configuredProviderInfo, createSdkModel } from "./sdkModels.ts";
 import { providerSource } from "./notices.ts";
-import type { Provider, ProviderUsage } from "./types.ts";
-import { calculateCostUsd } from "./usage.ts";
+import type { Provider, ProviderCostNormalizer } from "./types.ts";
+import { estimateProviderCost } from "./cost.ts";
 import { emitWarningOnce } from "./warnings.ts";
 import type { LanguageModel } from "ai";
+import type { AiSdkProviderOptions, CacheAffinity } from "./AiSdkProvider.ts";
 import type { PluginAttribution, PluginAttributionContext } from "@plurnk/plurnk-meta";
-import type { ProviderCost } from "@plurnk/plurnk-contracts";
 
 const reasoningStyleFromEnv = (
     env: NodeJS.ProcessEnv,
@@ -45,24 +46,32 @@ export const providerFromSdkModel = ({
     env,
     model,
     languageModel,
+    normalizeCost,
     url,
     headers,
     contextWindow,
     info,
     attributions,
+    cacheAffinity,
+    systemCacheProviderOptions,
+    reasoningResponseProviderOptions,
 }: {
     name: string;
     env: NodeJS.ProcessEnv;
     model: string;
     languageModel?: LanguageModel;
+    normalizeCost?: ProviderCostNormalizer;
     url?: string;
     headers?: Readonly<Record<string, string>>;
     contextWindow: number;
     info?: ModelInfo;
     attributions?: (context: PluginAttributionContext) => PluginAttribution;
+    cacheAffinity?: CacheAffinity;
+    systemCacheProviderOptions?: AiSdkProviderOptions;
+    reasoningResponseProviderOptions?: AiSdkProviderOptions;
 }): Provider => {
     emitWarningOnce(
-        `${name} provider: physical prompt counting is a chars/2 estimate; over-policy recovery fails closed without exact or bounded request evidence`,
+        `${name} provider: request-level prompt counting is a chars/2 estimate; hard context-envelope admission fails closed without exact or bounded evidence`,
         "PLURNK_PROMPT_COUNT_ESTIMATE",
     );
 
@@ -82,36 +91,34 @@ export const providerFromSdkModel = ({
                 ? configuredReasoning
                 : { tokens: Math.round(completionTokens / 2) };
 
-    const configuredRates = tokenRatesFromEnv(env, name);
     const catalogCost = info?.cost;
-    const rates = configuredRates ?? (catalogCost === undefined ? null : {
+    const rates = catalogCost === undefined ? null : {
         input: catalogCost.inputPer1M,
         output: catalogCost.outputPer1M,
-        cached: catalogCost.cacheReadPer1M ?? catalogCost.inputPer1M,
-    });
-    const calculateCost = rates === null
-        ? undefined
-        : (usage: ProviderUsage): number => calculateCostUsd(usage, rates);
-    const rateSource = configuredRates === null ? "Models.dev catalog rates" : "operator-configured rates";
-    const calculateCharge: (usage: ProviderUsage) => Exclude<ProviderCost, { kind: "authoritative" }> = rates === null
-        ? () => ({ kind: "unknown", reason: "no provider rate or settled charge is available" })
-        : rates.input === 0 && rates.output === 0 && rates.cached === 0
-            ? () => ({ kind: "free", source: rateSource })
-            : (usage: ProviderUsage) => ({
-                kind: "estimated",
-                usd: String(calculateCostUsd(usage, rates)),
-                source: rateSource,
-            });
+        ...(catalogCost.cacheReadPer1M === undefined
+            ? {}
+            : { cacheRead: catalogCost.cacheReadPer1M }),
+        ...(catalogCost.cacheWritePer1M === undefined
+            ? {}
+            : { cacheWrite: catalogCost.cacheWritePer1M }),
+    };
+    const estimateCost = (usage: Parameters<typeof estimateProviderCost>[0]) =>
+        estimateProviderCost(usage, rates, "Models.dev catalog rates");
+    const affinityEnabled = cacheAffinityFromEnv(env, name);
+    const cacheWritePolicy = cacheWritePolicyFromEnv(env, name);
 
     return new AiSdkProvider({
         model,
         ...(attributions === undefined ? {} : { attributions }),
         ...(languageModel === undefined ? {} : { languageModel }),
+        ...(normalizeCost === undefined ? {} : { normalizeCost }),
         ...(url === undefined ? {} : { url }),
         ...(headers === undefined ? {} : { headers: { ...headers } }),
         contextWindow,
-        fetchTimeoutMs: parseRequiredInt(env.PLURNK_PROVIDERS_FETCH_TIMEOUT, "PLURNK_PROVIDERS_FETCH_TIMEOUT", name),
-        streamIdleTimeoutMs: parseRequiredInt(env.PLURNK_PROVIDERS_STREAM_IDLE_TIMEOUT, "PLURNK_PROVIDERS_STREAM_IDLE_TIMEOUT", name),
+        fetchTimeoutMs: parseTimeoutMs(env.PLURNK_PROVIDERS_FETCH_TIMEOUT, "PLURNK_PROVIDERS_FETCH_TIMEOUT", name),
+        operationTimeoutMs: parseTimeoutMs(env.PLURNK_PROVIDERS_OPERATION_TIMEOUT, "PLURNK_PROVIDERS_OPERATION_TIMEOUT", name),
+        firstContentTimeoutMs: parseTimeoutMs(env.PLURNK_PROVIDERS_FIRST_CONTENT_TIMEOUT, "PLURNK_PROVIDERS_FIRST_CONTENT_TIMEOUT", name),
+        streamIdleTimeoutMs: parseTimeoutMs(env.PLURNK_PROVIDERS_STREAM_IDLE_TIMEOUT, "PLURNK_PROVIDERS_STREAM_IDLE_TIMEOUT", name),
         reasoning,
         reasoningResponseStyle: reasoningResponseStyleFromEnv(env, name),
         temperature: parseRequiredFloat(env.PLURNK_PROVIDERS_TEMPERATURE, "PLURNK_PROVIDERS_TEMPERATURE", name, 0),
@@ -122,10 +129,15 @@ export const providerFromSdkModel = ({
         retryAttempts: parseRequiredInt(env.PLURNK_PROVIDERS_RETRY_ATTEMPTS, "PLURNK_PROVIDERS_RETRY_ATTEMPTS", name),
         errorDetailLimit: parseRequiredInt(env.PLURNK_PROVIDERS_ERROR_DETAIL_LIMIT, "PLURNK_PROVIDERS_ERROR_DETAIL_LIMIT", name),
         reasoningStyle: reasoningStyleFromEnv(env, name),
-        promptCacheKey: url === undefined ? false : promptCacheKeyFromEnv(env, name),
+        ...(affinityEnabled && cacheAffinity !== undefined ? { cacheAffinity } : {}),
+        ...(cacheWritePolicy === "stable-system" && systemCacheProviderOptions !== undefined
+            ? { systemCacheProviderOptions }
+            : {}),
+        ...(reasoningResponseProviderOptions === undefined
+            ? {}
+            : { reasoningResponseProviderOptions }),
         serviceTier: env.PLURNK_PROVIDERS_SERVICE_TIER,
-        calculateCost,
-        calculateCharge,
+        estimateCost,
         source: providerSource(name),
         gbnfDebug: env.PLURNK_PROVIDERS_GBNF_DEBUG !== undefined
             && env.PLURNK_PROVIDERS_GBNF_DEBUG !== ""
@@ -165,8 +177,12 @@ export const catalogProviderFromEnv = (
         env,
         model: wireModel,
         languageModel: sdk.languageModel,
+        normalizeCost: sdk.normalizeCost,
         url: sdk.compatible?.url,
         headers: sdk.compatible?.headers,
+        cacheAffinity: sdk.cacheAffinity,
+        systemCacheProviderOptions: sdk.systemCacheProviderOptions,
+        reasoningResponseProviderOptions: sdk.reasoningResponseProviderOptions,
         contextWindow,
         info,
     });

package/src/compatibleProvider.test.ts

@@ -5,6 +5,8 @@ import { compatibleProviderFromEnv } from "./compatibleProvider.ts";
 const env = {
     OPENAI_BASE_URL: "http://local.test/v1",
     PLURNK_PROVIDERS_FETCH_TIMEOUT: "1000",
+    PLURNK_PROVIDERS_OPERATION_TIMEOUT: "3000",
+    PLURNK_PROVIDERS_FIRST_CONTENT_TIMEOUT: "1000",
     PLURNK_PROVIDERS_STREAM_IDLE_TIMEOUT: "0",
     PLURNK_PROVIDERS_REASONING: "off",
     PLURNK_PROVIDERS_TEMPERATURE: "0.2",
@@ -16,12 +18,13 @@ const env = {
     PLURNK_PROVIDERS_ERROR_DETAIL_LIMIT: "512",
     PLURNK_PROVIDERS_PROBE_ATTEMPTS: "1",
     PLURNK_PROVIDERS_PROBE_DELAY: "0",
-    PLURNK_PROVIDERS_PROMPT_CACHE_KEY: "1",
+    PLURNK_PROVIDERS_CACHE_AFFINITY: "1",
+    PLURNK_PROVIDERS_CACHE_WRITE_POLICY: "stable-system",
 };
 
 test.afterEach(() => mock.restoreAll());
 
-test("compatible endpoints preserve configured prompt-cache affinity", async () => {
+test("an undifferentiated compatible endpoint receives no guessed prompt-cache field", async () => {
     let body: Record<string, unknown> | undefined;
     mock.method(globalThis, "fetch", async (input: string | URL | Request, init?: RequestInit) => {
         if (String(input).endsWith("/models")) {
@@ -41,7 +44,7 @@ test("compatible endpoints preserve configured prompt-cache affinity", async ()
         messages: [{ role: "user", content: "hello" }],
     });
 
-    assert.equal(body?.prompt_cache_key, "worker-affinity");
+    assert.equal("prompt_cache_key" in (body ?? {}), false);
 });
 
 test("the server-wide DRY-off floor emits no DRY request fields", async () => {

package/src/compatibleProvider.ts

@@ -8,11 +8,14 @@ import {
     parseOptionalInt,
     parseRequiredFloat,
     parseRequiredInt,
-    promptCacheKeyFromEnv,
+    parseTimeoutMs,
+    cacheAffinityFromEnv,
+    cacheWritePolicyFromEnv,
     reasoningFromEnv,
     reasoningResponseStyleFromEnv,
 } from "./env.ts";
 import { providerSource } from "./notices.ts";
+import { plurnkCostNormalizer } from "./accounting.ts";
 import type { Provider } from "./types.ts";
 import { emitWarningOnce } from "./warnings.ts";
 
@@ -49,7 +52,10 @@ const probeModels = async (
 ): Promise<EndpointProbe> => {
     const modelsUrl = url.replace(/\/chat\/completions$/, "/models");
     try {
-        const response = await fetch(modelsUrl, { headers, signal: AbortSignal.timeout(timeout) });
+        const response = await fetch(modelsUrl, {
+            headers,
+            ...(timeout > 0 ? { signal: AbortSignal.timeout(timeout) } : {}),
+        });
         if (!response.ok) return { nCtx: null, llamaServer: false, servedModel: null, failed: true };
         const data = await response.json() as {
             data?: Array<{ id?: string; n_ctx?: number; meta?: { n_ctx?: number } }>;
@@ -93,7 +99,7 @@ const probeProps = async (
     try {
         const response = await fetch(url.replace(/\/v1\/chat\/completions$/, "/props"), {
             headers,
-            signal: AbortSignal.timeout(timeout),
+            ...(timeout > 0 ? { signal: AbortSignal.timeout(timeout) } : {}),
         });
         if (!response.ok) return { slotCount: null, eosText: null };
         const data = await response.json() as { total_slots?: number; eos_token?: string };
@@ -112,12 +118,17 @@ export const compatibleProviderFromEnv = async (
     model: string,
     baseUrlOverride?: string,
 ): Promise<Provider> => {
+    // The knobs remain universal and fail hard when malformed, but this local /
+    // first-party compatible route declares no vendor cache projection. llama-server
+    // already owns slot affinity and the first-party endpoint receives worker metadata.
+    cacheAffinityFromEnv(env, provider);
+    cacheWritePolicyFromEnv(env, provider);
     const url = chatUrl(provider, env, baseUrlOverride);
     const apiKey = provider === "openai" ? env.OPENAI_API_KEY : env.PLURNK_API_KEY;
     const headers: Record<string, string> = apiKey === undefined || apiKey.length === 0
         ? {}
         : { Authorization: `Bearer ${apiKey}` };
-    const timeout = parseRequiredInt(env.PLURNK_PROVIDERS_FETCH_TIMEOUT, "PLURNK_PROVIDERS_FETCH_TIMEOUT", provider);
+    const timeout = parseTimeoutMs(env.PLURNK_PROVIDERS_FETCH_TIMEOUT, "PLURNK_PROVIDERS_FETCH_TIMEOUT", provider);
     const attempts = parseRequiredInt(env.PLURNK_PROVIDERS_PROBE_ATTEMPTS, "PLURNK_PROVIDERS_PROBE_ATTEMPTS", provider);
     const probe = await probeModelsRetrying(
         url,
@@ -165,7 +176,7 @@ export const compatibleProviderFromEnv = async (
 
     if (!llamaServer) {
         emitWarningOnce(
-            `${provider} provider: physical prompt counting is a chars/2 estimate; over-policy recovery fails closed without exact or bounded request evidence`,
+            `${provider} provider: request-level prompt counting is a chars/2 estimate; hard context-envelope admission fails closed without exact or bounded evidence`,
             "PLURNK_PROMPT_COUNT_ESTIMATE",
         );
     }
@@ -176,7 +187,9 @@ export const compatibleProviderFromEnv = async (
         headers,
         contextWindow,
         fetchTimeoutMs: timeout,
-        streamIdleTimeoutMs: parseRequiredInt(env.PLURNK_PROVIDERS_STREAM_IDLE_TIMEOUT, "PLURNK_PROVIDERS_STREAM_IDLE_TIMEOUT", provider),
+        operationTimeoutMs: parseTimeoutMs(env.PLURNK_PROVIDERS_OPERATION_TIMEOUT, "PLURNK_PROVIDERS_OPERATION_TIMEOUT", provider),
+        firstContentTimeoutMs: parseTimeoutMs(env.PLURNK_PROVIDERS_FIRST_CONTENT_TIMEOUT, "PLURNK_PROVIDERS_FIRST_CONTENT_TIMEOUT", provider),
+        streamIdleTimeoutMs: parseTimeoutMs(env.PLURNK_PROVIDERS_STREAM_IDLE_TIMEOUT, "PLURNK_PROVIDERS_STREAM_IDLE_TIMEOUT", provider),
         reasoning: reasoningFromEnv(env, provider),
         reasoningResponseStyle: reasoningResponseStyleFromEnv(env, provider),
         reasoningStyle,
@@ -192,7 +205,6 @@ export const compatibleProviderFromEnv = async (
         tuningFloors: provider !== "plurnk",
         retryAttempts: parseRequiredInt(env.PLURNK_PROVIDERS_RETRY_ATTEMPTS, "PLURNK_PROVIDERS_RETRY_ATTEMPTS", provider),
         errorDetailLimit: parseRequiredInt(env.PLURNK_PROVIDERS_ERROR_DETAIL_LIMIT, "PLURNK_PROVIDERS_ERROR_DETAIL_LIMIT", provider),
-        promptCacheKey: promptCacheKeyFromEnv(env, provider),
         source: providerSource(provider),
         grammarStyle,
         gbnfDebug: env.PLURNK_PROVIDERS_GBNF_DEBUG !== undefined
@@ -200,6 +212,7 @@ export const compatibleProviderFromEnv = async (
             && env.PLURNK_PROVIDERS_GBNF_DEBUG !== "0",
         ...dataCaptureFromEnv(env, provider),
         firstPartyMetadata: provider === "plurnk",
+        normalizeCost: provider === "plurnk" ? plurnkCostNormalizer : undefined,
         apiKeyRejectedMessage: provider === "plurnk"
             ? "PLURNK_API_KEY was rejected by plurnk.ai (invalid or expired)."
             : undefined,