@oh-my-pi/pi-ai 15.10.6 → 15.10.8

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 ## [Unreleased]
 
+## [15.10.8] - 2026-06-09
+### Added
+
+- Added optional `fetch` transport override (`fetch?: FetchImpl`) to Google, Ollama, and OpenAI-compatible model-manager options so dynamic model discovery and metadata lookups can use a caller-supplied HTTP client instead of only global `fetch`
+- Added optional `fetch` on OAuth controller and API-key validation/login flows so token exchange, refresh, and device/PKCE login requests can be routed through a custom `fetch` implementation
+- Added optional `fetch` support to usage polling context, allowing usage providers to execute usage checks using an injected HTTP client
+- Added `AssistantMessage.upstreamProvider`, capturing the upstream provider an aggregator routed the request to (OpenRouter reports it via a top-level `provider` field on every chunk, e.g. `"Anthropic"`). Surfaced from the OpenAI-completions stream alongside `responseId`.
+
+### Fixed
+
+- Fixed a degenerate OpenAI Codex stream (the model emits whitespace-only `function_call_arguments.delta` frames forever — commonly seen right after a `todo` tool call) terminating the turn with an error instead of recovering. The whitespace-loop circuit-breaker now (a) stops aborting the shared per-request `AbortController` — `requestSignal` is an `AbortSignal.any` over it, so aborting latched it and made every reopen on the reused `requestSetup` impossible — and (b) drops the half-built junk tool call and replays the request from scratch, bounded by `CODEX_WHITESPACE_LOOP_RETRY_LIMIT` (2). Sampling nondeterminism usually clears the loop on a fresh attempt; once the budget is exhausted the error is surfaced as before, but without the junk tool call polluting the message.
+- Capped requested output tokens at 64k (`OPENAI_MAX_OUTPUT_TOKENS`, mirroring Anthropic's `CLAUDE_CODE_MAX_OUTPUT_TOKENS`) on OpenAI-family wires with a known upstream output cap — the `openai-completions` request builder (non-OpenRouter) and the shared responses sampling helper (`openai-responses`, `azure-openai-responses`). A model's catalog `maxTokens` often tracks its context window rather than the upstream's per-request output cap, so requesting the full ceiling 400'd (e.g. `z-ai/glm-4.7` asking for 131072 output exceeded the upstream's 131072-token *total* context). Output is now `min(requested, model.maxTokens, 64000)`.
+- Stopped sending `max_tokens`/`max_completion_tokens` on OpenRouter (`openrouter.ai`) completions requests. OpenRouter filters out any upstream whose advertised output cap is below the requested `max_tokens`, so a value derived from the catalog (which reflects the highest-cap provider) silently excluded lower-cap upstreams — `provider.order: ["cerebras"]` for `z-ai/glm-4.7` fell through to DeepInfra because Cerebras's ~40k output cap is below the request, while `only: ["cerebras"]` (no fallback target) bypassed the filter and worked. Omitting the field lets each upstream self-cap and keeps provider routing (`only`/`order`) honored. Kimi via OpenRouter stays exempt — it derives TPM rate limits from `max_tokens`.
+
+## [15.10.7] - 2026-06-08
+
+### Fixed
+
+- Fixed first-party Anthropic requests returning HTTP 400 "Invalid `signature` in `thinking` block" after interrupting the model during its visible output. `transformMessages` stripped the signature from every `thinking` block of an `aborted`/`error` turn, including blocks that had already finished streaming — Anthropic delivers a block's signature at `content_block_stop` before the next block starts, so a thinking block followed by `text`/`tool_use` is fully signed. The valid signature was then replayed empty (`signature: ""`), which signature-enforcing Anthropic rejects, including when the provider is routed through an LLM gateway baseUrl. Only the single mid-stream block at the abort point is now treated as untrustworthy; completed thinking blocks keep their replayable signatures ([#2144](https://github.com/can1357/oh-my-pi/issues/2144)).
+- Pinned a regression test against issue [#2123](https://github.com/can1357/oh-my-pi/issues/2123): OAuth requests to adaptive-thinking Claude Opus models (4.6+) ship a `context_management.edits[clear_thinking_20251015]` block paired with the `thinking` field, but the eager-todo prelude (and other paths that force `tool_choice` to `tool`/`any` on the first user turn) route through `disableThinkingIfToolChoiceForced`, which would strip `params.thinking` while leaving the orphan `context_management` behind. The Anthropic API then rejected the request with `400 ... clear_thinking_20251015 strategy requires thinking to be enabled or adaptive`. The fix that lands in [15.10.5] now drops both fields together; the new test locks the contract so the strategy can never outlive its enabling `thinking` payload again.
+- Fixed Antigravity usage counters so exhausted Google/Gemini quota renders as `0% free` while separate Anthropic/OpenAI-backed Antigravity model counters remain visible independently, without replaying stale pre-fix cached usage reports.
+
 ## [15.10.6] - 2026-06-08
 
 ### Added
@@ -3080,4 +3102,4 @@ _Dedicated to Peter's shoulder ([@steipete](https://twitter.com/steipete))_
 
 ## [0.9.4] - 2025-11-26
 
-Initial release with multi-provider LLM support.
+Initial release with multi-provider LLM support.

package/dist/types/provider-models/google.d.ts

@@ -2,6 +2,7 @@ import type { ModelManagerOptions } from "../model-manager";
 import type { FetchImpl } from "../types";
 export interface GoogleModelManagerConfig {
     apiKey?: string;
+    fetch?: FetchImpl;
 }
 export interface GoogleVertexModelManagerConfig {
     apiKey?: string;
@@ -13,10 +14,12 @@ export interface GoogleVertexModelManagerConfig {
 export interface GoogleAntigravityModelManagerConfig {
     oauthToken?: string;
     endpoint?: string;
+    fetch?: FetchImpl;
 }
 export interface GoogleGeminiCliModelManagerConfig {
     oauthToken?: string;
     endpoint?: string;
+    fetch?: FetchImpl;
 }
 export declare function googleModelManagerOptions(config?: GoogleModelManagerConfig): ModelManagerOptions<"google-generative-ai">;
 export declare function googleVertexModelManagerOptions(_config?: GoogleVertexModelManagerConfig): ModelManagerOptions;

package/dist/types/provider-models/ollama.d.ts

@@ -1,7 +1,9 @@
 import type { ModelManagerOptions } from "../model-manager";
+import type { FetchImpl } from "../types";
 export interface OllamaCloudModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function normalizeOllamaCloudBaseUrl(baseUrl?: string): string;
 export declare function ollamaCloudModelManagerOptions(config?: OllamaCloudModelManagerConfig): ModelManagerOptions<"ollama-chat">;

package/dist/types/provider-models/openai-compat.d.ts

@@ -1,6 +1,6 @@
 import type { ModelManagerOptions } from "../model-manager";
 import { getBundledModels } from "../models";
-import type { Api, Model, Provider } from "../types";
+import type { Api, FetchImpl, Model, Provider } from "../types";
 export interface ModelsDevModel {
     id?: string;
     name?: string;
@@ -27,41 +27,49 @@ export interface ModelsDevModel {
 type SimpleProviderConfig = {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 };
 export declare function createSimpleOpenAICompletionsOptions(providerId: Parameters<typeof getBundledModels>[0], defaultBaseUrl: string, config?: SimpleProviderConfig): ModelManagerOptions<"openai-completions">;
 export interface OpenAIModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function openaiModelManagerOptions(config?: OpenAIModelManagerConfig): ModelManagerOptions<"openai-responses">;
 export interface GroqModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function groqModelManagerOptions(config?: GroqModelManagerConfig): ModelManagerOptions<"openai-completions">;
 export interface CerebrasModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function cerebrasModelManagerOptions(config?: CerebrasModelManagerConfig): ModelManagerOptions<"openai-completions">;
 export interface HuggingfaceModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function huggingfaceModelManagerOptions(config?: HuggingfaceModelManagerConfig): ModelManagerOptions<"openai-completions">;
 export interface NvidiaModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function nvidiaModelManagerOptions(config?: NvidiaModelManagerConfig): ModelManagerOptions<"openai-completions">;
 export interface XaiModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function xaiModelManagerOptions(config?: XaiModelManagerConfig): ModelManagerOptions<"openai-completions">;
 export interface XaiOAuthModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 interface XAICuratedModel {
     id: string;
@@ -110,16 +118,19 @@ export declare function isLikelyAimlApiChatModelId(id: string): boolean;
 export interface AimlApiModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function aimlApiModelManagerOptions(config?: AimlApiModelManagerConfig): ModelManagerOptions<"openai-completions">;
 export interface DeepSeekModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function deepseekModelManagerOptions(config?: DeepSeekModelManagerConfig): ModelManagerOptions<"openai-completions">;
 export interface ZhipuCodingPlanModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function zhipuCodingPlanModelManagerOptions(config?: ZhipuCodingPlanModelManagerConfig): ModelManagerOptions<"openai-completions">;
 /**
@@ -151,11 +162,13 @@ export declare function stripFireworksDeepSeekThinkingToggle(model: Model<"opena
 export interface FireworksModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function fireworksModelManagerOptions(config?: FireworksModelManagerConfig): ModelManagerOptions<"openai-completions">;
 export interface FirepassModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 /**
  * Fire Pass is a Fireworks subscription product that exposes a single router
@@ -168,93 +181,111 @@ export declare function firepassModelManagerOptions(_config?: FirepassModelManag
 export interface WaferModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function waferPassModelManagerOptions(config?: WaferModelManagerConfig): ModelManagerOptions<"openai-completions">;
 export declare function waferServerlessModelManagerOptions(config?: WaferModelManagerConfig): ModelManagerOptions<"openai-completions">;
 export interface MistralModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function mistralModelManagerOptions(config?: MistralModelManagerConfig): ModelManagerOptions<"openai-completions">;
 export interface OpenCodeModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function opencodeZenModelManagerOptions(config?: OpenCodeModelManagerConfig): ModelManagerOptions<Api>;
 export declare function opencodeGoModelManagerOptions(config?: OpenCodeModelManagerConfig): ModelManagerOptions<Api>;
 export interface OllamaModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function ollamaModelManagerOptions(config?: OllamaModelManagerConfig): ModelManagerOptions<"openai-responses">;
 export interface OpenRouterModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function openrouterModelManagerOptions(config?: OpenRouterModelManagerConfig): ModelManagerOptions<"openai-completions">;
 export interface ZenMuxModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function zenmuxModelManagerOptions(config?: ZenMuxModelManagerConfig): ModelManagerOptions<Api>;
 export interface KiloModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function kiloModelManagerOptions(config?: KiloModelManagerConfig): ModelManagerOptions<"openai-completions">;
 export interface AlibabaCodingPlanModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function alibabaCodingPlanModelManagerOptions(config?: AlibabaCodingPlanModelManagerConfig): ModelManagerOptions<"openai-completions">;
 export interface VercelAiGatewayModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function vercelAiGatewayModelManagerOptions(config?: VercelAiGatewayModelManagerConfig): ModelManagerOptions<"anthropic-messages">;
 export interface KimiCodeModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function kimiCodeModelManagerOptions(config?: KimiCodeModelManagerConfig): ModelManagerOptions<"openai-completions">;
 export interface LmStudioModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function lmStudioModelManagerOptions(config?: LmStudioModelManagerConfig): ModelManagerOptions<"openai-completions">;
 export interface SyntheticModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function syntheticModelManagerOptions(config?: SyntheticModelManagerConfig): ModelManagerOptions<"openai-completions">;
 export interface VeniceModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function veniceModelManagerOptions(config?: VeniceModelManagerConfig): ModelManagerOptions<"openai-completions">;
 export interface TogetherModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function togetherModelManagerOptions(config?: TogetherModelManagerConfig): ModelManagerOptions<"openai-completions">;
 export interface MoonshotModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function moonshotModelManagerOptions(config?: MoonshotModelManagerConfig): ModelManagerOptions<"openai-completions">;
 export interface QwenPortalModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function qwenPortalModelManagerOptions(config?: QwenPortalModelManagerConfig): ModelManagerOptions<"openai-completions">;
 export interface QianfanModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function qianfanModelManagerOptions(config?: QianfanModelManagerConfig): ModelManagerOptions<"openai-completions">;
 export interface CloudflareAiGatewayModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function cloudflareAiGatewayModelManagerOptions(config?: CloudflareAiGatewayModelManagerConfig): ModelManagerOptions<"anthropic-messages">;
 /** Region codes for Xiaomi Token Plan clusters exposed as separate login providers. */
@@ -263,6 +294,7 @@ export type XiaomiTokenPlanRegion = "sgp" | "ams" | "cn";
 export interface XiaomiModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
     providerId?: Provider;
     tokenPlanRegion?: XiaomiTokenPlanRegion;
 }
@@ -271,26 +303,31 @@ export declare function xiaomiModelManagerOptions(config?: XiaomiModelManagerCon
 export interface LiteLLMModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function litellmModelManagerOptions(config?: LiteLLMModelManagerConfig): ModelManagerOptions<"openai-completions">;
 export interface VllmModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function vllmModelManagerOptions(config?: VllmModelManagerConfig): ModelManagerOptions<"openai-completions">;
 export interface NanoGptModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function nanoGptModelManagerOptions(config?: NanoGptModelManagerConfig): ModelManagerOptions<"openai-completions">;
 export interface GithubCopilotModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function githubCopilotModelManagerOptions(config?: GithubCopilotModelManagerConfig): ModelManagerOptions<Api>;
 export interface AnthropicModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 }
 export declare function anthropicModelManagerOptions(config?: AnthropicModelManagerConfig): ModelManagerOptions<"anthropic-messages">;
 export { UNK_CONTEXT_WINDOW, UNK_MAX_TOKENS } from "./discovery-constants";

package/dist/types/providers/openai-responses-shared.d.ts

@@ -85,7 +85,7 @@ type CommonSamplingOptions = Pick<StreamOptions, "temperature" | "topP" | "topK"
  * can let the upstream apply its own default instead of 400-ing on `maxTokens` values that
  * reflect the model's context window rather than the upstream output limit.
  */
-export declare function applyCommonResponsesSamplingParams<P extends CommonResponsesParams>(params: P, options: CommonSamplingOptions | undefined, model: Pick<Model, "provider" | "omitMaxOutputTokens">): void;
+export declare function applyCommonResponsesSamplingParams<P extends CommonResponsesParams>(params: P, options: CommonSamplingOptions | undefined, model: Pick<Model, "provider" | "omitMaxOutputTokens" | "maxTokens">): void;
 type ReasoningOptions = {
     reasoning?: string;
     reasoningSummary?: "auto" | "detailed" | "concise" | null;

package/dist/types/registry/api-key-validation.d.ts

@@ -1,9 +1,11 @@
+import type { FetchImpl } from "../types";
 type OpenAICompatibleValidationOptions = {
     provider: string;
     apiKey: string;
     baseUrl: string;
     model: string;
     signal?: AbortSignal;
+    fetch?: FetchImpl;
 };
 type AnthropicCompatibleValidationOptions = {
     provider: string;
@@ -11,12 +13,14 @@ type AnthropicCompatibleValidationOptions = {
     baseUrl: string;
     model: string;
     signal?: AbortSignal;
+    fetch?: FetchImpl;
 };
 type ModelListValidationOptions = {
     provider: string;
     apiKey: string;
     modelsUrl: string;
     signal?: AbortSignal;
+    fetch?: FetchImpl;
 };
 /**
  * Validate an API key against an OpenAI-compatible chat completions endpoint.

package/dist/types/registry/oauth/anthropic.d.ts

@@ -1,6 +1,7 @@
 /**
  * Anthropic OAuth flow (Claude Pro/Max)
  */
+import type { FetchImpl } from "../../types";
 import { OAuthCallbackFlow } from "./callback-server";
 import type { OAuthController, OAuthCredentials } from "./types";
 export declare class AnthropicOAuthFlow extends OAuthCallbackFlow {
@@ -19,4 +20,4 @@ export declare function loginAnthropic(ctrl: OAuthController): Promise<OAuthCred
 /**
  * Refresh Anthropic OAuth token
  */
-export declare function refreshAnthropicToken(refreshToken: string): Promise<OAuthCredentials>;
+export declare function refreshAnthropicToken(refreshToken: string, fetchOverride?: FetchImpl): Promise<OAuthCredentials>;

package/dist/types/registry/oauth/github-copilot.d.ts

@@ -1,8 +1,22 @@
+import type { FetchImpl } from "../../types";
 import type { OAuthCredentials } from "./types";
 export declare const COPILOT_USER_AGENT: "opencode/1.3.15";
 export declare const OPENCODE_HEADERS: {
     readonly "User-Agent": "opencode/1.3.15";
 };
+type GitHubCopilotLoginOptions = {
+    onAuth: (url: string, instructions?: string) => void;
+    onPrompt: (prompt: {
+        message: string;
+        placeholder?: string;
+        allowEmpty?: boolean;
+    }) => Promise<string>;
+    onProgress?: (message: string) => void;
+    signal?: AbortSignal;
+    pollIntervalFloorMs?: number;
+    pollIntervalScaleMs?: number;
+    fetch?: FetchImpl;
+};
 export type ParsedGitHubCopilotApiKey = {
     accessToken: string;
     enterpriseUrl?: string;
@@ -24,15 +38,5 @@ export declare function refreshGitHubCopilotToken(refreshToken: string, enterpri
  * @param options.onProgress - Optional progress callback
  * @param options.signal - Optional AbortSignal for cancellation
  */
-export declare function loginGitHubCopilot(options: {
-    onAuth: (url: string, instructions?: string) => void;
-    onPrompt: (prompt: {
-        message: string;
-        placeholder?: string;
-        allowEmpty?: boolean;
-    }) => Promise<string>;
-    onProgress?: (message: string) => void;
-    signal?: AbortSignal;
-    pollIntervalFloorMs?: number;
-    pollIntervalScaleMs?: number;
-}): Promise<OAuthCredentials>;
+export declare function loginGitHubCopilot(options: GitHubCopilotLoginOptions): Promise<OAuthCredentials>;
+export {};

package/dist/types/registry/oauth/types.d.ts

@@ -1,3 +1,4 @@
+import type { FetchImpl } from "../../types";
 import type { OAuthProviderUnion } from "../registry";
 export type OAuthCredentials = {
     refresh: string;
@@ -30,6 +31,7 @@ export interface OAuthController {
     onManualCodeInput?(): Promise<string>;
     onPrompt?(prompt: OAuthPrompt): Promise<string>;
     signal?: AbortSignal;
+    fetch?: FetchImpl;
 }
 export interface OAuthLoginCallbacks extends OAuthController {
     onAuth: (info: OAuthAuthInfo) => void;

package/dist/types/registry/oauth/xai-oauth.d.ts

@@ -7,6 +7,7 @@
  * {@link validateXAIEndpoint}: any non-HTTPS or non-`x.ai`/`*.x.ai` host is
  * rejected on every call site, not just the first.
  */
+import type { FetchImpl } from "../../types";
 import { OAuthCallbackFlow } from "./callback-server";
 import type { OAuthController, OAuthCredentials } from "./types";
 /**
@@ -57,4 +58,4 @@ export declare function loginXAIOAuth(ctrl: OAuthController): Promise<OAuthCrede
  * re-validates the cached `token_endpoint` on the refresh hot path so a
  * cached-but-poisoned endpoint cannot silently leak a refresh_token.
  */
-export declare function refreshXAIOAuthToken(refreshToken: string): Promise<OAuthCredentials>;
+export declare function refreshXAIOAuthToken(refreshToken: string, fetchOverride?: FetchImpl): Promise<OAuthCredentials>;

package/dist/types/registry/types.d.ts

@@ -9,12 +9,13 @@
  * line in `./registry.ts`.
  */
 import type { ModelManagerOptions } from "../model-manager";
-import type { Api } from "../types";
+import type { Api, FetchImpl } from "../types";
 import type { OAuthCredentials, OAuthLoginCallbacks } from "./oauth/types";
 /** Config passed to a provider's runtime model-manager factory. */
 export type ModelManagerConfig = {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
 };
 /**
  * API-key environment fallback: either a single env var name (e.g.

package/dist/types/types.d.ts

@@ -15,6 +15,18 @@ import type { OpenAIResponsesOptions } from "./providers/openai-responses";
 import type { KnownProviderId } from "./registry";
 import type { AssistantMessageEventStream } from "./utils/event-stream";
 export type { AssistantMessageEventStream } from "./utils/event-stream";
+/**
+ * Ceiling on the output-token count omp requests from any OpenAI-family endpoint
+ * (openai-responses, azure/xai responses, and openai-completions). Mirrors
+ * Anthropic's {@link CLAUDE_CODE_MAX_OUTPUT_TOKENS}.
+ *
+ * Catalog `maxTokens` frequently reflects a model's context window rather than a
+ * given upstream's real per-request output cap. OpenRouter, for instance,
+ * advertises 131072 output tokens for `z-ai/glm-4.7`, but the Cerebras upstream
+ * only allows ~131072 tokens total — so requesting the full ceiling overflows
+ * with a 400. Requested output is clamped to this value (and to `model.maxTokens`).
+ */
+export declare const OPENAI_MAX_OUTPUT_TOKENS = 64000;
 export type KnownApi = "openai-completions" | "openai-responses" | "openai-codex-responses" | "azure-openai-responses" | "anthropic-messages" | "bedrock-converse-stream" | "google-generative-ai" | "google-gemini-cli" | "google-vertex" | "ollama-chat" | "cursor-agent";
 export type Api = KnownApi | (string & {});
 export interface ApiOptionsMap {
@@ -449,6 +461,14 @@ export interface AssistantMessage {
     provider: Provider;
     model: string;
     responseId?: string;
+    /**
+     * Name of the upstream provider an aggregator routed this request to, as
+     * reported in the response (e.g. OpenRouter's top-level `provider` field:
+     * `"OpenAI"`, `"Anthropic"`, `"Together"`). Distinct from `provider`, which
+     * is the configured gateway we called (`"openrouter"`). Undefined for direct
+     * providers that expose no such field.
+     */
+    upstreamProvider?: string;
     usage: Usage;
     stopReason: StopReason;
     errorMessage?: string;

package/dist/types/usage.d.ts

@@ -5,7 +5,7 @@
  * and shared quotas across providers.
  */
 import * as z from "zod/v4";
-import type { Provider } from "./types";
+import type { FetchImpl, Provider } from "./types";
 export type UsageUnit = "percent" | "tokens" | "requests" | "usd" | "minutes" | "bytes" | "unknown";
 export type UsageStatus = "ok" | "warning" | "exhausted" | "unknown";
 /** Time window for a limit (e.g. 5h, 7d, monthly). */
@@ -231,7 +231,7 @@ export interface UsageFetchParams {
 }
 /** Shared runtime utilities for fetchers. */
 export interface UsageFetchContext {
-    fetch: typeof fetch;
+    fetch: FetchImpl;
     logger?: UsageLogger;
     retryWait?: (delayMs: number, signal?: AbortSignal) => Promise<void>;
 }

package/dist/types/utils/discovery/gemini.d.ts

@@ -1,4 +1,4 @@
-import type { Model } from "../../types";
+import type { FetchImpl, Model } from "../../types";
 /**
  * Configuration for Google Generative AI model discovery.
  */
@@ -14,7 +14,7 @@ export interface GeminiDiscoveryOptions {
     /** Optional abort signal for HTTP requests. */
     signal?: AbortSignal;
     /** Optional fetch implementation override for tests. */
-    fetch?: typeof fetch;
+    fetch?: FetchImpl;
 }
 /**
  * Fetches and normalizes Google Generative AI models from the public models endpoint.

package/dist/types/utils/discovery/openai-compatible.d.ts

@@ -1,4 +1,4 @@
-import type { Api, Model, Provider } from "../../types";
+import type { Api, FetchImpl, Model, Provider } from "../../types";
 /**
  * Minimal OpenAI-style model entry shape consumed by discovery.
  *
@@ -51,7 +51,7 @@ export interface FetchOpenAICompatibleModelsOptions<TApi extends Api> {
     /** Optional AbortSignal for request cancellation. */
     signal?: AbortSignal;
     /** Optional fetch implementation override for testing/custom runtimes. */
-    fetch?: typeof globalThis.fetch;
+    fetch?: FetchImpl;
     /**
      * Optional post-normalization filter.
      * Return false to skip a model.

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "15.10.6",
+	"version": "15.10.8",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -39,7 +39,7 @@
 	},
 	"dependencies": {
 		"@bufbuild/protobuf": "^2.12.0",
-		"@oh-my-pi/pi-utils": "15.10.6",
+		"@oh-my-pi/pi-utils": "15.10.8",
 		"openai": "^6.39.0",
 		"partial-json": "^0.1.7",
 		"zod": "4.4.3"

package/src/auth-storage.ts

@@ -492,6 +492,9 @@ const USAGE_FAILURE_BACKOFF_MS = 10_000;
 // Bumped from 3s — Claude usage retries up to 3 times with exponential backoff
 // (~3.5s total worst case); a tight per-request budget aborts retries mid-cycle.
 const DEFAULT_USAGE_REQUEST_TIMEOUT_MS = 10_000;
+const USAGE_REPORT_CACHE_KEY_VERSION_OVERRIDES: Partial<Record<Provider, number>> = {
+	"google-antigravity": 2,
+};
 const DEFAULT_OAUTH_REFRESH_TIMEOUT_MS = 10_000;
 /**
  * Refresh OAuth access tokens this many ms before their stated expiry. The
@@ -1568,6 +1571,7 @@ export class AuthStorage {
 			onPrompt: ctrl.onPrompt,
 			onManualCodeInput: ctrl.onManualCodeInput ?? manualCodeInput,
 			signal: ctrl.signal,
+			fetch: ctrl.fetch,
 		});
 		if (typeof result === "string") {
 			// Some flows (e.g. ollama) return "" to signal that no key was entered.
@@ -1638,15 +1642,19 @@ export class AuthStorage {
 	#buildUsageReportCacheKey(request: UsageRequestDescriptor): string {
 		const baseUrl = this.#normalizeUsageBaseUrl(request.baseUrl) || "default";
 		const identity = this.#buildUsageCacheIdentity(request.credential);
-		return `report:${request.provider}:${baseUrl}:${identity}`;
+		const versionOverride = USAGE_REPORT_CACHE_KEY_VERSION_OVERRIDES[request.provider];
+		const providerKey = versionOverride === undefined ? request.provider : `${versionOverride}:${request.provider}`;
+		return `report:${providerKey}:${baseUrl}:${identity}`;
 	}
 
 	#buildUsageReportsCacheKey(requests: ReadonlyArray<UsageRequestDescriptor>): string {
 		const snapshot = requests
-			.map(
-				request =>
-					`${request.provider}:${this.#normalizeUsageBaseUrl(request.baseUrl) || "default"}:${this.#buildUsageCacheIdentity(request.credential)}`,
-			)
+			.map(request => {
+				const versionOverride = USAGE_REPORT_CACHE_KEY_VERSION_OVERRIDES[request.provider];
+				const providerKey =
+					versionOverride === undefined ? request.provider : `${versionOverride}:${request.provider}`;
+				return `${providerKey}:${this.#normalizeUsageBaseUrl(request.baseUrl) || "default"}:${this.#buildUsageCacheIdentity(request.credential)}`;
+			})
 			.sort()
 			.join("\n");
 		return `reports:${Bun.hash(snapshot).toString(16)}`;

package/src/provider-models/google.ts

@@ -5,6 +5,7 @@ import { fetchGeminiModels } from "../utils/discovery/gemini";
 
 export interface GoogleModelManagerConfig {
 	apiKey?: string;
+	fetch?: FetchImpl;
 }
 
 export interface GoogleVertexModelManagerConfig {
@@ -18,22 +19,36 @@ export interface GoogleVertexModelManagerConfig {
 export interface GoogleAntigravityModelManagerConfig {
 	oauthToken?: string;
 	endpoint?: string;
+	fetch?: FetchImpl;
 }
 
 export interface GoogleGeminiCliModelManagerConfig {
 	oauthToken?: string;
 	endpoint?: string;
+	fetch?: FetchImpl;
 }
 
 const CLOUD_CODE_ASSIST_ENDPOINT = "https://cloudcode-pa.googleapis.com";
 
+function toDiscoveryFetch(fetchImpl: FetchImpl | undefined): typeof fetch | undefined {
+	if (!fetchImpl) {
+		return undefined;
+	}
+	return Object.assign(
+		(input: Parameters<typeof fetch>[0], init?: Parameters<typeof fetch>[1]) => fetchImpl(input, init),
+		{ preconnect: fetchImpl.preconnect ?? fetch.preconnect },
+	);
+}
+
 export function googleModelManagerOptions(
 	config?: GoogleModelManagerConfig,
 ): ModelManagerOptions<"google-generative-ai"> {
 	const apiKey = config?.apiKey;
 	return {
 		providerId: "google",
-		...(apiKey ? { fetchDynamicModels: () => fetchGeminiModels({ apiKey }) } : undefined),
+		...(apiKey
+			? { fetchDynamicModels: () => fetchGeminiModels({ apiKey, fetch: toDiscoveryFetch(config?.fetch) }) }
+			: undefined),
 	};
 }
 
@@ -53,6 +68,7 @@ export function googleAntigravityModelManagerOptions(
 						fetchAntigravityDiscoveryModels({
 							token,
 							endpoint: config?.endpoint,
+							fetcher: toDiscoveryFetch(config?.fetch),
 						}),
 				}
 			: undefined),
@@ -72,6 +88,7 @@ export function googleGeminiCliModelManagerOptions(
 						const models = await fetchAntigravityDiscoveryModels({
 							token,
 							endpoint,
+							fetcher: toDiscoveryFetch(config?.fetch),
 						});
 						if (models === null) {
 							return null;