@openrouter/sdk 0.10.2 → 0.12.0

package/esm/funcs/guardrailsBulkAssignMembers.js

@@ -9,6 +9,7 @@ import { safeParse } from "../lib/schemas.js";
 import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
 import { pathToFunc } from "../lib/url.js";
 import * as errors from "../models/errors/index.js";
+import * as models from "../models/index.js";
 import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
 /**
@@ -26,7 +27,9 @@ async function $do(client, request, options) {
         return [parsed, { status: "invalid" }];
     }
     const payload = parsed.value;
-    const body = encodeJSON("body", payload.RequestBody, { explode: true });
+    const body = encodeJSON("body", payload.BulkAssignMembersRequest, {
+        explode: true,
+    });
     const pathParams = {
         id: encodeSimple("id", payload.id, {
             explode: false,
@@ -53,8 +56,18 @@ async function $do(client, request, options) {
         securitySource: client._options.apiKey,
         retryConfig: options?.retries
             || client._options.retryConfig
+            || {
+                strategy: "backoff",
+                backoff: {
+                    initialInterval: 500,
+                    maxInterval: 60000,
+                    exponent: 1.5,
+                    maxElapsedTime: 3600000,
+                },
+                retryConnectionErrors: true,
+            }
             || { strategy: "none" },
-        retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+        retryCodes: options?.retryCodes || ["5XX"],
     };
     const requestRes = client._createRequest(context, {
         security: requestSecurity,
@@ -83,7 +96,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, operations.BulkAssignMembersToGuardrailResponse$inboundSchema), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, models.BulkAssignMembersResponse$inboundSchema), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/guardrailsBulkUnassignKeys.d.ts

@@ -5,6 +5,7 @@ import * as errors from "../models/errors/index.js";
 import { OpenRouterError } from "../models/errors/openroutererror.js";
 import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
 import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import * as models from "../models/index.js";
 import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
@@ -14,5 +15,5 @@ import { Result } from "../types/fp.js";
  * @remarks
  * Unassign multiple API keys from a specific guardrail. [Management key](/docs/guides/overview/auth/management-api-keys) required.
  */
-export declare function guardrailsBulkUnassignKeys(client: OpenRouterCore, request: operations.BulkUnassignKeysFromGuardrailRequest, options?: RequestOptions): APIPromise<Result<operations.BulkUnassignKeysFromGuardrailResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.NotFoundResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function guardrailsBulkUnassignKeys(client: OpenRouterCore, request: operations.BulkUnassignKeysFromGuardrailRequest, options?: RequestOptions): APIPromise<Result<models.BulkUnassignKeysResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.NotFoundResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 //# sourceMappingURL=guardrailsBulkUnassignKeys.d.ts.map

package/esm/funcs/guardrailsBulkUnassignKeys.js

@@ -9,6 +9,7 @@ import { safeParse } from "../lib/schemas.js";
 import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
 import { pathToFunc } from "../lib/url.js";
 import * as errors from "../models/errors/index.js";
+import * as models from "../models/index.js";
 import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
 /**
@@ -26,7 +27,9 @@ async function $do(client, request, options) {
         return [parsed, { status: "invalid" }];
     }
     const payload = parsed.value;
-    const body = encodeJSON("body", payload.RequestBody, { explode: true });
+    const body = encodeJSON("body", payload.BulkUnassignKeysRequest, {
+        explode: true,
+    });
     const pathParams = {
         id: encodeSimple("id", payload.id, {
             explode: false,
@@ -53,8 +56,18 @@ async function $do(client, request, options) {
         securitySource: client._options.apiKey,
         retryConfig: options?.retries
             || client._options.retryConfig
+            || {
+                strategy: "backoff",
+                backoff: {
+                    initialInterval: 500,
+                    maxInterval: 60000,
+                    exponent: 1.5,
+                    maxElapsedTime: 3600000,
+                },
+                retryConnectionErrors: true,
+            }
             || { strategy: "none" },
-        retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+        retryCodes: options?.retryCodes || ["5XX"],
     };
     const requestRes = client._createRequest(context, {
         security: requestSecurity,
@@ -83,7 +96,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, operations.BulkUnassignKeysFromGuardrailResponse$inboundSchema), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, models.BulkUnassignKeysResponse$inboundSchema), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/guardrailsBulkUnassignMembers.d.ts

@@ -5,6 +5,7 @@ import * as errors from "../models/errors/index.js";
 import { OpenRouterError } from "../models/errors/openroutererror.js";
 import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
 import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import * as models from "../models/index.js";
 import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
@@ -14,5 +15,5 @@ import { Result } from "../types/fp.js";
  * @remarks
  * Unassign multiple organization members from a specific guardrail. [Management key](/docs/guides/overview/auth/management-api-keys) required.
  */
