@oh-my-pi/pi-ai 18.2.8 → 18.2.9

package/CHANGELOG.md

@@ -2,6 +2,38 @@
 
 ## [Unreleased]
 
+## [18.2.9] - 2026-09-22
+
+### Added
+
+- Added Claude saved-reset discovery and redemption, including session-only resets, grant eligibility, expiry, and safe retry handling.
+
+### Fixed
+
+- Fixed custom OpenAI-compatible extension streamers failing when no compatibility configuration was provided.
+- Fixed local provider sign-in for LM Studio, llama.cpp, and vLLM so an empty API key is not treated as successful authentication.
+- Fixed Vercel AI Gateway models backed by non-Anthropic providers failing tool calls because of strict schema validation; requests now retry with compatible non-strict tool handling.
+- Improved AWS Bedrock authentication by refreshing expired AWS SSO sessions automatically, reducing the need to run `aws sso login` again.
+- Fixed Bedrock tool-enabled requests when tool descriptions are included in the system prompt.
+- Improved Alibaba Token Plan (Beijing) quota reporting across workspaces and made gateway rejection codes visible in error logs.
+- Fixed the tool-call loop guard so repeated identical calls continue to be redirected after the detection threshold is reached.
+- Fixed valid required null values inside tool argument unions being removed before dispatch ([#12523](https://github.com/can1357/oh-my-pi/pull/12523) by [@cswenor](https://github.com/cswenor)).
+- Signing in to a local provider (lm-studio, llama.cpp, vllm) with an empty key paste no longer reports the provider as logged in while its requests go out unauthenticated. ([#12436](https://github.com/can1357/oh-my-pi/pull/12436) by [@xiechimon](https://github.com/xiechimon))
+- Fixed every turn failing with `400 Invalid schema for function '<tool>' … Missing '<param>'` on Vercel AI Gateway models served from a non-Anthropic upstream (e.g. `openai/gpt-5.6-sol`): the translated strict-tool rejection now triggers the existing non-strict retry instead of failing the turn ([#12760](https://github.com/can1357/oh-my-pi/pull/12760) by [@primitive-type](https://github.com/primitive-type)).
+- Expired AWS SSO access tokens are now refreshed via the SSO OIDC `refresh_token` grant instead of failing with `sso-token-expired`, so Bedrock profiles keep working between `aws sso login` runs the same way the AWS CLI does ([#12736](https://github.com/can1357/oh-my-pi/pull/12736) by [@nwbb](https://github.com/nwbb)).
+- Fixed Bedrock rejecting tool-enabled requests when tool descriptions are inlined into the system prompt ([#12732](https://github.com/can1357/oh-my-pi/pull/12732) by [@mustafaabidali](https://github.com/mustafaabidali)).
+- Alibaba Token Plan (Beijing) quota reporting no longer pins requests to a single workspace, and HTTP-200 gateway rejections now log their error code ([#12395](https://github.com/can1357/oh-my-pi/pull/12395) by [@Dante-dan](https://github.com/Dante-dan)).
+- The tool-call loop guard keeps redirecting when a model continues the same identical call past the detection threshold instead of firing only once ([#12709](https://github.com/can1357/oh-my-pi/pull/12709) by [@F0Rextasy](https://github.com/F0Rextasy)).
+- Fixed OpenAI-compatible Gemini gateways losing message-level thought signatures when replaying tool-call history.
+- Added support for explicitly disabling reasoning with `reasoning_effort: "none"` through Chat Completions authentication gateways.
+- Improved Bedrock resilience by retrying transient in-stream internal server, service unavailable, and throttling errors.
+- Fixed Anthropic prompt-cache keep-alive refreshes for turns that used forced tool selection.
+- Fixed auth-broker usage reports incorrectly sharing usage limits between Team members with shared workspace and organization identifiers.
+- Fixed OpenAI Codex requests hanging when an error response body is delayed.
+- Fixed Kimi usage reporting so monthly totals and code quotas are shown alongside the five-hour usage window.
+- Bedrock no longer sends provider-invalid payloads when an errored tool result contains an image; the image is hoisted into a sibling block ([#12865](https://github.com/can1357/oh-my-pi/pull/12865) by [@roboomp](https://github.com/roboomp)).
+- Gemini, Vertex, and Cloud Code Assist requests no longer include the unsupported `minP`/`repetitionPenalty` sampling fields, which caused 400s when set globally ([#12850](https://github.com/can1357/oh-my-pi/pull/12850) by [@roboomp](https://github.com/roboomp)).
+
 ## [18.2.8] - 2026-09-21
 
 ### Added
@@ -2255,21 +2287,4 @@
 - Made the openai-completions non-strict retry reachable for `"mixed"` strict mode (previously gated to `all_strict`, i.e. Cerebras only) and taught it to recognize upstream tool-schema validation 400s (`Invalid tool parameters schema …`, `Invalid schema for function …`). A matching rejection now retries the request with base (non-strict) schemas and persists `strictToolsDisabled` on the provider session, so later requests skip the doomed strict attempt instead of paying a 400 + retry round-trip each turn. ([#2270](https://github.com/can1357/oh-my-pi/issues/2270))
 - Cross-model `anthropic-messages → anthropic-messages` continuations now preserve prior assistant turns' reasoning chains end-to-end: every prior `thinking`/`redactedThinking` block survives (not just the latest surviving assistant), and third-party ↔ third-party replays keep their signatures intact so the reasoning chain stays signed for the next turn. Signatures are stripped (and any `redacted_thinking` sibling without a native landing spot is dropped) only when an official Anthropic endpoint is on either end of the replay — official Anthropic cryptographically binds reasoning signatures to its key+session+model, while compatible reasoning endpoints (Z.AI, DeepSeek, custom anthropic-messages providers configured via `models.yaml`) treat them as opaque continuation hints. Source-side official detection uses the canonical catalog provider id `"anthropic"` (assistant messages carry no `baseUrl`); target-side detection reuses the baked `compat.officialEndpoint` flag. Latest-turn byte-for-byte behavior (Anthropic's "thinking blocks in the latest assistant message cannot be modified" rule) and existing aborted/errored last-block sanitization are unchanged. ([#2257](https://github.com/can1357/oh-my-pi/issues/2257), [#2265](https://github.com/can1357/oh-my-pi/issues/2265))
 
-## [15.10.12] - 2026-06-10
-
-### Added
-
-- Added `antigravityRankingStrategy` and registered it for `google-antigravity` in `DEFAULT_RANKING_STRATEGIES`, so new sessions are routed to OAuth credentials with quota headroom for the requested model backend (lowest relevant `remainingFraction` counter as the sole ranked window, 24h `windowDefaults` matching `daily-cloudcode-pa.googleapis.com` resets). Without it, the existing `antigravityUsageProvider` data never reached credential selection. ([#2198](https://github.com/can1357/oh-my-pi/issues/2198))
-
-### Changed
-
-- Updated MiniMax and MiniMax Token Plan defaults to `MiniMax-M3` and refreshed Token Plan login copy/links ([#1725](https://github.com/can1357/oh-my-pi/issues/1725)).
-
-### Fixed
-
-- Fixed OpenAI Responses and Azure OpenAI Responses streams silently surfacing incomplete output as successful when a custom/proxy provider drops the connection without sending a terminal `response.completed`/`response.incomplete` event. Both providers now detect premature stream closure and throw with `stopReason: "error"` ([#2184](https://github.com/can1357/oh-my-pi/pull/2184))
-- Fixed `isUsageLimitError` missing Antigravity / Cloud Code Assist's `Individual quota reached` 429 phrasing. The `USAGE_LIMIT_PATTERN` only knew `quota.?exceeded` / `limit_reached`, so `auth-retry` and `AuthStorage.markUsageLimitReached` treated the response as a terminal provider error and pinned sessions to the exhausted OAuth account instead of rotating to a sibling credential. The pattern now also matches `quota.?reached`. ([#2198](https://github.com/can1357/oh-my-pi/issues/2198))
-- Scoped Antigravity usage blocking and ranking by model family (`gemini-*`/`gemma-*` → Google, `claude-*` → Anthropic, `gpt-*`/`openai/*` → OpenAI), so an exhausted Gemini counter no longer makes a healthy Claude/OpenAI Antigravity credential unavailable until reset. ([#2198](https://github.com/can1357/oh-my-pi/issues/2198))
-- Fixed no-model Antigravity credential lookups (e.g. image-provider discovery) inheriting provider-wide exhaustion: `scopeLimits` now returns no limits without a concrete backend counter, and `blockScope` always returns a counter scope so missing model context can never fall through to AuthStorage's provider-wide block bucket. ([#2198](https://github.com/can1357/oh-my-pi/issues/2198))
-
-Older entries are archived in [packages/ai/CHANGELOG.md@8a9097246135](https://github.com/can1357/oh-my-pi/blob/8a9097246135bd572ff96fb552121fe1194d2906/packages/ai/CHANGELOG.md).
+Older entries are archived in [packages/ai/CHANGELOG.md@1f7329fc2c7c](https://github.com/can1357/oh-my-pi/blob/1f7329fc2c7c366b38731738e0db9c170f9bb348/packages/ai/CHANGELOG.md).

package/dist/types/auth-gateway/types.d.ts

@@ -47,6 +47,11 @@ export interface AuthGatewayParsedRequestOptions {
     reasoning?: Effort;
     /** Force-disable reasoning (Anthropic `thinking: { type: "disabled" }`). */
     disableReasoning?: boolean;
+    /**
+     * Preserve an explicit wire-level reasoning-off request through providers
+     * that distinguish it from the generic disable hint.
+     */
+    forceReasoningOff?: boolean;
     /**
      * Explicit Anthropic `thinking.budget_tokens`. Mirrors Rust's
      * `resolve_thinking_budget`: pins onto whichever effort the client

package/dist/types/auth-storage.d.ts

@@ -1,8 +1,7 @@
 import type { ApiKeyResolver } from "./auth-retry.js";
 import type { OAuthAuthInfo, OAuthController, OAuthCredentials, OAuthPrompt, OAuthProviderId } from "./registry/oauth/types.js";
 import type { Provider } from "./types.js";
-import type { ClientUsageIdentity, ClientUsageReport, ClientUsageSummary, CredentialRankingStrategy, ObservedUsageEntry, UsageHistoryEntry, UsageHistoryQuery, UsageLogger, UsageProvider, UsageReport } from "./usage.js";
-import { type CodexResetConsumeCode, type CodexResetCredit } from "./usage/openai-codex-reset.js";
+import type { ClientUsageIdentity, ClientUsageReport, ClientUsageSummary, CredentialRankingStrategy, ObservedUsageEntry, UsageHistoryEntry, UsageHistoryQuery, UsageLogger, UsageProvider, UsageReport, UsageResetCredit, UsageResetCredits } from "./usage.js";
 export { isSqliteBusyError, isSqliteCorruptionError, SqliteAuthCredentialStore } from "./auth/sqlite-credential-store.js";
 export type ApiKeyCredential = {
     type: "api_key";
@@ -685,14 +684,15 @@ export interface StoredOAuthRefreshResult<T extends OAuthCredential = OAuthCrede
     refreshed: boolean;
     removed: boolean;
 }
-/**
- * Identifies which stored account to redeem a saved rate-limit reset for.
- * Any one field is enough; `credentialId` is the most precise.
- */
+/** A saved-reset option bound to one provider and durable stored credential. */
 export interface ResetCreditTarget {
-    credentialId?: number;
+    provider: string;
+    credentialId: number;
+    /** Grant selected by the caller; a changed offer must be confirmed again. */
+    creditId?: string;
     accountId?: string;
     email?: string;
+    orgId?: string;
 }
 /** Outcome of {@link AuthStorage.redeemResetCredit}. */
 export interface ResetCreditRedeemOutcome {
@@ -706,20 +706,27 @@ export interface ResetCreditRedeemOutcome {
      * retryable, unlike a genuine `no_credit`), `http_<status>` (unexpected
      * HTTP).
      */
-    code: CodexResetConsumeCode;
+    code: string;
+    provider?: string;
     accountId?: string;
     email?: string;
+    orgId?: string;
+    /** Provider explanation for an unavailable or refused reset. */
+    reason?: string;
+    /** Normalized usage limit IDs the provider confirmed it cleared. */
+    cleared?: string[];
     /** The credit that was spent (when one was). */
     creditId?: string;
 }
 /** One stored account's live saved-reset status, from {@link AuthStorage.listResetCredits}. */
-export interface ResetCreditAccountStatus {
-    credentialId?: number;
+export interface ResetCreditAccountStatus extends UsageResetCredits {
+    provider: string;
+    credentialId: number;
     accountId?: string;
     email?: string;
-    /** Resets redeemable for this account right now (live, not cached). */
-    availableCount: number;
-    credits: CodexResetCredit[];
+    orgId?: string;
+    orgName?: string;
+    credits: UsageResetCredit[];
     /** Whether this is the given session's active account. */
     active: boolean;
     /** Set when the account's token refresh or list call failed. */
@@ -858,11 +865,23 @@ export declare class AuthStorage {
      * Check if credentials exist for a provider in storage.
      */
     has(provider: string): boolean;
+    /**
+     * True when the provider has stored credentials but none of them carries
+     * auth — i.e. its only credential is the KDL `empty-fallback` keyless-mode
+     * marker (an empty paste at an optional-key login prompt). Such a provider
+     * is configured-but-keyless: model availability treats it like an
+     * `auth: none` endpoint instead of locking it out (issue #12281).
+     */
+    hasKeylessPlaceholder(provider: string): boolean;
     /**
      * Dedicated auth for default-model availability (picker / `getAvailable`).
      * Unlike {@link getApiKey}, this does not refresh OAuth tokens, and unlike
      * {@link hasResolvableAuth} it ignores cross-provider env aliases so
      * `XAI_API_KEY` does not auto-select SuperGrok (`xai-oauth`).
+     *
+     * A stored keyless-fallback marker (empty paste at an optional-key login)
+     * does not count: it never reaches the wire as a bearer, so treating it as
+     * auth would present the provider as signed-in while requests go out bare.
      */
     hasAuth(provider: string): boolean;
     /**
@@ -1170,16 +1189,7 @@ export declare class AuthStorage {
      * explicit runtime/config API-key override suppresses OAuth.
      */
     getOAuthAccessByCredentialId(provider: string, credentialId: number, options?: AuthApiKeyOptions): Promise<OAuthAccessResolution | undefined>;
-    /**
-     * List saved rate-limit resets for every stored OAuth account of `provider`
-     * (Codex), fetched LIVE from the dedicated `rate-limit-reset-credits` route.
-     *
-     * This deliberately bypasses the usage-report cache: `/wham/usage` is
-     * IP-rate-limited and may serve stale (or pre-feature) snapshots when many
-     * accounts are polled, which would hide redeemable credits. One entry per
-     * account, with the session's active account flagged and unreachable
-     * accounts carrying an `error`.
-     */
+    /** List live saved-reset balances and eligibility for one provider's stored OAuth accounts. */
     listResetCredits(options?: {
         provider?: string;
         sessionId?: string;
@@ -1187,18 +1197,11 @@ export declare class AuthStorage {
         signal?: AbortSignal;
     }): Promise<ResetCreditAccountStatus[]>;
     /**
-     * Redeem one saved rate-limit reset (OpenAI Codex "saved resets") for a
-     * specific stored account.
-     *
-     * Resolves a fresh access token for the target account, picks an available
-     * credit (the given `creditId`, else the first redeemable one), spends it,
-     * and invalidates the cached usage report so the next `/usage` reflects the
-     * reset. Never throws for business outcomes — inspect the returned `code`.
+     * Redeem a stored account's saved reset after checking its live offer.
+     * Business refusals return a code; transport errors may throw without losing Claude's request ID.
      */
     redeemResetCredit(options: {
         target: ResetCreditTarget;
-        provider?: string;
-        creditId?: string;
         baseUrlResolver?: (provider: string) => string | undefined;
         signal?: AbortSignal;
     }): Promise<ResetCreditRedeemOutcome>;

package/dist/types/index.d.ts

@@ -39,6 +39,7 @@ export * from "./stream.js";
 export * from "./types.js";
 export * from "./usage.js";
 export * from "./usage/claude.js";
+export * from "./usage/claude-reset.js";
 export * from "./usage/cursor.js";
 export * from "./usage/gemini.js";
 export * from "./usage/github-copilot.js";

package/dist/types/providers/amazon-bedrock.d.ts

@@ -11,6 +11,13 @@
  */
 import type { Effort } from "@oh-my-pi/pi-catalog/effort";
 import type { StreamFunction, StreamOptions, ThinkingBudgets } from "../types.js";
+/**
+ * Resolve the service-model status for an in-stream exception/error code.
+ * Frame headers carry the bare shape name in either camelCase
+ * (`internalServerException`) or PascalCase (`InternalServerException`); both
+ * normalize to the same map key. Unknown shapes default to 400.
+ */
+export declare function bedrockStreamExceptionStatus(code: string): number;
 export type BedrockThinkingDisplay = "summarized" | "omitted";
 /** Bedrock guardrail trace verbosity, mirrors the Converse `guardrailConfig.trace` values. */
 export type BedrockGuardrailTrace = "enabled" | "disabled" | "enabled_full";

package/dist/types/providers/claude-code-fingerprint.d.ts

@@ -7,12 +7,31 @@
  * `registry` → `registry/oauth/anthropic` → back into the still-initializing
  * provider module.
  */
-/** Current Claude Code CLI version represented on the Anthropic wire. */
-export declare const claudeCodeVersion = "2.1.257";
+/**
+ * Pinned Claude Code CLI version: the offline fallback for {@link getClaudeCodeVersion}.
+ * Bumped to the latest npm release by `bun run check-spoofed-versions --update`.
+ */
+export declare const DEFAULT_CLAUDE_CODE_VERSION = "2.1.280";
 /** `@anthropic-ai/sdk` version bundled by the current Claude Code release. */
 export declare const claudeCodeSdkVersion = "0.112.1";
+/**
+ * Claude Code CLI version represented on the Anthropic wire (User-Agent, billing
+ * header): `PI_AI_CLAUDE_CODE_VERSION` → version adopted from a server rejection
+ * (see {@link adoptRequiredClaudeCodeVersion}) → {@link DEFAULT_CLAUDE_CODE_VERSION}.
+ */
+export declare function getClaudeCodeVersion(): string;
 /** User-Agent emitted by Claude Code's CLI inference entrypoint. */
-export declare const claudeCodeUserAgent = "claude-cli/2.1.257 (external, cli)";
+export declare function getClaudeCodeUserAgent(): string;
+/**
+ * Adopts the minimum version named by an Anthropic `claude_code_version_too_old`
+ * rejection for the rest of the process, so the pinned fallback going stale costs
+ * one rejected request instead of a hard failure.
+ *
+ * Returns true only when the wire version actually increased — callers retry on
+ * true, so a repeated rejection at the same version cannot loop. Always false
+ * while `PI_AI_CLAUDE_CODE_VERSION` pins the version explicitly.
+ */
+export declare function adoptRequiredClaudeCodeVersion(error: unknown): boolean;
 /** Prefix used to isolate custom Anthropic OAuth tools from built-in tools. */
 export declare const claudeToolPrefix: string;
 /** Identity block prepended by Claude Code's CLI runtime. */

package/dist/types/providers/google-gemini-cli.d.ts

@@ -95,9 +95,7 @@ interface CloudCodeAssistRequest {
             temperature?: number;
             topP?: number;
             topK?: number;
-            minP?: number;
             presencePenalty?: number;
-            repetitionPenalty?: number;
             thinkingConfig?: ThinkingConfig;
         };
         tools?: {

package/dist/types/providers/openai-chat-server-schema.d.ts

@@ -1048,7 +1048,7 @@ export declare const openaiChatRequestSchema: import("@oh-my-pi/omptype").Fluent
     prediction?: unknown;
     presence_penalty?: number | undefined;
     prompt_cache_key?: unknown;
-    reasoning_effort?: "high" | "low" | "max" | "medium" | "minimal" | "xhigh" | undefined;
+    reasoning_effort?: "high" | "low" | "max" | "medium" | "minimal" | "none" | "xhigh" | undefined;
     response_format?: unknown;
     safety_identifier?: unknown;
     seed?: number | undefined;
@@ -1263,7 +1263,7 @@ export declare const openaiChatRequestSchema: import("@oh-my-pi/omptype").Fluent
     prediction?: unknown;
     presence_penalty?: number | undefined;
     prompt_cache_key?: unknown;
-    reasoning_effort?: "high" | "low" | "max" | "medium" | "minimal" | "xhigh" | undefined;
+    reasoning_effort?: "high" | "low" | "max" | "medium" | "minimal" | "none" | "xhigh" | undefined;
     response_format?: unknown;
     safety_identifier?: unknown;
     seed?: number | undefined;

package/dist/types/usage/claude-api.d.ts

@@ -0,0 +1,22 @@
+/** Canonical host for Claude's first-party account API. */
+export declare const DEFAULT_CLAUDE_API_BASE_URL = "https://api.anthropic.com";
+/** Canonical subscription usage and profile endpoint. */
+export declare const DEFAULT_CLAUDE_OAUTH_BASE_URL = "https://api.anthropic.com/api/oauth";
+/** OAuth protocol beta required by Claude's account routes. */
+export declare const CLAUDE_OAUTH_BETA = "oauth-2025-04-20";
+/**
+ * Normalize Messages (`/v1`) and OAuth (`/api/oauth`) endpoints to the common
+ * API root used by both usage and reset routes. Custom path prefixes survive.
+ */
+export declare function normalizeClaudeApiBaseUrl(baseUrl?: string): string;
+/** Resolve the OAuth API base while retaining a configured proxy path prefix. */
+export declare function claudeOAuthBaseUrl(baseUrl?: string): string;
+/** Configured OAuth endpoint followed by canonical fallback, without duplicates. */
+export declare function claudeOAuthBaseUrls(baseUrl?: string): readonly string[];
+/** Resolve a first-party account route against the configured Claude API root. */
+export declare function claudeApiUrl(baseUrl: string | undefined, path: string): string;
+/** Shared OAuth and CLI identity headers for Claude usage, profile, and resets. */
+export declare function buildClaudeOAuthHeaders(accessToken: string, options?: {
+    beta?: string;
+    json?: boolean;
+}): Record<string, string>;

package/dist/types/usage/claude-reset.d.ts

@@ -0,0 +1,44 @@
+import type { UsageResetCredit, UsageResetCredits } from "../usage.js";
+import type { FetchImpl } from "../types.js";
+/** OAuth credential and transport used for an account's Claude reset operations. */
+export interface ClaudeResetAuth {
+    accessToken: string;
+    orgId?: string;
+    baseUrl?: string;
+    fetch: FetchImpl;
+    signal?: AbortSignal;
+}
+/** Live reset eligibility plus the exact organization and host used for redemption. */
+export interface ClaudeResetCreditList extends UsageResetCredits {
+    credits: UsageResetCredit[];
+    orgId?: string;
+    /** OAuth API base that answered discovery; pass back as consume `baseUrl`. */
+    baseUrl?: string;
+}
+/** Confirmed reset outcome; transport uncertainty never reports a successful spend. */
+export interface ClaudeResetConsumeResult {
+    ok: boolean;
+    code: string;
+    status: number;
+    cleared?: string[];
+    reason?: string;
+    raw?: unknown;
+}
+/**
+ * Reuse program blocks when a normal usage response actually includes them.
+ * A lone non-redeemable Cedar block is inconclusive because Juniper requires
+ * the separate at-wall read, so callers must still perform discovery.
+ *
+ * @internal
+ */
+export declare function parseClaudeResetCreditsFromUsagePayload(payload: unknown, orgId?: string, baseUrl?: string): ClaudeResetCreditList | null;
+/**
+ * Discover Claude's saved Cedar grant first, then its Juniper session reset.
+ * `null` means discovery failed; a zero-count object is an authoritative answer.
+ */
+export declare function listClaudeResetCredits(auth: ClaudeResetAuth): Promise<ClaudeResetCreditList | null>;
+/** Spend exactly the server-selected Claude reset. Mutation requests are never retried. */
+export declare function consumeClaudeResetCredit(auth: ClaudeResetAuth & {
+    credit: UsageResetCredit;
+    redeemRequestId?: string;
+}): Promise<ClaudeResetConsumeResult>;

package/dist/types/usage.d.ts

@@ -62,11 +62,29 @@ export interface UsageLimit {
  * Per-credit detail for a saved/banked rate-limit reset.
  *
  * Populated when the provider's listing endpoint returns individual credit
- * metadata (e.g. OpenAI Codex `wham/rate-limit-reset-credits`). Callers that
+ * metadata (e.g. OpenAI Codex credits or Claude Cedar grants). Callers that
  * only need the count can ignore this; display layers use `expiresAt` to show
  * when banked resets expire ([#3339](https://github.com/can1357/oh-my-pi/issues/3339)).
  */
 export interface UsageResetCreditDetail {
+    /** Opaque provider credit/grant identifier. */
+    id?: string;
+    /** Human-facing name for the reset. */
+    title?: string;
+    /** Provider reset program/family. */
+    program?: string;
+    /** Resets still banked in this credit/grant. */
+    remainingCount?: number;
+    /** Whether the provider says this credit can be redeemed now. */
+    usable?: boolean;
+    /** Whether redemption requires an exhausted covered limit. */
+    requiresLimit?: boolean;
+    /** Normalized {@link UsageLimit.id}s this credit resets. */
+    clears?: string[];
+    /** Normalized limit ids currently preventing redemption. */
+    blocking?: string[];
+    /** Used fractions for covered limits, keyed by normalized limit id. */
+    usedFractions?: Record<string, number>;
     /** ISO timestamp when the credit was granted. */
     grantedAt?: string;
     /** ISO timestamp when the credit expires and can no longer be redeemed. */
@@ -74,17 +92,31 @@ export interface UsageResetCreditDetail {
     /** Backend status, e.g. `available`, `redeemed`. */
     status?: string;
 }
+/** Reset credit carrying the provider id required by its consume endpoint. */
+export interface UsageResetCredit extends UsageResetCreditDetail {
+    id: string;
+}
 /**
  * Saved/banked rate-limit resets an account can redeem on demand.
  *
  * Surfaced by providers that let users defer a usage-window reset and spend it
- * later (OpenAI Codex "saved rate limit resets"). The redeem itself is a
- * separate, provider-specific action; this is the read-only count for display.
+ * later (OpenAI Codex and Claude Cedar resets). The redeem itself is a
+ * separate, provider-specific action; this is the read-only state for display.
  */
 export interface UsageResetCredits {
-    /** Number of resets available to redeem right now. */
+    /** Number of banked resets, including grants that are not currently usable. */
     availableCount: number;
-    /** Individual credit details (expiry dates, etc.) when the provider exposes them. */
+    /** Number of resets the provider says can be redeemed now. */
+    redeemableCount?: number;
+    /** Provider-selected credit/grant eligible for the next redemption. */
+    nextCreditId?: string;
+    /** Whether this account is eligible for the reset program. */
+    eligible?: boolean;
+    /** Provider reason the program or its credits are unavailable. */
+    reason?: string;
+    /** ISO timestamp until which redemption is cooling down. */
+    cooldownUntil?: string;
+    /** Individual credit details (expiry dates, coverage, etc.) when exposed. */
     credits?: UsageResetCreditDetail[];
 }
 /** Aggregated usage report for a provider. */
@@ -321,28 +353,74 @@ export declare const usageLimitSchema: import("@oh-my-pi/omptype").FluentType<{
     } | undefined;
 }>;
 export declare const usageResetCreditDetailSchema: import("@oh-my-pi/omptype").FluentType<{
+    blocking?: string[] | undefined;
+    clears?: string[] | undefined;
     expiresAt?: string | undefined;
     grantedAt?: string | undefined;
+    id?: string | undefined;
+    program?: string | undefined;
+    remainingCount?: number | undefined;
+    requiresLimit?: boolean | undefined;
     status?: string | undefined;
+    title?: string | undefined;
+    usable?: boolean | undefined;
+    usedFractions?: Record<string, number> | undefined;
 }, {
+    blocking?: string[] | undefined;
+    clears?: string[] | undefined;
     expiresAt?: string | undefined;
     grantedAt?: string | undefined;
+    id?: string | undefined;
+    program?: string | undefined;
+    remainingCount?: number | undefined;
+    requiresLimit?: boolean | undefined;
     status?: string | undefined;
+    title?: string | undefined;
+    usable?: boolean | undefined;
+    usedFractions?: Record<string, number> | undefined;
 }>;
 export declare const usageResetCreditsSchema: import("@oh-my-pi/omptype").FluentType<{
     availableCount: number;
+    cooldownUntil?: string | undefined;
     credits?: {
+        blocking?: string[] | undefined;
+        clears?: string[] | undefined;
         expiresAt?: string | undefined;
         grantedAt?: string | undefined;
+        id?: string | undefined;
+        program?: string | undefined;
+        remainingCount?: number | undefined;
+        requiresLimit?: boolean | undefined;
         status?: string | undefined;
+        title?: string | undefined;
+        usable?: boolean | undefined;
+        usedFractions?: Record<string, number> | undefined;
     }[] | undefined;
+    eligible?: boolean | undefined;
+    nextCreditId?: string | undefined;
+    reason?: string | undefined;
+    redeemableCount?: number | undefined;
 }, {
     availableCount: number;
+    cooldownUntil?: string | undefined;
     credits?: {
+        blocking?: string[] | undefined;
+        clears?: string[] | undefined;
         expiresAt?: string | undefined;
         grantedAt?: string | undefined;
+        id?: string | undefined;
+        program?: string | undefined;
+        remainingCount?: number | undefined;
+        requiresLimit?: boolean | undefined;
         status?: string | undefined;
+        title?: string | undefined;
+        usable?: boolean | undefined;
+        usedFractions?: Record<string, number> | undefined;
     }[] | undefined;
+    eligible?: boolean | undefined;
+    nextCreditId?: string | undefined;
+    reason?: string | undefined;
+    redeemableCount?: number | undefined;
 }>;
 export declare const usageReportSchema: import("@oh-my-pi/omptype").FluentType<{
     fetchedAt: number;
@@ -384,11 +462,25 @@ export declare const usageReportSchema: import("@oh-my-pi/omptype").FluentType<{
     raw?: unknown;
     resetCredits?: {
         availableCount: number;
+        cooldownUntil?: string | undefined;
         credits?: {
+            blocking?: string[] | undefined;
+            clears?: string[] | undefined;
             expiresAt?: string | undefined;
             grantedAt?: string | undefined;
+            id?: string | undefined;
+            program?: string | undefined;
+            remainingCount?: number | undefined;
+            requiresLimit?: boolean | undefined;
             status?: string | undefined;
+            title?: string | undefined;
+            usable?: boolean | undefined;
+            usedFractions?: Record<string, number> | undefined;
         }[] | undefined;
+        eligible?: boolean | undefined;
+        nextCreditId?: string | undefined;
+        reason?: string | undefined;
+        redeemableCount?: number | undefined;
     } | undefined;
 }, {
     fetchedAt: number;
@@ -430,11 +522,25 @@ export declare const usageReportSchema: import("@oh-my-pi/omptype").FluentType<{
     raw?: unknown;
     resetCredits?: {
         availableCount: number;
+        cooldownUntil?: string | undefined;
         credits?: {
+            blocking?: string[] | undefined;
+            clears?: string[] | undefined;
             expiresAt?: string | undefined;
             grantedAt?: string | undefined;
+            id?: string | undefined;
+            program?: string | undefined;
+            remainingCount?: number | undefined;
+            requiresLimit?: boolean | undefined;
             status?: string | undefined;
+            title?: string | undefined;
+            usable?: boolean | undefined;
+            usedFractions?: Record<string, number> | undefined;
         }[] | undefined;
+        eligible?: boolean | undefined;
+        nextCreditId?: string | undefined;
+        reason?: string | undefined;
+        redeemableCount?: number | undefined;
     } | undefined;
 }>;
 /** Optional logger for usage fetchers. */

package/dist/types/utils/schema/json-schema-validator.d.ts

@@ -16,7 +16,10 @@ export interface JsonSchemaValidationResult {
     success: boolean;
     issues: JsonSchemaValidationIssue[];
 }
+/** The unique discriminator-selected branch, or undefined when selection is ambiguous or absent. */
+export declare function getTagSelectedUnionBranch(branches: readonly unknown[], value: unknown): unknown;
 /** Whether any same-instance schema declaration or constraint owns this property name. */
 export declare function schemaDefinesProperty(schema: unknown, key: string): boolean;
-export declare function validateJsonSchemaValue(schema: unknown, value: unknown): JsonSchemaValidationResult;
-export declare function isJsonSchemaValueValid(schema: unknown, value: unknown): boolean;
+export declare function validateJsonSchemaValue(schema: unknown, value: unknown, root?: unknown): JsonSchemaValidationResult;
+/** Validate a subschema using its complete schema's local-reference context. */
+export declare function isJsonSchemaValueValid(schema: unknown, value: unknown, root?: unknown): boolean;

package/dist/types/utils/tool-call-loop-guard.d.ts

@@ -21,6 +21,6 @@ export interface RepeatedToolCallDetection {
 export declare class ToolCallLoopGuard {
     #private;
     constructor(options: ToolCallLoopGuardOptions);
-    /** Records one completed turn and returns the threshold hit, if any. */
+    /** Records one completed turn and reports repetitions at or beyond the threshold. */
     recordTurn(turn: ToolCallLoopTurn): RepeatedToolCallDetection | null;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-ai",
-	"version": "18.2.8",
+	"version": "18.2.9",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"keywords": [
 		"ai",
@@ -152,11 +152,11 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/omptype": "18.2.8",
-		"@oh-my-pi/pi-catalog": "18.2.8",
-		"@oh-my-pi/pi-natives": "18.2.8",
-		"@oh-my-pi/pi-utils": "18.2.8",
-		"@oh-my-pi/pi-wire": "18.2.8"
+		"@oh-my-pi/omptype": "18.2.9",
+		"@oh-my-pi/pi-catalog": "18.2.9",
+		"@oh-my-pi/pi-natives": "18.2.9",
+		"@oh-my-pi/pi-utils": "18.2.9",
+		"@oh-my-pi/pi-wire": "18.2.9"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"