jeopi-ai 16.2.13

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

@@ -0,0 +1,4 @@
+import type { CredentialRankingStrategy, UsageProvider, UsageReport } from "../usage";
+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/gemini.d.ts

@@ -0,0 +1,2 @@
+import type { UsageProvider } from "../usage";
+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";
+export declare const githubCopilotUsageProvider: UsageProvider;

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

@@ -0,0 +1,15 @@
+import type { CredentialRankingStrategy, UsageProvider } from "../usage";
+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";
+export declare const kimiUsageProvider: UsageProvider;

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

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

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

@@ -0,0 +1,5 @@
+import type { UsageProvider } from "../usage";
+/** 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,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

@@ -0,0 +1,3 @@
+import type { CredentialRankingStrategy, UsageProvider } from "../usage";
+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";
+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/zai.d.ts

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

package/dist/types/usage.d.ts

@@ -0,0 +1,346 @@
+import type { FetchImpl, Provider } from "./types";
+export type UsageUnit = "percent" | "tokens" | "requests" | "usd" | "minutes" | "bytes" | "unknown";
+export type UsageStatus = "ok" | "warning" | "exhausted" | "unknown";
+/** Time window for a limit (e.g. 5h, 7d, monthly). */
+export interface UsageWindow {
+    /** Stable identifier (e.g. "5h", "7d", "monthly"). */
+    id: string;
+    /** Human label (e.g. "5 Hour", "7 Day"). */
+    label: string;
+    /** Window duration in milliseconds, when known. */
+    durationMs?: number;
+    /** Absolute reset timestamp in milliseconds since epoch. */
+    resetsAt?: number;
+}
+/** Quantitative usage data. */
+export interface UsageAmount {
+    /** Amount used in the given unit. */
+    used?: number;
+    /** Maximum limit in the given unit. */
+    limit?: number;
+    /** Remaining amount in the given unit. */
+    remaining?: number;
+    /** Fraction used (0..1). */
+    usedFraction?: number;
+    /** Fraction remaining (0..1). */
+    remainingFraction?: number;
+    /** Unit for the amounts (percent, tokens, etc.). */
+    unit: UsageUnit;
+}
+/** Scope metadata describing what the limit applies to. */
+export interface UsageScope {
+    provider: Provider;
+    accountId?: string;
+    projectId?: string;
+    orgId?: string;
+    modelId?: string;
+    tier?: string;
+    windowId?: string;
+    shared?: boolean;
+}
+/** Normalized limit entry for a single window or quota bucket. */
+export interface UsageLimit {
+    /** Stable identifier for this limit entry. */
+    id: string;
+    /** Human label for display. */
+    label: string;
+    scope: UsageScope;
+    window?: UsageWindow;
+    amount: UsageAmount;
+    status?: UsageStatus;
+    notes?: string[];
+}
+/**
+ * Per-credit detail for a saved/banked rate-limit reset.
+ *
+ * Populated when the provider's listing endpoint returns individual credit
+ * metadata (e.g. OpenAI Codex `wham/rate-limit-reset-credits`). Callers that
+ * only need the count can ignore this; display layers use `expiresAt` to show
+ * when banked resets expire ([#3339](https://github.com/can1357/oh-my-pi/issues/3339)).
+ */
+export interface UsageResetCreditDetail {
+    /** ISO timestamp when the credit was granted. */
+    grantedAt?: string;
+    /** ISO timestamp when the credit expires and can no longer be redeemed. */
+    expiresAt?: string;
+    /** Backend status, e.g. `available`, `redeemed`. */
+    status?: 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;
+    /** Individual credit details (expiry dates, etc.) when the provider exposes them. */
+    credits?: UsageResetCreditDetail[];
+}
+/** 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;
+    /**
+     * Provider-wide disclaimers shown once above per-account sections.
+     * Use this for caveats that apply to every limit (e.g. "OMP-observed
+     * spend only"). Per-limit notes that differ per window (e.g. "Overage
+     * requests: N") stay on {@link UsageLimit.notes}.
+     */
+    notes?: string[];
+    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;
+}
+/** One observed provider request cost, attributed to the credential that made it. */
+export interface UsageCostHistoryEntry {
+    /** Epoch ms the request completed. */
+    recordedAt: number;
+    provider: Provider;
+    /** Stable credential identity key (account/email/project/secret derived). */
+    accountKey: string;
+    /** Estimated request cost in USD. */
+    costUsd: number;
+}
+/** Filter for reading observed request costs. */
+export interface UsageCostHistoryQuery {
+    provider?: string;
+    accountKey?: string;
+    /** Inclusive lower bound on {@link UsageCostHistoryEntry.recordedAt} (epoch ms). */
+    sinceMs?: number;
+}
+export declare const usageUnitSchema: import("arktype/internal/variants/string.ts").StringType<"bytes" | "minutes" | "percent" | "requests" | "tokens" | "unknown" | "usd", {}>;
+export declare const usageStatusSchema: import("arktype/internal/variants/string.ts").StringType<"exhausted" | "ok" | "unknown" | "warning", {}>;
+export declare const usageWindowSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    id: string;
+    label: string;
+    durationMs?: number | undefined;
+    resetsAt?: number | undefined;
+}, {}>;
+export declare const usageAmountSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    used?: number | undefined;
+    limit?: number | undefined;
+    remaining?: number | undefined;
+    usedFraction?: number | undefined;
+    remainingFraction?: number | undefined;
+    unit: "bytes" | "minutes" | "percent" | "requests" | "tokens" | "unknown" | "usd";
+}, {}>;
+export declare const usageScopeSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    provider: string;
+    accountId?: string | undefined;
+    projectId?: string | undefined;
+    orgId?: string | undefined;
+    modelId?: string | undefined;
+    tier?: string | undefined;
+    windowId?: string | undefined;
+    shared?: boolean | undefined;
+}, {}>;
+export declare const usageLimitSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    id: string;
+    label: string;
+    scope: {
+        provider: string;
+        accountId?: string | undefined;
+        projectId?: string | undefined;
+        orgId?: string | undefined;
+        modelId?: string | undefined;
+        tier?: string | undefined;
+        windowId?: string | undefined;
+        shared?: boolean | undefined;
+    };
+    window?: {
+        id: string;
+        label: string;
+        durationMs?: number | undefined;
+        resetsAt?: number | undefined;
+    } | undefined;
+    amount: {
+        used?: number | undefined;
+        limit?: number | undefined;
+        remaining?: number | undefined;
+        usedFraction?: number | undefined;
+        remainingFraction?: number | undefined;
+        unit: "bytes" | "minutes" | "percent" | "requests" | "tokens" | "unknown" | "usd";
+    };
+    status?: "exhausted" | "ok" | "unknown" | "warning" | undefined;
+    notes?: string[] | undefined;
+}, {}>;
+export declare const usageResetCreditDetailSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    grantedAt?: string | undefined;
+    expiresAt?: string | undefined;
+    status?: string | undefined;
+}, {}>;
+export declare const usageResetCreditsSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    availableCount: number;
+    credits?: {
+        grantedAt?: string | undefined;
+        expiresAt?: string | undefined;
+        status?: string | undefined;
+    }[] | undefined;
+}, {}>;
+export declare const usageReportSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    provider: string;
+    fetchedAt: number;
+    limits: {
+        id: string;
+        label: string;
+        scope: {
+            provider: string;
+            accountId?: string | undefined;
+            projectId?: string | undefined;
+            orgId?: string | undefined;
+            modelId?: string | undefined;
+            tier?: string | undefined;
+            windowId?: string | undefined;
+            shared?: boolean | undefined;
+        };
+        window?: {
+            id: string;
+            label: string;
+            durationMs?: number | undefined;
+            resetsAt?: number | undefined;
+        } | undefined;
+        amount: {
+            used?: number | undefined;
+            limit?: number | undefined;
+            remaining?: number | undefined;
+            usedFraction?: number | undefined;
+            remainingFraction?: number | undefined;
+            unit: "bytes" | "minutes" | "percent" | "requests" | "tokens" | "unknown" | "usd";
+        };
+        status?: "exhausted" | "ok" | "unknown" | "warning" | undefined;
+        notes?: string[] | undefined;
+    }[];
+    resetCredits?: {
+        availableCount: number;
+        credits?: {
+            grantedAt?: string | undefined;
+            expiresAt?: string | undefined;
+            status?: string | undefined;
+        }[] | undefined;
+    } | undefined;
+    notes?: string[] | undefined;
+    metadata?: {
+        [x: string]: unknown;
+    } | undefined;
+    raw?: unknown;
+}, {}>;
+/** Optional logger for usage fetchers. */
+export interface UsageLogger {
+    debug(message: string, meta?: Record<string, unknown>): void;
+    warn(message: string, meta?: Record<string, unknown>): void;
+}
+/** Credential bundle for usage endpoints. */
+export interface UsageCredential {
+    type: "api_key" | "oauth";
+    apiKey?: string;
+    accessToken?: string;
+    refreshToken?: string;
+    expiresAt?: number;
+    accountId?: string;
+    projectId?: string;
+    email?: string;
+    enterpriseUrl?: string;
+    metadata?: Record<string, unknown>;
+    apiEndpoint?: string;
+}
+/** Parameters provided to a usage fetcher. */
+export interface UsageFetchParams {
+    provider: Provider;
+    credential: UsageCredential;
+    /** Stable credential identity key derived by the auth storage layer. */
+    accountKey?: string;
+    baseUrl?: string;
+    signal?: AbortSignal;
+}
+/** Shared runtime utilities for fetchers. */
+export interface UsageFetchContext {
+    fetch: FetchImpl;
+    logger?: UsageLogger;
+    retryWait?: (delayMs: number, signal?: AbortSignal) => Promise<void>;
+    /** Observed request-cost history for providers without upstream usage APIs. */
+    listUsageCosts?: (query?: UsageCostHistoryQuery) => UsageCostHistoryEntry[];
+}
+/** Provider implementation for fetching usage information. */
+export interface UsageProvider {
+    id: Provider;
+    fetchUsage(params: UsageFetchParams, ctx: UsageFetchContext): Promise<UsageReport | null>;
+    /** Parse provider rate-limit response headers (lowercased keys) into a usage report, if supported. */
+    parseRateLimitHeaders?(headers: Record<string, string>, now?: number): UsageReport | null;
+    supports?(params: UsageFetchParams): boolean;
+    /** True when fetchUsage contacts upstream and can authenticate the credential for health checks. */
+    validatesCredentials?: boolean;
+}
+/** Request context used when ranking usage for a specific model. */
+export interface CredentialRankingContext {
+    /** Provider model id, when the caller is selecting a credential for one model. */
+    modelId?: string;
+}
+/** Strategy for usage-based credential ranking. Providers implement this to opt into smart credential selection. */
+export interface CredentialRankingStrategy {
+    /** Extract the primary (short) and secondary (long) window limits from a usage report. */
+    findWindowLimits(report: UsageReport, context?: CredentialRankingContext): {
+        primary?: UsageLimit;
+        secondary?: UsageLimit;
+    };
+    /**
+     * Restrict limits to the ones relevant for the requested model before
+     * credential-wide exhaustion checks and ranking. Providers with shared
+     * account-wide quotas can omit this and use all limits.
+     */
+    scopeLimits?(report: UsageReport, context?: CredentialRankingContext): UsageLimit[];
+    /**
+     * Return a provider-local backoff scope for the requested model. Providers
+     * with backend-specific quotas use this so one exhausted model family does
+     * not block unrelated families on the same OAuth credential.
+     */
+    blockScope?(context?: CredentialRankingContext): string | undefined;
+    /** Fallback window durations (ms) when limits don't specify durationMs. */
+    windowDefaults: {
+        primaryMs: number;
+        secondaryMs: number;
+    };
+    /** Optional: priority boost for specific credential states (e.g., fresh 5h ticker start). */
+    hasPriorityBoost?(primary: UsageLimit | undefined): boolean;
+}

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

