@cubos/agent-sdk 0.0.1151293 → 0.0.1152796

package/dist/generated/schema.d.ts

@@ -878,6 +878,189 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/metrics": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Metric catalog, whole instance
+         * @description Every metric the instance keeps, with its unit, how it aggregates, the dimensions it can be grouped and filtered by, the finest granularity it is kept at, and whether its history is complete. Root only.
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["MetricsCatalog"];
+                    };
+                };
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["MetricsError"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/metrics/dimensions/{dimension}/values": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Values of a dimension, whole instance
+         * @description The values a dimension takes in a slice, ranked by a metric — what a filter can offer given the page's other filters (its own is ignored). Root only.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description The dimension. */
+                    dimension: components["schemas"]["Dimension"];
+                };
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": components["schemas"]["DimensionValuesQuery"];
+                };
+            };
+            responses: {
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["DimensionValues"];
+                    };
+                };
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["MetricsError"];
+                    };
+                };
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["MetricsError"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/metrics/query": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Query metrics, whole instance
+         * @description Reads one or more metrics over an interval, optionally bucketed by time and grouped and filtered by dimensions. Values come as a map keyed by metric. With neither `granularity` nor `group_by`, the answer is exactly one row. Root only.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": components["schemas"]["MetricsQuery"];
+                };
+            };
+            responses: {
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["MetricsResult"];
+                    };
+                };
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["MetricsError"];
+                    };
+                };
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["MetricsError"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/plugins": {
         parameters: {
             query?: never;
@@ -3338,6 +3521,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 +4061,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;
@@ -8673,21 +8995,224 @@ export interface paths {
                 };
             };
         };
