hanzoai 8.5.648 → 8.5.653

package/dist/api/ai-api.d.ts

@@ -28,7 +28,6 @@ import type { AiModelList } from '../models';
 import type { AiModels } from '../models';
 import type { AiRanking } from '../models';
 import type { AiResponse } from '../models';
-import type { AiResponsesResource } from '../models';
 import type { AiRoutingEdit } from '../models';
 import type { AiRoutingRewardRequest } from '../models';
 import type { AiTokenCount } from '../models';
@@ -113,7 +112,9 @@ import type { PostAiTreeFiles200Response } from '../models';
 import type { PostAiVectors200Response } from '../models';
 import type { PostAiVideos200Response } from '../models';
 import type { PostAiWorkflows200Response } from '../models';
+import type { PostChat200Response } from '../models';
 import type { PostModelsByModelAccess200Response } from '../models';
+import type { PostResponses200Response } from '../models';
 import type { PutAiRouterCatalog200Response } from '../models';
 /**
  * AiApi - axios parameter creator
@@ -4761,7 +4762,7 @@ export declare const AiApiFp: (configuration?: Configuration) => {
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    postChat(openaiChatCompletionRequest: OpenaiChatCompletionRequest, xMaxCost?: number, xMaxLatencyMs?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<OpenaiChatCompletionResponse>>;
+    postChat(openaiChatCompletionRequest: OpenaiChatCompletionRequest, xMaxCost?: number, xMaxLatencyMs?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<PostChat200Response>>;
     /**
      * Implements the OpenAI-compatible chat completions API
      * @summary Implements the OpenAI-compatible chat completions API
@@ -4771,7 +4772,7 @@ export declare const AiApiFp: (configuration?: Configuration) => {
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    postChatCompletions(openaiChatCompletionRequest: OpenaiChatCompletionRequest, xMaxCost?: number, xMaxLatencyMs?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<OpenaiChatCompletionResponse>>;
+    postChatCompletions(openaiChatCompletionRequest: OpenaiChatCompletionRequest, xMaxCost?: number, xMaxLatencyMs?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<PostChat200Response>>;
     /**
      * Serves one completion to a caller with no account.
      * @summary Serves one completion to a caller with no account.
@@ -4789,7 +4790,7 @@ export declare const AiApiFp: (configuration?: Configuration) => {
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    postCompletions(openaiChatCompletionRequest: OpenaiChatCompletionRequest, xMaxCost?: number, xMaxLatencyMs?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<OpenaiChatCompletionResponse>>;
+    postCompletions(openaiChatCompletionRequest: OpenaiChatCompletionRequest, xMaxCost?: number, xMaxLatencyMs?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<PostChat200Response>>;
     /**
      * Implements POST /v1/decisions (the Decisions API).  Body: {\"model\": \"kai\", \"state\": \"...\"|{...}|[...], \"questions\": {\"<name>\": {\"type\": \"choice\"|\"noul\"|\"score\", \"instructions\": ..., \"criteria\": ...}}}. model is kai, Kai\'s versioned id kai-<12 hex of the weights\' sha256> — priced as kai and sent as asked — or Jev by OpenRouter\'s vendor ids, typesafe/jev-1.13 and ~typesafe/jev-latest, which reach Jev itself and bill at Jev\'s list price. No Jev id is ever answered by Kai: a bare one, such as jev-latest, is an unknown model. model is required; state and questions are required unless the request names a handle, which carries neither. instructions is optional and any JSON. A choice names at least 2 labels and a score at least 1 level, bounded by the token budget rather than a count; questions holds 1 to 100.  observe holds the state under an id, and a later request naming that id as its handle decides over it again. An id is 1 to 128 characters of A-Z, a-z, 0-9, \'.\', \'_\' and \'-\'. A handle belongs to the org that observed it: no other org\'s request can name it.  Response: {\"id\",\"model\",\"provider\",\"answers\":{\"<name>\":{\"type\",...}}, \"usage\":{\"input_tokens\",\"output_tokens\"},\"routing\",\"state_hash\",\"latency_ms\"}. usage.input_tokens is the billed count — the request\'s text counted once, the state once and each question\'s instructions and options once; a decision over a handle bills the state once, when it was observed.  The body may be sent gzip, deflate, br or zstd encoded; decoded, it is bounded as sent.  Refusals are {\"error\":{\"code\",\"message\"}}: 400 malformed JSON or unknown model, 401 no valid credential, 402 insufficient balance, 403 a key kind that may not call this (pk-), 415 any other Content-Encoding, 422 an invalid question or handle id, a state beyond the checkpoint\'s reach (code state_too_long) or a body past 16 MiB (code request_too_long), 429 rate limited or queue full, 502 the service failed, 503 the model is known and not served, 529 overloaded. 402, 429 and 529 carry Retry-After and Retry-After-Ms, and every answer carries X-Request-Id. Billed on the answer\'s input tokens at the model\'s price.
      * @summary Implements POST /v1/decisions (the Decisions API).
@@ -4851,7 +4852,7 @@ export declare const AiApiFp: (configuration?: Configuration) => {
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    postResponses(xMaxCost?: number, xMaxLatencyMs?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AiResponsesResource>>;
+    postResponses(xMaxCost?: number, xMaxLatencyMs?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<PostResponses200Response>>;
     /**
      * Implements POST /v1/videos/generations — the ASYNC create.  Body: {\"model\": \"...\", \"prompt\": \"...\", \"size\"?: \"1280x720\", \"seconds\"?: int}  It authenticates the caller, resolves the model to its upstream provider via the shared routing table (zen3-video* / wan2-2-t2v-a14b → the spark-video backend), reserves the per-video budget (the balance gate), creates ONE upstream job, registers it in the in-pod store, and returns the OpenAI-shaped video object with status \"queued\" IMMEDIATELY. The client then polls GET /v1/videos/{id} and downloads GET /v1/videos/{id}/content. Nothing is billed here — the debit lands on completion.
      * @summary Implements POST /v1/videos/generations — the ASYNC create.
@@ -7166,7 +7167,7 @@ export declare const AiApiFactory: (configuration?: Configuration, basePath?: st
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    postChat(requestParameters: AiApiPostChatRequest, options?: RawAxiosRequestConfig): AxiosPromise<OpenaiChatCompletionResponse>;
+    postChat(requestParameters: AiApiPostChatRequest, options?: RawAxiosRequestConfig): AxiosPromise<PostChat200Response>;
     /**
      * Implements the OpenAI-compatible chat completions API
      * @summary Implements the OpenAI-compatible chat completions API
@@ -7174,7 +7175,7 @@ export declare const AiApiFactory: (configuration?: Configuration, basePath?: st
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    postChatCompletions(requestParameters: AiApiPostChatCompletionsRequest, options?: RawAxiosRequestConfig): AxiosPromise<OpenaiChatCompletionResponse>;
+    postChatCompletions(requestParameters: AiApiPostChatCompletionsRequest, options?: RawAxiosRequestConfig): AxiosPromise<PostChat200Response>;
     /**
      * Serves one completion to a caller with no account.
      * @summary Serves one completion to a caller with no account.
@@ -7190,7 +7191,7 @@ export declare const AiApiFactory: (configuration?: Configuration, basePath?: st
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    postCompletions(requestParameters: AiApiPostCompletionsRequest, options?: RawAxiosRequestConfig): AxiosPromise<OpenaiChatCompletionResponse>;
+    postCompletions(requestParameters: AiApiPostCompletionsRequest, options?: RawAxiosRequestConfig): AxiosPromise<PostChat200Response>;
     /**
      * Implements POST /v1/decisions (the Decisions API).  Body: {\"model\": \"kai\", \"state\": \"...\"|{...}|[...], \"questions\": {\"<name>\": {\"type\": \"choice\"|\"noul\"|\"score\", \"instructions\": ..., \"criteria\": ...}}}. model is kai, Kai\'s versioned id kai-<12 hex of the weights\' sha256> — priced as kai and sent as asked — or Jev by OpenRouter\'s vendor ids, typesafe/jev-1.13 and ~typesafe/jev-latest, which reach Jev itself and bill at Jev\'s list price. No Jev id is ever answered by Kai: a bare one, such as jev-latest, is an unknown model. model is required; state and questions are required unless the request names a handle, which carries neither. instructions is optional and any JSON. A choice names at least 2 labels and a score at least 1 level, bounded by the token budget rather than a count; questions holds 1 to 100.  observe holds the state under an id, and a later request naming that id as its handle decides over it again. An id is 1 to 128 characters of A-Z, a-z, 0-9, \'.\', \'_\' and \'-\'. A handle belongs to the org that observed it: no other org\'s request can name it.  Response: {\"id\",\"model\",\"provider\",\"answers\":{\"<name>\":{\"type\",...}}, \"usage\":{\"input_tokens\",\"output_tokens\"},\"routing\",\"state_hash\",\"latency_ms\"}. usage.input_tokens is the billed count — the request\'s text counted once, the state once and each question\'s instructions and options once; a decision over a handle bills the state once, when it was observed.  The body may be sent gzip, deflate, br or zstd encoded; decoded, it is bounded as sent.  Refusals are {\"error\":{\"code\",\"message\"}}: 400 malformed JSON or unknown model, 401 no valid credential, 402 insufficient balance, 403 a key kind that may not call this (pk-), 415 any other Content-Encoding, 422 an invalid question or handle id, a state beyond the checkpoint\'s reach (code state_too_long) or a body past 16 MiB (code request_too_long), 429 rate limited or queue full, 502 the service failed, 503 the model is known and not served, 529 overloaded. 402, 429 and 529 carry Retry-After and Retry-After-Ms, and every answer carries X-Request-Id. Billed on the answer\'s input tokens at the model\'s price.
      * @summary Implements POST /v1/decisions (the Decisions API).
@@ -7251,7 +7252,7 @@ export declare const AiApiFactory: (configuration?: Configuration, basePath?: st
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    postResponses(requestParameters?: AiApiPostResponsesRequest, options?: RawAxiosRequestConfig): AxiosPromise<AiResponsesResource>;
+    postResponses(requestParameters?: AiApiPostResponsesRequest, options?: RawAxiosRequestConfig): AxiosPromise<PostResponses200Response>;
     /**
      * Implements POST /v1/videos/generations — the ASYNC create.  Body: {\"model\": \"...\", \"prompt\": \"...\", \"size\"?: \"1280x720\", \"seconds\"?: int}  It authenticates the caller, resolves the model to its upstream provider via the shared routing table (zen3-video* / wan2-2-t2v-a14b → the spark-video backend), reserves the per-video budget (the balance gate), creates ONE upstream job, registers it in the in-pod store, and returns the OpenAI-shaped video object with status \"queued\" IMMEDIATELY. The client then polls GET /v1/videos/{id} and downloads GET /v1/videos/{id}/content. Nothing is billed here — the debit lands on completion.
      * @summary Implements POST /v1/videos/generations — the ASYNC create.
@@ -13127,7 +13128,7 @@ export declare class AiApi extends BaseAPI {
      * @throws {RequiredError}
      * @memberof AiApi
      */
