@oh-my-pi/pi-ai 15.11.4 → 15.11.7

package/CHANGELOG.md

@@ -2,6 +2,46 @@
 
 ## [Unreleased]
 
+## [15.11.7] - 2026-06-12
+
+### Added
+
+- Added `requestModelId` and `thinking.suppress` options to `google-gemini-cli` so collapsed effort-tier variants serialize their per-effort upstream wire id, and thinking-off requests on models with `thinking.suppressWhenOff` send an explicit `thinkingConfig` (`includeThoughts: false` with `thinkingLevel: "MINIMAL"` or `thinkingBudget: 0`) — Cloud Code Assist re-applies the per-id baked server default when the config is omitted, silently thinking and billing the tokens
+- Added mandatory-reasoning clamping: models baked with `thinking.requiresEffort` floor omitted or disabled reasoning to the lowest supported effort in every api mapping, and `disableReasoning` no longer emits OpenRouter `reasoning: { enabled: false }` for them — fixes `omp bench` and utility requests 400ing with "Reasoning is mandatory for this endpoint and cannot be disabled" on OpenRouter Gemini 3.x
+
+### Changed
+
+- Changed `google-gemini-cli` request mapping to route per-request wire ids via `resolveWireModelId`: the session effort picks the backing variant id (collapsed `gemini-3.5-flash` at high → `gemini-3.5-flash-low`; claude pairs route off → bare id, efforts → `-thinking`) while `AssistantMessage.model` and usage attribution stay on the logical id. A thinking budget clamped to zero now falls through to the thinking-off path (off routing plus suppression) instead of only disabling thinking
+- Changed `openai-completions` and `anthropic-messages` to serialize per-request wire ids via `resolveWireModelId`, so collapsed `X`/`X-thinking` pairs on aggregators and custom providers switch to the thinking SKU when reasoning is enabled (previously only `google-gemini-cli` routed effort-tier variants)
+
+### Fixed
+
+- Fixed `google-gemini-cli` ignoring `Model.requestModelId` when serializing the request model id
+
+## [15.11.5] - 2026-06-12
+
+### Added
+
+- Added `AuthStorage.listUsageHistory` to retrieve historical usage snapshots with optional `provider` and `sinceMs` filtering
+- Added durable usage-history persistence in the sqlite auth store so successful usage reports are recorded as time-series snapshots of limit utilization for later trend inspection
+- Added `AuthStorage.redeemResetCredit` to redeem stored OpenAI Codex saved rate-limit reset credits for a target account by `credentialId`, `accountId`, or `email`
+- Added `listCodexResetCredits` and `consumeCodexResetCredit` exports for OpenAI Codex saved reset-credit listing and redemption
+- Added `resetCredits` with `availableCount` to `UsageReport` so OpenAI Codex usage data now exposes redeemable rate-limit resets
+- Added `openai-codex-reset` exports via package barrel for out-of-band tooling usage
+- Added a one-shot request-debug target that writes the next provider HTTP request JSON to an explicit path.
+
+### Changed
+
+- Changed `AuthStorage.redeemResetCredit` to invalidate cached usage data after a successful redemption so the next usage report reflects the reset immediately
+
+### Fixed
+
+- Fixed temporary credential block state so redeemed reset credits immediately make the affected account selectable again after `redeemResetCredit` succeeds
+- Fixed one-shot request-debug path handling so an explicit request log target is consumed after the next request and no longer affects subsequent calls
+- Fixed explicit request-debug path mode to create missing parent directories before writing request logs
+- 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

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

@@ -344,6 +344,9 @@ export declare const usageResponseSchema: z.ZodObject<{
             }>>;
             notes: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>>;
+        resetCredits: z.ZodOptional<z.ZodObject<{
+            availableCount: z.ZodNumber;
+        }, z.core.$strip>>;
         metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         raw: z.ZodOptional<z.ZodUnknown>;
     }, z.core.$strip>>;

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

