@modelprofile.com/authswitch 9.2.0 → 10.0.0

package/dist_ts/openaiusage.d.ts

@@ -0,0 +1,59 @@
+import type { IOpenAiAccountRateLimits } from './interfaces.openai.js';
+/**
+ * Why a backend read failed, never with the response body:
+ * - `unauthorized`: the access token was rejected (401); renew it or sign in again.
+ * - `rate_limited`: the service refused for too many requests (429); `retryAfter` is its raw header.
+ * - `forbidden`: access denied (403). `challenge`: a Cloudflare verification challenge answered instead.
+ * - `http`: another error status. `protocol`: an answer too large or not what this route returns.
+ * - `network`: the request did not complete. `aborted` / `timeout`: the caller's signal or the time limit.
+ */
+export type TOpenAiBackendFailure = 'unauthorized' | 'rate_limited' | 'forbidden' | 'challenge' | 'http' | 'protocol' | 'network' | 'aborted' | 'timeout';
+export declare class OpenAiBackendError extends Error {
+    readonly reason: TOpenAiBackendFailure;
+    readonly status?: number | undefined;
+    readonly retryAfter: string | null;
+    constructor(reason: TOpenAiBackendFailure, status?: number | undefined, retryAfter?: string | null);
+}
+/** Access to read one ChatGPT account. A legacy login may carry no workspace; its reads send none. */
+export interface IOpenAiReadAccess {
+    accessToken: string;
+    accountId?: string;
+    isFedrampAccount: boolean;
+}
+export interface IOpenAiBackendReadOptions {
+    fetch?: typeof fetch;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+    /** The `originator` header; defaults to `authswitch`. */
+    originator?: string;
+    /** Extra request headers a route requires. */
+    headers?: Record<string, string>;
+}
+/** One bounded GET of `https://chatgpt.com/backend-api/<path>`, answered as a JSON object or an `OpenAiBackendError`. */
+export declare const readChatGptBackend: (path: string, access: IOpenAiReadAccess, options?: IOpenAiBackendReadOptions) => Promise<Record<string, unknown>>;
+/** Credits and spend control, which only the account views show; the stored reading keeps the limits alone. */
+export interface IOpenAiAccountUsage {
+    /** The workspace the service answered for, when it names one. */
+    accountId: string | null;
+    rateLimits: IOpenAiAccountRateLimits;
+    credits?: {
+        unlimited: boolean;
+        hasCredits: boolean;
+        balance?: string;
+    };
+    spendControl?: {
+        reached: boolean;
+        individualLimit?: {
+            used: string;
+            limit: string;
+            remaining: string;
+            resetsAt: number;
+        };
+    };
+}
+/** Projects one `wham/usage` answer, refusing it whole when any member it carries is not the documented shape. */
+export declare const projectOpenAiAccountUsage: (value: unknown, observedAt: string) => IOpenAiAccountUsage;
+/** Reads and projects one account's `wham/usage`. An answer for another workspace is refused. */
+export declare const readOpenAiAccountUsage: (access: IOpenAiReadAccess, options?: IOpenAiBackendReadOptions & {
+    now?: () => Date;
+}) => Promise<IOpenAiAccountUsage>;

package/dist_ts/openaiusage.js

