@oh-my-pi/pi-ai 14.5.7 → 14.5.9

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## [14.5.9] - 2026-04-30
+### Added
+
+- Added `usage.reasoningTokens` to OpenAI and Google usage output when providers report reasoning/thinking tokens
+- Added `usage.cttl.ephemeral5m` and `usage.cttl.ephemeral1h` to report Anthropic cache-write TTL token buckets
+- Added `usage.server.webSearch` and `usage.server.webFetch` to report Anthropic server tool-call request counts
+
+### Fixed
+
+- Fixed OpenAI usage attribution to avoid double-counting `reasoning_tokens` in output totals
+- Fixed Anthropic streaming usage handling so a previously populated cache TTL breakdown is preserved when later events omit `cache_creation`
+
 ## [14.5.4] - 2026-04-28
 ### Changed
 

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "14.5.7",
+	"version": "14.5.9",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -46,8 +46,8 @@
 		"@aws-sdk/credential-provider-node": "^3.972.36",
 		"@bufbuild/protobuf": "^2.12.0",
 		"@google/genai": "^1.50.1",
-		"@oh-my-pi/pi-natives": "14.5.7",
-		"@oh-my-pi/pi-utils": "14.5.7",
+		"@oh-my-pi/pi-natives": "14.5.9",
+		"@oh-my-pi/pi-utils": "14.5.9",
 		"@sinclair/typebox": "^0.34.49",
 		"@smithy/node-http-handler": "^4.6.1",
 		"ajv": "^8.20.0",

package/src/providers/anthropic.ts

@@ -698,6 +698,42 @@ function createEmptyUsage(premiumRequests?: number): Usage {
 	};
 }
 
+export type AnthropicUsageLike = {
+	cache_creation?: { ephemeral_5m_input_tokens?: number | null; ephemeral_1h_input_tokens?: number | null } | null;
+	server_tool_use?: { web_search_requests?: number | null; web_fetch_requests?: number | null } | null;
+};
+
+/**
+ * Capture Anthropic's optional cache-creation TTL breakdown and server-tool-use
+ * counters into the harness Usage shape. Only sets fields that were reported, so
+ * a `message_delta` that omits `cache_creation` does not clobber the breakdown
+ * established at `message_start`.
+ */
+export function applyAnthropicUsageExtras(usage: Usage, source: AnthropicUsageLike): void {
+	const cacheCreation = source.cache_creation;
+	if (cacheCreation) {
+		const fiveMinute = cacheCreation.ephemeral_5m_input_tokens ?? 0;
+		const oneHour = cacheCreation.ephemeral_1h_input_tokens ?? 0;
+		if (fiveMinute > 0 || oneHour > 0) {
+			usage.cttl = {
+				...(fiveMinute > 0 ? { ephemeral5m: fiveMinute } : {}),
+				...(oneHour > 0 ? { ephemeral1h: oneHour } : {}),
+			};
+		}
+	}
+	const serverToolUse = source.server_tool_use;
+	if (serverToolUse) {
+		const webSearch = serverToolUse.web_search_requests ?? 0;
+		const webFetch = serverToolUse.web_fetch_requests ?? 0;
+		if (webSearch > 0 || webFetch > 0) {
+			usage.server = {
+				...(webSearch > 0 ? { webSearch } : {}),
+				...(webFetch > 0 ? { webFetch } : {}),
+			};
+		}
+	}
+}
+
 export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 	model: Model<"anthropic-messages">,
 	context: Context,
@@ -824,6 +860,7 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 								continue;
 							}
 							sawMessageStart = true;
+							applyAnthropicUsageExtras(output.usage, event.message.usage);
 							output.responseId = event.message.id;
 							output.usage.input = event.message.usage.input_tokens || 0;
 							output.usage.output = event.message.usage.output_tokens || 0;
@@ -989,6 +1026,7 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 							if (event.usage.cache_creation_input_tokens != null) {
 								output.usage.cacheWrite = event.usage.cache_creation_input_tokens;
 							}
+							applyAnthropicUsageExtras(output.usage, event.usage);
 							output.usage.totalTokens =
 								output.usage.input + output.usage.output + output.usage.cacheRead + output.usage.cacheWrite;
 							calculateCost(model, output.usage);

package/src/providers/google-gemini-cli.ts

@@ -804,14 +804,14 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 						// promptTokenCount includes cachedContentTokenCount, so subtract to get fresh input
 						const promptTokens = responseData.usageMetadata.promptTokenCount || 0;
 						const cacheReadTokens = responseData.usageMetadata.cachedContentTokenCount || 0;
