@plurnk/plurnk-providers 1.4.0 → 1.5.0

package/src/accounting.test.ts

@@ -0,0 +1,58 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { authoritativeChargeNormalizer } from "./accounting.ts";
+
+const evidence = ({ providerMetadata, usage }: { providerMetadata?: unknown; usage?: unknown }) => ({
+    ...(providerMetadata === undefined ? {} : { providerMetadata }),
+    ...(usage === undefined ? {} : { usage }),
+    response: { id: "response-1" },
+});
+
+test("xAI response ticks normalize to an exact provider-authoritative charge", () => {
+    const normalize = authoritativeChargeNormalizer("@ai-sdk/xai");
+    assert.notEqual(normalize, undefined);
+    assert.deepEqual(normalize!(evidence({ usage: { cost_in_usd_ticks: 15_493_500 } })), {
+        kind: "authoritative",
+        amount: { amount: "15493500", currency: "USDTICK" },
+        usdEquivalent: "0.00154935",
+        source: "xAI response usage.cost_in_usd_ticks",
+    });
+});
+
+test("OpenRouter response cost normalizes without rate reconstruction", () => {
+    const normalize = authoritativeChargeNormalizer("@openrouter/ai-sdk-provider");
+    assert.notEqual(normalize, undefined);
+    assert.deepEqual(normalize!(evidence({ providerMetadata: { openrouter: { usage: { cost: 3.2e-7 } } } })), {
+        kind: "authoritative",
+        amount: { amount: "0.00000032", currency: "USD" },
+        usdEquivalent: "0.00000032",
+        source: "OpenRouter response usage.cost",
+    });
+});
+
+test("DeepInfra's documented response estimate wins over local rate reconstruction", () => {
+    const normalize = authoritativeChargeNormalizer("@ai-sdk/deepinfra");
+    assert.notEqual(normalize, undefined);
+    assert.deepEqual(normalize!(evidence({ usage: { estimated_cost: 5.04e-5 } })), {
+        kind: "authoritative",
+        amount: { amount: "0.0000504", currency: "USD" },
+        usdEquivalent: "0.0000504",
+        source: "DeepInfra response usage.estimated_cost",
+    });
+});
+
+test("response cost normalization is an explicit adapter capability", () => {
+    assert.equal(authoritativeChargeNormalizer("@ai-sdk/anthropic"), undefined);
+    assert.equal(
+        authoritativeChargeNormalizer("@ai-sdk/xai")!(evidence({ usage: {} })),
+        undefined,
+    );
+    assert.throws(
+        () => authoritativeChargeNormalizer("@ai-sdk/xai")!(evidence({ usage: { cost_in_usd_ticks: "1" } })),
+        /cost_in_usd_ticks must be numeric/,
+    );
+    assert.throws(
+        () => authoritativeChargeNormalizer("@ai-sdk/deepinfra")!(evidence({ usage: { estimated_cost: "1" } })),
+        /estimated_cost must be numeric/,
+    );
+});

package/src/accounting.ts

