@cubos/agent-sdk 0.0.1152175 → 0.0.1152796

package/dist/generated/schema.d.ts

@@ -793,7 +793,7 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/v1/cost-metrics": {
+    "/api/v1/health": {
         parameters: {
             query?: never;
             header?: never;
@@ -801,59 +801,111 @@ export interface paths {
             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.
+         * Health check
+         * @description Public, unauthenticated liveness probe reporting that the process is up, along with the running server version. Returns a static response without touching Postgres or any provider, so it is cheap to poll from load balancers.
          */
         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;
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Server is alive. */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Health"];
+                    };
                 };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/me": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Whoami
+         * @description Returns the identity behind the bearer token: display name, key prefix (absent for the root caller), root flag, and the tenants the caller has a grant on, ordered by slug. Root resolves to every tenant; regular keys resolve to the union of their grants.
+         */
+        get: {
+            parameters: {
+                query?: never;
                 header?: never;
                 path?: never;
                 cookie?: never;
             };
             requestBody?: never;
             responses: {
+                /** @description Resolved identity. */
                 200: {
                     headers: {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["CostMetrics"];
+                        "application/json": components["schemas"]["WhoAmI"];
                     };
                 };
-                /** @description Invalid parameter, or a series of more than 2000 buckets. */
-                400: {
+                /** @description Missing or invalid credentials. */
+                401: {
                     headers: {
                         [name: string]: unknown;
                     };
                     content?: never;
                 };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        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;
@@ -864,7 +916,9 @@ export interface paths {
                     headers: {
                         [name: string]: unknown;
                     };
-                    content?: never;
+                    content: {
+                        "application/json": components["schemas"]["MetricsError"];
+                    };
                 };
             };
         };
@@ -876,85 +930,131 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/v1/health": {
+    "/api/v1/metrics/dimensions/{dimension}/values": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
+        get?: never;
+        put?: never;
         /**
-         * Health check
-         * @description Public, unauthenticated liveness probe reporting that the process is up, along with the running server version. Returns a static response without touching Postgres or any provider, so it is cheap to poll from load balancers.
+         * 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.
          */
-        get: {
+        post: {
             parameters: {
                 query?: never;
                 header?: never;
-                path?: never;
+                path: {
+                    /** @description The dimension. */
+                    dimension: components["schemas"]["Dimension"];
+                };
                 cookie?: never;
             };
-            requestBody?: never;
+            requestBody: {
+                content: {
+                    "application/json": components["schemas"]["DimensionValuesQuery"];
+                };
+            };
             responses: {
-                /** @description Server is alive. */
                 200: {
                     headers: {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["Health"];
+                        "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"];
                     };
                 };
             };
         };
-        put?: never;
-        post?: never;
         delete?: never;
         options?: never;
         head?: never;
         patch?: never;
         trace?: never;
     };
-    "/api/v1/me": {
+    "/api/v1/metrics/query": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
+        get?: never;
+        put?: never;
         /**
-         * Whoami
-         * @description Returns the identity behind the bearer token: display name, key prefix (absent for the root caller), root flag, and the tenants the caller has a grant on, ordered by slug. Root resolves to every tenant; regular keys resolve to the union of their grants.
+         * 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.
          */
-        get: {
+        post: {
             parameters: {
                 query?: never;
                 header?: never;
                 path?: never;
                 cookie?: never;
             };
-            requestBody?: never;
+            requestBody: {
+                content: {
+                    "application/json": components["schemas"]["MetricsQuery"];
+                };
+            };
             responses: {
-                /** @description Resolved identity. */
                 200: {
                     headers: {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["WhoAmI"];
+                        "application/json": components["schemas"]["MetricsResult"];
+                    };
+                };
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["MetricsError"];
                     };
                 };
-                /** @description Missing or invalid credentials. */
                 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;
@@ -7423,98 +7523,6 @@ 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;
@@ -9122,7 +9130,7 @@ export interface paths {
         };
         trace?: never;
     };
-    "/api/v1/tenants/{tenantSlug}/scheduled-runs": {
+    "/api/v1/tenants/{tenantSlug}/metrics": {
         parameters: {
             query?: never;
             header?: never;
@@ -9130,22 +9138,15 @@ export interface paths {
             cookie?: never;
         };
         /**
-         * List scheduled runs
-         * @description Lists the tenant's scheduled runs ordered enabled-first then by soonest firing, optionally filtered by source task template slug, owning user, or enabled flag. Requires `background_tasks:read`.
+         * 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?: {
-                    /** @description Enabled flag to filter runs by; omit for both enabled and disabled. */
-                    enabled?: boolean;
-                    /** @description Slug of the source task template to filter runs by; omit for all task templates. */
-                    task_template?: string;
-                    /** @description Owning user id to filter runs by; omit for all users. */
-                    user_id?: string;
-                };
+                query?: never;
                 header?: never;
                 path: {
-                    /** @description Tenant slug identifying the tenant. */
+                    /** @description Tenant slug (kebab-case). */
                     tenantSlug: string;
                 };
                 cookie?: never;
@@ -9157,15 +9158,9 @@ export interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["ScheduledRun"][];
+                        "application/json": components["schemas"]["MetricsCatalog"];
                     };
                 };
-                400: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content?: never;
-                };
                 401: {
                     headers: {
                         [name: string]: unknown;
@@ -9176,13 +9171,17 @@ 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"];
+                    };
                 };
             };
         };