@@ -0,0 +1,25 @@
+export interface AbortSourceTracker {
+    requestAbortController: AbortController;
+    requestSignal: AbortSignal;
+    abortLocally(reason: Error): Error;
+    getLocalAbortReason(): Error | undefined;
+    wasCallerAbort(): boolean;
+}
+/**
+ * Tracks whether a merged request signal was aborted by the caller or by provider-local logic.
+ *
+ * Caller aborts always take priority. When both the caller and a local watchdog fire near
+ * each other, the merged `requestSignal.reason` reflects whichever AbortController called
+ * `.abort()` first — but ordering is racy and not meaningful for upstream consumers. What
+ * matters is intent: if the caller's signal aborted, the request was cancelled by the
+ * caller, and any local watchdog reason is incidental and **MUST NOT** be surfaced as a
+ * retryable transient error (which would cause auto-retry to re-enter streaming and leave
+ * the UI showing a spinner the user already tried to cancel).
+ */
+export declare function createAbortSourceTracker(callerSignal?: AbortSignal): AbortSourceTracker;
+/**
+ * Race a shared promise against a caller's AbortSignal without coupling the
+ * underlying work to that signal. The shared promise keeps running (and caches
+ * its result) even when an individual caller bails out.
+ */
+export declare function raceWithSignal<T>(promise: Promise<T>, signal: AbortSignal | undefined): Promise<T>;

