agl 40.4.0 → 40.5.1

package/dist_ts/classes.inferenceservice.d.ts

@@ -1,5 +1,6 @@
 import type { IAuthoritySocketPaths } from './classes.authorityclient.js';
 import { InferenceRouter, type IInferenceAccountStatus, type IInferenceRoutingPolicy } from './classes.inferencerouter.js';
+import { type IInferenceSpendStore } from './classes.inferencespend.js';
 import { type IInferenceUsageObserverStatus } from './classes.inferenceusageobserver.js';
 import { type IInferenceGatewayClientOptions, type IInferenceGatewayGrant, type IInferenceGatewayLease, type IInferenceGatewayLimits, type IInferenceGatewayRestoredLease, type IInferenceGatewayStatus } from './classes.inferencegateway.js';
 import type { IInferenceAffinityStore } from './classes.inferenceaffinity.js';
@@ -17,6 +18,11 @@ export interface IInferenceServiceOptions {
     placements: IInferencePlacementJournal;
     /** Where the tokens of every answer are recorded for the usage metrics. */
     usageLedger: IInferenceUsageLedger;
+    /**
+     * Where the spend of the answers relayed on API keys is kept until the account service acknowledged it: the proxy's
+     * own database (`ProxyStore.spend`).
+     */
+    spendStore: IInferenceSpendStore;
     providerFetch?: typeof fetch;
     limits?: IInferenceGatewayLimits;
 }