-export declare function guardrailsBulkUnassignMembers(client: OpenRouterCore, request: operations.BulkUnassignMembersFromGuardrailRequest, options?: RequestOptions): APIPromise<Result<operations.BulkUnassignMembersFromGuardrailResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.NotFoundResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function guardrailsBulkUnassignMembers(client: OpenRouterCore, request: operations.BulkUnassignMembersFromGuardrailRequest, options?: RequestOptions): APIPromise<Result<models.BulkUnassignMembersResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.NotFoundResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 //# sourceMappingURL=guardrailsBulkUnassignMembers.d.ts.map

package/esm/funcs/guardrailsBulkUnassignMembers.js

@@ -9,6 +9,7 @@ import { safeParse } from "../lib/schemas.js";
 import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
 import { pathToFunc } from "../lib/url.js";
 import * as errors from "../models/errors/index.js";
+import * as models from "../models/index.js";
 import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
 /**
@@ -26,7 +27,9 @@ async function $do(client, request, options) {
         return [parsed, { status: "invalid" }];
     }
     const payload = parsed.value;
-    const body = encodeJSON("body", payload.RequestBody, { explode: true });
+    const body = encodeJSON("body", payload.BulkUnassignMembersRequest, {
+        explode: true,
+    });
     const pathParams = {
         id: encodeSimple("id", payload.id, {
             explode: false,
@@ -53,8 +56,18 @@ async function $do(client, request, options) {
         securitySource: client._options.apiKey,
         retryConfig: options?.retries
             || client._options.retryConfig
+            || {
+                strategy: "backoff",
+                backoff: {
+                    initialInterval: 500,
+                    maxInterval: 60000,
+                    exponent: 1.5,
+                    maxElapsedTime: 3600000,
+                },
+                retryConnectionErrors: true,
+            }
             || { strategy: "none" },
-        retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+        retryCodes: options?.retryCodes || ["5XX"],
     };
     const requestRes = client._createRequest(context, {
         security: requestSecurity,
@@ -83,7 +96,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, operations.BulkUnassignMembersFromGuardrailResponse$inboundSchema), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, models.BulkUnassignMembersResponse$inboundSchema), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/guardrailsCreate.d.ts

@@ -5,6 +5,7 @@ import * as errors from "../models/errors/index.js";
 import { OpenRouterError } from "../models/errors/openroutererror.js";
 import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
 import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import * as models from "../models/index.js";
 import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
@@ -14,5 +15,5 @@ import { Result } from "../types/fp.js";
  * @remarks
  * Create a new guardrail for the authenticated user. [Management key](/docs/guides/overview/auth/management-api-keys) required.
  */
-export declare function guardrailsCreate(client: OpenRouterCore, request: operations.CreateGuardrailRequest, options?: RequestOptions): APIPromise<Result<operations.CreateGuardrailResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function guardrailsCreate(client: OpenRouterCore, request: operations.CreateGuardrailRequest, options?: RequestOptions): APIPromise<Result<models.CreateGuardrailResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 //# sourceMappingURL=guardrailsCreate.d.ts.map

package/esm/funcs/guardrailsCreate.js

@@ -9,6 +9,7 @@ import { safeParse } from "../lib/schemas.js";
 import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
 import { pathToFunc } from "../lib/url.js";
 import * as errors from "../models/errors/index.js";