@@ -0,0 +1,88 @@
+import type {
+    AuthoritativeChargeNormalizer,
+} from "./types.ts";
+
+const recordOf = (value: unknown): Record<string, unknown> | null =>
+    typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value as Record<string, unknown>
+        : null;
+
+const decimalFromNumber = (value: number, subject: string): string => {
+    if (!Number.isFinite(value) || value < 0) {
+        throw new TypeError(`${subject} must be a finite non-negative number`);
+    }
+    const source = String(value);
+    if (!/[eE]/.test(source)) return source;
+    const [coefficient, exponentSource] = source.toLowerCase().split("e");
+    const exponent = Number(exponentSource);
+    const [integer, fraction = ""] = coefficient!.split(".");
+    const digits = `${integer}${fraction}`;
+    const point = integer!.length + exponent;
+    if (point <= 0) return `0.${"0".repeat(-point)}${digits}`;
+    if (point >= digits.length) return `${digits}${"0".repeat(point - digits.length)}`;
+    return `${digits.slice(0, point)}.${digits.slice(point)}`;
+};
+
+const usdFromTicks = (ticks: number): string => {
+    if (!Number.isSafeInteger(ticks) || ticks < 0) {
+        throw new TypeError("xAI costInUsdTicks must be a non-negative safe integer");
+    }
+    const digits = String(ticks).padStart(11, "0");
+    const integer = digits.slice(0, -10).replace(/^0+(?=\d)/, "");
+    const fraction = digits.slice(-10).replace(/0+$/, "");
+    return fraction === "" ? integer : `${integer}.${fraction}`;
+};
+
+const xaiCharge: AuthoritativeChargeNormalizer = ({ usage }) => {
+    const wireUsage = recordOf(usage);
+    if (wireUsage === null || !("cost_in_usd_ticks" in wireUsage)) return undefined;
+    const ticks = wireUsage.cost_in_usd_ticks;
+    if (typeof ticks !== "number") {
+        throw new TypeError("xAI usage.cost_in_usd_ticks must be numeric");
+    }
+    return {
+        kind: "authoritative",
+        amount: { amount: String(ticks), currency: "USDTICK" },
+        usdEquivalent: usdFromTicks(ticks),
+        source: "xAI response usage.cost_in_usd_ticks",
+    };
+};
+
+const openRouterCharge: AuthoritativeChargeNormalizer = ({ providerMetadata }) => {
+    const usage = recordOf(recordOf(recordOf(providerMetadata)?.openrouter)?.usage);
+    if (usage === null || !("cost" in usage)) return undefined;
+    const cost = usage.cost;
+    if (typeof cost !== "number") throw new TypeError("OpenRouter usage.cost must be numeric");
+    const amount = decimalFromNumber(cost, "OpenRouter usage.cost");
+    return {
+        kind: "authoritative",
+        amount: { amount, currency: "USD" },
+        usdEquivalent: amount,
+        source: "OpenRouter response usage.cost",
+    };
+};
+
+const deepInfraCharge: AuthoritativeChargeNormalizer = ({ usage }) => {
+    const wireUsage = recordOf(usage);
+    if (wireUsage === null || !("estimated_cost" in wireUsage)) return undefined;
+    const cost = wireUsage.estimated_cost;
+    if (typeof cost !== "number") throw new TypeError("DeepInfra usage.estimated_cost must be numeric");
+    const amount = decimalFromNumber(cost, "DeepInfra usage.estimated_cost");
+    return {
+        kind: "authoritative",
+        amount: { amount, currency: "USD" },
+        usdEquivalent: amount,
+        source: "DeepInfra response usage.estimated_cost",
+    };
+};
+
+export const authoritativeChargeNormalizer = (
+    sdkPackage: string,
+): AuthoritativeChargeNormalizer | undefined => {
+    switch (sdkPackage) {
+        case "@ai-sdk/xai": return xaiCharge;
+        case "@ai-sdk/deepinfra": return deepInfraCharge;
+        case "@openrouter/ai-sdk-provider": return openRouterCharge;
+        default: return undefined;
+    }
+};

package/src/aiSdkTransport.ts

@@ -1,7 +1,8 @@
 import { createOpenAICompatible, type ProviderErrorStructure } from "@ai-sdk/openai-compatible";
-import { generateText, streamText, type JSONValue, type LanguageModel, type LanguageModelUsage } from "ai";
+import { APICallError, generateText, streamText, type JSONValue, type LanguageModel, type LanguageModelUsage } from "ai";
+import { prepareRetries } from "ai/internal";
 import { z } from "zod/v4";