@@ -0,0 +1,222 @@
+// OpenAI protocol portions are adapted in TypeScript from OpenAI Codex (Apache-2.0) and modified by Task Venture Capital GmbH; see third-party-notices.md.
+import * as plugins from './plugins.js';
+import { commitinfo } from './00_commitinfo_data.js';
+/**
+ * The one reader of the ChatGPT backend's account routes, and of `wham/usage` in particular (Codex
+ * `codex-rs/backend-client`: `client.rs`, `models/rate_limit_status_payload.rs`). The authority's usage reading,
+ * the import's access-token proof and the legacy `limits` view all read an account through here.
+ */
+const DEFAULT_TIMEOUT_MS = 10_000;
+const MAX_RESPONSE_BYTES = 1024 * 1024;
+const MAX_ADDITIONAL_RATE_LIMITS = 128;
+const MAX_TEXT_BYTES = 256;
+export class OpenAiBackendError extends Error {
+    reason;
+    status;
+    retryAfter;
+    constructor(reason, status, retryAfter = null) {
+        super(`ChatGPT backend request failed (${reason}${status === undefined ? '' : ` ${status}`}).`);
+        this.reason = reason;
+        this.status = status;
+        this.retryAfter = retryAfter;
+        this.name = 'OpenAiBackendError';
+    }
+}
+const isRecord = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+/** One bounded GET of `https://chatgpt.com/backend-api/<path>`, answered as a JSON object or an `OpenAiBackendError`. */
+export const readChatGptBackend = async (path, access, options = {}) => {
+    // A referenced timer, unlike `AbortSignal.timeout`, so the read settles within its limit even when the
+    // transport ignores its signal and holds nothing else open.
+    const timeout = new AbortController();
+    const timer = setTimeout(() => timeout.abort(), options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    const signal = options.signal ? AbortSignal.any([options.signal, timeout.signal]) : timeout.signal;
+    const fetcher = options.fetch ?? globalThis.fetch;
+    const failure = () => new OpenAiBackendError(timeout.signal.aborted ? 'timeout' : signal.aborted ? 'aborted' : 'network');
+    // The signal settles the read even when a transport ignores it.
+    let onAbort;
+    const aborted = new Promise((_resolve, reject) => {
+        onAbort = () => reject(failure());
+        signal.addEventListener('abort', onAbort, { once: true });
+        if (signal.aborted)
+            onAbort();
+    });
+    aborted.catch(() => undefined);
+    try {
+        return await Promise.race([readBody(fetcher, path, access, options, signal, failure), aborted]);
+    }
+    finally {
+        clearTimeout(timer);
+        signal.removeEventListener('abort', onAbort);
+    }
+};
+const readBody = async (fetcher, path, access, options, signal, failure) => {
+    if (signal.aborted)
+        throw failure();
+    let response;
+    try {
+        response = await fetcher(`https://chatgpt.com/backend-api/${path}`, {
+            method: 'GET', redirect: 'error', signal,
+            headers: { ...plugins.flexOpenAi.createOpenAiChatGptAccessHeaders(access, options.originator ?? 'authswitch'),
+                'User-Agent': `authswitch/${commitinfo.version}`, Accept: 'application/json', ...options.headers },
+        });
+    }
+    catch {
+        throw failure();
+    }
+    if (signal.aborted) {
+        await response.body?.cancel().catch(() => undefined);
+        throw failure();
+    }
+    if (!response.ok) {
+        await response.body?.cancel().catch(() => undefined);
+        if (response.headers.get('cf-mitigated') === 'challenge')
+            throw new OpenAiBackendError('challenge', response.status);
+        if (response.status === 401)
+            throw new OpenAiBackendError('unauthorized', 401);
+        if (response.status === 429)
+            throw new OpenAiBackendError('rate_limited', 429, response.headers.get('retry-after'));
+        if (response.status === 403)
+            throw new OpenAiBackendError('forbidden', 403);
+        throw new OpenAiBackendError('http', response.status);
+    }
+    const declared = response.headers.get('content-length');
+    if (declared !== null && (!/^\d+$/.test(declared) || Number(declared) > MAX_RESPONSE_BYTES)) {
+        await response.body?.cancel().catch(() => undefined);
+        throw new OpenAiBackendError('protocol', response.status);
+    }
+    const reader = response.body?.getReader();
+    if (!reader)
+        throw new OpenAiBackendError('protocol', response.status);
+    const chunks = [];
+    let size = 0;
+    const cancel = () => { void reader.cancel().catch(() => undefined); };
+    signal.addEventListener('abort', cancel, { once: true });
+    try {
+        while (true) {
+            const part = await reader.read();
+            if (part.done)
+                break;
+            size += part.value.byteLength;
+            if (size > MAX_RESPONSE_BYTES) {
+                await reader.cancel().catch(() => undefined);
+                throw new OpenAiBackendError('protocol', response.status);
+            }
+            chunks.push(part.value);
+        }
+    }
+    catch (error) {
+        if (error instanceof OpenAiBackendError)
+            throw error;
+        throw failure();
+    }
+    finally {
+        signal.removeEventListener('abort', cancel);
+        reader.releaseLock();
+    }
+    if (signal.aborted)
+        throw failure();
+    let body;
+    try {
+        body = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    }
+    catch {
+        throw new OpenAiBackendError('protocol', response.status);
+    }
+    if (!isRecord(body))
+        throw new OpenAiBackendError('protocol', response.status);
+    return body;
+};
+const invalid = () => { throw new OpenAiBackendError('protocol'); };
+const boundedInteger = (value, minimum, maximum = Number.MAX_SAFE_INTEGER) => Number.isSafeInteger(value) && value >= minimum && value <= maximum ? value : invalid();
+const boundedText = (value) => typeof value === 'string' && value.length > 0 && Buffer.byteLength(value, 'utf8') <= MAX_TEXT_BYTES ? value : invalid();
+const present = (value) => value !== null && value !== undefined;
+const projectWindow = (value) => {
+    if (!isRecord(value))
+        return invalid();
+    return {
+        usedPercent: boundedInteger(value.used_percent, 0, 100),
+        limitWindowSeconds: boundedInteger(value.limit_window_seconds, 1),
+        resetAfterSeconds: boundedInteger(value.reset_after_seconds, 0),
+        resetsAt: boundedInteger(value.reset_at, 0),
+    };
+};
+const projectDetails = (value) => {
+    if (!isRecord(value) || typeof value.allowed !== 'boolean' || typeof value.limit_reached !== 'boolean')
+        return invalid();
+    return {
+        allowed: value.allowed,
+        limitReached: value.limit_reached,
+        ...(present(value.primary_window) ? { primaryWindow: projectWindow(value.primary_window) } : {}),
+        ...(present(value.secondary_window) ? { secondaryWindow: projectWindow(value.secondary_window) } : {}),
+    };
+};
+/** Projects one `wham/usage` answer, refusing it whole when any member it carries is not the documented shape. */
+export const projectOpenAiAccountUsage = (value, observedAt) => {
+    if (!isRecord(value))
+        return invalid();
+    const additional = value.additional_rate_limits ?? [];
+    if (!Array.isArray(additional) || additional.length > MAX_ADDITIONAL_RATE_LIMITS)
+        return invalid();
+    let credits;
+    if (present(value.credits)) {
+        const raw = value.credits;
+        if (!isRecord(raw) || typeof raw.unlimited !== 'boolean' || typeof raw.has_credits !== 'boolean')
+            return invalid();
+        credits = { unlimited: raw.unlimited, hasCredits: raw.has_credits,
+            ...(present(raw.balance) ? { balance: boundedText(raw.balance) } : {}) };
+    }
+    let spendControl;
+    if (present(value.spend_control)) {
+        const raw = value.spend_control;
+        if (!isRecord(raw) || typeof raw.reached !== 'boolean')
+            return invalid();
+        let individualLimit;
+        if (present(raw.individual_limit)) {
+            const limit = raw.individual_limit;
+            if (!isRecord(limit))
+                return invalid();
+            individualLimit = { used: boundedText(limit.used), limit: boundedText(limit.limit),
+                remaining: boundedText(limit.remaining), resetsAt: boundedInteger(limit.reset_at, 0) };
+        }
+        spendControl = { reached: raw.reached, ...(individualLimit ? { individualLimit } : {}) };
+    }
+    const reachedType = value.rate_limit_reached_type;
+    if (present(reachedType) && !isRecord(reachedType))
+        return invalid();
+    const resetCredits = value.rate_limit_reset_credits;
+    if (present(resetCredits) && !isRecord(resetCredits))
+        return invalid();
+    return {
+        accountId: present(value.account_id) ? boundedText(value.account_id) : null,
+        rateLimits: {
+            providerId: 'openai',
+            plan: boundedText(value.plan_type),
+            observedAt,
+            ...(present(value.rate_limit) ? { rateLimit: projectDetails(value.rate_limit) } : {}),
+            additionalRateLimits: additional.map(raw => {
+                if (!isRecord(raw))
+                    return invalid();
+                return {
+                    limitName: boundedText(raw.limit_name),
+                    meteredFeature: boundedText(raw.metered_feature),
+                    ...(present(raw.rate_limit) ? { rateLimit: projectDetails(raw.rate_limit) } : {}),
+                };
+            }),
+            ...(isRecord(reachedType) ? { rateLimitReachedType: boundedText(reachedType.type) } : {}),
+            ...(isRecord(resetCredits)
+                ? { rateLimitResetCreditsAvailableCount: boundedInteger(resetCredits.available_count, 0) } : {}),
+        },
+        ...(credits ? { credits } : {}),
+        ...(spendControl ? { spendControl } : {}),
+    };
+};
+/** Reads and projects one account's `wham/usage`. An answer for another workspace is refused. */
+export const readOpenAiAccountUsage = async (access, options = {}) => {
+    const body = await readChatGptBackend('wham/usage', access, options);
+    const usage = projectOpenAiAccountUsage(body, (options.now ?? (() => new Date()))().toISOString());
+    if (usage.accountId !== null && access.accountId !== undefined && usage.accountId !== access.accountId) {
+        throw new OpenAiBackendError('protocol');
+    }
+    return usage;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"openaiusage.js","sourceRoot":"","sources":["../ts/openaiusage.ts"],"names":[],"mappings":"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"}

package/dist_ts/plugins.d.ts

@@ -29,7 +29,5 @@ import * as typedrequest from '@api.global/typedrequest';
 export { smartconsole, smartsecret, smartdaemon, typedrequest };
 import * as flexModels from '@modelprofile.com/flexharness-models';
 import * as flexOpenAi from '@modelprofile.com/flexharness-providers/openai';
-import * as flexAuth from '@modelprofile.com/flexharness-providers/auth';
-import * as flexAccounts from '@modelprofile.com/flexharness-providers/accounts';
 import * as crossharness from '@modelprofile.com/mcp-crossharness';
-export { flexModels, flexOpenAi, flexAuth, flexAccounts, crossharness };
+export { flexModels, flexOpenAi, crossharness };

package/dist_ts/plugins.js

@@ -31,8 +31,6 @@ export { smartconsole, smartsecret, smartdaemon, typedrequest };
 // @modelprofile.com modules
 import * as flexModels from '@modelprofile.com/flexharness-models';
 import * as flexOpenAi from '@modelprofile.com/flexharness-providers/openai';
-import * as flexAuth from '@modelprofile.com/flexharness-providers/auth';
-import * as flexAccounts from '@modelprofile.com/flexharness-providers/accounts';
 import * as crossharness from '@modelprofile.com/mcp-crossharness';
-export { flexModels, flexOpenAi, flexAuth, flexAccounts, crossharness };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsc0JBQXNCO0FBQ3RCLE9BQU8sS0FBSyxFQUFFLE1BQU0sU0FBUyxDQUFDO0FBQzlCLE9BQU8sS0FBSyxFQUFFLE1BQU0sU0FBUyxDQUFDO0FBQzlCLE9BQU8sS0FBSyxJQUFJLE1BQU0sV0FBVyxDQUFDO0FBQ2xDLE9BQU8sS0FBSyxZQUFZLE1BQU0sb0JBQW9CLENBQUM7QUFDbkQsT0FBTyxLQUFLLE1BQU0sTUFBTSxhQUFhLENBQUM7QUFDdEMsT0FBTyxLQUFLLEdBQUcsTUFBTSxVQUFVLENBQUM7QUFDaEMsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUM1QyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sVUFBVSxDQUFDO0FBR3pDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxFQUFFLGFBQWEsRUFBRSxFQUFFLEVBQUUsR0FBRyxFQUFFLEVBQUUsRUFBRSxJQUFJLEVBQUUsQ0FBQztBQUVsRSxNQUFNLGFBQWEsR0FBRyxhQUFhLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNyRCxrR0FBa0c7QUFDbEcsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHLEdBQWlDLEVBQUUsQ0FBQyxhQUFhLENBQUMsYUFBYSxDQUFDLENBQUM7QUFLM0Y7OztHQUdHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sa0JBQWtCLEdBQUcsR0FBNkIsRUFBRSxDQUFDLE1BQU0sQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO0FBRTVGLHdCQUF3QjtBQUN4QiwrREFBK0Q7QUFDL0QsT0FBTyxLQUFLLE9BQU8sTUFBTSw4QkFBOEIsQ0FBQztBQUN4RCxpR0FBaUc7QUFDakcsT0FBTyxLQUFLLGFBQWEsTUFBTSx1QkFBdUIsQ0FBQztBQUN2RCxPQUFPLEVBQUUsT0FBTyxFQUFFLGFBQWEsRUFBRSxDQUFDO0FBRWxDLHNCQUFzQjtBQUN0QixPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxXQUFXLE1BQU0seUJBQXlCLENBQUM7QUFDdkQsT0FBTyxLQUFLLFdBQVcsTUFBTSx5QkFBeUIsQ0FBQztBQUN2RCxPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBQ3pELE9BQU8sRUFBRSxZQUFZLEVBQUUsV0FBVyxFQUFFLFdBQVcsRUFBRSxZQUFZLEVBQUUsQ0FBQztBQUVoRSw0QkFBNEI7QUFDNUIsT0FBTyxLQUFLLFVBQVUsTUFBTSxzQ0FBc0MsQ0FBQztBQUNuRSxPQUFPLEtBQUssVUFBVSxNQUFNLGdEQUFnRCxDQUFDO0FBQzdFLE9BQU8sS0FBSyxRQUFRLE1BQU0sOENBQThDLENBQUM7QUFDekUsT0FBTyxLQUFLLFlBQVksTUFBTSxrREFBa0QsQ0FBQztBQUNqRixPQUFPLEtBQUssWUFBWSxNQUFNLG9DQUFvQyxDQUFDO0FBQ25FLE9BQU8sRUFBRSxVQUFVLEVBQUUsVUFBVSxFQUFFLFFBQVEsRUFBRSxZQUFZLEVBQUUsWUFBWSxFQUFFLENBQUMifQ==
+export { flexModels, flexOpenAi, crossharness };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsc0JBQXNCO0FBQ3RCLE9BQU8sS0FBSyxFQUFFLE1BQU0sU0FBUyxDQUFDO0FBQzlCLE9BQU8sS0FBSyxFQUFFLE1BQU0sU0FBUyxDQUFDO0FBQzlCLE9BQU8sS0FBSyxJQUFJLE1BQU0sV0FBVyxDQUFDO0FBQ2xDLE9BQU8sS0FBSyxZQUFZLE1BQU0sb0JBQW9CLENBQUM7QUFDbkQsT0FBTyxLQUFLLE1BQU0sTUFBTSxhQUFhLENBQUM7QUFDdEMsT0FBTyxLQUFLLEdBQUcsTUFBTSxVQUFVLENBQUM7QUFDaEMsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUM1QyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sVUFBVSxDQUFDO0FBR3pDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxFQUFFLGFBQWEsRUFBRSxFQUFFLEVBQUUsR0FBRyxFQUFFLEVBQUUsRUFBRSxJQUFJLEVBQUUsQ0FBQztBQUVsRSxNQUFNLGFBQWEsR0FBRyxhQUFhLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNyRCxrR0FBa0c7QUFDbEcsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHLEdBQWlDLEVBQUUsQ0FBQyxhQUFhLENBQUMsYUFBYSxDQUFDLENBQUM7QUFLM0Y7OztHQUdHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sa0JBQWtCLEdBQUcsR0FBNkIsRUFBRSxDQUFDLE1BQU0sQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO0FBRTVGLHdCQUF3QjtBQUN4QiwrREFBK0Q7QUFDL0QsT0FBTyxLQUFLLE9BQU8sTUFBTSw4QkFBOEIsQ0FBQztBQUN4RCxpR0FBaUc7QUFDakcsT0FBTyxLQUFLLGFBQWEsTUFBTSx1QkFBdUIsQ0FBQztBQUN2RCxPQUFPLEVBQUUsT0FBTyxFQUFFLGFBQWEsRUFBRSxDQUFDO0FBRWxDLHNCQUFzQjtBQUN0QixPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxXQUFXLE1BQU0seUJBQXlCLENBQUM7QUFDdkQsT0FBTyxLQUFLLFdBQVcsTUFBTSx5QkFBeUIsQ0FBQztBQUN2RCxPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBQ3pELE9BQU8sRUFBRSxZQUFZLEVBQUUsV0FBVyxFQUFFLFdBQVcsRUFBRSxZQUFZLEVBQUUsQ0FBQztBQUVoRSw0QkFBNEI7QUFDNUIsT0FBTyxLQUFLLFVBQVUsTUFBTSxzQ0FBc0MsQ0FBQztBQUNuRSxPQUFPLEtBQUssVUFBVSxNQUFNLGdEQUFnRCxDQUFDO0FBQzdFLE9BQU8sS0FBSyxZQUFZLE1BQU0sb0NBQW9DLENBQUM7QUFDbkUsT0FBTyxFQUFFLFVBQVUsRUFBRSxVQUFVLEVBQUUsWUFBWSxFQUFFLENBQUMifQ==

package/dist_ts/preuse.d.ts

@@ -1,5 +1,7 @@
 import type { IAuthHarness, IHarnessAccount, IHarnessPreuseOptions, IHarnessPreuseResult, IHarnessUsageWindow } from './interfaces.harness.js';
 export declare const defaultPreusePrompt = "Write 2000 words about strawberries.";
+/** The close of every message about a prompt that may have reached the provider. */
+export declare const preuseMayHaveConsumed = "Tokens may already have been consumed; no automatic retry was made. Check the account status before trying again.";
 /**
  * Only fixed local messages may cross the inference error boundary.
  *
@@ -12,6 +14,54 @@ export declare class PreuseError extends Error {
     readonly requestStarted: boolean;
     constructor(messageArg: string, requestStarted?: boolean);
 }
+/**
+ * A limit that kept a preuse prompt from being answered.
+ *
+ * `usage_limit` is the account's quota, spent until it resets; `rate_limit` a short throttle. `window` names the
+ * window by its length (`weekly`, `five-hour`) and `resetsAt` is an ISO time; either is null when the account's
+ * usage reading or the provider's refusal did not state it.
+ */
+export interface IPreuseLimit {
+    kind: 'usage_limit' | 'rate_limit';
+    window: string | null;
+    resetsAt: string | null;
+}
+/**
+ * `Weekly usage limit reached, resets in 16h 46min (2026-09-27 05:12)`: human text, so the reset reads in local time.
+ * The limit itself keeps its ISO `resetsAt` for receipts and JSON output.
+ */
+export declare const describePreuseLimit: (limitArg: IPreuseLimit, nowArg: number) => string;
+/**
+ * A preuse a limit stopped. `usage` is the account's own usage reading before anything was sent; `provider`
+ * is the provider's refusal of the prompt, which `generationStarted` says came before or after it began to
+ * answer: a refusal before its answer consumed nothing.
+ */
+export declare class PreuseLimitError extends PreuseError {
+    readonly limit: IPreuseLimit;
+    readonly source: 'usage' | 'provider';
+    readonly generationStarted: boolean;
+    constructor(limit: IPreuseLimit, source: 'usage' | 'provider', generationStarted: boolean, nowArg: number);
+}
+/**
+ * Why a sent preuse prompt failed without a limit, and never with the provider's text.
+ *
+ * `http` is an answer with an HTTP error status; `stream` an error the answer stream reported after it began,
+ * with the machine-readable code the provider stated and no status, since its answer was a success; `response` an answer that could not be read;
+ * `network` a connection that failed before any answer; `aborted` an abort that was neither the caller's nor the
+ * deadline; `unknown` anything else. `status` and `providerCode` are null when the failure did not state them.
+ */
+export interface IPreuseFailure {
+    kind: 'http' | 'stream' | 'response' | 'network' | 'aborted' | 'unknown';
+    status: number | null;
+    providerCode: string | null;
+}
+/** `the provider answered HTTP 503`: the cause of a failed preuse, as the tail of a sentence. */
+export declare const describePreuseFailure: (failureArg: IPreuseFailure) => string;
+/** A sent preuse prompt that failed for the stated cause; its tokens may have been consumed. */
+export declare class PreuseFailureError extends PreuseError {
+    readonly failure: IPreuseFailure;
+    constructor(failure: IPreuseFailure);
+}
 export declare const validatePreuseOptions: (optionsArg: IHarnessPreuseOptions) => void;
 /**
  * What one account's turn in a run did.

package/dist_ts/preuse.js

@@ -1,5 +1,7 @@
-import { orderedUsageWindows } from './accounts.js';
+import { localDateTime, orderedUsageWindows, until } from './accounts.js';
 export const defaultPreusePrompt = 'Write 2000 words about strawberries.';
+/** The close of every message about a prompt that may have reached the provider. */
+export const preuseMayHaveConsumed = 'Tokens may already have been consumed; no automatic retry was made. Check the account status before trying again.';
 /**
  * Only fixed local messages may cross the inference error boundary.
  *
@@ -15,6 +17,59 @@ export class PreuseError extends Error {
         this.requestStarted = requestStarted;
     }
 }
+/**
+ * `Weekly usage limit reached, resets in 16h 46min (2026-09-27 05:12)`: human text, so the reset reads in local time.
+ * The limit itself keeps its ISO `resetsAt` for receipts and JSON output.
+ */
+export const describePreuseLimit = (limitArg, nowArg) => {
+    const name = `${limitArg.window === null ? '' : `${limitArg.window} `}${limitArg.kind === 'usage_limit' ? 'usage' : 'rate'} limit reached`;
+    const countdown = limitArg.resetsAt === null ? null : until(limitArg.resetsAt, nowArg);
+    const at = localDateTime(limitArg.resetsAt);
+    const reset = limitArg.resetsAt === null ? ''
+        : countdown === 'due' ? `, due to reset now (${at})` : `, resets in ${countdown} (${at})`;
+    return `${name.charAt(0).toUpperCase()}${name.slice(1)}${reset}`;
+};
+/**
+ * A preuse a limit stopped. `usage` is the account's own usage reading before anything was sent; `provider`
+ * is the provider's refusal of the prompt, which `generationStarted` says came before or after it began to
+ * answer: a refusal before its answer consumed nothing.
+ */
+export class PreuseLimitError extends PreuseError {
+    limit;
+    source;
+    generationStarted;
+    constructor(limit, source, generationStarted, nowArg) {
+        const described = describePreuseLimit(limit, nowArg);
+        super(source === 'usage' ? `${described}. No preuse prompt was sent.`
+            : generationStarted
+                ? `The provider stopped the answer: ${described}. Tokens may already have been consumed; no automatic retry was made.`
+                : `The provider refused the prompt before answering it: ${described}. No tokens were consumed; no automatic retry was made.`, source === 'provider');
+        this.limit = limit;
+        this.source = source;
+        this.generationStarted = generationStarted;
+    }
+}
+/** `the provider answered HTTP 503`: the cause of a failed preuse, as the tail of a sentence. */
+export const describePreuseFailure = (failureArg) => {
+    const status = failureArg.status === null ? null : `HTTP ${failureArg.status}`;
+    switch (failureArg.kind) {
+        case 'http': return `the provider answered ${status ?? 'with an HTTP error'}`;
+        case 'stream':
+            return `the answer stream reported an error${failureArg.providerCode === null ? '' : ` (code ${failureArg.providerCode})`}`;
+        case 'response': return `the provider's answer${status ? ` (${status})` : ''} could not be read`;
+        case 'network': return 'no answer arrived: the connection failed';
+        case 'aborted': return 'the request was aborted';
+        case 'unknown': return 'the request ended in an error that names no cause';
+    }
+};
+/** A sent preuse prompt that failed for the stated cause; its tokens may have been consumed. */
+export class PreuseFailureError extends PreuseError {
+    failure;
+    constructor(failure) {
+        super(`Preuse did not complete: ${describePreuseFailure(failure)}. ${preuseMayHaveConsumed}`, true);
+        this.failure = failure;
+    }
+}
 export const validatePreuseOptions = (optionsArg) => {
     if (typeof optionsArg.prompt !== 'string' || !optionsArg.prompt.trim() || Buffer.byteLength(optionsArg.prompt, 'utf8') > 16_384) {
         throw new PreuseError('The preuse prompt must contain between 1 and 16384 UTF-8 bytes.');
@@ -54,10 +109,14 @@ export const preuseCountsText = (summaryArg) => [
     ...(summaryArg.counts.interrupted ? [`${summaryArg.counts.interrupted} interrupted`] : []),
     ...(summaryArg.notRun.length ? [`${summaryArg.notRun.length} not run`] : []),
 ].join(', ');
-/** An adapter's own fixed message, or the fixed local text for an error that crossed the boundary unnamed. */
+/**
+ * An adapter's own fixed message, or, for an error that crossed the boundary unnamed, the fixed local text with
+ * the error's class name -- never its message, which may carry a provider body or a token.
+ */
 const preuseReason = (errorArg) => errorArg instanceof PreuseError
     ? errorArg.message
-    : 'Preuse failed. Tokens may already have been consumed; check account status before trying again.';
+    : `Preuse failed with an error the adapter did not name (${errorArg instanceof Error && /^[A-Za-z]{1,64}$/.test(errorArg.name) ? errorArg.name : 'unknown'}). `
+        + 'Tokens may already have been consumed; check account status before trying again.';
 /**
  * The account's reset schedule, read after its prompt completed, exactly as the single-account command reads it.
  *
@@ -115,4 +174,4 @@ export const preuseAccounts = async (harnessArg, accountsArg, optionsArg, report
     }
     return { results, counts, notRun };
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"preuse.js","sourceRoot":"","sources":["../ts/preuse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAG1E,MAAM,CAAC,MAAM,mBAAmB,GAAG,sCAAsC,CAAC;AAE1E,oFAAoF;AACpF,MAAM,CAAC,MAAM,qBAAqB,GAAG,mHAAmH,CAAC;AAEzJ;;;;;;;GAOG;AACH,MAAM,OAAO,WAAY,SAAQ,KAAK;IACY;IAAhD,YAAY,UAAkB,EAAkB,iBAAiB,KAAK;QAAI,KAAK,CAAC,UAAU,CAAC,CAAC;QAA5C,mBAAc,GAAd,cAAc,CAAQ;IAAuB,CAAC;CAC/F;AAeD;;;GAGG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,QAAsB,EAAE,MAAc,EAAU,EAAE;IACpF,MAAM,IAAI,GAAG,GAAG,QAAQ,CAAC,MAAM,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,MAAM,GAAG,GAAG,QAAQ,CAAC,IAAI,KAAK,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,gBAAgB,CAAC;IAC3I,MAAM,SAAS,GAAG,QAAQ,CAAC,QAAQ,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IACvF,MAAM,EAAE,GAAG,aAAa,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;IAC5C,MAAM,KAAK,GAAG,QAAQ,CAAC,QAAQ,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE;QAC3C,CAAC,CAAC,SAAS,KAAK,KAAK,CAAC,CAAC,CAAC,uBAAuB,EAAE,GAAG,CAAC,CAAC,CAAC,eAAe,SAAS,KAAK,EAAE,GAAG,CAAC;IAC5F,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,EAAE,CAAC;AACnE,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAM,OAAO,gBAAiB,SAAQ,WAAW;IACnB;IAAqC;IAC/C;IADlB,YAA4B,KAAmB,EAAkB,MAA4B,EAC3E,iBAA0B,EAAE,MAAc;QAC1D,MAAM,SAAS,GAAG,mBAAmB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QACrD,KAAK,CAAC,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,8BAA8B;YACnE,CAAC,CAAC,iBAAiB;gBACjB,CAAC,CAAC,oCAAoC,SAAS,uEAAuE;gBACtH,CAAC,CAAC,wDAAwD,SAAS,yDAAyD,EAChI,MAAM,KAAK,UAAU,CAAC,CAAC;QAPG,UAAK,GAAL,KAAK,CAAc;QAAkB,WAAM,GAAN,MAAM,CAAsB;QAC3E,sBAAiB,GAAjB,iBAAiB,CAAS;IAO5C,CAAC;CACF;AAgBD,iGAAiG;AACjG,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,UAA0B,EAAU,EAAE;IAC1E,MAAM,MAAM,GAAG,UAAU,CAAC,MAAM,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,UAAU,CAAC,MAAM,EAAE,CAAC;IAC/E,QAAQ,UAAU,CAAC,IAAI,EAAE,CAAC;QACxB,KAAK,MAAM,CAAC,CAAC,OAAO,yBAAyB,MAAM,IAAI,oBAAoB,EAAE,CAAC;QAC9E,KAAK,QAAQ;YACX,OAAO,sCAAsC,UAAU,CAAC,YAAY,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,UAAU,CAAC,YAAY,GAAG,EAAE,CAAC;QAC9H,KAAK,UAAU,CAAC,CAAC,OAAO,wBAAwB,MAAM,CAAC,CAAC,CAAC,KAAK,MAAM,GAAG,CAAC,CAAC,CAAC,EAAE,oBAAoB,CAAC;QACjG,KAAK,SAAS,CAAC,CAAC,OAAO,0CAA0C,CAAC;QAClE,KAAK,SAAS,CAAC,CAAC,OAAO,yBAAyB,CAAC;QACjD,KAAK,SAAS,CAAC,CAAC,OAAO,mDAAmD,CAAC;IAC7E,CAAC;AACH,CAAC,CAAC;AAEF,gGAAgG;AAChG,MAAM,OAAO,kBAAmB,SAAQ,WAAW;IACrB;IAA5B,YAA4B,OAAuB;QACjD,KAAK,CAAC,4BAA4B,qBAAqB,CAAC,OAAO,CAAC,KAAK,qBAAqB,EAAE,EAAE,IAAI,CAAC,CAAC;QAD1E,YAAO,GAAP,OAAO,CAAgB;IAEnD,CAAC;CACF;AAED,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,UAAiC,EAAQ,EAAE;IAC/E,IAAI,OAAO,UAAU,CAAC,MAAM,KAAK,QAAQ,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,MAAM,CAAC,UAAU,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,EAAE,CAAC;QAChI,MAAM,IAAI,WAAW,CAAC,iEAAiE,CAAC,CAAC;IAC3F,CAAC;IACD,IAAI,UAAU,CAAC,KAAK,KAAK,SAAS,IAAI,CAAC,OAAO,UAAU,CAAC,KAAK,KAAK,QAAQ,IAAI,CAAC,sCAAsC,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;QAC/I,MAAM,IAAI,WAAW,CAAC,8EAA8E,CAAC,CAAC;IACxG,CAAC;AACH,CAAC,CAAC;AAsCF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,WAAuC,EAAqB,EAAE;IAC1F,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,MAAM,OAAO,GAAsB,EAAE,CAAC;IACtC,KAAK,MAAM,OAAO,IAAI,WAAW,EAAE,CAAC;QAClC,IAAI,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;YAAE,SAAS;QACnC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;QACrB,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACxB,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,UAA6B,EAAU,EAAE,CAAC;IACzE,GAAG,UAAU,CAAC,MAAM,CAAC,SAAS,YAAY;IAC1C,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,MAAM,CAAC,OAAO,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IAC9E,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,MAAM,CAAC,MAAM,SAAS,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IAC3E,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,MAAM,CAAC,WAAW,cAAc,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IAC1F,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,MAAM,CAAC,MAAM,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;CAC7E,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAEb;;;GAGG;AACH,MAAM,YAAY,GAAG,CAAC,QAAiB,EAAU,EAAE,CAAC,QAAQ,YAAY,WAAW;IACjF,CAAC,CAAC,QAAQ,CAAC,OAAO;IAClB,CAAC,CAAC,yDAAyD,QAAQ,YAAY,KAAK,IAAI,kBAAkB,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,KAAK;UAC3J,kFAAkF,CAAC;AAEzF;;;;;GAKG;AACH,MAAM,kBAAkB,GAAG,KAAK,EAAE,UAAwB,EAAE,UAA2B,EAAE,SAAsB,EAA4B,EAAE;IAC3I,IAAI,SAAS,CAAC,OAAO;QAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;IAClD,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,MAAM,UAAU,CAAC,iBAAiB,CAAC,UAAU,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;QACxF,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,mBAAmB,CAAC,MAAM,CAAC,OAAO,EAAE,YAAY,CAAC,EAAE,CAAC;IAC1F,CAAC;IAAC,MAAM,CAAC;QAAC,OAAO,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC;IAAC,CAAC;AAC7C,CAAC,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,KAAK,EACjC,UAAwB,EACxB,WAAuC,EACvC,UAAmE,EACnE,SAA8C,EAClB,EAAE;IAC9B,MAAM,aAAa,GAAG,UAAU,CAAC,aAAa,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;IACjE,IAAI,CAAC,aAAa;QAAE,MAAM,IAAI,WAAW,CAAC,uCAAuC,CAAC,CAAC;IACnF,qBAAqB,CAAC,UAAU,CAAC,CAAC;IAClC,MAAM,OAAO,GAA2B,EAAE,CAAC;IAC3C,MAAM,MAAM,GAAmC,EAAE,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,CAAC;IACvG,MAAM,MAAM,GAAsB,EAAE,CAAC;IACrC,MAAM,KAAK,GAAG,WAAW,CAAC,MAAM,CAAC;IACjC,KAAK,MAAM,CAAC,KAAK,EAAE,OAAO,CAAC,IAAI,WAAW,CAAC,OAAO,EAAE,EAAE,CAAC;QACrD,IAAI,UAAU,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAAC,SAAS;QAAC,CAAC;QAClE,SAAS,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC;QACtD,IAAI,MAA4B,CAAC;QACjC,IAAI,CAAC;YACH,MAAM,SAAS,GAAG,MAAM,aAAa,CAAC,OAAO,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,UAAU,CAAC,MAAM,EAAE,KAAK,EAAE,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,MAAM,EAAE,CAAC,CAAC;YACrI,MAAM,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC,UAAU,EAAE,OAAO,EAAE,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;QAC5I,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,gGAAgG;YAChG,MAAM,OAAO,GAAG,UAAU,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,aAAa;gBACvD,CAAC,CAAC,KAAK,YAAY,WAAW,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC;YACjF,MAAM,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC;QAC7D,CAAC;QACD,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACrB,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;QACzB,SAAS,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC;IACxD,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC;AACrC,CAAC,CAAC"}

package/dist_ts/ts_migration/legacysources/shared.js

@@ -1,5 +1,6 @@
 import * as plugins from '../../plugins.js';
 import { readCredentialRaw } from '../../classes.credentialstore.js';
+import { parseOpenAiTokenClaims } from '../../openaiauth.js';
 import { resolveClaudeNativeHome } from '../../classes.claudenative.js';
 export const resolveLegacySourceLocations = (env, homeDirectory) => {
     const dataHome = env.XDG_DATA_HOME || plugins.path.join(homeDirectory, '.local', 'share');
@@ -54,7 +55,7 @@ export const parseLegacyJson = (raw) => {
 export const openAiSourceIdentity = (idToken) => {
     let info;
     try {
-        info = plugins.flexAuth.parseOpenAiChatGptTokenInfo(idToken);
+        info = parseOpenAiTokenClaims(idToken);
     }
     catch {
         return null;
@@ -122,7 +123,7 @@ export const accessTokenExpiry = (accessToken) => {
     if (!accessToken)
         return null;
     try {
-        return plugins.flexAuth.parseOpenAiChatGptTokenInfo(accessToken).expiresAt ?? null;
+        return parseOpenAiTokenClaims(accessToken).expiresAt ?? null;
     }
     catch {
         return null;
@@ -137,4 +138,4 @@ export const accessProofAvailable = (expiresAt, now) => {
 };
 export const EXPIRED_ACCESS_PROBLEM = 'the stored access token has expired, so the non-rotating proof is unavailable until the native tool '
     + 'refreshes its own store';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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