@linxiraos/pi-ai 1.0.0

package/dist/types/usage/alibaba-token-plan.d.ts

@@ -0,0 +1,3 @@
+import type { CredentialRankingStrategy, UsageProvider } from "../usage.js";
+export declare const alibabaTokenPlanUsageProvider: UsageProvider;
+export declare const alibabaTokenPlanRankingStrategy: CredentialRankingStrategy;

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

@@ -0,0 +1,4 @@
+import { type CredentialRankingStrategy, type UsageProvider, type UsageReport } from "../usage.js";
+export declare function parseClaudeRateLimitHeaders(headers: Record<string, string>, now?: number): UsageReport | null;
+export declare const claudeUsageProvider: UsageProvider;
+export declare const claudeRankingStrategy: CredentialRankingStrategy;

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

@@ -0,0 +1,4 @@
+import type { UsageProvider, UsageReport } from "../usage.js";
+export declare function parseCursorIndividualUsage(payload: unknown, fetchedAt?: number): UsageReport | null;
+export declare function parseCursorUsage(payload: unknown, fetchedAt?: number): UsageReport | null;
+export declare const cursorUsageProvider: UsageProvider;

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

@@ -0,0 +1,2 @@
+import type { UsageProvider } from "../usage.js";
+export declare const googleGeminiCliUsageProvider: UsageProvider;

package/dist/types/usage/github-copilot.d.ts

@@ -0,0 +1,7 @@
+/**
+ * GitHub Copilot usage provider.
+ *
+ * Normalizes Copilot quota usage into the shared UsageReport schema.
+ */
+import type { UsageProvider } from "../usage.js";
+export declare const githubCopilotUsageProvider: UsageProvider;

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

@@ -0,0 +1,15 @@
+import type { CredentialRankingStrategy, UsageProvider } from "../usage.js";
+export declare const antigravityUsageProvider: UsageProvider;
+/**
+ * Antigravity quotas are returned per backend counter (Anthropic / Google /
+ * OpenAI) and can include both daily and weekly windows. `fetchAntigravityUsage`
+ * sorts `limits` ascending by `remainingFraction`; after model-family scoping,
+ * the most-pressured relevant counter/window is index 0.
+ *
+ * Leave `secondary` unset: AuthStorage compares secondary metrics before
+ * primary metrics, which is correct for providers with a fixed short/long
+ * split but wrong here. Ranking Antigravity by the bottleneck counter first
+ * avoids preferring an account at 95% Gemini daily / 0% Claude weekly over one
+ * with healthier Gemini headroom.
+ */
+export declare const antigravityRankingStrategy: CredentialRankingStrategy;

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

@@ -0,0 +1,2 @@
+import type { UsageProvider } from "../usage.js";
+export declare const kimiUsageProvider: UsageProvider;

package/dist/types/usage/minimax-code.d.ts

@@ -0,0 +1,3 @@
+import type { UsageProvider } from "../usage.js";
+/** MiniMax Token Plan (international, `api.minimax.io`). */
+export declare const minimaxCodeUsageProvider: UsageProvider;

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

@@ -0,0 +1,5 @@
+import type { UsageProvider } from "../usage.js";
+/** Registers Ollama accounts with usage views even though no quota endpoint is exposed. */
+export declare const ollamaUsageProvider: UsageProvider;
+/** Registers Ollama Cloud accounts with usage views until a quota endpoint is available. */
+export declare const ollamaCloudUsageProvider: UsageProvider;

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

@@ -0,0 +1,18 @@
+/**
+ * Resolve the base URL for ChatGPT account-API requests (`wham/usage`,
+ * `wham/rate-limit-reset-credits`).
+ *
+ * These endpoints live on the canonical ChatGPT origin and authenticate with
+ * the Codex OAuth bearer minted for that origin. They are NOT part of the
+ * `/responses` API surface that streaming proxies (Headroom, 9router, etc.)
+ * forward, so a `providers.openai-codex.baseUrl` override pointed at such a
+ * proxy MUST NOT be used here — doing so 404s and silently breaks
+ * `/usage show` (issue #3679).
+ *
+ * Accepted overrides are the canonical `chatgpt.com` / `chat.openai.com`
+ * origins. Any extra path (e.g. a streaming override like
+ * `/backend-api/codex/responses`) is normalized to `${origin}/backend-api`,
+ * since the account endpoints always live directly under `/backend-api`. Any
+ * other host falls back to {@link CODEX_BASE_URL}.
+ */
+export declare function normalizeCodexBaseUrl(baseUrl?: string): string;

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

@@ -0,0 +1,88 @@
+/**
+ * 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, account_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.js";
+/** 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>;
+/**
+ * Pick the credit to spend: the available one that expires soonest.
+ *
+ * Credits are perishable, so spending in expiry order maximizes the bank's
+ * lifetime value. Available credits without a parseable `expiresAt` rank after
+ * dated ones; when nothing is available the first credit is returned unchanged
+ * (the consume then surfaces the backend's business outcome verbatim).
+ */
+export declare function pickSoonestExpiringCredit(credits: readonly CodexResetCredit[]): CodexResetCredit | undefined;
+/**
+ * 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

@@ -0,0 +1,10 @@
+import type { CredentialRankingStrategy, UsageProvider, UsageReport } from "../usage.js";
+/**
+ * Parse Codex `x-codex-{primary,secondary}-*` rate-limit response headers into
+ * a usage report. The backend attaches these snapshots to every response, so
+ * ingesting them lets credential selection block an exhausted account before
+ * the next request burns a wire 429.
+ */
+export declare function parseCodexRateLimitHeaders(headers: Record<string, string>, now?: number): UsageReport | null;
+export declare const openaiCodexUsageProvider: UsageProvider;
+export declare const codexRankingStrategy: CredentialRankingStrategy;

package/dist/types/usage/opencode-go.d.ts

@@ -0,0 +1,2 @@
+import type { UsageProvider } from "../usage.js";
+export declare const opencodeGoUsageProvider: UsageProvider;

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

@@ -0,0 +1 @@
+export declare const toNumber: (value: unknown) => number | undefined;

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

@@ -0,0 +1,2 @@
+import type { UsageProvider } from "../usage.js";
+export declare const syntheticUsageProvider: UsageProvider;

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

@@ -0,0 +1,2 @@
+import type { UsageProvider } from "../usage.js";
+export declare const umansUsageProvider: UsageProvider;

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

@@ -0,0 +1,12 @@
+/**
+ * SuperGrok (`xai-oauth`) subscription usage provider.
+ *
+ * Reads utilization from the Grok CLI billing endpoint. Prefer the legacy
+ * weekly `format=credits` payload (creditUsagePercent / productUsage). When
+ * xAI marks the account as unified billing and omits those fields, fall back
+ * to the default monthly included-quota shape (`monthlyLimit` / `used`).
+ * 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";
+export declare const xaiOauthUsageProvider: UsageProvider;

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

@@ -0,0 +1,3 @@
+import type { CredentialRankingStrategy, UsageProvider } from "../usage.js";
+export declare const zaiUsageProvider: UsageProvider;
+export declare const zaiRankingStrategy: CredentialRankingStrategy;