@oh-my-pi/pi-ai 18.3.5 → 18.4.0

package/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 ## [Unreleased]
 
+## [18.4.0] - 2026-09-28
+
+### Breaking Changes
+
+- Changed `LimitsApi.rotate()` to return a `CredentialRotation` object (`{ switched, afterSiblingWait? }`) instead of a boolean. Check `.switched` explicitly, since the returned object is always truthy.
+
+### Added
+
+- Added image metadata to hosted OpenAI image-generation results, including the model used and each generated image’s dimensions and quality.
+
+### Changed
+
+- Redesigned the browser page displayed during OAuth login.
+
+### Fixed
+
+- Fixed Anthropic accounts remaining blocked after quota resets, including for broker-connected clients, while preserving independent authentication and model-limit restrictions.
+- Fixed concurrent usage refreshes repeatedly probing providers after failures, reducing unnecessary usage-endpoint requests.
+- Fixed Gemini and Antigravity usage and cost reporting when upstream responses omit prompt-token counts or report more cached tokens than prompt tokens.
+- Fixed credential failover after authentication errors so stored credentials rotate through every distinct sibling instead of stopping after one attempt; rotation can also wait briefly for a temporarily blocked healthy sibling to become available.
+- Fixed native judge responses without token counts producing invalid usage and cost values.
+- Fixed Cursor usage, cost, and context accounting to include final input, cache, reasoning, and output metrics, improving compaction and handoff sizing.
+- Fixed Cursor MCP tool calls routed through external executors being returned as text instead of tool calls.
+- Fixed Cursor shell-tool timeouts being displayed in milliseconds rather than seconds.
+- Fixed fetch requests over Unix sockets when `PI_PROXY` is configured.
+- Fixed Ollama chat turns being recorded with zero cost; usage is now priced using the model’s cost information.
+- Fixed Anthropic requests failing after native compaction when per-message effort settings were present; effort controls are now handled correctly with compaction.
+
 ## [18.3.5] - 2026-09-27
 
 ### Breaking Changes