-        options?: never;
-        head?: never;
+        options?: never;
+        head?: never;
+        /**
+         * Update MCP skill
+         * @description Patches an MCP-owned skill; only the supplied fields change. Sending `unlocks_tool_ids` replaces the unlock set, and each id must belong to this MCP (else `400`); renaming the slug validates its form, and `409` if a sibling skill of the same MCP already holds it.
+         */
+        patch: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Skill slug, unique within the MCP (kebab-case). */
+                    skillSlug: string;
+                    /** @description MCP slug (kebab-case). */
+                    slug: string;
+                    /** @description Tenant slug (kebab-case). */
+                    tenantSlug: string;
+                };
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": components["schemas"]["UpdateMcpSkillInput"];
+                };
+            };
+            responses: {
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["McpSkill"];
+                    };
+                };
+                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;
+                };
+                409: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        trace?: never;
+    };
+    "/api/v1/tenants/{tenantSlug}/mcps/{slug}/tools/{toolName}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        /**
+         * Update MCP tool
+         * @description Sets the operator `enabled` switch on one catalog tool and returns the updated tool. `enabled = false` keeps the tool in the catalog while hiding it from agents; the flag survives the tool disappearing and reappearing upstream.
+         */
+        patch: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description MCP slug (kebab-case). */
+                    slug: string;
+                    /** @description Tenant slug (kebab-case). */
+                    tenantSlug: string;
+                    /** @description Tool name as exposed by the MCP server. */
+                    toolName: string;
+                };
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": components["schemas"]["UpdateMcpToolInput"];
+                };
+            };
+            responses: {
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["McpTool"];
+                    };
+                };
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        trace?: never;
+    };
+    "/api/v1/tenants/{tenantSlug}/metrics": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Metric catalog, one tenant
+         * @description The metrics this credential may read on the tenant, in the same shape as `GET /metrics`. Spend metrics need `conversations:read`, which already exposes the cost of every event.
+         */
+        get: {
+            parameters: {
+                query?: never;
+                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"]["MetricsCatalog"];
+                    };
+                };
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["MetricsError"];
+                    };
+                };
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["MetricsError"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/tenants/{tenantSlug}/metrics/dimensions/{dimension}/values": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
         /**
-         * Update MCP skill
-         * @description Patches an MCP-owned skill; only the supplied fields change. Sending `unlocks_tool_ids` replaces the unlock set, and each id must belong to this MCP (else `400`); renaming the slug validates its form, and `409` if a sibling skill of the same MCP already holds it.
+         * Values of a dimension, one tenant
+         * @description Same as `POST /metrics/dimensions/{dimension}/values`, scoped to the tenant.
          */
-        patch: {
+        post: {
             parameters: {
                 query?: never;
                 header?: never;
                 path: {
-                    /** @description Skill slug, unique within the MCP (kebab-case). */
-                    skillSlug: string;
-                    /** @description MCP slug (kebab-case). */
-                    slug: string;
+                    /** @description The dimension. */
+                    dimension: components["schemas"]["Dimension"];
                     /** @description Tenant slug (kebab-case). */
                     tenantSlug: string;
                 };
@@ -8695,7 +9220,7 @@ export interface paths {
             };
             requestBody: {
                 content: {
-                    "application/json": components["schemas"]["UpdateMcpSkillInput"];
+                    "application/json": components["schemas"]["DimensionValuesQuery"];
                 };
             };
             responses: {
@@ -8704,14 +9229,16 @@ export interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["McpSkill"];
+                        "application/json": components["schemas"]["DimensionValues"];
                     };
                 };
                 400: {
                     headers: {
                         [name: string]: unknown;
                     };
-                    content?: never;
+                    content: {
+                        "application/json": components["schemas"]["MetricsError"];
+                    };
                 };
                 401: {
                     headers: {
@@ -8723,25 +9250,27 @@ export interface paths {
                     headers: {
                         [name: string]: unknown;
                     };
-                    content?: never;
+                    content: {
+                        "application/json": components["schemas"]["MetricsError"];
+                    };
                 };
                 404: {
                     headers: {
                         [name: string]: unknown;
                     };
-                    content?: never;
-                };
-                409: {
-                    headers: {
-                        [name: string]: unknown;
+                    content: {
+                        "application/json": components["schemas"]["MetricsError"];
                     };
-                    content?: never;
                 };
             };
         };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
         trace?: never;
     };
-    "/api/v1/tenants/{tenantSlug}/mcps/{slug}/tools/{toolName}": {
+    "/api/v1/tenants/{tenantSlug}/metrics/query": {
         parameters: {
             query?: never;
             header?: never;
@@ -8750,31 +9279,23 @@ export interface paths {
         };
         get?: never;
         put?: never;
-        post?: never;
-        delete?: never;
-        options?: never;
-        head?: never;
         /**
-         * Update MCP tool
-         * @description Sets the operator `enabled` switch on one catalog tool and returns the updated tool. `enabled = false` keeps the tool in the catalog while hiding it from agents; the flag survives the tool disappearing and reappearing upstream.
+         * Query metrics, one tenant
+         * @description The tenant's metrics, in the same shape as `POST /metrics/query`; the `tenant` dimension does not exist here.
          */
-        patch: {
+        post: {
             parameters: {
                 query?: never;
                 header?: never;
                 path: {
-                    /** @description MCP slug (kebab-case). */
-                    slug: string;
                     /** @description Tenant slug (kebab-case). */
                     tenantSlug: string;
-                    /** @description Tool name as exposed by the MCP server. */
-                    toolName: string;
                 };
                 cookie?: never;
             };
             requestBody: {
                 content: {
-                    "application/json": components["schemas"]["UpdateMcpToolInput"];
+                    "application/json": components["schemas"]["MetricsQuery"];
                 };
             };
             responses: {
@@ -8783,7 +9304,15 @@ export interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["McpTool"];
+                        "application/json": components["schemas"]["MetricsResult"];
+                    };
+                };
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["MetricsError"];
                     };
                 };
                 401: {
@@ -8796,16 +9325,24 @@ export interface paths {
                     headers: {
                         [name: string]: unknown;
                     };
-                    content?: never;
+                    content: {
+                        "application/json": components["schemas"]["MetricsError"];
+                    };
                 };
                 404: {
                     headers: {
                         [name: string]: unknown;
                     };
-                    content?: never;
+                    content: {
+                        "application/json": components["schemas"]["MetricsError"];
+                    };
                 };
             };
         };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
         trace?: never;
     };
     "/api/v1/tenants/{tenantSlug}/scheduled-runs": {
@@ -11714,6 +12251,13 @@ export interface components {
             role_slugs: string[];
             task_template: components["schemas"]["TaskTemplateRef"];
         };
+        /**
+         * @description How a metric combines across rows. Only `sum` exists today; the others are
+         *     reserved so a consumer can be written against them now. For anything but
+         *     `sum`, adding up rows gives a wrong number — use `totals`.
+         * @enum {string}
+         */
+        Aggregation: "sum" | "ratio" | "quantile" | "distinct" | "gauge";
         AiProvider: {
             /**
              * @deprecated
@@ -11752,12 +12296,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 +12530,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`.
@@ -12080,6 +12659,23 @@ export interface components {
             /** Format: uuid */
             tool_call_id: string;
         };
+        Column: {
+            kind: components["schemas"]["ColumnKind"];
+            name: string;
+            unit: components["schemas"]["Unit"] | null;
+        };
+        /** @enum {string} */
+        ColumnKind: "bucket" | "dimension" | "metric";
+        /** @description Whether the history is all there yet. */
+        Completeness: {
+            /**
+             * Format: date-time
+             * @description Before this instant the history is still being attributed in the
+             *     background, so a slice reaching back past it reads low. Absent once it
+             *     is all there.
+             */
+            pending_before: string | null;
+        };
         ComponentInput: {
             description?: string;
             example_mdx?: string;
@@ -12280,7 +12876,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 +12933,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
@@ -12918,6 +13525,54 @@ export interface components {
             /** @description `conversation` (tied to a thread) or `outbound` (proactive send). */
             source: string;
         };
+        /**
+         * @description What a metric can be grouped and filtered by. One vocabulary for every
+         *     metric, so a dimension always means the same id wherever it appears.
+         * @enum {string}
+         */
+        Dimension: "tenant" | "user" | "agent" | "provider" | "model" | "kind";
+        DimensionInfo: {
+            description: string;
+            id: components["schemas"]["Dimension"];
+            /** @description Its values are ids the query can name with `include: ["labels"]`. */
+            labeled: boolean;
+        };
+        DimensionValue: {
+            label: components["schemas"]["EntityLabel"] | null;
+            metric_value: components["schemas"]["MetricValue"];
+            /** @description The value to filter on; `null` for the rows with none. */
+            value: string | null;
+        };
+        DimensionValues: {
+            next_cursor: string | null;
+            values: components["schemas"]["DimensionValue"][];
+        };
+        DimensionValuesQuery: {
+            cursor?: string | null;
+            /**
+             * @description The other filters of the page; this dimension's own is ignored, so the
+             *     list always offers every value the rest of the page allows.
+             */
+            filters?: {
+                [key: string]: components["schemas"]["FilterSpec"];
+            };
+            /** Format: date-time */
+            from?: string | null;
+            /**
+             * Format: int32
+             * @description 1 to 1 000. Default 100.
+             */
+            limit?: number | null;
+            /** @description The metric that ranks the values (and that they are counted in). */
+            metric: components["schemas"]["Metric"];
+            /** @description Keep values whose id or name contains this, case-insensitively. */
+            search?: string | null;
+            timezone?: string | null;
+            /** Format: date-time */
+            to?: string | null;
+        };
+        /** @enum {string} */
+        Direction: "asc" | "desc";
         DraftAgentConfig: {
             agents_md?: string | null;
             /**
@@ -12984,6 +13639,18 @@ export interface components {
              */
             tags: string[];
         };
+        /** @description A name for an id. Which fields are set depends on the dimension. */
+        EntityLabel: {
+            display_name: string | null;
+            /**
+             * @description A user's first channel identity (a phone, a handle): display names are
+             *     neither unique nor always set.
+             */
+            primary_identifier: string | null;
+            /** @description A provider's type (`openai`, `anthropic`, …). */
+            provider_type: string | null;
+            slug: string | null;
+        };
         /** @enum {string} */
         EventType: "user_message" | "task_prompt" | "agent_directive" | "agent_message" | "agent_file" | "llm_call" | "tool_result" | "turn_done" | "todo_update" | "memory_lookup" | "media_transcription" | "sub_conversation_started" | "sub_conversation_finished" | "eval_subcall_request" | "eval_subcall_result" | "compaction_done" | "filesystem_root" | "harness_error" | "guardrail_verdict" | "client_tool_call" | "title_generated" | "context_update";
         ExternalChannel: {
@@ -13052,6 +13719,19 @@ export interface components {
              */
             root_event_id: string | null;
         };
+        /**
+         * @description The values a dimension is restricted to. A filter selects exactly what it
+         *     lists, so one that lists nothing is refused rather than read as "all".
+         */
+        FilterSpec: {
+            /** @description Ids (or, for `model` and `kind`, the values themselves) to keep. */
+            in?: string[];
+            /**
+             * @description Also keep the rows where the dimension has no value — spend with no
+             *     user, a call recorded with no provider.
+             */
+            none?: boolean;
+        };
         /**
          * @description Abnormal stop reason. Absent on the happy path; callers distinguish text vs tool calls by
          *     inspecting `messages`.
@@ -13074,10 +13754,14 @@ export interface components {
             permission: string;
             tenant_slug: string;
         };
+        /** @enum {string} */
+        Granularity: "hour" | "day" | "week" | "month";
         Health: {
             status: string;
             version: string;
         };
+        /** @enum {string} */
+        Include: "totals" | "labels";
         KnowledgeBase: {
             accepts_conversation_sources: boolean;
             /** Format: date-time */
@@ -13259,6 +13943,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 */
@@ -13466,6 +14156,127 @@ export interface components {
             /** @enum {string} */
             type: "tool_result";
         };
+        /** @enum {string} */
+        Metric: "cost_usd" | "calls" | "input_tokens" | "cached_input_tokens" | "cache_write_tokens" | "output_tokens" | "reasoning_tokens" | "unclassified_tokens";
+        MetricInfo: {
+            aggregation: components["schemas"]["Aggregation"];
+            completeness: components["schemas"]["Completeness"];
+            description: string;
+            /** @description What it can be grouped and filtered by. */
+            dimensions: components["schemas"]["Dimension"][];
+            id: components["schemas"]["Metric"];
+            /** @description The finest granularity a series of it can be cut at. */
+            min_granularity: components["schemas"]["Granularity"];
+            unit: components["schemas"]["Unit"];
+        };
+        MetricsCatalog: {
+            /** @description Every dimension a metric here accepts. */
+            dimensions: components["schemas"]["DimensionInfo"][];
+            /** @description The metrics the credential may read in this scope. */
+            metrics: components["schemas"]["MetricInfo"][];
+        };
+        /**
+         * @description A refused request: a stable code, a sentence, and where in the request the
+         *     problem is — so a consumer can point at the field rather than parse prose.
+         */
+        MetricsError: {
+            error: string;
+            /** @description Path into the request body (`metrics[1]`, `filters.user.in[0]`). */
+            field: string | null;
+            message: string;
+        };
+        /**
+         * @description A metric as asked for: its id, or an object naming it plus parameters.
+         *     No metric takes parameters yet; the object form is accepted now so a
+         *     parameterised one (a quantile, say) is not a new request shape.
+         */
+        MetricSpec: components["schemas"]["Metric"] | (Record<string, unknown> & {
+            id: components["schemas"]["Metric"];
+        });
+        MetricsQuery: {
+            /** @description `next_cursor` of the previous page, sent with the same query. */
+            cursor?: string | null;
+            /** @description Per dimension, the values to keep. */
+            filters?: {
+                [key: string]: components["schemas"]["FilterSpec"];
+            };
+            /**
+             * Format: date-time
+             * @description Start of the slice, inclusive. Rounded down to the hour, since metrics
+             *     are kept per hour. Default: 30 days before `to`.
+             */
+            from?: string | null;
+            granularity?: components["schemas"]["Granularity"] | null;
+            group_by?: components["schemas"]["Dimension"][];
+            include?: components["schemas"]["Include"][];
+            /**
+             * Format: int32
+             * @description Rows per page, 1 to 10 000. Default 1 000.
+             */
+            limit?: number | null;
+            /** @description One or more metrics, by id or as `{ "id": … }`. */
+            metrics: components["schemas"]["MetricSpec"][];
+            /**
+             * @description Order within a bucket — rows always go bucket by bucket, oldest first.
+             *     Default: the first metric, descending.
+             */
+            order_by?: components["schemas"]["OrderBy"][];
+            /** @description IANA zone buckets are cut in. Default `UTC`. */
+            timezone?: string | null;
+            /**
+             * Format: date-time
+             * @description End of the slice, exclusive. Rounded up to the hour. Default: the end of
+             *     the current hour.
+             */
+            to?: string | null;
+        };
+        MetricsResult: {
+            /**
+             * @description Every bucket of the slice, empty ones included, in order — present
+             *     exactly when the query has a granularity. Rows with no value at all are
+             *     omitted, so this is what a chart fills its gaps from.
+             */
+            buckets: string[] | null;
+            columns: components["schemas"]["Column"][];
+            completeness: components["schemas"]["Completeness"];
+            /**
+             * @description Present with `include: ["labels"]`: per labeled dimension, id → name.
+             *     An id with no entry points at a row that was deleted.
+             */
+            labels: {
+                [key: string]: {
+                    [key: string]: components["schemas"]["EntityLabel"];
+                };
+            } | null;
+            /** @description Send it back as `cursor`, with the same query, for the next page. */
+            next_cursor: string | null;
+            query: components["schemas"]["ResolvedQuery"];
+            rows: components["schemas"]["MetricsRow"][];
+            totals: components["schemas"]["MetricsTotals"] | null;
+        };
+        MetricsRow: {
+            /**
+             * Format: date-time
+             * @description Start of the bucket, in the request's zone. Present exactly when the
+             *     query has a granularity.
+             */
+            bucket: string | null;
+            /** @description Every grouped dimension; `null` for the rows where it has no value. */
+            dimensions: {
+                [key: string]: string | null;
+            };
+            /** @description Every requested metric. */
+            values: {
+                [key: string]: components["schemas"]["MetricValue"];
+            };
+        };
+        MetricsTotals: {
+            values: {
+                [key: string]: components["schemas"]["MetricValue"];
+            };
+        };
+        /** @description One value. Integral units come back as integers, money as a float. */
+        MetricValue: number;
         /**
          * @description `None` ≠ `Some(false)`: the provider didn't expose this signal or our probe was inconclusive.
          *
@@ -13512,6 +14323,115 @@ export interface components {
         NamedClientToolInput: components["schemas"]["ClientToolInput"] & {
             name: string;
         };
+        /** @description Order by a requested metric or a grouped dimension. Exactly one of the two. */
+        OrderBy: {
+            dimension?: components["schemas"]["Dimension"] | null;
+            direction?: components["schemas"]["Direction"];
+            metric?: components["schemas"]["Metric"] | null;
+        };
+        /**
+         * @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.
          *
@@ -13681,6 +14601,22 @@ export interface components {
         ReplaceClientToolsInput: {
             tools: components["schemas"]["NamedClientToolInput"][];
         };
+        /**
+         * @description The query as it was answered: defaults filled in and the interval rounded
+         *     to whole hours.
+         */
+        ResolvedQuery: {
+            /** Format: date-time */
+            from: string;
+            granularity: components["schemas"]["Granularity"] | null;
+            group_by: components["schemas"]["Dimension"][];
+            /** Format: int32 */
+            limit: number;
+            metrics: components["schemas"]["Metric"][];
+            timezone: string;
+            /** Format: date-time */
+            to: string;
+        };
         RotatedSecret: {
             connection_secret: string;
         };
@@ -13851,24 +14787,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 +14990,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";
         /**
@@ -14097,6 +15062,8 @@ export interface components {
             has_pending_turn: boolean;
             is_processing: boolean;
         };
+        /** @enum {string} */
+        Unit: "usd" | "count" | "tokens";
         UpdateAgentInput: {
             agents_md?: string | null;
             /**