-import type { ChatMessage, ProviderAttemptFinishReason, ProviderUsage, TokenLogprob } from "./types.ts";
+import type { ChatMessage, ProviderAttemptFinishReason, ProviderChargeEvidence, ProviderUsage, TokenLogprob } from "./types.ts";
 import { normalizeUsage, type RawUsage } from "./usage.ts";
 import { emitWarningOnce } from "./warnings.ts";
 
@@ -66,6 +67,14 @@ const wireUsageOf = (
     return null;
 };
 
+const wireUsageEvidenceOf = (values: readonly unknown[]): unknown => {
+    for (let index = values.length - 1; index >= 0; index -= 1) {
+        const record = recordOf(values[index]);
+        if (record !== null && record.usage !== undefined) return record.usage;
+    }
+    return undefined;
+};
+
 const finishReasonOf = (reason: string | undefined): ProviderAttemptFinishReason => {
     switch (reason?.toLowerCase()) {
         case "stop":
@@ -146,6 +155,7 @@ export type AiSdkTransportResponse = {
         encrypted: Array<{ data: string; format: string | null }>;
     }>;
     logprobs: TokenLogprob[];
+    chargeEvidence: ProviderChargeEvidence;
     rawBody?: unknown;
 };
 
@@ -163,8 +173,46 @@ export type AiSdkModelRequest = Omit<AiSdkTransportRequest, "url" | "model" | "b
     reasoning?: "minimal" | "low" | "medium" | "high" | "xhigh" | "none" | "provider-default";
 };
 
