@oh-my-pi/pi-ai 18.3.0 → 18.3.1

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## [Unreleased]
 
+## [18.3.1] - 2026-09-25
+
+### Added
+
+- Added live steering support for GPT-6 models, allowing queued user messages to be delivered during an active streaming response.
+- Added the `anthropicSlowMode` stream option for first-party Claude OAuth requests, enabling slow-mode rate-limit handling, per-account rate-limit reporting, and server-paced retries during capacity limits.
+- Added support for capturing and redeeming Anthropic fallback credit tokens, including prompt-cache repricing for classifier refusals.
+- Added Vercel AI Gateway app attribution by sending `http-referer: https://omp.sh/` and `x-title: omp` by default; user-provided header values take precedence.
+
+### Fixed
+
+- Fixed account selection for OpenCode Go and SuperGrok (xai-oauth) so accounts without available funds or included quota are skipped in favor of eligible accounts.
+- Improved visibility into automatically disabled authentication credentials by logging a warning and including the affected account details in credential-disabled events.
+
 ## [18.3.0] - 2026-09-24
 
 ### Added

package/THIRD-PARTY-NOTICES.txt

@@ -78,8 +78,8 @@ below.
 uutils coreutils (https://github.com/uutils/coreutils), MIT
 --------------------------------------------------------------------------------
 Covers: base32, base64, basename, cat, cksum (shared checksum machinery),
-b2sum, md5sum, sha1sum, sha224sum, sha256sum, sha384sum, sha512sum, comm, cut,
-date, dirname, head, hostname, ln, ls, mkdir, mktemp, mv, nproc, paste,
+b2sum, md5sum, sha1sum, sha224sum, sha256sum, sha384sum, sha512sum, comm, cp,
+cut, date, dirname, head, hostname, ln, ls, mkdir, mktemp, mv, nproc, paste,
 printenv, readlink, realpath, rm, seq, sort, stat, tac, tail, tee, touch, tr,
 truncate, uname, uniq, wc, whoami, yes.
 

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

@@ -4,8 +4,15 @@ export declare function matchesAuthAccountSelector(selector: AuthAccountSelector
 /** Validated per-account routing policies (priority/reserve) plus the global reserve fallback. */
 export declare class AccountPolicies {
     #private;
-    readonly defaultReservePct: number;
     constructor(policies: AuthAccountPolicies, defaultReservePct: number | undefined);
+    /** Global usage reserve (0–100) for accounts without a per-account `reservePct`. */
+    get defaultReservePct(): number;
+    /**
+     * Replace the policy set and global reserve in place (live settings change).
+     * Validates the configuration and every provider in `storedCredentials` before
+     * committing; on error the previous policies stay active.
+     */
+    replace(policies: AuthAccountPolicies, defaultReservePct: number | undefined, storedCredentials?: ReadonlyMap<string, readonly AuthCredential[]>): void;
     validateUsageCapability(provider: string, canFetchUsage: boolean): void;
     validateFor(provider: string, credentials: readonly AuthCredential[]): void;
     /**

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

@@ -8,6 +8,8 @@ export type StoredCredential = {
     id: number;
     credential: AuthCredential;
 };
+/** {@link CredentialDisabledEvent} for a torn-down row, carrying the account identity it was signed in as. */
+export declare function credentialDisabledEvent(provider: string, row: StoredCredential, disabledCause: string): CredentialDisabledEvent;
 /** Credential equality used for snapshot change detection. */
 export declare function authCredentialEquals(left: AuthCredential, right: AuthCredential): boolean;
 /** Dependencies for credential validation, corruption handling, and assignment reset. */
@@ -61,6 +63,12 @@ export declare class CredentialPool implements CredentialsApi {
      * one extra `data_version` read and no second reload.
      */
     adoptExternalChanges(): Promise<void>;
+    /**
+     * Take over the subscribers, buffered disable events, and generation counter of
+     * the pool this one replaces (store swap). Listener sets are shared, so
+     * unsubscribe functions handed out by `previous` keep working.
+     */
+    adoptSubscribers(previous: CredentialPool): void;
     onGeneration(listener: (generation: number) => void): () => void;
     bump(reason: string): void;
     /**

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

@@ -251,9 +251,11 @@ export interface AuthCredentialSnapshot {
 /**
  * Event payload describing a credential that was just soft-disabled.
  *
- * Today the only call site is OAuth refresh failures with a definitive cause
- * (`invalid_grant`, `401/403` not from a network blip, etc.) — the
- * disabled_cause string is the verbatim error captured for forensics.
+ * Fired for automatic disables: a definitive OAuth refresh failure
+ * (`invalid_grant`, `401/403` not from a network blip, etc.), an upstream
+ * token invalidation, and an auth-broker disable. The disabled_cause string is
+ * the verbatim error captured for forensics. Every emission is also logged as
+ * a warning.
  *
  * Subscribers can use this to surface a notification, banner, or auto-launch
  * a re-login flow instead of letting the credential silently disappear.
@@ -261,6 +263,14 @@ export interface AuthCredentialSnapshot {
 export interface CredentialDisabledEvent {
     provider: string;
     disabledCause: string;
+    /** Database row id of the disabled credential (matches {@link StoredAuthCredential.id}). */
+    credentialId?: number;
+    /** Account identity recorded on the disabled OAuth credential, when the provider supplied one. */
+    email?: string;
+    accountId?: string;
+    /** Organization/workspace the credential was scoped to (Anthropic/ChatGPT multi-subscription). */
+    orgId?: string;
+    orgName?: string;
 }
 /** Configuration supplied when constructing credential storage. */
 export type AuthStorageOptions = {
@@ -280,10 +290,10 @@ export type AuthStorageOptions = {
     configValueResolver?: (config: string) => Promise<string | undefined>;
     /**
      * Optional callback fired when AuthStorage automatically disables a
-     * credential because something detected it as no longer usable — today
-     * that's the OAuth refresh-failure path in `getApiKey`. NOT fired for
-     * user-initiated `remove()` (the user already knows) or dedup of
-     * duplicate credentials (uninteresting hygiene).
+     * credential because something detected it as no longer usable (see
+     * {@link CredentialDisabledEvent}). NOT fired for user-initiated `remove()`
+     * (the user already knows) or dedup of duplicate credentials
+     * (uninteresting hygiene).
      */
     onCredentialDisabled?: (event: CredentialDisabledEvent) => void | Promise<void>;
     /**

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

@@ -53,6 +53,8 @@ export declare class UsageService implements UsageApi {
      * built-in fallback. Removing the override restores that resolver unchanged.
      */
     setProvider(provider: Provider, usageProvider: UsageProvider, apiKey?: string): void;
+    /** Carry runtime usage provider overrides over from the service this one replaces (store swap). */
+    adoptRuntimeProviders(previous: UsageService): void;
     /** Remove a runtime usage provider override and restore configured/default resolution. */
     removeProvider(provider: Provider): void;
     /** Preserve the persisted OAuth row's login anchor and subtype metadata on usage-path refresh. */

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

@@ -1,4 +1,4 @@
-import { type AuthAccountPolicies, AuthStorage, type AuthStorageOptions } from "../auth-storage.js";
+import { type AuthAccountPolicies, type AuthCredentialStore, AuthStorage, type AuthStorageOptions } from "../auth-storage.js";
 import { type AuthBrokerAccountPool } from "./remote-store.js";
 export interface AuthBrokerClientConfig {
     url: string;
@@ -44,6 +44,27 @@ export declare function loadAuthBrokerAccountPool(): Promise<AuthBrokerAccountPo
  * available, matching the TUI behavior.
  */
 export declare function resolveAuthBrokerConfig(options?: ResolveAuthBrokerConfigOptions): Promise<AuthBrokerClientConfig | null>;
+export interface OpenAuthCredentialStoreOptions {
+    /** Broker to connect to; `null` opens the local SQLite store under `agentDir`. */
+    brokerConfig: AuthBrokerClientConfig | null;
+    agentDir?: string;
+    cachePath?: string;
+    sourceLabel?: string;
+    /** Programmatic pool for SDK hosts. Takes precedence over the environment file. */
+    accountPool?: AuthBrokerAccountPool;
+}
+/** Credential store opened by {@link openAuthCredentialStore} plus its diagnostics label. */
+export interface OpenedAuthCredentialStore {
+    store: AuthCredentialStore;
+    sourceLabel: string;
+}
+/**
+ * Open the credential store {@link discoverAuthStorage} would use for
+ * `brokerConfig`: the remote broker store (fails fast when the broker has no
+ * usable snapshot) or the local SQLite store. Also feeds
+ * {@link AuthStorage.replaceStore} when broker settings change at runtime.
+ */
+export declare function openAuthCredentialStore(options: OpenAuthCredentialStoreOptions): Promise<OpenedAuthCredentialStore>;
 /**
  * Create an AuthStorage instance, using the broker when configured and falling
  * back to the local SQLite store otherwise. This is the single source of truth

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

@@ -1,5 +1,5 @@
 import type { AuthCredentialStore } from "./auth/store.js";
-import type { AuthApiKeyOptions, AuthStorageOptions, BlocksApi, CredentialsApi, HealthApi, KeysApi, LimitsApi, OAuthApi, ResetsApi, SessionsApi, UsageApi } from "./auth/types.js";
+import type { AuthAccountPolicies, AuthApiKeyOptions, AuthStorageOptions, BlocksApi, CredentialsApi, HealthApi, KeysApi, LimitsApi, OAuthApi, ResetsApi, SessionsApi, UsageApi } from "./auth/types.js";
 export { isSqliteBusyError, isSqliteCorruptionError, SqliteAuthCredentialStore } from "./auth/sqlite-credential-store.js";
 export * from "./auth/store.js";
 export * from "./auth/types.js";
@@ -7,28 +7,52 @@ export * from "./auth/types.js";
  * Credential management over an {@link AuthCredentialStore}: multi-account
  * selection with usage-aware ranking, rate-limit blocks, OAuth refresh, and
  * usage reporting. See the module doc for the namespace layout.
+ *
+ * Namespaces resolve against the current store on every access, so holders of
+ * this instance follow {@link AuthStorage.replaceStore} without re-wiring.
  */
 export declare class AuthStorage {
     #private;
+    constructor(store: AuthCredentialStore, options?: AuthStorageOptions);
     /** Stored credential rows, change/disable events, broker snapshot. */
-    readonly credentials: CredentialsApi;
+    get credentials(): CredentialsApi;
     /** Provider auth cascade and key overrides. */
-    readonly keys: KeysApi;
+    get keys(): KeysApi;
     /** OAuth login, account access, listings, refresh. */
-    readonly oauth: OAuthApi;
+    get oauth(): OAuthApi;
     /** Session → account pins. */
-    readonly sessions: SessionsApi;
+    get sessions(): SessionsApi;
     /** Usage reports, header ingestion, history. */
-    readonly usage: UsageApi;
+    get usage(): UsageApi;
     /** Model pool health and per-credential probes. */
-    readonly health: HealthApi;
+    get health(): HealthApi;
     /** Usage-limit marking and credential rotation. */
-    readonly limits: LimitsApi;
+    get limits(): LimitsApi;
     /** Saved rate-limit resets. */
-    readonly resets: ResetsApi;
+    get resets(): ResetsApi;
     /** Persisted rate-limit blocks (auth-broker server seam). */
-    readonly blocks: BlocksApi;
-    constructor(store: AuthCredentialStore, options?: AuthStorageOptions);
+    get blocks(): BlocksApi;
+    /**
+     * Apply new account routing policy (live `auth.accountPolicies` /
+     * `retry.usageReservePct` change). Throws a configuration error, leaving the
+     * active policy untouched, when the policy is malformed or does not match the
+     * stored OAuth accounts.
+     */
+    setAccountPolicies(config: {
+        accountPolicies: AuthAccountPolicies;
+        defaultReservePct: number;
+    }): void;
+    /**
+     * Swap the backing credential store in place (live `auth.broker.url` change).
+     * Loads `store` into fresh store-bound state — pins, blocks, and usage caches are
+     * keyed by the old store's row ids — then closes the previous store. Runtime key
+     * overrides, account policies, usage-provider overrides, and credential event
+     * subscribers carry over. On a load failure `store` is closed and the current
+     * store stays active.
+     */
+    replaceStore(store: AuthCredentialStore, options?: {
+        sourceLabel?: string;
+    }): Promise<void>;
     /** Open the SQLite store at `dbPath` and wrap it (standalone use, e.g. the pi-ai CLI). */
     static create(dbPath: string, options?: AuthStorageOptions): Promise<AuthStorage>;
     /** Close the underlying credential store; the instance must not be reused. */

package/dist/types/error/rate-limit.d.ts

@@ -26,8 +26,9 @@ export declare function calculateRateLimitBackoffMs(reason: RateLimitReason): nu
  * account-local usage cap rather than a bad credential or a transient blip.
  * HTTP 402 Payment Required represents an account-billing cap (xAI
  * Grok Build "usage balance exhausted", DeepSeek "Insufficient Balance",
- * OpenRouter credit exhaustion) when opaque, payment/deactivation/balance-worded,
- * or QUOTA_EXHAUSTED/CONCURRENT_LIMIT, while informative non-quota 402s (e.g.
+ * OpenCode Go "Insufficient account funds", OpenRouter credit exhaustion)
+ * when opaque, payment/deactivation/balance/funds-worded, or
+ * QUOTA_EXHAUSTED/CONCURRENT_LIMIT. Informative non-quota 402s (e.g.
  * endpoint subscription requirements) remain non-usage-limits. Always combine
  * with {@link isUsageLimitOutcome} when a message is available.
  */

package/dist/types/index.d.ts

@@ -21,6 +21,7 @@ export * from "./providers/anthropic-identity.js";
 export * from "./providers/anthropic-state.js";
 export type * from "./providers/anthropic-client.js";
 export * from "./providers/anthropic-user-profiles.js";
+export * from "./providers/anthropic-slow-mode.js";
 export type * from "./providers/apple-foundation-models.js";
 export type * from "./providers/azure-openai-responses.js";
 export type * from "./providers/cursor.js";

package/dist/types/providers/anthropic-slow-mode.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Anthropic subscription "slow mode" (Claude Code's `/low-priority`).
+ *
+ * After a Claude subscription account hits its 5-hour session limit, Anthropic
+ * may offer to keep serving it on spare capacity. A request opts in with
+ * `anthropic-usage-limit: slow`; the server reports the lane state back in
+ * `anthropic-ratelimit-unified-slow-*` response headers, and answers "no spare
+ * capacity right now" with a 429 `slot_busy` or a 529 overload that the client
+ * retries after the server-stated interval.
+ *
+ * This module owns the wire contract only (header names, parsing). The mode's
+ * state machine lives with the caller, which plugs into the Anthropic provider
+ * through {@link AnthropicSlowModeHooks}.
+ */
+import type { HeadersLike } from "../utils/retry-after.js";
+/** Request header that opts a first-party OAuth request into the slow lane. */
+export declare const ANTHROPIC_USAGE_LIMIT_HEADER = "anthropic-usage-limit";
+/** {@link ANTHROPIC_USAGE_LIMIT_HEADER} value selecting the slow lane. */
+export declare const ANTHROPIC_SLOW_USAGE_LIMIT = "slow";
+/** Server-side experiment arm; only `treatment` accounts may enter the slow lane. */
+export type AnthropicSlowOffer = "treatment" | "control";
+/** `anthropic-ratelimit-unified-slow-status` values; unknown strings map to `unrecognized`. */
+export type AnthropicSlowStatus = "active" | "not_needed" | "slot_busy" | "weekly_limit" | "budget_exhausted" | "ineligible" | "off" | "unrecognized";
+/** Slow-lane facts carried by one Anthropic response (success or error). */
+export interface AnthropicSlowModeSignal {
+    offer?: AnthropicSlowOffer;
+    status?: AnthropicSlowStatus;
+    /** Server-stated interval between capacity retries. */
+    retryAfterMs?: number;
+    /** Server-stated ceiling on total time spent waiting for capacity. */
+    maxWaitMs?: number;
+    /** Fraction (0..1) of the weekly slow-lane allowance already used. */
+    budgetUtilization?: number;
+    /** Epoch seconds when the slow-lane allowance resets. */
+    budgetResetAtSec?: number;
+    /** Epoch seconds of `anthropic-ratelimit-unified-reset` (the limit that was hit). */
+    unifiedResetAtSec?: number;
+    /** Epoch seconds of the 5-hour window reset. */
+    fiveHourResetAtSec?: number;
+    /** Epoch seconds of the weekly window reset. */
+    weeklyResetAtSec?: number;
+    /** True when the response carries unified usage-limit claim headers (a limit wall). */
+    unifiedLimitClaim: boolean;
+    /** True when extra usage (overage) is serving this account. */
+    overageInUse: boolean;
+}
+/** One pre-content failure the provider hands to {@link AnthropicSlowModeHooks.onFailure}. */
+export interface AnthropicSlowModeFailure {
+    /** Account lane of the failed request (see {@link AnthropicSlowModeHooks}). */
+    lane: string;
+    httpStatus?: number;
+    /** 529 or an `overloaded_error` envelope. */
+    overloaded: boolean;
+    signal?: AnthropicSlowModeSignal;
+    /** Whether the failed request carried `anthropic-usage-limit: slow`. */
+    sentSlow: boolean;
+    /** Milliseconds this request has already spent waiting for slow-lane capacity. */
+    waitedMs: number;
+    /** Capacity waits already taken by this request. */
+    attempts: number;
+}
+/** Retry decision returned by {@link AnthropicSlowModeHooks.onFailure}. */
+export interface AnthropicSlowModeRetry {
+    /** Delay before resending; `0` resends immediately. */
+    delayMs: number;
+    /** True when the delay is a capacity wait (counts toward the max-wait budget). */
+    capacityWait: boolean;
+}
+/**
+ * Caller-owned slow-mode state machine. The Anthropic provider only consults
+ * it for first-party OAuth requests (`api.anthropic.com` with a subscription
+ * bearer); every other route ignores it.
+ *
+ * Slow-lane state belongs to one Claude account, so every call carries a
+ * `lane` key identifying the credential that served the request: `cred:<id>`
+ * for a stored credential, else `key:<hash>` of the bearer.
+ */
+export interface AnthropicSlowModeHooks {
+    /** Whether the next request on `lane` should carry `anthropic-usage-limit: slow`. */
+    isActive(lane: string): boolean;
+    /** Observe the slow-lane headers of a successful (2xx) response on `lane`. */
+    observe(signal: AnthropicSlowModeSignal, lane: string): void;
+    /**
+     * Decide how to react to a failure that arrived before any content. Return
+     * a retry to resend the request (with or without the slow header, per
+     * {@link isActive}), or `undefined` to let normal error handling run.
+     */
+    onFailure(failure: AnthropicSlowModeFailure): AnthropicSlowModeRetry | undefined | Promise<AnthropicSlowModeRetry | undefined>;
+}
+/**
+ * Parse the slow-lane and unified-limit headers relevant to slow mode.
+ * Returns `undefined` when the response carries none of them.
+ */
+export declare function parseAnthropicSlowModeHeaders(headers: HeadersLike): AnthropicSlowModeSignal | undefined;

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

@@ -298,6 +298,8 @@ export type MessageCreateParams = {
      * header: `server-side-fallback-2026-06-01`.
      */
     fallbacks?: FallbackParam[];
+    /** Fallback credit token redeemed from a prior refusal (`fallback-credit-2026-06-01` / `fallback-credit-2026-07-01`). */
+    fallback_credit_token?: string;
 };
 export type MessageCreateParamsStreaming = MessageCreateParams & {
     stream: true;
@@ -404,6 +406,8 @@ export type StopDetails = {
     type: string;
     category?: string | null;
     explanation?: string | null;
+    fallback_credit_token?: string | null;
+    fallback_has_prefill_claim?: boolean | null;
 };
 export type MessageDelta = {
     stop_reason?: StopReason | null;

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

@@ -41,7 +41,7 @@
  *   // Inspect calls afterwards.
  *   expect(mock.calls).toHaveLength(2);
  */
-import type { Api, Context, Model, SimpleStreamOptions, StopDetails, StopReason, Usage } from "../types.js";
+import type { AnthropicFallbackCreditHandle, Api, Context, Model, SimpleStreamOptions, StopDetails, StopReason, Usage } from "../types.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 /** The API string this provider serves. */
 export declare const MOCK_API: "mock";
@@ -70,6 +70,8 @@ export interface MockResponse {
     stopReason?: StopReason;
     /** Structured terminal stop classification, e.g. Anthropic refusal metadata. */
     stopDetails?: StopDetails | null;
+    /** In-memory fallback credit handle attached when a refusal response carries a fallback credit token. */
+    fallbackCreditHandle?: AnthropicFallbackCreditHandle;
     /** Error text paired with an explicit `"error"` stop reason. */
     errorMessage?: string;
     /** Usage stats. Missing fields default to 0; missing `cost.total` is recomputed from components. */

package/dist/types/providers/openai-codex/live-steering.d.ts

@@ -0,0 +1,77 @@
+import type { LiveSteering, UserMessage } from "../../types.js";
+import type { InputItem } from "./request-transformer.js";
+/** Server acknowledgement of one `response.steer` submission. */
+export type CodexSteerAck = {
+    accepted: true;
+    id: string;
+} | {
+    accepted: false;
+    code?: string;
+    message?: string;
+};
+/** Socket surface the pump submits through. */
+export interface CodexSteerSocket {
+    /** Sends `response.steer`; resolves on the matching acknowledgement, rejects when the socket closes first. */
+    steer(previousResponseId: string, input: InputItem[]): Promise<CodexSteerAck>;
+}
+/** Steering the server accepted, with the exact input items it queued. */
+export interface CodexAcceptedSteer {
+    id: string;
+    items: InputItem[];
+}
+/** What a finished pump delivered into its response. */
+export interface CodexSteerOutcome {
+    responseId: string | undefined;
+    accepted: CodexAcceptedSteer[];
+    /**
+     * A submission ended without an acknowledgement, so the server may or may
+     * not hold it. The caller must drop the socket rather than chain from it.
+     */
+    uncertain: boolean;
+}
+/**
+ * Submits caller steering to one in-flight response. Stops after the first
+ * rejection: the server only rejects when the response no longer accepts input,
+ * and later submissions would reorder the caller's input.
+ */
+export declare class CodexSteerPump {
+    #private;
+    constructor(source: LiveSteering, socket: CodexSteerSocket, toInput: (messages: readonly UserMessage[]) => InputItem[] | undefined);
+    /** The response this pump steers, once started. */
+    get responseId(): string | undefined;
+    /** Starts submitting steering to `responseId`; later calls are ignored. */
+    start(responseId: string): void;
+    /** Stops claiming input, settles the submission in flight, and reports what the server accepted. */
+    finish(): Promise<CodexSteerOutcome>;
+}
+/**
+ * Converted steering input, or `undefined` when an item is not a plain user
+ * message (the only shape `response.steer` accepts).
+ */
+export declare function toSteerInputItems(items: readonly InputItem[]): InputItem[] | undefined;
+/** How the request after a steered response continues on the server. */
+export type CodexSteerPlan = 
+/** The server continues on its own: read its successor, send nothing. */
+{
+    kind: "attach";
+}
+/** The server awaits tool output: send only `input`; it prepends the accepted steering itself. */
+ | {
+    kind: "create";
+    input: InputItem[];
+}
+/** The request cannot line up with the server's queue: drop the socket and replay in full. */
+ | {
+    kind: "discard";
+};
+/**
+ * Line the next request up with steering the server accepted for the previous
+ * response.
+ *
+ * `delta` is the chained input (new items after the previous response), or
+ * `undefined` when the chain broke. The accepted steering must appear in it, in
+ * order; what remains decides the plan: nothing means the server's automatic
+ * successor is exactly this request, tool output means the server is waiting
+ * for it, anything else runs concurrently with a successor and cannot be sent.
+ */
+export declare function planSteeredRequest(delta: readonly InputItem[] | undefined, steering: readonly InputItem[]): CodexSteerPlan;

package/dist/types/providers/transform-messages.d.ts

@@ -18,12 +18,20 @@ import type { Api, AssistantMessage, Message, Model } from "../types.js";
  */
 export declare const SENSITIVE_TOKEN_RE: RegExp;
 /**
- * Toggle outbound credential-pattern redaction. When disabled (the default),
+ * Toggle process-wide outbound credential-pattern redaction (requests outside
+ * any {@link withCredentialRedaction} scope). When disabled (the default),
  * {@link redactSensitiveCredentials} and {@link redactSensitiveInObject} are
  * pass-throughs and outbound messages/system prompts leave the process
  * unmodified.
  */
 export declare function configureCredentialRedaction(enabled: boolean): void;
+/**
+ * Runs `fn` with outbound credential-pattern redaction forced on or off for
+ * every request it starts (including the async work those requests spawn),
+ * overriding {@link configureCredentialRedaction}. Lets concurrent sessions in
+ * one process each apply their own policy.
+ */
+export declare function withCredentialRedaction<T>(enabled: boolean, fn: () => T): T;
 export declare function redactSensitiveCredentials(text: string): string;
 export declare function redactSensitiveInObject(val: unknown): {
     result: unknown;

package/dist/types/types.d.ts

@@ -1,6 +1,7 @@
 export * from "@oh-my-pi/pi-catalog/effort";
 export * from "@oh-my-pi/pi-catalog/types";
 import type { Type } from "@oh-my-pi/omptype";
+import type { AnthropicSlowModeHooks } from "./providers/anthropic-slow-mode.js";
 import type { DeleteArgs, DeleteResult, DiagnosticsArgs, DiagnosticsResult, GrepArgs, GrepResult, LsArgs, LsResult, McpResult, PiBashExecArgs, PiBashExecResult, PiEditExecArgs, PiEditExecResult, PiFindExecArgs, PiFindExecResult, PiGrepExecArgs, PiGrepExecResult, PiLsExecArgs, PiLsExecResult, PiReadExecArgs, PiReadExecResult, PiWriteExecArgs, PiWriteExecResult, ReadArgs, ReadResult, ShellArgs, ShellResult, WriteArgs, WriteResult } from "@oh-my-pi/pi-catalog/discovery/cursor-proto";
 import type { Effort } from "@oh-my-pi/pi-catalog/effort";
 import type { Api, FetchImpl, Model, Provider, ThinkingBudgets, Usage } from "@oh-my-pi/pi-catalog/types";
@@ -338,6 +339,13 @@ export interface StreamOptions {
      * Providers can use this to persist transport/session state between turns.
      */
     providerSessionState?: Map<string, ProviderSessionState>;
+    /**
+     * Source of user steering a provider may deliver into the response it is
+     * streaming (OpenAI Responses `response.steer` over the Codex WebSocket).
+     * Providers without mid-response input ignore it; unclaimed steering stays
+     * with the caller for its next request.
+     */
+    liveSteering?: LiveSteering;
     /** Canonical Codex compaction classification; ignored by other providers. */
     codexCompaction?: CodexCompactionRequestContext;
     /** Codex Code Mode tool exposure snapshot emitted as `tool_namespaces_info` turn metadata; ignored by other providers. */
@@ -428,6 +436,39 @@ export interface StreamOptions {
     cwd?: string;
     /** Cursor exec/MCP tool handlers (cursor-agent only). */
     execHandlers?: CursorExecHandlers;
+    /**
+     * Anthropic fallback credit redemption handle from a prior classifier refusal.
+     * When present, the Anthropic provider replays the frozen request body and betas with
+     * the new model and `fallback_credit_token` to redeem prompt cache credit.
+     */
+    fallbackCreditRedemption?: AnthropicFallbackCreditHandle;
+    /**
+     * Anthropic subscription slow-mode state machine (Claude Code `/low-priority`).
+     * Consulted only for first-party OAuth `anthropic` requests: stamps
+     * `anthropic-usage-limit: slow` while active and decides capacity waits.
+     */
+    anthropicSlowMode?: AnthropicSlowModeHooks;
+}
+/**
+ * Caller-owned queue of user steering that a provider pulls from while a
+ * response streams. See {@link StreamOptions.liveSteering}.
+ */
+export interface LiveSteering {
+    /** Resolves once steering may be claimable, or when `signal` aborts. Never consumes input. */
+    wait(signal: AbortSignal): Promise<void>;
+    /** Takes the queued steering as provider messages; `undefined` when none is deliverable now. */
+    claim(signal: AbortSignal): Promise<LiveSteerClaim | undefined>;
+}
+/**
+ * Steering taken from a {@link LiveSteering} source. The provider settles it
+ * exactly once; later calls are ignored.
+ */
+export interface LiveSteerClaim {
+    readonly messages: readonly UserMessage[];
+    /** The server owns the input: the caller records it right after the current response. */
+    accept(): void;
+    /** Not delivered: the caller sends the input with its next request. */
+    reject(): void;
 }
 export interface SimpleStreamOptions extends Omit<StreamOptions, "apiKey"> {
     /**
@@ -794,6 +835,8 @@ export interface UserMessage {
     synthetic?: boolean;
     /** True when injected mid-turn as a steer; consumed by the agent's pre-LLM transform to wrap it for emphasis. Never rendered. */
     steering?: boolean;
+    /** True when the provider delivered this steer into the response it was streaming (`response.steer`). Display-only; never sent. */
+    liveSteered?: boolean;
     /** Timestamp of a client-side history rewrite represented by this message. */
     historyRewriteAt?: number;
     /** Who initiated this message for billing/attribution semantics. */
@@ -910,6 +953,8 @@ export interface AssistantMessage {
     requestControls?: AnthropicRequestControls;
     /** Provider-specific opaque payload used to reconstruct transport-native history. */
     providerPayload?: ProviderPayload;
+    /** In-memory fallback credit handle attached when a refusal response carries a fallback credit token. */
+    fallbackCreditHandle?: AnthropicFallbackCreditHandle;
     timestamp: number;
     duration?: number;
     ttft?: number;
@@ -1262,3 +1307,13 @@ export type AssistantMessageEvent = {
     reason: Extract<StopReason, "aborted" | "error">;
     error: AssistantMessage;
 };
+export interface AnthropicFallbackCreditHandle {
+    token: string;
+    prefillClaim?: boolean | null;
+    params: unknown;
+    betas?: readonly string[];
+    betaHeader?: string;
+    expiresAt: number;
+    /** The refused response's content, in `AssistantMessage` block form. */
+    refusedContent?: AssistantMessage["content"];
+}

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

@@ -8,5 +8,10 @@
  * Only OAuth access credentials are accepted; paid API keys are a separate
  * product and must never be sent here.
  */
-import type { UsageProvider } from "../usage.js";
+import type { CredentialRankingStrategy, UsageProvider } from "../usage.js";
 export declare const xaiOauthUsageProvider: UsageProvider;
+/**
+ * Ranks SuperGrok accounts by weekly credits (or unified monthly included quota).
+ * xAI reports no short window, so the meter maps to `secondary`, which drives drain ranking.
+ */
+export declare const xaiOauthRankingStrategy: CredentialRankingStrategy;

package/dist/types/utils/http-inspector.d.ts

@@ -32,6 +32,12 @@ export declare function buildHttp400DumpPayload(dump: RawHttpRequestDump, error:
  *  are excluded: 429/5xx are retried, so persisting them here would write one
  *  dump per attempt. */
 export declare function shouldDumpRejectedRequest(error: unknown): boolean;
+/**
+ * Remove the local request-dump lines {@link appendRawHttpRequestDumpFor400} appends,
+ * leaving only the provider-facing error text. Hosts that relay provider errors
+ * (RPC `prompt_result`) must not leak OMP-local file paths.
+ */
+export declare function stripRawHttpRequestDiagnostics(message: string): string;
 export declare function appendRawHttpRequestDumpFor400(message: string, error: unknown, dump: RawHttpRequestDump | undefined): Promise<string>;
 export declare function finalizeErrorMessage(error: unknown, rawRequestDump: RawHttpRequestDump | undefined, capturedErrorResponse?: CapturedHttpErrorResponse): Promise<string>;
 /**

package/package.json

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