package/dist/types/utils/anthropic-auth.d.ts

@@ -0,0 +1,35 @@
+/** Auth configuration for Anthropic */
+export interface AnthropicAuthConfig {
+    apiKey: string;
+    baseUrl: string;
+    isOAuth: boolean;
+}
+export declare function resolveAnthropicBaseUrlFromEnv(): string | undefined;
+/**
+ * Checks if a token is an OAuth token by looking for sk-ant-oat prefix.
+ */
+export declare function isOAuthToken(apiKey: string): boolean;
+/**
+ * Build an {@link AnthropicAuthConfig} from an already-resolved API key.
+ *
+ * `apiKey` is whatever the caller chose for `Authorization`/`x-api-key` —
+ * usually `authStorage.getApiKey("anthropic")`. `baseUrl` overrides the
+ * env-derived base; pass `undefined` to fall back to FOUNDRY/ANTHROPIC env
+ * resolution and finally `DEFAULT_BASE_URL`.
+ *
+ * `isOAuth` is derived from the token prefix so the helper stays pure: callers
+ * never have to thread the OAuth flag through their own resolution logic.
+ */
+export declare function buildAnthropicAuthConfig(apiKey: string, baseUrl?: string): AnthropicAuthConfig;
+/**
+ * Builds HTTP headers for Anthropic API requests (search variant).
+ *
+ * Forwards `ANTHROPIC_CUSTOM_HEADERS` when the resolver deems them applicable
+ * (Foundry mode, or a non-Anthropic base URL — typically an enterprise
+ * gateway), matching the streaming path so web search behaves identically.
+ */
+export declare function buildAnthropicSearchHeaders(auth: AnthropicAuthConfig): Record<string, string>;
+/**
+ * Builds the full API URL for Anthropic messages endpoint.
+ */
+export declare function buildAnthropicUrl(auth: AnthropicAuthConfig): string;