+const isStreamIdleTimeout = (cause: unknown): cause is Error | DOMException =>
+    typeof cause === "object"
+    && cause !== null
+    && (cause as { name?: string }).name === "TimeoutError"
+    && /chunk timeout/i.test(String((cause as { message?: unknown }).message ?? ""));
+
 const executeModel = async (
     request: AiSdkModelRequest,
+): Promise<AiSdkTransportResponse> => {
+    const timeoutSignal = AbortSignal.timeout(request.fetchTimeoutMs);
+    const operationSignal = request.signal === undefined
+        ? timeoutSignal
+        : AbortSignal.any([request.signal, timeoutSignal]);
+    const { retry } = prepareRetries({
+        maxRetries: request.retryAttempts,
+        abortSignal: operationSignal,
+    });
+    return retry(async () => {
+        try {
+            return await executeModelOnce({
+                ...request,
+                signal: operationSignal,
+                retryAttempts: 0,
+            });
+        } catch (cause) {
+            if (operationSignal.aborted) throw operationSignal.reason;
+            if (!isStreamIdleTimeout(cause)) throw cause;
+            throw new APICallError({
+                message: cause.message,
+                url: "model:generation",
+                requestBodyValues: {},
+                cause,
+                isRetryable: true,
+            });
+        }
+    });
+};
+
+const executeModelOnce = async (
+    request: AiSdkModelRequest,
 ): Promise<AiSdkTransportResponse> => {
     const {
         languageModel: model,
@@ -227,6 +275,7 @@ const executeModel = async (
         const rawBody = result.response.body;
         const values = [rawBody];
         const evidence = extractEvidence(values);
+        const accountingUsage = wireUsageEvidenceOf(values);
         const reasoningText = evidence.reasoning || result.reasoningText || "";
         const rawFinishReason = result.rawFinishReason;
         return {
@@ -241,6 +290,18 @@ const executeModel = async (
             metadata: metadataOf(values),
             reasoningEncrypted: evidence.reasoningEncrypted,
             logprobs: evidence.logprobs,
+            chargeEvidence: {
+                ...(accountingUsage === undefined ? {} : { usage: accountingUsage }),
+                ...(result.providerMetadata === undefined
+                    ? {}
+                    : { providerMetadata: result.providerMetadata }),
+                response: {
+                    id: result.response.id,
+                    ...(result.response.headers === undefined
+                        ? {}
+                        : { headers: result.response.headers }),
+                },
+            },
             ...(request.captureRawBody ? { rawBody } : {}),
         };
     }
@@ -258,11 +319,16 @@ const executeModel = async (
     }
     if (streamError !== undefined) throw streamError;
     const evidence = extractEvidence(rawChunks);
+    const accountingUsage = wireUsageEvidenceOf(rawChunks);
     const content = await result.text;
     const reasoningText = evidence.reasoning || (await result.reasoningText) || "";
     const rawFinishReason = await result.rawFinishReason;
+    const [response, providerMetadata] = await Promise.all([
+        result.response,
+        result.providerMetadata,
+    ]);
     return {
-        model: (await result.response).modelId,
+        model: response.modelId,
         content,
         reasoning: reasoningText,
         reasoningProjected: evidence.reasoningProjected,
@@ -273,6 +339,14 @@ const executeModel = async (
         metadata: metadataOf(rawChunks),
         reasoningEncrypted: evidence.reasoningEncrypted,
         logprobs: evidence.logprobs,
+        chargeEvidence: {
+            ...(accountingUsage === undefined ? {} : { usage: accountingUsage }),
+            ...(providerMetadata === undefined ? {} : { providerMetadata }),
+            response: {
+                id: response.id,
+                ...(response.headers === undefined ? {} : { headers: response.headers }),
+            },
+        },
         ...(request.captureRawBody ? { rawBody: rawChunks } : {}),
     };
 };

package/src/boundaries.test.ts

@@ -30,6 +30,7 @@ test("the OpenAI-compatible entrypoint excludes Node-owned provider machinery",
     const allowed = new Set([
         "AiSdkProvider.ts",
         "aiSdkTransport.ts",
+        "cost.ts",
         "env.ts",
         "errors.ts",
         "notices.ts",

package/src/catalogProvider.test.ts

@@ -1,6 +1,7 @@
 import test, { mock } from "node:test";
 import { strict as assert } from "node:assert";
 import { catalogProviderFromEnv } from "./catalogProvider.ts";
+import { providerCostFor } from "./cost.ts";
 import { resetEmittedWarnings } from "./warnings.ts";
 
 const env = {
@@ -119,22 +120,32 @@ 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", () => {
+    const usage = {
+        prompt: 1_000,
+        cached: 400,
+        completion: 100,
+        reasoning: 50,
+        total: 1_150,
+    };
+    const cataloged = catalogProviderFromEnv("deepseek", {
+        ...env,
+        DEEPSEEK_API_KEY: "test-key",
+    }, "deepseek-v4-flash");
+    assert.notEqual(cataloged, null);
+    assert.deepEqual(providerCostFor(cataloged!, usage), {
+        kind: "estimated",
+        usd: "0.00012712",
+        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");
+    assert.deepEqual(providerCostFor(uncataloged!, usage), {
+        kind: "unknown",
+        reason: "the response reported no cost and Models.dev has no rate for this model",
+    });
 });

package/src/catalogProvider.ts

@@ -10,14 +10,13 @@ import {
     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 { AuthoritativeChargeNormalizer, Provider, ProviderUsage } from "./types.ts";
+import { calculateCostUsd, calculateCostUsdDecimal } from "./usage.ts";
 import { emitWarningOnce } from "./warnings.ts";
 import type { LanguageModel } from "ai";
 import type { PluginAttribution, PluginAttributionContext } from "@plurnk/plurnk-meta";
@@ -45,6 +44,7 @@ export const providerFromSdkModel = ({
     env,
     model,
     languageModel,
+    normalizeCharge,
     url,
     headers,
     contextWindow,
@@ -55,6 +55,7 @@ export const providerFromSdkModel = ({
     env: NodeJS.ProcessEnv;
     model: string;
     languageModel?: LanguageModel;
+    normalizeCharge?: AuthoritativeChargeNormalizer;
     url?: string;
     headers?: Readonly<Record<string, string>>;
     contextWindow: number;
@@ -82,31 +83,30 @@ 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" })
+        ? () => ({ kind: "unknown", reason: "the response reported no cost and Models.dev has no rate for this model" })
         : rates.input === 0 && rates.output === 0 && rates.cached === 0
-            ? () => ({ kind: "free", source: rateSource })
+            ? () => ({ kind: "free", source: "Models.dev catalog rates" })
             : (usage: ProviderUsage) => ({
                 kind: "estimated",
-                usd: String(calculateCostUsd(usage, rates)),
-                source: rateSource,
+                usd: calculateCostUsdDecimal(usage, rates),
+                source: "Models.dev catalog rates",
             });
 
     return new AiSdkProvider({
         model,
         ...(attributions === undefined ? {} : { attributions }),
         ...(languageModel === undefined ? {} : { languageModel }),
+        ...(normalizeCharge === undefined ? {} : { normalizeCharge }),
         ...(url === undefined ? {} : { url }),
         ...(headers === undefined ? {} : { headers: { ...headers } }),
         contextWindow,
@@ -165,6 +165,7 @@ export const catalogProviderFromEnv = (
         env,
         model: wireModel,
         languageModel: sdk.languageModel,
+        normalizeCharge: sdk.normalizeCharge,
         url: sdk.compatible?.url,
         headers: sdk.compatible?.headers,
         contextWindow,

package/src/cost.test.ts

@@ -39,18 +39,19 @@ test("explicit free remains distinguishable from unknown", () => {
     assert.deepEqual(free, { kind: "free", source: "local model" });
     assert.deepEqual(unknown, {
         kind: "unknown",
-        reason: "legacy calculateCost returned zero without free-cost authority",
+        reason: "the response reported no cost and Models.dev has no rate for this model",
     });
     assert.equal(providerCostUsd(free), 0);
     assert.equal(providerCostUsd(unknown), null);
 });
 
-test("positive legacy cost remains an estimated USD compatibility result", () => {
-    assert.deepEqual(providerCostFor({ calculateCost: () => 0.25 }, usage), {
-        kind: "estimated",
-        usd: "0.25",
-        source: "legacy calculateCost",
+test("legacy calculateCost is not a monetary-reporting authority", () => {
+    const cost = providerCostFor({ calculateCost: () => 0.25 }, usage);
+    assert.deepEqual(cost, {
+        kind: "unknown",
+        reason: "the response reported no cost and Models.dev has no rate for this model",
     });
+    assert.equal(providerCostUsd(cost), null);
 });
 
 test("rejects malformed money instead of mining or coercing it", () => {

package/src/cost.ts

@@ -48,17 +48,13 @@ export const validateProviderCost = (cost: ProviderCost): ProviderCost => {
 export const resolveProviderCost = (
     charge: AuthoritativeCharge | undefined,
     current: ProviderCost | undefined,
-    legacy: () => number,
 ): ProviderCost => {
     if (charge !== undefined) return validateAuthoritativeCharge(charge);
     if (current !== undefined) return validateProviderCost(current);
-    const cost = legacy();
-    if (!Number.isFinite(cost) || cost < 0) {
-        throw new TypeError("legacy provider cost must be a finite non-negative number");
-    }
-    return cost > 0
-        ? { kind: "estimated", usd: String(cost), source: "legacy calculateCost" }
-        : { kind: "unknown", reason: "legacy calculateCost returned zero without free-cost authority" };
+    return {
+        kind: "unknown",
+        reason: "the response reported no cost and Models.dev has no rate for this model",
+    };
 };
 
 export const providerCostUsd = (cost: ProviderCost): number | null => {
@@ -79,5 +75,4 @@ export const providerCostFor = (
 ): ProviderCost => resolveProviderCost(
     charge,
     provider.calculateCharge?.(usage),
-    () => provider.calculateCost(usage),
 );

package/src/env.test.ts

@@ -1,6 +1,6 @@
 import test from "node:test";
 import { strict as assert } from "node:assert";
-import { parseRequiredInt, parseOptionalInt, requireEnv, reasoningFromEnv, reasoningResponseStyleFromEnv, tokenRatesFromEnv } from "./env.ts";
+import { parseRequiredInt, parseOptionalInt, requireEnv, reasoningFromEnv, reasoningResponseStyleFromEnv } from "./env.ts";
 
 test("parseRequiredInt: parses a non-negative integer", () => {
     assert.equal(parseRequiredInt("600000", "PLURNK_PROVIDERS_FETCH_TIMEOUT", "openai"), 600000);
@@ -59,31 +59,6 @@ test("requireEnv: returns the value or throws a named error", () => {
     assert.throws(() => requireEnv("", "GROQ_API_KEY", "groq"), /must be set/);
 });
 
-test("tokenRatesFromEnv is all-or-nothing, with cached input defaulting to input", () => {
-    assert.equal(tokenRatesFromEnv({}, "cloudflare"), null);
-    assert.deepEqual(tokenRatesFromEnv({
-        PLURNK_PROVIDERS_INPUT_USD_PER_MILLION: "0.435",
-        PLURNK_PROVIDERS_OUTPUT_USD_PER_MILLION: "0.87",
-    }, "cloudflare"), {
-        input: 0.435,
-        cached: 0.435,
-        output: 0.87,
-    });
-    assert.deepEqual(tokenRatesFromEnv({
-        PLURNK_PROVIDERS_INPUT_USD_PER_MILLION: "3",
-        PLURNK_PROVIDERS_CACHE_READ_USD_PER_MILLION: "0.3",
-        PLURNK_PROVIDERS_OUTPUT_USD_PER_MILLION: "15",
-    }, "cloudflare"), {
-        input: 3,
-        cached: 0.3,
-        output: 15,
-    });
-    assert.throws(
-        () => tokenRatesFromEnv({ PLURNK_PROVIDERS_INPUT_USD_PER_MILLION: "1" }, "cloudflare"),
-        /PLURNK_PROVIDERS_OUTPUT_USD_PER_MILLION must be set/,
-    );
-});
-
 // — per-alias knob scoping (per-alias scoping doctrine, user 2026-07-03) —
 
 test("scopeEnvToAlias: suffixed knob wins, bare is the fallback, other aliases ignored", async () => {

package/src/env.ts

@@ -91,27 +91,6 @@ export function effectiveContextWindow(operatorCap: number | null, naturalWindow
             : Math.min(operatorCap, naturalWindow);
 }
 
-export type ProviderTokenRates = { input: number; cached: number; output: number };
-
-// {§model-fact-resolution} — any explicit rate opts into one complete operator
-// estimate; cached input alone may default to the explicit input rate.
-export const tokenRatesFromEnv = (env: NodeJS.ProcessEnv, label: string): ProviderTokenRates | null => {
-    const inputName = "PLURNK_PROVIDERS_INPUT_USD_PER_MILLION";
-    const cachedName = "PLURNK_PROVIDERS_CACHE_READ_USD_PER_MILLION";
-    const outputName = "PLURNK_PROVIDERS_OUTPUT_USD_PER_MILLION";
-    const configured = [inputName, cachedName, outputName]
-        .some((name) => env[name] !== undefined && env[name] !== "");
-    if (!configured) return null;
-    const input = parseRequiredFloat(env[inputName], inputName, label, 0);
-    return {
-        input,
-        cached: env[cachedName] === undefined || env[cachedName] === ""
-            ? input
-            : parseRequiredFloat(env[cachedName], cachedName, label, 0),
-        output: parseRequiredFloat(env[outputName], outputName, label, 0),
-    };
-};
-
 // {§provider-generation-envelope} How much of a
 // DETECTED context window is reserved for reasoning and for completion — the
 // remainder (minus the consumer's own packing-safety margin) is the prompt
@@ -218,9 +197,6 @@ export const PROVIDERS_KNOBS = Object.freeze([
     "PLURNK_PROVIDERS_REASONING_BUDGET",
     "PLURNK_PROVIDERS_REASONING",
     "PLURNK_PROVIDERS_CONTEXT_WINDOW",
-    "PLURNK_PROVIDERS_INPUT_USD_PER_MILLION",
-    "PLURNK_PROVIDERS_CACHE_READ_USD_PER_MILLION",
-    "PLURNK_PROVIDERS_OUTPUT_USD_PER_MILLION",
     "PLURNK_PROVIDERS_RETRY_ATTEMPTS",
     "PLURNK_PROVIDERS_ERROR_DETAIL_LIMIT",
     "PLURNK_PROVIDERS_FETCH_TIMEOUT",

package/src/errors.ts

@@ -158,6 +158,7 @@ export const classifyProviderError = (
         if (status === 401 || status === 403) return { kind: "unauthorized", message };
         if (status === 402) return { kind: "quota_exceeded", message };
         if (status === 429) return { kind: "rate_limit", message };
+        if (status === 0 && err.isRetryable) return { kind: "network_failure", message };
         if (status >= 500) return { kind: "network_failure", message };
         if (status === 422 && wireErrorType(body) === "grammar_invalid") {
             return { kind: "grammar_invalid", message };

package/src/index.ts

@@ -45,7 +45,7 @@ export { default as Pool } from "./Pool.ts";
 export type { ProviderFetch } from "./AiSdkProvider.ts";
 export { parseRequiredInt, parseOptionalInt, parseRequiredFloat, parseOptionalFloat, requireEnv, reasoningFromEnv, reasoningResponseStyleFromEnv, scopeEnvToAlias, dataCaptureFromEnv, contextWindowFromEnv, effectiveContextWindow, envelopeFromEnv, resolveReserve, PROVIDERS_KNOBS } from "./env.ts";
 export type { Reasoning, ReasoningMode, ReasoningResponseStyle, ReserveSpec } from "./env.ts";
-export { normalizeUsage, calculateCostUsd } from "./usage.ts";
+export { normalizeUsage, calculateCostUsd, calculateCostUsdDecimal } from "./usage.ts";
 export {
     providerCostFor,
     providerCostUsd,

package/src/sdkModels.test.ts

@@ -19,9 +19,28 @@ test("createSdkModel uses Models.dev provider facts and operator credentials", (
     const sdk = createSdkModel("xai", "grok-build-0.1", { XAI_API_KEY: "test-key" });
     assert.notEqual(sdk, null);
     assert.equal(sdk?.catalog?.npm, "@ai-sdk/xai");
-    const languageModel = sdk?.languageModel as { provider: string; modelId: string };
-    assert.equal(languageModel.provider, "xai.responses");
-    assert.equal(languageModel.modelId, "grok-build-0.1");
+    assert.equal(sdk?.languageModel, undefined);
+    assert.deepEqual(sdk?.compatible, {
+        url: "https://api.x.ai/v1/chat/completions",
+        headers: { Authorization: "Bearer test-key" },
+    });
+    assert.notEqual(sdk?.normalizeCharge, undefined);
+});
+
+test("createSdkModel attaches DeepInfra's documented response-cost normalizer", () => {
+    const sdk = createSdkModel("deepinfra", "zai-org/GLM-5.2", {
+        DEEPINFRA_API_KEY: "test-key",
+    });
+    assert.notEqual(sdk?.languageModel, undefined);
+    assert.deepEqual(sdk?.normalizeCharge?.({
+        usage: { estimated_cost: 5.04e-5 },
+        response: { id: "response-1" },
+    }), {
+        kind: "authoritative",
+        amount: { amount: "0.0000504", currency: "USD" },
+        usdEquivalent: "0.0000504",
+        source: "DeepInfra response usage.estimated_cost",
+    });
 });
 
 test("createSdkModel expands catalog endpoint variables without treating them as credentials", () => {