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

package/CHANGELOG.md

@@ -2,7 +2,23 @@
 
 ## [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`
@@ -3102,4 +3118,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/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/openai-compat.d.ts

@@ -24,6 +24,17 @@ 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;

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/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/types.d.ts

@@ -741,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.

package/dist/types/usage/google-antigravity.d.ts

@@ -1,2 +1,27 @@
-import type { UsageProvider } from "../usage";
+import type { CredentialRankingStrategy, UsageProvider } from "../usage";
 export declare const antigravityUsageProvider: UsageProvider;
+/**
+ * Credential ranking strategy for `google-antigravity`. Drives proactive
+ * multi-account selection in {@link AuthStorage} by reading the per-counter
+ * Antigravity usage reports.
+ *
+ * Antigravity reports one {@link UsageLimit} per backend counter (Google /
+ * Anthropic / OpenAI) per tier per window, and {@link fetchAntigravityUsage}
+ * sorts them ascending by `remainingFraction` — so `limits[0]` is always the
+ * most-pressured counter for the credential, and `limits[1]` (when present)
+ * is the next-most-pressured counter.
+ *
+ * `AuthStorage` compares the `secondary*` ranking metrics before `primary*`
+ * because other providers model a long-window budget as secondary. Antigravity
+ * does not expose a short/long split; every counter is a sibling bottleneck.
+ * Therefore the most-pressured counter goes in `secondary`, with the runner-up
+ * in `primary`, so proactive account selection always ranks the bottleneck
+ * before any healthier sibling counter.
+ *
+ * The Antigravity API exposes `resetTime` but not window duration, so the
+ * drain-rate calculation depends on `windowDefaults`. Antigravity quotas are
+ * effectively daily; 24h is the right fallback for both axes — any 5h tier
+ * still ranks correctly because both credentials are normalised against the
+ * same fallback.
+ */
+export declare const antigravityRankingStrategy: CredentialRankingStrategy;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "15.10.8",
+	"version": "15.10.9",
 	"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.8",
+		"@oh-my-pi/pi-utils": "15.10.9",
 		"openai": "^6.39.0",
 		"partial-json": "^0.1.7",
 		"zod": "4.4.3"

package/src/auth-storage.ts