@@ -9194,30 +9193,254 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/v1/tenants/{tenantSlug}/scheduled-runs/{id}": {
+    "/api/v1/tenants/{tenantSlug}/metrics/dimensions/{dimension}/values": {
         parameters: {
             query?: never;
             header?: never;
             path?: never;
             cookie?: never;
         };
+        get?: never;
+        put?: never;
         /**
-         * Get scheduled run
-         * @description Returns one scheduled run with its bound parameters, the trigger prompt template and the prompt rendered from those parameters, and the background tasks it has spawned newest-first. Requires `background_tasks:read`.
+         * Values of a dimension, one tenant
+         * @description Same as `POST /metrics/dimensions/{dimension}/values`, scoped to the tenant.
          */
-        get: {
+        post: {
             parameters: {
                 query?: never;
                 header?: never;
                 path: {
-                    /** @description Id of the scheduled run to fetch. */
-                    id: string;
-                    /** @description Tenant slug identifying the tenant. */
+                    /** @description The dimension. */
+                    dimension: components["schemas"]["Dimension"];
+                    /** @description Tenant slug (kebab-case). */
                     tenantSlug: string;
                 };
                 cookie?: never;
             };
-            requestBody?: 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"];
+                    };
+                };
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["MetricsError"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/tenants/{tenantSlug}/metrics/query": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Query metrics, one tenant
+         * @description The tenant's metrics, in the same shape as `POST /metrics/query`; the `tenant` dimension does not exist here.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Tenant slug (kebab-case). */
+                    tenantSlug: string;
+                };
+                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"];
+                    };
+                };
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["MetricsError"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/tenants/{tenantSlug}/scheduled-runs": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List scheduled runs
+         * @description Lists the tenant's scheduled runs ordered enabled-first then by soonest firing, optionally filtered by source task template slug, owning user, or enabled flag. Requires `background_tasks:read`.
+         */
+        get: {
+            parameters: {
+                query?: {
+                    /** @description Enabled flag to filter runs by; omit for both enabled and disabled. */
+                    enabled?: boolean;
+                    /** @description Slug of the source task template to filter runs by; omit for all task templates. */
+                    task_template?: string;
+                    /** @description Owning user id to filter runs by; omit for all users. */
+                    user_id?: string;
+                };
+                header?: never;
+                path: {
+                    /** @description Tenant slug identifying the tenant. */
+                    tenantSlug: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ScheduledRun"][];
+                    };
+                };
+                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}/scheduled-runs/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get scheduled run
+         * @description Returns one scheduled run with its bound parameters, the trigger prompt template and the prompt rendered from those parameters, and the background tasks it has spawned newest-first. Requires `background_tasks:read`.
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Id of the scheduled run to fetch. */
+                    id: string;
+                    /** @description Tenant slug identifying the tenant. */
+                    tenantSlug: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
             responses: {
                 200: {
                     headers: {
@@ -12028,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
@@ -12429,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;
@@ -12767,177 +13014,6 @@ 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;
             /**
@@ -13449,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;
             /**
@@ -13515,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: {
@@ -13583,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`.
@@ -13605,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 */
@@ -14003,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.
          *
@@ -14049,6 +14323,12 @@ 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}
@@ -14321,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;
         };
@@ -14766,6 +15062,8 @@ export interface components {
             has_pending_turn: boolean;
             is_processing: boolean;
         };
+        /** @enum {string} */
+        Unit: "usd" | "count" | "tokens";
         UpdateAgentInput: {
             agents_md?: string | null;
             /**