@@ -2276,51 +2304,4 @@
 - Fixed explicit request-debug mode to overwrite existing `.res.log` files for the requested path instead of failing when they already exist
 - Fixed OpenAI Responses `previous_response_id` chaining on Zero Data Retention orgs: the in-provider retry classifier missed the ZDR-specific 400 ("Previous response cannot be used for this organization due to Zero Data Retention"), so chained turns kept failing every other request after a brief recovery — the chain was reset but not disabled, so the next successful full-replay turn re-armed it. The ZDR phrasing is now classified categorically: one strike disables chaining for the session (skipping the three-strike circuit breaker) and the in-call retry drops `store: true`/`previous_response_id` and replays the full transcript instead ([#2341](https://github.com/can1357/oh-my-pi/issues/2341)).
 
-## [15.11.4] - 2026-06-12
-
-### Added
-
-- Codex/Responses providers now map `end_turn: false` on the terminal stream event (Codex backend signal for "response ended, turn didn't" — commentary-only progress updates) to `stopDetails: { type: "pause_turn" }` with stopReason `"stop"`, so the agent loop can re-sample instead of ending the turn. Wired in `openai-codex-responses` and `processResponsesStream` (`openai-responses`/`azure-openai-responses`); inert for backends that never send the field.
-- Added Codex upstream protocol features to `openai-codex-responses` (tracking codex-rs as of June 2026): `onModerationMetadata` callback surfacing `response.metadata` → `openai_chatgpt_moderation_metadata` on both transports; `reasoningContext` option emitting `reasoning.context` (`auto`/`current_turn`/`all_turns`); `clientMetadata` option emitting `client_metadata` in the request body (canonical `x-codex-turn-metadata` envelope) without breaking the websocket append fast-path; and an opt-in `responsesLite` mode mirroring codex-rs — lite header on HTTP requests and the websocket upgrade, `ws_request_header_*` marker in `response.create` client metadata, lite-keyed socket pooling, image-detail stripping, forced serial tool calls, and `reasoning.context: all_turns` default. Dormant until OpenAI flips `use_responses_lite` in the model catalog.
-- Added `withOAuthAccess` — the `withAuth` counterpart for OAuth-access consumers: runs an operation through the central a/b/c auth-retry policy (resolve → force-refresh same account → rotate to a sibling) while handing the attempt the full `OAuthAccess` (bearer plus `accountId`/`projectId`/`enterpriseUrl` identity metadata). Use it instead of hand-rolled `getOAuthAccess` + fetch flows so 401s and usage-limits rotate credentials instead of failing the call.
-- Added `ProviderHttpError` — a typed HTTP error carrying `status`, `headers`, and `code` — replacing the ad-hoc `as Error & { status?... }` / `Object.assign` hacks at provider throw sites, with per-provider subclasses `CodexApiError`, `AuthGatewayError`, `GoogleApiError`, `GeminiCliApiError`, `OllamaApiError`, and `BedrockApiError`; `AnthropicApiError` now extends it. Google, Gemini CLI, Ollama, and Bedrock HTTP errors now also carry response headers, so server-suggested `retry-after` delays are visible to retry classification on those paths. The internal `withHttpStatus` helper was removed.
-- Added stateful SSE turn chaining for OpenAI Codex (on by default; disable with `PI_CODEX_STATEFUL=0` or `statefulResponses: false`): SSE requests now reuse `previous_response_id` with delta-only input instead of replaying the full transcript, mirroring the websocket fast-path via a shared transport-aware builder. Any history mutation or option change falls back to a full replay; a server-side `previous_response_not_found` (HTTP or in-stream) resets the chain and retries the turn with full context, and three consecutive stale failures disable chaining for the session.
-- Added stateful `previous_response_id` chaining to the platform OpenAI Responses provider (`openai-responses`): on by default against the official api.openai.com endpoint (forces `store: true`, which chaining requires), off for other Responses endpoints; override with `statefulResponses` or `PI_OPENAI_STATEFUL`. Chain detection compares the wire form of the conversation arguments alone — per-turn trailing scaffolding such as the GPT-5 "Juice: 0" developer item is excluded from the append-baseline prefix check and re-appended to the delta — and a rejected/stale previous response falls back to a one-shot full replay with the same circuit breaker.
-- Added `AuthStorage.getOAuthAccountIdentity()` and the `OAuthAccountIdentity` type — a read-only lookup returning the `accountId`/`email`/`projectId` of the OAuth credential a session is currently routed to, for display and metadata paths.
-
-### Changed
-
-- The GPT-5 "Juice: 0" no-reasoning developer item in `applyResponsesReasoningParams` is now gated on the resolved `compat.requiresJuiceZeroHack` flag (auto-detected from GPT-5-family model names by `@oh-my-pi/pi-catalog`, overridable per model) instead of an inline model-name check.
-
-### Fixed
-
-- Fixed websocket append fast-path to remain usable when only `client_metadata` changes between turns
-- Fixed `onModerationMetadata` handling so exceptions thrown by callback observers no longer terminate the response stream
-- Fixed local SQLite OAuth credential caches returning a stale Anthropic access token after another `omp` process refreshed and persisted the same row. `AuthStorage` now syncs the selected row from storage before returning or force-refreshing OAuth credentials, so concurrent sessions pick up peer-rotated tokens instead of surfacing a one-turn `401 Invalid authentication credentials`.
-- Fixed forced OAuth preflight refresh failures being swallowed silently in credential selection; they now emit a debug log (`OAuth preflight refresh failed`) so stale-refresh-token replays from concurrent sessions are diagnosable.
-
-## [15.11.3] - 2026-06-11
-
-### Fixed
-
-- Fixed GitHub Copilot long-context model requests to use the upstream `requestModelId` when calling Anthropic, OpenAI Responses, and OpenAI Completions APIs
-- Fixed GitHub Copilot model enablement to deduplicate catalog variants by upstream model ID when enabling all models
-
-## [15.11.2] - 2026-06-11
-
-### Fixed
-
-- Fixed Anthropic encoding of error tool results with whitespace-only content so requests no longer 400 with `tool_result: content cannot be empty if is_error is true`
-
-## [15.11.1] - 2026-06-11
-
-### Changed
-
-- Exported `resolveAnthropicMetadataUserId` so non-streaming Anthropic Messages consumers (e.g. the coding-agent web search provider) can produce the same Claude-Code-shaped `metadata.user_id` as the main streaming path.
-
-### Fixed
-
-- Preserved Anthropic `stop_details` on assistant messages so refusal and sensitive classifier stops remain structurally visible to callers. ([#2290](https://github.com/can1357/oh-my-pi/issues/2290))
-- Fixed OpenAI Responses, Azure OpenAI Responses, and OpenAI Completions streams hanging until the 120s idle watchdog errored the turn when a provider delivers the terminal frame but never sends `[DONE]` nor closes the connection. `processResponsesStream` now breaks out of the event loop on `response.completed`/`response.incomplete` (mirroring the Codex websocket/SSE terminal break), and the completions consumer breaks once `finish_reason` plus a usage payload arrived — or, for hosts that never send usage, ends the stream cleanly via a short post-finish grace window (`iterateWithTerminalGrace`) that aborts the transport to release the socket.
-
-Older entries are archived in [packages/ai/CHANGELOG.md@d58593a30902](https://github.com/can1357/oh-my-pi/blob/d58593a3090258473304608d68ffd1f620e6b695/packages/ai/CHANGELOG.md).
+Older entries are archived in [packages/ai/CHANGELOG.md@dfbf3cc34eeb](https://github.com/can1357/oh-my-pi/blob/dfbf3cc34eeb5653580f51bfbcae558a9840f697/packages/ai/CHANGELOG.md).

package/dist/types/auth/blocks.d.ts

@@ -11,6 +11,10 @@ export declare const DEFAULT_BLOCK_MS = 60000;
 export declare function providerTypeKey(provider: string, type: AuthCredential["type"]): string;
 /** Scoped backoff map key used by the credential block store. */
 export declare function scopedBackoffKey(providerKey: string, blockScope: string | undefined): string;
+/** Authentication backoffs apply to every model and cannot be healed by quota evidence. */
+export declare const AUTH_BLOCK_SCOPE = "auth";
+/** Account-policy backoffs apply to every model and survive quota resets. */
+export declare const ACCOUNT_POLICY_BLOCK_SCOPE = "account-policy";
 /** Scope key for one model-specific account-policy block, shared by selectors and rate limits. */
 export declare function modelAccountPolicyBlockScope(provider: string, modelId: string | undefined): string | undefined;
 /** Scope keys that a request must check, including model-policy constraints. */
@@ -67,26 +71,15 @@ export declare class CredentialBlocks implements BlocksApi {
      * that `markUsageLimitReached` set for the now-obsolete reset time.
      */
     clearAll(provider: string, credentialId: number): void;
-    /**
-     * Clear one backoff scope. The in-memory backoff is per scope so it is
-     * dropped directly; the persisted store deletes a credential's blocks as a
-     * unit, so it is only purged once no other scope still holds a live block.
-     * Leaving a persisted row behind is safe: the scope it belongs to is
-     * unblocked in memory, and the row heals on the pass where its own meter
-     * recovers.
-     */
-    clearScope(provider: string, credentialId: number, providerKey: string, blockScope: string | undefined): void;
+    /** Clear exactly one quota scope, preserving unrelated account and model blocks. */
+    clearScope(provider: string, credentialId: number, providerKey: string, blockScope: string | undefined): boolean;
     /** Providers whose stale usage-limit blocks a healthy live report may clear. */
     supportsHealing(provider: Provider): boolean;
     /**
      * Whether a fresh report could lift what currently blocks this credential.
      *
-     * A strategy that names healable scopes can only vouch for those scopes, so
-     * a live unscoped block — an Opus/Sonnet usage limit, a refresh failure —
-     * keeps the credential unusable whatever the report says about a tier. A
-     * probe then cannot change the outcome and must not be spent; the tier scope
-     * heals on a later pass, once the block that actually holds the credential
-     * has lifted.
+     * Claude reports can heal legacy account-wide quota blocks too. Explicit
+     * auth/account-policy blocks never justify a usage probe.
      */
     canHeal(provider: Provider, providerKey: string, credentialIndex: number, blockScopeOrScopes: string | readonly string[] | undefined): boolean;
     /**
@@ -107,9 +100,7 @@ export declare class CredentialBlocks implements BlocksApi {
      * Broker-server seam: persist one credential block and notify snapshot waiters.
      */
     upsert(block: StoredCredentialBlock): void;
-    /**
-     * Broker-server seam: clear all persisted blocks for one credential and notify snapshot waiters.
-     */
-    delete(credentialId: number, providerKey: string, blockScope: string): void;
+    /** Broker-server seam: clear exactly one persisted and local block and notify snapshot waiters. */
+    delete(credentialId: number, providerKey: string, blockScope: string, invalidateUsage?: boolean): void;
     deleteAll(credentialId: number): void;
 }

package/dist/types/auth/cascade.d.ts

@@ -1,4 +1,4 @@
-import type { ApiKeyResolver, ResolvedApiKey } from "../auth-retry.js";
+import { type ApiKeyResolver, type ResolvedApiKey } from "../auth-retry.js";
 import type { SessionAffinity } from "./affinity.js";
 import type { CredentialPool } from "./pool.js";
 import type { CredentialSelector } from "./select.js";

package/dist/types/auth/rotation.d.ts

@@ -5,7 +5,7 @@ import type { KeyOverrides } from "./cascade.js";
 import type { SessionAffinity } from "./affinity.js";
 import type { CredentialPool } from "./pool.js";
 import type { AuthCredentialStore } from "./store.js";
-import type { InvalidateCredentialMatchingOptions, LimitsApi, MarkUsageLimitOptions, RotateCredentialOptions, UsageLimitMarkResult } from "./types.js";
+import type { CredentialRotation, InvalidateCredentialMatchingOptions, LimitsApi, MarkUsageLimitOptions, RotateCredentialOptions, UsageLimitMarkResult } from "./types.js";
 import type { UsageService } from "./usage.js";
 /** Routing scope and strategy for one failed credential. */
 export type CredentialBlockRouting = {
@@ -60,7 +60,10 @@ export declare class RateLimits implements LimitsApi {
      *   reload when no broker hook is wired) and block it, then drop matching
      *   sticky state.
      *
-     * Returns whether another usable credential of the same type remains.
+     * For usage-limit and account-policy failures with no free sibling, sleeps
+     * until the earliest sibling unblocks when that is at most
+     * {@link SIBLING_UNBLOCK_WAIT_MAX_MS} away, then reports `afterSiblingWait`.
+     * Aborting `options.signal` during that wait rejects.
      */
-    rotate(provider: string, sessionId: string | undefined, options?: RotateCredentialOptions): Promise<boolean>;
+    rotate(provider: string, sessionId: string | undefined, options?: RotateCredentialOptions): Promise<CredentialRotation>;
 }

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

@@ -564,6 +564,10 @@ export interface ResetCreditRedeemOutcome {
 /** One stored account's live saved-reset status, from {@link AuthStorage.resets.list}. */
 export interface ResetCreditAccountStatus extends UsageResetCredits {
     provider: string;
+    /** Live quota evidence from this exact account's reset-discovery response. */
+    report?: UsageReport;
+    /** Provider-requested wait before retrying throttled reset discovery (not redemption). */
+    retryAfterMs?: number;
     credentialId: number;
     accountId?: string;
     email?: string;
@@ -627,6 +631,20 @@ export type RotateCredentialOptions = {
     credentialId?: number;
     signal?: AbortSignal;
 };
+/**
+ * Outcome of {@link LimitsApi.rotate}.
+ *
+ * `switched` is `true` when a usable same-type sibling credential is available,
+ * so the caller's next resolve hands it out. `afterSiblingWait` is `true` when
+ * no sibling was free at the failure but rotation slept out a sibling's short
+ * block (e.g. a Cloud Code Assist capacity 429 that resets in under a second);
+ * the freed credential may be one the caller already sent in this request, so
+ * attempted-bearer dedupe must let it through once.
+ */
+export interface CredentialRotation {
+    switched: boolean;
+    afterSiblingWait?: boolean;
+}
 /** Filter saved reset credits by provider and session. */
 export type ListResetCreditsOptions = {
     provider?: string;
@@ -1107,9 +1125,11 @@ export interface LimitsApi {
      *   reload when no broker hook is wired) and block it, then drop matching
      *   sticky state.
      *
-     * Returns whether another usable credential of the same type remains.
+     * For usage-limit and account-policy failures with no free sibling, waits
+     * (abortable via `options.signal`) when a sibling's block expires within a
+     * few seconds, then reports `afterSiblingWait`.
      */
-    rotate(provider: string, sessionId: string | undefined, options?: RotateCredentialOptions): Promise<boolean>;
+    rotate(provider: string, sessionId: string | undefined, options?: RotateCredentialOptions): Promise<CredentialRotation>;
     /** Invalidate a credential matching an API key after authentication failure. */
     invalidateMatching(provider: string, apiKey: string, options?: InvalidateCredentialMatchingOptions): Promise<boolean>;
 }
@@ -1134,7 +1154,7 @@ export interface BlocksApi {
      */
     upsert(block: StoredCredentialBlock): void;
     /**
-     * Broker-server seam: clear all persisted blocks for one credential and notify snapshot waiters.
+     * Broker-server seam: clear one exact persisted block and notify snapshot waiters.
      */
     delete(credentialId: number, providerKey: string, blockScope: string): void;
     /** Delete all persisted blocks for a credential. */

package/dist/types/auth/usage-cache.d.ts

@@ -8,8 +8,8 @@ export declare const USAGE_HEADER_INGEST_INTERVAL_MS = 60000;
 /**
  * Per-credential cool-down after a usage fetch fails. While this window is
  * active we serve the last successful value to avoid dropping the credential
- * from the report; without a previous value we just return null and retry
- * on the next poll. Used by UsageService.
+ * from the report; without a previous value we return null until the
+ * cooldown expires. Report invalidation does not bypass this cooldown.
  */
 export declare const USAGE_FAILURE_BACKOFF_MS = 10000;
 /** Default usage fetch timeout; used by the AuthStorage facade. */
@@ -44,6 +44,16 @@ export declare class UsageCache {
     constructor(store: AuthCredentialStore, pool: CredentialPool, usageProviders: (provider: Provider) => UsageProvider | undefined);
     get epoch(): number;
     bumpEpoch(): void;
+    /** Identifies confirmed recoveries that supersede an in-flight failed probe. */
+    recoveryEpoch(provider: Provider): number;
+    /**
+     * Changes when a user refresh, confirmed reset, or usage-implementation swap
+     * makes an in-flight probe too old to answer. Block marks do not change it:
+     * they stop a racing report from being cached, never trigger a re-probe.
+     */
+    refreshEpoch(provider: Provider): number;
+    /** Failure cooldowns survive report invalidation and process restarts. */
+    failureKey(reportKey: string): string;
     get<T>(key: string): UsageCacheEntry<T> | undefined;
     getStale<T>(key: string): UsageCacheEntry<T> | undefined;
     set<T>(key: string, entry: UsageCacheEntry<T>): void;
@@ -58,6 +68,8 @@ export declare class UsageCache {
      * `/usage` reflects a freshly-redeemed reset instead of stale numbers.
      */
     invalidate(provider: string, baseUrl?: string): void;
+    /** A confirmed reset permits one fresh probe even during a pre-reset failure cooldown. */
+    invalidateAfterReset(provider: Provider, baseUrl?: string): void;
     /**
      * Expire cached reports for a provider after its runtime usage implementation changes.
      * This keeps a newly installed extension provider from serving a built-in snapshot.

package/dist/types/auth/usage.d.ts

@@ -102,8 +102,8 @@ export declare class UsageService implements UsageApi {
     }): Promise<UsageReport[] | null>;
     /**
      * Discard cached usage reports before a user-requested refresh. The next
-     * read probes upstream serially per provider; a failure reports no fresh
-     * usage instead of replaying an invalidated last-good snapshot.
+     * read probes upstream serially per provider unless a failure cooldown is
+     * active. Failed probes never replay an invalidated last-good snapshot.
      */
     invalidate(provider?: string, signal?: AbortSignal): Promise<void>;
 }

package/dist/types/auth-broker/client.d.ts

@@ -6,7 +6,7 @@
  * `/v1/healthz` require a bearer token.
  */
 import type { AuthCredential, DisabledCredentialSummary } from "../auth-storage.js";
-import type { ClientUsageReportRequest, ClientUsageReportResponse, ClientUsageSummaryResponse, CredentialBlockRequest, CredentialBlockResponse, CredentialBlocksDeleteResponse, CredentialDisableResponse, CredentialRefreshResponse, CredentialUploadResponse, HealthzResponse, SnapshotResponse, SnapshotStreamEvent, UsageHistoryResponse, UsageResponse, UsageStaleResponse } from "./types.js";
+import type { ClientUsageReportRequest, ClientUsageReportResponse, ClientUsageSummaryResponse, CredentialBlockDeleteRequest, CredentialBlockRequest, CredentialBlockResponse, CredentialBlocksDeleteResponse, CredentialDisableResponse, CredentialRefreshResponse, CredentialUploadResponse, HealthzResponse, SnapshotResponse, SnapshotStreamEvent, UsageHistoryResponse, UsageResponse, UsageStaleResponse } from "./types.js";
 export interface AuthBrokerClientOptions {
     /** Base URL (e.g. `https://broker.tailnet:8765`). Trailing slashes are trimmed. */
     url: string;
@@ -96,5 +96,6 @@ export declare class AuthBrokerClient {
     listDisabledCredentials(provider?: string, signal?: AbortSignal): Promise<DisabledCredentialSummary[]>;
     uploadCredential(provider: string, credential: AuthCredential, signal?: AbortSignal): Promise<CredentialUploadResponse>;
     upsertCredentialBlock(id: number, block: CredentialBlockRequest, signal?: AbortSignal): Promise<CredentialBlockResponse>;
+    deleteCredentialBlock(id: number, block: CredentialBlockDeleteRequest, signal?: AbortSignal): Promise<CredentialBlocksDeleteResponse>;
     deleteCredentialBlocks(id: number, signal?: AbortSignal): Promise<CredentialBlocksDeleteResponse>;
 }

package/dist/types/auth-broker/remote-store.d.ts

@@ -76,7 +76,7 @@ export declare class RemoteAuthCredentialStore implements AuthCredentialStore {
     getCredentialBlockReconcileAfter(credentialId: number, providerKey: string, blockScope: string): number | undefined;
     listCredentialBlocks(credentialIds: readonly number[]): StoredCredentialBlock[];
     upsertCredentialBlock(block: StoredCredentialBlock): void;
-    deleteCredentialBlock(_credentialId: number, _providerKey: string, _blockScope: string): void;
+    deleteCredentialBlock(credentialId: number, providerKey: string, blockScope: string): void;
     deleteCredentialBlocks(credentialId: number): void;
     cleanExpiredCredentialBlocks(nowMs: number): void;
     /**
@@ -131,9 +131,8 @@ export declare class RemoteAuthCredentialStore implements AuthCredentialStore {
     refreshOAuthCredential(_provider: Provider, credentialId: number, _credential: OAuthCredential, signal?: AbortSignal): Promise<OAuthCredentials>;
     /**
      * Store-level hook consumed by `AuthStorage.usage.reports()` — proxies
-     * to the broker's `/v1/usage` endpoint. The broker's egress IP isn't
-     * rate-limited by Anthropic's per-IP `/usage` cap the way a heavy
-     * residential laptop is, so all credentials surface every cycle.
+     * to the broker's `/v1/usage` endpoint. Shared per-credential caches and
+     * cooldowns keep separate clients from multiplying provider probes.
      */
     fetchUsageReports(signal?: AbortSignal): Promise<UsageReport[] | null>;
     /**
@@ -142,8 +141,8 @@ export declare class RemoteAuthCredentialStore implements AuthCredentialStore {
      * same response (coalesced + cached), then overlays any client-observed
      * header hints for the matching credential.
      *
-     * The broker already aggregates with its own 30s TTL on the server side; our
-     * 15s client TTL is below that so we usually re-use the broker's cache too.
+     * The broker caches each credential independently; the short client TTL
+     * also folds sequential consumers into one broker round-trip.
      */
     getUsageReport(provider: Provider, credential: OAuthCredential, signal?: AbortSignal): Promise<UsageReport | null>;
     ingestUsageReport(provider: Provider, credential: OAuthCredential, report: UsageReport): boolean;

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

@@ -73,11 +73,13 @@ export interface DisabledCredentialsResponse {
 }
 /** POST /v1/credential/:id/block request body. */
 export type CredentialBlockRequest = CredentialBlockSnapshot;
+/** DELETE /v1/credential/:id/block request body; empty scope targets only the global row. */
+export type CredentialBlockDeleteRequest = Pick<CredentialBlockSnapshot, "providerKey" | "blockScope">;
 /** POST /v1/credential/:id/block response body. */
 export interface CredentialBlockResponse {
     ok: boolean;
 }
-/** DELETE /v1/credential/:id/blocks response body. */
+/** DELETE /v1/credential/:id/block or /blocks response body. */
 export interface CredentialBlocksDeleteResponse {
     ok: boolean;
 }

package/dist/types/auth-broker/wire-schemas.d.ts

@@ -14,7 +14,7 @@
  */
 import { type FluentType } from "@oh-my-pi/omptype";
 import { type ApiKeyCredential, type AuthCredential, type AuthCredentialSnapshotEntry, type DisabledCredentialSummary, type OAuthCredential, type RemoteOAuthCredential, type SnapshotCredential } from "../auth-storage.js";
-import type { ClientUsageReportRequest, ClientUsageReportResponse, ClientUsageSummaryResponse, CredentialBlockRequest, CredentialBlockResponse, CredentialBlockSnapshot, CredentialBlocksDeleteResponse, CredentialDisableResponse, CredentialRefreshResponse, CredentialUploadRequest, CredentialUploadResponse, DisabledCredentialsResponse, HealthzResponse, RefresherSchedule, SnapshotEntry, SnapshotResponse, SnapshotStreamEntryEvent, SnapshotStreamEvent, SnapshotStreamRemovedEvent, SnapshotStreamSnapshotEvent, UsageHistoryResponse, UsageResponse, UsageStaleResponse } from "./types.js";
+import type { ClientUsageReportRequest, ClientUsageReportResponse, ClientUsageSummaryResponse, CredentialBlockDeleteRequest, CredentialBlockRequest, CredentialBlockResponse, CredentialBlockSnapshot, CredentialBlocksDeleteResponse, CredentialDisableResponse, CredentialRefreshResponse, CredentialUploadRequest, CredentialUploadResponse, DisabledCredentialsResponse, HealthzResponse, RefresherSchedule, SnapshotEntry, SnapshotResponse, SnapshotStreamEntryEvent, SnapshotStreamEvent, SnapshotStreamRemovedEvent, SnapshotStreamSnapshotEvent, UsageHistoryResponse, UsageResponse, UsageStaleResponse } from "./types.js";
 /** Real OAuth credential (broker-side) — refresh token is the actual upstream value. */
 export declare const oauthCredentialSchema: FluentType<OAuthCredential>;
 /** OAuth credential as it appears in broker snapshots — refresh replaced with sentinel. */
@@ -62,6 +62,7 @@ export declare const disabledCredentialSummarySchema: FluentType<DisabledCredent
 /** Broker `GET /v1/credentials/disabled` response. */
 export declare const disabledCredentialsResponseSchema: FluentType<DisabledCredentialsResponse>;
 export declare const credentialBlockRequestSchema: FluentType<CredentialBlockRequest>;
+export declare const credentialBlockDeleteRequestSchema: FluentType<CredentialBlockDeleteRequest>;
 export declare const credentialBlockResponseSchema: FluentType<CredentialBlockResponse>;
 export declare const credentialBlocksDeleteResponseSchema: FluentType<CredentialBlocksDeleteResponse>;
 export declare const usageStaleResponseSchema: FluentType<UsageStaleResponse>;

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

@@ -13,10 +13,10 @@ import { isAuthRetryableError } from "./error/auth-classify.js";
  * - `error !== undefined && lastChance` → **step (c): switch account**
  *   (invalidate/usage-limit the current credential and rotate to a sibling).
  *
- * Current drivers preserve that bounded a/b/c sequence for ordinary 401/auth
- * failures. Account-scoped policy denials, 403s, and usage-limit failures skip
- * refresh and may repeat step (c) until the resolver returns `undefined`,
- * cycles, or hits {@link AUTH_RETRY_MAX_ATTEMPTS}.
+ * Current drivers give an ordinary 401/auth failure one step (b) before
+ * repeating step (c) through distinct siblings. Account-scoped policy denials,
+ * 403s, and usage-limit failures skip refresh. Rotation stops when the resolver
+ * returns `undefined`, cycles, or hits {@link AUTH_RETRY_MAX_ATTEMPTS}.
  */
 export interface ApiKeyResolveContext {
     /** True when the resolver should rotate to a sibling credential. */
@@ -36,11 +36,23 @@ export interface ResolvedApiKey {
     apiKey: string;
     /** Durable row id of the credential that supplied this bearer, when known. */
     credentialId?: number;
+    /**
+     * Resolved after `LimitsApi.rotate` slept out a sibling's short block
+     * (`afterSiblingWait`): the driver accepts this bearer even if the request
+     * already sent it before that block.
+     */
+    afterSiblingWait?: boolean;
 }
 export type ApiKeyResolution = string | ResolvedApiKey | undefined;
 export type ApiKeyResolver = (ctx: ApiKeyResolveContext) => Promise<ApiKeyResolution> | ApiKeyResolution;
 /** Extract the bearer while preserving optional credential provenance for streaming callers. */
 export declare function resolvedApiKeyBearer(resolved: ApiKeyResolution): string | undefined;
+/**
+ * Mark a post-rotation resolution as following a sibling-unblock wait so the
+ * retry driver may resend a bearer it already tried. Used by the rotating
+ * resolvers (`KeyCascade.resolver`, coding-agent `createApiKeyResolver`).
+ */
+export declare function markAfterSiblingWait(resolved: ApiKeyResolution): ApiKeyResolution;
 /** A static bearer string, or a {@link ApiKeyResolver} that mints/rotates one. */
 export type ApiKey = string | ApiKeyResolver;
 /** Keyless-provider credential marker; transports must not send it in authentication headers. */
@@ -63,9 +75,8 @@ export declare function resolveApiKeyOnce(key: ApiKey | undefined, signal?: Abor
 export declare function seedApiKeyResolver(seed: ApiKeyResolution, resolver: ApiKeyResolver): ApiKeyResolver;
 export { isAuthRetryableError };
 /**
- * Legacy bounded a/b/c retry sequence retained for public compatibility:
- * `false` → refresh-same, `true` → rotate/switch. Current drivers consume it
- * once for ordinary 401/auth failures; usage/account-limit failures may repeat
+ * Legacy a/b/c retry sequence retained for public compatibility:
+ * `false` → refresh-same, `true` → rotate/switch. Current drivers may repeat
  * sibling rotation until a termination guard fires.
  */
 export declare const AUTH_RETRY_STEPS: readonly boolean[];
@@ -79,8 +90,6 @@ export interface AuthRetryKeyState {
     lastKey: string;
     /** Whether the current credential already consumed its 401 refresh-same retry. */
     refreshedCurrent: boolean;
-    /** Whether the legacy non-usage auth path already switched to one sibling. */
-    legacyAuthSwitchUsed: boolean;
     /** Whether this operation already replayed once after an explicit token-refresh request. */
     tokenRefreshReplayUsed?: boolean;
     /** Total outbound attempts accepted for this logical operation, including the initial request. */
@@ -97,9 +106,9 @@ export declare function resolveNextAuthRetryKey(state: AuthRetryKeyState, resolv
  *   applicable policy is exhausted, the resolver declines or cycles, or the
  *   operation reaches {@link AUTH_RETRY_MAX_ATTEMPTS}. An explicit typed
  *   token-refresh request gets exactly one refresh-current replay and never
- *   enters sibling rotation. Ordinary 401/auth failures retain one
- *   refresh-same plus one sibling switch; 403/usage-limit failures rotate
- *   directly through distinct siblings.
+ *   enters sibling rotation. Ordinary 401/auth failures get one refresh-same,
+ *   then rotate through distinct siblings; 403/usage-limit failures skip the
+ *   refresh and rotate directly.
  *
  * Used by non-streaming consumers (image generation, web search, completion
  * helpers). The streaming driver in `stream.ts` implements the same policy with
@@ -142,7 +151,7 @@ export interface WithOAuthAccessOptions {
  * - initial → `getOAuthAccess` (or `opts.seed`).
  * - typed token-refresh request → one forced refresh-current replay, then stop.
  * - 401/auth failure → one `getOAuthAccess` with `forceRefresh: true` for the
- *   current account, then sibling rotation.
+ *   current account, then sibling rotation through distinct credentials.
  * - 403/usage-limit failure → `rotateSessionCredential` directly, without a
  *   force-refresh detour.
  *

package/dist/types/images/types.d.ts

@@ -14,11 +14,20 @@ export interface ImageGenerationRequest {
 export interface GeneratedImage {
     data: string;
     mimeType: string;
+    /** Output dimensions (`WIDTHxHEIGHT`) the provider reports for this image, which may differ from the request. */
+    size?: string;
+    /** Rendering quality the provider reports for this image. */
+    quality?: string;
 }
 export interface ImageGenerationResult {
     images: GeneratedImage[];
     text?: string;
     usage: Usage;
+    /**
+     * Image model the provider reports having run. Hosted backends may substitute their own model for the
+     * selected catalog entry (the ChatGPT/Codex backend does), so callers should prefer this over the catalog id.
+     */
+    model?: string;
 }
 export interface ImageGenerationOptions {
     apiKey: ApiKey;

package/dist/types/judgment/types.d.ts

@@ -101,6 +101,7 @@ export declare class JudgmentParseError extends Error {
 }
 /**
  * Usage from a backend that reports token counts and, optionally, one billed
- * USD amount. Judgment pricing is input-only, so the amount lands on `input`.
+ * USD amount. Missing or non-finite amounts contribute zero to session totals.
+ * Judgment pricing is input-only, so the amount lands on `input`.
  */
-export declare function tokenUsage(input: number, output: number, cost?: number): Usage;
+export declare function tokenUsage(input: number | undefined, output: number | undefined, cost?: number): Usage;

package/dist/types/providers/cursor/exec-modern.d.ts

@@ -17,7 +17,7 @@ import type { ToolResultMessage } from "../../types.js";
  * virtual registry. Re-exported here because this is where the frame builders
  * and their translation are consumed together.
  */
-export { cursorEditOwnedReadPath, cursorRawReadPath, omitUndefinedArgs, piEscapeRegexLiteral, piGrepSkip, piJoinPath, piLimit, piLsPath, piReadDisplayPath, piReadPath, piReadPathHasRange, piTimeout, } from "../cursor-pi-args.js";
+export { cursorEditOwnedReadPath, cursorRawReadPath, omitUndefinedArgs, piEscapeRegexLiteral, piGrepSkip, piJoinPath, piLimit, piLsPath, piReadDisplayPath, piReadPath, piReadPathHasRange, piTimeout, shellTimeoutSeconds, } from "../cursor-pi-args.js";
 /** Flatten a tool result's content into the single `output` string the Pi frames carry. */
 export declare function piOutputText(toolResult: ToolResultMessage): string;
 /**

package/dist/types/providers/cursor-pi-args.d.ts

@@ -124,6 +124,16 @@ export declare function piLimit(limit: number | undefined): number | undefined;
  * Negative values have no local meaning and fall back to the default.
  */
 export declare function piTimeout(timeout: number | undefined): number | undefined;
+/**
+ * Convert a legacy `ShellArgs`/`ShellStreamArgs` timeout into bash-tool seconds.
+ *
+ * Cursor states that budget in milliseconds — its own `ShellTimeout` result
+ * echoes it as `timeout_ms`, and `hard_timeout` documents the same unit — while
+ * the bash tool takes seconds and rejects anything past 3600, so forwarding the
+ * raw value turned a model-requested 15 s into `requested 15000s`. Sub-second
+ * budgets round up: 0 seconds means "no deadline" to the bash tool.
+ */
+export declare function shellTimeoutSeconds(timeoutMs: number | undefined): number | undefined;
 /**
  * Drop keys whose value is `undefined` so optional local-tool kwargs stay
  * absent rather than present-as-undefined.

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

@@ -211,11 +211,15 @@ export declare function mergeCursorMcpToolCallArgs(streamed: Record<string, unkn
  * `agent-loop.ts` execution pass skips it — Cursor's server-driven exec
  * channel already ran the tool via the bridge and buffered the result, so
  * treating this block as runnable would re-execute the same side-effecting
- * tool a second time.
+ * tool a second time. Pass `{ executed: false }` for a frame nothing ran: a
+ * call handed to an external executor is only a handoff while the marker is
+ * absent, and the consumer that runs it needs a runnable block.
  *
  * Exported for tests to exercise ordering with adjacent text/thinking blocks.
  */
-export declare function synthesizeCursorExecToolCall(output: AssistantMessage, stream: AssistantMessageEventStream, state: BlockState, toolCallId: string, toolName: string, args: Record<string, unknown>): void;
+export declare function synthesizeCursorExecToolCall(output: AssistantMessage, stream: AssistantMessageEventStream, state: BlockState, toolCallId: string, toolName: string, args: Record<string, unknown>, { executed }?: {
+    executed?: boolean;
+}): void;
 /** Exported for tests: drives one Cursor interaction update through the streaming state machine. */
 export declare function processInteractionUpdate(update: any, output: AssistantMessage, stream: AssistantMessageEventStream, state: BlockState, usageState: UsageState): void;
 /**

package/dist/types/providers/google-shared.d.ts

@@ -1,10 +1,10 @@
 /**
  * Shared utilities for Google Generative AI and Google Cloud Code Assist providers.
  */
-import type { AssistantMessage, Context, FetchImpl, Model, ServiceTier, StopReason, StreamOptions, TextContent, ThinkingContent, Tool, ToolCall } from "../types.js";
+import type { AssistantMessage, Context, FetchImpl, Model, ServiceTier, StopReason, StreamOptions, TextContent, ThinkingContent, Tool, ToolCall, Usage } from "../types.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { normalizeSchemaForGoogle } from "../utils/schema/index.js";
-import type { Content, FinishReason, FunctionCallingConfigMode, GenerateContentParameters, GenerateContentResponse, Part } from "./google-types.js";
+import type { Content, FinishReason, FunctionCallingConfigMode, GenerateContentParameters, GenerateContentResponse, Part, UsageMetadata } from "./google-types.js";
 export type { Content, FunctionCallingConfigMode, GenerateContentParameters, GenerateContentResponse, ThinkingConfig, } from "./google-types.js";
 export { normalizeSchemaForGoogle };
 type GoogleApiType = "google-generative-ai" | "google-gemini-cli" | "google-vertex";
@@ -120,6 +120,17 @@ export declare const EMPTY_STREAM_BASE_DELAY_MS = 500;
  * must be retried instead of surfaced.
  */
 export declare function hasMeaningfulGoogleContent(output: AssistantMessage): boolean;
+/**
+ * Maps Gemini `usageMetadata` onto {@link Usage} (cost zeroed for `calculateCost`).
+ *
+ * `promptTokenCount` includes `cachedContentTokenCount`, so input = prompt − cached,
+ * matching the OpenAI convention where input + cacheRead = total prompt tokens.
+ * Upstream sometimes omits `promptTokenCount` or reports a cache count above the
+ * prompt (Antigravity), so the prompt falls back to `total − candidates − thoughts`
+ * and cached tokens are clamped to it: input is never negative.
+ * Ref: https://ai.google.dev/api/generate-content#v1beta.GenerateContentResponse.UsageMetadata
+ */
+export declare function mapGoogleUsage(metadata: UsageMetadata): Usage;
 export declare function nextToolCallId(name: string): string;
 /**
  * Push the appropriate `text_end` / `thinking_end` event for the given block.

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

@@ -5,6 +5,10 @@ export declare function claudeResetClearedBlockScopes(cleared: readonly string[]
 /** OAuth credential and transport used for an account's Claude reset operations. */
 export interface ClaudeResetAuth {
     accessToken: string;
+    /** Observe a safe discovery read's throttle without retrying any mutation. */
+    onRateLimited?: (retryAfterMs: number | undefined) => void;
+    accountId?: string;
+    email?: string;
     orgId?: string;
     baseUrl?: string;
     fetch: FetchImpl;
@@ -13,6 +17,8 @@ export interface ClaudeResetAuth {
 /** Live reset eligibility plus the exact organization and host used for redemption. */
 export interface ClaudeResetCreditList extends UsageResetCredits {
     credits: UsageResetCredit[];
+    /** Quota evidence parsed from the same successful discovery response. */
+    report?: UsageReport;
     orgId?: string;
     /** OAuth API base that answered discovery; pass back as consume `baseUrl`. */
     baseUrl?: string;

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

@@ -1,4 +1,10 @@
 import { type CredentialRankingStrategy, type UsageProvider, type UsageReport } from "../usage.js";
 export declare function parseClaudeRateLimitHeaders(headers: Record<string, string>, now?: number): UsageReport | null;
+/** Parse the quota evidence in one live usage response, without any additional requests. */
+export declare function parseClaudeUsagePayload(raw: unknown, identity?: {
+    accountId?: string;
+    email?: string;
+    orgId?: string;
+}, endpoint?: string, fetchedAt?: number): UsageReport | null;
 export declare const claudeUsageProvider: UsageProvider;
 export declare const claudeRankingStrategy: CredentialRankingStrategy;

package/dist/types/usage.d.ts

@@ -669,6 +669,8 @@ export interface CredentialRankingStrategy {
         limits: UsageLimit[];
         healthy?: boolean;
     }[];
+    /** Whether fresh reports can heal legacy account-wide quota backoffs. */
+    healsGlobalBlocks?: boolean;
     /** Fallback window durations (ms) when limits don't specify durationMs. */
     windowDefaults: {
         primaryMs: number;

package/dist/types/utils/proxy.d.ts

@@ -23,8 +23,8 @@ export declare function getProxyForUrl(provider: string, url: URL): string | und
 /**
  * Return `init` with `proxy: proxyUrl` set when the request should tunnel.
  * A caller-supplied `init.proxy` always wins (the innermost, most specific
- * decision); local/metadata hosts, NO_PROXY matches, and unparseable URLs
- * pass through unchanged.
+ * decision); Unix sockets, local/metadata hosts, NO_PROXY matches, and
+ * unparseable URLs pass through unchanged.
  */
 export declare function withProxyInit(input: string | URL | Request, init: RequestInit | undefined, proxyUrl: string): RequestInit | undefined;
 /**