@plurnk/plurnk-providers 1.5.0 → 1.6.1

package/src/catalogProvider.ts

@@ -3,24 +3,24 @@ import {
     contextWindowFromEnv,
     effectiveContextWindow,
     dataCaptureFromEnv,
-    envelopeFromEnv,
+    generationEnvelopeFromEnv,
     parseRequiredFloat,
     parseRequiredInt,
-    promptCacheKeyFromEnv,
+    parseTimeoutMs,
+    cacheAffinityFromEnv,
+    cacheWritePolicyFromEnv,
     reasoningFromEnv,
     reasoningResponseStyleFromEnv,
-    resolveReserve,
-    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 { AuthoritativeChargeNormalizer, Provider, ProviderUsage } from "./types.ts";
-import { calculateCostUsd, calculateCostUsdDecimal } 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,
@@ -44,88 +44,102 @@ export const providerFromSdkModel = ({
     env,
     model,
     languageModel,
-    normalizeCharge,
+    normalizeCost,
     url,
     headers,
     contextWindow,
     info,
     attributions,
+    cacheAffinity,
+    systemCacheProviderOptions,
+    reasoningResponseProviderOptions,
+    additiveReasoningProvider,
 }: {
     name: string;
     env: NodeJS.ProcessEnv;
     model: string;
     languageModel?: LanguageModel;
-    normalizeCharge?: AuthoritativeChargeNormalizer;
+    normalizeCost?: ProviderCostNormalizer;
     url?: string;
     headers?: Readonly<Record<string, string>>;
     contextWindow: number;
     info?: ModelInfo;
     attributions?: (context: PluginAttributionContext) => PluginAttribution;
+    cacheAffinity?: CacheAffinity;
+    systemCacheProviderOptions?: AiSdkProviderOptions;
+    reasoningResponseProviderOptions?: AiSdkProviderOptions;
+    additiveReasoningProvider?: "anthropic" | "bedrock";
 }): 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; capacity is deferred to the provider`,
         "PLURNK_PROMPT_COUNT_ESTIMATE",
     );
 
-    const reasoning = reasoningFromEnv(env, name);
-    const { reasoningReserve: configuredReasoning, completionReserve: configuredCompletion } = envelopeFromEnv(env, name);
-    const completionReserve: ReserveSpec = "tokens" in configuredCompletion
-        ? configuredCompletion
-        : info?.maxOutput === undefined
-            ? configuredCompletion
-            : { tokens: Math.min(info.maxOutput, Math.round(configuredCompletion.percent * contextWindow)) };
-    const completionTokens = resolveReserve(completionReserve, contextWindow);
-    const reasoningReserve: ReserveSpec = "tokens" in configuredReasoning
-        ? configuredReasoning
-        : reasoning.budget !== null
-            ? { tokens: reasoning.budget }
-            : completionTokens === null
-                ? configuredReasoning
-                : { tokens: Math.round(completionTokens / 2) };
+    const maxInputTokens = info?.maxInputTokens ?? null;
+    const maxOutputTokens = info?.maxOutputTokens === undefined
+        ? null
+        : Math.min(info.maxOutputTokens, contextWindow);
+    const envelope = generationEnvelopeFromEnv(
+        env,
+        name,
+        contextWindow,
+        maxOutputTokens,
+    );
+    const reasoning = reasoningFromEnv(env, name, envelope.reasoningBudget);
 
     const catalogCost = info?.cost;
     const rates = catalogCost === undefined ? null : {
         input: catalogCost.inputPer1M,
         output: catalogCost.outputPer1M,
-        cached: catalogCost.cacheReadPer1M ?? catalogCost.inputPer1M,
+        ...(catalogCost.reasoningPer1M === undefined
+            ? {}
+            : { reasoning: catalogCost.reasoningPer1M }),
+        ...(catalogCost.cacheReadPer1M === undefined
+            ? {}
+            : { cacheRead: catalogCost.cacheReadPer1M }),
+        ...(catalogCost.cacheWritePer1M === undefined
+            ? {}
+            : { cacheWrite: catalogCost.cacheWritePer1M }),
     };
-    const calculateCost = rates === null
-        ? undefined
-        : (usage: ProviderUsage): number => calculateCostUsd(usage, rates);
-    const calculateCharge: (usage: ProviderUsage) => Exclude<ProviderCost, { kind: "authoritative" }> = rates === null
-        ? () => ({ 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: "Models.dev catalog rates" })
-            : (usage: ProviderUsage) => ({
-                kind: "estimated",
-                usd: calculateCostUsdDecimal(usage, rates),
-                source: "Models.dev catalog rates",
-            });
+    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 }),
-        ...(normalizeCharge === undefined ? {} : { normalizeCharge }),
+        ...(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),
+        maxInputTokens,
+        maxOutputTokens,
+        outputBudget: envelope.outputBudget,
+        reasoningBudget: reasoning.budget,
+        ...(additiveReasoningProvider === undefined ? {} : { additiveReasoningProvider }),
+        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),
         repeatPenalty: parseRequiredFloat(env.PLURNK_PROVIDERS_REPEAT_PENALTY, "PLURNK_PROVIDERS_REPEAT_PENALTY", name, 0),
         frequencyPenalty: parseRequiredFloat(env.PLURNK_PROVIDERS_FREQUENCY_PENALTY, "PLURNK_PROVIDERS_FREQUENCY_PENALTY", name, 0),
-        reasoningReserve,
-        completionReserve,
         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,9 +179,13 @@ export const catalogProviderFromEnv = (
         env,
         model: wireModel,
         languageModel: sdk.languageModel,
-        normalizeCharge: sdk.normalizeCharge,
+        normalizeCost: sdk.normalizeCost,
         url: sdk.compatible?.url,
         headers: sdk.compatible?.headers,
+        cacheAffinity: sdk.cacheAffinity,
+        systemCacheProviderOptions: sdk.systemCacheProviderOptions,
+        reasoningResponseProviderOptions: sdk.reasoningResponseProviderOptions,
+        additiveReasoningProvider: sdk.additiveReasoningProvider,
         contextWindow,
         info,
     });

package/src/compatibleProvider.test.ts

@@ -5,23 +5,25 @@ 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",
     PLURNK_PROVIDERS_REPEAT_PENALTY: "1.15",
     PLURNK_PROVIDERS_FREQUENCY_PENALTY: "0",
-    PLURNK_PROVIDERS_REASONING_RESERVE: "10%",
-    PLURNK_PROVIDERS_COMPLETION_RESERVE: "25%",
+    PLURNK_PROVIDERS_OUTPUT_BUDGET: "35%",
     PLURNK_PROVIDERS_RETRY_ATTEMPTS: "0",
     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 +43,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

@@ -3,16 +3,19 @@ import {
     contextWindowFromEnv,
     effectiveContextWindow,
     dataCaptureFromEnv,
-    envelopeFromEnv,
+    generationEnvelopeFromEnv,
     parseOptionalFloat,
     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,19 +176,26 @@ 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; capacity is deferred to the provider`,
             "PLURNK_PROMPT_COUNT_ESTIMATE",
         );
     }
