@cubos/agent-sdk 0.0.1151293 → 0.0.1152175

package/dist/generated/schema.d.ts

@@ -793,6 +793,89 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/cost-metrics": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Spend over time, whole instance
+         * @description Aggregates the spend of every tenant from the hourly cost rollup: totals, one row per group, a time series of the ten most expensive groups (plus one series summing the rest), and the values each filter can take given the others. Root only.
+         */
+        get: {
+            parameters: {
+                query?: {
+                    /** @description Comma-separated agent ids; `__none__` selects spend with no agent. */
+                    agent?: string;
+                    /** @description Start of the interval (RFC 3339), inclusive. Default: 30 days before `to`. */
+                    from?: string;
+                    /** @description `hour`, `day` (default), `week` or `month`. */
+                    granularity?: string;
+                    /**
+                     * @description Comma-separated dimensions to group by: `tenant`, `user`, `agent`,
+                     *     `provider`, `model`, `kind`. Empty: one group, the total.
+                     */
+                    group_by?: string;
+                    /** @description Comma-separated event types (`llm_call`, `media_transcription`, …). */
+                    kind?: string;
+                    /** @description Comma-separated model ids; `__none__` selects spend with no model. */
+                    model?: string;
+                    /** @description Comma-separated provider ids; `__none__` selects spend with no provider. */
+                    provider?: string;
+                    /** @description Comma-separated tenant ids. Whole-instance route only. */
+                    tenant?: string;
+                    /** @description IANA zone the buckets are cut in. Default `UTC`. */
+                    timezone?: string;
+                    /** @description End of the interval (RFC 3339), exclusive. Default: now. */
+                    to?: string;
+                    /** @description Comma-separated user ids; `__none__` selects spend with no user. */
+                    user?: string;
+                };
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["CostMetrics"];
+                    };
+                };
+                /** @description Invalid parameter, or a series of more than 2000 buckets. */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/health": {
         parameters: {
             query?: never;
@@ -3338,6 +3421,68 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/tenants/{tenantSlug}/channel-outbox": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Channel outbox report
+         * @description One summary per channel of what it has not sent: pending messages (how many, since when, how many are retrying), whether anything is trying to send them (`delivery` — `delivering`, or why not: `disabled`, `runner_disconnected`, `not_paired`, `no_worker`), and what the channel gave up on in the last `days` days with the most recent error. A channel retries a transient failure until the message is `retry_window_seconds` old; a channel that is not delivering makes no attempts, so its queue only waits.
+         */
+        get: {
+            parameters: {
+                query?: {
+                    /** @description How many days of given-up messages to count; clamped to 1..=90, default 7. */
+                    days?: number;
+                };
+                header?: never;
+                path: {
+                    /** @description Slug of the tenant that owns the channels. */
+                    tenantSlug: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ChannelOutboxReport"];
+                    };
+                };
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/tenants/{tenantSlug}/channels": {
         parameters: {
             query?: never;
@@ -3816,6 +3961,83 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/tenants/{tenantSlug}/channels/{slug}/outbox": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List a channel's unsent messages
+         * @description The channel's outbox summary (as in `GET /channel-outbox`) plus a page of the messages it has not sent, newest first: still pending, or given up on in the last `days` days. Each carries its conversation, a preview of the text (or the file's name, type and size), the attempts so far, the last error, and when the next attempt is due or when the channel gave up.
+         */
+        get: {
+            parameters: {
+                query?: {
+                    /** @description Cursor `<rfc3339>|<uuid>` from a previous page's `next_before`; omit for the first page. */
+                    before?: string;
+                    /** @description How many days of given-up messages to include; clamped to 1..=90, default 7. */
+                    days?: number;
+                    /** @description Page size; clamped to 1..=200, default 50. */
+                    limit?: number;
+                    /** @description `pending`, `failed` or `all` (default). Anything else is 400. */
+                    status?: string;
+                };
+                header?: never;
+                path: {
+                    /** @description Slug of the channel, unique within the tenant. */
+                    slug: string;
+                    /** @description Slug of the tenant that owns the channel. */
+                    tenantSlug: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ChannelOutbox"];
+                    };
+                };
+                /** @description Unknown `status` or malformed `before`. */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/tenants/{tenantSlug}/channels/{slug}/rotate-secret": {
         parameters: {
             query?: never;
@@ -7201,6 +7423,98 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/tenants/{tenantSlug}/cost-metrics": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Spend over time, one tenant
+         * @description The tenant's spend from the hourly cost rollup, in the same shape as `GET /cost-metrics`. Needs `conversations:read`, which already exposes the cost of every event.
+         */
+        get: {
+            parameters: {
+                query?: {
+                    /** @description Comma-separated agent ids; `__none__` selects spend with no agent. */
+                    agent?: string;
+                    /** @description Start of the interval (RFC 3339), inclusive. Default: 30 days before `to`. */
+                    from?: string;
+                    /** @description `hour`, `day` (default), `week` or `month`. */
+                    granularity?: string;
+                    /**
+                     * @description Comma-separated dimensions to group by: `tenant`, `user`, `agent`,
+                     *     `provider`, `model`, `kind`. Empty: one group, the total.
+                     */
+                    group_by?: string;
+                    /** @description Comma-separated event types (`llm_call`, `media_transcription`, …). */
+                    kind?: string;
+                    /** @description Comma-separated model ids; `__none__` selects spend with no model. */
+                    model?: string;
+                    /** @description Comma-separated provider ids; `__none__` selects spend with no provider. */
+                    provider?: string;
+                    /** @description Comma-separated tenant ids. Whole-instance route only. */
+                    tenant?: string;
+                    /** @description IANA zone the buckets are cut in. Default `UTC`. */
+                    timezone?: string;
+                    /** @description End of the interval (RFC 3339), exclusive. Default: now. */
+                    to?: string;
+                    /** @description Comma-separated user ids; `__none__` selects spend with no user. */
+                    user?: string;
+                };
+                header?: never;
+                path: {
+                    /** @description Tenant slug (kebab-case). */
+                    tenantSlug: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["CostMetrics"];
+                    };
+                };
+                /** @description Invalid parameter, or a series of more than 2000 buckets. */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/tenants/{tenantSlug}/knowledge-bases": {
         parameters: {
             query?: never;
@@ -11752,12 +12066,13 @@ export interface components {
             shared: boolean;
             slug: string;
             /**
-             * @description This provider type's token SKU ids → input/output/other. Lets the chat
-             *     transcript split a call's `token_usage` into ↑ input / ↓ output by
-             *     `provider_slug` without a per-model fetch. `Other` SKUs are omitted.
+             * @description This provider type's token SKU ids → class. Lets the chat transcript
+             *     split a call's `token_usage` into prompt (cached or not) and completion
+             *     (reasoning or not) for a call recorded before calls carried their own
+             *     `tokens`. `Other` SKUs are omitted.
              */
-            token_sku_directions: {
-                [key: string]: components["schemas"]["SkuDirection"];
+            token_sku_classes: {
+                [key: string]: components["schemas"]["SkuClass"];
             };
             /** @description One of the types `GET /ai-provider-types` lists, as declared by `plugin`. */
             type: string;
@@ -11985,6 +12300,40 @@ export interface components {
             /** @enum {string} */
             type: "external";
         });
+        ChannelOutbox: {
+            /** Format: int32 */
+            failed_window_days: number;
+            /** @description Newest first. */
+            items: components["schemas"]["OutboxItem"][];
+            /** @description Cursor for the next page (`before`); `null` on the last one. */
+            next_before: string | null;
+            /** Format: int64 */
+            retry_window_seconds: number;
+            summary: components["schemas"]["ChannelOutboxSummary"];
+        };
+        ChannelOutboxReport: {
+            /** @description One entry per channel of the tenant, ordered by slug. */
+            channels: components["schemas"]["ChannelOutboxSummary"][];
+            /**
+             * Format: int32
+             * @description The `days` the `failed` counts cover.
+             */
+            failed_window_days: number;
+            /**
+             * Format: int64
+             * @description How long a channel keeps retrying a message that fails transiently,
+             *     counted from when the message was written. Past it, the next failure
+             *     gives up on the message.
+             */
+            retry_window_seconds: number;
+        };
+        ChannelOutboxSummary: {
+            channel: components["schemas"]["ChannelRef"];
+            delivery: components["schemas"]["OutboxDelivery"];
+            failed: components["schemas"]["OutboxFailedSummary"];
+            pending: components["schemas"]["OutboxPendingSummary"];
+            type: components["schemas"]["ChannelType"];
+        };
         /**
          * @description Reduced channel reference embedded into other resources' responses (e.g. a conversation's
          *     originating channel) in place of a bare `channel_id`.
@@ -12280,7 +12629,10 @@ export interface components {
              *     The dashboard surfaces it per-item in the event detail view.
              */
             cost_usd: number;
-            /** Format: date-time */
+            /**
+             * Format: date-time
+             * @description When the row was written: when the core learned of the event.
+             */
             created_at: string;
             /**
              * Format: date-time
@@ -12334,6 +12686,14 @@ export interface components {
              */
             read_at: string | null;
             result?: unknown;
+            /**
+             * Format: date-time
+             * @description When the sender sent it, for a `user_message` that came through a
+             *     channel carrying a timestamp (WhatsApp). Usually the same minute as
+             *     `created_at`; hours earlier for a message recovered after a channel
+             *     outage. NULL when the channel carries none — show `created_at` then.
+             */
+            sent_at: string | null;
             /**
              * Format: int64
              * @description Per-conversation log order (1, 2, 3, …). Stable; not the SSE
@@ -12407,6 +12767,177 @@ export interface components {
             output_tokens: number | null;
             summary_text: string;
         };
+        CostAgentLabel: {
+            display_name: string;
+            /** Format: uuid */
+            id: string;
+            slug: string;
+        };
+        /**
+         * @description A dimension spend can be grouped or filtered by.
+         * @enum {string}
+         */
+        CostDimension: "tenant" | "user" | "agent" | "provider" | "model" | "kind";
+        CostFacets: {
+            agent: components["schemas"]["CostFacetValue"][];
+            kind: components["schemas"]["CostFacetValue"][];
+            model: components["schemas"]["CostFacetValue"][];
+            provider: components["schemas"]["CostFacetValue"][];
+            tenant: components["schemas"]["CostFacetValue"][];
+            user: components["schemas"]["CostFacetValue"][];
+        };
+        /** @description One value a filter can take, with the spend it would select. */
+        CostFacetValue: {
+            /** Format: double */
+            cost_usd: number;
+            /**
+             * @description The value to filter on; absent for "none" (the rows where the
+             *     dimension is NULL), which is filtered on as `none`.
+             */
+            value: string | null;
+        };
+        /**
+         * @description Time bucket of a series. The rollup is hourly in UTC; anything coarser is
+         *     cut in the request's time zone.
+         * @enum {string}
+         */
+        CostGranularity: "hour" | "day" | "week" | "month";
+        CostGroup: components["schemas"]["CostMeasures"] & {
+            key: components["schemas"]["CostKey"];
+        };
+        /**
+         * @description The value of every grouped dimension for one slice. A dimension outside
+         *     `group_by` is always absent; a grouped one is absent when the slice is the
+         *     rows where it is NULL.
+         */
+        CostKey: {
+            /** Format: uuid */
+            agent_id: string | null;
+            kind: string | null;
+            model: string | null;
+            /** Format: uuid */
+            provider_id: string | null;
+            /** Format: uuid */
+            tenant_id: string | null;
+            /** Format: uuid */
+            user_id: string | null;
+        };
+        /**
+         * @description Names for every id the response mentions. An id with no entry here points
+         *     at a row that no longer exists — spend outlives what produced it.
+         */
+        CostLabels: {
+            agents: components["schemas"]["CostAgentLabel"][];
+            providers: components["schemas"]["CostProviderLabel"][];
+            tenants: components["schemas"]["CostTenantLabel"][];
+            users: components["schemas"]["CostUserLabel"][];
+        };
+        CostMeasures: {
+            /**
+             * Format: int64
+             * @description The part of `input_tokens` written into the provider's cache.
+             */
+            cache_write_tokens: number;
+            /**
+             * Format: int64
+             * @description The part of `input_tokens` served from the provider's cache.
+             */
+            cached_input_tokens: number;
+            /**
+             * Format: int64
+             * @description Paid calls: one per event that carried a cost.
+             */
+            calls: number;
+            /** Format: double */
+            cost_usd: number;
+            /**
+             * Format: int64
+             * @description The whole prompt: read at full rate, served from cache and written to
+             *     it.
+             */
+            input_tokens: number;
+            /**
+             * Format: int64
+             * @description The whole completion, reasoning included.
+             */
+            output_tokens: number;
+            /**
+             * Format: int64
+             * @description The part of `output_tokens` spent thinking.
+             */
+            reasoning_tokens: number;
+        };
+        CostMetrics: {
+            /** Format: date-time */
+            backfill_cutover: string | null;
+            /**
+             * @description While the history recorded before the rollup existed is still being
+             *     attributed, totals that reach back past `backfill_cutover` are low.
+             */
+            backfill_pending: boolean;
+            /**
+             * @description Start of every bucket in the interval, in order, empty ones included —
+             *     cut in the request's time zone, so a day is a local day across DST.
+             */
+            buckets: string[];
+            facets: components["schemas"]["CostFacets"];
+            /** Format: date-time */
+            from: string;
+            granularity: components["schemas"]["CostGranularity"];
+            group_by: components["schemas"]["CostDimension"][];
+            /** @description One row per group, most expensive first, capped at 1000. */
+            groups: components["schemas"]["CostGroup"][];
+            groups_truncated: boolean;
+            labels: components["schemas"]["CostLabels"];
+            /**
+             * @description Per bucket and group, for the first eight groups by cost, plus one
+             *     "other" series (no `key`) summing the rest. Buckets with no spend are
+             *     omitted; `buckets` lists them all.
+             */
+            series: components["schemas"]["CostSeriesPoint"][];
+            timezone: string;
+            /** Format: date-time */
+            to: string;
+            /** @description Everything the filters select, over the whole interval. */
+            totals: components["schemas"]["CostMeasures"];
+            /**
+             * Format: int64
+             * @description Tokens of calls recorded before calls carried their own split, under a
+             *     SKU no provider plugin has ever declared a class for — counted in none
+             *     of the token measures.
+             */
+            unclassified_tokens: number;
+        };
+        CostProviderLabel: {
+            /** Format: uuid */
+            id: string;
+            provider_type: string;
+            slug: string;
+        };
+        CostSeriesPoint: components["schemas"]["CostMeasures"] & {
+            /**
+             * Format: date-time
+             * @description Start of the bucket, cut in the request's time zone.
+             */
+            bucket: string;
+            key?: components["schemas"]["CostKey"] | null;
+        };
+        CostTenantLabel: {
+            display_name: string;
+            /** Format: uuid */
+            id: string;
+            slug: string;
+        };
+        CostUserLabel: {
+            display_name: string | null;
+            /** Format: uuid */
+            id: string;
+            /**
+             * @description The user's first channel identity (a phone, a handle) — display names
+             *     are neither unique nor always set.
+             */
+            primary_identifier: string | null;
+        };
         CountTokensResponse: {
             breakdown: components["schemas"]["Breakdown"] | null;
             /**
@@ -13259,6 +13790,12 @@ export interface components {
             token_usage: {
                 [key: string]: number;
             };
+            /**
+             * @description `token_usage` summed by class when the call returned. All zero on
+             *     snapshots written before classes existed; their `token_usage` is
+             *     still there to classify.
+             */
+            tokens?: components["schemas"]["TokenCounts"];
         };
         Mcp: {
             /** Format: date-time */
@@ -13512,6 +14049,109 @@ export interface components {
         NamedClientToolInput: components["schemas"]["ClientToolInput"] & {
             name: string;
         };
+        /**
+         * @description Whether anything is trying to send this channel's queue right now.
+         * @enum {string}
+         */
+        OutboxDelivery: "delivering" | "disabled" | "runner_disconnected" | "not_paired" | "no_worker";
+        OutboxFailedSummary: {
+            /**
+             * Format: int64
+             * @description Messages the channel gave up on since `since`: refused outright by the
+             *     channel, or still failing past the retry window.
+             */
+            count: number;
+            /** @description The error recorded on the most recent of them. */
+            last_error: string | null;
+            /**
+             * Format: date-time
+             * @description When the most recent of them was given up on.
+             */
+            last_failed_at: string | null;
+            /**
+             * Format: date-time
+             * @description Start of the counted window (`days` before the request).
+             */
+            since: string;
+        };
+        OutboxFile: {
+            filename: string;
+            mime_type: string;
+            /** Format: int64 */
+            size_bytes: number;
+        };
+        OutboxItem: {
+            /**
+             * Format: int32
+             * @description Attempts that failed so far.
+             */
+            attempts: number;
+            /**
+             * Format: uuid
+             * @description Conversation the message belongs to; `null` for a proactive send.
+             */
+            conversation_id: string | null;
+            /**
+             * Format: date-time
+             * @description When the message was written.
+             */
+            created_at: string;
+            /**
+             * Format: date-time
+             * @description Failed only: when the channel gave up on it.
+             */
+            failed_at: string | null;
+            file: components["schemas"]["OutboxFile"] | null;
+            /**
+             * Format: uuid
+             * @description The event id (`conversation`) or the proactive send's id (`outbound`).
+             */
+            id: string;
+            /** @description Error of the latest failed attempt. */
+            last_error: string | null;
+            /**
+             * Format: date-time
+             * @description Pending only: when the next attempt is due. `null` means as soon as the
+             *     channel gets to it.
+             */
+            next_attempt_at: string | null;
+            /** @description First 200 characters of the text, or a file's caption. */
+            preview: string | null;
+            /** @description Channel-native recipient (chat id, phone, runner identifier). */
+            recipient: string | null;
+            source: components["schemas"]["OutboxItemSource"];
+            status: components["schemas"]["OutboxItemStatus"];
+            /** @description Display name of the user the message was for, when known. */
+            user_display_name: string | null;
+        };
+        /** @enum {string} */
+        OutboxItemSource: "conversation" | "outbound";
+        /** @enum {string} */
+        OutboxItemStatus: "pending" | "failed";
+        OutboxPendingSummary: {
+            /**
+             * Format: int64
+             * @description Messages waiting to be sent (conversation messages and files, plus
+             *     proactive sends such as the approval notice).
+             */
+            count: number;
+            /**
+             * Format: date-time
+             * @description The soonest scheduled retry, if any is scheduled.
+             */
+            next_attempt_at: string | null;
+            /**
+             * Format: date-time
+             * @description When the oldest of them was written. `null` when nothing is pending.
+             */
+            oldest_at: string | null;
+            /**
+             * Format: int64
+             * @description How many of them already failed at least once and are waiting out a
+             *     backoff.
+             */
+            retrying: number;
+        };
         /**
          * @description One citation note, already parsed.
          *
@@ -13851,24 +14491,19 @@ export interface components {
             slug: string;
         };
         /**
-         * @description Display metadata for one SKU. `scale` is the multiplier the UI applies
-         *     when showing/editing the price — internal storage is always USD per
-         *     raw unit (per token, per query), but operators read invoices in "per
-         *     million tokens" or "per thousand queries". The dashboard multiplies
-         *     `pricing[id] * scale` on display and divides the edited value back
-         *     down before persisting. Returned in `Vec` form so providers can
-         *     declare a stable display order independent of `HashMap` hashing.
-         *     Which side of a call a SKU charges for. Lets the dashboard split a recorded
-         *     `token_usage` map into input (↑) and output (↓) totals without hardcoding
-         *     SKU ids. SKUs partition the tokens — `input` and `cached_input` are disjoint
-         *     slices of the prompt — so summing all `Input` SKUs gives the true input
-         *     count with no double-counting.
+         * @description What kind of token a SKU counts, as the plugin serving its type declares
+         *     it. SKUs partition a call's tokens — `input` and `cached_input` are disjoint
+         *     slices of the prompt — so a class's total is the sum of its SKUs, with no
+         *     double counting.
          * @enum {string}
          */
-        SkuDirection: "input" | "output" | "other";
+        SkuClass: "input" | "cached_input" | "cache_write" | "output" | "reasoning" | "other";
         SkuDisplayDto: {
-            /** @description Whether this SKU charges for input (↑), output (↓), or neither. */
-            direction: components["schemas"]["SkuDirection"];
+            /**
+             * @description What kind of token this SKU counts, or `other` for a charge that is not
+             *     a token.
+             */
+            class: components["schemas"]["SkuClass"];
             id: string;
             /**
              * @description Human-readable label including the implicit unit
@@ -14059,6 +14694,40 @@ export interface components {
             permissions: string[];
             slug: string;
         };
+        /**
+         * @description A call's tokens by class: its `token_usage`, summed per [`SkuClass`] by the
+         *     core when the call returns — the one moment the plugin that declared the
+         *     classes is certainly running, so a record never depends on that plugin
+         *     being up when someone reads it. The fields are disjoint: the prompt is
+         *     `input + cached_input + cache_write`, the completion `output + reasoning`.
+         */
+        TokenCounts: {
+            /**
+             * Format: int64
+             * @default 0
+             */
+            cache_write: number;
+            /**
+             * Format: int64
+             * @default 0
+             */
+            cached_input: number;
+            /**
+             * Format: int64
+             * @default 0
+             */
+            input: number;
+            /**
+             * Format: int64
+             * @default 0
+             */
+            output: number;
+            /**
+             * Format: int64
+             * @default 0
+             */
+            reasoning: number;
+        };
         /** @enum {string} */
         ToolChoice: "auto" | "required" | "none";
         /**