-    postResponses(requestParameters?: AiApiPostResponsesRequest, options?: RawAxiosRequestConfig): Promise<globalAxios.AxiosResponse<AiResponsesResource, any, {}>>;
+    postResponses(requestParameters?: AiApiPostResponsesRequest, options?: RawAxiosRequestConfig): Promise<globalAxios.AxiosResponse<import("../models").AiResponsesResource, any, {}>>;
     /**
      * Implements POST /v1/videos/generations — the ASYNC create.  Body: {\"model\": \"...\", \"prompt\": \"...\", \"size\"?: \"1280x720\", \"seconds\"?: int}  It authenticates the caller, resolves the model to its upstream provider via the shared routing table (zen3-video* / wan2-2-t2v-a14b → the spark-video backend), reserves the per-video budget (the balance gate), creates ONE upstream job, registers it in the in-pod store, and returns the OpenAI-shaped video object with status \"queued\" IMMEDIATELY. The client then polls GET /v1/videos/{id} and downloads GET /v1/videos/{id}/content. Nothing is billed here — the debit lands on completion.
      * @summary Implements POST /v1/videos/generations — the ASYNC create.

package/dist/api/billing-api.d.ts

@@ -275,7 +275,7 @@ export declare const BillingApiAxiosParamCreator: (configuration?: Configuration
      */
     getBillingTransactionsById: (id: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
     /**
-     * Answers one row per BILLED call against the caller\'s org — transaction id, amount, timestamp and the metered unit. This is the raw charged ledger, not a rollup.  Each row is stamped with a canonical `metadata.product` derived from what the meter persisted: `agent` becomes agents, `provisioning` becomes the provisioned kind, a token-metered row becomes inference, anything else keeps its metering surface. The ledger has no product field of its own, so this read is where that dimension is made real — from the SAME charged rows, never a second meter. A row that already carries its own product WINS, so the derivation stops the day the meter records one.  `product=<id>` filters to one product server-side. `groupBy=product` reduces to `{product,requests,amountCents}` rollups instead of rows.  `amount` is whole USD cents, ROUNDED; `decimal` beside it is the SAME debit exact, as an 18-decimal USD string. Sum `decimal`. A page of sub-cent token calls totals correctly there and totals ZERO in `amount` — that difference is real money.  Scoped to the caller\'s own org\'s books, where the org\'s ledger file IS the tenant boundary; no client-supplied subject is ever forwarded. 401 without a validated principal. The co-resident read returns the 2000 most recent debits, newest first; `start` and `end` narrow the window only on the split-deploy upstream.
+     * Answers one row per BILLED call against the caller\'s org — transaction id, amount, timestamp and the metered unit. This is the raw charged ledger, not a rollup.  Each row is stamped with a canonical `metadata.product` derived from what the meter persisted: `agent` becomes agents, `provisioning` becomes the provisioned kind, a token-metered row becomes inference, anything else keeps its metering surface. The ledger has no product field of its own, so this read is where that dimension is made real — from the SAME charged rows, never a second meter. A row that already carries its own product WINS, so the derivation stops the day the meter records one.  Each row carries `name`: what its metered unit (`metadata.model`) reads as on a bill — `Desktop sandbox` for `desktop/visor`, `Agent sessions` for `session`. An AI model is its own name. Show `name`; `metadata.model` stays the unit the ledger keys on.  `product=<id>` filters to one product server-side. `groupBy=product` reduces to `{product,requests,amountCents}` rollups instead of rows.  `amount` is whole USD cents, ROUNDED; `decimal` beside it is the SAME debit exact, as an 18-decimal USD string. Sum `decimal`. A page of sub-cent token calls totals correctly there and totals ZERO in `amount` — that difference is real money.  Scoped to the caller\'s own org\'s books, where the org\'s ledger file IS the tenant boundary; no client-supplied subject is ever forwarded. 401 without a validated principal. The co-resident read returns the 2000 most recent debits, newest first; `start` and `end` narrow the window only on the split-deploy upstream.
      * @summary Every billed call the caller\'s org made, attributed to a product
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
@@ -664,7 +664,7 @@ export declare const BillingApiFp: (configuration?: Configuration) => {
      */
     getBillingTransactionsById(id: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<BillingTransaction>>;
     /**
-     * Answers one row per BILLED call against the caller\'s org — transaction id, amount, timestamp and the metered unit. This is the raw charged ledger, not a rollup.  Each row is stamped with a canonical `metadata.product` derived from what the meter persisted: `agent` becomes agents, `provisioning` becomes the provisioned kind, a token-metered row becomes inference, anything else keeps its metering surface. The ledger has no product field of its own, so this read is where that dimension is made real — from the SAME charged rows, never a second meter. A row that already carries its own product WINS, so the derivation stops the day the meter records one.  `product=<id>` filters to one product server-side. `groupBy=product` reduces to `{product,requests,amountCents}` rollups instead of rows.  `amount` is whole USD cents, ROUNDED; `decimal` beside it is the SAME debit exact, as an 18-decimal USD string. Sum `decimal`. A page of sub-cent token calls totals correctly there and totals ZERO in `amount` — that difference is real money.  Scoped to the caller\'s own org\'s books, where the org\'s ledger file IS the tenant boundary; no client-supplied subject is ever forwarded. 401 without a validated principal. The co-resident read returns the 2000 most recent debits, newest first; `start` and `end` narrow the window only on the split-deploy upstream.
+     * Answers one row per BILLED call against the caller\'s org — transaction id, amount, timestamp and the metered unit. This is the raw charged ledger, not a rollup.  Each row is stamped with a canonical `metadata.product` derived from what the meter persisted: `agent` becomes agents, `provisioning` becomes the provisioned kind, a token-metered row becomes inference, anything else keeps its metering surface. The ledger has no product field of its own, so this read is where that dimension is made real — from the SAME charged rows, never a second meter. A row that already carries its own product WINS, so the derivation stops the day the meter records one.  Each row carries `name`: what its metered unit (`metadata.model`) reads as on a bill — `Desktop sandbox` for `desktop/visor`, `Agent sessions` for `session`. An AI model is its own name. Show `name`; `metadata.model` stays the unit the ledger keys on.  `product=<id>` filters to one product server-side. `groupBy=product` reduces to `{product,requests,amountCents}` rollups instead of rows.  `amount` is whole USD cents, ROUNDED; `decimal` beside it is the SAME debit exact, as an 18-decimal USD string. Sum `decimal`. A page of sub-cent token calls totals correctly there and totals ZERO in `amount` — that difference is real money.  Scoped to the caller\'s own org\'s books, where the org\'s ledger file IS the tenant boundary; no client-supplied subject is ever forwarded. 401 without a validated principal. The co-resident read returns the 2000 most recent debits, newest first; `start` and `end` narrow the window only on the split-deploy upstream.
      * @summary Every billed call the caller\'s org made, attributed to a product
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
@@ -1043,7 +1043,7 @@ export declare const BillingApiFactory: (configuration?: Configuration, basePath
      */
     getBillingTransactionsById(requestParameters: BillingApiGetBillingTransactionsByIdRequest, options?: RawAxiosRequestConfig): AxiosPromise<BillingTransaction>;
     /**
-     * Answers one row per BILLED call against the caller\'s org — transaction id, amount, timestamp and the metered unit. This is the raw charged ledger, not a rollup.  Each row is stamped with a canonical `metadata.product` derived from what the meter persisted: `agent` becomes agents, `provisioning` becomes the provisioned kind, a token-metered row becomes inference, anything else keeps its metering surface. The ledger has no product field of its own, so this read is where that dimension is made real — from the SAME charged rows, never a second meter. A row that already carries its own product WINS, so the derivation stops the day the meter records one.  `product=<id>` filters to one product server-side. `groupBy=product` reduces to `{product,requests,amountCents}` rollups instead of rows.  `amount` is whole USD cents, ROUNDED; `decimal` beside it is the SAME debit exact, as an 18-decimal USD string. Sum `decimal`. A page of sub-cent token calls totals correctly there and totals ZERO in `amount` — that difference is real money.  Scoped to the caller\'s own org\'s books, where the org\'s ledger file IS the tenant boundary; no client-supplied subject is ever forwarded. 401 without a validated principal. The co-resident read returns the 2000 most recent debits, newest first; `start` and `end` narrow the window only on the split-deploy upstream.
+     * Answers one row per BILLED call against the caller\'s org — transaction id, amount, timestamp and the metered unit. This is the raw charged ledger, not a rollup.  Each row is stamped with a canonical `metadata.product` derived from what the meter persisted: `agent` becomes agents, `provisioning` becomes the provisioned kind, a token-metered row becomes inference, anything else keeps its metering surface. The ledger has no product field of its own, so this read is where that dimension is made real — from the SAME charged rows, never a second meter. A row that already carries its own product WINS, so the derivation stops the day the meter records one.  Each row carries `name`: what its metered unit (`metadata.model`) reads as on a bill — `Desktop sandbox` for `desktop/visor`, `Agent sessions` for `session`. An AI model is its own name. Show `name`; `metadata.model` stays the unit the ledger keys on.  `product=<id>` filters to one product server-side. `groupBy=product` reduces to `{product,requests,amountCents}` rollups instead of rows.  `amount` is whole USD cents, ROUNDED; `decimal` beside it is the SAME debit exact, as an 18-decimal USD string. Sum `decimal`. A page of sub-cent token calls totals correctly there and totals ZERO in `amount` — that difference is real money.  Scoped to the caller\'s own org\'s books, where the org\'s ledger file IS the tenant boundary; no client-supplied subject is ever forwarded. 401 without a validated principal. The co-resident read returns the 2000 most recent debits, newest first; `start` and `end` narrow the window only on the split-deploy upstream.
      * @summary Every billed call the caller\'s org made, attributed to a product
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
@@ -1870,7 +1870,7 @@ export declare class BillingApi extends BaseAPI {
      */
     getBillingTransactionsById(requestParameters: BillingApiGetBillingTransactionsByIdRequest, options?: RawAxiosRequestConfig): Promise<globalAxios.AxiosResponse<BillingTransaction, any, {}>>;
     /**
-     * Answers one row per BILLED call against the caller\'s org — transaction id, amount, timestamp and the metered unit. This is the raw charged ledger, not a rollup.  Each row is stamped with a canonical `metadata.product` derived from what the meter persisted: `agent` becomes agents, `provisioning` becomes the provisioned kind, a token-metered row becomes inference, anything else keeps its metering surface. The ledger has no product field of its own, so this read is where that dimension is made real — from the SAME charged rows, never a second meter. A row that already carries its own product WINS, so the derivation stops the day the meter records one.  `product=<id>` filters to one product server-side. `groupBy=product` reduces to `{product,requests,amountCents}` rollups instead of rows.  `amount` is whole USD cents, ROUNDED; `decimal` beside it is the SAME debit exact, as an 18-decimal USD string. Sum `decimal`. A page of sub-cent token calls totals correctly there and totals ZERO in `amount` — that difference is real money.  Scoped to the caller\'s own org\'s books, where the org\'s ledger file IS the tenant boundary; no client-supplied subject is ever forwarded. 401 without a validated principal. The co-resident read returns the 2000 most recent debits, newest first; `start` and `end` narrow the window only on the split-deploy upstream.
+     * Answers one row per BILLED call against the caller\'s org — transaction id, amount, timestamp and the metered unit. This is the raw charged ledger, not a rollup.  Each row is stamped with a canonical `metadata.product` derived from what the meter persisted: `agent` becomes agents, `provisioning` becomes the provisioned kind, a token-metered row becomes inference, anything else keeps its metering surface. The ledger has no product field of its own, so this read is where that dimension is made real — from the SAME charged rows, never a second meter. A row that already carries its own product WINS, so the derivation stops the day the meter records one.  Each row carries `name`: what its metered unit (`metadata.model`) reads as on a bill — `Desktop sandbox` for `desktop/visor`, `Agent sessions` for `session`. An AI model is its own name. Show `name`; `metadata.model` stays the unit the ledger keys on.  `product=<id>` filters to one product server-side. `groupBy=product` reduces to `{product,requests,amountCents}` rollups instead of rows.  `amount` is whole USD cents, ROUNDED; `decimal` beside it is the SAME debit exact, as an 18-decimal USD string. Sum `decimal`. A page of sub-cent token calls totals correctly there and totals ZERO in `amount` — that difference is real money.  Scoped to the caller\'s own org\'s books, where the org\'s ledger file IS the tenant boundary; no client-supplied subject is ever forwarded. 401 without a validated principal. The co-resident read returns the 2000 most recent debits, newest first; `start` and `end` narrow the window only on the split-deploy upstream.
      * @summary Every billed call the caller\'s org made, attributed to a product
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}

package/dist/api/billing-api.js

@@ -907,7 +907,7 @@ const BillingApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * Answers one row per BILLED call against the caller\'s org — transaction id, amount, timestamp and the metered unit. This is the raw charged ledger, not a rollup.  Each row is stamped with a canonical `metadata.product` derived from what the meter persisted: `agent` becomes agents, `provisioning` becomes the provisioned kind, a token-metered row becomes inference, anything else keeps its metering surface. The ledger has no product field of its own, so this read is where that dimension is made real — from the SAME charged rows, never a second meter. A row that already carries its own product WINS, so the derivation stops the day the meter records one.  `product=<id>` filters to one product server-side. `groupBy=product` reduces to `{product,requests,amountCents}` rollups instead of rows.  `amount` is whole USD cents, ROUNDED; `decimal` beside it is the SAME debit exact, as an 18-decimal USD string. Sum `decimal`. A page of sub-cent token calls totals correctly there and totals ZERO in `amount` — that difference is real money.  Scoped to the caller\'s own org\'s books, where the org\'s ledger file IS the tenant boundary; no client-supplied subject is ever forwarded. 401 without a validated principal. The co-resident read returns the 2000 most recent debits, newest first; `start` and `end` narrow the window only on the split-deploy upstream.
+         * Answers one row per BILLED call against the caller\'s org — transaction id, amount, timestamp and the metered unit. This is the raw charged ledger, not a rollup.  Each row is stamped with a canonical `metadata.product` derived from what the meter persisted: `agent` becomes agents, `provisioning` becomes the provisioned kind, a token-metered row becomes inference, anything else keeps its metering surface. The ledger has no product field of its own, so this read is where that dimension is made real — from the SAME charged rows, never a second meter. A row that already carries its own product WINS, so the derivation stops the day the meter records one.  Each row carries `name`: what its metered unit (`metadata.model`) reads as on a bill — `Desktop sandbox` for `desktop/visor`, `Agent sessions` for `session`. An AI model is its own name. Show `name`; `metadata.model` stays the unit the ledger keys on.  `product=<id>` filters to one product server-side. `groupBy=product` reduces to `{product,requests,amountCents}` rollups instead of rows.  `amount` is whole USD cents, ROUNDED; `decimal` beside it is the SAME debit exact, as an 18-decimal USD string. Sum `decimal`. A page of sub-cent token calls totals correctly there and totals ZERO in `amount` — that difference is real money.  Scoped to the caller\'s own org\'s books, where the org\'s ledger file IS the tenant boundary; no client-supplied subject is ever forwarded. 401 without a validated principal. The co-resident read returns the 2000 most recent debits, newest first; `start` and `end` narrow the window only on the split-deploy upstream.
          * @summary Every billed call the caller\'s org made, attributed to a product
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
@@ -1942,7 +1942,7 @@ const BillingApiFp = function (configuration) {
             return (axios, basePath) => (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Answers one row per BILLED call against the caller\'s org — transaction id, amount, timestamp and the metered unit. This is the raw charged ledger, not a rollup.  Each row is stamped with a canonical `metadata.product` derived from what the meter persisted: `agent` becomes agents, `provisioning` becomes the provisioned kind, a token-metered row becomes inference, anything else keeps its metering surface. The ledger has no product field of its own, so this read is where that dimension is made real — from the SAME charged rows, never a second meter. A row that already carries its own product WINS, so the derivation stops the day the meter records one.  `product=<id>` filters to one product server-side. `groupBy=product` reduces to `{product,requests,amountCents}` rollups instead of rows.  `amount` is whole USD cents, ROUNDED; `decimal` beside it is the SAME debit exact, as an 18-decimal USD string. Sum `decimal`. A page of sub-cent token calls totals correctly there and totals ZERO in `amount` — that difference is real money.  Scoped to the caller\'s own org\'s books, where the org\'s ledger file IS the tenant boundary; no client-supplied subject is ever forwarded. 401 without a validated principal. The co-resident read returns the 2000 most recent debits, newest first; `start` and `end` narrow the window only on the split-deploy upstream.
+         * Answers one row per BILLED call against the caller\'s org — transaction id, amount, timestamp and the metered unit. This is the raw charged ledger, not a rollup.  Each row is stamped with a canonical `metadata.product` derived from what the meter persisted: `agent` becomes agents, `provisioning` becomes the provisioned kind, a token-metered row becomes inference, anything else keeps its metering surface. The ledger has no product field of its own, so this read is where that dimension is made real — from the SAME charged rows, never a second meter. A row that already carries its own product WINS, so the derivation stops the day the meter records one.  Each row carries `name`: what its metered unit (`metadata.model`) reads as on a bill — `Desktop sandbox` for `desktop/visor`, `Agent sessions` for `session`. An AI model is its own name. Show `name`; `metadata.model` stays the unit the ledger keys on.  `product=<id>` filters to one product server-side. `groupBy=product` reduces to `{product,requests,amountCents}` rollups instead of rows.  `amount` is whole USD cents, ROUNDED; `decimal` beside it is the SAME debit exact, as an 18-decimal USD string. Sum `decimal`. A page of sub-cent token calls totals correctly there and totals ZERO in `amount` — that difference is real money.  Scoped to the caller\'s own org\'s books, where the org\'s ledger file IS the tenant boundary; no client-supplied subject is ever forwarded. 401 without a validated principal. The co-resident read returns the 2000 most recent debits, newest first; `start` and `end` narrow the window only on the split-deploy upstream.
          * @summary Every billed call the caller\'s org made, attributed to a product
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
@@ -2486,7 +2486,7 @@ const BillingApiFactory = function (configuration, basePath, axios) {
             return localVarFp.getBillingTransactionsById(requestParameters.id, options).then((request) => request(axios, basePath));
         },
         /**
-         * Answers one row per BILLED call against the caller\'s org — transaction id, amount, timestamp and the metered unit. This is the raw charged ledger, not a rollup.  Each row is stamped with a canonical `metadata.product` derived from what the meter persisted: `agent` becomes agents, `provisioning` becomes the provisioned kind, a token-metered row becomes inference, anything else keeps its metering surface. The ledger has no product field of its own, so this read is where that dimension is made real — from the SAME charged rows, never a second meter. A row that already carries its own product WINS, so the derivation stops the day the meter records one.  `product=<id>` filters to one product server-side. `groupBy=product` reduces to `{product,requests,amountCents}` rollups instead of rows.  `amount` is whole USD cents, ROUNDED; `decimal` beside it is the SAME debit exact, as an 18-decimal USD string. Sum `decimal`. A page of sub-cent token calls totals correctly there and totals ZERO in `amount` — that difference is real money.  Scoped to the caller\'s own org\'s books, where the org\'s ledger file IS the tenant boundary; no client-supplied subject is ever forwarded. 401 without a validated principal. The co-resident read returns the 2000 most recent debits, newest first; `start` and `end` narrow the window only on the split-deploy upstream.
+         * Answers one row per BILLED call against the caller\'s org — transaction id, amount, timestamp and the metered unit. This is the raw charged ledger, not a rollup.  Each row is stamped with a canonical `metadata.product` derived from what the meter persisted: `agent` becomes agents, `provisioning` becomes the provisioned kind, a token-metered row becomes inference, anything else keeps its metering surface. The ledger has no product field of its own, so this read is where that dimension is made real — from the SAME charged rows, never a second meter. A row that already carries its own product WINS, so the derivation stops the day the meter records one.  Each row carries `name`: what its metered unit (`metadata.model`) reads as on a bill — `Desktop sandbox` for `desktop/visor`, `Agent sessions` for `session`. An AI model is its own name. Show `name`; `metadata.model` stays the unit the ledger keys on.  `product=<id>` filters to one product server-side. `groupBy=product` reduces to `{product,requests,amountCents}` rollups instead of rows.  `amount` is whole USD cents, ROUNDED; `decimal` beside it is the SAME debit exact, as an 18-decimal USD string. Sum `decimal`. A page of sub-cent token calls totals correctly there and totals ZERO in `amount` — that difference is real money.  Scoped to the caller\'s own org\'s books, where the org\'s ledger file IS the tenant boundary; no client-supplied subject is ever forwarded. 401 without a validated principal. The co-resident read returns the 2000 most recent debits, newest first; `start` and `end` narrow the window only on the split-deploy upstream.
          * @summary Every billed call the caller\'s org made, attributed to a product
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
@@ -2991,7 +2991,7 @@ class BillingApi extends base_1.BaseAPI {
         return (0, exports.BillingApiFp)(this.configuration).getBillingTransactionsById(requestParameters.id, options).then((request) => request(this.axios, this.basePath));
     }
     /**
-     * Answers one row per BILLED call against the caller\'s org — transaction id, amount, timestamp and the metered unit. This is the raw charged ledger, not a rollup.  Each row is stamped with a canonical `metadata.product` derived from what the meter persisted: `agent` becomes agents, `provisioning` becomes the provisioned kind, a token-metered row becomes inference, anything else keeps its metering surface. The ledger has no product field of its own, so this read is where that dimension is made real — from the SAME charged rows, never a second meter. A row that already carries its own product WINS, so the derivation stops the day the meter records one.  `product=<id>` filters to one product server-side. `groupBy=product` reduces to `{product,requests,amountCents}` rollups instead of rows.  `amount` is whole USD cents, ROUNDED; `decimal` beside it is the SAME debit exact, as an 18-decimal USD string. Sum `decimal`. A page of sub-cent token calls totals correctly there and totals ZERO in `amount` — that difference is real money.  Scoped to the caller\'s own org\'s books, where the org\'s ledger file IS the tenant boundary; no client-supplied subject is ever forwarded. 401 without a validated principal. The co-resident read returns the 2000 most recent debits, newest first; `start` and `end` narrow the window only on the split-deploy upstream.
+     * Answers one row per BILLED call against the caller\'s org — transaction id, amount, timestamp and the metered unit. This is the raw charged ledger, not a rollup.  Each row is stamped with a canonical `metadata.product` derived from what the meter persisted: `agent` becomes agents, `provisioning` becomes the provisioned kind, a token-metered row becomes inference, anything else keeps its metering surface. The ledger has no product field of its own, so this read is where that dimension is made real — from the SAME charged rows, never a second meter. A row that already carries its own product WINS, so the derivation stops the day the meter records one.  Each row carries `name`: what its metered unit (`metadata.model`) reads as on a bill — `Desktop sandbox` for `desktop/visor`, `Agent sessions` for `session`. An AI model is its own name. Show `name`; `metadata.model` stays the unit the ledger keys on.  `product=<id>` filters to one product server-side. `groupBy=product` reduces to `{product,requests,amountCents}` rollups instead of rows.  `amount` is whole USD cents, ROUNDED; `decimal` beside it is the SAME debit exact, as an 18-decimal USD string. Sum `decimal`. A page of sub-cent token calls totals correctly there and totals ZERO in `amount` — that difference is real money.  Scoped to the caller\'s own org\'s books, where the org\'s ledger file IS the tenant boundary; no client-supplied subject is ever forwarded. 401 without a validated principal. The co-resident read returns the 2000 most recent debits, newest first; `start` and `end` narrow the window only on the split-deploy upstream.
      * @summary Every billed call the caller\'s org made, attributed to a product
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}

package/dist/api/train-api.d.ts

@@ -225,7 +225,7 @@ export declare const TrainApiAxiosParamCreator: (configuration?: Configuration)
      */
     postTrainJobsByIdEvents: (id: string, trainReportIn: TrainReportIn, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
     /**
-     * Publishes a job\'s output under a name. Only a succeeded job\'s output is publishable; a rejected one broke its regression budget and needs force, which the record keeps. The output must be stored. A capability is published with its route — the question keys it answers and, per key, the exact question (`{\"type\": \"choice\"|\"score\"|\"noul\", \"labels\": [...]}`) — the base SHA-256 its result names, and its form: head for a readout, full for every other adaptation. A route that claims a question another of the org\'s published capabilities claims is 409 route_conflict. A name the org already published moves to this job. Every org\'s published capabilities are what the decision service installs.
+     * Publishes a job\'s output under a name. Only a succeeded job\'s output is publishable; a rejected one broke its regression budget and needs force, which the record keeps. The output must be stored. A capability is published with its route — the question keys it answers and, per key, the exact question (`{\"type\": \"choice\"|\"score\"|\"noul\", \"labels\": [...]}`) — the base SHA-256 its result names, and its form: head for a readout, full for every other adaptation. A route that claims a question another of the org\'s published capabilities claims is 409 route_conflict. A name the org already published moves to this job. A head\'s tar is copied first to the serving store, the models bucket\'s capabilities/<org>/<sha256>, where the decision service fetches it; ai attaches the org\'s published capabilities to its decisions.
      * @summary Publishes a job\'s output under a name.
      * @param {string} id ID names the job.
      * @param {TrainPublishIn} trainPublishIn
@@ -430,7 +430,7 @@ export declare const TrainApiFp: (configuration?: Configuration) => {
      */
     postTrainJobsByIdEvents(id: string, trainReportIn: TrainReportIn, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<TrainReportOut>>;
     /**
-     * Publishes a job\'s output under a name. Only a succeeded job\'s output is publishable; a rejected one broke its regression budget and needs force, which the record keeps. The output must be stored. A capability is published with its route — the question keys it answers and, per key, the exact question (`{\"type\": \"choice\"|\"score\"|\"noul\", \"labels\": [...]}`) — the base SHA-256 its result names, and its form: head for a readout, full for every other adaptation. A route that claims a question another of the org\'s published capabilities claims is 409 route_conflict. A name the org already published moves to this job. Every org\'s published capabilities are what the decision service installs.
+     * Publishes a job\'s output under a name. Only a succeeded job\'s output is publishable; a rejected one broke its regression budget and needs force, which the record keeps. The output must be stored. A capability is published with its route — the question keys it answers and, per key, the exact question (`{\"type\": \"choice\"|\"score\"|\"noul\", \"labels\": [...]}`) — the base SHA-256 its result names, and its form: head for a readout, full for every other adaptation. A route that claims a question another of the org\'s published capabilities claims is 409 route_conflict. A name the org already published moves to this job. A head\'s tar is copied first to the serving store, the models bucket\'s capabilities/<org>/<sha256>, where the decision service fetches it; ai attaches the org\'s published capabilities to its decisions.
      * @summary Publishes a job\'s output under a name.
      * @param {string} id ID names the job.
      * @param {TrainPublishIn} trainPublishIn
@@ -626,7 +626,7 @@ export declare const TrainApiFactory: (configuration?: Configuration, basePath?:
      */
     postTrainJobsByIdEvents(requestParameters: TrainApiPostTrainJobsByIdEventsRequest, options?: RawAxiosRequestConfig): AxiosPromise<TrainReportOut>;
     /**
-     * Publishes a job\'s output under a name. Only a succeeded job\'s output is publishable; a rejected one broke its regression budget and needs force, which the record keeps. The output must be stored. A capability is published with its route — the question keys it answers and, per key, the exact question (`{\"type\": \"choice\"|\"score\"|\"noul\", \"labels\": [...]}`) — the base SHA-256 its result names, and its form: head for a readout, full for every other adaptation. A route that claims a question another of the org\'s published capabilities claims is 409 route_conflict. A name the org already published moves to this job. Every org\'s published capabilities are what the decision service installs.
+     * Publishes a job\'s output under a name. Only a succeeded job\'s output is publishable; a rejected one broke its regression budget and needs force, which the record keeps. The output must be stored. A capability is published with its route — the question keys it answers and, per key, the exact question (`{\"type\": \"choice\"|\"score\"|\"noul\", \"labels\": [...]}`) — the base SHA-256 its result names, and its form: head for a readout, full for every other adaptation. A route that claims a question another of the org\'s published capabilities claims is 409 route_conflict. A name the org already published moves to this job. A head\'s tar is copied first to the serving store, the models bucket\'s capabilities/<org>/<sha256>, where the decision service fetches it; ai attaches the org\'s published capabilities to its decisions.
      * @summary Publishes a job\'s output under a name.
      * @param {TrainApiPostTrainJobsByIdPublishRequest} requestParameters Request parameters.
      * @param {*} [options] Override http request option.
@@ -1178,7 +1178,7 @@ export declare class TrainApi extends BaseAPI {
      */
     postTrainJobsByIdEvents(requestParameters: TrainApiPostTrainJobsByIdEventsRequest, options?: RawAxiosRequestConfig): Promise<globalAxios.AxiosResponse<TrainReportOut, any, {}>>;
     /**
-     * Publishes a job\'s output under a name. Only a succeeded job\'s output is publishable; a rejected one broke its regression budget and needs force, which the record keeps. The output must be stored. A capability is published with its route — the question keys it answers and, per key, the exact question (`{\"type\": \"choice\"|\"score\"|\"noul\", \"labels\": [...]}`) — the base SHA-256 its result names, and its form: head for a readout, full for every other adaptation. A route that claims a question another of the org\'s published capabilities claims is 409 route_conflict. A name the org already published moves to this job. Every org\'s published capabilities are what the decision service installs.
+     * Publishes a job\'s output under a name. Only a succeeded job\'s output is publishable; a rejected one broke its regression budget and needs force, which the record keeps. The output must be stored. A capability is published with its route — the question keys it answers and, per key, the exact question (`{\"type\": \"choice\"|\"score\"|\"noul\", \"labels\": [...]}`) — the base SHA-256 its result names, and its form: head for a readout, full for every other adaptation. A route that claims a question another of the org\'s published capabilities claims is 409 route_conflict. A name the org already published moves to this job. A head\'s tar is copied first to the serving store, the models bucket\'s capabilities/<org>/<sha256>, where the decision service fetches it; ai attaches the org\'s published capabilities to its decisions.
      * @summary Publishes a job\'s output under a name.
      * @param {TrainApiPostTrainJobsByIdPublishRequest} requestParameters Request parameters.
      * @param {*} [options] Override http request option.

package/dist/api/train-api.js

@@ -767,7 +767,7 @@ const TrainApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * Publishes a job\'s output under a name. Only a succeeded job\'s output is publishable; a rejected one broke its regression budget and needs force, which the record keeps. The output must be stored. A capability is published with its route — the question keys it answers and, per key, the exact question (`{\"type\": \"choice\"|\"score\"|\"noul\", \"labels\": [...]}`) — the base SHA-256 its result names, and its form: head for a readout, full for every other adaptation. A route that claims a question another of the org\'s published capabilities claims is 409 route_conflict. A name the org already published moves to this job. Every org\'s published capabilities are what the decision service installs.
+         * Publishes a job\'s output under a name. Only a succeeded job\'s output is publishable; a rejected one broke its regression budget and needs force, which the record keeps. The output must be stored. A capability is published with its route — the question keys it answers and, per key, the exact question (`{\"type\": \"choice\"|\"score\"|\"noul\", \"labels\": [...]}`) — the base SHA-256 its result names, and its form: head for a readout, full for every other adaptation. A route that claims a question another of the org\'s published capabilities claims is 409 route_conflict. A name the org already published moves to this job. A head\'s tar is copied first to the serving store, the models bucket\'s capabilities/<org>/<sha256>, where the decision service fetches it; ai attaches the org\'s published capabilities to its decisions.
          * @summary Publishes a job\'s output under a name.
          * @param {string} id ID names the job.
          * @param {TrainPublishIn} trainPublishIn
@@ -1139,7 +1139,7 @@ const TrainApiFp = function (configuration) {
             return (axios, basePath) => (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Publishes a job\'s output under a name. Only a succeeded job\'s output is publishable; a rejected one broke its regression budget and needs force, which the record keeps. The output must be stored. A capability is published with its route — the question keys it answers and, per key, the exact question (`{\"type\": \"choice\"|\"score\"|\"noul\", \"labels\": [...]}`) — the base SHA-256 its result names, and its form: head for a readout, full for every other adaptation. A route that claims a question another of the org\'s published capabilities claims is 409 route_conflict. A name the org already published moves to this job. Every org\'s published capabilities are what the decision service installs.
+         * Publishes a job\'s output under a name. Only a succeeded job\'s output is publishable; a rejected one broke its regression budget and needs force, which the record keeps. The output must be stored. A capability is published with its route — the question keys it answers and, per key, the exact question (`{\"type\": \"choice\"|\"score\"|\"noul\", \"labels\": [...]}`) — the base SHA-256 its result names, and its form: head for a readout, full for every other adaptation. A route that claims a question another of the org\'s published capabilities claims is 409 route_conflict. A name the org already published moves to this job. A head\'s tar is copied first to the serving store, the models bucket\'s capabilities/<org>/<sha256>, where the decision service fetches it; ai attaches the org\'s published capabilities to its decisions.
          * @summary Publishes a job\'s output under a name.
          * @param {string} id ID names the job.
          * @param {TrainPublishIn} trainPublishIn
@@ -1393,7 +1393,7 @@ const TrainApiFactory = function (configuration, basePath, axios) {
             return localVarFp.postTrainJobsByIdEvents(requestParameters.id, requestParameters.trainReportIn, options).then((request) => request(axios, basePath));
         },
         /**
-         * Publishes a job\'s output under a name. Only a succeeded job\'s output is publishable; a rejected one broke its regression budget and needs force, which the record keeps. The output must be stored. A capability is published with its route — the question keys it answers and, per key, the exact question (`{\"type\": \"choice\"|\"score\"|\"noul\", \"labels\": [...]}`) — the base SHA-256 its result names, and its form: head for a readout, full for every other adaptation. A route that claims a question another of the org\'s published capabilities claims is 409 route_conflict. A name the org already published moves to this job. Every org\'s published capabilities are what the decision service installs.
+         * Publishes a job\'s output under a name. Only a succeeded job\'s output is publishable; a rejected one broke its regression budget and needs force, which the record keeps. The output must be stored. A capability is published with its route — the question keys it answers and, per key, the exact question (`{\"type\": \"choice\"|\"score\"|\"noul\", \"labels\": [...]}`) — the base SHA-256 its result names, and its form: head for a readout, full for every other adaptation. A route that claims a question another of the org\'s published capabilities claims is 409 route_conflict. A name the org already published moves to this job. A head\'s tar is copied first to the serving store, the models bucket\'s capabilities/<org>/<sha256>, where the decision service fetches it; ai attaches the org\'s published capabilities to its decisions.
          * @summary Publishes a job\'s output under a name.
          * @param {TrainApiPostTrainJobsByIdPublishRequest} requestParameters Request parameters.
          * @param {*} [options] Override http request option.
@@ -1662,7 +1662,7 @@ class TrainApi extends base_1.BaseAPI {
         return (0, exports.TrainApiFp)(this.configuration).postTrainJobsByIdEvents(requestParameters.id, requestParameters.trainReportIn, options).then((request) => request(this.axios, this.basePath));
     }
     /**
-     * Publishes a job\'s output under a name. Only a succeeded job\'s output is publishable; a rejected one broke its regression budget and needs force, which the record keeps. The output must be stored. A capability is published with its route — the question keys it answers and, per key, the exact question (`{\"type\": \"choice\"|\"score\"|\"noul\", \"labels\": [...]}`) — the base SHA-256 its result names, and its form: head for a readout, full for every other adaptation. A route that claims a question another of the org\'s published capabilities claims is 409 route_conflict. A name the org already published moves to this job. Every org\'s published capabilities are what the decision service installs.
+     * Publishes a job\'s output under a name. Only a succeeded job\'s output is publishable; a rejected one broke its regression budget and needs force, which the record keeps. The output must be stored. A capability is published with its route — the question keys it answers and, per key, the exact question (`{\"type\": \"choice\"|\"score\"|\"noul\", \"labels\": [...]}`) — the base SHA-256 its result names, and its form: head for a readout, full for every other adaptation. A route that claims a question another of the org\'s published capabilities claims is 409 route_conflict. A name the org already published moves to this job. A head\'s tar is copied first to the serving store, the models bucket\'s capabilities/<org>/<sha256>, where the decision service fetches it; ai attaches the org\'s published capabilities to its decisions.
      * @summary Publishes a job\'s output under a name.
      * @param {TrainApiPostTrainJobsByIdPublishRequest} requestParameters Request parameters.
      * @param {*} [options] Override http request option.

package/dist/esm/api/ai-api.d.ts

@@ -27,7 +27,6 @@ import type { AiModelList } from '../models';
 import type { AiModels } from '../models';
 import type { AiRanking } from '../models';
 import type { AiResponse } from '../models';
-import type { AiResponsesResource } from '../models';
 import type { AiRoutingEdit } from '../models';
 import type { AiRoutingRewardRequest } from '../models';
 import type { AiTokenCount } from '../models';
@@ -112,7 +111,9 @@ import type { PostAiTreeFiles200Response } from '../models';
 import type { PostAiVectors200Response } from '../models';
 import type { PostAiVideos200Response } from '../models';
 import type { PostAiWorkflows200Response } from '../models';
+import type { PostChat200Response } from '../models';
 import type { PostModelsByModelAccess200Response } from '../models';
+import type { PostResponses200Response } from '../models';
 import type { PutAiRouterCatalog200Response } from '../models';
 /**
  * AiApi - axios parameter creator
@@ -4760,7 +4761,7 @@ export declare const AiApiFp: (configuration?: Configuration) => {
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    postChat(openaiChatCompletionRequest: OpenaiChatCompletionRequest, xMaxCost?: number, xMaxLatencyMs?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<OpenaiChatCompletionResponse>>;
+    postChat(openaiChatCompletionRequest: OpenaiChatCompletionRequest, xMaxCost?: number, xMaxLatencyMs?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<PostChat200Response>>;
     /**
      * Implements the OpenAI-compatible chat completions API
      * @summary Implements the OpenAI-compatible chat completions API
@@ -4770,7 +4771,7 @@ export declare const AiApiFp: (configuration?: Configuration) => {
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    postChatCompletions(openaiChatCompletionRequest: OpenaiChatCompletionRequest, xMaxCost?: number, xMaxLatencyMs?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<OpenaiChatCompletionResponse>>;
+    postChatCompletions(openaiChatCompletionRequest: OpenaiChatCompletionRequest, xMaxCost?: number, xMaxLatencyMs?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<PostChat200Response>>;
     /**
      * Serves one completion to a caller with no account.
      * @summary Serves one completion to a caller with no account.
@@ -4788,7 +4789,7 @@ export declare const AiApiFp: (configuration?: Configuration) => {
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    postCompletions(openaiChatCompletionRequest: OpenaiChatCompletionRequest, xMaxCost?: number, xMaxLatencyMs?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<OpenaiChatCompletionResponse>>;
+    postCompletions(openaiChatCompletionRequest: OpenaiChatCompletionRequest, xMaxCost?: number, xMaxLatencyMs?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<PostChat200Response>>;
     /**
      * Implements POST /v1/decisions (the Decisions API).  Body: {\"model\": \"kai\", \"state\": \"...\"|{...}|[...], \"questions\": {\"<name>\": {\"type\": \"choice\"|\"noul\"|\"score\", \"instructions\": ..., \"criteria\": ...}}}. model is kai, Kai\'s versioned id kai-<12 hex of the weights\' sha256> — priced as kai and sent as asked — or Jev by OpenRouter\'s vendor ids, typesafe/jev-1.13 and ~typesafe/jev-latest, which reach Jev itself and bill at Jev\'s list price. No Jev id is ever answered by Kai: a bare one, such as jev-latest, is an unknown model. model is required; state and questions are required unless the request names a handle, which carries neither. instructions is optional and any JSON. A choice names at least 2 labels and a score at least 1 level, bounded by the token budget rather than a count; questions holds 1 to 100.  observe holds the state under an id, and a later request naming that id as its handle decides over it again. An id is 1 to 128 characters of A-Z, a-z, 0-9, \'.\', \'_\' and \'-\'. A handle belongs to the org that observed it: no other org\'s request can name it.  Response: {\"id\",\"model\",\"provider\",\"answers\":{\"<name>\":{\"type\",...}}, \"usage\":{\"input_tokens\",\"output_tokens\"},\"routing\",\"state_hash\",\"latency_ms\"}. usage.input_tokens is the billed count — the request\'s text counted once, the state once and each question\'s instructions and options once; a decision over a handle bills the state once, when it was observed.  The body may be sent gzip, deflate, br or zstd encoded; decoded, it is bounded as sent.  Refusals are {\"error\":{\"code\",\"message\"}}: 400 malformed JSON or unknown model, 401 no valid credential, 402 insufficient balance, 403 a key kind that may not call this (pk-), 415 any other Content-Encoding, 422 an invalid question or handle id, a state beyond the checkpoint\'s reach (code state_too_long) or a body past 16 MiB (code request_too_long), 429 rate limited or queue full, 502 the service failed, 503 the model is known and not served, 529 overloaded. 402, 429 and 529 carry Retry-After and Retry-After-Ms, and every answer carries X-Request-Id. Billed on the answer\'s input tokens at the model\'s price.
      * @summary Implements POST /v1/decisions (the Decisions API).
@@ -4850,7 +4851,7 @@ export declare const AiApiFp: (configuration?: Configuration) => {
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    postResponses(xMaxCost?: number, xMaxLatencyMs?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AiResponsesResource>>;
+    postResponses(xMaxCost?: number, xMaxLatencyMs?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<PostResponses200Response>>;
     /**
      * Implements POST /v1/videos/generations — the ASYNC create.  Body: {\"model\": \"...\", \"prompt\": \"...\", \"size\"?: \"1280x720\", \"seconds\"?: int}  It authenticates the caller, resolves the model to its upstream provider via the shared routing table (zen3-video* / wan2-2-t2v-a14b → the spark-video backend), reserves the per-video budget (the balance gate), creates ONE upstream job, registers it in the in-pod store, and returns the OpenAI-shaped video object with status \"queued\" IMMEDIATELY. The client then polls GET /v1/videos/{id} and downloads GET /v1/videos/{id}/content. Nothing is billed here — the debit lands on completion.
      * @summary Implements POST /v1/videos/generations — the ASYNC create.
@@ -7165,7 +7166,7 @@ export declare const AiApiFactory: (configuration?: Configuration, basePath?: st
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    postChat(requestParameters: AiApiPostChatRequest, options?: RawAxiosRequestConfig): AxiosPromise<OpenaiChatCompletionResponse>;
+    postChat(requestParameters: AiApiPostChatRequest, options?: RawAxiosRequestConfig): AxiosPromise<PostChat200Response>;
     /**
      * Implements the OpenAI-compatible chat completions API
      * @summary Implements the OpenAI-compatible chat completions API
@@ -7173,7 +7174,7 @@ export declare const AiApiFactory: (configuration?: Configuration, basePath?: st
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    postChatCompletions(requestParameters: AiApiPostChatCompletionsRequest, options?: RawAxiosRequestConfig): AxiosPromise<OpenaiChatCompletionResponse>;
+    postChatCompletions(requestParameters: AiApiPostChatCompletionsRequest, options?: RawAxiosRequestConfig): AxiosPromise<PostChat200Response>;
     /**
      * Serves one completion to a caller with no account.
      * @summary Serves one completion to a caller with no account.
@@ -7189,7 +7190,7 @@ export declare const AiApiFactory: (configuration?: Configuration, basePath?: st
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    postCompletions(requestParameters: AiApiPostCompletionsRequest, options?: RawAxiosRequestConfig): AxiosPromise<OpenaiChatCompletionResponse>;
+    postCompletions(requestParameters: AiApiPostCompletionsRequest, options?: RawAxiosRequestConfig): AxiosPromise<PostChat200Response>;
     /**
      * Implements POST /v1/decisions (the Decisions API).  Body: {\"model\": \"kai\", \"state\": \"...\"|{...}|[...], \"questions\": {\"<name>\": {\"type\": \"choice\"|\"noul\"|\"score\", \"instructions\": ..., \"criteria\": ...}}}. model is kai, Kai\'s versioned id kai-<12 hex of the weights\' sha256> — priced as kai and sent as asked — or Jev by OpenRouter\'s vendor ids, typesafe/jev-1.13 and ~typesafe/jev-latest, which reach Jev itself and bill at Jev\'s list price. No Jev id is ever answered by Kai: a bare one, such as jev-latest, is an unknown model. model is required; state and questions are required unless the request names a handle, which carries neither. instructions is optional and any JSON. A choice names at least 2 labels and a score at least 1 level, bounded by the token budget rather than a count; questions holds 1 to 100.  observe holds the state under an id, and a later request naming that id as its handle decides over it again. An id is 1 to 128 characters of A-Z, a-z, 0-9, \'.\', \'_\' and \'-\'. A handle belongs to the org that observed it: no other org\'s request can name it.  Response: {\"id\",\"model\",\"provider\",\"answers\":{\"<name>\":{\"type\",...}}, \"usage\":{\"input_tokens\",\"output_tokens\"},\"routing\",\"state_hash\",\"latency_ms\"}. usage.input_tokens is the billed count — the request\'s text counted once, the state once and each question\'s instructions and options once; a decision over a handle bills the state once, when it was observed.  The body may be sent gzip, deflate, br or zstd encoded; decoded, it is bounded as sent.  Refusals are {\"error\":{\"code\",\"message\"}}: 400 malformed JSON or unknown model, 401 no valid credential, 402 insufficient balance, 403 a key kind that may not call this (pk-), 415 any other Content-Encoding, 422 an invalid question or handle id, a state beyond the checkpoint\'s reach (code state_too_long) or a body past 16 MiB (code request_too_long), 429 rate limited or queue full, 502 the service failed, 503 the model is known and not served, 529 overloaded. 402, 429 and 529 carry Retry-After and Retry-After-Ms, and every answer carries X-Request-Id. Billed on the answer\'s input tokens at the model\'s price.
      * @summary Implements POST /v1/decisions (the Decisions API).
@@ -7250,7 +7251,7 @@ export declare const AiApiFactory: (configuration?: Configuration, basePath?: st
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    postResponses(requestParameters?: AiApiPostResponsesRequest, options?: RawAxiosRequestConfig): AxiosPromise<AiResponsesResource>;
+    postResponses(requestParameters?: AiApiPostResponsesRequest, options?: RawAxiosRequestConfig): AxiosPromise<PostResponses200Response>;
     /**
      * Implements POST /v1/videos/generations — the ASYNC create.  Body: {\"model\": \"...\", \"prompt\": \"...\", \"size\"?: \"1280x720\", \"seconds\"?: int}  It authenticates the caller, resolves the model to its upstream provider via the shared routing table (zen3-video* / wan2-2-t2v-a14b → the spark-video backend), reserves the per-video budget (the balance gate), creates ONE upstream job, registers it in the in-pod store, and returns the OpenAI-shaped video object with status \"queued\" IMMEDIATELY. The client then polls GET /v1/videos/{id} and downloads GET /v1/videos/{id}/content. Nothing is billed here — the debit lands on completion.
      * @summary Implements POST /v1/videos/generations — the ASYNC create.
@@ -13126,7 +13127,7 @@ export declare class AiApi extends BaseAPI {
      * @throws {RequiredError}
      * @memberof AiApi
      */
-    postResponses(requestParameters?: AiApiPostResponsesRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<AiResponsesResource, any, {}>>;
+    postResponses(requestParameters?: AiApiPostResponsesRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<import("..").AiResponsesResource, any, {}>>;
     /**
      * Implements POST /v1/videos/generations — the ASYNC create.  Body: {\"model\": \"...\", \"prompt\": \"...\", \"size\"?: \"1280x720\", \"seconds\"?: int}  It authenticates the caller, resolves the model to its upstream provider via the shared routing table (zen3-video* / wan2-2-t2v-a14b → the spark-video backend), reserves the per-video budget (the balance gate), creates ONE upstream job, registers it in the in-pod store, and returns the OpenAI-shaped video object with status \"queued\" IMMEDIATELY. The client then polls GET /v1/videos/{id} and downloads GET /v1/videos/{id}/content. Nothing is billed here — the debit lands on completion.
      * @summary Implements POST /v1/videos/generations — the ASYNC create.

package/dist/esm/api/billing-api.d.ts

@@ -274,7 +274,7 @@ export declare const BillingApiAxiosParamCreator: (configuration?: Configuration
      */
     getBillingTransactionsById: (id: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
     /**
-     * Answers one row per BILLED call against the caller\'s org — transaction id, amount, timestamp and the metered unit. This is the raw charged ledger, not a rollup.  Each row is stamped with a canonical `metadata.product` derived from what the meter persisted: `agent` becomes agents, `provisioning` becomes the provisioned kind, a token-metered row becomes inference, anything else keeps its metering surface. The ledger has no product field of its own, so this read is where that dimension is made real — from the SAME charged rows, never a second meter. A row that already carries its own product WINS, so the derivation stops the day the meter records one.  `product=<id>` filters to one product server-side. `groupBy=product` reduces to `{product,requests,amountCents}` rollups instead of rows.  `amount` is whole USD cents, ROUNDED; `decimal` beside it is the SAME debit exact, as an 18-decimal USD string. Sum `decimal`. A page of sub-cent token calls totals correctly there and totals ZERO in `amount` — that difference is real money.  Scoped to the caller\'s own org\'s books, where the org\'s ledger file IS the tenant boundary; no client-supplied subject is ever forwarded. 401 without a validated principal. The co-resident read returns the 2000 most recent debits, newest first; `start` and `end` narrow the window only on the split-deploy upstream.
+     * Answers one row per BILLED call against the caller\'s org — transaction id, amount, timestamp and the metered unit. This is the raw charged ledger, not a rollup.  Each row is stamped with a canonical `metadata.product` derived from what the meter persisted: `agent` becomes agents, `provisioning` becomes the provisioned kind, a token-metered row becomes inference, anything else keeps its metering surface. The ledger has no product field of its own, so this read is where that dimension is made real — from the SAME charged rows, never a second meter. A row that already carries its own product WINS, so the derivation stops the day the meter records one.  Each row carries `name`: what its metered unit (`metadata.model`) reads as on a bill — `Desktop sandbox` for `desktop/visor`, `Agent sessions` for `session`. An AI model is its own name. Show `name`; `metadata.model` stays the unit the ledger keys on.  `product=<id>` filters to one product server-side. `groupBy=product` reduces to `{product,requests,amountCents}` rollups instead of rows.  `amount` is whole USD cents, ROUNDED; `decimal` beside it is the SAME debit exact, as an 18-decimal USD string. Sum `decimal`. A page of sub-cent token calls totals correctly there and totals ZERO in `amount` — that difference is real money.  Scoped to the caller\'s own org\'s books, where the org\'s ledger file IS the tenant boundary; no client-supplied subject is ever forwarded. 401 without a validated principal. The co-resident read returns the 2000 most recent debits, newest first; `start` and `end` narrow the window only on the split-deploy upstream.
      * @summary Every billed call the caller\'s org made, attributed to a product
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
@@ -663,7 +663,7 @@ export declare const BillingApiFp: (configuration?: Configuration) => {
      */
     getBillingTransactionsById(id: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<BillingTransaction>>;
     /**
-     * Answers one row per BILLED call against the caller\'s org — transaction id, amount, timestamp and the metered unit. This is the raw charged ledger, not a rollup.  Each row is stamped with a canonical `metadata.product` derived from what the meter persisted: `agent` becomes agents, `provisioning` becomes the provisioned kind, a token-metered row becomes inference, anything else keeps its metering surface. The ledger has no product field of its own, so this read is where that dimension is made real — from the SAME charged rows, never a second meter. A row that already carries its own product WINS, so the derivation stops the day the meter records one.  `product=<id>` filters to one product server-side. `groupBy=product` reduces to `{product,requests,amountCents}` rollups instead of rows.  `amount` is whole USD cents, ROUNDED; `decimal` beside it is the SAME debit exact, as an 18-decimal USD string. Sum `decimal`. A page of sub-cent token calls totals correctly there and totals ZERO in `amount` — that difference is real money.  Scoped to the caller\'s own org\'s books, where the org\'s ledger file IS the tenant boundary; no client-supplied subject is ever forwarded. 401 without a validated principal. The co-resident read returns the 2000 most recent debits, newest first; `start` and `end` narrow the window only on the split-deploy upstream.
+     * Answers one row per BILLED call against the caller\'s org — transaction id, amount, timestamp and the metered unit. This is the raw charged ledger, not a rollup.  Each row is stamped with a canonical `metadata.product` derived from what the meter persisted: `agent` becomes agents, `provisioning` becomes the provisioned kind, a token-metered row becomes inference, anything else keeps its metering surface. The ledger has no product field of its own, so this read is where that dimension is made real — from the SAME charged rows, never a second meter. A row that already carries its own product WINS, so the derivation stops the day the meter records one.  Each row carries `name`: what its metered unit (`metadata.model`) reads as on a bill — `Desktop sandbox` for `desktop/visor`, `Agent sessions` for `session`. An AI model is its own name. Show `name`; `metadata.model` stays the unit the ledger keys on.  `product=<id>` filters to one product server-side. `groupBy=product` reduces to `{product,requests,amountCents}` rollups instead of rows.  `amount` is whole USD cents, ROUNDED; `decimal` beside it is the SAME debit exact, as an 18-decimal USD string. Sum `decimal`. A page of sub-cent token calls totals correctly there and totals ZERO in `amount` — that difference is real money.  Scoped to the caller\'s own org\'s books, where the org\'s ledger file IS the tenant boundary; no client-supplied subject is ever forwarded. 401 without a validated principal. The co-resident read returns the 2000 most recent debits, newest first; `start` and `end` narrow the window only on the split-deploy upstream.
      * @summary Every billed call the caller\'s org made, attributed to a product
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
@@ -1042,7 +1042,7 @@ export declare const BillingApiFactory: (configuration?: Configuration, basePath
      */
     getBillingTransactionsById(requestParameters: BillingApiGetBillingTransactionsByIdRequest, options?: RawAxiosRequestConfig): AxiosPromise<BillingTransaction>;
     /**
-     * Answers one row per BILLED call against the caller\'s org — transaction id, amount, timestamp and the metered unit. This is the raw charged ledger, not a rollup.  Each row is stamped with a canonical `metadata.product` derived from what the meter persisted: `agent` becomes agents, `provisioning` becomes the provisioned kind, a token-metered row becomes inference, anything else keeps its metering surface. The ledger has no product field of its own, so this read is where that dimension is made real — from the SAME charged rows, never a second meter. A row that already carries its own product WINS, so the derivation stops the day the meter records one.  `product=<id>` filters to one product server-side. `groupBy=product` reduces to `{product,requests,amountCents}` rollups instead of rows.  `amount` is whole USD cents, ROUNDED; `decimal` beside it is the SAME debit exact, as an 18-decimal USD string. Sum `decimal`. A page of sub-cent token calls totals correctly there and totals ZERO in `amount` — that difference is real money.  Scoped to the caller\'s own org\'s books, where the org\'s ledger file IS the tenant boundary; no client-supplied subject is ever forwarded. 401 without a validated principal. The co-resident read returns the 2000 most recent debits, newest first; `start` and `end` narrow the window only on the split-deploy upstream.
+     * Answers one row per BILLED call against the caller\'s org — transaction id, amount, timestamp and the metered unit. This is the raw charged ledger, not a rollup.  Each row is stamped with a canonical `metadata.product` derived from what the meter persisted: `agent` becomes agents, `provisioning` becomes the provisioned kind, a token-metered row becomes inference, anything else keeps its metering surface. The ledger has no product field of its own, so this read is where that dimension is made real — from the SAME charged rows, never a second meter. A row that already carries its own product WINS, so the derivation stops the day the meter records one.  Each row carries `name`: what its metered unit (`metadata.model`) reads as on a bill — `Desktop sandbox` for `desktop/visor`, `Agent sessions` for `session`. An AI model is its own name. Show `name`; `metadata.model` stays the unit the ledger keys on.  `product=<id>` filters to one product server-side. `groupBy=product` reduces to `{product,requests,amountCents}` rollups instead of rows.  `amount` is whole USD cents, ROUNDED; `decimal` beside it is the SAME debit exact, as an 18-decimal USD string. Sum `decimal`. A page of sub-cent token calls totals correctly there and totals ZERO in `amount` — that difference is real money.  Scoped to the caller\'s own org\'s books, where the org\'s ledger file IS the tenant boundary; no client-supplied subject is ever forwarded. 401 without a validated principal. The co-resident read returns the 2000 most recent debits, newest first; `start` and `end` narrow the window only on the split-deploy upstream.
      * @summary Every billed call the caller\'s org made, attributed to a product
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
@@ -1869,7 +1869,7 @@ export declare class BillingApi extends BaseAPI {
      */
     getBillingTransactionsById(requestParameters: BillingApiGetBillingTransactionsByIdRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<BillingTransaction, any, {}>>;
     /**
-     * Answers one row per BILLED call against the caller\'s org — transaction id, amount, timestamp and the metered unit. This is the raw charged ledger, not a rollup.  Each row is stamped with a canonical `metadata.product` derived from what the meter persisted: `agent` becomes agents, `provisioning` becomes the provisioned kind, a token-metered row becomes inference, anything else keeps its metering surface. The ledger has no product field of its own, so this read is where that dimension is made real — from the SAME charged rows, never a second meter. A row that already carries its own product WINS, so the derivation stops the day the meter records one.  `product=<id>` filters to one product server-side. `groupBy=product` reduces to `{product,requests,amountCents}` rollups instead of rows.  `amount` is whole USD cents, ROUNDED; `decimal` beside it is the SAME debit exact, as an 18-decimal USD string. Sum `decimal`. A page of sub-cent token calls totals correctly there and totals ZERO in `amount` — that difference is real money.  Scoped to the caller\'s own org\'s books, where the org\'s ledger file IS the tenant boundary; no client-supplied subject is ever forwarded. 401 without a validated principal. The co-resident read returns the 2000 most recent debits, newest first; `start` and `end` narrow the window only on the split-deploy upstream.
+     * Answers one row per BILLED call against the caller\'s org — transaction id, amount, timestamp and the metered unit. This is the raw charged ledger, not a rollup.  Each row is stamped with a canonical `metadata.product` derived from what the meter persisted: `agent` becomes agents, `provisioning` becomes the provisioned kind, a token-metered row becomes inference, anything else keeps its metering surface. The ledger has no product field of its own, so this read is where that dimension is made real — from the SAME charged rows, never a second meter. A row that already carries its own product WINS, so the derivation stops the day the meter records one.  Each row carries `name`: what its metered unit (`metadata.model`) reads as on a bill — `Desktop sandbox` for `desktop/visor`, `Agent sessions` for `session`. An AI model is its own name. Show `name`; `metadata.model` stays the unit the ledger keys on.  `product=<id>` filters to one product server-side. `groupBy=product` reduces to `{product,requests,amountCents}` rollups instead of rows.  `amount` is whole USD cents, ROUNDED; `decimal` beside it is the SAME debit exact, as an 18-decimal USD string. Sum `decimal`. A page of sub-cent token calls totals correctly there and totals ZERO in `amount` — that difference is real money.  Scoped to the caller\'s own org\'s books, where the org\'s ledger file IS the tenant boundary; no client-supplied subject is ever forwarded. 401 without a validated principal. The co-resident read returns the 2000 most recent debits, newest first; `start` and `end` narrow the window only on the split-deploy upstream.
      * @summary Every billed call the caller\'s org made, attributed to a product
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}

package/dist/esm/api/billing-api.js

@@ -901,7 +901,7 @@ export const BillingApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * Answers one row per BILLED call against the caller\'s org — transaction id, amount, timestamp and the metered unit. This is the raw charged ledger, not a rollup.  Each row is stamped with a canonical `metadata.product` derived from what the meter persisted: `agent` becomes agents, `provisioning` becomes the provisioned kind, a token-metered row becomes inference, anything else keeps its metering surface. The ledger has no product field of its own, so this read is where that dimension is made real — from the SAME charged rows, never a second meter. A row that already carries its own product WINS, so the derivation stops the day the meter records one.  `product=<id>` filters to one product server-side. `groupBy=product` reduces to `{product,requests,amountCents}` rollups instead of rows.  `amount` is whole USD cents, ROUNDED; `decimal` beside it is the SAME debit exact, as an 18-decimal USD string. Sum `decimal`. A page of sub-cent token calls totals correctly there and totals ZERO in `amount` — that difference is real money.  Scoped to the caller\'s own org\'s books, where the org\'s ledger file IS the tenant boundary; no client-supplied subject is ever forwarded. 401 without a validated principal. The co-resident read returns the 2000 most recent debits, newest first; `start` and `end` narrow the window only on the split-deploy upstream.
+         * Answers one row per BILLED call against the caller\'s org — transaction id, amount, timestamp and the metered unit. This is the raw charged ledger, not a rollup.  Each row is stamped with a canonical `metadata.product` derived from what the meter persisted: `agent` becomes agents, `provisioning` becomes the provisioned kind, a token-metered row becomes inference, anything else keeps its metering surface. The ledger has no product field of its own, so this read is where that dimension is made real — from the SAME charged rows, never a second meter. A row that already carries its own product WINS, so the derivation stops the day the meter records one.  Each row carries `name`: what its metered unit (`metadata.model`) reads as on a bill — `Desktop sandbox` for `desktop/visor`, `Agent sessions` for `session`. An AI model is its own name. Show `name`; `metadata.model` stays the unit the ledger keys on.  `product=<id>` filters to one product server-side. `groupBy=product` reduces to `{product,requests,amountCents}` rollups instead of rows.  `amount` is whole USD cents, ROUNDED; `decimal` beside it is the SAME debit exact, as an 18-decimal USD string. Sum `decimal`. A page of sub-cent token calls totals correctly there and totals ZERO in `amount` — that difference is real money.  Scoped to the caller\'s own org\'s books, where the org\'s ledger file IS the tenant boundary; no client-supplied subject is ever forwarded. 401 without a validated principal. The co-resident read returns the 2000 most recent debits, newest first; `start` and `end` narrow the window only on the split-deploy upstream.
          * @summary Every billed call the caller\'s org made, attributed to a product
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
@@ -1935,7 +1935,7 @@ export const BillingApiFp = function (configuration) {
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Answers one row per BILLED call against the caller\'s org — transaction id, amount, timestamp and the metered unit. This is the raw charged ledger, not a rollup.  Each row is stamped with a canonical `metadata.product` derived from what the meter persisted: `agent` becomes agents, `provisioning` becomes the provisioned kind, a token-metered row becomes inference, anything else keeps its metering surface. The ledger has no product field of its own, so this read is where that dimension is made real — from the SAME charged rows, never a second meter. A row that already carries its own product WINS, so the derivation stops the day the meter records one.  `product=<id>` filters to one product server-side. `groupBy=product` reduces to `{product,requests,amountCents}` rollups instead of rows.  `amount` is whole USD cents, ROUNDED; `decimal` beside it is the SAME debit exact, as an 18-decimal USD string. Sum `decimal`. A page of sub-cent token calls totals correctly there and totals ZERO in `amount` — that difference is real money.  Scoped to the caller\'s own org\'s books, where the org\'s ledger file IS the tenant boundary; no client-supplied subject is ever forwarded. 401 without a validated principal. The co-resident read returns the 2000 most recent debits, newest first; `start` and `end` narrow the window only on the split-deploy upstream.
+         * Answers one row per BILLED call against the caller\'s org — transaction id, amount, timestamp and the metered unit. This is the raw charged ledger, not a rollup.  Each row is stamped with a canonical `metadata.product` derived from what the meter persisted: `agent` becomes agents, `provisioning` becomes the provisioned kind, a token-metered row becomes inference, anything else keeps its metering surface. The ledger has no product field of its own, so this read is where that dimension is made real — from the SAME charged rows, never a second meter. A row that already carries its own product WINS, so the derivation stops the day the meter records one.  Each row carries `name`: what its metered unit (`metadata.model`) reads as on a bill — `Desktop sandbox` for `desktop/visor`, `Agent sessions` for `session`. An AI model is its own name. Show `name`; `metadata.model` stays the unit the ledger keys on.  `product=<id>` filters to one product server-side. `groupBy=product` reduces to `{product,requests,amountCents}` rollups instead of rows.  `amount` is whole USD cents, ROUNDED; `decimal` beside it is the SAME debit exact, as an 18-decimal USD string. Sum `decimal`. A page of sub-cent token calls totals correctly there and totals ZERO in `amount` — that difference is real money.  Scoped to the caller\'s own org\'s books, where the org\'s ledger file IS the tenant boundary; no client-supplied subject is ever forwarded. 401 without a validated principal. The co-resident read returns the 2000 most recent debits, newest first; `start` and `end` narrow the window only on the split-deploy upstream.
          * @summary Every billed call the caller\'s org made, attributed to a product
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
@@ -2478,7 +2478,7 @@ export const BillingApiFactory = function (configuration, basePath, axios) {
             return localVarFp.getBillingTransactionsById(requestParameters.id, options).then((request) => request(axios, basePath));
         },
         /**
-         * Answers one row per BILLED call against the caller\'s org — transaction id, amount, timestamp and the metered unit. This is the raw charged ledger, not a rollup.  Each row is stamped with a canonical `metadata.product` derived from what the meter persisted: `agent` becomes agents, `provisioning` becomes the provisioned kind, a token-metered row becomes inference, anything else keeps its metering surface. The ledger has no product field of its own, so this read is where that dimension is made real — from the SAME charged rows, never a second meter. A row that already carries its own product WINS, so the derivation stops the day the meter records one.  `product=<id>` filters to one product server-side. `groupBy=product` reduces to `{product,requests,amountCents}` rollups instead of rows.  `amount` is whole USD cents, ROUNDED; `decimal` beside it is the SAME debit exact, as an 18-decimal USD string. Sum `decimal`. A page of sub-cent token calls totals correctly there and totals ZERO in `amount` — that difference is real money.  Scoped to the caller\'s own org\'s books, where the org\'s ledger file IS the tenant boundary; no client-supplied subject is ever forwarded. 401 without a validated principal. The co-resident read returns the 2000 most recent debits, newest first; `start` and `end` narrow the window only on the split-deploy upstream.
+         * Answers one row per BILLED call against the caller\'s org — transaction id, amount, timestamp and the metered unit. This is the raw charged ledger, not a rollup.  Each row is stamped with a canonical `metadata.product` derived from what the meter persisted: `agent` becomes agents, `provisioning` becomes the provisioned kind, a token-metered row becomes inference, anything else keeps its metering surface. The ledger has no product field of its own, so this read is where that dimension is made real — from the SAME charged rows, never a second meter. A row that already carries its own product WINS, so the derivation stops the day the meter records one.  Each row carries `name`: what its metered unit (`metadata.model`) reads as on a bill — `Desktop sandbox` for `desktop/visor`, `Agent sessions` for `session`. An AI model is its own name. Show `name`; `metadata.model` stays the unit the ledger keys on.  `product=<id>` filters to one product server-side. `groupBy=product` reduces to `{product,requests,amountCents}` rollups instead of rows.  `amount` is whole USD cents, ROUNDED; `decimal` beside it is the SAME debit exact, as an 18-decimal USD string. Sum `decimal`. A page of sub-cent token calls totals correctly there and totals ZERO in `amount` — that difference is real money.  Scoped to the caller\'s own org\'s books, where the org\'s ledger file IS the tenant boundary; no client-supplied subject is ever forwarded. 401 without a validated principal. The co-resident read returns the 2000 most recent debits, newest first; `start` and `end` narrow the window only on the split-deploy upstream.
          * @summary Every billed call the caller\'s org made, attributed to a product
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
@@ -2982,7 +2982,7 @@ export class BillingApi extends BaseAPI {
         return BillingApiFp(this.configuration).getBillingTransactionsById(requestParameters.id, options).then((request) => request(this.axios, this.basePath));
     }
     /**
-     * Answers one row per BILLED call against the caller\'s org — transaction id, amount, timestamp and the metered unit. This is the raw charged ledger, not a rollup.  Each row is stamped with a canonical `metadata.product` derived from what the meter persisted: `agent` becomes agents, `provisioning` becomes the provisioned kind, a token-metered row becomes inference, anything else keeps its metering surface. The ledger has no product field of its own, so this read is where that dimension is made real — from the SAME charged rows, never a second meter. A row that already carries its own product WINS, so the derivation stops the day the meter records one.  `product=<id>` filters to one product server-side. `groupBy=product` reduces to `{product,requests,amountCents}` rollups instead of rows.  `amount` is whole USD cents, ROUNDED; `decimal` beside it is the SAME debit exact, as an 18-decimal USD string. Sum `decimal`. A page of sub-cent token calls totals correctly there and totals ZERO in `amount` — that difference is real money.  Scoped to the caller\'s own org\'s books, where the org\'s ledger file IS the tenant boundary; no client-supplied subject is ever forwarded. 401 without a validated principal. The co-resident read returns the 2000 most recent debits, newest first; `start` and `end` narrow the window only on the split-deploy upstream.
+     * Answers one row per BILLED call against the caller\'s org — transaction id, amount, timestamp and the metered unit. This is the raw charged ledger, not a rollup.  Each row is stamped with a canonical `metadata.product` derived from what the meter persisted: `agent` becomes agents, `provisioning` becomes the provisioned kind, a token-metered row becomes inference, anything else keeps its metering surface. The ledger has no product field of its own, so this read is where that dimension is made real — from the SAME charged rows, never a second meter. A row that already carries its own product WINS, so the derivation stops the day the meter records one.  Each row carries `name`: what its metered unit (`metadata.model`) reads as on a bill — `Desktop sandbox` for `desktop/visor`, `Agent sessions` for `session`. An AI model is its own name. Show `name`; `metadata.model` stays the unit the ledger keys on.  `product=<id>` filters to one product server-side. `groupBy=product` reduces to `{product,requests,amountCents}` rollups instead of rows.  `amount` is whole USD cents, ROUNDED; `decimal` beside it is the SAME debit exact, as an 18-decimal USD string. Sum `decimal`. A page of sub-cent token calls totals correctly there and totals ZERO in `amount` — that difference is real money.  Scoped to the caller\'s own org\'s books, where the org\'s ledger file IS the tenant boundary; no client-supplied subject is ever forwarded. 401 without a validated principal. The co-resident read returns the 2000 most recent debits, newest first; `start` and `end` narrow the window only on the split-deploy upstream.
      * @summary Every billed call the caller\'s org made, attributed to a product
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}