+import * as models from "../models/index.js";
 import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
 /**
@@ -26,7 +27,9 @@ async function $do(client, request, options) {
         return [parsed, { status: "invalid" }];
     }
     const payload = parsed.value;
-    const body = encodeJSON("body", payload.RequestBody, { explode: true });
+    const body = encodeJSON("body", payload.CreateGuardrailRequest, {
+        explode: true,
+    });
     const path = pathToFunc("/guardrails")();
     const headers = new Headers(compactMap({
         "Content-Type": "application/json",
@@ -47,8 +50,18 @@ async function $do(client, request, options) {
         securitySource: client._options.apiKey,
         retryConfig: options?.retries
             || client._options.retryConfig
+            || {
+                strategy: "backoff",
+                backoff: {
+                    initialInterval: 500,
+                    maxInterval: 60000,
+                    exponent: 1.5,
+                    maxElapsedTime: 3600000,
+                },
+                retryConnectionErrors: true,
+            }
             || { strategy: "none" },
-        retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+        retryCodes: options?.retryCodes || ["5XX"],
     };
     const requestRes = client._createRequest(context, {
         security: requestSecurity,
@@ -77,7 +90,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(201, operations.CreateGuardrailResponse$inboundSchema), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(201, models.CreateGuardrailResponse$inboundSchema), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/guardrailsDelete.d.ts

@@ -5,6 +5,7 @@ import * as errors from "../models/errors/index.js";
 import { OpenRouterError } from "../models/errors/openroutererror.js";
 import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
 import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import * as models from "../models/index.js";
 import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
@@ -14,5 +15,5 @@ import { Result } from "../types/fp.js";
  * @remarks
  * Delete an existing guardrail. [Management key](/docs/guides/overview/auth/management-api-keys) required.
  */
-export declare function guardrailsDelete(client: OpenRouterCore, request: operations.DeleteGuardrailRequest, options?: RequestOptions): APIPromise<Result<operations.DeleteGuardrailResponse, errors.UnauthorizedResponseError | errors.NotFoundResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function guardrailsDelete(client: OpenRouterCore, request: operations.DeleteGuardrailRequest, options?: RequestOptions): APIPromise<Result<models.DeleteGuardrailResponse, errors.UnauthorizedResponseError | errors.NotFoundResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 //# sourceMappingURL=guardrailsDelete.d.ts.map

package/esm/funcs/guardrailsDelete.js

@@ -9,6 +9,7 @@ import { safeParse } from "../lib/schemas.js";
 import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
 import { pathToFunc } from "../lib/url.js";
 import * as errors from "../models/errors/index.js";
+import * as models from "../models/index.js";
 import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
 /**
@@ -52,8 +53,18 @@ async function $do(client, request, options) {
         securitySource: client._options.apiKey,
         retryConfig: options?.retries
             || client._options.retryConfig
+            || {
+                strategy: "backoff",
+                backoff: {
+                    initialInterval: 500,
+                    maxInterval: 60000,
+                    exponent: 1.5,
+                    maxElapsedTime: 3600000,
+                },
+                retryConnectionErrors: true,
+            }
             || { strategy: "none" },
-        retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+        retryCodes: options?.retryCodes || ["5XX"],
     };
     const requestRes = client._createRequest(context, {
         security: requestSecurity,
@@ -82,7 +93,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, operations.DeleteGuardrailResponse$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, models.DeleteGuardrailResponse$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/guardrailsGet.d.ts

@@ -5,6 +5,7 @@ import * as errors from "../models/errors/index.js";
 import { OpenRouterError } from "../models/errors/openroutererror.js";
 import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
 import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import * as models from "../models/index.js";
 import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
@@ -14,5 +15,5 @@ import { Result } from "../types/fp.js";
  * @remarks
  * Get a single guardrail by ID. [Management key](/docs/guides/overview/auth/management-api-keys) required.
  */