package/dist/types/utils/block-symbols.d.ts

@@ -0,0 +1,20 @@
+/** Stores streamed tool-call argument JSON for live renderers and parser recovery. */
+export declare const kStreamingPartialJson: unique symbol;
+/** Carries streamed tool-call argument JSON without exposing a string-keyed property. */
+export type StreamingPartialJsonCarrier = object & {
+    [kStreamingPartialJson]?: string;
+};
+/** Reads streamed tool-call argument JSON from a block or event snapshot. */
+export declare function getStreamingPartialJson(block: StreamingPartialJsonCarrier | null | undefined): string | undefined;
+/** Writes streamed tool-call argument JSON to a block or clears it with `undefined`. */
+export declare function setStreamingPartialJson(block: StreamingPartialJsonCarrier, value: string | undefined): void;
+/** Clears streamed tool-call argument JSON without deleting or changing object shape. */
+export declare function clearStreamingPartialJson(block: StreamingPartialJsonCarrier): void;
+/** Stores a provider-local stream block index without exposing a string-keyed property. */
+export declare const kStreamingBlockIndex: unique symbol;
+/** Stores the last parsed argument prefix length for throttled streaming JSON parsing. */
+export declare const kStreamingLastParseLen: unique symbol;
+/** Marks streamed tool-call arguments that already received an authoritative done payload. */
+export declare const kStreamingArgumentsDone: unique symbol;
+/** Classifies Cursor's in-flight tool-call kind without leaking provider-private state. */
+export declare const kStreamingBlockKind: unique symbol;