@@ -11,7 +11,8 @@ import { Database } from "bun:sqlite";
 import type { ApiKeyResolver } from "./auth-retry";
 import type { OAuthController, OAuthCredentials, OAuthProviderId } from "./registry/oauth/types";
 import type { Provider } from "./types";
-import type { CredentialRankingStrategy, UsageLogger, UsageProvider, UsageReport } from "./usage";
+import type { CredentialRankingStrategy, UsageHistoryEntry, UsageHistoryQuery, UsageLogger, UsageProvider, UsageReport } from "./usage";
+import { type CodexResetConsumeCode, type CodexResetCredit } from "./usage/openai-codex-reset";
 export type ApiKeyCredential = {
     type: "api_key";
     key: string;
@@ -225,6 +226,14 @@ export interface AuthCredentialStore {
     }): string | null;
     setCache(key: string, value: string, expiresAtSec: number): void;
     cleanExpiredCache(): void;
+    /**
+     * Append usage-limit snapshots for trend history. Optional: stores without
+     * durable storage (e.g. the broker remote store) omit it and recording is
+     * skipped — the broker host records into its own database instead.
+     */
+    recordUsageSnapshots?(entries: UsageHistoryEntry[]): void;
+    /** Read recorded usage-limit snapshots, oldest first. */
+    listUsageHistory?(query?: UsageHistoryQuery): UsageHistoryEntry[];
     /**
      * Optional store-supplied OAuth refresh. When present, `AuthStorage` uses
      * it before the per-provider local refresh path. `RemoteAuthCredentialStore`
@@ -450,6 +459,44 @@ export interface InvalidateCredentialMatchingOptions {
     signal?: AbortSignal;
     sessionId?: string;
 }
+/**
+ * Identifies which stored account to redeem a saved rate-limit reset for.
+ * Any one field is enough; `credentialId` is the most precise.
+ */
+export interface ResetCreditTarget {
+    credentialId?: number;
+    accountId?: string;
+    email?: string;
+}
+/** Outcome of {@link AuthStorage.redeemResetCredit}. */
+export interface ResetCreditRedeemOutcome {
+    /** `true` only when a reset was actually applied (`code === "reset"`). */
+    ok: boolean;
+    /**
+     * Result code. Backend codes: `reset` (success), `already_redeemed`,
+     * `no_credit`, `nothing_to_reset`. Locally-synthesized: `no_account`
+     * (target not found), `account_unavailable` (token refresh failed),
+     * `http_<status>` (unexpected HTTP).
+     */
+    code: CodexResetConsumeCode;
+    accountId?: string;
+    email?: 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;
+    accountId?: string;
+    email?: string;
+    /** Resets redeemable for this account right now (live, not cached). */
+    availableCount: number;
+    credits: CodexResetCredit[];
+    /** Whether this is the given session's active account. */
+    active: boolean;
+    /** Set when the account's token refresh or list call failed. */
+    error?: string;
+}
 /**
  * Credential storage backed by an AuthCredentialStore.
  * Reads from storage on reload(), manages round-robin credential selection,
@@ -621,6 +668,11 @@ export declare class AuthStorage {
      * Logout from a provider.
      */
     logout(provider: string): Promise<void>;
