@oh-my-pi/pi-ai 15.10.7 → 15.10.9

package/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 ## [Unreleased]
 
+## [15.10.9] - 2026-06-09
+
+### Added
+
+- Added `antigravityRankingStrategy` and registered it as the default `CredentialRankingStrategy` for `google-antigravity`, so multi-account selection consumes the per-counter Antigravity usage reports (sorted ascending by `remainingFraction` in `fetchAntigravityUsage`) before falling back to round-robin — preventing the exhausted-counter credential from being chosen first when an unblocked sibling has headroom ([#2187](https://github.com/can1357/oh-my-pi/issues/2187)).
+- Added Claude Fable 5 to the first-party Anthropic catalog, seeded directly via `ANTHROPIC_CURATED_FALLBACK_MODELS` rather than waiting on models.dev (1M context / 128k output, adaptive thinking, $10/$50 per MTok). The model parser recognizes the `fable` kind so effort tiers (low→max), adaptive thinking, and Opus-4.7-style sampling restrictions apply; token limits and pricing are pinned in `applyAnthropicCatalogPolicy`.
+
+### Fixed
+
+- Fixed `google-antigravity` not rotating to another stored OAuth account when Cloud Code Assist returns `429 You have exhausted your capacity on this model. Your quota will reset after …`. `parseRateLimitReason` matched the literal `capacity` before the `quota will reset` suffix and downgraded the failure to `MODEL_CAPACITY_EXHAUSTED` (45–75 s backoff), and `isUsageLimitError` returned false for the same message — so `markUsageLimitReached` was never invoked and the agent kept hammering the exhausted credential while the retry layer bailed on the multi-hour `retry-after`. Both paths now treat the Antigravity phrasing as `QUOTA_EXHAUSTED` / usage-limit, blocking the current credential until reset and letting the session pick an unblocked sibling ([#2187](https://github.com/can1357/oh-my-pi/issues/2187)).
+- Fixed OpenRouter Anthropic chat-completions requests placing `cache_control` on empty assistant tool-call content. The cache marker now skips empty text and attaches to the most recent non-empty text part, avoiding HTTP 400 payloads with `{type:"text", text:"", cache_control:...}`.
+- Fixed Fable-only Anthropic request shaping to cover Claude Mythos 5, and added Mythos 5 to the first-party Anthropic catalog seed. Adaptive display, sampling suppression, mid-conversation system messages, forced-tool-choice downgrade, and Bedrock adaptive metadata now handle both model families.
+- Fixed adaptive-only Claude models (Opus 4.6+, Sonnet 4.6+, Fable/Mythos 5) returning HTTP 400 `"thinking.type.disabled" is not supported for this model` whenever thinking was turned off (utility calls and forced-tool turns route through the disable path). These models accept only `thinking.type: "adaptive"`; the request builder now omits the thinking field and pins the lowest adaptive effort instead of emitting `type: "disabled"`.
+- Widened the OpenAI-completions first-event watchdog floor from 120s to 300s for DeepSeek V4 reasoning models hosted on the official DeepSeek API. The reasoner emits no SSE bytes until its private chain-of-thought finishes, which routinely takes longer than the generic 100s first-event budget under load — every chat then aborted with `OpenAI completions stream timed out while waiting for the first event` and silently retried. Mirrors the existing GLM coding-plan widening ([#2177](https://github.com/can1357/oh-my-pi/issues/2177)).
+
+## [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

package/dist/types/model-thinking.d.ts

@@ -71,7 +71,7 @@ export declare function mapEffortToGoogleThinkingLevel<TApi extends Api>(model:
 /** Maps a normalized thinking effort to Anthropic adaptive effort values. */
 export declare function mapEffortToAnthropicAdaptiveEffort<TApi extends Api>(model: ApiModel<TApi>, effort: Effort): "low" | "medium" | "high" | "xhigh" | "max";
 /**
- * Returns true for Anthropic models with Opus 4.7 API restrictions:
+ * Returns true for Anthropic models with Opus 4.7+/Fable/Mythos API restrictions:
  * - Sampling parameters (temperature/top_p/top_k) return 400 error
  * - Thinking content is omitted by default (needs display: "summarized")
  */
@@ -79,7 +79,9 @@ export declare function hasOpus47ApiRestrictions(modelId: string): boolean;
 /**
  * Mid-conversation `role: "system"` messages (system instructions appended at
  * non-first positions in the `messages` array) are supported starting with
- * Claude Opus 4.8. Earlier Claude models reject the role.
+ * Claude Opus 4.8 and the Claude Fable/Mythos 5 generation. Earlier Claude
+ * models reject the role.
  * @see https://platform.claude.com/docs/en/build-with-claude/mid-conversation-system-messages
  */
 export declare function supportsMidConversationSystemMessages(modelId: string): boolean;
+export declare function isAnthropicFableOrMythosModel(modelId: string): boolean;

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;
@@ -24,44 +24,63 @@ export interface ModelsDevModel {
         npm?: string;
     };
 }
+/**
+ * Curated Anthropic models that are live or limited-availability on the
+ * first-party `/v1/models` endpoint but that models.dev has not catalogued yet.
+ * Seeded into model generation so the bundled catalog is never gated on
+ * models.dev's update cadence; deduped behind upstream catalog / models.dev
+ * entries once those appear. Token limits and pricing are pinned
+ * authoritatively in
+ * `applyAnthropicCatalogPolicy`, and `thinking` is derived by
+ * `refreshModelThinking` during generation.
+ */
+export declare const ANTHROPIC_CURATED_FALLBACK_MODELS: readonly Model<"anthropic-messages">[];
 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 +129,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 +173,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 +192,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 +305,7 @@ export type XiaomiTokenPlanRegion = "sgp" | "ams" | "cn";
 export interface XiaomiModelManagerConfig {
     apiKey?: string;
     baseUrl?: string;
+    fetch?: FetchImpl;
     providerId?: Provider;
     tokenPlanRegion?: XiaomiTokenPlanRegion;
 }
@@ -271,26 +314,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/amazon-bedrock.d.ts

@@ -27,11 +27,12 @@ export interface BedrockOptions extends StreamOptions {
      * - `"omitted"`: thinking content is suppressed; the encrypted signature still
      *   travels back for multi-turn continuity.
      *
-     * Starting with Claude Opus 4.7 the Anthropic API default is `"omitted"`, which
-     * leaves callers waiting on a silent stream during long reasoning runs (issue
-     * #1373). We default to `"summarized"` so adaptive-thinking models that accept
-     * the field keep producing visible thinking deltas. Older adaptive-thinking
-     * models (Opus 4.6, Sonnet 4.6+) reject the field, so we omit it for them.
+     * Starting with Claude Opus 4.7 and Claude Fable/Mythos 5 the Anthropic API
+     * default is `"omitted"`, which leaves callers waiting on a silent stream during
+     * long reasoning runs (issue #1373). We default to `"summarized"` so adaptive-
+     * thinking models that accept the field keep producing visible thinking deltas.
+     * Older adaptive-thinking models (Opus 4.6, Sonnet 4.6+) reject the field, so
+     * we omit it for them.
      */
     thinkingDisplay?: BedrockThinkingDisplay;
 }

package/dist/types/providers/anthropic.d.ts

@@ -56,17 +56,18 @@ export type AnthropicThinkingDisplay = "summarized" | "omitted";
 export interface AnthropicOptions extends StreamOptions {
     /**
      * Enable extended thinking.
-     * For Opus 4.6+: uses adaptive thinking (Claude decides when/how much to think).
-     * For older models: uses budget-based thinking with thinkingBudgetTokens.
+     * For adaptive-capable models (Opus 4.6+, Sonnet 4.6+, Fable/Mythos 5):
+     * uses adaptive thinking (Claude decides when/how much to think). For older
+     * models: uses budget-based thinking with thinkingBudgetTokens.
      */
     thinkingEnabled?: boolean;
     /**
      * Token budget for extended thinking (older models only).
-     * Ignored for Opus 4.6+ which uses adaptive thinking.
+     * Ignored for adaptive-capable models.
      */
     thinkingBudgetTokens?: number;
     /**
-     * Effort level for adaptive thinking (Opus 4.6+ only).
+     * Effort level for adaptive thinking.
      * Controls how much thinking Claude allocates:
      * - "max": Always thinks with no constraints
      * - "high": Always thinks, deep reasoning (default)
@@ -182,7 +183,7 @@ export declare function normalizeExtraBetas(betas?: string[] | string): string[]
 export declare function buildAnthropicClientOptions(args: AnthropicClientOptionsArgs): AnthropicClientOptionsResult;
 /**
  * A single Anthropic conversation turn, including the mid-conversation
- * `system` role (Opus 4.8+).
+ * `system` role (Opus 4.8+ and Fable/Mythos 5).
  */
 export type AnthropicMessageParam = MessageParam;
 export declare function convertAnthropicMessages(messages: Message[], model: Model<"anthropic-messages">, isOAuthToken: boolean, baseUrl?: string | undefined): AnthropicMessageParam[];

package/dist/types/providers/openai-completions.d.ts

@@ -41,7 +41,7 @@ export interface OpenAICompletionsOptions extends StreamOptions {
  * Exported for unit testing.
  */
 export declare function applyOpenRouterRoutingVariant(modelId: string, variant: string | undefined): string;
-/** Returns the widened OpenAI stream watchdog floor for slow GLM coding-plan reasoning models. */
+/** Returns the widened OpenAI stream watchdog floor for slow reasoning models hosted on OpenAI-compatible endpoints. */
 export declare function getOpenAICompletionsStreamIdleTimeoutFallbackMs(model: Model<"openai-completions">): number | undefined;
 export declare const streamOpenAICompletions: StreamFunction<"openai-completions">;
 export declare function parseChunkUsage(rawUsage: object, model: Model<"openai-completions">, premiumRequests: number | undefined): AssistantMessage["usage"];

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/rate-limit-utils.d.ts

@@ -5,10 +5,11 @@
 export type RateLimitReason = "QUOTA_EXHAUSTED" | "RATE_LIMIT_EXCEEDED" | "MODEL_CAPACITY_EXHAUSTED" | "SERVER_ERROR" | "UNKNOWN";
 /**
  * Classify a rate-limit error message into a reason category.
- * Priority order: MODEL_CAPACITY > RATE_LIMIT > QUOTA > SERVER_ERROR > UNKNOWN.
+ * Priority order: QUOTA (Antigravity "quota will reset") > MODEL_CAPACITY > QUOTA (account) >
+ * RATE_LIMIT > QUOTA (generic) > SERVER_ERROR > UNKNOWN.
  *
  * "resource exhausted" maps to MODEL_CAPACITY (transient, short wait)
- * "quota exceeded" maps to QUOTA_EXHAUSTED (long wait, switch account)
+ * "quota exceeded" / "quota will reset" maps to QUOTA_EXHAUSTED (long wait, switch account)
  */
 export declare function parseRateLimitReason(errorMessage: string): RateLimitReason;
 /**

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;
@@ -721,11 +741,20 @@ export interface AnthropicCompat {
     supportsLongCacheRetention?: boolean;
     /**
      * Whether mid-conversation `role: "system"` messages are accepted in the
-     * `messages` array (Claude Opus 4.8+ on the first-party Claude API and
-     * Claude Platform on AWS). When unset, auto-detected from the model id and
-     * base URL. Not available on Bedrock, Vertex AI, or Microsoft Foundry.
+     * `messages` array (Claude Opus 4.8+ and Claude Fable/Mythos 5 on the
+     * first-party Claude API and Claude Platform on AWS). When unset,
+     * auto-detected from the model id and base URL. Not available on Bedrock,
+     * Vertex AI, or Microsoft Foundry.
      */
     supportsMidConversationSystem?: boolean;
+    /**
+     * Whether the model accepts a forced `tool_choice` (`{ type: "any" }` or
+     * `{ type: "tool", name }`). Claude Fable/Mythos 5 reject forced tool use
+     * outright ("tool_choice forces tool use is not compatible with this model");
+     * the request builder downgrades forced choices to `auto` when this is false.
+     * When unset, auto-detected from the model id. Default: true.
+     */
+    supportsForcedToolChoice?: boolean;
 }
 /**
  * OpenRouter provider routing preferences.