-    const { reasoningReserve, completionReserve } = envelopeFromEnv(env, provider);
+    const envelope = generationEnvelopeFromEnv(env, provider, contextWindow, null);
+    const reasoning = reasoningFromEnv(env, provider, envelope.reasoningBudget);
     return new AiSdkProvider({
         model,
         url,
         headers,
         contextWindow,
+        maxInputTokens: null,
+        maxOutputTokens: null,
+        outputBudget: envelope.outputBudget,
+        reasoningBudget: reasoning.budget,
         fetchTimeoutMs: timeout,
-        streamIdleTimeoutMs: parseRequiredInt(env.PLURNK_PROVIDERS_STREAM_IDLE_TIMEOUT, "PLURNK_PROVIDERS_STREAM_IDLE_TIMEOUT", provider),
-        reasoning: reasoningFromEnv(env, 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,
         reasoningResponseStyle: reasoningResponseStyleFromEnv(env, provider),
         reasoningStyle,
         temperature: parseRequiredFloat(env.PLURNK_PROVIDERS_TEMPERATURE, "PLURNK_PROVIDERS_TEMPERATURE", provider, 0),
@@ -187,12 +205,9 @@ export const compatibleProviderFromEnv = async (
         dryBase: parseOptionalFloat(env.PLURNK_PROVIDERS_DRY_BASE, "PLURNK_PROVIDERS_DRY_BASE", provider, 0) ?? undefined,
         dryAllowedLength: parseOptionalInt(env.PLURNK_PROVIDERS_DRY_ALLOWED_LENGTH, "PLURNK_PROVIDERS_DRY_ALLOWED_LENGTH", provider) ?? undefined,
         repeatLastN: parseOptionalInt(env.PLURNK_PROVIDERS_REPEAT_LAST_N, "PLURNK_PROVIDERS_REPEAT_LAST_N", provider) ?? undefined,
-        reasoningReserve,
-        completionReserve,
         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 +215,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,
@@ -209,6 +225,6 @@ export const compatibleProviderFromEnv = async (
         tokenizeUrl,
         promptTokensUrl,
         servedModel: probe.servedModel ?? undefined,
-        requiresMaxTokens: llamaServer || undefined,
+        requiresOutputBudget: llamaServer || undefined,
     });
 };

package/src/cost.test.ts

@@ -1,62 +1,112 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import {
-    providerCostFor,
+    addDecimals,
+    estimateProviderCost,
     providerCostUsd,
-    validateAuthoritativeCharge,
+    resolveProviderCost,
+    sumProviderCostsUsd,
+    validateChargedCost,
 } from "./cost.ts";
 import type { ProviderUsage } from "./types.ts";
 
 const usage: ProviderUsage = {
-    prompt: 1,
-    completion: 1,
-    reasoning: 0,
-    cached: 0,
-    total: 2,
+    inputTokens: 1,
+    outputTokens: 1,
+    totalTokens: 2,
 };
 
-test("authoritative provider charge wins over a local estimate", () => {
-    const provider = {
-        calculateCost: () => 12,
-        calculateCharge: () => ({ kind: "estimated", usd: "12", source: "catalog" } as const),
-    };
-    const charge = {
-        kind: "authoritative",
+test("direct charged evidence wins over a Models.dev estimate", () => {
+    const charged = {
+        kind: "charged",
         amount: { amount: "0.0000042", currency: "XMR" },
         usdEquivalent: "0.73",
-        source: "settled upstream turn charge",
+        source: "settled upstream request charge",
     } as const;
-    assert.deepEqual(providerCostFor(provider, usage, charge), charge);
-    assert.equal(providerCostUsd(charge), 0.73);
+    const estimated = estimateProviderCost(usage, { input: 1, output: 1 }, "Models.dev");
+    assert.deepEqual(resolveProviderCost(charged, estimated), charged);
+    assert.equal(providerCostUsd(charged), "0.73");
 });
 
-test("explicit free remains distinguishable from unknown", () => {
-    const free = providerCostFor({
-        calculateCost: () => 0,
-        calculateCharge: () => ({ kind: "free", source: "local model" }),
-    }, usage);
-    const unknown = providerCostFor({ calculateCost: () => 0 }, usage);
-    assert.deepEqual(free, { kind: "free", source: "local model" });
+test("an exact zero estimate remains distinguishable from unknown cost", () => {
+    const zero = estimateProviderCost(usage, { input: 0, output: 0 }, "Models.dev");
+    const unknown = estimateProviderCost(usage, null, "Models.dev");
+    assert.deepEqual(zero, {
+        kind: "estimated",
+        amount: { amount: "0", currency: "USD" },
+        source: "Models.dev",
+    });
     assert.deepEqual(unknown, {
         kind: "unknown",
-        reason: "the response reported no cost and Models.dev has no rate for this model",
+        reason: "Models.dev has no complete rate for this model",
     });
-    assert.equal(providerCostUsd(free), 0);
+    assert.equal(providerCostUsd(zero), "0");
     assert.equal(providerCostUsd(unknown), null);
 });
 
-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("a distinct cache rate requires the applicable token category", () => {
+    assert.deepEqual(
+        estimateProviderCost(usage, { input: 1, output: 1, cacheRead: 0.1 }, "Models.dev"),
+        {
+            kind: "unknown",
+            reason: "the provider response omitted a token category with a distinct Models.dev rate",
+        },
+    );
+});
+
+test("a distinct reasoning rate prices reasoning as a subset of output", () => {
+    const withReasoning: ProviderUsage = {
+        inputTokens: 100,
+        outputTokens: 50,
+        totalTokens: 150,
+        outputTokenDetails: { reasoningTokens: 20 },
+    };
+    assert.deepEqual(
+        estimateProviderCost(withReasoning, {
+            input: 1,
+            output: 2,
+            reasoning: 5,
+        }, "Models.dev"),
+        {
+            kind: "estimated",
+            amount: { amount: "0.00026", currency: "USD" },
+            source: "Models.dev",
+        },
+    );
+});
+
+test("a distinct reasoning rate requires reported reasoning usage", () => {
+    assert.deepEqual(
+        estimateProviderCost(usage, { input: 1, output: 2, reasoning: 5 }, "Models.dev"),
+        {
+            kind: "unknown",
+            reason: "the provider response omitted a token category with a distinct Models.dev rate",
+        },
+    );
+});
+
+test("decimal aggregation is exact and becomes unknown if any request is unknown", () => {
+    assert.equal(addDecimals(["0.1", "0.02", "3"]), "3.12");
+    assert.equal(sumProviderCostsUsd([
+        {
+            kind: "charged",
+            amount: { amount: "0.1", currency: "USD" },
+            source: "provider",
+        },
+        {
+            kind: "estimated",
+            amount: { amount: "0.02", currency: "USD" },
+            source: "Models.dev",
+        },
+    ]), "0.12");
+    assert.equal(sumProviderCostsUsd([
+        { kind: "unknown", reason: "no evidence" },
+    ]), null);
 });
 
-test("rejects malformed money instead of mining or coercing it", () => {
-    assert.throws(() => validateAuthoritativeCharge({
-        kind: "authoritative",
+test("malformed charged money is rejected instead of coerced", () => {
+    assert.throws(() => validateChargedCost({
+        kind: "charged",
         amount: { amount: "1e3", currency: "usd" },
         usdEquivalent: "1000",
         source: "wire",