@distilled.cloud/cloudflare 0.16.2 → 0.16.4

package/src/client/api.ts

@@ -21,6 +21,10 @@ import {
   paginateWithDefaults,
   type PaginationStrategy,
 } from "@distilled.cloud/core/pagination";
+import {
+  parseRetryAfterForStatus,
+  parseServerRetryHint,
+} from "@distilled.cloud/core/retry-after";
 import { getPath, type RequestParts } from "@distilled.cloud/core/traits";
 import {
   CloudflareHttpError,
@@ -32,6 +36,7 @@ import {
   UnknownCloudflareError,
 } from "../errors.ts";
 import { Credentials, formatHeaders } from "../credentials.ts";
+import { Retry } from "../retry.ts";
 import { type ErrorMatcher, getErrorMatchers } from "../traits.ts";
 
 // ============================================================================
@@ -42,9 +47,19 @@ import { type ErrorMatcher, getErrorMatchers } from "../traits.ts";
  * Cloudflare error codes that map to global/default errors regardless of operation.
  * These are infrastructure-level errors that can occur on any endpoint.
  */
-const GLOBAL_ERROR_CODE_MAP: Record<number, (message: string) => unknown> = {
+const GLOBAL_ERROR_CODE_MAP: Record<
+  number,
+  (message: string, headers?: Record<string, string | undefined>) => unknown
+> = {
   // "Please wait and consider throttling your request speed"
-  971: (message) => new TooManyRequests({ message }),
+  // Cloudflare returns this code inside an envelope with arbitrary HTTP status
+  // (often 200), so we don't gate on status — TooManyRequests always declares
+  // `retryAfter`.
+  971: (message, headers) =>
+    new TooManyRequests({
+      message,
+      retryAfter: parseServerRetryHint(headers),
+    }),
   // Authentication-related error codes — surfaced regardless of HTTP status
   // (Cloudflare frequently returns these inside a 400 envelope rather than 401).
   // 6003: Invalid request headers (e.g. missing/invalid auth headers)
@@ -68,17 +83,30 @@ const GLOBAL_ERROR_CODE_MAP: Record<number, (message: string) => unknown> = {
  * returns the properly categorized error (with retry categories for 5xx).
  * For unmapped 5xx codes (e.g., Cloudflare-specific 520-530), returns a
  * CloudflareHttpError so the status is preserved.
+ *
+ * Retryable errors carry an optional `retryAfter` parsed from the standard
+ * `Retry-After` / `RateLimit` response headers; the retry policy honors it.
  */
-function httpStatusError(status: number, body?: string): unknown {
+function httpStatusError(
+  status: number,
+  body?: string,
+  headers?: Record<string, string | undefined>,
+): unknown {
   const ErrorClass = HTTP_STATUS_MAP[status as keyof typeof HTTP_STATUS_MAP];
   const message = body ?? String(status);
   if (ErrorClass) {
-    return new ErrorClass({ message });
+    return new ErrorClass({
+      message,
+      retryAfter: parseRetryAfterForStatus(status, headers),
+    });
   }
   // For unmapped 5xx codes (e.g., Cloudflare-specific 520-530), use
   // InternalServerError so they get ServerError + Retryable categories
   if (status >= 500) {
-    return new InternalServerError({ message });
+    return new InternalServerError({
+      message,
+      retryAfter: parseRetryAfterForStatus(status, headers),
+    });
   }
   return new CloudflareHttpError({
     status,
@@ -192,6 +220,7 @@ const matchError = (
   status: number,
   errorBody: unknown,
   errors?: readonly ApiErrorClass[],
+  headers?: Record<string, string | undefined>,
 ): Effect.Effect<never, unknown> => {
   // Handle non-JSON error responses (e.g., HTML from malformed URLs, 520 pages)
   const isNonJsonError =
@@ -202,7 +231,7 @@ const matchError = (
     const message = String((errorBody as any).body);
     // For 5xx errors, return a properly categorized error so retries work
     if (status >= 500) {
-      return Effect.fail(httpStatusError(status, message));
+      return Effect.fail(httpStatusError(status, message, headers));
     }
     return Effect.fail(
       new CloudflareHttpError({
@@ -245,7 +274,7 @@ const matchError = (
     const bodyStr =
       typeof errorBody === "string" ? errorBody : JSON.stringify(errorBody);
     if (status >= 500) {
-      return Effect.fail(httpStatusError(status, bodyStr));
+      return Effect.fail(httpStatusError(status, bodyStr, headers));
     }
     return Effect.fail(
       new CloudflareHttpError({
@@ -305,7 +334,7 @@ const matchError = (
 
   // Check global error codes before falling through to unknown
   if (errorCode !== undefined && errorCode in GLOBAL_ERROR_CODE_MAP) {
-    return Effect.fail(GLOBAL_ERROR_CODE_MAP[errorCode](errorMessage));
+    return Effect.fail(GLOBAL_ERROR_CODE_MAP[errorCode](errorMessage, headers));
   }
 
   // Heuristic fallback:
@@ -378,6 +407,7 @@ const _API = makeAPI<Credentials>({
   ParseError: CloudflareDecodeError as any,
   transformRequestParts: ({ pathTemplate, parts }) =>
     transformCloudflareRequestParts({ pathTemplate, parts }),
+  retry: Retry as any,
 });
 
 const paginatePageByItems: PaginationStrategy = (

package/src/retry.ts

@@ -1,6 +1,28 @@
+/**
+ * Cloudflare retry configuration.
+ *
+ * Defines the per-SDK `Retry` Context.Service tag that
+ * `packages/cloudflare/src/client.ts` wires into `makeAPI`. Callers can
+ * install a blanket retry policy at the layer level and have every
+ * Cloudflare API call below it pick it up:
+ *
+ * @example
+ * ```ts
+ * import * as Cloudflare from "@distilled.cloud/cloudflare";
+ *
+ * myEffect.pipe(Cloudflare.Retry.transient);
+ * Effect.provide(myEffect, Layer.succeed(Cloudflare.Retry.Retry, customPolicy));
+ * ```
+ */
+import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import * as Context from "effect/Context";
+import {
+  type Policy,
+  throttlingFactory,
+  transientFactory,
+} from "@distilled.cloud/core/retry";
+
 export {
   type Options,
   type Factory,
@@ -10,26 +32,26 @@ export {
   capped,
   throttlingOptions,
   transientOptions,
-} from "@distilled.cloud/core/retry";
-import {
-  type Policy,
-  throttlingOptions,
-  transientOptions,
+  throttlingFactory,
+  transientFactory,
 } from "@distilled.cloud/core/retry";
 
+/** Context tag for configuring retry behavior of Cloudflare API calls. */
 export class Retry extends Context.Service<Retry, Policy>()(
   "CloudflareRetry",
 ) {}
 
+/** Provides a custom retry policy to every Cloudflare API call below it. */
 export const policy = (optionsOrFactory: Policy) =>
   Effect.provide(Layer.succeed(Retry, optionsOrFactory));
 
+/** Disables all automatic retries. */
 export const none = Effect.provide(
   Layer.succeed(Retry, { while: () => false }),
 );
 
-/** Apply throttling retry policy (retries throttling errors indefinitely) */
-export const throttling = policy(throttlingOptions);
+/** Apply the throttling retry policy (retries throttling errors indefinitely). */
+export const throttling = policy(throttlingFactory);
 
-/** Apply transient retry policy (retries all transient errors indefinitely) */
-export const transient = policy(transientOptions);
+/** Apply the transient retry policy (retries all transient errors indefinitely). */
+export const transient = policy(transientFactory);

package/src/services/abuse-reports.ts

@@ -185,6 +185,8 @@ export const getAbuseReport: API.OperationMethod<
 export interface ListAbuseReportsRequest {
   /** Path param: Cloudflare Account ID */
   accountId: string;
+  page?: number;
+  perPage?: number;
   /** Query param: Returns reports created after the specified date */
   createdAfter?: string;
   /** Query param: Returns reports created before the specified date */
@@ -218,6 +220,8 @@ export interface ListAbuseReportsRequest {
 export const ListAbuseReportsRequest =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    page: Schema.optional(Schema.Number).pipe(T.HttpQuery("page")),
+    perPage: Schema.optional(Schema.Number).pipe(T.HttpQuery("per_page")),
     createdAfter: Schema.optional(Schema.String).pipe(
       T.HttpQuery("created_after"),
     ),
@@ -558,6 +562,8 @@ export interface ListMitigationsRequest {
   reportId: string;
   /** Path param: Cloudflare Account ID */
   accountId: string;
+  page?: number;
+  perPage?: number;
   /** Query param: Returns mitigation that were dispatched after the given date */
   effectiveAfter?: string;
   /** Query param: Returns mitigations that were dispatched before the given date */
@@ -590,6 +596,8 @@ export const ListMitigationsRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
   {
     reportId: Schema.String.pipe(T.HttpPath("reportId")),
     accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    page: Schema.optional(Schema.Number).pipe(T.HttpQuery("page")),
+    perPage: Schema.optional(Schema.Number).pipe(T.HttpQuery("per_page")),
     effectiveAfter: Schema.optional(Schema.String).pipe(
       T.HttpQuery("effective_after"),
     ),

package/src/services/accounts.ts

@@ -653,6 +653,7 @@ export const deleteAccount: API.OperationMethod<
 export interface ListLogAuditsRequest {
   /** Path param: The unique id that identifies the account. */
   accountId: string;
+  cursor?: string;
   /** Query param: Limits the returned results to logs older than the specified date. This can be a date string 2019-04-30 (interpreted in UTC) or an absolute timestamp that conforms to RFC3339. */
   before: string;
   /** Query param: Limits the returned results to logs newer than the specified date. This can be a date string 2019-04-30 (interpreted in UTC) or an absolute timestamp that conforms to RFC3339. */
@@ -711,6 +712,7 @@ export interface ListLogAuditsRequest {
 
 export const ListLogAuditsRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   accountId: Schema.String.pipe(T.HttpPath("account_id")),
+  cursor: Schema.optional(Schema.String).pipe(T.HttpQuery("cursor")),
   before: Schema.String.pipe(T.HttpQuery("before")),
   since: Schema.String.pipe(T.HttpQuery("since")),
   id: Schema.optional(
@@ -1406,6 +1408,8 @@ export const getMember: API.OperationMethod<
 export interface ListMembersRequest {
   /** Path param: Account identifier tag. */
   accountId: string;
+  page?: number;
+  perPage?: number;
   /** Query param: Direction to order results. */
   direction?: "asc" | "desc";
   /** Query param: Field to order results by. */
@@ -1416,6 +1420,8 @@ export interface ListMembersRequest {
 
 export const ListMembersRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   accountId: Schema.String.pipe(T.HttpPath("account_id")),
+  page: Schema.optional(Schema.Number).pipe(T.HttpQuery("page")),
+  perPage: Schema.optional(Schema.Number).pipe(T.HttpQuery("per_page")),
   direction: Schema.optional(Schema.Literals(["asc", "desc"])).pipe(
     T.HttpQuery("direction"),
   ),
@@ -2720,10 +2726,14 @@ export const getRole: API.OperationMethod<
 export interface ListRolesRequest {
   /** Path param: Account identifier tag. */
   accountId: string;
+  page?: number;
+  perPage?: number;
 }
 
 export const ListRolesRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   accountId: Schema.String.pipe(T.HttpPath("account_id")),
+  page: Schema.optional(Schema.Number).pipe(T.HttpQuery("page")),
+  perPage: Schema.optional(Schema.Number).pipe(T.HttpQuery("per_page")),
 }).pipe(
   T.Http({ method: "GET", path: "/accounts/{account_id}/roles" }),
 ) as unknown as Schema.Schema<ListRolesRequest>;
@@ -3822,12 +3832,16 @@ export const getToken: API.OperationMethod<
 export interface ListTokensRequest {
   /** Path param: Account identifier tag. */
   accountId: string;
+  page?: number;
+  perPage?: number;
   /** Query param: Direction to order results. */
   direction?: "asc" | "desc";
 }
 
 export const ListTokensRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   accountId: Schema.String.pipe(T.HttpPath("account_id")),
+  page: Schema.optional(Schema.Number).pipe(T.HttpQuery("page")),
+  perPage: Schema.optional(Schema.Number).pipe(T.HttpQuery("per_page")),
   direction: Schema.optional(Schema.Literals(["asc", "desc"])).pipe(
     T.HttpQuery("direction"),
   ),

package/src/services/ai-gateway.ts

@@ -217,12 +217,16 @@ export const getAiGateway: API.OperationMethod<
 export interface ListAiGatewaysRequest {
   /** Path param: */
   accountId: string;
+  page?: number;
+  perPage?: number;
   /** Query param: Search by id */
   search?: string;
 }
 
 export const ListAiGatewaysRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   accountId: Schema.String.pipe(T.HttpPath("account_id")),
+  page: Schema.optional(Schema.Number).pipe(T.HttpQuery("page")),
+  perPage: Schema.optional(Schema.Number).pipe(T.HttpQuery("per_page")),
   search: Schema.optional(Schema.String).pipe(T.HttpQuery("search")),
 }).pipe(
   T.Http({ method: "GET", path: "/accounts/{account_id}/ai-gateway/gateways" }),
@@ -1331,6 +1335,8 @@ export interface ListDatasetsRequest {
   gatewayId: string;
   /** Path param: */
   accountId: string;
+  page?: number;
+  perPage?: number;
   /** Query param: */
   enable?: boolean;
   /** Query param: */
@@ -1342,6 +1348,8 @@ export interface ListDatasetsRequest {
 export const ListDatasetsRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   gatewayId: Schema.String.pipe(T.HttpPath("gatewayId")),
   accountId: Schema.String.pipe(T.HttpPath("account_id")),
+  page: Schema.optional(Schema.Number).pipe(T.HttpQuery("page")),
+  perPage: Schema.optional(Schema.Number).pipe(T.HttpQuery("per_page")),
   enable: Schema.optional(Schema.Boolean).pipe(T.HttpQuery("enable")),
   name: Schema.optional(Schema.String).pipe(T.HttpQuery("name")),
   search: Schema.optional(Schema.String).pipe(T.HttpQuery("search")),
@@ -2092,6 +2100,8 @@ export interface ListEvaluationsRequest {
   gatewayId: string;
   /** Path param: */
   accountId: string;
+  page?: number;
+  perPage?: number;
   /** Query param: */
   name?: string;
   /** Query param: */
@@ -2104,6 +2114,8 @@ export const ListEvaluationsRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct(
   {
     gatewayId: Schema.String.pipe(T.HttpPath("gatewayId")),
     accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    page: Schema.optional(Schema.Number).pipe(T.HttpQuery("page")),
+    perPage: Schema.optional(Schema.Number).pipe(T.HttpQuery("per_page")),
     name: Schema.optional(Schema.String).pipe(T.HttpQuery("name")),
     processed: Schema.optional(Schema.Boolean).pipe(T.HttpQuery("processed")),
     search: Schema.optional(Schema.String).pipe(T.HttpQuery("search")),
@@ -2704,6 +2716,8 @@ export const deleteEvaluation: API.OperationMethod<
 export interface ListEvaluationTypesRequest {
   /** Path param: */
   accountId: string;
+  page?: number;
+  perPage?: number;
   /** Query param: */
   orderBy?: string;
   /** Query param: */
@@ -2713,6 +2727,8 @@ export interface ListEvaluationTypesRequest {
 export const ListEvaluationTypesRequest =
   /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
     accountId: Schema.String.pipe(T.HttpPath("account_id")),
+    page: Schema.optional(Schema.Number).pipe(T.HttpQuery("page")),
+    perPage: Schema.optional(Schema.Number).pipe(T.HttpQuery("per_page")),
     orderBy: Schema.optional(Schema.String).pipe(T.HttpQuery("order_by")),
     orderByDirection: Schema.optional(Schema.Literals(["asc", "desc"])).pipe(
       T.HttpQuery("order_by_direction"),
@@ -2937,6 +2953,16 @@ export interface ListLogsRequest {
   gatewayId: string;
   /** Path param: */
   accountId: string;
+  page?: number;
+  perPage?: number;
+  /** @deprecated Query param: */
+  cached?: boolean;
+  /** @deprecated Query param: */
+  direction?: "asc" | "desc";
+  /** @deprecated Query param: */
+  endDate?: string;
+  /** @deprecated Query param: */
+  feedback?: "0" | "1";
   /** Query param: */
   filters?: {
     key:
@@ -2968,28 +2994,6 @@ export interface ListLogsRequest {
     operator: "eq" | "neq" | "contains" | "lt" | "gt";
     value: (string | null | number | boolean)[];
   }[];
-  /** Query param: */
-  metaInfo?: boolean;
-  /** Query param: */
-  orderBy?:
-    | "created_at"
-    | "provider"
-    | "model"
-    | "model_type"
-    | "success"
-    | "cached";
-  /** Query param: */
-  orderByDirection?: "asc" | "desc";
-  /** Query param: */
-  search?: string;
-  /** @deprecated Query param: */
-  cached?: boolean;
-  /** @deprecated Query param: */
-  direction?: "asc" | "desc";
-  /** @deprecated Query param: */
-  endDate?: string;
-  /** @deprecated Query param: */
-  feedback?: "0" | "1";
   /** @deprecated Query param: */
   maxCost?: number;
   /** @deprecated Query param: */
@@ -3000,6 +3004,8 @@ export interface ListLogsRequest {
   maxTokensOut?: number;
   /** @deprecated Query param: */
   maxTotalTokens?: number;
+  /** Query param: */
+  metaInfo?: boolean;
   /** @deprecated Query param: */
   minCost?: number;
   /** @deprecated Query param: */
@@ -3014,12 +3020,24 @@ export interface ListLogsRequest {
   model?: string;
   /** @deprecated Query param: */
   modelType?: string;
+  /** Query param: */
+  orderBy?:
+    | "created_at"
+    | "provider"
+    | "model"
+    | "model_type"
+    | "success"
+    | "cached";
+  /** Query param: */
+  orderByDirection?: "asc" | "desc";
   /** @deprecated Query param: */
   provider?: string;
   /** @deprecated Query param: */
   requestContentType?: string;
   /** @deprecated Query param: */
   responseContentType?: string;
+  /** Query param: */
+  search?: string;
   /** @deprecated Query param: */
   startDate?: string;
   /** @deprecated Query param: */
@@ -3029,6 +3047,16 @@ export interface ListLogsRequest {
 export const ListLogsRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   gatewayId: Schema.String.pipe(T.HttpPath("gatewayId")),
   accountId: Schema.String.pipe(T.HttpPath("account_id")),
+  page: Schema.optional(Schema.Number).pipe(T.HttpQuery("page")),
+  perPage: Schema.optional(Schema.Number).pipe(T.HttpQuery("per_page")),
+  cached: Schema.optional(Schema.Boolean).pipe(T.HttpQuery("cached")),
+  direction: Schema.optional(Schema.Literals(["asc", "desc"])).pipe(
+    T.HttpQuery("direction"),
+  ),
+  endDate: Schema.optional(Schema.String).pipe(T.HttpQuery("end_date")),
+  feedback: Schema.optional(Schema.Literals(["0", "1"])).pipe(
+    T.HttpQuery("feedback"),
+  ),
   filters: Schema.optional(
     Schema.Array(
       Schema.Struct({
@@ -3071,7 +3099,31 @@ export const ListLogsRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
       }),
     ),
   ).pipe(T.HttpQuery("filters")),
+  maxCost: Schema.optional(Schema.Number).pipe(T.HttpQuery("max_cost")),
+  maxDuration: Schema.optional(Schema.Number).pipe(T.HttpQuery("max_duration")),
+  maxTokensIn: Schema.optional(Schema.Number).pipe(
+    T.HttpQuery("max_tokens_in"),
+  ),
+  maxTokensOut: Schema.optional(Schema.Number).pipe(
+    T.HttpQuery("max_tokens_out"),
+  ),
+  maxTotalTokens: Schema.optional(Schema.Number).pipe(
+    T.HttpQuery("max_total_tokens"),
+  ),
   metaInfo: Schema.optional(Schema.Boolean).pipe(T.HttpQuery("meta_info")),
+  minCost: Schema.optional(Schema.Number).pipe(T.HttpQuery("min_cost")),
+  minDuration: Schema.optional(Schema.Number).pipe(T.HttpQuery("min_duration")),
+  minTokensIn: Schema.optional(Schema.Number).pipe(
+    T.HttpQuery("min_tokens_in"),
+  ),
+  minTokensOut: Schema.optional(Schema.Number).pipe(
+    T.HttpQuery("min_tokens_out"),
+  ),
+  minTotalTokens: Schema.optional(Schema.Number).pipe(
+    T.HttpQuery("min_total_tokens"),
+  ),
+  model: Schema.optional(Schema.String).pipe(T.HttpQuery("model")),
+  modelType: Schema.optional(Schema.String).pipe(T.HttpQuery("model_type")),
   orderBy: Schema.optional(
     Schema.Literals([
       "created_at",
@@ -3085,52 +3137,17 @@ export const ListLogsRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   orderByDirection: Schema.optional(Schema.Literals(["asc", "desc"])).pipe(
     T.HttpQuery("order_by_direction"),
   ),
+  provider: Schema.optional(Schema.String).pipe(T.HttpQuery("provider")),
+  requestContentType: Schema.optional(Schema.String).pipe(
+    T.HttpQuery("request_content_type"),
+  ),
+  responseContentType: Schema.optional(Schema.String).pipe(
+    T.HttpQuery("response_content_type"),
+  ),
   search: Schema.optional(Schema.String).pipe(T.HttpQuery("search")),
-  cached: Schema.optional(Schema.Boolean),
-  direction: Schema.optional(Schema.Literals(["asc", "desc"])),
-  endDate: Schema.optional(Schema.String),
-  feedback: Schema.optional(Schema.Literals(["0", "1"])),
-  maxCost: Schema.optional(Schema.Number),
-  maxDuration: Schema.optional(Schema.Number),
-  maxTokensIn: Schema.optional(Schema.Number),
-  maxTokensOut: Schema.optional(Schema.Number),
-  maxTotalTokens: Schema.optional(Schema.Number),
-  minCost: Schema.optional(Schema.Number),
-  minDuration: Schema.optional(Schema.Number),
-  minTokensIn: Schema.optional(Schema.Number),
-  minTokensOut: Schema.optional(Schema.Number),
-  minTotalTokens: Schema.optional(Schema.Number),
-  model: Schema.optional(Schema.String),
-  modelType: Schema.optional(Schema.String),
-  provider: Schema.optional(Schema.String),
-  requestContentType: Schema.optional(Schema.String),
-  responseContentType: Schema.optional(Schema.String),
-  startDate: Schema.optional(Schema.String),
-  success: Schema.optional(Schema.Boolean),
+  startDate: Schema.optional(Schema.String).pipe(T.HttpQuery("start_date")),
+  success: Schema.optional(Schema.Boolean).pipe(T.HttpQuery("success")),
 }).pipe(
-  Schema.encodeKeys({
-    cached: "cached",
-    direction: "direction",
-    endDate: "end_date",
-    feedback: "feedback",
-    maxCost: "max_cost",
-    maxDuration: "max_duration",
-    maxTokensIn: "max_tokens_in",
-    maxTokensOut: "max_tokens_out",
-    maxTotalTokens: "max_total_tokens",
-    minCost: "min_cost",
-    minDuration: "min_duration",
-    minTokensIn: "min_tokens_in",
-    minTokensOut: "min_tokens_out",
-    minTotalTokens: "min_total_tokens",
-    model: "model",
-    modelType: "model_type",
-    provider: "provider",
-    requestContentType: "request_content_type",
-    responseContentType: "response_content_type",
-    startDate: "start_date",
-    success: "success",
-  }),
   T.Http({
     method: "GET",
     path: "/accounts/{account_id}/ai-gateway/gateways/{gatewayId}/logs",

package/src/services/ai.ts

@@ -99,24 +99,6 @@ export type RunAiResponse =
   | { description?: string | null };
 
 export const RunAiResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Union([
-  Schema.Array(
-    Schema.Struct({
-      label: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-      score: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
-    }),
-  ),
-  UploadableSchema.pipe(T.HttpFormDataFile()),
-  Schema.Struct({
-    audio: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-  }),
-  Schema.Struct({
-    data: Schema.optional(
-      Schema.Union([Schema.Array(Schema.Array(Schema.Number)), Schema.Null]),
-    ),
-    shape: Schema.optional(
-      Schema.Union([Schema.Array(Schema.Number), Schema.Null]),
-    ),
-  }),
   Schema.Struct({
     text: Schema.String,
     vtt: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
@@ -141,23 +123,6 @@ export const RunAiResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Union([
       words: "words",
     }),
   ),
-  Schema.Array(
-    Schema.Struct({
-      box: Schema.optional(
-        Schema.Union([
-          Schema.Struct({
-            xmax: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
-            xmin: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
-            ymax: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
-            ymin: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
-          }),
-          Schema.Null,
-        ]),
-      ),
-      label: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
-      score: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
-    }),
-  ),
   Schema.Struct({
     response: Schema.String,
     toolCalls: Schema.optional(
@@ -202,6 +167,41 @@ export const RunAiResponse = /*@__PURE__*/ /*#__PURE__*/ Schema.Union([
       usage: "usage",
     }),
   ),
+  Schema.Array(
+    Schema.Struct({
+      label: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      score: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    }),
+  ),
+  UploadableSchema.pipe(T.HttpFormDataFile()),
+  Schema.Struct({
+    audio: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+  }),
+  Schema.Struct({
+    data: Schema.optional(
+      Schema.Union([Schema.Array(Schema.Array(Schema.Number)), Schema.Null]),
+    ),
+    shape: Schema.optional(
+      Schema.Union([Schema.Array(Schema.Number), Schema.Null]),
+    ),
+  }),
+  Schema.Array(
+    Schema.Struct({
+      box: Schema.optional(
+        Schema.Union([
+          Schema.Struct({
+            xmax: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            xmin: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            ymax: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+            ymin: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+          }),
+          Schema.Null,
+        ]),
+      ),
+      label: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
+      score: Schema.optional(Schema.Union([Schema.Number, Schema.Null])),
+    }),
+  ),
   Schema.Struct({
     translatedText: Schema.optional(Schema.Union([Schema.String, Schema.Null])),
   }).pipe(Schema.encodeKeys({ translatedText: "translated_text" })),
@@ -543,6 +543,8 @@ export const listFinetunePublics: API.PaginatedOperationMethod<
 export interface ListModelsRequest {
   /** Path param: */
   accountId: string;
+  page?: number;
+  perPage?: number;
   /** Query param: Filter by Author */
   author?: string;
   /** Query param: Filter to hide experimental models */
@@ -557,6 +559,8 @@ export interface ListModelsRequest {
 
 export const ListModelsRequest = /*@__PURE__*/ /*#__PURE__*/ Schema.Struct({
   accountId: Schema.String.pipe(T.HttpPath("account_id")),
+  page: Schema.optional(Schema.Number).pipe(T.HttpQuery("page")),
+  perPage: Schema.optional(Schema.Number).pipe(T.HttpQuery("per_page")),
   author: Schema.optional(Schema.String).pipe(T.HttpQuery("author")),
   hideExperimental: Schema.optional(Schema.Boolean).pipe(
     T.HttpQuery("hide_experimental"),