@rulvar/openai 1.18.0 → 1.20.0

package/dist/index.d.ts

@@ -148,7 +148,23 @@ declare function buildResponsesParams(req: ChatRequest, ids: OpenAiIdMap, option
 type ResponsesStreamEvent = Record<string, unknown> & {
   type: string;
 };
-/** Normalizes Responses usage: input_tokens already includes cached reads. */
+/**
+* Normalizes Responses usage into the canonical Usage invariant, where
+* `inputTokens` is the FULL prompt. On the OpenAI wire `input_tokens`
+* is ALREADY that full count: `input_tokens_details.cached_tokens` and
+* `input_tokens_details.cache_write_tokens` (GPT-5.6 and later
+* families) are priced SUBSETS of it, never additional tokens, so both
+* pass through untouched and nothing is added. Verified on the live
+* wire 2026-07-18: two identical long prompts report the SAME
+* `input_tokens` while the details flip from write to read, and
+* `total_tokens` equals `input_tokens + output_tokens` on both calls.
+* Adding writes on top (the v1.19.0 reading of the field) double-billed
+* every written token at 1x + 1.25x and inflated budget debits
+* (v1.19.0 review P1-1). Contrast with the Anthropic adapter, whose
+* wire genuinely EXCLUDES both cache counts from `input_tokens`, so
+* that adapter adds them; the two wires differ, the canonical Usage
+* invariant does not.
+*/
 declare function normalizeOpenAiUsage(raw: Record<string, unknown> | undefined): Usage;
 /**
 * Maps the typed Responses SSE stream to ChatEvents, yielding each

package/dist/index.js

@@ -62,24 +62,23 @@ const OPENAI_MODELS = {
 	}),
 	"gpt-5.6": GPT_56_SOL,
 	"gpt-5.5": responses(4e5, 128e3, {
-		inputUsdPerMTok: 10,
-		outputUsdPerMTok: 40,
-		cacheReadUsdPerMTok: 1
+		inputUsdPerMTok: 5,
+		outputUsdPerMTok: 30,
+		cacheReadUsdPerMTok: .5
 	}),
 	"gpt-5.5-pro": responses(4e5, 128e3, {
-		inputUsdPerMTok: 40,
-		outputUsdPerMTok: 160,
-		cacheReadUsdPerMTok: 4
+		inputUsdPerMTok: 30,
+		outputUsdPerMTok: 180
 	}),
 	"gpt-5.4": responses(272e3, 1e5, {
-		inputUsdPerMTok: 6,
-		outputUsdPerMTok: 24,
-		cacheReadUsdPerMTok: .6
+		inputUsdPerMTok: 2.5,
+		outputUsdPerMTok: 15,
+		cacheReadUsdPerMTok: .25
 	}),
 	"gpt-5.4-mini": responses(272e3, 1e5, {
-		inputUsdPerMTok: 1.2,
-		outputUsdPerMTok: 4.8,
-		cacheReadUsdPerMTok: .12
+		inputUsdPerMTok: .75,
+		outputUsdPerMTok: 4.5,
+		cacheReadUsdPerMTok: .075
 	})
 };
 /**
@@ -102,7 +101,7 @@ const OPENAI_MODELS = {
 * silent reinterpretation.
 */
 const OPENAI_PRICING = {
-	pricingVersion: "openai-2026-07-18",
+	pricingVersion: "openai-2026-07-18-r2",
 	models: (() => {
 		const models = {};
 		for (const [name, info] of Object.entries(OPENAI_MODELS)) if (info.caps.pricing !== void 0) models[`openai:${name}`] = info.caps.pricing;
@@ -298,15 +297,50 @@ function buildResponsesParams(req, ids, options) {
 		effortDownmapped
 	};
 }
-/** Normalizes Responses usage: input_tokens already includes cached reads. */
+/**
+* Clamps the cache detail counts into the subset domain the pricing
+* fold relies on (`reads + writes <= input`, everything nonnegative).
+* The provider contract already guarantees it; impossible telemetry is
+* clamped rather than rejected because a rejection would discard PAID
+* evidence, and clamping is the conservative direction for the budget:
+* dropped detail tokens price at the FULL input rate instead of the
+* cache-read discount. Reads keep priority over writes, so a violation
+* shrinks the write premium, never the base charge.
+*/
+function clampCacheSubsets(inputTokens, rawRead, rawWrite) {
+	const cacheReadTokens = Math.min(Math.max(0, rawRead), Math.max(0, inputTokens));
+	return {
+		cacheReadTokens,
+		cacheWriteTokens: Math.min(Math.max(0, rawWrite), Math.max(0, inputTokens) - cacheReadTokens)
+	};
+}
+/**
+* Normalizes Responses usage into the canonical Usage invariant, where
+* `inputTokens` is the FULL prompt. On the OpenAI wire `input_tokens`
+* is ALREADY that full count: `input_tokens_details.cached_tokens` and
+* `input_tokens_details.cache_write_tokens` (GPT-5.6 and later
+* families) are priced SUBSETS of it, never additional tokens, so both
+* pass through untouched and nothing is added. Verified on the live
+* wire 2026-07-18: two identical long prompts report the SAME
+* `input_tokens` while the details flip from write to read, and
+* `total_tokens` equals `input_tokens + output_tokens` on both calls.
+* Adding writes on top (the v1.19.0 reading of the field) double-billed
+* every written token at 1x + 1.25x and inflated budget debits
+* (v1.19.0 review P1-1). Contrast with the Anthropic adapter, whose
+* wire genuinely EXCLUDES both cache counts from `input_tokens`, so
+* that adapter adds them; the two wires differ, the canonical Usage
+* invariant does not.
+*/
 function normalizeOpenAiUsage(raw) {
 	const inputDetails = raw?.input_tokens_details;
 	const outputDetails = raw?.output_tokens_details;
+	const inputTokens = typeof raw?.input_tokens === "number" ? raw.input_tokens : 0;
+	const clamped = clampCacheSubsets(inputTokens, typeof inputDetails?.cached_tokens === "number" ? inputDetails.cached_tokens : 0, typeof inputDetails?.cache_write_tokens === "number" ? inputDetails.cache_write_tokens : 0);
 	const usage = {
-		inputTokens: typeof raw?.input_tokens === "number" ? raw.input_tokens : 0,
+		inputTokens,
 		outputTokens: typeof raw?.output_tokens === "number" ? raw.output_tokens : 0,
-		cacheReadTokens: typeof inputDetails?.cached_tokens === "number" ? inputDetails.cached_tokens : 0,
-		cacheWriteTokens: 0
+		cacheReadTokens: clamped.cacheReadTokens,
+		cacheWriteTokens: clamped.cacheWriteTokens
 	};
 	const reasoning = outputDetails?.reasoning_tokens;
 	if (typeof reasoning === "number" && reasoning > 0) usage.reasoningTokens = reasoning;
@@ -415,31 +449,59 @@ async function* mapResponsesStream(stream, ids, options) {
 			};
 			return;
 		}
-		case "response.failed":
+		case "response.failed": {
+			const response = event.response;
+			const rawUsage = response?.usage;
+			if (rawUsage !== void 0) yield {
+				type: "usage",
+				usage: normalizeOpenAiUsage(rawUsage)
+			};
+			const error = response?.error;
 			yield {
 				type: "error",
-				error: {
-					code: "agent",
-					message: (event.response?.error)?.message ?? "response.failed",
-					retryable: false,
-					data: { kind: "transport" }
-				}
+				error: failedResponseError(typeof error?.code === "string" ? error.code : void 0, error?.message ?? "response.failed")
 			};
 			return;
+		}
 		case "error":
 			yield {
 				type: "error",
-				error: {
-					code: "agent",
-					message: event.message ?? "stream error",
-					retryable: false,
-					data: { kind: "transport" }
-				}
+				error: failedResponseError(typeof event.code === "string" ? event.code : void 0, event.message ?? "stream error")
 			};
 			return;
 		default: break;
 	}
 }
+/**
+* Classifies a terminal stream failure (`response.failed` /
+* SSE `error`) into the retryable WireError vocabulary by the
+* documented `response.error.code` enum (Responses API reference):
+* `rate_limit_exceeded` retries as a rate limit, `server_error` and
+* timeout-class codes retry as transport faults, and everything else
+* (validation such as `invalid_prompt`, policy, auth) stays
+* non-retryable. Unknown codes fail closed as non-retryable: retrying a
+* permanent failure would loop-bill it (v1.18.0 review P1-3).
+*/
+function failedResponseError(code, message) {
+	if (code === "rate_limit_exceeded") return {
+		code: "agent",
+		message,
+		retryable: true,
+		data: {
+			kind: "rate-limit",
+			providerCode: code
+		}
+	};
+	return {
+		code: "agent",
+		message,
+		retryable: code === "server_error" || code !== void 0 && code.endsWith("_timeout"),
+		data: {
+			kind: "transport",
+			...code === void 0 ? {} : { providerCode: code }
+		}
+	};
+}
 /** Projects SDK/API errors into the retryable WireError vocabulary. */
 function openAiErrorToWire(error) {
 	const record = error;
@@ -606,11 +668,13 @@ async function* mapChatCompletionsStream(stream, ids) {
 		const chunkUsage = chunk.usage;
 		if (chunkUsage !== void 0 && chunkUsage !== null) {
 			const promptDetails = chunkUsage.prompt_tokens_details;
+			const promptTokens = typeof chunkUsage.prompt_tokens === "number" ? chunkUsage.prompt_tokens : 0;
+			const clamped = clampCacheSubsets(promptTokens, typeof promptDetails?.cached_tokens === "number" ? promptDetails.cached_tokens : 0, typeof promptDetails?.cache_write_tokens === "number" ? promptDetails.cache_write_tokens : 0);
 			usage = {
-				inputTokens: typeof chunkUsage.prompt_tokens === "number" ? chunkUsage.prompt_tokens : 0,
+				inputTokens: promptTokens,
 				outputTokens: typeof chunkUsage.completion_tokens === "number" ? chunkUsage.completion_tokens : 0,
-				cacheReadTokens: typeof promptDetails?.cached_tokens === "number" ? promptDetails.cached_tokens : 0,
-				cacheWriteTokens: 0
+				cacheReadTokens: clamped.cacheReadTokens,
+				cacheWriteTokens: clamped.cacheWriteTokens
 			};
 		}
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rulvar/openai",
-  "version": "1.18.0",
+  "version": "1.20.0",
   "description": "Rulvar first-class provider adapter for the OpenAI Responses API, plus the openaiCompatible factory.",
   "type": "module",
   "license": "Apache-2.0",
@@ -23,13 +23,13 @@
   },
   "dependencies": {
     "openai": "^6.45.0",
-    "@rulvar/core": "1.18.0"
+    "@rulvar/core": "1.20.0"
   },
   "devDependencies": {
     "@types/node": "^22.20.0",
     "tsdown": "^0.22.3",
     "typescript": "~6.0.3",
-    "@rulvar/testing": "1.18.0"
+    "@rulvar/testing": "1.20.0"
   },
   "repository": {
     "type": "git",