package/dist/types/utils/deterministic-id.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A UUID-shaped string: five hex groups in the canonical 8-4-4-4-12 layout.
+ *
+ * NOT a spec-compliant RFC 4122 UUID — the version/variant nibbles are left as
+ * raw hash output — but the shape passes everywhere a UUID string is expected.
+ */
+export type DeterministicUuid = `${string}-${string}-${string}-${string}-${string}`;
+/**
+ * Format the leading 128 bits of `seed`'s SHA-256 digest as a v4-shape UUID
+ * (8-4-4-4-12 hex groups).
+ *
+ * Deterministic: identical seeds always map to the same id, so callers get
+ * stable ids across requests / conversation turns (reusing message-blob ids,
+ * keying prompt caches) without persisting a seed→id mapping.
+ */
+export declare function deterministicUuid(seed: string): DeterministicUuid;

package/dist/types/utils/empty-completion-retry.d.ts

@@ -0,0 +1,21 @@
+import type { AssistantMessage, Context } from "../types";
+import { AssistantMessageEventStream } from "./event-stream";
+export declare const MAX_EMPTY_COMPLETION_RETRIES = 2;
+export declare const EMPTY_COMPLETION_BASE_DELAY_MS = 500;
+/**
+ * Whether a completed assistant message carries content worth delivering: a tool
+ * call or any non-whitespace text. An empty/whitespace-only message — or one
+ * that only ever produced thinking — is the "empty response" failure.
+ */
+export declare function hasVisibleAssistantContent(message: AssistantMessage): boolean;
+interface EmptyCompletionRetryOptions {
+    signal?: AbortSignal;
+    providerRetryWait?: (delayMs: number, signal?: AbortSignal) => Promise<void>;
+}
+/**
+ * Wrap a single-attempt provider stream with bounded empty-completion retries.
+ * `attempt` MUST create a fresh request (and its own output message) on each
+ * call so a retry never inherits stale metadata from an empty attempt.
+ */
+export declare function withEmptyCompletionRetry<M, O extends EmptyCompletionRetryOptions>(model: M, context: Context, options: O | undefined, attempt: (model: M, context: Context, options?: O) => AssistantMessageEventStream): AssistantMessageEventStream;
+export {};

package/dist/types/utils/event-stream.d.ts

@@ -0,0 +1,30 @@
+import type { AssistantMessage, AssistantMessageEvent } from "../types";
+export declare class EventStream<T, R = T> implements AsyncIterable<T> {
+    #private;
+    queue: T[];
+    waiting: Array<{
+        resolve: (value: IteratorResult<T>) => void;
+        reject: (err: unknown) => void;
+    }>;
+    done: boolean;
+    /** True once finalResultPromise has been resolved or rejected. */
+    resultSettled: boolean;
+    finalResultPromise: Promise<R>;
+    resolveFinalResult: (result: R) => void;
+    rejectFinalResult: (err: unknown) => void;
+    isComplete: (event: T) => boolean;
+    extractResult: (event: T) => R;
+    constructor(isComplete: (event: T) => boolean, extractResult: (event: T) => R);
+    push(event: T): void;
+    deliver(event: T): void;
+    end(result?: R): void;
+    endWaiting(): void;
+    fail(err: unknown): void;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+    result(): Promise<R>;
+}
+export declare class AssistantMessageEventStream extends EventStream<AssistantMessageEvent, AssistantMessage> {
+    constructor();
+    push(event: AssistantMessageEvent): void;
+    end(result?: AssistantMessage): void;
+}