@@ -31,7 +31,7 @@ import type {
 import { claudeRankingStrategy, claudeUsageProvider } from "./usage/claude";
 import { googleGeminiCliUsageProvider } from "./usage/gemini";
 import { githubCopilotUsageProvider } from "./usage/github-copilot";
-import { antigravityUsageProvider } from "./usage/google-antigravity";
+import { antigravityRankingStrategy, antigravityUsageProvider } from "./usage/google-antigravity";
 import { kimiUsageProvider } from "./usage/kimi";
 import { codexRankingStrategy, openaiCodexUsageProvider } from "./usage/openai-codex";
 import { zaiUsageProvider } from "./usage/zai";
@@ -650,6 +650,7 @@ function resolveDefaultUsageProvider(provider: Provider): UsageProvider | undefi
 const DEFAULT_RANKING_STRATEGIES = new Map<Provider, CredentialRankingStrategy>([
 	["openai-codex", codexRankingStrategy],
 	["anthropic", claudeRankingStrategy],
+	["google-antigravity", antigravityRankingStrategy],
 ]);
 
 function resolveDefaultRankingStrategy(provider: Provider): CredentialRankingStrategy | undefined {

package/src/model-thinking.ts

@@ -23,7 +23,7 @@ type SemVer = {
 };
 
 type GeminiKind = "pro" | "flash";
-type AnthropicKind = "opus" | "sonnet";
+type AnthropicKind = "opus" | "sonnet" | "fable" | "mythos";
 type OpenAIVariant = "base" | "codex" | "codex-max" | "codex-mini" | "codex-spark" | "mini" | "max" | "nano";
 
 const CODEX_GPT_5_4_PRIORITY_BY_VARIANT: Partial<Record<OpenAIVariant, number>> = {
@@ -308,7 +308,8 @@ export function mapEffortToAnthropicAdaptiveEffort<TApi extends Api>(
 ): "low" | "medium" | "high" | "xhigh" | "max" {
 	const supported = requireSupportedEffort(model, effort);
 	if (anthropicModelHasRealXHighEffort(model)) {
-		// Opus 4.7+ on the Messages API exposes the full five-tier adaptive scale
+		// Opus 4.7+ and Fable/Mythos 5 on the Messages API expose the full
+		// five-tier adaptive scale
 		// (low/medium/high/xhigh/max). Shift our user-facing efforts up one notch so
 		// the top tier reaches the genuine "max" and "high" lands on Anthropic's
 		// recommended "xhigh" coding/agentic default.
@@ -341,33 +342,44 @@ export function mapEffortToAnthropicAdaptiveEffort<TApi extends Api>(
 }
 
 /**
- * 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")
  */
 export function hasOpus47ApiRestrictions(modelId: string): boolean {
 	const parsed = parseAnthropicModel(getCanonicalModelId(modelId));
 	if (!parsed) return false;
-	return semverGte(parsed.version, "4.7") && parsed.kind === "opus";
+	return (parsed.kind === "opus" && semverGte(parsed.version, "4.7")) || isFableOrMythos(parsed.kind);
 }
 
 /**
  * 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 function supportsMidConversationSystemMessages(modelId: string): boolean {
 	const parsed = parseAnthropicModel(getCanonicalModelId(modelId));
 	if (!parsed) return false;
-	return parsed.kind === "opus" && semverGte(parsed.version, "4.8");
+	return (parsed.kind === "opus" && semverGte(parsed.version, "4.8")) || isFableOrMythos(parsed.kind);
+}
+
+export function isAnthropicFableOrMythosModel(modelId: string): boolean {
+	const parsed = parseAnthropicModel(getCanonicalModelId(modelId));
+	return parsed !== null && isFableOrMythos(parsed.kind);
+}
+
+function isFableOrMythos(kind: AnthropicKind): boolean {
+	return kind === "fable" || kind === "mythos";
 }
 
 function anthropicModelHasRealXHighEffort<TApi extends Api>(model: ApiModel<TApi>): boolean {
 	if (model.api !== "anthropic-messages") return false;
 	const parsedModel = parseKnownModel(model.id);
-	if (parsedModel.family !== "anthropic" || parsedModel.kind !== "opus") return false;
-	return semverGte(parsedModel.version, "4.7");
+	if (parsedModel.family !== "anthropic") return false;
+	if (isFableOrMythos(parsedModel.kind)) return true;
+	return parsedModel.kind === "opus" && semverGte(parsedModel.version, "4.7");
 }
 
 function applyGeneratedModelPolicy(model: ApiModel<Api>): void {
@@ -431,6 +443,19 @@ function applyAnthropicCatalogPolicy(model: ApiModel<Api>, parsedModel: Anthropi
 		model.contextWindow = 1000000;
 		model.maxTokens = 128000;
 	}
+
+	// Claude Fable/Mythos 5: Anthropic's /v1/models omits token limits and
+	// pricing, and models.dev lags new releases. Pin authoritative values from
+	// the model card (1M context / 128k output) and pricing docs ($10 in / $50
+	// out per MTok).
+	if (model.provider === "anthropic" && isFableOrMythos(parsedModel.kind)) {
+		model.contextWindow = 1_000_000;
+		model.maxTokens = 128_000;
+		model.cost.input = 10;
+		model.cost.output = 50;
+		model.cost.cacheRead = 1;
+		model.cost.cacheWrite = 12.5;
+	}
 }
 
 function inferGeneratedApplyPatchToolType(
@@ -562,7 +587,9 @@ function inferAnthropicSupportedEfforts<TApi extends Api>(
 		(model.api === "anthropic-messages" || model.api === "bedrock-converse-stream") &&
 		semverGte(parsedModel.version, "4.6")
 	) {
-		return parsedModel.kind === "opus" ? DEFAULT_REASONING_EFFORTS_WITH_XHIGH : DEFAULT_REASONING_EFFORTS;
+		return parsedModel.kind === "opus" || isFableOrMythos(parsedModel.kind)
+			? DEFAULT_REASONING_EFFORTS_WITH_XHIGH
+			: DEFAULT_REASONING_EFFORTS;
 	}
 	return inferFallbackEfforts(model);
 }
@@ -618,7 +645,10 @@ function inferThinkingControlMode<TApi extends Api>(
 
 		case "bedrock-converse-stream":
 			if (parsedModel.family === "anthropic") {
-				if (semverGte(parsedModel.version, "4.6") && parsedModel.kind === "opus") {
+				if (
+					semverGte(parsedModel.version, "4.6") &&
+					(parsedModel.kind === "opus" || isFableOrMythos(parsedModel.kind))
+				) {
 					return "anthropic-adaptive";
 				}
 				if (semverGte(parsedModel.version, "4.5")) {
@@ -658,7 +688,7 @@ function parseGeminiModel(modelId: string): GeminiModel | null {
 }
 
 function parseAnthropicModel(modelId: string): AnthropicModel | null {
-	const match = /claude-(opus|sonnet)-(\d{1,2}(?:[.-]\d{1,2}){0,2})\b/.exec(modelId);
+	const match = /claude-(opus|sonnet|fable|mythos)-(\d{1,2}(?:[.-]\d{1,2}){0,2})\b/.exec(modelId);
 	if (!match) {
 		return null;
 	}