@@ -34,6 +40,11 @@ export declare class InferenceService {
      * to the authority, whose answer the cache holds.
      */
     private readonly observer;
+    /**
+     * The spend of the answers relayed on API keys until the account service acknowledged it: counted against each key's
+     * limit in the readings the cache hands out, and reported to the account service.
+     */
+    private readonly spend;
     private readonly abort;
     private ready;
     private started;
@@ -58,8 +69,9 @@ export declare class InferenceService {
     /**
      * The gateway's state, each pool account judged on the usage reading a request would route on now -- the account
      * service's answer from its own cache (`InferenceUsageCache.current`), so a pool no request used since the proxy
-     * started is judged as its next request would judge it -- the subscription account each provider's next new client
-     * session goes to, and the latest placements the journal holds.
+     * started is judged as its next request would judge it -- the account each provider's next new session of a client
+     * that names no credential goes to (a subscription while one takes it, else an API key), and the latest placements the
+     * journal holds.
      */
     status(signalArg: AbortSignal): Promise<IInferenceGatewayStatus & {
         baseUrl: string;

package/dist_ts/classes.inferenceservice.js

@@ -1,11 +1,12 @@
 import * as plugins from './plugins.js';
 import { AuthorityState } from './classes.authoritystate.js';
 import { FlexAccountAccess } from './classes.flexaccountaccess.js';
-import { InferenceRouter, InferenceRoutingError } from './classes.inferencerouter.js';
+import { InferenceRouter, InferenceRoutingError, inferencePaymentReportOptions } from './classes.inferencerouter.js';
 import { InferenceUsageCache } from './classes.inferenceusagecache.js';
+import { InferenceSpendOutbox } from './classes.inferencespend.js';
 import { InferenceUsageObserver } from './classes.inferenceusageobserver.js';
 import { InferenceGateway } from './classes.inferencegateway.js';
-import { findAuthorityGatewayLogin, findInferencePool, isAuthorityInstallationId, parseAuthorityScope } from '../dist_ts_interfaces/index.js';
+import { findAuthorityApiKeyLogin, findAuthorityGatewayLogin, findInferencePool, isAuthorityInstallationId, parseAuthorityScope } from '../dist_ts_interfaces/index.js';
 /** How many of the latest placements the status shows. */
 const recentPlacementCount = 20;
 /** One exclusive listener owns one stable authority scope; a restart can reclaim only that scope. */
@@ -22,6 +23,11 @@ export class InferenceService {
      * to the authority, whose answer the cache holds.
      */
     observer;
+    /**
+     * The spend of the answers relayed on API keys until the account service acknowledged it: counted against each key's
+     * limit in the readings the cache hands out, and reported to the account service.
+     */
+    spend;
     abort = new AbortController();
     ready = false;
     started = false;
@@ -45,6 +51,22 @@ export class InferenceService {
                 // Routing needs a reading: an account added a moment ago is routed on once its first read landed.
                 return client.getUsage(accountIdArg, login.id, signalArg, { waitForFirstRead: true });
             },
+            // A key's reading counts the answers whose spend the account service has not acknowledged yet.
+            view: (accountIdArg, snapshotArg) => this.spend.judged(accountIdArg, snapshotArg),
+        });
+        this.spend = new InferenceSpendOutbox({
+            store: options.spendStore,
+            // Reported on the login each answer was served on, which the outbox keeps with it: also once the key was removed.
+            report: async (accountIdArg, loginIdArg, answersArg, signalArg) => {
+                const client = this.authority.readyClient();
+                if (!this.ready || !client)
+                    throw new Error('The account service is unavailable.');
+                return client.recordSpend(accountIdArg, loginIdArg, answersArg, signalArg);
+            },
+            // The account service's answer counts the report's answers: it replaces the held reading as they leave the outbox.
+            acknowledged: (accountIdArg, usageArg) => this.usage.accept(accountIdArg, usageArg),
+            // An answer recorded without a login is reported on the key's live login, or the removed key's.
+            attribute: (accountIdArg) => findAuthorityApiKeyLogin(this.authority.getProjection(), accountIdArg)?.id,
         });
         this.observer = new InferenceUsageObserver({
             send: async (accountIdArg, reportArg, signalArg) => {
@@ -70,15 +92,21 @@ export class InferenceService {
             },
             usage: (accountIdArg, signalArg) => this.usage.get(accountIdArg, signalArg),
             // The account service holds a payment problem on the account's usage, which the cache then routes on.
-            reportPaymentProblem: async (accountIdArg, observedAtArg) => {
+            reportPaymentProblem: async (accountIdArg, observedAtArg, causeArg) => {
                 const client = this.authority.readyClient();
                 const login = findAuthorityGatewayLogin(this.authority.getProjection(), accountIdArg);
                 if (!this.ready || !client || typeof login === 'string')
                     throw new Error('The account login is unavailable.');
-                const usage = await client.reportPaymentProblem(accountIdArg, login.id, observedAtArg, this.abort.signal);
+                const usage = await client.reportPaymentProblem(accountIdArg, login.id, observedAtArg, this.abort.signal, inferencePaymentReportOptions(causeArg));
                 this.usage.accept(accountIdArg, usage);
             },
             resolveAccess: (accountIdArg, signalArg, rejectedGenerationArg) => this.access.resolveGateway(accountIdArg, AbortSignal.any([signalArg, this.abort.signal]), rejectedGenerationArg),
+            // Recorded on the login the route was served on, as the pool was read when the request was placed.
+            spend: {
+                record: (accountIdArg, loginIdArg, recordArg) => this.spend.record(accountIdArg, loginIdArg, recordArg),
+                held: (accountIdArg) => this.spend.held(accountIdArg),
+                uncounted: (accountIdArg, modelArg) => this.spend.uncounted(accountIdArg, modelArg),
+            },
         });
         this.gateway = new InferenceGateway({ router: this.router, signatureKey: options.signatureKey,
             affinity: options.affinity, placements: options.placements, usageLedger: options.usageLedger, port: options.port,
@@ -95,8 +123,10 @@ export class InferenceService {
             return undefined;
         return projection.snapshot.accounts.flatMap((account) => {
             const pool = findInferencePool(projection, account.id);
+            const login = findAuthorityGatewayLogin(projection, account.id);
             return pool ? [{ id: account.id, label: account.label, revision: String(account.revision), providerId: pool.provider,
-                    credential: pool.credential, maxUsagePercent: account.maxUsagePercent, reserveLiftUntil: account.reserveLiftUntil, lapsesAt: account.lapsesAt }] : [];
+                    credential: pool.credential, maxUsagePercent: account.maxUsagePercent, reserveLiftUntil: account.reserveLiftUntil, lapsesAt: account.lapsesAt,
+                    spendLimitMicroUsd: account.spendLimitMicroUsd, loginId: typeof login === 'string' ? null : login.id }] : [];
         });
     }
     /**
@@ -125,6 +155,8 @@ export class InferenceService {
                     incarnationId: binding.incarnationId, expectedRevision: binding.revision }, signal);
             }
             this.ready = true;
+            // The answers a run before left unacknowledged count from the start, before any request is placed, and are sent.
+            await this.spend.start(signal);
             return this.baseUrl;
         }
         catch (errorArg) {
@@ -147,17 +179,18 @@ export class InferenceService {
     /**
      * The gateway's state, each pool account judged on the usage reading a request would route on now -- the account
      * service's answer from its own cache (`InferenceUsageCache.current`), so a pool no request used since the proxy
-     * started is judged as its next request would judge it -- the subscription account each provider's next new client
-     * session goes to, and the latest placements the journal holds.
+     * started is judged as its next request would judge it -- the account each provider's next new session of a client
+     * that names no credential goes to (a subscription while one takes it, else an API key), and the latest placements the
+     * journal holds.
      */
     async status(signalArg) {
         const pool = this.poolAccounts() ?? [];
-        const readings = new Map(await Promise.all(pool.filter((accountArg) => accountArg.credential === 'subscription')
+        // A key's usage is its month's spend, with the payment problem the account service holds on it.
+        const readings = new Map(await Promise.all(pool
             .map(async (accountArg) => [accountArg.id, await this.usage.current(accountArg.id, signalArg)])));
         const accounts = this.router.accountStatus(pool, (accountIdArg) => readings.get(accountIdArg));
         const recent = await this.options.placements.recent(recentPlacementCount, signalArg);
-        const next = (providerArg) => accounts.find((accountArg) => accountArg.provider === providerArg && accountArg.credential === 'subscription'
-            && accountArg.placementRank === 1)?.id ?? null;
+        const next = (providerArg) => accounts.find((accountArg) => accountArg.provider === providerArg && accountArg.placementRank === 1)?.id ?? null;
         return { ...this.gateway.status(), baseUrl: this.baseUrl ?? '', usageObservations: this.observer.status(),
             authority: this.ready && this.authority.getProjection().state === 'ready' ? 'ready' : 'unavailable',
             accounts,
@@ -173,20 +206,26 @@ export class InferenceService {
                 await this.gateway.stop();
             }
             finally {
-                // Hand-overs in flight end before the authority connection closes under them.
+                // Hand-overs in flight end before the authority connection closes under them; the answers the gateway ended are
+                // in the outbox, which keeps what it holds for the next start.
                 try {
                     await this.observer.stop();
                 }
                 finally {
                     try {
-                        await this.access.stop();
+                        await this.spend.stop();
                     }
                     finally {
-                        await this.authority.stop();
+                        try {
+                            await this.access.stop();
+                        }
+                        finally {
+                            await this.authority.stop();
+                        }
                     }
                 }
             }
         })();
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.inferenceservice.js","sourceRoot":"","sources":["../../ts/classes.inferenceservice.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.inferenceservice.js","sourceRoot":"","sources":["../../ts/classes.inferenceservice.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.inferencespend.d.ts

@@ -0,0 +1,339 @@
+import * as plugins from './plugins.js';
+type TSpendAnswer = plugins.authswitchAuthority.IAuthSwitchSpendAnswer;
+type TUsageSnapshot = plugins.authswitchAuthority.IAuthSwitchUsageSnapshot;
+/**
+ * The `type` of every server tool a Messages request declares: each tool whose type is neither absent nor one of the
+ * client tools (`anthropicClientToolTypes`); a type that is no string is named as it reads.
+ */
+export declare const inferenceAnthropicServerToolTypes: (bodyArg: Record<string, unknown>) => string[];
+/**
+ * What of an Anthropic Messages request the proxy's price table (flexharness `getAnthropicModelPrice`,
+ * `getAnthropicRequestPrice`, `getAnthropicServerToolPrice`) cannot price, in words, or `undefined` when all of it can
+ * be: the model; a service tier other than `auto` and `standard_only`, the two a request may name
+ * (https://platform.claude.com/docs/en/api/service-tiers, read 2026-10-22), as the proxy sends a key with a spend limit
+ * on the standard tier only; a speed the model has no price for (`speed: "fast"` is Fast mode); an `inference_geo` the
+ * model has no surcharge for; a server tool whose exact type has no price, Anthropic's MCP connector included. A key
+ * with a monthly spend limit takes no such request, since its answer could not be priced (Decision Q4). The answer is
+ * still priced by the model that answered and what its usage states, never by this.
+ */
+export declare const inferenceAnthropicUnpricedRequest: (bodyArg: Record<string, unknown>) => string | undefined;
+/**
+ * The bytes a request goes to an Anthropic API key with a spend limit as: the body the price check read
+ * (`inferenceAnthropicUnpricedRequest`), encoded again with `service_tier: "standard_only"`, so it is served on the
+ * standard tier the price table prices and never on Priority Tier, which has no published price (lane A ruling 6), and
+ * Anthropic receives exactly what was checked -- also when the client named `standard_only` itself.
+ */
+export declare const inferenceAnthropicCheckedBytes: (bodyArg: Record<string, unknown>) => Uint8Array<ArrayBuffer>;
+/** What a relayed answer stated about its usage, as the gateway's usage tap read it while the answer passed. */
+export interface IInferenceAnsweredUsage {
+    /** The model that answered, as the answer named it; absent when it named none the tap could read. */
+    model?: string;
+    /**
+     * The answer's usage object as the provider sent it -- a stream's merged from `message_start` and the `message_delta`s
+     * after it -- absent when the answer stated none.
+     */
+    usage?: Record<string, unknown>;
+    /** The answer arrived whole: a JSON body read to its end, or a stream through `message_stop`. */
+    complete: boolean;
+}
+/** One answer's spend as the outbox keeps it, and why it could not be priced when it could not. */
+export interface IInferenceSpendRecord {
+    answer: TSpendAnswer;
+    /** Why the answer could not be priced (`answer.microUsd` is then null). */
+    unpriced?: string;
+}
+/**
+ * The spend of an answer an Anthropic API key served, priced once by the model that answered and the usage it stated
+ * (`readAnthropicMessagesUsage`, `priceModelCall`), never by the requested model, with the call fees of the server tools
+ * the request declared (`serverToolTypesArg`, `getAnthropicRequestPrice`). An answer whose model has no price, whose usage
+ * cannot be read completely or priced -- a tier, a cache lifetime, a server tool or a region the price lacks -- counts
+ * as one that could not be priced (`microUsd: null`), which holds a key with a spend limit until its month ends. A stream
+ * cut before it stated any usage records nothing: the client received no token of it; one cut later is priced on the
+ * usage it stated by then. `requestedModelArg` names the answer when it named no model.
+ */
+export declare const inferenceAnthropicSpend: (answeredArg: IInferenceAnsweredUsage, requestedModelArg: string, nowArg: number, serverToolTypesArg?: readonly string[]) => IInferenceSpendRecord | undefined;
+/**
+ * The `type` of every server tool a Responses request declares, in `tools` and in the tools its input adds
+ * (`additional_tools` and `tool_search_output` items), a namespace's own tools included: each tool that is no client
+ * tool (`openAiClientToolTypes`, a local `shell`); a type that is no string is named as it reads.
+ */
+export declare const inferenceOpenAiServerToolTypes: (bodyArg: Record<string, unknown>) => string[];
+/**
+ * What of a Responses request the proxy's price table (flexharness `getOpenAiModelPrice`) cannot price, in words, or
+ * `undefined` when all of it can be: the model, by its exact id or a listed snapshot (a dated id the price lists not is
+ * unpriced); an explicit service tier the model has no price for (`auto` and none go out as `default`; `fast` names
+ * Fast mode; `scale` has no published price); a background response (`background: true`), whose answer never passes the
+ * proxy; a server tool whose exact type has no call fee (`inferenceOpenAiServerToolTypes`). An OpenAI API key with a
+ * monthly spend limit takes no such request (Decision Q4).
+ */
+export declare const inferenceOpenAiUnpricedRequest: (bodyArg: Record<string, unknown>) => string | undefined;
+/**
+ * The bytes a Responses request goes to an OpenAI API key with a spend limit as: the body the price check read
+ * (`inferenceOpenAiUnpricedRequest`), the model rewritten to `wireModelArg`, encoded again with the service tier it was
+ * checked for (`default` when the client named `auto` or none), so OpenAI serves it on a tier the price table prices.
+ */
+export declare const inferenceOpenAiCheckedBytes: (bodyArg: Record<string, unknown>, wireModelArg: string) => Uint8Array<ArrayBuffer>;
+/** What a relayed Responses answer stated for its price, as the gateway's usage tap read it while the answer passed. */
+export interface IInferenceResponsesAnswered {
+    /**
+     * How the answer ended: `answered`, its terminal event (`response.completed`, `response.incomplete`,
+     * `response.failed`) or its JSON body was read; `unreadable`, it arrived but was too large to read (over 8 MiB);
+     * `cut`, it ended before either arrived -- the client left, or the provider's stream ended or failed.
+     */
+    outcome: 'answered' | 'unreadable' | 'cut';
+    /** The response's `status` as stated (`completed`, `incomplete`, `failed`). */
+    status?: string;
+    /** The model that answered (`response.model`). */
+    model?: string;
+    /** The service tier that served it (`response.service_tier`), as stated. */
+    serviceTier?: unknown;
+    /** The response's `usage` object as sent; absent when it stated none. */
+    usage?: Record<string, unknown>;
+    /** The ids of the answer's `web_search_call` and `file_search_call` items, each once, whatever its action. */
+    webSearchCalls: ReadonlySet<string>;
+    fileSearchCalls: ReadonlySet<string>;
+    /** A web or file search call without an id, which cannot be counted once. */
+    unidentifiedCalls: boolean;
+}
+/**
+ * The spend of a Responses answer an OpenAI API key served, priced once by the model that answered, the tier that served
+ * it and the usage it stated (`readOpenAiResponsesUsage`, `priceModelCall`), with every `web_search_call` item one web
+ * search and every `file_search_call` item one file search, counted once per item id whatever its action -- so AGL's
+ * figure can exceed OpenAI's bill. A completed, incomplete or failed answer that states its usage is priced; one whose
+ * model, tier or usage the price table cannot price counts as one that could not be priced (`microUsd: null`), which
+ * holds a key with a spend limit until its month ends, and so does one that arrived too large to read, or a completed
+ * or incomplete one that states no usage. A failed answer that states none, and one cut before its terminal event,
+ * record nothing (`undefined`): no usage is estimated, and the caller says so in the journal.
+ */
+export declare const inferenceOpenAiSpend: (answeredArg: IInferenceResponsesAnswered, requestedModelArg: string, nowArg: number) => IInferenceSpendRecord | undefined;
+/**
+ * One answer the proxy relayed on an API key, as its outbox keeps it until the accounts service acknowledged its cost:
+ * the spend report answer (`IAuthSwitchSpendAnswer`, its `answerId` as `id`) and the key's account. No prompt, answer
+ * content, token count or credential is part of it.
+ */
+export interface IInferenceSpendDocument {
+    /** The answer's id (`IAuthSwitchSpendAnswer.answerId`), a UUID. */
+    id: string;
+    /** The API key's account. */
+    accountId: string;
+    /**
+     * The key's login the answer was served on, which its report names, also once the key is removed; `null` when none
+     * could be named, so the answer waits, counted, until one can (`IInferenceSpendOutboxOptions.attribute`).
+     */
+    loginId: string | null;
+    endedAt: string;
+    model: string;
+    serviceTier: string | null;
+    microUsd: number | null;
+    priceSource: string | null;
+}
+export declare class InferenceSpendModel extends plugins.nosqldb.SmartDataDbDoc<InferenceSpendModel, IInferenceSpendDocument> {
+    static exact: plugins.nosqldb.TExact<InferenceSpendModel>;
+    id: string;
+    accountId: string;
+    loginId: string | null;
+    endedAt: string;
+    model: string;
+    serviceTier: string | null;
+    microUsd: number | null;
+    priceSource: string | null;
+}
+/** An answer the outbox keeps, with its key's account and the login it was served on (`null`: none named yet). */
+export interface IInferenceSpendEntry {
+    accountId: string;
+    loginId: string | null;
+    answer: TSpendAnswer;
+}
+/** The outbox's durable side: the answers kept in the proxy's own database until acknowledged. */
+export interface IInferenceSpendStore {
+    /** Every answer kept. */
+    load(signalArg: AbortSignal): Promise<IInferenceSpendEntry[]>;
+    /** Keeps an answer; one kept already with the same content is kept. */
+    insert(entryArg: IInferenceSpendEntry, signalArg: AbortSignal): Promise<void>;
+    /** Forgets answers by id; one forgotten already is forgotten. */
+    delete(answerIdsArg: readonly string[], signalArg: AbortSignal): Promise<void>;
+}
+/** The outbox's store in the proxy's database (`agl_inference_spend`, a model of `proxyModels`). */
+export declare class InferenceSpendStore implements IInferenceSpendStore {
+    load(signalArg: AbortSignal): Promise<IInferenceSpendEntry[]>;
+    insert(entryArg: IInferenceSpendEntry, signalArg: AbortSignal): Promise<void>;
+    delete(answerIdsArg: readonly string[], signalArg: AbortSignal): Promise<void>;
+}
+/**
+ * Something the outbox says in the proxy's journal: an answer that could not be priced (`unpriced`, an accounting
+ * error), a report the accounts service refused (`refused`), a key whose reports keep failing (`unreported`, said once
+ * until one goes through), answers the store could not keep (`unkept`) or acknowledged answers it could not remove
+ * (`unremoved`), each said once until the store takes writes again, an answer recorded with no login of its key
+ * (`unattributed`), and each answer that ended without its provider stating its usage, which counts nowhere (`uncounted`).
+ * Keys are named by their account's digest.
+ */
+export type TInferenceSpendJournalEntry = {
+    kind: 'unpriced';
+    account: string;
+    model: string;
+    reason: string;
+} | {
+    kind: 'refused';
+    account: string;
+    answers: number;
+    error: string;
+    retryAt: string;
+} | {
+    kind: 'unreported';
+    account: string;
+    answers: number;
+    error: string;
+} | {
+    kind: 'unkept';
+    answers: number;
+    error: string;
+} | {
+    kind: 'unremoved';
+    answers: number;
+    error: string;
+} | {
+    kind: 'unattributed';
+    account: string;
+    model: string;
+} | {
+    kind: 'uncounted';
+    account: string;
+    model: string;
+};
+export interface IInferenceSpendOutboxOptions {
+    store: IInferenceSpendStore;
+    /**
+     * Sends one report of answers a key served on one of its logins (`authswitch.authority.usage.spend`, one to 64 answers,
+     * each id once) and resolves with the key's usage the accounts service answered once the report committed.
+     */
+    report: (accountIdArg: string, loginIdArg: string, answersArg: TSpendAnswer[], signalArg: AbortSignal) => Promise<TUsageSnapshot>;
+    /**
+     * Names a login of the key for answers recorded without one -- the account service's live or removed API-key login of
+     * it -- or `undefined` while it names none; such answers count and hold the key until then.
+     */
+    attribute: (accountIdArg: string) => string | undefined;
+    /**
+     * Holds the usage an acknowledged report answered, which counts the report's answers: called in the same synchronous
+     * step that drops them from what is pending, so no reading is judged without them or with them twice.
+     */
+    acknowledged: (accountIdArg: string, usageArg: TUsageSnapshot) => void;
+    /** Where the outbox's journal entries go; one line on standard error, the proxy's journal, when unset. */
+    journal?: (entryArg: TInferenceSpendJournalEntry) => void;
+    now?: () => number;
+    /** The first wait after a report or a store write failed for a passing reason; it doubles up to `maxRetryMs`. */
+    retryMs?: number;
+    maxRetryMs?: number;
+    /** How long answers whose report the accounts service refused wait before they are sent again. */
+    heldRetryMs?: number;
+}
+/**
+ * The spend of the answers the proxy relayed on API keys, kept until the accounts service acknowledged it: durable in
+ * the proxy's database (`agl_inference_spend`), never expired, and counted against each key's limit while unacknowledged
+ * (`judged`), across restarts.
+ *
+ * `record` counts an answer at once and writes it to the store at once, on a chain of store writes that never waits for
+ * a report, so an answer recorded while a report is in flight is durable before that report settles. Answers are
+ * reported whether the store kept them yet or not -- the ledger records an answer once, so either makes it durable --
+ * per key and login in batches of at most 64 unique answers, one report in flight at a time, the first as soon as an
+ * answer is recorded and every one at start. An answer held in neither after a failed store write holds its key, with
+ * a spend limit, like a refused report (`held`). The in-memory index is complete because the proxy store has one owner
+ * (`ProxyStore` refuses a second engine); a second writer of `agl_inference_spend` would break it.
+ * An acknowledgement drops the report's answers and holds the usage the service answered in one step (`acknowledged`).
+ * A refusal of the report -- `invalid_input`, or a malformed request (`isAuthSwitchMalformedRequest`) -- holds its
+ * answers: they keep counting, the key with a spend limit takes no request while any is held (`held`), the refusal goes
+ * to the journal, and the answers are sent again after `heldRetryMs` and at every start, never dropped. Every other
+ * failure, `Internal server error` included, is passing: the key's reports wait, doubling from `retryMs` to
+ * `maxRetryMs`. Answers of months before the previous one are acknowledged by the service and counted nowhere, so they
+ * leave as every acknowledged answer does.
+ */
+export declare class InferenceSpendOutbox {
+    private readonly options;
+    /** The answers not acknowledged yet, by key, then answer id: an id is held once, so no report names one twice. */
+    private readonly entries;
+    private readonly accounts;
+    /** Acknowledged answers still to be removed from the store. */
+    private readonly acknowledgedIds;
+    private readonly abort;
+    private readonly now;
+    private readonly retryMs;
+    private readonly maxRetryMs;
+    private readonly heldRetryMs;
+    /** The store writes of recorded answers, one at a time, apart from the reports. */
+    private keepTail;
+    private keepFailures;
+    private keepRetryAt;
+    private keepSaid;
+    private keepTimer?;
+    private forgetFailures;
+    private forgetRetryAt;
+    private forgetSaid;
+    private started;
+    private stopped;
+    private running?;
+    private again;
+    private timer?;
+    constructor(options: IInferenceSpendOutboxOptions);
+    /** Loads the answers a run before left unacknowledged and sends them all now. */
+    start(signalArg?: AbortSignal): Promise<void>;
+    /**
+     * Counts a relayed answer's spend at once, writes it to the store and reports it, naming the key's login it was served
+     * on (`loginIdArg`), until the accounts service acknowledged it; an answer that could not be priced goes to the journal
+     * as well. One recorded without a login (`null`) counts all the same, holds the key (`held`) and waits for a login to
+     * be named (`attribute`), which the journal says. Throws for an answer no report could carry, a defect of its caller.
+     */
+    record(accountIdArg: string, loginIdArg: string | null, recordArg: IInferenceSpendRecord): void;
+    /**
+     * Says in the journal that an answer relayed on the key ended without its provider stating its usage -- the client left,
+     * the stream was cut, or the response failed stating none -- so nothing of it is counted; no usage is estimated for it
+     * (`inferenceOpenAiSpend`).
+     */
+    uncounted(accountIdArg: string, modelArg: string): void;
+    /** The answers relayed on a key whose spend the accounts service has not acknowledged yet. */
+    pending(accountIdArg: string): plugins.authswitchSpend.IAuthSwitchSpendPending[];
+    /**
+     * Whether spend of the key is not recorded and might never be: the accounts service refused a report of its answers
+     * that is still held, an answer is held in neither the store, whose write failed, nor the accounts service's ledger,
+     * or an answer has no login of the key to be reported on yet.
+     */
+    held(accountIdArg: string): boolean;
+    /**
+     * A key's usage as the proxy judges it now: its spend reading with the answers not acknowledged yet added, in the
+     * month now falls in (`authSwitchSpendWithPending`). Any other usage is answered as it is.
+     */
+    judged(accountIdArg: string, usageArg: TUsageSnapshot): TUsageSnapshot;
+    /**
+     * Stops sending; what is held stays in the store for the next start. The store writes in progress finish, and what is
+     * still not kept or not removed is written once more.
+     */
+    stop(): Promise<void>;
+    private add;
+    private say;
+    /** Runs the outbox's work now, or once more after the run in progress. */
+    private kick;
+    /** Removes what was acknowledged from the store, then sends every report that is due. */
+    private cycle;
+    /**
+     * Writes the recorded answers not kept yet to the store, on the outbox's chain of store writes, which runs apart from
+     * the reports and never waits for one; once they are kept the reports run. After a failed write the next waits,
+     * doubling from `retryMs`, unless an answer recorded meanwhile, or the stop, tries again sooner.
+     */
+    private keep;
+    /**
+     * One pass of the store writes: every answer not kept yet, one at a time. A write that fails is said once until the
+     * store takes writes again; the answers count meanwhile all the same.
+     */
+    private keepOnce;
+    /** Removes the acknowledged answers from the store; a failed removal waits, doubling, said once. */
+    private forget;
+    /**
+     * The next report due: a key's held answers once their wait ended, as a report of their own, else its other answers,
+     * kept or not; of one login, oldest first, at most 64, each id once. Answers recorded without a login take the one
+     * `attribute` names now; while it names none they wait, the key's reports backing off as after a passing failure.
+     */
+    private nextBatch;
+    private send;
+    private backoff;
+    /** Wakes the reports when the next held or waiting answer, or a removal to try again, is due. */
+    private arm;
+}
+export {};