-export declare function guardrailsGet(client: OpenRouterCore, request: operations.GetGuardrailRequest, options?: RequestOptions): APIPromise<Result<operations.GetGuardrailResponse, errors.UnauthorizedResponseError | errors.NotFoundResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function guardrailsGet(client: OpenRouterCore, request: operations.GetGuardrailRequest, options?: RequestOptions): APIPromise<Result<models.GetGuardrailResponse, errors.UnauthorizedResponseError | errors.NotFoundResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 //# sourceMappingURL=guardrailsGet.d.ts.map

package/esm/funcs/guardrailsGet.js

@@ -9,6 +9,7 @@ import { safeParse } from "../lib/schemas.js";
 import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
 import { pathToFunc } from "../lib/url.js";
 import * as errors from "../models/errors/index.js";
+import * as models from "../models/index.js";
 import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
 /**
@@ -52,8 +53,18 @@ async function $do(client, request, options) {
         securitySource: client._options.apiKey,
         retryConfig: options?.retries
             || client._options.retryConfig
+            || {
+                strategy: "backoff",
+                backoff: {
+                    initialInterval: 500,
+                    maxInterval: 60000,
+                    exponent: 1.5,
+                    maxElapsedTime: 3600000,
+                },
+                retryConnectionErrors: true,
+            }
             || { strategy: "none" },
-        retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+        retryCodes: options?.retryCodes || ["5XX"],
     };
     const requestRes = client._createRequest(context, {
         security: requestSecurity,
@@ -82,7 +93,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, operations.GetGuardrailResponse$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, models.GetGuardrailResponse$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/guardrailsList.d.ts

@@ -8,11 +8,14 @@ import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
 import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
+import { PageIterator } from "../types/operations.js";
 /**
  * List guardrails
  *
  * @remarks
  * List all guardrails for the authenticated user. [Management key](/docs/guides/overview/auth/management-api-keys) required.
  */
-export declare function guardrailsList(client: OpenRouterCore, request?: operations.ListGuardrailsRequest | undefined, options?: RequestOptions): APIPromise<Result<operations.ListGuardrailsResponse, errors.UnauthorizedResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function guardrailsList(client: OpenRouterCore, request?: operations.ListGuardrailsRequest | undefined, options?: RequestOptions): APIPromise<PageIterator<Result<operations.ListGuardrailsResponse, errors.UnauthorizedResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>, {
+    offset: number;
+}>>;
 //# sourceMappingURL=guardrailsList.d.ts.map

package/esm/funcs/guardrailsList.js

@@ -2,6 +2,7 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  * @generated-id: 4c066e741cd8
  */
+import { dlv } from "../lib/dlv.js";
 import { encodeFormQuery, encodeSimple } from "../lib/encodings.js";
 import * as M from "../lib/matchers.js";
 import { compactMap } from "../lib/primitives.js";
@@ -11,6 +12,7 @@ import { pathToFunc } from "../lib/url.js";
 import * as errors from "../models/errors/index.js";
 import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