+    /**
+     * Recorded usage-limit snapshots, oldest first. Empty when the underlying
+     * store has no durable history (e.g. a broker-backed remote store).
+     */
+    listUsageHistory(query?: UsageHistoryQuery): UsageHistoryEntry[];
     ingestUsageHeaders(provider: Provider, headers: Record<string, string>, options?: {
         sessionId?: string;
         baseUrl?: string;
@@ -713,6 +765,38 @@ export declare class AuthStorage {
      * exercise each stored account exactly once.
      */
     getOAuthAccesses(provider: string, options?: AuthApiKeyOptions): Promise<OAuthAccessResolution[]>;
+    /**
+     * 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`.
+     */
+    listResetCredits(options?: {
+        provider?: string;
+        sessionId?: string;
+        baseUrlResolver?: (provider: string) => string | undefined;
+        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`.
+     */
+    redeemResetCredit(options: {
+        target: ResetCreditTarget;
+        provider?: string;
+        creditId?: string;
+        baseUrlResolver?: (provider: string) => string | undefined;
+        signal?: AbortSignal;
+    }): Promise<ResetCreditRedeemOutcome>;
     invalidateCredentialMatching(provider: string, apiKey: string, options?: InvalidateCredentialMatchingOptions): Promise<boolean>;
     invalidateCredentialMatching(provider: string, apiKey: string, signal?: AbortSignal): Promise<boolean>;
     /**
@@ -836,6 +920,8 @@ export declare class SqliteAuthCredentialStore implements AuthCredentialStore {
     }): string | null;
     setCache(key: string, value: string, expiresAtSec: number): void;
     cleanExpiredCache(): void;
+    recordUsageSnapshots(entries: UsageHistoryEntry[]): void;
+    listUsageHistory(query?: UsageHistoryQuery): UsageHistoryEntry[];
     /**
      * Save OAuth credentials for a provider.
      * Preserves unrelated identities and replaces only the matching credential.

package/dist/types/index.d.ts

@@ -34,6 +34,7 @@ export * from "./usage/google-antigravity";
 export * from "./usage/kimi";
 export * from "./usage/minimax-code";
 export * from "./usage/openai-codex";
+export * from "./usage/openai-codex-reset";
 export * from "./usage/zai";
 export * from "./utils/anthropic-auth";
 export * from "./utils/event-stream";

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

@@ -83,6 +83,11 @@ export interface AnthropicOptions extends StreamOptions {
      * Ignored for adaptive-capable models.
      */
     thinkingBudgetTokens?: number;
+    /**
+     * Upstream wire model id override for collapsed effort-tier variants.
+     * Serialized as `requestModelId ?? model.requestModelId ?? model.id`.
+     */
+    requestModelId?: string;
     /**
      * Effort level for adaptive thinking.
      * Controls how much thinking Claude allocates:

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

@@ -34,7 +34,23 @@ export interface GoogleGeminiCliOptions extends StreamOptions {
         budgetTokens?: number;
         /** Thinking level. Use for Gemini 3 models (LOW/HIGH for Pro, MINIMAL/LOW/MEDIUM/HIGH for Flash). */
         level?: GoogleThinkingLevel;
+        /**
+         * Explicit wire suppression when `enabled` is false. Cloud Code Assist
+         * re-applies the per-id baked server default when thinkingConfig is
+         * omitted, so models with `thinking.suppressWhenOff` must send
+         * `includeThoughts: false` plus a MINIMAL level (or zero budget).
+         */
+        suppress?: {
+            level: GoogleThinkingLevel;
+        } | {
+            budget: number;
+        };
     };
+    /**
+     * Upstream wire model id override for collapsed effort-tier variants.
+     * Serialized as `requestModelId ?? model.requestModelId ?? model.id`.
+     */
+    requestModelId?: string;
     projectId?: string;
 }
 export { ANTIGRAVITY_SYSTEM_INSTRUCTION, getAntigravityUserAgent, getGeminiCliHeaders, getGeminiCliUserAgent, } from "@oh-my-pi/pi-catalog/wire/gemini-headers";

package/dist/types/usage/openai-codex-reset.d.ts

@@ -0,0 +1,79 @@
+/**
+ * OpenAI Codex "saved rate limit reset" redemption client.
+ *
+ * OpenAI lets paid Codex accounts bank a usage-window reset and spend it on
+ * demand (announced 2026-06-11). The count is surfaced on `/wham/usage` as
+ * `rate_limit_reset_credits.available_count` (see `./openai-codex.ts`), but the
+ * actual credit objects and the redeem action live on two dedicated routes:
+ *
+ *   GET  /wham/rate-limit-reset-credits           → list redeemable credits
+ *   POST /wham/rate-limit-reset-credits/consume   → spend one credit
+ *        body: { credit_id, redeem_request_id }
+ *
+ * `redeem_request_id` is a client-generated idempotency key (UUID). The consume
+ * response carries a `code`: `"reset"` on success, otherwise a business reason
+ * (`already_redeemed`, `no_credit`, `nothing_to_reset`).
+ *
+ * These are thin, dependency-light functions so both the interactive session
+ * (the `/usage reset` command + auto-redeem) and any out-of-band tooling can
+ * share one wire contract.
+ */
+import type { FetchImpl } from "../types";
+/** A single redeemable (or already-spent) saved reset. */
+export interface CodexResetCredit {
+    /** Opaque credit id, e.g. `RateLimitResetCredit_…`. Pass to {@link consumeCodexResetCredit}. */
+    id: string;
+    /** Backend reset family, e.g. `codex_rate_limits`. */
+    resetType?: string;
+    /** `available`, `redeemed`, … */
+    status?: string;
+    grantedAt?: string;
+    expiresAt?: string;
+    redeemStartedAt?: string | null;
+    redeemedAt?: string | null;
+    /** Human-facing card title, e.g. "One free rate limit reset". */
+    title?: string;
+    description?: string;
+}
+/** Result of listing an account's saved resets. */
+export interface CodexResetCreditList {
+    credits: CodexResetCredit[];
+    /** Backend-reported count of credits redeemable right now. */
+    availableCount: number;
+}
+/**
+ * Consume outcome `code`. `reset` means a window was actually reset; the others
+ * are no-op business outcomes the caller should surface verbatim-ish to the user.
+ */
+export type CodexResetConsumeCode = "reset" | "already_redeemed" | "no_credit" | "nothing_to_reset" | (string & {});
+export interface CodexResetConsumeResult {
+    /** `true` only when `code === "reset"` (a reset was applied). */
+    ok: boolean;
+    code: CodexResetConsumeCode;
+    /** HTTP status of the consume call (for diagnostics). */
+    status: number;
+    raw?: unknown;
+}
+interface CodexResetAuth {
+    accessToken: string;
+    accountId?: string;
+    /** Provider base URL override; defaults to the Codex backend. */
+    baseUrl?: string;
+    fetch: FetchImpl;
+    signal?: AbortSignal;
+}
+/**
+ * List the account's saved rate-limit resets. Returns `null` on transport/auth
+ * failure (non-2xx or thrown), letting callers treat it the same as "no data".
+ */
+export declare function listCodexResetCredits(auth: CodexResetAuth): Promise<CodexResetCreditList | null>;
+/**
+ * Spend one saved reset. `redeemRequestId` is the idempotency key; one is
+ * generated when omitted, so retrying with the SAME id is safe and won't
+ * double-spend. The returned `code` is `"reset"` on success.
+ */
+export declare function consumeCodexResetCredit(auth: CodexResetAuth & {
+    creditId: string;
+    redeemRequestId?: string;
+}): Promise<CodexResetConsumeResult>;
+export {};

package/dist/types/usage/openai-codex.d.ts

@@ -1,3 +1,4 @@
 import type { CredentialRankingStrategy, UsageProvider } from "../usage";
+export declare function normalizeCodexBaseUrl(baseUrl?: string): string;
 export declare const openaiCodexUsageProvider: UsageProvider;
 export declare const codexRankingStrategy: CredentialRankingStrategy;

package/dist/types/usage.d.ts

@@ -57,14 +57,64 @@ export interface UsageLimit {
     status?: UsageStatus;
     notes?: 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.
+ */
+export interface UsageResetCredits {
+    /** Number of resets available to redeem right now. */
+    availableCount: number;
+}
 /** Aggregated usage report for a provider. */
 export interface UsageReport {
     provider: Provider;
     fetchedAt: number;
     limits: UsageLimit[];
+    /** Saved rate-limit resets the account can redeem, when the provider reports them. */
+    resetCredits?: UsageResetCredits;
     metadata?: Record<string, unknown>;
     raw?: unknown;
 }
+/**
+ * Resolve a limit's used fraction (0..1; >1 means overage) from whichever
+ * amount fields the provider populated. Precedence mirrors the usage UIs:
+ * explicit fraction > used/limit > percent-unit used > inverted remaining.
+ */
+export declare function resolveUsedFraction(limit: UsageLimit): number | undefined;
+/**
+ * One recorded usage-limit snapshot: a single limit window of one account at
+ * a point in time. The usage cache itself is latest-snapshot-only; history
+ * rows are appended by the auth storage layer whenever a fresh report is
+ * fetched, so limit utilization stays inspectable over time.
+ */
+export interface UsageHistoryEntry {
+    /** Epoch ms the report was fetched. */
+    recordedAt: number;
+    provider: Provider;
+    /** Stable credential identity key (account/email/project derived). */
+    accountKey: string;
+    email?: string;
+    accountId?: string;
+    /** {@link UsageLimit.id} of the recorded window. */
+    limitId: string;
+    /** Human label of the limit. */
+    label: string;
+    windowLabel?: string;
+    /** Used fraction (0..1) when resolvable. */
+    usedFraction?: number;
+    status?: UsageStatus;
+    /** Epoch ms the window resets, when known. */
+    resetsAt?: number;
+}
+/** Filter for reading recorded usage history. */
+export interface UsageHistoryQuery {
+    provider?: string;
+    /** Inclusive lower bound on {@link UsageHistoryEntry.recordedAt} (epoch ms). */
+    sinceMs?: number;
+}
 export declare const usageUnitSchema: z.ZodEnum<{
     bytes: "bytes";
     minutes: "minutes";
@@ -155,6 +205,9 @@ export declare const usageLimitSchema: z.ZodObject<{
     }>>;
     notes: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
+export declare const usageResetCreditsSchema: z.ZodObject<{
+    availableCount: z.ZodNumber;
+}, z.core.$strip>;
 export declare const usageReportSchema: z.ZodObject<{
     provider: z.ZodString;
     fetchedAt: z.ZodNumber;
@@ -201,6 +254,9 @@ export declare const usageReportSchema: z.ZodObject<{
         }>>;
         notes: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
+    resetCredits: z.ZodOptional<z.ZodObject<{
+        availableCount: z.ZodNumber;
+    }, z.core.$strip>>;
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     raw: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$strip>;

package/dist/types/utils/request-debug.d.ts

@@ -22,6 +22,9 @@ export interface RequestDebugSession {
     wrapResponse(response: Response): Promise<Response>;
 }
 export declare function isRequestDebugEnabled(): boolean;
+export declare function setNextRequestDebugPath(requestPath: string): void;
+export declare function clearNextRequestDebugPath(): void;
+export declare function getNextRequestDebugPath(): string | undefined;
 export declare function wrapFetchForRequestDebug(fetchImpl: FetchImpl): FetchImpl;
 export declare function withRequestDebugFetch<T extends {
     fetch?: FetchImpl;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "15.11.4",
+	"version": "15.11.7",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -38,8 +38,8 @@
 	},
 	"dependencies": {
 		"@bufbuild/protobuf": "^2.12.0",
-		"@oh-my-pi/pi-catalog": "15.11.4",
-		"@oh-my-pi/pi-utils": "15.11.4",
+		"@oh-my-pi/pi-catalog": "15.11.7",
+		"@oh-my-pi/pi-utils": "15.11.7",
 		"openai": "^6.39.0",
 		"partial-json": "^0.1.7",
 		"zod": "4.4.3"