+						const thinkingTokens = responseData.usageMetadata.thoughtsTokenCount || 0;
 						output.usage = {
 							input: promptTokens - cacheReadTokens,
-							output:
-								(responseData.usageMetadata.candidatesTokenCount || 0) +
-								(responseData.usageMetadata.thoughtsTokenCount || 0),
+							output: (responseData.usageMetadata.candidatesTokenCount || 0) + thinkingTokens,
 							cacheRead: cacheReadTokens,
 							cacheWrite: 0,
 							totalTokens: responseData.usageMetadata.totalTokenCount || 0,
+							...(thinkingTokens > 0 ? { reasoningTokens: thinkingTokens } : {}),
 							cost: {
 								input: 0,
 								output: 0,

package/src/providers/google-vertex.ts

@@ -243,13 +243,14 @@ export const streamGoogleVertex: StreamFunction<"google-vertex"> = (
 					// input + cacheRead = total prompt tokens (no double-counting).
 					// Ref: https://ai.google.dev/api/generate-content#v1beta.GenerateContentResponse.UsageMetadata
 					const cachedTokens = chunk.usageMetadata.cachedContentTokenCount || 0;
+					const thinkingTokens = chunk.usageMetadata.thoughtsTokenCount || 0;
 					output.usage = {
 						input: (chunk.usageMetadata.promptTokenCount || 0) - cachedTokens,
-						output:
-							(chunk.usageMetadata.candidatesTokenCount || 0) + (chunk.usageMetadata.thoughtsTokenCount || 0),
+						output: (chunk.usageMetadata.candidatesTokenCount || 0) + thinkingTokens,
 						cacheRead: cachedTokens,
 						cacheWrite: 0,
 						totalTokens: chunk.usageMetadata.totalTokenCount || 0,
+						...(thinkingTokens > 0 ? { reasoningTokens: thinkingTokens } : {}),
 						cost: {
 							input: 0,
 							output: 0,

package/src/providers/google.ts

@@ -223,13 +223,14 @@ export const streamGoogle: StreamFunction<"google-generative-ai"> = (
 					// input + cacheRead = total prompt tokens (no double-counting).
 					// Ref: https://ai.google.dev/api/generate-content#v1beta.GenerateContentResponse.UsageMetadata
 					const cachedTokens = chunk.usageMetadata.cachedContentTokenCount || 0;
+					const thinkingTokens = chunk.usageMetadata.thoughtsTokenCount || 0;
 					output.usage = {
 						input: (chunk.usageMetadata.promptTokenCount || 0) - cachedTokens,
-						output:
-							(chunk.usageMetadata.candidatesTokenCount || 0) + (chunk.usageMetadata.thoughtsTokenCount || 0),
+						output: (chunk.usageMetadata.candidatesTokenCount || 0) + thinkingTokens,
 						cacheRead: cachedTokens,
 						cacheWrite: 0,
 						totalTokens: chunk.usageMetadata.totalTokenCount || 0,
+						...(thinkingTokens > 0 ? { reasoningTokens: thinkingTokens } : {}),
 						cost: {
 							input: 0,
 							output: 0,

package/src/providers/openai-codex-responses.ts

@@ -1119,6 +1119,7 @@ function handleResponseCompleted(
 					output_tokens?: number;
 					total_tokens?: number;
 					input_tokens_details?: { cached_tokens?: number };
+					output_tokens_details?: { reasoning_tokens?: number };
 				};
 				status?: string;
 			};
@@ -1127,12 +1128,14 @@ function handleResponseCompleted(
 
 	if (response?.usage) {
 		const cachedTokens = response.usage.input_tokens_details?.cached_tokens || 0;
+		const reasoningTokens = response.usage.output_tokens_details?.reasoning_tokens || 0;
 		output.usage = {
 			input: (response.usage.input_tokens || 0) - cachedTokens,
 			output: response.usage.output_tokens || 0,
 			cacheRead: cachedTokens,
 			cacheWrite: 0,
 			totalTokens: response.usage.total_tokens || 0,
+			...(reasoningTokens > 0 ? { reasoningTokens } : {}),
 			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
 		};
 	}

package/src/providers/openai-completions.ts

@@ -959,7 +959,7 @@ function getChoiceUsage(choice: ChatCompletionChunk.Choice): object | undefined
 	return getOptionalObjectProperty(choice, "usage");
 }
 
-function parseChunkUsage(
+export function parseChunkUsage(
 	rawUsage: object,
 	model: Model<"openai-completions">,
 	copilotPremiumRequests: number | undefined,
@@ -970,16 +970,28 @@ function parseChunkUsage(
 		getOptionalNumberProperty(rawUsage, "cached_tokens") ??
 		(promptTokenDetails ? getOptionalNumberProperty(promptTokenDetails, "cached_tokens") : undefined) ??
 		0;
+	// OpenRouter exposes cache writes via `prompt_tokens_details.cache_write_tokens`
+	// and INCLUDES them in `prompt_tokens`. Without subtracting, cache-write tokens
+	// leak into `input` (e.g. GLM/Anthropic via OpenRouter on a fresh cache).
+	// Ref: https://openrouter.ai/docs/guides/best-practices/prompt-caching
+	const cacheWriteTokens = promptTokenDetails
+		? (getOptionalNumberProperty(promptTokenDetails, "cache_write_tokens") ?? 0)
+		: 0;
 	const reasoningTokens =
 		(completionTokenDetails ? getOptionalNumberProperty(completionTokenDetails, "reasoning_tokens") : undefined) ?? 0;
-	const input = (getOptionalNumberProperty(rawUsage, "prompt_tokens") ?? 0) - cachedTokens;
-	const outputTokens = (getOptionalNumberProperty(rawUsage, "completion_tokens") ?? 0) + reasoningTokens;
+	const promptTokens = getOptionalNumberProperty(rawUsage, "prompt_tokens") ?? 0;
+	const input = Math.max(0, promptTokens - cachedTokens - cacheWriteTokens);
+	// Per OpenAI's CompletionUsage spec, `reasoning_tokens` is a subset of
+	// `completion_tokens` (which is the total billed output). Adding them would
+	// double-count.
+	const outputTokens = getOptionalNumberProperty(rawUsage, "completion_tokens") ?? 0;
 	const usage: AssistantMessage["usage"] = {
 		input,
 		output: outputTokens,
 		cacheRead: cachedTokens,
-		cacheWrite: 0,
-		totalTokens: input + outputTokens + cachedTokens,
+		cacheWrite: cacheWriteTokens,
+		totalTokens: input + outputTokens + cachedTokens + cacheWriteTokens,
+		...(reasoningTokens > 0 ? { reasoningTokens } : {}),
 		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
 		...(copilotPremiumRequests !== undefined ? { premiumRequests: copilotPremiumRequests } : {}),
 	};

package/src/providers/openai-responses-shared.ts

@@ -527,12 +527,14 @@ export async function processResponsesStream<TApi extends Api>(
 			}
 			if (response?.usage) {
 				const cachedTokens = response.usage.input_tokens_details?.cached_tokens || 0;
+				const reasoningTokens = response.usage.output_tokens_details?.reasoning_tokens || 0;
 				output.usage = {
 					input: (response.usage.input_tokens || 0) - cachedTokens,
 					output: response.usage.output_tokens || 0,
 					cacheRead: cachedTokens,
 					cacheWrite: 0,
 					totalTokens: response.usage.total_tokens || 0,
+					...(reasoningTokens > 0 ? { reasoningTokens } : {}),
 					cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
 				};
 			}

package/src/stream.ts

@@ -196,8 +196,13 @@ export function stream<TApi extends Api>(
 
 	const api: Api = model.api;
 	switch (api) {
-		case "anthropic-messages":
-			return streamAnthropic(model as Model<"anthropic-messages">, context, providerOptions);
+		case "anthropic-messages": {
+			const anthropicOptions = providerOptions as AnthropicOptions;
+			return streamAnthropic(model as Model<"anthropic-messages">, context, {
+				...anthropicOptions,
+				isOAuth: anthropicOptions.isOAuth ?? model.isOAuth,
+			});
+		}
 
 		case "openai-completions":
 			return streamOpenAICompletions(model as Model<"openai-completions">, context, providerOptions as any);

package/src/types.ts

@@ -306,12 +306,43 @@ export interface ToolCall {
 }
 
 export interface Usage {
+	/** Non-cached input tokens (matches the bucket the provider bills as new input). */
 	input: number;
+	/** Total output tokens for the turn, including thinking, assistant text, and tool-call argument tokens. */
 	output: number;
+	/** Tokens read from the prompt cache. */
 	cacheRead: number;
+	/** Tokens written to the prompt cache (cache creation). */
 	cacheWrite: number;
+	/** Sum of input + output + cacheRead + cacheWrite. */
 	totalTokens: number;
+	/** Copilot premium-request counter, when applicable. */
 	premiumRequests?: number;
+	/**
+	 * Reasoning/thinking tokens included in `output`, when the provider reports them
+	 * (OpenAI `output_tokens_details.reasoning_tokens`, Google `thoughtsTokenCount`).
+	 * Always a subset of `output` — non-reasoning output is `output - reasoningTokens`.
+	 *
+	 * Providers that don't expose this leave it undefined rather than guessing;
+	 * `undefined` means unknown, NOT zero.
+	 */
+	reasoningTokens?: number;
+	/**
+	 * Cache-write TTL breakdown (Anthropic only). When set, the components sum to
+	 * `cacheWrite`. Absent providers do not populate this.
+	 */
+	cttl?: {
+		ephemeral5m?: number;
+		ephemeral1h?: number;
+	};
+	/**
+	 * Server-side tool invocations made during this turn (Anthropic web_search /
+	 * web_fetch, OpenAI built-in tools when reported). Counts requests, not tokens.
+	 */
+	server?: {
+		webSearch?: number;
+		webFetch?: number;
+	};
 	cost: {
 		input: number;
 		output: number;
@@ -587,4 +618,11 @@ export interface Model<TApi extends Api = any> {
 	 * - `"function"` or undefined: JSON function-tool with `{input: string}` (spec §1.2).
 	 */
 	applyPatchToolType?: "freeform" | "function";
+	/**
+	 * Force OAuth-style request shaping for providers whose API key prefix doesn't
+	 * match an OAuth token (e.g. routing Anthropic traffic through a proxy that
+	 * expects Claude Code framing). When true, the streaming layer sets
+	 * `options.isOAuth = true` for the underlying provider call.
+	 */
+	isOAuth?: boolean;
 }