+import { createPageIterator, haltIterator, } from "../types/operations.js";
 /**
  * List guardrails
  *
@@ -23,7 +25,7 @@ export function guardrailsList(client, request, options) {
 async function $do(client, request, options) {
     const parsed = safeParse(request, (value) => operations.ListGuardrailsRequest$outboundSchema.optional().parse(value), "Input validation failed");
     if (!parsed.ok) {
-        return [parsed, { status: "invalid" }];
+        return [haltIterator(parsed), { status: "invalid" }];
     }
     const payload = parsed.value;
     const body = null;
@@ -50,8 +52,18 @@ async function $do(client, request, options) {
         securitySource: client._options.apiKey,
         retryConfig: options?.retries
             || client._options.retryConfig
+            || {
+                strategy: "backoff",
+                backoff: {
+                    initialInterval: 500,
+                    maxInterval: 60000,
+                    exponent: 1.5,
+                    maxElapsedTime: 3600000,
+                },
+                retryConnectionErrors: true,
+            }
             || { strategy: "none" },
-        retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+        retryCodes: options?.retryCodes || ["5XX"],
     };
     const requestRes = client._createRequest(context, {
         security: requestSecurity,
@@ -65,7 +77,7 @@ async function $do(client, request, options) {
         timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
     }, options);
     if (!requestRes.ok) {
-        return [requestRes, { status: "invalid" }];
+        return [haltIterator(requestRes), { status: "invalid" }];
     }
     const req = requestRes.value;
     const doResult = await client._do(req, {
@@ -75,16 +87,47 @@ async function $do(client, request, options) {
         retryCodes: context.retryCodes,
     });
     if (!doResult.ok) {
-        return [doResult, { status: "request-error", request: req }];
+        return [haltIterator(doResult), { status: "request-error", request: req }];
     }
     const response = doResult.value;
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, operations.ListGuardrailsResponse$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result, raw] = await M.match(M.json(200, operations.ListGuardrailsResponse$inboundSchema, {
+        key: "Result",
+    }), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
-        return [result, { status: "complete", request: req, response }];
+        return [haltIterator(result), {
+                status: "complete",
+                request: req,
+                response,
+            }];
     }
-    return [result, { status: "complete", request: req, response }];
+    const nextFunc = (responseData) => {
+        const offset = request?.offset ?? 0;
+        if (!responseData) {
+            return { next: () => null };
+        }
+        const results = dlv(responseData, "data");
+        if (!Array.isArray(results) || !results.length) {
+            return { next: () => null };
+        }
+        const limit = request?.limit ?? 0;
+        if (results.length < limit) {
+            return { next: () => null };
+        }
+        const nextOffset = offset + results.length;
+        const nextVal = () => guardrailsList(client, {
+            ...request,
+            offset: nextOffset,
+        }, options);
+        return { next: nextVal, "~next": { offset: nextOffset } };
+    };
+    const page = { ...result, ...nextFunc(raw) };
+    return [{ ...page, ...createPageIterator(page, (v) => !v.ok) }, {
+            status: "complete",
+            request: req,
+            response,
+        }];
 }
 //# sourceMappingURL=guardrailsList.js.map

package/esm/funcs/guardrailsListGuardrailKeyAssignments.d.ts

@@ -8,11 +8,14 @@ import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
 import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
+import { PageIterator } from "../types/operations.js";
 /**
  * List key assignments for a guardrail
  *
  * @remarks
  * List all API key assignments for a specific guardrail. [Management key](/docs/guides/overview/auth/management-api-keys) required.
  */
-export declare function guardrailsListGuardrailKeyAssignments(client: OpenRouterCore, request: operations.ListGuardrailKeyAssignmentsRequest, options?: RequestOptions): APIPromise<Result<operations.ListGuardrailKeyAssignmentsResponse, errors.UnauthorizedResponseError | errors.NotFoundResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function guardrailsListGuardrailKeyAssignments(client: OpenRouterCore, request: operations.ListGuardrailKeyAssignmentsRequest, options?: RequestOptions): APIPromise<PageIterator<Result<operations.ListGuardrailKeyAssignmentsResponse, errors.UnauthorizedResponseError | errors.NotFoundResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>, {
+    offset: number;
+}>>;
 //# sourceMappingURL=guardrailsListGuardrailKeyAssignments.d.ts.map

package/esm/funcs/guardrailsListGuardrailKeyAssignments.js

@@ -2,6 +2,7 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  * @generated-id: e0b13763f920
  */
+import { dlv } from "../lib/dlv.js";
 import { encodeFormQuery, encodeSimple } from "../lib/encodings.js";
 import * as M from "../lib/matchers.js";
 import { compactMap } from "../lib/primitives.js";
@@ -11,6 +12,7 @@ import { pathToFunc } from "../lib/url.js";
 import * as errors from "../models/errors/index.js";
 import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
