agl 40.4.0 → 40.5.0

package/dist_ts/classes.inferencespend.js

@@ -0,0 +1,815 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import * as plugins from './plugins.js';
+const hex64 = /^[a-f0-9]{64}$/;
+/** A service tier as a spend answer names it (`IAuthSwitchSpendAnswer.serviceTier`). */
+const serviceTierPattern = /^[a-z][a-z0-9_-]{0,63}$/;
+const isRecord = (valueArg) => typeof valueArg === 'object' && valueArg !== null && !Array.isArray(valueArg);
+/** The record's entry for a name the record itself holds, never one inherited from `Object.prototype`. */
+const own = (recordArg, keyArg) => recordArg !== undefined && Object.prototype.hasOwnProperty.call(recordArg, keyArg) ? recordArg[keyArg] : undefined;
+/** An error in one line, as the proxy's journal states it: its class and its own words, which carry no credential. */
+const oneLine = (errorArg) => (errorArg instanceof Error ? `${errorArg.name}: ${errorArg.message}` : String(errorArg)).replace(/\s+/gu, ' ');
+/** An account as the journal names it: the first 12 hex characters of the SHA-256 digest of its id. */
+const accountDigest = (accountIdArg) => plugins.crypto.createHash('sha256').update(accountIdArg).digest('hex').slice(0, 12);
+// Pricing ---------------------------------------------------------------------------------------------------------
+/**
+ * The tool types of the Messages API whose calls the caller runs itself, so a request carrying them costs tokens only:
+ * a tool the caller defines (no `type`, or `custom`) and Anthropic's client tools and client toolsets, as Anthropic's
+ * tool reference lists them (https://platform.claude.com/docs/en/agents-and-tools/tool-use/tool-reference, read
+ * 2026-10-22). Every other type is a tool Anthropic runs, a server tool, priced by its exact type
+ * (`getAnthropicServerToolPrice`) or not at all. Claude Code 2.1.306 declares its own tools, its tool search included,
+ * as `custom` ones; its WebSearch runs in a request of its own with `web_search_20250305`, and `advisor_20260301` comes
+ * only with an `advisorModel` setting.
+ */
+const anthropicClientToolTypes = new Set(['custom', 'memory_20250818', 'bash_20250124',
+    'text_editor_20250728', 'text_editor_20250124', 'computer_toolset_20260801', 'computer_20251124', 'computer_20250124',
+    'browser_toolset_20260801']);
+/**
+ * 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 const inferenceAnthropicServerToolTypes = (bodyArg) => (Array.isArray(bodyArg.tools) ? bodyArg.tools : []).flatMap((toolArg) => {
+    const type = isRecord(toolArg) ? toolArg.type : undefined;
+    if (type === undefined || type === null || (typeof type === 'string' && anthropicClientToolTypes.has(type)))
+        return [];
+    return [typeof type === 'string' ? type : JSON.stringify(type)];
+});
+/**
+ * The price of a request's answers: the model's, with the call fees of the server tools the request declares
+ * (`getAnthropicRequestPrice`); `undefined` when the model or one of the tools has no price.
+ */
+const anthropicRequestPrice = (modelArg, serverToolTypesArg) => {
+    const price = plugins.anthropicProvider.getAnthropicModelPrice(modelArg);
+    return price && plugins.anthropicProvider.getAnthropicRequestPrice(price, serverToolTypesArg);
+};
+/**
+ * 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 const inferenceAnthropicUnpricedRequest = (bodyArg) => {
+    const model = typeof bodyArg.model === 'string' ? bodyArg.model : '';
+    const price = plugins.anthropicProvider.getAnthropicModelPrice(model);
+    if (!price)
+        return `the model ${model}, which AGL's price table does not list`;
+    const tier = bodyArg.service_tier;
+    if (tier !== undefined && tier !== null && tier !== 'auto' && tier !== 'standard_only') {
+        return `the service tier ${JSON.stringify(tier)}, of which only "auto" and "standard_only" go to a key with a spend limit`;
+    }
+    const speed = bodyArg.speed;
+    const service = speed === undefined || speed === null || speed === 'standard' ? 'standard' : speed === 'fast' ? 'fast' : undefined;
+    if (service === undefined || own(price.services, service) === undefined) {
+        return `the speed ${JSON.stringify(speed)} of ${model}, which AGL's price table does not price`;
+    }
+    const geo = bodyArg.inference_geo;
+    if (geo !== undefined && geo !== null && geo !== 'global'
+        && (typeof geo !== 'string' || own(price.surcharges, `inference_geo:${geo}`) === undefined)) {
+        return `inference_geo ${JSON.stringify(geo)} on ${model}, which AGL's price table does not price`;
+    }
+    if (Array.isArray(bodyArg.mcp_servers) && bodyArg.mcp_servers.length > 0) {
+        return 'the MCP connector (mcp_servers), whose calls AGL\'s price table does not price';
+    }
+    const serverTools = inferenceAnthropicServerToolTypes(bodyArg);
+    let requestPrice;
+    try {
+        requestPrice = plugins.anthropicProvider.getAnthropicRequestPrice(price, serverTools);
+    }
+    catch {
+        return `the server tools ${serverTools.map((typeArg) => JSON.stringify(typeArg)).join(', ')}, whose fees AGL's price `
+            + 'table states twice';
+    }
+    if (requestPrice)
+        return undefined;
+    const unpricedTool = serverTools.find((typeArg) => plugins.anthropicProvider.getAnthropicServerToolPrice(typeArg) === undefined);
+    return `the server tool ${JSON.stringify(unpricedTool)}, whose calls AGL's price table does not price`;
+};
+/**
+ * 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 const inferenceAnthropicCheckedBytes = (bodyArg) => new TextEncoder().encode(JSON.stringify({ ...bodyArg, service_tier: 'standard_only' }));
+/**
+ * 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 const inferenceAnthropicSpend = (answeredArg, requestedModelArg, nowArg, serverToolTypesArg = []) => {
+    if (!answeredArg.usage && !answeredArg.complete)
+        return undefined;
+    const model = [answeredArg.model, requestedModelArg].find((modelArg) => plugins.authswitchUsageTokens.isAuthSwitchModelId(modelArg));
+    if (model === undefined)
+        throw new Error('A relayed answer names no model a spend report takes.');
+    const reportedTier = answeredArg.usage?.service_tier;
+    const answer = { answerId: plugins.crypto.randomUUID(), endedAt: new Date(nowArg).toISOString(), model,
+        serviceTier: typeof reportedTier === 'string' && serviceTierPattern.test(reportedTier) ? reportedTier : null };
+    const unpriced = (reasonArg) => ({ answer: { ...answer, microUsd: null, priceSource: null }, unpriced: reasonArg });
+    if (!answeredArg.usage)
+        return unpriced('the answer stated no usage');
+    let usage;
+    try {
+        usage = plugins.anthropicProvider.readAnthropicMessagesUsage(answeredArg.usage);
+    }
+    catch (errorArg) {
+        if (errorArg instanceof plugins.flexModels.ModelUsageReadError)
+            return unpriced(errorArg.message);
+        throw errorArg;
+    }
+    if (!plugins.anthropicProvider.getAnthropicModelPrice(model))
+        return unpriced(`AGL's price table does not list the model ${model}`);
+    let price;
+    try {
+        price = anthropicRequestPrice(model, serverToolTypesArg);
+    }
+    catch (errorArg) {
+        return unpriced(`AGL's price table disagrees with itself: ${oneLine(errorArg)}`);
+    }
+    if (!price)
+        return unpriced(`AGL's price table has no price for a server tool the request declared (${serverToolTypesArg.join(', ')})`);
+    const cost = plugins.flexModels.priceModelCall(price, usage);
+    if (!cost.priced)
+        return unpriced(`AGL's price table could not price it (${cost.reason}, service ${usage.service})`);
+    if (cost.microUsd > plugins.authswitchAuthority.authSwitchSpendAnswerMaxMicroUsd) {
+        return unpriced(`its price of ${cost.microUsd} micro-dollars is beyond what one answer can cost`);
+    }
+    return { answer: { ...answer, microUsd: cost.microUsd, priceSource: price.source.checkedAt } };
+};
+/**
+ * The tool types of the Responses API whose calls the caller runs itself, so a request declaring them costs tokens only,
+ * as OpenAI's Responses reference lists its tools (https://developers.openai.com/api/reference/resources/responses/methods/create
+ * and https://developers.openai.com/api/docs/guides/tools, read 2026-10-22): a function (`function`), a custom tool
+ * (`custom`), the local shell (`local_shell`), apply patch (`apply_patch`) and computer use (`computer`,
+ * `computer_use_preview`), whose calls the caller executes and answers. Two types are client tools in one mode only:
+ * `shell` with `environment.type: "local"` -- in a container OpenAI runs it
+ * (https://developers.openai.com/api/docs/guides/tools-shell) -- and `tool_search` with `execution: "client"`, whose
+ * search the caller runs and answers with a `tool_search_output` item; hosted, OpenAI runs it
+ * (https://developers.openai.com/api/docs/guides/tools-tool-search, read 2026-10-23). A `namespace` groups function and
+ * custom tools, each judged on its own. Every other type is a tool OpenAI runs, a server tool, priced only by the fee of
+ * its exact type (`IModelPrice.toolCallFees`: `web_search`, `file_search`), so `web_search_preview` and a dated
+ * `web_search_2025_08_26` have no price. Codex 0.163 sends `function`, `custom`, `tool_search` (`execution: "client"`)
+ * and `web_search` (`test/e2e/e2e.proxyspendcodex.node.ts`).
+ */
+const openAiClientToolTypes = new Set(['function', 'custom', 'local_shell', 'apply_patch', 'computer',
+    'computer_use_preview']);
+/**
+ * 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 const inferenceOpenAiServerToolTypes = (bodyArg) => {
+    const declared = (toolsArg) => (Array.isArray(toolsArg) ? toolsArg : []).flatMap((toolArg) => {
+        const tool = isRecord(toolArg) ? toolArg : {};
+        const type = tool.type;
+        if (type === 'namespace')
+            return declared(tool.tools);
+        if ((typeof type === 'string' && openAiClientToolTypes.has(type))
+            || (type === 'shell' && isRecord(tool.environment) && tool.environment.type === 'local')
+            || (type === 'tool_search' && tool.execution === 'client'))
+            return [];
+        return [typeof type === 'string' ? type : String(JSON.stringify(type))];
+    });
+    const added = (Array.isArray(bodyArg.input) ? bodyArg.input : []).flatMap((itemArg) => isRecord(itemArg)
+        && (itemArg.type === 'additional_tools' || itemArg.type === 'tool_search_output') ? declared(itemArg.tools) : []);
+    return [...declared(bodyArg.tools), ...added];
+};
+/**
+ * The service tier a Responses request goes to an OpenAI API key with a spend limit on: the one the client named when it
+ * named a tier the price table prices for the model, else Standard (`default`), never `auto`, which a project set to Fast
+ * serves at Fast prices (`readme` of flexharness-providers' OpenAI provider).
+ */
+const openAiCheckedTier = (bodyArg) => typeof bodyArg.service_tier === 'string' && bodyArg.service_tier !== 'auto' ? bodyArg.service_tier : 'default';
+/**
+ * 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 const inferenceOpenAiUnpricedRequest = (bodyArg) => {
+    const model = typeof bodyArg.model === 'string' ? bodyArg.model : '';
+    const price = plugins.openAiProvider.getOpenAiModelPrice(model);
+    if (!price)
+        return `the model ${model}, which AGL's price table does not list`;
+    const tier = bodyArg.service_tier;
+    if (tier !== undefined && tier !== null && tier !== 'auto'
+        && (typeof tier !== 'string' || own(price.services, tier) === undefined)) {
+        return `the service tier ${JSON.stringify(tier)} of ${model}, which AGL's price table does not price`;
+    }
+    if (bodyArg.background === true) {
+        return 'a background response (background: true), whose answer does not pass the proxy to be priced';
+    }
+    const unpricedTool = inferenceOpenAiServerToolTypes(bodyArg).find((typeArg) => own(price.toolCallFees, typeArg) === undefined);
+    return unpricedTool === undefined ? undefined
+        : `the server tool ${JSON.stringify(unpricedTool)}, whose calls AGL's price table does not price`;
+};
+/**
+ * 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 const inferenceOpenAiCheckedBytes = (bodyArg, wireModelArg) => new TextEncoder().encode(JSON.stringify({ ...bodyArg, model: wireModelArg, service_tier: openAiCheckedTier(bodyArg) }));
+/**
+ * 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 const inferenceOpenAiSpend = (answeredArg, requestedModelArg, nowArg) => {
+    if (answeredArg.outcome === 'cut' || (answeredArg.outcome === 'answered' && !answeredArg.usage && answeredArg.status === 'failed')) {
+        return undefined;
+    }
+    const model = [answeredArg.model, requestedModelArg].find((modelArg) => plugins.authswitchUsageTokens.isAuthSwitchModelId(modelArg));
+    if (model === undefined)
+        throw new Error('A relayed answer names no model a spend report takes.');
+    const tier = answeredArg.serviceTier;
+    const answer = { answerId: plugins.crypto.randomUUID(), endedAt: new Date(nowArg).toISOString(), model,
+        serviceTier: typeof tier === 'string' && serviceTierPattern.test(tier) ? tier : null };
+    const unpriced = (reasonArg) => ({ answer: { ...answer, microUsd: null, priceSource: null }, unpriced: reasonArg });
+    if (answeredArg.outcome === 'unreadable')
+        return unpriced('its final event was too large to read');
+    if (!answeredArg.usage)
+        return unpriced('the answer stated no usage');
+    if (answeredArg.unidentifiedCalls)
+        return unpriced('it holds a web or file search call without an id, which cannot be counted once');
+    let usage;
+    try {
+        usage = plugins.openAiProvider.readOpenAiResponsesUsage(answeredArg.usage, tier);
+    }
+    catch (errorArg) {
+        if (errorArg instanceof plugins.flexModels.ModelUsageReadError)
+            return unpriced(errorArg.message);
+        throw errorArg;
+    }
+    const price = plugins.openAiProvider.getOpenAiModelPrice(model);
+    if (!price)
+        return unpriced(`AGL's price table does not list the model ${model}`);
+    const toolCalls = {
+        ...(answeredArg.webSearchCalls.size ? { web_search: answeredArg.webSearchCalls.size } : {}),
+        ...(answeredArg.fileSearchCalls.size ? { file_search: answeredArg.fileSearchCalls.size } : {}),
+    };
+    const cost = plugins.flexModels.priceModelCall(price, { ...usage, toolCalls });
+    if (!cost.priced)
+        return unpriced(`AGL's price table could not price it (${cost.reason}, service ${usage.service})`);
+    if (cost.microUsd > plugins.authswitchAuthority.authSwitchSpendAnswerMaxMicroUsd) {
+        return unpriced(`its price of ${cost.microUsd} micro-dollars is beyond what one answer can cost`);
+    }
+    return { answer: { ...answer, microUsd: cost.microUsd, priceSource: price.source.checkedAt } };
+};
+const answerOf = (documentArg) => ({ answerId: documentArg.id,
+    endedAt: documentArg.endedAt, model: documentArg.model, serviceTier: documentArg.serviceTier,
+    microUsd: documentArg.microUsd, priceSource: documentArg.priceSource });
+const assertDocument = (valueArg) => {
+    const value = valueArg;
+    if (!isRecord(value) || Object.keys(value).length !== 8 || typeof value.accountId !== 'string' || !hex64.test(value.accountId)
+        || (value.loginId !== null && (typeof value.loginId !== 'string' || !hex64.test(value.loginId)))
+        || !plugins.authswitchAuthority.isAuthSwitchSpendAnswer(answerOf(value))) {
+        throw new Error('Invalid inference spend answer.');
+    }
+};
+let InferenceSpendModel = (() => {
+    let _classDecorators = [plugins.nosqldb.managed({ collectionName: 'agl_inference_spend' }), plugins.nosqldb.exactPersistence({ assertDocument })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = plugins.nosqldb.SmartDataDbDoc;
+    let _id_decorators;
+    let _id_initializers = [];
+    let _id_extraInitializers = [];
+    let _accountId_decorators;
+    let _accountId_initializers = [];
+    let _accountId_extraInitializers = [];
+    let _loginId_decorators;
+    let _loginId_initializers = [];
+    let _loginId_extraInitializers = [];
+    let _endedAt_decorators;
+    let _endedAt_initializers = [];
+    let _endedAt_extraInitializers = [];
+    let _model_decorators;
+    let _model_initializers = [];
+    let _model_extraInitializers = [];
+    let _serviceTier_decorators;
+    let _serviceTier_initializers = [];
+    let _serviceTier_extraInitializers = [];
+    let _microUsd_decorators;
+    let _microUsd_initializers = [];
+    let _microUsd_extraInitializers = [];
+    let _priceSource_decorators;
+    let _priceSource_initializers = [];
+    let _priceSource_extraInitializers = [];
+    var InferenceSpendModel = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _id_decorators = [plugins.nosqldb.unI()];
+            _accountId_decorators = [plugins.nosqldb.svDb()];
+            _loginId_decorators = [plugins.nosqldb.svDb()];
+            _endedAt_decorators = [plugins.nosqldb.svDb()];
+            _model_decorators = [plugins.nosqldb.svDb()];
+            _serviceTier_decorators = [plugins.nosqldb.svDb()];
+            _microUsd_decorators = [plugins.nosqldb.svDb()];
+            _priceSource_decorators = [plugins.nosqldb.svDb()];
+            __esDecorate(null, null, _id_decorators, { kind: "field", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _id_extraInitializers);
+            __esDecorate(null, null, _accountId_decorators, { kind: "field", name: "accountId", static: false, private: false, access: { has: obj => "accountId" in obj, get: obj => obj.accountId, set: (obj, value) => { obj.accountId = value; } }, metadata: _metadata }, _accountId_initializers, _accountId_extraInitializers);
+            __esDecorate(null, null, _loginId_decorators, { kind: "field", name: "loginId", static: false, private: false, access: { has: obj => "loginId" in obj, get: obj => obj.loginId, set: (obj, value) => { obj.loginId = value; } }, metadata: _metadata }, _loginId_initializers, _loginId_extraInitializers);
+            __esDecorate(null, null, _endedAt_decorators, { kind: "field", name: "endedAt", static: false, private: false, access: { has: obj => "endedAt" in obj, get: obj => obj.endedAt, set: (obj, value) => { obj.endedAt = value; } }, metadata: _metadata }, _endedAt_initializers, _endedAt_extraInitializers);
+            __esDecorate(null, null, _model_decorators, { kind: "field", name: "model", static: false, private: false, access: { has: obj => "model" in obj, get: obj => obj.model, set: (obj, value) => { obj.model = value; } }, metadata: _metadata }, _model_initializers, _model_extraInitializers);
+            __esDecorate(null, null, _serviceTier_decorators, { kind: "field", name: "serviceTier", static: false, private: false, access: { has: obj => "serviceTier" in obj, get: obj => obj.serviceTier, set: (obj, value) => { obj.serviceTier = value; } }, metadata: _metadata }, _serviceTier_initializers, _serviceTier_extraInitializers);
+            __esDecorate(null, null, _microUsd_decorators, { kind: "field", name: "microUsd", static: false, private: false, access: { has: obj => "microUsd" in obj, get: obj => obj.microUsd, set: (obj, value) => { obj.microUsd = value; } }, metadata: _metadata }, _microUsd_initializers, _microUsd_extraInitializers);
+            __esDecorate(null, null, _priceSource_decorators, { kind: "field", name: "priceSource", static: false, private: false, access: { has: obj => "priceSource" in obj, get: obj => obj.priceSource, set: (obj, value) => { obj.priceSource = value; } }, metadata: _metadata }, _priceSource_initializers, _priceSource_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            InferenceSpendModel = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        id = __runInitializers(this, _id_initializers, void 0);
+        accountId = (__runInitializers(this, _id_extraInitializers), __runInitializers(this, _accountId_initializers, void 0));
+        loginId = (__runInitializers(this, _accountId_extraInitializers), __runInitializers(this, _loginId_initializers, void 0));
+        endedAt = (__runInitializers(this, _loginId_extraInitializers), __runInitializers(this, _endedAt_initializers, void 0));
+        model = (__runInitializers(this, _endedAt_extraInitializers), __runInitializers(this, _model_initializers, void 0));
+        serviceTier = (__runInitializers(this, _model_extraInitializers), __runInitializers(this, _serviceTier_initializers, void 0));
+        microUsd = (__runInitializers(this, _serviceTier_extraInitializers), __runInitializers(this, _microUsd_initializers, void 0));
+        priceSource = (__runInitializers(this, _microUsd_extraInitializers), __runInitializers(this, _priceSource_initializers, void 0));
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, _priceSource_extraInitializers);
+        }
+    };
+    return InferenceSpendModel = _classThis;
+})();
+export { InferenceSpendModel };
+/** How long one store write may take before it counts as failed. */
+const storeWriteTimeoutMs = 30_000;
+/** How many kept answers one read of the store loads at a time. */
+const loadPage = 256;
+/** The outbox's store in the proxy's database (`agl_inference_spend`, a model of `proxyModels`). */
+export class InferenceSpendStore {
+    async load(signalArg) {
+        const entries = [];
+        let after;
+        for (;;) {
+            const stored = await InferenceSpendModel.exact.findStored({ ...(after === undefined ? {} : { filter: { id: { $gt: after } } }),
+                sort: { id: 1 }, limit: loadPage, signal: signalArg });
+            for (const entry of stored) {
+                const document = InferenceSpendModel.exact.toPersisted(entry);
+                entries.push({ accountId: document.accountId, loginId: document.loginId, answer: answerOf(document) });
+            }
+            if (stored.length < loadPage)
+                return entries;
+            after = entries.at(-1).answer.answerId;
+        }
+    }
+    async insert(entryArg, signalArg) {
+        const { answer } = entryArg;
+        const document = { id: answer.answerId, accountId: entryArg.accountId, loginId: entryArg.loginId,
+            endedAt: answer.endedAt,
+            model: answer.model, serviceTier: answer.serviceTier, microUsd: answer.microUsd, priceSource: answer.priceSource };
+        const inserted = await InferenceSpendModel.exact.insert(document, { signal: signalArg });
+        if (inserted.status !== 'conflict')
+            return;
+        const held = InferenceSpendModel.exact.toPersisted(inserted.document);
+        if (JSON.stringify(held) !== JSON.stringify(document))
+            throw new Error('The proxy keeps another answer under this answer id.');
+    }
+    async delete(answerIdsArg, signalArg) {
+        for (const id of answerIdsArg) {
+            const current = await InferenceSpendModel.exact.findStoredOne({ id }, { signal: signalArg });
+            if (!current)
+                continue;
+            const deleted = await InferenceSpendModel.exact.delete({ current }, { signal: signalArg });
+            if (deleted.status !== 'deleted' && await InferenceSpendModel.exact.findStoredOne({ id }, { signal: signalArg })) {
+                throw new Error('A spend answer could not be removed from the proxy\'s store.');
+            }
+        }
+    }
+}
+/** A count of answers in words: `1 answer`, `2 answers`. */
+const answersText = (countArg) => `${countArg} ${countArg === 1 ? 'answer' : 'answers'}`;
+const writeJournal = (entryArg) => {
+    process.stderr.write(entryArg.kind === 'unpriced'
+        ? `AGL proxy could not price an answer on API key ${entryArg.account} (${entryArg.model}): ${entryArg.reason}. It counts `
+            + 'as an answer that could not be priced, which holds a key with a monthly spend limit until its month ends or the '
+            + 'limit is removed.\n'
+        : entryArg.kind === 'refused'
+            ? `AGL proxy's spend report of API key ${entryArg.account} (${answersText(entryArg.answers)}) was refused by the accounts `
+                + `service: ${entryArg.error} The proxy keeps the answers and counts them, sends them again at ${entryArg.retryAt} `
+                + 'and at every start, and places nothing on the key while it has a monthly spend limit.\n'
+            : entryArg.kind === 'unreported'
+                ? `AGL proxy could not report the spend of API key ${entryArg.account} (${answersText(entryArg.answers)}) to the `
+                    + `accounts service: ${entryArg.error} -- it keeps the answers, counts them against the key's limit and tries again.\n`
+                : entryArg.kind === 'unkept'
+                    ? `AGL proxy could not keep the spend of ${answersText(entryArg.answers)} in its store: ${entryArg.error} -- it counts `
+                        + 'them and tries again.\n'
+                    : entryArg.kind === 'unremoved'
+                        ? `AGL proxy could not remove ${answersText(entryArg.answers)}, acknowledged, from its store: ${entryArg.error} -- it `
+                            + 'tries again; a start before then reports them again, which the accounts service records once.\n'
+                        : entryArg.kind === 'unattributed'
+                            ? `AGL proxy holds an answer on API key ${entryArg.account} (${entryArg.model}) with no login of the key to report `
+                                + 'it on: it counts, and holds the key while it has a monthly spend limit, until the account service names a login.\n'
+                            : `AGL proxy did not count an answer on API key ${entryArg.account} (${entryArg.model}): it ended without the provider `
+                                + 'stating its usage, so nothing of it counts against the key\'s monthly spend limit, though the provider may bill it.\n');
+};
+/**
+ * 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 class InferenceSpendOutbox {
+    options;
+    /** The answers not acknowledged yet, by key, then answer id: an id is held once, so no report names one twice. */
+    entries = new Map();
+    accounts = new Map();
+    /** Acknowledged answers still to be removed from the store. */
+    acknowledgedIds = new Set();
+    abort = new AbortController();
+    now;
+    retryMs;
+    maxRetryMs;
+    heldRetryMs;
+    /** The store writes of recorded answers, one at a time, apart from the reports. */
+    keepTail = Promise.resolve();
+    keepFailures = 0;
+    keepRetryAt = 0;
+    keepSaid = false;
+    keepTimer;
+    forgetFailures = 0;
+    forgetRetryAt = 0;
+    forgetSaid = false;
+    started = false;
+    stopped = false;
+    running;
+    again = false;
+    timer;
+    constructor(options) {
+        this.options = options;
+        this.now = options.now ?? Date.now;
+        this.retryMs = options.retryMs ?? 5_000;
+        this.maxRetryMs = options.maxRetryMs ?? 300_000;
+        this.heldRetryMs = options.heldRetryMs ?? 600_000;
+    }
+    /** Loads the answers a run before left unacknowledged and sends them all now. */
+    async start(signalArg) {
+        if (this.started || this.stopped)
+            throw new Error('The spend outbox cannot be started twice.');
+        for (const entry of await this.options.store.load(signalArg ?? this.abort.signal)) {
+            this.add(entry.accountId, { answer: entry.answer, loginId: entry.loginId, kept: true, keepFailed: false, heldUntil: null });
+        }
+        this.started = true;
+        this.kick();
+    }
+    /**
+     * 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, loginIdArg, recordArg) {
+        if (!hex64.test(accountIdArg) || (loginIdArg !== null && !hex64.test(loginIdArg))
+            || !plugins.authswitchAuthority.isAuthSwitchSpendAnswer(recordArg.answer)) {
+            throw new Error('A spend answer the accounts service would refuse was recorded.');
+        }
+        this.add(accountIdArg, { answer: { ...recordArg.answer }, loginId: loginIdArg, kept: false, keepFailed: false,
+            heldUntil: null });
+        if (recordArg.unpriced !== undefined) {
+            this.say({ kind: 'unpriced', account: accountDigest(accountIdArg), model: recordArg.answer.model, reason: recordArg.unpriced });
+        }
+        if (loginIdArg === null)
+            this.say({ kind: 'unattributed', account: accountDigest(accountIdArg), model: recordArg.answer.model });
+        this.keep();
+        this.kick();
+    }
+    /**
+     * 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, modelArg) {
+        this.say({ kind: 'uncounted', account: accountDigest(accountIdArg), model: modelArg });
+    }
+    /** The answers relayed on a key whose spend the accounts service has not acknowledged yet. */
+    pending(accountIdArg) {
+        return [...this.entries.get(accountIdArg)?.values() ?? []]
+            .map((entryArg) => ({ endedAt: entryArg.answer.endedAt, microUsd: entryArg.answer.microUsd }));
+    }
+    /**
+     * 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) {
+        return [...this.entries.get(accountIdArg)?.values() ?? []]
+            .some((entryArg) => entryArg.heldUntil !== null || (entryArg.keepFailed && !entryArg.kept) || entryArg.loginId === null);
+    }
+    /**
+     * 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, usageArg) {
+        if (usageArg.reading?.kind !== 'spend')
+            return usageArg;
+        return { ...usageArg, reading: { kind: 'spend', spend: plugins.authswitchSpend.authSwitchSpendWithPending(usageArg.reading.spend, this.pending(accountIdArg), this.now()) } };
+    }
+    /**
+     * 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.
+     */
+    async stop() {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        clearTimeout(this.timer);
+        this.timer = undefined;
+        clearTimeout(this.keepTimer);
+        this.keepTimer = undefined;
+        this.abort.abort(new Error('The spend outbox stopped.'));
+        await this.running;
+        await this.keepTail;
+        await this.keepOnce(true);
+        if (this.started)
+            await this.forget(AbortSignal.timeout(storeWriteTimeoutMs), true);
+    }
+    add(accountIdArg, entryArg) {
+        let entries = this.entries.get(accountIdArg);
+        if (!entries) {
+            entries = new Map();
+            this.entries.set(accountIdArg, entries);
+        }
+        entries.set(entryArg.answer.answerId, entryArg);
+    }
+    say(entryArg) {
+        try {
+            (this.options.journal ?? writeJournal)(entryArg);
+        }
+        catch { /* a journal line that fails changes nothing */ }
+    }
+    /** Runs the outbox's work now, or once more after the run in progress. */
+    kick() {
+        if (!this.started || this.stopped)
+            return;
+        if (this.running) {
+            this.again = true;
+            return;
+        }
+        clearTimeout(this.timer);
+        this.timer = undefined;
+        this.running = (async () => {
+            do {
+                this.again = false;
+                await this.cycle();
+            } while (this.again && !this.stopped);
+        })().catch(() => undefined).finally(() => {
+            this.running = undefined;
+            this.arm();
+        });
+    }
+    /** Removes what was acknowledged from the store, then sends every report that is due. */
+    async cycle() {
+        const signal = this.abort.signal;
+        if (this.now() >= this.forgetRetryAt)
+            await this.forget(signal, false);
+        for (let batch = this.nextBatch(); batch && !this.stopped; batch = this.nextBatch()) {
+            await this.send(batch.accountId, batch.loginId, batch.entries, signal);
+        }
+    }
+    /**
+     * 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.
+     */
+    keep() {
+        if (this.stopped)
+            return;
+        clearTimeout(this.keepTimer);
+        this.keepTimer = undefined;
+        this.keepTail = this.keepTail.then(() => this.keepOnce(false));
+    }
+    /**
+     * 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.
+     */
+    async keepOnce(finalArg) {
+        if (this.stopped && !finalArg)
+            return;
+        const unkept = [...this.entries].flatMap(([accountId, entries]) => [...entries.values()]
+            .filter((entryArg) => !entryArg.kept).map((entryArg) => ({ accountId, entry: entryArg })));
+        if (!unkept.length)
+            return;
+        try {
+            for (const { accountId, entry } of unkept) {
+                await this.options.store.insert({ accountId, loginId: entry.loginId, answer: entry.answer }, AbortSignal.timeout(storeWriteTimeoutMs));
+                entry.kept = true;
+                // Acknowledged while it was written: it leaves the store again.
+                if (this.entries.get(accountId)?.get(entry.answer.answerId) !== entry)
+                    this.acknowledgedIds.add(entry.answer.answerId);
+            }
+            this.keepFailures = 0;
+            this.keepRetryAt = 0;
+            this.keepSaid = false;
+            this.kick();
+        }
+        catch (errorArg) {
+            for (const { entry } of unkept)
+                if (!entry.kept)
+                    entry.keepFailed = true;
+            this.keepFailures += 1;
+            this.keepRetryAt = this.now() + this.backoff(this.keepFailures);
+            if (!this.keepSaid) {
+                this.keepSaid = true;
+                this.say({ kind: 'unkept', answers: unkept.filter((itemArg) => !itemArg.entry.kept).length, error: oneLine(errorArg) });
+            }
+            if (this.stopped)
+                return;
+            clearTimeout(this.keepTimer);
+            this.keepTimer = setTimeout(() => this.keep(), Math.max(0, this.keepRetryAt - this.now()));
+            this.keepTimer.unref?.();
+        }
+    }
+    /** Removes the acknowledged answers from the store; a failed removal waits, doubling, said once. */
+    async forget(signalArg, finalArg) {
+        if (!this.acknowledgedIds.size)
+            return;
+        const ids = [...this.acknowledgedIds];
+        try {
+            await this.options.store.delete(ids, signalArg);
+            for (const id of ids)
+                this.acknowledgedIds.delete(id);
+            this.forgetFailures = 0;
+            this.forgetRetryAt = 0;
+            this.forgetSaid = false;
+        }
+        catch (errorArg) {
+            if (this.stopped && !finalArg)
+                return;
+            this.forgetFailures += 1;
+            this.forgetRetryAt = this.now() + this.backoff(this.forgetFailures);
+            if (!this.forgetSaid) {
+                this.forgetSaid = true;
+                this.say({ kind: 'unremoved', answers: ids.length, error: oneLine(errorArg) });
+            }
+        }
+    }
+    /**
+     * 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.
+     */
+    nextBatch() {
+        const now = this.now();
+        for (const [accountId, entries] of this.entries) {
+            if ((this.accounts.get(accountId)?.retryAt ?? 0) > now)
+                continue;
+            const all = [...entries.values()];
+            if (all.some((entryArg) => entryArg.loginId === null)) {
+                const login = this.options.attribute(accountId);
+                if (login !== undefined && hex64.test(login))
+                    for (const entry of all)
+                        entry.loginId ??= login;
+            }
+            const named = all.filter((entryArg) => entryArg.loginId !== null);
+            const due = named.filter((entryArg) => entryArg.heldUntil !== null && entryArg.heldUntil <= now);
+            const fresh = named.filter((entryArg) => entryArg.heldUntil === null);
+            const oldest = (due.length ? due : fresh)
+                .sort((leftArg, rightArg) => Date.parse(leftArg.answer.endedAt) - Date.parse(rightArg.answer.endedAt));
+            const loginId = oldest[0]?.loginId;
+            if (loginId) {
+                return { accountId, loginId, entries: oldest.filter((entryArg) => entryArg.loginId === loginId)
+                        .slice(0, plugins.authswitchAuthority.authSwitchSpendAnswerBatchLimit) };
+            }
+            if (named.length < all.length) {
+                // Nothing of the key can be reported until a login is named: ask again later.
+                const account = this.accounts.get(accountId) ?? { failures: 0, retryAt: 0, said: true };
+                account.failures += 1;
+                account.retryAt = now + this.backoff(account.failures);
+                this.accounts.set(accountId, account);
+            }
+        }
+        return undefined;
+    }
+    async send(accountIdArg, loginIdArg, entriesArg, signalArg) {
+        const account = this.accounts.get(accountIdArg) ?? { failures: 0, retryAt: 0, said: false };
+        this.accounts.set(accountIdArg, account);
+        let usage;
+        try {
+            usage = await this.options.report(accountIdArg, loginIdArg, entriesArg.map((entryArg) => ({ ...entryArg.answer })), signalArg);
+        }
+        catch (errorArg) {
+            if (this.stopped)
+                return;
+            const refusal = plugins.authswitchAuthority.asAuthSwitchRefusal(errorArg);
+            if (refusal?.code === 'invalid_input' || plugins.authswitchAuthority.isAuthSwitchMalformedRequest(errorArg)) {
+                const retryAt = this.now() + this.heldRetryMs;
+                for (const entry of entriesArg)
+                    entry.heldUntil = retryAt;
+                this.say({ kind: 'refused', account: accountDigest(accountIdArg), answers: entriesArg.length,
+                    error: refusal?.instruction ?? plugins.authswitchAuthority.authSwitchMalformedRequestText,
+                    retryAt: new Date(retryAt).toISOString() });
+                return;
+            }
+            account.failures += 1;
+            account.retryAt = this.now() + this.backoff(account.failures);
+            if (!account.said) {
+                account.said = true;
+                this.say({ kind: 'unreported', account: accountDigest(accountIdArg),
+                    answers: this.entries.get(accountIdArg)?.size ?? entriesArg.length, error: oneLine(errorArg) });
+            }
+            return;
+        }
+        // The one acknowledgement step: the service's answer, which counts the report's answers, replaces the held reading
+        // in the same synchronous step that drops them from what is pending.
+        this.options.acknowledged(accountIdArg, usage);
+        const entries = this.entries.get(accountIdArg);
+        for (const entry of entriesArg) {
+            entries?.delete(entry.answer.answerId);
+            // One the store has not kept yet leaves it once its write lands (`keepOnce`).
+            if (entry.kept)
+                this.acknowledgedIds.add(entry.answer.answerId);
+        }
+        if (entries?.size === 0)
+            this.entries.delete(accountIdArg);
+        this.accounts.delete(accountIdArg);
+    }
+    backoff(failuresArg) {
+        return Math.min(this.maxRetryMs, this.retryMs * 2 ** Math.max(0, failuresArg - 1));
+    }
+    /** Wakes the reports when the next held or waiting answer, or a removal to try again, is due. */
+    arm() {
+        clearTimeout(this.timer);
+        this.timer = undefined;
+        if (this.stopped || !this.started)
+            return;
+        let due = Number.POSITIVE_INFINITY;
+        if (this.acknowledgedIds.size)
+            due = Math.min(due, this.forgetRetryAt);
+        for (const [accountId, entries] of this.entries) {
+            const retryAt = this.accounts.get(accountId)?.retryAt ?? 0;
+            for (const entry of entries.values())
+                due = Math.min(due, Math.max(retryAt, entry.heldUntil ?? 0));
+        }
+        if (!Number.isFinite(due))
+            return;
+        this.timer = setTimeout(() => this.kick(), Math.max(0, due - this.now()));
+        this.timer.unref?.();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.inferencespend.js","sourceRoot":"","sources":["../../ts/classes.inferencespend.ts"],"names":[],"mappings":"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"}