@plurnk/plurnk-providers 1.4.0 → 1.5.0

package/src/sdkModels.ts

@@ -6,13 +6,15 @@ import { createGroq } from "@ai-sdk/groq";
 import { createMistral } from "@ai-sdk/mistral";
 import { createOpenAI } from "@ai-sdk/openai";
 import { createTogetherAI } from "@ai-sdk/togetherai";
-import { createXai } from "@ai-sdk/xai";
 import { createOpenRouter } from "@openrouter/ai-sdk-provider";
 import { lookupProvider, type ProviderInfo } from "@plurnk/plurnk-models";
 import type { LanguageModel } from "ai";
+import { authoritativeChargeNormalizer } from "./accounting.ts";
+import type { AuthoritativeChargeNormalizer } from "./types.ts";
 
 export type SdkModel = {
     readonly languageModel?: LanguageModel;
+    readonly normalizeCharge?: AuthoritativeChargeNormalizer;
     readonly compatible?: {
         readonly url: string;
         readonly headers: Readonly<Record<string, string>>;
@@ -105,6 +107,7 @@ export const createSdkModel = (
     const catalog = lookupProvider(provider) ?? configuredProviderInfo(provider, env);
     if (catalog === null) return null;
     const url = baseUrl(provider, env, catalog, baseUrlOverride);
+    const normalizeCharge = authoritativeChargeNormalizer(catalog.npm);
 
     switch (catalog.npm) {
         case "@ai-sdk/openai":
@@ -130,6 +133,7 @@ export const createSdkModel = (
         case "@ai-sdk/deepinfra":
             return {
                 languageModel: createDeepInfra({ apiKey: requireApiKey(provider, env, catalog), baseURL: url }).languageModel(model),
+                ...(normalizeCharge === undefined ? {} : { normalizeCharge }),
                 catalog,
             };
         case "@ai-sdk/google":
@@ -137,11 +141,18 @@ export const createSdkModel = (
                 languageModel: createGoogle({ apiKey: requireApiKey(provider, env, catalog), baseURL: url }).languageModel(model),
                 catalog,
             };
-        case "@ai-sdk/xai":
+        case "@ai-sdk/xai": {
+            const key = requireApiKey(provider, env, catalog);
+            const compatibleBase = url ?? "https://api.x.ai/v1";
             return {
-                languageModel: createXai({ apiKey: requireApiKey(provider, env, catalog), baseURL: url }).languageModel(model),
+                compatible: {
+                    url: `${compatibleBase}/chat/completions`,
+                    headers: { Authorization: `Bearer ${key}` },
+                },
+                ...(normalizeCharge === undefined ? {} : { normalizeCharge }),
                 catalog,
             };
+        }
         case "@ai-sdk/anthropic":
             return {
                 languageModel: createAnthropic({ apiKey: requireApiKey(provider, env, catalog), baseURL: url }).languageModel(model),
@@ -169,6 +180,7 @@ export const createSdkModel = (
                         ...(env.OPENROUTER_X_TITLE === undefined ? {} : { "X-Title": env.OPENROUTER_X_TITLE }),
                     },
                 }).languageModel(model),
+                ...(normalizeCharge === undefined ? {} : { normalizeCharge }),
                 catalog,
             };
         case "@ai-sdk/openai-compatible":

package/src/types.ts

@@ -46,6 +46,25 @@ export interface ProviderUsage {
 
 export type AuthoritativeCharge = Extract<ProviderCost, { kind: "authoritative" }>;
 
+// Evidence exposed by the transport to the provider adapter that owns its
+// vendor protocol. Core and downstream consumers receive only the normalized
+// charge, never a requirement to understand provider metadata fields.
+export interface ProviderChargeEvidence {
+    readonly providerMetadata?: unknown;
+    // Provider-owned raw usage projection retained independently of optional
+    // full-body capture. Accounting fields cannot disappear merely because
+    // forensic raw-body capture is disabled.
+    readonly usage?: unknown;
+    readonly response: {
+        readonly id: string;
+        readonly headers?: Readonly<Record<string, string>>;
+    };
+}
+
+export type AuthoritativeChargeNormalizer = (
+    evidence: ProviderChargeEvidence,
+) => AuthoritativeCharge | undefined;
+
 // A successful exchange's closed finish set. ProviderAttemptFinishReason adds
 // the failed disposition that may occur only on ProviderError attempt evidence.
 export type FinishReason = "stop" | "length" | "tool_calls" | "content_filter" | null;
@@ -232,10 +251,10 @@ export interface Provider {
     // consumers (the tokenizer seam) prefer this over any client-side data.
     tokenize?(text: string): Promise<number[]>;
     // {§model-fact-resolution} — frozen 1.x local USD estimate compatibility.
-    // Consumers adapt its zero to unknown; only calculateCharge can prove free.
+    // This is not a monetary-reporting authority.
     calculateCost(usage: ProviderUsage): number;
-    // Current monetary result. The numeric calculateCost surface remains frozen
-    // for 1.x compatibility; zero on that legacy surface cannot prove `free`.
+    // Models.dev-derived monetary fallback. Direct response charges travel on
+    // ProviderResponse and take precedence at the consuming attempt boundary.
     calculateCharge?(usage: ProviderUsage): Exclude<ProviderCost, AuthoritativeCharge>;
 }
 

package/src/usage.test.ts

@@ -1,6 +1,6 @@
 import test from "node:test";
 import { strict as assert } from "node:assert";
-import { normalizeUsage, calculateCostUsd } from "./usage.ts";
+import { normalizeUsage, calculateCostUsd, calculateCostUsdDecimal } from "./usage.ts";
 
 // — normalizeUsage —
 
@@ -143,3 +143,11 @@ test("calculateCostUsd: zero rates → 0", () => {
     const usage = { prompt: 9, completion: 9, reasoning: 9, cached: 9, total: 27 };
     assert.equal(calculateCostUsd(usage, { input: 0, output: 0, cached: 0 }), 0);
 });
+
+test("calculateCostUsdDecimal preserves Models.dev rates without floating-point artifacts", () => {
+    const usage = { prompt: 1_000, completion: 100, reasoning: 50, cached: 400, total: 1_150 };
+    assert.equal(
+        calculateCostUsdDecimal(usage, { input: 0.14, output: 0.28, cached: 0.0028 }),
+        "0.00012712",
+    );
+});

package/src/usage.ts

@@ -90,15 +90,48 @@ export const normalizeUsage = (raw: RawUsage | null | undefined, reasoningText =
 // Conventional provider pricing: USD per million tokens, matching Models.dev.
 export type TokenRates = { input: number; output: number; cached: number };
 
+const decimalParts = (value: number): { coefficient: bigint; scale: number } => {
+    if (!Number.isFinite(value) || value < 0) {
+        throw new TypeError("token rates must be finite non-negative numbers");
+    }
+    const match = /^(\d+)(?:\.(\d+))?(?:e([+-]?\d+))?$/i.exec(String(value));
+    if (match === null) throw new TypeError(`cannot represent token rate ${value} as a decimal`);
+    const fraction = match[2] ?? "";
+    const exponent = Number(match[3] ?? "0");
+    const scale = fraction.length - exponent;
+    const coefficient = BigInt(`${match[1]}${fraction}`);
+    return scale < 0
+        ? { coefficient: coefficient * 10n ** BigInt(-scale), scale: 0 }
+        : { coefficient, scale };
+};
+
+const decimalString = (coefficient: bigint, scale: number): string => {
+    const digits = String(coefficient).padStart(scale + 1, "0");
+    if (scale === 0) return digits;
+    const integer = digits.slice(0, -scale);
+    const fraction = digits.slice(-scale).replace(/0+$/, "");
+    return fraction.length === 0 ? integer : `${integer}.${fraction}`;
+};
+
+// Models.dev rates are decimal USD-per-million values. Calculate their
+// projection as decimal arithmetic so ProviderCost preserves the table and
+// exact response counts without binary floating-point artifacts.
+export const calculateCostUsdDecimal = (usage: ProviderUsage, rates: TokenRates): string => {
+    const parts = [rates.input, rates.cached, rates.output].map(decimalParts);
+    const rateScale = Math.max(...parts.map(({ scale }) => scale));
+    const [input, cached, output] = parts.map(({ coefficient, scale }) =>
+        coefficient * 10n ** BigInt(rateScale - scale));
+    const nonCachedPrompt = Math.max(0, usage.prompt - usage.cached);
+    const outputTokens = usage.completion + usage.reasoning;
+    const coefficient = BigInt(nonCachedPrompt) * input!
+        + BigInt(usage.cached) * cached!
+        + BigInt(outputTokens) * output!;
+    return decimalString(coefficient, rateScale + 6);
+};
+
 // The one cost formula every provider uses: non-cached prompt at the input
 // rate, cached prompt at the cache rate, and billable output (completion +
 // reasoning) at the output rate.
 export const calculateCostUsd = (usage: ProviderUsage, rates: TokenRates): number => {
-    const nonCachedPrompt = Math.max(0, usage.prompt - usage.cached);
-    const output = usage.completion + usage.reasoning;
-    return (
-        nonCachedPrompt * rates.input
-        + usage.cached * rates.cached
-        + output * rates.output
-    ) / 1_000_000;
+    return Number(calculateCostUsdDecimal(usage, rates));
 };