+import { createPageIterator, haltIterator, } from "../types/operations.js";
 /**
  * List key assignments for a guardrail
  *
@@ -23,7 +25,7 @@ export function guardrailsListGuardrailKeyAssignments(client, request, options)
 async function $do(client, request, options) {
     const parsed = safeParse(request, (value) => operations.ListGuardrailKeyAssignmentsRequest$outboundSchema.parse(value), "Input validation failed");
     if (!parsed.ok) {
-        return [parsed, { status: "invalid" }];
+        return [haltIterator(parsed), { status: "invalid" }];
     }
     const payload = parsed.value;
     const body = null;
@@ -56,8 +58,18 @@ async function $do(client, request, options) {
         securitySource: client._options.apiKey,
         retryConfig: options?.retries
             || client._options.retryConfig
+            || {
+                strategy: "backoff",
+                backoff: {
+                    initialInterval: 500,
+                    maxInterval: 60000,
+                    exponent: 1.5,
+                    maxElapsedTime: 3600000,
+                },
+                retryConnectionErrors: true,
+            }
             || { strategy: "none" },
-        retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"],
+        retryCodes: options?.retryCodes || ["5XX"],
     };
     const requestRes = client._createRequest(context, {
         security: requestSecurity,
@@ -71,7 +83,7 @@ async function $do(client, request, options) {
         timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
     }, options);
     if (!requestRes.ok) {
-        return [requestRes, { status: "invalid" }];
+        return [haltIterator(requestRes), { status: "invalid" }];
     }
     const req = requestRes.value;
     const doResult = await client._do(req, {
@@ -81,16 +93,47 @@ async function $do(client, request, options) {
         retryCodes: context.retryCodes,
     });
     if (!doResult.ok) {
-        return [doResult, { status: "request-error", request: req }];
+        return [haltIterator(doResult), { status: "request-error", request: req }];
     }
     const response = doResult.value;
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, operations.ListGuardrailKeyAssignmentsResponse$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result, raw] = await M.match(M.json(200, operations.ListGuardrailKeyAssignmentsResponse$inboundSchema, {
+        key: "Result",
+    }), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
-        return [result, { status: "complete", request: req, response }];
+        return [haltIterator(result), {
+                status: "complete",
+                request: req,
+                response,
+            }];
     }
-    return [result, { status: "complete", request: req, response }];
+    const nextFunc = (responseData) => {
+        const offset = request?.offset ?? 0;
+        if (!responseData) {
+            return { next: () => null };
+        }
+        const results = dlv(responseData, "data");
+        if (!Array.isArray(results) || !results.length) {
+            return { next: () => null };
+        }
+        const limit = request?.limit ?? 0;
+        if (results.length < limit) {
+            return { next: () => null };
+        }
+        const nextOffset = offset + results.length;
+        const nextVal = () => guardrailsListGuardrailKeyAssignments(client, {
+            ...request,
+            offset: nextOffset,
+        }, options);
+        return { next: nextVal, "~next": { offset: nextOffset } };
+    };
+    const page = { ...result, ...nextFunc(raw) };
+    return [{ ...page, ...createPageIterator(page, (v) => !v.ok) }, {
+            status: "complete",
+            request: req,
+            response,
+        }];
 }
 //# sourceMappingURL=guardrailsListGuardrailKeyAssignments.js.map

package/esm/funcs/guardrailsListGuardrailMemberAssignments.d.ts

@@ -8,11 +8,14 @@ import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
 import * as operations from "../models/operations/index.js";
 import { APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
+import { PageIterator } from "../types/operations.js";
 /**
  * List member assignments for a guardrail
  *
  * @remarks
  * List all organization member assignments for a specific guardrail. [Management key](/docs/guides/overview/auth/management-api-keys) required.
  */
-export declare function guardrailsListGuardrailMemberAssignments(client: OpenRouterCore, request: operations.ListGuardrailMemberAssignmentsRequest, options?: RequestOptions): APIPromise<Result<operations.ListGuardrailMemberAssignmentsResponse, errors.UnauthorizedResponseError | errors.NotFoundResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function guardrailsListGuardrailMemberAssignments(client: OpenRouterCore, request: operations.ListGuardrailMemberAssignmentsRequest, options?: RequestOptions): APIPromise<PageIterator<Result<operations.ListGuardrailMemberAssignmentsResponse, errors.UnauthorizedResponseError | errors.NotFoundResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>, {
+    offset: number;
+}>>;
 //# sourceMappingURL=guardrailsListGuardrailMemberAssignments.d.ts.map